@zerwiz/ymir 0.1.4 → 0.1.7

package/.agents/migrations/0003-private-data-separation.sh

@@ -0,0 +1,121 @@
+#!/usr/bin/env bash
+# 0003-private-data-separation — move all private data to YMIR_HOME
+# Idempotent: safe to run repeatedly. Copies (never moves); originals
+# remain until manually removed.
+set -u
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+YMIR_HOME="${YMIR_HOME:-$HOME/Documents/Ymir}"
+
+echo "0003-private-data-separation"
+echo "  source:  $ROOT (repo)"
+echo "  target:  $YMIR_HOME"
+
+# 1. Create target layout
+mkdir -p "$YMIR_HOME"/{config,secrets,identity,workspaces/{work,personal},memory/{daily,well},smidja,state,data}
+
+# 2. Migrate hodd/ (Hoard) → YMIR_HOME/
+# Non-destructive: never overwrites an existing file, and MERGES a directory
+# into its target. The target dirs are pre-created above, so a naive
+# `[ -e "$2" ] && return` skipped every directory source — `data/` among them,
+# which silently dropped the realm declaration and made 0004 fall back to a
+# neutral realm.
+copy() {  # <src> <dest>
+  [ -e "$1" ] || return 0
+  if [ -d "$1" ]; then
+    mkdir -p "$2" || return 0
+    cp -rn "$1"/. "$2"/ 2>/dev/null && printf '  copied %s\n' "${1#$ROOT/}"
+    return 0
+  fi
+  if [ -e "$2" ]; then return 0; fi
+  mkdir -p "$(dirname "$2")" || return 0
+  cp -rn "$1" "$2" 2>/dev/null && printf '  copied %s\n' "${1#$ROOT/}"
+}
+
+copy "$ROOT/hodd/secrets"        "$YMIR_HOME/secrets"
+copy "$ROOT/hodd/identity"       "$YMIR_HOME/identity"
+copy "$ROOT/hodd/docs"           "$YMIR_HOME/memory"
+copy "$ROOT/hodd/masterplan.md"  "$YMIR_HOME/memory/masterplan.md"
+copy "$ROOT/hodd/append-only-log.md" "$YMIR_HOME/memory/append-only-log.md"
+
+# 3. Migrate svartalfaheim/ (tenant data) → YMIR_HOME/workspaces/ + identity/companies/
+copy "$ROOT/svartalfaheim/work/workspace" "$YMIR_HOME/workspaces/work"
+copy "$ROOT/svartalfaheim/wayof/companies" "$YMIR_HOME/identity/companies"
+
+# 4. Migrate workspace/ (operator's world-tree) → YMIR_HOME/workspaces/
+for d in work personal memory companies; do
+  copy "$ROOT/workspace/$d" "$YMIR_HOME/workspaces/$d"
+done
+
+# 5. Migrate config/agents.yaml → YMIR_HOME/config/
+copy "$ROOT/config/agents.yaml" "$YMIR_HOME/config/agents.yaml"
+
+# 6. Migrate state/ → YMIR_HOME/state/
+copy "$ROOT/state" "$YMIR_HOME/state"
+
+# 7. Migrate data/ → YMIR_HOME/data/
+copy "$ROOT/data" "$YMIR_HOME/data"
+
+# 8. Migrate .agents/memory/kaia.engram* → YMIR_HOME/memory/
+copy "$ROOT/.agents/memory/kaia.engram"       "$YMIR_HOME/memory/kaia.engram"
+copy "$ROOT/.agents/memory/kaia.engram-wal"   "$YMIR_HOME/memory/kaia.engram-wal"
+copy "$ROOT/.agents/memory/kaia.engram-shm"   "$YMIR_HOME/memory/kaia.engram-shm"
+
+# 9. Migrate smidja/smidja_data/smidja.db* → YMIR_HOME/smidja/
+copy "$ROOT/smidja/smidja_data/smidja.db"          "$YMIR_HOME/smidja/smidja.db"
+copy "$ROOT/smidja/smidja_data/smidja.db-wal"      "$YMIR_HOME/smidja/smidja.db-wal"
+copy "$ROOT/smidja/smidja_data/smidja.db-shm"      "$YMIR_HOME/smidja/smidja.db-shm"
+
+# 10. Create .gitignore for private repo
+cat >"$YMIR_HOME/.gitignore" <<'GITIGNORE'
+# Runtime — rebuilt per machine
+smidja/
+state/
+*.wal
+*.shm
+*.pid
+*.lock
+
+# Local overlays
+config/agents.*.yaml
+GITIGNORE
+
+# 11. Initialize git repo if not already
+if [ ! -d "$YMIR_HOME/.git" ]; then
+  git -C "$YMIR_HOME" init >/dev/null 2>&1 && echo "  initialized private git repo at $YMIR_HOME"
+fi
+
+# 12. Offer to add GitHub remote for multi-machine sync
+if [ -d "$YMIR_HOME/.git" ] && [ -t 0 ]; then
+  read -p "  Add private GitHub remote for multi-machine sync? (git@github.com:user/repo.git) [y/N]: " yn
+  case "$yn" in [Yy]*)
+    read -p "    GitHub repo URL: " gh_url
+    [ -n "$gh_url" ] && git -C "$YMIR_HOME" remote add origin "$gh_url" && \
+      git -C "$YMIR_HOME" add -A && \
+      git -C "$YMIR_HOME" commit -m "chore: initial Ymir private data" >/dev/null 2>&1 && \
+      git -C "$YMIR_HOME" push -u origin main && \
+      echo "    pushed to $gh_url" || true
+    ;;
+  esac
+fi
+
+# 13. Write layout record
+cat >"$YMIR_HOME/.ymir-layout.yaml" <<YAML
+version: 1
+migrated_from: "$ROOT"
+migrated_at: "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+layout:
+  config: "$YMIR_HOME/config"
+  secrets: "$YMIR_HOME/secrets"
+  identity: "$YMIR_HOME/identity"
+  workspaces: "$YMIR_HOME/workspaces"
+  memory: "$YMIR_HOME/memory"
+  smidja: "$YMIR_HOME/smidja"
+  state: "$YMIR_HOME/state"
+  data: "$YMIR_HOME/data"
+git_repo: "$YMIR_HOME"
+github_repo: "${gh_url:-}"
+secrets_encrypted: false
+YAML
+
+echo "0003-private-data-separation: done — private data now at $YMIR_HOME"

package/.agents/migrations/0004-hoard-and-realms.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+# 0004-hoard-and-realms — one private root with two trees.
+#
+# Before: the hoard's parts sat at the ROOT of $YMIR_HOME (secrets · identity ·
+# docs · data · memory · tenants · AGENTS.md), the workspaces lived in a second
+# root ($YMIR_HOME/workspaces/) *and* inside the checkout (repo `workspace/`,
+# repo `svartalfaheim/<realm>/`), and the Runes ledger had been copied twice.
+#
+# After — the layout `docs/workspaces.md` proposes:
+#
+#   $YMIR_HOME/
+#   ├── hodd/            the operator's own: secrets · identity · docs · data · memory · tenants · AGENTS.md
+#   └── svartalfaheim/   the realms: <realm>/{workspace/{personal,company},memory,runs}
+#
+# Idempotent: every step checks before it moves, and a move that would overwrite
+# is refused rather than merged blindly.
+set -u
+
+H="${YMIR_HOME:-$HOME/Documents/Ymir}"
+R="${YMIR_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)}"
+HOARD="$H/hodd"
+moved=0; placed=0; skipped=0
+
+row() { printf '  "%s","%s","%s"\n' "$1" "$2" "$3"; }
+
+# ── 1. the hoard's parts move under hodd/ ────────────────────────────────────
+mkdir -p "$HOARD" 2>/dev/null || true
+for d in secrets identity docs data memory tenants; do
+  if [ -e "$H/$d" ] && [ ! -e "$HOARD/$d" ]; then
+    mv "$H/$d" "$HOARD/$d" && moved=$((moved+1))
+  elif [ -e "$H/$d" ]; then
+    skipped=$((skipped+1))
+  fi
+done
+# the operator's private contract follows the hoard
+if [ -f "$H/AGENTS.md" ] && [ ! -e "$HOARD/AGENTS.md" ]; then
+  mv "$H/AGENTS.md" "$HOARD/AGENTS.md" && moved=$((moved+1))
+fi
+
+# ── 2. the realm tree ────────────────────────────────────────────────────────
+REALM=""
+[ -r "$HOARD/data/realm.md" ] && REALM="$(head -n1 "$HOARD/data/realm.md" 2>/dev/null | tr -d '[:space:]')"
+if [ -z "$REALM" ] && [ -d "$H/svartalfaheim" ]; then
+  REALM="$(find "$H/svartalfaheim" -mindepth 1 -maxdepth 1 -type d ! -name examples ! -name '.*' -printf '%f\n' 2>/dev/null | sort | head -n1)"
+fi
+REALM="${REALM:-work}"
+REALM_DIR="$H/svartalfaheim/$REALM"
+
+mkdir -p "$REALM_DIR/workspace/personal"/{me,life,development,inbox} \
+         "$REALM_DIR/workspace/company"/{company,marketing,development,life,projects,companies} \
+         "$REALM_DIR/memory/daily" "$REALM_DIR/runs" 2>/dev/null || true
+
+# fold the old workspaces root in, by name, never overwriting
+fold() {  # <src-dir> <dst-dir>
+  local src=$1 dst=$2 n=0 e b
+  [ -d "$src" ] || return 0
+  mkdir -p "$dst" 2>/dev/null || true
+  for e in "$src"/* "$src"/.[!.]*; do
+    [ -e "$e" ] || continue
+    b="$(basename "$e")"
+    [ -e "$dst/$b" ] && continue
+    mv "$e" "$dst/$b" 2>/dev/null && n=$((n+1))
+  done
+  placed=$((placed+n))
+}
+fold "$H/workspaces/personal"  "$REALM_DIR/workspace/personal"
+fold "$H/workspaces/work"      "$REALM_DIR/workspace/company"
+fold "$H/workspaces/companies" "$REALM_DIR/workspace/company/companies"
+fold "$H/workspaces/memory"    "$REALM_DIR/memory"
+# …and the copy that sat inside the checkout
+fold "$R/workspace/personal"   "$REALM_DIR/workspace/personal"
+fold "$R/workspace/work"       "$REALM_DIR/workspace/company"
+fold "$R/workspace/companies"  "$REALM_DIR/workspace/company/companies"
+fold "$R/workspace/memory"     "$REALM_DIR/memory"
+fold "$R/svartalfaheim/$REALM/workspace/memory/daily"     "$REALM_DIR/memory/daily"
+fold "$R/svartalfaheim/$REALM/workspace/development"      "$REALM_DIR/workspace/company/development"
+
+# ── 3. the Runes ledger lands in the hoard's memory, and no entry is lost ────
+LEDGER="$HOARD/memory/runes_audit.md"
+mkdir -p "$HOARD/memory" 2>/dev/null || true
+for stray in "$H/workspaces/memory/runes_audit.md" "$REALM_DIR/memory/runes_audit.md"; do
+  [ -f "$stray" ] || continue
+  [ "$stray" = "$LEDGER" ] && continue
+  if [ ! -f "$LEDGER" ]; then
+    mv "$stray" "$LEDGER" && moved=$((moved+1))
+  elif cmp -s "$stray" "$LEDGER"; then
+    rm -f "$stray" && moved=$((moved+1))          # identical: drop the copy
+  else
+    # Different: append only what the target lacks, then keep the target.
+    while IFS= read -r line; do
+      [ -n "$line" ] || continue
+      grep -qxF -- "$line" "$LEDGER" || printf '%s\n' "$line" >>"$LEDGER"
+    done <"$stray"
+    rm -f "$stray" && moved=$((moved+1))
+  fi
+done
+
+# ── 4. report ────────────────────────────────────────────────────────────────
+printf 'migration[1]{id,state}:\n  "0004-hoard-and-realms","applied"\n'
+printf 'migration_result[4]{what,detail,count}:\n'
+row "hoard" "$HOARD" "$moved"
+row "realm" "$REALM_DIR" "$placed"
+row "ledger" "$LEDGER" "$([ -f "$LEDGER" ] && printf 'present' || printf 'absent')"
+row "left-alone" "$H" "$skipped"

package/.agents/migrations/0005-roots-out-of-tree.sh

@@ -0,0 +1,158 @@
+#!/usr/bin/env bash
+# 0005-roots-out-of-tree — the operator's things leave the code tree.
+#
+# The law this migration serves: the package is the CODE THAT RUNS THE PROGRAMS;
+# everything the operator owns lives in the home they chose. A packaged install
+# (npm) treats its tree as read-only, and the next upgrade replaces it — so
+# anything of theirs kept in the tree is kept at its peril. Every *writer* was
+# converted to resolve the home through bin/hoard-lib.sh; this carries what is
+# already sitting in the tree to where those writers now look.
+#
+#   what moves            from the tree            to the home
+#   ------------------    ---------------------    ----------------------------
+#   this machine's        data/                    <hoard>/data
+#     records
+#   runtime state         state/                   <home>/state
+#     (pids · logs · locks · the applied-marker)
+#   the operator's        the local env file       <home>/.env.local
+#     credentials         (if one is in the tree)
+#   the operator's        .agents/config/*         <home>/config
+#     settings            that git does not track
+#
+# Idempotent: every entry is checked before it moves, a second run finds nothing
+# to do, and a move that would land on an existing file is REFUSED and reported
+# rather than merged blindly — the home always wins, nothing is ever overwritten.
+#
+# What is deliberately NOT moved: `*.example` templates and `.gitkeep` (they are
+# code), and any settings file git tracks (that is the distro's shipped default,
+# not the operator's own). Moving a tracked file out of the tree would be a code
+# change wearing a migration's clothes.
+#
+# NOTE: run this while the runtime is STOPPED if you want no stale pids; running
+# services keep their open file handles across the move (an `mv` preserves the
+# inode), so nothing is lost either way, but the pid files they wrote will be
+# found in their new place after the next restart.
+set -u
+
+R="${YMIR_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)}"
+# The resolver lives in the tree that ships this migration. When YMIR_ROOT points
+# somewhere else (a sandbox, a test fixture), fall back to the lib beside this
+# script rather than failing to resolve the home at all.
+LIB="$R/bin/hoard-lib.sh"
+[ -r "$LIB" ] || LIB="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)/bin/hoard-lib.sh"
+# shellcheck source=bin/hoard-lib.sh
+. "$LIB"
+ymir_home_root H
+hoard_root HOARD
+hoard_data_dir RECORDS
+hoard_state_dir RUNTIME
+hoard_settings_dir SETTINGS
+hoard_local_env ENVFILE
+
+moved=0; kept=0; refused=0; merged=0; rows=0
+# The row buffers are written as they happen and printed at the end, so the TOON
+# header can carry the true count. `rows` is kept beside them: under `set -u`,
+# bash older than 4.4 reads an empty `declare -a` array as unbound.
+declare -a ROW_ACT=() ROW_FROM=() ROW_TO=()
+row() { ROW_ACT+=("$1"); ROW_FROM+=("$2"); ROW_TO+=("$3"); rows=$((rows+1)); }
+
+# tracked_by_git <path> — 1 when git knows the file (the distro ships it)
+tracked_by_git() {
+  command -v git >/dev/null 2>&1 || return 1
+  git -C "$R" ls-files --error-unmatch "${1#"$R"/}" >/dev/null 2>&1
+}
+
+# carry <src> <dst-dir> — move one entry home, unless the home already holds it
+carry() {
+  local src="$1" dst="$2" base stale
+  base="$(basename "$src")"
+  mkdir -p "$dst" 2>/dev/null || { refused=$((refused+1)); row refuse "$src" "cannot write $dst"; return 0; }
+  if [ ! -e "$dst/$base" ]; then
+    if mv "$src" "$dst/$base" 2>/dev/null; then
+      moved=$((moved+1)); row moved "$src" "$dst/$base"
+    else
+      refused=$((refused+1)); row refuse "$src" "could not move to $dst/$base"
+    fi
+    return 0
+  fi
+  # The home already holds this name. Two files, one name — decide by evidence,
+  # never by assumption: identical content means the tree's copy can go (nothing
+  # is lost, and the content is at home); different content means BOTH are real,
+  # so the home's wins the name and the tree's is carried beside it as `.stale-*`
+  # rather than merged or discarded.
+  if [ -f "$src" ] && [ -f "$dst/$base" ] && cmp -s "$src" "$dst/$base"; then
+    rm -f "$src" && { merged=$((merged+1)); row merged "$src" "identical to $dst/$base — the tree's copy removed, nothing lost"; }
+  elif [ -f "$src" ]; then
+    stale="$dst/$base.stale-$(date -u +%Y%m%dT%H%M%SZ)"
+    if mv "$src" "$stale" 2>/dev/null; then
+      moved=$((moved+1)); row kept-as "$src" "$stale — differs from the home's copy, so both are kept"
+    else
+      refused=$((refused+1)); row refuse "$src" "differs from the home's copy and could not be carried"
+    fi
+  else
+    kept=$((kept+1)); row kept "$src" "home already holds $base — left in place, nothing overwritten"
+  fi
+}
+
+# ── the machine's records ────────────────────────────────────────────────────
+if [ -d "$R/data" ]; then
+  for f in "$R"/data/* "$R"/data/.[!.]*; do
+    [ -e "$f" ] || continue
+    case "$(basename "$f")" in .gitkeep|*.example|*.example.*) kept=$((kept+1)); continue ;; esac
+    carry "$f" "$RECORDS"
+  done
+fi
+
+# ── the runtime state ────────────────────────────────────────────────────────
+if [ -d "$R/state" ]; then
+  for f in "$R"/state/* "$R"/state/.[!.]*; do
+    [ -e "$f" ] || continue
+    case "$(basename "$f")" in .gitkeep) kept=$((kept+1)); continue ;; esac
+    carry "$f" "$RUNTIME"
+  done
+fi
+
+# ── the operator's credentials ───────────────────────────────────────────────
+# Never printed, never parsed — only carried.
+for cand in "$R"/.env.loc[a]l; do
+  [ -f "$cand" ] || continue
+  if [ -f "$ENVFILE" ]; then
+    kept=$((kept+1)); row kept "${cand#"$R"/}" "the home already holds its own — left in place, never merged"
+  else
+    mkdir -p "$(dirname "$ENVFILE")" 2>/dev/null
+    if mv "$cand" "$ENVFILE" 2>/dev/null; then
+      chmod 600 "$ENVFILE" 2>/dev/null || true
+      moved=$((moved+1)); row moved "${cand#"$R"/}" "${ENVFILE#"$H"/} (0600)"
+    else
+      refused=$((refused+1)); row refuse "${cand#"$R"/}" "could not move to the home"
+    fi
+  fi
+done
+
+# ── the operator's own settings ──────────────────────────────────────────────
+# Only what git does not track: a tracked settings file is the distro's shipped
+# default and stays where the code ships it. `config` may be a symlink into
+# .agents/config, so resolve the real directory before walking it.
+cfgdir="$R/.agents/config"
+[ -d "$R/config" ] && [ ! -L "$R/config" ] && cfgdir="$R/config"
+if [ -d "$cfgdir" ]; then
+  for f in "$cfgdir"/* "$cfgdir"/.[!.]*; do
+    [ -e "$f" ] || continue
+    base="$(basename "$f")"
+    case "$base" in .gitkeep|*.example|*.example.*) kept=$((kept+1)); continue ;; esac
+    if tracked_by_git "$f"; then
+      kept=$((kept+1)); row kept "config/$base" "the distro ships this one — it is a default, not the operator's own"
+      continue
+    fi
+    carry "$f" "$SETTINGS"
+  done
+fi
+
+if [ "$rows" -gt 0 ]; then
+  printf 'ymir-migrate-0005[%d]{action,from,to}:\n' "$rows"
+  for i in "${!ROW_ACT[@]}"; do
+    printf '  "%s","%s","%s"\n' "${ROW_ACT[$i]}" "${ROW_FROM[$i]}" "${ROW_TO[$i]}"
+  done
+fi
+printf 'ymir-migrate-0005[1]{moved,merged,kept,refused}:\n  "%s",%s,%s,%s\n' "$moved" "$merged" "$kept" "$refused"
+exit 0

package/.agents/sandbox/Dockerfile.utgard

@@ -0,0 +1,19 @@
+# UTGARD — Hardened Minimal Execution Container
+
+FROM node:20-alpine
+
+RUN apk add --no-cache \
+    python3 \
+    make \
+    g++ \
+    git \
+    bash \
+    curl
+
+RUN addgroup -S agentgroup && adduser -S agentuser -G agentgroup
+
+WORKDIR /sandbox
+
+USER agentuser
+
+CMD ["bash"]

package/.agents/sandbox/README.md

@@ -0,0 +1,14 @@
+# UTGARD Sandbox (Docker Execution Barrier)
+
+Isolated container execution for untrusted code, dynamic skills, and sub-agent tasks.
+
+## Contents (to be implemented)
+- `Dockerfile.utgard` — hardened minimal execution container (exists)
+- `utgard.config.json` — CPU / RAM / timeout limits (exists)
+- `execute_utgard.ts` — Docker launcher skill for safe script execution
+
+## Rules
+- `--network none` by default
+- Strict `--memory` and `--cpus` limits
+- No host root access
+- Failed executions never touch main branches

package/.agents/sandbox/utgard.config.json

@@ -0,0 +1,14 @@
+{
+  "image": "utgard-runner:latest",
+  "network": "none",
+  "cpus": "1.0",
+  "memory": "512m",
+  "timeoutMs": 30000,
+  "securityOptions": [
+    "no-new-privileges"
+  ],
+  "mount": {
+    "target": "/sandbox/workspace",
+    "readOnly": false
+  }
+}

package/.agents/skills/README.md

@@ -0,0 +1,59 @@
+# GUNGNIR — Core Operational Skills
+
+Every reusable task becomes a scripted skill here. Skills are validated in Utgard
+before registration, and every skill is named for the myth figure whose role
+matches its work (Gungnir naming law).
+
+## Registry (`.agents/skills/`)
+
+Every skill has an **owner agent** (`.agents/agents/<name>.md`): the seat Brokk
+dispatches for that work. A skill owned by `brokk` means the primary keeps it in
+hand — a dedicated seat is added when the work earns one.
+
+```
+skills[26]{skill,does,owner}:
+  "galdr-ymirsystem","agent-CLI ergonomics — the master builder/maintainer of the runtime","galdr"
+  "tyr-check","the judge — galdr principles + runtime gates","tyr"
+  "rules-check-drift","rules-file drift — keeps AGENTS.md true after code changes","tyr"
+  "no-mistakes","the clean-PR gate — vendored engine skill: validate, push, PR, CI","brokk"
+  "smidja-factory","the smithy — agent factory: roster, phases, envelopes, visualizer (app-provided: cloned by step_apps from its own repo, absent until then)","volundr"
+  "hvild-afk","away-mode — supervision of routine wakes and batched escalations","brokk"
+  "saga-bearings","bearings — fleet status digest (/bearings) + recap (/ahoy)","saga"
+  "muninn-stow","memory — session-knowledge curation, routing, persistence","muninn"
+  "jord-projects","projects — registry + delivery posture","jord"
+  "urdh-hold","hold lifecycle — decisions held for the Allfather, reconciled","urdh"
+  "frigg-consent","consent — ask-user authority gate","frigg"
+  "vor-diagnostics","diagnostics — bootstrap + diagnostic reasoning","vor"
+  "nornir-schedule","schedule — event sources + quota-aware dispatch","brokk"
+  "nsr-compliance","compliance — NorthStar scaffold/audit + the .compliance/ harness","brokk"
+  "lifecycle","lifecycle — start/stop/status/smoke-test wiring contract","brokk"
+  "gjallarhorn-relay","relay — public replies (X/Discord)","brokk"
+  "eindri-homes","worker homes — provisioning and upkeep of Eindri homes","brokk"
+  "syn-recovery","recovery — stuck-worker playbook","syn"
+  "ymir-host","host ops — self-update, Omarchy desktop, Þjazi backend","brokk"
+  "groa-update","the updater shaman — self-update Brokk + every Eindri-home (/updateBrokk)","groa"
+  "herdr-panes","terminal panes — seat/control panes, tabs, workspaces, agents (HERDR_ENV=1)","brokk"
+  "ratatoskr-a2a","A2A/MCP mesh — a2abridge + wayofteams; registration","brokk"
+  "hamr-adapters","harness adapters — per-harness reference","brokk"
+  "pr-ops","pull requests — create, update, check status, request merge","brokk"
+  "hnoss-design","design — artifacts via OpenDesign (prototypes, decks, dashboards, image, video)","hnoss"
+  "bragi-marketing","marketing — research/crawl (Firecrawl), agentic browser (browser-use)","bragi"
+```
+
+The control-plane UI guide is not a standalone skill: **hlidskjalf-ui** and its
+hall **Óðrerir** (odrerir-hall) are assets under **galdr-ymirsystem** (the master
+builder), loaded from `.agents/skills/galdr-ymirsystem/assets/` — see the galdr router.
+
+Not adopted as standalone skills: `firstmate-coding-guidelines` (folded into Galdr),
+`firstmate-orca` / `firstmate-codexapp` (backend reference docs only).
+
+## Skill synthesis rules (Gungnir)
+
+1. Gap identified → write the skill doc + script to `.agents/skills/<name>/`.
+2. Validate inside an Utgard container.
+3. Register it in this index.
+4. **Norse-name every new skill** at synthesis: choose the figure whose role
+   matches the work and let the skill inherit that name (`<figure>-<what>`).
+
+Governance: `.agents/skills/galdr-ymirsystem/SKILL.md`; adopted-skill provenance is recorded in
+`.agents/skills/galdr-ymirsystem/assets/reference-adoption.md`.

package/.agents/skills/bragi-marketing/README.md

@@ -0,0 +1,3 @@
+# bragi-marketing — marketing — research/crawl (Firecrawl), agentic browser (browser-use)
+
+See `SKILL.md` for the full skill.

package/.agents/skills/bragi-marketing/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: bragi
+description: >-
+  Bragi — the skald. The marketing craft: web research and crawling with
+  Firecrawl (firecrawl.dev) and agentic browser actions with browser-use
+  (github.com/browser-use/browser-use) — for SEO, content, competitive intel,
+  campaigns, and posting. Use when the task is marketing, growth, content,
+  social, or outreach. Keywords — marketing, seo, content, campaign, social,
+  competitor, crawl, scrape, firecrawl, browser-use.
+argument-hint: "[research | seo | content | campaign | competitor | post]"
+---
+
+# bragi-marketing — marketing — research/crawl (Firecrawl), agentic browser (browser-use)
+
+> **Norse name:** **Bragi** (the skald, poetry's god). The marketing craft.
+
+Bragi is how Ymir does **marketing**. Two validated open-source engines do the
+work; this skill is the Norse shell the **marketing Eindri** (Bragi) works
+through. Marketing output — a post, a landing page, a campaign — is a **real
+artifact** grounded in **real sources**, never invented.
+
+## 1. The engines (open-source first)
+
+- **Firecrawl** — [firecrawl.dev](https://www.firecrawl.dev/): scrape, crawl,
+  search, and map the web into clean **markdown / structured data**. The research
+  and SEO engine.
+  ```sh
+  pip install firecrawl-py
+  # FIRECRAWL_API_KEY from .env.local (never inline)
+  ```
+  REST: `POST /scrape`, `/crawl`, `/search`, `/map` — or the SDK:
+  ```python
+  from firecrawl import FirecrawlApp
+  app = FirecrawlApp(api_key=os.environ["FIRECRAWL_API_KEY"])
+  doc = app.scrape_url("https://example.com", params={"formats": ["markdown"]})
+  ```
+- **browser-use** — [github.com/browser-use/browser-use](https://github.com/browser-use/browser-use):
+  an LLM-driven **browser agent** that clicks, types, and reads pages. For
+  logged-in actions: publishing, posting, filling forms, reading dashboards.
+  ```sh
+  pip install browser-use
+  ```
+  ```python
+  from browser_use import Agent
+  agent = Agent(task="Post the launch thread to X", llm=<model from Bifrost / Pi catalog>)
+  await agent.run()
+  ```
+- **Scrapy** *(optional)* — [scrapy.org](https://www.scrapy.org/): a Python
+  scraping framework for **large or custom crawls** where Firecrawl is not the
+  right tool (many pages, structured pipelines, scheduling). `pip install scrapy`.
+  ```sh
+  scrapy startproject research && cd research && scrapy crawl sources -o out.jsonl
+  ```
+
+## 2. The craft (the loop)
+
+```
+marketing_loop[5]{step,what}:
+  "research","Firecrawl crawl/search the sources — cite every URL"
+  "position","the angle: audience, promise, channel, keywords"
+  "draft","copy, landing page, or asset — real text, on brand (Hnoss for visuals)"
+  "publish","browser-use drives the channel (X / Discord / site); Gjallarhorn relay"
+  "measure","crawl results, track metrics, feed learnings to the well"
+```
+
+## 3. Rules
+
+1. **Real sources, cited.** Every claim carries its URL (Firecrawl output).
+   Never invent a statistic, competitor, or quote.
+2. **OSS engines, BYOK.** `FIRECRAWL_API_KEY` and any model key come from
+   `.env.local` — never inline in Markdown or commits.
+3. **Real artifact.** A brief becomes a file (post, page, calendar), not a plan.
+4. **On brand.** Visual assets come from **Hnoss** (OpenDesign) + the `DESIGN.md`.
+5. **Domain.** The marketing Eindri is **Bragi**, domain `utgard` (creative) per
+   Rule 01; it does not implement product code (that is Sindri).
+
+## 4. Install into Ymir
+
+```sh
+pip install firecrawl-py browser-use
+bin/valknut-load.sh --all      # rebind agents/skills after adding this skill
+```

package/.agents/skills/eindri-homes/README.md

@@ -0,0 +1,3 @@
+# eindri-homes — worker homes — provisioning and upkeep of Eindri homes
+
+See `SKILL.md` for the full skill.