Update app.js

app.js

@@ -1,8 +1,8 @@
-  /**
+/**
  * axl_dataset_server.js
  * ══════════════════════════════════════════════════════════════════════════════
  * AXL Dataset Generation Server (Node.js/Express version)
- * Generates UCE training samples via AWS Bedrock + synthetic math injection.
+ * Generates UCE training samples via AWS Bedrock + deep synthetic math injection.
  * Returns JSON for download. Tracks domain diversity across requests.
  * 
  * Endpoints:
@@ -70,7 +70,7 @@ const bedrockClient = new BedrockRuntimeClient({
 async function callBedrock(prompt, maxTokens = 18000) {
     const command = new ConverseCommand({
         modelId: BEDROCK_MODEL_ID,
-        messages: [{ role: "user", content: [{ text: prompt }] }],
+        messages:[{ role: "user", content: [{ text: prompt }] }],
         inferenceConfig: { 
             maxTokens: maxTokens, 
             temperature: 0.9,
@@ -112,12 +112,10 @@ encoder. AXL is what survives after domain is stripped away.
 Declares an abstraction level. Everything inside a scope inherits
 its level tag. Scopes are numbered — lower is more fundamental.
 
-
 SCOPE <name> [level: <int>]
   ...contents...
 END SCOPE
 
-
 Example levels (not hardcoded, user defined):
 - level 0 = most fundamental (quantum, bits)
 - level 1 = composed structures (atoms, bytes)
@@ -132,7 +130,6 @@ A thing that exists within a scope. Has fields, states, and
 existence conditions. An entity does not exist unless its
 REQUIRES clause is satisfied.
 
-
 ENTITY <name>
   FIELD <name>: <type> [BOUND <range>] [CONSERVES] [DISCRETE]
   STATE <name>: REQUIRES <condition>
@@ -140,7 +137,6 @@ ENTITY <name>
   DERIVES FROM <entity_list>
 END ENTITY
 
-
 **FIELD** — a measurable or logical property of the entity
 **CONSERVES** — this field cannot change across any TRANSFORM
 **DISCRETE** — field only takes integer or enumerated values
@@ -153,28 +149,24 @@ Axiom declaration. Taken as true without derivation.
 The foundation everything else builds on.
 Multiple ASSUMEs compound — all must hold simultaneously.
 
-
 ASSUME <statement>
 ASSUME <entity> EXISTS
 ASSUME <field> EQUALS <value>
 ASSUME <relationship> HOLDS
 
-
 ---
 
 ### 4. BOUND
 Hard constraint on a field or relationship.
 Nothing outside a BOUND can exist in this scope.
 
-
-BOUND <field> WITHIN [<min>, <max>]
+BOUND <field> WITHIN[<min>, <max>]
 BOUND <field> ABOVE <value>
 BOUND <field> BELOW <value>
 BOUND <field> EQUALS <value>          # exact, no freedom
-BOUND <entity> COUNT WITHIN [<min>, <max>]
+BOUND <entity> COUNT WITHIN[<min>, <max>]
 BOUND <a> FORBIDS <b>                 # mutual exclusion
 
-
 ---
 
 ### 5. TEND
@@ -182,27 +174,23 @@ Soft objective. The system pulls toward this but does not
 require it. Multiple TENDs create competing pressures that
 produce equilibrium — emergence happens here.
 
-
 TEND <field> MIN                      # pull toward minimum
 TEND <field> MAX                      # pull toward maximum
 TEND <field> TOWARD <value>           # pull toward specific value
 TEND <system> STABLE                  # resist perturbation
 TEND <field> FOLLOW <other_field>     # track another field
 
-
 ---
 
 ### 6. OBJECTIVE
 Hard optimization target. Unlike TEND, this must be satisfied
 for the scope to be considered resolved.
 
-
 OBJECTIVE <name>
   OPTIMIZE <field> [MIN | MAX | EQUAL <value>]
   SUBJECT TO <constraint_list>
 END OBJECTIVE
 
-
 ---
 
 ### 7. DERIVE
@@ -210,14 +198,12 @@ Declares that something follows necessarily from other things.
 If the sources hold, the derived thing must hold.
 This is the upward propagation engine.
 
-
 DERIVE <entity | field | state>
   FROM <source_list>
   WHEN <condition>
   BY <transform_name>
 END DERIVE
 
-
 ---
 
 ### 8. TRANSFORM
@@ -225,7 +211,6 @@ A process that maps one configuration to another.
 Transforms are the edges between scope levels.
 They must declare what they CONSERVE and what they CHANGE.
 
-
 TRANSFORM <name>
   INPUT <entity_or_field_list>
   OUTPUT <entity_or_field_list>
@@ -235,7 +220,6 @@ TRANSFORM <name>
   PRODUCES <postcondition>
 END TRANSFORM
 
-
 ---
 
 ### 9. OBSERVE
@@ -243,12 +227,10 @@ What has been measured. This is the B value in the UCE.
 The system will work backwards from this to find what
 configuration of unknowns is consistent with it.
 
-
 OBSERVE <field | entity | state> EQUALS <value>
 OBSERVE <field> WITHIN [<min>, <max>]
 OBSERVE <pattern> IN <output>
 
-
 ---
 
 ### 10. UNKNOWN
@@ -257,11 +239,9 @@ The system navigates the abstraction domain to find
 values of UNKNOWNs that satisfy all constraints
 given the OBSERVATIONs.
 
-
 UNKNOWN <name>: <type> BOUND [<min>, <max>]
 UNKNOWN <name>: DISCRETE WITHIN <set>
 
-
 ---
 
 ### 11. COLLAPSE
@@ -269,27 +249,23 @@ Instruction to reduce abstraction — find the most concrete
 configuration satisfying all active constraints.
 This is reverse abstraction in one word.
 
-
 COLLAPSE <scope | entity | system>
   GIVEN <observation_list>
   FIND <unknown_list>
   CONFIDENCE <threshold>
 END COLLAPSE
 
-
 ---
 
 ### 12. EXPAND
 Opposite of COLLAPSE. Given a concrete configuration,
 derive upward — what higher-level behaviors emerge?
 
-
 EXPAND <entity | configuration>
   THROUGH <scope_list>
   OBSERVE_EMERGENT <property_list>
 END EXPAND
 
-
 ---
 
 ### 13. CONTRADICT
@@ -298,12 +274,10 @@ Not an error — a scope boundary marker.
 Where contradictions appear is where the interesting
 physics, biology, and logic lives.
 
-
 CONTRADICT <statement_a> WITH <statement_b>
   AT SCOPE <level>
   BOUNDARY_TYPE [SCALE | SPEED | INFORMATION | ENERGY]
 
-
 ---
 
 ### 14. EMERGES
@@ -312,27 +286,23 @@ but appears when lower entities compose.
 Emergence is not reducible to its parts in AXL —
 it must be explicitly declared.
 
-
 EMERGES <property>
   FROM COMPOSITION OF <entity_list>
   AT SCOPE <level>
   NOT PRESENT AT SCOPE <lower_level>
 
-
 ---
 
 ### 15. COMPOSES
 Declares that an entity is built from other entities.
 Composition respects all lower-scope constraints.
 
-
 COMPOSES <higher_entity>
   FROM <lower_entity_list>
   BOUND count: <range>
   CONSERVING <field_list>
 END COMPOSES
 
-
 ---
 
 ### 16. STEP
@@ -340,41 +310,35 @@ Sequence counter for iterative or feedback processes.
 Enables the system to learn groups across attempts.
 Critical for the mining feedback loop.
 
-
 STEP <n>
   STATE <snapshot>
   CANDIDATE <configuration>
   DELTA <change_from_previous>
 END STEP
 
-
 ---
 
 ### 17. CANDIDATE
 A proposed solution configuration.
 Multiple candidates can coexist until COLLAPSE selects.
 
-
 CANDIDATE <n>
   <field>: <value>
   SCORE: <objective_value>
   CONFIDENCE: <float 0-1>
 END CANDIDATE
 
-
 ---
 
 ### 18. UNLESS
 Conditional override. Higher scope can override lower scope
 constraints under specific conditions.
 
-
 UNLESS <condition>
   OVERRIDE <constraint>
   WITH <replacement>
 END UNLESS
 
-
 ---
 
 ### 19. CONSERVES
@@ -382,643 +346,21 @@ Declares an invariant across the entire system regardless
 of what transforms occur. Conservation laws in physics,
 invariants in computation, conservation of mass — all CONSERVES.
 
-
 CONSERVES <quantity> ACROSS <transform_list>
 CONSERVES <quantity> WITHIN SCOPE <level>
 
-
 ---
 
 ### 20. SAMPLE
 A specific observed instance used as training signal
 for the diffusion engine. The raw material for learning.
 
-
 SAMPLE <id>
   INPUT <configuration>
   OUTPUT <observed_value>
   STEP <n>
 END SAMPLE
-
-
----
-
-## PART II — GRAMMAR RULES
-
-
-program         := scope_block+
-scope_block     := SCOPE name [level] body END SCOPE
-body            := statement*
-statement       := assume | entity | bound | tend | objective
-                 | derive | transform | observe | unknown
-                 | collapse | expand | contradict | emerges
-                 | composes | step | candidate | conserves
-                 | sample | unless
-
-condition       := field op value | entity EXISTS | state ACTIVE
-                 | condition AND condition | condition OR condition
-                 | NOT condition
-
-range           := [min, max] | {discrete_set}
-direction       := MIN | MAX | STABLE | TOWARD value | FOLLOW field
-type            := REAL | INTEGER | BOOLEAN | SYMBOLIC | VECTOR
-op              := EQUALS | ABOVE | BELOW | WITHIN | FORBIDS
-
-
----
-
-## PART III — DEMONSTRATIONS
-
----
-
-### DEMONSTRATION 1: THE ATOM
-#### Encoding atomic structure from quantum scope upward
-
-axl:
-# ════════════════════════════════════════════════════
-# ATOM SYSTEM
-# Starting assumption: energy exists and is quantized
-# ════════════════════════════════════════════════════
-
-SCOPE quantum [level: 0]
-
-  ASSUME energy EXISTS
-  ASSUME energy DISCRETE                    # quantization axiom
-  ASSUME charge EXISTS
-  CONSERVES charge ACROSS ALL_TRANSFORMS
-  CONSERVES energy ACROSS ALL_TRANSFORMS UNLESS transform EQUALS radiation
-
-  ENTITY quark
-    FIELD charge: REAL BOUND [-1, 1] DISCRETE VALUES {-2/3, -1/3, 1/3, 2/3}
-    FIELD color: SYMBOLIC DISCRETE VALUES {red, green, blue, antired, antigreen, antiblue}
-    FIELD mass: REAL BOUND [0.002, 4.5] # GeV
-    STATE free: REQUIRES energy ABOVE confinement_threshold
-    STATE confined: REQUIRES energy BELOW confinement_threshold
-    TENDS state TOWARD confined                # quarks want to be bound
-  END ENTITY
-
-  ENTITY gluon
-    FIELD charge: BOUND [0, 0] CONSERVES
-    FIELD color: SYMBOLIC                      # carries color charge
-    TENDS quark_binding MAX                    # gluons maximize binding
-  END ENTITY
-
-  BOUND quark COLOR_NEUTRAL IN any_free_composite  # color confinement
-
-END SCOPE
-
-
-SCOPE hadron [level: 1]
-
-  ASSUME quantum SCOPE HOLDS                  # inherit all quantum rules
-
-  COMPOSES proton
-    FROM quark COUNT EQUALS 3
-    CONFIGURATION {up, up, down}              # charge = 2/3+2/3-1/3 = +1
-    CONSERVING charge
-    BOUND total_charge EQUALS 1
-    BOUND color EQUALS neutral                # must be colorless
-  END COMPOSES
-
-  COMPOSES neutron
-    FROM quark COUNT EQUALS 3
-    CONFIGURATION {up, down, down}            # charge = 2/3-1/3-1/3 = 0
-    CONSERVING charge
-    BOUND total_charge EQUALS 0
-    BOUND color EQUALS neutral
-  END COMPOSES
-
-  EMERGES stability
-    FROM COMPOSITION OF {proton, neutron}
-    AT SCOPE hadron
-    NOT PRESENT AT SCOPE quantum
-    # individual quarks don't have nuclear stability — it emerges here
-
-END SCOPE
-
-
-SCOPE nucleus [level: 2]
-
-  ASSUME hadron SCOPE HOLDS
-
-  COMPOSES nucleus
-    FROM {proton, neutron}
-    BOUND proton_count WITHIN [1, 118]        # known elements
-    BOUND neutron_count WITHIN [0, 177]
-    TEND binding_energy MAX                   # nucleus maximizes binding
-    TEND neutron_to_proton_ratio TOWARD 1.0   # stability tendency
-  END COMPOSES
-
-  ENTITY strong_force
-    FIELD range: BOUND [0, 3e-15]             # femtometers — very short range
-    FIELD strength: REAL
-    TENDS nucleon_separation MIN              # pulls nucleons together
-  END ENTITY
-
-  ENTITY weak_force
-    TRANSFORMS neutron INTO proton
-    WHEN neutron_to_proton_ratio ABOVE stable_ratio
-    PRODUCES {proton, electron, antineutrino}  # beta decay
-    CONSERVING charge
-    CONSERVING lepton_number
-  END ENTITY
-
-  EMERGES atomic_number
-    FROM proton COUNT
-    AT SCOPE nucleus
-    # proton count alone determines element identity — pure emergence
-
-END SCOPE
-
-
-SCOPE atom [level: 3]
-
-  ASSUME nucleus SCOPE HOLDS
-
-  ENTITY electron
-    FIELD charge: BOUND [-1, -1] CONSERVES
-    FIELD mass: BOUND [9.109e-31, 9.109e-31] CONSERVES
-    FIELD spin: DISCRETE VALUES {-0.5, 0.5}
-    FIELD orbital: DISCRETE VALUES {s, p, d, f}
-    FIELD energy_level: INTEGER BOUND [1, 7]
-    TENDS energy MIN                          # electrons seek lowest energy
-    BOUND same_orbital_same_spin FORBIDS      # Pauli exclusion principle
-  END ENTITY
-
-  COMPOSES atom
-    FROM {nucleus, electron}
-    BOUND electron_count EQUALS proton_count  # neutral atom
-    TEND electron ORBITAL_FILL lowest_energy_first  # Aufbau principle
-  END COMPOSES
-
-  EMERGES chemical_behavior
-    FROM valence_electron_configuration
-    AT SCOPE atom
-    NOT PRESENT AT SCOPE nucleus
-    # chemistry is purely a scope 3 emergence — nucleus knows nothing of it
-
-  EMERGES periodic_properties
-    FROM atomic_number MODULO orbital_filling_pattern
-    AT SCOPE atom
-
-END SCOPE
-
-
-# ══ COLLAPSE EXAMPLE: Given observed spectral lines, find element ══
-
-OBSERVE spectral_emission EQUALS {656nm, 486nm, 434nm, 410nm}
-
-UNKNOWN element: SYMBOLIC WITHIN periodic_table
-UNKNOWN atomic_number: INTEGER BOUND [1, 118]
-UNKNOWN electron_configuration: VECTOR
-
-COLLAPSE atom
-  GIVEN {spectral_emission}
-  FIND {element, atomic_number, electron_configuration}
-  CONFIDENCE 0.95
-END COLLAPSE
-
-# Answer the system should derive: Hydrogen (Z=1)
-
-
----
-
-### DEMONSTRATION 2: SHA-256 MINING
-#### Encoding the constraint and the intelligent nonce search
-
-axl:
-# ════════════════════════════════════════════════════
-# SHA-256 BITCOIN MINING SYSTEM
-# Objective: find nonce such that hash < target
-# The system does not know what SHA-256 is.
-# It knows: there is a transform, it has an output,
-# the output must satisfy a bound.
-# ════════════════════════════════════════════════════
-
-SCOPE bitfield [level: 0]
-
-  ASSUME bit EXISTS
-  ASSUME bit DISCRETE VALUES {0, 1}
-  ENTITY bit_array
-    FIELD length: INTEGER
-    FIELD value: VECTOR of bit
-    BOUND value COUNT EQUALS length
-  END ENTITY
-
-END SCOPE
-
-
-SCOPE sha256_internals [level: 1]
-
-  ASSUME bitfield SCOPE HOLDS
-
-  ENTITY message_schedule
-    FIELD W: VECTOR COUNT EQUALS 64        # 64 32-bit words
-    DERIVES FROM input_block
-    BY expansion_transform
-  END ENTITY
-
-  TRANSFORM round_function
-    INPUT {working_vars: VECTOR COUNT 8, W_i: bit_array}
-    OUTPUT {working_vars_next: VECTOR COUNT 8}
-    CONSERVES bit_count
-    CHANGES working_vars
-    # 64 applications of this = full SHA-256
-    # Each application: sigma, choice, majority, mod add
-    # AXL does not encode the arithmetic — that's the domain encoder's job
-    # AXL encodes only: this is a deterministic transform with known structure
-  END TRANSFORM
-
-  CONTRADICT input_a WITH input_b
-    AT SCOPE sha256_internals
-    BOUNDARY_TYPE INFORMATION
-    # Two different inputs CAN produce same output (collision)
-    # But finding one is computationally infeasible
-    # This contradiction is the security boundary
-
-  TRANSFORM sha256
-    INPUT {message: bit_array BOUND length WITHIN [0, 2^64]}
-    OUTPUT {digest: bit_array BOUND length EQUALS 256}
-    CONSERVES nothing                       # one-way: no conservation
-    CHANGES everything                      # avalanche: all output bits affected
-    REQUIRES input EXISTS
-    PRODUCES digest PSEUDO_RANDOM_FROM input
-    # PSEUDO_RANDOM_FROM is the key declaration:
-    # output is deterministic but statistically independent of input structure
-  END TRANSFORM
-
-END SCOPE
-
-
-SCOPE block_header [level: 2]
-
-  ASSUME sha256_internals SCOPE HOLDS
-
-  ENTITY block_header
-    FIELD version: INTEGER BOUND [1, 4]
-    FIELD prev_hash: bit_array BOUND length EQUALS 256   # GIVEN, fixed
-    FIELD merkle_root: bit_array BOUND length EQUALS 256 # GIVEN, fixed
-    FIELD timestamp: INTEGER                              # GIVEN, approximately fixed
-    FIELD bits: INTEGER                                   # GIVEN, encodes target
-    FIELD nonce: INTEGER BOUND [0, 4294967295]           # UNKNOWN — 32 bits of freedom
-  END ENTITY
-
-  DERIVE target
-    FROM bits
-    BY difficulty_decode_transform
-    # target = a 256-bit number. Valid hash must be below it.
-    # More leading zeros in target = harder problem
-
-END SCOPE
-
-
-SCOPE mining [level: 3]
-
-  ASSUME block_header SCOPE HOLDS
-
-  TRANSFORM double_sha256
-    INPUT {block_header}
-    OUTPUT {hash: bit_array BOUND length EQUALS 256}
-    BY {sha256 APPLIED_TWICE}
-  END TRANSFORM
-
-  OBJECTIVE valid_block
-    OPTIMIZE hash MIN                        # minimize hash value numerically
-    SUBJECT TO hash BELOW target             # hard bound — must be satisfied
-    SUBJECT TO nonce WITHIN [0, 4294967295]
-  END OBJECTIVE
-
-  # ══ HERE IS THE INTELLIGENCE LAYER ══
-  # The nonce space has NO smooth gradient (SHA-256 destroys it)
-  # But the SEARCH SPACE has learnable structure:
-  # - which regions have been explored (coverage)
-  # - step count gives sequence context
-  # - candidate scoring gives relative ranking
-  # This is what the UCE learns — not the hash, but the search
-
-  UNKNOWN nonce: INTEGER BOUND [0, 4294967295]
-
-  STEP 0
-    STATE {nonce_space: unexplored}
-    CANDIDATE 0
-      nonce: SAMPLE uniform
-      SCORE: UNKNOWN
-      CONFIDENCE: 0.0
-    END CANDIDATE
-  END STEP
-
-  STEP N
-    STATE {
-      explored_regions: VECTOR,              # coverage map
-      best_hash_so_far: bit_array,
-      distance_to_target: INTEGER,
-      step_count: N
-    }
-    CANDIDATE 0..50                          # 50 parallel candidates
-      nonce: DERIVES FROM {
-        explored_regions,
-        step_count,
-        best_hash_so_far
-      }
-      # The system learns: given search history,
-      # what nonce regions have NOT been tried
-      # and which historically neighboring regions
-      # produced closer hashes (within this block's structure)
-      SCORE: distance_to_target MIN
-      CONFIDENCE: LEARNS
-    END CANDIDATE
-  END STEP
-
-  OBSERVE hash BELOW target                  # this is the termination condition
-
-  COLLAPSE mining
-    GIVEN {block_header_fixed_fields, target, search_history}
-    FIND {nonce}
-    CONFIDENCE 0.99
-  END COLLAPSE
-
-  # ══ WHAT THE SYSTEM LEARNS ══
-  # Not: how to reverse SHA-256
-  # But: how to cover the nonce space intelligently
-  # avoiding redundant regions, clustering search
-  # around previously productive neighborhoods
-  # The intelligence is in the search, not the hash
-
-END SCOPE
-
-
----
-
-### DEMONSTRATION 3: CELL DIVISION (MITOSIS)
-#### Encoding life as constraint satisfaction
-
-axl:
-# ════════════════════════════════════════════════════
-# CELL DIVISION SYSTEM
-# Life as constraints on information replication
-# with error correction and state machines
-# ════════════════════════════════════════════════════
-
-SCOPE molecular [level: 0]
-
-  ASSUME molecule EXISTS
-  ASSUME information CAN BE ENCODED IN molecule
-  ASSUME chemical_bond EXISTS
-  CONSERVES atom_count ACROSS chemical_reactions
-  CONSERVES charge ACROSS chemical_reactions
-
-  ENTITY nucleotide
-    FIELD base: SYMBOLIC DISCRETE VALUES {adenine, thymine, guanine, cytosine}
-    FIELD sugar: SYMBOLIC EQUALS deoxyribose
-    FIELD phosphate: BOOLEAN
-    BOUND adenine PAIRS_WITH thymine ONLY      # base pairing rule
-    BOUND guanine PAIRS_WITH cytosine ONLY
-  END ENTITY
-
-  ENTITY dna_strand
-    FIELD sequence: VECTOR of nucleotide
-    FIELD length: INTEGER BOUND [1, 3e9]       # up to 3 billion base pairs
-    FIELD direction: SYMBOLIC DISCRETE VALUES {5_to_3, 3_to_5}
-    CONSERVES sequence UNLESS transform EQUALS mutation
-    TENDS base_pair_bonds STABLE               # double helix stability
-  END ENTITY
-
-  TRANSFORM base_pairing
-    INPUT {strand_a: dna_strand, strand_b: dna_strand}
-    OUTPUT {double_helix}
-    REQUIRES strand_a.direction FORBIDS strand_b.direction  # antiparallel
-    REQUIRES each_base PAIRS_WITH complement
-    CONSERVES sequence_information
-  END TRANSFORM
-
-END SCOPE
-
-
-SCOPE genome [level: 1]
-
-  ASSUME molecular SCOPE HOLDS
-
-  ENTITY chromosome
-    FIELD dna: dna_strand
-    FIELD histone_proteins: VECTOR
-    FIELD centromere_position: INTEGER
-    FIELD telomere_length: INTEGER BOUND [0, 15000]  # erosion limit
-    TENDS compaction MAX WHEN cell_dividing EQUALS true
-    TENDS compaction MIN WHEN cell_active EQUALS true
-  END ENTITY
-
-  ENTITY genome
-    FIELD chromosomes: VECTOR of chromosome
-    BOUND chromosome_count EQUALS 46          # human diploid — pairs of 23
-    CONSERVES chromosome_count UNLESS transform EQUALS meiosis
-    TENDS integrity MAX                       # genome resists damage
-  END ENTITY
-
-  ENTITY dna_polymerase
-    FIELD error_rate: REAL BOUND [1e-9, 1e-9] # one error per billion bases
-    TENDS accuracy MAX
-    TRANSFORMS dna_strand INTO dna_strand_copy
-    CONSERVES sequence UNLESS error_rate TRIGGERS
-  END ENTITY
-
-  EMERGES genetic_code
-    FROM nucleotide_triplet_sequence
-    AT SCOPE genome
-    NOT PRESENT AT SCOPE molecular
-    # individual nucleotides have no meaning — codons emerge at this level
-
-END SCOPE
-
-
-SCOPE cell [level: 2]
-
-  ASSUME genome SCOPE HOLDS
-
-  ENTITY cell
-    FIELD genome: genome
-    FIELD membrane: BOOLEAN EQUALS true        # boundary condition
-    FIELD atp_level: REAL BOUND [0, 1]         # energy state
-    FIELD size: REAL BOUND [minimum_viable, maximum_before_division]
-    FIELD age: INTEGER                         # division counter
-    FIELD state: SYMBOLIC DISCRETE VALUES {
-      G1,                                      # growth phase 1
-      S,                                       # synthesis (DNA replication)
-      G2,                                      # growth phase 2
-      M,                                       # mitosis (division)
-      G0,                                      # quiescent (resting)
-      apoptosis                                # programmed death
-    }
-    TENDS atp_level MAX                        # cells maximize energy
-    TENDS genome_integrity MAX                 # cells protect DNA
-    BOUND age BELOW hayflick_limit             # telomere erosion limit
-  END ENTITY
-
-  ENTITY checkpoint_protein
-    FIELD name: SYMBOLIC DISCRETE VALUES {p53, rb, cyclin_B, cdk1}
-    FIELD active: BOOLEAN
-    TENDS genome_damage OBSERVE                # monitors DNA integrity
-    TRANSFORMS cell.state INTO apoptosis
-      WHEN genome_damage ABOVE repair_threshold
-    # p53 is the key constraint enforcer — if damage is too great, die
-  END ENTITY
-
-END SCOPE
-
-
-SCOPE mitosis [level: 3]
-
-  ASSUME cell SCOPE HOLDS
-
-  # ══ TRIGGER CONDITIONS ══
-  # Cell division is itself a constraint satisfaction problem:
-  # divide WHEN AND ONLY WHEN all conditions hold
-
-  OBJECTIVE division_trigger
-    OPTIMIZE cell.state EQUAL M
-    SUBJECT TO {
-      cell.size ABOVE division_threshold,
-      cell.atp_level ABOVE 0.7,
-      dna_replication EQUALS complete,
-      checkpoint_all EQUALS passed,
-      external_growth_signal EQUALS present,
-      cell.age BELOW hayflick_limit
-    }
-    # ALL conditions must hold — AND logic, not OR
-    # This is why cancer is a constraint violation:
-    # it occurs when checkpoint constraints are BROKEN
-  END OBJECTIVE
-
-  TRANSFORM prophase
-    INPUT {cell: STATE G2}
-    OUTPUT {cell: chromosomes_condensed, spindle_forming}
-    REQUIRES division_trigger EQUALS satisfied
-    CONSERVES chromosome_count
-    CONSERVES genome_content
-  END TRANSFORM
-
-  TRANSFORM metaphase
-    INPUT {cell: chromosomes_condensed}
-    OUTPUT {cell: chromosomes_aligned_at_plate}
-    REQUIRES spindle_attached_to EQUALS all_chromosomes
-    # Checkpoint: spindle assembly checkpoint
-    # If any chromosome unattached — PAUSE here
-    BOUND unattached_chromosomes EQUALS 0
-      UNLESS OVERRIDE apoptosis
-  END TRANSFORM
-
-  TRANSFORM anaphase
-    INPUT {cell: chromosomes_aligned}
-    OUTPUT {sister_chromatids: separating}
-    CONSERVES chromosome_count_total
-    CHANGES chromosome_location
-    PRODUCES two_sets OF 46_chromosomes
-  END TRANSFORM
-
-  TRANSFORM telophase_and_cytokinesis
-    INPUT {cell: chromatids_separated}
-    OUTPUT {daughter_cell_1, daughter_cell_2}
-    CONSERVES genome_content IN each_daughter
-    CONSERVES organelle_distribution APPROXIMATELY
-    PRODUCES {
-      daughter_cell_1: IDENTICAL_GENOME_TO parent,
-      daughter_cell_2: IDENTICAL_GENOME_TO parent
-    }
-  END TRANSFORM
-
-  EMERGES tissue
-    FROM COMPOSITION OF {cell COUNT ABOVE 1}
-    AT SCOPE mitosis
-    NOT PRESENT AT SCOPE cell
-    # individual cells have no tissue identity — it emerges from composition
-
-  EMERGES cancer
-    FROM checkpoint_protein.active EQUALS false
-      AND division_trigger SATISFIED_WITHOUT all_conditions
-    AT SCOPE mitosis
-    # Cancer is not a new thing — it is constraint violation
-    # The cell divides when it should not because the objective
-    # function has been corrupted
-    CONTRADICT cancer WITH normal_division
-      AT SCOPE mitosis
-      BOUNDARY_TYPE INFORMATION           # corrupted information in genome
-
-  # ══ COLLAPSE EXAMPLE: Cancer diagnosis ══
-
-  OBSERVE {
-    cell.division_rate ABOVE normal_range,
-    checkpoint_protein.p53 EQUALS inactive,
-    cell.age ABOVE hayflick_limit
-  }
-
-  UNKNOWN {
-    mutation_site: dna_strand LOCATION,
-    checkpoint_broken: SYMBOLIC,
-    division_trigger_violated: OBJECTIVE_CLAUSE
-  }
-
-  COLLAPSE mitosis
-    GIVEN {abnormal_observations}
-    FIND {mutation_site, checkpoint_broken, division_trigger_violated}
-    CONFIDENCE 0.90
-  END COLLAPSE
-
-END SCOPE
-
-
-# ════════════════════════════════════════════════════
-# META: THE LANGUAGE DESCRIBING ITSELF
-# AXL encoding its own structure
-# ════════════════════════════════════════════════════
-
-SCOPE axl_meta [level: 0]
-
-  ASSUME symbol EXISTS
-  ASSUME symbol CAN CARRY meaning
-  ASSUME meaning IS RELATIVE TO scope
-
-  ENTITY keyword
-    FIELD token: SYMBOLIC
-    FIELD semantic: SYMBOLIC
-    FIELD abstraction_direction: DISCRETE VALUES {up, down, both, none}
-    FIELD arity: INTEGER                      # how many arguments it takes
-  END ENTITY
-
-  ENTITY statement
-    FIELD keywords: VECTOR of keyword
-    FIELD scope_level: INTEGER
-    DERIVES meaning FROM {keywords, scope_level, context}
-    # Same token, different scope = different meaning
-    # BOUND in scope 0 (physics) ≠ BOUND in scope 3 (biology)
-  END ENTITY
-
-  EMERGES program_meaning
-    FROM COMPOSITION OF {statement COUNT ABOVE 1}
-    AT SCOPE axl_meta
-    NOT PRESENT AT SCOPE symbol
-    # Individual symbols have no program meaning
-    # Meaning emerges from composition and scope
-
-  TEND expressiveness MAX
-  TEND ambiguity MIN
-  CONTRADICT expressiveness WITH ambiguity
-    AT SCOPE axl_meta
-    BOUNDARY_TYPE INFORMATION
-    # All languages face this — AXL resolves it via scope tagging
-
-END SCOPE
-
----
-
-## PART IV — DESIGN NOTES
-**On contradictions:**
-Every CONTRADICT in these examples marks a real scientific boundary:
-- quantum/classical = scale boundary
-- cancer/normal = information boundary
-- expressiveness/ambiguity = the language's own limit
-
-These are features, not bugs.
-
-`; // USER: replace in prod
+`;
 
 const SYSTEM_PROMPT_HEADER = `You are a dataset generator for the Universal Constraint Engine (UCE),
 a domain-agnostic constraint satisfaction and optimization system.
@@ -1097,12 +439,13 @@ function _safeNorm(bRaw) {
     if (!isFinite(bRaw) || isNaN(bRaw)) return 0.0;
     return sign(bRaw) * Math.log1p(Math.abs(bRaw)) / SCALE_K;
 }
+const fmt6 = (v) => Number(v.toFixed(6));
+const fmt8 = (v) => Number(v.toFixed(8));
 
 // ── SYNTHETIC INJECTORS ─────────────────────────────────────────────────────
 function synthPhysicsSamples(n) {
     let samples = [];
-    const templates = [["Kinetic Energy", c => 0.5 * (c[0]*100) * Math.pow(c[1]*50, 2), [[0.01,1], [0.01,1]], "Joules"],["Ohm's Law Power", c => Math.pow(c[0]*240, 2) / (c[1]*1000 + 0.001), [[0.01,1],[0.01,1]], "Watts"],
-        ["Gravitational PE", c => (c[0]*100) * 9.81 * (c[1]*100), [[0.01,1],[0.01,1]], "Joules"],
+    const templates = [["Kinetic Energy", c => 0.5 * (c[0]*100) * Math.pow(c[1]*50, 2), [[0.01,1],[0.01,1]], "Joules"],["Ohm's Law Power", c => Math.pow(c[0]*240, 2) / (c[1]*1000 + 0.001), [[0.01,1],[0.01,1]], "Watts"],["Gravitational PE", c => (c[0]*100) * 9.81 * (c[1]*100), [[0.01,1],[0.01,1]], "Joules"],
         ["Ideal Gas PV=nRT", c => ((c[0]*10)*(c[1]*100))/((c[2]*5+0.1)*8.314), [[0.01,1],[0.01,1],[0.01,1]], "Kelvin"],["Wave Frequency", c => (c[0]*1e8) / (c[1]*10+0.001), [[0.01,1],[0.01,1]], "Hz"],["Snell Refraction", c => ((c[0]*2+1)*Math.sin(c[1]*1.5)) / ((c[2]*2+1)+0.001), [[0.01,1],[0.01,1],[0.01,1]], "dim-less"],["Centripetal Accel", c => Math.pow(c[0]*50, 2)/(c[1]*10+0.001), [[0.01,1],[0.01,1]], "m/s²"],
         ["Doppler Shift", c => (c[0]*1000)*(1+(c[1]*50)/(340+0.001)), [[0.01,1],[0.01,1]], "Hz"]
     ];
@@ -1131,7 +474,7 @@ function synthPhysicsSamples(n) {
 }
 
 function synthFinanceSamples(n) {
-    let samples = [];
+    let samples =[];
     const kinds =["compound_interest", "loan_payment", "portfolio_return", "options_delta"];
     
     for (let i = 0; i < n; i++) {
@@ -1149,7 +492,7 @@ function synthFinanceSamples(n) {
                 let ret =[rnd(0.02, 0.25), rnd(0.02, 0.25), rnd(0.02, 0.25)];
                 bRaw = w[0]*ret[0] + w[1]*ret[1] + w[2]*ret[2]; cVals = w; desc = `Portfolio weighted return: ${bRaw.toFixed(4)}`;
             } else {
-                let S = rnd(50, 500), K = rnd(50, 500); bRaw = Math.max(0, S - K); cVals = [S/500, K/500]; desc = `Option intrinsic value: ${bRaw.toFixed(2)}`;
+                let S = rnd(50, 500), K = rnd(50, 500); bRaw = Math.max(0, S - K); cVals =[S/500, K/500]; desc = `Option intrinsic value: ${bRaw.toFixed(2)}`;
             }
             if (!isFinite(bRaw) || isNaN(bRaw)) continue;
             let nVars = cVals.length;
@@ -1166,38 +509,658 @@ function synthFinanceSamples(n) {
     return samples;
 }
 
-function synthCipherSamples(n) {
-    let samples = [];
-    const kinds =["caesar","vigenere_2","vigenere_4","affine","xor_byte"];
-    
-    for (let i=0; i<n; i++) {
-        let kind = randchoice(kinds);
-        try {
-            let bRaw, cVals, desc;
-            if (kind === "caesar") {
-                let shift = randint(0,25), p = randint(0,25); bRaw = (p+shift)%26; cVals = [shift/25.0]; desc = `Caesar shift=${shift} plain=${p} → ${bRaw|0}`;
-            } else if (kind === "vigenere_2") {
-                let k =[randint(0,25), randint(0,25)], p = [randint(0,25), randint(0,25)];
-                bRaw = ((p[0]+k[0])%26) + ((p[1]+k[1])%26); cVals =[k[0]/25.0, k[1]/25.0]; desc = `Vig2 key=${k}`;
-            } else if (kind === "vigenere_4") {
-                let k =[randint(0,25),randint(0,25),randint(0,25),randint(0,25)], p =[randint(0,25),randint(0,25),randint(0,25),randint(0,25)];
-                bRaw = k.reduce((acc, _, idx) => acc + ((p[idx]+k[idx])%26), 0); cVals = k.map(v=>v/25.0); desc = `Vig4 key=${k}`;
-            } else if (kind === "affine") {
-                let valid_a =[1,3,5,7,9,11,15,17,19,21,23,25], a_idx = randint(0,11); let a = valid_a[a_idx], b = randint(0,25), p = randint(0,25);
-                bRaw = (a*p+b)%26; cVals =[a_idx/11.0, b/25.0]; desc = `Affine a=${a} b=${b} plain=${p}`;
-            } else {
-                let key = randint(0,255), plain = randint(0,255); bRaw = plain ^ key; cVals =[key/255.0]; desc = `XOR key=${key} p=${plain} → ${bRaw|0}`;
+// ─────────────────────────────────────────────────────────────────────────────
+// CRYPTO INJECTORS (DEEP AXL)
+// ─────────────────────────────────────────────────────────────────────────────
+function synthXorSamples(n) {
+    const samples =[];
+    for (let i = 0; i < n; i++) {
+        const key   = randint(0, 255);
+        const plain = randint(0, 255);
+        const cipher = key ^ plain;
+        const cVal   = fmt6(key / 255.0);
+        const bRaw   = cipher;
+
+        const keyBits   = Array.from({length:8}, (_,b) => (key   >> (7-b)) & 1);
+        const plainBits = Array.from({length:8}, (_,b) => (plain >> (7-b)) & 1);
+        const outBits   = keyBits.map((kb, b) => kb ^ plainBits[b]);
+
+        const bitEntities = Array.from({length:8}, (_,b) =>
+            `  ENTITY bit_${b}\n` +
+            `    FIELD key_bit:   DISCRETE VALUES {0, 1} EQUALS ${keyBits[b]}\n` +
+            `    FIELD plain_bit: DISCRETE VALUES {0, 1} EQUALS ${plainBits[b]}\n` +
+            `    FIELD out_bit:   DISCRETE VALUES {0, 1}\n` +
+            `    DERIVES out_bit FROM {key_bit, plain_bit} BY xor_gate\n` +
+            `  END ENTITY`
+        ).join("\n");
+
+        const axl = [
+            `SCOPE xor_bit_level[level: 0]`,
+            `  ASSUME bit EXISTS`,
+            `  ASSUME bit DISCRETE VALUES {0, 1}`,
+            ``,
+            `  TRANSFORM xor_gate`,
+            `    INPUT  {a: bit, b: bit}`,
+            `    OUTPUT {out: bit}`,
+            `    PRODUCES 0 WHEN a EQUALS b`,
+            `    PRODUCES 1 WHEN a NOT_EQUALS b`,
+            `  END TRANSFORM`,
+            ``,
+            bitEntities,
+            `END SCOPE`,
+            ``,
+            `SCOPE xor_byte_level [level: 1]`,
+            `  ASSUME xor_bit_level SCOPE HOLDS`,
+            ``,
+            `  ENTITY byte_assembler`,
+            `    FIELD value: INTEGER BOUND[0, 255]`,
+            `    DERIVES value FROM {bit_7..bit_0} BY binary_weighted_sum`,
+            `  END ENTITY`,
+            ``,
+            `  CONSERVES bit_count ACROSS binary_weighted_sum`,
+            ``,
+            `  ENTITY key_byte`,
+            `    FIELD raw:        INTEGER BOUND [0, 255]`,
+            `    FIELD normalised: REAL    BOUND[0, 1]`,
+            `    DERIVES normalised FROM raw BY divide_255`,
+            `  END ENTITY`,
+            ``,
+            `  ENTITY plain_byte`,
+            `    FIELD raw: INTEGER BOUND [0, 255] EQUALS ${plain}`,
+            `  END ENTITY`,
+            ``,
+            `  ENTITY cipher_byte`,
+            `    FIELD raw: INTEGER BOUND[0, 255]`,
+            `    DERIVES raw FROM {key_byte.raw, plain_byte.raw} BY xor_byte_transform`,
+            `  END ENTITY`,
+            ``,
+            `  TRANSFORM xor_byte_transform`,
+            `    INPUT  {key: INTEGER BOUND[0,255], plain: INTEGER BOUND [0,255]}`,
+            `    OUTPUT {cipher: INTEGER BOUND [0,255]}`,
+            `    CONSERVES nothing`,
+            `    CHANGES cipher`,
+            `    PRODUCES cipher = key XOR plain  # applied bit-by-bit via xor_gate`,
+            `  END TRANSFORM`,
+            ``,
+            `  OBSERVE cipher_byte.raw EQUALS ${cipher}`,
+            `  UNKNOWN key_byte.normalised: REAL BOUND [0, 1]`,
+            ``,
+            `  COLLAPSE xor_byte_level`,
+            `    GIVEN cipher_byte.raw`,
+            `    FIND  key_byte.normalised`,
+            `    CONFIDENCE 0.99`,
+            `  END COLLAPSE`,
+            `END SCOPE`,
+        ].join("\n");
+
+        samples.push({
+            id:         crypto.randomUUID(),
+            domain:     "cryptography",
+            subdomain:  "xor_byte",
+            sense:      "EQUAL",
+            n_vars:     1,
+            vars_text:  "VARS c0 IN [0 1]",
+            expr_text:  `EXPR XOR plain=${plain} cipher=${cipher} key=UNKNOWN`,
+            sense_text: "SENSE EQUAL",
+            b_raw:      fmt6(bRaw),
+            b_norm:     fmt8(_safeNorm(bRaw)),
+            c_values:   [cVal],
+            mask:       [1],
+            candidates:[],
+            step_count: 0,
+            axl_source: axl,
+            metadata: {
+                description:      `XOR byte cipher: plain=${plain} key=${key} → cipher=${cipher}`,
+                units:            "character_code",
+                difficulty:       "medium",
+                scope_depth:      2,
+                has_emergence:    false,
+                has_contradiction: true,
+                key_bits:         keyBits,
+                plain_bits:       plainBits,
+                out_bits:         outBits,
             }
-            let nVars = cVals.length;
-            samples.push({
-                id: crypto.randomUUID(), domain: "cryptography", subdomain: kind, sense: "EQUAL", n_vars: nVars,
-                vars_text: "VARS " + cVals.map((_, j) => `c${j} IN [0 1]`).join(" "), expr_text: `EXPR CIPHER_${kind.toUpperCase()}`,
-                sense_text: "SENSE EQUAL", b_raw: bRaw, b_norm: Number(_safeNorm(bRaw).toFixed(8)), c_values: cVals.map(v => Number(v.toFixed(6))),
-                mask:[...Array(nVars).fill(1), ...Array(Math.max(0, 4 - nVars)).fill(0)], candidates:[], step_count: 0,
-                axl_source: `SCOPE cryptography [level: 1]\n  OBSERVE ${kind} EQUALS ${bRaw}\n  UNKNOWN key: VECTOR BOUND [0,1]\nEND SCOPE`,
-                metadata: { description: desc, units: "character_code", difficulty: nVars<=2?"medium":"hard", scope_depth: 1, has_emergence: false, has_contradiction: true }
-            });
-        } catch (e) {}
+        });
+    }
+    return samples;
+}
+
+function synthCaesarSamples(n) {
+    const samples =[];
+    for (let i = 0; i < n; i++) {
+        const msgLen = randint(1, 4);
+        const shift  = randint(0, 25);
+        const plains = Array.from({length: msgLen}, () => randint(0, 25));
+        const ciphers = plains.map(p => (p + shift) % 26);
+        const cVal  = fmt6(shift / 25.0);
+        const bRaw  = ciphers.reduce((a, b) => a + b, 0);
+
+        const charEntities = plains.map((p, idx) =>
+            `  ENTITY char_${idx}\n` +
+            `    FIELD plaintext:  INTEGER DISCRETE VALUES {0..25} EQUALS ${p}\n` +
+            `    FIELD ciphertext: INTEGER DISCRETE VALUES {0..25}\n` +
+            `    DERIVES ciphertext FROM {plaintext, shift} BY caesar_transform\n` +
+            `  END ENTITY`
+        ).join("\n");
+
+        const axl = [
+            `SCOPE alphabet_ring [level: 0]`,
+            `  ASSUME integer EXISTS`,
+            `  ASSUME modular_arithmetic HOLDS`,
+            ``,
+            `  ENTITY alphabet`,
+            `    FIELD size: INTEGER EQUALS 26`,
+            `    FIELD symbols: DISCRETE VALUES {a=0, b=1, c=2, ..., z=25}`,
+            `    BOUND any_char WITHIN [0, 25]`,
+            `  END ENTITY`,
+            ``,
+            `  TRANSFORM modular_add`,
+            `    INPUT  {a: INTEGER, b: INTEGER, mod: INTEGER}`,
+            `    OUTPUT {result: INTEGER}`,
+            `    PRODUCES result = (a + b) % mod`,
+            `    CONSERVES mod`,
+            `  END TRANSFORM`,
+            `END SCOPE`,
+            ``,
+            `SCOPE caesar_char [level: 1]`,
+            `  ASSUME alphabet_ring SCOPE HOLDS`,
+            ``,
+            `  TRANSFORM caesar_transform`,
+            `    INPUT  {plaintext: INTEGER BOUND [0,25], shift: INTEGER BOUND [0,25]}`,
+            `    OUTPUT {ciphertext: INTEGER BOUND [0,25]}`,
+            `    PRODUCES ciphertext = modular_add(plaintext, shift, 26)`,
+            `    CONSERVES alphabet_size`,
+            `    CHANGES  character_identity`,
+            `  END TRANSFORM`,
+            ``,
+            `  ENTITY shift_key`,
+            `    FIELD raw:        INTEGER BOUND [0, 25]`,
+            `    FIELD normalised: REAL    BOUND [0, 1]`,
+            `    DERIVES normalised FROM raw BY divide_25`,
+            `  END ENTITY`,
+            ``,
+            charEntities,
+            `END SCOPE`,
+            ``,
+            `SCOPE caesar_message [level: 2]`,
+            `  ASSUME caesar_char SCOPE HOLDS`,
+            ``,
+            `  ENTITY message`,
+            `    FIELD plaintext:  VECTOR OF INTEGER  EQUALS [${plains.join(", ")}]`,
+            `    FIELD ciphertext: VECTOR OF INTEGER`,
+            `    FIELD length:     INTEGER EQUALS ${msgLen}`,
+            `    DERIVES ciphertext FROM {plaintext, shift_key.raw} BY caesar_transform APPLIED_TO_EACH`,
+            `  END ENTITY`,
+            ``,
+            `  OBSERVE message.ciphertext EQUALS [${ciphers.join(", ")}]`,
+            `  OBSERVE SUM(message.ciphertext) EQUALS ${bRaw}`,
+            `  UNKNOWN shift_key.normalised: REAL BOUND [0, 1]`,
+            ``,
+            `  COLLAPSE caesar_message`,
+            `    GIVEN {message.plaintext, SUM(message.ciphertext)}`,
+            `    FIND  shift_key.normalised`,
+            `    CONFIDENCE 0.99`,
+            `  END COLLAPSE`,
+            `END SCOPE`,
+        ].join("\n");
+
+        samples.push({
+            id:         crypto.randomUUID(),
+            domain:     "cryptography",
+            subdomain:  "caesar",
+            sense:      "EQUAL",
+            n_vars:     1,
+            vars_text:  "VARS c0 IN [0 1]",
+            expr_text:  `EXPR CAESAR plains=[${plains}] ciphers=[${ciphers}] shift=UNKNOWN`,
+            sense_text: "SENSE EQUAL",
+            b_raw:      fmt6(bRaw),
+            b_norm:     fmt8(_safeNorm(bRaw)),
+            c_values:   [cVal],
+            mask:       [1],
+            candidates:[],
+            step_count: 0,
+            axl_source: axl,
+            metadata: {
+                description:      `Caesar cipher: shift=${shift} plains=[${plains}] → ciphers=[${ciphers}]`,
+                units:            "character_code_sum",
+                difficulty:       msgLen > 1 ? "medium" : "easy",
+                scope_depth:      3,
+                has_emergence:    false,
+                has_contradiction: true,
+            }
+        });
+    }
+    return samples;
+}
+
+function synthVigenereSamples(n) {
+    const samples =[];
+    for (let i = 0; i < n; i++) {
+        const keyLen = randint(2, 5);
+        const key    = Array.from({length: keyLen}, () => randint(0, 25));
+        const plain  = Array.from({length: keyLen}, () => randint(0, 25));
+        const cipher = plain.map((p, idx) => (p + key[idx]) % 26);
+        const bRaw   = cipher.reduce((a, b) => a + b, 0);
+        const cVals  = key.map(k => fmt6(k / 25.0));
+
+        const posEntities = plain.map((p, idx) =>
+            `  ENTITY position_${idx}\n` +
+            `    FIELD plaintext:  INTEGER EQUALS ${p}\n` +
+            `    FIELD key_char:   INTEGER BOUND [0, 25]  # UNKNOWN\n` +
+            `    FIELD ciphertext: INTEGER BOUND [0, 25]\n` +
+            `    DERIVES ciphertext FROM {plaintext, key_char} BY modular_add_26\n` +
+            `  END ENTITY`
+        ).join("\n");
+
+        const axl =[
+            `SCOPE alphabet_ring [level: 0]`,
+            `  ASSUME integer EXISTS`,
+            `  TRANSFORM modular_add_26`,
+            `    INPUT  {a: INTEGER BOUND[0,25], b: INTEGER BOUND [0,25]}`,
+            `    OUTPUT {result: INTEGER BOUND [0,25]}`,
+            `    PRODUCES result = (a + b) % 26`,
+            `  END TRANSFORM`,
+            `END SCOPE`,
+            ``,
+            `SCOPE vigenere_position [level: 1]`,
+            `  ASSUME alphabet_ring SCOPE HOLDS`,
+            posEntities,
+            `  EMERGES key_periodicity`,
+            `    FROM COMPOSITION OF {position_0..position_${keyLen-1}}`,
+            `    AT SCOPE vigenere_composition`,
+            `  END EMERGES`,
+            `END SCOPE`,
+            ``,
+            `SCOPE vigenere_composition [level: 2]`,
+            `  ASSUME vigenere_position SCOPE HOLDS`,
+            ``,
+            `  ENTITY key_vector`,
+            `    FIELD chars:       VECTOR OF INTEGER BOUND [0, 25]  # length ${keyLen}`,
+            `    FIELD normalised:  VECTOR OF REAL    BOUND [0, 1]`,
+            `    DERIVES normalised FROM chars BY divide_each_by_25`,
+            `  END ENTITY`,
+            ``,
+            `  ENTITY plaintext_vector`,
+            `    FIELD chars: VECTOR OF INTEGER EQUALS [${plain.join(", ")}]`,
+            `  END ENTITY`,
+            ``,
+            `  ENTITY ciphertext_vector`,
+            `    FIELD chars: VECTOR OF INTEGER`,
+            `    DERIVES chars FROM {plaintext_vector.chars, key_vector.chars}`,
+            `      BY modular_add_26 APPLIED_PAIRWISE`,
+            `  END ENTITY`,
+            ``,
+            `  OBSERVE ciphertext_vector.chars EQUALS[${cipher.join(", ")}]`,
+            `  OBSERVE SUM(ciphertext_vector.chars) EQUALS ${bRaw}`,
+            ``,
+            `  UNKNOWN key_vector.normalised: VECTOR OF REAL BOUND [0, 1]  # length ${keyLen}`,
+            ``,
+            `  COLLAPSE vigenere_composition`,
+            `    GIVEN {plaintext_vector.chars, ciphertext_vector.chars}`,
+            `    FIND  key_vector.normalised`,
+            `    CONFIDENCE 0.99`,
+            `  END COLLAPSE`,
+            `END SCOPE`,
+        ].join("\n");
+
+        samples.push({
+            id:         crypto.randomUUID(),
+            domain:     "cryptography",
+            subdomain:  `vigenere_${keyLen}char`,
+            sense:      "EQUAL",
+            n_vars:     keyLen,
+            vars_text:  Array.from({length:keyLen}, (_,j) => `c${j} IN [0 1]`).join(" "),
+            expr_text:  `EXPR VIGENERE keyLen=${keyLen} plains=[${plain}] ciphers=[${cipher}] key=UNKNOWN`,
+            sense_text: "SENSE EQUAL",
+            b_raw:      fmt6(bRaw),
+            b_norm:     fmt8(_safeNorm(bRaw)),
+            c_values:   cVals,
+            mask:[...Array(keyLen).fill(1), ...Array(Math.max(0, 4 - keyLen)).fill(0)],
+            candidates:[],
+            step_count: 0,
+            axl_source: axl,
+            metadata: {
+                description:      `Vigenère ${keyLen}-char key=[${key}] plains=[${plain}] → [${cipher}]`,
+                units:            "character_code_sum",
+                difficulty:       keyLen <= 2 ? "medium" : keyLen <= 4 ? "hard" : "expert",
+                scope_depth:      3,
+                has_emergence:    true,
+                has_contradiction: true,
+            }
+        });
+    }
+    return samples;
+}
+
+function synthAffineSamples(n) {
+    const VALID_A   =[1,3,5,7,9,11,15,17,19,21,23,25]; 
+    const INV_A_MAP = {1:1,3:9,5:21,7:15,9:3,11:19,15:7,17:23,19:11,21:5,23:17,25:25};
+    const samples =[];
+
+    for (let i = 0; i < n; i++) {
+        const aIdx  = randint(0, 11);
+        const a     = VALID_A[aIdx];
+        const b     = randint(0, 25);
+        const p     = randint(0, 25);
+        const cipher = (a * p + b) % 26;
+        const aInv  = INV_A_MAP[a];
+        const verify = ((aInv * (cipher - b)) % 26 + 26) % 26;
+        if (verify !== p) continue; 
+
+        const cVals =[fmt6(aIdx / 11.0), fmt6(b / 25.0)];
+        const bRaw  = cipher;
+
+        const axl = [
+            `SCOPE modular_arithmetic[level: 0]`,
+            `  ASSUME integer EXISTS`,
+            ``,
+            `  TRANSFORM modular_multiply_add`,
+            `    INPUT  {a: INTEGER, p: INTEGER, b: INTEGER, mod: INTEGER}`,
+            `    OUTPUT {result: INTEGER}`,
+            `    PRODUCES result = (a * p + b) % mod`,
+            `  END TRANSFORM`,
+            ``,
+            `  TRANSFORM modular_inverse`,
+            `    INPUT  {a: INTEGER, mod: INTEGER}`,
+            `    OUTPUT {a_inv: INTEGER}`,
+            `    REQUIRES gcd(a, mod) EQUALS 1   # invertibility condition`,
+            `    PRODUCES a_inv SUCH_THAT (a * a_inv) % mod EQUALS 1`,
+            `  END TRANSFORM`,
+            `END SCOPE`,
+            ``,
+            `SCOPE affine_cipher [level: 1]`,
+            `  ASSUME modular_arithmetic SCOPE HOLDS`,
+            ``,
+            `  ENTITY affine_key`,
+            `    FIELD a:      INTEGER DISCRETE VALUES {1,3,5,7,9,11,15,17,19,21,23,25}`,
+            `    FIELD b:      INTEGER BOUND [0, 25]`,
+            `    FIELD a_idx:  INTEGER BOUND[0, 11]`,
+            `    FIELD a_norm: REAL    BOUND[0, 1]`,
+            `    FIELD b_norm: REAL    BOUND [0, 1]`,
+            `    DERIVES a     FROM a_idx BY lookup_valid_a`,
+            `    DERIVES a_norm FROM a_idx BY divide_11`,
+            `    DERIVES b_norm FROM b    BY divide_25`,
+            `    BOUND a COPRIME_TO 26`,
+            `  END ENTITY`,
+            ``,
+            `  ENTITY affine_transform_result`,
+            `    FIELD plaintext:  INTEGER BOUND [0, 25] EQUALS ${p}`,
+            `    FIELD ciphertext: INTEGER BOUND [0, 25]`,
+            `    DERIVES ciphertext FROM {affine_key.a, plaintext, affine_key.b} BY modular_multiply_add`,
+            `  END ENTITY`,
+            ``,
+            `  ENTITY affine_inverse`,
+            `    FIELD a_inv:  INTEGER EQUALS ${aInv}`,
+            `    FIELD recovery: INTEGER`,
+            `    DERIVES recovery FROM {a_inv, ciphertext, b} BY modular_multiply_add`,
+            `  END ENTITY`,
+            ``,
+            `  CONTRADICT invertible WITH non_coprime_a`,
+            `    AT SCOPE affine_cipher`,
+            `    BOUNDARY_TYPE INFORMATION`,
+            `  END CONTRADICT`,
+            ``,
+            `  OBSERVE affine_transform_result.ciphertext EQUALS ${cipher}`,
+            `  UNKNOWN affine_key.a_norm: REAL BOUND [0, 1]`,
+            `  UNKNOWN affine_key.b_norm: REAL BOUND [0, 1]`,
+            ``,
+            `  COLLAPSE affine_cipher`,
+            `    GIVEN {affine_transform_result.plaintext, affine_transform_result.ciphertext}`,
+            `    FIND  {affine_key.a_norm, affine_key.b_norm}`,
+            `    CONFIDENCE 0.99`,
+            `  END COLLAPSE`,
+            `END SCOPE`,
+        ].join("\n");
+
+        samples.push({
+            id:         crypto.randomUUID(),
+            domain:     "cryptography",
+            subdomain:  "affine",
+            sense:      "EQUAL",
+            n_vars:     2,
+            vars_text:  "VARS c0 IN [0 1] c1 IN [0 1]",
+            expr_text:  `EXPR AFFINE a=${a}(idx=${aIdx}) b=${b} plain=${p} cipher=${cipher}`,
+            sense_text: "SENSE EQUAL",
+            b_raw:      fmt6(bRaw),
+            b_norm:     fmt8(_safeNorm(bRaw)),
+            c_values:   cVals,
+            mask:[1, 1],
+            candidates:[],
+            step_count: 0,
+            axl_source: axl,
+            metadata: {
+                description:      `Affine cipher: a=${a} b=${b} plain=${p} → cipher=${cipher}, inv_a=${aInv}`,
+                units:            "character_code",
+                difficulty:       "hard",
+                scope_depth:      2,
+                has_emergence:    false,
+                has_contradiction: true,
+                a_inverse:        aInv,
+                coprimality_proof: `gcd(${a},26)=1`,
+            }
+        });
+    }
+    return samples;
+}
+
+function synthXorStreamSamples(n) {
+    const samples =[];
+    for (let i = 0; i < n; i++) {
+        const keyLen   = randint(2, 4);
+        const msgLen   = randint(keyLen, keyLen * 2);
+        const key      = Array.from({length: keyLen},  () => randint(0, 255));
+        const plain    = Array.from({length: msgLen},  () => randint(0, 255));
+        const keyStream = Array.from({length: msgLen}, (_, idx) => key[idx % keyLen]);
+        const cipher   = plain.map((p, idx) => p ^ keyStream[idx]);
+        const bRaw     = cipher.reduce((a,b) => a+b, 0);
+        const cVals    = key.map(k => fmt6(k / 255.0));
+
+        const keyStreamComment = keyStream.map((k,idx) => `key[${idx%keyLen}]=${k}`).join(", ");
+
+        const axl = [
+            `SCOPE xor_gate [level: 0]`,
+            `  TRANSFORM xor_byte`,
+            `    INPUT  {a: INTEGER BOUND [0,255], b: INTEGER BOUND [0,255]}`,
+            `    OUTPUT {result: INTEGER BOUND[0,255]}`,
+            `    PRODUCES result = a XOR b`,
+            `  END TRANSFORM`,
+            `END SCOPE`,
+            ``,
+            `SCOPE key_stream [level: 1]`,
+            `  ASSUME xor_gate SCOPE HOLDS`,
+            ``,
+            `  ENTITY key_block`,
+            `    FIELD bytes: VECTOR OF INTEGER BOUND [0,255]  # length ${keyLen}`,
+            `    FIELD normalised: VECTOR OF REAL BOUND [0,1]`,
+            `    DERIVES normalised FROM bytes BY divide_each_by_255`,
+            `  END ENTITY`,
+            ``,
+            `  TRANSFORM key_schedule_repeating`,
+            `    INPUT  {key: key_block, message_length: INTEGER}`,
+            `    OUTPUT {stream: VECTOR OF INTEGER}`,
+            `    PRODUCES stream[i] = key.bytes[i mod ${keyLen}]`,
+            `  END TRANSFORM`,
+            ``,
+            `  EMERGES key_periodicity`,
+            `    FROM COMPOSITION OF key_block REPEATED`,
+            `    AT SCOPE key_stream`,
+            `    NOT PRESENT AT SCOPE xor_gate`,
+            `  END EMERGES`,
+            `END SCOPE`,
+            ``,
+            `SCOPE xor_stream_cipher[level: 2]`,
+            `  ASSUME key_stream SCOPE HOLDS`,
+            ``,
+            `  ENTITY plaintext_msg`,
+            `    FIELD bytes: VECTOR OF INTEGER EQUALS[${plain.join(", ")}]`,
+            `    FIELD length: INTEGER EQUALS ${msgLen}`,
+            `  END ENTITY`,
+            ``,
+            `  ENTITY ciphertext_msg`,
+            `    FIELD bytes: VECTOR OF INTEGER`,
+            `    DERIVES bytes FROM {plaintext_msg.bytes, key_stream} BY xor_byte APPLIED_PAIRWISE`,
+            `  END ENTITY`,
+            ``,
+            `  OBSERVE ciphertext_msg.bytes EQUALS [${cipher.join(", ")}]`,
+            `  OBSERVE SUM(ciphertext_msg.bytes) EQUALS ${bRaw}`,
+            ``,
+            `  UNKNOWN key_block.normalised: VECTOR OF REAL BOUND [0,1]  # length ${keyLen}`,
+            ``,
+            `  COLLAPSE xor_stream_cipher`,
+            `    GIVEN {plaintext_msg.bytes, ciphertext_msg.bytes}`,
+            `    FIND  key_block.normalised`,
+            `    CONFIDENCE 0.99`,
+            `  END COLLAPSE`,
+            `END SCOPE`,
+        ].join("\n");
+
+        samples.push({
+            id:         crypto.randomUUID(),
+            domain:     "cryptography",
+            subdomain:  `xor_stream_key${keyLen}`,
+            sense:      "EQUAL",
+            n_vars:     keyLen,
+            vars_text:  Array.from({length:keyLen}, (_,j) => `c${j} IN[0 1]`).join(" "),
+            expr_text:  `EXPR XOR_STREAM keyLen=${keyLen} msgLen=${msgLen} cipherSum=${bRaw}`,
+            sense_text: "SENSE EQUAL",
+            b_raw:      fmt6(bRaw),
+            b_norm:     fmt8(_safeNorm(bRaw)),
+            c_values:   cVals,
+            mask:[...Array(keyLen).fill(1), ...Array(Math.max(0, 4 - keyLen)).fill(0)],
+            candidates:[],
+            step_count: 0,
+            axl_source: axl,
+            metadata: {
+                description:      `XOR stream cipher: key=[${key}] len=${msgLen} → cipherSum=${bRaw}`,
+                units:            "byte_sum",
+                difficulty:       keyLen <= 2 ? "medium" : "hard",
+                scope_depth:      3,
+                has_emergence:    true,
+                has_contradiction: true,
+                key_period:       keyLen,
+            }
+        });
+    }
+    return samples;
+}
+
+function synthNonceSearchSamples(n) {
+    const samples =[];
+    for (let i = 0; i < n; i++) {
+        const stepCount    = randint(1, 20);
+        const targetZeros  = randint(1, 4);
+        const nonceBits    = 16;
+        const nonceRange   = Math.pow(2, nonceBits);
+
+        const trueNonce    = randint(0, nonceRange - 1);
+        const cVal         = fmt6(trueNonce / (nonceRange - 1));
+
+        const explored = Array.from({length: Math.min(stepCount, 5)}, () =>
+            fmt6(randint(0, nonceRange-1) / (nonceRange-1))
+        );
+
+        const stepBlocks = explored.map((nc, idx) =>[
+            `  STEP ${idx}`,
+            `    STATE {`,
+            `      explored_fraction: ${fmt6((idx+1)/nonceRange * 100)},`,
+            `      best_nonce_so_far: ${nc},`,
+            `      step_count: ${idx+1}`,
+            `    }`,
+            `    CANDIDATE 0`,
+            `      nonce_norm: ${nc}`,
+            `      score: UNKNOWN`,
+            `      confidence: LEARNS`,
+            `    END CANDIDATE`,
+            `  END STEP`,
+        ].join("\n")).join("\n");
+
+        const axl = [
+            `SCOPE nonce_space [level: 0]`,
+            `  ASSUME nonce EXISTS`,
+            `  ASSUME nonce DISCRETE VALUES {0..${nonceRange-1}}`,
+            ``,
+            `  ENTITY nonce_vector`,
+            `    FIELD raw:        INTEGER BOUND [0, ${nonceRange-1}]`,
+            `    FIELD normalised: REAL    BOUND [0, 1]`,
+            `    DERIVES normalised FROM raw BY divide_${nonceRange-1}`,
+            `    FIELD bits: VECTOR OF bit  # ${nonceBits} bits`,
+            `    DERIVES bits FROM raw BY integer_to_bits`,
+            `  END ENTITY`,
+            `END SCOPE`,
+            ``,
+            `SCOPE hash_constraint [level: 1]`,
+            `  ASSUME nonce_space SCOPE HOLDS`,
+            ``,
+            `  TRANSFORM double_hash`,
+            `    INPUT  {block_header_fixed, nonce: nonce_vector}`,
+            `    OUTPUT {hash: VECTOR OF bit}`,
+            `    CONSERVES nothing`,
+            `    CHANGES everything`,
+            `    PRODUCES hash PSEUDO_RANDOM_FROM nonce`,
+            `  END TRANSFORM`,
+            ``,
+            `  ENTITY difficulty_target`,
+            `    FIELD leading_zeros: INTEGER EQUALS ${targetZeros}`,
+            `    FIELD threshold:     INTEGER EQUALS ${Math.floor(nonceRange / Math.pow(2, targetZeros))}`,
+            `  END ENTITY`,
+            ``,
+            `  CONTRADICT smooth_gradient WITH hash_avalanche`,
+            `    AT SCOPE hash_constraint`,
+            `    BOUNDARY_TYPE INFORMATION`,
+            `  END CONTRADICT`,
+            `END SCOPE`,
+            ``,
+            `SCOPE nonce_search [level: 2]`,
+            `  ASSUME hash_constraint SCOPE HOLDS`,
+            ``,
+            stepBlocks,
+            ``,
+            `  ENTITY search_state`,
+            `    FIELD explored_regions: VECTOR OF REAL`,
+            `    FIELD step_count:       INTEGER EQUALS ${stepCount}`,
+            `    FIELD best_hash_gap:    REAL`,
+            `    TENDS coverage MAX`,
+            `    TENDS hash_gap MIN`,
+            `  END ENTITY`,
+            ``,
+            `  OBSERVE hash BELOW difficulty_target.threshold`,
+            `  UNKNOWN nonce_vector.normalised: REAL BOUND [0, 1]`,
+            ``,
+            `  COLLAPSE nonce_search`,
+            `    GIVEN {search_state, difficulty_target}`,
+            `    FIND  nonce_vector.normalised`,
+            `    CONFIDENCE 0.85`,
+            `  END COLLAPSE`,
+            `END SCOPE`,
+        ].join("\n");
+
+        samples.push({
+            id:         crypto.randomUUID(),
+            domain:     "cryptography",
+            subdomain:  "nonce_search",
+            sense:      "MINIMIZE",
+            n_vars:     1,
+            vars_text:  "VARS c0 IN[0 1]",
+            expr_text:  `EXPR NONCE_SEARCH target_zeros=${targetZeros} steps=${stepCount}`,
+            sense_text: "SENSE MINIMIZE",
+            b_raw:      fmt6(trueNonce / (nonceRange - 1)),
+            b_norm:     fmt8(_safeNorm(trueNonce / (nonceRange - 1))),
+            c_values:   [cVal],
+            mask:       [1],
+            candidates: explored.map(nc => [nc]),
+            step_count: stepCount,
+            axl_source: axl,
+            metadata: {
+                description:      `Nonce search: target=${targetZeros} leading zeros, ${stepCount} steps explored`,
+                units:            "normalised_nonce",
+                difficulty:       targetZeros <= 2 ? "medium" : "expert",
+                scope_depth:      3,
+                has_emergence:    false,
+                has_contradiction: true,
+                nonce_bits:       nonceBits,
+                target_zeros:     targetZeros,
+            }
+        });
     }
     return samples;
 }
@@ -1218,7 +1181,7 @@ function synthOptimizationSamples(n) {
                 sense: sense, n_vars: nVars, vars_text: "VARS " + cVals.map((_, j) => `c${j} IN [0 1]`).join(" "),
                 expr_text: "EXPR " + coeffs.map((c, j) => `${c.toFixed(3)}*c${j}`).join(" + "), sense_text: `SENSE ${sense}`,
                 b_raw: Number(bRaw.toFixed(6)), b_norm: Number(_safeNorm(bRaw).toFixed(8)), c_values: cVals.map(v => Number(v.toFixed(6))),
-                mask: Array(nVars).fill(1), candidates: [], step_count: 0,
+                mask:[...Array(nVars).fill(1), ...Array(Math.max(0, 4 - nVars)).fill(0)], candidates:[], step_count: 0,
                 axl_source: `SCOPE optimization[level: 2]\n  OBJECTIVE OPTIMIZE f ${sense}\n  SUBJECT TO c WITHIN [0,1]\nEND SCOPE`,
                 metadata: { description: `Linear ${sense.toLowerCase()} over ${nVars} variables`, units: "objective", difficulty: "easy", scope_depth: 1, has_emergence: false, has_contradiction: false }
             });
@@ -1227,7 +1190,19 @@ function synthOptimizationSamples(n) {
     return samples;
 }
 
-const SYNTHETIC_GENERATORS = [synthPhysicsSamples, synthFinanceSamples, synthCipherSamples, synthOptimizationSamples];
+function synthCryptoSamples(n) {
+    const perType = Math.ceil(n / 6);
+    return[
+        ...synthXorSamples(perType),
+        ...synthCaesarSamples(perType),
+        ...synthVigenereSamples(perType),
+        ...synthAffineSamples(perType),
+        ...synthXorStreamSamples(perType),
+        ...synthNonceSearchSamples(perType),
+    ].slice(0, n);
+}
+
+const SYNTHETIC_GENERATORS =[synthPhysicsSamples, synthFinanceSamples, synthCryptoSamples, synthOptimizationSamples];
 
 // ── FOCUS TRACKER ────────────────────────────────────────────────────────────
 class FocusTracker {
@@ -1275,7 +1250,7 @@ function saveDataset() {
 // ── JSON PARSER ──────────────────────────────────────────────────────────────
 function parseAiResponse(text) {
     let raw = text.trim();
-    const fences = ["```json", "```JSON", "```"];
+    const fences =["```json", "```JSON", "```"];
     for (let f of fences) {
         if (raw.startsWith(f)) { raw = raw.slice(f.length); break; }
     }
@@ -1431,7 +1406,7 @@ app.get('/dataset/download', (req, res) => {
 
 app.post('/dataset/clear', (req, res) => {
     const count = _dataset.length;
-    _dataset =[]; 
+    _dataset =[];
     if (fs.existsSync(DATASET_PATH)) fs.unlinkSync(DATASET_PATH);
     log(`Dataset cleared — removed ${count} samples`, "OK");
     res.json({ cleared: count });