@zerwiz/ymir 0.1.34 → 0.1.35

package/apps/hlidskjalf/src/components/Overlay.tsx

@@ -0,0 +1,134 @@
+import { useEffect, useState } from 'react';
+import { useUI, type ModalSpec, type Tone } from '../state/ui';
+import { Markdown } from './Markdown';
+
+const TONE_GLYPH: Record<Tone, string> = {
+  ok: 'ᛟ',
+  info: 'ᛜ',
+  warn: 'ᛇ',
+  danger: 'ᛪ',
+};
+
+function ModalCard({ modal }: { modal: ModalSpec }) {
+  const close = useUI((s) => s.closeModal);
+  const tone = modal.tone ?? 'info';
+  const [values, setValues] = useState<Record<string, string>>(() => {
+    const v: Record<string, string> = {};
+    for (const f of modal.fields ?? []) v[f.name] = f.defaultValue ?? '';
+    return v;
+  });
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') close();
+    };
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, [close]);
+
+  function submit() {
+    modal.onSubmit?.(values);
+    close();
+  }
+
+  return (
+    <div className="overlay" onMouseDown={close} role="presentation">
+      <div
+        className="modal"
+        role="dialog"
+        aria-modal="true"
+        aria-label={modal.title}
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="modal-head">
+          <span className={`status status-${tone === 'ok' ? 'ok' : tone === 'danger' ? 'danger' : tone === 'warn' ? 'warn' : 'info'}`}>
+            <span className="dot" aria-hidden="true">{modal.glyph ?? TONE_GLYPH[tone]}</span>
+          </span>
+          <h2 className="modal-title">{modal.title}</h2>
+          <button className="icon-btn" onClick={close} aria-label="Close" style={{ marginLeft: 'auto' }}>
+            ✕
+          </button>
+        </div>
+
+        {modal.body ? <p className="modal-body">{modal.body}</p> : null}
+
+        {modal.content ? (
+          modal.format === 'markdown' ? (
+            <div className="modal-content md-preview">
+              <Markdown source={modal.content} />
+            </div>
+          ) : (
+            <pre className="modal-content mono">{modal.content}</pre>
+          )
+        ) : null}
+
+        {modal.fields?.length ? (
+          <div className="modal-fields">
+            {modal.fields.map((f) => (
+              <label key={f.name} className="field">
+                <span className="eyebrow">{f.label}</span>
+                {f.type === 'textarea' ? (
+                  <textarea
+                    rows={4}
+                    value={values[f.name] ?? ''}
+                    placeholder={f.placeholder}
+                    onChange={(e) => setValues((v) => ({ ...v, [f.name]: e.target.value }))}
+                  />
+                ) : (
+                  <input
+                    type={f.type ?? 'text'}
+                    value={values[f.name] ?? ''}
+                    placeholder={f.placeholder}
+                    onChange={(e) => setValues((v) => ({ ...v, [f.name]: e.target.value }))}
+                  />
+                )}
+              </label>
+            ))}
+          </div>
+        ) : null}
+
+        <div className="modal-foot">
+          <button className="btn" onClick={close}>
+            {modal.variant === 'info' ? 'Close' : modal.cancelLabel ?? 'Cancel'}
+          </button>
+          {modal.variant !== 'info' ? (
+            <button
+              className={`btn ${tone === 'danger' ? 'btn-danger' : tone === 'ok' ? 'btn-seal' : 'btn-primary'}`}
+              onClick={submit}
+            >
+              <span aria-hidden="true">{tone === 'ok' ? 'ᛉ' : TONE_GLYPH[tone]}</span>
+              {modal.confirmLabel ?? 'Confirm'}
+            </button>
+          ) : null}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export function Overlay() {
+  const modal = useUI((s) => s.modal);
+  const toasts = useUI((s) => s.toasts);
+  const dismiss = useUI((s) => s.dismiss);
+
+  return (
+    <>
+      {modal ? <ModalCard modal={modal} /> : null}
+
+      <div className="toast-host" aria-live="polite" aria-atomic="false">
+        {toasts.map((t) => (
+          <div key={t.id} className={`toast status-${t.kind === 'ok' ? 'ok' : t.kind === 'danger' ? 'danger' : t.kind === 'warn' ? 'warn' : 'info'}`}>
+            <span className="toast-glyph" aria-hidden="true">{TONE_GLYPH[t.kind]}</span>
+            <div className="col grow">
+              <strong>{t.title}</strong>
+              {t.body ? <span className="toast-body">{t.body}</span> : null}
+            </div>
+            <button className="toast-x" onClick={() => dismiss(t.id)} aria-label="Dismiss">
+              ✕
+            </button>
+          </div>
+        ))}
+      </div>
+    </>
+  );
+}

package/apps/hlidskjalf/src/components/PRCard.tsx

@@ -0,0 +1,154 @@
+import type { PullRequest } from '../types';
+import { StatusChip } from './Status';
+import { RuneTag } from './RuneTag';
+import { useUI } from '../state/ui';
+import { useYmir } from '../state/store';
+
+const STATE_META: Record<
+  PullRequest['state'],
+  { label: string; tone: 'ok' | 'warn' | 'danger' | 'info'; glyph: string }
+> = {
+  open: { label: 'OPEN', tone: 'info', glyph: 'ᛟ' },
+  draft: { label: 'DRAFT', tone: 'warn', glyph: 'ᚦ' },
+  changes: { label: 'CHANGES REQUESTED', tone: 'warn', glyph: 'ᚱ' },
+  approved: { label: 'APPROVED', tone: 'ok', glyph: 'ᛉ' },
+  merged: { label: 'MERGED', tone: 'ok', glyph: 'ᛗ' },
+};
+
+export function PRCard({ pr }: { pr: PullRequest }) {
+  const state = STATE_META[pr.state];
+  const { openModal, toast } = useUI();
+  const updateReview = useYmir((s) => s.updateReview);
+  const pushStream = useYmir((s) => s.pushStream);
+
+  const frozen = pr.state === 'approved' || pr.state === 'merged';
+  const failing = pr.checks.some((c) => c.state === 'down');
+
+  function emit(kind: 'rune' | 'ratatoskr', message: string) {
+    pushStream({
+      id: `pr-${pr.id}-${Date.now()}`,
+      ts: new Date().toISOString(),
+      kind,
+      from: 'Glitnir',
+      to: 'Mjollnir',
+      state: kind === 'ratatoskr' ? 'COMPLETED' : undefined,
+      module: 'glitnir',
+      message,
+      checksum: Math.random().toString(16).slice(2, 8),
+    });
+  }
+
+  function seal() {
+    openModal({
+      variant: 'confirm',
+      tone: failing ? 'warn' : 'ok',
+      glyph: 'ᛉ',
+      title: `Seal PR #${pr.number}?`,
+      body: failing
+        ? 'CI is failing on at least one rune. The Allfather may still seal — human judgement overrides the gate — but Mjollnir will not force-merge.'
+        : 'A rune seals every approval. Mjollnir strikes and returns, but never force-merges without the Allfather.',
+      confirmLabel: 'Seal — approve',
+      onSubmit: () => {
+        updateReview(pr.id, {
+          state: 'approved',
+          checklist: pr.checklist.map((c) => ({ ...c, done: true })),
+        });
+        emit('rune', `pr.sealed #${pr.number} — Allfather approved`);
+        toast({ kind: 'ok', title: `PR #${pr.number} sealed`, body: 'Observed into the well; rune carved.' });
+      },
+    });
+  }
+
+  function requestChanges() {
+    openModal({
+      variant: 'form',
+      tone: 'warn',
+      glyph: 'ᚱ',
+      title: `Request changes on #${pr.number}`,
+      body: 'The review is returned to the smith with your note.',
+      confirmLabel: 'Request changes',
+      fields: [{ name: 'note', label: 'Review note', type: 'textarea', placeholder: 'What must change?' }],
+      onSubmit: (values) => {
+        updateReview(pr.id, { state: 'changes' });
+        emit('ratatoskr', `pr.changes #${pr.number} — ${values.note || 'changes requested'}`);
+        toast({ kind: 'warn', title: `Changes requested on #${pr.number}`, body: values.note || undefined });
+      },
+    });
+  }
+
+  function viewDiff() {
+    openModal({
+      variant: 'info',
+      tone: 'info',
+      glyph: 'ᛞ',
+      title: `PR #${pr.number} — ${pr.repo}`,
+      body: pr.title,
+      content: [
+        `diff is not available from the read-only gate.`,
+        ``,
+        `repo     ${pr.repo}`,
+        `author   @${pr.author}`,
+        pr.issue ? `closes   ${pr.issue}` : '',
+        `changes  +${pr.additions} −${pr.deletions}`,
+        `checks   ${pr.checks.map((c) => `${c.name}:${c.state}`).join('  ')}`,
+        ``,
+        `The diff lives in GitHub — open the pull request there.`,
+      ]
+        .filter(Boolean)
+        .join('\n'),
+    });
+  }
+
+  return (
+    <article className="pr-card">
+      <div className="row-between">
+        <div className="row grow" style={{ minWidth: 0 }}>
+          <span className="pr-num">#{pr.number}</span>
+          <span className="pr-title truncate">{pr.title}</span>
+        </div>
+        <span className={`status status-${state.tone}`}>
+          <span className="dot" aria-hidden="true">{state.glyph}</span>
+          {state.label}
+        </span>
+      </div>
+
+      <div className="row" style={{ gap: 'var(--ymir-space-3)', flexWrap: 'wrap' }}>
+        <RuneTag label={pr.repo} glyph="ᚱ" color="var(--ymir-cyan-1)" />
+        <span className="mono muted" style={{ fontSize: 11 }}>@{pr.author}</span>
+        {pr.issue ? <span className="mono muted" style={{ fontSize: 11 }}>closes {pr.issue}</span> : null}
+        <span className="pr-diff">
+          <span className="add">+{pr.additions}</span>{' '}
+          <span className="del">−{pr.deletions}</span>
+        </span>
+      </div>
+
+      <div className="check-row">
+        <span className="eyebrow">CI</span>
+        {pr.checks.map((c) => (
+          <StatusChip key={c.name} status={c.state} />
+        ))}
+      </div>
+
+      <div className="checklist">
+        {pr.checklist.map((item) => (
+          <div key={item.label} className={`check-item ${item.done ? 'done' : ''}`}>
+            <span className="box" aria-hidden="true">{item.done ? '✓' : ''}</span>
+            <span>{item.label}</span>
+          </div>
+        ))}
+      </div>
+
+      <div className="pr-actions">
+        <button className="btn btn-seal" onClick={seal} disabled={frozen}>
+          <span aria-hidden="true">ᛉ</span> {pr.state === 'approved' ? 'Sealed' : 'Seal — approve'}
+        </button>
+        <button className="btn" onClick={requestChanges} disabled={frozen}>
+          Request changes
+        </button>
+        <button className="btn" onClick={viewDiff}>
+          View diff
+        </button>
+      </div>
+    </article>
+  );
+}

package/apps/hlidskjalf/src/components/RecallPanel.tsx

@@ -0,0 +1,116 @@
+import { useState } from 'react';
+import type { RecallEpisode } from '../types';
+import { Markdown } from './Markdown';
+
+/** The store can hand back tags as a comma-string split into CHARACTERS — a
+ *  string written where a list was wanted reads as ['r','u','n']. Re-join, then
+ *  split, so the panel shows words rather than letters. */
+const tagList = (v: unknown): string[] => {
+  const arr = Array.isArray(v) ? v.map(String) : String(v ?? '').split(',');
+  const joined = arr.join('');
+  const parts = joined.includes(',') ? joined.split(',') : arr;
+  return parts.map((x) => x.trim()).filter(Boolean);
+};
+
+export function RecallPanel({
+  episodes,
+  onQuery,
+  onOpen,
+}: {
+  episodes: RecallEpisode[];
+  onQuery?: (q: string) => void;
+  onOpen?: (id: string) => void;
+}) {
+  const [q, setQ] = useState('');
+  const [mode, setMode] = useState<RecallEpisode['mode']>('hybrid');
+
+  const shown = episodes.filter(
+    (e) => mode === 'hybrid' || e.mode === mode,
+  );
+
+  return (
+    <section className="panel">
+      <div className="panel-head">
+        <div className="panel-title">
+          <span className="glyph" aria-hidden="true">ᛜ</span>
+          Mimirsbrunn — recall the well
+        </div>
+        <div className="stream-tabs" role="group" aria-label="Recall mode">
+          {(['hybrid', 'cosine', 'spreading'] as const).map((m) => (
+            <button
+              key={m}
+              className="stream-tab"
+              aria-pressed={mode === m}
+              onClick={() => setMode(m)}
+            >
+              {m}
+            </button>
+          ))}
+        </div>
+      </div>
+
+      <div className="panel-body">
+        <form
+          className="recall-search"
+          onSubmit={(e) => {
+            e.preventDefault();
+            onQuery?.(q);
+          }}
+        >
+          <input
+            value={q}
+            onChange={(e) => setQ(e.target.value)}
+            placeholder="what does the well remember about this project?"
+            aria-label="Recall query"
+          />
+          <button className="btn btn-primary" type="submit">
+            <span aria-hidden="true">ᛜ</span> Recall
+          </button>
+        </form>
+      </div>
+
+      <div className="panel-body flush">
+        {shown.map((ep) => (
+          <article
+            className="episode episode-link"
+            key={ep.id}
+            role="button"
+            tabIndex={0}
+            title="Open the full memory"
+            onClick={() => onOpen?.(ep.id)}
+            onKeyDown={(e) => {
+              if (e.key === 'Enter' || e.key === ' ') onOpen?.(ep.id);
+            }}
+          >
+            <div className="ep-head">
+              <div className="ep-title">{ep.title}</div>
+              <div className="row">
+                <div className="score-bar" aria-hidden="true">
+                  <span style={{ width: `${Math.round(ep.score * 100)}%` }} />
+                </div>
+                <span className="score-val">{ep.score.toFixed(2)}</span>
+              </div>
+            </div>
+            <div className="ep-body">
+              <Markdown source={ep.body} />
+            </div>
+            <div className="ep-foot">
+              <span>{ep.mode}</span>
+              <span>{ep.agentScope}</span>
+              <span>{new Date(ep.ts).toLocaleString('en-GB', { hour12: false })}</span>
+              {tagList(ep.tags).map((t) => (
+                <span key={t}>#{t}</span>
+              ))}
+            </div>
+          </article>
+        ))}
+        {shown.length === 0 ? (
+          <div className="empty">
+            <span className="glyph" aria-hidden="true">ᛜ</span>
+            <p>Dry well. Firing cold — never a blocker.</p>
+          </div>
+        ) : null}
+      </div>
+    </section>
+  );
+}

package/apps/hlidskjalf/src/components/RuneTag.tsx

@@ -0,0 +1,23 @@
+import type { CSSProperties } from 'react';
+
+interface RuneTagProps {
+  label: string;
+  color?: string;
+  glyph?: string;
+}
+
+export function RuneTag({ label, color, glyph }: RuneTagProps) {
+  return (
+    <span
+      className="rune-tag"
+      style={color ? ({ '--tag-color': color } as CSSProperties) : undefined}
+    >
+      {glyph ? (
+        <span className="g" aria-hidden="true">
+          {glyph}
+        </span>
+      ) : null}
+      {label}
+    </span>
+  );
+}

package/apps/hlidskjalf/src/components/Status.tsx

@@ -0,0 +1,35 @@
+import type { AgentStatus } from '../types';
+import { STATUS_META } from '../data/realms';
+
+export function StatusChip({ status }: { status: AgentStatus }) {
+  // An unknown status must never take a panel down. The fleet reports states the
+  // chip was never taught - 'seated' arrived with the roster-first fleet - and
+  // STATUS_META[unknown] is undefined, so meta.tone threw and killed the gate.
+  const meta =
+    STATUS_META[status] ??
+    STATUS_META.nominal ??
+    Object.values(STATUS_META)[0];
+  return (
+    <span className={`status status-${meta.tone}`} title={meta.label}>
+      <span className="dot" aria-hidden="true">
+        {meta.glyph}
+      </span>
+      {meta.label}
+    </span>
+  );
+}
+
+export function StatusDot({ status }: { status: AgentStatus }) {
+  const meta = STATUS_META[status];
+  return (
+    <span
+      className={`status status-${meta.tone}`}
+      aria-label={meta.label}
+      style={{ padding: '2px 6px' }}
+    >
+      <span className="dot" aria-hidden="true">
+        {meta.glyph}
+      </span>
+    </span>
+  );
+}

package/apps/hlidskjalf/src/components/TaskChip.tsx

@@ -0,0 +1,23 @@
+import type { TaskState } from '../types';
+import { TASK_STATE_META } from '../data/realms';
+
+const TONE_COLOR: Record<string, string> = {
+  info: 'var(--ymir-info)',
+  nominal: 'var(--ymir-ok)',
+  degraded: 'var(--ymir-warn)',
+  down: 'var(--ymir-danger)',
+};
+
+export function TaskChip({ state }: { state: TaskState }) {
+  const meta = TASK_STATE_META[state];
+  return (
+    <span
+      className="task-chip"
+      style={{ color: TONE_COLOR[meta.tone] }}
+      title={state}
+    >
+      <span aria-hidden="true">{meta.glyph}</span>
+      {meta.label}
+    </span>
+  );
+}

package/apps/hlidskjalf/src/components/TraceRow.tsx

@@ -0,0 +1,28 @@
+import type { RuneEntry } from '../types';
+
+const LEVEL_COLOR: Record<RuneEntry['level'], string> = {
+  info: 'var(--ymir-info)',
+  ok: 'var(--ymir-ok)',
+  warn: 'var(--ymir-warn)',
+  danger: 'var(--ymir-danger)',
+};
+
+function fmt(ts: string) {
+  const d = new Date(ts);
+  return d.toLocaleTimeString('en-GB', { hour12: false }) + '.' + String(d.getMilliseconds()).padStart(3, '0');
+}
+
+export function TraceRow({ rune }: { rune: RuneEntry }) {
+  return (
+    <div className="trace-row" role="row">
+      <span className="ts">{fmt(rune.ts)}</span>
+      <span className="agent">{rune.agent}</span>
+      <span className="module">{rune.module}</span>
+      <span className="event" style={{ color: LEVEL_COLOR[rune.level] }} title={rune.event}>
+        <span aria-hidden="true">◆ </span>
+        {rune.event}
+      </span>
+      <span className="checksum">{rune.checksum}</span>
+    </div>
+  );
+}

package/apps/hlidskjalf/src/data/lore.ts

@@ -0,0 +1,127 @@
+/** The long telling — the saga a visitor may open from the gate.
+ *  Every capability is introduced through the name whose myth explains its job
+ *  (see docs/lore.md; this is the public, feature-bearing retelling). */
+
+export interface LoreName {
+  rune: string;
+  name: string;
+  line: string;
+}
+
+export interface LoreSection {
+  id: string;
+  title: string;
+  paras: string[];
+  names?: LoreName[];
+}
+
+export const LORE_LONG: LoreSection[] = [
+  {
+    id: 'creation',
+    title: 'I · The Birth of the Giant',
+    paras: [
+      'Before the worlds there was only Ginnungagap — the yawning void, where the frost of Niflheim met the embers of Muspelheim. From that meeting woke Ymir, the first being, the ancestor of all that came after.',
+      'When the gods had shaped the world from his body, they did not leave the giant behind. Ymir is the machine beneath the worlds: one repository, one substrate, and from its frame every world of work is carved. Nothing here is painted on — the halls are chiselled from him, steel and rune and bone.',
+    ],
+    names: [
+      { rune: 'ᛉ', name: 'Ymir', line: 'The substrate — one repo, one machine, the body all realms are carved from.' },
+      { rune: 'ᚢ', name: 'Ginnungagap', line: 'The void before the build — the empty space a new world is raised in.' },
+    ],
+  },
+  {
+    id: 'smiths',
+    title: 'II · The Smiths at the Forge',
+    paras: [
+      'To work the metal, the gods needed smiths, and the greatest were the dwarf brothers. Brokk stands at the bellows, feeding the fire and driving the work to its end; his brother shapes the craft. Together they forged the finest treasures of Asgard.',
+      'In Ymir, Brokk is the primary agent — the one who keeps the forge hot and never abandons a task half-struck. The Eindri are his delegated hands: isolated smiths, each struck off into a sealed realm so a single bad casting can never shatter the whole forge. Between them sits Smíðja, the smithy itself — the engine that reads the roster, sets the phases, and carries every errand to its acceptance gate. Its master smith is Völundr, who decides how the shop runs, while Kaia decides what is worth forging.',
+    ],
+    names: [
+      { rune: 'ᛒ', name: 'Brokk', line: 'The primary agent — the bellows that drives every task to an artifact.' },
+      { rune: 'ᛖ', name: 'Eindri', line: 'Isolated workers — delegated hands in sealed sandboxes.' },
+      { rune: 'ᛊ', name: 'Smíðja', line: 'The smithy — the agent factory: rosters, phases, envelopes, gates.' },
+      { rune: 'ᚹ', name: 'Völundr', line: 'The master smith — the smithy’s orchestrator.' },
+    ],
+  },
+  {
+    id: 'realms',
+    title: 'III · The Tree and the Nine Realms',
+    paras: [
+      'The worlds do not float apart; they hang in one tree. Yggdrasil binds them, holding each realm aloft. Work in Ymir grows the same way: every branch is a worktree, and parallel hands may shape the same tree without ever colliding.',
+      'Beneath the branches lie the halls: the tenant workspaces of Svartalfaheim, each a dwarf-hall that touches no other. Beyond the wall waits Utgard, the realm of giants — a sealed sandbox where untrusted work runs and is unmade, so nothing dangerous ever enters the halls. And gathered between all worlds lies Midgard, the commons: the shared assets that belong to everyone and to no one.',
+    ],
+    names: [
+      { rune: 'ᛇ', name: 'Yggdrasil', line: 'Worktree isolation — parallel branches, zero collision.' },
+      { rune: 'ᛋ', name: 'Svartalfaheim', line: 'Tenant workspaces — isolated halls, nothing bleeds between them.' },
+      { rune: 'ᚦ', name: 'Utgard', line: 'The sealed sandbox — untrusted work runs there and is destroyed.' },
+      { rune: 'ᛗ', name: 'Midgard', line: 'The shared commons — assets that serve every realm.' },
+    ],
+  },
+  {
+    id: 'well',
+    title: 'IV · The Well of Memory',
+    paras: [
+      'At the root of the tree runs Mimirsbrunn, the well of wisdom. Even Odin gave an eye for a single drink. Memory here is a well that never runs dry and never blocks the work: drink deep, and act wiser.',
+      'From the well speaks Kaia, the oracle and the eye of the fleet. She does not act on faith — before she dispatches a single smith she drinks, recalling everything the project has taught, and then passes every plan through the Veil, the filter that asks: is this grounded in what the well holds, or spun from air? Everything the fleet does is inscribed into Runes, the ledger carved once and never un-carved.',
+    ],
+    names: [
+      { rune: 'ᛗ', name: 'Mimirsbrunn', line: 'Long-term memory — the engram well the fleet drinks from.' },
+      { rune: 'ᚲ', name: 'Kaia', line: 'The oracle — recalls before every dispatch; the eye that remembers.' },
+      { rune: 'ᚹ', name: 'The Veil', line: 'The anti-hallucination gate — nothing passes without evidence.' },
+      { rune: 'ᚱ', name: 'Runes', line: 'The append-only audit ledger — a rune carved stays carved.' },
+    ],
+  },
+  {
+    id: 'messenger',
+    title: 'V · The Messenger on the Tree',
+    paras: [
+      'A squirrel named Ratatoskr runs the length of the tree, carrying word between the eagle above and the serpent below. In Ymir, Ratatoskr is how agents speak to one another: the open A2A 1.0 protocol for horizontal delegation, with Redis as the squirrel’s nest beneath it.',
+      'Every agent that joins the tree carries a rune of introduction — a signed card naming its skills and its address — so discovery is by capability, never by guessing. And Hermóðr, the messenger who crossed to Hel and back, is the bridge by which an orchestrator delegates sideways to its peers while specialists reach their tools straight down.',
+    ],
+    names: [
+      { rune: 'ᚱ', name: 'Ratatoskr', line: 'A2A collaboration — agents delegating across the tree.' },
+      { rune: 'ᚨ', name: 'Runes of introduction', line: 'Signed agent cards — discovery by capability, never by address.' },
+      { rune: 'ᚺ', name: 'Hermóðr', line: 'The MCP/A2A bridge — sideways delegation, vertical tools.' },
+    ],
+  },
+  {
+    id: 'seat',
+    title: 'VI · The High Seat and the Gate',
+    paras: [
+      'From Hlidskjalf, Odin’s high seat, the Allfather sees every realm at once. It is the control plane: one operator’s window onto every agent, task, rune, and run — the fleet graph, the task stream, the well, and the reviews.',
+      'Every crossing into this world passes over Bifrost, the burning bridge; at its foot stands Heimdall, the watchman who vouches for every traveller — the guard that signs each agent’s rune of introduction, so no forged identity crosses. Gjallarhorn, Heimdall’s horn, carries the signal outward through the cloud. And when a change is ready it comes to Glitnir, the shining hall of judgement, where no merge passes without a human word.',
+    ],
+    names: [
+      { rune: 'ᚠ', name: 'Hlidskjalf', line: 'The control plane — the sovereign’s view of the whole fleet.' },
+      { rune: 'ᛒ', name: 'Bifrost', line: 'The ingress gateway — every crossing passes over it.' },
+      { rune: 'ᚺ', name: 'Heimdall', line: 'The security guard — signs every agent’s rune of introduction.' },
+      { rune: 'ᚷ', name: 'Gjallarhorn', line: 'The outbound tunnel — the horn that carries Ymir to the world.' },
+      { rune: 'ᚷ', name: 'Glitnir', line: 'The human review gate — no merge without judgement.' },
+    ],
+  },
+  {
+    id: 'artifacts',
+    title: 'VII · The Artifacts',
+    paras: [
+      'The smiths forged the gods’ weapons, and Ymir ships the same by analogy. Gungnir is Odin’s spear that never misses its mark — the skill-synthesis engine: a new capability is forged, proven in Utgard, and then it strikes true every time. Mjölnir is the hammer that returns to the hand — the issue-to-pull-request pipeline: it strikes an issue and comes back carrying a pull request.',
+      'Skrymir is the giant’s huge and silent hand reaching into the halls — the file browser. And Valhalla is the hall of the slain, where every hero is watched: the process monitor that keeps each daemon’s soul alive and in sight.',
+    ],
+    names: [
+      { rune: 'ᚷ', name: 'Gungnir', line: 'Skill synthesis — forged, validated, then it hits its mark.' },
+      { rune: 'ᛗ', name: 'Mjölnir', line: 'The issue→PR pipeline — strikes, and returns with a pull request.' },
+      { rune: 'ᛋ', name: 'Skrymir', line: 'The file browser — the huge hand reaching into the halls.' },
+      { rune: 'ᚹ', name: 'Valhalla', line: 'The process monitor — every daemon kept alive and watched.' },
+    ],
+  },
+  {
+    id: 'forge-rule',
+    title: 'VIII · The Rule of the Forge',
+    paras: [
+      'The greatest smiths do not hammer every nail themselves; they take up proven anvils. Ymir forges only what makes it Ymir — the seat, the smiths, and the messenger — while everything beneath is a validated open-source engine given a Norse name and a Norn-carved shell.',
+      'The giant is first carved in light metals — the working metals the smiths know best — so the whole of Ymir can be raised and proven end to end. When every gate answers, the forging is not done; it is reforged in heavier steel, one piece at a time. Never redesigned — only re-forged.',
+    ],
+    names: [
+      { rune: 'ᛉ', name: 'The forge rule', line: 'Open-source first — name the proven anvil, smith only what Ymir is.' },
+      { rune: 'ᛞ', name: 'The Reforging', line: 'Light metal first, then Rut steel — same contract, heavier metal.' },
+    ],
+  },
+];