@zerwiz/ymir 0.1.5 → 0.1.8

package/bin/hodd.sh

@@ -42,6 +42,24 @@ PY
   printf 'hodd[1]{action,file}:\n  "load","%s"\n' "$f"
 }
 
+# Resolve a secrets path: if the plaintext is absent but an .age sibling and the
+# hoard key exist, decrypt to stdout. Prints a path to a readable file (a temp
+# when decrypted) via the result var. Secrets stay encrypted at rest; the agent
+# never reads ciphertext directly — it asks for the resolved path.
+resolve_secret() {  # <file> <result-var>
+  local f=$1 var=$2 tmp key
+  if [ -r "$f" ]; then printf -v "$var" '%s' "$f"; return 0; fi
+  if [ -r "$f.age" ]; then
+    key="$HOARD/secrets/age.key"
+    command -v age >/dev/null 2>&1 || { printf 'error: %s is encrypted but age is not installed\nhelp: sudo pacman -S age\n' "$f.age" >&2; return 1; }
+    [ -r "$key" ] || { printf 'error: encrypted %s but no key at %s\n' "$f.age" "$key" >&2; return 1; }
+    tmp="$(mktemp)"; chmod 600 "$tmp"
+    age -d -i "$key" "$f.age" >"$tmp" 2>/dev/null || { rm -f "$tmp"; printf 'error: cannot decrypt %s\n' "$f.age" >&2; return 1; }
+    printf -v "$var" '%s' "$tmp"; return 0
+  fi
+  printf 'error: not readable: %s (and no %s.age)\n' "$f" "$f" >&2; return 1
+}
+
 case "$ACTION" in
   path)  printf '%s\n' "$HOARD" ;;
   init)
@@ -56,23 +74,29 @@ case "$ACTION" in
   load)
     f="${1:-}"; [ -n "$f" ] || { printf 'error: load needs a path under the Hoard\n' >&2; exit 2; }
     case "$f" in /*) ;; *) f="$HOARD/$f" ;; esac
-    load_env "$f" ;;
+    resolve_secret "$f" rf || exit 1
+    load_env "$rf"
+    case "$rf" in "$f") ;; *) rm -f "$rf" ;; esac ;;
   emit)
     # Print `export KEY=value` lines (quoting-safe) for the CALLER to eval, so
     # `eval "$(bin/hodd.sh emit <file>)"` sets the vars in the invoking shell.
+    # Transparently decrypts an .age sibling when the plaintext is absent.
     f="${1:-}"; [ -n "$f" ] || { printf 'error: emit needs a path under the Hoard\n' >&2; exit 2; }
     case "$f" in /*) ;; *) f="$HOARD/$f" ;; esac
-    [ -r "$f" ] || { printf 'error: not readable: %s\n' "$f" >&2; exit 1; }
-    python3 - "$f" <<'PY'
+    resolve_secret "$f" rf || exit 1
+    python3 - "$rf" <<'PY'
 import re, shlex, sys
 for line in open(sys.argv[1]):
     m = re.match(r'^([A-Za-z_][A-Za-z0-9_]*)=(.*)$', line.rstrip("\n"))
     if m:
         print(f"export {m.group(1)}={shlex.quote(m.group(2))}")
 PY
+    case "$rf" in "$f") ;; *) rm -f "$rf" ;; esac
     ;;
   tenant)
     t="${1:-}"; [ -n "$t" ] || { printf 'error: tenant needs a name\n' >&2; exit 2; }
-    load_env "$HOARD/tenants/$t/.env" ;;
+    resolve_secret "$HOARD/tenants/$t/.env" rf || exit 1
+    load_env "$rf"
+    case "$rf" in "$HOARD/tenants/$t/.env") ;; *) rm -f "$rf" ;; esac ;;
   *) printf 'error: unknown action %s\nhelp: bin/hodd.sh [path|init|ls|load|emit|tenant]\n' "$ACTION" >&2; exit 2 ;;
 esac

package/bin/huginn-research-worker.sh

@@ -12,6 +12,19 @@ set -u
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 
+# The operator's settings and secrets live in the home they chose, never in the
+# code tree — a packaged install replaces its tree on upgrade, and a credential
+# must never sit in a tree that ships (Rule 04).
+if [ -z "${YMIR_HOARD_LIB_LOADED:-}" ]; then
+  _yr="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  for _yc in "$_yr/hoard-lib.sh" "$(dirname "$_yr")/bin/hoard-lib.sh"; do
+    [ -r "$_yc" ] && { . "$_yc"; YMIR_HOARD_LIB_LOADED=1; break; }
+  done
+  unset _yr _yc
+fi
+hoard_settings_dir YMIR_SETTINGS_DIR
+hoard_local_env YMIR_ENV_FILE
+
 BRIEF="" OUTDIR="" MODEL=""
 while [ $# -gt 0 ]; do
   case "$1" in
@@ -28,7 +41,7 @@ done
 mkdir -p "$OUTDIR"
 
 # Resolve env — source .env.local if present.
-for f in "$ROOT/.env.local" "${YMIR_HOARD:-$HOME/Documents/Ymir}/.env.local"; do
+for f in "$YMIR_ENV_FILE" "${YMIR_HOARD:-$HOME/Documents/Ymir}/.env.local"; do
   [ -f "$f" ] && . "$f" 2>/dev/null || true
 done
 

package/bin/local-model-lock.sh

@@ -12,8 +12,27 @@ set -u
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-CFG="${YMIR_AGENTS_YAML:-$ROOT/config/agents.yaml}"
-LOCK="$ROOT/state/local-model.lock"
+
+# The operator's settings and secrets live in the home they chose, never in the
+# code tree — a packaged install replaces its tree on upgrade, and a credential
+# must never sit in a tree that ships (Rule 04).
+if [ -z "${YMIR_HOARD_LIB_LOADED:-}" ]; then
+  _yr="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  for _yc in "$_yr/hoard-lib.sh" "$(dirname "$_yr")/bin/hoard-lib.sh"; do
+    [ -r "$_yc" ] && { . "$_yc"; YMIR_HOARD_LIB_LOADED=1; break; }
+  done
+  unset _yr _yc
+fi
+hoard_settings_dir YMIR_SETTINGS_DIR
+hoard_local_env YMIR_ENV_FILE
+hoard_state_dir YMIR_STATE_DIR
+hoard_data_dir YMIR_DATA_DIR
+
+# The roots that live OUTSIDE the code tree: this machine's records and the
+# runtime state belong to the home the operator chose at installation, never in
+# the tree — a packaged install replaces its tree on upgrade (Rule 04).
+CFG="${YMIR_AGENTS_YAML:-$YMIR_SETTINGS_DIR/agents.yaml}"
+LOCK="$YMIR_STATE_DIR/local-model.lock"
 WAIT="${LOCAL_MODEL_WAIT:-1800}"
 
 [ $# -gt 0 ] || { printf 'error: usage: bin/local-model-lock.sh <command...>\n' >&2; exit 2; }
@@ -31,7 +50,7 @@ PY
 )"
 [ -n "$N" ] || N=1
 
-mkdir -p "$ROOT/state"
+mkdir -p "$YMIR_STATE_DIR"
 
 if [ "$N" -le 1 ]; then
   # one at a time — exclusive lock, wait for the peer to finish

package/bin/mimir-bridge.py

@@ -49,6 +49,35 @@ def engine(agent: str | None) -> Engram:
         return _pool[key]
 
 
+def layers():
+    """What the well actually holds, layer by layer - the record a UI reads."""
+    out = {"facts": 0, "facts_active": 0, "facts_superseded": 0, "entities": 0,
+           "edges": 0, "reflections": 0, "last_reflection": None, "vec_index": 0}
+    try:
+        con = sqlite3.connect(f"file:{STORE}?mode=ro", uri=True)
+        for key, sql in (
+            ("facts", "select count(*) from facts"),
+            ("facts_active", "select count(*) from facts where superseded_at is null"),
+            ("facts_superseded", "select count(*) from facts where superseded_at is not null"),
+            ("entities", "select count(*) from entities"),
+            ("edges", "select count(*) from edges"),
+            ("reflections", "select count(*) from reflections"),
+            ("vec_index", "select count(*) from vec_episodes_rowids"),
+        ):
+            try:
+                out[key] = int(con.execute(sql).fetchone()[0])
+            except Exception:
+                pass
+        try:
+            out["last_reflection"] = con.execute(
+                "select max(finished_at) from reflections").fetchone()[0]
+        except Exception:
+            pass
+    except Exception as e:
+        out["error"] = str(e)
+    return out
+
+
 def count_episodes() -> int:
     try:
         con = sqlite3.connect(f"file:{STORE}?mode=ro", uri=True)
@@ -98,10 +127,14 @@ class Handler(BaseHTTPRequestHandler):
                     "agents": engine(None).list_agents(),
                 })
             if u.path == "/inspect":
+                # THE LAYERS, not just the count. The smithy shows what it is told,
+                # and it was told three fields while the well holds six: a panel that
+                # reads only episodes cannot show that facts and entities exist.
                 return self._json(200, {
                     "store": str(STORE),
                     "episodes": count_episodes(),
                     "agents": engine(None).list_agents(),
+                    **layers(),
                 })
             if u.path == "/recent":
                 limit = int((q.get("limit") or ["60"])[0])

package/bin/mimir-bridge.sh

@@ -18,6 +18,19 @@ fi
 VERSION="1.0.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+# The roots that live OUTSIDE the code tree: this machine's records and the
+# runtime state belong to the home the operator chose at installation, never in
+# the tree — a packaged install replaces its tree on upgrade (Rule 04).
+if [ -z "${YMIR_HOARD_LIB_LOADED:-}" ]; then
+  _yr="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  for _yc in "$_yr/hoard-lib.sh" "$(dirname "$_yr")/bin/hoard-lib.sh"; do
+    [ -r "$_yc" ] && { . "$_yc"; YMIR_HOARD_LIB_LOADED=1; break; }
+  done
+  unset _yr _yc
+fi
+hoard_state_dir YMIR_STATE_DIR
+hoard_data_dir YMIR_DATA_DIR
 YMIR_HOME="${YMIR_HOME:-$HOME/Documents/Ymir}"
 BRIDGE="$ROOT/bin/mimir-bridge.py"
 DB="${ENGRAM_DB:-$YMIR_HOME/memory/kaia.engram}"
@@ -75,7 +88,7 @@ if ! "$PY" -c "import engram" 2>/dev/null; then
   printf 'error: engram not installed for %s\nhelp: bin/prereq-ensure.sh engram   (installs it into a compatible Python)\n' "$PY" >&2; exit 1
 fi
 
-mkdir -p "$ROOT/state" "$(dirname "$DB")"
+mkdir -p "$YMIR_STATE_DIR" "$(dirname "$DB")"
 ENGRAM_DB="$DB" MIMIRSBRUNN_PORT="$PORT" nohup "$PY" "$BRIDGE" >"$LOG_FILE" 2>&1 &
 echo $! >"$PID_FILE"
 sleep 3

package/bin/mimir-reflect.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# mimir-reflect — smelt the well's episodes into facts, through the LLAMA-ROUTER.
+#
+# The router is Ymir's one door to local models: its seats are llama.cpp on :8080
+# (coding) and Apodex on :1234 (research/planning). NEVER point this at Ollama —
+# ollama is the machine's own server, not a Ymir provider, and one local model
+# rides the router at a time. Swap seats by re-pointing the router, not by
+# reaching past it.
+#
+#   bin/mimir-reflect.sh              # the well, with the default seat
+#   YMIR_ROUTER_URL=http://127.0.0.1:8080/v1 YMIR_REFLECT_MODEL=qwen3.6-35b-a3b bin/mimir-reflect.sh
+set -euo pipefail
+
+WELL="${YMIR_WELL:-${YMIR_HOME:-$HOME/Documents/Ymir}/memory/kaia.engram}"
+BASE="${YMIR_ROUTER_URL:-http://127.0.0.1:1234/v1}"
+MODEL="${YMIR_REFLECT_MODEL:-apodex-1.0-mini}"
+
+[ -f "$WELL" ] || { echo "error: no well at $WELL" >&2; echo "help: set YMIR_WELL or run bin/mimir-bridge.py first" >&2; exit 1; }
+
+echo "mimir-reflect[well,seat]:"
+echo "  \"$WELL\""
+echo "  \"$BASE\"  model \"$MODEL\""
+echo
+
+# A local seat needs no key; an empty one keeps the OpenAI client quiet.
+OPENAI_API_KEY="${OPENAI_API_KEY:-local}" \
+  exec engram reflect "$WELL" --llm openai --model "$MODEL" --base-url "$BASE"

package/bin/mjollnir-webhook.sh

@@ -13,7 +13,20 @@ set -u
 VERSION="1.0.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-ENV_FILE="${BROKK_ENV_FILE:-$ROOT/.env.local}"
+
+# The operator's settings and secrets live in the home they chose, never in the
+# code tree — a packaged install replaces its tree on upgrade, and a credential
+# must never sit in a tree that ships (Rule 04).
+if [ -z "${YMIR_HOARD_LIB_LOADED:-}" ]; then
+  _yr="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  for _yc in "$_yr/hoard-lib.sh" "$(dirname "$_yr")/bin/hoard-lib.sh"; do
+    [ -r "$_yc" ] && { . "$_yc"; YMIR_HOARD_LIB_LOADED=1; break; }
+  done
+  unset _yr _yc
+fi
+hoard_settings_dir YMIR_SETTINGS_DIR
+hoard_local_env YMIR_ENV_FILE
+ENV_FILE="${BROKK_ENV_FILE:-$YMIR_ENV_FILE}"
 
 case "${1-}" in
   -v|-V|--version) printf '%s\n' "$VERSION"; exit 0 ;;

package/bin/mjollnir.sh

@@ -13,7 +13,26 @@ set -u
 VERSION="1.0.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-ENV_FILE="${BROKK_ENV_FILE:-$ROOT/.env.local}"
+
+# The operator's settings and secrets live in the home they chose, never in the
+# code tree — a packaged install replaces its tree on upgrade, and a credential
+# must never sit in a tree that ships (Rule 04).
+if [ -z "${YMIR_HOARD_LIB_LOADED:-}" ]; then
+  _yr="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  for _yc in "$_yr/hoard-lib.sh" "$(dirname "$_yr")/bin/hoard-lib.sh"; do
+    [ -r "$_yc" ] && { . "$_yc"; YMIR_HOARD_LIB_LOADED=1; break; }
+  done
+  unset _yr _yc
+fi
+hoard_settings_dir YMIR_SETTINGS_DIR
+hoard_local_env YMIR_ENV_FILE
+hoard_state_dir YMIR_STATE_DIR
+hoard_data_dir YMIR_DATA_DIR
+
+# The roots that live OUTSIDE the code tree: this machine's records and the
+# runtime state belong to the home the operator chose at installation, never in
+# the tree — a packaged install replaces its tree on upgrade (Rule 04).
+ENV_FILE="${BROKK_ENV_FILE:-$YMIR_ENV_FILE}"
 
 usage() { sed -n '2,13p' "$0" | sed 's/^# \{0,1\}//'; }
 CMD="${1-}"; shift || true
@@ -40,7 +59,7 @@ done
 if [ "$CMD" = status ]; then
   printf 'mjollnir[2]{field,value}:\n'
   printf '  "repo","%s"\n' "${REPO:-$ROOT}"
-  printf '  "pending","%s"\n' "$(find "$ROOT/data" -maxdepth 2 -name 'brief.md' -path '*issue-*' 2>/dev/null | wc -l | tr -d ' ')"
+  printf '  "pending","%s"\n' "$(find "$YMIR_DATA_DIR" -maxdepth 2 -name 'brief.md' -path '*issue-*' 2>/dev/null | wc -l | tr -d ' ')"
   exit 0
 fi
 [ "$CMD" = run ] || { printf 'error: unknown command %s\nhelp: bin/mjollnir.sh [run|status|--version]\n' "$CMD" >&2; exit 2; }
@@ -69,7 +88,7 @@ printf 'mjollnir[1]{issue,task,mode,repo}:\n  "%s","%s","%s","%s"\n' "$ISSUE" "$
 
 # 2. Scaffold the brief (the worker's contract).
 "$SCRIPT_DIR/erindi-brief.sh" "$ID" "$(basename "$REPO")" --mode "$MODE" >/dev/null 2>&1 || true
-BRIEF="$ROOT/data/$ID/brief.md"
+BRIEF="$YMIR_DATA_DIR/$ID/brief.md"
 if [ -f "$BRIEF" ]; then
   { printf '\n\n## Issue #%s — %s\n\n%s\n' "$ISSUE" "$TITLE" "$BODY"; } >>"$BRIEF"
 fi

package/bin/model-hardware.sh

@@ -17,7 +17,20 @@ set -u
 VERSION="1.0.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-OUT="${YMIR_LOCAL_MODELS_DOC:-$ROOT/data/local-models.md}"
+
+# The roots that live OUTSIDE the code tree: this machine's records and the
+# runtime state belong to the home the operator chose at installation, never in
+# the tree — a packaged install replaces its tree on upgrade (Rule 04).
+if [ -z "${YMIR_HOARD_LIB_LOADED:-}" ]; then
+  _yr="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  for _yc in "$_yr/hoard-lib.sh" "$(dirname "$_yr")/bin/hoard-lib.sh"; do
+    [ -r "$_yc" ] && { . "$_yc"; YMIR_HOARD_LIB_LOADED=1; break; }
+  done
+  unset _yr _yc
+fi
+hoard_state_dir YMIR_STATE_DIR
+hoard_data_dir YMIR_DATA_DIR
+OUT="${YMIR_LOCAL_MODELS_DOC:-$YMIR_DATA_DIR/local-models.md}"
 PRINT_ONLY=0
 
 case "${1-}" in -v|-V|--version) printf '%s\n' "$VERSION"; exit 0 ;; -h|--help) sed -n '2,14p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;; esac
@@ -53,8 +66,9 @@ block="<!-- model-hardware:begin -->
   build/run the CUDA build; keep K and V the same KV type (q8_0).
 - **Coding wants >= 80000 context.** Measure the real ceiling: load more until a
   request OOMs, then drop one step (ctx is per-model).
-- **Bench to the maximum:** load the \`.agents/skills/modeltesting\` skill, then
-  \`bin/models-detect.sh --write\` to register what serves.
+- **The method** — engines, wiring, and honest measurement — is the Galdr asset
+  \`.agents/skills/galdr-ymirsystem/assets/local-models.md\`. Then
+  \`bin/models-detect.sh --write\` registers what serves.
 <!-- model-hardware:end -->"
 
 # The researched settings are NOT in the managed block, so a re-run never clobbers

package/bin/model-resolve.sh

@@ -15,7 +15,20 @@ set -u
 VERSION="1.0.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-CFG="${YMIR_AGENTS_YAML:-$ROOT/config/agents.yaml}"
+
+# The operator's settings and secrets live in the home they chose, never in the
+# code tree — a packaged install replaces its tree on upgrade, and a credential
+# must never sit in a tree that ships (Rule 04).
+if [ -z "${YMIR_HOARD_LIB_LOADED:-}" ]; then
+  _yr="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  for _yc in "$_yr/hoard-lib.sh" "$(dirname "$_yr")/bin/hoard-lib.sh"; do
+    [ -r "$_yc" ] && { . "$_yc"; YMIR_HOARD_LIB_LOADED=1; break; }
+  done
+  unset _yr _yc
+fi
+hoard_settings_dir YMIR_SETTINGS_DIR
+hoard_local_env YMIR_ENV_FILE
+CFG="${YMIR_AGENTS_YAML:-$YMIR_SETTINGS_DIR/agents.yaml}"
 
 case "${1-}" in -v|-V|--version) printf '%s\n' "$VERSION"; exit 0 ;;
   -h|--help|"") sed -n '2,12p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;; esac

package/bin/nornir-job-hall-snapshot.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# nornir-job-hall-snapshot.sh — Óðrerir: refresh the Live Hall's board.
+#
+# The Hall is a glass: it reads apps/odrerir/public/livehall.json, written by
+# this job from the real system state (runes · projects · cron · wake queue ·
+# standing smiths · armed when-sources · landed errands). Scheduled at 08:00,
+# after the 06:00 observer and the 07:00 briefing, so the morning's board
+# carries the day's fresh runes. Stateless: read inputs → write the snapshot →
+# carve a Rune → exit.
+#
+# Overrides: BROKK_ROOT_OVERRIDE (hall-snapshot.sh), YMIR_HOME (the hoard).
+set -u
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="${BROKK_ROOT_OVERRIDE:-$(cd "$SCRIPT_DIR/.." && pwd)}"
+
+# The snapshot is runtime, never repo: it is gitignored where it lands.
+if ! "$ROOT/bin/hall-snapshot.sh" >/dev/null 2>&1; then
+  printf 'error: hall-snapshot.sh failed — the board is stale\n'
+  printf 'help: run bin/hall-snapshot.sh by hand to see the reason\n'
+  exit 1
+fi
+
+# Carve the Rune — the ledger lives with the hoard.
+# shellcheck source=bin/runes-append.sh
+. "$ROOT/bin/runes-append.sh"
+runes_append "odrerir" "hall.snapshot" --message "Live Hall board refreshed from real state" >/dev/null \
+  || printf 'hall-snapshot: rune append failed (non-fatal)\n'
+printf 'hall-snapshot: Live Hall board refreshed\n'

package/bin/nornir-job-nsr-compliance.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# nornir-job-nsr-compliance.sh — the NorthStar compliance round, nightly.
+#
+# Runs the deterministic NSR gates (.compliance/gates/check_*.sh — danger,
+# env, paths, platform, wiring) and carves one Rune with the verdict. A FAIL
+# is reported loudly in the Rune message — the morning briefing reads the
+# ledger, so a broken door is seen at sunrise, not found by accident.
+#
+# Stateless: run gates → write nothing but state/last + the Rune → exit.
+set -u
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="${BROKK_ROOT_OVERRIDE:-$(cd "$SCRIPT_DIR/.." && pwd)}"
+
+# The roots that live OUTSIDE the code tree: this machine's records and the
+# runtime state belong to the home the operator chose at installation, never in
+# the tree — a packaged install replaces its tree on upgrade (Rule 04).
+if [ -z "${YMIR_HOARD_LIB_LOADED:-}" ]; then
+  _yr="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  for _yc in "$_yr/hoard-lib.sh" "$(dirname "$_yr")/bin/hoard-lib.sh"; do
+    [ -r "$_yc" ] && { . "$_yc"; YMIR_HOARD_LIB_LOADED=1; break; }
+  done
+  unset _yr _yc
+fi
+hoard_state_dir YMIR_STATE_DIR
+hoard_data_dir YMIR_DATA_DIR
+STATE="${BROKK_STATE_OVERRIDE:-$YMIR_STATE_DIR}"
+
+GATES_DIR="$ROOT/.compliance/gates"
+[ -d "$GATES_DIR" ] || { printf 'error: no NSR gates at %s\n' "$GATES_DIR"; exit 1; }
+
+passed=0; failed=0; failed_names=""
+for g in "$GATES_DIR"/check_*.sh; do
+  name=$(basename "$g" .sh)
+  if bash "$g" >/dev/null 2>&1; then
+    passed=$((passed+1))
+  else
+    failed=$((failed+1)); failed_names="$failed_names $name"
+  fi
+done
+
+printf 'nsr-compliance: gates=%d passed=%d failed=%d%s\n' \
+  "$((passed+failed))" "$passed" "$failed" "$failed_names"
+
+# shellcheck source=bin/runes-append.sh
+. "$ROOT/bin/runes-append.sh"
+if [ "$failed" = 0 ]; then
+  runes_append "nornir" "nsr.compliance" --message "NSR compliance: $passed/$passed gates passed" >/dev/null \
+    || printf 'nsr-compliance: rune append failed (non-fatal)\n'
+  exit 0
+else
+  runes_append "nornir" "nsr.compliance.failed" --message "NSR compliance FAIL: gates $failed_names FAILED — mend at sunrise" >/dev/null \
+    || printf 'nsr-compliance: rune append failed (non-fatal)\n'
+  exit 1
+fi

package/bin/npm-publish.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+# npm-publish.sh — publish through the HOARD's npm token, every single time.
+#
+# Why this exists: this machine once held two tokens, and the one in ~/.npmrc was
+# stale. A publish then failed with a 2FA refusal that looked like a policy
+# problem but was a credential problem, and a session was spent on it. The token
+# with bypass-2FA lives in the hoard. So the rule is: never trust ~/.npmrc — read
+# the token from the hoard, hand it to npm through a temporary userconfig, and
+# throw the file away.
+#
+#   bin/npm-publish.sh                 # the platform (the repo root manifest)
+#   bin/npm-publish.sh apps/hlidskjalf # one package
+#   bin/npm-publish.sh --all           # the platform + every app package
+#   bin/npm-publish.sh --whoami        # which account the hoard token is
+#   bin/npm-publish.sh --dry-run apps/odrerir
+#   bin/npm-publish.sh --unpublish @zerwiz/ymir@0.1.5     # take ONE version back
+#   bin/npm-publish.sh --unpublish @zerwiz/ymir@0.1.5 --dry-run
+#
+# Unpublish: npm allows ONE VERSION back for 72 hours after it was published;
+# past that only npm support can remove it, which is why this door names the
+# version and refuses anything vaguer. A whole package is not a one-word act —
+# that needs npm's own tooling and a deliberate decision, not a flag here.
+#
+# A prerelease version (0.1.8-alpha) is published under `--tag next` automatically
+# — npm refuses a prerelease on `latest`, which is the second half of the same
+# lesson. A scoped package always goes out with public access.
+set -u
+
+VERSION="1.0.0"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+# shellcheck source=bin/hoard-lib.sh
+. "$SCRIPT_DIR/hoard-lib.sh"
+
+DRY=0; WHO=0; ALL=0; UNPUBLISH=0; UNPUB_SPEC=""; TARGETS=()
+for a in "$@"; do
+  case "$a" in
+    --whoami) WHO=1 ;;
+    --dry-run) DRY=1 ;;
+    --all) ALL=1 ;;
+    --unpublish) UNPUBLISH=1 ;;
+    --unpublish=*) UNPUBLISH=1; UNPUB_SPEC="${a#*=}" ;;
+    -v|-V|--version) printf '%s\n' "$VERSION"; exit 0 ;;
+    -h|--help|"") sed -n '2,22p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+    -*) printf 'error: unknown flag %s\nhelp: bin/npm-publish.sh [--all|--whoami|--unpublish <spec>|--dry-run] [<package-dir>...]\n' "$a" >&2; exit 2 ;;
+    *) TARGETS+=("$a") ;;
+  esac
+done
+# --all is the platform plus every app package. The smithy's own repo is
+# cloned at apps/smidja-factory (the registry maps smidja there), so it is a
+# target like any other app: it publishes as @zerwiz/smidja.
+[ "$ALL" = 1 ] && TARGETS=("$ROOT" "$ROOT/apps/hlidskjalf" "$ROOT/apps/hlidskjalf-mobile" "$ROOT/apps/odrerir" "$ROOT/apps/sessrumnir" "$ROOT/apps/smidja-factory")
+[ "${#TARGETS[@]}" -eq 0 ] && [ "$WHO" = 0 ] && [ "$UNPUBLISH" = 0 ] && TARGETS=("$ROOT")
+# `--unpublish @scope/name@1.2.3` — the spec may also arrive positionally.
+[ "$UNPUBLISH" = 1 ] && UNPUB_SPEC="${UNPUB_SPEC:-${TARGETS[0]:-}}" 
+
+# ── the token, from the hoard ────────────────────────────────────────────────
+envfile=""; hoard_env envfile
+TOKEN=""
+if [ -r "$envfile" ]; then
+  TOKEN="$(sed -n 's/^NPM_TOKEN=//p' "$envfile" | head -1 | tr -d '"'"'"' ')"
+fi
+if [ -z "$TOKEN" ] && [ "$WHO" = 1 ]; then
+  printf 'npm[1]{token,state}:\n  "NPM_TOKEN","absent in %s"\n' "${envfile#"$HOME"/}"
+  exit 1
+fi
+if [ -z "$TOKEN" ]; then
+  printf 'error: the hoard holds no NPM_TOKEN\nhelp: add NPM_TOKEN=<granular token with bypass 2FA> to %s\n' "${envfile#"$HOME"/}" >&2
+  printf 'help: npmjs.com → Access Tokens → Generate → granular, scope @zerwiz, bypass 2FA on\n' >&2
+  exit 1
+fi
+
+cfg="$(mktemp)"; chmod 600 "$cfg"
+printf '//registry.npmjs.org/:_authToken=%s\n' "$TOKEN" >"$cfg"
+trap 'rm -f "$cfg"' EXIT
+
+if [ "$WHO" = 1 ]; then
+  who="$(npm whoami --userconfig "$cfg" 2>/dev/null || printf 'unknown')"
+  printf 'npm[2]{token,account}:\n  "source","%s"\n  "whoami","%s"\n' "${envfile#"$HOME"/}" "$who"
+  exit 0
+fi
+
+# ── unpublish ────────────────────────────────────────────────────────────────
+# Take ONE version back. npm permits it for 72 hours after publication; beyond
+# that it is npm support's door, not this one. The spec must name a version:
+# `@scope/name@1.2.3`, never a bare name.
+if [ "$UNPUBLISH" = 1 ]; then
+  case "$UNPUB_SPEC" in
+    *@*@*) ;;  # @scope/name@version
+    *@[0-9]*) ;;
+    *) printf 'error: --unpublish needs a package AND a version\nhelp: bin/npm-publish.sh --unpublish @scope/name@<version>\n' >&2; exit 2 ;;
+  esac
+  if [ "$DRY" = 1 ]; then
+    printf 'npm_unpublish[1]{spec,state}:\n  "%s","dry-run — nothing was removed"\n' "$UNPUB_SPEC"
+    exit 0
+  fi
+  out="$(npm unpublish "$UNPUB_SPEC" --force --userconfig "$cfg" 2>&1)"; rc=$?
+  if [ "$rc" = 0 ]; then
+    printf 'npm_unpublish[1]{spec,state}:\n  "%s","unpublished"\n' "$UNPUB_SPEC"
+    printf 'note: the registry CDN may serve the tarball for a while after this; publishing a\n'
+    printf 'note: newer version moves the "latest" tag off it at once.\n'
+  else
+    why="$(printf '%s' "$out" | grep -m1 -E 'npm error (code )?[A-Z0-9]+|E[0-9]{3}' | cut -c1-90)"
+    printf 'error: unpublish failed — %s\nhelp: is it inside the 72-hour window, and is the token the right account? (bin/npm-publish.sh --whoami)\n' "${why:-see npm log}" >&2
+    exit 1
+  fi
+  exit 0
+fi
+
+# ── publish ──────────────────────────────────────────────────────────────────
+printf 'npm_publish[%d]{package,version,tag,state}:\n' "${#TARGETS[@]}"
+failed=0
+for dir in "${TARGETS[@]}"; do
+  pkg="$dir/package.json"
+  if [ ! -f "$pkg" ]; then
+    printf '  "%s","-","-","SKIP (no package.json)"\n' "${dir#"$ROOT"/}"
+    continue
+  fi
+  name="$(sed -n 's/.*"name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$pkg" | head -1)"
+  ver="$(sed -n 's/.*"version"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$pkg" | head -1)"
+  case "$ver" in *-*) tag=next ;; *) tag=latest ;; esac   # a prerelease never rides `latest`
+  if [ "$DRY" = 1 ]; then
+    printf '  "%s","%s","%s","dry-run"\n' "$name" "$ver" "$tag"
+    continue
+  fi
+  out="$(cd "$dir" && npm publish --access public --tag "$tag" --userconfig "$cfg" 2>&1)"; rc=$?
+  if [ "$rc" = 0 ]; then
+    printf '  "%s","%s","%s","published"\n' "$name" "$ver" "$tag"
+  else
+    why="$(printf '%s' "$out" | grep -m1 -E 'npm error (code )?[A-Z0-9]+|E[0-9]{3}' | cut -c1-90)"
+    printf '  "%s","%s","%s","FAILED (%s)"\n' "$name" "$ver" "$tag" "${why:-see npm log}"
+    failed=$((failed+1))
+  fi
+done
+[ "$failed" = 0 ] || { printf 'error: %d package(s) did not publish\nhelp: bin/npm-publish.sh --whoami  (is the hoard token still the right account?)\n' "$failed" >&2; exit 1; }
+exit 0

package/bin/omarchy-install.sh

@@ -24,6 +24,19 @@ VERSION="1.0.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 
+# The operator's settings and secrets live in the home they chose, never in the
+# code tree — a packaged install replaces its tree on upgrade, and a credential
+# must never sit in a tree that ships (Rule 04).
+if [ -z "${YMIR_HOARD_LIB_LOADED:-}" ]; then
+  _yr="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  for _yc in "$_yr/hoard-lib.sh" "$(dirname "$_yr")/bin/hoard-lib.sh"; do
+    [ -r "$_yc" ] && { . "$_yc"; YMIR_HOARD_LIB_LOADED=1; break; }
+  done
+  unset _yr _yc
+fi
+hoard_settings_dir YMIR_SETTINGS_DIR
+hoard_local_env YMIR_ENV_FILE
+
 # portability shim (bin/ymir-platform.sh)
 if [ -z "${YMIR_PLATFORM_LOADED:-}" ]; then
   _ymir_dir="$SCRIPT_DIR"
@@ -122,15 +135,15 @@ else
 fi
 
 # ── 6. the away-mode alarm channel + the crash sensor ────────────────────────
-if [ -e "$ROOT/config/wedge-alarm" ]; then
+if [ -e "$YMIR_SETTINGS_DIR/wedge-alarm" ]; then
   add alarm OK "channel kept"
 elif [ "$CHECK" = 1 ]; then
   add alarm WARN "channel not written (run without --check)"
-elif mkdir -p "$ROOT/config" 2>/dev/null && \
-     printf '# The channel the away-mode wedge alarm fires on when an escalation\n# cannot be delivered into the pane. See bin/wedge-notify.sh.\ndesktop\n' >"$ROOT/config/wedge-alarm" 2>/dev/null; then
-  add alarm OK "channel written (config/wedge-alarm)"
+elif mkdir -p "$YMIR_SETTINGS_DIR" 2>/dev/null && \
+     printf '# The channel the away-mode wedge alarm fires on when an escalation\n# cannot be delivered into the pane. See bin/wedge-notify.sh.\ndesktop\n' >"$YMIR_SETTINGS_DIR/wedge-alarm" 2>/dev/null; then
+  add alarm OK "channel written ($YMIR_SETTINGS_DIR/wedge-alarm)"
 else
-  add alarm WARN "could not write config/wedge-alarm"
+  add alarm WARN "could not write $YMIR_SETTINGS_DIR/wedge-alarm"
 fi
 
 # ── 7. the terminal backend Ymir needs ───────────────────────────────────────