Sec 18-19 in Pest + AST + parser: token economics + Kategoria types

Pest grammar:
- budget_annotation, branch_modifier (speculative|cached), focus_annotation
- purity_annotation extended with @neural, neural_dispatch + neural_target
- choreo_batch, model-routing locale params (remote_params, edge_params, cluster_params)
- type_expr split into type_expr (with effect_annotation?) + type_expr_base
- dependent_type, refinement_type, path_type, graded_type, effect_annotation
- GADT syntax: upper_ident<type_expr, ...> before bare upper_ident

AST types:
- BudgetAnnotation, BranchModifier, NeuralTarget, FocusAnnotation
- DepArg, RefinementType, GradedType, Grade, EffectType, Effect
- Updated: Branch (modifier), GivenClause (focus), AgentDecl (budget)
- Updated: FunctionDecl (neural_dispatch), Purity (+Neural)
- Updated: ChoreoStep (+Batch), LocaleConstructor (model routing params)

Parser: all new rules wired to AST builders.
Eval: new match arms (stubs — reference evaluator ignores modifiers).
Tests: all 105 pass, zero clippy warnings.

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

Author: hyperpolymath

crates/oo7-cli/src/main.rs

@@ -189,6 +189,7 @@ fn run_demo() {
         BranchArm {
             label: "accept".to_string(),
             given: Some(GivenClause {
+                focus: None,
                 items: vec![
                     GivenItem::Named(
                         "confidence".to_string(),
@@ -220,6 +221,7 @@ fn run_demo() {
         BranchArm {
             label: "revise".to_string(),
             given: Some(GivenClause {
+                focus: None,
                 items: vec![
                     GivenItem::Named(
                         "confidence".to_string(),
@@ -264,6 +266,7 @@ fn run_demo() {
         BranchArm {
             label: "reject".to_string(),
             given: Some(GivenClause {
+                focus: None,
                 items: vec![
                     GivenItem::Named(
                         "has_fatal_flaws".to_string(),

crates/oo7-core/src/ast.rs

@@ -6,6 +6,10 @@
 // The AST preserves the Harvard Architecture invariant:
 // DataExpr and ControlExpr are separate enum variants.
 // There is no way to construct a DataExpr containing control flow.
+//
+// Sections 18-19: Token Economics types (budget, branch modifiers,
+// neural dispatch, focus, batch) and Kategoria types (dependent,
+// refinement, path, graded, effect) are included.
 
 use serde::{Deserialize, Serialize};
 
@@ -111,9 +115,11 @@ pub enum ControlStmt {
         scrutinee: ControlExpr,
         arms: Vec<(Pattern, ControlExprOrBlock)>,
     },
-    /// `branch [traced "label"] { | arm -> body ... }`
+    /// `branch [modifier] [traced "label"] { | arm -> body ... }`
     /// THE HERMENEUTIC MOMENT — the only nondeterministic construct
+    /// Section 18.2: modifier can be `speculative` or `cached`
     Branch {
+        modifier: Option<BranchModifier>,
         traced: Option<String>,
         arms: Vec<BranchArm>,
     },
@@ -134,6 +140,148 @@ pub enum ControlStmt {
     Expr(ControlExpr),
 }
 
+// ============================================================
+// Section 18.1: Budget Annotation
+// ============================================================
+
+/// Budget annotation: @budget(N) — token budget as linear resource.
+/// Eclexia's shadow pricing applied to tokens.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BudgetAnnotation {
+    pub tokens: i64,
+}
+
+// ============================================================
+// Section 18.2: Branch Modifier
+// ============================================================
+
+/// Branch modifier — controls branch evaluation strategy.
+/// `speculative`: parallel evaluation of all arms (Chapel-style).
+/// `cached`: trace memoisation (Oblibeny reduction).
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
+pub enum BranchModifier {
+    /// Evaluate all arms in parallel, select best result.
+    Speculative,
+    /// Memoise via trace records — skip re-evaluation on cache hit.
+    Cached,
+}
+
+// ============================================================
+// Section 18.3: Neural Dispatch
+// ============================================================
+
+/// Neural dispatch target — specifies which neurosymbolic backend
+/// to route a @neural function to.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum NeuralTarget {
+    /// Hypatia ESN/RBF system: `hypatia("model_name")`
+    Hypatia(String),
+    /// ONNX model: `onnx("model.onnx")`
+    Onnx(String),
+    /// Custom backend: `custom("backend_name")`
+    Custom(String),
+}
+
+// ============================================================
+// Section 18.4: Focus Annotation
+// ============================================================
+
+/// Focus annotation on given clause: @focus(N).
+/// Allocates N tokens of context window to the evidence.
+/// Ephapax-style attention budgeting.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FocusAnnotation {
+    pub tokens: i64,
+}
+
+// ============================================================
+// Section 19: Kategoria Advanced Types
+// ============================================================
+
+/// Dependent type argument — either a value (Data) or a type name.
+/// Value arguments are Harvard-separated: only Data expressions.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum DepArg {
+    /// A runtime value (Data expression) used as type index
+    Value(DataExpr),
+    /// A type argument (stored as raw string for now)
+    Type(String),
+}
+
+/// Refinement type: { x : T | P }
+/// The predicate P is a Data expression (Harvard-separated).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RefinementType {
+    /// The bound variable name
+    pub var: String,
+    /// The base type (as raw string)
+    pub base_type: String,
+    /// Left side of the predicate
+    pub predicate_left: DataExpr,
+    /// Predicate operator
+    pub predicate_op: PredOp,
+    /// Right side of the predicate
+    pub predicate_right: DataExpr,
+}
+
+/// Graded type: @graded(grade) T — semiring-indexed resource tracking.
+/// In 007, grading tracks TOKEN COST.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GradedType {
+    /// The grade (exact count, omega, zero, or symbolic)
+    pub grade: Grade,
+    /// The inner type (as raw string)
+    pub inner_type: String,
+}
+
+/// Grade in a graded type — how many times a resource may be used.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum Grade {
+    /// Exact usage count
+    Exact(i64),
+    /// Unrestricted usage (omega)
+    Omega,
+    /// Phantom/unused (zero)
+    Zero,
+    /// Symbolic grade from a semiring
+    Symbolic(String),
+}
+
+/// Effect type: T !{effects} — tracked side effects in the type system.
+/// Makes the Harvard boundary GRADUAL.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EffectType {
+    /// The base type (as raw string)
+    pub base_type: String,
+    /// The set of effects
+    pub effects: Vec<Effect>,
+}
+
+/// Individual effect — one tracked side effect.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum Effect {
+    /// May send messages
+    Send,
+    /// May spawn agents
+    Spawn,
+    /// May move between locales
+    Migrate,
+    /// May mutate state
+    State,
+    /// Produces decision traces
+    Trace,
+    /// Invokes neurosymbolic system
+    Neural,
+    /// Costs N tokens
+    Tokens(i64),
+    /// User-defined effect
+    Custom(String),
+}
+
+// ============================================================
+// Branch Arms and Given Clauses
+// ============================================================
+
 /// A branch arm — one option in a hermeneutic branch point.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BranchArm {
@@ -151,8 +299,12 @@ pub struct BranchArm {
 ///
 /// INVARIANT: All items are DataExpr. Cannot contain control flow.
 /// This is enforced by the grammar AND the AST type.
+/// Section 18.4: optional focus annotation for attention budgeting.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct GivenClause {
+    /// Optional @focus(N) attention budget
+    pub focus: Option<FocusAnnotation>,
+    /// The evidence items
     pub items: Vec<GivenItem>,
 }
 
@@ -270,10 +422,13 @@ pub enum Pattern {
 // ============================================================
 
 /// Agent declaration.
+/// Section 18.1: includes optional budget annotation.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AgentDecl {
     pub name: String,
     pub capabilities: Vec<String>,
+    /// Optional token budget (Section 18.1)
+    pub budget: Option<BudgetAnnotation>,
     pub implements: Vec<(String, String)>,
     pub locale: Option<String>,
     pub data_blocks: Vec<DataBinding>,
@@ -361,16 +516,21 @@ pub struct BehaviourDecl {
 }
 
 /// Function declaration with purity annotation.
+/// Section 18.3: purity includes Neural variant; body may contain
+/// neural_dispatch for @neural functions.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct FunctionDecl {
     pub purity: Purity,
     pub name: String,
     pub params: Vec<(String, String)>,
     pub return_type: Option<String>,
     pub body: Vec<ControlStmt>,
+    /// Neural dispatch target (only for @neural functions)
+    pub neural_dispatch: Option<NeuralTarget>,
 }
 
 /// Purity level — part of the effect type system (Layer 8).
+/// Section 18.3: Neural variant added for neurosymbolic dispatch.
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
 pub enum Purity {
     /// Guaranteed termination, no side effects, addition-only
@@ -379,6 +539,8 @@ pub enum Purity {
     Pure,
     /// All effects permitted (default)
     Impure,
+    /// Neurosymbolic dispatch — routes to trained model, ~zero tokens
+    Neural,
 }
 
 // ============================================================
@@ -400,6 +562,7 @@ pub struct ChoreographyDecl {
 }
 
 /// A step in a choreography.
+/// Section 18.5: Batch variant added for amortised decisions.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ChoreoStep {
     /// Communication: `sender -> receiver : message_name(args...)`
@@ -432,6 +595,11 @@ pub enum ChoreoStep {
     },
     /// Goto: `goto label`
     Goto(String),
+    /// Batch: `batch { steps... }` — amortised decisions (Section 18.5)
+    /// Presents N decisions to the LLM as one structured prompt.
+    Batch {
+        steps: Vec<ChoreoStep>,
+    },
 }
 
 /// A branch arm in a choreography.
@@ -446,7 +614,7 @@ pub struct ChoreoBranchArm {
 }
 
 // ============================================================
-// Locales
+// Locales (Section 18.6: model-routing extensions)
 // ============================================================
 
 /// Locale declaration — names a compute location.
@@ -459,18 +627,28 @@ pub struct LocaleDecl {
 }
 
 /// Locale constructor — where computation executes.
+/// Section 18.6: Remote, Edge, Cluster extended with model-routing params.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum LocaleConstructor {
     /// Local execution
     Local,
     /// GPU device: `GPU(device: N)`
     Gpu { device: i64 },
-    /// Remote URL: `Remote(url: "...")`
-    Remote { url: String },
-    /// Edge region: `Edge(region: "...")`
-    Edge { region: String },
-    /// Cluster of nodes: `Cluster(nodes: [...])`
-    Cluster { nodes: Vec<String> },
+    /// Remote with optional model routing: `Remote(url: "...", model: "...")`
+    Remote {
+        url: Option<String>,
+        model: Option<String>,
+    },
+    /// Edge with optional model routing: `Edge(region: "...", model: "...")`
+    Edge {
+        region: Option<String>,
+        model: Option<String>,
+    },
+    /// Cluster with nodes and optional models: `Cluster(nodes: [...], models: [...])`
+    Cluster {
+        nodes: Vec<String>,
+        models: Vec<String>,
+    },
 }
 
 /// Locale expression — either a named locale or an inline constructor.

crates/oo7-core/src/eval.rs

@@ -468,7 +468,16 @@ impl Evaluator {
                 }
             }
 
-            ControlStmt::Branch { traced, arms } => {
+            ControlStmt::Branch {
+                modifier: _modifier,
+                traced,
+                arms,
+            } => {
+                // Section 18.2: modifier (speculative/cached) is ignored in
+                // the reference evaluator — it affects scheduling strategy,
+                // not observable semantics. A production runtime would fork
+                // evaluation streams for speculative and check trace cache
+                // for cached.
                 env.push_scope();
                 let r = self.eval_branch(traced, arms, env);
                 env.pop_scope();