Update app.js

app.js

@@ -1,464 +1,1448 @@
+/**
+ * axl_dataset_server.js
+ * ══════════════════════════════════════════════════════════════════════════════
+ * AXL Dataset Generation Server (Node.js/Express version)
+ * Generates UCE training samples via AWS Bedrock + synthetic math injection.
+ * Returns JSON for download. Tracks domain diversity across requests.
+ * 
+ * Endpoints:
+ *   GET  /status                     — generation stats
+ *   POST /generate?n=50&rps=3        — generate N samples, returns JSON array
+ *   GET  /dataset/download           — download full accumulated dataset as .json
+ *   POST /dataset/clear              — wipe accumulated dataset
+ *   GET  /domains                    — list focus tracker state
+ *   GET  /dataset/sample?n=5         — preview samples
+ * 
+ * Start: node axl_dataset_server.js
+ * ══════════════════════════════════════════════════════════════════════════════
+ */
+
 import express from 'express';
 import cors from 'cors';
 import dotenv from 'dotenv';
-import OpenAI from "openai";
-import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";
 import { NodeHttpHandler } from "@smithy/node-http-handler";
 
 dotenv.config();
-const app = express();
-const PORT = process.env.PORT || 7860;
 
+// ── LOGGING ──────────────────────────────────────────────────────────────────
+function ts() {
+    const now = new Date();
+    return `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}.${now.getMilliseconds().toString().padStart(3, '0').slice(0,3)}`;
+}
+
+const _LOG_LINES =[];
+
+function log(msg, level = "INFO") {
+    const prefix = { "INFO": "  ", "WARN": "⚠ ", "ERROR": "✖ ", "OK": "✔ ", "HEAD": "━━" }[level] || "  ";
+    const line = `[${ts()}] ${prefix} ${msg}`;
+    console.log(line);
+    _LOG_LINES.push(line);
+    if (_LOG_LINES.length > 500) _LOG_LINES.shift();
+}
+
+log("Starting AXL Dataset Server in Node.js…", "HEAD");
+
+// ── CONFIG ───────────────────────────────────────────────────────────────────
+const app = express();
 app.use(cors());
-app.use(express.json({ limit: '50mb' })); 
+app.use(express.json({ limit: '50mb' }));
 
-// --- SYSTEM PROMPT DEFINITIONS ---
-const CLAUDE_SYSTEM_PROMPT = "You are a pro. Provide elite, high-level technical responses.";
-const GPT_SYSTEM_PROMPT = "You are a worker. Be concise, efficient, and get the job done.";
+const PORT = process.env.PORT || 8000;
+const BEDROCK_REGION = process.env.AWS_REGION || "us-east-1";
+const BEDROCK_MODEL_ID = process.env.BEDROCK_MODEL || "anthropic.claude-3-5-sonnet-20241022-v2:0";
+const DATASET_PATH = path.resolve(process.env.DATASET_PATH || "axl_dataset.json");
+const DEFAULT_RPS = parseFloat(process.env.DEFAULT_RPS || "3");
+const MAX_RPS = parseFloat(process.env.MAX_RPS || "10");
+const SAMPLES_PER_CALL = parseInt(process.env.SAMPLES_PER_CALL || "8");
+const FOCUS_WINDOW = parseInt(process.env.FOCUS_WINDOW || "50");
+const SCALE_K = 30.0;
 
+// ── AWS BEDROCK CLIENT ───────────────────────────────────────────────────────
 const bedrockClient = new BedrockRuntimeClient({
-    region: "us-east-1",
-    requestHandler: new NodeHttpHandler({
-        http2Handler: undefined, 
-    }) 
+    region: BEDROCK_REGION,
+    requestHandler: new NodeHttpHandler({ http2Handler: undefined }) 
 });
 
-const azureOpenAI = new OpenAI({
-    apiKey: "",
-    baseURL: ``,
-    defaultQuery: { "api-version": "2024-05-01-preview" },
-    defaultHeaders: { "api-key": "" }
-});
-
-// --- DYNAMIC MODEL ROUTER ---
-function getBedrockModelId(modelName) {
-    switch(modelName) {
-        case "haiku":
-            return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-haiku-4-5-20251001-v1:0";
-        case "maverick":
-            return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/us.meta.llama4-maverick-17b-instruct-v1:0";
-        case "claude":
-        default:
-            return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6";
-    }
+async function callBedrock(prompt, maxTokens = 8000) {
+    const command = new ConverseCommand({
+        modelId: BEDROCK_MODEL_ID,
+        messages: [{ role: "user", content: [{ text: prompt }] }],
+        inferenceConfig: { 
+            maxTokens: maxTokens, 
+            temperature: 0.9,
+            topP: 0.95
+        }
+    });
+    
+    const t0 = Date.now();
+    const response = await bedrockClient.send(command);
+    const text = response.output.message.content.find(b => b.text)?.text || "";
+    log(`Bedrock call completed in ${((Date.now() - t0) / 1000).toFixed(1)}s — ${text.length} chars`);
+    return text;
 }
 
-// --- NON-STREAMING ENDPOINT (UPDATED FOR VISION) ---
-app.post('/api/generate', async (req, res) => {
-    // EXTRACT IMAGES HERE
-    const { model, prompt, system_prompt, images } = req.body;
-    console.log(`[TRAFFIC] Request for ${model} ${images?.length ? 'with images' : ''}`);
+// ── GUIDING PROMPT ───────────────────────────────────────────────────────────
+const AXL_SPEC_PLACEHOLDER = `
+# AXL — Abstraction Exchange Language
+### A Constraint-First, Bidirectionally Navigable Abstraction Language
+---
 
-    try {
-        if (model === "gpt" || model === "gpt-5-mini") {
-            let messagesPayload =[
-                { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT }
-            ];
-
-            // VISION SUPPORT FOR AZURE OPENAI
-            if (images && images.length > 0) {
-                let userContent = [{ type: "text", text: prompt }];
-                images.forEach(imgStr => {
-                    userContent.push({ type: "image_url", image_url: { url: imgStr } });
-                });
-                messagesPayload.push({ role: "user", content: userContent });
-            } else {
-                messagesPayload.push({ role: "user", content: prompt });
-            }
+## PHILOSOPHY
 
-            const response = await azureOpenAI.chat.completions.create({
-                model: "gpt-5-mini",
-                messages: messagesPayload,
-                reasoning_effort: "high"
-            });
-            
-            const totalTokens = response.usage ? response.usage.total_tokens : 0;
-            res.json({ success: true, data: response.choices[0].message.content, usage: { totalTokenCount: totalTokens } });
+AXL treats existence as a consequence of constraint satisfaction.
+Things exist not because they are declared, but because they are
+the only things consistent with the active assumptions and bounds.
+The language navigates upward (increasing abstraction, emergence)
+and downward (reducing abstraction, collapse to concrete).
 
-        } else {
-            // Handles Claude Sonnet, Claude Haiku, and Llama Maverick
-            const bedrockModelId = getBedrockModelId(model);
-            
-            // VISION SUPPORT FOR AWS BEDROCK
-            let contentBlock = [{ text: prompt }];
-            if (images && images.length > 0) {
-                const imageBlocks = images.map(imgStr => {
-                    const base64Data = imgStr.replace(/^data:image\/\w+;base64,/, "");
-                    return {
-                        image: {
-                            format: 'png', // Assuming normalized to PNG by frontend
-                            source: { bytes: Buffer.from(base64Data, 'base64') }
-                        }
-                    };
-                });
-                contentBlock = [...imageBlocks, ...contentBlock];
-            }
+The system does not know biology, physics, or cryptography.
+It knows only: what is bounded, what is tended toward, what is
+observed, and what must follow. Domain knowledge lives in the
+encoder. AXL is what survives after domain is stripped away.
 
-            const command = new ConverseCommand({
-                modelId: bedrockModelId,
-                system:[{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }],
-                messages: [{ role: "user", content: contentBlock }],
-                
-                // Ensure maxTokens is large enough for reasoning + response
-                inferenceConfig: { 
-                    maxTokens: model.includes("haiku") ? 32000 : 4000, 
-                    temperature: 1 
-                },
-
-                performanceConfig: model.includes("maverick") ? { latency: "standard" } : undefined,
-
-                additionalModelRequestFields: (function() {
-                    if (model.includes("haiku")) {
-                        return {
-                            reasoning_config: {
-                                type: "enabled",
-                                budget_tokens: 2048 
-                            } 
-                        };
-                    } else if (model.includes("claude")) {
-                        return {
-                            // thinking: { type: "adaptive" },
-                            output_config: { effort: "high" }
-                        };
-                    }
-                    return undefined;
-                })()
-            });
-          
-            const response = await bedrockClient.send(command);
-  
-          const text = response.output.message.content.find(b => b.text)?.text;
-            const tokenUsage = response.usage ? (response.usage.inputTokens + response.usage.outputTokens) : 0;
+---
 
-            res.json({ success: true, data: text, usage: { totalTokenCount: tokenUsage } });
-        }
-    } catch (err) {
-        console.error(`❌[${model?.toUpperCase() || 'UNKNOWN'} ERROR]:`, err.name, err.message);
-        res.status(500).json({ success: false, error: `${err.name}: ${err.message}` });
+## PART I — FULL VOCABULARY
+
+### 1. SCOPE DECLARATION
+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)
+- level 2 = functional systems (molecules, data blocks)
+- level 3 = emergent behavior (cells, algorithms)
+- level N = arbitrary abstraction ceiling
+
+---
+
+### 2. ENTITY
+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>
+  TENDS <field> <direction>
+  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
+**TENDS** — soft directional pull on a field (not a hard target)
+
+---
+
+### 3. ASSUME
+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> ABOVE <value>
+BOUND <field> BELOW <value>
+BOUND <field> EQUALS <value>          # exact, no freedom
+BOUND <entity> COUNT WITHIN [<min>, <max>]
+BOUND <a> FORBIDS <b>                 # mutual exclusion
+
+
+---
+
+### 5. TEND
+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
+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
+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>
+  CONSERVES <field_list>
+  CHANGES <field_list>
+  REQUIRES <precondition>
+  PRODUCES <postcondition>
+END TRANSFORM
+
+
+---
+
+### 9. OBSERVE
+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
+What we are solving for. The C vector in the UCE.
+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
+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
+Flags that two things cannot both be true simultaneously.
+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
+Declares a property that does not exist at lower scopes
+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
+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
+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
 
-// --- STREAMING ENDPOINT ---
-app.post('/api/stream', async (req, res) => {
-    const { model, prompt, system_prompt, images } = req.body; 
-    console.log(`[STREAM] Request for ${model} ${images?.length ? 'with images' : ''}`);
+  OBSERVE hash BELOW target                  # this is the termination condition
 
-    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-    res.setHeader('Transfer-Encoding', 'chunked');
-    res.setHeader('X-Accel-Buffering', 'no'); 
-    res.flushHeaders();
+  COLLAPSE mining
+    GIVEN {block_header_fixed_fields, target, search_history}
+    FIND {nonce}
+    CONFIDENCE 0.99
+  END COLLAPSE
 
-    let totalTokenCount = 0;
+  # ══ 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
 
-    try {
-        if (model === "gpt" || model === "gpt-5-mini") {
-            let messagesPayload =[
-                { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT }
-            ];
-
-            let userContent =[];
-            if (images && images.length > 0) {
-                userContent.push({ type: "text", text: prompt });
-                images.forEach(imgStr => {
-                    userContent.push({ type: "image_url", image_url: { url: imgStr } });
-                });
-                messagesPayload.push({ role: "user", content: userContent });
-            } else {
-                messagesPayload.push({ role: "user", content: prompt });
-            }
+END SCOPE
 
-            const stream = await azureOpenAI.chat.completions.create({
-                model: "gpt-5-mini",
-                messages: messagesPayload,
-                reasoning_effort: "high",
-                stream: true,
-                stream_options: { include_usage: true } 
-            });
 
-            for await (const chunk of stream) {
-                const delta = chunk.choices[0]?.delta;
-                if (delta?.reasoning_content) res.write(`__THINK__${delta.reasoning_content}`);
-                else if (delta?.content) res.write(delta.content);
-                if (chunk.usage) totalTokenCount = chunk.usage.total_tokens;
-            }
-            
-            res.write(`__USAGE__${JSON.stringify({ totalTokenCount })}`);
-            res.end();
+---
 
-        } else {
-            const bedrockModelId = getBedrockModelId(model);
-            let contentBlock = [{ text: prompt }];
-            
-            if (images && images.length > 0) {
-                const imageBlocks = images.map(imgStr => {
-                    const base64Data = imgStr.replace(/^data:image\/\w+;base64,/, "");
-                    return {
-                        image: {
-                            format: 'png', // Assuming normalized to PNG by frontend
-                            source: { bytes: Buffer.from(base64Data, 'base64') }
-                        }
-                    };
-                });
-                contentBlock = [...imageBlocks, ...contentBlock];
-            }
+### DEMONSTRATION 3: CELL DIVISION (MITOSIS)
+#### Encoding life as constraint satisfaction
 
-            const command = new ConverseStreamCommand({
-                modelId: bedrockModelId,
-                system:[{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }],
-                messages:[{ role: "user", content: contentBlock }],
-                inferenceConfig: { maxTokens: 48000, temperature: 1 },
-                additionalModelRequestFields: model.includes("claude") ? { 
-                    thinking: { type: "adaptive" },
-                    output_config: { effort: "high" }
-                } : undefined
-            });
+axl:
+# ════════════════════════════════════════════════════
+# CELL DIVISION SYSTEM
+# Life as constraints on information replication
+# with error correction and state machines
+# ════════════════════════════════════════════════════
 
-            const response = await bedrockClient.send(command);
-            
-            for await (const chunk of response.stream) {
-                if (chunk.contentBlockDelta) {
-                    const delta = chunk.contentBlockDelta.delta;
-                    if (delta.reasoningContent && delta.reasoningContent.text) {
-                        res.write(`__THINK__${delta.reasoningContent.text}`);
-                    } else if (delta.text) {
-                        res.write(delta.text);
-                    }
-                }
-                if (chunk.metadata && chunk.metadata.usage) {
-                    totalTokenCount = (chunk.metadata.usage.inputTokens || 0) + (chunk.metadata.usage.outputTokens || 0);
-                }
-            }
-            
-            res.write(`__USAGE__${JSON.stringify({ totalTokenCount })}`);
-            res.end();
-        }
-    } catch (err) {
-        console.error(`❌ [STREAM ERROR]:`, err.message);
-        res.write(`ERROR: ${err.message}`);
-        res.end();
+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
 
-app.get('/', async (req, res) => { res.json({ success: true }); });
-app.listen(PORT, '0.0.0.0', () => console.log(`Main AI Agent live on port ${PORT}`));
+  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
 
-/* import express from 'express';
-import cors from 'cors';
-import dotenv from 'dotenv';
-import OpenAI from "openai";
-import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
-import { NodeHttpHandler } from "@smithy/node-http-handler";
 
-dotenv.config();
-const app = express();
-const PORT = process.env.PORT || 7860;
+SCOPE mitosis [level: 3]
 
-app.use(cors());
-app.use(express.json({ limit: '50mb' })); 
+  ASSUME cell SCOPE HOLDS
 
-// --- SYSTEM PROMPT DEFINITIONS ---
-const CLAUDE_SYSTEM_PROMPT = "You are a pro. Provide elite, high-level technical responses.";
-const GPT_SYSTEM_PROMPT = "You are a worker. Be concise, efficient, and get the job done.";
+  # ══ TRIGGER CONDITIONS ══
+  # Cell division is itself a constraint satisfaction problem:
+  # divide WHEN AND ONLY WHEN all conditions hold
 
-const bedrockClient = new BedrockRuntimeClient({
-    region: "us-east-1",
-    requestHandler: new NodeHttpHandler({
-        http2Handler: undefined, 
-    }) 
-});
+  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
 
-const azureOpenAI = new OpenAI({
-    apiKey: "7U3m9NRkE38ThSWTr92hMgQ4hDCUFI9MAnFNrCgRL7MhdvckfTXwJQQJ99CBACHYHv6XJ3w3AAAAACOGV22P",
-    baseURL: `https://hollowpad-resource.cognitiveservices.azure.com/openai/deployments/gpt-5-mini`,
-    defaultQuery: { "api-version": "2024-05-01-preview" },
-    defaultHeaders: { "api-key": "7U3m9NRkE38ThSWTr92hMgQ4hDCUFI9MAnFNrCgRL7MhdvckfTXwJQQJ99CBACHYHv6XJ3w3AAAAACOGV22P" }
-});
+  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
 
-// --- DYNAMIC MODEL ROUTER ---
-function getBedrockModelId(modelName) {
-    switch(modelName) {
-        case "haiku":
-        return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-haiku-4-5-20251001-v1:0"
-           // return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-haiku-4-5";
-        case "maverick":
-            // Standard Bedrock cross-region inference mapping for Llama
-           // return "arn:aws:bedrock:us-east-1::foundation-model/meta.llama4-maverick-17b-instruct-v1:0"; 
-        return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/us.meta.llama4-maverick-17b-instruct-v1:0";
-      case "claude":
-        default:
-            return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6";
+  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.
+The UCE is trained on AXL (Abstraction eXchange Language) programs.
+It learns to invert constraints — given an observed output B, find the input configuration C.
+
+Below is the complete AXL language specification:
+`;
+
+const SYSTEM_PROMPT_FOOTER = `
+════════════════════════════════════════════════════════════════════════
+GENERATION TASK
+════════════════════════════════════════════════════════════════════════
+
+Generate exactly {n} training samples. Each sample encodes a real-world
+constraint problem in AXL and provides the ground-truth solution.
+
+STRICT REQUIREMENTS:
+1. Output ONLY a valid JSON array. No markdown, no backticks, no preamble.
+2. Each sample must have ALL fields shown in the schema below.
+3. b_raw and c_values must be COMPUTED EXACTLY — no placeholders.
+4. Every sample must be in a DIFFERENT domain or structural pattern.
+5. Vary: sense (EQUAL/MINIMIZE/MAXIMIZE/SELECT/TEND), n_vars (1-{max_vars}),
+         abstraction depth, domain (physics/finance/biology/crypto/chemistry/
+         engineering/logistics/game_theory/information_theory/ecology/etc.)
+6. For SELECT samples: candidates is a non-empty list of alternative C configs.
+7. For MINIMIZE/MAXIMIZE: c_values must actually be near the optimum.
+8. Include at least one multi-scope (hierarchical) AXL program per batch.
+9. Include at least one search/iterative problem using STEP and CANDIDATE.
+10. Do NOT repeat domains recently used: {recent_domains}
+
+JSON SCHEMA (output an array of these):
+{
+  "id": "<uuid string>",
+  "domain": "<domain name>",
+  "subdomain": "<specific topic>",
+  "sense": "<EQUAL|MINIMIZE|MAXIMIZE|SELECT|TEND>",
+  "n_vars": <integer 1 to {max_vars}>,
+  "vars_text": "VARS c0 IN[lo hi] c1 IN [lo hi] ...",
+  "expr_text": "EXPR <AXL expression or multi-line AXL program>",
+  "sense_text": "SENSE <EQUAL|MINIMIZE|MAXIMIZE|SELECT|TEND>",
+  "b_raw": <float — the computed observed output>,
+  "b_norm": <float — log-normalized b_raw>,
+  "c_values": [<float>, ...],
+  "mask":[1, 1, ..., 0, 0],
+  "candidates":[],
+  "step_count": 0,
+  "axl_source": "<full AXL program as single string with \\n for newlines>",
+  "metadata": {
+    "description": "<one sentence what this problem represents>",
+    "units": "<units of b_raw if applicable>",
+    "difficulty": "<easy|medium|hard|expert>",
+    "scope_depth": <integer — how many nested scopes>,
+    "has_emergence": <boolean>,
+    "has_contradiction": <boolean>
+  }
 }
 
-// --- NON-STREAMING ENDPOINT ---
-app.post('/api/generate', async (req, res) => {
-    const { model, prompt, system_prompt } = req.body;
-    console.log(`[TRAFFIC] Request for ${model}`);
+IMPORTANT ON b_norm: compute as Math.sign(b_raw) * Math.log1p(Math.abs(b_raw)) / 30.0
 
-    try {
-        if (model === "gpt" || model === "gpt-5-mini") {
-            const response = await azureOpenAI.chat.completions.create({
-                model: "gpt-5-mini",
-                messages:[
-                    { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT },
-                    { role: "user", content: prompt }
-                ],
-                reasoning_effort: "high"
+OUTPUT THE JSON ARRAY NOW:`;
+
+function buildPrompt(n, recentDomains, maxVars = 20) {
+    const spec = AXL_SPEC_PLACEHOLDER;
+    const recentStr = recentDomains.length > 0 ? recentDomains.slice(-10).join(", ") : "none yet";
+    let footer = SYSTEM_PROMPT_FOOTER.replace("{n}", n).replace("{max_vars}", maxVars).replace("{max_vars}", maxVars).replace("{recent_domains}", recentStr);
+    return SYSTEM_PROMPT_HEADER + spec + footer;
+}
+
+// ── MATH HELPERS ────────────────────────────────────────────────────────────
+const rnd = (min, max) => Math.random() * (max - min) + min;
+const randint = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
+const randchoice = (arr) => arr[Math.floor(Math.random() * arr.length)];
+const sign = (x) => x < 0 ? -1.0 : 1.0;
+function _safeNorm(bRaw) {
+    if (!isFinite(bRaw) || isNaN(bRaw)) return 0.0;
+    return sign(bRaw) * Math.log1p(Math.abs(bRaw)) / SCALE_K;
+}
+
+// ── 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"],
+        ["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"]
+    ];
+
+    for (let i = 0; i < n; i++) {
+        let tmpl = randchoice(templates);
+        let cVals = tmpl[2].map(r => rnd(r[0], r[1]));
+        try {
+            let bRaw = tmpl[1](cVals);
+            if (!isFinite(bRaw) || isNaN(bRaw)) continue;
+            let nVars = cVals.length;
+            samples.push({
+                id: crypto.randomUUID(), domain: "physics", subdomain: tmpl[0], sense: "EQUAL", n_vars: nVars,
+                vars_text: "VARS " + cVals.map((_, i) => `c${i} IN [0 1]`).join(" "),
+                expr_text: `EXPR ${tmpl[0].toUpperCase().replace(/ /g, "_")} n_vars=${nVars}`,
+                sense_text: "SENSE EQUAL", 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), ...Array(Math.max(0, 4 - nVars)).fill(0)],
+                candidates:[], step_count: 0,
+                axl_source: `SCOPE physics [level: 2]\n  OBSERVE ${tmpl[0]} EQUALS ${bRaw.toFixed(4)}\n  UNKNOWN c: VECTOR BOUND[0,1]\nEND SCOPE`,
+                metadata: { description: `${tmpl[0]} constraint inversion`, units: tmpl[3], difficulty: "medium", scope_depth: 1, has_emergence: false, has_contradiction: false }
             });
-            
-            const totalTokens = response.usage ? response.usage.total_tokens : 0;
-            res.json({ success: true, data: response.choices[0].message.content, usage: { totalTokenCount: totalTokens } });
-
-        } else {
-            // Handles Claude Sonnet, Claude Haiku, and Llama Maverick
-            const bedrockModelId = getBedrockModelId(model);
-       
-
-const command = new ConverseCommand({
-    modelId: bedrockModelId,
-    system: [{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }],
-    messages: [{ role: "user", content: [{ text: prompt }] }],
+        } catch (e) {}
+    }
+    return samples;
+}
+
+function synthFinanceSamples(n) {
+    let samples = [];
+    const kinds =["compound_interest", "loan_payment", "portfolio_return", "options_delta"];
     
-    // Ensure maxTokens is large enough for reasoning + response
-    inferenceConfig: { 
-        maxTokens: model.includes("haiku") ? 32000 : 4000, 
-        temperature: 1 
-    },
-
-    performanceConfig: model.includes("maverick") ? { latency: "standard" } : undefined,
-
-    additionalModelRequestFields: (function() {
-        if (model.includes("haiku")) {
-            return {
-                reasoning_config: {
-                    type: "enabled",
-                    budget_tokens: 2048 // As seen in your screenshot
-                }
-            };
-        } else if (model.includes("claude")) {
-            return {
-                thinking: { type: "adaptive" },
-                output_config: { effort: "high" }
-            };
-        }
-        return undefined;
-    })()
-});
-          
-            const response = await bedrockClient.send(command);
-            const text = response.output.message.content.find(b => b.text)?.text;
-            const tokenUsage = response.usage ? (response.usage.inputTokens + response.usage.outputTokens) : 0;
+    for (let i = 0; i < n; i++) {
+        let kind = randchoice(kinds);
+        try {
+            let bRaw, cVals, desc;
+            if (kind === "compound_interest") {
+                let P = rnd(1000, 100000), r = rnd(0.01, 0.25), t = rnd(1, 30);
+                bRaw = P * Math.exp(r * t); cVals =[P/100000, r/0.25, t/30]; desc = `Compound int: P=${P|0} r=${r.toFixed(3)} t=${t.toFixed(1)}y → ${bRaw.toFixed(2)}`;
+            } else if (kind === "loan_payment") {
+                let P = rnd(50000, 500000), r = rnd(0.002, 0.02), np = randint(60, 360);
+                bRaw = (P*r*Math.pow(1+r, np))/(Math.pow(1+r, np) - 1 + 1e-9); cVals =[P/500000, r/0.02, np/360]; desc = `Monthly loan payment: ${bRaw.toFixed(2)}`;
+            } else if (kind === "portfolio_return") {
+                let w = [rnd(0,1), rnd(0,1), rnd(0,1)]; let sum = w.reduce((a,b)=>a+b); w = w.map(x=>x/sum);
+                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)}`;
+            }
+            if (!isFinite(bRaw) || isNaN(bRaw)) continue;
+            let nVars = cVals.length;
+            samples.push({
+                id: crypto.randomUUID(), domain: "finance", subdomain: kind, sense: "EQUAL", n_vars: nVars,
+                vars_text: "VARS " + cVals.map((_, j) => `c${j} IN [0 1]`).join(" "), expr_text: `EXPR FINANCE_${kind.toUpperCase()}`,
+                sense_text: "SENSE EQUAL", 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), ...Array(Math.max(0, 4 - nVars)).fill(0)], candidates:[], step_count: 0,
+                axl_source: `SCOPE finance [level: 2]\n  OBSERVE ${kind} EQUALS ${bRaw.toFixed(6)}\n  UNKNOWN c: VECTOR BOUND[0,1]\nEND SCOPE`,
+                metadata: { description: desc, units: "currency", difficulty: "medium", scope_depth: 1, has_emergence: false, has_contradiction: false }
+            });
+        } catch (e) {}
+    }
+    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}`;
+            }
+            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 synthOptimizationSamples(n) {
+    let samples =[];
+    for(let i=0; i<n; i++) {
+        let sense = randchoice(["MINIMIZE", "MAXIMIZE"]);
+        let nVars = randint(2, 5);
+        try {
+            let coeffs = Array.from({length: nVars}, () => rnd(0.1, 10.0));
+            let cOpt = sense === "MINIMIZE" ? Array(nVars).fill(0.0) : Array(nVars).fill(1.0);
+            let cVals = cOpt.map(v => Math.min(1.0, Math.max(0.0, v + rnd(-0.05, 0.05))));
+            let bRaw = cVals.reduce((acc, val, j) => acc + val*coeffs[j], 0);
+
+            samples.push({
+                id: crypto.randomUUID(), domain: "optimization", subdomain: `linear_${sense.toLowerCase()}_${nVars}var`,
+                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,
+                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 }
+            });
+        } catch(e) {}
+    }
+    return samples;
+}
+
+const SYNTHETIC_GENERATORS = [synthPhysicsSamples, synthFinanceSamples, synthCipherSamples, synthOptimizationSamples];
+
+// ── FOCUS TRACKER ────────────────────────────────────────────────────────────
+class FocusTracker {
+    constructor(window = 50) {
+        this.window = window;
+        this.recent =[];
+        this.counts = {};
+        this.total = 0;
+    }
+    record(domain) {
+        this.recent.push(domain);
+        if (this.recent.length > this.window) this.recent.shift();
+        this.counts[domain] = (this.counts[domain] || 0) + 1;
+        this.total += 1;
+    }
+    stats() {
+        const sortedCounts = Object.entries(this.counts).sort((a,b)=>b[1]-a[1]).reduce((acc,[k,v])=>{acc[k]=v; return acc;},{});
+        return { total_generated: this.total, domain_counts: sortedCounts, recent_window: this.recent.slice(-20) };
+    }
+}
+const tracker = new FocusTracker(FOCUS_WINDOW);
+
+// ── STATE ────────────────────────────────────────────────────────────────────
+let _dataset =[];
 
-            res.json({ success: true, data: text, usage: { totalTokenCount: tokenUsage } });
+function loadExisting() {
+    if (fs.existsSync(DATASET_PATH)) {
+        const data = fs.readFileSync(DATASET_PATH, 'utf-8');
+        try {
+            _dataset = JSON.parse(data);
+            log(`Loaded ${_dataset.length} existing samples from ${DATASET_PATH}`, "OK");
+        } catch (e) {
+            log(`JSON Load Error on existing DB, resetting: ${e.message}`, "ERROR");
         }
-    } catch (err) {
-        console.error(`❌[${model?.toUpperCase() || 'UNKNOWN'} ERROR]:`, err.name, err.message);
-        res.status(500).json({ success: false, error: `${err.name}: ${err.message}` });
+    } else {
+        log("No existing dataset found — starting fresh", "OK");
     }
-});
+}
 
-// --- STREAMING ENDPOINT ---
-app.post('/api/stream', async (req, res) => {
-    const { model, prompt, system_prompt, images } = req.body; 
-    console.log(`[STREAM] Request for ${model} ${images?.length ? 'with images' : ''}`);
+function saveDataset() {
+    fs.writeFileSync(DATASET_PATH, JSON.stringify(_dataset, null, 2), 'utf-8');
+    log(`Saved ${_dataset.length} samples → ${DATASET_PATH}`, "OK");
+}
 
-    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-    res.setHeader('Transfer-Encoding', 'chunked');
-    res.setHeader('X-Accel-Buffering', 'no'); 
-    res.flushHeaders();
+// ── JSON PARSER ──────────────────────────────────────────────────────────────
+function parseAiResponse(text) {
+    let raw = text.trim();
+    const fences = ["```json", "```JSON", "```"];
+    for (let f of fences) {
+        if (raw.startsWith(f)) { raw = raw.slice(f.length); break; }
+    }
+    if (raw.endsWith("```")) raw = raw.slice(0, -3);
+    raw = raw.trim();
 
-    let totalTokenCount = 0;
+    let start = raw.indexOf('[');
+    let end = raw.lastIndexOf(']');
+    if (start === -1 || end === -1) return[];
 
     try {
-        if (model === "gpt" || model === "gpt-5-mini") {
-            let messagesPayload =[
-                { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT }
-            ];
-
-            let userContent =[];
-            if (images && images.length > 0) {
-                userContent.push({ type: "text", text: prompt });
-                images.forEach(imgStr => {
-                    userContent.push({ type: "image_url", image_url: { url: imgStr } });
-                });
-                messagesPayload.push({ role: "user", content: userContent });
-            } else {
-                messagesPayload.push({ role: "user", content: prompt });
+        let arr = JSON.parse(raw.slice(start, end + 1));
+        return arr;
+    } catch (e) {
+        // Fallback salvage logic
+        let salvaged =[];
+        let depth = 0; let inObj = false; let buf = "";
+        let jsonArea = raw.slice(start+1, end);
+        for(let i=0; i<jsonArea.length; i++){
+            let char = jsonArea[i];
+            if (char === '{') { depth++; inObj = true; }
+            if (inObj) buf += char;
+            if (char === '}') {
+                depth--;
+                if (depth === 0 && buf.trim()) {
+                    try { salvaged.push(JSON.parse(buf)); } catch (err) {}
+                    buf = ""; inObj = false;
+                }
             }
+        }
+        return salvaged;
+    }
+}
 
-            const stream = await azureOpenAI.chat.completions.create({
-                model: "gpt-5-mini",
-                messages: messagesPayload,
-                reasoning_effort: "high",
-                stream: true,
-                stream_options: { include_usage: true } 
-            });
+function validateSample(s) {
+    const required =["domain","sense","n_vars","vars_text","expr_text","sense_text","b_raw","b_norm","c_values","mask"];
+    for (let f of required) if (!(f in s)) return false;
+    if (!Array.isArray(s.c_values)) return false;
+    if (isNaN(s.b_raw) || !isFinite(s.b_raw)) return false;
+    if (s.c_values.length !== s.n_vars) return false;
+    if (!s.id) s.id = crypto.randomUUID();
+    return true;
+}
 
-            for await (const chunk of stream) {
-                const delta = chunk.choices[0]?.delta;
-                if (delta?.reasoning_content) res.write(`__THINK__${delta.reasoning_content}`);
-                else if (delta?.content) res.write(delta.content);
-                if (chunk.usage) totalTokenCount = chunk.usage.total_tokens;
-            }
-            
-            res.write(`__USAGE__${JSON.stringify({ totalTokenCount })}`);
-            res.end();
+// ── EXPRESS APP & ENDPOINTS ──────────────────────────────────────────────────
+loadExisting();
 
-        } else {
-            const bedrockModelId = getBedrockModelId(model);
-            let contentBlock = [{ text: prompt }];
-            
-            if (images && images.length > 0) {
-                const imageBlocks = images.map(imgStr => {
-                    const base64Data = imgStr.replace(/^data:image\/\w+;base64,/, "");
-                    return {
-                        image: {
-                            format: 'png', // Assuming normalized to PNG by frontend
-                            source: { bytes: Buffer.from(base64Data, 'base64') }
-                        }
-                    };
-                });
-                contentBlock = [...imageBlocks, ...contentBlock];
-            }
+if (SYSTEM_PROMPT_HEADER.includes("[AXL_SPEC_HERE]")) {
+    log("⚠  AXL spec placeholder not replaced in production code.", "WARN");
+}
 
-            const command = new ConverseStreamCommand({
-                modelId: bedrockModelId,
-                system:[{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }],
-                messages: [{ role: "user", content: contentBlock }],
-                inferenceConfig: { maxTokens: 48000, temperature: 1 },
-                additionalModelRequestFields: model.includes("claude") ? { 
-                    thinking: { type: "adaptive" },
-                    output_config: { effort: "high" }
-                } : undefined
-            });
+app.get('/status', (req, res) => {
+    res.json({
+        dataset_size: _dataset.length,
+        dataset_path: DATASET_PATH,
+        bedrock_model: BEDROCK_MODEL_ID,
+        focus_tracker: tracker.stats(),
+        server_time: new Date().toISOString()
+    });
+});
 
-            const response = await bedrockClient.send(command);
-            
-            for await (const chunk of response.stream) {
-                if (chunk.contentBlockDelta) {
-                    const delta = chunk.contentBlockDelta.delta;
-                    if (delta.reasoningContent && delta.reasoningContent.text) {
-                        res.write(`__THINK__${delta.reasoningContent.text}`);
-                    } else if (delta.text) {
-                        res.write(delta.text);
-                    }
-                }
-                if (chunk.metadata && chunk.metadata.usage) {
-                    totalTokenCount = (chunk.metadata.usage.inputTokens || 0) + (chunk.metadata.usage.outputTokens || 0);
+app.get('/domains', (req, res) => {
+    res.json(tracker.stats());
+});
+
+app.post('/generate', async (req, res) => {
+    const n = parseInt(req.query.n || req.body.n || "50");
+    const rps = parseFloat(req.query.rps || req.body.rps || DEFAULT_RPS.toString());
+    const synthFraction = parseFloat(req.query.synthetic_fraction || req.body.synthetic_fraction || "0.3");
+    const maxVars = parseInt(req.query.max_vars || req.body.max_vars || "20");
+    
+    let generated =[];
+    let errors = 0;
+
+    log(`Generation request: n=${n} rps=${rps} synthetic=${(synthFraction*100)|0}%`);
+
+    let n_synth = Math.floor(n * synthFraction);
+    if (n_synth > 0) {
+        log(`Generating ${n_synth} synthetic samples...`);
+        let perGen = Math.max(1, Math.floor(n_synth / SYNTHETIC_GENERATORS.length));
+        for (let genFn of SYNTHETIC_GENERATORS) {
+            let batch = genFn(perGen);
+            for (let s of batch) {
+                if (validateSample(s)) {
+                    generated.push(s);
+                    tracker.record(s.domain);
                 }
             }
+        }
+    }
+
+    let n_ai = n - generated.length;
+    let callsNeeded = Math.ceil(n_ai / SAMPLES_PER_CALL);
+    log(`AI generation: ${n_ai} samples via ${callsNeeded} Bedrock calls`);
+
+    let minInterval = 1000.0 / Math.min(rps, MAX_RPS);
+    
+    for (let callIdx = 0; callIdx < callsNeeded; callIdx++) {
+        let startStamp = Date.now();
+        let remaining = n_ai - generated.filter(s => s.metadata?.source === "ai").length;
+        let batchN = Math.min(SAMPLES_PER_CALL, remaining + 2); // +2 pad
+        
+        log(`Bedrock call ${callIdx+1}/${callsNeeded} — requesting ${batchN} samples`);
+        
+        try {
+            let prompt = buildPrompt(batchN, tracker.stats().recent_window, maxVars);
+            let responseText = await callBedrock(prompt);
+            let samples = parseAiResponse(responseText);
+            let validCount = 0;
             
-            res.write(`__USAGE__${JSON.stringify({ totalTokenCount })}`);
-            res.end();
+            for (let s of samples) {
+                if (validateSample(s)) {
+                    if (!s.metadata) s.metadata = {};
+                    s.metadata.source = "ai";
+                    generated.push(s);
+                    tracker.record(s.domain || "unknown");
+                    validCount++;
+                } else { errors++; }
+            }
+            log(`Call ${callIdx+1}: ${validCount} valid / ${samples.length} parsed`, "OK");
+        } catch(err) {
+            log(`Bedrock call ${callIdx+1} failed: ${err.message}`, "ERROR");
+            errors++;
+        }
+
+        // Throttle RPS logic
+        let duration = Date.now() - startStamp;
+        if (duration < minInterval && callIdx < callsNeeded - 1) {
+            await new Promise(r => setTimeout(r, minInterval - duration));
         }
-    } catch (err) {
-        console.error(`❌ [STREAM ERROR]:`, err.message);
-        res.write(`ERROR: ${err.message}`);
-        res.end();
     }
+
+    _dataset.push(...generated);
+    saveDataset();
+    log(`Generation complete: ${generated.length} new | total=${_dataset.length} | errors=${errors}`, "OK");
+    
+    res.json({
+        generated: generated.length,
+        errors: errors,
+        total_dataset: _dataset.length,
+        domain_breakdown: generated.reduce((acc, curr) => { acc[curr.domain] = (acc[curr.domain] || 0)+1; return acc }, {}),
+        samples: generated
+    });
+});
+
+app.get('/dataset/download', (req, res) => {
+    if (!fs.existsSync(DATASET_PATH)) {
+        return res.status(404).json({ error: "No dataset file found. Run /generate first." });
+    }
+    const timestamp = new Date().toISOString().replace(/T/, '_').replace(/:/g, '').split('.')[0];
+    res.download(DATASET_PATH, `axl_dataset_${timestamp}.json`);
+});
+
+app.post('/dataset/clear', (req, res) => {
+    const count = _dataset.length;
+    _dataset =[];
+    if (fs.existsSync(DATASET_PATH)) fs.unlinkSync(DATASET_PATH);
+    log(`Dataset cleared — removed ${count} samples`, "OK");
+    res.json({ cleared: count });
+});
+
+app.get('/dataset/sample', (req, res) => {
+    let n = parseInt(req.query.n || "5");
+    let shuffled = [..._dataset].sort(() => 0.5 - Math.random());
+    res.json({ samples: shuffled.slice(0, n) });
 });
 
-app.get('/', async (req, res) => { res.json({ success: true }); });
-app.listen(PORT, '0.0.0.0', () => console.log(`Main AI Agent live on port ${PORT}`));
-*/
+app.listen(PORT, '0.0.0.0', () => {
+    log(`Main Dataset Agent live on port ${PORT}`, "HEAD");
+});