feat: IR compiler

AGENTS.md

@@ -22,6 +22,7 @@
   - [ADR-0006: Dynamic Query Execution](docs/adr/ADR-0006-dynamic-query-execution.md)
   - [ADR-0007: Type Metadata Format](docs/adr/ADR-0007-type-metadata-format.md)
   - [ADR-0008: Tree Navigation](docs/adr/ADR-0008-tree-navigation.md)
+  - [ADR-0009: Type System](docs/adr/ADR-0009-type-system.md)
 - **Template**:
 
   ```markdown

crates/plotnik-cli/src/cli.rs

@@ -111,4 +111,16 @@ pub struct OutputArgs {
     /// Show inferred cardinalities
     #[arg(long)]
     pub cardinalities: bool,
+
+    /// Show compiled graph
+    #[arg(long)]
+    pub graph: bool,
+
+    /// Show unoptimized graph (before epsilon elimination)
+    #[arg(long)]
+    pub graph_raw: bool,
+
+    /// Show inferred types
+    #[arg(long)]
+    pub types: bool,
 }

crates/plotnik-cli/src/commands/debug/mod.rs

@@ -18,6 +18,9 @@ pub struct DebugArgs {
     pub cst: bool,
     pub spans: bool,
     pub cardinalities: bool,
+    pub graph: bool,
+    pub graph_raw: bool,
+    pub types: bool,
     pub color: bool,
 }
 
@@ -51,7 +54,7 @@ pub fn run(args: DebugArgs) {
         q.link(&lang);
     }
 
-    let show_query = has_query_input && !args.symbols;
+    let show_query = has_query_input && !args.symbols && !args.graph && !args.types;
     let show_source = has_source_input;
     let show_headers = (show_query || args.symbols) && show_source;
 
@@ -85,6 +88,26 @@ pub fn run(args: DebugArgs) {
         );
     }
 
+    // Build graph if needed for --graph, --graph-raw, or --types
+    if (args.graph || args.graph_raw || args.types)
+        && let Some(q) = query.take()
+    {
+        let (q, pre_opt_dump) = q.build_graph_with_pre_opt_dump();
+        if args.graph_raw {
+            println!("=== GRAPH (raw) ===");
+            print!("{}", pre_opt_dump);
+        }
+        if args.graph {
+            println!("=== GRAPH ===");
+            print!("{}", q.graph().dump_live(q.dead_nodes()));
+        }
+        if args.types {
+            println!("=== TYPES ===");
+            print!("{}", q.type_info().dump());
+        }
+        return;
+    }
+
     if show_source {
         let resolved_lang = resolve_lang(&args.lang, &args.source_text, &args.source_file);
         let source_code = load_source(&args.source_text, &args.source_file);

crates/plotnik-cli/src/main.rs

@@ -25,6 +25,9 @@ fn main() {
                 cst: output.cst,
                 spans: output.spans,
                 cardinalities: output.cardinalities,
+                graph: output.graph,
+                graph_raw: output.graph_raw,
+                types: output.types,
                 color: output.color.should_colorize(),
             });
         }

crates/plotnik-lib/src/diagnostics/message.rs

@@ -61,6 +61,11 @@ pub enum DiagnosticKind {
     DirectRecursion,
     FieldSequenceValue,
 
+    // Type inference errors
+    IncompatibleTypes,
+    MultiCaptureQuantifierNoName,
+    UnusedBranchLabels,
+
     // Link pass - grammar validation
     UnknownNodeType,
     UnknownField,
@@ -75,7 +80,10 @@ pub enum DiagnosticKind {
 impl DiagnosticKind {
     /// Default severity for this kind. Can be overridden by policy.
     pub fn default_severity(&self) -> Severity {
-        Severity::Error
+        match self {
+            Self::UnusedBranchLabels => Severity::Warning,
+            _ => Severity::Error,
+        }
     }
 
     /// Whether this kind suppresses `other` when spans overlap.
@@ -166,6 +174,13 @@ impl DiagnosticKind {
             Self::DirectRecursion => "infinite recursion: cycle consumes no input",
             Self::FieldSequenceValue => "field must match exactly one node",
 
+            // Type inference
+            Self::IncompatibleTypes => "incompatible types in alternation branches",
+            Self::MultiCaptureQuantifierNoName => {
+                "quantified expression with multiple captures requires `@name`"
+            }
+            Self::UnusedBranchLabels => "branch labels have no effect without capture",
+
             // Link pass - grammar validation
             Self::UnknownNodeType => "unknown node type",
             Self::UnknownField => "unknown field",
@@ -192,6 +207,7 @@ impl DiagnosticKind {
             // Semantic errors with name context
             Self::DuplicateDefinition => "`{}` is already defined".to_string(),
             Self::UndefinedReference => "`{}` is not defined".to_string(),
+            Self::IncompatibleTypes => "incompatible types: {}".to_string(),
 
             // Link pass errors with context
             Self::UnknownNodeType => "`{}` is not a valid node type".to_string(),