@fix operator: complete parse-time implementation + linter rules

Grammar: 135 Ohm rules (all lexical for whitespace control)
- FixpointExpression (named + anonymous)
- Match patterns (path, node, negation, query ref)
- Yield productions (relationship, node, node+rel, state, builtin, nested @fix)
- Termination conditions (stable, max_iterations, timeout, measure, compound)
- Constraint levels (L1 bounded / L2 general)

Parser: 40+ semantic actions compiling @fix → fixpoint IR nodes
- ext.fix contains structured match/yield/until/constraint data
- Status: 'declared' (execution is separate, via FixpointEngine)
- Nested @fix creates inner nodes + stores in outer yield

Types: fixpoint NodeType, fixpoint_derived RelationType, FixpointExt interface
IR Schema: Extended with fixpoint types + 5 graph invariants

Linter rules (10 ERROR + 5 WARNING total):
- E007: L1 constraint violation (no node creation)
- E008: L2 missing explicit bound
- E009: Missing constraint level
- E010: Unstratifiable negation (WARNING — heuristic)
- E011: Nesting de-escalation
- W004: High iteration count (>100)

Tests: 48 new (779 total), zero regressions
3-layer reviewed: session + PL domain expert + consultation team

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

Author: phillipclapham

spec/ir.schema.json

@@ -113,7 +113,8 @@
             "alternative",
             "exploring",
             "parking",
-            "block"
+            "block",
+            "fixpoint"
           ],
           "description": "Semantic type of this node"
         },
@@ -171,7 +172,8 @@
         "different",
         "alternative",
         "alternative_worse",
-        "alternative_better"
+        "alternative_better",
+        "fixpoint_derived"
       ],
       "description": "Type of relationship between nodes"
     },
@@ -312,6 +314,31 @@
           "type": "boolean",
           "default": true,
           "description": "If true, state markers must have required fields. Enforces Decision 3."
+        },
+        "fixpoint_constraint_valid": {
+          "type": "boolean",
+          "default": true,
+          "description": "If true, L1 fixpoint nodes have status 'converged' only. L2 fixpoint nodes have status 'converged' or 'bounded'."
+        },
+        "fixpoint_convergence_valid": {
+          "type": "boolean",
+          "default": true,
+          "description": "If true, every fixpoint node with status 'converged' has delta_sequence ending in 0."
+        },
+        "fixpoint_bound_present": {
+          "type": "boolean",
+          "default": true,
+          "description": "If true, every fixpoint node with constraint 'L2' has an explicit termination bound."
+        },
+        "fixpoint_nesting_monotone": {
+          "type": "boolean",
+          "default": true,
+          "description": "If true, nested fixpoint constraint levels are >= outer fixpoint constraint levels."
+        },
+        "fixpoint_derivation_complete": {
+          "type": "boolean",
+          "default": true,
+          "description": "If true, every element produced by @fix has a corresponding fixpoint_derived relationship."
         }
       },
       "additionalProperties": false

src/grammar.ohm

@@ -4,18 +4,18 @@ FlowScript {
   Line = BlankLine | RelationshipExpression | Element
 
   Element = Modifier* Content
-  Content = State | Insight | Question | Completion | Alternative | Block | Statement
+  Content = State | Insight | Question | Completion | Alternative | fixpointExpression | Block | Statement
 
   BlankLine = space* "\n"
-  Statement = ~Modifier (~("\n" | "{" | "}") any)+ "\n"?
+  Statement = ~Modifier ~"@fix" (~("\n" | "{" | "}") any)+ "\n"?
 
   // Blocks (thought blocks / atomic processing units)
   Block = "{" ws BlockContent? ws "}"
   BlockContent = BlockLine (separator? BlockLine)* separator?
   BlockLine = ws (ContinuationRel | RelationshipExpression | BlockElement)
   BlockElement = Modifier* BlockContent_inner
-  BlockContent_inner = State | Insight | Question | Completion | Alternative | Block | BlockStatement
-  BlockStatement = ~Modifier (~("\n" | "{" | "}" | ";") any)+
+  BlockContent_inner = State | Insight | Question | Completion | Alternative | fixpointExpression | Block | BlockStatement
+  BlockStatement = ~Modifier ~"@fix" (~("\n" | "{" | "}" | ";") any)+
   separator = (space | "\n" | ";")+
   ws = (space | "\n")*
 
@@ -127,6 +127,107 @@ FlowScript {
 
   identifier = letter (letter | digit | "_" | "-")*
 
+  // =========================================================================
+  // Fixpoint Expressions (@fix operator)
+  // All @fix rules are LEXICAL (lowercase) for explicit whitespace control.
+  // Syntactic rules auto-insert spaces which conflicts with @fix's
+  // multi-line block structure. Lexical rules give full control.
+  // =========================================================================
+
+  // @fix name? { clauses }
+  fixpointExpression = fixpointExpression_named | fixpointExpression_anon
+  fixpointExpression_named = "@fix" space+ fixName ws "{" ws fixpointClauses ws "}"
+  fixpointExpression_anon = "@fix" ws "{" ws fixpointClauses ws "}"
+
+  fixName = letter (letter | digit | "_")*
+
+  fixpointClauses = fixpointClause (ws fixpointClause)*
+  fixpointClause = fixMatchClause | fixYieldClause | fixUntilClause | fixConstraintClause
+
+  fixMatchClause = "match" ws ":" ws fixMatchBody
+  fixYieldClause = "yield" ws ":" ws fixYieldBody
+  fixUntilClause = "until" ws ":" ws fixTerminationCondition
+  fixConstraintClause = "constraint" ws ":" ws constraintLevel
+
+  constraintLevel = "L2" | "L1"
+
+  // --- Match patterns ---
+  fixMatchBody = fixMatchBody_braced | fixMatchBody_query
+  fixMatchBody_braced = "{" ws fixPatternList ws "}"
+  fixMatchBody_query = fixQueryRef
+  fixPatternList = fixPatternElement (ws "," ws fixPatternElement)*
+  fixPatternElement = fixNegationPattern | fixPathPattern | fixNodePattern
+
+  // Path pattern: A: node -> trusts -> B: node
+  fixPathPattern = fixNodePattern (ws "->" ws fixEdgeLabel ws "->" ws fixNodePattern)+
+  fixEdgeLabel = letter (letter | digit | "_")*
+
+  // Node pattern: A: node  or  A: thought(predicate1, predicate2)
+  fixNodePattern = fixVariable ws ":" ws fixNodeType fixMatchCondition?
+  fixMatchCondition = "(" ws fixPredicateList ws ")"
+  fixPredicateList = fixPredicate (ws "," ws fixPredicate)*
+  fixPredicate = fixPredicateName "(" ws fixArgList? ws ")"
+  fixPredicateName = letter (letter | digit | "_")*
+
+  // Negation: not node_pattern | not query_ref
+  fixNegationPattern = fixNegationPattern_node | fixNegationPattern_query
+  fixNegationPattern_node = "not" space+ fixNodePattern
+  fixNegationPattern_query = "not" space+ fixQueryRef
+
+  // Query references: tensions(), blocked(), etc.
+  fixQueryRef = fixQueryName "(" ws fixArgList? ws ")"
+  fixQueryName = "tensions" | "blocked" | "alternatives" | "why" | "what_if"
+  fixArgList = fixArg (ws "," ws fixArg)*
+  fixArg = fixVariable | string
+
+  // --- Yield productions ---
+  fixYieldBody = fixYieldBody_braced | fixYieldBody_nested | fixYieldBody_builtin
+  fixYieldBody_braced = "{" ws fixYieldList ws "}"
+  fixYieldBody_nested = fixpointExpression
+  fixYieldBody_builtin = fixBuiltinAction
+  fixYieldList = fixYieldElement (ws "," ws fixYieldElement)*
+  fixYieldElement = fixNodeRelProduction | fixNodeProduction | fixBuiltinAction | fixRelProduction | fixStateProduction | fixpointExpression
+
+  // new hypothesis(X) -> resolves -> X | source: abductive  (combined create + connect)
+  fixNodeRelProduction = "new" space+ fixNodeKind "(" ws fixArgList? ws ")" ws "->" ws fixEdgeLabel ws "->" ws fixVariable fixAnnotation*
+
+  // new hypothesis(X) | source: abductive  (create only)
+  fixNodeProduction = "new" space+ fixNodeKind "(" ws fixArgList? ws ")" fixAnnotation*
+  fixNodeKind = letter (letter | digit | "_")*
+
+  // A -> believes -> P | confidence: derived
+  fixRelProduction = fixVariable ws "->" ws fixEdgeLabel ws "->" ws fixVariable fixAnnotation*
+
+  // resolve(X) | annotate(X)
+  fixStateProduction = fixStateAction "(" ws fixVariable ws ")" fixAnnotation*
+  fixStateAction = "resolve" | "annotate"
+
+  // resolve(matched) — builtin action on query results
+  fixBuiltinAction = "resolve" "(" ws "matched" ws ")" fixAnnotation*
+
+  // Annotations: | key: value
+  fixAnnotation = ws "|" ws fixAnnotationKey ws ":" ws fixAnnotationValue
+  fixAnnotationKey = letter (letter | digit | "_")*
+  fixAnnotationValue = string | fixInteger | fixAnnotationIdent
+  fixAnnotationIdent = letter (letter | digit | "_")*
+
+  // --- Termination conditions ---
+  fixTerminationCondition = fixSimpleTermCondition (ws "or" ws fixSimpleTermCondition)*
+  fixSimpleTermCondition = fixIterationBound | fixTimeoutBound | fixMeasureBound | fixStableCondition
+  fixStableCondition = "stable"
+  fixIterationBound = "max_iterations" ws ":" ws fixInteger
+  fixTimeoutBound = "timeout" ws ":" ws fixInteger fixTimeUnit
+  fixTimeUnit = "ms" | "s" | "m"
+  fixMeasureBound = "measure" ws ":" ws fixMeasureName
+  fixMeasureName = letter (letter | digit | "_")*
+
+  // Fixpoint lexical primitives
+  fixVariable = upper (letter | digit | "_")*
+  fixInteger = digit+
+  fixNodeType = "fixpoint" | "thought" | "question" | "decision" | "blocker" | "action"
+              | "statement" | "insight" | "completion" | "alternative"
+              | "exploring" | "parking" | "block" | "node"
+
   // Lexical rules (whitespace handling)
   space := " " | "\t" | "\r"
 }

src/linter.ts

@@ -75,23 +75,35 @@ export class Linter {
       OrphanedNodesRule,
       CausalCyclesRule,
       AlternativesWithoutDecisionRule,
+      FixpointConstraintViolationRule,
+      FixpointL2MissingBoundRule,
+      FixpointMissingConstraintRule,
+      FixpointUnstratifiableNegationRule,
+      FixpointNestingDeEscalationRule,
       MissingRecommendedFieldsRule,
       DeepNestingRule,
-      LongCausalChainsRule
+      LongCausalChainsRule,
+      FixpointHighIterationCountRule
     } = require('./rules');
 
-    // ERROR rules (6 total)
+    // ERROR rules (10 total)
     this.rules.push(new UnlabeledTensionRule());
     this.rules.push(new MissingRequiredFieldsRule());
     this.rules.push(new InvalidSyntaxRule());
     this.rules.push(new OrphanedNodesRule());
     this.rules.push(new CausalCyclesRule());
     this.rules.push(new AlternativesWithoutDecisionRule());
+    this.rules.push(new FixpointConstraintViolationRule());
+    this.rules.push(new FixpointL2MissingBoundRule());
+    this.rules.push(new FixpointMissingConstraintRule());
+    this.rules.push(new FixpointNestingDeEscalationRule());
 
-    // WARNING rules (3 total)
+    // WARNING rules (5 total)
     this.rules.push(new MissingRecommendedFieldsRule());
     this.rules.push(new DeepNestingRule());
     this.rules.push(new LongCausalChainsRule());
+    this.rules.push(new FixpointUnstratifiableNegationRule());
+    this.rules.push(new FixpointHighIterationCountRule());
   }
 
   /**