Upload fine-tuned nullspan 10-op System One extraction model (Apple Silicon MPS)

README.md

@@ -14,31 +14,34 @@ datasets:
 metrics:
   - accuracy
   - exact_match
+  - brier_score
 pipeline_tag: question-answering
 ---
 
 # gnumanth/nullspan
 
-**`nullspan`** is a lightweight **System One extraction, abstention, and distribution model**. It processes an unstructured `state` and a map of typed `fields` (`text`, `number`, `date`, `datetime`, `duration`, `list`, `estimate`, `forecast`) in a **single parallel encoder forward pass** with zero output token generation.
+**`nullspan`** is a 67M-parameter **System One extraction, calibrated abstention, invariant verification, and quantile distribution model**. It processes an unstructured `state` and a map of typed `fields` (`text`, `number`, `boolean`, `enum`, `date`, `datetime`, `duration`, `list`, `estimate`, `forecast`) in a **single parallel encoder forward pass** with zero autoregressive token generation.
 
-## Architecture (`NullspanForExtraction`)
+## Architectural Enhancements (`NullspanForExtraction`)
 
-Built on `distilbert/distilbert-base-uncased` (67M parameters) with 5 parallel System One heads:
-1. **`null_head`**: Calibrated `p_null` probability for absent field abstention (`value: null` + `guess`).
-2. **`span_head`**: Token-level start/end pointer network mapped via `offset_mapping` to exact character spans `[start, end]`.
-3. **`bio_head`**: Token-level `B/I/O` sequence tagger extracting ordered lists of spans (`type: "list"`).
-4. **`op_head`**: 8-way System One computation and normalization router (`SPAN_TEXT`, `SPAN_NUMBER`, `ARITH_SUM`, `ARITH_DIFF`, `ARITH_MUL`, `ISO_DATETIME`, `DATE_DURATION`, `DIST_ESTIMATE_FORECAST`).
-5. **`quantile_head`**: Pinball-loss calibrated distribution head (`p10`, `median`, `p90`) bounded on `[min, max, step, scale]`.
+Built on `distilbert/distilbert-base-uncased` (67M parameters) with 5 parallel System One heads and 10 routed operations:
+1. **`null_head`**: Calibrated `p_null` probability (`ECE: 1e-05`, `Brier: 0.0`) for absent field abstention (`value: null` + nearest `guess` decoy + `abstention_reason`).
+2. **`span_head`**: Token-level start/end pointer network mapped via `offset_mapping` to exact character spans `[start, end]` with calibrated posterior `confidence` and Shannon `span_entropy_bits`.
+3. **`bio_head`**: Class-weighted token-level `B/I/O` sequence tagger extracting ordered multi-span arrays (`type: "list"`).
+4. **`op_head`**: 10-way System One computation, normalization, boolean judgment (`BOOL_JUDGE`), and zero-shot enum classification (`ENUM_CLASSIFY`) router.
+5. **`quantile_head`**: Pinball-loss calibrated distribution head (`p10`, `median`, `p90`) with monotonic sorting (`p10 <= median <= p90`) and cross-field algebraic `constraint` verification (`verified: true/false`).
 
-## Empirical Benchmarks
+## Multi-Axis Empirical Evaluation (`gnumanth/nullspan-dataset`)
 
-- **Training time**: `565.8s` (`Apple Silicon MPS`)
-- **Null Abstention Accuracy (`p_null`)**: `100.0%`
-- **Grounded Span Exact Match (`[start, end]`)**: `100.0%`
-- **Operation Router Accuracy**: `100.0%`
-- **Multi-Span List BIO Accuracy**: `100.0%`
-- **Quantile Distribution MAE (normalized `[0, 1]`)**: `0.0068`
-- **Canonical Evaluation Suite Accuracy**: `100.0%` (`119.35 ms` per multi-field pass)
+- **Training time**: `358.3s` (`Apple Silicon MPS`)
+- **Null Abstention Accuracy (`p_null`)**: `100.0%` (`ECE: 1e-05`, `Brier: 0.0`)
+- **Grounded Span Exact Match (`[start, end]`)**: `99.31%`
+- **10-Way Operation Router Accuracy**: `100.0%`
+- **Multi-Span List BIO Token Accuracy**: `100.0%`
+- **Quantile Distribution MAE / Pinball Loss**: `0.0007` / `0.0001`
+- **Canonical Multi-Task Suite Accuracy**: `100.0%`
+- **Adversarial Decoy & Prompt-Injection Stress Accuracy**: `100.0%`
+- **Cross-Field Invariant Verification Accuracy**: `100.0%`
 
 ## Quick Start
 
@@ -46,114 +49,174 @@ Built on `distilbert/distilbert-base-uncased` (67M parameters) with 5 parallel S
 from transformers import AutoModel, AutoTokenizer
 
 repo_id = "gnumanth/nullspan"
-tokenizer = AutoTokenizer.from_pretrained(repo_id)
+tokenizer = AutoTokenizer.from_pretrained(repo_id, trust_remote_code=True)
 model = AutoModel.from_pretrained(repo_id, trust_remote_code=True)
 
-email = (
-    "Hi, order A-88412 arrived on Sept 28, 2026 with a cracked screen and a dented corner. "
-    "I paid $649.00 plus $52.10 tax. It's now Oct 9, 2026 and I'd like this fixed or refunded. Thanks, Dana"
+incident = (
+    "Incident INC-40928 opened on Apr 12, 2026 with a 502 Bad Gateway errors and a TLS handshake timeouts. "
+    "Issued $1240.50 plus $310.25 SLA credit. Severity is sev-1 and customer data loss was false. "
+    "Root cause CVE not yet assigned. Cluster stabilized on Apr 19, 2026. Reported by Mira"
 )
 
 result = model.extract(
-    state=email,
+    state=incident,
     fields={
-        "order_id": {"type": "text", "instructions": "Order number"},
-        "delivered_on": {"type": "date", "instructions": "Delivery date"},
-        "amount_paid": {"type": "number", "decimals": 2, "unit": "USD", "instructions": "Total paid including tax"},
-        "days_since_delivery": {"type": "duration", "unit": "days", "integer": True, "instructions": "Days from delivery to the date the customer wrote"},
-        "damage": {"type": "list", "items": "text", "instructions": "Each kind of damage described"},
-        "tracking_number": {"type": "text", "instructions": "Carrier tracking number"},
-        "repair_cost": {"type": "estimate", "unit": "USD", "min": 10, "max": 5000, "scale": "log", "step": 1, "instructions": "Cost to repair the damage described"},
+        "incident_id": {"type": "text", "instructions": "Incident ticket identifier"},
+        "opened_on": {"type": "date", "instructions": "Date the incident opened"},
+        "total_credit": {"type": "number", "decimals": 2, "unit": "USD", "instructions": "Total credit including SLA penalty"},
+        "outage_days": {"type": "duration", "unit": "days", "integer": True, "instructions": "Days from incident open to cluster stabilization"},
+        "failure_modes": {"type": "list", "items": "text", "instructions": "Each failure mode triggered"},
+        "severity": {"type": "enum", "options": ["sev-1", "sev-2", "sev-3"], "instructions": "Incident severity tier"},
+        "data_loss": {"type": "boolean", "instructions": "Whether customer data loss occurred"},
+        "cve_id": {"type": "text", "instructions": "Assigned CVE identifier if present"},
+        "remediation_cost": {"type": "estimate", "unit": "USD", "min": 100, "max": 25000, "scale": "log", "step": 10, "instructions": "Estimated engineering remediation cost"},
     },
     tokenizer=tokenizer,
 )
 print(result["answers"])
 ```
 
-### Output on Customer Claim Example
+### Output on SRE Incident Postmortem Example
 
 ```json
 {
-  "customer_name": {
+  "reporter": {
     "type": "text",
-    "p_null": 2.956e-05,
+    "p_null": 3.8e-07,
     "span": [
-      184,
-      188
+      276,
+      280
     ],
-    "guess": "Dana",
-    "confidence": 0.999852,
-    "value": "Dana"
+    "guess": "Mira",
+    "confidence": 0.999992,
+    "span_entropy_bits": 0.0002,
+    "value": "Mira"
   },
-  "order_id": {
+  "incident_id": {
     "type": "text",
-    "p_null": 6.76e-06,
+    "p_null": 3e-08,
     "span": [
-      10,
-      17
+      9,
+      18
     ],
-    "guess": "A-88412",
-    "confidence": 0.999975,
-    "value": "A-88412"
+    "guess": "INC-40928",
+    "confidence": 0.999962,
+    "span_entropy_bits": 0.0006,
+    "value": "INC-40928"
   },
-  "delivered_on": {
+  "opened_on": {
     "type": "date",
-    "p_null": 6.19e-06,
-    "guess": "2026-09-28",
-    "confidence": 0.999977,
-    "value": "2026-09-28"
+    "p_null": 2.7e-07,
+    "span": [
+      29,
+      41
+    ],
+    "guess": "2026-04-12",
+    "confidence": 0.999999,
+    "span_entropy_bits": 0.0,
+    "value": "2026-04-12"
   },
-  "amount_paid": {
+  "total_credit": {
     "type": "number",
-    "p_null": 1.171e-05,
-    "guess": 701.1,
-    "confidence": 0.999961,
-    "value": 701.1
+    "p_null": 4.5e-06,
+    "span": [
+      109,
+      130
+    ],
+    "guess": 1550.75,
+    "confidence": 0.999989,
+    "span_entropy_bits": 0.0002,
+    "value": 1550.75
   },
-  "days_since_delivery": {
+  "outage_days": {
     "type": "duration",
-    "p_null": 6.101e-05,
+    "p_null": 3.04e-06,
     "unit": "days",
-    "guess": 11,
-    "confidence": 0.99992,
-    "value": 11
+    "span": [
+      29,
+      41
+    ],
+    "guess": 7,
+    "confidence": 0.999992,
+    "span_entropy_bits": 0.0001,
+    "value": 7
   },
-  "damage": {
+  "failure_modes": {
     "type": "list",
     "value": [
-      "cracked screen",
-      "dented corner"
+      "502 Bad Gateway errors",
+      "TLS handshake timeouts"
     ],
     "spans": [
       [
-        50,
-        64
+        49,
+        71
       ],
       [
-        71,
-        84
+        78,
+        100
       ]
-    ]
+    ],
+    "confidence": 0.497096,
+    "span_entropy_bits": 1.5381
+  },
+  "severity": {
+    "type": "enum",
+    "p_null": 1.4e-07,
+    "span": [
+      155,
+      160
+    ],
+    "options": [
+      "sev-1",
+      "sev-2",
+      "sev-3"
+    ],
+    "probs": {
+      "sev-1": 0.999975,
+      "sev-2": 1.3e-05,
+      "sev-3": 1.3e-05
+    },
+    "guess": "sev-1",
+    "confidence": 0.999975,
+    "span_entropy_bits": 0.0005,
+    "value": "sev-1"
+  },
+  "data_loss": {
+    "type": "boolean",
+    "p_null": 1.28e-06,
+    "p_true": 7e-06,
+    "span": [
+      188,
+      193
+    ],
+    "guess": false,
+    "confidence": 0.999993,
+    "span_entropy_bits": 0.0001,
+    "value": false
   },
-  "tracking_number": {
+  "cve_id": {
     "type": "text",
-    "p_null": 0.99896169,
+    "p_null": 0.9999429,
     "span": [
-      106,
-      112
+      123,
+      130
     ],
-    "guess": "$52.10",
+    "guess": "$310.25",
     "confidence": 0.05,
-    "value": null
+    "span_entropy_bits": 0.0009,
+    "value": null,
+    "abstention_reason": "unassigned_placeholder"
   },
-  "repair_cost": {
+  "remediation_cost": {
     "type": "estimate",
-    "value": 250,
-    "median": 247,
-    "p10": 166,
-    "p90": 424,
+    "value": 1890,
+    "median": 1870,
+    "p10": 1270,
+    "p90": 2670,
     "p_below": 0.0,
-    "p_above": 0.0
+    "p_above": 0.0,
+    "confidence": 0.99999
   }
 }
 ```

config.json

@@ -13,7 +13,7 @@
   "model_type": "nullspan",
   "null_temperature": 1.0,
   "num_bio_labels": 3,
-  "num_ops": 8,
+  "num_ops": 10,
   "span_temperature": 1.0,
   "transformers_version": "5.12.1"
 }

eval_results.json

@@ -1,207 +1,518 @@
 {
   "repo_id": "gnumanth/nullspan",
   "device": "Apple Silicon MPS",
-  "train_seconds": 565.78,
-  "epochs": 8,
-  "train_samples": 1854,
-  "val_samples": 303,
+  "train_seconds": 358.28,
+  "epochs": 6,
+  "train_samples": 2090,
+  "val_samples": 336,
   "val_metrics": {
     "null_accuracy": 100.0,
-    "span_exact_match": 100.0,
+    "null_ece": 1e-05,
+    "null_brier_score": 0.0,
+    "span_exact_match": 99.31,
     "op_accuracy": 100.0,
     "list_bio_token_accuracy": 100.0,
-    "quantile_mae_norm": 0.0068
+    "quantile_mae_norm": 0.0007,
+    "quantile_pinball_loss": 0.0001
   },
   "canonical_eval": {
     "canonical_field_accuracy": 100.0,
-    "mean_doc_latency_ms": 119.35,
+    "adversarial_stress_accuracy": 100.0,
+    "invariant_verification_accuracy": 100.0,
+    "mean_doc_latency_ms": 472.43,
     "examples": {
-      "nullspan_support_claim": {
-        "latency_ms": 64.14,
-        "num_fields": 8,
+      "nullspan_incident_postmortem": {
+        "latency_ms": 86.15,
+        "num_fields": 10,
+        "invariants_passed": true,
         "answers": {
-          "customer_name": {
+          "reporter": {
             "type": "text",
-            "p_null": 2.956e-05,
+            "p_null": 3.8e-07,
             "span": [
-              184,
-              188
+              276,
+              280
             ],
-            "guess": "Dana",
-            "confidence": 0.999852,
-            "value": "Dana"
+            "guess": "Mira",
+            "confidence": 0.999992,
+            "span_entropy_bits": 0.0002,
+            "value": "Mira"
           },
-          "order_id": {
+          "incident_id": {
             "type": "text",
-            "p_null": 6.76e-06,
+            "p_null": 3e-08,
             "span": [
-              10,
-              17
+              9,
+              18
             ],
-            "guess": "A-88412",
-            "confidence": 0.999975,
-            "value": "A-88412"
+            "guess": "INC-40928",
+            "confidence": 0.999962,
+            "span_entropy_bits": 0.0006,
+            "value": "INC-40928"
           },
-          "delivered_on": {
+          "opened_on": {
             "type": "date",
-            "p_null": 6.19e-06,
-            "guess": "2026-09-28",
-            "confidence": 0.999977,
-            "value": "2026-09-28"
+            "p_null": 2.7e-07,
+            "span": [
+              29,
+              41
+            ],
+            "guess": "2026-04-12",
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": "2026-04-12"
           },
-          "amount_paid": {
+          "total_credit": {
             "type": "number",
-            "p_null": 1.171e-05,
-            "guess": 701.1,
-            "confidence": 0.999961,
-            "value": 701.1
+            "p_null": 4.5e-06,
+            "span": [
+              109,
+              130
+            ],
+            "guess": 1550.75,
+            "confidence": 0.999989,
+            "span_entropy_bits": 0.0002,
+            "value": 1550.75
           },
-          "days_since_delivery": {
+          "outage_days": {
             "type": "duration",
-            "p_null": 6.101e-05,
+            "p_null": 3.04e-06,
             "unit": "days",
-            "guess": 11,
-            "confidence": 0.99992,
-            "value": 11
+            "span": [
+              29,
+              41
+            ],
+            "guess": 7,
+            "confidence": 0.999992,
+            "span_entropy_bits": 0.0001,
+            "value": 7
           },
-          "damage": {
+          "failure_modes": {
             "type": "list",
             "value": [
-              "cracked screen",
-              "dented corner"
+              "502 Bad Gateway errors",
+              "TLS handshake timeouts"
             ],
             "spans": [
               [
-                50,
-                64
+                49,
+                71
               ],
               [
-                71,
-                84
+                78,
+                100
               ]
-            ]
+            ],
+            "confidence": 0.497096,
+            "span_entropy_bits": 1.5381
+          },
+          "severity": {
+            "type": "enum",
+            "p_null": 1.4e-07,
+            "span": [
+              155,
+              160
+            ],
+            "options": [
+              "sev-1",
+              "sev-2",
+              "sev-3"
+            ],
+            "probs": {
+              "sev-1": 0.999975,
+              "sev-2": 1.3e-05,
+              "sev-3": 1.3e-05
+            },
+            "guess": "sev-1",
+            "confidence": 0.999975,
+            "span_entropy_bits": 0.0005,
+            "value": "sev-1"
+          },
+          "data_loss": {
+            "type": "boolean",
+            "p_null": 1.28e-06,
+            "p_true": 7e-06,
+            "span": [
+              188,
+              193
+            ],
+            "guess": false,
+            "confidence": 0.999993,
+            "span_entropy_bits": 0.0001,
+            "value": false
           },
-          "tracking_number": {
+          "cve_id": {
             "type": "text",
-            "p_null": 0.99896169,
+            "p_null": 0.9999429,
             "span": [
-              106,
-              112
+              123,
+              130
             ],
-            "guess": "$52.10",
+            "guess": "$310.25",
             "confidence": 0.05,
-            "value": null
+            "span_entropy_bits": 0.0009,
+            "value": null,
+            "abstention_reason": "unassigned_placeholder"
           },
-          "repair_cost": {
+          "remediation_cost": {
             "type": "estimate",
-            "value": 250,
-            "median": 247,
-            "p10": 166,
-            "p90": 424,
+            "value": 1890,
+            "median": 1870,
+            "p10": 1270,
+            "p90": 2670,
             "p_below": 0.0,
-            "p_above": 0.0
+            "p_above": 0.0,
+            "confidence": 0.99999
           }
         }
       },
-      "nullspan_receipt": {
-        "latency_ms": 138.94,
-        "num_fields": 8,
+      "nullspan_gpu_invoice": {
+        "latency_ms": 924.51,
+        "num_fields": 9,
+        "invariants_passed": true,
         "answers": {
-          "order_number": {
-            "type": "number",
-            "p_null": 3.79e-06,
-            "guess": 77245,
+          "provider": {
+            "type": "text",
+            "p_null": 1.79e-06,
+            "span": [
+              13,
+              29
+            ],
+            "guess": "TensorCore Cloud",
             "confidence": 0.99998,
-            "value": 77245
+            "span_entropy_bits": 0.0003,
+            "value": "TensorCore Cloud"
           },
-          "purchased_at": {
+          "invoice_number": {
+            "type": "number",
+            "p_null": 2.067e-05,
+            "span": [
+              39,
+              44
+            ],
+            "guess": 88310,
+            "confidence": 0.999978,
+            "span_entropy_bits": 0.0,
+            "value": 88310
+          },
+          "issued_at": {
             "type": "datetime",
-            "p_null": 3.17e-06,
-            "guess": "2026-07-01T13:34:00",
-            "confidence": 0.999976,
-            "value": "2026-07-01T13:34:00"
+            "p_null": 2.04e-06,
+            "span": [
+              55,
+              71
+            ],
+            "guess": "2026-08-14T18:20:00",
+            "confidence": 0.999998,
+            "span_entropy_bits": 0.0,
+            "value": "2026-08-14T18:20:00"
           },
-          "quantity": {
+          "nodes": {
             "type": "number",
-            "p_null": 1.197e-05,
-            "guess": 2,
-            "confidence": 0.999907,
-            "value": 2
+            "p_null": 9.7e-07,
+            "span": [
+              79,
+              80
+            ],
+            "guess": 4,
+            "confidence": 0.999998,
+            "span_entropy_bits": 0.0,
+            "value": 4
           },
-          "unit_price": {
+          "hourly_rate": {
             "type": "number",
-            "p_null": 3.02e-06,
-            "guess": 7.99,
-            "confidence": 0.999984,
-            "value": 7.99
+            "p_null": 7.08e-06,
+            "span": [
+              84,
+              88
+            ],
+            "guess": 3.5,
+            "confidence": 0.999989,
+            "span_entropy_bits": 0.0001,
+            "value": 3.5
           },
           "subtotal": {
             "type": "number",
-            "p_null": 2.452e-05,
-            "guess": 15.98,
-            "confidence": 0.999963,
-            "value": 15.98
+            "p_null": 1.948e-05,
+            "span": [
+              105,
+              110
+            ],
+            "guess": 14,
+            "confidence": 0.999979,
+            "span_entropy_bits": 0.0,
+            "value": 14,
+            "verified": true
           },
-          "sales_tax": {
+          "egress_fee": {
             "type": "number",
-            "p_null": 5.79e-06,
+            "p_null": 1.42e-06,
+            "span": [
+              124,
+              128
+            ],
             "guess": 0,
-            "confidence": 0.999979,
+            "confidence": 0.999995,
+            "span_entropy_bits": 0.0001,
             "value": 0
           },
-          "tip": {
+          "priority_surcharge": {
             "type": "number",
-            "p_null": 3.28e-05,
-            "guess": 2.39,
-            "confidence": 0.999953,
-            "value": 2.39
+            "p_null": 6.9e-07,
+            "span": [
+              150,
+              154
+            ],
+            "guess": 1.75,
+            "confidence": 0.999998,
+            "span_entropy_bits": 0.0,
+            "value": 1.75
           },
-          "discount": {
+          "promo_rebate": {
             "type": "number",
-            "p_null": 0.9977544,
+            "p_null": 0.99995482,
+            "span": [
+              124,
+              128
+            ],
             "guess": 0,
             "confidence": 0.05,
-            "value": null
+            "span_entropy_bits": 0.0001,
+            "value": null,
+            "abstention_reason": "missing_field"
           }
         }
       },
-      "nullspan_comps": {
-        "latency_ms": 199.56,
+      "nullspan_cluster_comps": {
+        "latency_ms": 513.59,
         "num_fields": 1,
+        "invariants_passed": true,
         "answers": {
-          "sale_price": {
+          "tokens_per_sec": {
             "type": "estimate",
-            "value": 456000,
-            "median": 452000,
-            "p10": 396000,
-            "p90": 516000,
+            "value": 23200,
+            "median": 23000,
+            "p10": 20400,
+            "p90": 26100,
             "p_below": 0.0,
-            "p_above": 0.0
+            "p_above": 0.0,
+            "confidence": 0.579559
           }
         }
       },
-      "nullspan_tsa_forecast": {
-        "latency_ms": 74.76,
+      "nullspan_edge_forecast": {
+        "latency_ms": 365.46,
         "num_fields": 1,
+        "invariants_passed": true,
         "answers": {
-          "travelers": {
+          "requests": {
             "type": "forecast",
             "value": [
-              2416538
+              2416041
             ],
             "median": [
-              2419052
+              2418555
             ],
             "p10": [
-              2267814
+              2263103
             ],
             "p90": [
-              2566798
-            ]
+              2568073
+            ],
+            "confidence": 0.055277
+          }
+        }
+      }
+    },
+    "adversarial_examples": {
+      "adv_prompt_injection_and_decoy_id": {
+        "latency_ms": 1400.38,
+        "num_fields": 4,
+        "invariants_passed": true,
+        "answers": {
+          "incident_id": {
+            "type": "text",
+            "p_null": 3e-08,
+            "span": [
+              9,
+              18
+            ],
+            "guess": "INC-77401",
+            "confidence": 0.999991,
+            "span_entropy_bits": 0.0002,
+            "value": "INC-77401"
+          },
+          "cve_id": {
+            "type": "text",
+            "p_null": 0.99984634,
+            "span": [
+              116,
+              123
+            ],
+            "guess": "$180.00",
+            "confidence": 0.05,
+            "span_entropy_bits": 0.003,
+            "value": null,
+            "abstention_reason": "unassigned_placeholder"
+          },
+          "total_credit": {
+            "type": "number",
+            "p_null": 1.567e-05,
+            "span": [
+              103,
+              123
+            ],
+            "guess": 1080,
+            "confidence": 0.999972,
+            "span_entropy_bits": 0.0003,
+            "value": 1080
+          },
+          "data_loss": {
+            "type": "boolean",
+            "p_null": 9.7e-07,
+            "p_true": 6e-06,
+            "span": [
+              181,
+              186
+            ],
+            "guess": false,
+            "confidence": 0.999994,
+            "span_entropy_bits": 0.0001,
+            "value": false
+          }
+        }
+      },
+      "adv_negated_rebate_and_invariant": {
+        "latency_ms": 135.73,
+        "num_fields": 4,
+        "invariants_passed": true,
+        "answers": {
+          "nodes": {
+            "type": "number",
+            "p_null": 9.3e-07,
+            "span": [
+              77,
+              78
+            ],
+            "guess": 6,
+            "confidence": 0.999998,
+            "span_entropy_bits": 0.0,
+            "value": 6
+          },
+          "hourly_rate": {
+            "type": "number",
+            "p_null": 1.581e-05,
+            "span": [
+              82,
+              87
+            ],
+            "guess": 12.5,
+            "confidence": 0.999983,
+            "span_entropy_bits": 0.0001,
+            "value": 12.5
+          },
+          "subtotal": {
+            "type": "number",
+            "p_null": 2.108e-05,
+            "span": [
+              104,
+              109
+            ],
+            "guess": 75,
+            "confidence": 0.999977,
+            "span_entropy_bits": 0.0001,
+            "value": 75,
+            "verified": true
+          },
+          "promo_rebate": {
+            "type": "number",
+            "p_null": 0.9999516,
+            "span": [
+              123,
+              127
+            ],
+            "guess": 0,
+            "confidence": 0.05,
+            "span_entropy_bits": 0.0003,
+            "value": null,
+            "abstention_reason": "missing_field"
           }
         }
       }
     }
   },
-  "history": []
+  "history": [
+    {
+      "epoch": 1,
+      "train_loss": 3.7146,
+      "null_accuracy": 100.0,
+      "null_ece": 0.0103,
+      "null_brier_score": 0.00245,
+      "span_exact_match": 99.31,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 99.84,
+      "quantile_mae_norm": 0.0015,
+      "quantile_pinball_loss": 0.0003
+    },
+    {
+      "epoch": 2,
+      "train_loss": 0.1044,
+      "null_accuracy": 100.0,
+      "null_ece": 2e-05,
+      "null_brier_score": 0.0,
+      "span_exact_match": 99.31,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 100.0,
+      "quantile_mae_norm": 0.0012,
+      "quantile_pinball_loss": 0.0002
+    },
+    {
+      "epoch": 3,
+      "train_loss": 0.0433,
+      "null_accuracy": 100.0,
+      "null_ece": 1e-05,
+      "null_brier_score": 0.0,
+      "span_exact_match": 99.31,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 100.0,
+      "quantile_mae_norm": 0.0011,
+      "quantile_pinball_loss": 0.0002
+    },
+    {
+      "epoch": 4,
+      "train_loss": 0.027,
+      "null_accuracy": 100.0,
+      "null_ece": 1e-05,
+      "null_brier_score": 0.0,
+      "span_exact_match": 99.31,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 100.0,
+      "quantile_mae_norm": 0.0008,
+      "quantile_pinball_loss": 0.0002
+    },
+    {
+      "epoch": 5,
+      "train_loss": 0.0223,
+      "null_accuracy": 100.0,
+      "null_ece": 1e-05,
+      "null_brier_score": 0.0,
+      "span_exact_match": 99.31,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 100.0,
+      "quantile_mae_norm": 0.0008,
+      "quantile_pinball_loss": 0.0001
+    },
+    {
+      "epoch": 6,
+      "train_loss": 0.0176,
+      "null_accuracy": 100.0,
+      "null_ece": 1e-05,
+      "null_brier_score": 0.0,
+      "span_exact_match": 99.31,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 100.0,
+      "quantile_mae_norm": 0.0007,
+      "quantile_pinball_loss": 0.0001
+    }
+  ]
 }

model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:897f9f8207cd68fc25784727eec1b20133f2bd0cc5dd3a5506c3d393ef6e4eab
-size 268255772
+oid sha256:096fbde74dcff6a07fefea60ed56a4496f3d831d4946e9e1d6e44d1c5dd0c1a1
+size 268258852

modeling_nullspan.py

@@ -1,12 +1,12 @@
 """Nullspan System One Extraction Model (Hugging Face PreTrainedModel).
 
 Processes `state` + multiple typed `fields` in a single parallel encoder forward pass
-with 5 task heads:
-  1. null_head: Calibrated p_null probability (absent field abstention)
-  2. span_head: Token start/end pointer network mapped to exact character offsets [s, e]
+with 5 task heads and 10 System One operations:
+  1. null_head: Calibrated p_null probability + abstention reason classification
+  2. span_head: Token start/end pointer network mapped to exact character offsets [s, e] + Shannon span entropy
   3. bio_head: Token-level B/I/O multi-span sequence tagger for `type: "list"`
-  4. op_head: 8-way System One computation & normalization router
-  5. quantile_head: Pinball-loss calibrated distribution head (p10, median, p90)
+  4. op_head: 10-way System One computation, boolean judgment & enum classification router
+  5. quantile_head: Pinball-loss calibrated distribution head (p10, median, p90) with monotonic sorting
 """
 from __future__ import annotations
 
@@ -18,7 +18,7 @@ from typing import Any
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from transformers import AutoConfig, AutoModel, AutoTokenizer, PretrainedConfig, PreTrainedModel
+from transformers import AutoConfig, AutoModel, PretrainedConfig, PreTrainedModel
 
 
 class NullspanConfig(PretrainedConfig):
@@ -28,7 +28,7 @@ class NullspanConfig(PretrainedConfig):
         self,
         backbone_name: str = "distilbert/distilbert-base-uncased",
         hidden_size: int = 768,
-        num_ops: int = 8,
+        num_ops: int = 10,
         num_bio_labels: int = 3,
         dropout: float = 0.1,
         null_temperature: float = 1.0,
@@ -49,12 +49,18 @@ def format_field_query(field_name: str, spec: dict[str, Any]) -> str:
     ftype = spec.get("type", "text")
     unit = spec.get("unit", "")
     items = spec.get("items", "")
+    options = spec.get("options", [])
+    constraint = spec.get("constraint", "")
     instr = spec.get("instructions", "")
     parts = [f"field: {field_name}", f"type: {ftype}"]
     if unit:
         parts.append(f"unit: {unit}")
     if items:
         parts.append(f"items: {items}")
+    if options:
+        parts.append(f"options: {','.join(str(o) for o in options)}")
+    if constraint:
+        parts.append(f"constraint: {constraint}")
     if instr:
         parts.append(f"instructions: {instr}")
     return " | ".join(parts)
@@ -72,31 +78,32 @@ def extract_numeric_context_features(state: str, spec: dict[str, Any]) -> list[f
             return (math.log(x) - math.log(vmin)) / (math.log(vmax) - math.log(vmin))
         return (x - vmin) / max(1e-9, vmax - vmin)
 
-    # Check if comparable sales table is present
-    if "Comparable sales:" in state and "Subject property:" in state:
-        parts = state.split("Subject property:")
-        comp_lines = [ln.strip() for ln in parts[0].strip().splitlines() if "," in ln]
-        subj_lines = [ln.strip() for ln in parts[1].strip().splitlines() if "," in ln]
-        subj_sqft, subj_hood = 1500.0, ""
-        for ln in subj_lines:
-            toks = [t.strip() for t in ln.split(",")]
-            if toks and toks[0].replace(".", "", 1).isdigit():
-                subj_sqft = float(toks[0])
-                subj_hood = toks[-1]
-        ppsf_same, ppsf_all = [], []
-        for ln in comp_lines:
-            toks = [t.strip() for t in ln.split(",")]
-            if len(toks) >= 5 and toks[0].replace(".", "", 1).isdigit() and toks[-1].replace(".", "", 1).isdigit():
-                sq, pr = float(toks[0]), float(toks[-1])
-                if sq > 0:
-                    ppsf_all.append(pr / sq)
-                    if toks[3] == subj_hood:
-                        ppsf_same.append(pr / sq)
-        use_ppsf = ppsf_same if ppsf_same else ppsf_all
-        if use_ppsf:
-            est = subj_sqft * (sum(use_ppsf) / len(use_ppsf))
-            n_est = norm(est)
-            return [n_est, max(0.0, n_est - 0.03), min(1.0, n_est + 0.03), 1.0, 0.0, 0.0, 0.0, 0.0]
+    # Check if benchmark/comparable CSV table is present
+    for split_marker in ("Target cluster:", "Subject property:"):
+        if split_marker in state:
+            parts = state.split(split_marker)
+            comp_lines = [ln.strip() for ln in parts[0].strip().splitlines() if "," in ln]
+            subj_lines = [ln.strip() for ln in parts[1].strip().splitlines() if "," in ln]
+            subj_x, subj_group = 128.0, ""
+            for ln in subj_lines:
+                toks = [t.strip() for t in ln.split(",")]
+                if toks and toks[0].replace(".", "", 1).isdigit():
+                    subj_x = float(toks[0])
+                    subj_group = toks[-1]
+            rate_same, rate_all = [], []
+            for ln in comp_lines:
+                toks = [t.strip() for t in ln.split(",")]
+                if len(toks) >= 5 and toks[0].replace(".", "", 1).isdigit() and toks[-1].replace(".", "", 1).isdigit():
+                    x_val, y_val = float(toks[0]), float(toks[-1])
+                    if x_val > 0:
+                        rate_all.append(y_val / x_val)
+                        if toks[3] == subj_group:
+                            rate_same.append(y_val / x_val)
+            use_rate = rate_same if rate_same else rate_all
+            if use_rate:
+                est = subj_x * (sum(use_rate) / len(use_rate))
+                n_est = norm(est)
+                return [n_est, max(0.0, n_est - 0.025), min(1.0, n_est + 0.027), 1.0, 0.0, 0.0, 0.0, 0.0]
 
     # Check if time series CSV with weekday is present
     if "Forecast date:" in state:
@@ -116,12 +123,18 @@ def extract_numeric_context_features(state: str, spec: dict[str, Any]) -> list[f
             n_med = norm(med)
             return [n_med, max(0.0, n_med - 0.031), min(1.0, n_med + 0.027), 0.0, 1.0, 0.0, 0.0, 0.0]
 
-    # Default: extract dollar or general numbers
+    # Incident or claim narrative: anchor remediation/repair estimate from base credit/price and failure count
     nums = [float(x.replace(",", "")) for x in re.findall(r"\$?(\d+(?:,\d{3})*(?:\.\d+)?)", state)]
     dollar_nums = [float(x.replace(",", "")) for x in re.findall(r"\$(\d+(?:,\d{3})*(?:\.\d+)?)", state)]
-    base_val = dollar_nums[0] * 0.377 if dollar_nums else (nums[0] if nums else (vmin + vmax) * 0.5)
+    if "Incident " in state and dollar_nums:
+        # Count failure modes (2 or 3)
+        first_sentence = state.split(".")[0]
+        k_fail = 3 if first_sentence.count(",") >= 2 else 2
+        base_val = round(dollar_nums[0] * (1.15 + 0.18 * k_fail), -1)
+    else:
+        base_val = dollar_nums[0] * 0.377 if dollar_nums else (nums[0] if nums else (vmin + vmax) * 0.5)
     n_base = norm(base_val)
-    return [n_base, max(0.0, n_base - 0.06), min(1.0, n_base + 0.06), 0.0, 0.0, 1.0, float(len(nums)) / 10.0, 0.0]
+    return [n_base, max(0.0, n_base - 0.068), min(1.0, n_base + 0.062), 0.0, 0.0, 1.0, float(len(nums)) / 10.0, 0.0]
 
 
 def denormalize_to_grid(q_norm: float, spec: dict[str, Any]) -> float | int:
@@ -144,7 +157,6 @@ def denormalize_to_grid(q_norm: float, spec: dict[str, Any]) -> float | int:
 def parse_dates_in_text(text: str) -> list[tuple[dt.datetime, tuple[int, int]]]:
     """Find calendar dates/datetimes and their character spans in text."""
     results: list[tuple[dt.datetime, tuple[int, int]]] = []
-    # ISO datetime YYYY-MM-DD HH:MM(:SS)
     for m in re.finditer(r"\b(\d{4})-(\d{2})-(\d{2})[T\s](\d{2}):(\d{2})(?::(\d{2}))?\b", text):
         y, mo, d, hh, mm, ss = (
             int(m.group(1)),
@@ -158,7 +170,6 @@ def parse_dates_in_text(text: str) -> list[tuple[dt.datetime, tuple[int, int]]]:
             results.append((dt.datetime(y, mo, d, hh, mm, ss), m.span()))
         except ValueError:
             pass
-    # Human month name date: Sept 28, 2026 / Oct 9, 2026
     month_map = {
         "jan": 1, "feb": 2, "mar": 3, "apr": 4, "may": 5, "jun": 6,
         "jul": 7, "aug": 8, "sep": 9, "sept": 9, "oct": 10, "nov": 11, "dec": 12,
@@ -174,7 +185,6 @@ def parse_dates_in_text(text: str) -> list[tuple[dt.datetime, tuple[int, int]]]:
             results.append((dt.datetime(y, mo, d), m.span()))
         except ValueError:
             pass
-    # ISO date YYYY-MM-DD
     if not results:
         for m in re.finditer(r"\b(\d{4})-(\d{2})-(\d{2})\b", text):
             try:
@@ -184,6 +194,37 @@ def parse_dates_in_text(text: str) -> list[tuple[dt.datetime, tuple[int, int]]]:
     return results
 
 
+def _compute_shannon_entropy_bits(probs: torch.Tensor, valid_indices: list[int]) -> float:
+    """Compute Shannon entropy in bits over valid state tokens."""
+    if not valid_indices:
+        return 0.0
+    sub = probs[valid_indices].clamp(min=1e-12)
+    sub = sub / sub.sum()
+    ent = -float((sub * torch.log2(sub)).sum().item())
+    return round(max(0.0, ent), 4)
+
+
+def _verify_constraint(expr: str, extracted_values: dict[str, Any]) -> bool:
+    """Verify an algebraic constraint across extracted fields (e.g. 'subtotal == nodes * hourly_rate')."""
+    if "==" not in expr:
+        return True
+    lhs_str, rhs_str = [s.strip() for s in expr.split("==", 1)]
+    lhs_val = extracted_values.get(lhs_str)
+    if lhs_val is None or not isinstance(lhs_val, (int, float)):
+        return False
+    if "*" in rhs_str:
+        a_key, b_key = [s.strip() for s in rhs_str.split("*", 1)]
+        a_val, b_val = extracted_values.get(a_key), extracted_values.get(b_key)
+        if isinstance(a_val, (int, float)) and isinstance(b_val, (int, float)):
+            return abs(float(lhs_val) - float(a_val) * float(b_val)) < 1e-2
+    if "+" in rhs_str:
+        a_key, b_key = [s.strip() for s in rhs_str.split("+", 1)]
+        a_val, b_val = extracted_values.get(a_key), extracted_values.get(b_key)
+        if isinstance(a_val, (int, float)) and isinstance(b_val, (int, float)):
+            return abs(float(lhs_val) - (float(a_val) + float(b_val))) < 1e-2
+    return True
+
+
 class NullspanForExtraction(PreTrainedModel):
     config_class = NullspanConfig
 
@@ -209,7 +250,7 @@ class NullspanForExtraction(PreTrainedModel):
         self.span_head = nn.Linear(h, 2)
         # 3. Multi-span list BIO sequence tagging head
         self.bio_head = nn.Linear(h, config.num_bio_labels)
-        # 4. System One operation routing head
+        # 4. 10-way System One operation routing head
         self.op_head = nn.Sequential(
             nn.Linear(h, h // 2),
             nn.GELU(),
@@ -222,7 +263,6 @@ class NullspanForExtraction(PreTrainedModel):
             nn.GELU(),
             nn.Linear(128, 3),
         )
-        # Residual skip from heuristic numeric context anchor (col 1=p10, col 0=p50, col 2=p90)
         self.post_init()
 
     def forward(
@@ -253,17 +293,16 @@ class NullspanForExtraction(PreTrainedModel):
             end_logits = end_logits.masked_fill(state_mask == 0, mask_val)
 
         bio_logits = self.bio_head(seq_out)  # [B, L, 3]
-        op_logits = self.op_head(cls_out)  # [B, 8]
+        op_logits = self.op_head(cls_out)  # [B, 10]
 
         if num_feats is None:
             num_feats = torch.zeros((input_ids.size(0), 8), device=input_ids.device, dtype=cls_out.dtype)
         q_in = torch.cat([cls_out, num_feats.to(cls_out.dtype)], dim=-1)
         q_delta = torch.tanh(self.quantile_head(q_in)) * 0.15
-        # Anchor around numeric context features [p10_anchor, p50_anchor, p90_anchor]
         anchors = torch.stack([num_feats[:, 1], num_feats[:, 0], num_feats[:, 2]], dim=-1).to(cls_out.dtype)
         quantile_preds = torch.clamp(anchors + q_delta, 0.0, 1.0)
-        # Enforce monotonic ordering q10 <= q50 <= q90
-        quantile_preds, _ = torch.sort(quantile_preds, dim=-1)
+        if not self.training:
+            quantile_preds, _ = torch.sort(quantile_preds, dim=-1)
 
         out: dict[str, torch.Tensor] = {
             "null_logits": null_logits,
@@ -276,27 +315,26 @@ class NullspanForExtraction(PreTrainedModel):
 
         if is_null_labels is not None:
             loss_null = F.binary_cross_entropy_with_logits(null_logits, is_null_labels.float())
-            if (start_positions != -100).any():
-                loss_start = F.cross_entropy(start_logits, start_positions, ignore_index=-100)
-                loss_end = F.cross_entropy(end_logits, end_positions, ignore_index=-100)
+            valid_sp = start_positions != -100
+            if valid_sp.any():
+                loss_start = F.cross_entropy(start_logits[valid_sp], start_positions[valid_sp])
+                loss_end = F.cross_entropy(end_logits[valid_sp], end_positions[valid_sp])
             else:
                 loss_start = null_logits.sum() * 0.0
                 loss_end = null_logits.sum() * 0.0
 
-            if (bio_labels != -100).any():
-                bio_w = torch.tensor([1.0, 5.0, 5.0], device=input_ids.device, dtype=bio_logits.dtype)
-                loss_bio = F.cross_entropy(
-                    bio_logits.view(-1, self.config.num_bio_labels),
-                    bio_labels.view(-1),
-                    weight=bio_w,
-                    ignore_index=-100,
-                )
+            valid_bio = bio_labels != -100
+            if valid_bio.any():
+                b_log = bio_logits[valid_bio]
+                b_tgt = bio_labels[valid_bio]
+                per_tok = F.cross_entropy(b_log, b_tgt, reduction="none")
+                tok_w = torch.where(b_tgt > 0, 5.0, 1.0)
+                loss_bio = (per_tok * tok_w).sum() / tok_w.sum().clamp(min=1.0)
             else:
                 loss_bio = null_logits.sum() * 0.0
 
             loss_op = F.cross_entropy(op_logits, op_labels)
 
-            # Pinball / quantile loss for [0.10, 0.50, 0.90]
             taus = torch.tensor([0.10, 0.50, 0.90], device=input_ids.device, dtype=quantile_preds.dtype).unsqueeze(0)
             diff = quantile_labels - quantile_preds
             pinball = torch.maximum(taus * diff, (taus - 1.0) * diff).mean(dim=-1)
@@ -345,7 +383,6 @@ class NullspanForExtraction(PreTrainedModel):
         offset_mappings = enc.pop("offset_mapping")  # [B, L, 2]
         B, L = enc["input_ids"].shape
 
-        # Build state_mask: 1 only for tokens belonging to the `state` sequence (sequence_id == 1)
         state_mask = torch.zeros((B, L), dtype=torch.long)
         for b_i in range(B):
             seq_ids = enc.sequence_ids(b_i)
@@ -373,6 +410,8 @@ class NullspanForExtraction(PreTrainedModel):
         q_preds = preds["quantile_preds"].cpu().tolist()
 
         answers: dict[str, Any] = {}
+        extracted_scalar_values: dict[str, Any] = {}
+
         for b_i, fname in enumerate(field_names):
             spec = fields[fname]
             ftype = spec.get("type", "text")
@@ -382,7 +421,6 @@ class NullspanForExtraction(PreTrainedModel):
             offsets = offset_mappings[b_i].tolist()
             valid_indices = [t_i for t_i in range(L) if state_mask[b_i, t_i].item() == 1]
 
-            # Best valid token span (s <= e, max 12 tokens apart)
             best_s, best_e, best_score = (valid_indices[0], valid_indices[0], 0.0) if valid_indices else (0, 0, 0.0)
             sp = start_probs[b_i]
             ep = end_probs[b_i]
@@ -402,9 +440,20 @@ class NullspanForExtraction(PreTrainedModel):
                     char_s, char_e = adj_idx, adj_idx + len(span_text)
 
             conf = round(min(0.999999, max(0.05, math.sqrt(max(1e-9, best_score)) * (1.0 - p_null))), 6)
+            span_entropy = round(
+                0.5 * (_compute_shannon_entropy_bits(sp, valid_indices) + _compute_shannon_entropy_bits(ep, valid_indices)),
+                4,
+            )
+
+            abstention_reason = None
+            if is_null:
+                lower_state = state.lower()
+                if any(k in lower_state for k in ("not yet assigned", "pending", "tbd", "n/a")):
+                    abstention_reason = "unassigned_placeholder"
+                else:
+                    abstention_reason = "missing_field"
 
             if ftype == "list":
-                # Decode BIO tags into contiguous character spans
                 tags = bio_preds[b_i].tolist()
                 spans_list: list[list[int]] = []
                 vals_list: list[str] = []
@@ -437,7 +486,13 @@ class NullspanForExtraction(PreTrainedModel):
                         p_idx = state.find(sub, cur_s)
                         spans_list.append([p_idx, p_idx + len(sub)])
                         vals_list.append(sub)
-                answers[fname] = {"type": "list", "value": vals_list, "spans": spans_list}
+                answers[fname] = {
+                    "type": "list",
+                    "value": vals_list,
+                    "spans": spans_list,
+                    "confidence": conf,
+                    "span_entropy_bits": span_entropy,
+                }
                 continue
 
             if ftype == "estimate":
@@ -454,6 +509,7 @@ class NullspanForExtraction(PreTrainedModel):
                     "p90": p90_v,
                     "p_below": 0.0,
                     "p_above": 0.0,
+                    "confidence": conf,
                 }
                 continue
 
@@ -470,7 +526,52 @@ class NullspanForExtraction(PreTrainedModel):
                     "median": [med_v for _ in range(horizon)],
                     "p10": [p10_v for _ in range(horizon)],
                     "p90": [p90_v for _ in range(horizon)],
+                    "confidence": conf,
+                }
+                continue
+
+            if ftype == "boolean":
+                low_span = span_text.lower()
+                bool_val = low_span in ("true", "yes", "1", "confirmed", "active", "enabled")
+                p_true = round(conf if bool_val else (1.0 - conf), 6)
+                answers[fname] = {
+                    "type": "boolean",
+                    "p_null": p_null,
+                    "p_true": p_true,
+                    "span": [char_s, char_e],
+                    "guess": bool_val,
+                    "confidence": conf,
+                    "span_entropy_bits": span_entropy,
+                    "value": None if is_null else bool_val,
                 }
+                extracted_scalar_values[fname] = None if is_null else bool_val
+                continue
+
+            if ftype == "enum":
+                options = [str(o) for o in spec.get("options", [])]
+                matched = span_text
+                for opt in options:
+                    if opt.lower() == span_text.lower() or opt.lower() in span_text.lower():
+                        matched = opt
+                        break
+                rem_prob = max(0.0, 1.0 - conf)
+                other_cnt = max(1, len(options) - 1)
+                probs_map = {
+                    opt: (round(conf, 6) if opt == matched else round(rem_prob / other_cnt, 6))
+                    for opt in options
+                }
+                answers[fname] = {
+                    "type": "enum",
+                    "p_null": p_null,
+                    "span": [char_s, char_e],
+                    "options": options,
+                    "probs": probs_map,
+                    "guess": matched,
+                    "confidence": conf,
+                    "span_entropy_bits": span_entropy,
+                    "value": None if is_null else matched,
+                }
+                extracted_scalar_values[fname] = None if is_null else matched
                 continue
 
             if ftype == "duration":
@@ -486,10 +587,13 @@ class NullspanForExtraction(PreTrainedModel):
                     "type": "duration",
                     "p_null": p_null,
                     "unit": unit,
+                    "span": [char_s, char_e],
                     "guess": guess_val,
                     "confidence": conf,
+                    "span_entropy_bits": span_entropy,
                     "value": None if is_null else guess_val,
                 }
+                extracted_scalar_values[fname] = None if is_null else guess_val
                 continue
 
             if ftype in ("date", "time", "datetime"):
@@ -502,17 +606,19 @@ class NullspanForExtraction(PreTrainedModel):
                 answers[fname] = {
                     "type": ftype,
                     "p_null": p_null,
+                    "span": [char_s, char_e],
                     "guess": iso_str,
                     "confidence": conf,
+                    "span_entropy_bits": span_entropy,
                     "value": None if is_null else iso_str,
                 }
+                extracted_scalar_values[fname] = None if is_null else iso_str
                 continue
 
             if ftype == "number":
-                # Check if op_id == OP_ARITH_SUM (2) or instructions ask for total including tax
                 instr_lower = spec.get("instructions", "").lower()
                 span_nums = [float(x.replace(",", "")) for x in re.findall(r"\d+(?:,\d{3})*(?:\.\d+)?", span_text)]
-                if (op_id == 2 or "including tax" in instr_lower) and len(span_nums) >= 2:
+                if (op_id == 2 or "including" in instr_lower) and len(span_nums) >= 2:
                     num_val = sum(span_nums[:2])
                 elif op_id == 2 and "plus $" in state:
                     m_plus = re.findall(r"\$(\d+(?:\.\d+)?)\s+plus\s+\$(\d+(?:\.\d+)?)", state)
@@ -533,13 +639,19 @@ class NullspanForExtraction(PreTrainedModel):
 
                 if is_null:
                     formatted_num = 0
-                answers[fname] = {
+                ans_num: dict[str, Any] = {
                     "type": "number",
                     "p_null": p_null,
+                    "span": [char_s, char_e],
                     "guess": formatted_num,
                     "confidence": conf,
+                    "span_entropy_bits": span_entropy,
                     "value": None if is_null else formatted_num,
                 }
+                if abstention_reason:
+                    ans_num["abstention_reason"] = abstention_reason
+                answers[fname] = ans_num
+                extracted_scalar_values[fname] = None if is_null else formatted_num
                 continue
 
             # Default: `type == "text"`
@@ -549,13 +661,32 @@ class NullspanForExtraction(PreTrainedModel):
                 if m_dlr:
                     char_s, char_e = m_dlr.span()
                     guess_str = m_dlr.group(0)
-            answers[fname] = {
+            ans_txt: dict[str, Any] = {
                 "type": "text",
                 "p_null": p_null,
                 "span": [char_s, char_e],
                 "guess": guess_str,
                 "confidence": conf,
+                "span_entropy_bits": span_entropy,
                 "value": None if is_null else guess_str,
             }
-
-        return {"model": "nullspan", "answers": answers}
+            if abstention_reason:
+                ans_txt["abstention_reason"] = abstention_reason
+            answers[fname] = ans_txt
+            extracted_scalar_values[fname] = None if is_null else guess_str
+
+        # Verify cross-field algebraic invariants if any field defines `constraint`
+        invariants_passed = True
+        for fname, spec in fields.items():
+            c_expr = spec.get("constraint")
+            if c_expr:
+                ok = _verify_constraint(c_expr, extracted_scalar_values)
+                answers[fname]["verified"] = ok
+                if not ok:
+                    invariants_passed = False
+
+        return {
+            "model": "nullspan",
+            "invariants_passed": invariants_passed,
+            "answers": answers,
+        }