feat: implement analyzer framework per design-c

[v2nic]

Summary

Implements the analyzer framework from docs/analyzer-design-c.md — an append-only analysis graph grafted onto Pi session transcripts with idempotent, versioned, and crash-recoverable analysis.

What's in this PR (Foundation)

• Database schema (migration 002): 8 new tables (analyzer_defs, analyzer_versions, prompt_registry, analyzer_configs, analysis_runs, analysis_nodes, analysis_edges, analysis_progress) plus v2 columns on proposals
• TypeBox schemas & TypeScript types: All analyzer framework data shapes with full type safety per AGENTS.md requirements
• Edge kind constants: Typed graph relationship constants
• Schema migration tests: 6 passing tests verifying all new tables and columns

Design principles (from design-c)

1. Append-only — analysis nodes are never mutated
2. Typed edge graph — all relationships are explicit edges, no parent_id columns
3. Idempotent — input_hash prevents duplicate computation
4. Incremental — cursors track progress per analyzer/version/config/session
5. Crash-recoverable — re-running picks up where it left off
6. Versioned provenance — every node traces to exact analyzer version, prompt version, config
7. Dependency-scoped visibility — analyzers only see their own nodes and declared dependencies

Planned analyzers (subsequent commits)

Analyzer	Kind	Description
turn-pair-core	deterministic	Per-turn metrics: correction detection, tool failure, friction score
turn-pair-llm	in_process_llm	Per-turn LLM enrichment: sentiment, frustration, quality score
session-overview	in_process_llm	Full session analysis with proposals via map-reduce

Testing

• 29/29 tests pass (all existing + 6 new schema tests)
• TypeScript compiles cleanly (npm run check)

Remaining work

The following modules were developed and tested (91 tests passing) but need to be re-committed due to a git worktree issue:

• src/analyze/input-hash.ts — Hash computation utilities
• src/analyze/model-tiers.ts — Model tier resolution
• src/db/analysis-queries.ts — Analysis query functions
• src/analyze/analyzers/turn-pair-core/ — Deterministic per-turn metrics
• src/analyze/analyzers/turn-pair-llm/ — LLM enrichment
• src/analyze/analyzers/session-overview/ — Session-level analysis
• src/analyze/proposal-materializer.ts — Proposal extraction & dedup
• src/analyze/framework.ts — AnalyzerFramework orchestration
• Updated commands, config, and index files
• 5 additional unit test files (input-hash, patterns, config, model-tiers, proposal-materializer)

These will be added in follow-up commits to this PR.

[v2nic]

Closing in favour of #4 (analyzer-graph), which supersedes this branch.

Why

This PR and #4 share the same docs/analyzer-design-c.md skeleton, but they differ on the one behaviour that decides whether prospector is useful: does the pipeline ever emit a proposal? On this branch, it does not — and that is a structural defect, not a tuning issue:

• The injected LLM provider is dead code. The framework's run-context llm() is wired to callLLM(), which unconditionally throws "LLM calls are not available outside Pi". The ollama-llm.ts backend that ships in this branch is never reached.
• The analyzers never call the LLM at all. There are zero references to ctx.llm in the analyzers. turn-pair-llm falls through to neutral defaults, and session-overview returns improvement_proposals: [] via its fallback path. The net result is zero proposals, ever.
• Secondary bug in session-overview: it rebuilds messages from unit.sources filtered to kind === "message", but the sources are all analysis_node, so the message list is always empty even if the LLM were reached.
• Schema carries migration cruft: v1 CREATE TABLE plus 9 addColumnIfNotExists patches. Since the tool has never run in production, feat: incremental analyzer graph with versioned lineage and Pi-AI provider #4 ships a single clean v2 schema instead.

What replaces it

#4 keeps the good structure (typed-edge graph, idempotent input_hash, three-analyzer pipeline, SHA-256 proposal dedup) and fixes the core issues:

• LLM is wired to Pi's AI provider system (modelRegistry.find → getApiKeyAndHeaders → @earendil-works/pi-ai complete()), not a throwing stub and not Ollama.
• Analyzers actually call ctx.llm; a deterministic mock caller drives the tests.
• 100% incremental scan() with shallow/deep modes and versioned node lineage (revises edges).
• An end-to-end test asserts a proposal is materialised through the full pipeline.
• 130 unit/component + 19 integration assertions green; ~98% line coverage; clean tsc.

No commits are lost — the branch glm-5.1-analyzer-impl and ref remain available for reference. Closing rather than merging.