§03 PART 1/6 (12,780 chars · Sections: Introduction & Overview; One Constitution, Two Proof Lanes; 1. Strict Representation Before Judgment; 2. The Closed Grammar: Seven Opcodes, Four Layers) — Part 2 → · 1-Call Brief · Full §03 · Raw .txt · All: P1 P2 P3 P4 P5 P6

EISA Four-Gate Verdict Machine & Strict AST Parser

The production EISA core determines which bounded acts earn constitutional standing; Semantic Switch is an experimental alpha module for structure-preserving entity-resolution research.

By Blayne Aina · Principal Systems Architect and creator of AINA · October 31, 2026


Entity resolution has a data-boundary problem before it has a model problem.

Contacts, companies, products, and other native records can contain identifiers that should never be sent raw to an external AI provider. But destructive redaction destroys the relationships that useful comparison requires: exact equality, normalized equality, phone variance, token containment, and the difference between a substitution, insertion, deletion, and transposition.

Semantic Switch resolves that transport problem first. Native rows, keys, and the private crosswalk remain under client control. External computation receives structure-preserving fictional records instead of the declared raw values. Qdrant Edge and qBlock can then nominate candidate partitions without exposing the native rows. Fracture adjudicates identity, Forge selects canonical values with provenance, local restoration maps authorized references back to exact native values, and Shield defends the resolved baseline.

Protected computation alone still does not make a decision correct.

Three agents can read the same contaminated context, repeat the same unsupported merger, and produce three confident explanations. A judge model can make the fourth vote. Nothing about that process establishes which records were compared, which values survived inspection, which contradiction was omitted, or whether the proposed partition covers the candidate universe exactly once.

A trustworthy system does not count votes. It compiles each proposal into a bounded act and recomputes the declared predicates over sealed evidence.

Article 02 built the evidence world: exact source revisions, confined parser views, served-content receipts, and server-cut ev_ handles. Article 03 connects it to Semantic Switch and the Evidence Instruction Set Architecture (EISA): protected computation first, deterministic constitutional judgment second.

Native data stays local. Semantic Switch powers protected qBlock candidates. EISA determines whether the resulting judgments are well-formed, evidence-contained, type-correct, and substantively consistent. The Room commits the result without executing it.

That last distinction matters. An operative EISA act is not a CRM merge, a file write, or a network effect. It is a recognized constitutional artifact entering the coordination and execution boundaries that Articles 04–08 govern.

One Constitution, Two Proof Lanes

EISA applies the same rule to two very different proposal classes:

                         sealed evidence world
                                  │
                    strict acts over one sealed case
                                  │
                    Four-Gate deterministic verdict
                       ┌──────────┴──────────┐
                       │                     │
              Proof Lane A            Proof Lane B
         PDF vector relations       Protected entity resolution
         CONNECTS only              Semantic Switch → qBlock →
         geometry + direction       Fracture → Forge → Shield
         frames + branch labels     identity + canonical state
                       └──────────┬──────────┘
                                  │
                  squad.eisa.submission/1 → eisa_<32hex>
                                  │
                   Room authority and fenced execution

The recognition spine is ev_ evidence → eisacase_ sealed case → bounded EISA_ACT_V1 acts → Four-Gate recognition → recognized artifact → immutable eisa_ Room submission. The two lanes demonstrate that spine in different evidence domains.

Lane A proves a narrow spatial relation from parser-committed geometry rather than asking a vision model to infer an arrow. Lane B turns native customer records into a protected comparison substrate, adjudicates identity relations, compiles canonical state, and defends the sealed baseline against later drift.

Naming precision: Forge names two related but distinct responsibilities. In Proof Lane A, eisa.forge.document_layout/1 is the wire profile for spatial AssertLayoutRelation acts. In Proof Lane B, EISA Forge is Stage 3 of the entity-resolution pipeline, compiling canonical state after Fracture admits an identity partition. The layout profile and the canonical-state compiler are not the same mechanism or proof surface.

The common rule is more important than either application: a proposal may not choose its own evidence world, suppress inconvenient matter, or narrate itself into authority.

1. Strict Representation Before Judgment

A grammar cannot govern a transition if two parsers can assign different meanings to the same bytes.

Gate 1 begins with strict::parse

EISA does not deserialize submissions through an ordinary last-key-wins JSON map. strict::parse drives a recursive StrictVisitor before schema evaluation:

  • visit_map checks whether each incoming key already exists and rejects duplicates.
  • visit_f64 refuses non-finite numbers.
  • de.end() rejects trailing non-whitespace matter after the root value.

A submission is capped at 1 MiB before parsing and must be a non-empty array of at most 256 acts. One submission belongs to one act family: Fracture contact acts or Forge layout acts, never a mixture.

This prevents a gateway from seeing one opcode while a downstream evaluator executes another. The August 2026 Ruby JSON vulnerability CVE-2026-71847 is a related warning about parser edge cases: incomplete objects containing duplicate keys could trigger a heap-use-after-free in the affected native parser. EISA's separate point is semantic—duplicate-key matter is ambiguous and therefore inadmissible, not repaired.

The exact ten-key act envelope

Every act contains all ten, and only ten, top-level fields in ACT_KEYS:

Field Current wire law
version Exactly EISA_ACT_V1
stage A declared stage whose family admits the opcode: Fracture or Forge
actor Must match the authenticated caller, case-insensitively
opcode One of the seven closed opcodes
operands An object with exactly the opcode's declared keys
evidenceRefs At most 16 strings naming Room-issued ev_ handles; layout relations require exactly the connector/from/to handles
confidence An empty object, or { "bps": integer } with 0 <= bps <= 10000; audit only
boundedReason A string of at most 1,024 characters, with control characters other than newline refused; audit only
sourceEvent Empty, or evt_<16 hex>_<8 hex>
artifactHash The sealed case's bare 64-lowercase-hex JCS digest; no sha256: prefix

confidence and boundedReason are not consulted by any gate and do not enter consensusIdentity. A model can explain itself for operators. It cannot make its explanation causal by declaring it confident.

Act IDs are local dependency names: a letter followed by up to 63 ASCII letters, digits, underscores, or hyphens. Duplicate IDs fault every act carrying the ambiguous name.

Record-relative RFC 6901 pointers

A Fracture BindEvidenceTag coordinate has exactly three fields:

{
  "artifact": "records",
  "recordId": "rec_101",
  "pointer": "/contact/workEmail"
}

The participant names the record and pointer. The recognizer reads the value. Coordinates never name a filesystem path, URL, case-array index, or foreign artifact.

pointer::parse enforces:

  • a leading /;
  • at most 256 bytes and eight tokens;
  • no whole-record empty pointer;
  • no control characters;
  • only RFC 6901 ~0 and ~1 escapes.

pointer::resolve then walks the sealed record. Object members must exist. Array indices use canonical decimal syntax—0 or a nonzero digit sequence without leading zeroes—and must be in bounds. Traversal into a scalar fails. Missing fields, malformed indices, and out-of-bounds access become typed faults rather than guessed values.

Comparator inputs are non-null, non-empty strings of at most 1,024 characters. Numbers, booleans, arrays, objects, nulls, and whitespace-only strings do not become comparator text through coercion.

The profile bounds

Constant Value Boundary
VERSION EISA_ACT_V1 Wire version
PROFILE eisa.fracture.contact/1 Contact act family
LAYOUT_PROFILE eisa.forge.document_layout/1 Layout act family
RECORDS_ARTIFACT records Only coordinate substrate
MAX_SUBMISSION_BYTES 1,048,576 Submission bytes
MAX_ACTS 256 Acts per submission
MAX_REASON_CHARS 1,024 boundedReason characters
MAX_ID_CHARS 64 Act and record ID ceiling
MAX_POINTER_BYTES 256 Pointer bytes
MAX_POINTER_DEPTH 8 Pointer tokens
MAX_VALUE_CHARS 1,024 Compared string characters
MAX_REFS 16 Evidence handles per act
MAX_LIST 1,000 Members, support, counter, and groups
MAX_CHAIN 4 Duplicate links per transitive chain
MAX_CASE_BYTES 4,194,304 Sealed case-file bytes
MAX_CASE_RECORDS 1,000 Records per case
MIN_PHONE_DIGITS 7 Minimum digits on each phone side

2. The Closed Grammar: Seven Opcodes, Four Layers

The opcode set is closed. New semantics cannot be introduced by sending a persuasive string.

Layer Opcode Stage Exact operand keys Constitutional role
0 BindEvidenceTag Fracture id, tag, coordinates Compare values at two distinct sealed-record coordinates using one positive or counter tag
0 RequestHumanReview Fracture id, reason, members Emit lawful non-operative review matter over at least one sealed record
0 RejectUnlawfulAct Fracture id, rejected, fault Preserve anti-knowledge rejecting a 64-hex matter identity or act digest under a registered fault
0 AssertLayoutRelation Forge id, relation, connector, from, to Prove CONNECTS over three sealed whole-node layout citations
1 AssertDuplicatePair Fracture id, pair, support, counter Link two records using admitted positive bindings and every admitted counter binding on that pair
2 AssertTransitiveClosure Fracture id, pair, chain Compose two to four admitted duplicate links into a simple path
3 ProposePartition Fracture id, groups, support Cover every sealed record exactly once with connected, non-contradicted groups

Dependencies point downward. Layer 0 observations feed Layer 1 pairs; Layer 1 pairs feed Layer 2 closure; Layers 1 and 2 support the Layer 3 partition. A missing, faulted, wrongly typed, cyclic, or pair-mismatched dependency cannot become support by being named confidently.

RequestHumanReview accepts only INSUFFICIENT_EVIDENCE, CONFLICTING_EVIDENCE, SOURCE_DEFECT, or OUT_OF_PROFILE. It records a review obligation; it does not assert that a human has acted. RejectUnlawfulAct validates the rejected identity's digest shape and fault class; it does not need to prove that the rejected target exists.

A submission cannot contain both an admitted terminal partition and an admitted review request. That is submission_mixed_decision, not a hedge with extra authority.

END OF §03 PART 1/6 — Next: https://blayneaina.com/03-eisa-four-gate-verdict-machine-and-entity-resolution/part-2/ · §03 1-Call Brief · Raw .md