@zerwiz/ymir 0.1.34 → 0.1.35

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

@@ -0,0 +1,147 @@
+import type { GateId } from '../types';
+
+export interface PageMeta {
+  title: string;
+  description: string;
+}
+
+export const SITE = {
+  name: 'Ymir · Hlidskjalf',
+  url: 'https://ymir.local',
+  image: '/og.png',
+  twitter: '@ymir',
+};
+
+/** Smíðja's eye — the trace visualizer. The API on :8437 also serves the built UI. */
+export const VISUALIZER_URL =
+  (import.meta.env.VITE_VISUALIZER_URL as string | undefined) ?? 'http://127.0.0.1:8437';
+
+/**
+ * The Óðrerir Live Hall — the landing's carved stone/bronze board. It is not one
+ * of the three apps (those the gate raises), so its door is a plain page in a new
+ * tab. On this machine the hall answers on :4322; anywhere else, the public hall.
+ */
+export const HALL_URL = (() => {
+  const override = import.meta.env.VITE_HALL_URL as string | undefined;
+  if (override) return override;
+  const host = typeof window === 'undefined' ? '' : window.location.host;
+  const local = host.startsWith('localhost') || host.startsWith('127.0.0.1');
+  return local ? 'http://localhost:4322' : 'https://hall.ymir.zerwiz.org';
+})();
+
+/** Per-gate metadata — every view is a page and declares its own story. */
+export const GATE_META: Record<GateId, PageMeta> = {
+  fleet: {
+    title: 'Fleet',
+    description:
+      'Agent Cards, live status, and A2A hops across the realm — the forge stays hot.',
+  },
+  tasks: {
+    title: 'Tasks',
+    description:
+      'The A2A lifecycle board: SUBMITTED → WORKING → terminal states that never restart.',
+  },
+  well: {
+    title: 'The Well',
+    description:
+      'Mimirsbrunn recall, episodes, and timeline. Drink before you act, water it after.',
+  },
+  runes: {
+    title: 'Runes',
+    description:
+      'The append-only ledger — every significant action carved once, checksum-chained.',
+  },
+  reviews: {
+    title: 'Glitnir · Reviews',
+    description:
+      'Human-in-the-loop pull-request reviews. Mjollnir strikes and returns, but never force-merges.',
+  },
+  processes: {
+    title: 'Valhalla',
+    description:
+      'Process supervision across PM2, Docker, and systemd — dead daemons brought back.',
+  },
+  files: {
+    title: 'Skrymir',
+    description:
+      'The giant’s hand — a realm-scoped file browser served through Bifrost.',
+  },
+  chat: {
+    title: 'OmniChat',
+    description:
+      'Speak with Kaia, the oracle by the well. She recalls before she dispatches.',
+  },
+  forge: {
+    title: 'The Forge',
+    description:
+      'Create and edit Eindri agents and skills — every worker earns a mythological name that matches its craft.',
+  },
+  profile: {
+    title: 'Profile',
+    description:
+      'Personal and company settings — your accent, your tenants’ colours, the house seal, and members.',
+  },
+  runtime: {
+    title: 'Runtime',
+    description:
+      'The Sága session digest — lock, bridge, wakes, fleet, context, and the Nornir start, as injected at session open.',
+  },
+  cron: {
+    title: 'Cron · Nornir',
+    description:
+      'The scheduled jobs of the Nornir, their times, and their health.',
+  },
+  sessions: {
+    title: 'Sessions · Smiðja',
+    description:
+      'Every factory run — phases, status, tokens, and cost — read from the smithy’s own smidja.db.',
+  },
+  worktrees: { title: 'Worktrees', description: 'Yggdrasil isolated worktrees — id, branch, owning agent, head.' },
+  trace: {
+    title: 'Trace',
+    description:
+      'A run’s lanes, phases, agents, and tool calls; the span-nested execution path.',
+  },
+  decisions: {
+    title: 'Decisions',
+    description:
+      'Failures grouped by phase and model, with the fix to apply — what to change to make the system work.',
+  },
+  stats: {
+    title: 'Stats',
+    description:
+      'Runs, tokens, and cost — totals and by chain and model.',
+  },
+};
+
+function setMeta(attr: 'name' | 'property', key: string, content: string): void {
+  let el = document.head.querySelector<HTMLMetaElement>(`meta[${attr}="${key}"]`);
+  if (!el) {
+    el = document.createElement('meta');
+    el.setAttribute(attr, key);
+    document.head.appendChild(el);
+  }
+  el.setAttribute('content', content);
+}
+
+/** Apply title + description + social tags for the active gate. */
+export function applyMeta(gate: GateId, tenant: string): void {
+  const m = GATE_META[gate] ?? GATE_META.fleet;
+  const title = `${m.title} · ${tenant} · ${SITE.name}`;
+  const url = `${SITE.url}/#/${gate}`;
+
+  document.title = title;
+
+  setMeta('name', 'description', m.description);
+  setMeta('property', 'og:site_name', SITE.name);
+  setMeta('property', 'og:type', 'website');
+  setMeta('property', 'og:title', title);
+  setMeta('property', 'og:description', m.description);
+  setMeta('property', 'og:image', SITE.image);
+  setMeta('property', 'og:url', url);
+  setMeta('name', 'twitter:card', 'summary_large_image');
+  setMeta('name', 'twitter:site', SITE.twitter);
+  setMeta('name', 'twitter:title', title);
+  setMeta('name', 'twitter:description', m.description);
+  setMeta('name', 'twitter:image', SITE.image);
+}

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

@@ -0,0 +1,95 @@
+/**
+ * Mythology name engine — every Eindri earns a name whose myth matches its craft.
+ * Gungnir naming law: capability → Norse figure → descriptor.
+ */
+
+export interface MythFigure {
+  name: string;
+  myth: string;
+  descriptor: string;
+  domains: string[];
+  glyph: string;
+}
+
+export const MYTH_FIGURES: MythFigure[] = [
+  { name: 'Brokk', myth: 'the bellows-smith', descriptor: 'forger', domains: ['build', 'forge', 'orchestration', 'dev', 'development', 'pipeline'], glyph: 'ᛒ' },
+  { name: 'Sindri', myth: 'the smith', descriptor: 'smith', domains: ['code', 'frontend', 'backend', 'refactor', 'synthesis', 'typescript', 'react'], glyph: 'ᛊ' },
+  { name: 'Eitri', myth: 'the craftsman', descriptor: 'craftsman', domains: ['design', 'ux', 'ui', 'css', 'component'], glyph: 'ᛖ' },
+  { name: 'Bragi', myth: 'the skald', descriptor: 'skald', domains: ['marketing', 'content', 'seo', 'social', 'copy', 'brand', 'writing'], glyph: 'ᛒ' },
+  { name: 'Huginn', myth: 'the raven (thought)', descriptor: 'sage', domains: ['research', 'analysis', 'search', 'rag', 'knowledge', 'discovery'], glyph: 'ᚺ' },
+  { name: 'Muninn', myth: 'the raven (memory)', descriptor: 'keeper', domains: ['memory', 'recall', 'embeddings', 'vector', 'engram', 'well'], glyph: 'ᛗ' },
+  { name: 'Tyr', myth: 'the one-handed judge', descriptor: 'judge', domains: ['validation', 'compliance', 'test', 'testing', 'audit', 'qa', 'lint'], glyph: 'ᛏ' },
+  { name: 'Heimdall', myth: 'the watchman at Bifrost', descriptor: 'watcher', domains: ['auth', 'security', 'gateway', 'oauth', 'jwt', 'guard', 'identity'], glyph: 'ᚺ' },
+  { name: 'Ratatoskr', myth: 'the squirrel of Yggdrasil', descriptor: 'messenger', domains: ['a2a', 'message', 'bus', 'queue', 'redis', 'dispatch', 'event'], glyph: 'ᚱ' },
+  { name: 'Yggdrasil', myth: 'the world-tree', descriptor: 'weaver', domains: ['git', 'worktree', 'branch', 'merge', 'isolation'], glyph: 'ᛃ' },
+  { name: 'Mimir', myth: 'the keeper of the well', descriptor: 'oracle', domains: ['knowledge', 'wisdom', 'documentation', 'docs'], glyph: 'ᛗ' },
+  { name: 'Skrymir', myth: 'the giant of the halls', descriptor: 'giant', domains: ['files', 'storage', 's3', 'minio', 'browser', 'assets'], glyph: 'ᛊ' },
+  { name: 'Valhalla', myth: 'the hall of the slain', descriptor: 'warden', domains: ['process', 'monitor', 'health', 'pm2', 'docker', 'supervision', 'uptime'], glyph: 'ᚢ' },
+  { name: 'Hermod', myth: 'the messenger who crossed Hel', descriptor: 'bridge', domains: ['mcp', 'integration', 'bridge', 'cross-realm', 'tool'], glyph: 'ᚺ' },
+  { name: 'Utgard', myth: 'the walled realm', descriptor: 'wall', domains: ['sandbox', 'container', 'docker', 'security', 'cgroups', 'seccomp'], glyph: 'ᚢ' },
+  { name: 'Gungnir', myth: "Odin's spear that never misses", descriptor: 'spear', domains: ['skill', 'synthesis', 'tooling', 'cli'], glyph: 'ᚷ' },
+  { name: 'Mjollnir', myth: 'the hammer that returns', descriptor: 'hammer', domains: ['issue', 'pr', 'bug', 'pipeline', 'github', 'fix'], glyph: 'ᛗ' },
+  { name: 'Hlidskjalf', myth: "Odin's high seat", descriptor: 'seat', domains: ['dashboard', 'ui', 'observability', 'portal', 'frontend'], glyph: 'ᚺ' },
+  { name: 'Gjallarhorn', myth: "Heimdall's horn", descriptor: 'horn', domains: ['tunnel', 'cloudflare', 'network', 'ingress', 'proxy'], glyph: 'ᚷ' },
+  { name: 'Norns', myth: 'the weavers of fate', descriptor: 'weaver', domains: ['schedule', 'cron', 'time', 'planning', 'automation'], glyph: 'ᚾ' },
+  { name: 'Idunn', myth: 'keeper of the apples', descriptor: 'healer', domains: ['maintenance', 'recovery', 'backup', 'restore', 'healing'], glyph: 'ᛁ' },
+  { name: 'Andvari', myth: 'the dwarf of the hoard', descriptor: 'treasurer', domains: ['secrets', 'keys', 'vault', 'env', 'credentials', 'stripe'], glyph: 'ᚨ' },
+  { name: 'Forseti', myth: 'the settler of disputes', descriptor: 'arbiter', domains: ['review', 'approval', 'mediation', 'pr', 'policy'], glyph: 'ᚠ' },
+  { name: 'Loki', myth: 'the shape-changer', descriptor: 'trickster', domains: ['chaos', 'fuzz', 'edge-case', 'red-team', 'stress'], glyph: 'ᛚ' },
+  { name: 'Surtr', myth: 'the fire giant', descriptor: 'ember', domains: ['security', 'firewall', 'red-team', 'pentest', 'threat'], glyph: 'ᛊ' },
+  { name: 'Skadi', myth: 'the winter huntress', descriptor: 'hunter', domains: ['monitor', 'alert', 'telemetry', 'metrics', 'trace', 'observe'], glyph: 'ᛊ' },
+  { name: 'Njord', myth: 'the lord of the sea', descriptor: 'trader', domains: ['finance', 'billing', 'revenue', 'business', 'growth'], glyph: 'ᚾ' },
+  { name: 'Freyr', myth: 'the giver of peace and plenty', descriptor: 'grower', domains: ['growth', 'life', 'wellbeing', 'habit', 'personal'], glyph: 'ᚠ' },
+];
+
+const AETTS = ['galdr', 'mimir', 'yggd', 'rat', 'heimd', 'bifr', 'val', 'skyr', 'gung', 'mjoll', 'hlid'] as const;
+
+export interface NameSuggestion {
+  figure: MythFigure;
+  score: number;
+}
+
+/** Rank myth figures against a free-text capability/role description. */
+export function suggestFigures(text: string, limit = 3): NameSuggestion[] {
+  const tokens = text
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((t) => t.length > 2);
+
+  const scored = MYTH_FIGURES.map((figure) => {
+    let score = 0;
+    for (const d of figure.domains) {
+      if (tokens.some((t) => t.includes(d) || d.includes(t))) score += 2;
+      if (text.toLowerCase().includes(d)) score += 1;
+    }
+    return { figure, score };
+  })
+    .filter((s) => s.score > 0)
+    .sort((a, b) => b.score - a.score);
+
+  if (scored.length >= limit) return scored.slice(0, limit);
+
+  // fill with a stable selection (by name) if not enough domain hits
+  const used = new Set(scored.map((s) => s.figure.name));
+  const filler = MYTH_FIGURES.filter((f) => !used.has(f.name))
+    .slice(0, limit - scored.length)
+    .map((figure) => ({ figure, score: 0 }));
+  return [...scored, ...filler];
+}
+
+export function aettFor(text: string): string {
+  const t = text.toLowerCase();
+  if (/memory|recall|well|engram|vector/.test(t)) return 'mimir';
+  if (/git|worktree|branch|tree/.test(t)) return 'yggd';
+  if (/message|a2a|bus|queue/.test(t)) return 'rat';
+  if (/auth|guard|security|identity/.test(t)) return 'heimd';
+  if (/gateway|proxy|ingress|bridge/.test(t)) return 'bifr';
+  if (/process|health|monitor|supervis/.test(t)) return 'val';
+  if (/file|storage|asset/.test(t)) return 'skyr';
+  if (/skill|synthesis|tool/.test(t)) return 'gung';
+  if (/issue|pr|bug|pipeline/.test(t)) return 'mjoll';
+  if (/dashboard|ui|portal|observ/.test(t)) return 'hlid';
+  return 'galdr';
+}
+
+export const AETTS_LIST = AETTS;

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

@@ -0,0 +1,167 @@
+import type { GateId, DomainDef, RealmDef, TaskState, AgentStatus } from '../types';
+
+// Single tenant: the switchable unit is a WORKSPACE (personal | work), not a
+// tenant. Domains are knowledge areas inside a workspace. Houses are brands.
+export const WORKSPACES: RealmDef[] = [
+  {
+    id: 'work',
+    tenant: 'Work',
+    name: 'Work',
+    kind: 'work',
+    company: 'wayof',
+    domains: ['company', 'marketing', 'development', 'life'],
+    tint: '#c9973f',
+    tint2: '#7d5f2a',
+    glyph: 'ᛉ',
+  },
+  {
+    id: 'personal',
+    tenant: 'Personal',
+    name: 'Personal',
+    kind: 'personal',
+    domains: ['me', 'life', 'development'],
+    tint: '#96a0a8',
+    tint2: '#5f686e',
+    glyph: 'ᛗ',
+  },
+];
+
+/** Back-compat alias — the active `realm` id is now a workspace id. */
+export const REALMS = WORKSPACES;
+
+export const DOMAIN_LABEL: Record<string, string> = {
+  company: 'Company',
+  marketing: 'Marketing',
+  development: 'Development',
+  life: 'Life',
+  me: 'Me',
+};
+
+export const DOMAINS: Record<string, DomainDef> = {
+  ymirlabs: { id: 'ymirlabs', name: 'Ymir Labs', accent: '#c9973f', glyph: 'ᛦ' },
+  brokkforge: { id: 'brokkforge', name: 'Brokk Forge', accent: '#f59e0b', glyph: 'ᛒ' },
+  runestone: { id: 'runestone', name: 'Runestone Labs', accent: '#f43f5e', glyph: 'ᚱ' },
+  muninn: { id: 'muninn', name: 'Muninn Labs', accent: '#8b5cf6', glyph: 'ᛗ' },
+  dvalin: { id: 'dvalin', name: 'Dvalin', accent: '#94a3b8', glyph: 'ᛞ' },
+  utgard: { id: 'utgard', name: 'Utgard Studios', accent: '#d946ef', glyph: 'ᚢ' },
+  askr: { id: 'askr', name: 'Askr', accent: '#34d399', glyph: 'ᚨ' },
+  mannheim: { id: 'mannheim', name: 'Mannheim', accent: '#64748b', glyph: 'ᛘ' },
+};
+
+export const realmById = (id: string): RealmDef =>
+  REALMS.find((r) => r.id === id) ?? REALMS[0];
+
+export interface AccentPreset {
+  id: string;
+  name: string;
+  tint: string | null;
+  tint2: string | null;
+}
+
+/**
+ * Personal accent presets. `realm` follows the tenant tint (the structural
+ * default); every other preset lets the operator paint their own seat.
+ */
+export const ACCENTS: AccentPreset[] = [
+  { id: 'realm', name: 'Realm default', tint: null, tint2: null },
+  { id: 'azure', name: 'Azure', tint: '#c9973f', tint2: '#0ea5e9' },
+  { id: 'indigo', name: 'Indigo', tint: '#818cf8', tint2: '#6366f1' },
+  { id: 'violet', name: 'Violet', tint: '#a855f7', tint2: '#7c3aed' },
+  { id: 'magenta', name: 'Magenta', tint: '#d946ef', tint2: '#c026d3' },
+  { id: 'crimson', name: 'Crimson', tint: '#f43f5e', tint2: '#e11d48' },
+  { id: 'ember', name: 'Ember', tint: '#f87171', tint2: '#ef4444' },
+  { id: 'orange', name: 'Orange', tint: '#fb923c', tint2: '#f97316' },
+  { id: 'amber', name: 'Amber', tint: '#f59e0b', tint2: '#d97706' },
+  { id: 'lime', name: 'Lime', tint: '#a3e635', tint2: '#84cc16' },
+  { id: 'emerald', name: 'Emerald', tint: '#34d399', tint2: '#10b981' },
+  { id: 'teal', name: 'Teal', tint: '#2dd4bf', tint2: '#14b8a6' },
+  { id: 'cyan', name: 'Cyan', tint: '#22d3ee', tint2: '#06b6d4' },
+  { id: 'steel', name: 'Steel', tint: '#94a3b8', tint2: '#64748b' },
+];
+
+/**
+ * Resolve a realm definition for any tenant — known realms keep their
+ * canonical tint; a freshly provisioned tenant is derived from its house seal.
+ */
+export function realmDef(
+  id: string,
+  grant?: { tenant?: string; domain?: string; tint?: string; glyph?: string },
+): RealmDef {
+  const known = WORKSPACES.find((r) => r.id === id);
+  if (known) return known;
+  const house = DOMAINS[grant?.domain ?? 'ymirlabs'];
+  return {
+    id,
+    tenant: grant?.tenant ?? id,
+    name: grant?.tenant ?? id,
+    domain: house.id,
+    tint: grant?.tint ?? house.accent,
+    tint2: grant?.tint ?? house.accent,
+    glyph: grant?.glyph ?? house.glyph,
+  };
+}
+
+export interface GateDef {
+  id: GateId;
+  label: string;
+  glyph: string;
+  hint: string;
+}
+
+export const GATES: GateDef[] = [
+  { id: 'fleet', label: 'Fleet', glyph: 'ᚠ', hint: 'Agent Cards · status · A2A graph' },
+  { id: 'tasks', label: 'Tasks', glyph: 'ᛏ', hint: 'A2A lifecycle board' },
+  { id: 'well', label: 'Well', glyph: 'ᛜ', hint: 'Mimirsbrunn recall · timeline' },
+  { id: 'runes', label: 'Runes', glyph: 'ᚱ', hint: 'Append-only ledger' },
+  { id: 'reviews', label: 'Reviews', glyph: 'ᛉ', hint: 'Glitnir PR cards' },
+  { id: 'processes', label: 'Processes', glyph: 'ᛞ', hint: 'Valhalla supervision' },
+  { id: 'files', label: 'Files', glyph: 'ᛊ', hint: 'Skrymir file browser' },
+  { id: 'chat', label: 'OmniChat', glyph: 'ᚴ', hint: 'Kaia · orchestration' },
+  { id: 'forge', label: 'Forge', glyph: 'ᚨ', hint: 'Create · edit · Eindri & skills' },
+  { id: 'runtime', label: 'Runtime', glyph: 'ᛖ', hint: 'Sága digest · session seating' },
+  { id: 'cron', label: 'Cron', glyph: 'ᛃ', hint: 'Nornir schedule · job health' },
+  { id: 'sessions', label: 'Sessions', glyph: 'ᛋ', hint: 'Smiðja runs · phase progress' },
+  { id: 'worktrees', label: 'Worktrees', glyph: 'ᛥ', hint: 'Yggdrasil worktrees · branch · owning agent' },
+  { id: 'trace', label: 'Trace', glyph: 'ᛚ', hint: 'Lanes · phases · tool calls' },
+  { id: 'decisions', label: 'Decisions', glyph: 'ᚦ', hint: 'Failures grouped · the fix' },
+  { id: 'stats', label: 'Stats', glyph: 'ᛗ', hint: 'Tokens · cost · by chain & model' },
+  { id: 'profile', label: 'Profile', glyph: 'ᛝ', hint: 'Personal & company settings' },
+];
+
+export const TASK_STATES: TaskState[] = [
+  'SUBMITTED',
+  'WORKING',
+  'INPUT_REQUIRED',
+  'AUTH_REQUIRED',
+  'COMPLETED',
+  'FAILED',
+  'REJECTED',
+  'CANCELED',
+];
+
+export const TERMINAL_STATES: TaskState[] = [
+  'COMPLETED',
+  'FAILED',
+  'REJECTED',
+  'CANCELED',
+];
+
+export const TASK_STATE_META: Record<
+  TaskState,
+  { glyph: string; label: string; tone: AgentStatus | 'info' }
+> = {
+  SUBMITTED: { glyph: 'ᛋ', label: 'Submitted', tone: 'info' },
+  WORKING: { glyph: 'ᚹ', label: 'Working', tone: 'info' },
+  INPUT_REQUIRED: { glyph: 'ᛁ', label: 'Input required', tone: 'degraded' },
+  AUTH_REQUIRED: { glyph: 'ᚨ', label: 'Auth required', tone: 'degraded' },
+  COMPLETED: { glyph: 'ᚲ', label: 'Completed', tone: 'nominal' },
+  FAILED: { glyph: 'ᚠ', label: 'Failed', tone: 'down' },
+  REJECTED: { glyph: 'ᚱ', label: 'Rejected', tone: 'down' },
+  CANCELED: { glyph: 'ᛪ', label: 'Canceled', tone: 'degraded' },
+};
+
+export const STATUS_META: Record<AgentStatus, { glyph: string; label: string; tone: string }> = {
+  nominal: { glyph: 'ᛟ', label: 'NOMINAL', tone: 'ok' },
+  degraded: { glyph: 'ᛇ', label: 'DEGRADED', tone: 'warn' },
+  down: { glyph: 'ᛪ', label: 'DOWN', tone: 'danger' },
+};

package/apps/hlidskjalf/src/gates/Cron.tsx

@@ -0,0 +1,77 @@
+import { useYmir } from '../state/store';
+import { StatusChip } from '../components/Status';
+import { MetricTile } from '../components/MetricTile';
+
+/**
+ * Cron — the Nornir schedule (plan 24). Reads `/api/cron`; says `offline`
+ * when the gate API has nothing to report. Read-only.
+ */
+export function Cron() {
+  const cron = useYmir((s) => s.cron);
+  const jobs = cron?.jobs ?? [];
+  const running = cron?.running ?? false;
+
+  return (
+    <>
+      <div className="stage-head">
+        <div>
+          <h1 className="stage-title">Nornir · Cron</h1>
+          <p className="stage-deck">
+            The fates who govern time · scheduled jobs, started at session open
+          </p>
+        </div>
+        <div className="row">
+          <StatusChip status={running ? 'nominal' : 'down'} />
+        </div>
+      </div>
+
+      <div className="metric-grid" style={{ marginBottom: 'var(--ymir-space-4)' }}>
+        <MetricTile label="Scheduler" value={running ? 'RUNNING' : 'STOPPED'} tone={running ? 'var(--ymir-ok)' : 'var(--ymir-danger)'} delta={cron?.pid ? `pid ${cron.pid}` : '—'} />
+        <MetricTile label="Jobs" value={jobs.length} delta="declared in config/cron.yaml" />
+        <MetricTile label="Daily briefing" value="07:00" delta="workspace/memory/daily" />
+        <MetricTile label="Observer" value="06:00" delta="Huginn · read-only" />
+      </div>
+
+      <section className="panel">
+        <div className="panel-head">
+          <div className="panel-title">
+            <span className="glyph" aria-hidden="true">ᛃ</span>
+            Schedule
+          </div>
+          <span className="mono dim" style={{ fontSize: 10 }}>
+            {cron ? 'live · nornir-cron-start.sh' : 'offline'}
+          </span>
+        </div>
+        <div className="panel-body flush">
+          <table className="data-table">
+            <thead>
+              <tr>
+                <th>Time</th>
+                <th>Job</th>
+                <th>Status</th>
+              </tr>
+            </thead>
+            <tbody>
+              {jobs.map((j) => (
+                <tr key={j.at + j.command}>
+                  <td className="mono num">{j.at}</td>
+                  <td className="mono">{j.command}</td>
+                  <td>
+                    <StatusChip status={j.status === 'scheduled' ? 'nominal' : 'down'} />
+                  </td>
+                </tr>
+              ))}
+              {jobs.length === 0 ? (
+                <tr>
+                  <td colSpan={3} className="muted" style={{ padding: 12 }}>
+                    No jobs. Sign in live (gate API) to read config/cron.yaml.
+                  </td>
+                </tr>
+              ) : null}
+            </tbody>
+          </table>
+        </div>
+      </section>
+    </>
+  );
+}

package/apps/hlidskjalf/src/gates/Decisions.tsx

@@ -0,0 +1,67 @@
+import { useYmir } from '../state/store';
+import { MetricTile } from '../components/MetricTile';
+
+/** Decisions — failures grouped by phase and model, with the fix to apply (W0083). */
+export function Decisions() {
+  const decisions = useYmir((s) => s.smidjaDecisions);
+  const db = useYmir((s) => s.smidjaDb);
+  const total = decisions.reduce((a, d) => a + d.count, 0);
+
+  return (
+    <>
+      <div className="stage-head">
+        <div>
+          <h1 className="stage-title">Decisions</h1>
+          <p className="stage-deck">The self-improving surface · failures grouped · the fix to apply</p>
+        </div>
+      </div>
+
+      <div className="metric-grid" style={{ marginBottom: 'var(--ymir-space-4)' }}>
+        <MetricTile label="Failed phases" value={total} tone={total ? 'var(--ymir-danger)' : 'var(--ymir-ok)'} delta="across runs" />
+        <MetricTile label="Buckets" value={decisions.length} delta="diagnosis × model" />
+        <MetricTile label="Source" value="smidja.db" delta={db} />
+        <MetricTile label="Bias" value="fix first" tone="var(--ymir-cyan-1)" delta="action over analysis" />
+      </div>
+
+      <section className="panel">
+        <div className="panel-head">
+          <div className="panel-title">
+            <span className="glyph" aria-hidden="true">ᚦ</span>
+            Failures
+          </div>
+        </div>
+        <div className="panel-body flush">
+          {decisions.length === 0 ? (
+            <div className="empty" style={{ padding: 24 }}>
+              <span className="glyph" aria-hidden="true">ᚦ</span>
+              <p>No failed phases recorded. The forge holds.</p>
+            </div>
+          ) : (
+            <table className="data-table">
+              <thead>
+                <tr>
+                  <th>Phase</th>
+                  <th>Model</th>
+                  <th>Count</th>
+                  <th>Error</th>
+                </tr>
+              </thead>
+              <tbody>
+                {decisions.map((d, i) => (
+                  <tr key={`${d.phase}-${d.model}-${i}`}>
+                    <td className="mono">{d.phase}</td>
+                    <td className="muted">{d.model ?? '—'}</td>
+                    <td className="num">{d.count}</td>
+                    <td className="mono dim" style={{ maxWidth: 360, overflow: 'hidden', textOverflow: 'ellipsis' }}>
+                      {d.error ?? ''}
+                    </td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          )}
+        </div>
+      </section>
+    </>
+  );
+}