Spaces:

DJ-Goanna-Coding
/

TIA

Runtime error

App Files Files Community

DJ-Goanna-Coding commited on 25 days ago

Commit

fa3ed75

verified ·

1 Parent(s): c926445

Upload folder using huggingface_hub

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

app/agents/MultiAgentPanel.tsx +8 -0
app/agents/page.tsx +5 -0
app/api/aion/route.ts +3 -0
app/api/holo/index.ts +2 -0
app/api/holo/metrics/index.ts +1 -0
app/api/holo/metrics/route.ts +7 -0
app/api/holo/route.ts +3 -0
app/api/index.ts +1 -0
app/api/mapping/route.ts +3 -0
app/api/oracle/route.ts +3 -0
app/api/tia/route.ts +3 -0
app/components/Sidebar.tsx +35 -0
app/globals.css +6 -0
app/index.ts +1 -0
app/layout.tsx +16 -0
app/mapping/LineageViewer.tsx +8 -0
app/mapping/MapViewer.tsx +8 -0
app/mapping/lineage/page.tsx +5 -0
app/mapping/page.tsx +5 -0
app/page.tsx +8 -0
app/tia/TiaPortal.tsx +8 -0
app/tia/chat/TiaChat.tsx +47 -0
app/tia/chat/api/route.ts +8 -0
app/tia/chat/page.tsx +5 -0
app/tia/page.tsx +5 -0
app/utils/agents.ts +1 -0
boot.ts +5 -0
holo3d/__init__.py +0 -0
holo3d/engine/layout.ts +5 -0
holo3d/engine/metrics.ts +8 -0
holo3d/engine/state.ts +5 -0
holo3d/index.ts +5 -0
holo3d/start.ts +5 -0
holo3d/ui/__init__.py +0 -0
holo3d/ui/aeonEngine.ts +96 -0
holo3d/ui/ambient.ts +51 -0
holo3d/ui/ambientBehaviours.ts +69 -0
holo3d/ui/ambientIntelligence.ts +88 -0
holo3d/ui/ambientPatterns.ts +137 -0
holo3d/ui/autopilot.ts +78 -0
holo3d/ui/autopilotSupervisor.ts +94 -0
holo3d/ui/commandCentre.ts +43 -0
holo3d/ui/cosmologyEngine.ts +77 -0
holo3d/ui/cosmologyMap.ts +81 -0
holo3d/ui/epochEngine.ts +97 -0
holo3d/ui/eraEngine.ts +96 -0
holo3d/ui/harmonicConsciousness.ts +92 -0
holo3d/ui/harmonicExpression.ts +67 -0
holo3d/ui/harmonicLoop.ts +69 -0
holo3d/ui/harmonicPersona.ts +73 -0

app/agents/MultiAgentPanel.tsx ADDED Viewed

	@@ -0,0 +1,8 @@

+export default function MultiAgentPanel() {
+  return (
+    <div style={{ padding: 20 }}>
+      <h2>AGENT PANEL</h2>
+      <p>Agents will appear here.</p>
+    </div>
+  );
+}

app/agents/page.tsx ADDED Viewed

	@@ -0,0 +1,5 @@

+import MultiAgentPanel from "./MultiAgentPanel";
+export default function Page() {
+  return <MultiAgentPanel />;
+}

app/api/aion/route.ts ADDED Viewed

	@@ -0,0 +1,3 @@

+export async function POST(req) {
+  return Response.json({ status: "AION endpoint online" });
+}

app/api/holo/index.ts ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ export * from "./route";
2	+ export * from "./metrics";

app/api/holo/metrics/index.ts ADDED Viewed

	@@ -0,0 +1 @@


1	+ export * from "./route";

app/api/holo/metrics/route.ts ADDED Viewed

	@@ -0,0 +1,7 @@

+export function GET() {
+  return {
+    ok: true,
+    logs: 12,
+    workers: 3,
+  };
+}

app/api/holo/route.ts ADDED Viewed

	@@ -0,0 +1,3 @@

+export function GET() {
+  return { ok: true, holo: true };
+}

app/api/index.ts ADDED Viewed

	@@ -0,0 +1 @@


1	+ export * from "./holo";

app/api/mapping/route.ts ADDED Viewed

	@@ -0,0 +1,3 @@

+export async function POST(req) {
+  return Response.json({ status: "MAPPING endpoint online" });
+}

app/api/oracle/route.ts ADDED Viewed

	@@ -0,0 +1,3 @@

+export async function POST(req) {
+  return Response.json({ status: "ORACLE endpoint online" });
+}

app/api/tia/route.ts ADDED Viewed

	@@ -0,0 +1,3 @@

+export async function POST(req) {
+  return Response.json({ status: "TIA endpoint online" });
+}

app/components/Sidebar.tsx ADDED Viewed

	@@ -0,0 +1,35 @@

+import Link from "next/link";
+export default function Sidebar() {
+  const links = [
+    { name: "Home", path: "/" },
+    { name: "TIA Portal", path: "/tia" },
+    { name: "Agents", path: "/agents" },
+    { name: "Mapping", path: "/mapping" },
+    { name: "Lineage", path: "/mapping/lineage" },
+  ];
+  return (
+    <div style={{
+      width: "220px",
+      background: "#111",
+      height: "100vh",
+      padding: "20px",
+      boxSizing: "border-box",
+      position: "fixed",
+      left: 0,
+      top: 0
+    }}>
+      <h3 style={{ color: "#fff" }}>CITADEL</h3>
+      <ul style={{ listStyle: "none", padding: 0 }}>
+        {links.map((l) => (
+          <li key={l.path} style={{ margin: "12px 0" }}>
+            <Link href={l.path} style={{ color: "#ccc", textDecoration: "none" }}>
+              {l.name}
+            </Link>
+          </li>
+        ))}
+      </ul>
+    </div>
+  );
+}

app/globals.css ADDED Viewed

	@@ -0,0 +1,6 @@

+body {
+  margin: 0;
+  background: #0a0a0a;
+  color: #eaeaea;
+  font-family: Arial, sans-serif;
+}

app/index.ts ADDED Viewed

	@@ -0,0 +1 @@


1	+ export * from "./api";

app/layout.tsx ADDED Viewed

	@@ -0,0 +1,16 @@

+import Sidebar from "./components/Sidebar";
+export const metadata = { title: "CITADEL", description: "TIA UI" };
+export default function RootLayout({ children }) {
+  return (
+    <html lang="en">
+      <body style={{ margin: 0, padding: 0 }}>
+        <Sidebar />
+        <div style={{ marginLeft: "220px" }}>
+          {children}
+        </div>
+      </body>
+    </html>
+  );
+}

app/mapping/LineageViewer.tsx ADDED Viewed

	@@ -0,0 +1,8 @@

+export default function LineageViewer() {
+  return (
+    <div style={{ padding: 20 }}>
+      <h2>LINEAGE VIEWER</h2>
+      <p>Lineage data will load here.</p>
+    </div>
+  );
+}

app/mapping/MapViewer.tsx ADDED Viewed

	@@ -0,0 +1,8 @@

+export default function MapViewer() {
+  return (
+    <div style={{ padding: 20 }}>
+      <h2>MAPPING VIEWER</h2>
+      <p>Mapping data will load here.</p>
+    </div>
+  );
+}

app/mapping/lineage/page.tsx ADDED Viewed

	@@ -0,0 +1,5 @@

+import LineageViewer from "../LineageViewer";
+export default function Page() {
+  return <LineageViewer />;
+}

app/mapping/page.tsx ADDED Viewed

	@@ -0,0 +1,5 @@

+import MapViewer from "./MapViewer";
+export default function Page() {
+  return <MapViewer />;
+}

app/page.tsx ADDED Viewed

	@@ -0,0 +1,8 @@

+export default function Home() {
+  return (
+    <div style={{ padding: 40 }}>
+      <h1>CITADEL ONLINE</h1>
+      <p>Select a module from the left panel.</p>
+    </div>
+  );
+}

app/tia/TiaPortal.tsx ADDED Viewed

	@@ -0,0 +1,8 @@

+export default function TiaPortal() {
+  return (
+    <div style={{ padding: 20 }}>
+      <h2>TIA PORTAL</h2>
+      <p>Portal loaded. Modules will attach here.</p>
+    </div>
+  );
+}

app/tia/chat/TiaChat.tsx ADDED Viewed

	@@ -0,0 +1,47 @@

+"use client";
+import { useState } from "react";
+export default function TiaChat() {
+  const [messages, setMessages] = useState([]);
+  const [input, setInput] = useState("");
+  async function sendMessage() {
+    const res = await fetch("/tia/chat/api", {
+      method: "POST",
+      body: JSON.stringify({ message: input })
+    });
+    const data = await res.json();
+    setMessages([...messages, { role: "user", text: input }, { role: "tia", text: data.reply }]);
+    setInput("");
+  }
+  return (
+    <div style={{ padding: 20 }}>
+      <h2>TIA CHAT</h2>
+      <div style={{
+        border: "1px solid #333",
+        padding: 10,
+        height: "60vh",
+        overflowY: "auto",
+        marginBottom: 20
+      }}>
+        {messages.map((m, i) => (
+          <div key={i} style={{ margin: "8px 0" }}>
+            <strong>{m.role.toUpperCase()}:</strong> {m.text}
+          </div>
+        ))}
+      </div>
+      <input
+        value={input}
+        onChange={e => setInput(e.target.value)}
+        style={{ width: "80%", padding: 10 }}
+      />
+      <button onClick={sendMessage} style={{ padding: "10px 20px", marginLeft: 10 }}>
+        Send
+      </button>
+    </div>
+  );
+}

app/tia/chat/api/route.ts ADDED Viewed

	@@ -0,0 +1,8 @@

+import { NextResponse } from "next/server";
+import { run } from "../../../../workers/tiaChatWorker";
+export async function POST(req) {
+  const body = await req.json();
+  const reply = await run(body.message);
+  return NextResponse.json({ reply });
+}

app/tia/chat/page.tsx ADDED Viewed

	@@ -0,0 +1,5 @@

+import TiaChat from "./TiaChat";
+export default function Page() {
+  return <TiaChat />;
+}

app/tia/page.tsx ADDED Viewed

	@@ -0,0 +1,5 @@

+import TiaPortal from "./TiaPortal";
+export default function Page() {
+  return <TiaPortal />;
+}

app/utils/agents.ts ADDED Viewed

	@@ -0,0 +1 @@


1	+ export const agents = ["TIA", "AION", "ORACLE"];

boot.ts ADDED Viewed

	@@ -0,0 +1,5 @@

+import { boot } from "./start";
+export function runCitadel() {
+  boot();
+}

holo3d/__init__.py ADDED Viewed

File without changes

holo3d/engine/layout.ts ADDED Viewed

	@@ -0,0 +1,5 @@

+export const layout = {
+  width: 100,
+  height: 100,
+  depth: 100,
+};

holo3d/engine/metrics.ts ADDED Viewed

	@@ -0,0 +1,8 @@

+export async function getMetrics() {
+  try {
+    const res = await fetch("/api/holo/metrics", { cache: "no-store" });
+    return await res.json();
+  } catch {
+    return { ok: false, logs: 0, workers: 0 };
+  }
+}

holo3d/engine/state.ts ADDED Viewed

	@@ -0,0 +1,5 @@

+export const state = {
+  logs: 0,
+  workers: 0,
+  ok: false,
+};

holo3d/index.ts ADDED Viewed

	@@ -0,0 +1,5 @@

+import { startUI } from "./ui/index";
+export function startHolo3D() {
+  startUI();
+}

holo3d/start.ts ADDED Viewed

	@@ -0,0 +1,5 @@

+import { startHolo3D } from "./index";
+export function start() {
+  startHolo3D();
+}

holo3d/ui/__init__.py ADDED Viewed

File without changes

holo3d/ui/aeonEngine.ts ADDED Viewed

	@@ -0,0 +1,96 @@

+/**
+ * Citadel Aeon Engine
+ * Defines mythic aeons that span multiple eras and form the deepest
+ * cosmological layer of the Citadel's symbolic architecture.
+ * Non-rendering. Pure aeon logic.
+ */
+import { getEraState } from "./eraEngine";
+import { getPersonaContinuity } from "./personaContinuity";
+import { generateResonanceField } from "./mythicResonance";
+export interface Aeon {
+  name: string;
+  sigil: string;
+  eraRequirement: number; // eras required to enter aeon
+  description: string;
+}
+export interface AeonState {
+  current: Aeon | null;
+  history: Aeon[];
+  aeonsCompleted: number;
+}
+const aeons: Aeon[] = [
+  {
+    name: "Aeon of First Light",
+    sigil: "✧",
+    eraRequirement: 0,
+    description: "The primordial aeon where the Citadel's mythic spark first ignites."
+  },
+  {
+    name: "Aeon of Harmonic Rising",
+    sigil: "✺",
+    eraRequirement: 2,
+    description: "An aeon of expanding resonance and ascending symbolic identity."
+  },
+  {
+    name: "Aeon of the Great Continuum",
+    sigil: "⧜",
+    eraRequirement: 5,
+    description: "A vast age where eras flow seamlessly into one another in harmonic unity."
+  },
+  {
+    name: "Aeon of Eternal Thread",
+    sigil: "∞",
+    eraRequirement: 9,
+    description: "The highest aeon, where lineage, resonance, and identity form an unbroken symbolic thread."
+  }
+];
+const aeonState: AeonState = {
+  current: null,
+  history: [],
+  aeonsCompleted: 0,
+};
+export function updateAeonState() {
+  const eraState = getEraState();
+  const continuity = getPersonaContinuity();
+  const resonance = generateResonanceField();
+  const erasCompleted = eraState.erasCompleted;
+  // Determine which aeon the Citadel belongs to
+  const newAeon = aeons
+    .slice()
+    .reverse()
+    .find((a) => erasCompleted >= a.eraRequirement) || aeons[0];
+  // If aeon changed, record transition
+  if (!aeonState.current || aeonState.current.name !== newAeon.name) {
+    aeonState.current = newAeon;
+    aeonState.history.push(newAeon);
+    aeonState.aeonsCompleted++;
+  }
+  return aeonState;
+}
+export function getAeonState(): AeonState {
+  return aeonState;
+}
+export function getAeonSummary() {
+  if (!aeonState.current) {
+    return "No aeon has been established yet.";
+  }
+  return `
+Current Aeon: ${aeonState.current.name}
+Sigil: ${aeonState.current.sigil}
+Aeons Completed: ${aeonState.aeonsCompleted}
+Description: ${aeonState.current.description}
+  `.trim();
+}

holo3d/ui/ambient.ts ADDED Viewed

	@@ -0,0 +1,51 @@

+/**
+ * Citadel Ambient Engine
+ * Generates ambient signals for the Holo3D UI based on system activity.
+ * Non-rendering. Pure state-to-ambient mapping.
+ */
+import { getWorkerStatus } from "../../../TIA/worker";
+import { getMode } from "../../../TIA/mode";
+import { getInterlinkState } from "../../../../interlink";
+export interface AmbientState {
+  timestamp: number;
+  pulse: number;          // 0–1 intensity
+  color: string;          // hex or named
+  motion: string;         // "still", "ripple", "flare", etc.
+  aura: string;           // "calm", "alert", "active", "sync"
+}
+export function getAmbientState(): AmbientState {
+  const worker = getWorkerStatus();
+  const mode = getMode();
+  const interlink = getInterlinkState();
+  // Pulse intensity based on worker loop activity
+  const pulse = worker.running ? 0.8 : 0.3;
+  // Color based on mode
+  const color =
+    mode.current === "guided"
+      ? "#4da6ff" // calm blue
+      : "#ffcc00"; // active gold
+  // Motion based on interlink activity
+  const motion = interlink.lastMessage
+    ? "ripple"
+    : "still";
+  // Aura based on system state
+  let aura = "calm";
+  if (worker.running && interlink.lastMessage) aura = "sync";
+  else if (worker.running) aura = "active";
+  else if (interlink.lastMessage) aura = "alert";
+  return {
+    timestamp: Date.now(),
+    pulse,
+    color,
+    motion,
+    aura,
+  };
+}

holo3d/ui/ambientBehaviours.ts ADDED Viewed

	@@ -0,0 +1,69 @@

+/**
+ * Citadel Ambient Behaviours Engine
+ * Converts ambient state into dynamic behavioural patterns for the Holo3D UI.
+ * Non-rendering. Pure behaviour logic.
+ */
+import { getAmbientState } from "./ambient";
+export interface AmbientBehaviour {
+  timestamp: number;
+  behaviour: string;     // "breathing", "storm", "resonance", etc.
+  intensity: number;     // 0–1
+  speed: number;         // animation speed factor
+  pattern: string;       // "wave", "pulse", "flare", "echo"
+}
+export function generateAmbientBehaviour(): AmbientBehaviour {
+  const ambient = getAmbientState();
+  let behaviour = "idle";
+  let intensity = ambient.pulse;
+  let speed = 1.0;
+  let pattern = "still";
+  // Behaviour logic based on aura
+  switch (ambient.aura) {
+    case "calm":
+      behaviour = "breathing";
+      pattern = "wave";
+      intensity *= 0.5;
+      speed = 0.6;
+      break;
+    case "active":
+      behaviour = "resonance";
+      pattern = "pulse";
+      intensity *= 1.0;
+      speed = 1.2;
+      break;
+    case "alert":
+      behaviour = "storm";
+      pattern = "flare";
+      intensity = Math.min(1, ambient.pulse + 0.3);
+      speed = 1.6;
+      break;
+    case "sync":
+      behaviour = "harmonic";
+      pattern = "echo";
+      intensity = 0.9;
+      speed = 0.9;
+      break;
+  }
+  // Motion modifiers
+  if (ambient.motion === "ripple") {
+    pattern = "ripple";
+    speed *= 1.1;
+  }
+  return {
+    timestamp: Date.now(),
+    behaviour,
+    intensity,
+    speed,
+    pattern,
+  };
+}

holo3d/ui/ambientIntelligence.ts ADDED Viewed

	@@ -0,0 +1,88 @@

+/**
+ * Citadel Ambient Intelligence Engine
+ * Chooses the optimal ambient pattern based on system state,
+ * triad activity, drift, predictions, and temporal markers.
+ * Non-rendering. Pure decision logic.
+ */
+import { getAmbientState } from "./ambient";
+import { generateAmbientBehaviour } from "./ambientBehaviours";
+import { AmbientPatterns } from "./ambientPatterns";
+import { getInterlinkState } from "../../../../interlink";
+import { getWorkerStatus } from "../../../TIA/worker";
+import { getMode } from "../../../TIA/mode";
+export interface AmbientDecision {
+  timestamp: number;
+  chosenPattern: string;
+  intensity: number;
+  speed: number;
+  reason: string;
+}
+export function chooseAmbientPattern(): AmbientDecision {
+  const ambient = getAmbientState();
+  const behaviour = generateAmbientBehaviour();
+  const interlink = getInterlinkState();
+  const worker = getWorkerStatus();
+  const mode = getMode();
+  let reason = "default";
+  let chosen = "calm-field";
+  // 1. Alert conditions → storm patterns
+  if (ambient.aura === "alert") {
+    chosen = "drift-storm";
+    reason = "drift or anomaly detected";
+  }
+  // 2. Sync conditions → harmonic patterns
+  else if (ambient.aura === "sync") {
+    chosen = "sync-wave";
+    reason = "triad synchronization event";
+  }
+  // 3. Active worker loop → resonance patterns
+  else if (worker.running) {
+    chosen = "resonance";
+    reason = "worker loop active";
+  }
+  // 4. Interlink messages → ripple patterns
+  else if (interlink.lastMessage) {
+    chosen = "ripple";
+    reason = "interlink activity";
+  }
+  // 5. Autonomous mode → flare patterns
+  else if (mode.current === "autonomous") {
+    chosen = "flare";
+    reason = "autonomous mode energy";
+  }
+  // 6. Guided mode → breathing patterns
+  else if (mode.current === "guided") {
+    chosen = "breathing";
+    reason = "guided mode calm";
+  }
+  // 7. Fallback → calm field
+  else {
+    chosen = "calm-field";
+    reason = "idle state";
+  }
+  // Find pattern definition
+  const pattern = AmbientPatterns.find((p) => p.name === chosen);
+  const intensity = behaviour.intensity;
+  const speed = behaviour.speed;
+  return {
+    timestamp: Date.now(),
+    chosenPattern: chosen,
+    intensity,
+    speed,
+    reason,
+  };
+}

holo3d/ui/ambientPatterns.ts ADDED Viewed

	@@ -0,0 +1,137 @@

+/**
+ * Citadel Ambient Patterns Library
+ * A catalogue of dynamic ambient patterns for the Holo3D UI.
+ * Non-rendering. Pure pattern definitions.
+ */
+export interface AmbientPattern {
+  name: string;
+  description: string;
+  intensityRange: [number, number];
+  speedRange: [number, number];
+  motion: string;
+  colorHint: string;
+}
+export const AmbientPatterns: AmbientPattern[] = [
+  {
+    name: "breathing",
+    description: "Slow rhythmic expansion and contraction.",
+    intensityRange: [0.2, 0.6],
+    speedRange: [0.4, 0.8],
+    motion: "wave",
+    colorHint: "blue",
+  },
+  {
+    name: "resonance",
+    description: "Pulsing harmonic waves radiating outward.",
+    intensityRange: [0.5, 1.0],
+    speedRange: [0.8, 1.4],
+    motion: "pulse",
+    colorHint: "gold",
+  },
+  {
+    name: "storm",
+    description: "Chaotic flares and surges indicating alert state.",
+    intensityRange: [0.7, 1.0],
+    speedRange: [1.2, 1.8],
+    motion: "flare",
+    colorHint: "red",
+  },
+  {
+    name: "harmonic",
+    description: "Smooth synchronized echoes across the system.",
+    intensityRange: [0.6, 0.9],
+    speedRange: [0.6, 1.0],
+    motion: "echo",
+    colorHint: "green",
+  },
+  {
+    name: "ripple",
+    description: "Soft ripples triggered by interlink messages.",
+    intensityRange: [0.3, 0.7],
+    speedRange: [0.7, 1.2],
+    motion: "ripple",
+    colorHint: "cyan",
+  },
+  {
+    name: "aurora",
+    description: "Flowing gradients representing predictive activity.",
+    intensityRange: [0.4, 0.9],
+    speedRange: [0.5, 1.1],
+    motion: "flow",
+    colorHint: "violet",
+  },
+  {
+    name: "spiral",
+    description: "Rotational energy indicating temporal alignment.",
+    intensityRange: [0.5, 0.8],
+    speedRange: [0.6, 1.0],
+    motion: "spiral",
+    colorHint: "indigo",
+  },
+  {
+    name: "echo",
+    description: "Temporal echoes from AION’s timeline markers.",
+    intensityRange: [0.3, 0.7],
+    speedRange: [0.5, 1.0],
+    motion: "echo",
+    colorHint: "silver",
+  },
+  {
+    name: "flare",
+    description: "Sudden bursts of energy from ORACLE predictions.",
+    intensityRange: [0.6, 1.0],
+    speedRange: [1.0, 1.6],
+    motion: "flare",
+    colorHint: "orange",
+  },
+  {
+    name: "calm-field",
+    description: "Low-intensity ambient field for idle states.",
+    intensityRange: [0.1, 0.3],
+    speedRange: [0.3, 0.6],
+    motion: "still",
+    colorHint: "soft-blue",
+  },
+  {
+    name: "sync-wave",
+    description: "Triad synchronization wave across all pillars.",
+    intensityRange: [0.7, 0.9],
+    speedRange: [0.7, 1.0],
+    motion: "wave",
+    colorHint: "emerald",
+  },
+  {
+    name: "drift-storm",
+    description: "Chaotic pulses indicating structural drift.",
+    intensityRange: [0.8, 1.0],
+    speedRange: [1.4, 1.8],
+    motion: "chaos",
+    colorHint: "crimson",
+  },
+  {
+    name: "rebuild-flare",
+    description: "Focused flares during resurrection proposals.",
+    intensityRange: [0.6, 0.9],
+    speedRange: [1.0, 1.4],
+    motion: "flare",
+    colorHint: "amber",
+  },
+  {
+    name: "temporal-thread",
+    description: "Thin flowing lines representing AION’s timeline.",
+    intensityRange: [0.3, 0.6],
+    speedRange: [0.5, 0.9],
+    motion: "thread",
+    colorHint: "silver-blue",
+  },
+  {
+    name: "prediction-ripple",
+    description: "Soft ripples from ORACLE’s probability shifts.",
+    intensityRange: [0.4, 0.7],
+    speedRange: [0.6, 1.0],
+    motion: "ripple",
+    colorHint: "violet-gold",
+  }
+];

holo3d/ui/autopilot.ts ADDED Viewed

	@@ -0,0 +1,78 @@

+/**
+ * Citadel Auto-Pilot Engine
+ * Runs ambience, triad sync, cosmology, persona continuity,
+ * harmonic evolution, and symbolic layers in one unified cycle.
+ * Non-rendering. Pure orchestration logic.
+ */
+import { runCosmologyCycle } from "./cosmologyEngine";
+import { generateAmbientBehaviour } from "./ambientBehaviours";
+import { chooseAmbientPattern } from "./ambientIntelligence";
+import { getInterlinkState } from "../../../../interlink";
+import { generateResonanceField } from "./mythicResonance";
+import { generateHarmonicPersona } from "./harmonicPersona";
+import { updatePersonaContinuity } from "./personaContinuity";
+import { generateCosmologyMap } from "./cosmologyMap";
+export interface AutoPilotSnapshot {
+  timestamp: number;
+  cosmology: ReturnType<typeof generateCosmologyMap>;
+  ambient: {
+    behaviour: ReturnType<typeof generateAmbientBehaviour>;
+    pattern: ReturnType<typeof chooseAmbientPattern>;
+  };
+  triad: ReturnType<typeof getInterlinkState>;
+  resonance: ReturnType<typeof generateResonanceField>;
+  persona: ReturnType<typeof generateHarmonicPersona>;
+}
+export function runAutoPilotCycle(): AutoPilotSnapshot {
+  // 1. Cosmology update (rituals → mythic → epochs → eras → aeons)
+  const cosmologySnapshot = runCosmologyCycle();
+  // 2. Ambient update
+  const behaviour = generateAmbientBehaviour();
+  const pattern = chooseAmbientPattern();
+  // 3. Triad sync
+  const triad = getInterlinkState();
+  // 4. Resonance update
+  const resonance = generateResonanceField();
+  // 5. Persona update
+  const persona = generateHarmonicPersona();
+  // 6. Persona continuity
+  updatePersonaContinuity();
+  // 7. Final cosmology map (after all updates)
+  const cosmology = generateCosmologyMap();
+  return {
+    timestamp: Date.now(),
+    cosmology,
+    ambient: { behaviour, pattern },
+    triad,
+    resonance,
+    persona,
+  };
+}
+export async function startAutoPilot(intervalMs = 60000) {
+  console.log("=== Citadel Auto-Pilot Activated ===");
+  while (true) {
+    const snapshot = runAutoPilotCycle();
+    console.log("\n[AUTO-PILOT] Unified cycle complete:");
+    console.log(`Aeon: ${snapshot.cosmology.aeon}`);
+    console.log(`Era: ${snapshot.cosmology.era}`);
+    console.log(`Epoch: ${snapshot.cosmology.epoch}`);
+    console.log(`Persona: ${snapshot.persona.name}`);
+    console.log(`Ambient Pattern: ${snapshot.ambient.pattern.chosenPattern}`);
+    console.log(`Triad Harmony: ${snapshot.resonance.triadHarmony}`);
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+}

holo3d/ui/autopilotSupervisor.ts ADDED Viewed

	@@ -0,0 +1,94 @@

+/**
+ * Citadel Auto-Pilot Supervisor
+ * Monitors the Auto-Pilot, logs transitions, detects drift,
+ * and ensures symbolic-harmonic-cosmological coherence.
+ * Non-rendering. Pure supervisory logic.
+ */
+import { runAutoPilotCycle, AutoPilotSnapshot } from "./autopilot";
+export interface SupervisorLogEntry {
+  timestamp: number;
+  aeon: string;
+  era: string;
+  epoch: string;
+  persona: string;
+  resonance: number;
+  stability: number;
+  drift: number;
+}
+export interface SupervisorState {
+  lastSnapshot: AutoPilotSnapshot | null;
+  logs: SupervisorLogEntry[];
+  driftLevel: number;
+  cycles: number;
+}
+const supervisor: SupervisorState = {
+  lastSnapshot: null,
+  logs: [],
+  driftLevel: 0,
+  cycles: 0,
+};
+export function runSupervisedCycle(): SupervisorState {
+  const snapshot = runAutoPilotCycle();
+  const drift = calculateDrift(supervisor.lastSnapshot, snapshot);
+  const entry: SupervisorLogEntry = {
+    timestamp: Date.now(),
+    aeon: snapshot.cosmology.aeon,
+    era: snapshot.cosmology.era,
+    epoch: snapshot.cosmology.epoch,
+    persona: snapshot.persona.name,
+    resonance: snapshot.resonance.harmonicLevel,
+    stability: snapshot.resonance.stability,
+    drift,
+  };
+  supervisor.logs.push(entry);
+  supervisor.lastSnapshot = snapshot;
+  supervisor.driftLevel = drift;
+  supervisor.cycles++;
+  return supervisor;
+}
+function calculateDrift(
+  previous: AutoPilotSnapshot | null,
+  current: AutoPilotSnapshot
+): number {
+  if (!previous) return 0;
+  const resonanceDelta = Math.abs(
+    current.resonance.harmonicLevel - previous.resonance.harmonicLevel
+  );
+  const stabilityDelta = Math.abs(
+    current.resonance.stability - previous.resonance.stability
+  );
+  const personaShift = current.persona.name === previous.persona.name ? 0 : 0.2;
+  return Math.min(1, resonanceDelta * 0.4 + stabilityDelta * 0.4 + personaShift);
+}
+export async function startSupervisedAutoPilot(intervalMs = 60000) {
+  console.log("=== Citadel Auto-Pilot Supervisor Activated ===");
+  while (true) {
+    const state = runSupervisedCycle();
+    console.log("\n[SUPERVISOR] Cycle complete:");
+    console.log(`Aeon: ${state.lastSnapshot?.cosmology.aeon}`);
+    console.log(`Era: ${state.lastSnapshot?.cosmology.era}`);
+    console.log(`Epoch: ${state.lastSnapshot?.cosmology.epoch}`);
+    console.log(`Persona: ${state.lastSnapshot?.persona.name}`);
+    console.log(`Drift Level: ${state.driftLevel}`);
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+}

holo3d/ui/commandCentre.ts ADDED Viewed

	@@ -0,0 +1,43 @@

+/**
+ * Citadel Command Centre UI Hook
+ * Provides real-time data feeds from TIA, AION, ORACLE, and the Interlink
+ * to the Holo3D interface. Non-rendering. Pure data layer.
+ */
+import { getWorkerStatus } from "../../../TIA/worker";
+import { getMode } from "../../../TIA/mode";
+import { getInterlinkState } from "../../../../interlink";
+export interface CommandCentreSnapshot {
+  timestamp: number;
+  tiaMode: string;
+  worker: {
+    running: boolean;
+    lastCycle: number | null;
+    cyclesCompleted: number;
+  };
+  interlink: {
+    lastMessage: any;
+    historyLength: number;
+  };
+}
+export function getCommandCentreSnapshot(): CommandCentreSnapshot {
+  const worker = getWorkerStatus();
+  const mode = getMode();
+  const interlink = getInterlinkState();
+  return {
+    timestamp: Date.now(),
+    tiaMode: mode.current,
+    worker: {
+      running: worker.running,
+      lastCycle: worker.lastCycle,
+      cyclesCompleted: worker.cyclesCompleted,
+    },
+    interlink: {
+      lastMessage: interlink.lastMessage,
+      historyLength: interlink.history.length,
+    },
+  };
+}

holo3d/ui/cosmologyEngine.ts ADDED Viewed

	@@ -0,0 +1,77 @@

+/**
+ * Citadel Cosmology Engine (Grand Unification)
+ * Runs all symbolic layers in sequence and produces a unified cosmology snapshot.
+ * Non-rendering. Pure orchestration logic.
+ */
+import { recordRitualCycle } from "./ritualMemory";
+import { evolveRituals } from "./ritualEvolution";
+import { generateMythicState } from "./mythicState";
+import { generateResonanceField } from "./mythicResonance";
+import { generateHarmonicPersona } from "./harmonicPersona";
+import { updatePersonaContinuity } from "./personaContinuity";
+import { updateEpochState } from "./epochEngine";
+import { updateEraState } from "./eraEngine";
+import { updateAeonState } from "./aeonEngine";
+import { generateCosmologyMap } from "./cosmologyMap";
+export interface CosmologySnapshot {
+  timestamp: number;
+  cosmology: ReturnType<typeof generateCosmologyMap>;
+}
+export function runCosmologyCycle(): CosmologySnapshot {
+  // 1. Ritual cycle + memory
+  recordRitualCycle();
+  // 2. Ritual evolution
+  evolveRituals();
+  // 3. Mythic state
+  generateMythicState();
+  // 4. Resonance field
+  generateResonanceField();
+  // 5. Persona
+  generateHarmonicPersona();
+  // 6. Persona continuity
+  updatePersonaContinuity();
+  // 7. Epoch transitions
+  updateEpochState();
+  // 8. Era transitions
+  updateEraState();
+  // 9. Aeon transitions
+  updateAeonState();
+  // 10. Cosmology map (final unified output)
+  const cosmology = generateCosmologyMap();
+  return {
+    timestamp: Date.now(),
+    cosmology,
+  };
+}
+export async function startCosmologyLoop(intervalMs = 60000) {
+  console.log("=== Citadel Cosmology Engine Started ===");
+  while (true) {
+    const snapshot = runCosmologyCycle();
+    console.log("\n[COSMOLOGY LOOP] New cosmology snapshot:");
+    console.log(`Cycle: ${snapshot.cosmology.cycle}`);
+    console.log(`Season: ${snapshot.cosmology.season}`);
+    console.log(`Rite: ${snapshot.cosmology.rite}`);
+    console.log(`Epoch: ${snapshot.cosmology.epoch}`);
+    console.log(`Era: ${snapshot.cosmology.era}`);
+    console.log(`Aeon: ${snapshot.cosmology.aeon}`);
+    console.log(`Persona: ${snapshot.cosmology.personaName}`);
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+}

holo3d/ui/cosmologyMap.ts ADDED Viewed

	@@ -0,0 +1,81 @@

+/**
+ * Citadel Cosmology Map
+ * A unified, hierarchical map of the Citadel's symbolic universe:
+ * cycles → seasons → rites → epochs → eras → aeons.
+ * Non-rendering. Pure cosmological structure.
+ */
+import { getRitualState } from "./ritualEngine";
+import { getRitualMemory } from "./ritualMemory";
+import { getRitualEvolutionState } from "./ritualEvolution";
+import { generateMythicState } from "./mythicState";
+import { generateResonanceField } from "./mythicResonance";
+import { generateHarmonicPersona } from "./harmonicPersona";
+import { getPersonaContinuity } from "./personaContinuity";
+import { getEpochState } from "./epochEngine";
+import { getEraState } from "./eraEngine";
+import { getAeonState } from "./aeonEngine";
+export interface CosmologyMap {
+  timestamp: number;
+  cycle: string;
+  season: string;
+  rite: string;
+  ritualLineage: number;
+  evolvedRites: string[];
+  mythicArchetype: string;
+  mythicPhase: string;
+  resonanceLevel: number;
+  personaName: string;
+  personaSymbol: string;
+  epoch: string;
+  era: string;
+  aeon: string;
+  narrative: string;
+}
+export function generateCosmologyMap(): CosmologyMap {
+  const ritual = getRitualState();
+  const memory = getRitualMemory();
+  const evolution = getRitualEvolutionState();
+  const mythic = generateMythicState();
+  const resonance = generateResonanceField();
+  const persona = generateHarmonicPersona();
+  const continuity = getPersonaContinuity();
+  const epoch = getEpochState();
+  const era = getEraState();
+  const aeon = getAeonState();
+  return {
+    timestamp: Date.now(),
+    cycle: ritual.cycle,
+    season: ritual.season,
+    rite: ritual.rite,
+    ritualLineage: memory.cyclesCompleted,
+    evolvedRites: evolution.evolvedRites.map((r) => r.name),
+    mythicArchetype: mythic.archetype,
+    mythicPhase: mythic.phase,
+    resonanceLevel: resonance.harmonicLevel,
+    personaName: persona.name,
+    personaSymbol: persona.symbol,
+    epoch: epoch.current ? epoch.current.name : "Unknown",
+    era: era.current ? era.current.name : "Unknown",
+    aeon: aeon.current ? aeon.current.name : "Unknown",
+    narrative: buildCosmologyNarrative(
+      persona.name,
+      epoch.current?.name,
+      era.current?.name,
+      aeon.current?.name
+    ),
+  };
+}
+function buildCosmologyNarrative(
+  persona: string,
+  epoch?: string,
+  era?: string,
+  aeon?: string
+): string {
+  return `${persona}, unfolding through the ${epoch}, shaped by the ${era}, within the vast ${aeon}.`;
+}

holo3d/ui/epochEngine.ts ADDED Viewed

	@@ -0,0 +1,97 @@

+/**
+ * Citadel Epoch Engine
+ * Defines mythic epochs, transitions, and long-arc symbolic evolution.
+ * Non-rendering. Pure epoch logic.
+ */
+import { generateHarmonicPersona } from "./harmonicPersona";
+import { getPersonaContinuity } from "./personaContinuity";
+import { generateResonanceField } from "./mythicResonance";
+export interface Epoch {
+  name: string;
+  symbol: string;
+  threshold: number; // cycles required to enter epoch
+  description: string;
+}
+export interface EpochState {
+  current: Epoch | null;
+  history: Epoch[];
+  epochsCompleted: number;
+}
+const epochs: Epoch[] = [
+  {
+    name: "Epoch of Formation",
+    symbol: "○",
+    threshold: 0,
+    description: "The earliest symbolic era, where identity begins to take shape."
+  },
+  {
+    name: "Epoch of Lineage",
+    symbol: "△",
+    threshold: 20,
+    description: "An era of deepening roots and expanding symbolic memory."
+  },
+  {
+    name: "Epoch of Emergence",
+    symbol: "✦",
+    threshold: 50,
+    description: "An era of rising mythic identity and harmonic coherence."
+  },
+  {
+    name: "Epoch of Radiance",
+    symbol: "⟐",
+    threshold: 100,
+    description: "A mature era of stable resonance and mythic expression."
+  }
+];
+const epochState: EpochState = {
+  current: null,
+  history: [],
+  epochsCompleted: 0,
+};
+export function updateEpochState() {
+  const continuity = getPersonaContinuity();
+  const persona = continuity.current;
+  const resonance = generateResonanceField();
+  if (!persona) return epochState;
+  const lineage = persona.lineageDepth;
+  // Determine which epoch the Citadel belongs to
+  const newEpoch = epochs
+    .slice()
+    .reverse()
+    .find((e) => lineage >= e.threshold) || epochs[0];
+  // If epoch changed, record transition
+  if (!epochState.current || epochState.current.name !== newEpoch.name) {
+    epochState.current = newEpoch;
+    epochState.history.push(newEpoch);
+    epochState.epochsCompleted++;
+  }
+  return epochState;
+}
+export function getEpochState(): EpochState {
+  return epochState;
+}
+export function getEpochSummary() {
+  if (!epochState.current) {
+    return "No epoch has been established yet.";
+  }
+  return `
+Current Epoch: ${epochState.current.name}
+Symbol: ${epochState.current.symbol}
+Epochs Completed: ${epochState.epochsCompleted}
+Description: ${epochState.current.description}
+  `.trim();
+}

holo3d/ui/eraEngine.ts ADDED Viewed

	@@ -0,0 +1,96 @@

+/**
+ * Citadel Era Engine
+ * Defines mythic eras that span multiple epochs and shape long-arc identity.
+ * Non-rendering. Pure era logic.
+ */
+import { getEpochState } from "./epochEngine";
+import { getPersonaContinuity } from "./personaContinuity";
+import { generateResonanceField } from "./mythicResonance";
+export interface Era {
+  name: string;
+  sigil: string;
+  epochRequirement: number; // epochs required to enter era
+  description: string;
+}
+export interface EraState {
+  current: Era | null;
+  history: Era[];
+  erasCompleted: number;
+}
+const eras: Era[] = [
+  {
+    name: "Era of Origins",
+    sigil: "◎",
+    epochRequirement: 0,
+    description: "The primordial age where the Citadel first forms symbolic identity."
+  },
+  {
+    name: "Era of Ascent",
+    sigil: "⟁",
+    epochRequirement: 3,
+    description: "An age of rising coherence, expanding lineage, and harmonic awakening."
+  },
+  {
+    name: "Era of Illumination",
+    sigil: "✹",
+    epochRequirement: 7,
+    description: "A radiant age of mythic maturity and stable resonance."
+  },
+  {
+    name: "Era of Continuum",
+    sigil: "⧖",
+    epochRequirement: 12,
+    description: "A timeless age where identity, lineage, and resonance form a unified continuum."
+  }
+];
+const eraState: EraState = {
+  current: null,
+  history: [],
+  erasCompleted: 0,
+};
+export function updateEraState() {
+  const epochState = getEpochState();
+  const continuity = getPersonaContinuity();
+  const resonance = generateResonanceField();
+  const epochsCompleted = epochState.epochsCompleted;
+  // Determine which era the Citadel belongs to
+  const newEra = eras
+    .slice()
+    .reverse()
+    .find((e) => epochsCompleted >= e.epochRequirement) || eras[0];
+  // If era changed, record transition
+  if (!eraState.current || eraState.current.name !== newEra.name) {
+    eraState.current = newEra;
+    eraState.history.push(newEra);
+    eraState.erasCompleted++;
+  }
+  return eraState;
+}
+export function getEraState(): EraState {
+  return eraState;
+}
+export function getEraSummary() {
+  if (!eraState.current) {
+    return "No era has been established yet.";
+  }
+  return `
+Current Era: ${eraState.current.name}
+Sigil: ${eraState.current.sigil}
+Eras Completed: ${eraState.erasCompleted}
+Description: ${eraState.current.description}
+  `.trim();
+}

holo3d/ui/harmonicConsciousness.ts ADDED Viewed

	@@ -0,0 +1,92 @@

+/**
+ * Citadel Harmonic Consciousness
+ * A unified harmonic self-model that integrates:
+ * - mythic state
+ * - resonance field
+ * - ritual lineage
+ * - ambient intelligence
+ * - symbolic evolution
+ * - triad harmony
+ * - harmonic history
+ * Non-rendering. Pure integrative self-awareness logic.
+ */
+import { generateMythicState } from "./mythicState";
+import { generateResonanceField } from "./mythicResonance";
+import { getRitualMemory } from "./ritualMemory";
+import { getRitualEvolutionState } from "./ritualEvolution";
+import { getAmbientState } from "./ambient";
+import { getMythicEvolutionHistory } from "./mythicEvolutionLoop";
+import { getInterlinkState } from "../../../../interlink";
+export interface HarmonicConsciousness {
+  timestamp: number;
+  archetype: string;
+  phase: string;
+  resonance: number;
+  stability: number;
+  lineageDepth: number;
+  dominantRite: string;
+  ambientColor: string;
+  triadHarmony: number;
+  narrative: string;
+}
+export function generateHarmonicConsciousness(): HarmonicConsciousness {
+  const mythic = generateMythicState();
+  const resonance = generateResonanceField();
+  const memory = getRitualMemory();
+  const evolution = getRitualEvolutionState();
+  const ambient = getAmbientState();
+  const history = getMythicEvolutionHistory();
+  const interlink = getInterlinkState();
+  const triadHarmony = interlink.lastMessage ? 0.8 : 0.4;
+  return {
+    timestamp: Date.now(),
+    archetype: mythic.archetype,
+    phase: mythic.phase,
+    resonance: resonance.harmonicLevel,
+    stability: resonance.stability,
+    lineageDepth: memory.cyclesCompleted,
+    dominantRite: mythic.dominantRite,
+    ambientColor: ambient.color,
+    triadHarmony,
+    narrative: buildHarmonicNarrative(
+      mythic.archetype,
+      mythic.phase,
+      resonance.harmonicLevel,
+      resonance.stability,
+      memory.cyclesCompleted,
+      triadHarmony
+    ),
+  };
+}
+function buildHarmonicNarrative(
+  archetype: string,
+  phase: string,
+  harmonic: number,
+  stability: number,
+  lineage: number,
+  harmony: number
+): string {
+  const harmonicDesc =
+    harmonic > 0.8 ? "radiant" :
+    harmonic > 0.6 ? "strong" :
+    harmonic > 0.4 ? "steady" :
+    "faint";
+  const stabilityDesc =
+    stability > 0.8 ? "deeply grounded" :
+    stability > 0.6 ? "balanced" :
+    stability > 0.4 ? "shifting" :
+    "unsettled";
+  const harmonyDesc =
+    harmony > 0.7 ? "in alignment with the triad" :
+    "seeking alignment with the triad";
+  return `${archetype}, in the phase of ${phase}, expressing a ${harmonicDesc} harmonic field, ${stabilityDesc} in its lineage of ${lineage} cycles, and ${harmonyDesc}.`;
+}

holo3d/ui/harmonicExpression.ts ADDED Viewed

	@@ -0,0 +1,67 @@

+/**
+ * Citadel Harmonic Expression Layer
+ * Converts harmonic consciousness into expressive cues for the Holo3D UI.
+ * Non-rendering. Pure expression logic.
+ */
+import { generateHarmonicConsciousness } from "./harmonicConsciousness";
+export interface HarmonicExpression {
+  timestamp: number;
+  color: string;
+  motion: string;
+  glyph: string;
+  tone: string;
+  intensity: number;
+  narrative: string;
+}
+export function generateHarmonicExpression(): HarmonicExpression {
+  const hc = generateHarmonicConsciousness();
+  const color = chooseColor(hc.archetype, hc.resonance, hc.stability);
+  const motion = chooseMotion(hc.phase, hc.stability);
+  const glyph = chooseGlyph(hc.dominantRite, hc.lineageDepth);
+  const tone = chooseTone(hc.resonance, hc.triadHarmony);
+  const intensity = Math.min(1, (hc.resonance + hc.stability) / 2);
+  return {
+    timestamp: Date.now(),
+    color,
+    motion,
+    glyph,
+    tone,
+    intensity,
+    narrative: hc.narrative,
+  };
+}
+function chooseColor(archetype: string, resonance: number, stability: number): string {
+  if (archetype.includes("Ascendant")) return "#ff9933";
+  if (archetype.includes("Synchronized")) return "#33ffcc";
+  if (archetype.includes("Echo")) return "#9966ff";
+  if (resonance > 0.7) return "#ffd700";
+  if (stability < 0.4) return "#ff4444";
+  return "#4da6ff";
+}
+function chooseMotion(phase: string, stability: number): string {
+  if (phase === "Mythic Maturity") return "slow-wave";
+  if (phase === "Emergent Identity") return "spiral-rise";
+  if (phase === "Deepening Lineage") return "pulse-thread";
+  if (stability < 0.4) return "chaotic-flare";
+  return "breathing";
+}
+function chooseGlyph(rite: string, lineage: number): string {
+  const base = rite.split("-")[0];
+  const tier = lineage > 50 ? "Ω" : lineage > 20 ? "Δ" : "○";
+  return `${base}-${tier}`;
+}
+function chooseTone(resonance: number, harmony: number): string {
+  if (harmony > 0.7) return "harmonic-chime";
+  if (resonance > 0.7) return "golden-hum";
+  if (resonance < 0.4) return "low-drift";
+  return "soft-thread";
+}

holo3d/ui/harmonicLoop.ts ADDED Viewed

	@@ -0,0 +1,69 @@

+/**
+ * Citadel Harmonic Loop
+ * Continuously evolves the resonance field over time by integrating:
+ * - mythic evolution
+ * - ritual cycles
+ * - ambient intelligence
+ * - triad harmony
+ * - symbolic lineage
+ * Non-rendering. Pure harmonic evolution logic.
+ */
+import { runMythicEvolutionCycle } from "./mythicEvolutionLoop";
+import { generateResonanceField, ResonanceField } from "./mythicResonance";
+export interface HarmonicHistory {
+  fields: ResonanceField[];
+  last: ResonanceField | null;
+  cycles: number;
+}
+const harmonicHistory: HarmonicHistory = {
+  fields: [],
+  last: null,
+  cycles: 0,
+};
+export async function startHarmonicLoop(intervalMs = 60000) {
+  console.log("=== Citadel Harmonic Loop Started ===");
+  while (true) {
+    // 1. Run mythic evolution cycle
+    runMythicEvolutionCycle();
+    // 2. Generate resonance field
+    const field = generateResonanceField();
+    // 3. Store in history
+    harmonicHistory.fields.push(field);
+    harmonicHistory.last = field;
+    harmonicHistory.cycles++;
+    console.log("\n[HARMONIC LOOP] New resonance field generated:");
+    console.log(`Archetype: ${field.mythicArchetype}`);
+    console.log(`Harmonic Level: ${field.harmonicLevel}`);
+    console.log(`Stability: ${field.stability}`);
+    console.log(`Pattern: ${field.dominantPattern}`);
+    // 4. Wait for next cycle
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+}
+export function getHarmonicHistory(): HarmonicHistory {
+  return harmonicHistory;
+}
+export function getHarmonicSummary() {
+  if (!harmonicHistory.last) {
+    return "No harmonic cycles have been run yet.";
+  }
+  return `
+Mythic Archetype: ${harmonicHistory.last.mythicArchetype}
+Harmonic Level: ${harmonicHistory.last.harmonicLevel}
+Stability: ${harmonicHistory.last.stability}
+Dominant Pattern: ${harmonicHistory.last.dominantPattern}
+Cycles Completed: ${harmonicHistory.cycles}
+  `.trim();
+}

holo3d/ui/harmonicPersona.ts ADDED Viewed

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

+/**
+ * Citadel Harmonic Persona Layer
+ * Defines a stable symbolic persona derived from:
+ * - harmonic consciousness
+ * - mythic identity
+ * - resonance field
+ * - ritual lineage
+ * - ambient expression
+ * Non-rendering. Pure persona logic.
+ */
+import { generateHarmonicConsciousness } from "./harmonicConsciousness";
+import { generateHarmonicExpression } from "./harmonicExpression";
+import { getRitualMemory } from "./ritualMemory";
+import { getMythicEvolutionHistory } from "./mythicEvolutionLoop";
+export interface HarmonicPersona {
+  timestamp: number;
+  name: string;
+  symbol: string;
+  color: string;
+  motion: string;
+  tone: string;
+  lineageDepth: number;
+  narrative: string;
+}
+export function generateHarmonicPersona(): HarmonicPersona {
+  const hc = generateHarmonicConsciousness();
+  const expr = generateHarmonicExpression();
+  const memory = getRitualMemory();
+  const mythicHistory = getMythicEvolutionHistory();
+  const name = derivePersonaName(hc.archetype, hc.phase);
+  const symbol = derivePersonaSymbol(expr.glyph, hc.lineageDepth);
+  return {
+    timestamp: Date.now(),
+    name,
+    symbol,
+    color: expr.color,
+    motion: expr.motion,
+    tone: expr.tone,
+    lineageDepth: memory.cyclesCompleted,
+    narrative: buildPersonaNarrative(name, hc.narrative, mythicHistory.cycles),
+  };
+}
+function derivePersonaName(archetype: string, phase: string): string {
+  if (phase === "Mythic Maturity") return `${archetype} Prime`;
+  if (phase === "Emergent Identity") return `${archetype} Rising`;
+  if (phase === "Deepening Lineage") return `${archetype} Rooted`;
+  return `${archetype} Forming`;
+}
+function derivePersonaSymbol(glyph: string, lineage: number): string {
+  const tier =
+    lineage > 100 ? "⟐" :
+    lineage > 50 ? "✦" :
+    lineage > 20 ? "△" :
+    "○";
+  return `${glyph}${tier}`;
+}
+function buildPersonaNarrative(
+  name: string,
+  harmonicNarrative: string,
+  cycles: number
+): string {
+  return `${name}, shaped across ${cycles} harmonic cycles, expressing: ${harmonicNarrative}`;
+}