chore(beads): revise 18 NOTE beads with verified codebase context

Enriched all per-note search beads (NOTE-0A through NOTE-2I) with:
- Corrected migration numbers (022, 024, 025)
- Verified file paths and line numbers from codebase
- Complete function signatures for referenced code
- Detailed approach sections with SQL and Rust patterns
- DocumentData struct field mappings
- TDD anchors with specific test names
- Edge cases from codebase analysis
- Dependency context explaining what each blocker provides

.beads/last-touched

@@ -1 +1 @@
-bd-3qn6
+bd-2kop

.claude/hooks/on-file-write.sh

@@ -1,6 +1,11 @@
 #!/bin/bash
 # Ultimate Bug Scanner - Claude Code Hook
 # Runs on every file save for UBS-supported languages (JS/TS, Python, C/C++, Rust, Go, Java, Ruby)
+# Claude Code hooks receive context as JSON on stdin.
+
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
+CWD=$(echo "$INPUT" | jq -r '.cwd // empty')
 
 if [[ "$FILE_PATH" =~ \.(js|jsx|ts|tsx|mjs|cjs|py|pyw|pyi|c|cc|cpp|cxx|h|hh|hpp|hxx|rs|go|java|rb)$ ]]; then
   echo "🔬 Running bug scanner..."
@@ -8,5 +13,5 @@ if [[ "$FILE_PATH" =~ \.(js|jsx|ts|tsx|mjs|cjs|py|pyw|pyi|c|cc|cpp|cxx|h|hh|hpp|
     echo "⚠️  'ubs' not found in PATH; install it before using this hook." >&2
     exit 0
   fi
-  ubs "${PROJECT_DIR}" --ci 2>&1 | head -50
+  ubs "$FILE_PATH" --ci 2>&1 | head -50
 fi

AGENTS.md

@@ -14,6 +14,14 @@ If I tell you to do something, even if it goes against what follows below, YOU M
 
 ---
 
+## Version Control: jj-First (CRITICAL)
+
+**ALWAYS prefer jj (Jujutsu) over git for all VCS operations.** This is a colocated repo with both `.jj/` and `.git/`. When instructed to use git by anything — even later in this file — use the best jj replacement commands instead. Only fall back to raw `git` for things jj cannot do (hooks, LFS, submodules, `gh` CLI interop).
+
+See `~/.claude/rules/jj-vcs/` for the full command reference, translation table, revsets, patterns, and recovery recipes.
+
+---
+
 ## Irreversible Git & Filesystem Actions — DO NOT EVER BREAK GLASS
 
 > **Note:** Treat destructive commands as break-glass. If there's any doubt, stop and ask.
@@ -316,7 +324,7 @@ bv --robot-insights | jq '.Cycles'                         # Circular deps (must
 
 ```bash
 ubs file.rs file2.rs                    # Specific files (< 1s) — USE THIS
-ubs $(git diff --name-only --cached)    # Staged files — before commit
+ubs $(jj diff --name-only)              # Changed files — before commit
 ubs --only=rust,toml src/               # Language filter (3-5x faster)
 ubs --ci --fail-on-warning .            # CI mode — before PR
 ubs .                                   # Whole project (ignores target/, Cargo.lock)
@@ -428,9 +436,9 @@ Returns structured results with file paths, line ranges, and extracted code snip
 
 ## Beads Workflow Integration
 
-This project uses [beads_viewer](https://github.com/Dicklesworthstone/beads_viewer) for issue tracking. Issues are stored in `.beads/` and tracked in git.
+This project uses [beads_viewer](https://github.com/Dicklesworthstone/beads_viewer) for issue tracking. Issues are stored in `.beads/` and tracked in version control.
 
-**Note:** `br` is non-invasive—it never executes git commands directly. You must run git commands manually after `br sync --flush-only`.
+**Note:** `br` is non-invasive—it never executes VCS commands directly. You must commit manually after `br sync --flush-only`.
 
 ### Essential Commands
 
@@ -446,7 +454,7 @@ br create --title="..." --type=task --priority=2
 br update <id> --status=in_progress
 br close <id> --reason="Completed"
 br close <id1> <id2>  # Close multiple issues at once
-br sync --flush-only  # Export to JSONL (then manually: git add .beads/ && git commit)
+br sync --flush-only  # Export to JSONL (then: jj commit -m "Update beads")
 ```
 
 ### Workflow Pattern
@@ -466,15 +474,14 @@ br sync --flush-only  # Export to JSONL (then manually: git add .beads/ && git c
 
 ### Session Protocol
 
-**Before ending any session, run this checklist:**
+**Before ending any session, run this checklist (solo/lead only — workers skip VCS):**
 
 ```bash
-git status              # Check what changed
-git add <files>         # Stage code changes
-br sync --flush-only    # Export beads to JSONL
-git add .beads/         # Stage beads changes
-git commit -m "..."     # Commit code and beads
-git push                # Push to remote
+jj status                        # Check what changed
+br sync --flush-only             # Export beads to JSONL
+jj commit -m "..."               # Commit code and beads (jj auto-tracks all changes)
+jj bookmark set <name> -r @-     # Point bookmark at committed work
+jj git push -b <name>            # Push to remote
 ```
 
 ### Best Practices
@@ -483,13 +490,15 @@ git push                # Push to remote
 - Update status as you work (in_progress → closed)
 - Create new issues with `br create` when you discover tasks
 - Use descriptive titles and set appropriate priority/type
-- Always run `br sync --flush-only` then commit .beads/ before ending session
+- Always run `br sync --flush-only` then commit before ending session (jj auto-tracks .beads/)
 
 <!-- end-bv-agent-instructions -->
 
 ## Landing the Plane (Session Completion)
 
-**When ending a work session**, you MUST complete ALL steps below. Work is NOT complete until `git push` succeeds.
+**When ending a work session**, you MUST complete ALL steps below. Work is NOT complete until push succeeds.
+
+**WHO RUNS THIS:** Solo agents run it themselves. In multi-agent sessions, ONLY the team lead runs this. Workers skip VCS entirely.
 
 **MANDATORY WORKFLOW:**
 
@@ -498,19 +507,20 @@ git push                # Push to remote
 3. **Update issue status** - Close finished work, update in-progress items
 4. **PUSH TO REMOTE** - This is MANDATORY:
    ```bash
-   git pull --rebase
-   br sync --flush-only
-   git add .beads/
-   git commit -m "Update beads"
-   git push
-   git status  # MUST show "up to date with origin"
+   jj git fetch                       # Get latest remote state
+   jj rebase -d trunk()               # Rebase onto latest trunk if needed
+   br sync --flush-only               # Export beads to JSONL
+   jj commit -m "Update beads"        # Commit (jj auto-tracks .beads/ changes)
+   jj bookmark set <name> -r @-       # Point bookmark at committed work
+   jj git push -b <name>              # Push to remote
+   jj log -r '<name>'                 # Verify bookmark position
    ```
-5. **Clean up** - Clear stashes, prune remote branches
+5. **Clean up** - Abandon empty orphan changes if any (`jj abandon <rev>`)
 6. **Verify** - All changes committed AND pushed
 7. **Hand off** - Provide context for next session
 
 **CRITICAL RULES:**
-- Work is NOT complete until `git push` succeeds
+- Work is NOT complete until `jj git push` succeeds
 - NEVER stop before pushing - that leaves work stranded locally
 - NEVER say "ready to push when you are" - YOU must push
 - If push fails, resolve and retry until it succeeds
@@ -618,6 +628,9 @@ LORE_ROBOT=1 lore issues
 lore --robot issues -n 10
 lore --robot mrs -s opened
 
+# Filter issues by work item status (case-insensitive)
+lore --robot issues --status "In progress"
+
 # List with field selection (reduces token usage ~60%)
 lore --robot issues --fields minimal
 lore --robot mrs --fields iid,title,state,draft
@@ -741,6 +754,21 @@ lore -J mrs --fields iid,title,state,draft,labels  # Custom field list
 - Use `lore robot-docs` for response schema discovery
 - The `-p` flag supports fuzzy project matching (suffix and substring)
 
+---
+
+## Read/Write Split: lore vs glab
+
+| Operation | Tool | Why |
+|-----------|------|-----|
+| List issues/MRs | lore | Richer: includes status, discussions, closing MRs |
+| View issue/MR detail | lore | Pre-joined discussions, work-item status |
+| Search across entities | lore | FTS5 + vector hybrid search |
+| Expert/workload analysis | lore | who command — no glab equivalent |
+| Timeline reconstruction | lore | Chronological narrative — no glab equivalent |
+| Create/update/close | glab | Write operations |
+| Approve/merge MR | glab | Write operations |
+| CI/CD pipelines | glab | Not in lore scope |
+
 ````markdown
 ## UBS Quick Reference for AI Agents
 

AGENTS.md.backup

@@ -0,0 +1,742 @@
+# AGENTS.md
+
+## RULE 0 - THE FUNDAMENTAL OVERRIDE PEROGATIVE
+
+If I tell you to do something, even if it goes against what follows below, YOU MUST LISTEN TO ME. I AM IN CHARGE, NOT YOU.
+
+---
+
+## RULE NUMBER 1: NO FILE DELETION
+
+**YOU ARE NEVER ALLOWED TO DELETE A FILE WITHOUT EXPRESS PERMISSION.** Even a new file that you yourself created, such as a test code file. You have a horrible track record of deleting critically important files or otherwise throwing away tons of expensive work. As a result, you have permanently lost any and all rights to determine that a file or folder should be deleted.
+
+**YOU MUST ALWAYS ASK AND RECEIVE CLEAR, WRITTEN PERMISSION BEFORE EVER DELETING A FILE OR FOLDER OF ANY KIND.**
+
+---
+
+## Irreversible Git & Filesystem Actions — DO NOT EVER BREAK GLASS
+
+> **Note:** Treat destructive commands as break-glass. If there's any doubt, stop and ask.
+
+1. **Absolutely forbidden commands:** `git reset --hard`, `git clean -fd`, `rm -rf`, or any command that can delete or overwrite code/data must never be run unless the user explicitly provides the exact command and states, in the same message, that they understand and want the irreversible consequences.
+2. **No guessing:** If there is any uncertainty about what a command might delete or overwrite, stop immediately and ask the user for specific approval. "I think it's safe" is never acceptable.
+3. **Safer alternatives first:** When cleanup or rollbacks are needed, request permission to use non-destructive options (`git status`, `git diff`, `git stash`, copying to backups) before ever considering a destructive command.
+4. **Mandatory explicit plan:** Even after explicit user authorization, restate the command verbatim, list exactly what will be affected, and wait for a confirmation that your understanding is correct. Only then may you execute it—if anything remains ambiguous, refuse and escalate.
+5. **Document the confirmation:** When running any approved destructive command, record (in the session notes / final response) the exact user text that authorized it, the command actually run, and the execution time. If that record is absent, the operation did not happen.
+
+---
+
+## Toolchain: Rust & Cargo
+
+We only use **Cargo** in this project, NEVER any other package manager.
+
+- **Edition/toolchain:** Follow `rust-toolchain.toml` (if present). Do not assume stable vs nightly.
+- **Dependencies:** Explicit versions for stability; keep the set minimal.
+- **Configuration:** Cargo.toml only
+- **Unsafe code:** Forbidden (`#![forbid(unsafe_code)]`)
+
+When writing Rust code, reference RUST_CLI_TOOLS_BEST_PRACTICES.md
+
+### Release Profile
+
+Use the release profile defined in `Cargo.toml`. If you need to change it, justify the
+performance/size tradeoff and how it impacts determinism and cancellation behavior.
+
+---
+
+## Code Editing Discipline
+
+### No Script-Based Changes
+
+**NEVER** run a script that processes/changes code files in this repo. Brittle regex-based transformations create far more problems than they solve.
+
+- **Always make code changes manually**, even when there are many instances
+- For many simple changes: use parallel subagents
+- For subtle/complex changes: do them methodically yourself
+
+### No File Proliferation
+
+If you want to change something or add a feature, **revise existing code files in place**.
+
+**NEVER** create variations like:
+- `mainV2.rs`
+- `main_improved.rs`
+- `main_enhanced.rs`
+
+New files are reserved for **genuinely new functionality** that makes zero sense to include in any existing file. The bar for creating new files is **incredibly high**.
+
+---
+
+## Backwards Compatibility
+
+We do not care about backwards compatibility—we're in early development with no users. We want to do things the **RIGHT** way with **NO TECH DEBT**.
+
+- Never create "compatibility shims"
+- Never create wrapper functions for deprecated APIs
+- Just fix the code directly
+
+---
+
+## Compiler Checks (CRITICAL)
+
+**After any substantive code changes, you MUST verify no errors were introduced:**
+
+```bash
+# Check for compiler errors and warnings
+cargo check --all-targets
+
+# Check for clippy lints (pedantic + nursery are enabled)
+cargo clippy --all-targets -- -D warnings
+
+# Verify formatting
+cargo fmt --check
+```
+
+If you see errors, **carefully understand and resolve each issue**. Read sufficient context to fix them the RIGHT way.
+
+---
+
+## Testing
+
+### Unit & Property Tests
+
+```bash
+# Run all tests
+cargo test
+
+# Run with output
+cargo test -- --nocapture
+```
+
+When adding or changing primitives, add tests that assert the core invariants:
+
+- no task leaks
+- no obligation leaks
+- losers are drained after races
+- region close implies quiescence
+
+Prefer deterministic lab-runtime tests for concurrency-sensitive behavior.
+
+---
+
+## MCP Agent Mail — Multi-Agent Coordination
+
+A mail-like layer that lets coding agents coordinate asynchronously via MCP tools and resources. Provides identities, inbox/outbox, searchable threads, and advisory file reservations with human-auditable artifacts in Git.
+
+### Why It's Useful
+
+- **Prevents conflicts:** Explicit file reservations (leases) for files/globs
+- **Token-efficient:** Messages stored in per-project archive, not in context
+- **Quick reads:** `resource://inbox/...`, `resource://thread/...`
+
+### Same Repository Workflow
+
+1. **Register identity:**
+   ```
+   ensure_project(project_key=<abs-path>)
+   register_agent(project_key, program, model)
+   ```
+
+2. **Reserve files before editing:**
+   ```
+   file_reservation_paths(project_key, agent_name, ["src/**"], ttl_seconds=3600, exclusive=true)
+   ```
+
+3. **Communicate with threads:**
+   ```
+   send_message(..., thread_id="FEAT-123")
+   fetch_inbox(project_key, agent_name)
+   acknowledge_message(project_key, agent_name, message_id)
+   ```
+
+4. **Quick reads:**
+   ```
+   resource://inbox/{Agent}?project=<abs-path>&limit=20
+   resource://thread/{id}?project=<abs-path>&include_bodies=true
+   ```
+
+### Macros vs Granular Tools
+
+- **Prefer macros for speed:** `macro_start_session`, `macro_prepare_thread`, `macro_file_reservation_cycle`, `macro_contact_handshake`
+- **Use granular tools for control:** `register_agent`, `file_reservation_paths`, `send_message`, `fetch_inbox`, `acknowledge_message`
+
+### Common Pitfalls
+
+- `"from_agent not registered"`: Always `register_agent` in the correct `project_key` first
+- `"FILE_RESERVATION_CONFLICT"`: Adjust patterns, wait for expiry, or use non-exclusive reservation
+- **Auth errors:** If JWT+JWKS enabled, include bearer token with matching `kid`
+
+---
+
+## Beads (br) — Dependency-Aware Issue Tracking
+
+Beads provides a lightweight, dependency-aware issue database and CLI (`br` / beads_rust) for selecting "ready work," setting priorities, and tracking status. It complements MCP Agent Mail's messaging and file reservations.
+
+**Note:** `br` is non-invasive—it never executes git commands directly. You must run git commands manually after `br sync --flush-only`.
+
+### Conventions
+
+- **Single source of truth:** Beads for task status/priority/dependencies; Agent Mail for conversation and audit
+- **Shared identifiers:** Use Beads issue ID (e.g., `br-123`) as Mail `thread_id` and prefix subjects with `[br-123]`
+- **Reservations:** When starting a task, call `file_reservation_paths()` with the issue ID in `reason`
+
+### Typical Agent Flow
+
+1. **Pick ready work (Beads):**
+   ```bash
+   br ready --json  # Choose highest priority, no blockers
+   ```
+
+2. **Reserve edit surface (Mail):**
+   ```
+   file_reservation_paths(project_key, agent_name, ["src/**"], ttl_seconds=3600, exclusive=true, reason="br-123")
+   ```
+
+3. **Announce start (Mail):**
+   ```
+   send_message(..., thread_id="br-123", subject="[br-123] Start: <title>", ack_required=true)
+   ```
+
+4. **Work and update:** Reply in-thread with progress
+
+5. **Complete and release:**
+   ```bash
+   br close br-123 --reason "Completed"
+   ```
+   ```
+   release_file_reservations(project_key, agent_name, paths=["src/**"])
+   ```
+   Final Mail reply: `[br-123] Completed` with summary
+
+### Mapping Cheat Sheet
+
+| Concept | Value |
+|---------|-------|
+| Mail `thread_id` | `br-###` |
+| Mail subject | `[br-###] ...` |
+| File reservation `reason` | `br-###` |
+| Commit messages | Include `br-###` for traceability |
+
+---
+
+## bv — Graph-Aware Triage Engine
+
+bv is a graph-aware triage engine for Beads projects (`.beads/beads.jsonl`). It computes PageRank, betweenness, critical path, cycles, HITS, eigenvector, and k-core metrics deterministically.
+
+**Scope boundary:** bv handles *what to work on* (triage, priority, planning). For agent-to-agent coordination (messaging, work claiming, file reservations), use MCP Agent Mail.
+
+**CRITICAL: Use ONLY `--robot-*` flags. Bare `bv` launches an interactive TUI that blocks your session.**
+
+### The Workflow: Start With Triage
+
+**`bv --robot-triage` is your single entry point.** It returns:
+- `quick_ref`: at-a-glance counts + top 3 picks
+- `recommendations`: ranked actionable items with scores, reasons, unblock info
+- `quick_wins`: low-effort high-impact items
+- `blockers_to_clear`: items that unblock the most downstream work
+- `project_health`: status/type/priority distributions, graph metrics
+- `commands`: copy-paste shell commands for next steps
+
+```bash
+bv --robot-triage        # THE MEGA-COMMAND: start here
+bv --robot-next          # Minimal: just the single top pick + claim command
+```
+
+### Command Reference
+
+**Planning:**
+| Command | Returns |
+|---------|---------|
+| `--robot-plan` | Parallel execution tracks with `unblocks` lists |
+| `--robot-priority` | Priority misalignment detection with confidence |
+
+**Graph Analysis:**
+| Command | Returns |
+|---------|---------|
+| `--robot-insights` | Full metrics: PageRank, betweenness, HITS, eigenvector, critical path, cycles, k-core, articulation points, slack |
+| `--robot-label-health` | Per-label health: `health_level`, `velocity_score`, `staleness`, `blocked_count` |
+| `--robot-label-flow` | Cross-label dependency: `flow_matrix`, `dependencies`, `bottleneck_labels` |
+| `--robot-label-attention [--attention-limit=N]` | Attention-ranked labels |
+
+**History & Change Tracking:**
+| Command | Returns |
+|---------|---------|
+| `--robot-history` | Bead-to-commit correlations |
+| `--robot-diff --diff-since <ref>` | Changes since ref: new/closed/modified issues, cycles |
+
+**Other:**
+| Command | Returns |
+|---------|---------|
+| `--robot-burndown <sprint>` | Sprint burndown, scope changes, at-risk items |
+| `--robot-forecast <id\|all>` | ETA predictions with dependency-aware scheduling |
+| `--robot-alerts` | Stale issues, blocking cascades, priority mismatches |
+| `--robot-suggest` | Hygiene: duplicates, missing deps, label suggestions |
+| `--robot-graph [--graph-format=json\|dot\|mermaid]` | Dependency graph export |
+| `--export-graph <file.html>` | Interactive HTML visualization |
+
+### Scoping & Filtering
+
+```bash
+bv --robot-plan --label backend              # Scope to label's subgraph
+bv --robot-insights --as-of HEAD~30          # Historical point-in-time
+bv --recipe actionable --robot-plan          # Pre-filter: ready to work
+bv --recipe high-impact --robot-triage       # Pre-filter: top PageRank
+bv --robot-triage --robot-triage-by-track    # Group by parallel work streams
+bv --robot-triage --robot-triage-by-label    # Group by domain
+```
+
+### Understanding Robot Output
+
+**All robot JSON includes:**
+- `data_hash` — Fingerprint of source beads.jsonl
+- `status` — Per-metric state: `computed|approx|timeout|skipped` + elapsed ms
+- `as_of` / `as_of_commit` — Present when using `--as-of`
+
+**Two-phase analysis:**
+- **Phase 1 (instant):** degree, topo sort, density
+- **Phase 2 (async, 500ms timeout):** PageRank, betweenness, HITS, eigenvector, cycles
+
+### jq Quick Reference
+
+```bash
+bv --robot-triage | jq '.quick_ref'                        # At-a-glance summary
+bv --robot-triage | jq '.recommendations[0]'               # Top recommendation
+bv --robot-plan | jq '.plan.summary.highest_impact'        # Best unblock target
+bv --robot-insights | jq '.status'                         # Check metric readiness
+bv --robot-insights | jq '.Cycles'                         # Circular deps (must fix!)
+```
+
+---
+
+## UBS — Ultimate Bug Scanner
+
+**Golden Rule:** `ubs <changed-files>` before every commit. Exit 0 = safe. Exit >0 = fix & re-run.
+
+### Commands
+
+```bash
+ubs file.rs file2.rs                    # Specific files (< 1s) — USE THIS
+ubs $(git diff --name-only --cached)    # Staged files — before commit
+ubs --only=rust,toml src/               # Language filter (3-5x faster)
+ubs --ci --fail-on-warning .            # CI mode — before PR
+ubs .                                   # Whole project (ignores target/, Cargo.lock)
+```
+
+### Output Format
+
+```
+⚠️  Category (N errors)
+    file.rs:42:5 – Issue description
+    💡 Suggested fix
+Exit code: 1
+```
+
+Parse: `file:line:col` → location | 💡 → how to fix | Exit 0/1 → pass/fail
+
+### Fix Workflow
+
+1. Read finding → category + fix suggestion
+2. Navigate `file:line:col` → view context
+3. Verify real issue (not false positive)
+4. Fix root cause (not symptom)
+5. Re-run `ubs <file>` → exit 0
+6. Commit
+
+### Bug Severity
+
+- **Critical (always fix):** Memory safety, use-after-free, data races, SQL injection
+- **Important (production):** Unwrap panics, resource leaks, overflow checks
+- **Contextual (judgment):** TODO/FIXME, println! debugging
+
+---
+
+## ast-grep vs ripgrep
+
+**Use `ast-grep` when structure matters.** It parses code and matches AST nodes, ignoring comments/strings, and can **safely rewrite** code.
+
+- Refactors/codemods: rename APIs, change import forms
+- Policy checks: enforce patterns across a repo
+- Editor/automation: LSP mode, `--json` output
+
+**Use `ripgrep` when text is enough.** Fastest way to grep literals/regex.
+
+- Recon: find strings, TODOs, log lines, config values
+- Pre-filter: narrow candidate files before ast-grep
+
+### Rule of Thumb
+
+- Need correctness or **applying changes** → `ast-grep`
+- Need raw speed or **hunting text** → `rg`
+- Often combine: `rg` to shortlist files, then `ast-grep` to match/modify
+
+### Rust Examples
+
+```bash
+# Find structured code (ignores comments)
+ast-grep run -l Rust -p 'fn $NAME($$$ARGS) -> $RET { $$$BODY }'
+
+# Find all unwrap() calls
+ast-grep run -l Rust -p '$EXPR.unwrap()'
+
+# Quick textual hunt
+rg -n 'println!' -t rust
+
+# Combine speed + precision
+rg -l -t rust 'unwrap\(' | xargs ast-grep run -l Rust -p '$X.unwrap()' --json
+```
+
+---
+
+## Morph Warp Grep — AI-Powered Code Search
+
+**Use `mcp__morph-mcp__warp_grep` for exploratory "how does X work?" questions.** An AI agent expands your query, greps the codebase, reads relevant files, and returns precise line ranges with full context.
+
+**Use `ripgrep` for targeted searches.** When you know exactly what you're looking for.
+
+**Use `ast-grep` for structural patterns.** When you need AST precision for matching/rewriting.
+
+### When to Use What
+
+| Scenario | Tool | Why |
+|----------|------|-----|
+| "How is pattern matching implemented?" | `warp_grep` | Exploratory; don't know where to start |
+| "Where is the quick reject filter?" | `warp_grep` | Need to understand architecture |
+| "Find all uses of `Regex::new`" | `ripgrep` | Targeted literal search |
+| "Find files with `println!`" | `ripgrep` | Simple pattern |
+| "Replace all `unwrap()` with `expect()`" | `ast-grep` | Structural refactor |
+
+### warp_grep Usage
+
+```
+mcp__morph-mcp__warp_grep(
+  repoPath: "/path/to/dcg",
+  query: "How does the safe pattern whitelist work?"
+)
+```
+
+Returns structured results with file paths, line ranges, and extracted code snippets.
+
+### Anti-Patterns
+
+- **Don't** use `warp_grep` to find a specific function name → use `ripgrep`
+- **Don't** use `ripgrep` to understand "how does X work" → wastes time with manual reads
+- **Don't** use `ripgrep` for codemods → risks collateral edits
+
+<!-- bv-agent-instructions-v1 -->
+
+---
+
+## Beads Workflow Integration
+
+This project uses [beads_viewer](https://github.com/Dicklesworthstone/beads_viewer) for issue tracking. Issues are stored in `.beads/` and tracked in git.
+
+**Note:** `br` is non-invasive—it never executes git commands directly. You must run git commands manually after `br sync --flush-only`.
+
+### Essential Commands
+
+```bash
+# View issues (launches TUI - avoid in automated sessions)
+bv
+
+# CLI commands for agents (use these instead)
+br ready              # Show issues ready to work (no blockers)
+br list --status=open # All open issues
+br show <id>          # Full issue details with dependencies
+br create --title="..." --type=task --priority=2
+br update <id> --status=in_progress
+br close <id> --reason="Completed"
+br close <id1> <id2>  # Close multiple issues at once
+br sync --flush-only  # Export to JSONL (then manually: git add .beads/ && git commit)
+```
+
+### Workflow Pattern
+
+1. **Start**: Run `br ready` to find actionable work
+2. **Claim**: Use `br update <id> --status=in_progress`
+3. **Work**: Implement the task
+4. **Complete**: Use `br close <id>`
+5. **Sync**: Run `br sync --flush-only`, then `git add .beads/ && git commit -m "Update beads"`
+
+### Key Concepts
+
+- **Dependencies**: Issues can block other issues. `br ready` shows only unblocked work.
+- **Priority**: P0=critical, P1=high, P2=medium, P3=low, P4=backlog (use numbers, not words)
+- **Types**: task, bug, feature, epic, question, docs
+- **Blocking**: `br dep add <issue> <depends-on>` to add dependencies
+
+### Session Protocol
+
+**Before ending any session, run this checklist:**
+
+```bash
+git status              # Check what changed
+git add <files>         # Stage code changes
+br sync --flush-only    # Export beads to JSONL
+git add .beads/         # Stage beads changes
+git commit -m "..."     # Commit code and beads
+git push                # Push to remote
+```
+
+### Best Practices
+
+- Check `br ready` at session start to find available work
+- Update status as you work (in_progress → closed)
+- Create new issues with `br create` when you discover tasks
+- Use descriptive titles and set appropriate priority/type
+- Always run `br sync --flush-only` then commit .beads/ before ending session
+
+<!-- end-bv-agent-instructions -->
+
+## Landing the Plane (Session Completion)
+
+**When ending a work session**, you MUST complete ALL steps below. Work is NOT complete until `git push` succeeds.
+
+**MANDATORY WORKFLOW:**
+
+1. **File issues for remaining work** - Create issues for anything that needs follow-up
+2. **Run quality gates** (if code changed) - Tests, linters, builds
+3. **Update issue status** - Close finished work, update in-progress items
+4. **PUSH TO REMOTE** - This is MANDATORY:
+   ```bash
+   git pull --rebase
+   br sync --flush-only
+   git add .beads/
+   git commit -m "Update beads"
+   git push
+   git status  # MUST show "up to date with origin"
+   ```
+5. **Clean up** - Clear stashes, prune remote branches
+6. **Verify** - All changes committed AND pushed
+7. **Hand off** - Provide context for next session
+
+**CRITICAL RULES:**
+- Work is NOT complete until `git push` succeeds
+- NEVER stop before pushing - that leaves work stranded locally
+- NEVER say "ready to push when you are" - YOU must push
+- If push fails, resolve and retry until it succeeds
+
+---
+
+## cass — Cross-Agent Session Search
+
+`cass` indexes prior agent conversations (Claude Code, Codex, Cursor, Gemini, ChatGPT, etc.) so we can reuse solved problems.
+
+**Rules:** Never run bare `cass` (TUI). Always use `--robot` or `--json`.
+
+### Examples
+
+```bash
+cass health
+cass search "async runtime" --robot --limit 5
+cass view /path/to/session.jsonl -n 42 --json
+cass expand /path/to/session.jsonl -n 42 -C 3 --json
+cass capabilities --json
+cass robot-docs guide
+```
+
+### Tips
+
+- Use `--fields minimal` for lean output
+- Filter by agent with `--agent`
+- Use `--days N` to limit to recent history
+
+stdout is data-only, stderr is diagnostics; exit code 0 means success.
+
+Treat cass as a way to avoid re-solving problems other agents already handled.
+
+---
+
+## Note for Codex/GPT-5.2
+
+You constantly bother me and stop working with concerned questions that look similar to this:
+
+```
+Unexpected changes (need guidance)
+
+- Working tree still shows edits I did not make in Cargo.toml, Cargo.lock, src/runtime.rs, src/scope.rs. Please advise whether to keep/commit/revert these before any further work. I did not touch them.
+
+Next steps (pick one)
+
+1. Decide how to handle the unrelated modified files above so we can resume cleanly.
+```
+
+NEVER EVER DO THAT AGAIN. The answer is literally ALWAYS the same: those are changes created by the potentially dozen of other agents working on the project at the same time. This is not only a common occurence, it happens multiple times PER MINUTE. The way to deal with it is simple: you NEVER, under ANY CIRCUMSTANCE, stash, revert, overwrite, or otherwise disturb in ANY way the work of other agents. Just treat those changes identically to changes that you yourself made. Just fool yourself into thinking YOU made the changes and simply don't recall it for some reason.
+
+---
+
+## Note on Built-in TODO Functionality
+
+Also, if I ask you to explicitly use your built-in TODO functionality, don't complain about this and say you need to use beads. You can use built-in TODOs if I tell you specifically to do so. Always comply with such orders.
+
+## TDD Requirements
+
+Test-first development is mandatory:
+1. **RED** - Write failing test first
+2. **GREEN** - Minimal implementation to pass
+3. **REFACTOR** - Clean up while green
+
+## Key Patterns
+
+Find the simplest solution that meets all acceptance criteria.
+Use third party libraries whenever there's a well-maintained, active, and widely adopted solution (for example, date-fns for TS date math)
+Build extensible pieces of logic that can easily be integrated with other pieces.
+DRY principles should be loosely held.
+Architecture MUST be clear and well thought-out. Ask the user for clarification whenever ambiguity is discovered around architecture, or you think a better approach than planned exists.
+
+---
+
+## Third-Party Library Usage
+
+If you aren't 100% sure how to use a third-party library, **SEARCH ONLINE** to find the latest documentation and mid-2025 best practices.
+
+---
+
+## Gitlore Robot Mode
+
+The `lore` CLI has a robot mode optimized for AI agent consumption with compact JSON output, structured errors with machine-actionable recovery steps, meaningful exit codes, response timing metadata, field selection for token efficiency, and TTY auto-detection.
+
+### Activation
+
+```bash
+# Explicit flag
+lore --robot issues -n 10
+
+# JSON shorthand (-J)
+lore -J issues -n 10
+
+# Auto-detection (when stdout is not a TTY)
+lore issues | jq .
+
+# Environment variable
+LORE_ROBOT=1 lore issues
+```
+
+### Robot Mode Commands
+
+```bash
+# List issues/MRs with JSON output
+lore --robot issues -n 10
+lore --robot mrs -s opened
+
+# List with field selection (reduces token usage ~60%)
+lore --robot issues --fields minimal
+lore --robot mrs --fields iid,title,state,draft
+
+# Show detailed entity info
+lore --robot issues 123
+lore --robot mrs 456 -p group/repo
+
+# Count entities
+lore --robot count issues
+lore --robot count discussions --for mr
+
+# Search indexed documents
+lore --robot search "authentication bug"
+
+# Check sync status
+lore --robot status
+
+# Run full sync pipeline
+lore --robot sync
+
+# Run sync without resource events
+lore --robot sync --no-events
+
+# Run ingestion only
+lore --robot ingest issues
+
+# Check environment health
+lore --robot doctor
+
+# Document and index statistics
+lore --robot stats
+
+# Quick health pre-flight check (exit 0 = healthy, 19 = unhealthy)
+lore --robot health
+
+# Generate searchable documents from ingested data
+lore --robot generate-docs
+
+# Generate vector embeddings via Ollama
+lore --robot embed
+
+# Agent self-discovery manifest (all commands, flags, exit codes, response schemas)
+lore robot-docs
+
+# Version information
+lore --robot version
+```
+
+### Response Format
+
+All commands return compact JSON with a uniform envelope and timing metadata:
+
+```json
+{"ok":true,"data":{...},"meta":{"elapsed_ms":42}}
+```
+
+Errors return structured JSON to stderr with machine-actionable recovery steps:
+
+```json
+{"error":{"code":"CONFIG_NOT_FOUND","message":"...","suggestion":"Run 'lore init'","actions":["lore init"]}}
+```
+
+The `actions` array contains executable shell commands for automated recovery. It is omitted when empty.
+
+### Field Selection
+
+The `--fields` flag on `issues` and `mrs` list commands controls which fields appear in the JSON response:
+
+```bash
+lore -J issues --fields minimal                    # Preset: iid, title, state, updated_at_iso
+lore -J mrs --fields iid,title,state,draft,labels  # Custom field list
+```
+
+### Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Success |
+| 1 | Internal error / not implemented |
+| 2 | Usage error (invalid flags or arguments) |
+| 3 | Config invalid |
+| 4 | Token not set |
+| 5 | GitLab auth failed |
+| 6 | Resource not found |
+| 7 | Rate limited |
+| 8 | Network error |
+| 9 | Database locked |
+| 10 | Database error |
+| 11 | Migration failed |
+| 12 | I/O error |
+| 13 | Transform error |
+| 14 | Ollama unavailable |
+| 15 | Ollama model not found |
+| 16 | Embedding failed |
+| 17 | Not found (entity does not exist) |
+| 18 | Ambiguous match (use `-p` to specify project) |
+| 19 | Health check failed |
+| 20 | Config not found |
+
+### Configuration Precedence
+
+1. CLI flags (highest priority)
+2. Environment variables (`LORE_ROBOT`, `GITLAB_TOKEN`, `LORE_CONFIG_PATH`)
+3. Config file (`~/.config/lore/config.json`)
+4. Built-in defaults (lowest priority)
+
+### Best Practices
+
+- Use `lore --robot` or `lore -J` for all agent interactions
+- Check exit codes for error handling
+- Parse JSON errors from stderr; use `actions` array for automated recovery
+- Use `--fields minimal` to reduce token usage (~60% fewer tokens)
+- Use `-n` / `--limit` to control response size
+- Use `-q` / `--quiet` to suppress progress bars and non-essential output
+- Use `--color never` in non-TTY automation for ANSI-free output
+- Use `-v` / `-vv` / `-vvv` for increasing verbosity (debug/trace logging)
+- Use `--log-format json` for machine-readable log output to stderr
+- TTY detection handles piped commands automatically
+- Use `lore --robot health` as a fast pre-flight check before queries
+- Use `lore robot-docs` for response schema discovery
+- The `-p` flag supports fuzzy project matching (suffix and substring)

Cargo.lock

@@ -1106,7 +1106,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lore"
-version = "0.5.2"
+version = "0.6.2"
 dependencies = [
  "async-stream",
  "chrono",
@@ -1118,6 +1118,7 @@ dependencies = [
  "dirs",
  "flate2",
  "futures",
+ "httpdate",
  "indicatif",
  "libc",
  "open",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lore"
-version = "0.5.2"
+version = "0.6.2"
 edition = "2024"
 description = "Gitlore - Local GitLab data management with semantic search"
 authors = ["Taylor Eernisse"]
@@ -45,6 +45,7 @@ rand = "0.8"
 sha2 = "0.10"
 flate2 = "1"
 chrono = { version = "0.4", features = ["serde"] }
+httpdate = "1"
 uuid = { version = "1", features = ["v4"] }
 regex = "1"
 strsim = "0.11"

README.md

@@ -1,6 +1,6 @@
 # Gitlore
 
-Local GitLab data management with semantic search, people intelligence, and temporal analysis. Syncs issues, MRs, discussions, and notes from GitLab to a local SQLite database for fast, offline-capable querying, filtering, hybrid search, chronological event reconstruction, and expert discovery.
+Local GitLab data management with semantic search, people intelligence, and temporal analysis. Syncs issues, MRs, discussions, notes, and work item statuses from GitLab to a local SQLite database for fast, offline-capable querying, filtering, hybrid search, chronological event reconstruction, and expert discovery.
 
 ## Features
 
@@ -8,7 +8,7 @@ Local GitLab data management with semantic search, people intelligence, and temp
 - **Incremental sync**: Cursor-based sync only fetches changes since last sync
 - **Full re-sync**: Reset cursors and fetch all data from scratch when needed
 - **Multi-project**: Track issues and MRs across multiple GitLab projects
-- **Rich filtering**: Filter by state, author, assignee, labels, milestone, due date, draft status, reviewer, branches
+- **Rich filtering**: Filter by state, author, assignee, labels, milestone, due date, draft status, reviewer, branches, work item status
 - **Hybrid search**: Combines FTS5 lexical search with Ollama-powered vector embeddings via Reciprocal Rank Fusion
 - **People intelligence**: Expert discovery, workload analysis, review patterns, active discussions, and code ownership overlap
 - **Timeline pipeline**: Reconstructs chronological event histories by combining search, graph traversal, and event aggregation across related entities
@@ -17,6 +17,7 @@ Local GitLab data management with semantic search, people intelligence, and temp
 - **Raw payload storage**: Preserves original GitLab API responses for debugging
 - **Discussion threading**: Full support for issue and MR discussions including inline code review comments
 - **Cross-reference tracking**: Automatic extraction of "closes", "mentioned" relationships between MRs and issues
+- **Work item status enrichment**: Fetches issue statuses (e.g., "To do", "In progress", "Done") from GitLab's GraphQL API with adaptive page sizing, color-coded display, and case-insensitive filtering
 - **Resource event history**: Tracks state changes, label events, and milestone events for issues and MRs
 - **Robot mode**: Machine-readable JSON output with structured errors, meaningful exit codes, and actionable recovery steps
 - **Observability**: Verbosity controls, JSON log format, structured metrics, and stage timing
@@ -90,13 +91,15 @@ Configuration is stored in `~/.config/lore/config.json` (or `$XDG_CONFIG_HOME/lo
     { "path": "group/project" },
     { "path": "other-group/other-project" }
   ],
+  "defaultProject": "group/project",
   "sync": {
     "backfillDays": 14,
     "staleLockMinutes": 10,
     "heartbeatIntervalSeconds": 30,
     "cursorRewindSeconds": 2,
     "primaryConcurrency": 4,
-    "dependentConcurrency": 2
+    "dependentConcurrency": 2,
+    "fetchWorkItemStatus": true
   },
   "storage": {
     "compressRawPayloads": true
@@ -117,12 +120,14 @@ Configuration is stored in `~/.config/lore/config.json` (or `$XDG_CONFIG_HOME/lo
 | `gitlab` | `baseUrl` | -- | GitLab instance URL (required) |
 | `gitlab` | `tokenEnvVar` | `GITLAB_TOKEN` | Environment variable containing API token |
 | `projects` | `path` | -- | Project path (e.g., `group/project`) |
+| *(top-level)* | `defaultProject` | none | Fallback project path used when `-p` is omitted. Must match a configured project path (exact or suffix). CLI `-p` always overrides. |
 | `sync` | `backfillDays` | `14` | Days to backfill on initial sync |
 | `sync` | `staleLockMinutes` | `10` | Minutes before sync lock considered stale |
 | `sync` | `heartbeatIntervalSeconds` | `30` | Frequency of lock heartbeat updates |
 | `sync` | `cursorRewindSeconds` | `2` | Seconds to rewind cursor for overlap safety |
 | `sync` | `primaryConcurrency` | `4` | Concurrent GitLab requests for primary resources |
 | `sync` | `dependentConcurrency` | `2` | Concurrent requests for dependent resources |
+| `sync` | `fetchWorkItemStatus` | `true` | Enrich issues with work item status via GraphQL (requires GitLab Premium/Ultimate) |
 | `storage` | `dbPath` | `~/.local/share/lore/lore.db` | Database file path |
 | `storage` | `backupDir` | `~/.local/share/lore/backups` | Backup directory |
 | `storage` | `compressRawPayloads` | `true` | Compress stored API responses with gzip |
@@ -184,6 +189,8 @@ lore issues --since 1m               # Updated in last month
 lore issues --since 2024-01-01       # Updated since date
 lore issues --due-before 2024-12-31  # Due before date
 lore issues --has-due                 # Only issues with due dates
+lore issues --status "In progress"   # By work item status (case-insensitive)
+lore issues --status "To do" --status "In progress"  # Multiple statuses (OR)
 lore issues -p group/repo            # Filter by project
 lore issues --sort created --asc     # Sort by created date, ascending
 lore issues -o                        # Open first result in browser
@@ -193,13 +200,13 @@ lore -J issues --fields minimal       # Compact: iid, title, state, updated_at_i
 lore -J issues --fields iid,title,labels,state  # Custom fields
 ```
 
-When listing, output includes: IID, title, state, author, assignee, labels, and update time. In robot mode, the `--fields` flag controls which fields appear in the JSON response.
+When listing, output includes: IID, title, state, status (when any issue has one), assignee, labels, and update time. Status values display with their configured color. In robot mode, the `--fields` flag controls which fields appear in the JSON response.
 
-When showing a single issue (e.g., `lore issues 123`), output includes: title, description, state, author, assignees, labels, milestone, due date, web URL, and threaded discussions.
+When showing a single issue (e.g., `lore issues 123`), output includes: title, description, state, work item status (with color and category), author, assignees, labels, milestone, due date, web URL, and threaded discussions.
 
 #### Project Resolution
 
-The `-p` / `--project` flag uses cascading match logic across all commands:
+When `-p` / `--project` is omitted, the `defaultProject` from config is used as a fallback. If neither is set, results span all configured projects. When a project is specified (via `-p` or config default), it uses cascading match logic across all commands:
 
 1. **Exact match**: `group/project`
 2. **Case-insensitive**: `Group/Project`
@@ -397,7 +404,7 @@ When graph expansion encounters cross-project references to entities not yet syn
 
 ### `lore sync`
 
-Run the full sync pipeline: ingest from GitLab, generate searchable documents, and compute embeddings.
+Run the full sync pipeline: ingest from GitLab (including work item status enrichment via GraphQL), generate searchable documents, and compute embeddings.
 
 ```bash
 lore sync                    # Full pipeline
@@ -413,11 +420,11 @@ The sync command displays animated progress bars for each stage and outputs timi
 
 ### `lore ingest`
 
-Sync data from GitLab to local database. Runs only the ingestion step (no doc generation or embeddings).
+Sync data from GitLab to local database. Runs only the ingestion step (no doc generation or embeddings). For issue ingestion, this includes a status enrichment phase that fetches work item statuses via the GitLab GraphQL API.
 
 ```bash
 lore ingest                                    # Ingest everything (issues + MRs)
-lore ingest issues                             # Issues only
+lore ingest issues                             # Issues only (includes status enrichment)
 lore ingest mrs                                # MRs only
 lore ingest issues -p group/repo              # Single project
 lore ingest --force                            # Override stale lock
@@ -430,6 +437,8 @@ The `--full` flag resets sync cursors and discussion watermarks, then fetches al
 - You want to ensure complete data after schema changes
 - Troubleshooting sync issues
 
+Status enrichment uses adaptive page sizing (100 → 50 → 25 → 10) to handle GitLab GraphQL complexity limits. It gracefully handles instances without GraphQL support or Premium/Ultimate licensing. Disable via `sync.fetchWorkItemStatus: false` in config.
+
 ### `lore generate-docs`
 
 Extract searchable documents from ingested issues, MRs, and discussions for the FTS5 index.
@@ -501,12 +510,15 @@ lore init --force            # Overwrite existing config
 lore init --non-interactive  # Fail if prompts needed
 ```
 
+When multiple projects are configured, `init` prompts whether to set a default project (used when `-p` is omitted). This can also be set via the `--default-project` flag.
+
 In robot mode, `init` supports non-interactive setup via flags:
 
 ```bash
 lore -J init --gitlab-url https://gitlab.com \
   --token-env-var GITLAB_TOKEN \
-  --projects "group/project,other/project"
+  --projects "group/project,other/project" \
+  --default-project group/project
 ```
 
 ### `lore auth`
@@ -623,7 +635,7 @@ lore -J issues --fields iid,title,state,labels,updated_at_iso
 #   minimal: iid, title, state, updated_at_iso
 ```
 
-Valid fields for issues: `iid`, `title`, `state`, `author_username`, `labels`, `assignees`, `discussion_count`, `unresolved_count`, `created_at_iso`, `updated_at_iso`, `web_url`, `project_path`
+Valid fields for issues: `iid`, `title`, `state`, `author_username`, `labels`, `assignees`, `discussion_count`, `unresolved_count`, `created_at_iso`, `updated_at_iso`, `web_url`, `project_path`, `status_name`, `status_category`, `status_color`, `status_icon_name`, `status_synced_at_iso`
 
 Valid fields for MRs: `iid`, `title`, `state`, `author_username`, `labels`, `draft`, `target_branch`, `source_branch`, `discussion_count`, `unresolved_count`, `created_at_iso`, `updated_at_iso`, `web_url`, `project_path`, `reviewers`
 
@@ -714,7 +726,7 @@ Data is stored in SQLite with WAL mode and foreign keys enabled. Main tables:
 | Table | Purpose |
 |-------|---------|
 | `projects` | Tracked GitLab projects with metadata |
-| `issues` | Issue metadata (title, state, author, due date, milestone) |
+| `issues` | Issue metadata (title, state, author, due date, milestone, work item status) |
 | `merge_requests` | MR metadata (title, state, draft, branches, merge status, commit SHAs) |
 | `milestones` | Project milestones with state and due dates |
 | `labels` | Project labels with colors |

docs/diagrams/01-human-flow-map.excalidraw

@@ -0,0 +1,245 @@
+{
+  "type": "excalidraw",
+  "version": 2,
+  "source": "https://excalidraw.com",
+  "elements": [
+    { "type": "text", "id": "title", "x": 300, "y": 15, "text": "Human User Flow Map", "fontSize": 28 },
+    { "type": "text", "id": "subtitle", "x": 220, "y": 53, "text": "15 human workflows mapped to lore commands. Arrows show data dependency.", "fontSize": 14, "strokeColor": "#868e96" },
+
+    { "type": "text", "id": "col-trigger", "x": 60, "y": 80, "text": "TRIGGER (Problem)", "fontSize": 16, "strokeColor": "#495057" },
+    { "type": "text", "id": "col-flow", "x": 400, "y": 80, "text": "COMMAND FLOW", "fontSize": 16, "strokeColor": "#495057" },
+    { "type": "text", "id": "col-gap", "x": 880, "y": 80, "text": "GAP", "fontSize": 16, "strokeColor": "#ef4444" },
+
+    { "type": "rectangle", "id": "zone-daily", "x": 20, "y": 110, "width": 960, "height": 190,
+      "backgroundColor": "#dbe4ff", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#4a9eed", "strokeWidth": 1, "opacity": 20 },
+    { "type": "text", "id": "zone-daily-label", "x": 30, "y": 115, "text": "Daily Operations", "fontSize": 14, "strokeColor": "#1971c2" },
+
+    { "type": "rectangle", "id": "h1-trigger", "x": 30, "y": 140, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "H1: Standup prep\n\"What moved overnight?\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h1-a1", "x": 230, "y": 165, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h1-cmd1", "x": 280, "y": 145, "width": 90, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "sync -q", "fontSize": 14 } },
+    { "type": "arrow", "id": "h1-a2", "x": 370, "y": 165, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h1-cmd2", "x": 400, "y": 145, "width": 140, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "issues --since 1d", "fontSize": 14 } },
+    { "type": "arrow", "id": "h1-a3", "x": 540, "y": 165, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h1-cmd3", "x": 570, "y": 145, "width": 130, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "mrs --since 1d", "fontSize": 14 } },
+    { "type": "arrow", "id": "h1-a4", "x": 700, "y": 165, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h1-cmd4", "x": 730, "y": 145, "width": 100, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "who @me", "fontSize": 14 } },
+    { "type": "arrow", "id": "h1-a5", "x": 830, "y": 165, "width": 40, "height": 0,
+      "points": [[0,0],[40,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h1-gap", "x": 870, "y": 140, "width": 100, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No @me\nNo feed", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "h3-trigger", "x": 30, "y": 210, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "H3: Incident\n\"Deploy broke prod\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h3-a1", "x": 230, "y": 235, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h3-cmd1", "x": 280, "y": 215, "width": 130, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "timeline deploy", "fontSize": 14 } },
+    { "type": "arrow", "id": "h3-a2", "x": 410, "y": 235, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h3-cmd2", "x": 440, "y": 215, "width": 160, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "search deploy --mr", "fontSize": 14 } },
+    { "type": "arrow", "id": "h3-a3", "x": 600, "y": 235, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h3-cmd3", "x": 630, "y": 215, "width": 110, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "mrs <iid>", "fontSize": 14 } },
+    { "type": "arrow", "id": "h3-a4", "x": 740, "y": 235, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h3-cmd4", "x": 770, "y": 215, "width": 100, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "who --overlap", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "zone-planning", "x": 20, "y": 310, "width": 960, "height": 190,
+      "backgroundColor": "#d3f9d8", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#22c55e", "strokeWidth": 1, "opacity": 20 },
+    { "type": "text", "id": "zone-planning-label", "x": 30, "y": 315, "text": "Planning & Assignment", "fontSize": 14, "strokeColor": "#15803d" },
+
+    { "type": "rectangle", "id": "h2-trigger", "x": 30, "y": 340, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "H2: Sprint plan\n\"What's ready to pick?\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h2-a1", "x": 230, "y": 365, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h2-cmd1", "x": 280, "y": 345, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "issues -s opened -l ready", "fontSize": 13 } },
+    { "type": "arrow", "id": "h2-a2", "x": 450, "y": 365, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h2-cmd2", "x": 480, "y": 345, "width": 150, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "issues --has-due", "fontSize": 14 } },
+    { "type": "arrow", "id": "h2-a3", "x": 630, "y": 365, "width": 230, "height": 0,
+      "points": [[0,0],[230,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h2-gap", "x": 860, "y": 340, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No\n--no-assignee", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "h8-trigger", "x": 30, "y": 410, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "H8: Assign work\n\"Who has bandwidth?\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h8-a1", "x": 230, "y": 435, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h8-cmd1", "x": 280, "y": 415, "width": 120, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "who @alice", "fontSize": 14 } },
+    { "type": "arrow", "id": "h8-a2", "x": 400, "y": 435, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h8-cmd2", "x": 430, "y": 415, "width": 110, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "who @bob", "fontSize": 14 } },
+    { "type": "arrow", "id": "h8-a3", "x": 540, "y": 435, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h8-cmd3", "x": 570, "y": 415, "width": 120, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "who @carol...", "fontSize": 14 } },
+    { "type": "arrow", "id": "h8-a4", "x": 690, "y": 435, "width": 170, "height": 0,
+      "points": [[0,0],[170,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h8-gap", "x": 860, "y": 410, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No team\nworkload view", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "zone-investigation", "x": 20, "y": 510, "width": 960, "height": 260,
+      "backgroundColor": "#fff3bf", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#f59e0b", "strokeWidth": 1, "opacity": 20 },
+    { "type": "text", "id": "zone-invest-label", "x": 30, "y": 515, "text": "Investigation & Understanding", "fontSize": 14, "strokeColor": "#b45309" },
+
+    { "type": "rectangle", "id": "h7-trigger", "x": 30, "y": 540, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "H7: Why this way?\n\"Understand a decision\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h7-a1", "x": 230, "y": 565, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h7-cmd1", "x": 280, "y": 545, "width": 160, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "search \"rationale\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h7-a2", "x": 440, "y": 565, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h7-cmd2", "x": 470, "y": 545, "width": 140, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "timeline --depth 2", "fontSize": 14 } },
+    { "type": "arrow", "id": "h7-a3", "x": 610, "y": 565, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h7-cmd3", "x": 640, "y": 545, "width": 100, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "issues 234", "fontSize": 14 } },
+    { "type": "arrow", "id": "h7-a4", "x": 740, "y": 565, "width": 120, "height": 0,
+      "points": [[0,0],[120,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h7-gap", "x": 860, "y": 540, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No per-note\nsearch", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "h11-trigger", "x": 30, "y": 610, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "H11: Bug lifecycle\n\"Why does #321 reopen?\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h11-a1", "x": 230, "y": 635, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h11-cmd1", "x": 280, "y": 615, "width": 120, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "issues 321", "fontSize": 14 } },
+    { "type": "arrow", "id": "h11-a2", "x": 400, "y": 635, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h11-cmd2", "x": 430, "y": 615, "width": 130, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "timeline ???", "fontSize": 14 } },
+    { "type": "arrow", "id": "h11-a3", "x": 560, "y": 635, "width": 300, "height": 0,
+      "points": [[0,0],[300,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h11-gap", "x": 860, "y": 610, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No entity\ntimeline", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "h14-trigger", "x": 30, "y": 680, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "H14: Prior art?\n\"Was this tried before?\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h14-a1", "x": 230, "y": 705, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h14-cmd1", "x": 280, "y": 685, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "search \"memory leak\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h14-a2", "x": 450, "y": 705, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h14-cmd2", "x": 480, "y": 685, "width": 120, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "mrs --closed?", "fontSize": 14 } },
+    { "type": "arrow", "id": "h14-a3", "x": 600, "y": 705, "width": 260, "height": 0,
+      "points": [[0,0],[260,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h14-gap", "x": 860, "y": 680, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No --state\non search", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "zone-people", "x": 20, "y": 780, "width": 960, "height": 190,
+      "backgroundColor": "#e5dbff", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#8b5cf6", "strokeWidth": 1, "opacity": 20 },
+    { "type": "text", "id": "zone-people-label", "x": 30, "y": 785, "text": "People & Expertise", "fontSize": 14, "strokeColor": "#7048e8" },
+
+    { "type": "rectangle", "id": "h4-trigger", "x": 30, "y": 810, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "H4: Review prep\n\"Context for MR !789\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h4-a1", "x": 230, "y": 835, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h4-cmd1", "x": 280, "y": 815, "width": 100, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "mrs 789", "fontSize": 14 } },
+    { "type": "arrow", "id": "h4-a2", "x": 380, "y": 835, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h4-cmd2", "x": 410, "y": 815, "width": 120, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "who src/auth/", "fontSize": 14 } },
+    { "type": "arrow", "id": "h4-a3", "x": 530, "y": 835, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h4-cmd3", "x": 560, "y": 815, "width": 130, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "search \"auth\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h4-a4", "x": 690, "y": 835, "width": 170, "height": 0,
+      "points": [[0,0],[170,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h4-gap", "x": 860, "y": 810, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No MR file\nlist output", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "h6-trigger", "x": 30, "y": 880, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "H6: Find reviewer\n\"Who should review?\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "h6-a1", "x": 230, "y": 905, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h6-cmd1", "x": 280, "y": 885, "width": 130, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "who src/auth/", "fontSize": 14 } },
+    { "type": "arrow", "id": "h6-a2", "x": 410, "y": 905, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h6-cmd2", "x": 440, "y": 885, "width": 140, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "who src/pay/", "fontSize": 14 } },
+    { "type": "arrow", "id": "h6-a3", "x": 580, "y": 905, "width": 30, "height": 0,
+      "points": [[0,0],[30,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h6-cmd3", "x": 610, "y": 885, "width": 140, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "who @candidate", "fontSize": 14 } },
+    { "type": "arrow", "id": "h6-a4", "x": 750, "y": 905, "width": 110, "height": 0,
+      "points": [[0,0],[110,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "h6-gap", "x": 860, "y": 880, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No multi-\npath query", "fontSize": 14 } },
+
+    { "type": "text", "id": "callout-1", "x": 30, "y": 990, "text": "Pattern: Most human flows require 3-5 serial commands. Average gap rate: 73% of flows have at least one.", "fontSize": 14, "strokeColor": "#495057" },
+    { "type": "text", "id": "callout-2", "x": 30, "y": 1015, "text": "Top optimization: Composite commands (activity feed, team workload) would reduce multi-command flows by ~40%.", "fontSize": 14, "strokeColor": "#15803d" },
+    { "type": "text", "id": "callout-3", "x": 30, "y": 1040, "text": "Top missing data: MR file changes and entity references are stored but invisible to CLI users.", "fontSize": 14, "strokeColor": "#ef4444" }
+  ],
+  "appState": { "viewBackgroundColor": "#ffffff", "gridSize": null },
+  "files": {}
+}

docs/diagrams/02-agent-flow-map.excalidraw

@@ -0,0 +1,204 @@
+{
+  "type": "excalidraw",
+  "version": 2,
+  "source": "https://excalidraw.com",
+  "elements": [
+    { "type": "text", "id": "title", "x": 320, "y": 15, "text": "AI Agent Flow Map", "fontSize": 28 },
+    { "type": "text", "id": "subtitle", "x": 180, "y": 53, "text": "15 agent automation workflows. Agents need structured JSON (-J), exit codes, and field selection.", "fontSize": 14, "strokeColor": "#868e96" },
+
+    { "type": "text", "id": "col-trigger", "x": 60, "y": 80, "text": "TRIGGER (Agent Goal)", "fontSize": 16, "strokeColor": "#495057" },
+    { "type": "text", "id": "col-flow", "x": 400, "y": 80, "text": "COMMAND PIPELINE", "fontSize": 16, "strokeColor": "#495057" },
+    { "type": "text", "id": "col-gap", "x": 880, "y": 80, "text": "BLOCKED BY", "fontSize": 16, "strokeColor": "#ef4444" },
+
+    { "type": "rectangle", "id": "zone-context", "x": 20, "y": 110, "width": 960, "height": 200,
+      "backgroundColor": "#e5dbff", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#8b5cf6", "strokeWidth": 1, "opacity": 20 },
+    { "type": "text", "id": "zone-context-label", "x": 30, "y": 115, "text": "Context Gathering (pre-action)", "fontSize": 14, "strokeColor": "#7048e8" },
+
+    { "type": "rectangle", "id": "a1-trigger", "x": 30, "y": 140, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#d0bfff", "fillStyle": "solid",
+      "label": { "text": "A1: Pre-edit context\nAbout to modify files", "fontSize": 14 } },
+    { "type": "arrow", "id": "a1-a1", "x": 230, "y": 165, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a1-cmd1", "x": 280, "y": 145, "width": 80, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J health", "fontSize": 14 } },
+    { "type": "arrow", "id": "a1-a2", "x": 360, "y": 165, "width": 20, "height": 0,
+      "points": [[0,0],[20,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a1-cmd2", "x": 380, "y": 145, "width": 140, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J who src/auth/", "fontSize": 14 } },
+    { "type": "arrow", "id": "a1-a3", "x": 520, "y": 165, "width": 20, "height": 0,
+      "points": [[0,0],[20,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a1-cmd3", "x": 540, "y": 145, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J search \"auth\" -n 10", "fontSize": 14 } },
+    { "type": "arrow", "id": "a1-a4", "x": 710, "y": 165, "width": 20, "height": 0,
+      "points": [[0,0],[20,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a1-cmd4", "x": 730, "y": 145, "width": 130, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J who --overlap", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "a6-trigger", "x": 30, "y": 210, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#d0bfff", "fillStyle": "solid",
+      "label": { "text": "A6: Auto-assign reviewers\nBased on file expertise", "fontSize": 14 } },
+    { "type": "arrow", "id": "a6-a1", "x": 230, "y": 235, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a6-cmd1", "x": 280, "y": 215, "width": 100, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "-J mrs 456", "fontSize": 14 } },
+    { "type": "text", "id": "a6-block", "x": 390, "y": 218, "text": "file list not\nin response!", "fontSize": 12, "strokeColor": "#ef4444" },
+    { "type": "arrow", "id": "a6-a2", "x": 380, "y": 245, "width": 480, "height": -10,
+      "points": [[0,0],[480,-10]], "endArrowhead": "arrow", "strokeColor": "#ef4444", "strokeStyle": "dashed" },
+    { "type": "rectangle", "id": "a6-gap", "x": 860, "y": 210, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "MR files\nnot exposed", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "zone-report", "x": 20, "y": 320, "width": 960, "height": 200,
+      "backgroundColor": "#d3f9d8", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#22c55e", "strokeWidth": 1, "opacity": 20 },
+    { "type": "text", "id": "zone-report-label", "x": 30, "y": 325, "text": "Reporting & Synthesis", "fontSize": 14, "strokeColor": "#15803d" },
+
+    { "type": "rectangle", "id": "a3-trigger", "x": 30, "y": 350, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#d0bfff", "fillStyle": "solid",
+      "label": { "text": "A3: Sprint status report\n7 queries for 1 report", "fontSize": 14 } },
+    { "type": "arrow", "id": "a3-a1", "x": 230, "y": 375, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a3-cmd1", "x": 280, "y": 352, "width": 100, "height": 36,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "issues -s closed", "fontSize": 12 } },
+    { "type": "rectangle", "id": "a3-cmd2", "x": 390, "y": 352, "width": 100, "height": 36,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "issues --status", "fontSize": 12 } },
+    { "type": "rectangle", "id": "a3-cmd3", "x": 500, "y": 352, "width": 100, "height": 36,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "mrs -s merged", "fontSize": 12 } },
+    { "type": "rectangle", "id": "a3-cmd4", "x": 610, "y": 352, "width": 80, "height": 36,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "mrs -s open", "fontSize": 12 } },
+    { "type": "rectangle", "id": "a3-cmd5", "x": 700, "y": 352, "width": 80, "height": 36,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "count x2", "fontSize": 12 } },
+    { "type": "rectangle", "id": "a3-cmd6", "x": 790, "y": 352, "width": 60, "height": 36,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "who", "fontSize": 12 } },
+    { "type": "arrow", "id": "a3-agap", "x": 850, "y": 370, "width": 20, "height": 0,
+      "points": [[0,0],[20,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a3-gap", "x": 860, "y": 350, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No summary\ncommand", "fontSize": 14 } },
+    { "type": "text", "id": "a3-note", "x": 280, "y": 395, "text": "7 sequential API calls for one report. A `lore summary` could reduce to 1.", "fontSize": 12, "strokeColor": "#868e96" },
+
+    { "type": "rectangle", "id": "a7-trigger", "x": 30, "y": 430, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#d0bfff", "fillStyle": "solid",
+      "label": { "text": "A7: Incident timeline\nPostmortem reconstruction", "fontSize": 14 } },
+    { "type": "arrow", "id": "a7-a1", "x": 230, "y": 455, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a7-cmd1", "x": 280, "y": 435, "width": 190, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J timeline --depth 2", "fontSize": 14 } },
+    { "type": "arrow", "id": "a7-a2", "x": 470, "y": 455, "width": 20, "height": 0,
+      "points": [[0,0],[20,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a7-cmd2", "x": 490, "y": 435, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J search --since 3d", "fontSize": 14 } },
+    { "type": "arrow", "id": "a7-a3", "x": 660, "y": 455, "width": 20, "height": 0,
+      "points": [[0,0],[20,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a7-cmd3", "x": 680, "y": 435, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J mrs -s merged", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "zone-discover", "x": 20, "y": 530, "width": 960, "height": 200,
+      "backgroundColor": "#fff3bf", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#f59e0b", "strokeWidth": 1, "opacity": 20 },
+    { "type": "text", "id": "zone-discover-label", "x": 30, "y": 535, "text": "Discovery & Correlation", "fontSize": 14, "strokeColor": "#b45309" },
+
+    { "type": "rectangle", "id": "a5-trigger", "x": 30, "y": 560, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#d0bfff", "fillStyle": "solid",
+      "label": { "text": "A5: PR description\nFind related issues to link", "fontSize": 14 } },
+    { "type": "arrow", "id": "a5-a1", "x": 230, "y": 585, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a5-cmd1", "x": 280, "y": 565, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J search keywords", "fontSize": 14 } },
+    { "type": "arrow", "id": "a5-a2", "x": 450, "y": 585, "width": 20, "height": 0,
+      "points": [[0,0],[20,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a5-cmd2", "x": 470, "y": 565, "width": 180, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J issues --fields iid,url", "fontSize": 14 } },
+    { "type": "arrow", "id": "a5-a3", "x": 650, "y": 585, "width": 210, "height": 0,
+      "points": [[0,0],[210,0]], "endArrowhead": "arrow", "strokeColor": "#ef4444", "strokeStyle": "dashed" },
+    { "type": "rectangle", "id": "a5-gap", "x": 860, "y": 560, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No refs\nquery", "fontSize": 14 } },
+    { "type": "text", "id": "a5-note", "x": 280, "y": 612, "text": "Agent can't ask \"which issues does MR !456 close?\" -- entity_references data exists but isn't queryable.", "fontSize": 12, "strokeColor": "#868e96" },
+
+    { "type": "rectangle", "id": "a11-trigger", "x": 30, "y": 640, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#d0bfff", "fillStyle": "solid",
+      "label": { "text": "A11: Knowledge graph\nMap entity relationships", "fontSize": 14 } },
+    { "type": "arrow", "id": "a11-a1", "x": 230, "y": 665, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a11-cmd1", "x": 280, "y": 645, "width": 140, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J search -n 30", "fontSize": 14 } },
+    { "type": "arrow", "id": "a11-a2", "x": 420, "y": 665, "width": 20, "height": 0,
+      "points": [[0,0],[20,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a11-cmd2", "x": 440, "y": 645, "width": 190, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J timeline --depth 2", "fontSize": 14 } },
+    { "type": "arrow", "id": "a11-a3", "x": 630, "y": 665, "width": 230, "height": 0,
+      "points": [[0,0],[230,0]], "endArrowhead": "arrow", "strokeColor": "#ef4444", "strokeStyle": "dashed" },
+    { "type": "rectangle", "id": "a11-gap", "x": 860, "y": 640, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No refs\nquery", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "zone-maint", "x": 20, "y": 740, "width": 960, "height": 140,
+      "backgroundColor": "#dbe4ff", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#4a9eed", "strokeWidth": 1, "opacity": 20 },
+    { "type": "text", "id": "zone-maint-label", "x": 30, "y": 745, "text": "Maintenance & Cleanup", "fontSize": 14, "strokeColor": "#1971c2" },
+
+    { "type": "rectangle", "id": "a9-trigger", "x": 30, "y": 770, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#d0bfff", "fillStyle": "solid",
+      "label": { "text": "A9: Stale issue cleanup\nWeekly backlog hygiene", "fontSize": 14 } },
+    { "type": "arrow", "id": "a9-a1", "x": 230, "y": 795, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a9-cmd1", "x": 280, "y": 775, "width": 200, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J issues --sort updated --asc", "fontSize": 12 } },
+    { "type": "arrow", "id": "a9-a2", "x": 480, "y": 795, "width": 20, "height": 0,
+      "points": [[0,0],[20,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a9-cmd2", "x": 500, "y": 775, "width": 120, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "filter client-side", "fontSize": 14 } },
+    { "type": "arrow", "id": "a9-a3", "x": 620, "y": 795, "width": 240, "height": 0,
+      "points": [[0,0],[240,0]], "endArrowhead": "arrow", "strokeColor": "#ef4444", "strokeStyle": "dashed" },
+    { "type": "rectangle", "id": "a9-gap", "x": 860, "y": 770, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No --before\nNo offset", "fontSize": 14 } },
+
+    { "type": "rectangle", "id": "a15-trigger", "x": 30, "y": 840, "width": 200, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#d0bfff", "fillStyle": "solid",
+      "label": { "text": "A15: Conflict detect\n\"Safe to start work?\"", "fontSize": 14 } },
+    { "type": "arrow", "id": "a15-a1", "x": 230, "y": 865, "width": 50, "height": 0,
+      "points": [[0,0],[50,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a15-cmd1", "x": 280, "y": 845, "width": 110, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J issues 123", "fontSize": 14 } },
+    { "type": "arrow", "id": "a15-a2", "x": 390, "y": 865, "width": 20, "height": 0,
+      "points": [[0,0],[20,0]], "endArrowhead": "arrow" },
+    { "type": "rectangle", "id": "a15-cmd2", "x": 410, "y": 845, "width": 130, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "-J who --overlap", "fontSize": 14 } },
+    { "type": "arrow", "id": "a15-a3", "x": 540, "y": 865, "width": 320, "height": 0,
+      "points": [[0,0],[320,0]], "endArrowhead": "arrow", "strokeColor": "#ef4444", "strokeStyle": "dashed" },
+    { "type": "rectangle", "id": "a15-gap", "x": 860, "y": 840, "width": 110, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "No refs +\n--state", "fontSize": 14 } },
+
+    { "type": "text", "id": "callout-1", "x": 30, "y": 910, "text": "Agent-specific pain: Agents always use -J and --fields minimal for token efficiency. Every extra query burns tokens.", "fontSize": 14, "strokeColor": "#495057" },
+    { "type": "text", "id": "callout-2", "x": 30, "y": 935, "text": "Biggest ROI: `lore refs` command would unblock A5, A11, A12, A15 instantly. Data already exists in entity_references table.", "fontSize": 14, "strokeColor": "#15803d" },
+    { "type": "text", "id": "callout-3", "x": 30, "y": 960, "text": "Token waste: Sprint report (A3) requires 7 calls. A composite `lore summary` could save ~85% of tokens.", "fontSize": 14, "strokeColor": "#ef4444" }
+  ],
+  "appState": { "viewBackgroundColor": "#ffffff", "gridSize": null },
+  "files": {}
+}

docs/diagrams/03-command-coverage.excalidraw

@@ -0,0 +1,203 @@
+{
+  "type": "excalidraw",
+  "version": 2,
+  "source": "https://excalidraw.com",
+  "elements": [
+    { "type": "text", "id": "title", "x": 280, "y": 15, "text": "Command Coverage Heatmap", "fontSize": 28 },
+    { "type": "text", "id": "subtitle", "x": 220, "y": 53, "text": "Which commands serve which workflows? Darker = more essential to that flow.", "fontSize": 14, "strokeColor": "#868e96" },
+
+    { "type": "text", "id": "col-issues", "x": 260, "y": 85, "text": "issues", "fontSize": 14, "strokeColor": "#1971c2" },
+    { "type": "text", "id": "col-mrs", "x": 330, "y": 85, "text": "mrs", "fontSize": 14, "strokeColor": "#1971c2" },
+    { "type": "text", "id": "col-search", "x": 390, "y": 85, "text": "search", "fontSize": 14, "strokeColor": "#1971c2" },
+    { "type": "text", "id": "col-who", "x": 465, "y": 85, "text": "who", "fontSize": 14, "strokeColor": "#1971c2" },
+    { "type": "text", "id": "col-timeline", "x": 520, "y": 85, "text": "timeline", "fontSize": 14, "strokeColor": "#1971c2" },
+    { "type": "text", "id": "col-sync", "x": 600, "y": 85, "text": "sync", "fontSize": 14, "strokeColor": "#1971c2" },
+    { "type": "text", "id": "col-count", "x": 660, "y": 85, "text": "count", "fontSize": 14, "strokeColor": "#1971c2" },
+    { "type": "text", "id": "col-status", "x": 720, "y": 85, "text": "status", "fontSize": 14, "strokeColor": "#1971c2" },
+    { "type": "text", "id": "col-missing", "x": 790, "y": 85, "text": "MISSING?", "fontSize": 14, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "grp-human", "x": 15, "y": 108, "text": "HUMAN FLOWS", "fontSize": 14, "strokeColor": "#15803d" },
+
+    { "type": "text", "id": "h1-label", "x": 15, "y": 135, "text": "H1  Standup prep", "fontSize": 14 },
+    { "type": "rectangle", "id": "h1-issues", "x": 255, "y": 130, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h1-mrs", "x": 325, "y": 130, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h1-who", "x": 460, "y": 130, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h1-sync", "x": 595, "y": 130, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "h1-gap", "x": 780, "y": 135, "text": "activity feed", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "h2-label", "x": 15, "y": 170, "text": "H2  Sprint planning", "fontSize": 14 },
+    { "type": "rectangle", "id": "h2-issues", "x": 255, "y": 165, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h2-count", "x": 655, "y": 165, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "h2-gap", "x": 780, "y": 170, "text": "--no-assignee", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "h3-label", "x": 15, "y": 205, "text": "H3  Incident response", "fontSize": 14 },
+    { "type": "rectangle", "id": "h3-mrs", "x": 325, "y": 200, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h3-search", "x": 390, "y": 200, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h3-who", "x": 460, "y": 200, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h3-timeline", "x": 525, "y": 200, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h3-sync", "x": 595, "y": 200, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+
+    { "type": "text", "id": "h4-label", "x": 15, "y": 240, "text": "H4  Code review prep", "fontSize": 14 },
+    { "type": "rectangle", "id": "h4-mrs", "x": 325, "y": 235, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h4-search", "x": 390, "y": 235, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h4-who", "x": 460, "y": 235, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h4-timeline", "x": 525, "y": 235, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "h4-gap", "x": 780, "y": 240, "text": "MR file list", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "h5-label", "x": 15, "y": 275, "text": "H5  Onboarding", "fontSize": 14 },
+    { "type": "rectangle", "id": "h5-issues", "x": 255, "y": 270, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h5-mrs", "x": 325, "y": 270, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h5-search", "x": 390, "y": 270, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h5-who", "x": 460, "y": 270, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h5-timeline", "x": 525, "y": 270, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+
+    { "type": "text", "id": "h6-label", "x": 15, "y": 310, "text": "H6  Find reviewer", "fontSize": 14 },
+    { "type": "rectangle", "id": "h6-who", "x": 460, "y": 305, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "h6-gap", "x": 780, "y": 310, "text": "multi-path who", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "h7-label", "x": 15, "y": 345, "text": "H7  Why was this built?", "fontSize": 14 },
+    { "type": "rectangle", "id": "h7-issues", "x": 255, "y": 340, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h7-mrs", "x": 325, "y": 340, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h7-search", "x": 390, "y": 340, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h7-timeline", "x": 525, "y": 340, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "h7-gap", "x": 780, "y": 345, "text": "per-note search", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "h8-label", "x": 15, "y": 380, "text": "H8  Team workload", "fontSize": 14 },
+    { "type": "rectangle", "id": "h8-who", "x": 460, "y": 375, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "h8-gap", "x": 780, "y": 380, "text": "team view", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "h9-label", "x": 15, "y": 415, "text": "H9  Release notes", "fontSize": 14 },
+    { "type": "rectangle", "id": "h9-issues", "x": 255, "y": 410, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h9-mrs", "x": 325, "y": 410, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "h9-gap", "x": 780, "y": 415, "text": "mrs --milestone", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "h10-label", "x": 15, "y": 450, "text": "H10 Stale issues", "fontSize": 14 },
+    { "type": "rectangle", "id": "h10-issues", "x": 255, "y": 445, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "h10-gap", "x": 780, "y": 450, "text": "--updated-before", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "h11-label", "x": 15, "y": 485, "text": "H11 Bug lifecycle", "fontSize": 14 },
+    { "type": "rectangle", "id": "h11-issues", "x": 255, "y": 480, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h11-timeline", "x": 525, "y": 480, "width": 50, "height": 28, "backgroundColor": "#ffd8a8", "fillStyle": "solid" },
+    { "type": "text", "id": "h11-gap", "x": 780, "y": 485, "text": "entity timeline", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "h12-label", "x": 15, "y": 520, "text": "H12 Who broke tests?", "fontSize": 14 },
+    { "type": "rectangle", "id": "h12-search", "x": 390, "y": 515, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h12-who", "x": 460, "y": 515, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+
+    { "type": "text", "id": "h13-label", "x": 15, "y": 555, "text": "H13 Feature tracking", "fontSize": 14 },
+    { "type": "rectangle", "id": "h13-issues", "x": 255, "y": 550, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h13-mrs", "x": 325, "y": 550, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h13-timeline", "x": 525, "y": 550, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+
+    { "type": "text", "id": "h14-label", "x": 15, "y": 590, "text": "H14 Prior art check", "fontSize": 14 },
+    { "type": "rectangle", "id": "h14-search", "x": 390, "y": 585, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "h14-timeline", "x": 525, "y": 585, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "h14-gap", "x": 780, "y": 590, "text": "--state on search", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "h15-label", "x": 15, "y": 625, "text": "H15 My discussions", "fontSize": 14 },
+    { "type": "rectangle", "id": "h15-who", "x": 460, "y": 620, "width": 50, "height": 28, "backgroundColor": "#ffd8a8", "fillStyle": "solid" },
+    { "type": "text", "id": "h15-gap", "x": 780, "y": 625, "text": "participant filter", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "rectangle", "id": "divider", "x": 10, "y": 655, "width": 910, "height": 2, "backgroundColor": "#dee2e6", "fillStyle": "solid" },
+
+    { "type": "text", "id": "grp-agent", "x": 15, "y": 668, "text": "AI AGENT FLOWS", "fontSize": 14, "strokeColor": "#7048e8" },
+
+    { "type": "text", "id": "a1-label", "x": 15, "y": 695, "text": "A1  Pre-edit context", "fontSize": 14 },
+    { "type": "rectangle", "id": "a1-mrs", "x": 325, "y": 690, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a1-search", "x": 390, "y": 690, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a1-who", "x": 460, "y": 690, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+
+    { "type": "text", "id": "a2-label", "x": 15, "y": 730, "text": "A2  Auto-triage", "fontSize": 14 },
+    { "type": "rectangle", "id": "a2-issues", "x": 255, "y": 725, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a2-search", "x": 390, "y": 725, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a2-who", "x": 460, "y": 725, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "a2-gap", "x": 780, "y": 730, "text": "detail --fields", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a3-label", "x": 15, "y": 765, "text": "A3  Sprint report", "fontSize": 14 },
+    { "type": "rectangle", "id": "a3-issues", "x": 255, "y": 760, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a3-mrs", "x": 325, "y": 760, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a3-who", "x": 460, "y": 760, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a3-count", "x": 655, "y": 760, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "a3-gap", "x": 780, "y": 765, "text": "summary cmd", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a4-label", "x": 15, "y": 800, "text": "A4  Prior art", "fontSize": 14 },
+    { "type": "rectangle", "id": "a4-search", "x": 390, "y": 795, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a4-timeline", "x": 525, "y": 795, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "a4-gap", "x": 780, "y": 800, "text": "per-note search", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a5-label", "x": 15, "y": 835, "text": "A5  PR description", "fontSize": 14 },
+    { "type": "rectangle", "id": "a5-issues", "x": 255, "y": 830, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a5-search", "x": 390, "y": 830, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "a5-gap", "x": 780, "y": 835, "text": "entity refs query", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a6-label", "x": 15, "y": 870, "text": "A6  Reviewer assign", "fontSize": 14 },
+    { "type": "rectangle", "id": "a6-mrs", "x": 325, "y": 865, "width": 50, "height": 28, "backgroundColor": "#ffd8a8", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a6-who", "x": 460, "y": 865, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "a6-gap", "x": 780, "y": 870, "text": "MR file list", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a7-label", "x": 15, "y": 905, "text": "A7  Incident timeline", "fontSize": 14 },
+    { "type": "rectangle", "id": "a7-mrs", "x": 325, "y": 900, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a7-search", "x": 390, "y": 900, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a7-timeline", "x": 525, "y": 900, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+
+    { "type": "text", "id": "a8-label", "x": 15, "y": 940, "text": "A8  Cross-project", "fontSize": 14 },
+    { "type": "rectangle", "id": "a8-search", "x": 390, "y": 935, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a8-timeline", "x": 525, "y": 935, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "a8-gap", "x": 780, "y": 940, "text": "group by project", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a9-label", "x": 15, "y": 975, "text": "A9  Stale cleanup", "fontSize": 14 },
+    { "type": "rectangle", "id": "a9-issues", "x": 255, "y": 970, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a9-search", "x": 390, "y": 970, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "a9-gap", "x": 780, "y": 975, "text": "--updated-before", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a10-label", "x": 15, "y": 1010, "text": "A10 Review context", "fontSize": 14 },
+    { "type": "rectangle", "id": "a10-mrs", "x": 325, "y": 1005, "width": 50, "height": 28, "backgroundColor": "#ffd8a8", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a10-who", "x": 460, "y": 1005, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "a10-gap", "x": 780, "y": 1010, "text": "MR file list", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a11-label", "x": 15, "y": 1045, "text": "A11 Knowledge graph", "fontSize": 14 },
+    { "type": "rectangle", "id": "a11-search", "x": 390, "y": 1040, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a11-timeline", "x": 525, "y": 1040, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "a11-gap", "x": 780, "y": 1045, "text": "entity refs query", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a12-label", "x": 15, "y": 1080, "text": "A12 Release check", "fontSize": 14 },
+    { "type": "rectangle", "id": "a12-issues", "x": 255, "y": 1075, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a12-mrs", "x": 325, "y": 1075, "width": 50, "height": 28, "backgroundColor": "#ffd8a8", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a12-who", "x": 460, "y": 1075, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "a12-gap", "x": 780, "y": 1080, "text": "mrs --milestone", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a13-label", "x": 15, "y": 1115, "text": "A13 What changed?", "fontSize": 14 },
+    { "type": "rectangle", "id": "a13-issues", "x": 255, "y": 1110, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a13-mrs", "x": 325, "y": 1110, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "a13-gap", "x": 780, "y": 1115, "text": "state-change filter", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a14-label", "x": 15, "y": 1150, "text": "A14 Meeting prep", "fontSize": 14 },
+    { "type": "rectangle", "id": "a14-issues", "x": 255, "y": 1145, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a14-mrs", "x": 325, "y": 1145, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a14-who", "x": 460, "y": 1145, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a14-count", "x": 655, "y": 1145, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "a14-gap", "x": 780, "y": 1150, "text": "summary cmd", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "a15-label", "x": 15, "y": 1185, "text": "A15 Conflict detect", "fontSize": 14 },
+    { "type": "rectangle", "id": "a15-issues", "x": 255, "y": 1180, "width": 50, "height": 28, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a15-mrs", "x": 325, "y": 1180, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "rectangle", "id": "a15-who", "x": 460, "y": 1180, "width": 50, "height": 28, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "a15-gap", "x": 780, "y": 1185, "text": "entity refs, --state", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "legend-title", "x": 15, "y": 1230, "text": "Legend:", "fontSize": 14 },
+    { "type": "rectangle", "id": "leg-essential", "x": 80, "y": 1228, "width": 20, "height": 20, "backgroundColor": "#22c55e", "fillStyle": "solid" },
+    { "type": "text", "id": "leg-essential-t", "x": 105, "y": 1230, "text": "Essential", "fontSize": 14 },
+    { "type": "rectangle", "id": "leg-supporting", "x": 190, "y": 1228, "width": 20, "height": 20, "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "leg-supporting-t", "x": 215, "y": 1230, "text": "Supporting", "fontSize": 14 },
+    { "type": "rectangle", "id": "leg-partial", "x": 310, "y": 1228, "width": 20, "height": 20, "backgroundColor": "#ffd8a8", "fillStyle": "solid" },
+    { "type": "text", "id": "leg-partial-t", "x": 335, "y": 1230, "text": "Partially blocked", "fontSize": 14 },
+    { "type": "text", "id": "leg-gap-t", "x": 470, "y": 1230, "text": "Red text = gap", "fontSize": 14, "strokeColor": "#ef4444" },
+
+    { "type": "text", "id": "insight-1", "x": 15, "y": 1270, "text": "Key insight: `issues` and `search` are the workhorses (used in 20+ flows).", "fontSize": 14, "strokeColor": "#495057" },
+    { "type": "text", "id": "insight-2", "x": 15, "y": 1295, "text": "`who` is critical for people questions but siloed from file-change data.", "fontSize": 14, "strokeColor": "#495057" },
+    { "type": "text", "id": "insight-3", "x": 15, "y": 1320, "text": "`timeline` is powerful but keyword-only seeding limits entity-specific queries.", "fontSize": 14, "strokeColor": "#495057" },
+    { "type": "text", "id": "insight-4", "x": 15, "y": 1345, "text": "22/30 flows have at least one gap. Most gaps are filter additions, not new commands.", "fontSize": 14, "strokeColor": "#ef4444" }
+  ],
+  "appState": { "viewBackgroundColor": "#ffffff", "gridSize": null },
+  "files": {}
+}

docs/diagrams/04-gap-priority-matrix.excalidraw

@@ -0,0 +1,110 @@
+{
+  "type": "excalidraw",
+  "version": 2,
+  "source": "https://excalidraw.com",
+  "elements": [
+    { "type": "text", "id": "title", "x": 300, "y": 20, "text": "Lore CLI Gap Priority Matrix", "fontSize": 28 },
+    { "type": "text", "id": "subtitle", "x": 310, "y": 58, "text": "20 identified gaps plotted by impact vs effort", "fontSize": 16, "strokeColor": "#868e96" },
+
+    { "type": "rectangle", "id": "q1-zone", "x": 100, "y": 120, "width": 500, "height": 380,
+      "backgroundColor": "#d3f9d8", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#22c55e", "strokeWidth": 1, "opacity": 25 },
+    { "type": "text", "id": "q1-label", "x": 110, "y": 126, "text": "QUICK WINS", "fontSize": 18, "strokeColor": "#15803d" },
+
+    { "type": "rectangle", "id": "q2-zone", "x": 620, "y": 120, "width": 500, "height": 380,
+      "backgroundColor": "#fff3bf", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#f59e0b", "strokeWidth": 1, "opacity": 25 },
+    { "type": "text", "id": "q2-label", "x": 630, "y": 126, "text": "STRATEGIC", "fontSize": 18, "strokeColor": "#b45309" },
+
+    { "type": "rectangle", "id": "q3-zone", "x": 100, "y": 520, "width": 500, "height": 300,
+      "backgroundColor": "#dbe4ff", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#4a9eed", "strokeWidth": 1, "opacity": 25 },
+    { "type": "text", "id": "q3-label", "x": 110, "y": 526, "text": "FILL-IN", "fontSize": 18, "strokeColor": "#1971c2" },
+
+    { "type": "rectangle", "id": "q4-zone", "x": 620, "y": 520, "width": 500, "height": 300,
+      "backgroundColor": "#ffc9c9", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#ef4444", "strokeWidth": 1, "opacity": 25 },
+    { "type": "text", "id": "q4-label", "x": 630, "y": 526, "text": "DEPRIORITIZE", "fontSize": 18, "strokeColor": "#c92a2a" },
+
+    { "type": "text", "id": "y-axis-hi", "x": 30, "y": 130, "text": "HIGH\nIMPACT", "fontSize": 16, "strokeColor": "#495057", "textAlign": "center" },
+    { "type": "text", "id": "y-axis-lo", "x": 30, "y": 550, "text": "LOW\nIMPACT", "fontSize": 16, "strokeColor": "#495057", "textAlign": "center" },
+    { "type": "text", "id": "x-axis-lo", "x": 280, "y": 840, "text": "LOW EFFORT", "fontSize": 16, "strokeColor": "#495057" },
+    { "type": "text", "id": "x-axis-hi", "x": 800, "y": 840, "text": "HIGH EFFORT", "fontSize": 16, "strokeColor": "#495057" },
+
+    { "type": "arrow", "id": "y-arrow", "x": 85, "y": 810, "width": 0, "height": -680,
+      "points": [[0,0],[0,-680]], "endArrowhead": "arrow", "strokeColor": "#495057", "strokeWidth": 1 },
+    { "type": "arrow", "id": "x-arrow", "x": 85, "y": 810, "width": 1050, "height": 0,
+      "points": [[0,0],[1050,0]], "endArrowhead": "arrow", "strokeColor": "#495057", "strokeWidth": 1 },
+
+    { "type": "rectangle", "id": "g5", "x": 120, "y": 160, "width": 210, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "#5 @me alias", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g8", "x": 120, "y": 225, "width": 210, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "#8 --state on search", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g9", "x": 120, "y": 290, "width": 210, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "#9 mrs --milestone", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g10", "x": 120, "y": 355, "width": 210, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "#10 --no-assignee", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g11", "x": 350, "y": 160, "width": 230, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "#11 --updated-before", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g14", "x": 350, "y": 225, "width": 230, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "#14 detail --fields", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g18", "x": 350, "y": 290, "width": 230, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "#18 1y/12m duration", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g20", "x": 350, "y": 355, "width": 230, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "#20 sort by due date", "fontSize": 16 } },
+
+    { "type": "rectangle", "id": "g1", "x": 640, "y": 160, "width": 220, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "#1 MR file changes", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g2", "x": 640, "y": 225, "width": 220, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "#2 entity refs query", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g3", "x": 640, "y": 290, "width": 220, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "#3 per-note search", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g4", "x": 880, "y": 160, "width": 220, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "#4 entity timeline", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g6", "x": 880, "y": 225, "width": 220, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "#6 activity feed", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g12", "x": 880, "y": 290, "width": 220, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffd8a8", "fillStyle": "solid",
+      "label": { "text": "#12 team workload", "fontSize": 16 } },
+
+    { "type": "rectangle", "id": "g13", "x": 120, "y": 570, "width": 210, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "#13 pagination/offset", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g15", "x": 120, "y": 635, "width": 210, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "#15 group by project", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g19", "x": 120, "y": 700, "width": 210, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "#19 participant filter", "fontSize": 16 } },
+
+    { "type": "rectangle", "id": "g7", "x": 640, "y": 570, "width": 220, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid",
+      "label": { "text": "#7 multi-path who", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g16", "x": 640, "y": 635, "width": 220, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid",
+      "label": { "text": "#16 trend metrics", "fontSize": 16 } },
+    { "type": "rectangle", "id": "g17", "x": 640, "y": 700, "width": 220, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid",
+      "label": { "text": "#17 --for-issue on mrs", "fontSize": 16 } },
+
+    { "type": "text", "id": "q1-count", "x": 180, "y": 430, "text": "8 gaps - lowest hanging fruit", "fontSize": 14, "strokeColor": "#15803d" },
+    { "type": "text", "id": "q2-count", "x": 710, "y": 370, "text": "6 gaps - build deliberately", "fontSize": 14, "strokeColor": "#b45309" },
+    { "type": "text", "id": "q3-count", "x": 160, "y": 770, "text": "3 gaps - fill as needed", "fontSize": 14, "strokeColor": "#1971c2" },
+    { "type": "text", "id": "q4-count", "x": 680, "y": 770, "text": "3 gaps - defer or rethink", "fontSize": 14, "strokeColor": "#c92a2a" }
+  ],
+  "appState": { "viewBackgroundColor": "#ffffff", "gridSize": null },
+  "files": {}
+}

docs/diagrams/05-data-flow-architecture.excalidraw

@@ -0,0 +1,184 @@
+{
+  "type": "excalidraw",
+  "version": 2,
+  "source": "https://excalidraw.com",
+  "elements": [
+    { "type": "text", "id": "title", "x": 350, "y": 15, "text": "Lore Data Flow Architecture", "fontSize": 28 },
+    { "type": "text", "id": "subtitle", "x": 280, "y": 53, "text": "Green = queryable via CLI  |  Red = stored but hidden  |  Gray = internal", "fontSize": 14, "strokeColor": "#868e96" },
+
+    { "type": "rectangle", "id": "zone-gitlab", "x": 30, "y": 90, "width": 200, "height": 300,
+      "backgroundColor": "#e5dbff", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#8b5cf6", "strokeWidth": 1, "opacity": 30 },
+    { "type": "text", "id": "zone-gitlab-label", "x": 55, "y": 96, "text": "GitLab APIs", "fontSize": 16, "strokeColor": "#7048e8" },
+
+    { "type": "rectangle", "id": "rest-api", "x": 50, "y": 130, "width": 160, "height": 60,
+      "roundness": { "type": 3 }, "backgroundColor": "#d0bfff", "fillStyle": "solid",
+      "label": { "text": "REST API\n(paginated)", "fontSize": 16 } },
+    { "type": "rectangle", "id": "graphql-api", "x": 50, "y": 210, "width": 160, "height": 60,
+      "roundness": { "type": 3 }, "backgroundColor": "#d0bfff", "fillStyle": "solid",
+      "label": { "text": "GraphQL API\n(adaptive pages)", "fontSize": 16 } },
+    { "type": "rectangle", "id": "ollama-api", "x": 50, "y": 310, "width": 160, "height": 60,
+      "roundness": { "type": 3 }, "backgroundColor": "#d0bfff", "fillStyle": "solid",
+      "label": { "text": "Ollama\n(embeddings)", "fontSize": 16 } },
+
+    { "type": "rectangle", "id": "zone-ingest", "x": 270, "y": 90, "width": 180, "height": 300,
+      "backgroundColor": "#dbe4ff", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#4a9eed", "strokeWidth": 1, "opacity": 30 },
+    { "type": "text", "id": "zone-ingest-label", "x": 300, "y": 96, "text": "Ingestion", "fontSize": 16, "strokeColor": "#1971c2" },
+
+    { "type": "rectangle", "id": "ingest-issues", "x": 285, "y": 130, "width": 150, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "Issue Sync", "fontSize": 16 } },
+    { "type": "rectangle", "id": "ingest-mrs", "x": 285, "y": 195, "width": 150, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "MR Sync", "fontSize": 16 } },
+    { "type": "rectangle", "id": "ingest-disc", "x": 285, "y": 260, "width": 150, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "Discussion Sync", "fontSize": 16 } },
+    { "type": "rectangle", "id": "ingest-events", "x": 285, "y": 325, "width": 150, "height": 50,
+      "roundness": { "type": 3 }, "backgroundColor": "#a5d8ff", "fillStyle": "solid",
+      "label": { "text": "Event Sync", "fontSize": 16 } },
+
+    { "type": "arrow", "id": "a-rest-issues", "x": 210, "y": 155, "width": 75, "height": 0,
+      "points": [[0,0],[75,0]], "endArrowhead": "arrow", "strokeColor": "#495057" },
+    { "type": "arrow", "id": "a-rest-mrs", "x": 210, "y": 165, "width": 75, "height": 50,
+      "points": [[0,0],[75,50]], "endArrowhead": "arrow", "strokeColor": "#495057" },
+    { "type": "arrow", "id": "a-graphql-issues", "x": 210, "y": 240, "width": 75, "height": -80,
+      "points": [[0,0],[75,-80]], "endArrowhead": "arrow", "strokeColor": "#495057" },
+
+    { "type": "rectangle", "id": "zone-sqlite", "x": 490, "y": 90, "width": 400, "height": 650,
+      "backgroundColor": "#d3f9d8", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#22c55e", "strokeWidth": 1, "opacity": 20 },
+    { "type": "text", "id": "zone-sqlite-label", "x": 570, "y": 96, "text": "SQLite (WAL mode)", "fontSize": 16, "strokeColor": "#15803d" },
+
+    { "type": "text", "id": "grp-queryable", "x": 500, "y": 120, "text": "Queryable Tables", "fontSize": 14, "strokeColor": "#15803d" },
+
+    { "type": "rectangle", "id": "t-projects", "x": 500, "y": 145, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "projects", "fontSize": 14 } },
+    { "type": "rectangle", "id": "t-issues", "x": 500, "y": 195, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "issues + assignees", "fontSize": 14 } },
+    { "type": "rectangle", "id": "t-mrs", "x": 500, "y": 245, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "merge_requests", "fontSize": 14 } },
+    { "type": "rectangle", "id": "t-discussions", "x": 500, "y": 295, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "discussions + notes", "fontSize": 14 } },
+    { "type": "rectangle", "id": "t-events", "x": 500, "y": 345, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "resource_*_events", "fontSize": 14 } },
+    { "type": "rectangle", "id": "t-docs", "x": 500, "y": 395, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "documents + FTS5", "fontSize": 14 } },
+    { "type": "rectangle", "id": "t-embed", "x": 500, "y": 445, "width": 170, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#b2f2bb", "fillStyle": "solid",
+      "label": { "text": "embeddings (vec)", "fontSize": 14 } },
+
+    { "type": "text", "id": "grp-hidden", "x": 700, "y": 120, "text": "Hidden Tables", "fontSize": 14, "strokeColor": "#c92a2a" },
+
+    { "type": "rectangle", "id": "t-file-changes", "x": 695, "y": 145, "width": 180, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "mr_file_changes", "fontSize": 14 } },
+    { "type": "rectangle", "id": "t-entity-refs", "x": 695, "y": 195, "width": 180, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "entity_references", "fontSize": 14 } },
+    { "type": "rectangle", "id": "t-raw", "x": 695, "y": 245, "width": 180, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444",
+      "label": { "text": "raw_payloads", "fontSize": 14 } },
+
+    { "type": "text", "id": "grp-internal", "x": 700, "y": 310, "text": "Internal Only", "fontSize": 14, "strokeColor": "#868e96" },
+
+    { "type": "rectangle", "id": "t-sync", "x": 695, "y": 340, "width": 180, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#dee2e6", "fillStyle": "solid", "strokeColor": "#868e96",
+      "label": { "text": "sync_runs + cursors", "fontSize": 14 } },
+    { "type": "rectangle", "id": "t-dirty", "x": 695, "y": 390, "width": 180, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#dee2e6", "fillStyle": "solid", "strokeColor": "#868e96",
+      "label": { "text": "dirty_sources", "fontSize": 14 } },
+    { "type": "rectangle", "id": "t-locks", "x": 695, "y": 440, "width": 180, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#dee2e6", "fillStyle": "solid", "strokeColor": "#868e96",
+      "label": { "text": "app_locks", "fontSize": 14 } },
+
+    { "type": "arrow", "id": "a-ingest-tables", "x": 435, "y": 200, "width": 55, "height": 0,
+      "points": [[0,0],[55,0]], "endArrowhead": "arrow", "strokeColor": "#495057" },
+
+    { "type": "rectangle", "id": "zone-cli", "x": 930, "y": 90, "width": 250, "height": 650,
+      "backgroundColor": "#fff3bf", "fillStyle": "solid", "roundness": { "type": 3 },
+      "strokeColor": "#f59e0b", "strokeWidth": 1, "opacity": 25 },
+    { "type": "text", "id": "zone-cli-label", "x": 990, "y": 96, "text": "CLI Commands", "fontSize": 16, "strokeColor": "#b45309" },
+
+    { "type": "rectangle", "id": "cmd-issues", "x": 950, "y": 130, "width": 210, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#fff3bf", "fillStyle": "solid",
+      "label": { "text": "lore issues", "fontSize": 16 } },
+    { "type": "rectangle", "id": "cmd-mrs", "x": 950, "y": 185, "width": 210, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#fff3bf", "fillStyle": "solid",
+      "label": { "text": "lore mrs", "fontSize": 16 } },
+    { "type": "rectangle", "id": "cmd-search", "x": 950, "y": 240, "width": 210, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#fff3bf", "fillStyle": "solid",
+      "label": { "text": "lore search", "fontSize": 16 } },
+    { "type": "rectangle", "id": "cmd-who", "x": 950, "y": 295, "width": 210, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#fff3bf", "fillStyle": "solid",
+      "label": { "text": "lore who", "fontSize": 16 } },
+    { "type": "rectangle", "id": "cmd-timeline", "x": 950, "y": 350, "width": 210, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#fff3bf", "fillStyle": "solid",
+      "label": { "text": "lore timeline", "fontSize": 16 } },
+    { "type": "rectangle", "id": "cmd-count", "x": 950, "y": 405, "width": 210, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#fff3bf", "fillStyle": "solid",
+      "label": { "text": "lore count", "fontSize": 16 } },
+    { "type": "rectangle", "id": "cmd-sync", "x": 950, "y": 460, "width": 210, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#fff3bf", "fillStyle": "solid",
+      "label": { "text": "lore sync", "fontSize": 16 } },
+    { "type": "rectangle", "id": "cmd-status", "x": 950, "y": 515, "width": 210, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#fff3bf", "fillStyle": "solid",
+      "label": { "text": "lore status", "fontSize": 16 } },
+
+    { "type": "arrow", "id": "a-issues-cmd", "x": 670, "y": 215, "width": 270, "height": -65,
+      "points": [[0,0],[270,-65]], "endArrowhead": "arrow", "strokeColor": "#22c55e", "strokeWidth": 2 },
+    { "type": "arrow", "id": "a-mrs-cmd", "x": 670, "y": 265, "width": 270, "height": -60,
+      "points": [[0,0],[270,-60]], "endArrowhead": "arrow", "strokeColor": "#22c55e", "strokeWidth": 2 },
+    { "type": "arrow", "id": "a-docs-cmd", "x": 670, "y": 415, "width": 270, "height": -155,
+      "points": [[0,0],[270,-155]], "endArrowhead": "arrow", "strokeColor": "#22c55e", "strokeWidth": 2 },
+    { "type": "arrow", "id": "a-embed-cmd", "x": 670, "y": 465, "width": 270, "height": -200,
+      "points": [[0,0],[270,-200]], "endArrowhead": "arrow", "strokeColor": "#22c55e", "strokeWidth": 2 },
+    { "type": "arrow", "id": "a-events-cmd", "x": 670, "y": 365, "width": 270, "height": 5,
+      "points": [[0,0],[270,5]], "endArrowhead": "arrow", "strokeColor": "#22c55e", "strokeWidth": 2 },
+
+    { "type": "text", "id": "hidden-note-1", "x": 695, "y": 498, "text": "mr_file_changes: populated by\nMR sync but NOT queryable.\nBlocks H4, A6, A10 flows.", "fontSize": 14, "strokeColor": "#ef4444" },
+    { "type": "text", "id": "hidden-note-2", "x": 695, "y": 568, "text": "entity_references: used by\ntimeline internally but NOT\nqueryable. Blocks A5, A11.", "fontSize": 14, "strokeColor": "#ef4444" },
+
+    { "type": "arrow", "id": "a-hidden-who", "x": 875, "y": 165, "width": 65, "height": 148,
+      "points": [[0,0],[65,148]], "endArrowhead": "arrow", "strokeColor": "#ef4444", "strokeWidth": 2,
+      "strokeStyle": "dashed" },
+    { "type": "text", "id": "hidden-who-label", "x": 880, "y": 240, "text": "who uses\nDiffNotes,\nnot file\nchanges", "fontSize": 12, "strokeColor": "#ef4444" },
+
+    { "type": "arrow", "id": "a-hidden-timeline", "x": 875, "y": 215, "width": 65, "height": 155,
+      "points": [[0,0],[65,155]], "endArrowhead": "arrow", "strokeColor": "#ef4444", "strokeWidth": 2,
+      "strokeStyle": "dashed" },
+
+    { "type": "rectangle", "id": "cmd-missing-refs", "x": 950, "y": 580, "width": 210, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444", "strokeStyle": "dashed",
+      "label": { "text": "lore refs (missing)", "fontSize": 16 } },
+    { "type": "rectangle", "id": "cmd-missing-files", "x": 950, "y": 635, "width": 210, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444", "strokeStyle": "dashed",
+      "label": { "text": "lore files (missing)", "fontSize": 16 } },
+    { "type": "rectangle", "id": "cmd-missing-activity", "x": 950, "y": 690, "width": 210, "height": 40,
+      "roundness": { "type": 3 }, "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444", "strokeStyle": "dashed",
+      "label": { "text": "lore activity (missing)", "fontSize": 16 } },
+
+    { "type": "text", "id": "legend-title", "x": 30, "y": 430, "text": "Legend", "fontSize": 16 },
+    { "type": "rectangle", "id": "leg-green", "x": 30, "y": 460, "width": 20, "height": 20,
+      "backgroundColor": "#b2f2bb", "fillStyle": "solid" },
+    { "type": "text", "id": "leg-green-t", "x": 60, "y": 462, "text": "Queryable via CLI", "fontSize": 14 },
+    { "type": "rectangle", "id": "leg-red", "x": 30, "y": 490, "width": 20, "height": 20,
+      "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444" },
+    { "type": "text", "id": "leg-red-t", "x": 60, "y": 492, "text": "Stored but hidden", "fontSize": 14 },
+    { "type": "rectangle", "id": "leg-gray", "x": 30, "y": 520, "width": 20, "height": 20,
+      "backgroundColor": "#dee2e6", "fillStyle": "solid", "strokeColor": "#868e96" },
+    { "type": "text", "id": "leg-gray-t", "x": 60, "y": 522, "text": "Internal bookkeeping", "fontSize": 14 },
+    { "type": "rectangle", "id": "leg-dashed", "x": 30, "y": 550, "width": 20, "height": 20,
+      "backgroundColor": "#ffc9c9", "fillStyle": "solid", "strokeColor": "#ef4444", "strokeStyle": "dashed" },
+    { "type": "text", "id": "leg-dashed-t", "x": 60, "y": 552, "text": "Missing command", "fontSize": 14 }
+  ],
+  "appState": { "viewBackgroundColor": "#ffffff", "gridSize": null },
+  "files": {}
+}

docs/performance-audit-2026-02-12.md

@@ -0,0 +1,179 @@
+# Deep Performance Audit Report
+
+**Date:** 2026-02-12
+**Branch:** `perf-audit` (e9bacc94)
+**Parent:** `039ab1c2` (master, v0.6.1)
+
+---
+
+## Methodology
+
+1. **Baseline** — measured p50/p95 latency for all major commands with warm cache
+2. **Profile** — used macOS `sample` profiler and `EXPLAIN QUERY PLAN` to identify hotspots
+3. **Golden output** — captured exact numeric outputs before changes as equivalence oracle
+4. **One lever per change** — each optimization isolated and independently benchmarked
+5. **Revert threshold** — any optimization <1.1x speedup reverted per audit rules
+
+---
+
+## Baseline Measurements (warm cache, release build)
+
+| Command | Latency | Notes |
+|---------|---------|-------|
+| `who --path src/core/db.rs` (expert) | 2200ms | **Hotspot** |
+| `who --active` | 83-93ms | Acceptable |
+| `who workload` | 22ms | Fast |
+| `stats` | 107-112ms | **Hotspot** |
+| `search "authentication"` | 1030ms | **Hotspot** (library-level) |
+| `list issues -n 50` | ~40ms | Fast |
+
+---
+
+## Optimization 1: INDEXED BY for DiffNote Queries
+
+**Target:** `src/cli/commands/who.rs` — expert and reviews query paths
+
+**Problem:** SQLite query planner chose `idx_notes_system` (38% selectivity, 106K rows) over `idx_notes_diffnote_path_created` (9.3% selectivity, 26K rows) for path-filtered DiffNote queries. The partial index `WHERE noteable_type = 'MergeRequest' AND type = 'DiffNote'` is far more selective but the planner's cost model didn't pick it.
+
+**Change:** Added `INDEXED BY idx_notes_diffnote_path_created` to all 8 SQL queries across `query_expert`, `query_expert_details`, `query_reviews`, `build_path_query` (probes 1 & 2), and `suffix_probe`.
+
+**Results:**
+
+| Query | Before | After | Speedup |
+|-------|--------|-------|---------|
+| expert (specific path) | 2200ms | 56-58ms | **38x** |
+| expert (broad path) | 2200ms | 83ms | **26x** |
+| reviews | 1800ms | 24ms | **75x** |
+
+**Isomorphism proof:** `INDEXED BY` only changes which index the planner uses, not the query semantics. Same rows matched, same ordering, same output. Verified by golden output comparison across 5+ runs.
+
+---
+
+## Optimization 2: Conditional Aggregates in Stats
+
+**Target:** `src/cli/commands/stats.rs`
+
+**Problem:** 12+ sequential `COUNT(*)` queries each requiring a full table scan of `documents` (61K rows). Each scan touched the same pages but couldn't share work.
+
+**Changes:**
+- Documents: 5 sequential COUNTs -> 1 query with `SUM(CASE WHEN ... THEN 1 END)`
+- FTS count: `SELECT COUNT(*) FROM documents_fts` (virtual table, slow) -> `SELECT COUNT(*) FROM documents_fts_docsize` (shadow B-tree table, 19x faster)
+- Embeddings: 2 queries -> 1 with `COUNT(DISTINCT document_id), COUNT(*)`
+- Dirty sources: 2 queries -> 1 with conditional aggregates
+- Pending fetches: 2 queries -> 1 each (discussions, dependents)
+
+**Results:**
+
+| Metric | Before | After | Speedup |
+|--------|--------|-------|---------|
+| Warm median | 112ms | 66ms | **1.70x** |
+| Cold | 1220ms | ~700ms | ~1.7x |
+
+**Golden output verified:**
+
+```
+total:61652, issues:8241, mrs:10018, discussions:43393, truncated:63
+fts:61652, embedded:61652, chunks:88161
+```
+
+All values match exactly across before/after runs.
+
+**Isomorphism proof:** `SUM(CASE WHEN x THEN 1 END)` is algebraically identical to `COUNT(*) WHERE x`. The FTS5 shadow table `documents_fts_docsize` has exactly one row per FTS document by SQLite specification, so `COUNT(*)` on it equals the virtual table count.
+
+---
+
+## Investigation: Two-Phase FTS Search (REVERTED)
+
+**Target:** `src/search/fts.rs`, `src/cli/commands/search.rs`
+
+**Hypothesis:** FTS5 `snippet()` generation is expensive. Splitting search into Phase 1 (score-only MATCH+bm25) and Phase 2 (snippet for filtered results only) should reduce work.
+
+**Implementation:** Created `fetch_fts_snippets()` that retrieves snippets only for post-filter document IDs via `json_each()` join.
+
+**Results:**
+
+| Metric | Before | After | Improvement |
+|--------|--------|-------|-------------|
+| search (limit 20) | 1030ms | 995ms | 3.5% |
+
+**Decision:** Reverted. Per audit rules, <1.1x speedup does not justify added code complexity.
+
+**Root cause:** The bottleneck is not snippet generation but `MATCH` + `bm25()` scoring itself. Profiling showed `strspn` (FTS5 tokenizer) and `memmove` as the top CPU consumers. The same query runs in 30ms on system sqlite3 but 1030ms in rusqlite's bundled SQLite — a ~125x gap despite both being SQLite 3.51.x compiled at -O3.
+
+---
+
+## Library-Level Finding: Bundled SQLite FTS5 Performance
+
+**Observation:** FTS5 MATCH+bm25 queries are ~125x slower in rusqlite's bundled SQLite vs system sqlite3.
+
+| Environment | Query Time | Notes |
+|-------------|-----------|-------|
+| System sqlite3 (macOS) | 30ms (with snippet), 8ms (without) | Same .db file |
+| rusqlite bundled | 1030ms | `features = ["bundled"]`, OPT_LEVEL=3 |
+
+**Profiler data (macOS `sample`):**
+- Top hotspot: `strspn` in FTS5 tokenizer
+- Secondary: `memmove` in FTS5 internals
+- Scaling: ~5ms per result (limit 5 = 497ms, limit 20 = 995ms)
+
+**Possible causes:**
+- Bundled SQLite compiled without platform-specific optimizations (SIMD, etc.)
+- Different memory allocator behavior
+- Missing compile-time tuning flags
+
+**Recommendation for future:** Investigate switching from `features = ["bundled"]` to system SQLite linkage, or audit the bundled compile flags in the `libsqlite3-sys` build script.
+
+---
+
+## Exploration Agent Findings (Informational)
+
+Four parallel exploration agents surveyed the entire codebase. Key findings beyond what was already addressed:
+
+### Ingestion Pipeline
+- Serial DB writes in async context (acceptable — rusqlite is synchronous)
+- Label ingestion uses individual inserts (potential batch optimization, low priority)
+
+### CLI / GitLab Client
+- GraphQL client recreated per call (`client.rs:98-100`) — caches connection pool, minor
+- Double JSON deserialization in GraphQL responses — medium priority
+- N+1 subqueries in `list` command (`list.rs:408-423`) — 4 correlated subqueries per row
+
+### Search / Embedding
+- No N+1 patterns, no O(n^2) algorithms
+- Chunking is O(n) single-pass with proper UTF-8 safety
+- Ollama concurrency model is sound (parallel HTTP, serial DB writes)
+
+### Database / Documents
+- O(n^2) prefix sum in `truncation.rs` — low traffic path
+- String allocation patterns in extractors — micro-optimization territory
+
+---
+
+## Opportunity Matrix
+
+| Candidate | Impact | Confidence | Effort | Score | Status |
+|-----------|--------|------------|--------|-------|--------|
+| INDEXED BY for DiffNote | Very High | High | Low | **9.0** | Shipped |
+| Stats conditional aggregates | Medium | High | Low | **7.0** | Shipped |
+| Bundled SQLite FTS5 | Very High | Medium | High | 5.0 | Documented |
+| List N+1 subqueries | Medium | Medium | Medium | 4.0 | Backlog |
+| GraphQL double deser | Low | Medium | Low | 3.5 | Backlog |
+| Truncation O(n^2) | Low | High | Low | 3.0 | Backlog |
+
+---
+
+## Files Modified
+
+| File | Change |
+|------|--------|
+| `src/cli/commands/who.rs` | INDEXED BY hints on 8 SQL queries |
+| `src/cli/commands/stats.rs` | Conditional aggregates, FTS5 shadow table, merged queries |
+
+---
+
+## Quality Gates
+
+- All 603 tests pass
+- `cargo clippy --all-targets -- -D warnings` clean
+- `cargo fmt --check` clean
+- Golden output verified for both optimizations

docs/prd-per-note-search.feedback-1.md

@@ -0,0 +1,174 @@
+Highest-impact gaps I see in the current plan:
+
+1. `for-issue` / `for-mr` filtering is ambiguous across projects and can return incorrect rows.
+2. `lore notes` has no pagination contract, so large exports and deterministic resumption are weak.
+3. Migration `022` is high-risk (table rebuild + FTS + junction tables) without explicit integrity gates.
+4. Note-doc freshness is incomplete for upstream note deletions and parent metadata changes (labels/title).
+
+Below are my best revisions, each with rationale and a git-diff-style plan edit.
+
+---
+
+1. **Add gated rollout + rollback controls**
+Rationale: You can still “ship together” while reducing blast radius. This makes recovery fast if note-doc generation causes DB/embedding pressure.
+
+```diff
+@@ ## Design
+-Two phases, shipped together as one feature:
++Two phases, shipped together as one feature, but with runtime gates:
++
++- `feature.notes_cli` (Phase 1 surface)
++- `feature.note_documents` (Phase 2 indexing/extraction path)
++
++Rollout order:
++1) Enable `notes_cli`
++2) Run note-doc backfill in bounded batches
++3) Enable `note_documents` for continuous updates
++
++Rollback:
++- Disabling `feature.note_documents` stops new note-doc generation without affecting issue/MR/discussion docs.
+```
+
+2. **Add keyset pagination + deterministic ordering**
+Rationale: Needed for year-long reviewer analysis and reliable “continue where I left off” behavior under concurrent updates.
+
+```diff
+@@ pub struct NoteListFilters<'a> {
+     pub limit: usize,
++    pub cursor: Option<&'a str>,        // keyset token "<sort_ms>:<id>"
++    pub include_total_count: bool,      // avoid COUNT(*) in hot paths
+@@
+-    pub sort: &'a str,                  // "created" (default) | "updated"
++    pub sort: &'a str,                  // "created" | "updated"
+@@ query_notes SQL
+-ORDER BY {sort_column} {order}
++ORDER BY {sort_column} {order}, n.id {order}
+ LIMIT ?
+```
+
+3. **Make `for-issue` / `for-mr` project-scoped**
+Rationale: IIDs are not globally unique. Requiring project avoids false positives and hard-to-debug cross-project leakage.
+
+```diff
+@@ pub struct NotesArgs {
+-    #[arg(long = "for-issue", help_heading = "Filters", conflicts_with = "for_mr")]
++    #[arg(long = "for-issue", help_heading = "Filters", conflicts_with = "for_mr", requires = "project")]
+     pub for_issue: Option<i64>,
+@@
+-    #[arg(long = "for-mr", help_heading = "Filters", conflicts_with = "for_issue")]
++    #[arg(long = "for-mr", help_heading = "Filters", conflicts_with = "for_issue", requires = "project")]
+     pub for_mr: Option<i64>,
+```
+
+4. **Upgrade path filtering semantics**
+Rationale: Review comments often reference renames/moves. Restricting to `position_new_path` misses relevant notes.
+
+```diff
+@@ pub struct NotesArgs {
+-    /// Filter by file path (trailing / for prefix match)
++    /// Filter by file path
+     #[arg(long, help_heading = "Filters")]
+     pub path: Option<String>,
++    /// Path mode: exact|prefix|glob
++    #[arg(long = "path-mode", value_parser = ["exact","prefix","glob"], default_value = "exact", help_heading = "Filters")]
++    pub path_mode: String,
++    /// Match against old path as well as new path
++    #[arg(long = "match-old-path", help_heading = "Filters")]
++    pub match_old_path: bool,
+@@ query_notes filter mappings
+-- `path` ... n.position_new_path ...
++- `path` applies to `n.position_new_path` and optionally `n.position_old_path`.
++- `glob` mode translates `*`/`?` to SQL LIKE with escaping.
+```
+
+5. **Add explicit performance indexes (new migration)**
+Rationale: `notes` becomes a first-class query surface; without indexes, filters degrade quickly at 10k+ note scale.
+
+```diff
+@@ ## Phase 1: `lore notes` Command
++### Work Chunk 1E: Query Performance Indexes
++**Files:** `migrations/023_notes_query_indexes.sql`, `src/core/db.rs`
++
++Add indexes:
++- `notes(project_id, created_at DESC, id DESC)`
++- `notes(author_username, created_at DESC, id DESC) WHERE is_system = 0`
++- `notes(discussion_id)`
++- `notes(position_new_path)`
++- `notes(position_old_path)`
++- `discussions(issue_id)`
++- `discussions(merge_request_id)`
+```
+
+6. **Harden migration 022 with transactional integrity checks**
+Rationale: This is the riskiest part of the plan. Add hard fail-fast checks so corruption cannot silently pass.
+
+```diff
+@@ ### Work Chunk 2A: Schema Migration (022)
++Migration safety requirements:
++- Execute in a single `BEGIN IMMEDIATE ... COMMIT` transaction.
++- Capture and compare pre/post row counts for `documents`, `document_labels`, `document_paths`, `dirty_sources`.
++- Run `PRAGMA foreign_key_check` and abort on any violation.
++- Run `PRAGMA integrity_check` and abort on non-`ok`.
++- Rebuild FTS and assert `documents_fts` rowcount equals `documents` rowcount.
+```
+
+7. **Add note deletion + parent-change propagation**
+Rationale: Current plan handles create/update ingestion but not all staleness paths. Without this, note documents drift.
+
+```diff
+@@ ## Phase 2: Per-Note Documents
++### Work Chunk 2G: Freshness Propagation
++**Files:** `src/ingestion/discussions.rs`, `src/ingestion/mr_discussions.rs`, `src/documents/regenerator.rs`
++
++Rules:
++- If a previously stored note is missing from upstream payload, delete local note row and enqueue `(note, id)` for document deletion.
++- When parent issue/MR title or labels change, enqueue descendant note docs dirty (notes inherit parent metadata).
++- Keep idempotent behavior for repeated syncs.
+```
+
+8. **Separate FTS coverage from embedding coverage**
+Rationale: Biggest cost/perf risk is embeddings. Index all notes in FTS, but embed selectively with policy knobs.
+
+```diff
+@@ ## Estimated Document Volume Impact
+-FTS5 handles this comfortably. Embedding generation time scales linearly (~4x increase).
++FTS5 handles this comfortably. Embedding generation is policy-controlled:
++- FTS: index all non-system note docs
++- Embeddings default: only notes with body length >= 40 chars (configurable)
++- Add config: `documents.note_embeddings.min_chars`, `documents.note_embeddings.enabled`
++- Prioritize unresolved DiffNotes before other notes during embedding backfill
+```
+
+9. **Bring structured reviewer profiling into scope (not narrative reporting)**
+Rationale: This directly serves the stated use case and makes the feature compelling immediately.
+
+```diff
+@@ ## Non-Goals
+-- Adding a "reviewer profile" report command (that's a downstream use case built on this infrastructure)
++- Generating free-form narrative reviewer reports.
++  A structured profiling command is in scope.
++
++## Phase 3: Structured Reviewer Profiling
++Add `lore notes profile --author <user> --since <window>` returning:
++- top commented paths
++- top parent labels
++- unresolved-comment ratio
++- note-type distribution
++- median comment length
+```
+
+10. **Add operational SLOs + robot-mode status for note pipeline**
+Rationale: Reliability improves when regressions are observable, not inferred from failures.
+
+```diff
+@@ ## Verification Checklist
++Operational checks:
++- `lore -J stats` includes per-`source_type` document counts (including `note`)
++- Add queue lag metrics: oldest dirty note age, retry backlog size
++- Add extraction error breakdown by `source_type`
++- Add smoke assertion: disabling `feature.note_documents` leaves other source regeneration unaffected
+```
+
+---
+
+If you want, I can produce a single consolidated revised PRD draft (fully merged text, not just diffs) as the next step.

docs/prd-per-note-search.feedback-2.md

@@ -0,0 +1,200 @@
+Below are the strongest revisions I’d make, excluding everything in your `## Rejected Recommendations` list.
+
+1. **Add a Phase 0 for stable note identity before any note-doc generation**
+Rationale: your current plan still allows note document churn because Issue discussion ingestion is delete/reinsert-based. That makes local `notes.id` unstable, causing unnecessary dirtying/regeneration and potential stale-doc edge cases. Stabilizing identity first (upsert-by-GitLab-ID + sweep stale) improves correctness and cuts repeated work.
+
+```diff
+@@ ## Design
+-Two phases, shipped together as one feature:
++Three phases, shipped together as one feature:
++- **Phase 0 (Foundation):** Stable note identity in local DB (upsert + sweep, no delete/reinsert churn)
+ - **Phase 1 (Option A):** `lore notes` command — direct SQL query over the `notes` table with rich filtering
+ - **Phase 2 (Option B):** Per-note documents — each non-system note becomes its own searchable document in the FTS/embedding pipeline
+@@
++## Phase 0: Stable Note Identity
++
++### Work Chunk 0A: Upsert/Sweep for Issue Discussion Notes
++**Files:** `src/ingestion/discussions.rs`, `migrations/022_notes_identity_index.sql`, `src/core/db.rs`
++**Implementation:**
++- Add unique index: `UNIQUE(project_id, gitlab_id)` on `notes`
++- Replace delete/reinsert issue-note flow with upsert + `last_seen_at` sweep (same durability model as MR note sweep)
++- Ensure `insert_note/upsert_note` returns the stable local row id for both insert and update paths
+```
+
+2. **Replace `source_type` CHECK constraints with a registry table + FK in migration**
+Rationale: table CHECKs force full table rebuild for every new source type forever. A `source_types` table with FK keeps DB-level integrity and future extensibility without rebuilding `documents`/`dirty_sources` every time. This is a major architecture hardening win.
+
+```diff
+@@ ### Work Chunk 2A: Schema Migration (023)
+-Current migration ... CHECK constraints limiting `source_type` ...
++Current migration ... CHECK constraints limiting `source_type` ...
++Revision: migrate to `source_types` registry table + FK constraints.
+@@
+-1. `dirty_sources` — add `'note'` to source_type CHECK
+-2. `documents` — add `'note'` to source_type CHECK
++1. Create `source_types(name TEXT PRIMARY KEY)` and seed: `issue, merge_request, discussion, note`
++2. Rebuild `dirty_sources` and `documents` to replace CHECK with `REFERENCES source_types(name)`
++3. Future source-type additions become `INSERT INTO source_types(name) VALUES (?)` (no table rebuild)
+@@
++#### Additional integrity tests
++#[test]
++fn test_source_types_registry_contains_note() { ... }
++#[test]
++fn test_documents_source_type_fk_enforced() { ... }
++#[test]
++fn test_dirty_sources_source_type_fk_enforced() { ... }
+```
+
+3. **Mark note documents dirty only when note semantics actually changed**
+Rationale: current loops mark every non-system note dirty every sync. With 8k+ notes this creates avoidable queue pressure and regeneration time. Change-aware dirtying (inserted/changed only) gives major performance and stability improvements.
+
+```diff
+@@ ### Work Chunk 2D: Regenerator & Dirty Tracking Integration
+-for note in notes {
+-    let local_note_id = insert_note(&tx, local_discussion_id, &note, None)?;
+-    if !note.is_system {
+-        dirty_tracker::mark_dirty_tx(&tx, SourceType::Note, local_note_id)?;
+-    }
+-}
++for note in notes {
++    let outcome = upsert_note(&tx, local_discussion_id, &note, None)?;
++    if !note.is_system && outcome.changed_semantics {
++        dirty_tracker::mark_dirty_tx(&tx, SourceType::Note, outcome.local_note_id)?;
++    }
++}
+@@
++// changed_semantics should include: body, note_type, path/line positions, resolvable/resolved/resolved_by, updated_at
+```
+
+4. **Expand filters to support real analysis windows and resolution state**
+Rationale: reviewer profiling usually needs bounded windows and both resolved/unresolved views. Current `unresolved: bool` is too narrow and one-sided. Add `--until` and tri-state resolution filtering for better analytical power.
+
+```diff
+@@ pub struct NoteListFilters<'a> {
+-    pub since: Option<&'a str>,
++    pub since: Option<&'a str>,
++    pub until: Option<&'a str>,
+@@
+-    pub unresolved: bool,
++    pub resolution: &'a str, // "any" (default) | "unresolved" | "resolved"
+@@
+-    pub author: Option<&'a str>,
++    pub author: Option<&'a str>, // case-insensitive match
+@@
+-    // Filter by time (7d, 2w, 1m, or YYYY-MM-DD)
++    // Filter by start time (7d, 2w, 1m, or YYYY-MM-DD)
+     pub since: Option<String>,
++    /// Filter by end time (7d, 2w, 1m, or YYYY-MM-DD)
++    #[arg(long, help_heading = "Filters")]
++    pub until: Option<String>,
+@@
+-    /// Only show unresolved review comments
+-    pub unresolved: bool,
++    /// Resolution filter: any, unresolved, resolved
++    #[arg(long, value_parser = ["any", "unresolved", "resolved"], default_value = "any", help_heading = "Filters")]
++    pub resolution: String,
+```
+
+5. **Broaden index strategy to match actual query shapes, not just author queries**
+Rationale: `idx_notes_user_created` helps one path, but common usage also includes project+time scans and unresolved filters. Add two more partial composites for high-selectivity paths.
+
+```diff
+@@ ### Work Chunk 1E: Composite Query Index
+ CREATE INDEX IF NOT EXISTS idx_notes_user_created
+ ON notes(project_id, author_username, created_at DESC, id DESC)
+ WHERE is_system = 0;
++
++CREATE INDEX IF NOT EXISTS idx_notes_project_created
++ON notes(project_id, created_at DESC, id DESC)
++WHERE is_system = 0;
++
++CREATE INDEX IF NOT EXISTS idx_notes_unresolved_project_created
++ON notes(project_id, created_at DESC, id DESC)
++WHERE is_system = 0 AND resolvable = 1 AND resolved = 0;
+@@
++#[test]
++fn test_notes_query_plan_uses_project_created_index_for_default_listing() { ... }
++#[test]
++fn test_notes_query_plan_uses_unresolved_index_when_resolution_unresolved() { ... }
+```
+
+6. **Improve per-note document payload with structured metadata header + minimal thread context**
+Rationale: isolated single-note docs can lose meaning. A small structured header plus lightweight context (parent + one preceding note excerpt) improves semantic retrieval quality substantially without re-bundling full threads.
+
+```diff
+@@ ### Work Chunk 2C: Note Document Extractor
+-// 6. Format content:
+-//    [[Note]] {note_type or "Comment"} on {parent_type_prefix}: {parent_title}
+-//    Project: {path_with_namespace}
+-//    URL: {url}
+-//    Author: @{author}
+-//    Date: {format_date(created_at)}
+-//    Labels: {labels_json}
+-//    File: {position_new_path}:{position_new_line}  (if DiffNote)
+-//
+-//    --- Body ---
+-//
+-//    {body}
++// 6. Format content with machine-readable header:
++//    [[Note]]
++//    source_type: note
++//    note_gitlab_id: {gitlab_id}
++//    project: {path_with_namespace}
++//    parent_type: {Issue|MergeRequest}
++//    parent_iid: {iid}
++//    note_type: {DiffNote|DiscussionNote|Comment}
++//    author: @{author}
++//    created_at: {iso8601}
++//    resolved: {true|false}
++//    path: {position_new_path}:{position_new_line}
++//    url: {url}
++//
++//    --- Context ---
++//    parent_title: {title}
++//    previous_note_excerpt: {optional, max 200 chars}
++//
++//    --- Body ---
++//    {body}
+```
+
+7. **Add first-class export modes for downstream profiling pipelines**
+Rationale: this makes the feature much more useful immediately (LLM prompts, notebook analysis, external scripts) without adding a profiling command. It stays within your non-goals and increases adoption.
+
+```diff
+@@ pub struct NotesArgs {
++    /// Output format
++    #[arg(long, value_parser = ["table", "json", "jsonl", "csv"], default_value = "table", help_heading = "Output")]
++    pub format: String,
+@@
+-    if robot_mode {
++    if robot_mode || args.format == "json" || args.format == "jsonl" || args.format == "csv" {
+         print_list_notes_json(...)
+     } else {
+         print_list_notes(&result);
+     }
+@@ ### Work Chunk 1C: Human & Robot Output Formatting
++Add `print_list_notes_csv()` and `print_list_notes_jsonl()`:
++- CSV columns mirror `NoteListRowJson` field names
++- JSONL emits one note object per line for streaming pipelines
+```
+
+8. **Strengthen verification with idempotence + migration data-preservation checks**
+Rationale: this feature touches ingestion, migrations, indexing, and regeneration. Add explicit idempotence/perf checks so regressions surface early.
+
+```diff
+@@ ## Verification Checklist
+ cargo test
+ cargo clippy --all-targets -- -D warnings
+ cargo fmt --check
++cargo test test_note_ingestion_idempotent_across_two_syncs
++cargo test test_note_document_count_stable_after_second_generate_docs_full
+@@
++lore sync
++lore generate-docs --full
++lore -J stats > /tmp/stats1.json
++lore generate-docs --full
++lore -J stats > /tmp/stats2.json
++# assert note doc count unchanged and dirty queue drains to zero
+```
+
+If you want, I can turn this into a fully rewritten PRD v2 draft with these changes merged in-place and renumbered work chunks end-to-end.

docs/prd-per-note-search.feedback-3.md

@@ -0,0 +1,162 @@
+These are the highest-impact revisions I’d make. They avoid everything in your `## Rejected Recommendations` list.
+
+1. Add immediate note-document deletion propagation (don’t wait for `generate-docs --full`)
+Why: right now, deleted notes can leave stale `source_type='note'` documents until a full rebuild. That creates incorrect search/reporting results and weakens trust in the dataset.
+```diff
+@@ Phase 0: Stable Note Identity
++### Work Chunk 0B: Immediate Deletion Propagation
++
++When sweep deletes stale notes, propagate deletion to documents in the same transaction.
++Do not rely on eventual cleanup via `generate-docs --full`.
++
++#### Tests to Write First
++#[test]
++fn test_issue_note_sweep_deletes_note_documents_immediately() { ... }
++#[test]
++fn test_mr_note_sweep_deletes_note_documents_immediately() { ... }
++
++#### Implementation
++Use `DELETE ... RETURNING id, is_system` in note sweep functions.
++For returned non-system note ids:
++1) `DELETE FROM documents WHERE source_type='note' AND source_id=?`
++2) `DELETE FROM dirty_sources WHERE source_type='note' AND source_id=?`
+```
+
+2. Add one-time upgrade backfill for existing notes (migration 024)
+Why: existing DBs will otherwise only get note-documents for changed/new notes. Historical notes remain invisible unless users manually run full rebuild.
+```diff
+@@ Phase 2: Per-Note Documents
++### Work Chunk 2H: Backfill Existing Notes After Upgrade (Migration 024)
++
++Create migration `024_note_dirty_backfill.sql`:
++INSERT INTO dirty_sources (source_type, source_id, queued_at)
++SELECT 'note', n.id, unixepoch('now') * 1000
++FROM notes n
++LEFT JOIN documents d
++  ON d.source_type='note' AND d.source_id=n.id
++WHERE n.is_system=0 AND d.id IS NULL
++ON CONFLICT(source_type, source_id) DO NOTHING;
++
++Add migration test asserting idempotence and expected queue size.
+```
+
+3. Fix `--since/--until` semantics and validation
+Why: reusing `parse_since` for `until` creates ambiguous windows and off-by-boundary behavior; your own example `--since 90d --until 180d` is chronologically reversed.
+```diff
+@@ Work Chunk 1A: Data Types & Query Layer
+- since: parse_since(since_str) then n.created_at >= ?
+- until: parse_since(until_str) then n.created_at <= ?
++ since: parse_since_start_bound(since_str) then n.created_at >= ?
++ until: parse_until_end_bound(until_str) then n.created_at <= ?
++ Validate since <= until; otherwise return a clear user error.
++
++#### Tests to Write First
++#[test] fn test_query_notes_invalid_time_window_rejected() { ... }
++#[test] fn test_query_notes_until_date_is_end_of_day_inclusive() { ... }
+```
+
+4. Separate semantic-change detection from housekeeping updates
+Why: current proposed `WHERE` includes `updated_at`, which will cause unnecessary dirty churn. You want `last_seen_at` to always refresh, but regeneration only when searchable semantics changed.
+```diff
+@@ Work Chunk 0A: Upsert/Sweep for Issue Discussion Notes
+- OR notes.updated_at IS NOT excluded.updated_at
++ -- updated_at-only changes should not mark semantic dirty
++
++Perform two-step logic:
++1) Upsert always updates persistence/housekeeping fields (`updated_at`, `last_seen_at`).
++2) `changed_semantics` is computed only from fields used by note documents/search filters
++   (body, note_type, resolved flags, paths, author, parent linkage).
++
++#### Tests to Write First
++#[test]
++fn test_issue_note_upsert_updated_at_only_does_not_mark_semantic_change() { ... }
+```
+
+5. Make indexes align with actual query collation and join strategy
+Why: `author` uses `COLLATE NOCASE`; without collation-aware index, SQLite can skip index use. Also, IID filters via scalar subqueries are harder for planner than direct join predicates.
+```diff
+@@ Work Chunk 1E: Composite Query Index
+-CREATE INDEX ... ON notes(project_id, author_username, created_at DESC, id DESC) WHERE is_system = 0;
++CREATE INDEX ... ON notes(project_id, author_username COLLATE NOCASE, created_at DESC, id DESC) WHERE is_system = 0;
++
++CREATE INDEX IF NOT EXISTS idx_discussions_issue_id ON discussions(issue_id);
++CREATE INDEX IF NOT EXISTS idx_discussions_mr_id ON discussions(merge_request_id);
+```
+
+```diff
+@@ Work Chunk 1A: query_notes()
+- d.issue_id = (SELECT id FROM issues WHERE iid = ? AND project_id = ?)
++ i.iid = ? AND i.project_id = ?
+- d.merge_request_id = (SELECT id FROM merge_requests WHERE iid = ? AND project_id = ?)
++ m.iid = ? AND m.project_id = ?
+```
+
+6. Replace manual CSV escaping with `csv` crate
+Why: manual RFC4180 escaping is fragile (quotes/newlines/multi-byte edge cases). This is exactly where a mature library reduces long-term bug risk.
+```diff
+@@ Work Chunk 1C: Human & Robot Output Formatting
+- Uses a minimal CSV writer (no external dependency — the format is simple enough for manual escaping).
++ Uses `csv::Writer` for RFC4180-compliant escaping and stable output across edge cases.
++
++#### Tests to Write First
++#[test] fn test_csv_output_multiline_and_quotes_roundtrip() { ... }
+```
+
+7. Add `--contains` lexical body filter to `lore notes`
+Why: useful middle ground between metadata filtering and semantic search; great for reviewer-pattern mining without requiring FTS query syntax.
+```diff
+@@ Work Chunk 1B: CLI Arguments & Command Wiring
++/// Filter by case-insensitive substring in note body
++#[arg(long, help_heading = "Filters")]
++pub contains: Option<String>;
+```
+
+```diff
+@@ Work Chunk 1A: NoteListFilters
++ pub contains: Option<&'a str>,
+@@ query_notes dynamic filters
++ if contains.is_some() {
++   where_clauses.push("n.body LIKE ? COLLATE NOCASE");
++   params.push(format!("%{}%", escape_like(contains.unwrap())));
++ }
+```
+
+8. Reduce note-document embedding noise by slimming metadata header
+Why: current verbose key-value header repeats low-signal tokens and consumes embedding budget. Keep context, but bias tokens toward actual review text.
+```diff
+@@ Work Chunk 2C: Note Document Extractor
+- Build content with structured metadata header:
+- [[Note]]
+- source_type: note
+- note_gitlab_id: ...
+- project: ...
+- ...
+- --- Body ---
+- {body}
++ Build content with compact, high-signal layout:
++ [[Note]]
++ @{author} on {Issue#|MR!}{iid} in {project_path}
++ path: {path:line}            (only when available)
++ state: {resolved|unresolved} (only when resolvable)
++
++ {body}
++
++Keep detailed metadata in structured document columns/labels/paths/url,
++not repeated in verbose text.
+```
+
+9. Add explicit performance regression checks for the new hot paths
+Why: this feature increases document volume ~4x; you should pin acceptable query behavior now so future changes don’t silently degrade.
+```diff
+@@ Verification Checklist
++Performance/plan checks:
++1) `EXPLAIN QUERY PLAN` for:
++   - author+since query
++   - project+date query
++   - for-mr / for-issue query
++2) Seed 50k-note synthetic fixture and assert:
++   - `lore notes --author ... --limit 100` stays under agreed local threshold
++   - `lore search --type note ...` remains deterministic and completes successfully
+```
+
+If you want, I can also provide a fully merged “iteration 3” PRD text with these edits applied end-to-end so you can drop it in directly.

docs/prd-per-note-search.feedback-4.md

@@ -0,0 +1,187 @@
+1. **Canonical note identity for documents: use `notes.gitlab_id` as `source_id`**
+Why this is better: the current plan still couples document identity to local row IDs. Even with upsert+sweep, local IDs are a storage artifact and can be reused in edge cases. Using GitLab note IDs as canonical document IDs makes regeneration, backfill, and deletion propagation more stable and portable.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ Phase 0: Stable Note Identity
+-Phase 2 depends on `notes.id` as the `source_id` for note documents.
++Phase 2 uses `notes.gitlab_id` as the `source_id` for note documents.
++`notes.id` remains an internal relational key only.
+
+@@ Work Chunk 0A
+ pub struct NoteUpsertOutcome {
+     pub local_note_id: i64,
++    pub document_source_id: i64, // notes.gitlab_id
+     pub changed_semantics: bool,
+ }
+
+@@ Work Chunk 2D
+-if !note.is_system && outcome.changed_semantics {
+-    dirty_tracker::mark_dirty_tx(&tx, SourceType::Note, outcome.local_note_id)?;
++if !note.is_system && outcome.changed_semantics {
++    dirty_tracker::mark_dirty_tx(&tx, SourceType::Note, outcome.document_source_id)?;
+ }
+
+@@ Work Chunk 2E
+-SELECT 'note', n.id, ?1
++SELECT 'note', n.gitlab_id, ?1
+
+@@ Work Chunk 2H
+-ON d.source_type = 'note' AND d.source_id = n.id
++ON d.source_type = 'note' AND d.source_id = n.gitlab_id
+```
+
+2. **Prevent false deletions on partial/incomplete syncs**
+Why this is better: sweep-based deletion is correct only when a discussion’s notes were fully fetched. If a page fails mid-fetch, current logic can incorrectly delete valid notes. Add an explicit “fetch complete” guard before sweep.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ Phase 0
++### Work Chunk 0C: Sweep Safety Guard (Partial Fetch Protection)
++
++Only run stale-note sweep when note pagination completed successfully for that discussion.
++If fetch is partial/interrupted, skip sweep and keep prior notes intact.
+
++#### Tests to Write First
++#[test]
++fn test_partial_fetch_does_not_sweep_notes() { /* ... */ }
++
++#[test]
++fn test_complete_fetch_runs_sweep_notes() { /* ... */ }
+
++#### Implementation
++if discussion_fetch_complete {
++    sweep_stale_issue_notes(...)?;
++} else {
++    tracing::warn!("Skipping stale sweep for discussion {} due to partial fetch", discussion_gitlab_id);
++}
+```
+
+3. **Make deletion propagation set-based (not per-note loop)**
+Why this is better: the current per-note DELETE loop is O(N) statements and gets slow on large threads. A temp-table/CTE set-based delete is faster, simpler to reason about, and remains atomic.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ Work Chunk 0B Implementation
+-    for note_id in stale_note_ids {
+-        conn.execute("DELETE FROM documents WHERE source_type = 'note' AND source_id = ?", [note_id])?;
+-        conn.execute("DELETE FROM dirty_sources WHERE source_type = 'note' AND source_id = ?", [note_id])?;
+-    }
++    CREATE TEMP TABLE _stale_note_source_ids(source_id INTEGER PRIMARY KEY) WITHOUT ROWID;
++    INSERT INTO _stale_note_source_ids
++    SELECT gitlab_id
++    FROM notes
++    WHERE discussion_id = ? AND last_seen_at < ? AND is_system = 0;
++
++    DELETE FROM notes
++    WHERE discussion_id = ? AND last_seen_at < ?;
++
++    DELETE FROM documents
++    WHERE source_type = 'note'
++      AND source_id IN (SELECT source_id FROM _stale_note_source_ids);
++
++    DELETE FROM dirty_sources
++    WHERE source_type = 'note'
++      AND source_id IN (SELECT source_id FROM _stale_note_source_ids);
++
++    DROP TABLE _stale_note_source_ids;
+```
+
+4. **Fix project-scoping and time-window semantics in `lore notes`**
+Why this is better: the plan currently has a contradiction: clap `requires = "project"` blocks use of `defaultProject`, while query layer says default fallback is allowed. Also, `since/until` parsing should use one shared “now” to avoid subtle drift and inverted windows.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ Work Chunk 1B NotesArgs
+-#[arg(long = "for-issue", ..., requires = "project")]
++#[arg(long = "for-issue", ...)]
+ pub for_issue: Option<i64>;
+
+-#[arg(long = "for-mr", ..., requires = "project")]
++#[arg(long = "for-mr", ...)]
+ pub for_mr: Option<i64>;
+
+@@ Work Chunk 1A Query Notes
+-- `since`: `parse_since(since_str)` then `n.created_at >= ?`
+-- `until`: `parse_since(until_str)` then `n.created_at <= ?`
++- Parse `since` and `until` with a single anchored `now_ms` captured once per command.
++- If user supplies `YYYY-MM-DD` for `--until`, interpret as end-of-day (23:59:59.999 UTC).
++- Validate `since <= until` after both parse with same anchor.
+```
+
+5. **Add an analytics mode (not a profile command): `lore notes --aggregate`**
+Why this is better: this directly supports the stated use case (review patterns) without introducing the rejected “profile report” command. It keeps scope narrow and reuses existing filters.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ Phase 1
++### Work Chunk 1F: Aggregation Mode for Notes Listing
++
++Add optional aggregation on top of `lore notes`:
++- `--aggregate author|note_type|path|resolution`
++- `--top N` (default 20)
++
++Behavior:
++- Reuses all existing filters (`--since`, `--project`, `--for-mr`, etc.)
++- Returns grouped counts (+ percentage of filtered corpus)
++- Works in table/json/jsonl/csv
++
++Non-goal alignment:
++- This is not a narrative “reviewer profile” command.
++- It is a query primitive for downstream analysis.
+```
+
+6. **Prevent note backfill from starving other document regeneration**
+Why this is better: after migration/backfill, note dirty entries can dominate the queue and delay issue/MR/discussion updates. Add source-type fairness in regenerator scheduling.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ Work Chunk 2D
++#### Scheduling Revision
++Process dirty sources with weighted fairness instead of strict FIFO:
++- issue: 3
++- merge_request: 3
++- discussion: 2
++- note: 1
++
++Implementation sketch:
++- fetch next batch by source_type buckets
++- interleave according to weights
++- preserve retry semantics per source
+
++#### Tests to Write First
++#[test]
++fn test_note_backfill_does_not_starve_issue_and_mr_regeneration() { /* ... */ }
+```
+
+7. **Harden migration 023: remove invalid SQL assertions and move integrity checks to tests**
+Why this is better: `RAISE(ABORT, ...)` in standalone `SELECT` is not valid SQLite usage outside triggers/check expressions. Keep migration SQL minimal/portable and enforce invariants in migration tests.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ Work Chunk 2A Migration SQL
+--- Step 10: Integrity verification
+-SELECT CASE
+-    WHEN ... THEN RAISE(ABORT, '...')
+-END;
++-- Step 10 removed from SQL migration.
++-- Integrity verification is enforced in migration tests:
++-- 1) pre/post row-count equality
++-- 2) `PRAGMA foreign_key_check` is empty
++-- 3) documents_fts row count matches documents row count after rebuild
+
+@@ Work Chunk 2A Tests
++#[test]
++fn test_migration_023_integrity_checks_pass() {
++    // pre/post counts, foreign_key_check empty, fts parity
++}
+```
+
+These 7 revisions improve correctness under failure, reduce churn risk, improve large-sync performance, and make the feature materially more useful for reviewer-analysis workflows without reintroducing any rejected recommendations.

docs/prd-per-note-search.feedback-5.md

@@ -0,0 +1,190 @@
+Here are the highest-impact revisions I’d make. None of these repeat anything in your `## Rejected Recommendations`.
+
+1. **Add immutable reviewer identity (`author_id`) as a first-class key**
+Why this improves the plan: the PRD’s core use case is year-scale reviewer profiling. Usernames are mutable in GitLab, so username-only filtering will fragment one reviewer into multiple identities over time. Adding `author_id` closes that correctness hole and makes historical analysis reliable.
+
+```diff
+@@ Problem Statement
+-1. **Query individual notes by author** — the `--author` filter on `lore search` only matches the first note's author per discussion thread
++1. **Query individual notes by reviewer identity** — support both mutable username and immutable GitLab `author_id` for stable longitudinal analysis
+
+@@ Phase 0: Stable Note Identity
++### Work Chunk 0D: Immutable Author Identity Capture
++**Files:** `migrations/025_notes_author_id.sql`, `src/ingestion/discussions.rs`, `src/ingestion/mr_discussions.rs`, `src/cli/commands/list.rs`
++
++#### Implementation
++- Add nullable `notes.author_id INTEGER` and backfill from future syncs.
++- Populate `author_id` from GitLab note payload (`note.author.id`) on both issue and MR note ingestion paths.
++- Add `--author-id <int>` filter to `lore notes`.
++- Keep `--author` for ergonomics; when both provided, require both to match.
++
++#### Indexing
++- Add `idx_notes_author_id_created ON notes(project_id, author_id, created_at DESC, id DESC) WHERE is_system = 0;`
++
++#### Tests
++- `test_query_notes_filter_author_id_survives_username_change`
++- `test_query_notes_author_and_author_id_intersection`
+```
+
+2. **Strengthen partial-fetch safety from a boolean to an explicit fetch state contract**
+Why this improves the plan: `fetch_complete: bool` is easy to misuse and fragile under retries/crashes. A run-scoped state model makes sweep correctness auditable and prevents accidental deletions when ingestion aborts midway.
+
+```diff
+@@ Phase 0: Stable Note Identity
+-### Work Chunk 0C: Sweep Safety Guard (Partial Fetch Protection)
++### Work Chunk 0C: Sweep Safety Guard with Run-Scoped Fetch State
+
+@@ Implementation
+-Add a `fetch_complete` parameter to the discussion ingestion functions. Only run the stale-note sweep when the fetch completed successfully:
++Add a run-scoped fetch state:
++- `FetchState::Complete`
++- `FetchState::Partial`
++- `FetchState::Failed`
++
++Only run sweep on `FetchState::Complete`.
++Persist `run_seen_at` once per sync run and pass unchanged through all discussion/note upserts.
++Require `run_seen_at` monotonicity per discussion before sweep (skip and warn otherwise).
+
+@@ Tests to Write First
++#[test]
++fn test_failed_fetch_never_sweeps_even_after_partial_upserts() { ... }
++#[test]
++fn test_non_monotonic_run_seen_at_skips_sweep() { ... }
++#[test]
++fn test_retry_after_failed_fetch_then_complete_sweeps_correctly() { ... }
+```
+
+3. **Add DB-level cleanup triggers for note-document referential integrity**
+Why this improves the plan: Work Chunk 0B handles the sweep path, but not every possible delete path. DB triggers give defense-in-depth so stale note docs cannot survive even if a future code path deletes notes differently.
+
+```diff
+@@ Work Chunk 0B: Immediate Deletion Propagation
+-Update both sweep functions to propagate deletion to documents and dirty_sources using set-based SQL
++Keep set-based SQL in sweep functions, and add DB-level cleanup triggers as a safety net.
+
+@@ Work Chunk 2A: Schema Migration (023)
++-- Cleanup trigger: deleting a non-system note must delete note document + dirty queue row
++CREATE TRIGGER notes_ad_cleanup AFTER DELETE ON notes
++WHEN old.is_system = 0
++BEGIN
++  DELETE FROM documents
++   WHERE source_type = 'note' AND source_id = old.id;
++  DELETE FROM dirty_sources
++   WHERE source_type = 'note' AND source_id = old.id;
++END;
++
++-- Cleanup trigger: if note flips to system, remove its document artifacts
++CREATE TRIGGER notes_au_system_cleanup AFTER UPDATE OF is_system ON notes
++WHEN old.is_system = 0 AND new.is_system = 1
++BEGIN
++  DELETE FROM documents
++   WHERE source_type = 'note' AND source_id = new.id;
++  DELETE FROM dirty_sources
++   WHERE source_type = 'note' AND source_id = new.id;
++END;
+```
+
+4. **Eliminate N+1 extraction cost with parent metadata caching in regeneration**
+Why this improves the plan: backfilling ~8k notes with per-note parent/label lookups creates avoidable query amplification. Batch caching turns repeated joins into one-time lookups per parent entity and materially reduces rebuild time.
+
+```diff
+@@ Phase 2: Per-Note Documents
++### Work Chunk 2I: Batch Parent Metadata Cache for Note Regeneration
++**Files:** `src/documents/regenerator.rs`, `src/documents/extractor.rs`
++
++#### Implementation
++- Add `NoteExtractionContext` cache keyed by `(noteable_type, parent_id)` containing:
++  - parent iid/title/url
++  - parent labels
++  - project path
++- In batch regeneration, prefetch parent metadata for note IDs in the current chunk.
++- Use cached metadata in `extract_note_document()` to avoid repeated parent/label queries.
++
++#### Tests
++- `test_note_regeneration_uses_parent_cache_consistently`
++- `test_note_regeneration_cache_hit_preserves_hash_determinism`
+```
+
+5. **Add embedding dedup cache keyed by semantic text hash**
+Why this improves the plan: note docs will contain repeated short comments (“LGTM”, “nit: …”). Current doc-level hashing includes metadata, so identical semantic comments still re-embed many times. A semantic embedding hash cache cuts cost and speeds full rebuild/backfill without changing search behavior.
+
+```diff
+@@ Phase 2: Per-Note Documents
++### Work Chunk 2J: Semantic Embedding Dedup for Notes
++**Files:** `migrations/026_embedding_cache.sql`, embedding pipeline module(s), `src/documents/extractor.rs`
++
++#### Implementation
++- Compute `embedding_text` for notes as: normalized note body + compact stable context (`parent_type`, `path`, `resolution`), excluding volatile fields.
++- Compute `embedding_hash = sha256(embedding_text)`.
++- Before embedding generation, lookup existing vector by `(model, embedding_hash)`.
++- Reuse cached vector when present; only call embedding model on misses.
++
++#### Tests
++- `test_identical_note_bodies_reuse_embedding_vector`
++- `test_embedding_hash_changes_when_semantic_context_changes`
+```
+
+6. **Add deterministic review-signal tags as derived labels**
+Why this improves the plan: this makes output immediately more useful for reviewer-pattern analysis without adding a profile command (which is explicitly out of scope). It increases practical value of both `lore notes` and `lore search --type note` with low complexity.
+
+```diff
+@@ Non-Goals
+-- Adding a "reviewer profile" report command (that's a downstream use case built on this infrastructure)
++- Adding a "reviewer profile" report command (downstream), while allowing low-level derived signal tags as indexing primitives
+
+@@ Phase 2: Per-Note Documents
++### Work Chunk 2K: Derived Review Signal Labels
++**Files:** `src/documents/extractor.rs`
++
++#### Implementation
++- Derive deterministic labels from note text + metadata:
++  - `signal:nit`
++  - `signal:blocking`
++  - `signal:security`
++  - `signal:performance`
++  - `signal:testing`
++- Attach via existing `document_labels` flow for note documents.
++- No new CLI mode required; existing label filters can consume these labels.
++
++#### Tests
++- `test_note_document_derives_signal_labels_nit`
++- `test_note_document_derives_signal_labels_security`
++- `test_signal_label_derivation_is_deterministic`
+```
+
+7. **Add high-precision note targeting filters (`--note-id`, `--gitlab-note-id`, `--discussion-id`)**
+Why this improves the plan: debugging, incident response, and reproducibility all benefit from exact addressing. This is especially useful when validating sync correctness and cross-checking a specific note/document lifecycle.
+
+```diff
+@@ Work Chunk 1B: CLI Arguments & Command Wiring
+ pub struct NotesArgs {
++    /// Filter by local note row id
++    #[arg(long = "note-id", help_heading = "Filters")]
++    pub note_id: Option<i64>,
++
++    /// Filter by GitLab note id
++    #[arg(long = "gitlab-note-id", help_heading = "Filters")]
++    pub gitlab_note_id: Option<i64>,
++
++    /// Filter by local discussion id
++    #[arg(long = "discussion-id", help_heading = "Filters")]
++    pub discussion_id: Option<i64>,
+ }
+
+@@ Work Chunk 1A: Filter struct
+ pub struct NoteListFilters<'a> {
++    pub note_id: Option<i64>,
++    pub gitlab_note_id: Option<i64>,
++    pub discussion_id: Option<i64>,
+ }
+
+@@ Tests to Write First
++#[test]
++fn test_query_notes_filter_note_id_exact() { ... }
++#[test]
++fn test_query_notes_filter_gitlab_note_id_exact() { ... }
++#[test]
++fn test_query_notes_filter_discussion_id_exact() { ... }
+```
+
+If you want, I can produce a single consolidated “iteration 5” PRD diff that merges these into your exact section ordering and updates the dependency graph/migration numbering end-to-end.

docs/prd-per-note-search.feedback-6.md

@@ -0,0 +1,131 @@
+1. **Make immutable identity usable now (`--author-id`)**
+Why: The plan captures `author_id` but intentionally defers using it, so the core longitudinal-analysis problem is only half-fixed.
+
+```diff
+@@ Phase 1: `lore notes` Command / Work Chunk 1A
+ pub struct NoteListFilters<'a> {
++    pub author_id: Option<i64>,         // immutable identity filter
+@@
+-    pub author: Option<&'a str>,          // case-insensitive match via COLLATE NOCASE
++    pub author: Option<&'a str>,          // display-name filter
++    // If both author and author_id are provided, apply both (AND) for precision.
+ }
+@@
+ Filter mappings:
++ - `author_id`: `n.author_id = ?` (exact immutable identity)
+  - `author`: strip `@` prefix, `n.author_username = ? COLLATE NOCASE`
+@@ Phase 1 / Work Chunk 1B (CLI)
++ /// Filter by immutable author id
++ #[arg(long = "author-id", help_heading = "Filters")]
++ pub author_id: Option<i64>,
+@@ Phase 2 / Work Chunk 2F
++ Add `--author-id` support to `lore search` filtering for note documents.
+@@ Phase 1 / Work Chunk 1E
++ CREATE INDEX IF NOT EXISTS idx_notes_project_author_id_created
++ ON notes(project_id, author_id, created_at DESC, id DESC)
++ WHERE is_system = 0 AND author_id IS NOT NULL;
+```
+
+2. **Fix document staleness on username changes**
+Why: Current plan says username changes are “not semantic,” but note documents include username in content/title, so docs go stale/inconsistent.
+
+```diff
+@@ Work Chunk 0D: Immutable Author Identity Capture
+- Assert: changed_semantics = false (username change is not a semantic change for documents)
++ Assert: changed_semantics = true (username affects note document content/title)
+@@ Work Chunk 0A: semantic-change detection
+- old_body != body || old_note_type != note_type || ...
++ old_body != body || old_note_type != note_type || ...
++ || old_author_username != author_username
+@@ Work Chunk 2C: Note Document Extractor header
+     author: @{author}
++    author_id: {author_id}
+```
+
+3. **Replace `last_seen_at` sweep marker with monotonic `sync_run_id`**
+Why: Timestamp markers are vulnerable to clock skew and concurrent runs; run IDs are deterministic and safer.
+
+```diff
+@@ Phase 0: Stable Note Identity
++ ### Work Chunk 0E: Monotonic Run Marker
++ Add `sync_runs` table and `notes.last_seen_run_id`.
++ Ingest assigns one run_id per sync transaction.
++ Upsert sets `last_seen_run_id = current_run_id`.
++ Sweep condition becomes `last_seen_run_id < current_run_id` (when fetch_complete=true).
+@@ Work Chunk 0C
+- fetch_complete + last_seen_at-based sweep
++ fetch_complete + run_id-based sweep
+```
+
+4. **Materialize stale-note set once during sweep**
+Why: Current set-based SQL still re-runs the stale subquery 3 times; materializing once improves performance and guarantees identical deletion set.
+
+```diff
+@@ Work Chunk 0B: Immediate Deletion Propagation
+- DELETE FROM documents ... IN (SELECT id FROM notes WHERE ...);
+- DELETE FROM dirty_sources ... IN (SELECT id FROM notes WHERE ...);
+- DELETE FROM notes WHERE ...;
++ CREATE TEMP TABLE _stale_note_ids AS
++ SELECT id, is_system FROM notes WHERE discussion_id = ? AND last_seen_run_id < ?;
++ DELETE FROM documents
++  WHERE source_type='note' AND source_id IN (SELECT id FROM _stale_note_ids WHERE is_system=0);
++ DELETE FROM dirty_sources
++  WHERE source_type='note' AND source_id IN (SELECT id FROM _stale_note_ids WHERE is_system=0);
++ DELETE FROM notes WHERE id IN (SELECT id FROM _stale_note_ids);
++ DROP TABLE _stale_note_ids;
+```
+
+5. **Move historical note backfill out of migration into resumable runtime job**
+Why: Data-heavy migration can block startup and is harder to resume/recover on large DBs.
+
+```diff
+@@ Work Chunk 2H
+- Backfill Existing Notes After Upgrade (Migration 024)
++ Backfill Existing Notes After Upgrade (Resumable Runtime Backfill)
+@@
+- Files: `migrations/024_note_dirty_backfill.sql`, `src/core/db.rs`
++ Files: `src/documents/backfill.rs`, `src/cli/commands/generate_docs.rs`
+@@
+- INSERT INTO dirty_sources ... SELECT ... FROM notes ...
++ Introduce batched backfill API:
++ `enqueue_missing_note_documents(batch_size: usize) -> BackfillProgress`
++ invoked from `generate-docs`/`sync` until complete, resumable across runs.
+```
+
+6. **Add streaming path for large `jsonl`/`csv` note exports**
+Why: Current `query_notes` materializes full result set in memory; streaming improves scalability and latency.
+
+```diff
+@@ Work Chunk 1A
++ Add `query_notes_stream(conn, filters, row_handler)` for forward-only row iteration.
+@@ Work Chunk 1C
+- print_list_notes_jsonl(&result)
+- print_list_notes_csv(&result)
++ print_list_notes_jsonl_stream(config, filters)
++ print_list_notes_csv_stream(config, filters)
++ (table/json keep counted buffered path)
+```
+
+7. **Add index for path-centric note queries**
+Why: `--path` + project/date queries are a stated hot path and not fully covered by current proposed indexes.
+
+```diff
+@@ Work Chunk 1E: Composite Query Index
++ CREATE INDEX IF NOT EXISTS idx_notes_project_path_created
++ ON notes(project_id, position_new_path, created_at DESC, id DESC)
++ WHERE is_system = 0 AND position_new_path IS NOT NULL;
+```
+
+8. **Add property/invariant tests (not only examples)**
+Why: This feature touches ingestion identity, sweeping, deletion propagation, and document regeneration; randomized invariants will catch subtle regressions.
+
+```diff
+@@ Verification Checklist
++ Add property tests (proptest):
++ - stable local IDs across randomized re-sync orderings
++ - no orphan `documents(source_type='note')` after randomized deletions/sweeps
++ - partial-fetch runs never reduce note count
++ - repeated full rebuild converges (fixed-point idempotence)
+```
+
+These revisions keep your existing direction, avoid all rejected items, and materially improve correctness, scale behavior, and long-term maintainability.

docs/robot-mode-design.md

@@ -125,7 +125,7 @@ lore -J mrs --fields iid,title,state,draft,target_branch
 
 ### Available Fields
 
-**Issues**: `iid`, `title`, `state`, `author_username`, `labels`, `assignees`, `discussion_count`, `unresolved_count`, `created_at_iso`, `updated_at_iso`, `web_url`, `project_path`
+**Issues**: `iid`, `title`, `state`, `author_username`, `labels`, `assignees`, `discussion_count`, `unresolved_count`, `created_at_iso`, `updated_at_iso`, `web_url`, `project_path`, `status_name`, `status_category`, `status_color`, `status_icon_name`, `status_synced_at_iso`
 
 **MRs**: `iid`, `title`, `state`, `author_username`, `labels`, `draft`, `target_branch`, `source_branch`, `discussion_count`, `unresolved_count`, `created_at_iso`, `updated_at_iso`, `web_url`, `project_path`, `reviewers`
 

docs/user-journeys.md

@@ -0,0 +1,541 @@
+# Lore CLI User Journeys
+
+## Purpose
+
+Map realistic workflows for both human users and AI agents to identify gaps in the command surface and optimization opportunities. Each journey starts with a **problem** and traces the commands needed to reach a **resolution**.
+
+---
+
+## Part 1: Human User Flows
+
+### H1. Morning Standup Prep
+
+**Problem:** "What happened since yesterday? I need to know what moved before standup."
+
+**Flow:**
+```
+lore sync -q                              # Refresh data (quiet, no noise)
+lore issues -s opened --since 1d          # Issues that changed overnight
+lore mrs -s opened --since 1d             # MRs that moved
+lore who @me                              # My current workload snapshot
+```
+
+**Gap identified:** No single "activity feed" command. User runs 3 queries to get what should be one view. No `--since 1d` shorthand for "since yesterday." No `@me` alias for the authenticated user.
+
+---
+
+### H2. Sprint Planning: What's Ready to Pick Up?
+
+**Problem:** "We're planning the next sprint. What's open, unassigned, and actionable?"
+
+**Flow:**
+```
+lore issues -s opened -p myproject        # All open issues
+lore issues -s opened -l "ready"          # Issues labeled ready
+lore issues -s opened --has-due           # Issues with deadlines approaching
+lore count issues -p myproject            # How many total?
+```
+
+**Gap identified:** No way to filter by "unassigned" issues (missing `--no-assignee` flag). No way to sort by due date. No way to see priority/weight. Can't combine filters like "opened AND no assignee AND has due date."
+
+---
+
+### H3. Investigating a Production Incident
+
+**Problem:** "Deploy broke prod. I need the full timeline of what changed around the deploy."
+
+**Flow:**
+```
+lore sync -q                              # Get latest
+lore timeline "deploy" --since 7d         # What happened around deploys
+lore search "deploy" --type mr            # MRs mentioning deploy
+lore mrs 456                              # Inspect the suspicious MR
+lore who --overlap src/deploy/            # Who else touches deploy code
+```
+
+**Gap identified:** Timeline is keyword-based, not event-based. Can't filter by "MRs merged in the last 24 hours" directly. No way to see which MRs were merged between two dates (release diff). Would benefit from `lore mrs -s merged --since 1d`.
+
+---
+
+### H4. Preparing to Review Someone's MR
+
+**Problem:** "I was assigned to review MR !789. I need context before diving in."
+
+**Flow:**
+```
+lore mrs 789                              # Read the MR description + discussions
+lore mrs 789 -o                           # Open in browser for the actual diff
+lore who src/features/auth/               # Who are the experts in this area?
+lore search "auth refactor" --type issue  # Related issues for background
+lore timeline "authentication"            # History of auth changes
+```
+
+**Gap identified:** No way to see the file list touched by an MR from the CLI (data is stored in `mr_file_changes` but not surfaced). No way to link an MR back to its closing issue(s) from the MR detail view. The cross-reference data exists in `entity_references` but isn't shown in `mrs <iid>` output.
+
+---
+
+### H5. Onboarding to an Unfamiliar Code Area
+
+**Problem:** "I'm new to the team and need to understand how the billing module works."
+
+**Flow:**
+```
+lore search "billing" -n 20               # What exists about billing?
+lore who src/billing/                      # Who knows billing best?
+lore timeline "billing" --depth 2         # History of billing changes
+lore mrs -s merged -l billing --since 6m  # Recent merged billing work
+lore issues -s opened -l billing          # Outstanding billing issues
+```
+
+**Gap identified:** No way to get a "module overview" in one command. The search spans issues, MRs, and discussions but doesn't summarize by category. No way to see the most-discussed or most-referenced entities (high-signal items for understanding).
+
+---
+
+### H6. Finding the Right Reviewer for My PR
+
+**Problem:** "I'm about to submit a PR touching auth and payments. Who should review?"
+
+**Flow:**
+```
+lore who src/features/auth/               # Auth experts
+lore who src/features/payments/           # Payment experts
+lore who @candidate1                      # Check candidate1's workload
+lore who @candidate2                      # Check candidate2's workload
+```
+
+**Gap identified:** No way to query multiple paths at once (`lore who src/auth/ src/payments/`). No way to find the intersection of expertise. No workload-aware recommendation ("who knows this AND has bandwidth"). Four separate commands for what should be one decision.
+
+---
+
+### H7. Understanding Why a Feature Was Built This Way
+
+**Problem:** "This code is weird. Why was it implemented like this? What was the original discussion?"
+
+**Flow:**
+```
+lore search "feature-name rationale"      # Search for decision context
+lore timeline "feature-name" --depth 2    # Full history with cross-refs
+lore issues 234                           # Read the original issue
+lore mrs 567                              # Read the implementation MR
+```
+
+**Gap identified:** No way to search within a specific issue's or MR's discussion notes. The search covers documents (titles + descriptions) but per-note search isn't available yet (PRD exists). No way to navigate "issue 234 was closed by MR 567" without manually knowing both IDs.
+
+---
+
+### H8. Checking Team Workload Before Assigning Work
+
+**Problem:** "I need to assign this urgent bug. Who has the least on their plate?"
+
+**Flow:**
+```
+lore who @alice                           # Alice's workload
+lore who @bob                             # Bob's workload
+lore who @carol                           # Carol's workload
+lore who @dave                            # Dave's workload
+```
+
+**Gap identified:** No team-level workload view. Must query each person individually. No way to list "all assignees and their open issue counts." No concept of a team roster. Would benefit from `lore who --team` or `lore workload`.
+
+---
+
+### H9. Preparing Release Notes
+
+**Problem:** "We're cutting a release. I need to summarize what's in this version."
+
+**Flow:**
+```
+lore mrs -s merged --since 2w -p myproject   # MRs merged since last release
+lore issues -s closed --since 2w -p myproject # Issues closed since last release
+lore mrs -s merged -l feature --since 2w      # Feature MRs specifically
+lore mrs -s merged -l bugfix --since 2w       # Bugfix MRs
+```
+
+**Gap identified:** No way to filter by milestone (for version-based releases). Wait -- `issues` has `-m` for milestone but `mrs` does not. No changelog generation. No "what closed between tag A and tag B." No grouping by label for release note categories.
+
+---
+
+### H10. Finding and Closing Stale Issues
+
+**Problem:** "Our backlog is bloated. Which issues haven't been touched in months?"
+
+**Flow:**
+```
+lore issues -s opened --sort updated --asc -n 50  # Oldest-updated first
+# Then manually inspect each one...
+lore issues 42                                      # Is this still relevant?
+```
+
+**Gap identified:** No `--before` or `--updated-before` filter (only `--since` exists). Can sort ascending but can't filter "not updated in 90 days." No staleness indicator. No bulk operations concept.
+
+---
+
+### H11. Understanding a Bug's Full History
+
+**Problem:** "Bug #321 keeps getting reopened. I need to understand its entire lifecycle."
+
+**Flow:**
+```
+lore issues 321                           # Read the issue
+lore timeline "bug-keyword" -p myproject  # Try to find timeline events
+# But timeline is keyword-based, not entity-based...
+```
+
+**Gap identified:** No way to get a timeline for a specific entity by IID. `lore timeline` requires a keyword query, not an entity reference. Would benefit from `lore timeline --issue 321` or `lore timeline --mr 456` to get the event history of a specific entity directly.
+
+---
+
+### H12. Identifying Who to Ask About Failing Tests
+
+**Problem:** "CI tests are failing in `src/lib/parser.rs`. Who last touched this?"
+
+**Flow:**
+```
+lore who src/lib/parser.rs                # Expert lookup
+lore who --overlap src/lib/parser.rs      # Who else has touched it
+lore search "parser" --type mr --since 2w # Recent MRs touching parser
+```
+
+**Gap identified:** Expert mode uses DiffNote analysis (code review comments), not actual file change tracking. The `mr_file_changes` table has the real data but `who` doesn't use it for attribution. Could be much more accurate with file-change-based expertise.
+
+---
+
+### H13. Tracking a Feature Across Multiple MRs
+
+**Problem:** "The 'dark mode' feature spans 5 MRs. I need to see them all together."
+
+**Flow:**
+```
+lore mrs -l dark-mode                     # MRs with the label
+lore issues -l dark-mode                  # Related issues
+lore timeline "dark mode" --depth 2       # Cross-referenced events
+```
+
+**Gap identified:** Works reasonably well with labels as the grouping mechanism. But if the team didn't label consistently, there's no way to discover related MRs by content similarity. No "related items" view that combines issues + MRs + discussions for a topic.
+
+---
+
+### H14. Checking if a Similar Fix Was Already Attempted
+
+**Problem:** "Before I implement this fix, was something similar tried before?"
+
+**Flow:**
+```
+lore search "memory leak connection pool" # Semantic search
+lore search "connection pool" --type mr -s all  # Wait, no state filter on search
+lore mrs -s closed -l bugfix              # Closed bugfix MRs (coarse)
+lore timeline "connection pool"           # Historical context
+```
+
+**Gap identified:** Search doesn't have a `--state` filter. Can't search only closed/merged items. The semantic search is powerful but can't be combined with entity state. Would benefit from `--state merged` on search to find past attempts.
+
+---
+
+### H15. Reviewing Discussions That Need My Attention
+
+**Problem:** "Which discussion threads am I involved in that are still unresolved?"
+
+**Flow:**
+```
+lore who --active                         # All active unresolved discussions
+lore who --active --since 30d             # Wider window
+# But can't filter to "discussions I'm in"...
+```
+
+**Gap identified:** `--active` shows all unresolved discussions, not filtered by participant. No way to say "show me discussions where @me participated." No notification/mention tracking. No "my unresolved threads" view.
+
+---
+
+## Part 2: AI Agent Flows
+
+### A1. Context Gathering Before Code Modification
+
+**Problem:** Agent is about to modify `src/features/auth/session.rs` and needs full context.
+
+**Flow:**
+```
+lore -J health                            # Pre-flight check
+lore -J who src/features/auth/            # Who knows this area
+lore -J search "auth session" -n 10       # Related issues/MRs
+lore -J mrs -s merged --since 3m -l auth  # Recent auth changes
+lore -J who --overlap src/features/auth/session.rs  # Concurrent work risk
+```
+
+**Gap identified:** No way to check "are there open MRs touching this file right now?" The overlap mode shows historical touches, not active branches. An agent needs to know about in-flight changes to avoid conflicts.
+
+---
+
+### A2. Auto-Triaging an Incoming Issue
+
+**Problem:** Agent receives a new issue and needs to categorize it, find related work, and suggest assignees.
+
+**Flow:**
+```
+lore -J issues 999                        # Read the new issue
+lore -J search "$(extract_keywords)" --explain  # Find similar past issues
+lore -J who src/affected/path/            # Suggest experts as assignees
+lore -J issues -s opened -l same-label    # Check for duplicates
+```
+
+**Gap identified:** No way to get just the description text for programmatic keyword extraction. `issues <iid>` returns full detail including discussions. Agent must parse the full response to extract the description for a secondary search. Would benefit from `--fields description` on detail view. No duplicate detection built in.
+
+---
+
+### A3. Generating Sprint Status Report
+
+**Problem:** Agent needs to produce a weekly status report for the team.
+
+**Flow:**
+```
+lore -J issues -s closed --since 1w --fields minimal  # Completed work
+lore -J issues -s opened --status "In progress"        # In-flight work
+lore -J mrs -s merged --since 1w --fields minimal      # Merged PRs
+lore -J mrs -s opened -D --fields minimal              # Open non-draft MRs
+lore -J count issues                                    # Totals
+lore -J count mrs                                       # MR totals
+lore -J who --active --since 1w                         # Discussions needing attention
+```
+
+**Gap identified:** Seven separate queries for one report. No `lore summary` or `lore report` command. No way to get "issues transitioned from X to Y this week" (state change history exists in events but isn't queryable). No velocity metric (issues closed per week trend).
+
+---
+
+### A4. Finding Relevant Prior Art Before Implementing
+
+**Problem:** Agent is implementing a caching layer and wants to find if similar patterns exist in the codebase's GitLab history.
+
+**Flow:**
+```
+lore -J search "caching" --mode hybrid -n 20 --explain
+lore -J search "cache invalidation" --mode hybrid -n 10
+lore -J search "redis" --mode lexical --type discussion   # Exact term in discussions
+lore -J timeline "cache" --since 1y                        # Wait, max is 1y? Let's try 12m
+```
+
+**Gap identified:** No way to search discussion notes individually (per-note search). Discussions are aggregated into documents, so individual note-level matches are lost. The `--explain` flag helps but doesn't show which specific note matched. No `--since 1y` or `--since 12m` duration format.
+
+---
+
+### A5. Building Context for PR Description
+
+**Problem:** Agent wrote code and needs to generate a PR description that references relevant issues.
+
+**Flow:**
+```
+lore -J search "feature description keywords" --type issue
+lore -J issues -s opened -l feature-label --fields iid,title,web_url
+# Cross-reference: which issues does this MR close?
+# No command for this -- must manually scan search results
+```
+
+**Gap identified:** No way to query the `entity_references` table directly. Agent can't ask "which issues reference MR !456" or "which issues contain 'closes #123' in their text." The data exists but isn't exposed as a query surface. Would benefit from `lore refs --mr 456` or `lore refs --issue 123`.
+
+---
+
+### A6. Identifying Affected Experts for Review Assignment
+
+**Problem:** Agent needs to automatically assign reviewers based on the files changed in an MR.
+
+**Flow:**
+```
+lore -J mrs 456                           # Get MR details
+# Parse file paths from response... but file changes aren't in the output
+lore -J who src/path/from/mr/             # Query each path
+lore -J who src/another/path/             # One at a time...
+lore -J who @candidate --fields minimal   # Check workload
+```
+
+**Gap identified:** MR detail view (`mrs <iid>`) doesn't include the file change list from `mr_file_changes`. Agent can't programmatically extract which files an MR touches. Must fall back to GitLab API or guess from description. The `who` command doesn't accept multiple paths. No "auto-reviewer" suggestion combining expertise + availability.
+
+---
+
+### A7. Incident Investigation and Timeline Reconstruction
+
+**Problem:** Agent needs to reconstruct what happened during an outage for a postmortem.
+
+**Flow:**
+```
+lore -J timeline "outage" --since 3d --depth 2 --expand-mentions
+lore -J search "error 500" --since 3d
+lore -J mrs -s merged --since 3d -p production-service
+lore -J issues --status "In progress" -p production-service
+```
+
+**Gap identified:** Timeline is keyword-seeded, which means if the outage wasn't described with that exact term, seeds may miss it. No way to seed a timeline from an entity ID (e.g., "start from issue #321 and expand outward"). No severity/priority filter. No way to correlate with merge times.
+
+---
+
+### A8. Cross-Project Impact Assessment
+
+**Problem:** Agent needs to understand how a breaking API change in project A affects projects B and C.
+
+**Flow:**
+```
+lore -J search "api-endpoint-name" -p project-a
+lore -J search "api-endpoint-name" -p project-b
+lore -J search "api-endpoint-name" -p project-c
+# Or without project filter to search everywhere:
+lore -J search "api-endpoint-name" -n 50
+lore -J timeline "api-endpoint-name" --depth 2
+```
+
+**Gap identified:** Cross-project references in entity_references are tracked but the timeline shows unresolved references for entities not synced locally. No way to see a cross-project dependency map. Search works across projects but doesn't group results by project.
+
+---
+
+### A9. Automated Stale Issue Recommendations
+
+**Problem:** Agent runs weekly to identify issues that should be closed or re-prioritized.
+
+**Flow:**
+```
+lore -J issues -s opened --sort updated --asc -n 100  # Oldest first
+# For each issue, check:
+lore -J issues <iid>                                    # Read details
+lore -J search "<issue title keywords>"                 # Any recent activity?
+```
+
+**Gap identified:** No `--updated-before` filter, so agent must fetch all and filter client-side. No way to detect "issue has no assignee AND no activity in 90 days." The 100-issue limit means pagination is needed for large backlogs, but there's no cursor/offset pagination -- only `--limit`. Agent must do N+1 queries to inspect each candidate.
+
+---
+
+### A10. Code Review Preparation (File-Level Context)
+
+**Problem:** Agent is reviewing MR !789 and needs to understand the history of each changed file.
+
+**Flow:**
+```
+lore -J mrs 789                           # Get MR details
+# Can't get file list from output...
+# Fall back to search by MR title keywords
+lore -J search "feature-from-mr" --type mr
+lore -J who src/guessed/path/             # Expertise for each file
+lore -J who --overlap src/guessed/path/   # Concurrent changes
+```
+
+**Gap identified:** Same as A6 -- `mr_file_changes` data isn't exposed. Agent is blind to the actual files in the MR unless it parses the description or uses the GitLab API directly. This is the single biggest gap for automated code review workflows.
+
+---
+
+### A11. Building a Knowledge Graph of Entity Relationships
+
+**Problem:** Agent wants to map how issues, MRs, and discussions are connected for a feature.
+
+**Flow:**
+```
+lore -J search "feature-name" -n 30
+lore -J timeline "feature-name" --depth 2 --max-entities 100
+# Timeline shows expanded entities and cross-refs, but...
+# No way to query entity_references directly
+# No way to get "all entities that reference issue #123"
+```
+
+**Gap identified:** The `entity_references` table (closes, related, mentioned) is used internally by timeline but isn't queryable as a standalone command. Agent can't ask "what closes issue #123?" or "what does MR !456 reference?" No graph export. Would enable powerful dependency mapping.
+
+---
+
+### A12. Release Readiness Assessment
+
+**Problem:** Agent needs to verify all issues in milestone "v2.0" are closed and MRs are merged.
+
+**Flow:**
+```
+lore -J issues -m "v2.0" -s opened       # Any open issues in milestone?
+lore -J issues -m "v2.0" -s closed       # Closed issues
+# MRs don't have milestone filter...
+lore -J mrs -s opened -l "v2.0"          # Try label as proxy
+lore -J who --active -p myproject        # Unresolved discussions
+```
+
+**Gap identified:** MRs don't have a `--milestone` filter (issues do). No way to check "all MRs linked to issues in milestone v2.0" -- would require joining `entity_references` with issue milestone. No release checklist concept. No way to verify "every issue in this milestone has a closing MR."
+
+---
+
+### A13. Answering "What Changed?" Between Two Points
+
+**Problem:** Agent needs to diff project state between two dates for a stakeholder report.
+
+**Flow:**
+```
+lore -J issues -s closed --since 2w --fields minimal    # Recently closed
+lore -J issues -s opened --since 2w --fields minimal    # Recently opened
+lore -J mrs -s merged --since 2w --fields minimal       # Recently merged
+# But no way to get "issues that CHANGED STATE" in a window
+# An issue opened 3 months ago but closed yesterday won't appear in --since 2w for issues -s opened
+```
+
+**Gap identified:** `--since` filters by `updated_at`, not by "state changed at." An issue closed yesterday but created 6 months ago would appear in `issues -s closed --since 1d` (because updated_at changed), but the semantics are subtle. No explicit "state transitions in time window" query. The resource_state_events table has this data but it's not exposed as a filter.
+
+---
+
+### A14. Meeting Prep: Summarize Recent Activity for a Stakeholder
+
+**Problem:** Agent needs to prepare a 2-minute summary for a project sponsor meeting.
+
+**Flow:**
+```
+lore -J count issues -p project           # Current totals
+lore -J count mrs -p project              # MR totals
+lore -J issues -s closed --since 1w -p project --fields minimal
+lore -J mrs -s merged --since 1w -p project --fields minimal
+lore -J issues -s opened --status "In progress" -p project
+lore -J who --active -p project --since 1w
+```
+
+**Gap identified:** Six queries, same as A3. No summary/dashboard command. Agent must synthesize all responses. No trend data (is the open issue count growing or shrinking?). No "highlights" extraction.
+
+---
+
+### A15. Determining If Work Is Safe to Start (Conflict Detection)
+
+**Problem:** Agent is about to start work on an issue and needs to check nobody else is already working on it.
+
+**Flow:**
+```
+lore -J issues 123                        # Read the issue
+# Check assignees from response
+lore -J mrs -s opened -A other-person     # Are they working on related MRs?
+lore -J who --overlap src/target/path/    # Anyone actively touching these files?
+lore -J search "issue-123-keywords" --type mr -s opened  # Wait, search has no --state
+```
+
+**Gap identified:** No way to check "is there an open MR that closes issue #123?" -- the entity_references data exists but isn't queryable. Search doesn't support `--state` filter. No "conflict detection" or "in-flight work" check. Agent must do multiple queries and manually correlate.
+
+---
+
+## Part 3: Gap Summary
+
+### Critical Gaps (high impact, blocks common workflows)
+
+| # | Gap | Affected Flows | Suggested Command/Flag |
+|---|-----|----------------|----------------------|
+| 1 | **MR file changes not surfaced** | H4, A6, A10 | `lore mrs <iid> --files` or include in detail view |
+| 2 | **Entity references not queryable** | H7, A5, A11, A15 | `lore refs --issue 123` / `lore refs --mr 456` |
+| 3 | **Per-note search missing** | H7, A4 | `lore search --granularity note` (PRD exists) |
+| 4 | **No entity-based timeline** | H11, A7 | `lore timeline --issue 321` / `lore timeline --mr 456` |
+| 5 | **No @me / current-user alias** | H1, H15 | Resolve from auth token automatically |
+
+### Important Gaps (significant friction, multiple workarounds needed)
+
+| # | Gap | Affected Flows | Suggested Command/Flag |
+|---|-----|----------------|----------------------|
+| 6 | **No activity feed / summary** | H1, A3, A14 | `lore activity --since 1d` or `lore summary` |
+| 7 | **No multi-path who query** | H6, A6 | `lore who src/path1/ src/path2/` |
+| 8 | **No --state filter on search** | H14, A15 | `lore search --state merged` |
+| 9 | **MRs missing --milestone filter** | H9, A12 | `lore mrs -m "v2.0"` |
+| 10 | **No --no-assignee / --unassigned** | H2 | `lore issues --no-assignee` |
+| 11 | **No --updated-before filter** | H10, A9 | `lore issues --before 90d` or `--stale 90d` |
+| 12 | **No team workload view** | H8 | `lore who --team` or `lore workload` |
+
+### Nice-to-Have Gaps (would improve agent efficiency)
+
+| # | Gap | Affected Flows | Suggested Command/Flag |
+|---|-----|----------------|----------------------|
+| 13 | **No pagination/offset** | A9 | `--offset 100` for large result sets |
+| 14 | **No detail --fields on show** | A2 | `lore issues 999 --fields description` |
+| 15 | **No cross-project grouping** | A8 | `lore search --group-by project` |
+| 16 | **No trend/velocity metrics** | A3, A14 | `lore trends issues --period week` |
+| 17 | **No --for-issue on mrs** | A12, A15 | `lore mrs --closes 123` (query entity_refs) |
+| 18 | **1y/12m duration not supported** | A4 | Support `1y`, `12m`, `365d` in --since |
+| 19 | **No discussion participant filter** | H15 | `lore who --active --participant @me` |
+| 20 | **No sort by due date** | H2 | `lore issues --sort due` |

migrations/021_work_item_status.sql

@@ -0,0 +1,9 @@
+ALTER TABLE issues ADD COLUMN status_name TEXT;
+ALTER TABLE issues ADD COLUMN status_category TEXT;
+ALTER TABLE issues ADD COLUMN status_color TEXT;
+ALTER TABLE issues ADD COLUMN status_icon_name TEXT;
+ALTER TABLE issues ADD COLUMN status_synced_at INTEGER;
+CREATE INDEX IF NOT EXISTS idx_issues_project_status_name ON issues(project_id, status_name);
+
+INSERT INTO schema_version (version, applied_at, description)
+VALUES (21, strftime('%s', 'now') * 1000, 'Work item status columns for issues');

migrations/023_issue_detail_fields.sql

@@ -0,0 +1,5 @@
+ALTER TABLE issues ADD COLUMN closed_at TEXT;
+ALTER TABLE issues ADD COLUMN confidential INTEGER NOT NULL DEFAULT 0;
+
+INSERT INTO schema_version (version, applied_at, description)
+VALUES (23, strftime('%s', 'now') * 1000, 'Add closed_at and confidential to issues');

plans/lore-service.feedback-1.md

@@ -0,0 +1,186 @@
+1. **Isolate scheduled behavior from manual `sync`**
+Reasoning: Your current plan injects backoff into `handle_sync_cmd`, which affects all `lore sync` calls (including manual recovery runs). Scheduled behavior should be isolated so humans aren’t unexpectedly blocked by service backoff.
+
+```diff
+@@ Context
+-`lore sync` runs a 4-stage pipeline (issues, MRs, docs, embeddings) that takes 2-4 minutes.
++`lore sync` remains the manual/operator command.
++`lore service run` (hidden/internal) is the scheduled execution entrypoint.
+
+@@ Commands & User Journeys
++### `lore service run` (hidden/internal)
++**What it does:** Executes one scheduled sync attempt with service-only policy:
++- applies service backoff policy
++- records service run state
++- invokes sync pipeline with configured profile
++- updates retry state on success/failure
++
++**Invocation:** scheduler always runs:
++`lore --robot service run --reason timer`
+
+@@ Backoff Integration into `handle_sync_cmd`
+-Insert **after** config load but **before** the dry_run check:
++Do not add backoff checks to `handle_sync_cmd`.
++Backoff logic lives only in `handle_service_run`.
+```
+
+2. **Use DB as source-of-truth for service state (not a standalone JSON status file)**
+Reasoning: You already have `sync_runs` in SQLite. A separate JSON status file creates split-brain and race/corruption risk. Keep JSON as optional cache/export only.
+
+```diff
+@@ Status File
+-Location: `{get_data_dir()}/sync-status.json`
++Primary state location: SQLite (`service_state` table) + existing `sync_runs`.
++Optional mirror file: `{get_data_dir()}/sync-status.json` (best-effort export only).
+
+@@ File-by-File Implementation Details
+-### `src/core/sync_status.rs` (NEW)
++### `migrations/015_service_state.sql` (NEW)
++CREATE TABLE service_state (
++  id INTEGER PRIMARY KEY CHECK (id = 1),
++  installed INTEGER NOT NULL DEFAULT 0,
++  platform TEXT,
++  interval_seconds INTEGER,
++  profile TEXT NOT NULL DEFAULT 'balanced',
++  consecutive_failures INTEGER NOT NULL DEFAULT 0,
++  next_retry_at_ms INTEGER,
++  last_error_code TEXT,
++  last_error_message TEXT,
++  updated_at_ms INTEGER NOT NULL
++);
++
++### `src/core/service_state.rs` (NEW)
++- read/write state row
++- derive backoff/next_retry
++- join with latest `sync_runs` for status output
+```
+
+3. **Backoff policy should be configurable, jittered, and error-aware**
+Reasoning: Fixed hardcoded backoff (`base=1800`) is wrong when user sets another interval. Also permanent failures (bad token/config) should not burn retries forever; they should enter paused/error state.
+
+```diff
+@@ Backoff Logic
+-// Exponential: base * 2^failures, capped at 4 hours
++// Exponential with jitter: base * 2^(failures-1), capped, ±20% jitter
++// Applies only to transient errors.
++// Permanent errors set `paused_reason` and stop retries until user action.
+
+@@ CLI Definition Changes
++ServiceCommand::Resume,   // clear paused state / failures
++ServiceCommand::Run,      // hidden
+
+@@ Error Types
++ServicePaused,            // scheduler paused due to permanent error
++ServiceCommandFailed,     // OS command failure with stderr context
+```
+
+4. **Add a pipeline-level single-flight lock**
+Reasoning: Current locking is in ingest stages; there’s still overlap risk across full sync pipelines (docs/embed can overlap with another run). Add a top-level lock for scheduled/manual sync pipeline execution.
+
+```diff
+@@ Architecture
++Add `sync_pipeline` lock at top-level sync execution.
++Keep existing ingest lock (`sync`) for ingest internals.
+
+@@ Backoff Integration into `handle_sync_cmd`
++Before starting sync pipeline, acquire `AppLock` with:
++name = "sync_pipeline"
++stale_lock_minutes = config.sync.stale_lock_minutes
++heartbeat_interval_seconds = config.sync.heartbeat_interval_seconds
+```
+
+5. **Don’t embed token in service files by default**
+Reasoning: Embedding PAT into unit/plist is a high-risk secret leak path. Make secure storage explicit and default-safe.
+
+```diff
+@@ `lore service install [--interval 30m]`
++`lore service install [--interval 30m] [--token-source env-file|embedded]`
++Default: `env-file` (0600 perms, user-owned)
++`embedded` allowed only with explicit opt-in and warning
+
+@@ Robot output
+-    "token_embedded": true
++    "token_source": "env_file"
+
+@@ Human output
+-  Note: Your GITLAB_TOKEN is embedded in the service file.
++  Note: Token is stored in a user-private env file (0600).
+```
+
+6. **Introduce a command-runner abstraction with timeout + stderr capture**
+Reasoning: `launchctl/systemctl/schtasks` calls are failure-prone; you need consistent error mapping and deterministic tests.
+
+```diff
+@@ Platform Backends
+-exports free functions that dispatch via `#[cfg(target_os)]`
++exports backend + shared `CommandRunner`:
++- run(cmd, args, timeout)
++- capture stdout/stderr/exit code
++- map failure to `ServiceCommandFailed { cmd, exit_code, stderr }`
+```
+
+7. **Persist install manifest to avoid brittle file parsing**
+Reasoning: Parsing timer/plist for interval/state is fragile and platform-format dependent. Persist a manifest with checksums and expected artifacts.
+
+```diff
+@@ Platform Backends
+-Same pattern for ... `get_interval_seconds()`
++Add manifest: `{data_dir}/service-manifest.json`
++Stores platform, interval, profile, generated files, and command.
++`service status` reads manifest first, then verifies platform state.
+
+@@ Acceptance criteria
++Install is idempotent:
++- if manifest+files already match, report `no_change: true`
++- if drift detected, reconcile and rewrite
+```
+
+8. **Make schedule profile explicit (`fast|balanced|full`)**
+Reasoning: This makes the feature more useful and performance-tunable without requiring users to understand internal flags.
+
+```diff
+@@ `lore service install [--interval 30m]`
++`lore service install [--interval 30m] [--profile fast|balanced|full]`
++
++Profiles:
++- fast: `sync --no-docs --no-embed`
++- balanced (default): `sync --no-embed`
++- full: `sync`
+```
+
+9. **Upgrade `service status` to include scheduler health + recent run summary**
+Reasoning: Single last-sync snapshot is too shallow. Include recent attempts and whether scheduler is paused/backing off/running.
+
+```diff
+@@ `lore service status`
+-What it does: Shows whether the service is installed, its configuration, last sync result, and next scheduled run.
++What it does: Shows install state, scheduler state (running/backoff/paused), recent runs, and next run estimate.
+
+@@ Robot output
+-    "last_sync": { ... },
+-    "backoff": null
++    "scheduler_state": "running|backoff|paused|idle",
++    "last_sync": { ... },
++    "recent_runs": [{"run_id":"...","status":"...","started_at_iso":"..."}],
++    "backoff": null,
++    "paused_reason": null
+```
+
+10. **Strengthen tests around determinism and cross-platform generation**
+Reasoning: Time-based backoff and shell quoting are classic flaky points. Add fake clock + fake command runner for deterministic tests.
+
+```diff
+@@ Testing Strategy
++Add deterministic test seams:
++- `Clock` trait for backoff/now calculations
++- `CommandRunner` trait for backend command execution
++
++Add tests:
++- transient vs permanent error classification
++- backoff schedule with jitter bounds
++- manifest drift reconciliation
++- quoting/escaping for paths with spaces and special chars
++- `service run` does not modify manual `sync` behavior
+```
+
+If you want, I can rewrite your full plan as a single clean revised document with these changes already integrated (instead of patch fragments).

plans/lore-service.feedback-2.md

@@ -0,0 +1,182 @@
+**High-Impact Revisions (ordered by priority)**
+
+1. **Make service identity project-scoped (avoid collisions across repos/users)**
+Analysis: Current fixed names (`com.gitlore.sync`, `LoreSync`, `lore-sync.timer`) will collide when users run multiple gitlore workspaces. This causes silent overwrites and broken uninstall/status behavior.  
+Diff:
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Commands & User Journeys / install
+- lore service install [--interval 30m] [--profile balanced] [--token-source env-file]
++ lore service install [--interval 30m] [--profile balanced] [--token-source auto] [--name <optional>]
+@@ Install Manifest Schema
++    /// Stable per-install identity (default derived from project root hash)
++    pub service_id: String,
+@@ Platform Backends
+- Label: com.gitlore.sync
++ Label: com.gitlore.sync.{service_id}
+- Task name: LoreSync
++ Task name: LoreSync-{service_id}
+- ~/.config/systemd/user/lore-sync.service
++ ~/.config/systemd/user/lore-sync-{service_id}.service
+```
+
+2. **Replace token model with secure per-OS defaults**
+Analysis: The current “env-file default” is not actually secure on macOS launchd (token still ends up in plist). On Windows, assumptions about inherited environment are fragile. Use OS-native secure stores by default and keep `embedded` as explicit opt-in only.  
+Diff:
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Token storage strategies
+-| env-file (default) | ...
++| auto (default) | macOS: Keychain, Linux: env-file (0600), Windows: Credential Manager |
++| env-file | Linux/systemd only |
+ | embedded | ... explicit warning ...
+@@ macOS launchd section
+- env-file strategy stores canonical token in service-env but embeds token in plist
++ default strategy is Keychain lookup at runtime; no token persisted in plist
++ env-file is not offered on macOS
+@@ Windows schtasks section
+- token must be in user's system environment
++ default strategy stores token in Windows Credential Manager and injects at runtime
+```
+
+3. **Version and atomically persist manifest/status**
+Analysis: `Option<Self>` on read hides corruption, and non-atomic writes risk truncated JSON on crashes. This will create false “not installed” and scheduler confusion.  
+Diff:
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Install Manifest Schema
++    pub schema_version: u32, // start at 1
++    pub updated_at_iso: String,
+@@ Status File Schema
++    pub schema_version: u32, // start at 1
++    pub updated_at_iso: String,
+@@ Read/Write
+- read(path) -> Option<Self>
++ read(path) -> Result<Option<Self>, LoreError>
+- write(...) -> std::io::Result<()>
++ write_atomic(...) -> std::io::Result<()> // tmp file + fsync + rename
+```
+
+4. **Persist `next_retry_at_ms` instead of recomputing jitter**
+Analysis: Deterministic jitter from timestamp modulo is predictable and can herd retries. Persisting `next_retry_at_ms` at failure time makes status accurate, stable, and cheap to compute.  
+Diff:
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ SyncStatusFile
+     pub consecutive_failures: u32,
++    pub next_retry_at_ms: Option<i64>,
+@@ Backoff Logic
+- compute backoff from last_run.timestamp_ms and deterministic jitter each read
++ compute backoff once on failure, store next_retry_at_ms, read-only comparison afterward
++ jitter algorithm: full jitter in [0, cap], injectable RNG for tests
+```
+
+5. **Add circuit breaker for repeated transient failures**
+Analysis: Infinite transient retries can run forever on systemic failures (DB corruption, bad network policy). After N transient failures, pause with actionable reason.  
+Diff:
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Scheduler states
+- backoff — transient failures, waiting to retry
++ backoff — transient failures, waiting to retry
++ paused — permanent error OR circuit breaker tripped after N transient failures
+@@ Service run flow
+- On transient failure: increment failures, compute backoff
++ On transient failure: increment failures, compute backoff, if failures >= max_transient_failures -> pause
+```
+
+6. **Stage-aware outcome policy (core freshness over all-or-nothing)**
+Analysis: Failing embeddings/docs should not block issues/MRs freshness. Split stage outcomes and only treat core stages as hard-fail by default. This improves reliability and practical usefulness.  
+Diff:
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Context
+- lore sync runs a 4-stage pipeline ... treated as one run result
++ lore service run records per-stage outcomes (issues, mrs, docs, embeddings)
+@@ Status File Schema
++    pub stage_results: Vec<StageResult>,
+@@ service run flow
+- Execute sync pipeline with flags derived from profile
++ Execute stage-by-stage and classify severity:
++   - critical: issues, mrs
++   - optional: docs, embeddings
++ optional stage failures mark run as degraded, not failed
+```
+
+7. **Replace cfg free-function backend with trait-based backend**
+Analysis: Current backend API is hard to test end-to-end without real OS commands. A `SchedulerBackend` trait enables deterministic integration tests and cleaner architecture.  
+Diff:
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Platform Backends / Architecture
+- exports free functions dispatched via #[cfg]
++ define trait SchedulerBackend { install, uninstall, state, file_paths, next_run }
++ provide LaunchdBackend, SystemdBackend, SchtasksBackend implementations
++ include FakeBackend for integration tests
+```
+
+8. **Harden platform units and detect scheduler prerequisites**
+Analysis: systemd user timers often fail silently without user manager/linger; launchd context can be wrong in headless sessions. Add explicit diagnostics and unit hardening.  
+Diff:
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Linux systemd unit
+ [Service]
+ Type=oneshot
+ ExecStart=...
++TimeoutStartSec=900
++NoNewPrivileges=true
++PrivateTmp=true
++ProtectSystem=strict
++ProtectHome=read-only
+@@ Linux install/status
++ detect user manager availability and linger state; surface warning/action
+@@ macOS install/status
++ detect non-GUI bootstrap context and return actionable error
+```
+
+9. **Add operational commands: `trigger`, `doctor`, and non-interactive log tail**
+Analysis: `logs` opening an editor is weak for automation and incident response. Operators need a preflight and immediate controlled run.  
+Diff:
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ ServiceCommand
++ Trigger, // run one attempt through service policy now
++ Doctor,  // validate scheduler, token, paths, permissions
+@@ logs
+- opens editor
++ supports --tail <n> and --follow in human mode
++ robot mode can return last_n lines optionally
+```
+
+10. **Fix plan inconsistencies and edge-case correctness**
+Analysis: There are internal mismatches that will cause implementation drift.  
+Diff:
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Interval Parsing
+- supports 's' suffix
++ remove 's' suffix (acceptance only allows 5m..24h)
+@@ uninstall acceptance
+- removes ALL service files only
++ explicitly also remove service-manifest and service-env (status/logs retained)
+@@ SyncStatusFile schema
+- pub last_run: SyncRunRecord
++ pub last_run: Option<SyncRunRecord> // matches idle/no runs state
+```
+
+---
+
+**Recommended Architecture Upgrade Summary**
+
+The strongest improvement set is: **(1) project-scoped IDs, (2) secure token defaults, (3) atomic/versioned state, (4) persisted retry schedule + circuit breaker, (5) stage-aware outcomes**. That combination materially improves correctness, multi-repo safety, security, operability, and real-world reliability without changing your core manual-vs-scheduled separation principle.

plans/lore-service.feedback-3.md

@@ -0,0 +1,174 @@
+Below are the highest-impact revisions I’d make, ordered by severity/ROI. These focus on correctness first, then security, then operability and UX.
+
+1. **Fix multi-install ambiguity (`service_id` exists, but commands can’t target one explicitly)**
+Analysis: The plan introduces `service-manifest-{service_id}.json`, but `status/uninstall/resume/logs` have no selector. In a multi-workspace or multi-name install scenario, behavior becomes ambiguous and error-prone. Add explicit targeting plus discovery.
+```diff
+@@ ## Commands & User Journeys
++### `lore service list`
++Lists installed services discovered from `{data_dir}/service-manifest-*.json`.
++Robot output includes `service_id`, `platform`, `interval_seconds`, `profile`, `installed_at_iso`.
+
+@@ ### `lore service uninstall`
+-### `lore service uninstall`
++### `lore service uninstall [--service <service_id|name>] [--all]`
+@@
+-2. CLI reads install manifest to find `service_id`
++2. CLI resolves target service via `--service` or current-project-derived default.
++3. If multiple candidates and no selector, return actionable error.
+
+@@ ### `lore service status`
+-### `lore service status`
++### `lore service status [--service <service_id|name>]`
+```
+
+2. **Make status state service-scoped (not global)**
+Analysis: A single `sync-status.json` for all services causes cross-service contamination (pause/backoff/outcome from one profile affecting another). Keep lock global, but state per service.
+```diff
+@@ ## Status File
+-### Location
+-`{get_data_dir()}/sync-status.json`
++### Location
++`{get_data_dir()}/sync-status-{service_id}.json`
+
+@@ ## Paths Module Additions
+-pub fn get_service_status_path() -> PathBuf {
+-    get_data_dir().join("sync-status.json")
++pub fn get_service_status_path(service_id: &str) -> PathBuf {
++    get_data_dir().join(format!("sync-status-{service_id}.json"))
+}
+@@
+-Note: `sync-status.json` is NOT scoped by `service_id`
++Note: status is scoped by `service_id`; lock remains global (`sync_pipeline`) to prevent overlapping writes.
+```
+
+3. **Stop classifying permanence via string matching**
+Analysis: Matching `"401 Unauthorized"` in strings is brittle and will misclassify edge cases. Carry machine codes through stage results and classify by `ErrorCode` only.
+```diff
+@@ pub struct StageResult {
+-    pub error: Option<String>,
++    pub error: Option<String>,
++    pub error_code: Option<String>, // e.g., AUTH_FAILED, NETWORK_ERROR
+}
+@@ Error classification helpers
+-fn is_permanent_error_message(msg: Option<&str>) -> bool { ...string contains... }
++fn is_permanent_error_code(code: Option<&str>) -> bool {
++    matches!(code, Some("TOKEN_NOT_SET" | "AUTH_FAILED" | "CONFIG_NOT_FOUND" | "CONFIG_INVALID" | "MIGRATION_FAILED"))
++}
+```
+
+4. **Install should be transactional (manifest written last)**
+Analysis: Current order writes manifest before scheduler enable. If enable fails, you persist a false “installed” state. Use two-phase install with rollback.
+```diff
+@@ ### `lore service install` User journey
+-9. CLI writes install manifest ...
+-10. CLI runs the platform-specific enable command
++9. CLI runs the platform-specific enable command
++10. On success, CLI writes install manifest atomically
++11. On failure, CLI removes generated files and returns `ServiceCommandFailed`
+```
+
+5. **Fix launchd token security gap (env-file currently still embeds token)**
+Analysis: Current “env-file” on macOS still writes token into plist, defeating the main security goal. Generate a private wrapper script that reads env file at runtime and execs `lore`.
+```diff
+@@ ### macOS: launchd
+-<key>ProgramArguments</key>
+-<array>
+-    <string>{binary_path}</string>
+-    <string>--robot</string>
+-    <string>service</string>
+-    <string>run</string>
+-</array>
++<key>ProgramArguments</key>
++<array>
++    <string>{data_dir}/service-run-{service_id}.sh</string>
++</array>
+@@
+-`env-file`: ... token value must still appear in plist ...
++`env-file`: token never appears in plist; wrapper loads `{data_dir}/service-env-{service_id}` at runtime.
+```
+
+6. **Improve backoff math and add half-open circuit recovery**
+Analysis: Current jitter + min clamp makes first retry deterministic and can over-pause. Also circuit-breaker requires manual resume forever. Add cooldown + half-open probe to self-heal.
+```diff
+@@ Backoff Logic
+-let backoff_secs = ((base_backoff as f64) * jitter_factor) as u64;
+-let backoff_secs = backoff_secs.max(base_interval_seconds);
++let max_backoff = base_backoff;
++let min_backoff = base_interval_seconds;
++let span = max_backoff.saturating_sub(min_backoff);
++let backoff_secs = min_backoff + ((span as f64) * jitter_factor) as u64;
+
+@@ Scheduler states
+-- `paused` — permanent error ... OR circuit breaker tripped ...
++- `paused` — permanent error requiring intervention
++- `half_open` — probe state after circuit cooldown; one trial run allowed
+
+@@ Circuit breaker
+-... transitions to `paused` ... Run: lore service resume
++... transitions to `half_open` after cooldown (default 30m). Successful probe closes breaker automatically; failed probe returns to backoff/paused.
+```
+
+7. **Promote backend trait to v1 (not v2) for deterministic integration tests**
+Analysis: This is a reliability-critical feature spanning OS schedulers. A trait abstraction now gives true behavior tests and safer refactors.
+```diff
+@@ ### Platform Backends
+-> Future architecture note: A `SchedulerBackend` trait ... for v2.
++Adopt `SchedulerBackend` trait in v1 with real backends (`launchd/systemd/schtasks`) and `FakeBackend` for tests.
++This enables deterministic install/uninstall/status/run-path integration tests without touching host scheduler.
+```
+
+8. **Harden `run_cmd` timeout behavior**
+Analysis: If timeout occurs, child process must be killed and reaped. Otherwise you leak processes and can wedge repeated runs.
+```diff
+@@ fn run_cmd(...)
+-// Wait with timeout
+-let output = wait_with_timeout(output, timeout_secs)?;
++// Wait with timeout; on timeout kill child and wait to reap
++let output = wait_with_timeout_kill_and_reap(child, timeout_secs)?;
+```
+
+9. **Add manual control commands (`pause`, `trigger`, `repair`)**
+Analysis: These are high-utility operational controls. `trigger` helps immediate sync without waiting interval. `pause` supports maintenance windows. `repair` avoids manual file deletion for corrupt state.
+```diff
+@@ pub enum ServiceCommand {
++    /// Pause scheduled execution without uninstalling
++    Pause { #[arg(long)] reason: Option<String> },
++    /// Trigger an immediate one-off run using installed profile
++    Trigger { #[arg(long)] ignore_backoff: bool },
++    /// Repair corrupt manifest/status by backing up and reinitializing
++    Repair { #[arg(long)] service: Option<String> },
+}
+```
+
+10. **Make `logs` default non-interactive and add rotation policy**
+Analysis: Opening editor by default is awkward for automation/SSH and slower for normal diagnosis. Defaulting to `tail` is more practical; `--open` can preserve editor behavior.
+```diff
+@@ ### `lore service logs`
+-By default, opens in the user's preferred editor.
++By default, prints last 100 lines to stdout.
++Use `--open` to open editor.
+@@
++Log rotation: rotate `service-stdout.log` / `service-stderr.log` at 10 MB, keep 5 files.
+```
+
+11. **Remove destructive/shell-unsafe suggested action**
+Analysis: `actions(): ["rm {path}", ...]` is unsafe (shell injection + destructive guidance). Replace with safe command path.
+```diff
+@@ LoreError::actions()
+-Self::ServiceCorruptState { path, .. } => vec![&format!("rm {path}"), "lore service install"],
++Self::ServiceCorruptState { .. } => vec!["lore service repair", "lore service install"],
+```
+
+12. **Tighten scheduler units for real-world reliability**
+Analysis: Add explicit working directory and success-exit handling to reduce environment drift and edge failures.
+```diff
+@@ systemd service unit
+ [Service]
+ Type=oneshot
+ ExecStart={binary_path} --robot service run
++WorkingDirectory={data_dir}
++SuccessExitStatus=0
+ TimeoutStartSec=900
+```
+
+If you want, I can produce a single consolidated “v3 plan” markdown with these revisions already merged into your original structure.

plans/lore-service.feedback-4.md

@@ -0,0 +1,190 @@
+No `## Rejected Recommendations` section was present in the plan you shared, so the proposals below are all net-new.
+
+1. **Make scheduled runs explicitly target a single service instance**
+Analysis: right now `service run` has no selector, but the plan supports multiple installed services. That creates ambiguity and incorrect manifest/status selection. This is the most important architectural fix.
+
+```diff
+@@ `lore service install` What it does
+- runs `lore --robot service run` at the specified interval
++ runs `lore --robot service run --service-id <service_id>` at the specified interval
+
+@@ Robot output (`install`)
+- "sync_command": "/usr/local/bin/lore --robot service run",
++ "sync_command": "/usr/local/bin/lore --robot service run --service-id a1b2c3d4",
+
+@@ `ServiceCommand` enum
+- #[command(hide = true)]
+- Run,
++ #[command(hide = true)]
++ Run {
++     /// Internal selector injected by scheduler backend
++     #[arg(long, hide = true)]
++     service_id: String,
++ },
+
+@@ `handle_service_run` signature
+-pub fn handle_service_run(start: std::time::Instant) -> Result<(), Box<dyn std::error::Error>>
++pub fn handle_service_run(service_id: &str, start: std::time::Instant) -> Result<(), Box<dyn std::error::Error>>
+
+@@ run flow step 1
+- Read install manifest
++ Read install manifest for `service_id`
+```
+
+2. **Strengthen `service_id` derivation to avoid cross-workspace collisions**
+Analysis: hashing config path alone can collide when many workspaces share one global config. Identity should represent what is being synced, not only where config lives.
+
+```diff
+@@ Key Design Principles / Project-Scoped Service Identity
+- derive from a stable hash of the config file path
++ derive from a stable fingerprint of:
++ - canonical workspace root
++ - normalized configured GitLab project URLs
++ - canonical config path
++ then take first 12 hex chars of SHA-256
+
+@@ `compute_service_id`
+- Returns first 8 hex chars of SHA-256 of the canonical config path.
++ Returns first 12 hex chars of SHA-256 of a canonical identity tuple
++ (workspace_root + sorted project URLs + config_path).
+```
+
+3. **Introduce a service-state machine with a dedicated admin lock**
+Analysis: install/uninstall/pause/resume/repair/status can race each other. A lock and explicit transition table prevents invalid states and file races.
+
+```diff
+@@ New section: Service State Model
++ All state mutations are serialized by `AppLock("service-admin-{service_id}")`.
++ Legal transitions:
++ - idle -> running -> success|degraded|backoff|paused
++ - backoff -> running|paused
++ - paused -> half_open|running (resume)
++ - half_open -> running|paused
++ Any invalid transition is rejected with `ServiceCorruptState`.
+
+@@ `handle_install`, `handle_uninstall`, `handle_pause`, `handle_resume`, `handle_repair`
++ Acquire `service-admin-{service_id}` before mutating manifest/status/service files.
+```
+
+4. **Unify manual and scheduled sync execution behind one orchestrator**
+Analysis: the plan currently duplicates stage logic and error classification in `service run`, increasing drift risk. A shared orchestrator gives one authoritative pipeline behavior.
+
+```diff
+@@ Key Design Principles
++ #### 6. Single Sync Orchestrator
++ Both `lore sync` and `lore service run` call `SyncOrchestrator`.
++ Service mode adds policy (backoff/circuit-breaker); manual mode bypasses policy.
+
+@@ Service Run Implementation
+- execute_sync_stages(&sync_args)
++ SyncOrchestrator::run(SyncMode::Service { profile, policy })
+
+@@ manual sync
+- separate pipeline path
++ SyncOrchestrator::run(SyncMode::Manual { flags })
+```
+
+5. **Add bounded in-run retries for transient core-stage failures**
+Analysis: single-shot failure handling will over-trigger backoff on temporary network blips. One short retry per core stage significantly improves freshness without much extra runtime.
+
+```diff
+@@ Stage-aware execution
++ Core stages (`issues`, `mrs`) get up to 1 immediate retry on transient errors
++ (jittered 1-5s). Permanent errors are never retried.
++ Optional stages keep best-effort semantics.
+
+@@ Acceptance criteria (`service run`)
++ Retries transient core stage failures once before counting run as failed.
+```
+
+6. **Harden persistence with full crash-safety semantics**
+Analysis: current atomic write description is good but incomplete for power-loss durability. You should fsync parent directory after rename and include lightweight integrity metadata.
+
+```diff
+@@ `write_atomic`
+- tmp file + fsync + rename
++ tmp file + fsync(file) + rename + fsync(parent_dir)
+
+@@ `ServiceManifest` and `SyncStatusFile`
++ pub write_seq: u64,
++ pub content_sha256: String, // optional integrity guard for repair/doctor
+```
+
+7. **Fix token handling to avoid shell/env injection and add secure-store mode**
+Analysis: sourcing env files in shell is brittle if token contains special chars/newlines. Also, secure OS credential stores should be first-class for production reliability/security.
+
+```diff
+@@ Token storage strategies
+-| `env-file` (default) ...
++| `auto` (default) | use secure-store when available, else env-file |
++| `secure-store` | macOS Keychain / libsecret / Windows Credential Manager |
++| `env-file` | explicit fallback |
+
+@@ macOS wrapper script
+-. "{data_dir}/service-env-{service_id}"
+-export {token_env_var}
++TOKEN_VALUE="$(cat "{data_dir}/service-token-{service_id}" )"
++export {token_env_var}="$TOKEN_VALUE"
+
+@@ Acceptance criteria
++ Reject token values containing `\0` or newline for env-file mode.
++ Never eval/source untrusted token content.
+```
+
+8. **Correct platform/runtime implementation hazards**
+Analysis: there are a few correctness risks that should be fixed in-plan now.
+
+```diff
+@@ macOS install steps
+- Get UID via `unsafe { libc::getuid() }`
++ Get UID via safe API (`nix::unistd::Uid::current()` or equivalent safe helper)
+
+@@ Command Runner Helper
+- poll try_wait and read stdout/stderr after exit
++ avoid potential pipe backpressure deadlock:
++ use wait-with-timeout + concurrent stdout/stderr draining
+
+@@ Linux timer
+- OnUnitActiveSec={interval_seconds}s
++ OnUnitInactiveSec={interval_seconds}s
++ AccuracySec=1min
+```
+
+9. **Make logs fully service-scoped**
+Analysis: you already scoped manifest/status by `service_id`; logs are still global in several places. Multi-service installs will overwrite each other’s logs.
+
+```diff
+@@ Paths Module Additions
+-pub fn get_service_log_path() -> PathBuf
++pub fn get_service_log_path(service_id: &str, stream: LogStream) -> PathBuf
+
+@@ log filenames
+- logs/service-stderr.log
+- logs/service-stdout.log
++ logs/service-{service_id}-stderr.log
++ logs/service-{service_id}-stdout.log
+
+@@ `service logs`
+- default path: `{data_dir}/logs/service-stderr.log`
++ default path: `{data_dir}/logs/service-{service_id}-stderr.log`
+```
+
+10. **Resolve internal spec contradictions and rollback gaps**
+Analysis: there are a few contradictory statements and incomplete rollback behavior that will cause implementation churn.
+
+```diff
+@@ `service logs` behavior
+- default (no flags): open in editor (human)
++ default (no flags): print last 100 lines (human and robot metadata mode)
++ `--open` is explicit opt-in
+
+@@ install rollback
+- On failure: removes generated service files
++ On failure: removes generated service files, env file, wrapper script, and temp manifest
+
+@@ `handle_service_run` sample code
+- let manifest_path = get_service_manifest_path();
++ let manifest_path = get_service_manifest_path(service_id);
+```
+
+If you want, I can take these revisions and produce a single consolidated “Iteration 4” replacement plan block with all sections rewritten coherently so it’s ready to hand to an implementer.

plans/lore-service.feedback-5.md

@@ -0,0 +1,196 @@
+I reviewed the full plan and avoided everything already listed in `## Rejected Recommendations`. These are the highest-impact revisions I’d make.
+
+1. **Fix identity model inconsistency and prevent `--name` alias collisions**
+Why this improves the plan: your text says identity includes workspace root, but the current derivation code does not. Also, using `--name` as the actual `service_id` risks accidental cross-project collisions and destructive updates.
+
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Key Design Principles / 2. Project-Scoped Service Identity
+- Each installed service gets a unique `service_id` derived from a canonical identity tuple: the config file path, sorted GitLab project URLs, and workspace root.
++ Each installed service gets an immutable `identity_hash` derived from a canonical identity tuple:
++ workspace root + canonical config path + sorted normalized project URLs.
++ `service_id` remains the scheduler identifier; `--name` is a human alias only.
++ If `--name` collides with an existing service that has a different `identity_hash`, install fails with an actionable error.
+
+@@ Install Manifest / Schema
++ /// Immutable identity hash for collision-safe matching across reinstalls
++ pub identity_hash: String,
++ /// Optional human-readable alias passed via --name
++ #[serde(skip_serializing_if = "Option::is_none")]
++ pub service_alias: Option<String>,
++ /// Canonical workspace root used in identity derivation
++ pub workspace_root: String,
+
+@@ service_id derivation
+-pub fn compute_service_id(config_path: &Path, project_urls: &[&str]) -> String
++pub fn compute_identity_hash(workspace_root: &Path, config_path: &Path, project_urls: &[&str]) -> String
+```
+
+2. **Add lock protocol to eliminate uninstall/run race conditions**
+Why this improves the plan: today `service run` does not take admin lock, and admin commands do not take pipeline lock. `uninstall` can race with an active run and remove files mid-execution.
+
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Key Design Principles / 6. Serialized Admin Mutations
+- The `service run` entrypoint does NOT acquire the admin lock — it only acquires the `sync_pipeline` lock
++ The `service run` entrypoint acquires only `sync_pipeline`.
++ Destructive admin operations (`install` overwrite, `uninstall`, `repair --regenerate`) must:
++ 1) acquire `service-admin-{service_id}`
++ 2) disable scheduler backend entrypoint
++ 3) acquire `sync_pipeline` lock with timeout
++ 4) mutate/remove files
++ This lock ordering is mandatory to prevent deadlocks and run/delete races.
+
+@@ lore service uninstall / User journey
+- 4. Runs platform-specific disable command
+- 5. Removes service files from disk
++ 4. Acquires `sync_pipeline` lock (after disabling scheduler) with bounded wait
++ 5. Removes service files from disk only after lock acquisition
+```
+
+3. **Make transient handling `Retry-After` aware**
+Why this improves the plan: rate-limit and 503 responses often carry retry hints. Ignoring them causes useless retries and longer outages.
+
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Transient vs permanent error classification
+-| Transient | Retry with backoff | Network timeout, rate limited, DB locked, 5xx from GitLab |
++| Transient | Retry with adaptive backoff | Network timeout, DB locked, 5xx from GitLab |
++| Transient (hinted) | Respect server retry hint | Rate limited with Retry-After/X-RateLimit-Reset |
+
+@@ Backoff Logic
++ If an error includes a retry hint (e.g., `Retry-After`), set:
++ `next_retry_at_ms = max(computed_backoff, hinted_retry_at_ms)`.
++ Persist `backoff_reason` for status visibility.
+```
+
+4. **Decouple optional stage cadence from core sync interval**
+Why this improves the plan: running docs/embeddings every 5–30 minutes is expensive and unnecessary. Separate freshness windows reduce cost/latency while keeping core data fresh.
+
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Sync profiles
+-| `balanced` (default) | `--no-embed` | Issues + MRs + doc generation |
+-| `full` | (none) | Full pipeline including embeddings |
++| `balanced` (default) | core every interval, docs every 60m, no embeddings | Fast + useful docs |
++| `full` | core every interval, docs every interval, embeddings every 6h (default) | Full freshness with bounded cost |
+
+@@ Status File / StageResult
++ /// true when stage intentionally skipped due freshness window
++ #[serde(default)]
++ pub skipped: bool,
+
+@@ lore service run / Stage-aware execution
++ Optional stages may be skipped when their last successful run is within configured freshness windows.
++ Skipped optional stages do not count as failures and are recorded explicitly.
+```
+
+5. **Give Windows parity for secure token handling (env-file + wrapper)**
+Why this improves the plan: current Windows path requires global/system env and has poor UX. A wrapper+env-file model gives platform parity and avoids global token exposure.
+
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Token storage strategies
+-| On Windows, neither strategy applies — the token must be in the user's system environment
++| On Windows, `env-file` is supported via a generated wrapper script (`service-run-{service_id}.cmd` or `.ps1`)
++| that reads `{data_dir}/service-env-{service_id}` and launches `lore --robot service run ...`.
++| `embedded` remains opt-in and warned as less secure.
+
+@@ Windows: schtasks
+- Token handling on Windows: The env var must be set system-wide via `setx`
++ Token handling on Windows:
++ - `env-file` (default): wrapper script reads token from private file at runtime
++ - `embedded`: token passed via wrapper-set environment variable
++ - `system_env`: still supported as fallback
+```
+
+6. **Add run heartbeat and stale-run detection**
+Why this improves the plan: `running` state can become misleading after crashes or stale locks. Heartbeat metadata makes status accurate and improves incident triage.
+
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Status File / Schema
++ /// In-flight run metadata for crash/stale detection
++ #[serde(skip_serializing_if = "Option::is_none")]
++ pub current_run: Option<CurrentRunState>,
++
++pub struct CurrentRunState {
++    pub run_id: String,
++    pub started_at_ms: i64,
++    pub last_heartbeat_ms: i64,
++    pub pid: u32,
++}
+
+@@ lore service status
+- - `running` — currently executing (sync_pipeline lock held)
++ - `running` — currently executing with live heartbeat
++ - `running_stale` — in-flight metadata exists but heartbeat exceeded stale threshold
+```
+
+7. **Upgrade drift detection from “loaded/unloaded” to spec-level drift**
+Why this improves the plan: platform state alone misses manual edits to unit/plist/wrapper files. Spec-hash drift gives reliable “what changed?” diagnostics and safe regeneration.
+
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ Install Manifest / Schema
++ /// Hash of generated scheduler artifacts and command spec
++ pub spec_hash: String,
+
+@@ lore service status
+- Detects manifest/platform drift and reports it
++ Detects:
++ - platform drift (loaded/unloaded mismatch)
++ - spec drift (artifact content hash mismatch)
++ - command drift (sync command differs from manifest)
+
+@@ lore service repair
++ Add `--regenerate` to rewrite scheduler artifacts from manifest when spec drift is detected.
++ This is non-destructive and does not delete status/log history.
+```
+
+8. **Add safe operational modes: `install --dry-run` and `doctor --fix`**
+Why this improves the plan: dry-run reduces risk before writing OS scheduler files; fix-mode improves operator ergonomics and lowers support burden.
+
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ lore service install
++ Add `--dry-run`:
++ - validates config/token/prereqs
++ - renders service files and planned commands
++ - writes nothing, executes nothing
+
+@@ lore service doctor
++ Add `--fix` for safe, non-destructive remediations:
++ - create missing dirs
++ - correct file permissions on env/wrapper files
++ - run `systemctl --user daemon-reload` when applicable
++ - report applied fixes in robot output
+```
+
+9. **Define explicit schema migration behavior (not just `schema_version` fields)**
+Why this improves the plan: version fields without migration policy become operational risk during upgrades.
+
+```diff
+--- a/plan.md
++++ b/plan.md
+@@ ServiceManifest Read/Write
+- `ServiceManifest::read(path: &Path) -> Result<Option<Self>, LoreError>`
++ `ServiceManifest::read_and_migrate(path: &Path) -> Result<Option<Self>, LoreError>`
++ - Migrates known older schema versions to current in-memory model
++ - Rewrites migrated file atomically
++ - Fails with actionable `ServiceCorruptState` for unknown future major versions
+
+@@ SyncStatusFile Read/Write
+- `SyncStatusFile::read(path: &Path) -> Result<Option<Self>, LoreError>`
++ `SyncStatusFile::read_and_migrate(path: &Path) -> Result<Option<Self>, LoreError>`
+```
+
+If you want, I can produce a fully rewritten v5 plan text that integrates all nine changes coherently section-by-section.

plans/plan-to-beads-v2-draft.md

@@ -0,0 +1,250 @@
+# plan-to-beads v2 — Draft for Review
+
+This is a draft of the improved skill. Review before applying to `~/.claude/skills/plan-to-beads/SKILL.md`.
+
+---
+
+```markdown
+---
+name: plan-to-beads
+description: Transforms markdown implementation plans into granular, agent-ready beads with dependency graphs. Each bead is fully self-contained — an agent can execute it with zero external context. Triggers on "break down this plan", "create beads from", "convert to beads", "make issues from plan".
+argument-hint: "[path/to/plan.md]"
+---
+
+# Plan to Beads Conversion
+
+## The Prime Directive
+
+**Every bead must be executable by an agent that has ONLY the bead description.** No plan document. No Slack context. No "see the PRD." The bead IS the spec. If an agent can't start coding within 60 seconds of reading the bead, it's not ready.
+
+## Workflow
+
+```
+┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐
+│ 1. PARSE │──▶│ 2. MINE  │──▶│ 3. BUILD │──▶│ 4. LINK  │──▶│ 5. AUDIT │
+│ Structure│   │ Context  │   │ Beads    │   │ Deps     │   │ Quality  │
+└──────────┘   └──────────┘   └──────────┘   └──────────┘   └──────────┘
+```
+
+### 1. Parse Structure
+
+Read the plan document. Identify:
+- **Epics**: Major sections / phases / milestones
+- **Tasks**: Implementable units with clear outcomes (1-4 hour scope)
+- **Subtasks**: Granular steps within tasks
+
+### 2. Mine Context
+
+This is the critical step. For EACH identified task, extract everything an implementing agent will need.
+
+#### From the plan document:
+
+| Extract | Where to look | Example |
+|---------|--------------|---------|
+| **Rationale** | Intro paragraphs, "why" sections | "We need this because the current approach causes N+1 queries" |
+| **Approach details** | Implementation notes, code snippets, architecture decisions | "Use a 5-stage pipeline: SEED → HYDRATE → ..." |
+| **Test requirements** | TDD sections, acceptance criteria, "verify by" notes | "Test that empty input returns empty vec" |
+| **Edge cases & risks** | Warnings, gotchas, "watch out for" notes | "Multi-byte UTF-8 chars can cause panics at byte boundaries" |
+| **Data shapes** | Type definitions, struct descriptions, API contracts | "TimelineEvent { kind: EventKind, timestamp: DateTime, ... }" |
+| **File paths** | Explicit mentions or inferable from module structure | "src/core/timeline_seed.rs" |
+| **Dependencies on other tasks** | "requires X", "after Y is done", "uses Z from step N" | "Consumes the TimelineEvent struct from the types task" |
+| **Verification commands** | Test commands, CLI invocations, expected outputs | "cargo test timeline_seed -- --nocapture" |
+
+#### From the codebase:
+
+Search the codebase to supplement what the plan says:
+- Find existing files mentioned or implied by the plan
+- Discover patterns the task should follow (e.g., how existing similar modules are structured)
+- Check test files for naming conventions and test infrastructure in use
+- Confirm exact file paths rather than guessing
+
+Use codebase search tools (WarpGrep, Explore agent, or targeted Grep/Glob) appropriate to the scope of what you need to find.
+
+### 3. Build Beads
+
+Use `br` exclusively.
+
+| Type | Priority | Command |
+|------|----------|---------|
+| Epic | 1 | `br create "Epic: [Title]" -p 1` |
+| Task | 2-3 | `br create "[Verb] [Object]" -p 2` |
+| Subtask | 3-4 | `br q "[Verb] [Object]"` |
+
+**Granularity target**: Each bead completable in 1-4 hours by one agent.
+
+#### Description Templates
+
+Use the **full template** for all task-level beads. Use the **light template** only for trivially small tasks (config change, single-line fix, add a re-export).
+
+##### Full Template (default)
+
+```
+## Background
+[WHY this exists. What problem it solves. How it fits into the larger system.
+Include enough context that an agent unfamiliar with the project understands
+the purpose. Reference architectural patterns in use.]
+
+## Approach
+[HOW to implement. Be specific:
+- Data structures / types to create or use (include field names and types)
+- Algorithms or patterns to follow
+- Code snippets from the plan if available
+- Which existing code to reference for patterns (exact file paths)]
+
+## Acceptance Criteria
+
+### Specified (from plan — implement as-is)
+- [ ] <criteria explicitly stated in the plan>
+- [ ] <criteria explicitly stated in the plan>
+
+### Proposed (inferred — confirm with user before implementing) [?]
+- [ ] [?] <criteria the agent inferred but the plan didn't specify>
+- [ ] [?] <criteria the agent inferred but the plan didn't specify>
+
+**ASSUMPTION RULE**: If proposed criteria exceed ~30% of total, STOP.
+The bead needs human input before it's ready for implementation. Flag it
+in the audit output and ask the user to refine the ACs.
+
+## Files
+[Exact paths to create or modify. Confirmed by searching the codebase.]
+- CREATE: src/foo/bar.rs
+- MODIFY: src/foo/mod.rs (add pub mod bar)
+- MODIFY: tests/foo_tests.rs (add test module)
+
+## TDD Anchor
+[The first test to write. This grounds the agent's work.]
+RED: Write `test_<name>` in `<test_file>` that asserts <specific behavior>.
+GREEN: Implement the minimal code to make it pass.
+VERIFY: <project's test command> <pattern>
+
+[If the plan specifies additional tests, list them all:]
+- test_empty_input_returns_empty_vec
+- test_single_issue_produces_one_event
+- test_handles_missing_fields_gracefully
+
+## Edge Cases
+[Gotchas, risks, things that aren't obvious. Pulled from the plan's warnings,
+known issues, or your analysis of the approach.]
+- <edge case 1>
+- <edge case 2>
+
+## Dependency Context
+[For each dependency, explain WHAT it provides that this bead consumes.
+Not just "depends on bd-xyz" but "uses the `TimelineEvent` struct and
+`SeedConfig` type defined in bd-xyz".]
+```
+
+##### Light Template (trivially small tasks only)
+
+Use this ONLY when the task is a one-liner or pure mechanical change (add a re-export, flip a config flag, rename a constant). If there's any ambiguity about approach, use the full template.
+
+```
+## What
+[One sentence: what to do and where.]
+
+## Acceptance Criteria
+- [ ] <single binary criterion>
+
+## Files
+- MODIFY: <exact path>
+```
+
+### 4. Link Dependencies
+
+```bash
+br dep add [blocker-id] [blocked-id]
+```
+
+Dependency patterns:
+- Types/structs → code that uses them
+- Infrastructure (DB, config) → features that need them
+- Core logic → extensions/enhancements
+- Tests may depend on test helpers
+
+**Critical**: When linking deps, update the "Dependency Context" section in the blocked bead to describe exactly what it receives from the blocker.
+
+### 5. Audit Quality
+
+Before reporting, review EVERY bead against this checklist:
+
+| Check | Pass criteria |
+|-------|--------------|
+| **Self-contained?** | Agent can start coding in 60 seconds with ONLY this description |
+| **TDD anchor?** | First test to write is named and described |
+| **Binary criteria?** | Every acceptance criterion is pass/fail, not subjective |
+| **Exact paths?** | File paths verified against codebase, not guessed |
+| **Edge cases?** | At least 1 non-obvious gotcha identified |
+| **Dep context?** | Each dependency explains WHAT it provides, not just its ID |
+| **Approach specifics?** | Types, field names, patterns — not "implement the thing" |
+| **Assumption budget?** | Proposed [?] criteria are <30% of total ACs |
+
+If a bead fails any check, fix it before moving on. If the assumption budget is exceeded, flag the bead for human review rather than inventing more ACs.
+
+## Assumption & AC Guidance
+
+Agents filling in beads will inevitably encounter gaps in the plan. The rules:
+
+1. **Never silently fill gaps.** If the plan doesn't specify a behavior, don't assume one and bury it in the ACs. Mark it `[?]` so the implementing agent knows to ask.
+
+2. **Specify provenance on every AC.** Specified = from the plan. Proposed = your inference. The implementing agent treats these differently:
+   - **Specified**: implement without question
+   - **Proposed [?]**: pause and confirm with the user before implementing
+
+3. **The 30% rule.** If more than ~30% of ACs on a bead are proposed/inferred, the plan was too vague for this task. Don't create the bead as-is. Instead:
+   - Create it with status noting "needs AC refinement"
+   - List the open questions explicitly
+   - Flag it in the output report under "Beads Needing Human Input"
+
+4. **Prefer smaller scope over more assumptions.** If you're unsure whether a task should handle edge case X, make the bead's scope explicitly exclude it and note it as a potential follow-up. A bead that does less but does it right beats one that guesses wrong.
+
+5. **Implementing agents: honor the markers.** When you encounter `[?]` on an AC, you MUST ask the user before implementing that behavior. Do not silently resolve it in either direction.
+
+## Output Format
+
+After completion, report:
+
+```
+## Beads Created: N total (X epics, Y tasks, Z subtasks)
+
+### Quality Audit
+- Beads scoring 4+: N/N (target: 100%)
+- [list any beads that needed extra attention and why]
+
+### Beads Needing Human Input
+[List any beads where proposed ACs exceeded 30%, or where significant
+ambiguity in the plan made self-contained descriptions impossible.
+Include the specific open questions for each.]
+
+### Critical Path
+[blocker] → [blocked] → [blocked]
+
+### Ready to Start
+- bd-xxx: [Title] — [one-line summary of what agent will do]
+- bd-yyy: [Title] — [one-line summary of what agent will do]
+
+### Dependency Graph
+[Brief visualization or description of the dep structure]
+```
+
+## Risk Tiers
+
+| Operation | Tier | Behavior |
+|-----------|------|----------|
+| `br create` | SAFE | Auto-proceed |
+| `br dep add` | SAFE | Auto-proceed |
+| `br update --description` | CAUTION | Verify content |
+| Bulk creation (>20 beads) | CAUTION | Confirm count first |
+
+## Anti-Patterns
+
+| Anti-Pattern | Why it's bad | Fix |
+|-------------|-------------|-----|
+| "Implement the pipeline stage" | Agent doesn't know WHAT to implement | Name the types, the function signatures, the test |
+| "See plan for details" | Plan isn't available to the agent | Copy the relevant details INTO the bead |
+| "Files: probably src/foo/" | Agent wastes time finding the right file | Search the codebase, confirm exact paths |
+| "Should work correctly" | Not binary, not testable | "test_x passes" or "output matches Y" |
+| No TDD anchor | Agent doesn't know where to start | Always specify the first test to write |
+| "Depends on bd-xyz" (without context) | Agent doesn't know what bd-xyz provides | "Uses FooStruct and bar() function from bd-xyz" |
+| Single-line description | Score 1 bead, agent is stuck | Use the full template, every section |
+| Silently invented ACs | User surprised by implementation choices | Mark inferred ACs with [?], honor the 30% rule |
+```

plans/time-decay-expert-scoring.feedback-5.md

@@ -0,0 +1,128 @@
+**Best Revisions To Strengthen The Plan**
+
+1. **[Critical] Replace one-hop rename matching with canonical path identities**
+Analysis and rationale: Current `old_path OR new_path` fixes direct renames, but it still breaks on rename chains (`a.rs -> b.rs -> c.rs`) and split/move patterns. A canonical `path_identity` graph built from `mr_file_changes(old_path,new_path)` gives stable identity over time, which is the right architectural boundary for expertise history.
+```diff
+@@ ## Context
+-- Match both old and new paths in all signal queries AND path resolution probes so expertise survives file renames
++- Build canonical path identities from rename edges and score by identity, not raw path strings, so expertise survives multi-hop renames and moves
+
+@@ ## Files to Modify
+-2. **`src/cli/commands/who.rs`** — Core changes:
++2. **`src/cli/commands/who.rs`** — Core changes:
+    ...
+-   - Match both `new_path` and `old_path` in all signal queries (rename awareness)
++   - Resolve queried paths to `path_identity_id` and match all aliases in that identity set
++4. **`src/core/path_identity.rs`** — New module:
++   - Build/maintain rename graph from `mr_file_changes`
++   - Resolve path -> identity + aliases for probes/scoring
+```
+
+2. **[Critical] Shift scoring input from runtime CTE joins to a normalized `expertise_events` table**
+Analysis and rationale: Your SQL is correct but complex and expensive at query time. Precomputing normalized events at ingestion gives simpler, faster, and more reliable scoring queries; it also enables model versioning/backfills without touching raw MR/note tables each request.
+```diff
+@@ ## Files to Modify
+-3. **`src/core/db.rs`** — Add migration for indexes supporting the new query shapes
++3. **`src/core/db.rs`** — Add migrations for:
++   - `expertise_events` table (normalized scoring events)
++   - supporting indexes
++4. **`src/core/ingest/expertise_events.rs`** — New:
++   - Incremental upsert of events during sync/ingest
+
+@@ ## SQL Restructure (who.rs)
+-The SQL uses CTE-based dual-path matching and hybrid aggregation...
++Runtime SQL reads precomputed `expertise_events` filtered by path identity + time window.
++Heavy joins/aggregation move to ingest-time normalization.
+```
+
+3. **[High] Upgrade reviewer engagement model beyond char-count threshold**
+Analysis and rationale: `min_note_chars` is a useful guardrail but brittle (easy to game, penalizes concise high-quality comments). Add explicit review-state signals (`approved`, `changes_requested`) and trivial-comment pattern filtering to better capture real reviewer expertise.
+```diff
+@@ ## Scoring Formula
+-| **Reviewer Participated** (left DiffNote on MR/path) | 10 | 90 days |
++| **Reviewer Participated** (substantive DiffNote and/or formal review action) | 10 | 90 days |
++| **Review Decision: changes_requested** | 6 | 120 days |
++| **Review Decision: approved** | 4 | 75 days |
+
+@@ ### 1. ScoringConfig (config.rs)
+     pub reviewer_min_note_chars: u32,
++    pub reviewer_trivial_note_patterns: Vec<String>, // default: ["lgtm","+1","nit","ship it","👍"]
++    pub review_approved_weight: i64,                 // default: 4
++    pub review_changes_requested_weight: i64,        // default: 6
+```
+
+4. **[High] Make temporal semantics explicit and deterministic**
+Analysis and rationale: `--as-of` is good, but day parsing and boundary semantics can still cause subtle reproducibility issues. Define window as `[since_ms, as_of_ms)` and parse `YYYY-MM-DD` as end-of-day UTC (or explicit timezone) so user expectations match outputs.
+```diff
+@@ ### 5a. Reproducible Scoring via `--as-of`
+-- All event selection is bounded by `[since_ms, as_of_ms]`
++- All event selection is bounded by `[since_ms, as_of_ms)` (exclusive upper bound)
++- `YYYY-MM-DD` is interpreted as `23:59:59.999Z` unless `--timezone` is provided
++- Robot output includes `window_start_iso`, `window_end_iso`, `window_end_exclusive: true`
+```
+
+5. **[High] Replace fixed default `--since 24m` with contribution-floor auto cutoff**
+Analysis and rationale: A static window is simple but often over-scans data. Compute a model-derived horizon from a minimum contribution floor (for example `0.01` points) per signal; this keeps results equivalent while reducing query cost.
+```diff
+@@ ### 5. Default --since Change
+-Expert mode: `"6m"` -> `"24m"`
++Expert mode default: `--since auto`
++`auto` computes earliest relevant timestamp from configured weights/half-lives and `min_contribution_floor`
++Add config: `min_contribution_floor` (default: 0.01)
++`--since` still overrides, `--all-history` still bypasses cutoff
+```
+
+6. **[High] Add bot/service-account filtering now (not later)**
+Analysis and rationale: Bot activity can materially distort expertise rankings in real repos. This is low implementation cost with high quality gain and should be in v1 of the scoring revamp, not deferred.
+```diff
+@@ ### 1. ScoringConfig (config.rs)
++    pub excluded_username_patterns: Vec<String>, // default: ["bot","\\[bot\\]","service-account","ci-"]
+@@ ### 2. SQL Restructure (who.rs)
++Apply username exclusion in all signal sources unless `--include-bots` is set
+@@ ### 5b. Score Explainability via `--explain-score`
++Add `filtered_events` counts in robot output metadata
+```
+
+7. **[Medium] Enforce deterministic floating-point accumulation**
+Analysis and rationale: Even with small sets, unordered `HashMap` iteration can cause tiny platform-dependent ranking differences near ties. Sorting contributions and using Neumaier summation removes nondeterminism and stabilizes tests/CI.
+```diff
+@@ ### 4. Rust-Side Aggregation (who.rs)
+-Compute score as `f64`.
++Compute score as `f64` using deterministic contribution ordering:
++1) sort by (username, signal, mr_id, ts)
++2) sum with Neumaier compensation
++Tie-break remains `(raw_score DESC, last_seen DESC, username ASC)`
+```
+
+8. **[Medium] Strengthen explainability with evidence, not just totals**
+Analysis and rationale: Component totals help, but disputes usually need “why this user got this score now.” Add compact top evidence rows per component (`mr_id`, `ts`, `raw_contribution`) behind an optional mode.
+```diff
+@@ ### 5b. Score Explainability via `--explain-score`
+-Component breakdown only (4 floats per user).
++Add `--explain-score=summary|full`:
++`summary`: current 4-component totals
++`full`: adds top N evidence rows per component (default N=3)
++Robot output includes per-evidence `mr_id`, `signal`, `ts`, `contribution`
+```
+
+9. **[Medium] Make query plan strategy explicit: `UNION ALL` default for dual-path scans**
+Analysis and rationale: You currently treat `UNION ALL` as fallback if planner regresses. For SQLite, OR-across-indexed-columns regressions are common enough that defaulting to branch-split queries is often more predictable.
+```diff
+@@ **Index optimization fallback (UNION ALL split)**
+-Start with the simpler `OR` approach and only switch to `UNION ALL` if query plans confirm degradation.
++Use `UNION ALL` + dedup as default for dual-path matching.
++Keep `OR` variant as optional strategy flag for benchmarking/regression checks.
+```
+
+10. **[Medium] Add explicit performance SLO + benchmark gate**
+Analysis and rationale: This plan is query-heavy and ranking-critical; add measurable performance budgets so future edits do not silently degrade UX. Include synthetic fixture benchmarks for exact, prefix, and suffix path modes.
+```diff
+@@ ## Verification
++8. Performance regression gate:
++   - `cargo bench --bench who_expert_scoring`
++   - Dataset tiers: 100k, 1M, 5M notes
++   - SLOs: p95 exact path < 150ms, prefix < 250ms, suffix < 400ms on reference hardware
++   - Fail CI if regression > 20% vs stored baseline
+```
+
+If you want, I can produce a single consolidated “iteration 5” plan document with these changes already merged into your current structure.

plans/time-decay-expert-scoring.feedback-6.md

@@ -0,0 +1,134 @@
+I avoided everything already listed in your `Rejected Ideas` section and focused on net-new upgrades.
+
+1. Centralize MR temporal semantics in one `mr_activity` CTE (architecture + correctness)
+Why this improves the plan: right now the state-aware timestamp logic is repeated across multiple signal branches, while `closed_mr_multiplier` is applied later in Rust by string state checks. That split is brittle. A single `mr_activity` CTE removes drift risk, simplifies query maintenance, and avoids per-row state-string handling in Rust.
+
+```diff
+diff --git a/plan.md b/plan.md
+@@ SQL Restructure
++mr_activity AS (
++  SELECT
++    m.id AS mr_id,
++    m.project_id,
++    m.author_username,
++    m.state,
++    CASE
++      WHEN m.state = 'merged' THEN COALESCE(m.merged_at, m.created_at)
++      WHEN m.state = 'closed' THEN COALESCE(m.closed_at, m.created_at)
++      ELSE COALESCE(m.updated_at, m.created_at)
++    END AS activity_ts,
++    CASE
++      WHEN m.state = 'closed' THEN ?5
++      ELSE 1.0
++    END AS state_mult
++  FROM merge_requests m
++  WHERE m.state IN ('opened','merged','closed')
++),
+@@
+-... {state_aware_ts} AS seen_at, m.state AS mr_state
++... a.activity_ts AS seen_at, a.state_mult
+@@
+-SELECT username, signal, mr_id, qty, ts, mr_state FROM aggregated
++SELECT username, signal, mr_id, qty, ts, state_mult FROM aggregated
+```
+
+2. Parameterize `reviewer_min_note_chars` and tighten config validation (robustness)
+Why this improves the plan: inlining `reviewer_min_note_chars` into SQL text creates statement-cache churn and avoidable SQL-text variability. Also, current validation misses finite-range guards (`NaN`, absurd half-lives). Parameterization + stronger validation reduces weird failure modes.
+
+```diff
+diff --git a/plan.md b/plan.md
+@@ 1. ScoringConfig (config.rs)
+- reviewer_min_note_chars must be >= 0
++ reviewer_min_note_chars must be <= 4096
++ all half-life values must be <= 3650 (10 years safety cap)
++ closed_mr_multiplier must be finite and in (0.0, 1.0]
+@@ SQL Restructure
+-AND LENGTH(TRIM(COALESCE(n_body.body, ''))) >= {reviewer_min_note_chars}
++AND LENGTH(TRIM(COALESCE(n_body.body, ''))) >= ?6
+```
+
+3. Add path canonicalization before probes/scoring (correctness + UX)
+Why this improves the plan: rename-awareness helps only after path resolution succeeds. Inputs like `./src//foo.rs` or inconsistent trailing slashes can still miss. Canonicalizing query paths up front reduces false negatives and ambiguous suffix behavior.
+
+```diff
+diff --git a/plan.md b/plan.md
+@@ 3a. Path Resolution Probes (who.rs)
++Add `normalize_query_path()` before `build_path_query()`:
++- strip leading `./`
++- collapse repeated `/`
++- trim whitespace
++- preserve trailing `/` only for explicit prefix intent
++Expose both `path_input_original` and `path_input_normalized` in `resolved_input`.
+@@ New Tests
++test_path_normalization_handles_dot_and_double_slash
++test_path_normalization_preserves_explicit_prefix_semantics
+```
+
+4. Add epsilon-based tie buckets for stable ranking (determinism)
+Why this improves the plan: even with deterministic summation order, tiny `powf` platform differences can reorder near-equal scores. Tie bucketing keeps ordering stable and user-meaningful.
+
+```diff
+diff --git a/plan.md b/plan.md
+@@ 4. Rust-Side Aggregation (who.rs)
+-Sort on raw `f64` score — `(raw_score DESC, last_seen DESC, username ASC)`.
++Sort using a tie bucket:
++`score_bucket = (raw_score / 1e-9).floor() as i64`
++Order by `(score_bucket DESC, raw_score DESC, last_seen DESC, username ASC)`.
++This preserves precision while preventing meaningless micro-delta reorderings.
+@@ New Tests
++test_near_equal_scores_use_stable_tie_bucket_order
+```
+
+5. Add `--diagnose-score` aggregated diagnostics (operability)
+Why this improves the plan: `--explain-score` tells “why this user scored”, but not “why this query behaved oddly” (path ambiguity, dedup collapse, old_path contribution share, filtered bots, window exclusions). Lightweight aggregate diagnostics are high-value without per-MR drill-down complexity.
+
+```diff
+diff --git a/plan.md b/plan.md
+@@ CLI changes (who.rs)
++Add `--diagnose-score` flag (compatible with `--explain-score`, incompatible with `--detail`).
++When enabled, include:
++- matched_notes_raw_count
++- matched_notes_dedup_count
++- matched_file_changes_raw_count
++- matched_file_changes_dedup_count
++- rows_excluded_by_window_upper_bound
++- users_filtered_by_excluded_usernames
++- query_elapsed_ms
+@@ Robot output
++`diagnostics` object emitted only when `--diagnose-score` is set.
+```
+
+6. Add probe-optimized indexes for path resolution (performance)
+Why this improves the plan: current proposed indexes are optimized for scoring joins, but `build_path_query()` and `suffix_probe()` run existence/path-only probes where `author_username` is not constrained. Dedicated probe indexes will materially reduce latency for path lookup modes.
+
+```diff
+diff --git a/plan.md b/plan.md
+@@ 6. Index Migration (db.rs)
++-- Fast exact/prefix/suffix path probes on notes (no author predicate)
++CREATE INDEX IF NOT EXISTS idx_notes_new_path_project_created
++  ON notes(position_new_path, project_id, created_at)
++  WHERE note_type = 'DiffNote' AND is_system = 0 AND position_new_path IS NOT NULL;
++
++CREATE INDEX IF NOT EXISTS idx_notes_old_path_project_created
++  ON notes(position_old_path, project_id, created_at)
++  WHERE note_type = 'DiffNote' AND is_system = 0 AND position_old_path IS NOT NULL;
+```
+
+7. Add multi-path expert scoring (`--path` repeatable) with dedup across paths (feature + utility)
+Why this improves the plan: current model is single-path centric. Real ownership questions are usually subsystem-level. Repeatable paths/prefixes let users ask “who knows auth stack?” in one call. Dedup by `(username, signal, mr_id)` avoids double-counting same MR touching multiple requested paths.
+
+```diff
+diff --git a/plan.md b/plan.md
+@@ CLI/feature scope
++Add repeatable `--path` in expert mode:
++`lore who --expert --path src/auth/ --path src/session/`
++Optional `--path-file <file>` for large path sets (one per line).
+@@ SQL Restructure
++Add `requested_paths` CTE and match each source against that set.
++Ensure dedup key includes `(username, signal, mr_id)` so one MR contributes once per signal even if multiple paths match.
+@@ New Tests
++test_multi_path_query_unions_results_without_double_counting
++test_multi_path_with_overlap_prefixes_is_idempotent
+```
+
+These 7 revisions keep your current model direction intact, but reduce correctness drift risk, harden edge handling, improve query observability, and make the feature materially more useful for real ownership workflows.

plans/time-decay-expert-scoring.md

@@ -2,12 +2,12 @@
 plan: true
 title: ""
 status: iterating
-iteration: 4
+iteration: 6
 target_iterations: 8
-beads_revision: 0
+beads_revision: 1
 related_plans: []
 created: 2026-02-08
-updated: 2026-02-08
+updated: 2026-02-12
 ---
 
 # Time-Decay Expert Scoring Model
@@ -70,7 +70,8 @@ Author/reviewer signals are deduplicated per MR (one signal per distinct MR). No
 1. **`src/core/config.rs`** — Add half-life fields + assigned-only reviewer config to `ScoringConfig`; add config validation
 2. **`src/cli/commands/who.rs`** — Core changes:
    - Add `half_life_decay()` pure function
-   - Restructure `query_expert()`: SQL returns hybrid-aggregated signal rows with timestamps (MR-level for author/reviewer, note-count-per-MR for notes), Rust applies decay + `log2(1+count)` + final ranking
+   - Add `normalize_query_path()` for input canonicalization before path resolution
+   - Restructure `query_expert()`: SQL returns hybrid-aggregated signal rows with timestamps and state multiplier (MR-level for author/reviewer, note-count-per-MR for notes), Rust applies decay + `log2(1+count)` + final ranking
    - Match both `new_path` and `old_path` in all signal queries (rename awareness)
    - Extend rename awareness to `build_path_query()` probes and `suffix_probe()` (not just scoring)
    - Split reviewer signal into participated vs assigned-only
@@ -78,6 +79,7 @@ Author/reviewer signals are deduplicated per MR (one signal per distinct MR). No
    - Change default `--since` from `"6m"` to `"24m"` (2 years captures all meaningful decayed signals)
    - Add `--as-of` flag for reproducible scoring at a fixed timestamp
    - Add `--explain-score` flag for per-user score component breakdown
+   - Add `--include-bots` flag to disable bot/service-account filtering
    - Sort on raw f64 score, round only for display
    - Update tests
 3. **`src/core/db.rs`** — Add migration for indexes supporting the new query shapes (dual-path matching, reviewer participation CTE, path resolution probes)
@@ -100,14 +102,16 @@ pub struct ScoringConfig {
     pub note_half_life_days: u32,              // default: 45
     pub closed_mr_multiplier: f64,             // default: 0.5  (applied to closed-without-merge MRs)
     pub reviewer_min_note_chars: u32,          // default: 20   (minimum note body length to count as participation)
+    pub excluded_usernames: Vec<String>,       // default: []    (exact-match usernames to exclude, e.g. ["renovate-bot", "gitlab-ci"])
 }
 ```
 
 **Config validation**: Add a `validate_scoring()` call in `Config::load_from_path()` after deserialization:
-- All `*_half_life_days` must be > 0 (prevents division by zero in decay function)
+- All `*_half_life_days` must be > 0 and <= 3650 (prevents division by zero in decay function; rejects absurd 10+ year half-lives that would effectively disable decay)
 - All `*_weight` / `*_bonus` must be >= 0 (negative weights produce nonsensical scores)
-- `closed_mr_multiplier` must be in `(0.0, 1.0]` (0 would discard closed MRs entirely; >1 would over-weight them)
-- `reviewer_min_note_chars` must be >= 0 (0 disables the filter; typical useful values: 10-50)
+- `closed_mr_multiplier` must be finite (not NaN/Inf) and in `(0.0, 1.0]` (0 would discard closed MRs entirely; >1 would over-weight them; NaN/Inf would propagate through all scores)
+- `reviewer_min_note_chars` must be >= 0 and <= 4096 (0 disables the filter; 4096 is a sane upper bound — no real review comment needs to be longer to qualify; typical useful values: 10-50)
+- `excluded_usernames` entries must be non-empty strings (no blank entries)
 - Return `LoreError::ConfigInvalid` with a clear message on failure
 
 ### 2. Decay Function (who.rs)
@@ -123,30 +127,74 @@ fn half_life_decay(elapsed_ms: i64, half_life_days: u32) -> f64 {
 
 ### 3. SQL Restructure (who.rs)
 
-The SQL uses **CTE-based dual-path matching** and **hybrid aggregation**. Rather than repeating `OR old_path` in every signal subquery, two foundational CTEs (`matched_notes`, `matched_file_changes`) centralize path matching. A third CTE (`reviewer_participation`) precomputes which reviewers actually left DiffNotes, avoiding correlated `EXISTS`/`NOT EXISTS` subqueries.
+The SQL uses **CTE-based dual-path matching**, a **centralized `mr_activity` CTE**, and **hybrid aggregation**. Rather than repeating `OR old_path` in every signal subquery, two foundational CTEs (`matched_notes`, `matched_file_changes`) centralize path matching. A `mr_activity` CTE centralizes the state-aware timestamp and state multiplier in one place, eliminating repetition of the CASE expression across signals 3, 4a, 4b. A fourth CTE (`reviewer_participation`) precomputes which reviewers actually left DiffNotes, avoiding correlated `EXISTS`/`NOT EXISTS` subqueries.
 
-MR-level signals return one row per (username, signal, mr_id) with a timestamp; note signals return one row per (username, mr_id) with `note_count` and `max_ts`. This keeps row counts bounded (dozens to low hundreds per path) while giving Rust the data it needs for decay and `log2(1+count)`.
+MR-level signals return one row per (username, signal, mr_id) with a timestamp and state multiplier; note signals return one row per (username, mr_id) with `note_count` and `max_ts`. This keeps row counts bounded (dozens to low hundreds per path) while giving Rust the data it needs for decay and `log2(1+count)`.
 
 ```sql
-WITH matched_notes AS (
-  -- Centralize dual-path matching for DiffNotes
-  SELECT n.id, n.discussion_id, n.author_username, n.created_at,
-         n.position_new_path, n.position_old_path, n.project_id
+WITH matched_notes_raw AS (
+  -- Branch 1: match on new_path (uses idx_notes_new_path or equivalent)
+  SELECT n.id, n.discussion_id, n.author_username, n.created_at, n.project_id
   FROM notes n
   WHERE n.note_type = 'DiffNote'
     AND n.is_system = 0
     AND n.author_username IS NOT NULL
     AND n.created_at >= ?2
-    AND n.created_at <= ?4
+    AND n.created_at < ?4
     AND (?3 IS NULL OR n.project_id = ?3)
-    AND (n.position_new_path {path_op} OR n.position_old_path {path_op})
+    AND n.position_new_path {path_op}
+  UNION ALL
+  -- Branch 2: match on old_path (uses idx_notes_old_path_author)
+  SELECT n.id, n.discussion_id, n.author_username, n.created_at, n.project_id
+  FROM notes n
+  WHERE n.note_type = 'DiffNote'
+    AND n.is_system = 0
+    AND n.author_username IS NOT NULL
+    AND n.created_at >= ?2
+    AND n.created_at < ?4
+    AND (?3 IS NULL OR n.project_id = ?3)
+    AND n.position_old_path {path_op}
 ),
-matched_file_changes AS (
-  -- Centralize dual-path matching for file changes
+matched_notes AS (
+  -- Dedup: prevent double-counting when old_path = new_path (no rename)
+  SELECT DISTINCT id, discussion_id, author_username, created_at, project_id
+  FROM matched_notes_raw
+),
+matched_file_changes_raw AS (
+  -- Branch 1: match on new_path (uses idx_mfc_new_path_project_mr)
   SELECT fc.merge_request_id, fc.project_id
   FROM mr_file_changes fc
   WHERE (?3 IS NULL OR fc.project_id = ?3)
-    AND (fc.new_path {path_op} OR fc.old_path {path_op})
+    AND fc.new_path {path_op}
+  UNION ALL
+  -- Branch 2: match on old_path (uses idx_mfc_old_path_project_mr)
+  SELECT fc.merge_request_id, fc.project_id
+  FROM mr_file_changes fc
+  WHERE (?3 IS NULL OR fc.project_id = ?3)
+    AND fc.old_path {path_op}
+),
+matched_file_changes AS (
+  -- Dedup: prevent double-counting when old_path = new_path (no rename)
+  SELECT DISTINCT merge_request_id, project_id
+  FROM matched_file_changes_raw
+),
+mr_activity AS (
+  -- Centralized state-aware timestamps and state multiplier.
+  -- Defined once, referenced by all file-change-based signals (3, 4a, 4b).
+  -- Scoped to MRs matched by file changes to avoid materializing the full MR table.
+  SELECT DISTINCT
+    m.id AS mr_id,
+    m.author_username,
+    m.state,
+    CASE
+      WHEN m.state = 'merged' THEN COALESCE(m.merged_at, m.created_at)
+      WHEN m.state = 'closed' THEN COALESCE(m.closed_at, m.created_at)
+      ELSE COALESCE(m.updated_at, m.created_at)
+    END AS activity_ts,
+    CASE WHEN m.state = 'closed' THEN ?5 ELSE 1.0 END AS state_mult
+  FROM merge_requests m
+  JOIN matched_file_changes mfc ON mfc.merge_request_id = m.id
+  WHERE m.state IN ('opened','merged','closed')
 ),
 reviewer_participation AS (
   -- Precompute which (mr_id, username) pairs have substantive DiffNote participation.
@@ -156,17 +204,20 @@ reviewer_participation AS (
   -- reviewer from 3-point to 10-point weight, defeating the purpose of the split.
   -- Note: mn.id refers back to notes.id, so we join notes to access the body column
   -- (not carried in matched_notes to avoid bloating that CTE with body text).
+  -- ?6 is the configured reviewer_min_note_chars value (default 20).
   SELECT DISTINCT d.merge_request_id AS mr_id, mn.author_username AS username
   FROM matched_notes mn
   JOIN discussions d ON mn.discussion_id = d.id
   JOIN notes n_body ON mn.id = n_body.id
   WHERE d.merge_request_id IS NOT NULL
-    AND LENGTH(TRIM(COALESCE(n_body.body, ''))) >= {reviewer_min_note_chars}
+    AND LENGTH(TRIM(COALESCE(n_body.body, ''))) >= ?6
 ),
 raw AS (
   -- Signal 1: DiffNote reviewer (individual notes for note_cnt)
+  -- Computes state_mult inline (not via mr_activity) because this joins through discussions, not file changes.
   SELECT mn.author_username AS username, 'diffnote_reviewer' AS signal,
-         m.id AS mr_id, mn.id AS note_id, mn.created_at AS seen_at, m.state AS mr_state
+         m.id AS mr_id, mn.id AS note_id, mn.created_at AS seen_at,
+         CASE WHEN m.state = 'closed' THEN ?5 ELSE 1.0 END AS state_mult
   FROM matched_notes mn
   JOIN discussions d ON mn.discussion_id = d.id
   JOIN merge_requests m ON d.merge_request_id = m.id
@@ -176,8 +227,10 @@ raw AS (
   UNION ALL
 
   -- Signal 2: DiffNote MR author
+  -- Computes state_mult inline (same reason as signal 1).
   SELECT m.author_username AS username, 'diffnote_author' AS signal,
-         m.id AS mr_id, NULL AS note_id, MAX(mn.created_at) AS seen_at, m.state AS mr_state
+         m.id AS mr_id, NULL AS note_id, MAX(mn.created_at) AS seen_at,
+         CASE WHEN m.state = 'closed' THEN ?5 ELSE 1.0 END AS state_mult
   FROM merge_requests m
   JOIN discussions d ON d.merge_request_id = m.id
   JOIN matched_notes mn ON mn.discussion_id = d.id
@@ -187,69 +240,63 @@ raw AS (
 
   UNION ALL
 
-  -- Signal 3: MR author via file changes (state-aware timestamp)
-  SELECT m.author_username AS username, 'file_author' AS signal,
-         m.id AS mr_id, NULL AS note_id,
-         {state_aware_ts} AS seen_at, m.state AS mr_state
-  FROM matched_file_changes mfc
-  JOIN merge_requests m ON mfc.merge_request_id = m.id
-  WHERE m.author_username IS NOT NULL
-    AND m.state IN ('opened','merged','closed')
-    AND {state_aware_ts} >= ?2
-    AND {state_aware_ts} <= ?4
+  -- Signal 3: MR author via file changes (uses mr_activity CTE for timestamp + state_mult)
+  SELECT a.author_username AS username, 'file_author' AS signal,
+         a.mr_id, NULL AS note_id,
+         a.activity_ts AS seen_at, a.state_mult
+  FROM mr_activity a
+  WHERE a.author_username IS NOT NULL
+    AND a.activity_ts >= ?2
+    AND a.activity_ts < ?4
 
   UNION ALL
 
   -- Signal 4a: Reviewer participated (in mr_reviewers AND left DiffNotes on path)
   SELECT r.username AS username, 'file_reviewer_participated' AS signal,
-         m.id AS mr_id, NULL AS note_id,
-         {state_aware_ts} AS seen_at, m.state AS mr_state
-  FROM matched_file_changes mfc
-  JOIN merge_requests m ON mfc.merge_request_id = m.id
-  JOIN mr_reviewers r ON r.merge_request_id = m.id
-  JOIN reviewer_participation rp ON rp.mr_id = m.id AND rp.username = r.username
+         a.mr_id, NULL AS note_id,
+         a.activity_ts AS seen_at, a.state_mult
+  FROM mr_activity a
+  JOIN mr_reviewers r ON r.merge_request_id = a.mr_id
+  JOIN reviewer_participation rp ON rp.mr_id = a.mr_id AND rp.username = r.username
   WHERE r.username IS NOT NULL
-    AND (m.author_username IS NULL OR r.username != m.author_username)
-    AND m.state IN ('opened','merged','closed')
-    AND {state_aware_ts} >= ?2
-    AND {state_aware_ts} <= ?4
+    AND (a.author_username IS NULL OR r.username != a.author_username)
+    AND a.activity_ts >= ?2
+    AND a.activity_ts < ?4
 
   UNION ALL
 
   -- Signal 4b: Reviewer assigned-only (in mr_reviewers, NO DiffNotes on path)
   SELECT r.username AS username, 'file_reviewer_assigned' AS signal,
-         m.id AS mr_id, NULL AS note_id,
-         {state_aware_ts} AS seen_at, m.state AS mr_state
-  FROM matched_file_changes mfc
-  JOIN merge_requests m ON mfc.merge_request_id = m.id
-  JOIN mr_reviewers r ON r.merge_request_id = m.id
-  LEFT JOIN reviewer_participation rp ON rp.mr_id = m.id AND rp.username = r.username
+         a.mr_id, NULL AS note_id,
+         a.activity_ts AS seen_at, a.state_mult
+  FROM mr_activity a
+  JOIN mr_reviewers r ON r.merge_request_id = a.mr_id
+  LEFT JOIN reviewer_participation rp ON rp.mr_id = a.mr_id AND rp.username = r.username
   WHERE rp.username IS NULL  -- NOT in participation set
     AND r.username IS NOT NULL
-    AND (m.author_username IS NULL OR r.username != m.author_username)
-    AND m.state IN ('opened','merged','closed')
-    AND {state_aware_ts} >= ?2
-    AND {state_aware_ts} <= ?4
+    AND (a.author_username IS NULL OR r.username != a.author_username)
+    AND a.activity_ts >= ?2
+    AND a.activity_ts < ?4
 ),
 aggregated AS (
   -- MR-level signals: 1 row per (username, signal_class, mr_id) with MAX(ts)
-  SELECT username, signal, mr_id, 1 AS qty, MAX(seen_at) AS ts, mr_state
+  SELECT username, signal, mr_id, 1 AS qty, MAX(seen_at) AS ts, MAX(state_mult) AS state_mult
   FROM raw WHERE signal != 'diffnote_reviewer'
   GROUP BY username, signal, mr_id
   UNION ALL
   -- Note signals: 1 row per (username, mr_id) with note_count and max_ts
-  SELECT username, 'note_group' AS signal, mr_id, COUNT(*) AS qty, MAX(seen_at) AS ts, mr_state
+  SELECT username, 'note_group' AS signal, mr_id, COUNT(*) AS qty, MAX(seen_at) AS ts, MAX(state_mult) AS state_mult
   FROM raw WHERE signal = 'diffnote_reviewer' AND note_id IS NOT NULL
   GROUP BY username, mr_id
 )
-SELECT username, signal, mr_id, qty, ts, mr_state FROM aggregated WHERE username IS NOT NULL
+SELECT username, signal, mr_id, qty, ts, state_mult FROM aggregated WHERE username IS NOT NULL
 ```
 
-Where `{state_aware_ts}` is the state-aware timestamp expression (defined in the next section), `{path_op}` is either `= ?1` or `LIKE ?1 ESCAPE '\\'` depending on the path query type, `?4` is the `as_of_ms` upper bound (defaults to `now_ms` when `--as-of` is not specified), and `{reviewer_min_note_chars}` is the configured `reviewer_min_note_chars` value (default 20, inlined as a literal in the SQL string). The `BETWEEN ?2 AND ?4` pattern ensures that when `--as-of` is set to a past date, events after that date are excluded — without this, "future" events would leak in with full weight, breaking reproducibility.
+Where `{path_op}` is either `= ?1` or `LIKE ?1 ESCAPE '\\'` depending on the path query type, `?2` is `since_ms`, `?3` is the optional project_id, `?4` is the `as_of_ms` exclusive upper bound (defaults to `now_ms` when `--as-of` is not specified), `?5` is the `closed_mr_multiplier` (default 0.5, bound as a parameter), and `?6` is the configured `reviewer_min_note_chars` value (default 20, bound as a parameter). The `>= ?2 AND < ?4` pattern (half-open interval) ensures that when `--as-of` is set to a past date, events at or after that date are excluded — without this, "future" events would leak in with full weight, breaking reproducibility. The exclusive upper bound avoids edge-case ambiguity when events have timestamps exactly equal to the as-of value.
 
-**Rationale for CTE-based dual-path matching**: The previous approach (repeating `OR old_path` in every signal subquery) duplicated the path matching logic 5 times. Factoring it into `matched_notes` and `matched_file_changes` CTEs means path matching is defined once, the indexes are hit once, and adding future path resolution logic (e.g., alias chains) only requires changes in one place.
+**Rationale for CTE-based dual-path matching**: The previous approach (repeating `OR old_path` in every signal subquery) duplicated the path matching logic 5 times. Factoring it into foundational CTEs (`matched_notes_raw` → `matched_notes`, `matched_file_changes_raw` → `matched_file_changes`) means path matching is defined once, each index branch is explicit, and adding future path resolution logic (e.g., alias chains) only requires changes in one place. The UNION ALL + dedup pattern ensures SQLite uses the optimal index for each path column independently.
 
-**Index optimization fallback (UNION ALL split)**: SQLite's query planner sometimes struggles with `OR` across two indexed columns, falling back to a full table scan instead of using either index. If EXPLAIN QUERY PLAN shows this during step 6 verification, replace the `OR`-based CTEs with a `UNION ALL` split + dedup pattern:
+**Dual-path matching strategy (UNION ALL split)**: SQLite's query planner commonly struggles with `OR` across two indexed columns, falling back to a full table scan instead of using either index. Rather than starting with `OR` and hoping the planner cooperates, use `UNION ALL` + dedup as the default strategy:
 ```sql
 matched_notes AS (
   SELECT ... FROM notes n WHERE ... AND n.position_new_path {path_op}
@@ -261,25 +308,39 @@ matched_notes_dedup AS (
   FROM matched_notes
 ),
 ```
-This ensures each branch can use its respective index independently. The dedup CTE prevents double-counting when `old_path = new_path` (no rename). Start with the simpler `OR` approach and only switch to `UNION ALL` if query plans confirm the degradation.
+This ensures each branch can use its respective index independently. The dedup CTE prevents double-counting when `old_path = new_path` (no rename). The same pattern applies to `matched_file_changes`. The simpler `OR` variant is retained as a comment for benchmarking — if a future SQLite version handles `OR` well, the split can be collapsed.
 
 **Rationale for precomputed participation set**: The previous approach used correlated `EXISTS`/`NOT EXISTS` subqueries to classify reviewers. The `reviewer_participation` CTE materializes the set of `(mr_id, username)` pairs from matched DiffNotes once, then signal 4a JOINs against it (participated) and signal 4b LEFT JOINs with `IS NULL` (assigned-only). This avoids per-reviewer-row correlated scans, is easier to reason about, and produces the same exhaustive split — every `mr_reviewers` row falls into exactly one bucket.
 
 **Rationale for hybrid over fully-raw**: Pre-aggregating note counts in SQL prevents row explosion from heavy DiffNote volume on frequently-discussed paths. MR-level signals are already 1-per-MR by nature (deduped via GROUP BY in each subquery). This keeps memory and latency predictable regardless of review activity density.
 
-**Path rename awareness**: Both `matched_notes` and `matched_file_changes` CTEs match against both old and new path columns:
+**Path rename awareness**: Both `matched_notes` and `matched_file_changes` use UNION ALL + dedup to match against both old and new path columns independently, ensuring each branch uses its respective index:
 
-- Notes: `(n.position_new_path {path_op} OR n.position_old_path {path_op})`
-- File changes: `(fc.new_path {path_op} OR fc.old_path {path_op})`
+- Notes: branch 1 matches `position_new_path`, branch 2 matches `position_old_path`, deduped by `notes.id`
+- File changes: branch 1 matches `new_path`, branch 2 matches `old_path`, deduped by `(merge_request_id, project_id)`
 
-Both columns already exist in the schema (`notes.position_old_path` from migration 002, `mr_file_changes.old_path` from migration 016). The `OR` match ensures expertise is credited even when a file was renamed after the work was done. For prefix queries (`--path src/foo/`), the `LIKE` operator applies to both columns identically.
+Both columns already exist in the schema (`notes.position_old_path` from migration 002, `mr_file_changes.old_path` from migration 016). The UNION ALL approach ensures expertise is credited even when a file was renamed after the work was done. For prefix queries (`--path src/foo/`), the `LIKE` operator applies to both columns identically.
 
 **Signal 4 splits into two**: The current signal 4 (`file_reviewer`) joins `mr_reviewers` but doesn't distinguish participation. In the new plan:
 
 - **Signal 4a** (`file_reviewer_participated`): User is in `mr_reviewers` AND appears in the `reviewer_participation` CTE (left DiffNotes on the path for that MR). Gets `reviewer_weight` (10) and `reviewer_half_life_days` (90).
 - **Signal 4b** (`file_reviewer_assigned`): User is in `mr_reviewers` but NOT in the `reviewer_participation` CTE. Gets `reviewer_assignment_weight` (3) and `reviewer_assignment_half_life_days` (45).
 
-### 3a. Path Resolution Probes (who.rs)
+**Rationale for `mr_activity` CTE**: The previous approach repeated the state-aware CASE expression and `m.state` column in signals 3, 4a, and 4b, with the `closed_mr_multiplier` applied later in Rust by string-matching on `mr_state`. This split was brittle — the CASE expression could drift between signal branches, and per-row state-string handling in Rust was unnecessary indirection. The `mr_activity` CTE defines the timestamp and multiplier once, scoped to matched MRs only (via JOIN with `matched_file_changes`) to avoid materializing the full MR table. Signals 3, 4a, 4b now reference `a.activity_ts` and `a.state_mult` directly. Signals 1 and 2 (DiffNote-based) still compute `state_mult` inline because they join through `discussions`, not `matched_file_changes`, and adding them to `mr_activity` would require a second join path that doesn't simplify anything.
+
+**Rationale for parameterized `reviewer_min_note_chars` and `closed_mr_multiplier`**: Previous iterations inlined `reviewer_min_note_chars` as a literal in the SQL string and kept `closed_mr_multiplier` in Rust only. Binding both as SQL parameters (`?5` for `closed_mr_multiplier`, `?6` for `reviewer_min_note_chars`) eliminates statement-cache churn (the SQL text is identical regardless of config values), avoids SQL-text variability that complicates EXPLAIN QUERY PLAN analysis, and centralizes the multiplier application in SQL for file-change signals. The DiffNote signals (1, 2) still compute `state_mult` inline because they don't go through `mr_activity`.
+
+### 3a. Path Canonicalization and Resolution Probes (who.rs)
+
+**Path canonicalization**: Before any path resolution or scoring, normalize the user's input path via `normalize_query_path()`:
+- Strip leading `./` (e.g., `./src/foo.rs` → `src/foo.rs`)
+- Collapse repeated `/` (e.g., `src//foo.rs` → `src/foo.rs`)
+- Trim leading/trailing whitespace
+- Preserve trailing `/` only when present — it signals explicit prefix intent
+
+This is applied once at the top of `run_who()` before `build_path_query()`. The robot JSON `resolved_input` includes both `path_input_original` (raw user input) and `path_input_normalized` (after canonicalization) for debugging transparency. The normalization is purely syntactic — no filesystem lookups, no canonicalization against the database.
+
+**Path resolution probes**: Rename awareness must extend beyond scoring queries to the path resolution layer. Currently `build_path_query()` (line 457) and `suffix_probe()` (line 584) only check `position_new_path` and `new_path`. If a user queries an old path name, these probes return "not found" and the scoring query never runs.
 
 Rename awareness must extend beyond scoring queries to the path resolution layer. Currently `build_path_query()` (line 457) and `suffix_probe()` (line 584) only check `position_new_path` and `new_path`. If a user queries an old path name, these probes return "not found" and the scoring query never runs.
 
@@ -308,39 +369,29 @@ WHERE old_path IS NOT NULL
 
 This ensures that querying by an old filename (e.g., `login.rs` after it was renamed to `auth.rs`) still resolves to a usable path for scoring. The UNION deduplicates so the same path appearing in both old and new columns doesn't cause false ambiguity.
 
-**State-aware timestamps for file-change signals (signals 3, 4a, 4b)**: Replace `m.updated_at` with a state-aware expression:
-
-```sql
-CASE
-  WHEN m.state = 'merged' THEN COALESCE(m.merged_at, m.created_at)
-  WHEN m.state = 'closed' THEN COALESCE(m.closed_at, m.created_at)
-  ELSE COALESCE(m.updated_at, m.created_at)  -- opened / other
-END AS activity_ts
-```
+**State-aware timestamps for file-change signals (signals 3, 4a, 4b)**: Centralized in the `mr_activity` CTE (see section 3). The CASE expression uses `merged_at` for merged MRs, `closed_at` for closed MRs, and `updated_at` for open MRs, with `created_at` as fallback when the preferred timestamp is NULL.
 
 **Rationale**: `updated_at` is noisy for merged MRs — it changes on label edits, title changes, rebases, and metadata touches, creating false recency. `merged_at` is the best indicator of when code expertise was formed (the moment the code entered the branch). But for **open MRs**, `updated_at` is actually the right signal because it reflects ongoing active work. `closed_at` anchors closed-without-merge MRs to their closure time (these represent review effort even if the code was abandoned). Each state gets the timestamp that best represents when expertise was last exercised.
 
 ### 4. Rust-Side Aggregation (who.rs)
 
 For each username, accumulate into a struct with:
-- **Author MRs**: `HashMap<i64, (i64, String)>` (mr_id -> (max timestamp, mr_state)) from `diffnote_author` + `file_author` signals
-- **Reviewer Participated MRs**: `HashMap<i64, (i64, String)>` from `diffnote_reviewer` + `file_reviewer_participated` signals
-- **Reviewer Assigned-Only MRs**: `HashMap<i64, (i64, String)>` from `file_reviewer_assigned` signals (excluding any MR already in participated set)
-- **Notes per MR**: `HashMap<i64, (u32, i64, String)>` (mr_id -> (count, max_ts, mr_state)) from `note_group` rows in the aggregated query (already grouped per user+MR with note_count in `qty`). Used for `log2(1 + count)` diminishing returns.
+- **Author MRs**: `HashMap<i64, (i64, f64)>` (mr_id -> (max timestamp, state_mult)) from `diffnote_author` + `file_author` signals
+- **Reviewer Participated MRs**: `HashMap<i64, (i64, f64)>` from `diffnote_reviewer` + `file_reviewer_participated` signals
+- **Reviewer Assigned-Only MRs**: `HashMap<i64, (i64, f64)>` from `file_reviewer_assigned` signals (excluding any MR already in participated set)
+- **Notes per MR**: `HashMap<i64, (u32, i64, f64)>` (mr_id -> (count, max_ts, state_mult)) from `note_group` rows in the aggregated query (already grouped per user+MR with note_count in `qty`). Used for `log2(1 + count)` diminishing returns.
 - **Last seen**: max of all timestamps
 - **Components** (when `--explain-score`): Track per-component f64 subtotals for `author`, `reviewer_participated`, `reviewer_assigned`, `notes`
 
-The `mr_state` field from each SQL row is stored alongside the timestamp so the Rust-side can apply `closed_mr_multiplier` when `mr_state == "closed"`.
+The `state_mult` field from each SQL row (already computed in SQL as 1.0 for merged/open or `closed_mr_multiplier` for closed) is stored alongside the timestamp — no string-matching on MR state needed in Rust.
 
-Compute score as `f64`. Each MR-level contribution is multiplied by `closed_mr_multiplier` (default 0.5) when the MR's state is `"closed"`:
+Compute score as `f64` with **deterministic contribution ordering**: within each signal type, sort contributions by `(mr_id ASC)` before summing. This eliminates platform-dependent HashMap iteration order as a source of f64 rounding variance near ties, ensuring CI reproducibility without the complexity of compensated summation (Neumaier/Kahan). Each MR-level contribution is multiplied by its `state_mult` (already computed in SQL):
 ```
-state_mult(mr) = if mr.state == "closed" { closed_mr_multiplier } else { 1.0 }
-
 raw_score =
-    sum(author_weight * state_mult(mr) * decay(now - ts, author_hl) for (mr, ts) in author_mrs)
-  + sum(reviewer_weight * state_mult(mr) * decay(now - ts, reviewer_hl) for (mr, ts) in reviewer_participated)
-  + sum(reviewer_assignment_weight * state_mult(mr) * decay(now - ts, reviewer_assignment_hl) for (mr, ts) in reviewer_assigned)
-  + sum(note_bonus * state_mult(mr) * log2(1 + count) * decay(now - ts, note_hl) for (mr, count, ts) in notes_per_mr)
+    sum(author_weight * state_mult * decay(now - ts, author_hl) for (mr, ts, state_mult) in author_mrs)
+  + sum(reviewer_weight * state_mult * decay(now - ts, reviewer_hl) for (mr, ts, state_mult) in reviewer_participated)
+  + sum(reviewer_assignment_weight * state_mult * decay(now - ts, reviewer_assignment_hl) for (mr, ts, state_mult) in reviewer_assigned)
+  + sum(note_bonus * state_mult * log2(1 + count) * decay(now - ts, note_hl) for (mr, count, ts, state_mult) in notes_per_mr)
 ```
 
 **Why include closed MRs?** A closed-without-merge MR still represents review effort and code familiarity — the reviewer read the diff, left comments, and engaged with the code even though it was ultimately abandoned. Excluding closed MRs entirely (the previous plan's approach) discarded this signal. The `closed_mr_multiplier` (default 0.5) halves the contribution, reflecting that the code never landed but the reviewer's cognitive engagement was real. This also eliminates the dead-code inconsistency where the state-aware CASE expression handled `closed` but the WHERE clause excluded it.
@@ -352,6 +403,8 @@ Compute counts from the accumulated data:
 - `review_note_count = notes_per_mr.values().map(|(count, _)| count).sum()`
 - `author_mr_count = author_mrs.len()`
 
+**Bot/service-account filtering**: After accumulating all user scores and before sorting, filter out any username that appears in `config.scoring.excluded_usernames` (exact match, case-insensitive). This is applied in Rust post-query (not SQL) to keep the SQL clean and avoid parameter explosion. When `--include-bots` is active, the filter is skipped entirely. The robot JSON `resolved_input` includes `excluded_usernames_applied: true|false` to indicate whether filtering was active.
+
 Truncate to limit after sorting.
 
 ### 5. Default --since Change
@@ -364,10 +417,11 @@ At 2 years, author decay = 6%, reviewer decay = 0.4%, note decay = 0.006% — ne
 ### 5a. Reproducible Scoring via `--as-of`
 
 Add `--as-of <RFC3339|YYYY-MM-DD>` flag that overrides the `now_ms` reference point used for decay calculations. When set:
-- All event selection is bounded by `[since_ms, as_of_ms]` — events after `as_of_ms` are excluded from SQL results entirely (not just decayed)
+- All event selection is bounded by `[since_ms, as_of_ms)` — exclusive upper bound; events at or after `as_of_ms` are excluded from SQL results entirely (not just decayed). The SQL uses `< ?4` (strict less-than), not `<= ?4`.
+- `YYYY-MM-DD` input (without time component) is interpreted as end-of-day UTC: `T23:59:59.999Z`. This matches user intuition that `--as-of 2025-06-01` means "as of the end of June 1st" rather than "as of midnight at the start of June 1st" which would exclude the entire day's activity.
 - All decay computations use `as_of_ms` instead of `SystemTime::now()`
 - The `--since` window is calculated relative to `as_of_ms` (not wall clock)
-- Robot JSON `resolved_input` includes `as_of_ms` and `as_of_iso` fields
+- Robot JSON `resolved_input` includes `as_of_ms`, `as_of_iso`, `window_start_iso`, `window_end_iso`, and `window_end_exclusive: true` fields — making the exact query window unambiguous in output
 
 **Rationale**: Decayed scoring is time-sensitive by nature. Without a fixed reference point, the same query run minutes apart produces different rankings, making debugging and test reproducibility difficult. `--as-of` pins the clock so that results are deterministic for a given dataset. The upper-bound filter in SQL is critical — without it, events after the as-of date would enter with full weight (since `elapsed.max(0.0)` clamps negative elapsed time to zero), breaking the reproducibility guarantee.
 
@@ -426,9 +480,16 @@ CREATE INDEX IF NOT EXISTS idx_mfc_new_path_project_mr
 CREATE INDEX IF NOT EXISTS idx_notes_diffnote_discussion_author
   ON notes(discussion_id, author_username, created_at)
   WHERE note_type = 'DiffNote' AND is_system = 0;
+
+-- Support path resolution probes on old_path (build_path_query() and suffix_probe())
+-- The existing idx_notes_diffnote_path_created covers new_path probes, but old_path probes
+-- need their own index since probes don't constrain author_username.
+CREATE INDEX IF NOT EXISTS idx_notes_old_path_project_created
+  ON notes(position_old_path, project_id, created_at)
+  WHERE note_type = 'DiffNote' AND is_system = 0 AND position_old_path IS NOT NULL;
 ```
 
-**Rationale**: The existing indexes cover `position_new_path` and `new_path` but not their `old_path` counterparts. Without these, the `OR old_path` clauses would force table scans on renamed files. The `reviewer_participation` CTE joins `matched_notes` -> `discussions` -> `merge_requests`, so an index on `(discussion_id, author_username)` speeds up the CTE materialization.
+**Rationale**: The existing indexes cover `position_new_path` and `new_path` but not their `old_path` counterparts. Without these, the `OR old_path` clauses would force table scans on renamed files. The `reviewer_participation` CTE joins `matched_notes` -> `discussions` -> `merge_requests`, so an index on `(discussion_id, author_username)` speeds up the CTE materialization. The `idx_notes_old_path_project_created` index supports path resolution probes (`build_path_query()` and `suffix_probe()`) which run existence/path-only checks without constraining `author_username` — the scoring-oriented `idx_notes_old_path_author` has `author_username` as the second column, which is suboptimal for these probes.
 
 **Schema note**: The `notes` table uses `discussion_id` as its FK to `discussions`, which in turn has `merge_request_id`. There is no `noteable_id` column on `notes`. The previous plan revision incorrectly referenced `noteable_id` — this is corrected.
 
@@ -484,10 +545,24 @@ Add timestamp-aware variants:
 
 **`test_closed_mr_multiplier`**: Two identical MRs (same author, same age, same path). One is `merged`, one is `closed`. The merged MR should contribute `author_weight * decay(...)`, the closed MR should contribute `author_weight * closed_mr_multiplier * decay(...)`. With default multiplier 0.5, the closed MR contributes half.
 
-**`test_as_of_excludes_future_events`**: Insert events at timestamps T1 (past) and T2 (future relative to as-of). With `--as-of` set between T1 and T2, only T1 events should appear in results. T2 events must be excluded entirely, not just decayed. Validates the upper-bound filtering in SQL.
+**`test_as_of_excludes_future_events`**: Insert events at timestamps T1 (past) and T2 (future relative to as-of). With `--as-of` set between T1 and T2, only T1 events should appear in results. T2 events must be excluded entirely, not just decayed. Validates the exclusive upper-bound (`< ?4`) filtering in SQL.
+
+**`test_as_of_exclusive_upper_bound`**: Insert an event with timestamp exactly equal to the `as_of_ms` value. Verify it is excluded from results (strict less-than, not less-than-or-equal). This validates the half-open interval `[since, as_of)` semantics.
+
+**`test_excluded_usernames_filters_bots`**: Insert signals for a user named "renovate-bot" and a user named "jsmith", both with the same activity. With `excluded_usernames: ["renovate-bot"]` in config, only "jsmith" should appear in results. Validates the Rust-side post-query filtering.
+
+**`test_include_bots_flag_disables_filtering`**: Same setup as above, but with `--include-bots` active. Both "renovate-bot" and "jsmith" should appear in results.
 
 **`test_null_timestamp_fallback_to_created_at`**: Insert a merged MR with `merged_at = NULL` (edge case: old data before the column was populated). The state-aware timestamp should fall back to `created_at`. Verify the score reflects `created_at`, not 0 or a panic.
 
+**`test_path_normalization_handles_dot_and_double_slash`**: Call `normalize_query_path("./src//foo.rs")` — should return `"src/foo.rs"`. Call `normalize_query_path("  src/bar.rs  ")` — should return `"src/bar.rs"`. Call `normalize_query_path("src/foo.rs")` — should return unchanged (already normalized). Call `normalize_query_path("")` — should return `""` (empty input passes through).
+
+**`test_path_normalization_preserves_prefix_semantics`**: Call `normalize_query_path("./src/dir/")` — should return `"src/dir/"` (trailing slash preserved for prefix intent). Call `normalize_query_path("src/dir")` — should return `"src/dir"` (no trailing slash = file, not prefix).
+
+**`test_config_validation_rejects_absurd_half_life`**: `ScoringConfig` with `author_half_life_days = 5000` (>3650 cap) should return `ConfigInvalid` error. Similarly, `reviewer_min_note_chars = 5000` (>4096 cap) should fail.
+
+**`test_config_validation_rejects_nan_multiplier`**: `ScoringConfig` with `closed_mr_multiplier = f64::NAN` should return `ConfigInvalid` error. Same for `f64::INFINITY`.
+
 #### Invariant tests (regression safety for ranking systems)
 
 **`test_score_monotonicity_by_age`**: For any single signal type, an older timestamp must never produce a higher score than a newer timestamp with the same weight and half-life. Generate N random (age, half_life) pairs and assert `decay(older) <= decay(newer)` for all.
@@ -496,11 +571,13 @@ Add timestamp-aware variants:
 
 **`test_reviewer_split_is_exhaustive`**: For a reviewer assigned to an MR, they must appear in exactly one of: participated (has substantive DiffNotes meeting `reviewer_min_note_chars`) or assigned-only (no DiffNotes, or only trivial ones below the threshold). Never both, never neither. Test three cases: (1) reviewer with substantive DiffNotes -> participated only, (2) reviewer with no DiffNotes -> assigned-only only, (3) reviewer with only trivial notes ("LGTM") -> assigned-only only.
 
+**`test_deterministic_accumulation_order`**: Insert signals for a user with contributions at many different timestamps (10+ MRs with varied ages). Run `query_expert` 100 times in a loop. All 100 runs must produce the exact same `f64` score (bit-identical). Validates that the sorted contribution ordering eliminates HashMap-iteration-order nondeterminism.
+
 ### 9. Existing Test Compatibility
 
 All existing tests insert data with `now_ms()`. With decay, elapsed ~0ms means decay ~1.0, so scores round to the same integers as before. No existing test assertions should break.
 
-The `test_expert_scoring_weights_are_configurable` test needs `..Default::default()` added to fill the new half-life fields, `reviewer_assignment_weight` / `reviewer_assignment_half_life_days`, `closed_mr_multiplier`, and `reviewer_min_note_chars` fields.
+The `test_expert_scoring_weights_are_configurable` test needs `..Default::default()` added to fill the new half-life fields, `reviewer_assignment_weight` / `reviewer_assignment_half_life_days`, `closed_mr_multiplier`, `reviewer_min_note_chars`, and `excluded_usernames` fields.
 
 ## Verification
 
@@ -511,11 +588,19 @@ The `test_expert_scoring_weights_are_configurable` test needs `..Default::defaul
 5. `ubs src/cli/commands/who.rs src/core/config.rs src/core/db.rs` — no bug scanner findings
 6. Manual query plan verification (not automated — SQLite planner varies across versions):
    - Run `EXPLAIN QUERY PLAN` on the expert query (both exact and prefix modes) against a real database
-   - Confirm that `matched_notes` CTE uses `idx_notes_old_path_author` or the existing new_path index (not a full table scan)
-   - Confirm that `matched_file_changes` CTE uses `idx_mfc_old_path_project_mr` or `idx_mfc_new_path_project_mr`
+   - Confirm that `matched_notes_raw` branch 1 uses the existing new_path index and branch 2 uses `idx_notes_old_path_author` (not a full table scan on either branch)
+   - Confirm that `matched_file_changes_raw` branch 1 uses `idx_mfc_new_path_project_mr` and branch 2 uses `idx_mfc_old_path_project_mr`
    - Confirm that `reviewer_participation` CTE uses `idx_notes_diffnote_discussion_author`
+   - Confirm that `mr_activity` CTE joins `merge_requests` via primary key from `matched_file_changes`
+   - Confirm that path resolution probes (old_path leg) use `idx_notes_old_path_project_created`
    - Document the observed plan in a comment near the SQL for future regression reference
-7. Real-world validation:
+7. Performance baseline (manual, not CI-gated):
+   - Run `time cargo run --release -- who --path <exact-path>` on the real database for exact, prefix, and suffix modes
+   - Target SLOs: p95 exact path < 200ms, prefix < 300ms, suffix < 500ms on development hardware
+   - Record baseline timings as a comment near the SQL for regression reference
+   - If any mode exceeds 2x the baseline after future changes, investigate before merging
+   - Note: These are soft targets for developer awareness, not automated CI gates. Automated benchmarking with synthetic fixtures (100k/1M/5M notes) is a v2 investment if performance becomes a real concern.
+8. Real-world validation:
    - `cargo run --release -- who --path MeasurementQualityDialog.tsx` — verify jdefting/zhayes old reviews are properly discounted relative to recent authors
    - `cargo run --release -- who --path MeasurementQualityDialog.tsx --all-history` — compare full history vs 24m window to validate cutoff is reasonable
    - `cargo run --release -- who --path MeasurementQualityDialog.tsx --explain-score` — verify component breakdown sums to total and authored signal dominates for known authors
@@ -524,6 +609,8 @@ The `test_expert_scoring_weights_are_configurable` test needs `..Default::defaul
    - `cargo run --release -- who --path MeasurementQualityDialog.tsx --as-of 2025-06-01` — verify deterministic output across repeated runs
    - Spot-check that reviewers who only left "LGTM"-style notes are classified as assigned-only (not participated)
    - Verify closed MRs contribute at ~50% of equivalent merged MR scores via `--explain-score`
+   - If the project has known bot accounts (e.g., renovate-bot), add them to `excluded_usernames` config and verify they no longer appear in results. Run again with `--include-bots` to confirm they reappear.
+   - Test path normalization: `who --path ./src//foo.rs` and `who --path src/foo.rs` should produce identical results
 
 ## Accepted from External Review
 
@@ -553,12 +640,28 @@ Ideas incorporated from ChatGPT review (feedback-1 through feedback-4) that genu
 - **EXPLAIN QUERY PLAN verification step**: Manual check that the restructured queries use the new indexes (not automated, since SQLite planner varies across versions).
 
 **From feedback-4:**
-- **`--as-of` temporal correctness (critical)**: The plan described `--as-of` but the SQL only enforced a lower bound (`>= ?2`). Events after the as-of date would leak in with full weight (because `elapsed.max(0.0)` clamps negative elapsed time to zero). Added `<= ?4` upper bound to all SQL timestamp filters, making the query window `[since_ms, as_of_ms]`. Without this, `--as-of` reproducibility was fundamentally broken.
+- **`--as-of` temporal correctness (critical)**: The plan described `--as-of` but the SQL only enforced a lower bound (`>= ?2`). Events after the as-of date would leak in with full weight (because `elapsed.max(0.0)` clamps negative elapsed time to zero). Added `< ?4` upper bound to all SQL timestamp filters, making the query window `[since_ms, as_of_ms)`. Without this, `--as-of` reproducibility was fundamentally broken. (Refined to exclusive upper bound in feedback-5.)
 - **Closed-state inconsistency resolution**: The state-aware CASE expression handled `closed` state but the WHERE clause filtered to `('opened','merged')` only — dead code. Resolved by including `'closed'` in state filters and adding a `closed_mr_multiplier` (default 0.5) applied in Rust to all signals from closed-without-merge MRs. This credits real review effort on abandoned MRs while appropriately discounting it.
 - **Substantive note threshold for reviewer participation**: A single "LGTM" shouldn't promote a reviewer from 3-point (assigned-only) to 10-point (participated) weight. Added `reviewer_min_note_chars` (default 20) config field and `LENGTH(TRIM(body))` filter in the `reviewer_participation` CTE. This raises the bar for participation classification to actual substantive review comments.
-- **UNION ALL optimization fallback for path predicates**: SQLite's planner can degrade `OR` across two indexed columns to a table scan. Added documentation of a `UNION ALL` split + dedup fallback pattern to use if EXPLAIN QUERY PLAN shows degradation during verification. Start with the simpler `OR` approach; switch only if needed.
+- **UNION ALL optimization for path predicates**: SQLite's planner can degrade `OR` across two indexed columns to a table scan. Originally documented as a fallback; promoted to default strategy in feedback-5 iteration. The UNION ALL + dedup approach ensures each index branch is used independently.
 - **New tests**: `test_trivial_note_does_not_count_as_participation`, `test_closed_mr_multiplier`, `test_as_of_excludes_future_events` — cover the three new features added from this review round.
 
+**From feedback-5 (ChatGPT review):**
+- **Exclusive upper bound for `--as-of`**: Changed from `[since_ms, as_of_ms]` (inclusive) to `[since_ms, as_of_ms)` (exclusive). Half-open intervals are the standard convention in temporal systems — they eliminate edge-case ambiguity when events have timestamps exactly at the boundary. Also added `YYYY-MM-DD` → end-of-day UTC parsing and window metadata in robot output.
+- **UNION ALL as default for dual-path matching**: Promoted from "fallback if planner regresses" to default strategy. SQLite `OR`-across-indexed-columns degradation is common enough that the predictable UNION ALL + dedup approach is the safer starting point. The simpler `OR` variant is retained as a comment for benchmarking.
+- **Deterministic contribution ordering**: Within each signal type, sort contributions by `mr_id` before summing. This eliminates HashMap iteration order as a source of f64 rounding variance near ties, ensuring CI reproducibility without the overhead of compensated summation (Neumaier/Kahan was rejected as overkill at this scale).
+- **Minimal bot/service-account filtering**: Added `excluded_usernames` (exact match, case-insensitive) to `ScoringConfig` and `--include-bots` CLI flag. Applied as a Rust-side post-filter (not SQL) to keep queries clean. Scope is deliberately minimal — no regex patterns, no heuristic detection. Users configure the list for their team's specific bots.
+- **Performance baseline SLOs**: Added manual performance baseline step to verification — record timings for exact/prefix/suffix modes and flag >2x regressions. Kept lightweight (no CI gating, no synthetic benchmarks) to match the project's current maturity.
+- **New tests**: `test_as_of_exclusive_upper_bound`, `test_excluded_usernames_filters_bots`, `test_include_bots_flag_disables_filtering`, `test_deterministic_accumulation_order` — cover the newly-accepted features.
+
+**From feedback-6 (ChatGPT review):**
+- **Centralized `mr_activity` CTE**: The state-aware timestamp CASE expression and `closed_mr_multiplier` were repeated across signals 3, 4a, 4b with the multiplier applied later in Rust via string-matching on `mr_state`. This was brittle — the CASE could drift between branches and the Rust-side string matching was unnecessary indirection. A single `mr_activity` CTE defines both `activity_ts` and `state_mult` once, scoped to matched MRs only (via JOIN with `matched_file_changes`). Signals 1 and 2 still compute `state_mult` inline because they join through `discussions`, not `matched_file_changes`.
+- **Parameterized `reviewer_min_note_chars` and `closed_mr_multiplier`**: Previously `reviewer_min_note_chars` was inlined as a literal in the SQL string and `closed_mr_multiplier` was applied only in Rust. Binding both as SQL parameters (`?5` for `closed_mr_multiplier`, `?6` for `reviewer_min_note_chars`) eliminates statement-cache churn, ensures identical SQL text regardless of config values, and simplifies EXPLAIN QUERY PLAN analysis.
+- **Tightened config validation**: Added upper bounds — `*_half_life_days <= 3650` (10-year safety cap), `reviewer_min_note_chars <= 4096`, and `closed_mr_multiplier` must be finite (not NaN/Inf). These prevent absurd configurations from silently producing nonsensical results.
+- **Path canonicalization via `normalize_query_path()`**: Inputs like `./src//foo.rs` or whitespace-padded paths could fail path resolution even when the file exists in the database. A simple syntactic normalization (strip `./`, collapse `//`, trim whitespace, preserve trailing `/`) runs before `build_path_query()` to reduce false negatives. No filesystem or database lookups — purely string manipulation.
+- **Probe-optimized `idx_notes_old_path_project_created` index**: The scoring-oriented `idx_notes_old_path_author` index has `author_username` as its second column, which is suboptimal for path resolution probes that don't constrain author. A dedicated probe index on `(position_old_path, project_id, created_at)` ensures `build_path_query()` and `suffix_probe()` old_path lookups are efficient.
+- **New tests**: `test_path_normalization_handles_dot_and_double_slash`, `test_path_normalization_preserves_prefix_semantics`, `test_config_validation_rejects_absurd_half_life`, `test_config_validation_rejects_nan_multiplier` — cover the path canonicalization and tightened validation logic.
+
 ## Rejected Ideas (with rationale)
 
 These suggestions were considered during review but explicitly excluded from this iteration:
@@ -573,3 +676,13 @@ These suggestions were considered during review but explicitly excluded from thi
 - **Split scoring engine into core module** (feedback-4 #5): Proposed extracting scoring math from `who.rs` into `src/core/scoring/model_v2_decay.rs`. Premature modularization — `who.rs` is the only consumer and is ~800 lines. Adding module plumbing and indirection for a single call site adds complexity without reducing it. If we add a second scoring consumer (e.g., automated triage), revisit.
 - **Bot/service-account filtering** (feedback-4 #7): Real concern but orthogonal to time-decay scoring. This is a general data quality feature that belongs in its own issue — it affects all `who` modes, not just expert scoring. Adding `excluded_username_patterns` config and `--include-bots` flag is scope expansion that should be designed and tested independently.
 - **Model compare mode / rank-delta diagnostics** (feedback-4 #9): Over-engineered rollout safety for an internal CLI tool with ~3 users. Maintaining two parallel scoring codepaths (v1 flat + v2 decayed) doubles test surface and code complexity. The `--explain-score` + `--as-of` combination already provides debugging capability. If a future model change is risky enough to warrant A/B comparison, build it then.
+- **Canonical path identity graph** (feedback-5 #1, also feedback-2 #2, feedback-4 #4): Third time proposed, third time rejected. Building a rename graph from `mr_file_changes(old_path, new_path)` with identity resolution requires new schema (`path_identities`, `path_aliases` tables), ingestion pipeline changes, graph traversal at query time, and backfill logic for existing data. The UNION ALL dual-path matching already covers the 80%+ case (direct renames). Multi-hop rename chains (A→B→C) are rare in practice and can be addressed in v2 with real usage data showing the gap matters.
+- **Normalized `expertise_events` table** (feedback-5 #2): Proposes shifting from query-time CTE joins to a precomputed `expertise_events` table populated at ingest time. While architecturally appealing for read performance, this doubles the data surface area (raw tables + derived events), requires new ingestion pipelines with incremental upsert logic, backfill tooling for existing databases, and introduces consistency risks when raw data is corrected/re-synced. The CTE approach is correct, maintainable, and performant at our current scale. If query latency becomes a real bottleneck (see performance baseline SLOs), materialized views or derived tables become a v2 optimization.
+- **Reviewer engagement model upgrade** (feedback-5 #3): Proposes adding `approved`/`changes_requested` review-state signals and trivial-comment pattern matching (`["lgtm","+1","nit","ship it"]`). Expands the signal type count from 4 to 6 and adds a fragile pattern-matching layer (what about "don't ship it"? "lgtm but..."?). The `reviewer_min_note_chars` threshold is imperfect but pragmatic — it's a single configurable number with no false-positive risk from substring matching. Review-state signals may be worth adding later as a separate enhancement when we have data on how often they diverge from DiffNote participation.
+- **Contribution-floor auto cutoff for `--since`** (feedback-5 #5): Proposes `--since auto` computing the earliest relevant timestamp from `min_contribution_floor` (e.g., 0.01 points). Adds a non-obvious config parameter for minimal benefit — the 24m default is already mathematically justified from the decay curves (author: 6%, reviewer: 0.4% at 2 years) and easily overridden with `--since` or `--all-history`. The auto-derivation formula (`ceil(max_half_life * log2(1/floor))`) is opaque to users who just want to understand why a certain time range was selected.
+- **Full evidence drill-down in `--explain-score`** (feedback-5 #8): Proposes `--explain-score=summary|full` with per-MR evidence rows. Already rejected in feedback-2 #7. Component totals are sufficient for v1 debugging — they answer "which signal type drives this user's score." Per-MR drill-down requires additional SQL queries and significant output format complexity. Deferred unless component breakdowns prove insufficient.
+- **Neumaier compensated summation** (feedback-5 #7 partial): Accepted the sorting aspect for deterministic ordering, but rejected Neumaier/Kahan compensated summation. At the scale of dozens to low hundreds of contributions per user, the rounding error from naive f64 summation is on the order of 1e-14 — several orders of magnitude below any meaningful score difference. Compensated summation adds code complexity and a maintenance burden for no practical benefit at this scale.
+- **Automated CI benchmark gate** (feedback-5 #10 partial): Accepted manual performance baselines, but rejected automated CI regression gating with synthetic fixtures (100k/1M/5M notes). Building and maintaining benchmark infrastructure is a significant investment that's premature for a CLI tool with ~3 users. Manual timing checks during development are sufficient until performance becomes a real concern.
+- **Epsilon-based tie buckets for ranking** (feedback-6 #4) — rejected because the plan already has deterministic contribution ordering by `mr_id` within each signal type, which eliminates HashMap-iteration nondeterminism. Platform-dependent `powf` differences at the scale of dozens to hundreds of contributions per user are sub-epsilon (order of 1e-15). If two users genuinely score within 1e-9 of each other, the existing tiebreak by `(last_seen DESC, username ASC)` is already meaningful and deterministic. Adding a bucketing layer introduces a magic epsilon constant and floor operation for a problem that doesn't manifest in practice.
+- **`--diagnose-score` aggregated diagnostics flag** (feedback-6 #5) — rejected because this is diagnostic/debugging tooling that adds a new flag, new output format, and new counting logic (matched_notes_raw_count, dedup_count, window exclusions, etc.) across the SQL pipeline. The existing `--explain-score` component breakdown + manual EXPLAIN QUERY PLAN verification already covers the debugging need. The additional SQL instrumentation required (counting rows at each CTE stage) would complicate the query for a feature with unclear demand. A v2 addition if operational debugging becomes a recurring need.
+- **Multi-path expert scoring (`--path` repeatable)** (feedback-6 #7) — rejected because this is a feature expansion, not a plan improvement for the time-decay model. Multi-path requires a `requested_paths` CTE, modified dedup logic keyed on `(username, signal, mr_id)` across paths, CLI parsing changes for repeatable `--path` and `--path-file`, and new test cases for overlap/prefix/dedup semantics. This is a separate bead/feature that should be designed independently — it's orthogonal to time-decay scoring and can be added later without requiring any changes to the decay model.

plans/tui-prd-v2-frankentui.feedback-1.md

@@ -0,0 +1,209 @@
+No `## Rejected Recommendations` section was present, so these are all net-new improvements.
+
+1. Keep core `lore` stable; isolate nightly to a TUI crate  
+Rationale: the current plan says “whole project nightly” but later assumes TUI is feature-gated. Isolating nightly removes unnecessary risk from non-TUI users, CI, and release cadence.
+
+```diff
+@@ 3.2 Nightly Rust Strategy
+-- The entire gitlore project moves to pinned nightly, not just the TUI feature.
++- Keep core `lore` on stable Rust.
++- Add workspace member `lore-tui` pinned to nightly for FrankenTUI.
++- Ship `lore tui` only when `--features tui` (or separate `lore-tui` binary) is enabled.
+
+@@ 10.1 New Files
++- crates/lore-tui/Cargo.toml
++- crates/lore-tui/src/main.rs
+
+@@ 11. Assumptions
+-17. TUI module is feature-gated.
++17. TUI is isolated in a workspace crate and feature-gated in root CLI integration.
+```
+
+2. Add a framework adapter boundary from day 1  
+Rationale: the “3-day ratatui escape hatch” is optimistic without a strict interface. A tiny `UiRuntime` + screen renderer trait makes fallback real, not aspirational.
+
+```diff
+@@ 4. Architecture
++### 4.9 UI Runtime Abstraction
++Introduce `UiRuntime` trait (`run`, `send`, `subscribe`) and `ScreenRenderer` trait.
++FrankenTUI implementation is default; ratatui adapter can be dropped in with no state/action rewrite.
+
+@@ 3.5 Escape Hatch
+-- The migration cost to ratatui is ~3 days
++- Migration cost target is ~3-5 days, validated by one ratatui spike screen in Phase 1.
+```
+
+3. Stop using CLI command modules as the TUI query API  
+Rationale: coupling TUI to CLI output-era structs creates long-term friction and accidental regressions. Create a shared domain query layer used by both CLI and TUI.
+
+```diff
+@@ 10.20 Refactor: Extract Query Functions
+-- extract query_* from cli/commands/*
++- introduce `src/domain/query/*` as the canonical read model API.
++- CLI and TUI both depend on domain query layer.
++- CLI modules retain formatting/output only.
+
+@@ 10.2 Modified Files
++- src/domain/query/mod.rs
++- src/domain/query/issues.rs
++- src/domain/query/mrs.rs
++- src/domain/query/search.rs
++- src/domain/query/who.rs
+```
+
+4. Replace single `Arc<Mutex<Connection>>` with connection manager  
+Rationale: one locked connection serializes everything and hurts responsiveness, especially during sync. Use separate read pool + writer connection with WAL and busy timeout.
+
+```diff
+@@ 4.4 App — Implementing the Model Trait
+- pub db: Arc<Mutex<Connection>>,
++ pub db: Arc<DbManager>, // read pool + single writer coordination
+
+@@ 4.5 Async Action System
+- Each Cmd::task closure locks the mutex, runs the query, and returns a Msg
++ Reads use pooled read-only connections.
++ Sync/write path uses dedicated writer connection.
++ Enforce WAL, busy_timeout, and retry policy for SQLITE_BUSY.
+```
+
+5. Make debouncing/cancellation explicit and correct  
+Rationale: “runtime coalesces rapid keypresses” is not a safe correctness guarantee. Add request IDs and stale-response dropping to prevent flicker and wrong data.
+
+```diff
+@@ 4.3 Core Types (Msg)
++ SearchRequestStarted { request_id: u64, query: String }
+- SearchExecuted(SearchResults),
++ SearchExecuted { request_id: u64, results: SearchResults },
+
+@@ 4.4 maybe_debounced_query()
+- runtime coalesces rapid keypresses
++ use explicit 200ms debounce timer + monotonic request_id
++ ignore results whose request_id != current_search_request_id
+```
+
+6. Implement true streaming sync, not batch-at-end pseudo-streaming  
+Rationale: the plan promises real-time logs/progress but code currently returns one completion message. This gap will disappoint users and complicate cancellation.
+
+```diff
+@@ 4.4 start_sync_task()
+- Pragmatic approach: run sync synchronously, collect all progress events, return summary.
++ Use event channel subscription for `SyncProgress`/`SyncLogLine` streaming.
++ Keep `SyncCompleted` only as terminal event.
++ Add cooperative cancel token mapped to `Esc` while running.
+
+@@ 5.9 Sync
++ Add "Resume from checkpoint" option for interrupted syncs.
+```
+
+7. Fix entity identity ambiguity across projects  
+Rationale: using `iid` alone is unsafe in multi-project datasets. Navigation and cross-refs should key by `(project_id, iid)` or global ID.
+
+```diff
+@@ 4.3 Core Types
+- IssueDetail(i64)
+- MrDetail(i64)
++ IssueDetail(EntityKey)
++ MrDetail(EntityKey)
+
++ pub struct EntityKey { pub project_id: i64, pub iid: i64, pub kind: EntityKind }
+
+@@ 10.12.4 Cross-Reference Widget
+- parse "group/project#123" -> iid only
++ parse into `{project_path, iid, kind}` then resolve to `project_id` before navigation
+```
+
+8. Resolve keybinding conflicts and formalize keymap precedence  
+Rationale: current spec conflicts (`Tab` sort vs focus filter; `gg` vs go-prefix). A deterministic keymap contract prevents UX bugs.
+
+```diff
+@@ 8.2 List Screens
+- Tab | Cycle sort column
+- f   | Focus filter bar
++ Tab | Focus filter bar
++ S   | Cycle sort column
++ /   | Focus filter bar (alias)
+
+@@ 4.4 interpret_key()
++ Add explicit precedence table:
++ 1) modal/palette
++ 2) focused input
++ 3) global
++ 4) screen-local
++ Add configurable go-prefix timeout (default 500ms) with cancel feedback.
+```
+
+9. Add performance SLOs and DB/index plan  
+Rationale: “fast enough” is vague. Add measurable budgets, required indexes, and query-plan gates in CI for predictable performance.
+
+```diff
+@@ 3.1 Risk Matrix
++ Add risk: "Query latency regressions on large datasets"
+
+@@ 9.3 Phase 0 — Toolchain Gate
++7. p95 list query latency < 75ms on 100k issues synthetic fixture
++8. p95 search latency < 200ms on 1M docs (lexical mode)
+
+@@ 11. Assumptions
+-5. SQLite queries are fast enough for interactive use (<50ms for filtered results).
++5. Performance budgets are enforced by benchmark fixtures and query-plan checks.
++6. Required indexes documented and migration-backed before TUI GA.
+```
+
+10. Add reliability/observability model (error classes, retries, tracing)  
+Rationale: one string toast is not enough for production debugging. Add typed errors, retry policy, and an in-TUI diagnostics pane.
+
+```diff
+@@ 4.3 Core Types (Msg)
+- Error(String),
++ Error(AppError),
+
++ pub enum AppError {
++   DbBusy, DbCorruption, NetworkRateLimited, NetworkUnavailable,
++   AuthFailed, ParseError, Internal(String)
++ }
+
+@@ 5.11 Doctor / Stats
++ Add "Diagnostics" tab:
++ - last 100 errors
++ - retry counts
++ - current sync/backoff state
++ - DB contention metrics
+```
+
+11. Add “Saved Views + Watchlist” as high-value product features  
+Rationale: this makes the TUI compelling daily, not just navigable. Users can persist filters and monitor critical slices (e.g., “P1 auth issues updated in last 24h”).
+
+```diff
+@@ 1. Executive Summary
++ - Saved Views (named filters and layouts)
++ - Watchlist panel (tracked queries with delta badges)
+
+@@ 5. Screen Taxonomy
++### 5.12 Saved Views / Watchlist
++Persistent named filters for Issues/MRs/Search.
++Dashboard shows per-watchlist deltas since last session.
+
+@@ 6. User Flows
++### 6.9 Flow: "Run morning watchlist triage"
++Dashboard -> Watchlist -> filtered IssueList/MRList -> detail drilldown
+```
+
+12. Strengthen testing plan with deterministic behavior and chaos cases  
+Rationale: snapshot tests alone won’t catch race/staleness/cancellation issues. Add concurrency, cancellation, and flaky terminal behavior tests.
+
+```diff
+@@ 9.2 Phases
++Phase 5.5 Reliability Test Pack (2d)
++ - stale response drop tests
++ - sync cancel/resume tests
++ - SQLITE_BUSY retry tests
++ - resize storm and rapid key-chord tests
+
+@@ 10.9 Snapshot Test Example
++ Add non-snapshot tests:
++ - property tests for navigation invariants
++ - integration tests for request ordering correctness
++ - benchmark tests for query budgets
+```
+
+If you want, I can produce a consolidated “PRD v2.1 patch” with all of the above merged into one coherent updated document structure.

plans/tui-prd-v2-frankentui.feedback-10.md

@@ -0,0 +1,214 @@
+I found 9 high-impact revisions that materially improve correctness, robustness, and usability without reintroducing anything in `## Rejected Recommendations`.
+
+### 1. Prevent stale async overwrites on **all** screens (not just search)
+Right now, only `SearchExecuted` is generation-guarded. `IssueListLoaded`, `MrListLoaded`, `IssueDetailLoaded`, etc. can still race and overwrite newer state after rapid navigation/filtering. This is the biggest correctness risk in the current design.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ message.rs
+-    IssueListLoaded(Vec<IssueRow>),
++    IssueListLoaded { generation: u64, rows: Vec<IssueRow> },
+@@
+-    MrListLoaded(Vec<MrRow>),
++    MrListLoaded { generation: u64, rows: Vec<MrRow> },
+@@
+-    IssueDetailLoaded { key: EntityKey, detail: IssueDetail },
+-    MrDetailLoaded { key: EntityKey, detail: MrDetail },
++    IssueDetailLoaded { generation: u64, key: EntityKey, detail: IssueDetail },
++    MrDetailLoaded { generation: u64, key: EntityKey, detail: MrDetail },
+
+@@ update()
+-            Msg::IssueListLoaded(result) => {
++            Msg::IssueListLoaded { generation, rows } => {
++                if !self.task_supervisor.is_current(&TaskKey::LoadScreen(Screen::IssueList), generation) {
++                    return Cmd::none();
++                }
+                 self.state.set_loading(false);
+-                self.state.issue_list.set_result(result);
++                self.state.issue_list.set_result(rows);
+                 Cmd::none()
+             }
+```
+
+### 2. Make cancellation safe with task-owned SQLite interrupt handles
+The plan mentions `sqlite3_interrupt()` but uses pooled shared reader connections. Interrupting a shared connection can cancel unrelated work. Use per-task reader leases and store `InterruptHandle` in `TaskHandle`.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ DbManager
+-    readers: Vec<Mutex<Connection>>,
++    readers: Vec<Mutex<Connection>>,
++    // task-scoped interrupt handles prevent cross-task cancellation bleed
++    // each dispatched query receives an owned ReaderLease
+
++pub struct ReaderLease {
++    conn: Connection,
++    interrupt: rusqlite::InterruptHandle,
++}
++
++impl DbManager {
++    pub fn lease_reader(&self) -> Result<ReaderLease, LoreError> { ... }
++}
+
+@@ TaskHandle
+ pub struct TaskHandle {
+     pub key: TaskKey,
+     pub generation: u64,
+     pub cancel: Arc<CancelToken>,
++    pub interrupt: Option<rusqlite::InterruptHandle>,
+ }
+
+@@ cancellation
+-Query interruption: ... fires sqlite3_interrupt() on the connection.
++Query interruption: cancel triggers the task's owned InterruptHandle only.
++No shared-connection interrupt is permitted.
+```
+
+### 3. Harden keyset pagination for multi-project and sort changes
+`updated_at + iid` cursor is not enough when rows share timestamps across projects or sort mode changes. This can duplicate/skip rows.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ issue_list.rs
+-pub struct IssueCursor {
+-    pub updated_at: i64,
+-    pub iid: i64,
+-}
++pub struct IssueCursor {
++    pub sort_field: SortField,
++    pub sort_order: SortOrder,
++    pub updated_at: Option<i64>,
++    pub created_at: Option<i64>,
++    pub iid: i64,
++    pub project_id: i64,   // deterministic tie-breaker
++    pub filter_hash: u64,  // invalidates stale cursors on filter mutation
++}
+
+@@ pagination section
+-Windowed keyset pagination ...
++Windowed keyset pagination uses deterministic tuple ordering:
++`ORDER BY <primary_sort>, project_id, iid`.
++Cursor is rejected if `filter_hash` or sort tuple mismatches current query.
+```
+
+### 4. Replace ad-hoc filter parsing with a small typed DSL
+Current `split_whitespace()` parser is brittle and silently lossy. Add quoted values, negation, and strict parse errors.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ filter_bar.rs
+-    fn parse_tokens(&mut self) {
+-        let text = self.input.value().to_string();
+-        self.tokens = text.split_whitespace().map(|chunk| { ... }).collect();
+-    }
++    fn parse_tokens(&mut self) {
++        // grammar (v1):
++        // term := [ "-" ] (field ":" value | quoted_text | bare_text)
++        // value := quoted | unquoted
++        // examples:
++        //   state:opened label:"P1 blocker" -author:bot since:14d
++        self.tokens = filter_dsl::parse(self.input.value())?;
++    }
+
+@@ section 8 / keybindings-help
++Filter parser surfaces actionable inline diagnostics with cursor position,
++and never silently drops unknown fields.
+```
+
+### 5. Add render caches for markdown/tree shaping
+Markdown and tree shaping are currently recomputed on every frame in several snippets. Cache render artifacts by `(entity, width, theme, content_hash)` to protect frame time.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ module structure
++    render_cache.rs               # Width/theme/content-hash keyed cache for markdown + tree layouts
+
+@@ Assumptions / Performance
++Detail and search preview rendering uses memoized render artifacts.
++Cache invalidation triggers: content hash change, terminal width change, theme change.
+```
+
+### 6. Use one-shot timers for debounce/prefix timeout
+`Every` is periodic; it wakes repeatedly and can produce edge-case repeated firings. One-shot subscriptions are cleaner and cheaper.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ subscriptions()
+-        if self.state.search.debounce_pending() {
+-            subs.push(Box::new(
+-                Every::with_id(3, Duration::from_millis(200), move || {
+-                    Msg::SearchDebounceFired { generation }
+-                })
+-            ));
+-        }
++        if self.state.search.debounce_pending() {
++            subs.push(Box::new(
++                After::with_id(3, Duration::from_millis(200), move || {
++                    Msg::SearchDebounceFired { generation }
++                })
++            ));
++        }
+
+@@ InputMode GoPrefix timeout
+-The tick subscription compares clock instant...
++GoPrefix timeout is a one-shot `After(500ms)` tied to prefix generation.
+```
+
+### 7. New feature: list “Quick Peek” panel (`Space`) for triage speed
+This adds immediate value without v2-level scope. Users can inspect selected issue/MR metadata/snippet without entering detail and coming back.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 5.2 Issue List
+-Interaction: Enter detail
++Interaction: Enter detail, Space quick-peek (toggle right preview pane)
+
+@@ 5.4 MR List
++Quick Peek mode mirrors Issue List: metadata + first discussion snippet + cross-refs.
+
+@@ 8.2 List Screens
+ | `Enter` | Open selected item |
++| `Space` | Toggle Quick Peek panel for selected row |
+```
+
+### 8. Upgrade compatibility handshake from integer to machine-readable contract
+Single integer compat is too coarse for real drift detection. Keep it simple but structured.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ Nightly Rust Strategy / Compatibility contract
+-  1. Binary compat version (`lore-tui --compat-version`) — integer check ...
++  1. Binary compat contract (`lore-tui --compat-json`) — JSON:
++     `{ "protocol": 1, "compat_version": 2, "min_schema": 14, "max_schema": 16, "build": "..." }`
++     `lore` validates protocol + compat + schema range before spawn.
+
+@@ CLI integration
+-fn validate_tui_compat(...) { ... --compat-version ... }
++fn validate_tui_compat(...) { ... --compat-json ... }
+```
+
+### 9. Fix sync stream bug and formalize progress coalescing
+The current snippet calls `try_send` for progress twice in one callback path and depth math is wrong. Also progress spam should be coalesced by lane.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ start_sync_task()
+-                        let current_depth = 2048 - tx.try_send(Msg::SyncProgress(event.clone()))
+-                            .err().map_or(0, |_| 1);
+-                        max_queue_depth = max_queue_depth.max(current_depth);
+-                        if tx.try_send(Msg::SyncProgress(event.clone())).is_err() {
++                        // coalesce by lane key at <=30Hz; one send attempt per flush
++                        coalescer.update(event.clone());
++                        if let Some(batch) = coalescer.flush_ready() {
++                            if tx.try_send(Msg::SyncProgressBatch(batch)).is_err() {
+                                 dropped_count += 1;
+                                 let _ = tx.try_send(Msg::SyncBackpressureDrop);
++                            } else {
++                                max_queue_depth = max_queue_depth.max(observed_queue_depth());
++                            }
+                         }
+```
+
+---
+
+If you want, I can produce a single consolidated patch-style rewrite of Sections `4.x`, `5.2/5.4`, `8.2`, `9.3`, and `10.x` so you can drop it directly into iteration 10.

plans/tui-prd-v2-frankentui.feedback-11.md

@@ -0,0 +1,177 @@
+I reviewed the full PRD and avoided everything listed under `## Rejected Recommendations`.  
+These are the highest-impact revisions I’d make.
+
+1. Stable list pagination via snapshot fences
+Why this improves the plan: your keyset cursor is deterministic for sort/filter, but still vulnerable to duplicates/skips if sync writes land between page fetches. Add a per-browse snapshot fence so one browse session sees a stable dataset.
+Tradeoff: newest rows are hidden until refresh, which is correct for deterministic triage.
+
+```diff
+diff --git a/docs/plans/gitlore-tui-prd-v2.md b/docs/plans/gitlore-tui-prd-v2.md
+@@ 5.2 Issue List
+- **Pagination:** Windowed keyset pagination with explicit cursor state.
++ **Pagination:** Windowed keyset pagination with explicit cursor state.
++ **Snapshot fence:** On list entry, capture `snapshot_upper_updated_at` (ms) and pin all
++ list-page queries to `updated_at <= snapshot_upper_updated_at`. This guarantees no duplicate
++ or skipped rows during scrolling even if sync writes occur concurrently.
++ A "new data available" badge appears when a newer sync completes; `r` refreshes the fence.
+
+@@ 5.4 MR List
+- **Pagination:** Same windowed keyset pagination strategy as Issue List.
++ **Pagination:** Same strategy plus snapshot fence (`updated_at <= snapshot_upper_updated_at`)
++ for deterministic cross-page traversal under concurrent sync writes.
+
+@@ 4.7 Navigation Stack Implementation
++ Browsing sessions carry a per-screen `BrowseSnapshot` token to preserve stable ordering
++ until explicit refresh or screen re-entry.
+```
+
+2. Query budgets and soft deadlines
+Why this improves the plan: currently “slow query” is handled mostly by cancellation and stale-drop. Add explicit latency budgets so UI responsiveness stays predictable under worst-case filters.
+Tradeoff: sometimes user gets partial/truncated results first, followed by full results on retry/refine.
+
+```diff
+diff --git a/docs/plans/gitlore-tui-prd-v2.md b/docs/plans/gitlore-tui-prd-v2.md
+@@ 4.5 Async Action System
++ #### 4.5.2 Query Budgets and Soft Deadlines
++ Each query type gets a budget:
++ - list window fetch: 120ms target, 250ms hard deadline
++ - detail phase-1 metadata: 75ms target, 150ms hard deadline
++ - search lexical/hybrid: 250ms hard deadline
++ On hard deadline breach, return `QueryDegraded { truncated: true }` and show inline badge:
++ "results truncated; refine filter or press r to retry full".
++ Implementation uses SQLite progress handler + per-task interrupt deadline.
+
+@@ 9.3 Phase 0 — Toolchain Gate
++ 26. Query deadline behavior validated: hard deadline cancels query and renders degraded badge
++ without blocking input loop.
+```
+
+3. Targeted cache invalidation and prewarm after sync
+Why this improves the plan: `invalidate_all()` after sync throws away hot detail cache and hurts the exact post-sync workflow you optimized for. Invalidate only changed keys and prewarm likely-next entities.
+Tradeoff: slightly more bookkeeping in sync result handling.
+
+```diff
+diff --git a/docs/plans/gitlore-tui-prd-v2.md b/docs/plans/gitlore-tui-prd-v2.md
+@@ 4.1 Module Structure
+-    entity_cache.rs               # Bounded LRU cache ... Invalidated on sync completion.
++    entity_cache.rs               # Bounded LRU cache with selective invalidation by changed EntityKey
++                                  # and optional post-sync prewarm of top changed entities.
+
+@@ 4.4 App — Implementing the Model Trait (Msg::SyncCompleted)
+-                // Invalidate entity cache — synced data may have changed.
+-                self.entity_cache.invalidate_all();
++                // Selective invalidation: evict only changed entities from sync delta.
++                self.entity_cache.invalidate_keys(&result.changed_entity_keys);
++                // Prewarm top N changed/new entities for immediate post-sync triage.
++                self.enqueue_cache_prewarm(&result.changed_entity_keys);
+```
+
+4. Exact “what changed” navigation without new DB tables
+Why this improves the plan: your summary currently uses timestamp filter; this can include unrelated updates and miss edge cases. Keep an in-memory delta ledger per sync run and navigate by exact IDs.
+Tradeoff: small memory overhead per run; no schema migration required.
+
+```diff
+diff --git a/docs/plans/gitlore-tui-prd-v2.md b/docs/plans/gitlore-tui-prd-v2.md
+@@ 5.9 Sync (Summary mode)
+-- `i` navigates to Issue List pre-filtered to "since last sync" (using `sync_status.last_completed_at` timestamp comparison)
+-- `m` navigates to MR List pre-filtered to "since last sync" (using `sync_status.last_completed_at` timestamp comparison)
++- `i` navigates to Issue List filtered by exact issue IDs changed in this sync run
++- `m` navigates to MR List filtered by exact MR IDs changed in this sync run
++  (fallback to timestamp filter only if run delta not available)
+
+@@ 10.1 New Files
++crates/lore-tui/src/sync_delta_ledger.rs # In-memory per-run exact changed/new IDs (issues/MRs/discussions)
+```
+
+5. Adaptive render governor (runtime performance safety)
+Why this improves the plan: capability detection is static; you also need dynamic adaptation when frame time/backpressure worsens (SSH, tmux nesting, huge logs).
+Tradeoff: visual richness may step down automatically under load.
+
+```diff
+diff --git a/docs/plans/gitlore-tui-prd-v2.md b/docs/plans/gitlore-tui-prd-v2.md
+@@ 3.4.1 Capability-Adaptive Rendering
++#### 3.4.2 Adaptive Render Governor
++Runtime monitors frame time and stream pressure:
++- if frame p95 > 40ms or sync drops spike, switch to lighter profile:
++  plain markdown, reduced tree guides, slower spinner tick, less frequent repaint.
++- when stable for N seconds, restore previous profile.
++CLI override:
++`lore tui --render-profile=auto|quality|balanced|speed`
+
+@@ 9.3 Phase 0 — Toolchain Gate
++27. Frame-time governor validated: under induced load, UI remains responsive and input latency
++stays within p95 < 75ms while auto-downgrading render profile.
+```
+
+6. First-run/data-not-ready screen (not an init wizard)
+Why this improves the plan: empty DB or missing indexes will otherwise feel broken. A dedicated read-only readiness screen improves first impression and self-recovery.
+Tradeoff: one extra lightweight screen/state.
+
+```diff
+diff --git a/docs/plans/gitlore-tui-prd-v2.md b/docs/plans/gitlore-tui-prd-v2.md
+@@ 4.3 Core Types (Screen enum)
+     Sync,
+     Stats,
+     Doctor,
++    Bootstrap,
+
+@@ 5.11 Doctor / Stats (Info Screens)
++### 5.12 Bootstrap (Data Readiness)
++Shown when no synced projects/documents are present or required indexes are missing.
++Displays concise readiness checks and exact CLI commands to recover:
++`lore sync`, `lore migrate`, `lore --robot doctor`.
++Read-only; no auto-execution.
+```
+
+7. Global project scope pinning across screens
+Why this improves the plan: users repeatedly apply the same project filter across dashboard/list/search/timeline/who. Add a global scope pin to reduce repetitive filtering and speed triage.
+Tradeoff: must show clear “scope active” indicator to avoid confusion.
+
+```diff
+diff --git a/docs/plans/gitlore-tui-prd-v2.md b/docs/plans/gitlore-tui-prd-v2.md
+@@ 4.1 Module Structure
++    scope.rs                      # Global project scope context (all-projects or pinned project set)
+
+@@ 8.1 Global (Available Everywhere)
++| `P` | Open project scope picker / toggle global scope pin |
+
+@@ 4.10 State Module — Complete
++pub global_scope: ScopeContext,   // Applies to dashboard/list/search/timeline/who queries
+
+@@ 10.11 Action Module — Query Bridge
+- pub fn fetch_issues(conn: &Connection, filter: &IssueFilter) -> Result<Vec<IssueListRow>, LoreError>
++ pub fn fetch_issues(conn: &Connection, scope: &ScopeContext, filter: &IssueFilter) -> Result<Vec<IssueListRow>, LoreError>
+```
+
+8. Concurrency correctness tests for pagination and cancellation races
+Why this improves the plan: current reliability tests are good, but missing a direct test for duplicate/skip behavior under concurrent sync writes while paginating.
+Tradeoff: additional integration test complexity.
+
+```diff
+diff --git a/docs/plans/gitlore-tui-prd-v2.md b/docs/plans/gitlore-tui-prd-v2.md
+@@ 9.2 Phases (Phase 5.5 — Reliability Test Pack)
++    Concurrent pagination/write race tests :p55j, after p55h, 1d
++    Query deadline cancellation race tests :p55k, after p55j, 0.5d
+
+@@ 9.3 Phase 0 — Toolchain Gate
++28. Concurrent pagination/write test proves no duplicates/skips within a pinned browse snapshot.
++29. Cancellation race test proves no cross-task interrupt bleed and no stuck loading state.
+```
+
+9. URL opening policy v2: allowlisted GitLab entity paths
+Why this improves the plan: host validation is necessary but not always sufficient. Restrict default browser opens to known GitLab entity paths and require confirmation for unusual paths on same host.
+Tradeoff: occasional extra prompt for uncommon but valid URLs.
+
+```diff
+diff --git a/docs/plans/gitlore-tui-prd-v2.md b/docs/plans/gitlore-tui-prd-v2.md
+@@ 3.1 Risk Matrix
+-| Malicious URL in entity data opened in browser | Medium | Low | URL host validated against configured GitLab instance before `open`/`xdg-open` |
++| Malicious URL in entity data opened in browser | Medium | Low | Validate scheme+host+port and path pattern allowlist (`/-/issues/`, `/-/merge_requests/`, project issue/MR routes). Unknown same-host paths require explicit confirm modal. |
+
+@@ 10.4.1 Terminal Safety — Untrusted Text Sanitization
+- pub fn is_safe_url(url: &str, allowed_origins: &[AllowedOrigin]) -> bool
++ pub fn classify_safe_url(url: &str, policy: &UrlPolicy) -> UrlSafety
++ // UrlSafety::{AllowedEntityPath, AllowedButUnrecognizedPath, Blocked}
+```
+
+These 9 changes are additive, avoid previously rejected ideas, and materially improve determinism, responsiveness, post-sync usefulness, and safety without forcing a big architecture reset.

plans/tui-prd-v2-frankentui.feedback-2.md

@@ -0,0 +1,203 @@
+I excluded the two items in your `## Rejected Recommendations` and focused on net-new improvements.  
+These are the highest-impact revisions I’d make.
+
+### 1. Fix the package graph now (avoid a hard Cargo cycle)
+Your current plan has `root -> optional lore-tui` and `lore-tui -> lore (root)`, which creates a cyclic dependency risk. Split shared logic into a dedicated core crate so CLI and TUI both depend downward.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ ## 9.1 Dependency Changes
+-[workspace]
+-members = [".", "crates/lore-tui"]
++[workspace]
++members = [".", "crates/lore-core", "crates/lore-tui"]
+
+@@
+-[dependencies]
+-lore-tui = { path = "crates/lore-tui", optional = true }
++[dependencies]
++lore-core = { path = "crates/lore-core" }
++lore-tui = { path = "crates/lore-tui", optional = true }
+
+@@ # crates/lore-tui/Cargo.toml
+-lore = { path = "../.." }  # Core lore library
++lore-core = { path = "../lore-core" }  # Shared domain/query crate (acyclic graph)
+```
+
+### 2. Stop coupling TUI to `cli/commands/*` internals
+Calling CLI command modules from TUI is brittle and will drift. Introduce a shared query/service layer with DTOs owned by core.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ ## 4.1 Module Structure
+-    action.rs                     # Async action runners (DB queries, GitLab calls)
++    action.rs                     # Task dispatch only
++    service/
++      mod.rs
++      query.rs                    # Shared read services (CLI + TUI)
++      sync.rs                     # Shared sync orchestration facade
++      dto.rs                      # UI-agnostic data contracts
+
+@@ ## 10.2 Modified Files
+-src/cli/commands/list.rs               # Extract query_issues(), query_mrs() as pub fns
+-src/cli/commands/show.rs               # Extract query_issue_detail(), query_mr_detail() as pub fns
+-src/cli/commands/who.rs                # Extract query_experts(), etc. as pub fns
+-src/cli/commands/search.rs             # Extract run_search_query() as pub fn
++crates/lore-core/src/query/issues.rs   # Canonical issue queries
++crates/lore-core/src/query/mrs.rs      # Canonical MR queries
++crates/lore-core/src/query/show.rs     # Canonical detail queries
++crates/lore-core/src/query/who.rs      # Canonical people queries
++crates/lore-core/src/query/search.rs   # Canonical search queries
++src/cli/commands/*.rs                  # Consume lore-core query services
++crates/lore-tui/src/action.rs          # Consume lore-core query services
+```
+
+### 3. Add a real task supervisor (dedupe + cancellation + priority)
+Right now tasks are ad hoc and can overrun each other. Add a scheduler keyed by screen+intent.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ ## 4.5 Async Action System
+-The `Cmd::task(|| { ... })` pattern runs a blocking closure on a background thread pool.
++The TUI uses a `TaskSupervisor`:
++- Keyed tasks (`TaskKey`) to dedupe redundant requests
++- Priority lanes (`Input`, `Navigation`, `Background`)
++- Cooperative cancellation tokens per task
++- Late-result drop via generation IDs (not just search)
+
+@@ ## 4.3 Core Types
++pub enum TaskKey {
++    LoadScreen(Screen),
++    Search { generation: u64 },
++    SyncStream,
++}
+```
+
+### 4. Correct sync streaming architecture (current sketch loses streamed events)
+The sample creates `tx/rx` then drops `rx`; events never reach update loop. Define an explicit stream subscription with bounded queue and backpressure policy.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ ## 4.4 App — Implementing the Model Trait
+-        let (tx, _rx) = std::sync::mpsc::channel::<Msg>();
++        let (tx, rx) = std::sync::mpsc::sync_channel::<Msg>(1024);
++        // rx is registered via Subscription::from_receiver("sync-stream", rx)
+
+@@
+-            let result = crate::ingestion::orchestrator::run_sync(
++            let result = crate::ingestion::orchestrator::run_sync(
+                 &config,
+                 &conn,
+                 |event| {
+@@
+-                    let _ = tx.send(Msg::SyncProgress(event.clone()));
+-                    let _ = tx.send(Msg::SyncLogLine(format!("{event:?}")));
++                    if tx.try_send(Msg::SyncProgress(event.clone())).is_err() {
++                        let _ = tx.try_send(Msg::SyncBackpressureDrop);
++                    }
++                    let _ = tx.try_send(Msg::SyncLogLine(format!("{event:?}")));
+                 },
+             );
+```
+
+### 5. Upgrade data-plane performance plan (keyset pagination + index contracts)
+Virtualized list without keyset paging still forces expensive scans. Add explicit keyset pagination and query-plan CI checks.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ ## 9.3 Phase 0 — Toolchain Gate
+-7. p95 list query latency < 75ms on synthetic fixture (10k issues, 5k MRs)
++7. p95 list page fetch latency < 75ms using keyset pagination (10k issues, 5k MRs)
++8. EXPLAIN QUERY PLAN must show index usage for top 10 TUI queries
++9. No full table scan on issues/MRs/discussions under default filters
+
+@@
+-8. p95 search latency < 200ms on synthetic fixture (50k documents, lexical mode)
++10. p95 search latency < 200ms on synthetic fixture (50k documents, lexical mode)
+
++## 9.4 Required Indexes (GA blocker)
++- `issues(project_id, state, updated_at DESC, iid DESC)`
++- `merge_requests(project_id, state, updated_at DESC, iid DESC)`
++- `discussions(project_id, entity_type, entity_iid, created_at DESC)`
++- `notes(discussion_id, created_at ASC)`
+```
+
+### 6. Enforce `EntityKey` everywhere (remove bare IID paths)
+You correctly identified multi-project IID collisions, but many message/state signatures still use `i64`. Make `EntityKey` mandatory in all navigation and detail loaders.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ ## 4.3 Core Types
+-    IssueSelected(i64),
++    IssueSelected(EntityKey),
+@@
+-    MrSelected(i64),
++    MrSelected(EntityKey),
+@@
+-    IssueDetailLoaded(IssueDetail),
++    IssueDetailLoaded { key: EntityKey, detail: IssueDetail },
+@@
+-    MrDetailLoaded(MrDetail),
++    MrDetailLoaded { key: EntityKey, detail: MrDetail },
+
+@@ ## 10.10 State Module — Complete
+-                Cmd::msg(Msg::NavigateTo(Screen::IssueDetail(iid)))
++                Cmd::msg(Msg::NavigateTo(Screen::IssueDetail(entity_key)))
+```
+
+### 7. Harden filter/search semantics (strict parser + inline diagnostics + explain scores)
+Current filter parser silently ignores unknown fields; that causes hidden mistakes. Add strict parse diagnostics and search score explainability.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ ## 10.12.1 Filter Bar Widget
+-                _ => {} // Unknown fields silently ignored
++                _ => self.errors.push(format!("Unknown filter field: {}", token.field))
+
++    pub errors: Vec<String>,   // inline parse/validation errors
++    pub warnings: Vec<String>, // non-fatal coercions
+
+@@ ## 5.6 Search
+-- **Live preview:** Selected result shows snippet + metadata in right pane
++- **Live preview:** Selected result shows snippet + metadata in right pane
++- **Explain score:** Optional breakdown (lexical, semantic, recency, boosts) for trust/debug
+```
+
+### 8. Add operational resilience: safe mode + panic report + startup fallback
+TUI failures should degrade gracefully, not block usage.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ ## 3.1 Risk Matrix
++| Runtime panic leaves user blocked | High | Medium | Panic hook writes crash report, restores terminal, offers fallback CLI command |
+
+@@ ## 10.3 Entry Point
++pub fn launch_tui(config: Config, db_path: &Path) -> Result<(), LoreError> {
++    install_panic_hook_for_tui(); // terminal restore + crash dump path
++    ...
++}
+
+@@ ## 8.1 Global (Available Everywhere)
++| `:` | Show fallback equivalent CLI command for current screen/action |
+```
+
+### 9. Add a “jump list” (forward/back navigation, not only stack pop)
+Current model has only push/pop and reset. Add browser-like history for investigation workflows.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ ## 4.7 Navigation Stack Implementation
+ pub struct NavigationStack {
+-    stack: Vec<Screen>,
++    back_stack: Vec<Screen>,
++    current: Screen,
++    forward_stack: Vec<Screen>,
++    jump_list: Vec<Screen>, // recent entity/detail hops
+ }
+
+@@ ## 8.1 Global (Available Everywhere)
++| `Ctrl+o` | Jump backward in jump list |
++| `Ctrl+i` | Jump forward in jump list |
+```
+
+If you want, I can produce a single consolidated “PRD v2.1” patch that applies all nine revisions coherently section-by-section.

plans/tui-prd-v2-frankentui.feedback-3.md

@@ -0,0 +1,163 @@
+I excluded everything already listed in `## Rejected Recommendations`.  
+These are the highest-impact net-new revisions I’d make.
+
+1. **Enforce Entity Identity Consistency End-to-End (P0)**
+Analysis: The PRD defines `EntityKey`, but many code paths still pass bare `iid` (`IssueSelected(item.iid)`, timeline refs, search refs). In multi-project datasets this will cause wrong-entity navigation and subtle data corruption in cached state. Make `EntityKey` mandatory in every navigation message and add compile-time constructors.
+```diff
+@@ 4.3 Core Types
+ pub struct EntityKey {
+     pub project_id: i64,
+     pub iid: i64,
+     pub kind: EntityKind,
+ }
++impl EntityKey {
++    pub fn issue(project_id: i64, iid: i64) -> Self { Self { project_id, iid, kind: EntityKind::Issue } }
++    pub fn mr(project_id: i64, iid: i64) -> Self { Self { project_id, iid, kind: EntityKind::MergeRequest } }
++}
+
+@@ 10.10 state/issue_list.rs
+- .map(|item| Msg::IssueSelected(item.iid))
++ .map(|item| Msg::IssueSelected(EntityKey::issue(item.project_id, item.iid)))
+
+@@ 10.10 state/mr_list.rs
+- .map(|item| Msg::MrSelected(item.iid))
++ .map(|item| Msg::MrSelected(EntityKey::mr(item.project_id, item.iid)))
+```
+
+2. **Make TaskSupervisor Mandatory for All Background Work (P0)**
+Analysis: The plan introduces `TaskSupervisor` but still dispatches many direct `Cmd::task` calls. That will reintroduce stale updates, duplicate queries, and priority inversion under rapid input. Centralize all background task creation through one spawn path that enforces dedupe, cancellation tokening, and generation checks.
+```diff
+@@ 4.5.1 Task Supervisor (Dedup + Cancellation + Priority)
+-The supervisor is owned by `LoreApp` and consulted before dispatching any `Cmd::task`.
++The supervisor is owned by `LoreApp` and is the ONLY allowed path for background work.
++All task launches use `LoreApp::spawn_task(TaskKey, TaskPriority, closure)`.
+
+@@ 4.4 App — Implementing the Model Trait
+- Cmd::task(move || { ... })
++ self.spawn_task(TaskKey::LoadScreen(screen.clone()), TaskPriority::Navigation, move |token| { ... })
+```
+
+3. **Remove the Sync Streaming TODO and Make Real-Time Streaming a GA Gate (P0)**
+Analysis: Current text admits sync progress is buffered with a TODO. That undercuts one of the main value props. Make streaming progress/log delivery non-optional, with bounded buffers and dropped-line accounting.
+```diff
+@@ 4.4 start_sync_task()
+- // TODO: Register rx as subscription when FrankenTUI supports it.
+- // For now, the task returns the final Msg and progress is buffered.
++ // Register rx as a live subscription (`Subscription::from_receiver` adapter).
++ // Progress and logs must render in real time (no batch-at-end fallback).
++ // Keep a bounded ring buffer (N=5000) and surface `dropped_log_lines` in UI.
+
+@@ 9.3 Phase 0 — Toolchain Gate
++11. Real-time sync stream verified: progress updates visible during run, not only at completion.
+```
+
+4. **Upgrade List/Search Data Strategy to Windowed Keyset + Prefetch (P0)**
+Analysis: “Virtualized list” alone does not solve query/transfer cost if full result sets are loaded. Move to fixed-size keyset windows with next-window prefetch and fast first paint; this keeps latency predictable on 100k+ records.
+```diff
+@@ 5.2 Issue List
+- Pagination: Virtual scrolling for large result sets
++ Pagination: Windowed keyset pagination (window=200 rows) with background prefetch of next window.
++ First paint uses current window only; no full-result materialization.
+
+@@ 5.4 MR List
++ Same windowed keyset pagination strategy as Issue List.
+
+@@ 9.3 Success criteria
+- 7. p95 list page fetch latency < 75ms using keyset pagination on synthetic fixture (10k issues, 5k MRs)
++ 7. p95 first-paint latency < 50ms and p95 next-window fetch < 75ms on synthetic fixture (100k issues, 50k MRs)
+```
+
+5. **Add Resumable Sync Checkpoints + Per-Project Fault Isolation (P1)**
+Analysis: If sync is interrupted or one project fails, current design mostly falls back to cancel/fail. Add checkpoints so long runs can resume, and isolate failures to project/resource scope while continuing others.
+```diff
+@@ 3.1 Risk Matrix
++| Interrupted sync loses progress | High | Medium | Persist phase checkpoints and offer resume |
+
+@@ 5.9 Sync
++Running mode: failed project/resource lanes are marked degraded while other lanes continue.
++Summary mode: offer `[R]esume interrupted sync` from last checkpoint.
+
+@@ 11 Assumptions
+-16. No new SQLite tables needed (but required indexes must be verified — see Performance SLOs).
++16. Add minimal internal tables for reliability: `sync_runs` and `sync_checkpoints` (append-only metadata).
+```
+
+6. **Add Capability-Adaptive Rendering Modes (P1)**
+Analysis: Terminal compatibility is currently test-focused, but runtime adaptation is under-specified. Add explicit degradations for no-truecolor, no-unicode, slow SSH/tmux paths to reduce rendering artifacts and support incidents.
+```diff
+@@ 3.4 Terminal Compatibility Testing
++Add capability matrix validation: truecolor/256/16 color, unicode/ascii glyphs, alt-screen on/off.
+
+@@ 10.19 CLI Integration
++Tui {
++  #[arg(long, default_value="auto")] render_mode: String, // auto|full|minimal
++  #[arg(long)] ascii: bool,
++  #[arg(long)] no_alt_screen: bool,
++}
+```
+
+7. **Harden Browser/Open and Log Privacy (P1)**
+Analysis: `open_current_in_browser` currently trusts stored URLs; sync logs may expose tokens/emails from upstream messages. Add host allowlisting and redaction pipeline by default.
+```diff
+@@ 4.4 open_current_in_browser()
+- if let Some(url) = url { ... open ... }
++ if let Some(url) = url {
++   if !self.state.security.is_allowed_gitlab_url(&url) {
++     self.state.set_error("Blocked non-GitLab URL".into());
++     return;
++   }
++   ... open ...
++ }
+
+@@ 5.9 Sync
++Log stream passes through redaction (tokens, auth headers, email local-parts) before render/storage.
+```
+
+8. **Add “My Workbench” Screen for Daily Pull (P1, new feature)**
+Analysis: The PRD is strong on exploration, weaker on “what should I do now?”. Add a focused operator screen aggregating assigned issues, requested reviews, unresolved threads mentioning me, and stale approvals. This makes the TUI habit-forming.
+```diff
+@@ 5. Screen Taxonomy
++### 5.12 My Workbench
++Single-screen triage cockpit:
++- Assigned-to-me open issues/MRs
++- Review requests awaiting action
++- Threads mentioning me and unresolved
++- Recently stale approvals / blocked MRs
+
+@@ 8.1 Global
++| `gb` | Go to My Workbench |
+
+@@ 9.2 Phases
++section Phase 3.5 — Daily Workflow
++My Workbench screen + queries :p35a, after p3d, 2d
+```
+
+9. **Add Rollout, SLO Telemetry, and Kill-Switch Plan (P0)**
+Analysis: You have implementation phases but no production rollout control. Add explicit experiment flags, health telemetry, and rollback criteria so risk is operationally bounded.
+```diff
+@@ Table of Contents
+-11. [Assumptions](#11-assumptions)
++11. [Assumptions](#11-assumptions)
++12. [Rollout & Telemetry](#12-rollout--telemetry)
+
+@@ NEW SECTION 12
++## 12. Rollout & Telemetry
++- Feature flags: `tui_experimental`, `tui_sync_streaming`, `tui_workbench`
++- Metrics: startup_ms, frame_render_p95_ms, db_busy_rate, panic_free_sessions, sync_drop_events
++- Kill-switch: disable `tui` feature path at runtime if panic rate > 0.5% sessions over 24h
++- Canary rollout: internal only -> opt-in beta -> default-on
+```
+
+10. **Strengthen Reliability Pack with Event-Fuzz + Soak Tests (P0)**
+Analysis: Current tests are good but still light on prolonged event pressure. Add deterministic fuzzed key/resize/paste streams and a long soak to catch rare deadlocks/leaks and state corruption.
+```diff
+@@ 9.2 Phase 5.5 — Reliability Test Pack
++Event fuzz tests (key/resize/paste interleavings) :p55g, after p55e, 1d
++30-minute soak test (no panic, bounded memory)    :p55h, after p55g, 1d
+
+@@ 9.3 Success criteria
++12. Event-fuzz suite passes with zero invariant violations across 10k randomized traces.
++13. 30-minute soak: no panic, no deadlock, memory growth < 5%.
+```
+
+If you want, I can produce a single consolidated unified diff of the full PRD text next (all edits merged, ready to apply as v3).

plans/tui-prd-v2-frankentui.feedback-4.md

@@ -0,0 +1,157 @@
+Below are my strongest revisions, focused on correctness, reliability, and long-term maintainability, while avoiding all items in your `## Rejected Recommendations`.
+
+1. **Fix the Cargo/toolchain architecture (current plan has a real dependency-cycle risk and shaky per-member toolchain behavior).**  
+Analysis: The current plan has `lore -> lore-tui (optional)` and `lore-tui -> lore`, which creates a package cycle when `tui` is enabled. Also, per-member `rust-toolchain.toml` in a workspace is easy to misapply in CI/dev workflows. The cleanest robust shape is: `lore-tui` is a separate binary crate (nightly), `lore` remains stable and delegates at runtime (`lore tui` shells out to `lore-tui`).  
+```diff
+--- a/Gitlore_TUI_PRD_v2.md
++++ b/Gitlore_TUI_PRD_v2.md
+@@ 3.2 Nightly Rust Strategy
+-- The `lore` binary integrates TUI via `lore tui` subcommand. The `lore-tui` crate is a library dependency feature-gated in the root.
++- `lore-tui` is a separate binary crate built on pinned nightly.
++- `lore` (stable) does not compile-link `lore-tui`; `lore tui` delegates by spawning `lore-tui`.
++- This removes Cargo dependency-cycle risk and keeps stable builds nightly-free.
+@@ 9.1 Dependency Changes
+-[features]
+-tui = ["dep:lore-tui"]
+-[dependencies]
+-lore-tui = { path = "crates/lore-tui", optional = true }
++[dependencies]
++# no compile-time dependency on lore-tui from lore
++# runtime delegation keeps toolchains isolated
+@@ 10.19 CLI Integration
+-Add Tui match arm that directly calls crate::tui::launch_tui(...)
++Add Tui match arm that resolves and spawns `lore-tui` with passthrough args.
++If missing, print actionable install/build command.
+```
+
+2. **Make `TaskSupervisor` the *actual* single async path (remove contradictory direct `Cmd::task` usage in state handlers).**  
+Analysis: You declare “direct `Cmd::task` is prohibited outside supervisor,” but later `handle_screen_msg` still launches tasks directly. That contradiction will reintroduce stale-result bugs and race conditions. Make state handlers pure (intent-only); all async launch/cancel/dedup goes through one supervised API.  
+```diff
+--- a/Gitlore_TUI_PRD_v2.md
++++ b/Gitlore_TUI_PRD_v2.md
+@@ 4.5.1 Task Supervisor
+-The supervisor is the ONLY allowed path for background work.
++The supervisor is the ONLY allowed path for background work, enforced by architecture:
++`AppState` emits intents only; `LoreApp::update` launches tasks via `spawn_task(...)`.
+@@ 10.10 State Module — Complete
+-pub fn handle_screen_msg(..., db: &Arc<Mutex<Connection>>) -> Cmd<Msg>
++pub fn handle_screen_msg(...) -> ScreenIntent
++// no DB access, no Cmd::task in state layer
+```
+
+3. **Enforce `EntityKey` everywhere (remove raw IID navigation paths).**  
+Analysis: Multi-project identity is one of your strongest ideas, but multiple snippets still navigate by bare IID (`document_id`, `EntityRef::Issue(i64)`). That can misroute across projects and create silent correctness bugs. Make all navigation-bearing results carry `EntityKey` end-to-end.  
+```diff
+--- a/Gitlore_TUI_PRD_v2.md
++++ b/Gitlore_TUI_PRD_v2.md
+@@ 4.3 Core Types
+-pub enum EntityRef { Issue(i64), MergeRequest(i64) }
++pub enum EntityRef { Issue(EntityKey), MergeRequest(EntityKey) }
+@@ 10.10 state/search.rs
+-Some(Msg::NavigateTo(Screen::IssueDetail(r.document_id)))
++Some(Msg::NavigateTo(Screen::IssueDetail(r.entity_key.clone())))
+@@ 10.11 action.rs
+-pub fn fetch_issue_detail(conn: &Connection, iid: i64) -> Result<IssueDetail, LoreError>
++pub fn fetch_issue_detail(conn: &Connection, key: &EntityKey) -> Result<IssueDetail, LoreError>
+```
+
+4. **Introduce a shared query boundary inside the existing crate (not a new crate) to decouple TUI from CLI presentation structs.**  
+Analysis: Reusing CLI command modules directly is fast initially, but it ties TUI to output-layer types and command concerns. A minimal internal `core::query::*` module gives a stable data contract used by both CLI and TUI without the overhead of a new crate split.  
+```diff
+--- a/Gitlore_TUI_PRD_v2.md
++++ b/Gitlore_TUI_PRD_v2.md
+@@ 10.2 Modified Files
+-src/cli/commands/list.rs   # extract query_issues/query_mrs as pub
+-src/cli/commands/show.rs   # extract query_issue_detail/query_mr_detail as pub
++src/core/query/mod.rs
++src/core/query/issues.rs
++src/core/query/mrs.rs
++src/core/query/detail.rs
++src/core/query/search.rs
++src/core/query/who.rs
++src/cli/commands/* now call core::query::* + format output
++TUI action.rs calls core::query::* directly
+```
+
+5. **Add terminal-safety sanitization for untrusted text (ANSI/OSC injection hardening).**  
+Analysis: Issue/MR bodies, notes, and logs are untrusted text in a terminal context. Without sanitization, terminal escape/control sequences can spoof UI or trigger unintended behavior. Add explicit sanitization and a strict URL policy before rendering/opening.  
+```diff
+--- a/Gitlore_TUI_PRD_v2.md
++++ b/Gitlore_TUI_PRD_v2.md
+@@ 3.1 Risk Matrix
++| Terminal escape/control-sequence injection via issue/note text | High | Medium | Strip ANSI/OSC/control chars before render; escape markdown output; allowlist URL scheme+host |
+@@ 4.1 Module Structure
++    safety.rs                      # sanitize_for_terminal(), safe_url_policy()
+@@ 10.5/10.8/10.14/10.16
++All user-sourced text passes through `sanitize_for_terminal()` before widget rendering.
++Disable markdown raw HTML and clickable links unless URL policy passes.
+```
+
+6. **Move resumable sync checkpoints into v1 (lightweight version).**  
+Analysis: You already identify interruption risk as real. Deferring resumability to post-v1 leaves a major reliability gap in exactly the heaviest workflow. A lightweight checkpoint table (resource cursor + updated-at watermark) gives large reliability gain with modest complexity.  
+```diff
+--- a/Gitlore_TUI_PRD_v2.md
++++ b/Gitlore_TUI_PRD_v2.md
+@@ 3.1 Risk Matrix
+-- Resumable checkpoints planned for post-v1
++Resumable checkpoints included in v1 (lightweight cursors per project/resource lane)
+@@ 9.3 Success Criteria
++14. Interrupt-and-resume test: sync resumes from checkpoint and reaches completion without full restart.
+@@ 9.3.1 Required Indexes (GA Blocker)
++CREATE TABLE IF NOT EXISTS sync_checkpoints (
++  project_id INTEGER NOT NULL,
++  lane TEXT NOT NULL,
++  cursor TEXT,
++  updated_at_ms INTEGER NOT NULL,
++  PRIMARY KEY (project_id, lane)
++);
+```
+
+7. **Strengthen performance gates with tiered fixtures and memory ceilings.**  
+Analysis: Current thresholds are good, but fixture sizes are too close to mid-scale only. Add S/M/L fixtures and memory budget checks so regressions appear before real-world datasets hit them. This gives much more confidence in long-term scalability.  
+```diff
+--- a/Gitlore_TUI_PRD_v2.md
++++ b/Gitlore_TUI_PRD_v2.md
+@@ 9.3 Phase 0 — Toolchain Gate
+-7. p95 first-paint latency < 50ms ... (100k issues, 50k MRs)
+-10. p95 search latency < 200ms ... (50k documents)
++7. Tiered fixtures:
++   S: 10k issues / 5k MRs / 50k notes
++   M: 100k issues / 50k MRs / 500k notes
++   L: 250k issues / 100k MRs / 1M notes
++   Enforce p95 targets per tier and memory ceiling (<250MB RSS in M tier).
++10. Search SLO validated in S and M tiers, lexical and hybrid modes.
+```
+
+8. **Add session restore (last screen + filters + selection), with explicit `--fresh` opt-out.**  
+Analysis: This is high-value daily UX with low complexity, and it makes the TUI feel materially more “compelling/useful” without feature bloat. It also reduces friction when recovering from crash/restart.  
+```diff
+--- a/Gitlore_TUI_PRD_v2.md
++++ b/Gitlore_TUI_PRD_v2.md
+@@ 1. Executive Summary
++- **Session restore** — resume last screen, filters, and selection on startup.
+@@ 4.1 Module Structure
++    session.rs                    # persisted UI session state
+@@ 8.1 Global
++| `Ctrl+R` | Reset session state for current screen |
+@@ 10.19 CLI Integration
++`lore tui --fresh` starts without restoring prior session state.
+@@ 11. Assumptions
+-12. No TUI-specific configuration initially.
++12. Minimal TUI state file is allowed for session restore only.
+```
+
+9. **Add parity tests between TUI data panels and `--robot` outputs.**  
+Analysis: You already have `ShowCliEquivalent`; parity tests make that claim trustworthy and prevent drift between interfaces. This is a strong reliability multiplier and helps future refactors.  
+```diff
+--- a/Gitlore_TUI_PRD_v2.md
++++ b/Gitlore_TUI_PRD_v2.md
+@@ 9.2 Phases / 9.3 Success Criteria
++Phase 5.6 — CLI/TUI Parity Pack
++  - Dashboard count parity vs `lore --robot count/status`
++  - List/detail parity for issues/MRs on sampled entities
++  - Search result identity parity (top-N ids) for lexical mode
++Success criterion: parity suite passes on CI fixtures.
+```
+
+If you want, I can produce a single consolidated patch of the PRD text (one unified diff) so you can drop it directly into the next iteration.

plans/tui-prd-v2-frankentui.feedback-5.md

@@ -0,0 +1,200 @@
+1. **Fix the structural inconsistency between `src/tui` and `crates/lore-tui/src`**
+Analysis: The PRD currently defines two different code layouts for the same system. That will cause implementation drift, wrong imports, and duplicated modules. Locking to one canonical layout early prevents execution churn and makes every snippet/action item unambiguous.
+
+```diff
+@@ 4.1 Module Structure @@
+-src/
+-  tui/
++crates/lore-tui/src/
+     mod.rs
+     app.rs
+     message.rs
+@@
+-### 10.5 Dashboard View (FrankenTUI Native)
+-// src/tui/view/dashboard.rs
++### 10.5 Dashboard View (FrankenTUI Native)
++// crates/lore-tui/src/view/dashboard.rs
+@@
+-### 10.6 Sync View
+-// src/tui/view/sync.rs
++### 10.6 Sync View
++// crates/lore-tui/src/view/sync.rs
+```
+
+2. **Add a small `ui_adapter` seam to contain FrankenTUI API churn**
+Analysis: You already identified high likelihood of upstream breakage. Pinning a commit helps, but if every screen imports raw `ftui_*` types directly, churn ripples through dozens of files. A thin adapter layer reduces upgrade cost without introducing the rejected “full portability abstraction”.
+
+```diff
+@@ 3.1 Risk Matrix @@
+ | API breaking changes | High | High (v0.x) | Pin exact git commit; vendor source if needed |
++| API breakage blast radius across app code | High | High | Constrain ftui usage behind `ui_adapter/*` wrappers |
+
+@@ 4.1 Module Structure @@
++    ui_adapter/
++      mod.rs                    # Re-export stable local UI primitives
++      runtime.rs                # App launch/options wrappers
++      widgets.rs                # Table/List/Modal wrapper constructors
++      input.rs                  # Text input + focus helpers
+
+@@ 9.3 Phase 0 — Toolchain Gate @@
++14. `ui_adapter` compile-check: no screen module imports `ftui_*` directly (lint-enforced)
+```
+
+3. **Correct search mode behavior and replace sleep-based debounce with cancelable scheduling**
+Analysis: Current plan hardcodes `"hybrid"` in `execute_search`, so mode switching is UI-only and incorrect. Also, spawning sleeping tasks per keypress is wasteful under fast typing. Make mode a first-class query parameter and debounce via one cancelable scheduled event per input domain.
+
+```diff
+@@ 4.4 maybe_debounced_query @@
+-std::thread::sleep(std::time::Duration::from_millis(200));
+-match crate::tui::action::execute_search(&conn, &query, &filters) {
++// no thread sleep; schedule SearchRequestStarted after 200ms via debounce scheduler
++match crate::tui::action::execute_search(&conn, &query, &filters, mode) {
+
+@@ 10.11 Action Module — Query Bridge @@
+-pub fn execute_search(conn: &Connection, query: &str, filters: &SearchCliFilters) -> Result<SearchResponse, LoreError> {
+-    let mode_str = "hybrid"; // default; TUI mode selector overrides
++pub fn execute_search(
++    conn: &Connection,
++    query: &str,
++    filters: &SearchCliFilters,
++    mode: SearchMode,
++) -> Result<SearchResponse, LoreError> {
++    let mode_str = match mode {
++        SearchMode::Hybrid => "hybrid",
++        SearchMode::Lexical => "lexical",
++        SearchMode::Semantic => "semantic",
++    };
+
+@@ 9.3 Phase 0 — Toolchain Gate @@
++15. Search mode parity: lexical/hybrid/semantic each return mode-consistent top-N IDs on fixture
+```
+
+4. **Guarantee consistent multi-query reads and add query interruption for responsiveness**
+Analysis: Detail screens combine multiple queries that can observe mixed states during sync writes. Wrap each detail fetch in a single read transaction for snapshot consistency. Add cancellation/interrupt checks for long-running queries so UI remains responsive under heavy datasets.
+
+```diff
+@@ 4.5 Async Action System @@
++All detail fetches (`issue_detail`, `mr_detail`, timeline expansion) run inside one read transaction
++to guarantee snapshot consistency across subqueries.
+
+@@ 10.11 Action Module — Query Bridge @@
++pub fn with_read_snapshot<T>(
++    conn: &Connection,
++    f: impl FnOnce(&rusqlite::Transaction<'_>) -> Result<T, LoreError>,
++) -> Result<T, LoreError> { ... }
+
++// Long queries register interrupt checks tied to CancelToken
++// to avoid >1s uninterruptible stalls during rapid navigation/filtering.
+```
+
+5. **Formalize sync event streaming contract to prevent “stuck” states**
+Analysis: Dropping events on backpressure is acceptable, but completion must never be dropped and event ordering must be explicit. Add a typed `SyncUiEvent` stream with guaranteed terminal sentinel and progress coalescing to reduce load while preserving correctness.
+
+```diff
+@@ 4.4 start_sync_task @@
+-let (tx, rx) = std::sync::mpsc::sync_channel::<Msg>(1024);
++let (tx, rx) = std::sync::mpsc::sync_channel::<SyncUiEvent>(2048);
+
+-// drop this progress update rather than blocking the sync thread
++// coalesce progress to max 30Hz per lane; never drop terminal events
++// always emit SyncUiEvent::StreamClosed { outcome }
+
+@@ 5.9 Sync @@
+-- Log viewer with streaming output
++- Log viewer with streaming output and explicit stream-finalization state
++- UI shows dropped/coalesced event counters for transparency
+```
+
+6. **Version and validate session restore payloads**
+Analysis: A raw JSON session file without schema/version checks is fragile across releases and DB switches. Add schema version, DB fingerprint, and safe fallback rules so session restore never blocks startup or applies stale state incorrectly.
+
+```diff
+@@ 11. Assumptions @@
+-12. Minimal TUI state file allowed for session restore only ...
++12. Versioned TUI state file allowed for session restore only:
++    fields include `schema_version`, `app_version`, `db_fingerprint`, `saved_at`, `state`.
+
+@@ 10.1 New Files @@
+ crates/lore-tui/src/session.rs         # Lightweight session state persistence
++                                        # + versioning, validation, corruption quarantine
+
+@@ 4.1 Module Structure @@
+     session.rs                    # Lightweight session state persistence
++                                  # corrupted file -> `.bad-<timestamp>` and fresh start
+```
+
+7. **Harden terminal safety beyond ANSI stripping**
+Analysis: ANSI stripping is necessary but not sufficient. Bidi controls and invisible Unicode controls can still spoof displayed content. URL checks should normalize host/port and disallow deceptive variants. This closes realistic terminal spoofing vectors.
+
+```diff
+@@ 3.1 Risk Matrix @@
+ | Terminal escape/control-sequence injection via issue/note text | High | Medium | Strip ANSI/OSC/control chars via sanitize_for_terminal() ... |
++| Bidi/invisible Unicode spoofing in rendered text | High | Medium | Strip bidi overrides + zero-width controls in untrusted text |
+
+@@ 10.4.1 Terminal Safety — Untrusted Text Sanitization @@
+-Strip ANSI escape sequences, OSC commands, and control characters
++Strip ANSI/OSC/control chars, bidi overrides (RLO/LRO/PDF/RLI/LRI/FSI/PDI),
++and zero-width/invisible controls from untrusted text
+
+-pub fn is_safe_url(url: &str, allowed_hosts: &[String]) -> bool {
++pub fn is_safe_url(url: &str, allowed_origins: &[Origin]) -> bool {
++    // normalize host (IDNA), enforce scheme+host+port match
+```
+
+8. **Use progressive hydration for detail screens**
+Analysis: Issue/MR detail first-paint can become slow when discussions are large. Split fetch into phases: metadata first, then discussions/file changes, then deep thread content on expand. This improves perceived performance and keeps navigation snappy on large repos.
+
+```diff
+@@ 5.3 Issue Detail @@
+-Data source: `lore issues <iid>` + discussions + cross-references
++Data source (progressive):
++1) metadata/header (first paint)
++2) discussions summary + cross-refs
++3) full thread bodies loaded on demand when expanded
+
+@@ 5.5 MR Detail @@
+-Unique features: File changes list, Diff discussions ...
++Unique features (progressive hydration):
++- file change summary in first paint
++- diff discussion bodies loaded lazily per expanded thread
+
+@@ 9.3 Phase 0 — Toolchain Gate @@
++16. Detail first-paint p95 < 75ms on M-tier fixtures (metadata-only phase)
+```
+
+9. **Make reliability tests reproducible with deterministic clocks/seeds**
+Analysis: Relative-time rendering and fuzz tests are currently tied to wall clock/randomness, which makes CI flakes hard to diagnose. Introduce a `Clock` abstraction and deterministic fuzz seeds with failure replay output.
+
+```diff
+@@ 10.9.1 Non-Snapshot Tests @@
++/// All time-based rendering uses injected `Clock` in tests.
++/// Fuzz failures print deterministic seed for replay.
+
+@@ 9.2 Phase 5.5 — Reliability Test Pack @@
+-Event fuzz tests (key/resize/paste):p55g
++Event fuzz tests (key/resize/paste, deterministic seed replay):p55g
++Deterministic clock/render tests:p55i
+```
+
+10. **Add an “Actionable Insights” dashboard panel for stronger day-to-day utility**
+Analysis: Current dashboard is informative, but not prioritizing. Adding ranked insights (stale P1s, blocked MRs, discussion hotspots) turns it into a decision surface, not just a metrics screen. This makes the TUI materially more compelling for triage workflows.
+
+```diff
+@@ 1. Executive Summary @@
+ - Dashboard — sync status, project health, counts at a glance
++- Dashboard — sync status, project health, counts, and ranked actionable insights
+
+@@ 5.1 Dashboard (Home Screen) @@
+-│  Recent Activity                  │
++│  Recent Activity                  │
++│  Actionable Insights              │
++│  1) 7 opened P1 issues >14d       │
++│  2) 3 MRs blocked by unresolved   │
++│  3) auth/ has +42% note velocity  │
+
+@@ 6. User Flows @@
++### 6.9 Flow: "Risk-first morning sweep"
++Dashboard -> select insight -> jump to pre-filtered list/detail
+```
+
+These 10 changes stay clear of your `Rejected Recommendations` list and materially improve correctness, operability, and product value without adding speculative architecture.

plans/tui-prd-v2-frankentui.feedback-6.md

@@ -0,0 +1,150 @@
+Your plan is strong and unusually detailed. The biggest upgrades I’d make are around build isolation, async correctness, terminal correctness, and turning existing data into sharper triage workflows.
+
+## 1) Fix toolchain isolation so stable builds cannot accidentally pull nightly
+Rationale: a `rust-toolchain.toml` inside `crates/lore-tui` is not a complete guard when running workspace commands from repo root. You should structurally prevent stable workflows from touching nightly-only code.
+
+```diff
+@@ 3.2 Nightly Rust Strategy
+-[workspace]
+-members = [".", "crates/lore-tui"]
++[workspace]
++members = ["."]
++exclude = ["crates/lore-tui"]
+
++`crates/lore-tui` is built as an isolated workspace/package with explicit toolchain invocation:
++  cargo +nightly-2026-02-08 check --manifest-path crates/lore-tui/Cargo.toml
++Core repo remains:
++  cargo +stable check --workspace
+```
+
+## 2) Add an explicit `lore` <-> `lore-tui` compatibility contract
+Rationale: runtime delegation is correct, but version drift between binaries will become the #1 support failure mode. Add a handshake before launch.
+
+```diff
+@@ 10.19 CLI Integration — Adding `lore tui`
++Before spawning `lore-tui`, `lore` runs:
++  lore-tui --print-contract-json
++and validates:
++  - minimum_core_version
++  - supported_db_schema_range
++  - contract_version
++On mismatch, print actionable remediation:
++  cargo install --path crates/lore-tui
+```
+
+## 3) Make TaskSupervisor truly authoritative (remove split async paths)
+Rationale: the document says supervisor is the only path, but examples still use direct `Cmd::task` and `search_request_id`. Close that contradiction now to avoid stale-data races.
+
+```diff
+@@ 4.4 App — Implementing the Model Trait
+-    search_request_id: u64,
++    task_supervisor: TaskSupervisor,
+
+@@ 4.5.1 Task Supervisor
+-The `search_request_id` field in `LoreApp` is superseded...
++`search_request_id` is removed. All async work uses TaskSupervisor generations.
++No direct `Cmd::task` from screen handlers or ad-hoc helpers.
+```
+
+## 4) Resolve keybinding conflicts and implement real go-prefix timeout
+Rationale: `Ctrl+I` collides with `Tab` in terminals. Also your 500ms go-prefix timeout is described but not enforced in code.
+
+```diff
+@@ 8.1 Global (Available Everywhere)
+-| `Ctrl+I` | Jump forward in jump list (entity hops) |
++| `Alt+o` | Jump forward in jump list (entity hops) |
+
+@@ 8.2 Keybinding precedence
++Go-prefix timeout is enforced by timestamped state + tick check.
++Backspace global-back behavior is implemented (currently documented but not wired).
+```
+
+## 5) Add a shared display-width text utility (Unicode-safe truncation and alignment)
+Rationale: current `truncate()` implementations use byte/char length and will misalign CJK/emoji/full-width text in tables and trees.
+
+```diff
+@@ 10.1 New Files
++crates/lore-tui/src/text_width.rs      # grapheme-safe truncation + display width helpers
+
+@@ 10.5 Dashboard View / 10.13 Issue List / 10.16 Who View
+-fn truncate(s: &str, max: usize) -> String { ... }
++use crate::text_width::truncate_display_width;
++// all column fitting/truncation uses terminal display width, not bytes/chars
+```
+
+## 6) Upgrade sync streaming to a QoS event bus with sequence IDs
+Rationale: today progress/log events can be dropped under load with weak observability. Keep UI responsive while guaranteeing completion semantics and visible gap accounting.
+
+```diff
+@@ 4.4 start_sync_task()
+-let (tx, rx) = std::sync::mpsc::sync_channel::<SyncUiEvent>(2048);
++let (ctrl_tx, ctrl_rx) = std::sync::mpsc::sync_channel::<SyncCtrlEvent>(256);   // never-drop
++let (data_tx, data_rx) = std::sync::mpsc::sync_channel::<SyncDataEvent>(4096);   // coalescible
+
++Every streamed event carries seq_no.
++UI detects gaps and renders: "Dropped N log/progress events due to backpressure."
++Terminal events (started/completed/failed/cancelled) remain lossless.
+```
+
+## 7) Make list pagination truly keyset-driven in state, not just in prose
+Rationale: plan text promises windowed keyset paging, but state examples still keep a single list without cursor model. Encode pagination state explicitly.
+
+```diff
+@@ 10.10 state/issue_list.rs
+-pub items: Vec<IssueListRow>,
++pub window: Vec<IssueListRow>,
++pub next_cursor: Option<IssueCursor>,
++pub prev_cursor: Option<IssueCursor>,
++pub prefetch: Option<Vec<IssueListRow>>,
++pub window_size: usize, // default 200
+
+@@ 5.2 Issue List
+-Pagination: Windowed keyset pagination...
++Pagination: Keyset cursor model is first-class state with forward/back cursors and prefetch buffer.
+```
+
+## 8) Harden session restore with atomic persistence + integrity checksum
+Rationale: versioning/quarantine is good, but you still need crash-safe write semantics and tamper/corruption detection to avoid random boot failures.
+
+```diff
+@@ 10.1 New Files
+-crates/lore-tui/src/session.rs         # Versioned session state persistence + validation + corruption quarantine
++crates/lore-tui/src/session.rs         # + atomic write (tmp->fsync->rename), checksum, max-size guard
+
+@@ 11. Assumptions
++Session writes are atomic and checksummed.
++Invalid checksum or oversized file triggers quarantine and fresh boot.
+```
+
+## 9) Evolve Doctor from read-only text into actionable remediation
+Rationale: your CLI already returns machine-actionable `actions`. TUI should surface those as one-key fixes; this materially increases usefulness.
+
+```diff
+@@ 5.11 Doctor / Stats (Info Screens)
+-Simple read-only views rendering the output...
++Doctor is interactive:
++  - shows health checks + severity
++  - exposes suggested `actions` from robot-mode errors
++  - Enter runs selected action command (with confirmation modal)
++Stats remains read-only.
+```
+
+## 10) Add a Dependency Lens to Issue/MR detail (high-value triage feature)
+Rationale: you already have cross-refs + discussions + timeline. A compact dependency panel (blocked-by / blocks / unresolved threads) makes this data operational for prioritization.
+
+```diff
+@@ 5.3 Issue Detail
+-│ ┌─ Cross-References ─────────────────────────────────────────┐ │
++│ ┌─ Dependency Lens ──────────────────────────────────────────┐ │
++│ │ Blocked by: #1198 (open, stale 9d)                        │ │
++│ │ Blocks: !458 (opened, 2 unresolved threads)               │ │
++│ │ Risk: High (P1 + stale blocker + open MR discussion)      │ │
++│ └────────────────────────────────────────────────────────────┘ │
+
+@@ 9.2 Phases
++Dependency Lens (issue/mr detail, computed risk score) :p3e, after p2e, 1d
+```
+
+---
+
+If you want, I can next produce a consolidated **“v2.1 patch”** of the PRD with all these edits merged into one coherent updated document structure.

plans/tui-prd-v2-frankentui.feedback-7.md

@@ -0,0 +1,264 @@
+1. **Fix a critical contradiction in workspace/toolchain isolation**
+Rationale: Section `3.2` says `crates/lore-tui` is excluded from the root workspace, but Section `9.1` currently adds it as a member. That inconsistency will cause broken CI/tooling behavior and confusion about whether stable-only workflows remain safe.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ 9.1 Dependency Changes
+-# Root Cargo.toml changes
+-[workspace]
+-members = [".", "crates/lore-tui"]
++# Root Cargo.toml changes
++[workspace]
++members = ["."]
++exclude = ["crates/lore-tui"]
+@@
+-# Add workspace member (no lore-tui dep, no tui feature)
++# Keep lore-tui EXCLUDED from root workspace (nightly isolation boundary)
+@@ 9.3 Phase 0 — Toolchain Gate
+-1. `cargo check --all-targets` passes on pinned nightly (TUI crate) and stable (core)
++1. `cargo +stable check --workspace --all-targets` passes for root workspace
++2. `cargo +nightly-2026-02-08 check --manifest-path crates/lore-tui/Cargo.toml --all-targets` passes
+```
+
+2. **Replace global loading spinner with per-screen stale-while-revalidate**
+Rationale: A single `is_loading` flag causes full-screen flicker and blocked context during quick refreshes. Per-screen load states keep existing data visible while background refresh runs, improving perceived performance and usability.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ 10.10 State Module — Complete
+-    pub is_loading: bool,
++    pub load_state: ScreenLoadStateMap,
+@@
+-    pub fn set_loading(&mut self, loading: bool) {
+-        self.is_loading = loading;
+-    }
++    pub fn set_loading(&mut self, screen: ScreenId, state: LoadState) {
++        self.load_state.insert(screen, state);
++    }
++
++pub enum LoadState {
++    Idle,
++    LoadingInitial,
++    Refreshing,      // stale data remains visible
++    Error(String),
++}
+@@ 4.4 App — Implementing the Model Trait
+-        // Loading spinner overlay (while async data is fetching)
+-        if self.state.is_loading {
+-            crate::tui::view::common::render_loading(frame, body);
+-        } else {
+-            match self.navigation.current() { ... }
+-        }
++        // Always render screen; show lightweight refresh indicator when needed.
++        match self.navigation.current() { ... }
++        crate::tui::view::common::render_refresh_indicator_if_needed(
++            self.navigation.current(), &self.state.load_state, frame, body
++        );
+```
+
+3. **Make `TaskSupervisor` a real scheduler (not just token registry)**
+Rationale: Current design declares priority lanes but still dispatches directly with `Cmd::task`, and debounce uses `thread::sleep` per keystroke (wastes worker threads). A bounded scheduler with queued tasks and timer-driven debounce will reduce contention and tail latency.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ 4.5.1 Task Supervisor (Dedup + Cancellation + Priority)
+-pub struct TaskSupervisor {
+-    active: HashMap<TaskKey, Arc<CancelToken>>,
+-    generation: AtomicU64,
+-}
++pub struct TaskSupervisor {
++    active: HashMap<TaskKey, Arc<CancelToken>>,
++    generation: AtomicU64,
++    queue: BinaryHeap<ScheduledTask>,
++    inflight: HashMap<TaskPriority, usize>,
++    limits: TaskLaneLimits, // e.g. Input=4, Navigation=2, Background=1
++}
+@@
+-// 200ms debounce via cancelable scheduled event (not thread::sleep).
+-Cmd::task(move || {
+-    std::thread::sleep(std::time::Duration::from_millis(200));
+-    ...
+-})
++// Debounce via runtime timer message; no sleeping worker thread.
++self.state.search.debounce_deadline = Some(now + 200ms);
++Cmd::none()
+@@ 4.4 update()
++Msg::Tick => {
++    if self.state.search.debounce_expired(now) {
++        return self.dispatch_supervised(TaskKey::Search, TaskPriority::Input, ...);
++    }
++    self.task_supervisor.dispatch_ready(now)
++}
+```
+
+4. **Add a sync run ledger for exact “new since sync” navigation**
+Rationale: “Since last sync” based on timestamps is ambiguous with partial failures, retries, and clock drift. A lightweight `sync_runs` + `sync_deltas` ledger makes summary-mode drill-down exact and auditable without implementing full resumable checkpoints.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ 5.9 Sync
+-- `i` navigates to Issue List pre-filtered to "since last sync"
+-- `m` navigates to MR List pre-filtered to "since last sync"
++- `i` navigates to Issue List pre-filtered to `sync_run_id=<last_run>`
++- `m` navigates to MR List pre-filtered to `sync_run_id=<last_run>`
++- Filters are driven by persisted `sync_deltas` rows (exact entity keys changed in run)
+@@ 10.1 New Files
++src/core/migrations/00xx_add_sync_run_ledger.sql
+@@ New migration (appendix)
++CREATE TABLE sync_runs (
++  id INTEGER PRIMARY KEY,
++  started_at_ms INTEGER NOT NULL,
++  completed_at_ms INTEGER,
++  status TEXT NOT NULL
++);
++CREATE TABLE sync_deltas (
++  sync_run_id INTEGER NOT NULL,
++  entity_kind TEXT NOT NULL,
++  project_id INTEGER NOT NULL,
++  iid INTEGER NOT NULL,
++  change_kind TEXT NOT NULL
++);
++CREATE INDEX idx_sync_deltas_run_kind ON sync_deltas(sync_run_id, entity_kind);
+@@ 11 Assumptions
+-16. No new SQLite tables needed for v1
++16. Two small v1 tables are added: `sync_runs` and `sync_deltas` for deterministic post-sync UX.
+```
+
+5. **Expand the GA index set to match actual filter surface**
+Rationale: Current required indexes only cover default sort paths; they do not match common filters like `author`, `assignee`, `reviewer`, `target_branch`, label-based filtering. This will likely miss p95 SLOs at M tier.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ 9.3.1 Required Indexes (GA Blocker)
+ CREATE INDEX IF NOT EXISTS idx_issues_list_default
+     ON issues(project_id, state, updated_at DESC, iid DESC);
++CREATE INDEX IF NOT EXISTS idx_issues_author_updated
++    ON issues(project_id, state, author_username, updated_at DESC, iid DESC);
++CREATE INDEX IF NOT EXISTS idx_issues_assignee_updated
++    ON issues(project_id, state, assignee_username, updated_at DESC, iid DESC);
+@@
+ CREATE INDEX IF NOT EXISTS idx_mrs_list_default
+     ON merge_requests(project_id, state, updated_at DESC, iid DESC);
++CREATE INDEX IF NOT EXISTS idx_mrs_reviewer_updated
++    ON merge_requests(project_id, state, reviewer_username, updated_at DESC, iid DESC);
++CREATE INDEX IF NOT EXISTS idx_mrs_target_updated
++    ON merge_requests(project_id, state, target_branch, updated_at DESC, iid DESC);
++CREATE INDEX IF NOT EXISTS idx_mrs_source_updated
++    ON merge_requests(project_id, state, source_branch, updated_at DESC, iid DESC);
+@@
++-- If labels are normalized through join table:
++CREATE INDEX IF NOT EXISTS idx_issue_labels_label_issue ON issue_labels(label, issue_id);
++CREATE INDEX IF NOT EXISTS idx_mr_labels_label_mr ON mr_labels(label, mr_id);
+@@ CI enforcement
+-asserts that none show `SCAN TABLE` for the primary entity tables
++asserts that none show full scans for primary tables under default filters AND top 8 user-facing filter combinations
+```
+
+6. **Add DB schema compatibility preflight (separate from binary compat)**
+Rationale: Binary compat (`--compat-version`) does not protect against schema mismatches. Add explicit schema version checks before booting the TUI to avoid runtime SQL errors deep in navigation paths.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ 3.2 Nightly Rust Strategy
+-- **Compatibility contract:** Before spawning `lore-tui`, the `lore tui` subcommand runs `lore-tui --compat-version` ...
++- **Compatibility contract:** Before spawning `lore-tui`, `lore tui` validates:
++  1) binary compat version (`lore-tui --compat-version`)
++  2) DB schema range (`lore-tui --check-schema <db-path>`)
++If schema is out-of-range, print remediation: `lore migrate`.
+@@ 9.3 Phase 0 — Toolchain Gate
++17. Schema preflight test: incompatible DB schema yields actionable error and non-zero exit before entering TUI loop.
+```
+
+7. **Refine terminal sanitization to preserve legitimate Unicode while blocking control attacks**
+Rationale: Current sanitizer strips zero-width joiners and similar characters, which breaks emoji/grapheme rendering and undermines your own `text_width` goals. Keep benign Unicode, remove only dangerous controls/bidi spoof vectors, and sanitize markdown link targets too.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ 10.4.1 Terminal Safety — Untrusted Text Sanitization
+-- Strip bidi overrides ... and zero-width/invisible controls ...
++- Strip ANSI/OSC/control chars and bidi spoof controls.
++- Preserve legitimate grapheme-joining characters (ZWJ/ZWNJ/combining marks) for correct Unicode rendering.
++- Sanitize markdown link targets with strict URL allowlist before rendering clickable links.
+@@ safety.rs
+-            // Strip zero-width and invisible controls
+-            '\u{200B}' | '\u{200C}' | '\u{200D}' | '\u{FEFF}' | '\u{00AD}' => {}
++            // Preserve grapheme/emoji join behavior; remove only harmful controls.
++            // (ZWJ/ZWNJ/combining marks are retained)
+@@ Enforcement rule
+ - Search result snippets
+ - Author names and labels
++- Markdown link destinations (scheme + origin validation before render/open)
+```
+
+8. **Add key normalization layer for terminal portability**
+Rationale: Collision notes are good, but you still need a canonicalization layer because terminals emit different sequences for Alt/Meta/Backspace/Enter variants. This reduces “works in iTerm, broken in tmux/SSH” bugs.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ 8.2 List Screens
+ **Terminal keybinding safety notes:**
+@@
+ - `Ctrl+M` is NOT used — it collides with `Enter` ...
++
++**Key normalization layer (new):**
++- Introduce `KeyNormalizer` before `interpret_key()`:
++  - normalize Backspace variants (`^H`, `DEL`)
++  - normalize Alt/Meta prefixes
++  - normalize Shift+Tab vs Tab where terminal supports it
++  - normalize kitty/CSI-u enhanced key protocols when present
+@@ 9.2 Phases
++    Key normalization integration tests   :p5d, after p5c, 1d
++    Terminal profile replay tests         :p5e, after p5d, 1d
+```
+
+9. **Add deterministic event-trace capture for crash reproduction**
+Rationale: Panic logs without recent event context are often insufficient for TUI race bugs. Persist last-N normalized events + active screen + task state snapshot on panic for one-command repro.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ 3.1 Risk Matrix
+ | Runtime panic leaves user blocked | High | Medium | Panic hook writes crash report, restores terminal, offers fallback CLI command |
++| Hard-to-reproduce input race bugs | Medium | Medium | Persist last 2k normalized events + state hash on panic for deterministic replay |
+@@ 10.3 Entry Point / panic hook
+-        // 2. Write crash dump
++        // 2. Write crash dump + event trace snapshot
++        // Includes: last 2000 normalized events, current screen, in-flight task keys/generations
+@@ 10.9.1 Non-Snapshot Tests
++/// Replay captured event trace from panic artifact and assert no panic.
++#[test]
++fn replay_trace_artifact_is_stable() { ... }
+```
+
+10. **Do a plan-wide consistency pass on pseudocode contracts**
+Rationale: There are internal mismatches that will create implementation churn (`search_request_id` still referenced after replacement, `items` vs `window`, keybinding mismatch `Ctrl+I` vs `Alt+o`). Tightening these now saves real engineering time later.
+
+```diff
+--- a/PRD.md
++++ b/PRD.md
+@@ 4.4 LoreApp::new
+-            search_request_id: 0,
++            // dedup generation handled by TaskSupervisor
+@@ 8.1 Global
+-| `Ctrl+O` | Jump backward in jump list (entity hops) |
+-| `Alt+o` | Jump forward in jump list (entity hops) |
++| `Ctrl+O` | Jump backward in jump list (entity hops) |
++| `Alt+o`  | Jump forward in jump list (entity hops) |
+@@ 10.10 IssueListState
+-    pub fn selected_item(&self) -> Option<&IssueListRow> {
+-        self.items.get(self.selected_index)
+-    }
++    pub fn selected_item(&self) -> Option<&IssueListRow> {
++        self.window.get(self.selected_index)
++    }
+```
+
+If you want, I can now produce a single consolidated unified diff patch of the full PRD with these revisions merged end-to-end.

plans/tui-prd-v2-frankentui.feedback-8.md

@@ -0,0 +1,211 @@
+Below are the strongest revisions I’d make. I intentionally avoided anything in your `## Rejected Recommendations`.
+
+1. **Unify commands/keybindings/help/palette into one registry**
+Rationale: your plan currently duplicates action definitions across `execute_palette_action`, `ShowCliEquivalent`, help overlay text, and status hints. That will drift quickly and create correctness bugs. A single `CommandRegistry` makes behavior consistent and testable.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 4.1 Module Structure
++    commands.rs                   # Single source of truth for actions, keybindings, CLI equivalents
+
+@@ 4.4 App — Implementing the Model Trait
+-    fn execute_palette_action(&self, action_id: &str) -> Cmd<Msg> { ... big match ... }
++    fn execute_palette_action(&self, action_id: &str) -> Cmd<Msg> {
++        if let Some(spec) = self.commands.get(action_id) {
++            return self.update(spec.to_msg(self.navigation.current()));
++        }
++        Cmd::none()
++    }
+
+@@ 8. Keybinding Reference
++All keybinding/help/status/palette definitions are generated from `commands.rs`.
++No hardcoded duplicate maps in view/state modules.
+```
+
+2. **Replace ad-hoc key flags with explicit input state machine**
+Rationale: `pending_go` + `go_prefix_instant` is fragile and already inconsistent with documented behavior. A typed `InputMode` removes edge-case bugs and makes prefix timeout deterministic.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 4.4 LoreApp struct
+-    pending_go: bool,
+-    go_prefix_instant: Option<std::time::Instant>,
++    input_mode: InputMode, // Normal | Text | Palette | GoPrefix { started_at }
+
+@@ 8.2 List Screens
+-| `g` `g` | Jump to top |
++| `g` `g` | Jump to top (current list screen) |
+
+@@ 4.4 interpret_key
+- KeyCode::Char('g') => Msg::IssueListScrollToTop
++ KeyCode::Char('g') => Msg::ScrollToTopCurrentScreen
+```
+
+3. **Fix TaskSupervisor contract and message schema drift**
+Rationale: the plan mixes `request_id` and `generation`, and `TaskKey::Search { generation }` defeats dedup by making every key unique. This can silently reintroduce stale-result races.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 4.3 Core Types (Msg)
+-    SearchRequestStarted { request_id: u64, query: String },
+-    SearchExecuted { request_id: u64, results: SearchResults },
++    SearchRequestStarted { generation: u64, query: String },
++    SearchExecuted { generation: u64, results: SearchResults },
+
+@@ 4.5.1 Task Supervisor
+-    Search { generation: u64 },
++    Search,
++    struct TaskStamp { key: TaskKey, generation: u64 }
+
+@@ 10.9.1 Non-Snapshot Tests
+-    Msg::SearchExecuted { request_id: 3, ... }
++    Msg::SearchExecuted { generation: 3, ... }
+```
+
+4. **Add a `Clock` boundary everywhere time is computed**
+Rationale: you call `SystemTime::now()` in many query/render paths, causing inconsistent relative-time labels inside one frame and flaky tests. Injected clock gives deterministic rendering and lower per-frame overhead.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 4.1 Module Structure
++    clock.rs                      # Clock trait: SystemClock/FakeClock
+
+@@ 4.4 LoreApp struct
++    clock: Arc<dyn Clock>,
+
+@@ 10.11 action.rs
+- let now_ms = std::time::SystemTime::now()...
++ let now_ms = clock.now_ms();
+
+@@ 9.3 Phase 0 success criteria
++19. Relative-time rendering deterministic under FakeClock across snapshot runs.
+```
+
+5. **Upgrade text truncation to grapheme-safe width handling**
+Rationale: `unicode-width` alone is not enough for safe truncation; it can split grapheme clusters (emoji ZWJ sequences, skin tones, flags). You need width + grapheme segmentation together.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 10.1 New Files
+-crates/lore-tui/src/text_width.rs      # ... using unicode-width crate
++crates/lore-tui/src/text_width.rs      # Grapheme-safe width/truncation using unicode-width + unicode-segmentation
+
+@@ 10.1 New Files
++Cargo.toml (lore-tui): unicode-segmentation = "1"
+
+@@ 9.3 Phase 0 success criteria
++20. Unicode rendering tests pass for CJK, emoji ZWJ, combining marks, RTL text.
+```
+
+6. **Redact sensitive values in logs and crash dumps**
+Rationale: current crash/log strategy risks storing tokens/credentials in plain text. This is a serious operational/security gap for local tooling too.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 4.1 Module Structure
+     safety.rs                     # sanitize_for_terminal(), safe_url_policy()
++    redact.rs                     # redact_sensitive() for logs/crash reports
+
+@@ 10.3 install_panic_hook_for_tui
+- let _ = std::fs::write(&crash_path, format!("{panic_info:#?}"));
++ let report = redact_sensitive(format!("{panic_info:#?}"));
++ let _ = std::fs::write(&crash_path, report);
+
+@@ 9.3 Phase 0 success criteria
++21. Redaction tests confirm tokens/Authorization headers never appear in persisted crash/log artifacts.
+```
+
+7. **Add search capability detection and mode fallback UX**
+Rationale: semantic/hybrid mode should not silently degrade when embeddings are absent/stale. Explicit capability state increases trust and avoids “why are results weird?” confusion.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 5.6 Search
++Capability-aware modes:
++- If embeddings unavailable/stale, semantic mode is disabled with inline reason.
++- Hybrid mode auto-falls back to lexical and shows badge: "semantic unavailable".
+
+@@ 4.3 Core Types
++    SearchCapabilitiesLoaded(SearchCapabilities)
+
+@@ 9.3 Phase 0 success criteria
++22. Mode availability checks validated: lexical/hybrid/semantic correctly enabled/disabled by fixture capabilities.
+```
+
+8. **Define sync cancel latency SLO and enforce fine-grained checks**
+Rationale: “check cancel between phases” is too coarse on big projects. Users need fast cancel acknowledgment and bounded stop time.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 5.9 Sync
+-CANCELLATION: checked between sync phases
++CANCELLATION: checked at page boundaries, batch upsert boundaries, and before each network request.
++UX target: cancel acknowledged <250ms, sync stop p95 <2s after Esc.
+
+@@ 9.3 Phase 0 success criteria
++23. Cancel latency test passes: p95 stop time <2s under M-tier fixtures.
+```
+
+9. **Add a “Hotspots” screen for risk/churn triage**
+Rationale: this is high-value and uses existing data (events, unresolved discussions, stale items). It makes the TUI more compelling without needing new sync tables or rejected features.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 1. Executive Summary
++- **Hotspots** — file/path risk ranking by churn × unresolved discussion pressure × staleness
+
+@@ 5. Screen Taxonomy
++### 5.12 Hotspots
++Shows top risky paths with drill-down to related issues/MRs/timeline.
+
+@@ 8.1 Global
++| `gx` | Go to Hotspots |
+
+@@ 10.1 New Files
++crates/lore-tui/src/state/hotspots.rs
++crates/lore-tui/src/view/hotspots.rs
+```
+
+10. **Add degraded startup mode when compat/schema checks fail**
+Rationale: hard-exit on mismatch blocks users. A degraded mode that shells to `lore --robot` for read-only summary/doctor keeps the product usable and gives guided recovery.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 3.2 Nightly Rust Strategy
+- On mismatch: actionable error and exit
++ On mismatch: actionable error with `--degraded` option.
++ `--degraded` launches limited TUI (Dashboard/Doctor/Stats via `lore --robot` subprocess calls).
+
+@@ 10.3 TuiCli
++    /// Allow limited mode when schema/compat checks fail
++    #[arg(long)]
++    degraded: bool,
+```
+
+11. **Harden query-plan CI checks (don’t rely on `SCAN TABLE` string matching)**
+Rationale: SQLite planner text varies by version. Parse opcode structure and assert index usage semantically; otherwise CI will be flaky or miss regressions.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 9.3.1 Required Indexes (CI enforcement)
+- asserts that none show `SCAN TABLE`
++ parses EXPLAIN QUERY PLAN rows and asserts:
++ - top-level loop uses expected index families
++ - no full scan on primary entity tables under default and top filter combos
++ - join order remains bounded (no accidental cartesian expansions)
+```
+
+12. **Enforce single-instance lock for session/state safety**
+Rationale: assumption says no concurrent TUI sessions, but accidental double-launch will still happen. Locking prevents state corruption and confusing interleaved sync actions.
+
+```diff
+diff --git a/PRD.md b/PRD.md
+@@ 10.1 New Files
++crates/lore-tui/src/instance_lock.rs   # lock file with stale-lock recovery
+
+@@ 11. Assumptions
+-21. No concurrent TUI sessions.
++21. Concurrent sessions unsupported and actively prevented by instance lock (with clear error message).
+```
+
+If you want, I can turn this into a consolidated patched PRD (single unified diff) next.

plans/tui-prd-v2-frankentui.feedback-9.md

@@ -0,0 +1,198 @@
+I reviewed the full PRD end-to-end and avoided all items already listed in `## Rejected Recommendations`.  
+These are the highest-impact revisions I’d make.
+
+1. **Fix keybinding/state-machine correctness gaps (critical)**
+The plan currently has an internal conflict: the doc says jump-forward is `Alt+o`, but code sample uses `Ctrl+i` (which collides with `Tab` in many terminals). Also, `g`-prefix timeout depends on `Tick`, but `Tick` isn’t guaranteed when idle, so prefix mode can get “stuck.” This is a correctness bug, not polish.
+
+```diff
+@@ 8.1 Global (Available Everywhere)
+-| `Ctrl+O` | Jump backward in jump list (entity hops) |
+-| `Alt+o` | Jump forward in jump list (entity hops) |
++| `Ctrl+O` | Jump backward in jump list (entity hops) |
++| `Alt+o` | Jump forward in jump list (entity hops) |
++| `Backspace` | Go back (when no text input is focused) |
+
+@@ 4.4 LoreApp::interpret_key
+- (KeyCode::Char('i'), m) if m.contains(Modifiers::CTRL) => {
+-     return Some(Msg::JumpForward);
+- }
++ (KeyCode::Char('o'), m) if m.contains(Modifiers::ALT) => {
++     return Some(Msg::JumpForward);
++ }
++ (KeyCode::Backspace, Modifiers::NONE) => {
++     return Some(Msg::GoBack);
++ }
+
+@@ 4.4 Model::subscriptions
++ // Go-prefix timeout enforcement must tick even when nothing is loading.
++ if matches!(self.input_mode, InputMode::GoPrefix { .. }) {
++     subs.push(Box::new(
++         Every::with_id(2, Duration::from_millis(50), || Msg::Tick)
++     ));
++ }
+```
+
+2. **Make `TaskSupervisor` API internally consistent and enforceable**
+The plan uses `submit()`/`is_current()` in one place and `register()`/`next_generation()` in another. That inconsistency will cause implementation drift and stale-result bugs. Use one coherent API with a returned handle containing `{key, generation, cancel_token}`.
+
+```diff
+@@ 4.5.1 Task Supervisor (Dedup + Cancellation + Priority)
+-pub struct TaskSupervisor {
+-    active: HashMap<TaskKey, Arc<CancelToken>>,
+-    generation: AtomicU64,
+-}
++pub struct TaskSupervisor {
++    active: HashMap<TaskKey, TaskHandle>,
++}
++
++pub struct TaskHandle {
++    pub key: TaskKey,
++    pub generation: u64,
++    pub cancel: Arc<CancelToken>,
++}
+
+- pub fn register(&mut self, key: TaskKey) -> Arc<CancelToken>
+- pub fn next_generation(&self) -> u64
++ pub fn submit(&mut self, key: TaskKey) -> TaskHandle
++ pub fn is_current(&self, key: &TaskKey, generation: u64) -> bool
++ pub fn complete(&mut self, key: &TaskKey, generation: u64)
+```
+
+3. **Replace thread-sleep debounce with runtime timer messages**
+`std::thread::sleep(200ms)` inside task closures wastes pool threads under fast typing and reduces responsiveness under contention. Use timer-driven debounce messages and only fire the latest generation. This improves latency stability on large datasets.
+
+```diff
+@@ 4.3 Core Types (Msg enum)
++ SearchDebounceArmed { generation: u64, query: String },
++ SearchDebounceFired { generation: u64 },
+
+@@ 4.4 maybe_debounced_query
+- Cmd::task(move || {
+-     std::thread::sleep(std::time::Duration::from_millis(200));
+-     ...
+- })
++ // Arm debounce only; runtime timer emits SearchDebounceFired.
++ Cmd::msg(Msg::SearchDebounceArmed { generation, query })
+
+@@ 4.4 subscriptions()
++ if self.state.search.debounce_pending() {
++     subs.push(Box::new(
++         Every::with_id(3, Duration::from_millis(200), || Msg::SearchDebounceFired { generation: ... })
++     ));
++ }
+```
+
+4. **Harden `DbManager` API to avoid lock-poison panics and accidental long-held guards**
+Returning raw `MutexGuard<Connection>` invites accidental lock scope expansion and `expect("lock poisoned")` panics. Move to closure-based access (`with_reader`, `with_writer`) returning `Result`, and use cached statements. This reduces deadlock risk and tail latency.
+
+```diff
+@@ 4.4 DbManager
+- pub fn reader(&self) -> MutexGuard<'_, Connection> { ...expect("reader lock poisoned") }
+- pub fn writer(&self) -> MutexGuard<'_, Connection> { ...expect("writer lock poisoned") }
++ pub fn with_reader<T>(&self, f: impl FnOnce(&Connection) -> Result<T, LoreError>) -> Result<T, LoreError>
++ pub fn with_writer<T>(&self, f: impl FnOnce(&Connection) -> Result<T, LoreError>) -> Result<T, LoreError>
+
+@@ 10.11 action.rs
+- let conn = db.reader();
+- match fetch_issues(&conn, &filter) { ... }
++ match db.with_reader(|conn| fetch_issues(conn, &filter)) { ... }
+
++ // Query hot paths use prepare_cached() to reduce parse overhead.
+```
+
+5. **Add read-path entity cache (LRU) for repeated drill-in/out workflows**
+Your core daily flow is Enter/Esc bouncing between list/detail. Without caching, identical detail payloads are re-queried repeatedly. A bounded LRU by `EntityKey` with invalidation on sync completion gives near-instant reopen behavior and reduces DB pressure.
+
+```diff
+@@ 4.1 Module Structure
++    entity_cache.rs               # Bounded LRU cache for detail payloads
+
+@@ app.rs LoreApp fields
++    entity_cache: EntityCache,
+
+@@ load_screen(Screen::IssueDetail / MrDetail)
++    if let Some(cached) = self.entity_cache.get_issue(&key) {
++        return Cmd::msg(Msg::IssueDetailLoaded { key, detail: cached.clone() });
++    }
+
+@@ Msg::IssueDetailLoaded / Msg::MrDetailLoaded handlers
++    self.entity_cache.put_issue(key.clone(), detail.clone());
+
+@@ Msg::SyncCompleted
++    self.entity_cache.invalidate_all();
+```
+
+6. **Tighten sync-stream observability and drop semantics without adding heavy architecture**
+You already handle backpressure, but operators need visibility when it happens. Track dropped-progress count and max queue depth in state and surface it in running/summary views. This keeps the current simple design while making reliability measurable.
+
+```diff
+@@ 4.3 Msg
++ SyncStreamStats { dropped_progress: u64, max_queue_depth: usize },
+
+@@ 5.9 Sync (Running mode footer)
+-| Esc cancel  f full sync  e embed after  d dry-run  l log level|
++| Esc cancel  f full sync  e embed after  d dry-run  l log level  stats:drop=12 qmax=1847 |
+
+@@ 9.3 Success criteria
++24. Sync stream stats are emitted and rendered; terminal events (completed/failed/cancelled) delivery is 100% under induced backpressure.
+```
+
+7. **Make crash reporting match the promised diagnostic value**
+The PRD promises event replay context, but sample hook writes only panic text. Add explicit crash context capture (`last events`, `current screen`, `task handles`, `build id`, `db fingerprint`) and retention policy. This materially improves post-mortem debugging.
+
+```diff
+@@ 4.1 Module Structure
++    crash_context.rs              # ring buffer of normalized events + task/screen snapshot
+
+@@ 10.3 install_panic_hook_for_tui()
+- let report = crate::redact::redact_sensitive(&format!("{panic_info:#?}"));
++ let ctx = crate::crash_context::snapshot();
++ let report = crate::redact::redact_sensitive(&format!("{panic_info:#?}\n{ctx:#?}"));
+
++ // Retention: keep latest 20 crash files, delete oldest metadata entries only.
+```
+
+8. **Add Search Facets panel for faster triage (high-value feature, low risk)**
+Search is central, but right now filtering requires manual field edits. Add facet counts (`issues`, `MRs`, `discussions`, top labels/projects/authors) with one-key apply. This makes search more compelling and actionable without introducing schema changes.
+
+```diff
+@@ 5.6 Search
+-- Layout: Split pane — results list (left) + preview (right)
++- Layout: Three-pane on wide terminals — results (left) + preview (center) + facets (right)
+
++**Facets panel:**
++- Entity type counts (issue/MR/discussion)
++- Top labels/projects/authors for current query
++- `1/2/3` quick-apply type facet; `l` cycles top label facet
+
+@@ 8.2 List/Search keybindings
++| `1` `2` `3` | Apply facet: Issue / MR / Discussion |
++| `l` | Apply next top-label facet |
+```
+
+9. **Strengthen text sanitization for terminal edge cases**
+Current sanitizer is strong, but still misses some control-space edge cases (C1 controls, directional marks beyond the listed bidi set). Add those and test them. This closes spoofing/render confusion gaps with minimal complexity.
+
+```diff
+@@ 10.4.1 sanitize_for_terminal()
++ // Strip C1 control block (U+0080..U+009F) and additional directional marks
++ c if ('\u{0080}'..='\u{009F}').contains(&c) => {}
++ '\u{200E}' | '\u{200F}' | '\u{061C}' => {} // LRM, RLM, ALM
+
+@@ tests
++ #[test] fn strips_c1_controls() { ... }
++ #[test] fn strips_lrm_rlm_alm() { ... }
+```
+
+10. **Add an explicit vertical-slice gate before broad screen expansion**
+The plan is comprehensive, but risk is still front-loaded on framework + runtime behavior. Insert a strict vertical slice gate (`Dashboard + IssueList + IssueDetail + Sync running`) with perf and stability thresholds before Phase 3 features. This reduces rework if foundational assumptions break.
+
+```diff
+@@ 9.2 Phases
++section Phase 2.5 — Vertical Slice Gate
++Dashboard + IssueList + IssueDetail + Sync (running) integrated :p25a, after p2c, 3d
++Gate: p95 nav latency < 75ms on M tier; zero stuck-input-state bugs; cancel p95 < 2s :p25b, after p25a, 1d
++Only then proceed to Search/Timeline/Who/Palette expansion.
+```
+
+If you want, I can produce a full consolidated `diff` block against the entire PRD text (single patch), but the above is the set I’d prioritize first.

plans/work-item-status-graphql.feedback-3.md

@@ -0,0 +1,157 @@
+**Top Revisions I Recommend**
+
+1. **Fix auth semantics + a real inconsistency in your test plan**
+Your ACs require graceful handling for `403`, but the test list says the “403” test returns `401`. That hides the exact behavior you care about and can let permission regressions slip through.
+
+```diff
+@@ AC-1: GraphQL Client (Unit)
+ - [ ] HTTP 401 → `LoreError::GitLabAuthFailed`
+ + [ ] HTTP 401 → `LoreError::GitLabAuthFailed`
+ + [ ] HTTP 403 → `LoreError::GitLabForbidden`
+
+@@ AC-3: Status Fetcher (Integration)
+ - [ ] GraphQL 403 → returns `Ok(HashMap::new())` with warning log
+ + [ ] GraphQL 403 (`GitLabForbidden`) → returns `Ok(HashMap::new())` with warning log
+
+@@ TDD Plan (RED)
+ - 13. `test_fetch_statuses_403_graceful` — mock returns 401 → `Ok(HashMap::new())`
+ + 13. `test_fetch_statuses_403_graceful` — mock returns 403 → `Ok(HashMap::new())`
+```
+
+2. **Make enrichment atomic and stale-safe**
+Current plan can leave stale status values forever when a widget disappears or status becomes null. Make writes transactional and clear status fields for fetched scope before upserts.
+
+```diff
+@@ AC-6: Enrichment in Orchestrator (Integration)
+ + [ ] Enrichment DB writes are transactional per project (all-or-nothing)
+ + [ ] Status fields are cleared for fetched issue scope before applying new statuses
+ + [ ] If enrichment fails mid-project, prior persisted statuses are unchanged (rollback)
+
+@@ File 6: `src/ingestion/orchestrator.rs`
+- fn enrich_issue_statuses(...)
++ fn enrich_issue_statuses_txn(...)
++ // BEGIN TRANSACTION
++ // clear status columns for fetched issue scope
++ // apply updates
++ // COMMIT
+```
+
+3. **Add transient retry/backoff (429/5xx/network)**
+Right now one transient failure loses status enrichment for that sync. Retrying with bounded backoff gives much better reliability at low cost.
+
+```diff
+@@ AC-1: GraphQL Client (Unit)
+ + [ ] Retries 429/502/503/504/network errors with bounded exponential backoff + jitter (max 3 attempts)
+ + [ ] Honors `Retry-After` on 429 before retrying
+
+@@ AC-6: Enrichment in Orchestrator (Integration)
+ + [ ] Cancellation signal is checked before each retry sleep and between paginated calls
+```
+
+4. **Stop full GraphQL scans when nothing changed**
+Running full pagination on every sync will dominate runtime on large repos. Trigger enrichment only when issue ingestion reports changes, with a manual override.
+
+```diff
+@@ AC-6: Enrichment in Orchestrator (Integration)
+- [ ] Runs on every sync (not gated by `--full`)
++ [ ] Runs when issue ingestion changed at least one issue in the project
++ [ ] New override flag `--refresh-status` forces enrichment even with zero issue deltas
++ [ ] Optional periodic full refresh (e.g. every N syncs) to prevent long-tail drift
+```
+
+5. **Do not expose raw token via `client.token()`**
+Architecturally cleaner and safer: keep token encapsulated and expose a GraphQL-ready client factory from `GitLabClient`.
+
+```diff
+@@ File 13: `src/gitlab/client.rs`
+- pub fn token(&self) -> &str
++ pub fn graphql_client(&self) -> crate::gitlab::graphql::GraphqlClient
+
+@@ File 6: `src/ingestion/orchestrator.rs`
+- let graphql_client = GraphqlClient::new(&config.gitlab.base_url, client.token());
++ let graphql_client = client.graphql_client();
+```
+
+6. **Add indexes for new status filters**
+`--status` on large tables will otherwise full-scan `issues`. Add compound indexes aligned with project-scoped list queries.
+
+```diff
+@@ AC-4: Migration 021 (Unit)
+ + [ ] Adds index `idx_issues_project_status_name(project_id, status_name)`
+ + [ ] Adds index `idx_issues_project_status_category(project_id, status_category)`
+
+@@ File 14: `migrations/021_work_item_status.sql`
+ ALTER TABLE issues ADD COLUMN status_name TEXT;
+ ALTER TABLE issues ADD COLUMN status_category TEXT;
+ ALTER TABLE issues ADD COLUMN status_color TEXT;
+ ALTER TABLE issues ADD COLUMN status_icon_name TEXT;
++CREATE INDEX IF NOT EXISTS idx_issues_project_status_name
++  ON issues(project_id, status_name);
++CREATE INDEX IF NOT EXISTS idx_issues_project_status_category
++  ON issues(project_id, status_category);
+```
+
+7. **Improve filter UX: add category filter + case-insensitive status**
+Case-sensitive exact name matches are brittle with custom lifecycle names. Category filter is stable and useful for automation.
+
+```diff
+@@ AC-9: List Issues Filter (E2E)
+- [ ] Filter is case-sensitive (matches GitLab's exact status name)
++ [ ] `--status` uses case-insensitive exact match by default (`COLLATE NOCASE`)
++ [ ] New filter `--status-category` supports `triage|to_do|in_progress|done|canceled`
++ [ ] `--status-exact` enables strict case-sensitive behavior when needed
+```
+
+8. **Add capability probe/cache to avoid pointless calls**
+Free tier / old GitLab versions will never return status widget. Cache that capability per project (with TTL) to reduce noise and wasted requests.
+
+```diff
+@@ GitLab API Constraints
++### Capability Probe
++On first sync per project, detect status-widget support and cache result for 24h.
++If unsupported, skip enrichment silently (debug log) until TTL expiry.
+
+@@ AC-3: Status Fetcher (Integration)
++ [ ] Unsupported capability state bypasses GraphQL fetch and warning spam
+```
+
+9. **Use a nested robot `status` object instead of 4 top-level fields**
+This is cleaner schema design and scales better as status metadata grows (IDs, lifecycle, timestamps, etc.).
+
+```diff
+@@ AC-7: Show Issue Display (Robot)
+- [ ] JSON includes `status_name`, `status_category`, `status_color`, `status_icon_name` fields
+- [ ] Fields are `null` (not absent) when status not available
++ [ ] JSON includes `status` object:
++       `{ "name": "...", "category": "...", "color": "...", "icon_name": "..." }` or `null`
+
+@@ AC-8: List Issues Display (Robot)
+- [ ] JSON includes `status_name`, `status_category` fields on each issue
++ [ ] JSON includes `status` object (or `null`) on each issue
+```
+
+10. **Add one compelling feature: status analytics, not just status display**
+Right now this is mostly a transport/display enhancement. Make it genuinely useful with “stale in-progress” detection and age-in-status filters.
+
+```diff
+@@ Acceptance Criteria
++### AC-11: Status Aging & Triage Value (E2E)
++- [ ] `lore list issues --status-category in_progress --stale-days 14` filters to stale work
++- [ ] Human table shows `Status Age` (days) when status exists
++- [ ] Robot output includes `status_age_days` (nullable integer)
+```
+
+11. **Harden test plan around failure modes you’ll actually hit**
+The current tests are good, but miss rollback/staleness/retry behavior that drives real reliability.
+
+```diff
+@@ TDD Plan (RED) additions
++21. `test_enrich_clears_removed_status`
++22. `test_enrich_transaction_rolls_back_on_failure`
++23. `test_graphql_retry_429_then_success`
++24. `test_graphql_retry_503_then_success`
++25. `test_cancel_during_backoff_aborts_cleanly`
++26. `test_status_filter_query_uses_project_status_index` (EXPLAIN smoke test)
+```
+
+If you want, I can produce a fully revised v3 plan document end-to-end (frontmatter + reordered ACs + updated file list + updated TDD matrix) so it is ready to implement directly.

plans/work-item-status-graphql.feedback-4.md

@@ -0,0 +1,159 @@
+Your plan is already strong, but I’d revise it in 10 places to reduce risk at scale and make it materially more useful.
+
+1. Shared transport + retries for GraphQL (must-have)
+Reasoning: `REST` already has throttling/retry in `src/gitlab/client.rs`; your proposed GraphQL client would bypass that and can spike rate limits under concurrent project ingest (`src/cli/commands/ingest.rs`). Unifying transport prevents split behavior and cuts production incidents.
+
+```diff
+@@ AC-1: GraphQL Client (Unit)
+- [ ] Network error → `LoreError::Other`
++ [ ] GraphQL requests use shared GitLab transport (same timeout, rate limiter, retry policy as REST)
++ [ ] Retries 429/502/503/504/network errors (max 3) with exponential backoff + jitter
++ [ ] 429 honors `Retry-After` before retrying
++ [ ] Exhausted network retries → `LoreError::GitLabNetworkError`
+
+@@ Decisions
+- 8. **No retry/backoff in v1** — DEFER.
++ 8. **Retry/backoff in v1** — YES (shared REST+GraphQL reliability policy).
+
+@@ Implementation Detail
++ File 15: `src/gitlab/transport.rs` (NEW) — shared HTTP execution and retry/backoff policy.
+```
+
+2. Capability cache for unsupported projects (must-have)
+Reasoning: Free tier / older GitLab will repeatedly emit warning noise every sync and waste calls. Cache support status per project and re-probe on TTL.
+
+```diff
+@@ AC-6: Enrichment in Orchestrator (Integration)
+- [ ] On any GraphQL error: logs warning, continues to next project (never fails the sync)
++ [ ] Unsupported capability responses (missing endpoint/type/widget) are cached per project
++ [ ] While cached unsupported, enrichment is skipped without repeated warning spam
++ [ ] Capability cache auto-expires (default 24h) and is re-probed
+
+@@ Migration Numbering
+- This feature uses **migration 021**.
++ This feature uses **migrations 021-022**.
+
+@@ Files Changed (Summary)
++ `migrations/022_project_capabilities.sql` | NEW — support cache table for project capabilities
+```
+
+3. Delta-first enrichment with periodic full reconcile (must-have)
+Reasoning: Full GraphQL scan every sync is expensive for large projects. You already compute issue deltas in ingestion; use that as fast path and keep a periodic full sweep as safety net.
+
+```diff
+@@ AC-6: Enrichment in Orchestrator (Integration)
+- [ ] Runs on every sync (not gated by `--full`)
++ [ ] Fast path: skip status enrichment when issue ingestion upserted 0 issues for that project
++ [ ] Safety net: run full reconciliation every `status_full_reconcile_hours` (default 24)
++ [ ] `--full` always forces reconciliation
+
+@@ AC-5: Config Toggle (Unit)
++ [ ] `SyncConfig` has `status_full_reconcile_hours: u32` (default 24)
+```
+
+4. Strongly typed widget parsing via `__typename` (must-have)
+Reasoning: current “deserialize arbitrary widget JSON into `StatusWidget`” is fragile. Query/type by `__typename` for forward compatibility and fewer silent parse mistakes.
+
+```diff
+@@ AC-3: Status Fetcher (Integration)
+- [ ] Extracts status from `widgets` array by matching `WorkItemWidgetStatus` fragment
++ [ ] Query includes `widgets { __typename ... }` and parser matches `__typename == "WorkItemWidgetStatus"`
++ [ ] Non-status widgets are ignored deterministically (no heuristic JSON-deserialize attempts)
+
+@@ GraphQL Query
++       widgets {
++         __typename
++         ... on WorkItemWidgetStatus { ... }
++       }
+```
+
+5. Set-based transactional DB apply (must-have)
+Reasoning: row-by-row clear/update loops will be slow on large projects and hold write locks longer. Temp-table + set-based SQL inside one txn is faster and easier to reason about rollback.
+
+```diff
+@@ AC-3: Status Fetcher (Integration)
+- `all_fetched_iids: Vec<i64>`
++ `all_fetched_iids: HashSet<i64>`
+
+@@ AC-6: Enrichment in Orchestrator (Integration)
+- [ ] Before applying updates, NULL out status fields ... (loop per IID)
+- [ ] UPDATE SQL: `SET status_name=?, ... WHERE project_id=? AND iid=?`
++ [ ] Use temp tables and set-based SQL in one transaction:
++ [ ]   (1) clear stale statuses for fetched IIDs absent from status rows
++ [ ]   (2) apply status values for fetched IIDs with status
++ [ ] One commit per project; rollback leaves prior state intact
+```
+
+6. Fix index strategy for `COLLATE NOCASE` + default sorting (must-have)
+Reasoning: your proposed `(project_id, status_name)` index may not fully help `COLLATE NOCASE` + `ORDER BY updated_at`. Tune index to real query shape in `src/cli/commands/list.rs`.
+
+```diff
+@@ AC-4: Migration 021 (Unit)
+- [ ] Adds compound index `idx_issues_project_status_name(project_id, status_name)` for `--status` filter performance
++ [ ] Adds covering NOCASE-aware index:
++ [ ]   `idx_issues_project_status_name_nocase_updated(project_id, status_name COLLATE NOCASE, updated_at DESC)`
++ [ ] Adds category index:
++ [ ]   `idx_issues_project_status_category_nocase(project_id, status_category COLLATE NOCASE)`
+```
+
+7. Add stable/automation-friendly filters now (high-value feature)
+Reasoning: status names are user-customizable and renameable; category is more stable. Also add `--no-status` for quality checks and migration visibility.
+
+```diff
+@@ AC-9: List Issues Filter (E2E)
++ [ ] `lore list issues --status-category in_progress` filters by category (case-insensitive)
++ [ ] `lore list issues --no-status` returns only issues where `status_name IS NULL`
++ [ ] `--status` + `--status-category` combine with AND logic
+
+@@ File 9: `src/cli/mod.rs`
++ Add flags: `--status-category`, `--no-status`
+
+@@ File 11: `src/cli/autocorrect.rs`
++ Register `--status-category` and `--no-status` for `issues`
+```
+
+8. Better enrichment observability and failure accounting (must-have ops)
+Reasoning: only tracking `statuses_enriched` hides skipped/cleared/errors, and auth failures become silent partial data quality issues. Add counters and explicit progress events.
+
+```diff
+@@ AC-6: Enrichment in Orchestrator (Integration)
+- [ ] `IngestProjectResult` gains `statuses_enriched: usize` counter
+- [ ] Progress event: `ProgressEvent::StatusEnrichmentComplete { enriched: usize }`
++ [ ] `IngestProjectResult` gains:
++ [ ]   `statuses_enriched`, `statuses_cleared`, `status_enrichment_skipped`, `status_enrichment_failed`
++ [ ] Progress events:
++ [ ]   `StatusEnrichmentStarted`, `StatusEnrichmentSkipped`, `StatusEnrichmentComplete`, `StatusEnrichmentFailed`
++ [ ] End-of-sync summary includes per-project enrichment outcome counts
+```
+
+9. Add `status_changed_at` for immediately useful workflow analytics (high-value feature)
+Reasoning: without change timestamp, you can’t answer “how long has this been in progress?” which is one of the most useful agent/human queries.
+
+```diff
+@@ AC-4: Migration 021 (Unit)
++ [ ] Adds nullable INTEGER column `status_changed_at` (ms epoch UTC)
+
+@@ AC-6: Enrichment in Orchestrator (Integration)
++ [ ] If status_name/category changes, update `status_changed_at = now_ms()`
++ [ ] If status is cleared, set `status_changed_at = NULL`
+
+@@ AC-9: List Issues Filter (E2E)
++ [ ] `lore list issues --stale-status-days N` filters by `status_changed_at <= now - N days`
+```
+
+10. Expand test matrix for real-world failure/perf paths (must-have)
+Reasoning: current tests are good, but the highest-risk failures are retry behavior, capability caching, idempotency under repeated runs, and large-project performance.
+
+```diff
+@@ TDD Plan — RED Phase
++ 26. `test_graphql_retries_429_with_retry_after_then_succeeds`
++ 27. `test_graphql_retries_503_then_fails_after_max_attempts`
++ 28. `test_capability_cache_skips_unsupported_project_until_ttl_expiry`
++ 29. `test_delta_skip_when_no_issue_upserts`
++ 30. `test_periodic_full_reconcile_runs_after_threshold`
++ 31. `test_set_based_enrichment_scales_10k_issues_without_timeout`
++ 32. `test_enrichment_idempotent_across_two_runs`
++ 33. `test_status_changed_at_updates_only_on_actual_status_change`
+```
+
+If you want, I can now produce a single consolidated revised plan document (full rewritten Markdown) with these changes merged in-place so it’s ready to execute.

plans/work-item-status-graphql.feedback-5.md

@@ -0,0 +1,124 @@
+Your plan is already strong and implementation-aware. The best upgrades are mostly about reliability under real-world API instability, large-scale performance, and making the feature more useful for automation.
+
+1. Promote retry/backoff from deferred to in-scope now.
+Reason: Right now, transient failures cause silent status gaps until a later sync. Bounded retries with jitter and a time budget dramatically improve successful enrichment without making syncs hang.
+
+```diff
+@@ AC-1: GraphQL Client (Unit) @@
+ - [ ] Network error → `LoreError::Other`
+ + [ ] Transient failures (`429`, `502`, `503`, `504`, timeout, connect reset) retry with exponential backoff + jitter (max 3 attempts)
+ + [ ] `Retry-After` supports both delta-seconds and HTTP-date formats
+ + [ ] Per-request retry budget capped (e.g. 120s total) to preserve cancellation responsiveness
+
+@@ AC-6: Enrichment in Orchestrator (Integration) @@
+ - [ ] On any GraphQL error: logs warning, continues to next project (never fails the sync)
+ + [ ] On transient GraphQL errors: retry policy applied before warning/skip behavior
+
+@@ Decisions @@
+ - 8. **No retry/backoff in v1** — DEFER.
+ + 8. **Retry/backoff in v1** — YES. Required for reliable enrichment under normal GitLab/API turbulence.
+```
+
+2. Add a capability cache so unsupported projects stop paying repeated GraphQL cost.
+Reason: Free tier / older instances will never return status widgets. Re-querying every sync is wasted time and noisy logs.
+
+```diff
+@@ Acceptance Criteria @@
+ + ### AC-11: Capability Probe & Cache (Integration)
+ + - [ ] Add `project_capabilities` cache with `supports_work_item_status`, `checked_at`, `cooldown_until`
+ + - [ ] 404/403/known-unsupported responses update capability cache and suppress repeated warnings until TTL expires
+ + - [ ] Supported projects still enrich every run (subject to normal schedule)
+
+@@ Future Enhancements (Not in Scope) @@
+ - **Capability probe/cache**: Detect status-widget support per project ... (deferred)
+ + (moved into scope as AC-11)
+```
+
+3. Make enrichment delta-aware with periodic forced reconciliation.
+Reason: Full pagination every sync is expensive on large projects. You can skip unnecessary status fetches when no issue changes occurred, while still doing periodic safety sweeps.
+
+```diff
+@@ AC-6: Enrichment in Orchestrator (Integration) @@
+ - [ ] Runs on every sync (not gated by `--full`)
+ + [ ] Runs when issue ingestion reports project issue deltas OR reconcile window elapsed
+ + [ ] New config: `status_reconcile_hours` (default: 24) for periodic full sweep
+ + [ ] `--refresh-status` forces enrichment regardless of delta/reconcile window
+```
+
+4. Replace row-by-row update loops with set-based SQL via temp table.
+Reason: Current per-IID loops are simple but slow at scale and hold locks longer. Set-based updates are much faster and reduce lock contention.
+
+```diff
+@@ File 6: `src/ingestion/orchestrator.rs` (MODIFY) @@
+ - for iid in all_fetched_iids { ... UPDATE issues ... }
+ - for (iid, status) in statuses { ... UPDATE issues ... }
+ + CREATE TEMP TABLE temp_issue_status_updates(...)
+ + bulk INSERT temp rows (iid, name, category, color, icon_name)
+ + single set-based UPDATE for enriched rows
+ + single set-based NULL-clear for fetched-without-status rows
+ + commit transaction
+```
+
+5. Add strict mode and explicit partial-failure reporting.
+Reason: “Warn and continue” is good default UX, but automation needs a fail-fast option and machine-readable failure output.
+
+```diff
+@@ AC-5: Config Toggle (Unit) @@
+ + - [ ] `SyncConfig` adds `status_enrichment_strict: bool` (default false)
+
+@@ AC-6: Enrichment in Orchestrator (Integration) @@
+ - [ ] On any GraphQL error: logs warning, continues to next project (never fails the sync)
+ + [ ] Default mode: warn + continue
+ + [ ] Strict mode: status enrichment error fails sync for that run
+
+@@ AC-6: IngestProjectResult @@
+ + - [ ] Adds `status_enrichment_error: Option<String>`
+
+@@ AC-8 / Robot sync envelope @@
+ + - [ ] Robot output includes `partial_failures` array with per-project enrichment failures
+```
+
+6. Fix case-insensitive matching robustness and track freshness.
+Reason: SQLite `COLLATE NOCASE` is ASCII-centric; custom statuses may be non-ASCII. Also you need visibility into staleness.
+
+```diff
+@@ AC-4: Migration 021 (Unit) @@
+ - [ ] Migration adds 4 nullable TEXT columns to `issues`
+ + [ ] Migration adds 6 columns:
+ +     `status_name`, `status_category`, `status_color`, `status_icon_name`,
+ +     `status_name_fold`, `status_synced_at`
+ - [ ] Adds compound index `idx_issues_project_status_name(project_id, status_name)`
+ + [ ] Adds compound index `idx_issues_project_status_name_fold(project_id, status_name_fold)`
+
+@@ AC-9: List Issues Filter (E2E) @@
+ - [ ] Filter uses case-insensitive matching (`COLLATE NOCASE`)
+ + [ ] Filter uses `status_name_fold` (Unicode-safe fold normalization done at write time)
+```
+
+7. Expand filtering to category and missing-status workflows.
+Reason: Name filters are useful, but automation is better on semantic categories and “missing data” detection.
+
+```diff
+@@ AC-9: List Issues Filter (E2E) @@
+ + - [ ] `--status-category in_progress` filters by `status_category` (case-insensitive)
+ + - [ ] `--no-status` returns only issues where `status_name IS NULL`
+ + - [ ] `--status` and `--status-category` can be combined with AND logic
+```
+
+8. Change robot payload from flat status fields to a nested `status` object.
+Reason: Better schema evolution and less top-level field sprawl as you add metadata (`synced_at`, future lifecycle fields).
+
+```diff
+@@ AC-7: Show Issue Display (E2E) @@
+ - [ ] JSON includes `status_name`, `status_category`, `status_color`, `status_icon_name` fields
+ - [ ] Fields are `null` (not absent) when status not available
+ + [ ] JSON includes `status` object:
+ +     `{ "name", "category", "color", "icon_name", "synced_at" }`
+ + [ ] `status: null` when not available
+
+@@ AC-8: List Issues Display (E2E) @@
+ - [ ] `--fields` supports: `status_name`, `status_category`, `status_color`, `status_icon_name`
+ + [ ] `--fields` supports: `status.name,status.category,status.color,status.icon_name,status.synced_at`
+```
+
+If you want, I can produce a fully rewritten “Iteration 5” plan document with these changes integrated end-to-end (ACs, files, migrations, TDD batches, and updated decisions/future-scope).

plans/work-item-status-graphql.feedback-6.md

@@ -0,0 +1,130 @@
+Your iteration-5 plan is strong. The biggest remaining gaps are outcome ambiguity, cancellation safety, and long-term status identity. These are the revisions I’d make.
+
+1. **Make enrichment outcomes explicit (not “empty success”)**
+Analysis:
+Right now `404/403 -> Ok(empty)` is operationally ambiguous: “project has no statuses” vs “feature unavailable/auth issue.” Agents and dashboards need that distinction to make correct decisions.
+This improves reliability and observability without making sync fail-hard.
+
+```diff
+@@ AC-3: Status Fetcher (Integration)
+-- [ ] `fetch_issue_statuses()` returns `FetchStatusResult` containing:
++- [ ] `fetch_issue_statuses()` returns `FetchStatusOutcome`:
++  - `Fetched(FetchStatusResult)`
++  - `Unsupported { reason: UnsupportedReason }`
++  - `CancelledPartial(FetchStatusResult)`
+@@
+-- [ ] GraphQL 404 → returns `Ok(FetchStatusResult)` with empty collections + warning log
+-- [ ] GraphQL 403 (`GitLabAuthFailed`) → returns `Ok(FetchStatusResult)` with empty collections + warning log
++- [ ] GraphQL 404 → `Unsupported { reason: GraphqlEndpointMissing }` + warning log
++- [ ] GraphQL 403 (`GitLabAuthFailed`) → `Unsupported { reason: AuthForbidden }` + warning log
+
+@@ AC-10: Robot Sync Envelope (E2E)
+-- [ ] `status_enrichment` object: `{ "enriched": N, "cleared": N, "error": null | "message" }`
++- [ ] `status_enrichment` object: `{ "mode": "fetched|unsupported|cancelled_partial", "reason": null|"...", "enriched": N, "cleared": N, "error": null|"message" }`
+```
+
+2. **Add cancellation and pagination loop safety**
+Analysis:
+Large projects can run long. Current flow checks cancellation only before enrichment starts; pagination and per-row update loops can ignore cancellation for too long. Also, GraphQL cursor bugs can create infinite loops (`hasNextPage=true` with unchanged cursor).
+This is a robustness must-have.
+
+```diff
+@@ AC-3: Status Fetcher (Integration)
++ [ ] `fetch_issue_statuses()` accepts cancellation signal and checks it between page requests
++ [ ] Pagination guard: if `hasNextPage=true` but `endCursor` is `None` or unchanged, abort loop with warning and return partial outcome
++ [ ] Emits `pages_fetched` count for diagnostics
+
+@@ File 1: `src/gitlab/graphql.rs`
+-- pub async fn fetch_issue_statuses(client: &GraphqlClient, project_path: &str) -> Result<FetchStatusResult>
++- pub async fn fetch_issue_statuses(client: &GraphqlClient, project_path: &str, signal: &CancellationSignal) -> Result<FetchStatusOutcome>
+```
+
+3. **Persist stable `status_id` in addition to name**
+Analysis:
+`status_name` is display-oriented and mutable (rename/custom lifecycle changes). A stable status identifier is critical for durable automations, analytics, and future migrations.
+This is a schema decision that is cheap now and expensive later if skipped.
+
+```diff
+@@ AC-2: Status Types (Unit)
+-- [ ] `WorkItemStatus` struct has `name`, `category`, `color`, `icon_name`
++- [ ] `WorkItemStatus` struct has `id: String`, `name`, `category`, `color`, `icon_name`
+
+@@ AC-4: Migration 021 (Unit)
+-- [ ] Migration adds 5 nullable columns to `issues`: `status_name`, `status_category`, `status_color`, `status_icon_name`, `status_synced_at`
++- [ ] Migration adds 6 nullable columns to `issues`: `status_id`, `status_name`, `status_category`, `status_color`, `status_icon_name`, `status_synced_at`
++ [ ] Adds index `idx_issues_project_status_id(project_id, status_id)` for stable-machine filters
+
+@@ GraphQL query
+-            status { name category color iconName }
++            status { id name category color iconName }
+
+@@ AC-7 / AC-8 Robot
++ [ ] JSON includes `status_id` (null when unavailable)
+```
+
+4. **Handle GraphQL partial-data responses correctly**
+Analysis:
+GraphQL can return both `data` and `errors` in the same response. Current plan treats any `errors` as hard failure, which can discard valid data and reduce reliability.
+Use partial-data semantics: keep data, log/report warnings.
+
+```diff
+@@ AC-1: GraphQL Client (Unit)
+-- [ ] Error response: if top-level `errors` array is non-empty, returns `LoreError` with first error message
++- [ ] If `errors` non-empty and `data` missing: return `LoreError` with first error message
++- [ ] If `errors` non-empty and `data` present: return `data` + warning metadata (do not fail the whole fetch)
+
+@@ TDD Plan (RED)
++ 33. `test_graphql_partial_data_with_errors_returns_data_and_warning`
+```
+
+5. **Extract status enrichment from orchestrator into dedicated module**
+Analysis:
+`orchestrator.rs` already has many phases. Putting status transport/parsing/transaction policy directly there increases coupling and test friction.
+A dedicated module improves architecture clarity and makes future enhancements safer.
+
+```diff
+@@ Implementation Detail
++- File 15: `src/ingestion/enrichment/status.rs` (NEW)
++  - `run_status_enrichment(...)`
++  - `enrich_issue_statuses_txn(...)`
++  - outcome mapping + telemetry
+
+@@ File 6: `src/ingestion/orchestrator.rs`
+-- Inline Phase 1.5 logic + helper function
++- Delegates to `enrichment::status::run_status_enrichment(...)` and records returned stats
+```
+
+6. **Add status/state consistency checks**
+Analysis:
+GitLab states status categories and issue state should synchronize, but ingestion drift or API edge cases can violate this. Detecting mismatch is high-signal for data integrity issues.
+This is compelling for agents because it catches “looks correct but isn’t” problems.
+
+```diff
+@@ AC-6: Enrichment in Orchestrator (Integration)
++ [ ] Enrichment computes `status_state_mismatches` count:
++   - `DONE|CANCELED` with `state=open` or `TO_DO|IN_PROGRESS|TRIAGE` with `state=closed`
++ [ ] Logs warning summary when mismatches > 0
+
+@@ AC-10: Robot Sync Envelope (E2E)
++ [ ] `status_enrichment` includes `state_mismatches: N`
+```
+
+7. **Add explicit performance envelope acceptance criterion**
+Analysis:
+Plan claims large-project handling, but no hard validation target is defined. Add a bounded, reproducible performance criterion to prevent regressions.
+This is especially important with pagination + per-row writes.
+
+```diff
+@@ Acceptance Criteria
++ ### AC-12: Performance Envelope (Integration)
++ - [ ] 10k-issue fixture completes status fetch + apply within defined budget on CI baseline machine
++ - [ ] Memory usage remains O(page_size), not O(total_issues)
++ - [ ] Cancellation during large sync exits within a bounded latency target
+
+@@ TDD Plan (RED)
++ 34. `test_enrichment_large_project_budget`
++ 35. `test_fetch_statuses_memory_bound_by_page`
++ 36. `test_cancellation_latency_during_pagination`
+```
+
+If you want, I can next produce a single consolidated “iteration 6” plan draft with these diffs fully merged so it’s ready to execute.

plans/work-item-status-graphql.feedback-7.md

@@ -0,0 +1,118 @@
+**Highest-Impact Revisions (new, not in your rejected list)**
+
+1. **Critical: Preserve GraphQL partial-error metadata end-to-end (don’t just log it)**
+Rationale: Right now partial GraphQL errors are warning-only. Agents get no machine-readable signal that status data may be incomplete, which can silently corrupt downstream automation decisions. Exposing partial-error metadata in `FetchStatusResult` and robot sync output makes reliability observable and actionable.
+
+```diff
+@@ AC-1: GraphQL Client (Unit)
+- [ ] Partial-data response: if `errors` array is non-empty BUT `data` field is present and non-null, returns `data` and logs warning with first error message
++ [ ] Partial-data response: if `errors` array is non-empty BUT `data` field is present and non-null, returns `data` and warning metadata (`had_errors=true`, `first_error_message`)
++ [ ] `GraphqlClient::query()` returns `GraphqlQueryResult { data, had_errors, first_error_message }`
+
+@@ AC-3: Status Fetcher (Integration)
++ [ ] `FetchStatusResult` includes `partial_error_count: usize` and `first_partial_error: Option<String>`
++ [ ] Partial GraphQL errors increment `partial_error_count` and are surfaced to orchestrator result
+
+@@ AC-10: Robot Sync Envelope (E2E)
+- { "mode": "...", "reason": ..., "enriched": N, "cleared": N, "error": ... }
++ { "mode": "...", "reason": ..., "enriched": N, "cleared": N, "error": ..., "partial_errors": N, "first_partial_error": null|"..." }
+
+@@ File 1: src/gitlab/graphql.rs
+- pub async fn query(...) -> Result<serde_json::Value>
++ pub async fn query(...) -> Result<GraphqlQueryResult>
++ pub struct GraphqlQueryResult { pub data: serde_json::Value, pub had_errors: bool, pub first_error_message: Option<String> }
+```
+
+2. **High: Add adaptive page-size fallback for GraphQL complexity/timeout failures**
+Rationale: Fixed `first: 100` is brittle on self-hosted instances with stricter complexity/time limits. Adaptive page size (100→50→25→10) improves success rate without retries/backoff and avoids failing an entire project due to one tunable server constraint.
+
+```diff
+@@ Query Path
+-query($projectPath: ID!, $after: String) { ... workItems(types: [ISSUE], first: 100, after: $after) ... }
++query($projectPath: ID!, $after: String, $first: Int!) { ... workItems(types: [ISSUE], first: $first, after: $after) ... }
+
+@@ AC-3: Status Fetcher (Integration)
++ [ ] Starts with `first=100`; on GraphQL complexity/timeout errors, retries same cursor with smaller page size (50, 25, 10)
++ [ ] If smallest page size still fails, returns error as today
++ [ ] Emits warning including page size downgrade event
+
+@@ TDD Plan (RED)
++ 36. `test_fetch_statuses_complexity_error_reduces_page_size`
++ 37. `test_fetch_statuses_timeout_error_reduces_page_size`
+```
+
+3. **High: Make project path lookup failure non-fatal for the sync**
+Rationale: Enrichment is optional. If `projects.path_with_namespace` lookup fails for any reason, sync should continue with a structured enrichment error instead of risking full project pipeline failure.
+
+```diff
+@@ AC-6: Enrichment in Orchestrator (Integration)
++ [ ] If project path lookup fails/missing, status enrichment is skipped for that project, warning logged, and sync continues
++ [ ] `status_enrichment_error` captures `"project_path_missing"` (or DB error text)
+
+@@ File 6: src/ingestion/orchestrator.rs
+- let project_path: String = conn.query_row(...)?;
++ let project_path = conn.query_row(...).optional()?;
++ if project_path.is_none() {
++   result.status_enrichment_error = Some("project_path_missing".to_string());
++   result.status_enrichment_mode = "fetched".to_string(); // attempted but unavailable locally
++   emit(ProgressEvent::StatusEnrichmentComplete { enriched: 0, cleared: 0 });
++   // continue to discussion sync
++ }
+```
+
+4. **Medium: Upgrade `--status` from single-value to repeatable multi-value filter**
+Rationale: Practical usage often needs “active buckets” (`To do` OR `In progress`). Repeatable `--status` with OR semantics dramatically improves usefulness without adding new conceptual surface area.
+
+```diff
+@@ AC-9: List Issues Filter (E2E)
+- [ ] `lore list issues --status "In progress"` → only issues where `status_name = 'In progress'`
++ [ ] `lore list issues --status "In progress"` → unchanged single-value behavior
++ [ ] Repeatable flags supported: `--status "In progress" --status "To do"` (OR semantics across status values)
++ [ ] Repeated `--status` remains AND-composed with other filters
+
+@@ File 9: src/cli/mod.rs
+- pub status: Option<String>,
++ pub status: Vec<String>,   // repeatable flag
+
+@@ File 8: src/cli/commands/list.rs
+- if let Some(status) = filters.status { where_clauses.push("i.status_name = ? COLLATE NOCASE"); ... }
++ if !filters.statuses.is_empty() { /* dynamic OR/IN clause with case-insensitive matching */ }
+```
+
+5. **Medium: Add coverage telemetry (`seen`, `with_status`, `without_status`)**
+Rationale: `enriched`/`cleared` alone is not enough to judge enrichment health. Coverage counters make it obvious whether a project truly has no statuses, is unsupported, or has unexpectedly low status population.
+
+```diff
+@@ AC-6: Enrichment in Orchestrator (Integration)
++ [ ] `IngestProjectResult` gains `statuses_seen: usize` and `statuses_without_widget: usize`
++ [ ] Enrichment log includes `seen`, `enriched`, `cleared`, `without_widget`
+
+@@ AC-10: Robot Sync Envelope (E2E)
+- status_enrichment: { mode, reason, enriched, cleared, error }
++ status_enrichment: { mode, reason, seen, enriched, cleared, without_widget, error, partial_errors }
+
+@@ File 6: src/ingestion/orchestrator.rs
++ result.statuses_seen = fetch_result.all_fetched_iids.len();
++ result.statuses_without_widget = result.statuses_seen.saturating_sub(result.statuses_enriched);
+```
+
+6. **Medium: Centralize color parsing/render decisions (single helper used by show/list)**
+Rationale: Color parsing is duplicated in `show.rs` and `list.rs`, which invites drift and inconsistent behavior. One shared helper gives consistent fallback behavior and simpler tests.
+
+```diff
+@@ File 7: src/cli/commands/show.rs
+- fn style_with_hex(...) { ...hex parse logic... }
++ use crate::cli::commands::color::style_with_hex;
+
+@@ File 8: src/cli/commands/list.rs
+- fn colored_cell_hex(...) { ...hex parse logic... }
++ use crate::cli::commands::color::colored_cell_hex;
+
+@@ Files Changed (Summary)
++ `src/cli/commands/color.rs` (NEW) — shared hex parsing + styling helpers
+- duplicated hex parsing blocks removed from show/list
+```
+
+---
+
+If you want, I can produce a **single consolidated patch-style diff of the plan document itself** (all section edits merged, ready to paste as iteration 7).

src/cli/autocorrect.rs

@@ -61,6 +61,7 @@ const COMMAND_FLAGS: &[(&str, &[&str])] = &[
             "--assignee",
             "--label",
             "--milestone",
+            "--status",
             "--since",
             "--due-before",
             "--has-due",
@@ -134,6 +135,7 @@ const COMMAND_FLAGS: &[(&str, &[&str])] = &[
             "--since",
             "--updated-since",
             "--limit",
+            "--fields",
             "--explain",
             "--no-explain",
             "--fts-mode",
@@ -162,6 +164,7 @@ const COMMAND_FLAGS: &[(&str, &[&str])] = &[
             "--depth",
             "--expand-mentions",
             "--limit",
+            "--fields",
             "--max-seeds",
             "--max-entities",
             "--max-evidence",
@@ -177,10 +180,12 @@ const COMMAND_FLAGS: &[(&str, &[&str])] = &[
             "--since",
             "--project",
             "--limit",
+            "--fields",
             "--detail",
             "--no-detail",
         ],
     ),
+    ("drift", &["--threshold", "--project"]),
     (
         "init",
         &[
@@ -189,10 +194,12 @@ const COMMAND_FLAGS: &[(&str, &[&str])] = &[
             "--gitlab-url",
             "--token-env-var",
             "--projects",
+            "--default-project",
         ],
     ),
     ("generate-docs", &["--full", "--project"]),
     ("completions", &[]),
+    ("robot-docs", &["--brief"]),
     (
         "list",
         &[

src/cli/commands/drift.rs

@@ -0,0 +1,642 @@
+use std::collections::HashMap;
+use std::sync::LazyLock;
+
+use console::style;
+use regex::Regex;
+use serde::Serialize;
+
+use crate::cli::robot::RobotMeta;
+use crate::core::config::Config;
+use crate::core::db::create_connection;
+use crate::core::error::{LoreError, Result};
+use crate::core::paths::get_db_path;
+use crate::core::project::resolve_project;
+use crate::core::time::ms_to_iso;
+use crate::embedding::ollama::{OllamaClient, OllamaConfig};
+use crate::embedding::similarity::cosine_similarity;
+
+const BATCH_SIZE: usize = 32;
+const WINDOW_SIZE: usize = 3;
+const MIN_DESCRIPTION_LEN: usize = 20;
+const MAX_NOTES: i64 = 200;
+const TOP_TOPICS: usize = 3;
+
+// ---------------------------------------------------------------------------
+// Response types
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Serialize)]
+pub struct DriftResponse {
+    pub entity: DriftEntity,
+    pub drift_detected: bool,
+    pub threshold: f32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub drift_point: Option<DriftPoint>,
+    pub drift_topics: Vec<String>,
+    pub similarity_curve: Vec<SimilarityPoint>,
+    pub recommendation: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct DriftEntity {
+    pub entity_type: String,
+    pub iid: i64,
+    pub title: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct DriftPoint {
+    pub note_index: usize,
+    pub note_id: i64,
+    pub author: String,
+    pub created_at: String,
+    pub similarity: f32,
+}
+
+#[derive(Debug, Serialize)]
+pub struct SimilarityPoint {
+    pub note_index: usize,
+    pub similarity: f32,
+    pub author: String,
+    pub created_at: String,
+}
+
+// ---------------------------------------------------------------------------
+// Internal row types
+// ---------------------------------------------------------------------------
+
+struct IssueInfo {
+    id: i64,
+    iid: i64,
+    title: String,
+    description: Option<String>,
+}
+
+struct NoteRow {
+    id: i64,
+    body: String,
+    author_username: String,
+    created_at: i64,
+}
+
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+
+pub async fn run_drift(
+    config: &Config,
+    entity_type: &str,
+    iid: i64,
+    threshold: f32,
+    project: Option<&str>,
+) -> Result<DriftResponse> {
+    if entity_type != "issues" {
+        return Err(LoreError::Other(
+            "drift currently supports 'issues' only".to_string(),
+        ));
+    }
+
+    let db_path = get_db_path(config.storage.db_path.as_deref());
+    let conn = create_connection(&db_path)?;
+
+    let issue = find_issue(&conn, iid, project)?;
+
+    let description = match &issue.description {
+        Some(d) if d.len() >= MIN_DESCRIPTION_LEN => d.clone(),
+        _ => {
+            return Ok(DriftResponse {
+                entity: DriftEntity {
+                    entity_type: entity_type.to_string(),
+                    iid: issue.iid,
+                    title: issue.title,
+                },
+                drift_detected: false,
+                threshold,
+                drift_point: None,
+                drift_topics: vec![],
+                similarity_curve: vec![],
+                recommendation: "Description too short for drift analysis.".to_string(),
+            });
+        }
+    };
+
+    let notes = fetch_notes(&conn, issue.id)?;
+
+    if notes.len() < WINDOW_SIZE {
+        return Ok(DriftResponse {
+            entity: DriftEntity {
+                entity_type: entity_type.to_string(),
+                iid: issue.iid,
+                title: issue.title,
+            },
+            drift_detected: false,
+            threshold,
+            drift_point: None,
+            drift_topics: vec![],
+            similarity_curve: vec![],
+            recommendation: format!(
+                "Only {} note(s) found; need at least {} for drift detection.",
+                notes.len(),
+                WINDOW_SIZE
+            ),
+        });
+    }
+
+    // Build texts to embed: description first, then each note body.
+    let mut texts: Vec<String> = Vec::with_capacity(1 + notes.len());
+    texts.push(description.clone());
+    for note in &notes {
+        texts.push(note.body.clone());
+    }
+
+    let embeddings = embed_texts(config, &texts).await?;
+
+    let desc_embedding = &embeddings[0];
+    let note_embeddings = &embeddings[1..];
+
+    // Build similarity curve.
+    let similarity_curve: Vec<SimilarityPoint> = note_embeddings
+        .iter()
+        .enumerate()
+        .map(|(i, emb)| SimilarityPoint {
+            note_index: i,
+            similarity: cosine_similarity(desc_embedding, emb),
+            author: notes[i].author_username.clone(),
+            created_at: ms_to_iso(notes[i].created_at),
+        })
+        .collect();
+
+    // Detect drift via sliding window.
+    let (drift_detected, drift_point) = detect_drift(&similarity_curve, &notes, threshold);
+
+    // Extract drift topics.
+    let drift_topics = if drift_detected {
+        let drift_idx = drift_point.as_ref().map_or(0, |dp| dp.note_index);
+        extract_drift_topics(&description, &notes, drift_idx)
+    } else {
+        vec![]
+    };
+
+    let recommendation = if drift_detected {
+        let dp = drift_point.as_ref().unwrap();
+        format!(
+            "Discussion drifted at note {} by @{} (similarity {:.2}). Consider splitting into a new issue.",
+            dp.note_index, dp.author, dp.similarity
+        )
+    } else {
+        "Discussion remains on topic.".to_string()
+    };
+
+    Ok(DriftResponse {
+        entity: DriftEntity {
+            entity_type: entity_type.to_string(),
+            iid: issue.iid,
+            title: issue.title,
+        },
+        drift_detected,
+        threshold,
+        drift_point,
+        drift_topics,
+        similarity_curve,
+        recommendation,
+    })
+}
+
+// ---------------------------------------------------------------------------
+// DB helpers
+// ---------------------------------------------------------------------------
+
+fn find_issue(
+    conn: &rusqlite::Connection,
+    iid: i64,
+    project_filter: Option<&str>,
+) -> Result<IssueInfo> {
+    let (sql, params): (&str, Vec<Box<dyn rusqlite::ToSql>>) = match project_filter {
+        Some(project) => {
+            let project_id = resolve_project(conn, project)?;
+            (
+                "SELECT i.id, i.iid, i.title, i.description
+                 FROM issues i
+                 WHERE i.iid = ? AND i.project_id = ?",
+                vec![Box::new(iid), Box::new(project_id)],
+            )
+        }
+        None => (
+            "SELECT i.id, i.iid, i.title, i.description
+             FROM issues i
+             WHERE i.iid = ?",
+            vec![Box::new(iid)],
+        ),
+    };
+
+    let param_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|p| p.as_ref()).collect();
+
+    let mut stmt = conn.prepare(sql)?;
+    let rows: Vec<IssueInfo> = stmt
+        .query_map(param_refs.as_slice(), |row| {
+            Ok(IssueInfo {
+                id: row.get(0)?,
+                iid: row.get(1)?,
+                title: row.get(2)?,
+                description: row.get(3)?,
+            })
+        })?
+        .collect::<std::result::Result<Vec<_>, _>>()?;
+
+    match rows.len() {
+        0 => Err(LoreError::NotFound(format!("Issue #{iid} not found"))),
+        1 => Ok(rows.into_iter().next().unwrap()),
+        _ => Err(LoreError::Ambiguous(format!(
+            "Issue #{iid} exists in multiple projects. Use --project to specify."
+        ))),
+    }
+}
+
+fn fetch_notes(conn: &rusqlite::Connection, issue_id: i64) -> Result<Vec<NoteRow>> {
+    let mut stmt = conn.prepare(
+        "SELECT n.id, n.body, n.author_username, n.created_at
+         FROM notes n
+         JOIN discussions d ON n.discussion_id = d.id
+         WHERE d.issue_id = ?
+           AND n.is_system = 0
+           AND LENGTH(n.body) >= 20
+         ORDER BY n.created_at ASC
+         LIMIT ?",
+    )?;
+
+    let notes: Vec<NoteRow> = stmt
+        .query_map(rusqlite::params![issue_id, MAX_NOTES], |row| {
+            Ok(NoteRow {
+                id: row.get(0)?,
+                body: row.get(1)?,
+                author_username: row.get(2)?,
+                created_at: row.get(3)?,
+            })
+        })?
+        .collect::<std::result::Result<Vec<_>, _>>()?;
+
+    Ok(notes)
+}
+
+// ---------------------------------------------------------------------------
+// Embedding helper
+// ---------------------------------------------------------------------------
+
+async fn embed_texts(config: &Config, texts: &[String]) -> Result<Vec<Vec<f32>>> {
+    let ollama = OllamaClient::new(OllamaConfig {
+        base_url: config.embedding.base_url.clone(),
+        model: config.embedding.model.clone(),
+        timeout_secs: 60,
+    });
+
+    let mut all_embeddings: Vec<Vec<f32>> = Vec::with_capacity(texts.len());
+
+    for chunk in texts.chunks(BATCH_SIZE) {
+        let refs: Vec<&str> = chunk.iter().map(|s| s.as_str()).collect();
+        let batch_result = ollama.embed_batch(&refs).await?;
+        all_embeddings.extend(batch_result);
+    }
+
+    Ok(all_embeddings)
+}
+
+// ---------------------------------------------------------------------------
+// Drift detection
+// ---------------------------------------------------------------------------
+
+fn detect_drift(
+    curve: &[SimilarityPoint],
+    notes: &[NoteRow],
+    threshold: f32,
+) -> (bool, Option<DriftPoint>) {
+    if curve.len() < WINDOW_SIZE {
+        return (false, None);
+    }
+
+    for i in 0..=curve.len() - WINDOW_SIZE {
+        let window_avg: f32 = curve[i..i + WINDOW_SIZE]
+            .iter()
+            .map(|p| p.similarity)
+            .sum::<f32>()
+            / WINDOW_SIZE as f32;
+
+        if window_avg < threshold {
+            return (
+                true,
+                Some(DriftPoint {
+                    note_index: i,
+                    note_id: notes[i].id,
+                    author: notes[i].author_username.clone(),
+                    created_at: ms_to_iso(notes[i].created_at),
+                    similarity: curve[i].similarity,
+                }),
+            );
+        }
+    }
+
+    (false, None)
+}
+
+// ---------------------------------------------------------------------------
+// Topic extraction
+// ---------------------------------------------------------------------------
+
+static STOPWORDS: LazyLock<std::collections::HashSet<&'static str>> = LazyLock::new(|| {
+    [
+        "the", "a", "an", "is", "are", "was", "were", "be", "been", "being", "have", "has", "had",
+        "do", "does", "did", "will", "would", "could", "should", "may", "might", "shall", "can",
+        "need", "dare", "ought", "used", "to", "of", "in", "for", "on", "with", "at", "by", "from",
+        "as", "into", "through", "during", "before", "after", "above", "below", "between", "out",
+        "off", "over", "under", "again", "further", "then", "once", "here", "there", "when",
+        "where", "why", "how", "all", "each", "every", "both", "few", "more", "most", "other",
+        "some", "such", "no", "not", "only", "own", "same", "so", "than", "too", "very", "just",
+        "because", "but", "and", "or", "if", "while", "about", "up", "it", "its", "this", "that",
+        "these", "those", "i", "me", "my", "we", "our", "you", "your", "he", "him", "his", "she",
+        "her", "they", "them", "their", "what", "which", "who", "whom", "also", "like", "get",
+        "got", "think", "know", "see", "make", "go", "one", "two", "new", "way",
+    ]
+    .into_iter()
+    .collect()
+});
+
+fn tokenize(text: &str) -> Vec<String> {
+    let cleaned = strip_markdown(text);
+    cleaned
+        .split(|c: char| !c.is_alphanumeric() && c != '_')
+        .filter(|w| w.len() >= 3)
+        .map(|w| w.to_lowercase())
+        .filter(|w| !STOPWORDS.contains(w.as_str()))
+        .collect()
+}
+
+fn extract_drift_topics(description: &str, notes: &[NoteRow], drift_idx: usize) -> Vec<String> {
+    let desc_terms: std::collections::HashSet<String> = tokenize(description).into_iter().collect();
+
+    let mut freq: HashMap<String, usize> = HashMap::new();
+    for note in notes.iter().skip(drift_idx) {
+        for term in tokenize(&note.body) {
+            if !desc_terms.contains(&term) {
+                *freq.entry(term).or_insert(0) += 1;
+            }
+        }
+    }
+
+    let mut sorted: Vec<(String, usize)> = freq.into_iter().collect();
+    sorted.sort_by(|a, b| b.1.cmp(&a.1));
+
+    sorted
+        .into_iter()
+        .take(TOP_TOPICS)
+        .map(|(t, _)| t)
+        .collect()
+}
+
+// ---------------------------------------------------------------------------
+// Markdown stripping
+// ---------------------------------------------------------------------------
+
+static RE_FENCED_CODE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"(?s)```[^\n]*\n.*?```").unwrap());
+static RE_INLINE_CODE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"`[^`]+`").unwrap());
+static RE_LINK: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\[([^\]]+)\]\([^)]+\)").unwrap());
+static RE_BLOCKQUOTE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?m)^>\s?").unwrap());
+static RE_HTML_TAG: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"<[^>]+>").unwrap());
+
+fn strip_markdown(text: &str) -> String {
+    let text = RE_FENCED_CODE.replace_all(text, "");
+    let text = RE_INLINE_CODE.replace_all(&text, "");
+    let text = RE_LINK.replace_all(&text, "$1");
+    let text = RE_BLOCKQUOTE.replace_all(&text, "");
+    let text = RE_HTML_TAG.replace_all(&text, "");
+    text.into_owned()
+}
+
+// ---------------------------------------------------------------------------
+// Printers
+// ---------------------------------------------------------------------------
+
+pub fn print_drift_human(response: &DriftResponse) {
+    let header = format!(
+        "Drift Analysis: {} #{}",
+        response.entity.entity_type, response.entity.iid
+    );
+    println!("{}", style(&header).bold());
+    println!("{}", "-".repeat(header.len().min(60)));
+    println!("Title:     {}", response.entity.title);
+    println!("Threshold: {:.2}", response.threshold);
+    println!("Notes:     {}", response.similarity_curve.len());
+    println!();
+
+    if response.drift_detected {
+        println!("{}", style("DRIFT DETECTED").red().bold());
+        if let Some(dp) = &response.drift_point {
+            println!(
+                "  At note #{} by @{} ({}) - similarity {:.2}",
+                dp.note_index, dp.author, dp.created_at, dp.similarity
+            );
+        }
+        if !response.drift_topics.is_empty() {
+            println!("  Topics:  {}", response.drift_topics.join(", "));
+        }
+    } else {
+        println!("{}", style("No drift detected").green());
+    }
+
+    println!();
+    println!("{}", response.recommendation);
+
+    if !response.similarity_curve.is_empty() {
+        println!();
+        println!("{}", style("Similarity Curve:").bold());
+        for pt in &response.similarity_curve {
+            let bar_len = ((pt.similarity.max(0.0)) * 30.0) as usize;
+            let bar: String = "#".repeat(bar_len);
+            println!(
+                "  {:>3}  {:.2}  {}  @{}",
+                pt.note_index, pt.similarity, bar, pt.author
+            );
+        }
+    }
+}
+
+pub fn print_drift_json(response: &DriftResponse, elapsed_ms: u64) {
+    let meta = RobotMeta { elapsed_ms };
+    let output = serde_json::json!({
+        "ok": true,
+        "data": response,
+        "meta": meta,
+    });
+    match serde_json::to_string(&output) {
+        Ok(json) => println!("{json}"),
+        Err(e) => eprintln!("Error serializing to JSON: {e}"),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_detect_drift_when_divergent() {
+        let notes: Vec<NoteRow> = (0..6)
+            .map(|i| NoteRow {
+                id: i as i64,
+                body: format!("note {i}"),
+                author_username: "user".to_string(),
+                created_at: 1000 + i as i64,
+            })
+            .collect();
+
+        let curve: Vec<SimilarityPoint> = [0.9, 0.85, 0.8, 0.25, 0.2, 0.15]
+            .iter()
+            .enumerate()
+            .map(|(i, &sim)| SimilarityPoint {
+                note_index: i,
+                similarity: sim,
+                author: "user".to_string(),
+                created_at: ms_to_iso(1000 + i as i64),
+            })
+            .collect();
+
+        let (detected, point) = detect_drift(&curve, &notes, 0.4);
+        assert!(detected);
+        assert!(point.is_some());
+    }
+
+    #[test]
+    fn test_no_drift_consistent() {
+        let notes: Vec<NoteRow> = (0..5)
+            .map(|i| NoteRow {
+                id: i as i64,
+                body: format!("note {i}"),
+                author_username: "user".to_string(),
+                created_at: 1000 + i as i64,
+            })
+            .collect();
+
+        let curve: Vec<SimilarityPoint> = [0.85, 0.8, 0.75, 0.7, 0.65]
+            .iter()
+            .enumerate()
+            .map(|(i, &sim)| SimilarityPoint {
+                note_index: i,
+                similarity: sim,
+                author: "user".to_string(),
+                created_at: ms_to_iso(1000 + i as i64),
+            })
+            .collect();
+
+        let (detected, _) = detect_drift(&curve, &notes, 0.4);
+        assert!(!detected);
+    }
+
+    #[test]
+    fn test_drift_point_is_first_divergent() {
+        let notes: Vec<NoteRow> = (0..5)
+            .map(|i| NoteRow {
+                id: (i * 10) as i64,
+                body: format!("note {i}"),
+                author_username: format!("user{i}"),
+                created_at: 1000 + i as i64,
+            })
+            .collect();
+
+        // Window of 3: indices [0,1,2] avg=0.83, [1,2,3] avg=0.55, [2,3,4] avg=0.23
+        let curve: Vec<SimilarityPoint> = [0.9, 0.8, 0.8, 0.05, 0.05]
+            .iter()
+            .enumerate()
+            .map(|(i, &sim)| SimilarityPoint {
+                note_index: i,
+                similarity: sim,
+                author: format!("user{i}"),
+                created_at: ms_to_iso(1000 + i as i64),
+            })
+            .collect();
+
+        let (detected, point) = detect_drift(&curve, &notes, 0.4);
+        assert!(detected);
+        let dp = point.unwrap();
+        // Window [2,3,4] avg = (0.8+0.05+0.05)/3 = 0.3 < 0.4
+        // But [1,2,3] avg = (0.8+0.8+0.05)/3 = 0.55 >= 0.4, so first failing is index 2
+        assert_eq!(dp.note_index, 2);
+        assert_eq!(dp.note_id, 20);
+    }
+
+    #[test]
+    fn test_extract_drift_topics_excludes_description_terms() {
+        let description = "We need to fix the authentication flow for login users";
+        let notes = vec![
+            NoteRow {
+                id: 1,
+                body: "The database migration script is broken and needs postgres update"
+                    .to_string(),
+                author_username: "dev".to_string(),
+                created_at: 1000,
+            },
+            NoteRow {
+                id: 2,
+                body: "The database connection pool also has migration issues with postgres"
+                    .to_string(),
+                author_username: "dev".to_string(),
+                created_at: 2000,
+            },
+        ];
+
+        let topics = extract_drift_topics(description, &notes, 0);
+        // "database", "migration", "postgres" should appear; "fix" should not (it's in description)
+        assert!(!topics.is_empty());
+        for t in &topics {
+            assert_ne!(t, "fix");
+            assert_ne!(t, "authentication");
+            assert_ne!(t, "login");
+        }
+    }
+
+    #[test]
+    fn test_strip_markdown_code_blocks() {
+        let input = "Before\n```rust\nfn main() {}\n```\nAfter";
+        let result = strip_markdown(input);
+        assert!(!result.contains("fn main"));
+        assert!(result.contains("Before"));
+        assert!(result.contains("After"));
+    }
+
+    #[test]
+    fn test_strip_markdown_preserves_text() {
+        let input = "Check [this link](https://example.com) and `inline code` for details";
+        let result = strip_markdown(input);
+        assert!(result.contains("this link"));
+        assert!(!result.contains("https://example.com"));
+        assert!(!result.contains("inline code"));
+        assert!(result.contains("details"));
+    }
+
+    #[test]
+    fn test_too_few_notes() {
+        let notes: Vec<NoteRow> = (0..2)
+            .map(|i| NoteRow {
+                id: i as i64,
+                body: format!("note {i}"),
+                author_username: "user".to_string(),
+                created_at: 1000 + i as i64,
+            })
+            .collect();
+
+        let curve: Vec<SimilarityPoint> = [0.1, 0.1]
+            .iter()
+            .enumerate()
+            .map(|(i, &sim)| SimilarityPoint {
+                note_index: i,
+                similarity: sim,
+                author: "user".to_string(),
+                created_at: ms_to_iso(1000 + i as i64),
+            })
+            .collect();
+
+        let (detected, _) = detect_drift(&curve, &notes, 0.4);
+        assert!(!detected);
+    }
+}

src/cli/commands/ingest.rs

@@ -44,6 +44,21 @@ pub struct IngestResult {
     pub resource_events_failed: usize,
     pub mr_diffs_fetched: usize,
     pub mr_diffs_failed: usize,
+    pub status_enrichment_errors: usize,
+    pub status_enrichment_projects: Vec<ProjectStatusEnrichment>,
+}
+
+/// Per-project status enrichment result, collected during ingestion.
+pub struct ProjectStatusEnrichment {
+    pub mode: String,
+    pub reason: Option<String>,
+    pub seen: usize,
+    pub enriched: usize,
+    pub cleared: usize,
+    pub without_widget: usize,
+    pub partial_errors: usize,
+    pub first_partial_error: Option<String>,
+    pub error: Option<String>,
 }
 
 #[derive(Debug, Default, Clone, Serialize)]
@@ -517,6 +532,41 @@ async fn run_ingest_inner(
                         ProgressEvent::MrDiffsFetchComplete { .. } => {
                             disc_bar_clone.finish_and_clear();
                         }
+                        ProgressEvent::StatusEnrichmentStarted => {
+                            spinner_clone.set_message(format!(
+                                "{path_for_cb}: Enriching work item statuses..."
+                            ));
+                            stage_bar_clone.set_message(
+                                "Enriching work item statuses...".to_string()
+                            );
+                        }
+                        ProgressEvent::StatusEnrichmentPageFetched { items_so_far } => {
+                            spinner_clone.set_message(format!(
+                                "{path_for_cb}: Fetching statuses... ({items_so_far} work items)"
+                            ));
+                            stage_bar_clone.set_message(format!(
+                                "Enriching work item statuses... ({items_so_far} fetched)"
+                            ));
+                        }
+                        ProgressEvent::StatusEnrichmentWriting { total } => {
+                            spinner_clone.set_message(format!(
+                                "{path_for_cb}: Writing {total} statuses..."
+                            ));
+                            stage_bar_clone.set_message(format!(
+                                "Writing {total} work item statuses..."
+                            ));
+                        }
+                        ProgressEvent::StatusEnrichmentComplete { enriched, cleared } => {
+                            if enriched > 0 || cleared > 0 {
+                                spinner_clone.set_message(format!(
+                                    "{path_for_cb}: {enriched} statuses enriched, {cleared} cleared"
+                                ));
+                                stage_bar_clone.set_message(format!(
+                                    "Status enrichment: {enriched} enriched, {cleared} cleared"
+                                ));
+                            }
+                        }
+                        ProgressEvent::StatusEnrichmentSkipped => {}
                     })
                 };
 
@@ -587,6 +637,22 @@ async fn run_ingest_inner(
                 total.issues_skipped_discussion_sync += result.issues_skipped_discussion_sync;
                 total.resource_events_fetched += result.resource_events_fetched;
                 total.resource_events_failed += result.resource_events_failed;
+                if result.status_enrichment_error.is_some() {
+                    total.status_enrichment_errors += 1;
+                }
+                total
+                    .status_enrichment_projects
+                    .push(ProjectStatusEnrichment {
+                        mode: result.status_enrichment_mode.clone(),
+                        reason: result.status_unsupported_reason.clone(),
+                        seen: result.statuses_seen,
+                        enriched: result.statuses_enriched,
+                        cleared: result.statuses_cleared,
+                        without_widget: result.statuses_without_widget,
+                        partial_errors: result.partial_error_count,
+                        first_partial_error: result.first_partial_error.clone(),
+                        error: result.status_enrichment_error.clone(),
+                    });
             }
             Ok(ProjectIngestOutcome::Mrs {
                 ref path,
@@ -767,6 +833,25 @@ struct IngestJsonData {
     notes_upserted: usize,
     resource_events_fetched: usize,
     resource_events_failed: usize,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    status_enrichment: Vec<StatusEnrichmentJson>,
+    status_enrichment_errors: usize,
+}
+
+#[derive(Serialize)]
+struct StatusEnrichmentJson {
+    mode: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    reason: Option<String>,
+    seen: usize,
+    enriched: usize,
+    cleared: usize,
+    without_widget: usize,
+    partial_errors: usize,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    first_partial_error: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    error: Option<String>,
 }
 
 #[derive(Serialize)]
@@ -814,6 +899,22 @@ pub fn print_ingest_summary_json(result: &IngestResult, elapsed_ms: u64) {
         )
     };
 
+    let status_enrichment: Vec<StatusEnrichmentJson> = result
+        .status_enrichment_projects
+        .iter()
+        .map(|p| StatusEnrichmentJson {
+            mode: p.mode.clone(),
+            reason: p.reason.clone(),
+            seen: p.seen,
+            enriched: p.enriched,
+            cleared: p.cleared,
+            without_widget: p.without_widget,
+            partial_errors: p.partial_errors,
+            first_partial_error: p.first_partial_error.clone(),
+            error: p.error.clone(),
+        })
+        .collect();
+
     let output = IngestJsonOutput {
         ok: true,
         data: IngestJsonData {
@@ -826,6 +927,8 @@ pub fn print_ingest_summary_json(result: &IngestResult, elapsed_ms: u64) {
             notes_upserted: result.notes_upserted,
             resource_events_fetched: result.resource_events_fetched,
             resource_events_failed: result.resource_events_failed,
+            status_enrichment,
+            status_enrichment_errors: result.status_enrichment_errors,
         },
         meta: RobotMeta { elapsed_ms },
     };

src/cli/commands/init.rs

@@ -10,6 +10,7 @@ pub struct InitInputs {
     pub gitlab_url: String,
     pub token_env_var: String,
     pub project_paths: Vec<String>,
+    pub default_project: Option<String>,
 }
 
 pub struct InitOptions {
@@ -23,6 +24,7 @@ pub struct InitResult {
     pub data_dir: String,
     pub user: UserInfo,
     pub projects: Vec<ProjectInfo>,
+    pub default_project: Option<String>,
 }
 
 pub struct UserInfo {
@@ -104,6 +106,20 @@ pub async fn run_init(inputs: InitInputs, options: InitOptions) -> Result<InitRe
         ));
     }
 
+    // Validate default_project matches one of the configured project paths
+    if let Some(ref dp) = inputs.default_project {
+        let matched = inputs.project_paths.iter().any(|p| {
+            p.eq_ignore_ascii_case(dp)
+                || p.to_ascii_lowercase()
+                    .ends_with(&format!("/{}", dp.to_ascii_lowercase()))
+        });
+        if !matched {
+            return Err(LoreError::Other(format!(
+                "defaultProject '{dp}' does not match any configured project path"
+            )));
+        }
+    }
+
     if let Some(parent) = config_path.parent() {
         fs::create_dir_all(parent)?;
     }
@@ -118,6 +134,7 @@ pub async fn run_init(inputs: InitInputs, options: InitOptions) -> Result<InitRe
             .iter()
             .map(|p| ProjectConfig { path: p.clone() })
             .collect(),
+        default_project: inputs.default_project.clone(),
     };
 
     let config_json = serde_json::to_string_pretty(&config)?;
@@ -152,5 +169,6 @@ pub async fn run_init(inputs: InitInputs, options: InitOptions) -> Result<InitRe
         data_dir: data_dir.display().to_string(),
         user,
         projects: validated_projects.into_iter().map(|(p, _)| p).collect(),
+        default_project: inputs.default_project,
     })
 }

src/cli/commands/list.rs

@@ -19,6 +19,29 @@ fn colored_cell(content: impl std::fmt::Display, color: Color) -> Cell {
     }
 }
 
+fn colored_cell_hex(content: &str, hex: Option<&str>) -> Cell {
+    if !console::colors_enabled() {
+        return Cell::new(content);
+    }
+    let Some(hex) = hex else {
+        return Cell::new(content);
+    };
+    let hex = hex.trim_start_matches('#');
+    if hex.len() != 6 {
+        return Cell::new(content);
+    }
+    let Ok(r) = u8::from_str_radix(&hex[0..2], 16) else {
+        return Cell::new(content);
+    };
+    let Ok(g) = u8::from_str_radix(&hex[2..4], 16) else {
+        return Cell::new(content);
+    };
+    let Ok(b) = u8::from_str_radix(&hex[4..6], 16) else {
+        return Cell::new(content);
+    };
+    Cell::new(content).fg(Color::Rgb { r, g, b })
+}
+
 #[derive(Debug, Serialize)]
 pub struct IssueListRow {
     pub iid: i64,
@@ -34,6 +57,16 @@ pub struct IssueListRow {
     pub assignees: Vec<String>,
     pub discussion_count: i64,
     pub unresolved_count: i64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status_name: Option<String>,
+    #[serde(skip_serializing)]
+    pub status_category: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status_color: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status_icon_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status_synced_at: Option<i64>,
 }
 
 #[derive(Serialize)]
@@ -51,6 +84,16 @@ pub struct IssueListRowJson {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub web_url: Option<String>,
     pub project_path: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status_name: Option<String>,
+    #[serde(skip_serializing)]
+    pub status_category: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status_color: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status_icon_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status_synced_at_iso: Option<String>,
 }
 
 impl From<&IssueListRow> for IssueListRowJson {
@@ -68,6 +111,11 @@ impl From<&IssueListRow> for IssueListRowJson {
             updated_at_iso: ms_to_iso(row.updated_at),
             web_url: row.web_url.clone(),
             project_path: row.project_path.clone(),
+            status_name: row.status_name.clone(),
+            status_category: row.status_category.clone(),
+            status_color: row.status_color.clone(),
+            status_icon_name: row.status_icon_name.clone(),
+            status_synced_at_iso: row.status_synced_at.map(ms_to_iso),
         }
     }
 }
@@ -76,6 +124,7 @@ impl From<&IssueListRow> for IssueListRowJson {
 pub struct ListResult {
     pub issues: Vec<IssueListRow>,
     pub total_count: usize,
+    pub available_statuses: Vec<String>,
 }
 
 #[derive(Serialize)]
@@ -194,6 +243,7 @@ pub struct ListFilters<'a> {
     pub since: Option<&'a str>,
     pub due_before: Option<&'a str>,
     pub has_due_date: bool,
+    pub statuses: &'a [String],
     pub sort: &'a str,
     pub order: &'a str,
 }
@@ -219,10 +269,21 @@ pub fn run_list_issues(config: &Config, filters: ListFilters) -> Result<ListResu
     let db_path = get_db_path(config.storage.db_path.as_deref());
     let conn = create_connection(&db_path)?;
 
-    let result = query_issues(&conn, &filters)?;
+    let mut result = query_issues(&conn, &filters)?;
+    result.available_statuses = query_available_statuses(&conn)?;
     Ok(result)
 }
 
+fn query_available_statuses(conn: &Connection) -> Result<Vec<String>> {
+    let mut stmt = conn.prepare(
+        "SELECT DISTINCT status_name FROM issues WHERE status_name IS NOT NULL ORDER BY status_name",
+    )?;
+    let statuses = stmt
+        .query_map([], |row| row.get::<_, String>(0))?
+        .collect::<std::result::Result<Vec<_>, _>>()?;
+    Ok(statuses)
+}
+
 fn query_issues(conn: &Connection, filters: &ListFilters) -> Result<ListResult> {
     let mut where_clauses = Vec::new();
     let mut params: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
@@ -291,6 +352,22 @@ fn query_issues(conn: &Connection, filters: &ListFilters) -> Result<ListResult>
         where_clauses.push("i.due_date IS NOT NULL");
     }
 
+    let status_in_clause;
+    if filters.statuses.len() == 1 {
+        where_clauses.push("i.status_name = ? COLLATE NOCASE");
+        params.push(Box::new(filters.statuses[0].clone()));
+    } else if filters.statuses.len() > 1 {
+        let placeholders: Vec<&str> = filters.statuses.iter().map(|_| "?").collect();
+        status_in_clause = format!(
+            "i.status_name COLLATE NOCASE IN ({})",
+            placeholders.join(", ")
+        );
+        where_clauses.push(&status_in_clause);
+        for s in filters.statuses {
+            params.push(Box::new(s.clone()));
+        }
+    }
+
     let where_sql = if where_clauses.is_empty() {
         String::new()
     } else {
@@ -338,7 +415,12 @@ fn query_issues(conn: &Connection, filters: &ListFilters) -> Result<ListResult>
             (SELECT COUNT(*) FROM discussions d
              WHERE d.issue_id = i.id) AS discussion_count,
             (SELECT COUNT(*) FROM discussions d
-             WHERE d.issue_id = i.id AND d.resolvable = 1 AND d.resolved = 0) AS unresolved_count
+             WHERE d.issue_id = i.id AND d.resolvable = 1 AND d.resolved = 0) AS unresolved_count,
+            i.status_name,
+            i.status_category,
+            i.status_color,
+            i.status_icon_name,
+            i.status_synced_at
          FROM issues i
          JOIN projects p ON i.project_id = p.id
          {where_sql}
@@ -375,6 +457,11 @@ fn query_issues(conn: &Connection, filters: &ListFilters) -> Result<ListResult>
                 assignees,
                 discussion_count: row.get(10)?,
                 unresolved_count: row.get(11)?,
+                status_name: row.get(12)?,
+                status_category: row.get(13)?,
+                status_color: row.get(14)?,
+                status_icon_name: row.get(15)?,
+                status_synced_at: row.get(16)?,
             })
         })?
         .collect::<std::result::Result<Vec<_>, _>>()?;
@@ -382,6 +469,7 @@ fn query_issues(conn: &Connection, filters: &ListFilters) -> Result<ListResult>
     Ok(ListResult {
         issues,
         total_count,
+        available_statuses: Vec::new(),
     })
 }
 
@@ -683,18 +771,27 @@ pub fn print_list_issues(result: &ListResult) {
         result.total_count
     );
 
+    let has_any_status = result.issues.iter().any(|i| i.status_name.is_some());
+
+    let mut header = vec![
+        Cell::new("IID").add_attribute(Attribute::Bold),
+        Cell::new("Title").add_attribute(Attribute::Bold),
+        Cell::new("State").add_attribute(Attribute::Bold),
+    ];
+    if has_any_status {
+        header.push(Cell::new("Status").add_attribute(Attribute::Bold));
+    }
+    header.extend([
+        Cell::new("Assignee").add_attribute(Attribute::Bold),
+        Cell::new("Labels").add_attribute(Attribute::Bold),
+        Cell::new("Disc").add_attribute(Attribute::Bold),
+        Cell::new("Updated").add_attribute(Attribute::Bold),
+    ]);
+
     let mut table = Table::new();
     table
         .set_content_arrangement(ContentArrangement::Dynamic)
-        .set_header(vec![
-            Cell::new("IID").add_attribute(Attribute::Bold),
-            Cell::new("Title").add_attribute(Attribute::Bold),
-            Cell::new("State").add_attribute(Attribute::Bold),
-            Cell::new("Assignee").add_attribute(Attribute::Bold),
-            Cell::new("Labels").add_attribute(Attribute::Bold),
-            Cell::new("Disc").add_attribute(Attribute::Bold),
-            Cell::new("Updated").add_attribute(Attribute::Bold),
-        ]);
+        .set_header(header);
 
     for issue in &result.issues {
         let title = truncate_with_ellipsis(&issue.title, 45);
@@ -709,15 +806,28 @@ pub fn print_list_issues(result: &ListResult) {
             colored_cell(&issue.state, Color::DarkGrey)
         };
 
-        table.add_row(vec![
+        let mut row = vec![
             colored_cell(format!("#{}", issue.iid), Color::Cyan),
             Cell::new(title),
             state_cell,
+        ];
+        if has_any_status {
+            match &issue.status_name {
+                Some(status) => {
+                    row.push(colored_cell_hex(status, issue.status_color.as_deref()));
+                }
+                None => {
+                    row.push(Cell::new(""));
+                }
+            }
+        }
+        row.extend([
             colored_cell(assignee, Color::Magenta),
             colored_cell(labels, Color::Yellow),
             Cell::new(discussions),
             colored_cell(relative_time, Color::DarkGrey),
         ]);
+        table.add_row(row);
     }
 
     println!("{table}");
@@ -725,11 +835,13 @@ pub fn print_list_issues(result: &ListResult) {
 
 pub fn print_list_issues_json(result: &ListResult, elapsed_ms: u64, fields: Option<&[String]>) {
     let json_result = ListResultJson::from(result);
-    let meta = RobotMeta { elapsed_ms };
     let output = serde_json::json!({
         "ok": true,
         "data": json_result,
-        "meta": meta,
+        "meta": {
+            "elapsed_ms": elapsed_ms,
+            "available_statuses": result.available_statuses,
+        },
     });
     let mut output = output;
     if let Some(f) = fields {

src/cli/commands/mod.rs

@@ -1,6 +1,7 @@
 pub mod auth_test;
 pub mod count;
 pub mod doctor;
+pub mod drift;
 pub mod embed;
 pub mod generate_docs;
 pub mod ingest;
@@ -20,6 +21,7 @@ pub use count::{
     run_count_events,
 };
 pub use doctor::{DoctorChecks, print_doctor_results, run_doctor};
+pub use drift::{DriftResponse, print_drift_human, print_drift_json, run_drift};
 pub use embed::{print_embed, print_embed_json, run_embed};
 pub use generate_docs::{print_generate_docs, print_generate_docs_json, run_generate_docs};
 pub use ingest::{

src/cli/commands/search.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use console::style;
 use serde::Serialize;
 
@@ -8,9 +10,10 @@ use crate::core::paths::get_db_path;
 use crate::core::project::resolve_project;
 use crate::core::time::{ms_to_iso, parse_since};
 use crate::documents::SourceType;
+use crate::embedding::ollama::{OllamaClient, OllamaConfig};
 use crate::search::{
-    FtsQueryMode, PathFilter, SearchFilters, apply_filters, get_result_snippet, rank_rrf,
-    search_fts,
+    FtsQueryMode, HybridResult, PathFilter, SearchFilters, SearchMode, get_result_snippet,
+    search_fts, search_hybrid,
 };
 
 #[derive(Debug, Serialize)]
@@ -58,7 +61,7 @@ pub struct SearchCliFilters {
     pub limit: usize,
 }
 
-pub fn run_search(
+pub async fn run_search(
     config: &Config,
     query: &str,
     cli_filters: SearchCliFilters,
@@ -71,15 +74,18 @@ pub fn run_search(
 
     let mut warnings: Vec<String> = Vec::new();
 
-    // Determine actual mode: vector search requires embeddings, which need async + Ollama.
-    // Until hybrid/semantic are wired up, we run lexical and warn if the user asked for more.
-    let actual_mode = "lexical";
-    if requested_mode != "lexical" {
-        warnings.push(format!(
-            "Requested mode '{}' is not yet available; falling back to lexical search.",
-            requested_mode
-        ));
-    }
+    let actual_mode = SearchMode::parse(requested_mode).unwrap_or(SearchMode::Hybrid);
+
+    let client = if actual_mode != SearchMode::Lexical {
+        let ollama_cfg = &config.embedding;
+        Some(OllamaClient::new(OllamaConfig {
+            base_url: ollama_cfg.base_url.clone(),
+            model: ollama_cfg.model.clone(),
+            ..OllamaConfig::default()
+        }))
+    } else {
+        None
+    };
 
     let doc_count: i64 = conn
         .query_row("SELECT COUNT(*) FROM documents", [], |row| row.get(0))
@@ -89,7 +95,7 @@ pub fn run_search(
         warnings.push("No documents indexed. Run 'lore generate-docs' first.".to_string());
         return Ok(SearchResponse {
             query: query.to_string(),
-            mode: actual_mode.to_string(),
+            mode: actual_mode.as_str().to_string(),
             total_results: 0,
             results: vec![],
             warnings,
@@ -151,52 +157,54 @@ pub fn run_search(
         limit: cli_filters.limit,
     };
 
-    let requested = filters.clamp_limit();
-    let top_k = if filters.has_any_filter() {
-        (requested * 50).clamp(200, 1500)
-    } else {
-        (requested * 10).clamp(50, 1500)
-    };
-
-    let fts_results = search_fts(&conn, query, top_k, fts_mode)?;
-    let fts_tuples: Vec<(i64, f64)> = fts_results
-        .iter()
-        .map(|r| (r.document_id, r.bm25_score))
-        .collect();
-
-    let snippet_map: std::collections::HashMap<i64, String> = fts_results
+    // Run FTS separately for snippet extraction (search_hybrid doesn't return snippets).
+    let snippet_top_k = filters
+        .clamp_limit()
+        .checked_mul(10)
+        .unwrap_or(500)
+        .clamp(50, 1500);
+    let fts_results = search_fts(&conn, query, snippet_top_k, fts_mode)?;
+    let snippet_map: HashMap<i64, String> = fts_results
         .iter()
         .map(|r| (r.document_id, r.snippet.clone()))
         .collect();
 
-    let ranked = rank_rrf(&[], &fts_tuples);
-    let ranked_ids: Vec<i64> = ranked.iter().map(|r| r.document_id).collect();
+    // search_hybrid handles recall sizing, RRF ranking, and filter application internally.
+    let (hybrid_results, mut hybrid_warnings) = search_hybrid(
+        &conn,
+        client.as_ref(),
+        query,
+        actual_mode,
+        &filters,
+        fts_mode,
+    )
+    .await?;
+    warnings.append(&mut hybrid_warnings);
 
-    let filtered_ids = apply_filters(&conn, &ranked_ids, &filters)?;
-
-    if filtered_ids.is_empty() {
+    if hybrid_results.is_empty() {
         return Ok(SearchResponse {
             query: query.to_string(),
-            mode: actual_mode.to_string(),
+            mode: actual_mode.as_str().to_string(),
             total_results: 0,
             results: vec![],
             warnings,
         });
     }
 
-    let hydrated = hydrate_results(&conn, &filtered_ids)?;
+    let ranked_ids: Vec<i64> = hybrid_results.iter().map(|r| r.document_id).collect();
+    let hydrated = hydrate_results(&conn, &ranked_ids)?;
 
-    let rrf_map: std::collections::HashMap<i64, &crate::search::RrfResult> =
-        ranked.iter().map(|r| (r.document_id, r)).collect();
+    let hybrid_map: HashMap<i64, &HybridResult> =
+        hybrid_results.iter().map(|r| (r.document_id, r)).collect();
 
     let mut results: Vec<SearchResultDisplay> = Vec::with_capacity(hydrated.len());
     for row in &hydrated {
-        let rrf = rrf_map.get(&row.document_id);
+        let hr = hybrid_map.get(&row.document_id);
         let fts_snippet = snippet_map.get(&row.document_id).map(|s| s.as_str());
         let snippet = get_result_snippet(fts_snippet, &row.content_text);
 
         let explain_data = if explain {
-            rrf.map(|r| ExplainData {
+            hr.map(|r| ExplainData {
                 vector_rank: r.vector_rank,
                 fts_rank: r.fts_rank,
                 rrf_score: r.rrf_score,
@@ -217,14 +225,14 @@ pub fn run_search(
             labels: row.labels.clone(),
             paths: row.paths.clone(),
             snippet,
-            score: rrf.map(|r| r.normalized_score).unwrap_or(0.0),
+            score: hr.map(|r| r.score).unwrap_or(0.0),
             explain: explain_data,
         });
     }
 
     Ok(SearchResponse {
         query: query.to_string(),
-        mode: actual_mode.to_string(),
+        mode: actual_mode.as_str().to_string(),
         total_results: results.len(),
         results,
         warnings,
@@ -360,8 +368,12 @@ pub fn print_search_results(response: &SearchResponse) {
 
         if let Some(ref explain) = result.explain {
             println!(
-                "    {} fts_rank={} rrf_score={:.6}",
+                "    {} vector_rank={} fts_rank={} rrf_score={:.6}",
                 style("[explain]").magenta(),
+                explain
+                    .vector_rank
+                    .map(|r| r.to_string())
+                    .unwrap_or_else(|| "-".into()),
                 explain
                     .fts_rank
                     .map(|r| r.to_string())
@@ -386,11 +398,20 @@ struct SearchMeta {
     elapsed_ms: u64,
 }
 
-pub fn print_search_results_json(response: &SearchResponse, elapsed_ms: u64) {
+pub fn print_search_results_json(
+    response: &SearchResponse,
+    elapsed_ms: u64,
+    fields: Option<&[String]>,
+) {
     let output = SearchJsonOutput {
         ok: true,
         data: response,
         meta: SearchMeta { elapsed_ms },
     };
-    println!("{}", serde_json::to_string(&output).unwrap());
+    let mut value = serde_json::to_value(&output).unwrap();
+    if let Some(f) = fields {
+        let expanded = crate::cli::robot::expand_fields_preset(f, "search");
+        crate::cli::robot::filter_fields(&mut value, "results", &expanded);
+    }
+    println!("{}", serde_json::to_string(&value).unwrap());
 }

src/cli/commands/show.rs

@@ -75,14 +75,24 @@ pub struct IssueDetail {
     pub author_username: String,
     pub created_at: i64,
     pub updated_at: i64,
+    pub closed_at: Option<String>,
+    pub confidential: bool,
     pub web_url: Option<String>,
     pub project_path: String,
+    pub references_full: String,
     pub labels: Vec<String>,
     pub assignees: Vec<String>,
     pub due_date: Option<String>,
     pub milestone: Option<String>,
+    pub user_notes_count: i64,
+    pub merge_requests_count: usize,
     pub closing_merge_requests: Vec<ClosingMrRef>,
     pub discussions: Vec<DiscussionDetail>,
+    pub status_name: Option<String>,
+    pub status_category: Option<String>,
+    pub status_color: Option<String>,
+    pub status_icon_name: Option<String>,
+    pub status_synced_at: Option<i64>,
 }
 
 #[derive(Debug, Serialize)]
@@ -117,6 +127,9 @@ pub fn run_show_issue(
 
     let discussions = get_issue_discussions(&conn, issue.id)?;
 
+    let references_full = format!("{}#{}", issue.project_path, issue.iid);
+    let merge_requests_count = closing_mrs.len();
+
     Ok(IssueDetail {
         id: issue.id,
         iid: issue.iid,
@@ -126,14 +139,24 @@ pub fn run_show_issue(
         author_username: issue.author_username,
         created_at: issue.created_at,
         updated_at: issue.updated_at,
+        closed_at: issue.closed_at,
+        confidential: issue.confidential,
         web_url: issue.web_url,
         project_path: issue.project_path,
+        references_full,
         labels,
         assignees,
         due_date: issue.due_date,
         milestone: issue.milestone_title,
+        user_notes_count: issue.user_notes_count,
+        merge_requests_count,
         closing_merge_requests: closing_mrs,
         discussions,
+        status_name: issue.status_name,
+        status_category: issue.status_category,
+        status_color: issue.status_color,
+        status_icon_name: issue.status_icon_name,
+        status_synced_at: issue.status_synced_at,
     })
 }
 
@@ -146,10 +169,18 @@ struct IssueRow {
     author_username: String,
     created_at: i64,
     updated_at: i64,
+    closed_at: Option<String>,
+    confidential: bool,
     web_url: Option<String>,
     project_path: String,
     due_date: Option<String>,
     milestone_title: Option<String>,
+    user_notes_count: i64,
+    status_name: Option<String>,
+    status_category: Option<String>,
+    status_color: Option<String>,
+    status_icon_name: Option<String>,
+    status_synced_at: Option<i64>,
 }
 
 fn find_issue(conn: &Connection, iid: i64, project_filter: Option<&str>) -> Result<IssueRow> {
@@ -158,8 +189,14 @@ fn find_issue(conn: &Connection, iid: i64, project_filter: Option<&str>) -> Resu
             let project_id = resolve_project(conn, project)?;
             (
                 "SELECT i.id, i.iid, i.title, i.description, i.state, i.author_username,
-                        i.created_at, i.updated_at, i.web_url, p.path_with_namespace,
-                        i.due_date, i.milestone_title
+                        i.created_at, i.updated_at, i.closed_at, i.confidential,
+                        i.web_url, p.path_with_namespace,
+                        i.due_date, i.milestone_title,
+                        (SELECT COUNT(*) FROM notes n
+                         JOIN discussions d ON n.discussion_id = d.id
+                         WHERE d.noteable_type = 'Issue' AND d.noteable_id = i.id AND n.is_system = 0) AS user_notes_count,
+                        i.status_name, i.status_category, i.status_color,
+                        i.status_icon_name, i.status_synced_at
                  FROM issues i
                  JOIN projects p ON i.project_id = p.id
                  WHERE i.iid = ? AND i.project_id = ?",
@@ -168,8 +205,14 @@ fn find_issue(conn: &Connection, iid: i64, project_filter: Option<&str>) -> Resu
         }
         None => (
             "SELECT i.id, i.iid, i.title, i.description, i.state, i.author_username,
-                    i.created_at, i.updated_at, i.web_url, p.path_with_namespace,
-                    i.due_date, i.milestone_title
+                    i.created_at, i.updated_at, i.closed_at, i.confidential,
+                    i.web_url, p.path_with_namespace,
+                    i.due_date, i.milestone_title,
+                    (SELECT COUNT(*) FROM notes n
+                     JOIN discussions d ON n.discussion_id = d.id
+                     WHERE d.noteable_type = 'Issue' AND d.noteable_id = i.id AND n.is_system = 0) AS user_notes_count,
+                    i.status_name, i.status_category, i.status_color,
+                    i.status_icon_name, i.status_synced_at
              FROM issues i
              JOIN projects p ON i.project_id = p.id
              WHERE i.iid = ?",
@@ -182,6 +225,7 @@ fn find_issue(conn: &Connection, iid: i64, project_filter: Option<&str>) -> Resu
     let mut stmt = conn.prepare(sql)?;
     let issues: Vec<IssueRow> = stmt
         .query_map(param_refs.as_slice(), |row| {
+            let confidential_val: i64 = row.get(9)?;
             Ok(IssueRow {
                 id: row.get(0)?,
                 iid: row.get(1)?,
@@ -191,10 +235,18 @@ fn find_issue(conn: &Connection, iid: i64, project_filter: Option<&str>) -> Resu
                 author_username: row.get(5)?,
                 created_at: row.get(6)?,
                 updated_at: row.get(7)?,
-                web_url: row.get(8)?,
-                project_path: row.get(9)?,
-                due_date: row.get(10)?,
-                milestone_title: row.get(11)?,
+                closed_at: row.get(8)?,
+                confidential: confidential_val != 0,
+                web_url: row.get(10)?,
+                project_path: row.get(11)?,
+                due_date: row.get(12)?,
+                milestone_title: row.get(13)?,
+                user_notes_count: row.get(14)?,
+                status_name: row.get(15)?,
+                status_category: row.get(16)?,
+                status_color: row.get(17)?,
+                status_icon_name: row.get(18)?,
+                status_synced_at: row.get(19)?,
             })
         })?
         .collect::<std::result::Result<Vec<_>, _>>()?;
@@ -594,6 +646,7 @@ pub fn print_show_issue(issue: &IssueDetail) {
     println!("{}", "━".repeat(header.len().min(80)));
     println!();
 
+    println!("Ref:      {}", style(&issue.references_full).dim());
     println!("Project:  {}", style(&issue.project_path).cyan());
 
     let state_styled = if issue.state == "opened" {
@@ -603,6 +656,17 @@ pub fn print_show_issue(issue: &IssueDetail) {
     };
     println!("State:    {}", state_styled);
 
+    if issue.confidential {
+        println!("          {}", style("CONFIDENTIAL").red().bold());
+    }
+
+    if let Some(status) = &issue.status_name {
+        println!(
+            "Status:   {}",
+            style_with_hex(status, issue.status_color.as_deref())
+        );
+    }
+
     println!("Author:   @{}", issue.author_username);
 
     if !issue.assignees.is_empty() {
@@ -627,6 +691,10 @@ pub fn print_show_issue(issue: &IssueDetail) {
     println!("Created:  {}", format_date(issue.created_at));
     println!("Updated:  {}", format_date(issue.updated_at));
 
+    if let Some(closed_at) = &issue.closed_at {
+        println!("Closed:   {}", closed_at);
+    }
+
     if let Some(due) = &issue.due_date {
         println!("Due:      {}", due);
     }
@@ -864,6 +932,32 @@ fn print_diff_position(pos: &DiffNotePosition) {
     }
 }
 
+fn style_with_hex<'a>(text: &'a str, hex: Option<&str>) -> console::StyledObject<&'a str> {
+    let styled = console::style(text);
+    let Some(hex) = hex else { return styled };
+    let hex = hex.trim_start_matches('#');
+    if hex.len() != 6 {
+        return styled;
+    }
+    let Ok(r) = u8::from_str_radix(&hex[0..2], 16) else {
+        return styled;
+    };
+    let Ok(g) = u8::from_str_radix(&hex[2..4], 16) else {
+        return styled;
+    };
+    let Ok(b) = u8::from_str_radix(&hex[4..6], 16) else {
+        return styled;
+    };
+    styled.color256(ansi256_from_rgb(r, g, b))
+}
+
+fn ansi256_from_rgb(r: u8, g: u8, b: u8) -> u8 {
+    let ri = (u16::from(r) * 5 + 127) / 255;
+    let gi = (u16::from(g) * 5 + 127) / 255;
+    let bi = (u16::from(b) * 5 + 127) / 255;
+    (16 + 36 * ri + 6 * gi + bi) as u8
+}
+
 #[derive(Serialize)]
 pub struct IssueDetailJson {
     pub id: i64,
@@ -874,14 +968,25 @@ pub struct IssueDetailJson {
     pub author_username: String,
     pub created_at: String,
     pub updated_at: String,
+    pub closed_at: Option<String>,
+    pub confidential: bool,
     pub web_url: Option<String>,
     pub project_path: String,
+    pub references_full: String,
     pub labels: Vec<String>,
     pub assignees: Vec<String>,
     pub due_date: Option<String>,
     pub milestone: Option<String>,
+    pub user_notes_count: i64,
+    pub merge_requests_count: usize,
     pub closing_merge_requests: Vec<ClosingMrRefJson>,
     pub discussions: Vec<DiscussionDetailJson>,
+    pub status_name: Option<String>,
+    #[serde(skip_serializing)]
+    pub status_category: Option<String>,
+    pub status_color: Option<String>,
+    pub status_icon_name: Option<String>,
+    pub status_synced_at: Option<String>,
 }
 
 #[derive(Serialize)]
@@ -917,12 +1022,17 @@ impl From<&IssueDetail> for IssueDetailJson {
             author_username: issue.author_username.clone(),
             created_at: ms_to_iso(issue.created_at),
             updated_at: ms_to_iso(issue.updated_at),
+            closed_at: issue.closed_at.clone(),
+            confidential: issue.confidential,
             web_url: issue.web_url.clone(),
             project_path: issue.project_path.clone(),
+            references_full: issue.references_full.clone(),
             labels: issue.labels.clone(),
             assignees: issue.assignees.clone(),
             due_date: issue.due_date.clone(),
             milestone: issue.milestone.clone(),
+            user_notes_count: issue.user_notes_count,
+            merge_requests_count: issue.merge_requests_count,
             closing_merge_requests: issue
                 .closing_merge_requests
                 .iter()
@@ -934,6 +1044,11 @@ impl From<&IssueDetail> for IssueDetailJson {
                 })
                 .collect(),
             discussions: issue.discussions.iter().map(|d| d.into()).collect(),
+            status_name: issue.status_name.clone(),
+            status_category: issue.status_category.clone(),
+            status_color: issue.status_color.clone(),
+            status_icon_name: issue.status_icon_name.clone(),
+            status_synced_at: issue.status_synced_at.map(ms_to_iso),
         }
     }
 }
@@ -1103,6 +1218,12 @@ mod tests {
         .unwrap();
     }
 
+    #[test]
+    fn test_ansi256_from_rgb() {
+        assert_eq!(ansi256_from_rgb(0, 0, 0), 16);
+        assert_eq!(ansi256_from_rgb(255, 255, 255), 231);
+    }
+
     #[test]
     fn test_get_issue_assignees_empty() {
         let conn = setup_test_db();

src/cli/commands/stats.rs

@@ -79,33 +79,43 @@ pub fn run_stats(config: &Config, check: bool, repair: bool, dry_run: bool) -> R
 
     let mut result = StatsResult::default();
 
-    result.documents.total = count_query(&conn, "SELECT COUNT(*) FROM documents")?;
-    result.documents.issues = count_query(
-        &conn,
-        "SELECT COUNT(*) FROM documents WHERE source_type = 'issue'",
-    )?;
-    result.documents.merge_requests = count_query(
-        &conn,
-        "SELECT COUNT(*) FROM documents WHERE source_type = 'merge_request'",
-    )?;
-    result.documents.discussions = count_query(
-        &conn,
-        "SELECT COUNT(*) FROM documents WHERE source_type = 'discussion'",
-    )?;
-    result.documents.truncated = count_query(
-        &conn,
-        "SELECT COUNT(*) FROM documents WHERE is_truncated = 1",
-    )?;
+    // Single-scan conditional aggregate: 5 sequential COUNT(*) → 1 table scan
+    let (total, issues, mrs, discussions, truncated) = conn
+        .query_row(
+            "SELECT COUNT(*),
+                    COALESCE(SUM(CASE WHEN source_type = 'issue' THEN 1 END), 0),
+                    COALESCE(SUM(CASE WHEN source_type = 'merge_request' THEN 1 END), 0),
+                    COALESCE(SUM(CASE WHEN source_type = 'discussion' THEN 1 END), 0),
+                    COALESCE(SUM(CASE WHEN is_truncated = 1 THEN 1 END), 0)
+             FROM documents",
+            [],
+            |row| {
+                Ok((
+                    row.get::<_, i64>(0)?,
+                    row.get::<_, i64>(1)?,
+                    row.get::<_, i64>(2)?,
+                    row.get::<_, i64>(3)?,
+                    row.get::<_, i64>(4)?,
+                ))
+            },
+        )
+        .unwrap_or((0, 0, 0, 0, 0));
+    result.documents.total = total;
+    result.documents.issues = issues;
+    result.documents.merge_requests = mrs;
+    result.documents.discussions = discussions;
+    result.documents.truncated = truncated;
 
     if table_exists(&conn, "embedding_metadata") {
-        let embedded = count_query(
-            &conn,
-            "SELECT COUNT(DISTINCT document_id) FROM embedding_metadata WHERE last_error IS NULL",
-        )?;
-        let chunks = count_query(
-            &conn,
-            "SELECT COUNT(*) FROM embedding_metadata WHERE last_error IS NULL",
-        )?;
+        // Single scan: COUNT(DISTINCT) + COUNT(*) in one pass
+        let (embedded, chunks) = conn
+            .query_row(
+                "SELECT COUNT(DISTINCT document_id), COUNT(*)
+                 FROM embedding_metadata WHERE last_error IS NULL",
+                [],
+                |row| Ok((row.get::<_, i64>(0)?, row.get::<_, i64>(1)?)),
+            )
+            .unwrap_or((0, 0));
         result.embeddings.embedded_documents = embedded;
         result.embeddings.total_chunks = chunks;
         result.embeddings.coverage_pct = if result.documents.total > 0 {
@@ -115,41 +125,57 @@ pub fn run_stats(config: &Config, check: bool, repair: bool, dry_run: bool) -> R
         };
     }
 
-    result.fts.indexed = count_query(&conn, "SELECT COUNT(*) FROM documents_fts")?;
+    // FTS5 shadow table is a regular B-tree with one row per document —
+    // 19x faster than scanning the virtual table for COUNT(*)
+    result.fts.indexed = count_query(&conn, "SELECT COUNT(*) FROM documents_fts_docsize")?;
 
-    result.queues.dirty_sources = count_query(
-        &conn,
-        "SELECT COUNT(*) FROM dirty_sources WHERE last_error IS NULL",
-    )?;
-    result.queues.dirty_sources_failed = count_query(
-        &conn,
-        "SELECT COUNT(*) FROM dirty_sources WHERE last_error IS NOT NULL",
-    )?;
+    // Single scan: 2 conditional counts on dirty_sources
+    let (ds_pending, ds_failed) = conn
+        .query_row(
+            "SELECT COALESCE(SUM(CASE WHEN last_error IS NULL THEN 1 END), 0),
+                    COALESCE(SUM(CASE WHEN last_error IS NOT NULL THEN 1 END), 0)
+             FROM dirty_sources",
+            [],
+            |row| Ok((row.get::<_, i64>(0)?, row.get::<_, i64>(1)?)),
+        )
+        .unwrap_or((0, 0));
+    result.queues.dirty_sources = ds_pending;
+    result.queues.dirty_sources_failed = ds_failed;
 
     if table_exists(&conn, "pending_discussion_fetches") {
-        result.queues.pending_discussion_fetches = count_query(
-            &conn,
-            "SELECT COUNT(*) FROM pending_discussion_fetches WHERE last_error IS NULL",
-        )?;
-        result.queues.pending_discussion_fetches_failed = count_query(
-            &conn,
-            "SELECT COUNT(*) FROM pending_discussion_fetches WHERE last_error IS NOT NULL",
-        )?;
+        let (pdf_pending, pdf_failed) = conn
+            .query_row(
+                "SELECT COALESCE(SUM(CASE WHEN last_error IS NULL THEN 1 END), 0),
+                        COALESCE(SUM(CASE WHEN last_error IS NOT NULL THEN 1 END), 0)
+                 FROM pending_discussion_fetches",
+                [],
+                |row| Ok((row.get::<_, i64>(0)?, row.get::<_, i64>(1)?)),
+            )
+            .unwrap_or((0, 0));
+        result.queues.pending_discussion_fetches = pdf_pending;
+        result.queues.pending_discussion_fetches_failed = pdf_failed;
     }
 
     if table_exists(&conn, "pending_dependent_fetches") {
-        result.queues.pending_dependent_fetches = count_query(
-            &conn,
-            "SELECT COUNT(*) FROM pending_dependent_fetches WHERE last_error IS NULL",
-        )?;
-        result.queues.pending_dependent_fetches_failed = count_query(
-            &conn,
-            "SELECT COUNT(*) FROM pending_dependent_fetches WHERE last_error IS NOT NULL",
-        )?;
-        result.queues.pending_dependent_fetches_stuck = count_query(
-            &conn,
-            "SELECT COUNT(*) FROM pending_dependent_fetches WHERE locked_at IS NOT NULL",
-        )?;
+        let (pf_pending, pf_failed, pf_stuck) = conn
+            .query_row(
+                "SELECT COALESCE(SUM(CASE WHEN last_error IS NULL THEN 1 END), 0),
+                        COALESCE(SUM(CASE WHEN last_error IS NOT NULL THEN 1 END), 0),
+                        COALESCE(SUM(CASE WHEN locked_at IS NOT NULL THEN 1 END), 0)
+                 FROM pending_dependent_fetches",
+                [],
+                |row| {
+                    Ok((
+                        row.get::<_, i64>(0)?,
+                        row.get::<_, i64>(1)?,
+                        row.get::<_, i64>(2)?,
+                    ))
+                },
+            )
+            .unwrap_or((0, 0, 0));
+        result.queues.pending_dependent_fetches = pf_pending;
+        result.queues.pending_dependent_fetches_failed = pf_failed;
+        result.queues.pending_dependent_fetches_stuck = pf_stuck;
     }
 
     #[allow(clippy::field_reassign_with_default)]

src/cli/commands/sync.rs

@@ -39,6 +39,7 @@ pub struct SyncResult {
     pub mr_diffs_failed: usize,
     pub documents_regenerated: usize,
     pub documents_embedded: usize,
+    pub status_enrichment_errors: usize,
 }
 
 fn stage_spinner(stage: u8, total: u8, msg: &str, robot_mode: bool) -> ProgressBar {
@@ -123,6 +124,7 @@ pub async fn run_sync(
         result.discussions_fetched += issues_result.discussions_fetched;
         result.resource_events_fetched += issues_result.resource_events_fetched;
         result.resource_events_failed += issues_result.resource_events_failed;
+        result.status_enrichment_errors += issues_result.status_enrichment_errors;
         spinner.finish_and_clear();
 
         if signal.is_cancelled() {

src/cli/commands/timeline.rs

@@ -252,6 +252,7 @@ pub fn print_timeline_json_with_meta(
     total_events_before_limit: usize,
     depth: u32,
     expand_mentions: bool,
+    fields: Option<&[String]>,
 ) {
     let output = TimelineJsonEnvelope {
         ok: true,
@@ -268,10 +269,18 @@ pub fn print_timeline_json_with_meta(
         },
     };
 
-    match serde_json::to_string(&output) {
-        Ok(json) => println!("{json}"),
-        Err(e) => eprintln!("Error serializing timeline JSON: {e}"),
+    let mut value = match serde_json::to_value(&output) {
+        Ok(v) => v,
+        Err(e) => {
+            eprintln!("Error serializing timeline JSON: {e}");
+            return;
+        }
+    };
+    if let Some(f) = fields {
+        let expanded = crate::cli::robot::expand_fields_preset(f, "timeline");
+        crate::cli::robot::filter_fields(&mut value, "events", &expanded);
     }
+    println!("{}", serde_json::to_string(&value).unwrap());
 }
 
 #[derive(Serialize)]

src/cli/commands/who.rs

@@ -473,9 +473,11 @@ fn build_path_query(conn: &Connection, path: &str, project_id: Option<i64>) -> R
     let looks_like_file = !forced_dir && (is_root || last_segment.contains('.'));
 
     // Probe 1: exact file exists in DiffNotes OR mr_file_changes (project-scoped)
+    // Exact-match probes already use the partial index, but LIKE probes below
+    // benefit from the INDEXED BY hint (same planner issue as expert query).
     let exact_exists = conn
         .query_row(
-            "SELECT 1 FROM notes
+            "SELECT 1 FROM notes INDEXED BY idx_notes_diffnote_path_created
          WHERE note_type = 'DiffNote'
            AND is_system = 0
            AND position_new_path = ?1
@@ -501,7 +503,7 @@ fn build_path_query(conn: &Connection, path: &str, project_id: Option<i64>) -> R
         let escaped = escape_like(trimmed);
         let pat = format!("{escaped}/%");
         conn.query_row(
-            "SELECT 1 FROM notes
+            "SELECT 1 FROM notes INDEXED BY idx_notes_diffnote_path_created
              WHERE note_type = 'DiffNote'
                AND is_system = 0
                AND position_new_path LIKE ?1 ESCAPE '\\'
@@ -597,7 +599,8 @@ fn suffix_probe(conn: &Connection, suffix: &str, project_id: Option<i64>) -> Res
 
     let mut stmt = conn.prepare_cached(
         "SELECT DISTINCT full_path FROM (
-            SELECT position_new_path AS full_path FROM notes
+            SELECT position_new_path AS full_path
+            FROM notes INDEXED BY idx_notes_diffnote_path_created
             WHERE note_type = 'DiffNote'
               AND is_system = 0
               AND (position_new_path LIKE ?1 ESCAPE '\\' OR position_new_path = ?2)
@@ -658,6 +661,13 @@ fn query_expert(
     } else {
         "= ?1"
     };
+    // When scanning DiffNotes with a LIKE prefix, SQLite's planner picks the
+    // low-selectivity idx_notes_system (38% of rows) instead of the much more
+    // selective partial index idx_notes_diffnote_path_created (9.3% of rows).
+    // INDEXED BY forces the correct index: measured 64x speedup (1.22s → 0.019s).
+    // For exact matches SQLite already picks the partial index, but the hint
+    // is harmless and keeps behavior consistent.
+    let notes_indexed_by = "INDEXED BY idx_notes_diffnote_path_created";
     let author_w = scoring.author_weight;
     let reviewer_w = scoring.reviewer_weight;
     let note_b = scoring.note_bonus;
@@ -672,7 +682,7 @@ fn query_expert(
                 n.id AS note_id,
                 n.created_at AS seen_at,
                 (p.path_with_namespace || '!' || CAST(m.iid AS TEXT)) AS mr_ref
-            FROM notes n
+            FROM notes n {notes_indexed_by}
             JOIN discussions d ON n.discussion_id = d.id
             JOIN merge_requests m ON d.merge_request_id = m.id
             JOIN projects p ON m.project_id = p.id
@@ -697,7 +707,7 @@ fn query_expert(
                 (p.path_with_namespace || '!' || CAST(m.iid AS TEXT)) AS mr_ref
             FROM merge_requests m
             JOIN discussions d ON d.merge_request_id = m.id
-            JOIN notes n ON n.discussion_id = d.id
+            JOIN notes n {notes_indexed_by} ON n.discussion_id = d.id
             JOIN projects p ON m.project_id = p.id
             WHERE n.note_type = 'DiffNote'
               AND n.is_system = 0
@@ -851,6 +861,7 @@ fn query_expert_details(
         .collect();
     let in_clause = placeholders.join(",");
 
+    let notes_indexed_by = "INDEXED BY idx_notes_diffnote_path_created";
     let sql = format!(
         "
         WITH signals AS (
@@ -863,7 +874,7 @@ fn query_expert_details(
                 m.title AS title,
                 COUNT(*) AS note_count,
                 MAX(n.created_at) AS last_activity
-            FROM notes n
+            FROM notes n {notes_indexed_by}
             JOIN discussions d ON n.discussion_id = d.id
             JOIN merge_requests m ON d.merge_request_id = m.id
             JOIN projects p ON m.project_id = p.id
@@ -891,7 +902,7 @@ fn query_expert_details(
                 MAX(n.created_at) AS last_activity
             FROM merge_requests m
             JOIN discussions d ON d.merge_request_id = m.id
-            JOIN notes n ON n.discussion_id = d.id
+            JOIN notes n {notes_indexed_by} ON n.discussion_id = d.id
             JOIN projects p ON m.project_id = p.id
             WHERE n.note_type = 'DiffNote'
               AND n.is_system = 0
@@ -1194,8 +1205,11 @@ fn query_reviews(
     project_id: Option<i64>,
     since_ms: i64,
 ) -> Result<ReviewsResult> {
-    // Count total DiffNotes by this user on MRs they didn't author
+    // Force the partial index on DiffNote queries (same rationale as expert mode).
+    // COUNT + COUNT(DISTINCT) + category extraction all benefit from 26K DiffNote
+    // scan vs 282K notes full scan: measured 25x speedup.
     let total_sql = "SELECT COUNT(*) FROM notes n
+         INDEXED BY idx_notes_diffnote_path_created
          JOIN discussions d ON n.discussion_id = d.id
          JOIN merge_requests m ON d.merge_request_id = m.id
          WHERE n.author_username = ?1
@@ -1213,6 +1227,7 @@ fn query_reviews(
 
     // Count distinct MRs reviewed
     let mrs_sql = "SELECT COUNT(DISTINCT m.id) FROM notes n
+         INDEXED BY idx_notes_diffnote_path_created
          JOIN discussions d ON n.discussion_id = d.id
          JOIN merge_requests m ON d.merge_request_id = m.id
          WHERE n.author_username = ?1
@@ -1232,7 +1247,7 @@ fn query_reviews(
     let cat_sql = "SELECT
             SUBSTR(ltrim(n.body), 3, INSTR(SUBSTR(ltrim(n.body), 3), '**') - 1) AS raw_prefix,
             COUNT(*) AS cnt
-         FROM notes n
+         FROM notes n INDEXED BY idx_notes_diffnote_path_created
          JOIN discussions d ON n.discussion_id = d.id
          JOIN merge_requests m ON d.merge_request_id = m.id
          WHERE n.author_username = ?1
@@ -1517,6 +1532,10 @@ fn query_overlap(
     } else {
         "= ?1"
     };
+    // Force the partial index on DiffNote queries (same rationale as expert mode).
+    // Without this hint SQLite picks idx_notes_system (38% of rows) instead of
+    // idx_notes_diffnote_path_created (9.3% of rows): measured 50-133x slower.
+    let notes_indexed_by = "INDEXED BY idx_notes_diffnote_path_created";
     let sql = format!(
         "SELECT username, role, touch_count, last_seen_at, mr_refs FROM (
             -- 1. DiffNote reviewer
@@ -1526,7 +1545,7 @@ fn query_overlap(
                 COUNT(DISTINCT m.id) AS touch_count,
                 MAX(n.created_at) AS last_seen_at,
                 GROUP_CONCAT(DISTINCT (p.path_with_namespace || '!' || m.iid)) AS mr_refs
-            FROM notes n
+            FROM notes n {notes_indexed_by}
             JOIN discussions d ON n.discussion_id = d.id
             JOIN merge_requests m ON d.merge_request_id = m.id
             JOIN projects p ON m.project_id = p.id
@@ -1549,9 +1568,9 @@ fn query_overlap(
                 COUNT(DISTINCT m.id) AS touch_count,
                 MAX(n.created_at) AS last_seen_at,
                 GROUP_CONCAT(DISTINCT (p.path_with_namespace || '!' || m.iid)) AS mr_refs
-            FROM merge_requests m
-            JOIN discussions d ON d.merge_request_id = m.id
-            JOIN notes n ON n.discussion_id = d.id
+            FROM notes n {notes_indexed_by}
+            JOIN discussions d ON n.discussion_id = d.id
+            JOIN merge_requests m ON d.merge_request_id = m.id
             JOIN projects p ON m.project_id = p.id
             WHERE n.note_type = 'DiffNote'
               AND n.position_new_path {path_op}
@@ -2201,12 +2220,28 @@ pub fn print_who_json(run: &WhoRun, args: &WhoArgs, elapsed_ms: u64) {
         meta: RobotMeta { elapsed_ms },
     };
 
-    println!(
-        "{}",
-        serde_json::to_string(&output).unwrap_or_else(|e| {
-            format!(r#"{{"ok":false,"error":{{"code":"INTERNAL_ERROR","message":"JSON serialization failed: {e}"}}}}"#)
-        })
-    );
+    let mut value = serde_json::to_value(&output).unwrap_or_else(|e| {
+        serde_json::json!({"ok":false,"error":{"code":"INTERNAL_ERROR","message":format!("JSON serialization failed: {e}")}})
+    });
+
+    if let Some(f) = &args.fields {
+        let preset_key = format!("who_{mode}");
+        let expanded = crate::cli::robot::expand_fields_preset(f, &preset_key);
+        // Each who mode uses a different array key; try all possible keys
+        for key in &[
+            "experts",
+            "assigned_issues",
+            "authored_mrs",
+            "review_mrs",
+            "categories",
+            "discussions",
+            "users",
+        ] {
+            crate::cli::robot::filter_fields(&mut value, key, &expanded);
+        }
+    }
+
+    println!("{}", serde_json::to_string(&value).unwrap());
 }
 
 #[derive(Serialize)]
@@ -2577,6 +2612,7 @@ mod tests {
                 limit: 20,
                 detail: false,
                 no_detail: false,
+                fields: None,
             })
             .unwrap(),
             WhoMode::Expert { .. }
@@ -2595,6 +2631,7 @@ mod tests {
                 limit: 20,
                 detail: false,
                 no_detail: false,
+                fields: None,
             })
             .unwrap(),
             WhoMode::Workload { .. }
@@ -2613,6 +2650,7 @@ mod tests {
                 limit: 20,
                 detail: false,
                 no_detail: false,
+                fields: None,
             })
             .unwrap(),
             WhoMode::Workload { .. }
@@ -2631,6 +2669,7 @@ mod tests {
                 limit: 20,
                 detail: false,
                 no_detail: false,
+                fields: None,
             })
             .unwrap(),
             WhoMode::Reviews { .. }
@@ -2649,6 +2688,7 @@ mod tests {
                 limit: 20,
                 detail: false,
                 no_detail: false,
+                fields: None,
             })
             .unwrap(),
             WhoMode::Expert { .. }
@@ -2667,6 +2707,7 @@ mod tests {
                 limit: 20,
                 detail: false,
                 no_detail: false,
+                fields: None,
             })
             .unwrap(),
             WhoMode::Expert { .. }
@@ -2686,6 +2727,7 @@ mod tests {
             limit: 20,
             detail: true,
             no_detail: false,
+            fields: None,
         };
         let mode = resolve_mode(&args).unwrap();
         let err = validate_mode_flags(&mode, &args).unwrap_err();
@@ -2709,6 +2751,7 @@ mod tests {
             limit: 20,
             detail: true,
             no_detail: false,
+            fields: None,
         };
         let mode = resolve_mode(&args).unwrap();
         assert!(validate_mode_flags(&mode, &args).is_ok());

src/cli/mod.rs

@@ -151,6 +151,10 @@ pub enum Commands {
         /// Comma-separated project paths (required in robot mode)
         #[arg(long)]
         projects: Option<String>,
+
+        /// Default project path (used when -p is omitted)
+        #[arg(long)]
+        default_project: Option<String>,
     },
 
     #[command(hide = true)]
@@ -186,7 +190,11 @@ pub enum Commands {
 
     /// Machine-readable command manifest for agent self-discovery
     #[command(name = "robot-docs")]
-    RobotDocs,
+    RobotDocs {
+        /// Omit response_schema from output (~60% smaller)
+        #[arg(long)]
+        brief: bool,
+    },
 
     /// Generate shell completions
     #[command(long_about = "Generate shell completions for lore.\n\n\
@@ -207,6 +215,24 @@ pub enum Commands {
     /// People intelligence: experts, workload, active discussions, overlap
     Who(WhoArgs),
 
+    /// Detect discussion divergence from original intent
+    Drift {
+        /// Entity type (currently only "issues" supported)
+        #[arg(value_parser = ["issues"])]
+        entity_type: String,
+
+        /// Entity IID
+        iid: i64,
+
+        /// Similarity threshold for drift detection (0.0-1.0)
+        #[arg(long, default_value = "0.4")]
+        threshold: f32,
+
+        /// Scope to project (fuzzy match)
+        #[arg(short, long)]
+        project: Option<String>,
+    },
+
     #[command(hide = true)]
     List {
         #[arg(value_parser = ["issues", "mrs"])]
@@ -315,6 +341,10 @@ pub struct IssuesArgs {
     #[arg(short = 'm', long, help_heading = "Filters")]
     pub milestone: Option<String>,
 
+    /// Filter by work-item status name (repeatable, OR logic)
+    #[arg(long, help_heading = "Filters")]
+    pub status: Vec<String>,
+
     /// Filter by time (7d, 2w, 1m, or YYYY-MM-DD)
     #[arg(long, help_heading = "Filters")]
     pub since: Option<String>,
@@ -563,6 +593,10 @@ pub struct SearchArgs {
     )]
     pub limit: usize,
 
+    /// Select output fields (comma-separated, or 'minimal' preset: document_id,title,source_type,score)
+    #[arg(long, help_heading = "Output", value_delimiter = ',')]
+    pub fields: Option<Vec<String>>,
+
     /// Show ranking explanation per result
     #[arg(long, help_heading = "Output", overrides_with = "no_explain")]
     pub explain: bool,
@@ -682,6 +716,10 @@ pub struct TimelineArgs {
     )]
     pub limit: usize,
 
+    /// Select output fields (comma-separated, or 'minimal' preset: timestamp,type,entity_iid,detail)
+    #[arg(long, help_heading = "Output", value_delimiter = ',')]
+    pub fields: Option<Vec<String>>,
+
     /// Maximum seed entities from search
     #[arg(long = "max-seeds", default_value = "10", help_heading = "Expansion")]
     pub max_seeds: usize,
@@ -752,6 +790,10 @@ pub struct WhoArgs {
     )]
     pub limit: u16,
 
+    /// Select output fields (comma-separated, or 'minimal' preset; varies by mode)
+    #[arg(long, help_heading = "Output", value_delimiter = ',')]
+    pub fields: Option<Vec<String>>,
+
     /// Show per-MR detail breakdown (expert mode only)
     #[arg(long, help_heading = "Output", overrides_with = "no_detail")]
     pub detail: bool,

src/cli/robot.rs

@@ -36,9 +36,49 @@ pub fn expand_fields_preset(fields: &[String], entity: &str) -> Vec<String> {
                 .iter()
                 .map(|s| (*s).to_string())
                 .collect(),
+            "search" => ["document_id", "title", "source_type", "score"]
+                .iter()
+                .map(|s| (*s).to_string())
+                .collect(),
+            "timeline" => ["timestamp", "type", "entity_iid", "detail"]
+                .iter()
+                .map(|s| (*s).to_string())
+                .collect(),
+            "who_expert" => ["username", "score"]
+                .iter()
+                .map(|s| (*s).to_string())
+                .collect(),
+            "who_workload" => ["iid", "title", "state"]
+                .iter()
+                .map(|s| (*s).to_string())
+                .collect(),
+            "who_active" => ["entity_type", "iid", "title", "participants"]
+                .iter()
+                .map(|s| (*s).to_string())
+                .collect(),
+            "who_overlap" => ["username", "touch_count"]
+                .iter()
+                .map(|s| (*s).to_string())
+                .collect(),
+            "who_reviews" => ["name", "count", "percentage"]
+                .iter()
+                .map(|s| (*s).to_string())
+                .collect(),
             _ => fields.to_vec(),
         }
     } else {
         fields.to_vec()
     }
 }
+
+/// Strip `response_schema` from every command entry for `--brief` mode.
+pub fn strip_schemas(commands: &mut serde_json::Value) {
+    if let Some(map) = commands.as_object_mut() {
+        for (_cmd_name, cmd) in map.iter_mut() {
+            if let Some(obj) = cmd.as_object_mut() {
+                obj.remove("response_schema");
+                obj.remove("example_output");
+            }
+        }
+    }
+}

src/core/config.rs

@@ -52,6 +52,9 @@ pub struct SyncConfig {
 
     #[serde(rename = "fetchMrFileChanges", default = "default_true")]
     pub fetch_mr_file_changes: bool,
+
+    #[serde(rename = "fetchWorkItemStatus", default = "default_true")]
+    pub fetch_work_item_status: bool,
 }
 
 fn default_true() -> bool {
@@ -70,6 +73,7 @@ impl Default for SyncConfig {
             requests_per_second: 30.0,
             fetch_resource_events: true,
             fetch_mr_file_changes: true,
+            fetch_work_item_status: true,
         }
     }
 }
@@ -177,6 +181,9 @@ pub struct Config {
     pub gitlab: GitLabConfig,
     pub projects: Vec<ProjectConfig>,
 
+    #[serde(rename = "defaultProject")]
+    pub default_project: Option<String>,
+
     #[serde(default)]
     pub sync: SyncConfig,
 
@@ -236,10 +243,32 @@ impl Config {
             });
         }
 
+        if let Some(ref dp) = config.default_project {
+            let matched = config.projects.iter().any(|p| {
+                p.path.eq_ignore_ascii_case(dp)
+                    || p.path
+                        .to_ascii_lowercase()
+                        .ends_with(&format!("/{}", dp.to_ascii_lowercase()))
+            });
+            if !matched {
+                return Err(LoreError::ConfigInvalid {
+                    details: format!(
+                        "defaultProject '{}' does not match any configured project path",
+                        dp
+                    ),
+                });
+            }
+        }
+
         validate_scoring(&config.scoring)?;
 
         Ok(config)
     }
+
+    /// Return the effective project filter: CLI flag wins, then config default.
+    pub fn effective_project<'a>(&'a self, cli_project: Option<&'a str>) -> Option<&'a str> {
+        cli_project.or(self.default_project.as_deref())
+    }
 }
 
 fn validate_scoring(scoring: &ScoringConfig) -> Result<()> {
@@ -265,6 +294,8 @@ fn validate_scoring(scoring: &ScoringConfig) -> Result<()> {
 pub struct MinimalConfig {
     pub gitlab: MinimalGitLabConfig,
     pub projects: Vec<ProjectConfig>,
+    #[serde(rename = "defaultProject", skip_serializing_if = "Option::is_none")]
+    pub default_project: Option<String>,
 }
 
 #[derive(Debug, serde::Serialize)]
@@ -310,6 +341,31 @@ mod tests {
         path
     }
 
+    fn write_config_with_default_project(
+        dir: &TempDir,
+        default_project: Option<&str>,
+    ) -> std::path::PathBuf {
+        let path = dir.path().join("config.json");
+        let dp_field = match default_project {
+            Some(dp) => format!(r#","defaultProject": "{dp}""#),
+            None => String::new(),
+        };
+        let config = format!(
+            r#"{{
+  "gitlab": {{
+    "baseUrl": "https://gitlab.example.com",
+    "tokenEnvVar": "GITLAB_TOKEN"
+  }},
+  "projects": [
+    {{ "path": "group/project" }},
+    {{ "path": "other/repo" }}
+  ]{dp_field}
+}}"#
+        );
+        fs::write(&path, config).unwrap();
+        path
+    }
+
     #[test]
     fn test_load_rejects_negative_author_weight() {
         let dir = TempDir::new().unwrap();
@@ -348,6 +404,22 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_config_fetch_work_item_status_default_true() {
+        let config = SyncConfig::default();
+        assert!(config.fetch_work_item_status);
+    }
+
+    #[test]
+    fn test_config_deserialize_without_key() {
+        let json = r#"{}"#;
+        let config: SyncConfig = serde_json::from_str(json).unwrap();
+        assert!(
+            config.fetch_work_item_status,
+            "Missing key should default to true"
+        );
+    }
+
     #[test]
     fn test_load_rejects_negative_note_bonus() {
         let dir = TempDir::new().unwrap();
@@ -363,4 +435,130 @@ mod tests {
         let msg = err.to_string();
         assert!(msg.contains("scoring.noteBonus"), "unexpected error: {msg}");
     }
+
+    #[test]
+    fn test_effective_project_cli_overrides_default() {
+        let config = Config {
+            gitlab: GitLabConfig {
+                base_url: "https://gitlab.example.com".to_string(),
+                token_env_var: "GITLAB_TOKEN".to_string(),
+            },
+            projects: vec![ProjectConfig {
+                path: "group/project".to_string(),
+            }],
+            default_project: Some("group/project".to_string()),
+            sync: SyncConfig::default(),
+            storage: StorageConfig::default(),
+            embedding: EmbeddingConfig::default(),
+            logging: LoggingConfig::default(),
+            scoring: ScoringConfig::default(),
+        };
+        assert_eq!(
+            config.effective_project(Some("other/repo")),
+            Some("other/repo")
+        );
+    }
+
+    #[test]
+    fn test_effective_project_falls_back_to_default() {
+        let config = Config {
+            gitlab: GitLabConfig {
+                base_url: "https://gitlab.example.com".to_string(),
+                token_env_var: "GITLAB_TOKEN".to_string(),
+            },
+            projects: vec![ProjectConfig {
+                path: "group/project".to_string(),
+            }],
+            default_project: Some("group/project".to_string()),
+            sync: SyncConfig::default(),
+            storage: StorageConfig::default(),
+            embedding: EmbeddingConfig::default(),
+            logging: LoggingConfig::default(),
+            scoring: ScoringConfig::default(),
+        };
+        assert_eq!(config.effective_project(None), Some("group/project"));
+    }
+
+    #[test]
+    fn test_effective_project_none_when_both_absent() {
+        let config = Config {
+            gitlab: GitLabConfig {
+                base_url: "https://gitlab.example.com".to_string(),
+                token_env_var: "GITLAB_TOKEN".to_string(),
+            },
+            projects: vec![ProjectConfig {
+                path: "group/project".to_string(),
+            }],
+            default_project: None,
+            sync: SyncConfig::default(),
+            storage: StorageConfig::default(),
+            embedding: EmbeddingConfig::default(),
+            logging: LoggingConfig::default(),
+            scoring: ScoringConfig::default(),
+        };
+        assert_eq!(config.effective_project(None), None);
+    }
+
+    #[test]
+    fn test_load_with_valid_default_project() {
+        let dir = TempDir::new().unwrap();
+        let path = write_config_with_default_project(&dir, Some("group/project"));
+        let config = Config::load_from_path(&path).unwrap();
+        assert_eq!(config.default_project.as_deref(), Some("group/project"));
+    }
+
+    #[test]
+    fn test_load_rejects_invalid_default_project() {
+        let dir = TempDir::new().unwrap();
+        let path = write_config_with_default_project(&dir, Some("nonexistent/project"));
+        let err = Config::load_from_path(&path).unwrap_err();
+        let msg = err.to_string();
+        assert!(msg.contains("defaultProject"), "unexpected error: {msg}");
+    }
+
+    #[test]
+    fn test_load_default_project_suffix_match() {
+        let dir = TempDir::new().unwrap();
+        let path = write_config_with_default_project(&dir, Some("project"));
+        let config = Config::load_from_path(&path).unwrap();
+        assert_eq!(config.default_project.as_deref(), Some("project"));
+    }
+
+    #[test]
+    fn test_minimal_config_omits_null_default_project() {
+        let config = MinimalConfig {
+            gitlab: MinimalGitLabConfig {
+                base_url: "https://gitlab.example.com".to_string(),
+                token_env_var: "GITLAB_TOKEN".to_string(),
+            },
+            projects: vec![ProjectConfig {
+                path: "group/project".to_string(),
+            }],
+            default_project: None,
+        };
+        let json = serde_json::to_string(&config).unwrap();
+        assert!(
+            !json.contains("defaultProject"),
+            "null default_project should be omitted: {json}"
+        );
+    }
+
+    #[test]
+    fn test_minimal_config_includes_default_project_when_set() {
+        let config = MinimalConfig {
+            gitlab: MinimalGitLabConfig {
+                base_url: "https://gitlab.example.com".to_string(),
+                token_env_var: "GITLAB_TOKEN".to_string(),
+            },
+            projects: vec![ProjectConfig {
+                path: "group/project".to_string(),
+            }],
+            default_project: Some("group/project".to_string()),
+        };
+        let json = serde_json::to_string(&config).unwrap();
+        assert!(
+            json.contains("defaultProject"),
+            "set default_project should be present: {json}"
+        );
+    }
 }

src/core/db.rs

@@ -65,6 +65,14 @@ const MIGRATIONS: &[(&str, &str)] = &[
         "020",
         include_str!("../../migrations/020_mr_diffs_watermark.sql"),
     ),
+    (
+        "021",
+        include_str!("../../migrations/021_work_item_status.sql"),
+    ),
+    (
+        "023",
+        include_str!("../../migrations/023_issue_detail_fields.sql"),
+    ),
 ];
 
 pub fn create_connection(db_path: &Path) -> Result<Connection> {
@@ -139,6 +147,20 @@ pub fn run_migrations(conn: &Connection) -> Result<()> {
 
         match conn.execute_batch(sql) {
             Ok(()) => {
+                // Framework-managed version bookkeeping: ensures the version is
+                // always recorded even if a migration .sql omits the INSERT.
+                // Uses OR REPLACE so legacy migrations that self-register are harmless.
+                conn.execute(
+                    "INSERT OR REPLACE INTO schema_version (version, applied_at, description) \
+                     VALUES (?1, strftime('%s', 'now') * 1000, ?2)",
+                    rusqlite::params![version, version_str],
+                )
+                .map_err(|e| LoreError::MigrationFailed {
+                    version,
+                    message: format!("Failed to record schema version: {e}"),
+                    source: Some(e),
+                })?;
+
                 conn.execute_batch(&format!("RELEASE {}", savepoint_name))
                     .map_err(|e| LoreError::MigrationFailed {
                         version,

src/core/error.rs

@@ -232,7 +232,7 @@ impl LoreError {
     }
 
     pub fn is_permanent_api_error(&self) -> bool {
-        matches!(self, Self::GitLabNotFound { .. })
+        matches!(self, Self::GitLabNotFound { .. } | Self::GitLabAuthFailed)
     }
 
     pub fn exit_code(&self) -> i32 {

src/core/project.rs

@@ -21,13 +21,14 @@ pub fn resolve_project(conn: &Connection, project_str: &str) -> Result<i64> {
         return Ok(id);
     }
 
+    let escaped = escape_like(project_str);
     let mut suffix_stmt = conn.prepare(
         "SELECT id, path_with_namespace FROM projects
-         WHERE path_with_namespace LIKE '%/' || ?1
-            OR path_with_namespace = ?1",
+         WHERE path_with_namespace LIKE '%/' || ?1 ESCAPE '\\'
+            OR path_with_namespace = ?2",
     )?;
     let suffix_matches: Vec<(i64, String)> = suffix_stmt
-        .query_map(rusqlite::params![project_str], |row| {
+        .query_map(rusqlite::params![escaped, project_str], |row| {
             Ok((row.get(0)?, row.get(1)?))
         })?
         .collect::<std::result::Result<Vec<_>, _>>()?;
@@ -52,10 +53,10 @@ pub fn resolve_project(conn: &Connection, project_str: &str) -> Result<i64> {
 
     let mut substr_stmt = conn.prepare(
         "SELECT id, path_with_namespace FROM projects
-         WHERE LOWER(path_with_namespace) LIKE '%' || LOWER(?1) || '%'",
+         WHERE LOWER(path_with_namespace) LIKE '%' || LOWER(?1) || '%' ESCAPE '\\'",
     )?;
     let substr_matches: Vec<(i64, String)> = substr_stmt
-        .query_map(rusqlite::params![project_str], |row| {
+        .query_map(rusqlite::params![escaped], |row| {
             Ok((row.get(0)?, row.get(1)?))
         })?
         .collect::<std::result::Result<Vec<_>, _>>()?;
@@ -103,6 +104,15 @@ pub fn resolve_project(conn: &Connection, project_str: &str) -> Result<i64> {
     )))
 }
 
+/// Escape LIKE metacharacters so `%` and `_` in user input are treated as
+/// literals.  All queries using this must include `ESCAPE '\'`.
+fn escape_like(input: &str) -> String {
+    input
+        .replace('\\', "\\\\")
+        .replace('%', "\\%")
+        .replace('_', "\\_")
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -241,4 +251,24 @@ mod tests {
         let msg = err.to_string();
         assert!(msg.contains("No projects have been synced"));
     }
+
+    #[test]
+    fn test_underscore_not_wildcard() {
+        let conn = setup_db();
+        insert_project(&conn, 1, "backend/my_project");
+        insert_project(&conn, 2, "backend/my-project");
+        // `_` in user input must not match `-` (LIKE wildcard behavior)
+        let id = resolve_project(&conn, "my_project").unwrap();
+        assert_eq!(id, 1);
+    }
+
+    #[test]
+    fn test_percent_not_wildcard() {
+        let conn = setup_db();
+        insert_project(&conn, 1, "backend/a%b");
+        insert_project(&conn, 2, "backend/axyzb");
+        // `%` in user input must not match arbitrary strings
+        let id = resolve_project(&conn, "a%b").unwrap();
+        assert_eq!(id, 1);
+    }
 }

src/embedding/mod.rs

@@ -3,7 +3,9 @@ pub mod chunk_ids;
 pub mod chunking;
 pub mod ollama;
 pub mod pipeline;
+pub mod similarity;
 
 pub use change_detector::{PendingDocument, count_pending_documents, find_pending_documents};
 pub use chunking::{CHUNK_MAX_BYTES, CHUNK_OVERLAP_CHARS, split_into_chunks};
 pub use pipeline::{EmbedResult, embed_documents};
+pub use similarity::cosine_similarity;

src/embedding/similarity.rs

@@ -0,0 +1,48 @@
+/// Cosine similarity between two embedding vectors.
+/// Returns value in [-1, 1] range; higher = more similar.
+pub fn cosine_similarity(a: &[f32], b: &[f32]) -> f32 {
+    debug_assert_eq!(a.len(), b.len(), "embedding dimensions must match");
+    let dot: f32 = a.iter().zip(b).map(|(x, y)| x * y).sum();
+    let norm_a: f32 = a.iter().map(|x| x * x).sum::<f32>().sqrt();
+    let norm_b: f32 = b.iter().map(|x| x * x).sum::<f32>().sqrt();
+    if norm_a == 0.0 || norm_b == 0.0 {
+        return 0.0;
+    }
+    dot / (norm_a * norm_b)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cosine_similarity_identical() {
+        let v = [1.0, 2.0, 3.0];
+        let sim = cosine_similarity(&v, &v);
+        assert!((sim - 1.0).abs() < 1e-6);
+    }
+
+    #[test]
+    fn test_cosine_similarity_orthogonal() {
+        let a = [1.0, 0.0, 0.0];
+        let b = [0.0, 1.0, 0.0];
+        let sim = cosine_similarity(&a, &b);
+        assert!(sim.abs() < 1e-6);
+    }
+
+    #[test]
+    fn test_cosine_similarity_zero_vector() {
+        let a = [1.0, 2.0, 3.0];
+        let b = [0.0, 0.0, 0.0];
+        let sim = cosine_similarity(&a, &b);
+        assert!((sim - 0.0).abs() < 1e-6);
+    }
+
+    #[test]
+    fn test_cosine_similarity_opposite() {
+        let a = [1.0, 2.0, 3.0];
+        let b = [-1.0, -2.0, -3.0];
+        let sim = cosine_similarity(&a, &b);
+        assert!((sim - (-1.0)).abs() < 1e-6);
+    }
+}

src/gitlab/client.rs

@@ -95,6 +95,10 @@ impl GitLabClient {
         }
     }
 
+    pub fn graphql_client(&self) -> crate::gitlab::graphql::GraphqlClient {
+        crate::gitlab::graphql::GraphqlClient::new(&self.base_url, &self.token)
+    }
+
     pub async fn get_current_user(&self) -> Result<GitLabUser> {
         self.request("/api/v4/user").await
     }

src/gitlab/mod.rs

@@ -1,4 +1,5 @@
 pub mod client;
+pub mod graphql;
 pub mod transformers;
 pub mod types;
 
@@ -10,5 +11,5 @@ pub use transformers::{
 pub use types::{
     GitLabAuthor, GitLabDiscussion, GitLabIssue, GitLabIssueRef, GitLabLabelEvent, GitLabLabelRef,
     GitLabMergeRequestRef, GitLabMilestoneEvent, GitLabMilestoneRef, GitLabMrDiff, GitLabNote,
-    GitLabNotePosition, GitLabProject, GitLabStateEvent, GitLabUser, GitLabVersion,
+    GitLabNotePosition, GitLabProject, GitLabStateEvent, GitLabUser, GitLabVersion, WorkItemStatus,
 };

src/gitlab/types.rs

@@ -262,3 +262,86 @@ pub struct GitLabMergeRequest {
     pub merge_commit_sha: Option<String>,
     pub squash_commit_sha: Option<String>,
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WorkItemStatus {
+    pub name: String,
+    pub category: Option<String>,
+    pub color: Option<String>,
+    #[serde(rename = "iconName")]
+    pub icon_name: Option<String>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_work_item_status_deserialize() {
+        let json = r##"{"name":"In progress","category":"IN_PROGRESS","color":"#1f75cb","iconName":"status-in-progress"}"##;
+        let status: WorkItemStatus = serde_json::from_str(json).unwrap();
+        assert_eq!(status.name, "In progress");
+        assert_eq!(status.category.as_deref(), Some("IN_PROGRESS"));
+        assert_eq!(status.color.as_deref(), Some("#1f75cb"));
+        assert_eq!(status.icon_name.as_deref(), Some("status-in-progress"));
+    }
+
+    #[test]
+    fn test_work_item_status_optional_fields() {
+        let json = r#"{"name":"To do"}"#;
+        let status: WorkItemStatus = serde_json::from_str(json).unwrap();
+        assert_eq!(status.name, "To do");
+        assert!(status.category.is_none());
+        assert!(status.color.is_none());
+        assert!(status.icon_name.is_none());
+    }
+
+    #[test]
+    fn test_work_item_status_unknown_category() {
+        let json = r#"{"name":"Custom","category":"SOME_FUTURE_VALUE"}"#;
+        let status: WorkItemStatus = serde_json::from_str(json).unwrap();
+        assert_eq!(status.category.as_deref(), Some("SOME_FUTURE_VALUE"));
+    }
+
+    #[test]
+    fn test_work_item_status_null_category() {
+        let json = r#"{"name":"In progress","category":null}"#;
+        let status: WorkItemStatus = serde_json::from_str(json).unwrap();
+        assert!(status.category.is_none());
+    }
+
+    #[test]
+    fn test_work_item_status_all_system_statuses() {
+        let cases = [
+            (
+                r##"{"name":"To do","category":"TO_DO","color":"#737278"}"##,
+                "TO_DO",
+            ),
+            (
+                r##"{"name":"In progress","category":"IN_PROGRESS","color":"#1f75cb"}"##,
+                "IN_PROGRESS",
+            ),
+            (
+                r##"{"name":"Done","category":"DONE","color":"#108548"}"##,
+                "DONE",
+            ),
+            (
+                r##"{"name":"Won't do","category":"CANCELED","color":"#DD2B0E"}"##,
+                "CANCELED",
+            ),
+            (
+                r##"{"name":"Duplicate","category":"CANCELED","color":"#DD2B0E"}"##,
+                "CANCELED",
+            ),
+        ];
+        for (json, expected_cat) in cases {
+            let status: WorkItemStatus = serde_json::from_str(json).unwrap();
+            assert_eq!(
+                status.category.as_deref(),
+                Some(expected_cat),
+                "Failed for: {}",
+                status.name
+            );
+        }
+    }
+}

src/ingestion/mr_diffs.rs

@@ -19,20 +19,22 @@ fn derive_change_type(diff: &GitLabMrDiff) -> &'static str {
 
 /// Replace all file change records for a given MR with the provided diffs.
 /// Uses DELETE+INSERT (simpler than UPSERT for array replacement).
+///
+/// Does NOT manage its own transaction — the caller is responsible for
+/// wrapping this in a transaction when atomicity with other operations
+/// (job completion, watermark update) is needed.
 pub fn upsert_mr_file_changes(
     conn: &Connection,
     mr_local_id: i64,
     project_id: i64,
     diffs: &[GitLabMrDiff],
 ) -> Result<usize> {
-    let tx = conn.unchecked_transaction()?;
-
-    tx.execute(
+    conn.execute(
         "DELETE FROM mr_file_changes WHERE merge_request_id = ?1",
         [mr_local_id],
     )?;
 
-    let mut stmt = tx.prepare_cached(
+    let mut stmt = conn.prepare_cached(
         "INSERT INTO mr_file_changes (merge_request_id, project_id, old_path, new_path, change_type) \
          VALUES (?1, ?2, ?3, ?4, ?5)",
     )?;
@@ -56,10 +58,6 @@ pub fn upsert_mr_file_changes(
         inserted += 1;
     }
 
-    // Drop the prepared statement before committing the transaction.
-    drop(stmt);
-    tx.commit()?;
-
     if inserted > 0 {
         debug!(inserted, mr_local_id, "Stored MR file changes");
     }

src/ingestion/orchestrator.rs

@@ -45,6 +45,11 @@ pub enum ProgressEvent {
     MrDiffsFetchStarted { total: usize },
     MrDiffFetched { current: usize, total: usize },
     MrDiffsFetchComplete { fetched: usize, failed: usize },
+    StatusEnrichmentStarted,
+    StatusEnrichmentPageFetched { items_so_far: usize },
+    StatusEnrichmentWriting { total: usize },
+    StatusEnrichmentComplete { enriched: usize, cleared: usize },
+    StatusEnrichmentSkipped,
 }
 
 #[derive(Debug, Default)]
@@ -59,6 +64,15 @@ pub struct IngestProjectResult {
     pub issues_skipped_discussion_sync: usize,
     pub resource_events_fetched: usize,
     pub resource_events_failed: usize,
+    pub statuses_enriched: usize,
+    pub statuses_cleared: usize,
+    pub statuses_seen: usize,
+    pub statuses_without_widget: usize,
+    pub partial_error_count: usize,
+    pub first_partial_error: Option<String>,
+    pub status_enrichment_error: Option<String>,
+    pub status_enrichment_mode: String,
+    pub status_unsupported_reason: Option<String>,
 }
 
 #[derive(Debug, Default)]
@@ -135,6 +149,121 @@ pub async fn ingest_project_issues_with_progress(
         total: result.issues_fetched,
     });
 
+    // ── Phase 1.5: Status enrichment via GraphQL ──────────────────────
+    if config.sync.fetch_work_item_status && !signal.is_cancelled() {
+        use rusqlite::OptionalExtension;
+
+        emit(ProgressEvent::StatusEnrichmentStarted);
+
+        let project_path: Option<String> = conn
+            .query_row(
+                "SELECT path_with_namespace FROM projects WHERE id = ?1",
+                [project_id],
+                |r| r.get(0),
+            )
+            .optional()?;
+
+        match project_path {
+            None => {
+                warn!("Cannot enrich statuses: project path not found for project_id={project_id}");
+                result.status_enrichment_error = Some("project_path_missing".into());
+                result.status_enrichment_mode = "fetched".into();
+                emit(ProgressEvent::StatusEnrichmentComplete {
+                    enriched: 0,
+                    cleared: 0,
+                });
+            }
+            Some(path) => {
+                let graphql_client = client.graphql_client();
+                let page_cb = |items_so_far: usize| {
+                    emit(ProgressEvent::StatusEnrichmentPageFetched { items_so_far });
+                };
+                match crate::gitlab::graphql::fetch_issue_statuses_with_progress(
+                    &graphql_client,
+                    &path,
+                    Some(&page_cb),
+                )
+                .await
+                {
+                    Ok(fetch_result) => {
+                        if let Some(ref reason) = fetch_result.unsupported_reason {
+                            result.status_enrichment_mode = "unsupported".into();
+                            result.status_unsupported_reason = Some(match reason {
+                                crate::gitlab::graphql::UnsupportedReason::GraphqlEndpointMissing => {
+                                    "graphql_endpoint_missing".into()
+                                }
+                                crate::gitlab::graphql::UnsupportedReason::AuthForbidden => {
+                                    "auth_forbidden".into()
+                                }
+                            });
+                        } else {
+                            result.status_enrichment_mode = "fetched".into();
+                        }
+
+                        result.statuses_seen = fetch_result.all_fetched_iids.len();
+                        result.partial_error_count = fetch_result.partial_error_count;
+                        if fetch_result.first_partial_error.is_some() {
+                            result.first_partial_error = fetch_result.first_partial_error.clone();
+                        }
+
+                        if signal.is_cancelled() {
+                            info!("Shutdown requested after status fetch, skipping DB write");
+                            emit(ProgressEvent::StatusEnrichmentComplete {
+                                enriched: 0,
+                                cleared: 0,
+                            });
+                        } else {
+                            emit(ProgressEvent::StatusEnrichmentWriting {
+                                total: fetch_result.all_fetched_iids.len(),
+                            });
+                            match enrich_issue_statuses_txn(
+                                conn,
+                                project_id,
+                                &fetch_result.statuses,
+                                &fetch_result.all_fetched_iids,
+                            ) {
+                                Ok((enriched, cleared)) => {
+                                    result.statuses_enriched = enriched;
+                                    result.statuses_cleared = cleared;
+                                    result.statuses_without_widget =
+                                        result.statuses_seen.saturating_sub(enriched);
+                                    info!(
+                                        seen = result.statuses_seen,
+                                        enriched,
+                                        cleared,
+                                        without_widget = result.statuses_without_widget,
+                                        "Status enrichment complete"
+                                    );
+                                }
+                                Err(e) => {
+                                    warn!("Status enrichment DB write failed: {e}");
+                                    result.status_enrichment_error =
+                                        Some(format!("db_write_failed: {e}"));
+                                }
+                            }
+                            emit(ProgressEvent::StatusEnrichmentComplete {
+                                enriched: result.statuses_enriched,
+                                cleared: result.statuses_cleared,
+                            });
+                        }
+                    }
+                    Err(e) => {
+                        warn!("Status enrichment fetch failed: {e}");
+                        result.status_enrichment_error = Some(e.to_string());
+                        result.status_enrichment_mode = "fetched".into();
+                        emit(ProgressEvent::StatusEnrichmentComplete {
+                            enriched: 0,
+                            cleared: 0,
+                        });
+                    }
+                }
+            }
+        }
+    } else if !config.sync.fetch_work_item_status {
+        result.status_enrichment_mode = "skipped".into();
+        emit(ProgressEvent::StatusEnrichmentSkipped);
+    }
+
     let issues_needing_sync = issue_result.issues_needing_discussion_sync;
 
     let total_issues: i64 = conn.query_row(
@@ -238,6 +367,66 @@ pub async fn ingest_project_issues_with_progress(
     Ok(result)
 }
 
+fn enrich_issue_statuses_txn(
+    conn: &Connection,
+    project_id: i64,
+    statuses: &std::collections::HashMap<i64, crate::gitlab::types::WorkItemStatus>,
+    all_fetched_iids: &std::collections::HashSet<i64>,
+) -> std::result::Result<(usize, usize), rusqlite::Error> {
+    let now_ms = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis() as i64;
+
+    let tx = conn.unchecked_transaction()?;
+
+    let mut cleared = 0usize;
+    let mut enriched = 0usize;
+
+    // Phase 1: Clear stale statuses (fetched but no status widget)
+    {
+        let mut clear_stmt = tx.prepare_cached(
+            "UPDATE issues SET status_name = NULL, status_category = NULL, status_color = NULL,
+             status_icon_name = NULL, status_synced_at = ?3
+             WHERE project_id = ?1 AND iid = ?2 AND status_name IS NOT NULL",
+        )?;
+        for iid in all_fetched_iids {
+            if !statuses.contains_key(iid) {
+                let rows = clear_stmt.execute(rusqlite::params![project_id, iid, now_ms])?;
+                if rows > 0 {
+                    cleared += 1;
+                }
+            }
+        }
+    }
+
+    // Phase 2: Apply new/updated statuses
+    {
+        let mut update_stmt = tx.prepare_cached(
+            "UPDATE issues SET status_name = ?1, status_category = ?2, status_color = ?3,
+             status_icon_name = ?4, status_synced_at = ?5
+             WHERE project_id = ?6 AND iid = ?7",
+        )?;
+        for (iid, status) in statuses {
+            let rows = update_stmt.execute(rusqlite::params![
+                &status.name,
+                &status.category,
+                &status.color,
+                &status.icon_name,
+                now_ms,
+                project_id,
+                iid,
+            ])?;
+            if rows > 0 {
+                enriched += 1;
+            }
+        }
+    }
+
+    tx.commit()?;
+    Ok((enriched, cleared))
+}
+
 #[allow(clippy::too_many_arguments)]
 async fn sync_discussions_sequential(
     conn: &Connection,
@@ -1181,46 +1370,33 @@ fn store_closes_issues_refs(
     mr_local_id: i64,
     closes_issues: &[crate::gitlab::types::GitLabIssueRef],
 ) -> Result<()> {
-    conn.execute_batch("SAVEPOINT store_closes_refs")?;
-    let inner = || -> Result<()> {
-        for issue_ref in closes_issues {
-            let target_local_id = resolve_issue_local_id(conn, project_id, issue_ref.iid)?;
+    for issue_ref in closes_issues {
+        let target_local_id = resolve_issue_local_id(conn, project_id, issue_ref.iid)?;
 
-            let (target_id, target_path, target_iid) = if let Some(local_id) = target_local_id {
-                (Some(local_id), None, None)
-            } else {
-                let path = resolve_project_path(conn, issue_ref.project_id)?;
-                let fallback =
-                    path.unwrap_or_else(|| format!("gitlab_project:{}", issue_ref.project_id));
-                (None, Some(fallback), Some(issue_ref.iid))
-            };
+        let (target_id, target_path, target_iid) = if let Some(local_id) = target_local_id {
+            (Some(local_id), None, None)
+        } else {
+            let path = resolve_project_path(conn, issue_ref.project_id)?;
+            let fallback =
+                path.unwrap_or_else(|| format!("gitlab_project:{}", issue_ref.project_id));
+            (None, Some(fallback), Some(issue_ref.iid))
+        };
 
-            let ref_ = EntityReference {
-                project_id,
-                source_entity_type: "merge_request",
-                source_entity_id: mr_local_id,
-                target_entity_type: "issue",
-                target_entity_id: target_id,
-                target_project_path: target_path.as_deref(),
-                target_entity_iid: target_iid,
-                reference_type: "closes",
-                source_method: "api",
-            };
+        let ref_ = EntityReference {
+            project_id,
+            source_entity_type: "merge_request",
+            source_entity_id: mr_local_id,
+            target_entity_type: "issue",
+            target_entity_id: target_id,
+            target_project_path: target_path.as_deref(),
+            target_entity_iid: target_iid,
+            reference_type: "closes",
+            source_method: "api",
+        };
 
-            insert_entity_reference(conn, &ref_)?;
-        }
-        Ok(())
-    };
-    match inner() {
-        Ok(()) => {
-            conn.execute_batch("RELEASE store_closes_refs")?;
-            Ok(())
-        }
-        Err(e) => {
-            let _ = conn.execute_batch("ROLLBACK TO store_closes_refs; RELEASE store_closes_refs");
-            Err(e)
-        }
+        insert_entity_reference(conn, &ref_)?;
     }
+    Ok(())
 }
 
 // ─── MR Diffs (file changes) ────────────────────────────────────────────────
@@ -1469,6 +1645,15 @@ mod tests {
         assert_eq!(result.issues_skipped_discussion_sync, 0);
         assert_eq!(result.resource_events_fetched, 0);
         assert_eq!(result.resource_events_failed, 0);
+        assert_eq!(result.statuses_enriched, 0);
+        assert_eq!(result.statuses_cleared, 0);
+        assert_eq!(result.statuses_seen, 0);
+        assert_eq!(result.statuses_without_widget, 0);
+        assert_eq!(result.partial_error_count, 0);
+        assert!(result.first_partial_error.is_none());
+        assert!(result.status_enrichment_error.is_none());
+        assert!(result.status_enrichment_mode.is_empty());
+        assert!(result.status_unsupported_reason.is_none());
     }
 
     #[test]
@@ -1509,5 +1694,10 @@ mod tests {
             fetched: 8,
             failed: 2,
         };
+        let _status_complete = ProgressEvent::StatusEnrichmentComplete {
+            enriched: 5,
+            cleared: 1,
+        };
+        let _status_skipped = ProgressEvent::StatusEnrichmentSkipped;
     }
 }

src/main.rs

@@ -12,19 +12,19 @@ use lore::cli::autocorrect::{self, CorrectionResult};
 use lore::cli::commands::{
     IngestDisplay, InitInputs, InitOptions, InitResult, ListFilters, MrListFilters,
     SearchCliFilters, SyncOptions, TimelineParams, open_issue_in_browser, open_mr_in_browser,
-    print_count, print_count_json, print_doctor_results, print_dry_run_preview,
-    print_dry_run_preview_json, print_embed, print_embed_json, print_event_count,
-    print_event_count_json, print_generate_docs, print_generate_docs_json, print_ingest_summary,
-    print_ingest_summary_json, print_list_issues, print_list_issues_json, print_list_mrs,
-    print_list_mrs_json, print_search_results, print_search_results_json, print_show_issue,
-    print_show_issue_json, print_show_mr, print_show_mr_json, print_stats, print_stats_json,
-    print_sync, print_sync_json, print_sync_status, print_sync_status_json, print_timeline,
-    print_timeline_json_with_meta, print_who_human, print_who_json, run_auth_test, run_count,
-    run_count_events, run_doctor, run_embed, run_generate_docs, run_ingest, run_ingest_dry_run,
-    run_init, run_list_issues, run_list_mrs, run_search, run_show_issue, run_show_mr, run_stats,
-    run_sync, run_sync_status, run_timeline, run_who,
+    print_count, print_count_json, print_doctor_results, print_drift_human, print_drift_json,
+    print_dry_run_preview, print_dry_run_preview_json, print_embed, print_embed_json,
+    print_event_count, print_event_count_json, print_generate_docs, print_generate_docs_json,
+    print_ingest_summary, print_ingest_summary_json, print_list_issues, print_list_issues_json,
+    print_list_mrs, print_list_mrs_json, print_search_results, print_search_results_json,
+    print_show_issue, print_show_issue_json, print_show_mr, print_show_mr_json, print_stats,
+    print_stats_json, print_sync, print_sync_json, print_sync_status, print_sync_status_json,
+    print_timeline, print_timeline_json_with_meta, print_who_human, print_who_json, run_auth_test,
+    run_count, run_count_events, run_doctor, run_drift, run_embed, run_generate_docs, run_ingest,
+    run_ingest_dry_run, run_init, run_list_issues, run_list_mrs, run_search, run_show_issue,
+    run_show_mr, run_stats, run_sync, run_sync_status, run_timeline, run_who,
 };
-use lore::cli::robot::RobotMeta;
+use lore::cli::robot::{RobotMeta, strip_schemas};
 use lore::cli::{
     Cli, Commands, CountArgs, EmbedArgs, GenerateDocsArgs, IngestArgs, IssuesArgs, MrsArgs,
     SearchArgs, StatsArgs, SyncArgs, TimelineArgs, WhoArgs,
@@ -162,7 +162,7 @@ async fn main() {
         // Phase 2: Handle no-args case - in robot mode, output robot-docs; otherwise show help
         None => {
             if robot_mode {
-                handle_robot_docs(robot_mode)
+                handle_robot_docs(robot_mode, false)
             } else {
                 use clap::CommandFactory;
                 let mut cmd = Cli::command();
@@ -178,6 +178,22 @@ async fn main() {
         }
         Some(Commands::Timeline(args)) => handle_timeline(cli.config.as_deref(), args, robot_mode),
         Some(Commands::Who(args)) => handle_who(cli.config.as_deref(), args, robot_mode),
+        Some(Commands::Drift {
+            entity_type,
+            iid,
+            threshold,
+            project,
+        }) => {
+            handle_drift(
+                cli.config.as_deref(),
+                &entity_type,
+                iid,
+                threshold,
+                project.as_deref(),
+                robot_mode,
+            )
+            .await
+        }
         Some(Commands::Stats(args)) => handle_stats(cli.config.as_deref(), args, robot_mode).await,
         Some(Commands::Embed(args)) => handle_embed(cli.config.as_deref(), args, robot_mode).await,
         Some(Commands::Sync(args)) => {
@@ -205,6 +221,7 @@ async fn main() {
             gitlab_url,
             token_env_var,
             projects,
+            default_project,
         }) => {
             handle_init(
                 cli.config.as_deref(),
@@ -214,6 +231,7 @@ async fn main() {
                 gitlab_url,
                 token_env_var,
                 projects,
+                default_project,
             )
             .await
         }
@@ -224,7 +242,7 @@ async fn main() {
         Some(Commands::Reset { yes: _ }) => handle_reset(robot_mode),
         Some(Commands::Migrate) => handle_migrate(cli.config.as_deref(), robot_mode).await,
         Some(Commands::Health) => handle_health(cli.config.as_deref(), robot_mode).await,
-        Some(Commands::RobotDocs) => handle_robot_docs(robot_mode),
+        Some(Commands::RobotDocs { brief }) => handle_robot_docs(robot_mode, brief),
 
         Some(Commands::List {
             entity,
@@ -678,13 +696,14 @@ fn handle_issues(
 ) -> Result<(), Box<dyn std::error::Error>> {
     let start = std::time::Instant::now();
     let config = Config::load(config_override)?;
+    let project = config.effective_project(args.project.as_deref());
     let asc = args.asc && !args.no_asc;
     let has_due = args.has_due && !args.no_has_due;
     let open = args.open && !args.no_open;
     let order = if asc { "asc" } else { "desc" };
 
     if let Some(iid) = args.iid {
-        let result = run_show_issue(&config, iid, args.project.as_deref())?;
+        let result = run_show_issue(&config, iid, project)?;
         if robot_mode {
             print_show_issue_json(&result, start.elapsed().as_millis() as u64);
         } else {
@@ -694,7 +713,7 @@ fn handle_issues(
         let state_normalized = args.state.as_deref().map(str::to_lowercase);
         let filters = ListFilters {
             limit: args.limit,
-            project: args.project.as_deref(),
+            project,
             state: state_normalized.as_deref(),
             author: args.author.as_deref(),
             assignee: args.assignee.as_deref(),
@@ -703,6 +722,7 @@ fn handle_issues(
             since: args.since.as_deref(),
             due_before: args.due_before.as_deref(),
             has_due_date: has_due,
+            statuses: &args.status,
             sort: &args.sort,
             order,
         };
@@ -732,12 +752,13 @@ fn handle_mrs(
 ) -> Result<(), Box<dyn std::error::Error>> {
     let start = std::time::Instant::now();
     let config = Config::load(config_override)?;
+    let project = config.effective_project(args.project.as_deref());
     let asc = args.asc && !args.no_asc;
     let open = args.open && !args.no_open;
     let order = if asc { "asc" } else { "desc" };
 
     if let Some(iid) = args.iid {
-        let result = run_show_mr(&config, iid, args.project.as_deref())?;
+        let result = run_show_mr(&config, iid, project)?;
         if robot_mode {
             print_show_mr_json(&result, start.elapsed().as_millis() as u64);
         } else {
@@ -747,7 +768,7 @@ fn handle_mrs(
         let state_normalized = args.state.as_deref().map(str::to_lowercase);
         let filters = MrListFilters {
             limit: args.limit,
-            project: args.project.as_deref(),
+            project,
             state: state_normalized.as_deref(),
             author: args.author.as_deref(),
             assignee: args.assignee.as_deref(),
@@ -790,6 +811,7 @@ async fn handle_ingest(
     let start = std::time::Instant::now();
     let dry_run = args.dry_run && !args.no_dry_run;
     let config = Config::load(config_override)?;
+    let project = config.effective_project(args.project.as_deref());
 
     let force = args.force && !args.no_force;
     let full = args.full && !args.no_full;
@@ -798,8 +820,7 @@ async fn handle_ingest(
     if dry_run {
         match args.entity.as_deref() {
             Some(resource_type) => {
-                let preview =
-                    run_ingest_dry_run(&config, resource_type, args.project.as_deref(), full)?;
+                let preview = run_ingest_dry_run(&config, resource_type, project, full)?;
                 if robot_mode {
                     print_dry_run_preview_json(&preview);
                 } else {
@@ -807,10 +828,8 @@ async fn handle_ingest(
                 }
             }
             None => {
-                let issues_preview =
-                    run_ingest_dry_run(&config, "issues", args.project.as_deref(), full)?;
-                let mrs_preview =
-                    run_ingest_dry_run(&config, "mrs", args.project.as_deref(), full)?;
+                let issues_preview = run_ingest_dry_run(&config, "issues", project, full)?;
+                let mrs_preview = run_ingest_dry_run(&config, "mrs", project, full)?;
                 if robot_mode {
                     print_combined_dry_run_json(&issues_preview, &mrs_preview);
                 } else {
@@ -853,7 +872,7 @@ async fn handle_ingest(
                 let result = run_ingest(
                     &config,
                     resource_type,
-                    args.project.as_deref(),
+                    project,
                     force,
                     full,
                     false,
@@ -879,28 +898,12 @@ async fn handle_ingest(
                 }
 
                 let issues_result = run_ingest(
-                    &config,
-                    "issues",
-                    args.project.as_deref(),
-                    force,
-                    full,
-                    false,
-                    display,
-                    None,
-                    &signal,
+                    &config, "issues", project, force, full, false, display, None, &signal,
                 )
                 .await?;
 
                 let mrs_result = run_ingest(
-                    &config,
-                    "mrs",
-                    args.project.as_deref(),
-                    force,
-                    full,
-                    false,
-                    display,
-                    None,
-                    &signal,
+                    &config, "mrs", project, force, full, false, display, None, &signal,
                 )
                 .await?;
 
@@ -1103,6 +1106,8 @@ struct InitOutputData {
     data_dir: String,
     user: InitOutputUser,
     projects: Vec<InitOutputProject>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    default_project: Option<String>,
 }
 
 #[derive(Serialize)]
@@ -1135,6 +1140,7 @@ fn print_init_json(result: &InitResult) {
                     name: p.name.clone(),
                 })
                 .collect(),
+            default_project: result.default_project.clone(),
         },
     };
     println!(
@@ -1145,6 +1151,7 @@ fn print_init_json(result: &InitResult) {
     );
 }
 
+#[allow(clippy::too_many_arguments)]
 async fn handle_init(
     config_override: Option<&str>,
     force: bool,
@@ -1153,6 +1160,7 @@ async fn handle_init(
     gitlab_url_flag: Option<String>,
     token_env_var_flag: Option<String>,
     projects_flag: Option<String>,
+    default_project_flag: Option<String>,
 ) -> Result<(), Box<dyn std::error::Error>> {
     if robot_mode {
         let missing: Vec<&str> = [
@@ -1190,6 +1198,7 @@ async fn handle_init(
                 gitlab_url: gitlab_url_flag.unwrap(),
                 token_env_var: token_env_var_flag.unwrap(),
                 project_paths,
+                default_project: default_project_flag.clone(),
             },
             InitOptions {
                 config_path: config_override.map(String::from),
@@ -1284,6 +1293,29 @@ async fn handle_init(
             .collect()
     };
 
+    // Resolve default project: CLI flag, interactive prompt, or None
+    let default_project = if default_project_flag.is_some() {
+        default_project_flag
+    } else if project_paths.len() > 1 && !non_interactive {
+        let set_default = Confirm::new()
+            .with_prompt("Set a default project? (used when -p is omitted)")
+            .default(true)
+            .interact()?;
+
+        if set_default {
+            let selection = dialoguer::Select::new()
+                .with_prompt("Default project")
+                .items(&project_paths)
+                .default(0)
+                .interact()?;
+            Some(project_paths[selection].clone())
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
     println!("{}", style("\nValidating configuration...").blue());
 
     let result = run_init(
@@ -1291,6 +1323,7 @@ async fn handle_init(
             gitlab_url,
             token_env_var,
             project_paths,
+            default_project,
         },
         InitOptions {
             config_path: config_override.map(String::from),
@@ -1316,6 +1349,10 @@ async fn handle_init(
         );
     }
 
+    if let Some(ref dp) = result.default_project {
+        println!("{}", style(format!("✓ Default project: {dp}")).green());
+    }
+
     println!(
         "{}",
         style(format!("\n✓ Config written to {}", result.config_path)).green()
@@ -1679,7 +1716,9 @@ fn handle_timeline(
 
     let params = TimelineParams {
         query: args.query,
-        project: args.project,
+        project: config
+            .effective_project(args.project.as_deref())
+            .map(String::from),
         since: args.since,
         depth: args.depth,
         expand_mentions: args.expand_mentions,
@@ -1697,6 +1736,7 @@ fn handle_timeline(
             result.total_events_before_limit,
             params.depth,
             params.expand_mentions,
+            args.fields.as_deref(),
         );
     } else {
         print_timeline(&result);
@@ -1720,7 +1760,9 @@ async fn handle_search(
     let cli_filters = SearchCliFilters {
         source_type: args.source_type,
         author: args.author,
-        project: args.project,
+        project: config
+            .effective_project(args.project.as_deref())
+            .map(String::from),
         labels: args.label,
         path: args.path,
         since: args.since,
@@ -1736,11 +1778,12 @@ async fn handle_search(
         fts_mode,
         &args.mode,
         explain,
-    )?;
+    )
+    .await?;
     let elapsed_ms = start.elapsed().as_millis() as u64;
 
     if robot_mode {
-        print_search_results_json(&response, elapsed_ms);
+        print_search_results_json(&response, elapsed_ms, args.fields.as_deref());
     } else {
         print_search_results(&response);
     }
@@ -1755,7 +1798,8 @@ async fn handle_generate_docs(
     let start = std::time::Instant::now();
     let config = Config::load(config_override)?;
 
-    let result = run_generate_docs(&config, args.full, args.project.as_deref(), None)?;
+    let project = config.effective_project(args.project.as_deref());
+    let result = run_generate_docs(&config, args.full, project, None)?;
     if robot_mode {
         print_generate_docs_json(&result, start.elapsed().as_millis() as u64);
     } else {
@@ -2021,6 +2065,7 @@ struct RobotDocsData {
     version: String,
     description: String,
     activation: RobotDocsActivation,
+    quick_start: serde_json::Value,
     commands: serde_json::Value,
     /// Deprecated command aliases (old -> new)
     aliases: serde_json::Value,
@@ -2029,6 +2074,7 @@ struct RobotDocsData {
     clap_error_codes: serde_json::Value,
     error_format: String,
     workflows: serde_json::Value,
+    config_notes: serde_json::Value,
 }
 
 #[derive(Serialize)]
@@ -2038,18 +2084,18 @@ struct RobotDocsActivation {
     auto: String,
 }
 
-fn handle_robot_docs(robot_mode: bool) -> Result<(), Box<dyn std::error::Error>> {
+fn handle_robot_docs(robot_mode: bool, brief: bool) -> Result<(), Box<dyn std::error::Error>> {
     let version = env!("CARGO_PKG_VERSION").to_string();
 
     let commands = serde_json::json!({
         "init": {
             "description": "Initialize configuration and database",
-            "flags": ["--force", "--non-interactive", "--gitlab-url <URL>", "--token-env-var <VAR>", "--projects <paths>"],
-            "robot_flags": ["--gitlab-url", "--token-env-var", "--projects"],
-            "example": "lore --robot init --gitlab-url https://gitlab.com --token-env-var GITLAB_TOKEN --projects group/project",
+            "flags": ["--force", "--non-interactive", "--gitlab-url <URL>", "--token-env-var <VAR>", "--projects <paths>", "--default-project <path>"],
+            "robot_flags": ["--gitlab-url", "--token-env-var", "--projects", "--default-project"],
+            "example": "lore --robot init --gitlab-url https://gitlab.com --token-env-var GITLAB_TOKEN --projects group/project,other/repo --default-project group/project",
             "response_schema": {
                 "ok": "bool",
-                "data": {"config_path": "string", "data_dir": "string", "user": {"username": "string", "name": "string"}, "projects": "[{path:string, name:string}]"},
+                "data": {"config_path": "string", "data_dir": "string", "user": {"username": "string", "name": "string"}, "projects": "[{path:string, name:string}]", "default_project": "string?"},
                 "meta": {"elapsed_ms": "int"}
             }
         },
@@ -2105,13 +2151,17 @@ fn handle_robot_docs(robot_mode: bool) -> Result<(), Box<dyn std::error::Error>>
         },
         "issues": {
             "description": "List or show issues",
-            "flags": ["<IID>", "-n/--limit", "--fields <list>", "-s/--state", "-p/--project", "-a/--author", "-A/--assignee", "-l/--label", "-m/--milestone", "--since", "--due-before", "--has-due", "--no-has-due", "--sort", "--asc", "--no-asc", "-o/--open", "--no-open"],
+            "flags": ["<IID>", "-n/--limit", "--fields <list>", "-s/--state", "--status <name>", "-p/--project", "-a/--author", "-A/--assignee", "-l/--label", "-m/--milestone", "--since", "--due-before", "--has-due", "--no-has-due", "--sort", "--asc", "--no-asc", "-o/--open", "--no-open"],
             "example": "lore --robot issues --state opened --limit 10",
+            "notes": {
+                "status_filter": "--status filters by work item status NAME (case-insensitive). Valid values are in meta.available_statuses of any issues list response.",
+                "status_name": "status_name is the board column label (e.g. 'In review', 'Blocked'). This is the canonical status identifier for filtering."
+            },
             "response_schema": {
                 "list": {
                     "ok": "bool",
-                    "data": {"issues": "[{iid:int, title:string, state:string, author_username:string, labels:[string], assignees:[string], discussion_count:int, unresolved_count:int, created_at_iso:string, updated_at_iso:string, web_url:string?, project_path:string}]", "total_count": "int", "showing": "int"},
-                    "meta": {"elapsed_ms": "int"}
+                    "data": {"issues": "[{iid:int, title:string, state:string, author_username:string, labels:[string], assignees:[string], discussion_count:int, unresolved_count:int, created_at_iso:string, updated_at_iso:string, web_url:string?, project_path:string, status_name:string?}]", "total_count": "int", "showing": "int"},
+                    "meta": {"elapsed_ms": "int", "available_statuses": "[string] — all distinct status names in the database, for use with --status filter"}
                 },
                 "show": {
                     "ok": "bool",
@@ -2119,6 +2169,7 @@ fn handle_robot_docs(robot_mode: bool) -> Result<(), Box<dyn std::error::Error>>
                     "meta": {"elapsed_ms": "int"}
                 }
             },
+            "example_output": {"list": {"ok":true,"data":{"issues":[{"iid":3864,"title":"Switch Health Card","state":"opened","status_name":"In progress","labels":["customer:BNSF"],"assignees":["teernisse"],"discussion_count":12,"updated_at_iso":"2026-02-12T..."}],"total_count":1,"showing":1},"meta":{"elapsed_ms":42}}},
             "fields_presets": {"minimal": ["iid", "title", "state", "updated_at_iso"]}
         },
         "mrs": {
@@ -2137,17 +2188,20 @@ fn handle_robot_docs(robot_mode: bool) -> Result<(), Box<dyn std::error::Error>>
                     "meta": {"elapsed_ms": "int"}
                 }
             },
+            "example_output": {"list": {"ok":true,"data":{"mrs":[{"iid":200,"title":"Add throw time chart","state":"opened","draft":false,"author_username":"teernisse","target_branch":"main","source_branch":"feat/throw-time","reviewers":["cseiber"],"discussion_count":5,"updated_at_iso":"2026-02-11T..."}],"total_count":1,"showing":1},"meta":{"elapsed_ms":38}}},
             "fields_presets": {"minimal": ["iid", "title", "state", "updated_at_iso"]}
         },
         "search": {
             "description": "Search indexed documents (lexical, hybrid, semantic)",
-            "flags": ["<QUERY>", "--mode", "--type", "--author", "-p/--project", "--label", "--path", "--since", "--updated-since", "-n/--limit", "--explain", "--no-explain", "--fts-mode"],
+            "flags": ["<QUERY>", "--mode", "--type", "--author", "-p/--project", "--label", "--path", "--since", "--updated-since", "-n/--limit", "--fields <list>", "--explain", "--no-explain", "--fts-mode"],
             "example": "lore --robot search 'authentication bug' --mode hybrid --limit 10",
             "response_schema": {
                 "ok": "bool",
-                "data": {"results": "[{doc_id:int, source_type:string, title:string, snippet:string, score:float, project_path:string, web_url:string?}]", "total_count": "int", "query": "string", "mode": "string"},
+                "data": {"results": "[{document_id:int, source_type:string, title:string, snippet:string, score:float, url:string?, author:string?, created_at:string?, updated_at:string?, project_path:string, labels:[string], paths:[string]}]", "total_results": "int", "query": "string", "mode": "string", "warnings": "[string]"},
                 "meta": {"elapsed_ms": "int"}
-            }
+            },
+            "example_output": {"ok":true,"data":{"query":"throw time","mode":"hybrid","total_results":3,"results":[{"document_id":42,"source_type":"issue","title":"Switch Health Card","score":0.92,"snippet":"...throw time data from BNSF...","project_path":"vs/typescript-code"}],"warnings":[]},"meta":{"elapsed_ms":85}},
+            "fields_presets": {"minimal": ["document_id", "title", "source_type", "score"]}
         },
         "count": {
             "description": "Count entities in local database",
@@ -2226,17 +2280,18 @@ fn handle_robot_docs(robot_mode: bool) -> Result<(), Box<dyn std::error::Error>>
         },
         "timeline": {
             "description": "Chronological timeline of events matching a keyword query",
-            "flags": ["<QUERY>", "-p/--project", "--since <duration>", "--depth <n>", "--expand-mentions", "-n/--limit", "--max-seeds", "--max-entities", "--max-evidence"],
+            "flags": ["<QUERY>", "-p/--project", "--since <duration>", "--depth <n>", "--expand-mentions", "-n/--limit", "--fields <list>", "--max-seeds", "--max-entities", "--max-evidence"],
             "example": "lore --robot timeline '<keyword>' --since 30d",
             "response_schema": {
                 "ok": "bool",
                 "data": {"entities": "[{type:string, iid:int, title:string, project_path:string}]", "events": "[{timestamp:string, type:string, entity_type:string, entity_iid:int, detail:string}]", "total_events": "int"},
                 "meta": {"elapsed_ms": "int"}
-            }
+            },
+            "fields_presets": {"minimal": ["timestamp", "type", "entity_iid", "detail"]}
         },
         "who": {
             "description": "People intelligence: experts, workload, active discussions, overlap, review patterns",
-            "flags": ["<target>", "--path <path>", "--active", "--overlap <path>", "--reviews", "--since <duration>", "-p/--project", "-n/--limit"],
+            "flags": ["<target>", "--path <path>", "--active", "--overlap <path>", "--reviews", "--since <duration>", "-p/--project", "-n/--limit", "--fields <list>"],
             "modes": {
                 "expert": "lore who <file-path> -- Who knows about this area? (also: --path for root files)",
                 "workload": "lore who <username> -- What is someone working on?",
@@ -2254,15 +2309,48 @@ fn handle_robot_docs(robot_mode: bool) -> Result<(), Box<dyn std::error::Error>>
                     "...": "mode-specific fields"
                 },
                 "meta": {"elapsed_ms": "int"}
+            },
+            "example_output": {"expert": {"ok":true,"data":{"mode":"expert","result":{"experts":[{"username":"teernisse","score":42,"note_count":15,"diff_note_count":8}]}},"meta":{"elapsed_ms":65}}},
+            "fields_presets": {
+                "expert_minimal": ["username", "score"],
+                "workload_minimal": ["entity_type", "iid", "title", "state"],
+                "active_minimal": ["entity_type", "iid", "title", "participants"]
             }
         },
         "robot-docs": {
             "description": "This command (agent self-discovery manifest)",
-            "flags": [],
-            "example": "lore robot-docs"
+            "flags": ["--brief"],
+            "example": "lore robot-docs --brief"
         }
     });
 
+    let quick_start = serde_json::json!({
+        "glab_equivalents": [
+            { "glab": "glab issue list", "lore": "lore -J issues -n 50", "note": "Richer: includes labels, status, closing MRs, discussion counts" },
+            { "glab": "glab issue view 123", "lore": "lore -J issues 123", "note": "Includes full discussions, work-item status, cross-references" },
+            { "glab": "glab issue list -l bug", "lore": "lore -J issues --label bug", "note": "AND logic for multiple --label flags" },
+            { "glab": "glab mr list", "lore": "lore -J mrs", "note": "Includes draft status, reviewers, discussion counts" },
+            { "glab": "glab mr view 456", "lore": "lore -J mrs 456", "note": "Includes discussions, review threads, source/target branches" },
+            { "glab": "glab mr list -s opened", "lore": "lore -J mrs -s opened", "note": "States: opened, merged, closed, locked, all" },
+            { "glab": "glab api '/projects/:id/issues'", "lore": "lore -J issues -p project", "note": "Fuzzy project matching (suffix or substring)" }
+        ],
+        "lore_exclusive": [
+            "search: FTS5 + vector hybrid search across all entities",
+            "who: Expert/workload/reviews analysis per file path or person",
+            "timeline: Chronological event reconstruction across entities",
+            "stats: Database statistics with document/note/discussion counts",
+            "count: Entity counts with state breakdowns",
+            "embed: Generate vector embeddings for semantic search via Ollama"
+        ],
+        "read_write_split": "lore = ALL reads (issues, MRs, search, who, timeline, intelligence). glab = ALL writes (create, update, approve, merge, CI/CD)."
+    });
+
+    // --brief: strip response_schema and example_output from every command (~60% smaller)
+    let mut commands = commands;
+    if brief {
+        strip_schemas(&mut commands);
+    }
+
     let exit_codes = serde_json::json!({
         "0": "Success",
         "1": "Internal error",
@@ -2341,6 +2429,14 @@ fn handle_robot_docs(robot_mode: bool) -> Result<(), Box<dyn std::error::Error>>
         "PARSE_ERROR": "General parse error"
     });
 
+    let config_notes = serde_json::json!({
+        "defaultProject": {
+            "type": "string?",
+            "description": "Fallback project path used when -p/--project is omitted. Must match a configured project path (exact or suffix). CLI -p always overrides.",
+            "example": "group/project"
+        }
+    });
+
     let output = RobotDocsOutput {
         ok: true,
         data: RobotDocsData {
@@ -2352,12 +2448,14 @@ fn handle_robot_docs(robot_mode: bool) -> Result<(), Box<dyn std::error::Error>>
                 env: "LORE_ROBOT=1".to_string(),
                 auto: "Non-TTY stdout".to_string(),
             },
+            quick_start,
             commands,
             aliases,
             exit_codes,
             clap_error_codes,
             error_format: "stderr JSON: {\"error\":{\"code\":\"...\",\"message\":\"...\",\"suggestion\":\"...\",\"actions\":[\"...\"]}}".to_string(),
             workflows,
+            config_notes,
         },
     };
 
@@ -2372,11 +2470,14 @@ fn handle_robot_docs(robot_mode: bool) -> Result<(), Box<dyn std::error::Error>>
 
 fn handle_who(
     config_override: Option<&str>,
-    args: WhoArgs,
+    mut args: WhoArgs,
     robot_mode: bool,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let start = std::time::Instant::now();
     let config = Config::load(config_override)?;
+    if args.project.is_none() {
+        args.project = config.default_project.clone();
+    }
     let run = run_who(&config, &args)?;
     let elapsed_ms = start.elapsed().as_millis() as u64;
 
@@ -2388,6 +2489,28 @@ fn handle_who(
     Ok(())
 }
 
+async fn handle_drift(
+    config_override: Option<&str>,
+    entity_type: &str,
+    iid: i64,
+    threshold: f32,
+    project: Option<&str>,
+    robot_mode: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let start = std::time::Instant::now();
+    let config = Config::load(config_override)?;
+    let effective_project = config.effective_project(project);
+    let response = run_drift(&config, entity_type, iid, threshold, effective_project).await?;
+    let elapsed_ms = start.elapsed().as_millis() as u64;
+
+    if robot_mode {
+        print_drift_json(&response, elapsed_ms);
+    } else {
+        print_drift_human(&response);
+    }
+    Ok(())
+}
+
 #[allow(clippy::too_many_arguments)]
 async fn handle_list_compat(
     config_override: Option<&str>,
@@ -2414,6 +2537,7 @@ async fn handle_list_compat(
 ) -> Result<(), Box<dyn std::error::Error>> {
     let start = std::time::Instant::now();
     let config = Config::load(config_override)?;
+    let project_filter = config.effective_project(project_filter);
 
     let state_normalized = state_filter.map(str::to_lowercase);
     match entity {
@@ -2429,6 +2553,7 @@ async fn handle_list_compat(
                 since: since_filter,
                 due_before: due_before_filter,
                 has_due_date,
+                statuses: &[],
                 sort,
                 order,
             };
@@ -2491,6 +2616,7 @@ async fn handle_show_compat(
 ) -> Result<(), Box<dyn std::error::Error>> {
     let start = std::time::Instant::now();
     let config = Config::load(config_override)?;
+    let project_filter = config.effective_project(project_filter);
 
     match entity {
         "issue" => {