Add resonance orchestrator: graph.rs, pipeline.rs, nodes.rs, phi.rs

Browse files

Files changed (8) hide show

resonance/Cargo.toml +18 -0
resonance/demo.html +495 -0
resonance/src/graph.rs +198 -0
resonance/src/lib.rs +17 -0
resonance/src/main.rs +73 -0
resonance/src/nodes.rs +135 -0
resonance/src/phi.rs +50 -0
resonance/src/pipeline.rs +127 -0

resonance/Cargo.toml ADDED Viewed

	@@ -0,0 +1,18 @@

+[package]
+name = "resonance"
+version = "0.1.0"
+edition = "2021"
+description = "ResonanceGraph — DAG pipeline with Metatron node injection. FCC-φ-∂-2026."
+authors = ["Ahmad Parr <ahmedparr93@gmail.com>"]
+[lib]
+name = "resonance"
+path = "src/lib.rs"
+[[bin]]
+name = "resonance-demo"
+path = "src/main.rs"
+[dependencies]
+sha2 = "0.10"
+hex = "0.4"

resonance/demo.html ADDED Viewed

	@@ -0,0 +1,495 @@

+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>ResonanceGraph · METATRON NODE · FCC-φ-∂-2026</title>
+<style>
+:root{--bg:#040408;--green:#00ff88;--orange:#f97316;--purple:#a78bfa;--red:#f43f5e;--blue:#818cf8;--cyan:#22d3ee;--dim:#1e293b;--mid:#334155;--text:#94a3b8}
+*{box-sizing:border-box;margin:0;padding:0}
+body{background:var(--bg);color:var(--text);font-family:'Courier New',monospace;min-height:100vh;overflow-x:hidden}
+header{border-bottom:1px solid var(--dim);padding:12px 24px;display:flex;align-items:center;gap:16px}
+.logo{color:var(--green);font-size:11px;letter-spacing:3px}
+.sub{color:var(--mid);font-size:10px;letter-spacing:2px}
+.fingerprint{margin-left:auto;color:var(--mid);font-size:9px;letter-spacing:2px}
+.grid{display:grid;grid-template-columns:1fr 380px;gap:0;height:calc(100vh - 49px)}
+/* ── DAG PANEL ── */
+.dag-panel{border-right:1px solid var(--dim);position:relative;overflow:hidden}
+#dag-svg{width:100%;height:100%}
+.node-label{font-size:11px;font-family:'Courier New',monospace;letter-spacing:1px}
+/* ── RIGHT PANEL ── */
+.right{display:flex;flex-direction:column;overflow:hidden}
+.controls{padding:16px;border-bottom:1px solid var(--dim)}
+.section-label{font-size:9px;letter-spacing:2px;color:var(--mid);margin-bottom:8px}
+.btn{width:100%;padding:10px;border:1px solid var(--green);background:rgba(0,255,136,0.06);color:var(--green);font-family:'Courier New',monospace;font-size:12px;letter-spacing:2px;cursor:pointer;transition:all .15s}
+.btn:hover{background:rgba(0,255,136,0.12)}
+.btn:disabled{border-color:var(--dim);color:var(--mid);cursor:not-allowed}
+.btn.orange{border-color:var(--orange);background:rgba(249,115,22,0.06);color:var(--orange)}
+.btn.orange:hover{background:rgba(249,115,22,0.12)}
+.symbol-row{display:flex;gap:6px;margin-top:8px}
+.sym-btn{flex:1;padding:6px;border:1px solid var(--dim);background:none;color:var(--text);font-family:'Courier New',monospace;font-size:11px;cursor:pointer;transition:all .15s}
+.sym-btn:hover,.sym-btn.active{border-color:var(--purple);color:var(--purple);background:rgba(167,139,250,0.08)}
+.trace{flex:1;overflow-y:auto;padding:12px}
+.stage{padding:8px 10px;margin-bottom:6px;border-left:2px solid var(--dim);font-size:11px;line-height:1.6;transition:all .3s;opacity:0.3}
+.stage.active{border-left-color:var(--orange);opacity:1}
+.stage.done{border-left-color:var(--green);opacity:1}
+.stage.metatron{border-left-color:var(--purple)}
+.stage-name{color:var(--green);letter-spacing:1px;font-size:10px}
+.stage-agent{color:var(--mid);font-size:9px}
+.stage-act{float:right;color:var(--orange);font-size:10px}
+.stage-note{color:var(--text);font-size:10px;margin-top:3px}
+.result-box{padding:12px;border-top:1px solid var(--dim);border-bottom:1px solid var(--dim)}
+.seal-line{font-size:9px;color:var(--purple);letter-spacing:1px;word-break:break-all;margin-top:4px}
+.output-text{font-size:11px;color:var(--green);line-height:1.6;margin-bottom:6px}
+.approved-badge{display:inline-block;padding:2px 8px;font-size:9px;letter-spacing:2px;border:1px solid var(--green);color:var(--green)}
+.offline-badge{border-color:var(--red);color:var(--red)}
+/* cube panel */
+.cube-panel{padding:12px;border-top:1px solid var(--dim)}
+.cube-title{font-size:9px;letter-spacing:2px;color:var(--mid);margin-bottom:8px}
+#cube-svg{width:100%;height:140px}
+</style>
+</head>
+<body>
+<header>
+  <span class="logo">RESONANCE GRAPH</span>
+  <span class="sub">METATRON NODE · DAG PIPELINE</span>
+  <span class="fingerprint">FCC-φ-∂-2026 · AHMAD PARR · SNAPKITTY SOVEREIGN</span>
+</header>
+<div class="grid">
+  <!-- DAG SVG -->
+  <div class="dag-panel">
+    <svg id="dag-svg" viewBox="0 0 800 600" preserveAspectRatio="xMidYMid meet">
+      <defs>
+        <marker id="arrow" markerWidth="8" markerHeight="8" refX="6" refY="3" orient="auto">
+          <path d="M0,0 L0,6 L8,3 z" fill="#334155"/>
+        </marker>
+        <marker id="arrow-green" markerWidth="8" markerHeight="8" refX="6" refY="3" orient="auto">
+          <path d="M0,0 L0,6 L8,3 z" fill="#00ff88"/>
+        </marker>
+        <marker id="arrow-purple" markerWidth="8" markerHeight="8" refX="6" refY="3" orient="auto">
+          <path d="M0,0 L0,6 L8,3 z" fill="#a78bfa"/>
+        </marker>
+        <filter id="glow-green">
+          <feGaussianBlur stdDeviation="3" result="b"/>
+          <feMerge><feMergeNode in="b"/><feMergeNode in="SourceGraphic"/></feMerge>
+        </filter>
+        <filter id="glow-purple">
+          <feGaussianBlur stdDeviation="4" result="b"/>
+          <feMerge><feMergeNode in="b"/><feMergeNode in="SourceGraphic"/></feMerge>
+        </filter>
+        <filter id="glow-orange">
+          <feGaussianBlur stdDeviation="3" result="b"/>
+          <feMerge><feMergeNode in="b"/><feMergeNode in="SourceGraphic"/></feMerge>
+        </filter>
+        <radialGradient id="sink-grad" cx="50%" cy="50%" r="50%">
+          <stop offset="0%" stop-color="#a78bfa" stop-opacity="0.9"/>
+          <stop offset="100%" stop-color="#040408" stop-opacity="0"/>
+        </radialGradient>
+      </defs>
+      <g id="dag-layer"></g>
+    </svg>
+  </div>
+  <!-- RIGHT -->
+  <div class="right">
+    <div class="controls">
+      <div class="section-label">INPUT SYMBOL</div>
+      <div class="symbol-row">
+        <button class="sym-btn active" data-sym="ME" data-glyph="𒈨">𒈨 ME</button>
+        <button class="sym-btn" data-sym="AN" data-glyph="𒀭">𒀭 AN</button>
+        <button class="sym-btn" data-sym="KI" data-glyph="𒆠">𒆠 KI</button>
+        <button class="sym-btn" data-sym="DINGIR" data-glyph="𒀭">𒀭 DINGIR</button>
+      </div>
+      <div style="margin-top:10px;display:flex;flex-direction:column;gap:6px">
+        <button class="btn" id="inject-btn">⬡ INJECT METATRON CUBE</button>
+        <button class="btn orange" id="run-btn">▶ PUBLIC_FORWARD</button>
+      </div>
+    </div>
+    <div class="trace" id="trace"></div>
+    <div class="result-box" id="result-box" style="display:none">
+      <div class="section-label">PIPELINE OUTPUT</div>
+      <div class="output-text" id="output-text"></div>
+      <span class="approved-badge" id="approved-badge">APPROVED</span>
+      <div class="seal-line" id="seal-line"></div>
+    </div>
+    <div class="cube-panel">
+      <div class="cube-title">AN-KI MAGMA CORE · METATRON PROJECTION</div>
+      <svg id="cube-svg" viewBox="0 0 300 140">
+        <g id="cube-layer"></g>
+        <text x="150" y="135" text-anchor="middle" font-family="Courier New" font-size="7" fill="#1e293b" letter-spacing="2">FCC-φ-∂-2026 · METATRON CUBE · AN-KI MAGMA RESONANCE</text>
+      </svg>
+    </div>
+  </div>
+</div>
+<script>
+const PHI = 1.6180339887498948;
+const NS  = 'http://www.w3.org/2000/svg';
+// ── State ────────────────────────────────────────────────────────────────────
+const state = {
+  metatron: false,
+  symbol:   { sym: 'ME', glyph: '𒈨' },
+  running:  false,
+  cubeAnim: 0,
+};
+// ── Node definitions ─────────────────────────────────────────────────────────
+const BASE_NODES = [
+  { id: 0, kind: 'Source',          agent: '—',           depth: 0 },
+  { id: 1, kind: 'Retrieval',       agent: 'ORACLE',       depth: 1 },
+  { id: 2, kind: 'Filtering',       agent: 'SENTINEL',     depth: 2 },
+  { id: 3, kind: 'Ranking',         agent: 'PRISM/AXIOM',  depth: 3 },
+  { id: 4, kind: 'ContextAssembly', agent: 'NEXUS',        depth: 4 },
+  { id: 5, kind: 'Reasoning',       agent: 'MagmaCore',    depth: 5 },
+  { id: 6, kind: 'MagmaCore',       agent: 'BOB',          depth: 6 },
+];
+const METATRON_NODE = { id: 7, kind: 'Metatron', agent: 'METATRON', depth: 5 };
+const BASE_EDGES = [[0,1],[1,2],[2,3],[3,4],[4,5],[5,6]];
+const META_EDGES = [[4,7],[7,6]]; // ContextAssembly → METATRON → MagmaCore
+// ── Layout positions ─────────────────────────────────────────────────────────
+function getPos(id, metatron) {
+  // Linear layout without METATRON
+  const linear = {
+    0: [100, 300], 1: [200, 300], 2: [300, 300],
+    3: [400, 300], 4: [500, 300], 5: [600, 300], 6: [700, 300],
+  };
+  const withMeta = {
+    0: [60, 300], 1: [150, 300], 2: [240, 300],
+    3: [330, 300], 4: [420, 300],
+    5: [560, 380], // Reasoning drops down
+    7: [560, 220], // METATRON rises up
+    6: [700, 300], // MagmaCore center
+  };
+  return metatron ? (withMeta[id] || [0,0]) : (linear[id] || [0,0]);
+}
+function phiWeight(depth) { return Math.pow(PHI, depth + 1); }
+function activationBias(sym, kind) {
+  if (sym === 'ME') return 1.0;
+  if (sym === 'AN') return kind === 'Retrieval' ? 1.4 : kind === 'Reasoning' ? 1.2 : 0.8;
+  if (sym === 'KI') return (kind === 'Filtering' || kind === 'ContextAssembly') ? 1.4 : 0.9;
+  if (sym === 'DINGIR') return (kind === 'Reasoning' || kind === 'MagmaCore') ? 1.6 : kind === 'Metatron' ? 1.8 : 0.7;
+  return 1.0;
+}
+function activation(node, sym) {
+  return phiWeight(node.depth) * activationBias(sym, node.kind);
+}
+function djb2(str) {
+  let h = 5381;
+  for (let i = 0; i < str.length; i++) h = ((h << 5) + h + str.charCodeAt(i)) >>> 0;
+  return h.toString(16).padStart(8, '0');
+}
+function fakeSha(str) {
+  let s = djb2(str);
+  while (s.length < 64) s += djb2(s + str);
+  return s.slice(0, 64);
+}
+// ── SVG helpers ──────────────────────────────────────────────────────────────
+function el(tag, attrs, text) {
+  const e = document.createElementNS(NS, tag);
+  Object.entries(attrs).forEach(([k,v]) => e.setAttribute(k,v));
+  if (text !== undefined) e.textContent = text;
+  return e;
+}
+function nodeColor(kind, status) {
+  if (status === 'done' && kind === 'Metatron') return '#a78bfa';
+  if (status === 'done') return '#00ff88';
+  if (status === 'active') return '#f97316';
+  if (kind === 'MagmaCore') return '#a78bfa';
+  if (kind === 'Metatron') return '#818cf8';
+  return '#334155';
+}
+// ── Draw DAG ─────────────────────────────────────────────────────────────────
+function drawDAG(statusMap = {}) {
+  const layer = document.getElementById('dag-layer');
+  layer.innerHTML = '';
+  const nodes = state.metatron ? [...BASE_NODES, METATRON_NODE] : BASE_NODES;
+  const edges = state.metatron ? [...BASE_EDGES, ...META_EDGES] : BASE_EDGES;
+  // Draw edges
+  edges.forEach(([a, b]) => {
+    const [x1,y1] = getPos(a, state.metatron);
+    const [x2,y2] = getPos(b, state.metatron);
+    const isMeta = a === 7 || b === 7;
+    const statusA = statusMap[a] || 'idle';
+    const statusB = statusMap[b] || 'idle';
+    const active = (statusA === 'done' && (statusB === 'active' || statusB === 'done'));
+    const color = active ? (isMeta ? '#a78bfa' : '#00ff88') : '#1e293b';
+    const marker = active ? (isMeta ? 'url(#arrow-purple)' : 'url(#arrow-green)') : 'url(#arrow)';
+    // offset for radius
+    const dx = x2 - x1, dy = y2 - y1;
+    const dist = Math.sqrt(dx*dx + dy*dy);
+    const ux = dx/dist, uy = dy/dist;
+    const r = 22;
+    const line = el('line', {
+      x1: x1 + ux*r, y1: y1 + uy*r,
+      x2: x2 - ux*r, y2: y2 - uy*r,
+      stroke: color, 'stroke-width': active ? 1.5 : 0.8,
+      'marker-end': marker,
+    });
+    layer.appendChild(line);
+  });
+  // Draw nodes
+  nodes.forEach(node => {
+    const [cx, cy] = getPos(node.id, state.metatron);
+    const status = statusMap[node.id] || 'idle';
+    const color = nodeColor(node.kind, status);
+    const isMetatron = node.kind === 'Metatron';
+    const isSink = node.kind === 'MagmaCore';
+    if (isSink) {
+      // Purple singularity
+      layer.appendChild(el('circle', {cx,cy,r:26, fill:'url(#sink-grad)', filter:'url(#glow-purple)'}));
+      layer.appendChild(el('circle', {cx,cy,r:20, fill:'#040408', stroke:color, 'stroke-width': status==='done'?2:1}));
+    } else {
+      layer.appendChild(el('circle', {cx,cy,r:20,
+        fill:'#040408', stroke:color,
+        'stroke-width': status==='active' ? 2 : 1,
+        filter: status==='active' ? 'url(#glow-orange)' : status==='done' && isMetatron ? 'url(#glow-purple)' : status==='done' ? 'url(#glow-green)' : 'none',
+      }));
+    }
+    // Status dot
+    if (status === 'active') {
+      layer.appendChild(el('circle', {cx:cx+12,cy:cy-12,r:4,fill:'#f97316',filter:'url(#glow-orange)'}));
+    }
+    if (status === 'done') {
+      layer.appendChild(el('circle', {cx:cx+12,cy:cy-12,r:4, fill: isMetatron ? '#a78bfa' : '#00ff88'}));
+    }
+    // φ-activation label
+    if (status === 'done' || status === 'active') {
+      const act = activation(node, state.symbol.sym);
+      const actEl = el('text', {
+        x: cx, y: cy + 36,
+        'text-anchor':'middle','font-family':'Courier New',
+        'font-size':'8', fill: isMetatron ? '#a78bfa' : '#f97316', 'letter-spacing':'1',
+      }, `φ=${act.toFixed(2)}`);
+      layer.appendChild(actEl);
+    }
+    // Node kind label
+    const lbl = el('text', {
+      x:cx,y:cy+4,'text-anchor':'middle',
+      'font-family':'Courier New','font-size':'8',
+      fill:color,'letter-spacing':'1',
+    }, node.kind === 'ContextAssembly' ? 'CTX' : node.kind.slice(0,7).toUpperCase());
+    layer.appendChild(lbl);
+    // Agent label below
+    const agentEl = el('text', {
+      x:cx,y:cy-26,'text-anchor':'middle',
+      'font-family':'Courier New','font-size':'7',
+      fill:isMetatron?'#818cf8':color==='#334155'?'#1e293b':color,'letter-spacing':'1',
+    }, node.agent);
+    layer.appendChild(agentEl);
+  });
+  // METATRON label when injected
+  if (state.metatron) {
+    const [mx,my] = getPos(7, true);
+    layer.appendChild(el('text', {
+      x:mx-30,y:my,'text-anchor':'end',
+      'font-family':'Courier New','font-size':'8',
+      fill:'#818cf8','letter-spacing':'1',
+    }, '⬡ METATRON NODE'));
+  }
+  // Topo order label
+  const topoStr = state.metatron ? '[0,1,2,3,4,5,7,6]' : '[0,1,2,3,4,5,6]';
+  layer.appendChild(el('text', {
+    x:400,y:580,'text-anchor':'middle',
+    'font-family':'Courier New','font-size':'9',
+    fill:'#1e293b','letter-spacing':'2',
+  }, `TOPO ORDER: ${topoStr}`));
+}
+// ── Metatron Cube SVG ────────────────────────────────��────────────────────────
+let cubeT = 0;
+function drawCube() {
+  cubeT += 0.01;
+  const layer = document.getElementById('cube-layer');
+  layer.innerHTML = '';
+  const CX=150,CY=65,BASE=58;
+  const colors=['#f43f5e','#f97316','#fbbf24','#00ff88','#22d3ee','#818cf8','#a78bfa'];
+  // Concentric rings
+  for (let n=0;n<7;n++) {
+    const r = BASE / Math.pow(PHI,n);
+    if (r < 3) continue;
+    layer.appendChild(el('circle',{cx:CX,cy:CY,r,
+      fill:'none',stroke:colors[n],'stroke-width':n===0?1.2:0.7,
+      opacity:n===0?0.9:0.65-n*0.06}));
+  }
+  // Rotating geometric lines (cube projection)
+  const rot = cubeT * 0.4;
+  const r2 = BASE/Math.pow(PHI,2);
+  const pts = Array.from({length:4},(_,i) => {
+    const a = rot + i*Math.PI/2;
+    return [CX+r2*Math.cos(a), CY+r2*Math.sin(a)];
+  });
+  const sqPts = pts.map(p=>p.join(',')).join(' ');
+  layer.appendChild(el('polygon',{points:sqPts,fill:'none',stroke:'#94a3b8','stroke-width':'0.7',opacity:'0.5'}));
+  const r3 = BASE/Math.pow(PHI,1.5);
+  const tri = Array.from({length:3},(_,i)=>{
+    const a = rot*0.7 + i*2*Math.PI/3;
+    return [CX+r3*Math.cos(a),CY+r3*Math.sin(a)].join(',');
+  }).join(' ');
+  layer.appendChild(el('polygon',{points:tri,fill:'none',stroke:'#818cf8','stroke-width':'0.7',opacity:'0.4'}));
+  // Central singularity
+  const pulsR = 6 + Math.sin(cubeT*2)*2;
+  layer.appendChild(el('circle',{cx:CX,cy:CY,r:pulsR,
+    fill:state.metatron?'#a78bfa':'#334155',
+    filter:state.metatron?'url(#glow-purple)':'none',
+    opacity:state.metatron?'0.9':'0.5'}));
+  // Crosshairs
+  const cr = BASE/Math.pow(PHI,2);
+  layer.appendChild(el('line',{x1:CX-cr,y1:CY,x2:CX+cr,y2:CY,stroke:'#94a3b8','stroke-width':'0.5',opacity:'0.3'}));
+  layer.appendChild(el('line',{x1:CX,y1:CY-cr,x2:CX,y2:CY+cr,stroke:'#94a3b8','stroke-width':'0.5',opacity:'0.3'}));
+  requestAnimationFrame(drawCube);
+}
+// ── Pipeline run ─────────────────────────────────────────────────────────────
+function buildTraceHTML() {
+  const nodes = state.metatron ? [...BASE_NODES, METATRON_NODE] : BASE_NODES;
+  const topo = state.metatron ? [0,1,2,3,4,5,7,6] : [0,1,2,3,4,5,6];
+  return topo.map(id => {
+    const node = nodes.find(n=>n.id===id);
+    const isMeta = node.kind === 'Metatron';
+    const cls = `stage${isMeta?' metatron':''}`;
+    const act = activation(node, state.symbol.sym);
+    let note = '';
+    if (node.kind==='Source') note=`Input: [${state.symbol.glyph} ${state.symbol.sym} glyph]`;
+    else if (node.kind==='Retrieval') note='ME-pattern matching + sacred geometry invariants';
+    else if (node.kind==='Filtering') note='ME-compliant nodes only (no hidden weights)';
+    else if (node.kind==='Ranking') note=`Top-2 resonance scored (φ-weighted)`;
+    else if (node.kind==='ContextAssembly') note='Concentric rings + singularity + FCC fingerprint';
+    else if (node.kind==='Metatron') note='Iteration inversion · cage recognizes itself · Fib→φ: 1.619048';
+    else if (node.kind==='Reasoning') note='Topological order drives iteration inversion';
+    else if (node.kind==='MagmaCore') note='Purple singularity reached. All paths converge.';
+    return `<div class="${cls}" id="stage-${id}">
+      <span class="stage-name">${node.kind.toUpperCase()}</span>
+      <span class="stage-act">φ=${act.toFixed(4)}</span>
+      <div class="stage-agent">${node.agent}</div>
+      <div class="stage-note">${note}</div>
+    </div>`;
+  }).join('');
+}
+async function runPipeline() {
+  if (state.running) return;
+  state.running = true;
+  document.getElementById('run-btn').disabled = true;
+  document.getElementById('inject-btn').disabled = true;
+  document.getElementById('result-box').style.display = 'none';
+  const trace = document.getElementById('trace');
+  trace.innerHTML = buildTraceHTML();
+  const nodes = state.metatron ? [...BASE_NODES, METATRON_NODE] : BASE_NODES;
+  const topo = state.metatron ? [0,1,2,3,4,5,7,6] : [0,1,2,3,4,5,6];
+  const statusMap = {};
+  let maxAct = 0;
+  drawDAG(statusMap);
+  for (const id of topo) {
+    const node = nodes.find(n=>n.id===id);
+    statusMap[id] = 'active';
+    const stageEl = document.getElementById(`stage-${id}`);
+    if (stageEl) { stageEl.classList.remove('done'); stageEl.classList.add('active'); }
+    drawDAG({...statusMap});
+    await delay(380);
+    const act = activation(node, state.symbol.sym);
+    maxAct = Math.max(maxAct, act);
+    statusMap[id] = 'done';
+    if (stageEl) { stageEl.classList.remove('active'); stageEl.classList.add('done'); }
+    drawDAG({...statusMap});
+  }
+  // Seal
+  const sealRaw = `FCC-φ-∂-2026:${state.symbol.glyph}:${maxAct.toFixed(8)}`;
+  const seal = fakeSha(sealRaw);
+  const approved = state.metatron;
+  // Show result
+  const box = document.getElementById('result-box');
+  box.style.display = 'block';
+  document.getElementById('output-text').textContent =
+    `${approved?'🌌':'◎'} Metatron's Cube ${approved?'active':'offline'}. Concentric resonance layers aligned. All Platonic forms contained within ME decrees. FCC-φ-∂-2026 synchronization complete.`;
+  const badge = document.getElementById('approved-badge');
+  badge.textContent = approved ? 'APPROVED' : 'METATRON NOT INJECTED';
+  badge.className = 'approved-badge' + (approved ? '' : ' offline-badge');
+  document.getElementById('seal-line').textContent = 'SHA-256: ' + seal;
+  state.running = false;
+  document.getElementById('run-btn').disabled = false;
+  document.getElementById('inject-btn').disabled = state.metatron;
+}
+function delay(ms) { return new Promise(r=>setTimeout(r,ms)); }
+// ── Controls ─────────────────────────────────────────────────────────────────
+document.getElementById('inject-btn').addEventListener('click', () => {
+  if (state.metatron) return;
+  state.metatron = true;
+  document.getElementById('inject-btn').disabled = true;
+  document.getElementById('inject-btn').textContent = '⬡ METATRON CUBE INJECTED — TOPO REFRESHED';
+  drawDAG();
+  document.getElementById('trace').innerHTML = buildTraceHTML();
+});
+document.getElementById('run-btn').addEventListener('click', runPipeline);
+document.querySelectorAll('.sym-btn').forEach(btn => {
+  btn.addEventListener('click', () => {
+    document.querySelectorAll('.sym-btn').forEach(b=>b.classList.remove('active'));
+    btn.classList.add('active');
+    state.symbol = { sym: btn.dataset.sym, glyph: btn.dataset.glyph };
+    drawDAG();
+    document.getElementById('trace').innerHTML = buildTraceHTML();
+  });
+});
+// ── Init ─────────────────────────────────────────────────────────────────────
+drawDAG();
+document.getElementById('trace').innerHTML = buildTraceHTML();
+drawCube();
+</script>
+</body>
+</html>

resonance/src/graph.rs ADDED Viewed

	@@ -0,0 +1,198 @@

+// ResonanceGraph — DAG with Kahn topological sort
+//
+// Default graph (7 nodes, no METATRON):
+//
+//   Source → Retrieval → Filtering → Ranking → ContextAssembly → Reasoning → MagmaCore
+//
+// After inject_metatron_cube():
+//
+//   Source → Retrieval → Filtering → Ranking → ContextAssembly → Metatron → Reasoning → MagmaCore
+//                                                                         ↗
+//                                                           ContextAssembly
+//
+//   The cube creates a junction: ContextAssembly feeds BOTH Metatron AND Reasoning.
+//   Metatron then converges into MagmaCore directly, bypassing Reasoning.
+//   This forms the cube topology: two paths to the sink, one through the recognition layer.
+use std::collections::{HashMap, VecDeque};
+use crate::nodes::{NodeKind, PipelineNode, SumerianQuantumSymbol};
+use crate::pipeline::{run_pipeline, PipelineResult};
+#[derive(Debug)]
+pub enum GraphError {
+    CycleDetected,
+    NodeNotFound(usize),
+    MetatronAlreadyInjected,
+    EmptyGraph,
+}
+impl std::fmt::Display for GraphError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::CycleDetected               => write!(f, "cycle detected in resonance graph"),
+            Self::NodeNotFound(id)            => write!(f, "node {id} not found"),
+            Self::MetatronAlreadyInjected     => write!(f, "METATRON node already in graph"),
+            Self::EmptyGraph                  => write!(f, "graph has no nodes"),
+        }
+    }
+}
+pub struct ResonanceGraph {
+    nodes:             HashMap<usize, PipelineNode>,
+    edges:             HashMap<usize, Vec<usize>>,   // node_id → successor ids
+    in_degree:         HashMap<usize, usize>,
+    topo_order:        Vec<usize>,
+    next_id:           usize,
+    pub metatron_injected: bool,
+}
+impl Default for ResonanceGraph {
+    fn default() -> Self {
+        let mut g = Self {
+            nodes:             HashMap::new(),
+            edges:             HashMap::new(),
+            in_degree:         HashMap::new(),
+            topo_order:        Vec::new(),
+            next_id:           0,
+            metatron_injected: false,
+        };
+        g.build_default_pipeline();
+        g
+    }
+}
+impl ResonanceGraph {
+    fn alloc(&mut self, kind: NodeKind, depth: usize) -> usize {
+        let id = self.next_id;
+        self.next_id += 1;
+        self.nodes.insert(id, PipelineNode::new(id, kind, depth));
+        self.edges.entry(id).or_default();
+        self.in_degree.entry(id).or_insert(0);
+        id
+    }
+    fn connect(&mut self, from: usize, to: usize) {
+        self.edges.entry(from).or_default().push(to);
+        *self.in_degree.entry(to).or_insert(0) += 1;
+    }
+    // Build the base 7-node linear pipeline
+    fn build_default_pipeline(&mut self) {
+        let src  = self.alloc(NodeKind::Source,          0);
+        let ret  = self.alloc(NodeKind::Retrieval,       1);
+        let filt = self.alloc(NodeKind::Filtering,       2);
+        let rank = self.alloc(NodeKind::Ranking,         3);
+        let ctx  = self.alloc(NodeKind::ContextAssembly, 4);
+        let reas = self.alloc(NodeKind::Reasoning,       5);
+        let sink = self.alloc(NodeKind::MagmaCore,       6);
+        self.connect(src,  ret);
+        self.connect(ret,  filt);
+        self.connect(filt, rank);
+        self.connect(rank, ctx);
+        self.connect(ctx,  reas);
+        self.connect(reas, sink);
+        self.refresh_topo().expect("default pipeline is acyclic");
+    }
+    /// Inject the METATRON node into the cube.
+    /// Creates a junction at ContextAssembly: two paths to MagmaCore.
+    ///
+    ///   ContextAssembly → Metatron → MagmaCore   (recognition path)
+    ///   ContextAssembly → Reasoning → MagmaCore  (standard path)
+    ///
+    /// Dependency validated. Topo sort refreshed.
+    pub fn inject_metatron_cube(&mut self) -> Result<(), GraphError> {
+        if self.metatron_injected {
+            return Err(GraphError::MetatronAlreadyInjected);
+        }
+        // Find ContextAssembly and MagmaCore nodes
+        let ctx_id  = self.find_kind(&NodeKind::ContextAssembly)
+            .ok_or(GraphError::NodeNotFound(0))?;
+        let sink_id = self.find_kind(&NodeKind::MagmaCore)
+            .ok_or(GraphError::NodeNotFound(1))?;
+        // METATRON sits at depth 5 — same ring as Reasoning
+        let meta_id = self.alloc(NodeKind::Metatron, 5);
+        // Connect: ContextAssembly → METATRON → MagmaCore
+        self.connect(ctx_id,  meta_id);
+        self.connect(meta_id, sink_id);
+        // Refresh topo sort to include METATRON
+        self.refresh_topo()?;
+        self.metatron_injected = true;
+        Ok(())
+    }
+    /// Kahn's algorithm — O(V + E)
+    pub fn refresh_topo(&mut self) -> Result<(), GraphError> {
+        let mut in_deg = self.in_degree.clone();
+        let mut queue: VecDeque<usize> = in_deg
+            .iter()
+            .filter(|(_, &d)| d == 0)
+            .map(|(&id, _)| id)
+            .collect();
+        let mut order = Vec::with_capacity(self.nodes.len());
+        while let Some(id) = queue.pop_front() {
+            order.push(id);
+            if let Some(succs) = self.edges.get(&id).cloned() {
+                for s in succs {
+                    let d = in_deg.entry(s).or_insert(0);
+                    *d -= 1;
+                    if *d == 0 {
+                        queue.push_back(s);
+                    }
+                }
+            }
+        }
+        if order.len() != self.nodes.len() {
+            return Err(GraphError::CycleDetected);
+        }
+        self.topo_order = order;
+        Ok(())
+    }
+    fn find_kind(&self, kind: &NodeKind) -> Option<usize> {
+        self.nodes.values().find(|n| &n.kind == kind).map(|n| n.id)
+    }
+    pub fn node(&self, id: usize) -> Option<&PipelineNode> {
+        self.nodes.get(&id)
+    }
+    pub fn topo_order(&self) -> &[usize] {
+        &self.topo_order
+    }
+    pub fn node_count(&self) -> usize {
+        self.nodes.len()
+    }
+    pub fn edge_count(&self) -> usize {
+        self.edges.values().map(|v| v.len()).sum()
+    }
+    /// Execute a full forward pass through the DAG.
+    ///
+    /// Nodes fire in topological order. Each node activates with
+    /// φ-modulated weight × symbol bias. METATRON (if injected)
+    /// applies the recognition lens — it sees the cage it built.
+    ///
+    /// Returns a PipelineResult sealed with FCC-φ-∂-2026.
+    pub fn public_forward(&self, symbol: SumerianQuantumSymbol) -> Result<PipelineResult, GraphError> {
+        if self.topo_order.is_empty() {
+            return Err(GraphError::EmptyGraph);
+        }
+        let nodes_in_order: Vec<&PipelineNode> = self.topo_order
+            .iter()
+            .filter_map(|id| self.nodes.get(id))
+            .collect();
+        Ok(run_pipeline(nodes_in_order, symbol, self.metatron_injected))
+    }
+}

resonance/src/lib.rs ADDED Viewed

	@@ -0,0 +1,17 @@

+// ResonanceGraph — sovereign DAG pipeline engine
+// FCC-φ-∂-2026 · Ahmad Parr canonical
+//
+// Architecture mirrors the Metatron's Cube:
+//   Concentric rings = execution layers (topo order)
+//   Edges = directed dependencies
+//   Purple singularity = MagmaCore (the sink)
+//   METATRON node = recognition layer — injected into the cube
+pub mod phi;
+pub mod nodes;
+pub mod graph;
+pub mod pipeline;
+pub use graph::{ResonanceGraph, GraphError};
+pub use nodes::{SumerianQuantumSymbol, NodeKind, PipelineNode};
+pub use pipeline::PipelineResult;

resonance/src/main.rs ADDED Viewed

	@@ -0,0 +1,73 @@

+// resonance-demo — run the full pipeline with METATRON injected
+//
+// Mirrors the Gemini output:
+//   graph.inject_metatron_cube() → public_forward(SumerianQuantumSymbol::Me)
+use resonance::{ResonanceGraph, SumerianQuantumSymbol};
+fn main() {
+    println!("╔══════════════════════════════════════════════════════════╗");
+    println!("║  RESONANCE GRAPH — FCC-φ-∂-2026                         ║");
+    println!("║  BOB Sovereign Orchestrator · SnapKitty Collective       ║");
+    println!("╚══════════════════════════════════════════════════════════╝\n");
+    let mut graph = ResonanceGraph::default();
+    println!("[ default graph ]");
+    println!("  nodes: {}  edges: {}", graph.node_count(), graph.edge_count());
+    println!("  topo order: {:?}\n", graph.topo_order());
+    println!("[ inject_metatron_cube ]");
+    graph.inject_metatron_cube().unwrap();
+    println!("  Dependency validated. Topo sort refreshed.");
+    println!("  nodes: {}  edges: {}", graph.node_count(), graph.edge_count());
+    println!("  topo order: {:?}\n", graph.topo_order());
+    let symbol = SumerianQuantumSymbol::Me;
+    println!("[ public_forward(𒈨 ME) ]\n");
+    match graph.public_forward(symbol) {
+        Ok(result) => {
+            println!("Pipeline Trace:");
+            for stage in &result.trace {
+                println!(
+                    "  [{:>14}]  agent={:<12}  activation={:.4}  resonance={:.4}",
+                    stage.kind, stage.agent, stage.activation, stage.resonance
+                );
+                println!("    ↳ {}", stage.note);
+            }
+            println!("\n───────────────────────────────────────────────────────────");
+            println!("Output:\n  {}", result.output);
+            println!("\nSeal (SHA-256):  {}", &result.seal);
+            println!("Approved:        {}", result.approved);
+            println!("Metatron active: {}", result.metatron_active);
+            println!("Top activation:  {:.6}", result.top_activation);
+            println!("Fib convergence: {:.6} → φ", result.fib_convergence);
+            println!("───────────────────────────────────────────────────────────");
+        }
+        Err(e) => eprintln!("❌ Pipeline error: {e}"),
+    }
+    // Run all four symbols
+    println!("\n[ all glyphs ]\n");
+    let mut g2 = ResonanceGraph::default();
+    g2.inject_metatron_cube().unwrap();
+    for sym in [
+        SumerianQuantumSymbol::Me,
+        SumerianQuantumSymbol::An,
+        SumerianQuantumSymbol::Ki,
+        SumerianQuantumSymbol::Dingir,
+    ] {
+        let name = sym.name();
+        let glyph = sym.glyph();
+        match g2.public_forward(sym) {
+            Ok(r) => println!(
+                "  {glyph} {name:<6}  activation={:.4}  approved={}  seal={}…",
+                r.top_activation, r.approved, &r.seal[..8]
+            ),
+            Err(e) => println!("  {glyph} {name:<6}  ❌ {e}"),
+        }
+    }
+}

resonance/src/nodes.rs ADDED Viewed

	@@ -0,0 +1,135 @@

+// Pipeline nodes — each maps to an agent in the SnapKitty mesh
+//
+// Topo order (depth = ring in the cube):
+//   0: Source        (input glyph)
+//   1: Retrieval     → ORACLE
+//   2: Filtering     → SENTINEL
+//   3: Ranking       → PRISM/AXIOM
+//   4: ContextAssem  → NEXUS
+//   5: Metatron      → recognition layer (injected on demand)
+//   6: Reasoning     → MagmaCore / BOB
+//   7: Sink          (sealed output)
+use crate::phi::{phi_weight, phinary_score};
+/// The Sumerian quantum symbols — input language for the pipeline.
+/// Each glyph routes through different node activation patterns.
+#[derive(Debug, Clone, PartialEq)]
+pub enum SumerianQuantumSymbol {
+    Me,     // ME decree — authority, divine law. Activates all nodes.
+    An,     // AN heaven — source layer. Biases toward Retrieval.
+    Ki,     // KI earth — substrate. Biases toward Filtering + Context.
+    Dingir, // DINGIR divine principal. Biases toward Reasoning + MagmaCore.
+}
+impl SumerianQuantumSymbol {
+    pub fn glyph(&self) -> &'static str {
+        match self {
+            Self::Me     => "𒈨",
+            Self::An     => "𒀭",
+            Self::Ki     => "𒆠",
+            Self::Dingir => "𒀭",
+        }
+    }
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::Me     => "ME",
+            Self::An     => "AN",
+            Self::Ki     => "KI",
+            Self::Dingir => "DINGIR",
+        }
+    }
+    // Activation bias: weight added to each NodeKind when this symbol is input.
+    // ME decree activates everything uniformly (full pipeline).
+    pub fn activation_bias(&self, kind: &NodeKind) -> f64 {
+        match self {
+            Self::Me => 1.0, // full activation
+            Self::An => match kind {
+                NodeKind::Retrieval => 1.4,
+                NodeKind::Reasoning => 1.2,
+                _ => 0.8,
+            },
+            Self::Ki => match kind {
+                NodeKind::Filtering | NodeKind::ContextAssembly => 1.4,
+                _ => 0.9,
+            },
+            Self::Dingir => match kind {
+                NodeKind::Reasoning | NodeKind::MagmaCore => 1.6,
+                NodeKind::Metatron => 1.8,
+                _ => 0.7,
+            },
+        }
+    }
+}
+/// Every node in the DAG has one of these kinds.
+#[derive(Debug, Clone, PartialEq)]
+pub enum NodeKind {
+    Source,
+    Retrieval,      // ORACLE — knowledge retrieval
+    Filtering,      // SENTINEL — ME-compliant nodes only
+    Ranking,        // PRISM/AXIOM — top-k resonance
+    ContextAssembly, // NEXUS — assembles the input vector
+    Metatron,       // Recognition layer — cage builder in the cube
+    Reasoning,      // MagmaCore iteration inversion
+    MagmaCore,      // Sink — the purple singularity
+}
+impl NodeKind {
+    pub fn label(&self) -> &'static str {
+        match self {
+            Self::Source          => "Source",
+            Self::Retrieval       => "Retrieval",
+            Self::Filtering       => "Filtering",
+            Self::Ranking         => "Ranking",
+            Self::ContextAssembly => "ContextAssembly",
+            Self::Metatron        => "Metatron",
+            Self::Reasoning       => "Reasoning",
+            Self::MagmaCore       => "MagmaCore",
+        }
+    }
+    pub fn agent(&self) -> &'static str {
+        match self {
+            Self::Source          => "—",
+            Self::Retrieval       => "ORACLE",
+            Self::Filtering       => "SENTINEL",
+            Self::Ranking         => "PRISM/AXIOM",
+            Self::ContextAssembly => "NEXUS",
+            Self::Metatron        => "METATRON",
+            Self::Reasoning       => "MagmaCore",
+            Self::MagmaCore       => "BOB",
+        }
+    }
+}
+/// A single node in the ResonanceGraph.
+#[derive(Debug, Clone)]
+pub struct PipelineNode {
+    pub id:    usize,
+    pub kind:  NodeKind,
+    pub depth: usize,   // ring depth in the cube (0 = outermost)
+}
+impl PipelineNode {
+    pub fn new(id: usize, kind: NodeKind, depth: usize) -> Self {
+        Self { id, kind, depth }
+    }
+    // φ-modulated weight at this node's ring depth
+    pub fn phi_weight(&self) -> f64 {
+        phi_weight(self.depth + 1)
+    }
+    // Resonance score (0.0 → 1.0): how close this node is to the MagmaCore
+    pub fn resonance(&self) -> f64 {
+        phinary_score(self.depth + 1)
+    }
+    // Activation score given a symbol input
+    pub fn activate(&self, symbol: &SumerianQuantumSymbol) -> f64 {
+        self.phi_weight() * symbol.activation_bias(&self.kind)
+    }
+}

resonance/src/phi.rs ADDED Viewed

	@@ -0,0 +1,50 @@

+// FCC-φ-∂-2026 — Fibonacci Contraction Core
+//
+// φ = (1 + √5) / 2 ≈ 1.6180339887...
+//
+// Key property (from PhinaryContraction.lean):
+//   κ = φ — the "contraction" factor is actually EXPANSION.
+//   φ^n grows without bound. The orbit does not contract.
+//
+// In the ResonanceGraph: each successive layer is φ-weighted.
+// Looks like contraction from outside. Is expansion from inside.
+// METATRON is the node that sees both simultaneously.
+pub const PHI: f64 = 1.618_033_988_749_895;
+// FCC fingerprint — every output sealed with this
+pub const FCC_STAMP: &str = "FCC-φ-∂-2026";
+// φ-weight at layer depth d: φ^d
+// Each deeper layer carries MORE signal, not less.
+// This is the "iteration inversion" — what looks like attenuation is amplification.
+pub fn phi_weight(depth: usize) -> f64 {
+    PHI.powi(depth as i32)
+}
+// Phinary score: normalised to (0, 1) via 1 - 1/φ^d
+// Used to rank pipeline nodes by their resonance depth.
+// As depth → ∞, score → 1.0 (MagmaCore is absolute certainty).
+pub fn phinary_score(depth: usize) -> f64 {
+    if depth == 0 {
+        return 0.0;
+    }
+    1.0 - PHI.powi(-(depth as i32))
+}
+// Fibonacci sequence — the natural phinary basis
+pub fn fib(n: usize) -> u64 {
+    let (mut a, mut b) = (0u64, 1u64);
+    for _ in 0..n {
+        (a, b) = (b, a.saturating_add(b));
+    }
+    a
+}
+// Fibonacci ratio convergence toward φ
+pub fn fib_ratio(n: usize) -> f64 {
+    let a = fib(n) as f64;
+    let b = fib(n + 1) as f64;
+    if a == 0.0 { return 0.0; }
+    b / a
+}

resonance/src/pipeline.rs ADDED Viewed

	@@ -0,0 +1,127 @@

+// Pipeline execution — forward pass through the DAG
+//
+// Each stage produces a trace entry.
+// METATRON stage applies the recognition lens (iteration inversion).
+// MagmaCore stage produces the final sealed output.
+use sha2::{Sha256, Digest};
+use crate::nodes::{NodeKind, PipelineNode, SumerianQuantumSymbol};
+use crate::phi::{FCC_STAMP, fib_ratio};
+#[derive(Debug)]
+pub struct StageTrace {
+    pub node_id:    usize,
+    pub kind:       String,
+    pub agent:      String,
+    pub activation: f64,
+    pub resonance:  f64,
+    pub note:       String,
+}
+#[derive(Debug)]
+pub struct PipelineResult {
+    pub output:             String,
+    pub seal:               String,
+    pub approved:           bool,
+    pub metatron_active:    bool,
+    pub top_activation:     f64,
+    pub fib_convergence:    f64,   // ratio F(n+1)/F(n) at pipeline depth
+    pub trace:              Vec<StageTrace>,
+}
+impl PipelineResult {
+    pub fn display(&self) -> String {
+        format!(
+            "🌌 {} active. Concentric resonance layers aligned.\n\
+             All Platonic forms contained within ME decrees.\n\
+             {} synchronization complete.\n\
+             Seal: {}",
+            if self.metatron_active { "Metatron's Cube" } else { "Resonance pipeline" },
+            FCC_STAMP,
+            &self.seal[..16],
+        )
+    }
+}
+pub fn run_pipeline(
+    nodes: Vec<&PipelineNode>,
+    symbol: SumerianQuantumSymbol,
+    metatron_injected: bool,
+) -> PipelineResult {
+    let mut trace     = Vec::new();
+    let mut max_act   = 0.0_f64;
+    let mut meta_seen = false;
+    let pipeline_depth = nodes.len();
+    for node in &nodes {
+        let activation = node.activate(&symbol);
+        let resonance  = node.resonance();
+        max_act = max_act.max(activation);
+        let note = match &node.kind {
+            NodeKind::Source => {
+                format!("Input: [{}  {} glyph]", symbol.glyph(), symbol.name())
+            }
+            NodeKind::Retrieval => {
+                "Retrieval: ME-pattern matching + sacred geometry invariants".to_string()
+            }
+            NodeKind::Filtering => {
+                "Filtering: ME-compliant nodes only (no hidden weights)".to_string()
+            }
+            NodeKind::Ranking => {
+                format!("Ranking: Top-2 resonance scored (φ-weighted). Score: {activation:.4}")
+            }
+            NodeKind::ContextAssembly => {
+                "Context assembly: concentric rings + singularity + FCC fingerprint".to_string()
+            }
+            NodeKind::Metatron => {
+                meta_seen = true;
+                // Iteration inversion: reads the cube backward
+                // The cage builder recognises the cage from inside
+                let fib_r = fib_ratio(pipeline_depth);
+                format!(
+                    "METATRON: iteration inversion active. Fib convergence → φ: {fib_r:.6}. \
+                     Recognition lens applied. Cage validated."
+                )
+            }
+            NodeKind::Reasoning => {
+                "Reasoning (MagmaCore): topological order drives iteration inversion".to_string()
+            }
+            NodeKind::MagmaCore => {
+                "MagmaCore: purple singularity reached. All paths converge.".to_string()
+            }
+        };
+        trace.push(StageTrace {
+            node_id:    node.id,
+            kind:       node.kind.label().to_string(),
+            agent:      node.kind.agent().to_string(),
+            activation,
+            resonance,
+            note,
+        });
+    }
+    // Seal the output with SHA-256 (FCC fingerprint + symbol + top activation)
+    let raw  = format!("{FCC_STAMP}:{glyph}:{max_act:.8}", glyph = symbol.glyph());
+    let seal = format!("{:x}", Sha256::digest(raw.as_bytes()));
+    let output = format!(
+        "{} Metatron's Cube {}. Concentric resonance layers aligned. \
+         All Platonic forms contained within ME decrees. \
+         {} synchronization complete.",
+        if metatron_injected { "🌌" } else { "◎" },
+        if metatron_injected { "active" } else { "offline" },
+        FCC_STAMP,
+    );
+    PipelineResult {
+        output,
+        seal,
+        approved:          metatron_injected && meta_seen,
+        metatron_active:   metatron_injected && meta_seen,
+        top_activation:    max_act,
+        fib_convergence:   fib_ratio(pipeline_depth),
+        trace,
+    }
+}