feat: Act 4 -- Five Bules personality demo

Five personality profiles on fork/race/fold/vent/interfere axes:
- Explorer: high temp (0.8-1.6), wide top-p (0.98), forks broadly
- Builder: low temp (0.2-0.5), narrow top-p (0.70), folds tightly
- Creative: medium-high temp, aggressive C3 (threshold=2), races freely
- Anxious: medium temp, frequent C3 (threshold=2), interferes early
- Balanced: standard glossolalia, phi convergence

Four swappable models:
- buleyean-smollm2 (360M, void-trained)
- base-smollm2 (360M, standard instruct)
- buleyean-qwen (0.5B, void-trained)
- base-qwen (0.5B, standard instruct)

All five personalities generate in parallel. Each shows
immediately when done. Amber accent.

THM-FIVE-BULE-PERSONALITY + THM-PHI-ATTRACTOR (Lean 4).

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.11-slim
+
+RUN apt-get update && apt-get install -y curl && \
+    curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
+    apt-get install -y nodejs && \
+    rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py aether-server.mjs simd-kernels.wasm ./
+
+RUN mkdir -p /tmp/hf_cache
+ENV PYTHONUNBUFFERED=1 HF_HOME=/tmp/hf_cache
+EXPOSE 7860
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,14 @@
 ---
-title: Five Bules
-emoji: 🐠
-colorFrom: blue
-colorTo: red
+title: Five Bules - Personality as Void Walking
+emoji: "\U0001F3AD"
+colorFrom: yellow
+colorTo: yellow
 sdk: docker
-pinned: false
+app_port: 7860
+pinned: true
+models:
+  - bartowski/SmolLM2-360M-Instruct-GGUF
+  - forkjoin-ai/buleyean-smollm2-360m
+  - bartowski/Qwen2.5-0.5B-Instruct-GGUF
+  - forkjoin-ai/buleyean-qwen2.5-0.5b
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

aether-server.mjs

@@ -0,0 +1,679 @@
+/**
+ * Aether Inference Server with Glossolalia Decoder
+ *
+ * SmolLM2-360M inference using WASM SIMD kernels.
+ * Two endpoints:
+ *   /generate-standard  -- standard top-p sampling
+ *   /generate-glossolalia -- temperature-ensemble fork/race/fold
+ */
+
+import { createServer } from 'http';
+import { readFileSync, existsSync } from 'fs';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PORT = parseInt(process.env.AETHER_PORT || '7861');
+
+// ─── Model Configs ──────────────────────────────────────────────────────────
+const CONFIGS = {
+  'smollm2-360m': {
+    hiddenDim: 960, numLayers: 32, numHeads: 15, numKvHeads: 5,
+    headDim: 64, intermediateSize: 2560, vocabSize: 49152,
+    ropeTheta: 100000.0, rmsNormEps: 1e-5, eosToken: 2,
+  },
+  'qwen2.5-0.5b': {
+    hiddenDim: 896, numLayers: 24, numHeads: 14, numKvHeads: 2,
+    headDim: 64, intermediateSize: 4864, vocabSize: 151936,
+    ropeTheta: 1000000.0, rmsNormEps: 1e-6, eosToken: 151645, // <|im_end|>
+  },
+};
+
+// Five Bule Personality Profiles (THM-FIVE-BULE-PERSONALITY)
+// Each personality is a position on the fork/race/fold/vent/interfere axes
+const PERSONALITIES = {
+  explorer:  { temps: [0.8, 1.2, 1.6], topP: 0.98, absorbingThreshold: 5, label: 'Explorer -- forks broadly, high temperature diversity' },
+  builder:   { temps: [0.2, 0.3, 0.5], topP: 0.70, absorbingThreshold: 4, label: 'Builder -- folds tightly, low temperature, precise' },
+  creative:  { temps: [0.6, 1.0, 1.4], topP: 0.95, absorbingThreshold: 2, label: 'Creative -- races freely, aggressive C3 perturbation' },
+  anxious:   { temps: [0.4, 0.6, 0.8], topP: 0.85, absorbingThreshold: 2, label: 'Anxious -- interferes early, cautious, frequent C3' },
+  balanced:  { temps: [0.4, 0.7, 1.0], topP: 0.90, absorbingThreshold: 3, label: 'Balanced -- standard glossolalia, phi convergence' },
+};
+
+// Default config (overridden per-model)
+let C = CONFIGS['qwen2.5-0.5b'];
+let kvDim = C.numKvHeads * C.headDim;
+let gqaRatio = C.numHeads / C.numKvHeads;
+
+// ─── WASM SIMD ──────────────────────────────────────────────────────────────
+let simd = null;
+
+async function loadSIMD() {
+  const p = join(__dirname, 'simd-kernels.wasm');
+  if (!existsSync(p)) return null;
+  try {
+    const { instance } = await WebAssembly.instantiate(readFileSync(p), {
+      env: { expf: Math.exp, tanhf: Math.tanh, powf: Math.pow },
+    });
+    const w = instance.exports; w.resetHeap(65536);
+    const mem = w.memory;
+    const hf = () => new Float32Array(mem.buffer);
+    const cp = (ptr, f) => hf().set(f, ptr >> 2);
+    const rd = (ptr, n) => hf().slice(ptr >> 2, (ptr >> 2) + n);
+    const wrap = (fn) => (...args) => { const s = w.getHeapPtr(); try { return fn(s, ...args); } finally { w.resetHeap(s); } };
+    console.log('[Aether] WASM SIMD loaded');
+    return {
+      matVec: wrap((s, mat, vec, rows, cols) => {
+        if (mat.byteLength > 100_000_000) return matVecJS(mat, vec, rows, cols);
+        const mP=w.allocate(mat.byteLength),vP=w.allocate(vec.byteLength),rP=w.allocate(rows*4);
+        cp(mP,mat);cp(vP,vec);w.matVecSimdBatch4(mP,vP,rP,rows,cols);return rd(rP,rows);
+      }),
+      rmsNorm: wrap((s,x,wt,eps) => {
+        const xP=w.allocate(x.byteLength),wP=w.allocate(wt.byteLength),rP=w.allocate(x.byteLength);
+        cp(xP,x);cp(wP,wt);w.rmsNormSimd(xP,wP,rP,x.length,eps);return rd(rP,x.length);
+      }),
+      softmax: wrap((s,x) => {
+        const xP=w.allocate(x.byteLength),rP=w.allocate(x.byteLength);
+        cp(xP,x);w.softmaxSimd(xP,rP,x.length);return rd(rP,x.length);
+      }),
+      fusedSiluMul: wrap((s,g,u) => {
+        const gP=w.allocate(g.byteLength),uP=w.allocate(u.byteLength),rP=w.allocate(g.byteLength);
+        cp(gP,g);cp(uP,u);w.fusedSiluMul(gP,uP,rP,g.length);return rd(rP,g.length);
+      }),
+      add: wrap((s,a,b) => {
+        const aP=w.allocate(a.byteLength),bP=w.allocate(b.byteLength),rP=w.allocate(a.byteLength);
+        cp(aP,a);cp(bP,b);w.addSimd(aP,bP,rP,a.length);return rd(rP,a.length);
+      }),
+    };
+  } catch(e) { console.warn('[Aether] WASM failed:',e.message); return null; }
+}
+
+// ─── JS Fallbacks ───────────────────────────────────────────────────────────
+function matVecJS(m,v,rows,cols){const o=new Float32Array(rows);for(let r=0;r<rows;r++){let s=0;const off=r*cols;for(let c=0;c<cols;c++)s+=m[off+c]*v[c];o[r]=s;}return o;}
+function rmsNormJS(x,w,eps){let ss=0;for(let i=0;i<x.length;i++)ss+=x[i]*x[i];ss=1/Math.sqrt(ss/x.length+eps);const o=new Float32Array(x.length);for(let i=0;i<x.length;i++)o[i]=x[i]*ss*w[i];return o;}
+function softmaxJS(x){let mx=-Infinity;for(let i=0;i<x.length;i++)if(x[i]>mx)mx=x[i];const o=new Float32Array(x.length);let s=0;for(let i=0;i<x.length;i++){o[i]=Math.exp(x[i]-mx);s+=o[i];}for(let i=0;i<x.length;i++)o[i]/=s;return o;}
+function fusedSiluMulJS(g,u){const o=new Float32Array(g.length);for(let i=0;i<g.length;i++){const v=g[i];o[i]=(v/(1+Math.exp(-v)))*u[i];}return o;}
+function addJS(a,b){const o=new Float32Array(a.length);for(let i=0;i<a.length;i++)o[i]=a[i]+b[i];return o;}
+const op = () => ({ matVec:simd?.matVec||matVecJS, rmsNorm:simd?.rmsNorm||rmsNormJS, softmax:simd?.softmax||softmaxJS, fusedSiluMul:simd?.fusedSiluMul||fusedSiluMulJS, add:simd?.add||addJS });
+
+// ─── Q8_0 Dequant ───────────────────────────────────────────────────────────
+function fp16(lo,hi){const h=lo|(hi<<8),s=(h>>15)&1,e=(h>>10)&0x1f,f=h&0x3ff;if(e===0)return f===0?0:(s?-1:1)*(f/1024)*Math.pow(2,-14);if(e===31)return 0;return(s?-1:1)*Math.pow(2,e-15)*(1+f/1024);}
+function dequantQ8(data,n){const o=new Float32Array(n),nb=Math.ceil(n/32);for(let b=0;b<nb;b++){const off=b*34,sc=fp16(data[off],data[off+1]);const cnt=Math.min(32,n-b*32);for(let i=0;i<cnt;i++){const v=data[off+2+i];o[b*32+i]=(v>127?v-256:v)*sc;}}return o;}
+function dequantByType(data,n,type){if(type===0)return new Float32Array(data.buffer,data.byteOffset,n);if(type===8)return dequantQ8(data,n);if(type===1){const o=new Float32Array(n);for(let i=0;i<n;i++)o[i]=fp16(data[i*2],data[i*2+1]);return o;}return dequantQ8(data,n);}
+
+// ─── GGUF Parser ────────────────────────────────────────────────────────────
+const MAGIC=0x46554747;const BSZ={2:32,3:32,6:32,7:32,8:32,9:32,10:256,11:256,12:256,13:256,14:256,15:256};const BBY={2:18,3:20,6:22,7:24,8:34,9:36,10:84,11:110,12:144,13:176,14:210,15:292};const TSZ={0:4,1:2,16:1,17:2,18:4,19:8,20:8};
+function csz(d,t){let n=1n;for(const x of d)n*=x;const b=BSZ[t];if(b&&BBY[t])return Math.ceil(Number(n)/b)*BBY[t];return Math.ceil(Number(n)*(TSZ[t]??4));}
+function rs(b,o){const l=Number(b.readBigUInt64LE(o));return{v:b.subarray(o+8,o+8+l).toString('utf8'),o:o+8+l};}
+function rv(b,o,t){switch(t){case 0:return{v:b.readUInt8(o),o:o+1};case 1:return{v:b.readInt8(o),o:o+1};case 2:return{v:b.readUInt16LE(o),o:o+2};case 3:return{v:b.readInt16LE(o),o:o+2};case 4:return{v:b.readUInt32LE(o),o:o+4};case 5:return{v:b.readInt32LE(o),o:o+4};case 6:return{v:b.readFloatLE(o),o:o+4};case 7:return{v:b.readUInt8(o)!==0,o:o+1};case 8:{const r=rs(b,o);return{v:r.v,o:r.o};}case 10:return{v:b.readBigUInt64LE(o),o:o+8};case 11:return{v:b.readBigInt64LE(o),o:o+8};case 12:return{v:b.readDoubleLE(o),o:o+8};case 9:{const at=b.readUInt32LE(o),al=Number(b.readBigUInt64LE(o+4));let co=o+12;const a=[];for(let i=0;i<al;i++){const r=rv(b,co,at);a.push(r.v);co=r.o;}return{v:a,o:co};}default:throw new Error(`Unknown GGUF type ${t}`);}}
+function parseGGUF(buf){let o=0;if(buf.readUInt32LE(o)!==MAGIC)throw new Error('Not GGUF');o+=4;o+=4;const tc=Number(buf.readBigUInt64LE(o));o+=8;const kc=Number(buf.readBigUInt64LE(o));o+=8;let align=32;for(let i=0;i<kc;i++){const{v:k,o:o1}=rs(buf,o);o=o1;const vt=buf.readUInt32LE(o);o+=4;const{v,o:o2}=rv(buf,o,vt);o=o2;if(k==='general.alignment')align=Number(v);}const tensors=[];for(let i=0;i<tc;i++){const{v:name,o:o1}=rs(buf,o);o=o1;const nd=buf.readUInt32LE(o);o+=4;const dims=[];for(let d=0;d<nd;d++){dims.push(buf.readBigUInt64LE(o));o+=8;}const type=buf.readUInt32LE(o);o+=4;const offset=buf.readBigUInt64LE(o);o+=8;tensors.push({name,dims,type,offset,size:csz(dims,type),numElements:Number(dims.reduce((a,b)=>a*b,1n))});}return{tensors,dataOffset:Math.ceil(o/align)*align};}
+
+// ─── BPE Tokenizer ──────────────────────────────────────────────────────────
+class Tok{constructor(j){const m=j.model||{};this.vocab=m.vocab||{};this.rev={};for(const[t,id]of Object.entries(this.vocab))this.rev[id]=t;this.mr={};for(const[i,mg]of(m.merges||[]).entries())this.mr[mg]=i;this.added={};if(j.added_tokens)for(const t of j.added_tokens)this.added[t.content]=t.id;}
+encode(text){const sp=/<\|[^|]+\|>/g;const parts=[];let last=0,m;while((m=sp.exec(text))!==null){if(m.index>last)parts.push({t:text.slice(last,m.index),s:false});parts.push({t:m[0],s:true});last=m.index+m[0].length;}if(last<text.length)parts.push({t:text.slice(last),s:false});const tokens=[];for(const p of parts){if(p.s){const id=this.added[p.t]??this.vocab[p.t];if(id!==undefined)tokens.push(id);continue;}const words=p.t.match(/\S+|\s+/g)||[];for(const w of words){let syms=[];for(const ch of w){if(this.vocab[ch]!==undefined)syms.push(ch);else for(const b of Buffer.from(ch,'utf8'))syms.push(`<0x${b.toString(16).toUpperCase().padStart(2,'0')}>`)}while(syms.length>1){let best=Infinity,bi=-1;for(let i=0;i<syms.length-1;i++){const r=this.mr[`${syms[i]} ${syms[i+1]}`];if(r!==undefined&&r<best){best=r;bi=i;}}if(bi===-1)break;syms.splice(bi,2,syms[bi]+syms[bi+1]);}for(const s of syms){const id=this.vocab[s]??this.added[s];if(id!==undefined)tokens.push(id);}}}return tokens;}
+decode(tokens){const p=[];for(const t of tokens){const s=this.rev[t];if(s&&s.startsWith('<0x')&&s.endsWith('>'))p.push(String.fromCharCode(parseInt(s.slice(3,-1),16)));else if(s&&!s.startsWith('<|'))p.push(s);}return p.join('').replace(/Ġ/g,' ').replace(/Ċ/g,'\n');}}
+
+// ─── RoPE (LLaMA style: ADJACENT pairs) ─────────────────────────────────────
+function applyRoPE(x, headDim, position, theta) {
+  for (let i = 0; i < headDim; i += 2) {
+    const freq = 1.0 / Math.pow(theta, (2 * (i/2)) / headDim);
+    const angle = position * freq;
+    const cos = Math.cos(angle), sin = Math.sin(angle);
+    const x0 = x[i], x1 = x[i + 1];
+    x[i]     = x0 * cos - x1 * sin;
+    x[i + 1] = x0 * sin + x1 * cos;
+  }
+}
+
+// ─── Models ─────────────────────────────────────────────────────────────────
+const models = {};
+let activeModel = null;
+
+function loadModel(name, ggufPath, tokPath, configName) {
+  const cfg = CONFIGS[configName] || CONFIGS['smollm2-360m'];
+  console.log(`[Aether] Loading ${name} (${configName}: ${cfg.numLayers}L, ${cfg.hiddenDim}d)...`);
+  const t0=Date.now();const buf=readFileSync(ggufPath);const parsed=parseGGUF(buf);
+  console.log(`[Aether] Parsed ${parsed.tensors.length} tensors in ${Date.now()-t0}ms`);
+  const tokenizer=new Tok(JSON.parse(readFileSync(tokPath,'utf8')));
+  const byName={};for(const t of parsed.tensors)byName[t.name]=t;
+  function get(nm){const t=byName[nm];if(!t)return null;const raw=new Uint8Array(buf.buffer,buf.byteOffset+parsed.dataOffset+Number(t.offset),t.size);return dequantByType(raw,t.numElements,t.type);}
+  console.log('[Aether] Dequantizing...');const tokenEmbd=get('token_embd.weight');const layers=[];
+  for(let i=0;i<cfg.numLayers;i++){if(i%8===0)console.log(`[Aether]   Layer ${i}/${cfg.numLayers}`);layers.push({an:get(`blk.${i}.attn_norm.weight`),fn:get(`blk.${i}.ffn_norm.weight`),qw:get(`blk.${i}.attn_q.weight`),kw:get(`blk.${i}.attn_k.weight`),vw:get(`blk.${i}.attn_v.weight`),ow:get(`blk.${i}.attn_output.weight`),gw:get(`blk.${i}.ffn_gate.weight`),uw:get(`blk.${i}.ffn_up.weight`),dw:get(`blk.${i}.ffn_down.weight`)});}
+  const outNorm=get('output_norm.weight');let outWeight=get('output.weight');if(!outWeight){console.log('[Aether] Tied embeddings');outWeight=tokenEmbd;}
+  const loadTime=Date.now()-t0;
+  console.log(`[Aether] ${name} loaded in ${(loadTime/1000).toFixed(1)}s`);
+  models[name]={tokenEmbd,layers,outNorm,outWeight,tokenizer,loadTime,name,config:cfg};
+  return models[name];
+}
+
+function getModel(name) {
+  return models[name] || models['base'] || Object.values(models)[0];
+}
+
+// ─── Forward Pass (returns raw logits) ──────────────────────────────────────
+function forwardPass(prompt, modelName) {
+  const o = op();
+  const model = getModel(modelName);
+  const mc = model.config; // model-specific config
+  const mcKvDim = mc.numKvHeads * mc.headDim;
+  const mcGqaRatio = mc.numHeads / mc.numKvHeads;
+  const chatPrompt = `<|im_start|>user\n${prompt}<|im_end|>\n<|im_start|>assistant\n`;
+  const inputTokens = model.tokenizer.encode(chatPrompt);
+  const allTokens = [...inputTokens];
+  const kvCache = Array.from({length:mc.numLayers},()=>({k:[],v:[]}));
+
+  return {
+    inputTokens, config: mc,
+    step(allToks, kvC, diag) {
+      const pos = allToks.length - 1;
+      const tid = allToks[allToks.length - 1];
+      const x0 = model.tokenEmbd.slice(tid*mc.hiddenDim,(tid+1)*mc.hiddenDim);
+      let x = x0;
+      const layerNorms = diag ? [] : null;
+      const attnEntropies = diag ? [] : null;
+
+      for (let l=0;l<mc.numLayers;l++) {
+        const ly=model.layers[l];
+        const xPrev = x;
+        const normed=o.rmsNorm(x,ly.an,mc.rmsNormEps);
+        const q=o.matVec(ly.qw,normed,mc.hiddenDim,mc.hiddenDim);
+        const k=o.matVec(ly.kw,normed,mcKvDim,mc.hiddenDim);
+        const v=o.matVec(ly.vw,normed,mcKvDim,mc.hiddenDim);
+        for(let h=0;h<mc.numHeads;h++)applyRoPE(q.subarray(h*mc.headDim,(h+1)*mc.headDim),mc.headDim,pos,mc.ropeTheta);
+        for(let h=0;h<mc.numKvHeads;h++)applyRoPE(k.subarray(h*mc.headDim,(h+1)*mc.headDim),mc.headDim,pos,mc.ropeTheta);
+        kvC[l].k.push(new Float32Array(k));kvC[l].v.push(new Float32Array(v));
+        const seqLen=kvC[l].k.length;const attnOut=new Float32Array(mc.hiddenDim);
+        const headEntropies = diag ? [] : null;
+        for(let h=0;h<mc.numHeads;h++){const kvH=Math.floor(h/mcGqaRatio);const qH=q.subarray(h*mc.headDim,(h+1)*mc.headDim);const scores=new Float32Array(seqLen);
+          for(let s=0;s<seqLen;s++){const kH=kvC[l].k[s].subarray(kvH*mc.headDim,(kvH+1)*mc.headDim);let dot=0;for(let d=0;d<mc.headDim;d++)dot+=qH[d]*kH[d];scores[s]=dot/Math.sqrt(mc.headDim);}
+          const w=softmaxJS(scores);
+          if (diag) { let he=0; for(let s=0;s<seqLen;s++) if(w[s]>1e-10) he-=w[s]*Math.log(w[s]); headEntropies.push(Math.round(he*1000)/1000); }
+          for(let s=0;s<seqLen;s++){const vH=kvC[l].v[s].subarray(kvH*mc.headDim,(kvH+1)*mc.headDim);const wt=w[s];for(let d=0;d<mc.headDim;d++)attnOut[h*mc.headDim+d]+=wt*vH[d];}}
+        if (diag) attnEntropies.push(headEntropies);
+        const projected=o.matVec(ly.ow,attnOut,mc.hiddenDim,mc.hiddenDim);const postAttn=o.add(x,projected);
+        const ffnIn=o.rmsNorm(postAttn,ly.fn,mc.rmsNormEps);const gate=o.matVec(ly.gw,ffnIn,mc.intermediateSize,mc.hiddenDim);
+        const up=o.matVec(ly.uw,ffnIn,mc.intermediateSize,mc.hiddenDim);const activated=o.fusedSiluMul(gate,up);
+        const down=o.matVec(ly.dw,activated,mc.hiddenDim,mc.intermediateSize);x=o.add(postAttn,down);
+
+        if (diag) {
+          let norm=0, delta=0, prevNorm=0;
+          for(let i=0;i<mc.hiddenDim;i++) { norm+=x[i]*x[i]; delta+=(x[i]-xPrev[i])**2; prevNorm+=xPrev[i]*xPrev[i]; }
+          layerNorms.push({ norm: Math.round(Math.sqrt(norm)*100)/100, residual: prevNorm>0 ? Math.round(Math.sqrt(delta/prevNorm)*1000)/1000 : 0 });
+        }
+      }
+      const finalNormed=o.rmsNorm(x,model.outNorm,mc.rmsNormEps);
+      const logits = o.matVec(model.outWeight,finalNormed,mc.vocabSize,mc.hiddenDim);
+      return { logits, layerNorms, attnEntropies };
+    }
+  };
+}
+
+// ─── Sampling Functions ─────────────────────────────────────────────────────
+
+function sampleStandard(logits, temperature = 0.7, topP = 0.9) {
+  const o = op();
+  const scaled = new Float32Array(logits.length);
+  for (let i = 0; i < logits.length; i++) scaled[i] = logits[i] / temperature;
+  const probs = o.softmax(scaled);
+  // Top-p
+  const indexed = Array.from(probs).map((p,i)=>({p,i})).sort((a,b)=>b.p-a.p);
+  let cumP = 0;
+  const candidates = [];
+  for (const {p,i} of indexed) { cumP += p; candidates.push({p,i}); if (cumP >= topP) break; }
+  const total = candidates.reduce((s,c) => s+c.p, 0);
+  const r = Math.random() * total;
+  let acc = 0;
+  for (const {p,i} of candidates) { acc += p; if (r < acc) return i; }
+  return candidates[0].i;
+}
+
+function glossolaliaMerge(rawLogits, temperatures = [0.4, 0.7, 1.0]) {
+  const V = rawLogits.length;
+  const logV = Math.log(V);
+  const agents = [];
+
+  for (const tau of temperatures) {
+    const scaled = new Float32Array(V);
+    for (let i = 0; i < V; i++) scaled[i] = rawLogits[i] / Math.max(tau, 0.01);
+    const probs = softmaxJS(scaled);
+
+    // Shannon entropy
+    let h = 0;
+    for (let i = 0; i < V; i++) { const p = probs[i]; if (p > 1e-12) h -= p * Math.log(p); }
+
+    // Deficit weight: low entropy = high confidence = high weight
+    const w = Math.max(1.0 - h / logV, 1e-8); // the sliver
+
+    // Top-5 for diagnostics
+    const top5 = Array.from(probs).map((p,i)=>({p,i})).sort((a,b)=>b.p-a.p).slice(0,5);
+
+    agents.push({ probs, entropy: h, weight: w, tau, top5 });
+  }
+
+  // Merge: weighted average
+  const totalW = agents.reduce((s,a) => s + a.weight, 0);
+  const merged = new Float32Array(V);
+  for (const a of agents) {
+    const nw = a.weight / totalW;
+    for (let i = 0; i < V; i++) merged[i] += nw * a.probs[i];
+  }
+
+  return { merged, agents, totalW };
+}
+
+function sampleGlossolalia(logits) {
+  const { merged, agents } = glossolaliaMerge(logits);
+  const indexed = Array.from(merged).map((p,i)=>({p,i})).sort((a,b)=>b.p-a.p);
+  let cumP = 0;
+  const candidates = [];
+  for (const {p,i} of indexed) { cumP += p; candidates.push({p,i}); if (cumP >= 0.95) break; }
+  const total = candidates.reduce((s,c) => s+c.p, 0);
+  const r = Math.random() * total;
+  let acc = 0;
+  for (const {p,i} of candidates) { acc += p; if (r < acc) return { tokenId: i, agents, merged }; }
+  return { tokenId: candidates[0].i, agents, merged };
+}
+
+// ─── C2/C3 Metacognitive Monitoring ─────────────────────────────────────────
+// C2: Detect entropy regime collapse (>50% drop in 3-token window)
+// C3: Detect absorbing states + apply diversity perturbation
+
+function detectRegimeChange(state) {
+  const h = state.entropyHistory;
+  if (h.length < 3) return false;
+  const recent = h.slice(-3);
+  const older = h.slice(-6, -3);
+  if (older.length === 0) return false;
+  const recentMean = recent.reduce((a, b) => a + b, 0) / recent.length;
+  const olderMean = older.reduce((a, b) => a + b, 0) / older.length;
+  return olderMean > 0 && recentMean < olderMean * 0.5;
+}
+
+function metacognitiveC3(logits, state, selectedToken, absorbingThreshold = 3) {
+  // Update repeat tracking
+  if (selectedToken === state.lastToken) state.repeatCount++;
+  else { state.repeatCount = 0; state.lastToken = selectedToken; }
+
+  const isAbsorbing = state.repeatCount >= absorbingThreshold;
+  const isRegimeCollapse = detectRegimeChange(state);
+
+  if (!isAbsorbing && !isRegimeCollapse) {
+    return { logits, perturbed: false, reason: null };
+  }
+
+  // Perturbation: eta scales with repetition depth
+  const eta = 0.1 * (1 + state.repeatCount);
+  const perturbed = new Float32Array(logits.length);
+  let totalOther = 0;
+  for (let i = 0; i < logits.length; i++) if (i !== selectedToken && logits[i] > 0) totalOther += logits[i];
+  const redistributionMass = Math.abs(logits[selectedToken]) * eta;
+
+  for (let i = 0; i < logits.length; i++) {
+    if (i === selectedToken) perturbed[i] = logits[i] * (1 - eta);
+    else if (totalOther > 0 && logits[i] > 0) perturbed[i] = logits[i] + redistributionMass * (logits[i] / totalOther);
+    else perturbed[i] = logits[i];
+  }
+
+  state.perturbationCount++;
+  return {
+    logits: perturbed,
+    perturbed: true,
+    reason: isAbsorbing ? `absorbing(${state.repeatCount} repeats)` : 'regime_collapse',
+    eta,
+  };
+}
+
+function sampleWithMetacog(rawLogits, metacogState) {
+  const { merged, agents } = glossolaliaMerge(rawLogits);
+
+  // Compute merged entropy for C2 tracking
+  let mergedEntropy = 0;
+  for (let i = 0; i < merged.length; i++) { const p = merged[i]; if (p > 1e-12) mergedEntropy -= p * Math.log(p); }
+  metacogState.entropyHistory.push(mergedEntropy);
+
+  // First sample from merged (pre-C3) to detect what token would be chosen
+  const indexed = Array.from(merged).map((p,i)=>({p,i})).sort((a,b)=>b.p-a.p);
+  let cumP = 0, candidates = [];
+  for (const {p,i} of indexed) { cumP += p; candidates.push({p,i}); if (cumP >= 0.95) break; }
+  let total = candidates.reduce((s,c) => s+c.p, 0);
+  let r = Math.random() * total, acc = 0, preC3Token = candidates[0].i;
+  for (const {p,i} of candidates) { acc += p; if (r < acc) { preC3Token = i; break; } }
+
+  // C3: check and potentially perturb
+  const c3 = metacognitiveC3(rawLogits, metacogState, preC3Token);
+
+  let finalToken = preC3Token;
+  if (c3.perturbed) {
+    // Re-merge with perturbed logits
+    const { merged: remerged } = glossolaliaMerge(c3.logits);
+    const ridx = Array.from(remerged).map((p,i)=>({p,i})).sort((a,b)=>b.p-a.p);
+    cumP = 0; candidates = [];
+    for (const {p,i} of ridx) { cumP += p; candidates.push({p,i}); if (cumP >= 0.95) break; }
+    total = candidates.reduce((s,c) => s+c.p, 0);
+    r = Math.random() * total; acc = 0;
+    for (const {p,i} of candidates) { acc += p; if (r < acc) { finalToken = i; break; } }
+  }
+
+  return {
+    tokenId: finalToken, agents, merged, mergedEntropy,
+    c3: { perturbed: c3.perturbed, reason: c3.reason, eta: c3.eta,
+          preC3Token, repeatCount: metacogState.repeatCount,
+          perturbationCount: metacogState.perturbationCount },
+  };
+}
+
+// ─── Generation Loops ───────────────────────────────────────────────────────
+
+function generateStandard(prompt, maxTokens = 8192, modelName = 'buleyean') {
+  const t0 = performance.now();
+  const model = getModel(modelName);
+  const fwd = forwardPass(prompt, modelName);
+  const allTokens = [...fwd.inputTokens];
+  const kvC = Array.from({length:model.config.numLayers},()=>({k:[],v:[]}));
+  const tokenTimes = [];
+
+  // Prefill
+  for (let i = 0; i < fwd.inputTokens.length; i++) {
+    fwd.step(allTokens.slice(0, i+1), kvC, false);
+  }
+
+  const perTokenInfo = [];
+
+  // Decode
+  for (let i = 0; i < maxTokens; i++) {
+    const ts = performance.now();
+    const { logits, layerNorms, attnEntropies } = fwd.step(allTokens, kvC, true);
+    const o2 = op();
+    const scaled = new Float32Array(logits.length);
+    for (let j = 0; j < logits.length; j++) scaled[j] = logits[j] / 0.7;
+    const probs = o2.softmax(scaled);
+
+    const chosen = sampleStandard(logits);
+    const chosenProb = probs[chosen];
+    const perplexity = chosenProb > 0 ? -Math.log2(chosenProb) : 99;
+
+    // Vocab coverage: tokens with >0.1% probability
+    let vocabCoverage = 0;
+    for (let j = 0; j < probs.length; j++) if (probs[j] > 0.001) vocabCoverage++;
+
+    // Top-5
+    const top5 = Array.from(probs).map((p,j)=>({p,i:j})).sort((a,b)=>b.p-a.p).slice(0,5)
+      .map(t => ({ token: model.tokenizer.decode([t.i]), prob: Math.round(t.p*1000)/1000 }));
+
+    tokenTimes.push(performance.now() - ts);
+    perTokenInfo.push({ perplexity: Math.round(perplexity*100)/100, chosenProb: Math.round(chosenProb*1000)/1000, vocabCoverage, top5, layerNorms, attnEntropies });
+
+    if (chosen === model.config.eosToken) break;
+    allTokens.push(chosen);
+  }
+
+  const genTokens = allTokens.slice(fwd.inputTokens.length);
+  const totalTime = performance.now() - t0;
+  const avgMs = tokenTimes.length > 0 ? tokenTimes.reduce((a,b)=>a+b,0)/tokenTimes.length : 0;
+
+  return {
+    text: model.tokenizer.decode(genTokens), tokens: genTokens.length,
+    totalTimeMs: Math.round(totalTime), avgTokenMs: Math.round(avgMs),
+    mode: 'standard', temperature: 0.7, topP: 0.9,
+    tokenDiagnostics: perTokenInfo,
+  };
+}
+
+function generateGlossolalia(prompt, maxTokens = 8192, modelName = 'buleyean') {
+  const t0 = performance.now();
+  const model = getModel(modelName);
+  const fwd = forwardPass(prompt, modelName);
+  const allTokens = [...fwd.inputTokens];
+  const kvC = Array.from({length:model.config.numLayers},()=>({k:[],v:[]}));
+  const tokenTimes = [];
+  const perTokenDiag = [];
+
+  // Prefill
+  for (let i = 0; i < fwd.inputTokens.length; i++) {
+    fwd.step(allTokens.slice(0, i+1), kvC, false);
+  }
+
+  // Decode with Glossolalia
+  for (let i = 0; i < maxTokens; i++) {
+    const ts = performance.now();
+    const { logits, layerNorms, attnEntropies } = fwd.step(allTokens, kvC, true);
+    const { tokenId, agents } = sampleGlossolalia(logits);
+
+    // Token-level perplexity from merged distribution
+    const { merged } = glossolaliaMerge(logits);
+    const chosenProb = merged[tokenId] || 0;
+    const perplexity = chosenProb > 0 ? -Math.log2(chosenProb) : 99;
+    let vocabCoverage = 0;
+    for (let j = 0; j < merged.length; j++) if (merged[j] > 0.001) vocabCoverage++;
+
+    tokenTimes.push(performance.now() - ts);
+
+    perTokenDiag.push({
+      agents: agents.map(a => ({
+        tau: a.tau, entropy: Math.round(a.entropy*1000)/1000, weight: Math.round(a.weight*1000)/1000,
+        top3: a.top5.slice(0,3).map(t => ({ token: model.tokenizer.decode([t.i]), prob: Math.round(t.p*1000)/1000 })),
+      })),
+      perplexity: Math.round(perplexity*100)/100,
+      chosenProb: Math.round(chosenProb*1000)/1000,
+      vocabCoverage,
+      layerNorms,
+      attnEntropies,
+    });
+
+    if (tokenId === model.config.eosToken) break;
+    allTokens.push(tokenId);
+  }
+
+  const genTokens = allTokens.slice(fwd.inputTokens.length);
+  const totalTime = performance.now() - t0;
+  const avgMs = tokenTimes.length > 0 ? tokenTimes.reduce((a,b)=>a+b,0)/tokenTimes.length : 0;
+
+  return {
+    text: model.tokenizer.decode(genTokens), tokens: genTokens.length,
+    totalTimeMs: Math.round(totalTime), avgTokenMs: Math.round(avgMs),
+    mode: 'glossolalia', temperatures: [0.4, 0.7, 1.0],
+    diagnostics: perTokenDiag,
+  };
+}
+
+// ─── Metacog Generation (Glossolalia + C2/C3) ───────────────────────────────
+
+function generateMetacog(prompt, maxTokens = 8192, modelName = 'buleyean') {
+  const t0 = performance.now();
+  const model = getModel(modelName);
+  const fwd = forwardPass(prompt, modelName);
+  const allTokens = [...fwd.inputTokens];
+  const kvC = Array.from({length:model.config.numLayers},()=>({k:[],v:[]}));
+  const tokenTimes = [];
+  const perTokenDiag = [];
+
+  // Metacognitive state (persists across tokens)
+  const metacogState = { repeatCount: 0, lastToken: -1, entropyHistory: [], perturbationCount: 0 };
+
+  // Prefill
+  for (let i = 0; i < fwd.inputTokens.length; i++) {
+    fwd.step(allTokens.slice(0, i+1), kvC, false);
+  }
+
+  // Decode with Glossolalia + C2/C3
+  for (let i = 0; i < maxTokens; i++) {
+    const ts = performance.now();
+    const { logits, layerNorms } = fwd.step(allTokens, kvC, true);
+    const result = sampleWithMetacog(logits, metacogState);
+
+    const chosenProb = result.merged[result.tokenId] || 0;
+    const perplexity = chosenProb > 0 ? -Math.log2(chosenProb) : 99;
+    let vocabCoverage = 0;
+    for (let j = 0; j < result.merged.length; j++) if (result.merged[j] > 0.001) vocabCoverage++;
+
+    tokenTimes.push(performance.now() - ts);
+
+    perTokenDiag.push({
+      agents: result.agents.map(a => ({
+        tau: a.tau, entropy: Math.round(a.entropy*1000)/1000, weight: Math.round(a.weight*1000)/1000,
+        top3: a.top5.slice(0,3).map(t => ({ token: model.tokenizer.decode([t.i]), prob: Math.round(t.p*1000)/1000 })),
+      })),
+      perplexity: Math.round(perplexity*100)/100,
+      chosenProb: Math.round(chosenProb*1000)/1000,
+      vocabCoverage,
+      layerNorms,
+      c3: result.c3,
+      mergedEntropy: Math.round(result.mergedEntropy*1000)/1000,
+    });
+
+    if (result.tokenId === model.config.eosToken) break;
+    allTokens.push(result.tokenId);
+  }
+
+  const genTokens = allTokens.slice(fwd.inputTokens.length);
+  const totalTime = performance.now() - t0;
+  const avgMs = tokenTimes.length > 0 ? tokenTimes.reduce((a,b)=>a+b,0)/tokenTimes.length : 0;
+
+  return {
+    text: model.tokenizer.decode(genTokens), tokens: genTokens.length,
+    totalTimeMs: Math.round(totalTime), avgTokenMs: Math.round(avgMs),
+    mode: 'metacog', temperatures: [0.4, 0.7, 1.0],
+    diagnostics: perTokenDiag,
+    metacogSummary: {
+      totalPerturbations: metacogState.perturbationCount,
+      finalRepeatCount: metacogState.repeatCount,
+      entropyHistory: metacogState.entropyHistory.map(h => Math.round(h*1000)/1000),
+    },
+  };
+}
+
+// ─── Personality Generation ────────────────────────────────��─────────────────
+
+function generatePersonality(prompt, maxTokens = 8192, modelName = 'buleyean-smollm2', personalityName = 'balanced') {
+  const personality = PERSONALITIES[personalityName] || PERSONALITIES.balanced;
+  const model = getModel(modelName);
+  const mc = model.config;
+  const t0 = performance.now();
+  const fwd = forwardPass(prompt, modelName);
+  const allTokens = [...fwd.inputTokens];
+  const kvC = Array.from({length:mc.numLayers},()=>({k:[],v:[]}));
+  const tokenTimes = [];
+  const metacogState = { repeatCount: 0, lastToken: -1, entropyHistory: [], perturbationCount: 0 };
+
+  for (let i = 0; i < fwd.inputTokens.length; i++) fwd.step(allTokens.slice(0,i+1), kvC, false);
+
+  for (let i = 0; i < maxTokens; i++) {
+    const ts = performance.now();
+    const { logits } = fwd.step(allTokens, kvC, false);
+    const { merged } = glossolaliaMerge(logits, personality.temps);
+
+    let mergedEntropy = 0;
+    for (let j = 0; j < merged.length; j++) { const p = merged[j]; if (p > 1e-12) mergedEntropy -= p * Math.log(p); }
+    metacogState.entropyHistory.push(mergedEntropy);
+
+    const indexed = Array.from(merged).map((p,j)=>({p,i:j})).sort((a,b)=>b.p-a.p);
+    let cumP = 0, candidates = [];
+    for (const {p,i} of indexed) { cumP += p; candidates.push({p,i}); if (cumP >= personality.topP) break; }
+    let total = candidates.reduce((s,c) => s+c.p, 0);
+    let r = Math.random() * total, acc = 0, preC3Token = candidates[0].i;
+    for (const {p,i} of candidates) { acc += p; if (r < acc) { preC3Token = i; break; } }
+
+    const c3 = metacognitiveC3(logits, metacogState, preC3Token, personality.absorbingThreshold);
+    let finalToken = preC3Token;
+    if (c3.perturbed) {
+      const { merged: rm } = glossolaliaMerge(c3.logits, personality.temps);
+      const ri = Array.from(rm).map((p,j)=>({p,i:j})).sort((a,b)=>b.p-a.p);
+      cumP = 0; candidates = [];
+      for (const {p,i} of ri) { cumP += p; candidates.push({p,i}); if (cumP >= personality.topP) break; }
+      total = candidates.reduce((s,c) => s+c.p, 0);
+      r = Math.random() * total; acc = 0;
+      for (const {p,i} of candidates) { acc += p; if (r < acc) { finalToken = i; break; } }
+    }
+
+    tokenTimes.push(performance.now() - ts);
+    if (finalToken === mc.eosToken) break;
+    allTokens.push(finalToken);
+  }
+
+  const genTokens = allTokens.slice(fwd.inputTokens.length);
+  const totalTime = performance.now() - t0;
+  const avgMs = tokenTimes.length > 0 ? tokenTimes.reduce((a,b)=>a+b,0)/tokenTimes.length : 0;
+
+  return {
+    text: model.tokenizer.decode(genTokens), tokens: genTokens.length,
+    totalTimeMs: Math.round(totalTime), avgTokenMs: Math.round(avgMs),
+    mode: 'personality', personality: personalityName,
+    personalityLabel: personality.label,
+    temperatures: personality.temps,
+    modelName,
+    metacogSummary: { totalPerturbations: metacogState.perturbationCount },
+  };
+}
+
+// ─── HTTP Server ────────────────────────────────────────────────────────────
+const server = createServer((req, res) => {
+  let body = '';
+  req.on('data', c => body += c);
+  req.on('end', () => {
+    try {
+      if (req.url === '/health') {
+        res.writeHead(200,{'Content-Type':'application/json'});
+        res.end(JSON.stringify({status:'ok',models:Object.keys(models),personalities:Object.keys(PERSONALITIES),simd:!!simd}));
+        return;
+      }
+      if (req.method !== 'POST') { res.writeHead(404); res.end(); return; }
+      const { prompt, max_tokens, model, personality } = JSON.parse(body);
+      const mn = model || 'buleyean-smollm2';
+      let result;
+      if (req.url === '/generate-personality') result = generatePersonality(prompt, max_tokens||128, mn, personality||'balanced');
+      else if (req.url === '/generate-standard') result = generateStandard(prompt, max_tokens||128, mn);
+      else if (req.url === '/generate-glossolalia') result = generateGlossolalia(prompt, max_tokens||128, mn);
+      else if (req.url === '/generate-metacog') result = generateMetacog(prompt, max_tokens||128, mn);
+      else { res.writeHead(404); res.end(); return; }
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+    } catch (e) {
+      console.error('[Aether]', e);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+  });
+});
+
+// ─── Model Registry ─────────────────────────────────────────────────────────
+const MODEL_REGISTRY = [
+  { name: 'buleyean-smollm2', repo: 'forkjoin-ai/buleyean-smollm2-360m', file: 'buleyean-smollm2-360m-q8_0.gguf', tokRepo: 'HuggingFaceTB/SmolLM2-360M-Instruct', config: 'smollm2-360m' },
+  { name: 'base-smollm2', repo: 'bartowski/SmolLM2-360M-Instruct-GGUF', file: 'SmolLM2-360M-Instruct-Q8_0.gguf', tokRepo: 'HuggingFaceTB/SmolLM2-360M-Instruct', config: 'smollm2-360m' },
+  { name: 'buleyean-qwen', repo: 'forkjoin-ai/buleyean-qwen2.5-0.5b', file: 'buleyean-qwen2.5-0.5b-q8_0.gguf', tokRepo: 'Qwen/Qwen2.5-0.5B-Instruct', config: 'qwen2.5-0.5b' },
+  { name: 'base-qwen', repo: 'bartowski/Qwen2.5-0.5B-Instruct-GGUF', file: 'Qwen2.5-0.5B-Instruct-Q8_0.gguf', tokRepo: 'Qwen/Qwen2.5-0.5B-Instruct', config: 'qwen2.5-0.5b' },
+];
+
+function dl(repo, file) {
+  const local = `/tmp/hf_cache/${file}`;
+  if (existsSync(local)) return local;
+  console.log(`[Aether] Downloading ${repo}/${file}...`);
+  execSync(`python3 -c "from huggingface_hub import hf_hub_download; hf_hub_download('${repo}', '${file}', cache_dir='/tmp/hf_cache', local_dir='/tmp/hf_cache')"`, { stdio: 'inherit' });
+  return local;
+}
+
+function dlTok(repo) {
+  const local = `/tmp/hf_cache/tokenizer-${repo.replace(/\//g,'-')}.json`;
+  if (existsSync(local)) return local;
+  console.log(`[Aether] Downloading tokenizer from ${repo}...`);
+  execSync(`python3 -c "from huggingface_hub import hf_hub_download; p=hf_hub_download('${repo}', 'tokenizer.json'); import shutil; shutil.copy(p, '${local}')"`, { stdio: 'inherit' });
+  return local;
+}
+
+async function main() {
+  simd = await loadSIMD();
+
+  // Load all models that fit in memory (load sequentially, keep all)
+  for (const m of MODEL_REGISTRY) {
+    try {
+      const gguf = dl(m.repo, m.file);
+      const tok = dlTok(m.tokRepo);
+      loadModel(m.name, gguf, tok, m.config);
+    } catch (e) {
+      console.error(`[Aether] Failed to load ${m.name}: ${e.message}`);
+    }
+  }
+
+  server.listen(PORT, '127.0.0.1', () => console.log(`[Aether] http://127.0.0.1:${PORT} (SIMD: ${!!simd}, models: ${Object.keys(models).join(', ')})`));
+}
+
+main().catch(e => { console.error('[Aether] Fatal:', e); process.exit(1); });

app.py

@@ -0,0 +1,199 @@
+"""
+Five Bules -- Personality as Void Walking
+Act 4: Five personality profiles on fork/race/fold/vent/interfere axes.
+
+Same model, same prompt. Different personality = different decoder config.
+Explorer forks broadly. Builder folds tightly. Creative races freely.
+Anxious interferes early. Balanced converges to phi.
+"""
+
+import gradio as gr
+import json
+import time
+import subprocess
+import urllib.request
+import urllib.error
+import select
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+print("[Five Bules] Starting Aether...", flush=True)
+aether_proc = subprocess.Popen(
+    ["node", "aether-server.mjs"],
+    env={**__import__('os').environ, "AETHER_PORT": "7861"},
+    stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+)
+
+print("[Five Bules] Waiting for Aether...", flush=True)
+for attempt in range(300):
+    try:
+        req = urllib.request.Request("http://127.0.0.1:7861/health")
+        resp = urllib.request.urlopen(req, timeout=2)
+        health = json.loads(resp.read())
+        if health.get("status") == "ok" and health.get("models"):
+            print(f"[Five Bules] Aether ready (models: {health.get('models')})", flush=True)
+            break
+    except Exception:
+        pass
+    if aether_proc.stdout and select.select([aether_proc.stdout], [], [], 0)[0]:
+        line = aether_proc.stdout.readline()
+        if line: print(f"  {line.decode().strip()}", flush=True)
+    time.sleep(1)
+else:
+    print("[Five Bules] WARNING: Aether not ready after 300s", flush=True)
+
+
+def call_personality(prompt, max_tokens, model, personality):
+    try:
+        data = json.dumps({"prompt": prompt, "max_tokens": max_tokens, "model": model, "personality": personality}).encode()
+        req = urllib.request.Request("http://127.0.0.1:7861/generate-personality", data=data, headers={"Content-Type": "application/json"})
+        resp = urllib.request.urlopen(req, timeout=600)
+        return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        body = e.read().decode() if e.fp else str(e)
+        try: detail = json.loads(body).get("error", body[:300])
+        except Exception: detail = body[:300]
+        return {"text": f"[Error: {detail}]", "tokens": 0, "totalTimeMs": 0, "avgTokenMs": 0}
+    except Exception as e:
+        return {"text": f"[Error: {e}]", "tokens": 0, "totalTimeMs": 0, "avgTokenMs": 0}
+
+
+def run_all(prompt, max_tokens, model_name):
+    if not prompt or not prompt.strip():
+        yield "", "", "", "", "", ""
+        return
+
+    max_tokens = int(max_tokens)
+    personas = ["explorer", "builder", "creative", "anxious", "balanced"]
+    results = {p: [None] for p in personas}
+
+    def run(p):
+        results[p][0] = call_personality(prompt, max_tokens, model_name, p)
+
+    def fmt(r):
+        return r["text"] if r else "generating..."
+
+    def stats(r):
+        if not r: return "running..."
+        return f'{r["tokens"]} tok / {r["totalTimeMs"]/1000:.1f}s / C3: {r.get("metacogSummary",{}).get("totalPerturbations",0)}'
+
+    def build():
+        texts = tuple(fmt(results[p][0]) for p in personas)
+        diag_lines = []
+        for p in personas:
+            r = results[p][0]
+            if r:
+                diag_lines.append(f"[{p.upper()}] {stats(r)}")
+                diag_lines.append(f"  temps={r.get('temperatures','?')} | {r.get('personalityLabel','')}")
+                diag_lines.append("")
+        return texts + ("\n".join(diag_lines),)
+
+    with ThreadPoolExecutor(max_workers=5) as pool:
+        futures = {pool.submit(run, p): p for p in personas}
+        for future in as_completed(futures):
+            future.result()
+            yield build()
+    yield build()
+
+
+CSS = """
+.gradio-container { max-width: 1200px !important; margin: 0 auto !important; }
+.gradio-container, .dark { background: #09090b !important; }
+#hero { text-align: center; padding: 2rem 0 1rem; }
+#hero h1 { font-size: 2.5rem; font-weight: 300; letter-spacing: -0.02em; color: #fafafa; margin: 0; }
+#hero .accent { color: #f59e0b; }
+#hero .subtitle { color: #71717a; font-size: 0.95rem; margin-top: 0.5rem; }
+.response-card { background: #0c0c0f !important; border: 1px solid #1f1f23 !important; border-radius: 8px !important; }
+.response-card textarea { background: #0c0c0f !important; border: none !important; color: #e4e4e7 !important; font-size: 0.9rem !important; line-height: 1.5 !important; }
+.p-label { font-size: 0.75rem !important; text-transform: uppercase !important; letter-spacing: 0.05em !important; font-weight: 600 !important; }
+#prompt-input > label > span { display: none !important; }
+#prompt-input textarea { background: #111114 !important; border: 1px solid #1f1f23 !important; border-radius: 8px !important; color: #fafafa !important; font-size: 1rem !important; padding: 1rem !important; }
+#prompt-input textarea:focus { border-color: #f59e0b !important; }
+#gen-btn { background: #f59e0b !important; border: none !important; border-radius: 8px !important; font-weight: 500 !important; color: #09090b !important; }
+.prompt-chip { background: #111114 !important; border: 1px solid #1f1f23 !important; border-radius: 6px !important; color: #a1a1aa !important; font-size: 0.85rem !important; }
+.prompt-chip:hover { border-color: #f59e0b !important; color: #fafafa !important; }
+#footer { text-align: center; padding: 2rem 0; border-top: 1px solid #1f1f23; margin-top: 2rem; }
+#footer p { color: #52525b; font-size: 0.8rem; }
+#footer a { color: #f59e0b; text-decoration: none; }
+footer.svelte-1ax1toq { display: none !important; }
+.built-with { display: none !important; }
+"""
+
+with gr.Blocks(css=CSS, theme=gr.themes.Base(primary_hue="yellow", neutral_hue="zinc"), title="Five Bules") as demo:
+
+    gr.HTML("""
+    <div id="hero">
+        <h1>The Five <span class="accent">Bules</span></h1>
+        <p class="subtitle">Personality as void walking. Same model, same prompt, five decoder configurations.<br/>
+        Each personality is a position on the fork/race/fold/vent/interfere axes.<br/>
+        THM-FIVE-BULE-PERSONALITY -- all five converge to &phi;<sub>inv</sub> &approx; 0.618.</p>
+    </div>
+    """)
+
+    with gr.Row():
+        prompt = gr.Textbox(elem_id="prompt-input", placeholder="Tell me about yourself.", lines=2, label="Prompt", show_label=False, interactive=True, scale=4)
+        with gr.Column(scale=1):
+            model_choice = gr.Dropdown(
+                choices=["buleyean-smollm2", "base-smollm2", "buleyean-qwen", "base-qwen"],
+                value="buleyean-smollm2", label="Model",
+            )
+            max_tok = gr.Slider(minimum=8, maximum=8192, value=64, step=1, label="Max tokens")
+
+    btn = gr.Button("Generate All Five", elem_id="gen-btn", variant="primary")
+
+    with gr.Row(equal_height=True):
+        with gr.Column():
+            gr.HTML('<p class="p-label" style="color:#3b82f6">Explorer -- forks broadly</p>')
+            explorer_out = gr.Textbox(lines=8, show_label=False, interactive=False, elem_classes=["response-card"])
+        with gr.Column():
+            gr.HTML('<p class="p-label" style="color:#22c55e">Builder -- folds tightly</p>')
+            builder_out = gr.Textbox(lines=8, show_label=False, interactive=False, elem_classes=["response-card"])
+        with gr.Column():
+            gr.HTML('<p class="p-label" style="color:#a855f7">Creative -- races freely</p>')
+            creative_out = gr.Textbox(lines=8, show_label=False, interactive=False, elem_classes=["response-card"])
+
+    with gr.Row(equal_height=True):
+        with gr.Column():
+            gr.HTML('<p class="p-label" style="color:#ef4444">Anxious -- interferes early</p>')
+            anxious_out = gr.Textbox(lines=8, show_label=False, interactive=False, elem_classes=["response-card"])
+        with gr.Column():
+            gr.HTML('<p class="p-label" style="color:#f59e0b">Balanced -- phi convergence</p>')
+            balanced_out = gr.Textbox(lines=8, show_label=False, interactive=False, elem_classes=["response-card"])
+        with gr.Column():
+            gr.HTML('<p class="p-label" style="color:#71717a">Diagnostics</p>')
+            diag_out = gr.Textbox(lines=8, show_label=False, interactive=False, elem_classes=["response-card"])
+
+    outputs = [explorer_out, builder_out, creative_out, anxious_out, balanced_out, diag_out]
+    inputs = [prompt, max_tok, model_choice]
+
+    def run(p, mt, m):
+        for vals in run_all(p, mt, m):
+            yield vals
+
+    btn.click(run, inputs, outputs)
+    prompt.submit(run, inputs, outputs)
+
+    gr.HTML('<p style="color:#52525b; font-size:0.8rem; margin-top:1.5rem; margin-bottom:0.5rem;">Try these:</p>')
+    with gr.Row():
+        for p in ["Tell me about yourself.", "What scares you?", "Describe the perfect day.", "How do you handle failure?"]:
+            gr.Button(p, size="sm", elem_classes=["prompt-chip"]).click(
+                fn=lambda x=p: x, outputs=[prompt]
+            ).then(fn=run, inputs=inputs, outputs=outputs)
+
+    gr.HTML("""
+    <div id="footer">
+        <p style="color:#a1a1aa; font-size:0.85rem; margin-bottom:0.5rem;">
+            SmolLM2-360M + Qwen2.5-0.5B &middot; Aether WASM-SIMD &middot; Two architectures, five personalities
+        </p>
+        <p>
+            <a href="https://forkracefold.com/">Whitepaper</a> &middot;
+            <a href="https://huggingface.co/spaces/forkjoin-ai/the-void">The Void</a> &middot;
+            <a href="https://huggingface.co/spaces/forkjoin-ai/glossolalia">Glossolalia</a> &middot;
+            <a href="https://huggingface.co/spaces/forkjoin-ai/metacog">Metacog</a>
+        </p>
+        <p style="margin-top:1rem;">Personality = 5 measurable distances &middot; THM-PHI-ATTRACTOR &middot;
+        <a href="https://forkracefold.com/">&phi;&sup2; = &phi; + 1</a></p>
+    </div>
+    """)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=5.0.0,<6.0.0
+huggingface-hub>=0.26.0

simd-kernels.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a05084c8998119797c6e80927678ce007e3285b78c6e7e8feee223ca4bb13636
+size 14553