@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/hlidskjalf/src/types.ts

@@ -0,0 +1,251 @@
+// Known realms autocomplete; arbitrary realm ids are allowed so a freshly
+// provisioned tenant (first GitHub login) can exist without a rebuild.
+export type RealmId = 'work' | 'personal' | (string & {});
+
+export type TenantRole = 'owner' | 'admin' | 'member';
+
+export interface TenantGrant {
+  realm: RealmId;
+  tenant: string;
+  role: TenantRole;
+  domain: DomainId;
+  tint: string;
+  glyph: string;
+}
+
+export interface User {
+  login: string;
+  name: string;
+  email: string;
+  avatar: string;
+}
+
+export interface Session {
+  user: User;
+  tenants: TenantGrant[];
+  /** How the session was established. `github` is OAuth through the gate. */
+  method: 'github' | 'gate';
+  issuedAt: string;
+  /** mock JWS — replaced by Heimdall-issued httpOnly JWT once W0028 lands */
+  token: string;
+}
+
+export type DomainId =
+  | 'ymirlabs'
+  | 'brokkforge'
+  | 'runestone'
+  | 'muninn'
+  | 'dvalin'
+  | 'utgard'
+  | 'askr'
+  | 'mannheim';
+
+export type AgentStatus = 'nominal' | 'degraded' | 'down';
+
+export type TaskState =
+  | 'SUBMITTED'
+  | 'WORKING'
+  | 'COMPLETED'
+  | 'FAILED'
+  | 'REJECTED'
+  | 'CANCELED'
+  | 'INPUT_REQUIRED'
+  | 'AUTH_REQUIRED';
+
+export type GateId =
+  | 'fleet'
+  | 'tasks'
+  | 'well'
+  | 'runes'
+  | 'reviews'
+  | 'processes'
+  | 'files'
+  | 'chat'
+  | 'forge'
+  | 'profile'
+  | 'runtime'
+  | 'cron'
+  | 'sessions'
+  | 'worktrees'
+  | 'trace'
+  | 'decisions'
+  | 'stats';
+
+export interface SkillDef {
+  id: string;
+  name: string;
+  /** Norse aett prefix (galdr-, mimir-, yggd-, rat-, heimd-, bifr-, val-, skyr-) */
+  aett: string;
+  description: string;
+  capabilities: string[];
+  validated: boolean;
+  domain: DomainId;
+  createdAt: string;
+}
+
+export interface AgentCard {
+  id: string;
+  name: string;
+  role: string;
+  realm: RealmId;
+  domain: DomainId;
+  status: AgentStatus;
+  capabilities: string[];
+  skills: string[];
+  interface: {
+    protocol: string;
+    endpoint: string;
+    signed: boolean;
+  };
+  model: string;
+  uptime: number;
+  tasksDone: number;
+  /** Live facts from the agent's own pane, when it is genuinely standing. */
+  live?: {
+    kind: string;
+    state: string;
+    pane: string;
+    workspace: string;
+    cwd: string;
+    task: string;
+  };
+  traceability: number;
+}
+
+export interface Task {
+  id: string;
+  title: string;
+  state: TaskState;
+  realm: RealmId;
+  agent: string;
+  agentId: string;
+  order: string;
+  progress: number;
+  startedAt: string;
+  updatedAt: string;
+  artifacts: string[];
+  log: string[];
+}
+
+export interface RuneEntry {
+  id: string;
+  ts: string;
+  agent: string;
+  module: string;
+  event: string;
+  checksum: string;
+  realm: RealmId;
+  order: string;
+  level: 'info' | 'ok' | 'warn' | 'danger';
+}
+
+export interface StreamEvent {
+  id: string;
+  ts: string;
+  kind: 'ratatoskr' | 'rune';
+  from: string;
+  to?: string;
+  taskId?: string;
+  state?: TaskState;
+  module?: string;
+  message: string;
+  checksum?: string;
+  gate?: GateId;
+}
+
+export interface RecallEpisode {
+  id: string;
+  title: string;
+  body: string;
+  score: number;
+  mode: 'hybrid' | 'cosine' | 'spreading' | 'recent';
+  agentScope: string;
+  ts: string;
+  tags: string[];
+}
+
+export interface ProcessInfo {
+  id: string;
+  name: string;
+  daemon: string;
+  manager: 'pm2' | 'docker' | 'systemd';
+  status: AgentStatus;
+  cpu: number;
+  mem: number;
+  restarts: number;
+  uptime: number;
+  realm: RealmId | 'platform';
+}
+
+export interface PullRequest {
+  id: string;
+  number: number;
+  title: string;
+  repo: string;
+  author: string;
+  realm: RealmId;
+  state: 'open' | 'draft' | 'changes' | 'approved' | 'merged';
+  checks: { name: string; state: AgentStatus }[];
+  checklist: { label: string; done: boolean }[];
+  additions: number;
+  deletions: number;
+  issue?: string;
+  updatedAt: string;
+}
+
+export interface FileNode {
+  name: string;
+  type: 'dir' | 'file';
+  path: string;
+  size?: number;
+  updated?: string;
+  children?: FileNode[];
+}
+
+export interface ChatMessage {
+  id: string;
+  from: 'user' | 'kaia';
+  body: string;
+  ts: string;
+  recalling?: boolean;
+  thinking?: boolean;
+  error?: boolean;
+  model?: string;
+  agents?: string[];
+}
+
+export interface RealmDef {
+  id: RealmId;
+  /** display name of the active workspace (kept as `tenant` for compatibility) */
+  tenant: string;
+  name?: string;
+  kind?: 'work' | 'personal';
+  company?: string;
+  domains?: TopicId[];
+  /** brand label — display only, never isolation */
+  domain?: DomainId;
+  tint: string;
+  tint2: string;
+  glyph: string;
+}
+
+/** Knowledge domains — the axes a workspace covers. */
+export type TopicId = 'company' | 'marketing' | 'development' | 'life' | 'me';
+
+export interface WorkspaceDef {
+  id: string;
+  name: string;
+  kind: 'work' | 'personal';
+  company?: string;
+  domains: DomainId[];
+  tint: string;
+  tint2: string;
+  glyph: string;
+}
+
+export interface DomainDef {
+  id: DomainId;
+  name: string;
+  accent: string;
+  glyph: string;
+}

package/apps/hlidskjalf/src/vite-env.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_API_URL?: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}

package/apps/hlidskjalf/static/landing.md

@@ -0,0 +1,6 @@
+Headline: Forge the machine, not the dashboard.
+
+Subhead: Hlidskjalf is the control plane for the whole Ymir system: agents, worktrees, memory, and fleet state.
+
+CTA 1: Launch
+CTA 2: Watch

package/apps/hlidskjalf/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src"]
+}

package/apps/hlidskjalf/vite.config.ts

@@ -0,0 +1,49 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+// Ports are environment-driven so a deployment can avoid collisions with other
+// services on a shared host; the historic defaults are unchanged. The gate API
+// reads the same names (scripts/start.sh passes them through).
+const SPA_PORT = Number(process.env.HLIDSKJALF_PORT ?? 3888);
+const API_PORT = Number(process.env.HLIDSKJALF_API_PORT ?? 3889);
+// Bind host: 127.0.0.1 for bare local dev. Inside a container the published port
+// is forwarded to the container's interface, so a deployment sets this to 0.0.0.0
+// (and pins the host-side publish to loopback where the surface must stay private).
+const SPA_HOST = process.env.HLIDSKJALF_HOST ?? '127.0.0.1';
+const API_ORIGIN = `http://127.0.0.1:${API_PORT}`;
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    host: SPA_HOST,
+    port: SPA_PORT,
+    strictPort: false,
+    // Tunnelled hostnames (Cloudflare -> gate API -> vite) must be allowed or
+    // Vite blocks them with "Blocked request. This host … is not allowed."
+    // Keep hostnames in env (private); default to allowing any host on this
+    // localhost-bound dev server rather than hardcoding an operator domain.
+    allowedHosts: (() => {
+      const list = (process.env.YMIR_ALLOWED_HOSTS ?? '').split(',').map((h) => h.trim()).filter(Boolean);
+      return list.length ? list : true;
+    })(),
+    proxy: {
+      // The local gate API (apps/hlidskjalf/server) reading the Brokk runtime.
+      '/api': API_ORIGIN,
+    },
+    fs: {
+      // Allow importing the canonical design tokens from midgard/.
+      allow: ['..', '../..', '../../..'],
+    },
+  },
+  preview: {
+    host: SPA_HOST,
+    port: SPA_PORT,
+    proxy: {
+      '/api': API_ORIGIN,
+    },
+  },
+  build: {
+    outDir: 'dist',
+    sourcemap: true,
+  },
+});

package/apps/hlidskjalf-mobile/App.tsx

@@ -0,0 +1,93 @@
+import { useEffect, useState } from 'react';
+import { SafeAreaView, ScrollView, StyleSheet, Text, View } from 'react-native';
+import { StatusBar } from 'expo-status-bar';
+
+/**
+ * Hlidskjalf Mobile — the sovereign's view in the hand (W0037).
+ *
+ * Reads the same gate API the web control plane uses (`apps/hlidskjalf/server`).
+ * Set the API base with `EXPO_PUBLIC_API_URL` (default http://127.0.0.1:3889),
+ * or point it at Bifrost in production.
+ */
+const API = process.env.EXPO_PUBLIC_API_URL ?? 'http://127.0.0.1:3889';
+
+type Agent = { id: string; name: string; role: string; status: string };
+type Task = { id: string; title: string; state: string; agent: string };
+
+async function get<T>(path: string): Promise<T | null> {
+  try {
+    const res = await fetch(`${API}${path}`);
+    if (!res.ok) return null;
+    return (await res.json()) as T;
+  } catch {
+    return null;
+  }
+}
+
+export default function App() {
+  const [agents, setAgents] = useState<Agent[]>([]);
+  const [tasks, setTasks] = useState<Task[]>([]);
+  const [online, setOnline] = useState<boolean | null>(null);
+
+  useEffect(() => {
+    let alive = true;
+    const load = async () => {
+      const health = await get<{ ok: boolean }>('/api/health');
+      const a = await get<Agent[]>('/api/agents');
+      const t = await get<Task[]>('/api/tasks');
+      if (!alive) return;
+      setOnline(Boolean(health?.ok));
+      setAgents(a ?? []);
+      setTasks((t ?? []).slice(0, 20));
+    };
+    void load();
+    const timer = setInterval(load, 5000);
+    return () => {
+      alive = false;
+      clearInterval(timer);
+    };
+  }, []);
+
+  return (
+    <SafeAreaView style={styles.safe}>
+      <StatusBar style="light" />
+      <ScrollView contentContainerStyle={styles.wrap}>
+        <Text style={styles.brand}>HLIDSKJALF</Text>
+        <Text style={styles.deck}>
+          {online === null ? 'reading the realms…' : online ? 'live · the gate answers' : 'offline · the gate is quiet'}
+        </Text>
+
+        <Text style={styles.h}>Fleet · {agents.length}</Text>
+        {agents.map((a) => (
+          <View key={a.id} style={styles.row}>
+            <Text style={styles.name}>{a.name}</Text>
+            <Text style={styles.meta}>
+              {a.role} · {a.status}
+            </Text>
+          </View>
+        ))}
+
+        <Text style={styles.h}>Forge orders · {tasks.length}</Text>
+        {tasks.map((t) => (
+          <View key={t.id} style={styles.row}>
+            <Text style={styles.name}>
+              {t.id} · {t.title}
+            </Text>
+            <Text style={styles.meta}>{t.state}</Text>
+          </View>
+        ))}
+      </ScrollView>
+    </SafeAreaView>
+  );
+}
+
+const styles = StyleSheet.create({
+  safe: { flex: 1, backgroundColor: '#080c14' },
+  wrap: { padding: 20, gap: 8 },
+  brand: { color: '#38bdf8', fontSize: 22, fontWeight: '700', letterSpacing: 2 },
+  deck: { color: '#94a3b8', marginBottom: 12 },
+  h: { color: '#e2e8f0', fontSize: 16, fontWeight: '700', marginTop: 18, marginBottom: 6 },
+  row: { borderTopWidth: 1, borderTopColor: '#1e293b', paddingVertical: 8 },
+  name: { color: '#e2e8f0', fontSize: 15 },
+  meta: { color: '#64748b', fontSize: 12, marginTop: 2 },
+});

package/apps/hlidskjalf-mobile/app.json

@@ -0,0 +1,13 @@
+{
+  "expo": {
+    "name": "Hlidskjalf",
+    "slug": "hlidskjalf",
+    "version": "0.1.0",
+    "orientation": "portrait",
+    "scheme": "ymir",
+    "userInterfaceStyle": "dark",
+    "backgroundColor": "#080c14",
+    "ios": { "supportsTablet": true },
+    "android": { "adaptiveIcon": { "backgroundColor": "#080c14" } }
+  }
+}

package/apps/hlidskjalf-mobile/index.ts

@@ -0,0 +1,4 @@
+import { registerRootComponent } from 'expo';
+import App from './App';
+
+registerRootComponent(App);

package/apps/hlidskjalf-mobile/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@zerwiz/hlidskjalf-mobile",
+  "version": "0.1.0",
+  "private": false,
+  "main": "index.ts",
+  "scripts": {
+    "start": "expo start",
+    "android": "expo start --android",
+    "ios": "expo start --ios",
+    "web": "expo start --web"
+  },
+  "dependencies": {
+    "expo": "~52.0.0",
+    "expo-status-bar": "~2.0.0",
+    "react": "18.3.1",
+    "react-native": "0.76.5"
+  },
+  "devDependencies": {
+    "@types/react": "~18.3.12",
+    "typescript": "~5.3.3"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zerwiz/hlidskjalf-mobile.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "App.tsx",
+    "app.json",
+    "index.ts"
+  ]
+}

package/apps/hlidskjalf-mobile/public/icon.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="32" height="32" role="img" aria-label="the road — the seat carried, Hlidskjalf on a phone">
+  <title>the road — the seat carried, Hlidskjalf on a phone</title>
+  <rect width="32" height="32" rx="7" fill="#0e0c09"/>
+  <g transform="translate(4 4) scale(1.0)" fill="none" stroke="#c9973f" stroke-width="1.8" stroke-linecap="square" stroke-linejoin="miter">
+    <path d="M8 20V4H14L18 8L14 12H8 M14 12L18 20"/>
+  </g>
+</svg>

package/apps/hlidskjalf-mobile/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": { "strict": true }
+}

package/apps/odrerir/.astro/content.d.ts

@@ -0,0 +1,159 @@
+declare module 'astro:content' {
+	export interface RenderResult {
+		Content: import('astro/runtime/server/index.js').AstroComponentFactory;
+		headings: import('astro').MarkdownHeading[];
+		remarkPluginFrontmatter: Record<string, any>;
+	}
+	interface Render {
+		'.md': Promise<RenderResult>;
+	}
+
+	export interface RenderedContent {
+		html: string;
+		metadata?: {
+			imagePaths: Array<string>;
+			[key: string]: unknown;
+		};
+	}
+
+	type Flatten<T> = T extends { [K: string]: infer U } ? U : never;
+
+	export type CollectionKey = keyof DataEntryMap;
+	export type CollectionEntry<C extends CollectionKey> = Flatten<DataEntryMap[C]>;
+
+	type AllValuesOf<T> = T extends any ? T[keyof T] : never;
+
+	export type ReferenceDataEntry<
+		C extends CollectionKey,
+		E extends keyof DataEntryMap[C] = string,
+	> = {
+		collection: C;
+		id: E;
+	};
+
+	export type ReferenceLiveEntry<C extends keyof LiveContentConfig['collections']> = {
+		collection: C;
+		id: string;
+	};
+
+	export function getCollection<C extends keyof DataEntryMap, E extends CollectionEntry<C>>(
+		collection: C,
+		filter?: (entry: CollectionEntry<C>) => entry is E,
+	): Promise<E[]>;
+	export function getCollection<C extends keyof DataEntryMap>(
+		collection: C,
+		filter?: (entry: CollectionEntry<C>) => unknown,
+	): Promise<CollectionEntry<C>[]>;
+
+	export function getLiveCollection<C extends keyof LiveContentConfig['collections']>(
+		collection: C,
+		filter?: LiveLoaderCollectionFilterType<C>,
+	): Promise<
+		import('astro').LiveDataCollectionResult<LiveLoaderDataType<C>, LiveLoaderErrorType<C>>
+	>;
+
+	export function getEntry<
+		C extends keyof DataEntryMap,
+		E extends keyof DataEntryMap[C] | (string & {}),
+	>(
+		entry: ReferenceDataEntry<C, E>,
+	): E extends keyof DataEntryMap[C]
+		? Promise<DataEntryMap[C][E]>
+		: Promise<CollectionEntry<C> | undefined>;
+	export function getEntry<
+		C extends keyof DataEntryMap,
+		E extends keyof DataEntryMap[C] | (string & {}),
+	>(
+		collection: C,
+		id: E,
+	): E extends keyof DataEntryMap[C]
+		? string extends keyof DataEntryMap[C]
+			? Promise<DataEntryMap[C][E]> | undefined
+			: Promise<DataEntryMap[C][E]>
+		: Promise<CollectionEntry<C> | undefined>;
+	export function getLiveEntry<C extends keyof LiveContentConfig['collections']>(
+		collection: C,
+		filter: string | LiveLoaderEntryFilterType<C>,
+	): Promise<import('astro').LiveDataEntryResult<LiveLoaderDataType<C>, LiveLoaderErrorType<C>>>;
+
+	/** Resolve an array of entry references from the same collection */
+	export function getEntries<C extends keyof DataEntryMap>(
+		entries: ReferenceDataEntry<C, keyof DataEntryMap[C]>[],
+	): Promise<CollectionEntry<C>[]>;
+
+	export function render<C extends keyof DataEntryMap>(
+		entry: DataEntryMap[C][string],
+	): Promise<RenderResult>;
+
+	export function render<C extends keyof LiveContentConfig['collections']>(
+		entry: import('astro').LiveDataEntry<LiveLoaderDataType<C>>,
+	): Promise<RenderResult>;
+
+	export function reference<
+		C extends
+			| keyof DataEntryMap
+			// Allow generic `string` to avoid excessive type errors in the config
+			// if `dev` is not running to update as you edit.
+			// Invalid collection names will be caught at build time.
+			| (string & {}),
+	>(
+		collection: C,
+	): import('astro/zod').ZodPipe<
+		import('astro/zod').ZodString,
+		import('astro/zod').ZodTransform<
+			C extends keyof DataEntryMap
+				? {
+						collection: C;
+						id: string;
+					}
+				: never,
+			string
+		>
+	>;
+
+	type ReturnTypeOrOriginal<T> = T extends (...args: any[]) => infer R ? R : T;
+	type InferEntrySchema<C extends keyof DataEntryMap> = import('astro/zod').infer<
+		ReturnTypeOrOriginal<Required<ContentConfig['collections'][C]>['schema']>
+	>;
+	type ExtractLoaderConfig<T> = T extends { loader: infer L } ? L : never;
+	type InferLoaderSchema<
+		C extends keyof DataEntryMap,
+		L = ExtractLoaderConfig<ContentConfig['collections'][C]>,
+	> = L extends { schema: import('astro/zod').ZodSchema }
+		? import('astro/zod').infer<L['schema']>
+		: any;
+
+	type DataEntryMap = {
+		
+	};
+
+	type ExtractLoaderTypes<T> = T extends import('astro/loaders').LiveLoader<
+		infer TData,
+		infer TEntryFilter,
+		infer TCollectionFilter,
+		infer TError
+	>
+		? { data: TData; entryFilter: TEntryFilter; collectionFilter: TCollectionFilter; error: TError }
+		: { data: never; entryFilter: never; collectionFilter: never; error: never };
+	type ExtractEntryFilterType<T> = ExtractLoaderTypes<T>['entryFilter'];
+	type ExtractCollectionFilterType<T> = ExtractLoaderTypes<T>['collectionFilter'];
+	type ExtractErrorType<T> = ExtractLoaderTypes<T>['error'];
+	type ExtractDataType<T> = ExtractLoaderTypes<T>['data'];
+
+	type LiveLoaderDataType<C extends keyof LiveContentConfig['collections']> =
+		LiveContentConfig['collections'][C]['schema'] extends undefined
+			? ExtractDataType<LiveContentConfig['collections'][C]['loader']>
+			: import('astro/zod').infer<
+					Exclude<LiveContentConfig['collections'][C]['schema'], undefined>
+				>;
+	type LiveLoaderEntryFilterType<C extends keyof LiveContentConfig['collections']> =
+		ExtractEntryFilterType<LiveContentConfig['collections'][C]['loader']>;
+	type LiveLoaderCollectionFilterType<C extends keyof LiveContentConfig['collections']> =
+		ExtractCollectionFilterType<LiveContentConfig['collections'][C]['loader']>;
+	type LiveLoaderErrorType<C extends keyof LiveContentConfig['collections']> = ExtractErrorType<
+		LiveContentConfig['collections'][C]['loader']
+	>;
+
+	export type ContentConfig = never;
+	export type LiveContentConfig = never;
+}

package/apps/odrerir/.astro/dev.json

@@ -0,0 +1,24 @@
+{
+	"pid": 1465001,
+	"port": 4323,
+	"url": "http://localhost:4323",
+	"urls": {
+		"local": [
+			"http://localhost:4323/"
+		],
+		"network": [
+			"http://192.168.68.110:4323/",
+			"http://100.100.93.103:4323/",
+			"http://172.20.0.1:4323/",
+			"http://172.17.0.1:4323/"
+		],
+		"networkInterfaceNames": [
+			"wlp147s0",
+			"tailscale0",
+			"br-be702e22bb12",
+			"docker0"
+		]
+	},
+	"background": true,
+	"startedAt": "2026-09-16T21:32:45.249Z"
+}