Type checker: Kategoria L1-L3 + L7 linear types + @Budget tracking

typechecker.rs (~2650 lines):
- Type IR covering all Kategoria levels (concrete L1-7, extension L8-10)
- Three-pass architecture: declaration gathering, type checking, linear verification
- L1: primitive inference, binop rules, Harvard violation detection
- L2: constructor typing, pattern exhaustiveness, enum registration
- L3: unification engine with occurs check, generic instantiation, purity subtyping
- L7: linear binding tracking — use exactly once, branch-consistent merging,
  send_final consumption, exchange handle swap, spawn handle creation
- @Budget: token budget as linear quantity, cost deduction per operation,
  cached branch (0 cost), @neural (0 cost), BudgetExceeded errors
- resolve_type_str: recursive-descent parser bridging String→Type IR
- Public API: check_program(), infer_expr(), infer_data()

typechecker_tests.rs (36 tests, 141 total):
- L1: literals, binop rules, Harvard violation
- L2: constructor typing, exhaustiveness checking
- L3: function calls, unification, purity enforcement
- L7: linear use-once/twice/never, branch consistent/inconsistent
- Budget: within/exceed, cached zero-cost, neural zero-cost

CLI: `oo7 typecheck <file>` command added.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

crates/oo7-cli/src/main.rs

@@ -12,13 +12,15 @@
 use oo7_core::ast::*;
 use oo7_core::eval::Evaluator;
 use oo7_core::parser;
+use oo7_core::typechecker;
 
 fn main() {
     let args: Vec<String> = std::env::args().collect();
 
     match args.get(1).map(|s| s.as_str()) {
         Some("parse") => cmd_parse(&args),
         Some("check") => cmd_check(&args),
+        Some("typecheck") => cmd_typecheck(&args),
         Some("eval") => cmd_eval(&args),
         Some("demo") => run_demo(),
         Some("--help") | Some("-h") | None => print_usage(),
@@ -34,11 +36,12 @@ fn print_usage() {
     println!("007 Agent Meta-Language — Reference Evaluator");
     println!();
     println!("Usage:");
-    println!("  oo7 parse <file.007>   Parse a .007 file and print AST as JSON");
-    println!("  oo7 check <file.007>   Validate syntax (no output on success)");
-    println!("  oo7 eval <file.007>    Parse and evaluate (parse-only for now)");
-    println!("  oo7 demo               Run built-in demo producing decision traces");
-    println!("  oo7 --help             Show this help message");
+    println!("  oo7 parse <file.007>      Parse a .007 file and print AST as JSON");
+    println!("  oo7 check <file.007>      Validate syntax (no output on success)");
+    println!("  oo7 typecheck <file.007>  Type-check a .007 file (L1-3, L7)");
+    println!("  oo7 eval <file.007>       Parse and evaluate (parse-only for now)");
+    println!("  oo7 demo                  Run built-in demo producing decision traces");
+    println!("  oo7 --help                Show this help message");
     println!();
     println!("The telescope is on. We're looking.");
 }
@@ -102,6 +105,30 @@ fn cmd_check(args: &[String]) {
     }
 }
 
+/// `oo7 typecheck <file.007>` — parse and type-check.
+fn cmd_typecheck(args: &[String]) {
+    let source = read_source_file(args);
+    let path = args.get(2).unwrap();
+
+    match parser::parse_program(&source) {
+        Ok(program) => match typechecker::check_program(&program) {
+            Ok(()) => {
+                eprintln!("OK: type check passed");
+            }
+            Err(errors) => {
+                for e in &errors {
+                    eprintln!("Type error: {}", e.message);
+                }
+                std::process::exit(1);
+            }
+        },
+        Err(e) => {
+            eprintln!("{}", format_parse_error(path, &e));
+            std::process::exit(1);
+        }
+    }
+}
+
 /// `oo7 eval <file.007>` — parse and evaluate.
 ///
 /// Currently this only parses and reports the structure, since the

crates/oo7-core/src/lib.rs

@@ -19,9 +19,11 @@ pub mod parser;
 #[cfg(test)]
 mod parser_tests;
 pub mod trace;
+pub mod typechecker;
 
 // Re-export key types for convenience.
 pub use ast::*;
 pub use eval::{BranchStrategy, Evaluator, PredicateFirstStrategy, RtValue};
 pub use parser::{parse_program, ParseError};
 pub use trace::{DecisionTrace, TraceRecord};
+pub use typechecker::{check_program, Type, TypeError};