@zerwiz/ymir 0.1.4 → 0.1.5

package/bin/nornir-job-git-sync.sh

@@ -0,0 +1,152 @@
+#!/usr/bin/env bash
+# nornir-job-git-sync.sh - Yggdrasil, the world-tree kept in order.
+#
+# Configurable git sync/backup for Ymir and its realm workspaces. Two modes:
+#   fetch  (default, safe)  fetch --prune, then fast-forward ONLY (--ff-only).
+#   push   (opt-in)         commit local work, then push. Never force.
+#
+# Laws this job obeys:
+#   * never force anything (no --force, no reset, no checkout, no clean);
+#   * never discard unlanded work — a dirty tree is committed, not stashed;
+#   * a target that is not a git repo, has no remote, or has diverged is
+#     reported plainly and left untouched.
+#
+# Config (all optional):
+#   BROKK_GIT_SYNC_MODE      fetch | push            (default fetch)
+#   BROKK_GIT_SYNC_REMOTE    remote name             (default origin)
+#   BROKK_GIT_SYNC_TARGETS   colon-separated repo paths (default: auto-discover)
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="${BROKK_ROOT_OVERRIDE:-$(cd "$SCRIPT_DIR/.." && pwd)}"
+BROKK_HOME="${BROKK_HOME:-$ROOT}"
+DATA="${BROKK_DATA_OVERRIDE:-$BROKK_HOME/data}"
+# shellcheck source=bin/runes-append.sh
+. "$SCRIPT_DIR/runes-append.sh"
+
+MODE="${BROKK_GIT_SYNC_MODE:-fetch}"
+REMOTE="${BROKK_GIT_SYNC_REMOTE:-origin}"
+REALM="${BROKK_REALM:-}"
+if [ -z "$REALM" ] && [ -r "$DATA/realm.md" ]; then
+  REALM=$(head -n 1 "$DATA/realm.md" 2>/dev/null | tr -d '[:space:]')
+fi
+REALM="${REALM:-}"
+# Never assume the company's slug: resolve the operator's realm neutrally.
+if [ -z "$REALM" ]; then . "$SCRIPT_DIR/realm-lib.sh"; ymir_active_realm "$ROOT" REALM; fi
+STAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+command -v git >/dev/null 2>&1 || { printf 'error: git not installed\nhelp: install git and re-run\n'; exit 1; }
+
+if [ "$MODE" != "fetch" ] && [ "$MODE" != "push" ]; then
+  printf 'error: unknown BROKK_GIT_SYNC_MODE=%s\nhelp: use fetch (safe) or push (opt-in)\n' "$MODE"
+  exit 2
+fi
+
+discover_targets() {
+  if [ -n "${BROKK_GIT_SYNC_TARGETS:-}" ]; then
+    printf '%s\n' "$BROKK_GIT_SYNC_TARGETS" | tr ':' '\n'
+    return 0
+  fi
+  [ -d "$BROKK_HOME/.git" ] && printf '%s\n' "$BROKK_HOME"
+  [ -d "$BROKK_HOME/workspace/.git" ] && printf '%s\n' "$BROKK_HOME/workspace"
+  [ -d "$BROKK_HOME/midgard/.git" ] && printf '%s\n' "$BROKK_HOME/midgard"
+  for d in "$BROKK_HOME"/svartalfaheim/*; do
+    [ -d "$d" ] || continue
+    [ -d "$d/.git" ] && printf '%s\n' "$d"
+    [ -d "$d/workspace/.git" ] && printf '%s\n' "$d/workspace"
+    for p in "$d"/projects/*; do
+      [ -d "$p/.git" ] && printf '%s\n' "$p"
+    done
+  done
+  return 0
+}
+
+total=0
+ok=0
+skipped=0
+failed=0
+
+printf 'GIT SYNC - %s mode=%s remote=%s realm=%s\n' "$STAMP" "$MODE" "$REMOTE" "$REALM"
+
+while IFS= read -r target; do
+  [ -n "$target" ] || continue
+  total=$((total + 1))
+  if ! git -C "$target" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    printf 'target: skip (not a git repo) %s\n' "$target"
+    runes_append "yggdrasil" "git.sync" --realm "$REALM" --message "skip non-repo $target" >/dev/null 2>&1 || true
+    skipped=$((skipped + 1))
+    continue
+  fi
+  if ! git -C "$target" remote get-url "$REMOTE" >/dev/null 2>&1; then
+    printf 'target: skip (no remote %s) %s\n' "$REMOTE" "$target"
+    runes_append "yggdrasil" "git.sync" --realm "$REALM" --message "skip no-remote($REMOTE) $target" >/dev/null 2>&1 || true
+    skipped=$((skipped + 1))
+    continue
+  fi
+
+  branch=$(git -C "$target" rev-parse --abbrev-ref HEAD 2>/dev/null || printf '?')
+
+  if [ "$MODE" = "fetch" ]; then
+    if ! git -C "$target" fetch --prune "$REMOTE" >>/dev/null 2>&1; then
+      printf 'target: fetch FAILED %s (%s)\n' "$target" "$branch"
+      runes_append "yggdrasil" "git.sync" --realm "$REALM" --message "fetch failed $target ($branch)" >/dev/null 2>&1 || true
+      failed=$((failed + 1))
+      continue
+    fi
+    upstream=$(git -C "$target" rev-parse --abbrev-ref --symbolic-full-name '@{u}' 2>/dev/null || true)
+    if [ -z "$upstream" ]; then
+      printf 'target: fetched (no upstream tracked) %s (%s)\n' "$target" "$branch"
+      runes_append "yggdrasil" "git.sync" --realm "$REALM" --message "fetched no-upstream $target ($branch)" >/dev/null 2>&1 || true
+      ok=$((ok + 1))
+      continue
+    fi
+    if git -C "$target" merge --ff-only "$upstream" >>/dev/null 2>&1; then
+      printf 'target: fast-forward OK %s (%s -> %s)\n' "$target" "$branch" "$upstream"
+      runes_append "yggdrasil" "git.sync" --realm "$REALM" --message "ff-only ok $target ($branch <- $upstream)" >/dev/null 2>&1 || true
+      ok=$((ok + 1))
+    else
+      printf 'target: DIVERGED - ff-only refused, left untouched %s (%s)\n' "$target" "$branch"
+      runes_append "yggdrasil" "git.sync" --realm "$REALM" --message "diverged ff-only refused $target ($branch)" >/dev/null 2>&1 || true
+      failed=$((failed + 1))
+    fi
+  else
+    dirty=$(git -C "$target" status --porcelain 2>/dev/null || true)
+    if [ -n "$dirty" ]; then
+      git -C "$target" add -A >/dev/null 2>&1 || true
+      if git -C "$target" commit -m "nornir git-sync $STAMP" >>/dev/null 2>&1; then
+        printf 'target: committed local work %s (%s)\n' "$target" "$branch"
+      else
+        printf 'target: commit skipped (nothing staged) %s\n' "$target"
+      fi
+    fi
+    upstream=$(git -C "$target" rev-parse --abbrev-ref --symbolic-full-name '@{u}' 2>/dev/null || true)
+    if [ -n "$upstream" ]; then
+      if git -C "$target" push "$REMOTE" HEAD >>/dev/null 2>&1; then
+        printf 'target: pushed %s (%s)\n' "$target" "$branch"
+        ok=$((ok + 1))
+      else
+        printf 'target: push REJECTED (no force used) %s (%s)\n' "$target" "$branch"
+        failed=$((failed + 1))
+      fi
+    else
+      if git -C "$target" push -u "$REMOTE" HEAD >>/dev/null 2>&1; then
+        printf 'target: pushed and set upstream %s (%s)\n' "$target" "$branch"
+        ok=$((ok + 1))
+      else
+        printf 'target: push REJECTED (no force used) %s (%s)\n' "$target" "$branch"
+        failed=$((failed + 1))
+      fi
+    fi
+  fi
+done <<EOF
+$(discover_targets)
+EOF
+
+if [ "$total" = "0" ]; then
+  summary="no git targets found under $BROKK_HOME (mode=$MODE)"
+  printf 'git-sync: %s\n' "$summary"
+else
+  summary="targets=$total ok=$ok skipped=$skipped failed=$failed mode=$MODE"
+  printf 'git-sync: %s\n' "$summary"
+fi
+runes_append "yggdrasil" "git.sync" --realm "$REALM" --message "$summary" >/dev/null 2>&1 || printf 'git-sync: rune append failed (non-fatal)\n'

package/bin/nornir-job-memory-housekeeping.sh

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+# nornir-job-memory-housekeeping.sh - Muninn, the raven of memory.
+#
+# Nightly engram/memory housekeeping. Muninn (memory) remembers and prunes.
+# This job:
+#   1. reports the state of the engram/vector store (decay/compress are the
+#      engine's job; when no engine is wired it says so, it does not fake it);
+#   2. snapshots the memory trees to a compressed backup FIRST;
+#   3. only then, and only when explicitly enabled, prunes ephemeral files.
+#
+# Safety law: never destructive without a backup. If the backup cannot be
+# written, no file is removed and the failure is reported plainly.
+#
+# Environment:
+#   BROKK_HOME, BROKK_STATE_OVERRIDE
+#   BROKK_BACKUP_DIR     backup target (default $BROKK_HOME/state/backups)
+#   BROKK_MEMORY_ROOTS   colon-separated roots (defaults below)
+#   BROKK_MIMIR_DB       vector/engram db path to inspect
+#   BROKK_MEMORY_PRUNE   set 1 to enable pruning after a successful backup
+#   BROKK_MEMORY_PRUNE_DAYS  age threshold for pruning (default 7)
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="${BROKK_ROOT_OVERRIDE:-$(cd "$SCRIPT_DIR/.." && pwd)}"
+BROKK_HOME="${BROKK_HOME:-$ROOT}"
+STATE="${BROKK_STATE_OVERRIDE:-$BROKK_HOME/state}"
+DATA="${BROKK_DATA_OVERRIDE:-$BROKK_HOME/data}"
+# shellcheck source=bin/runes-append.sh
+. "$SCRIPT_DIR/runes-append.sh"
+
+REALM="${BROKK_REALM:-}"
+if [ -z "$REALM" ] && [ -r "$DATA/realm.md" ]; then
+  REALM=$(head -n 1 "$DATA/realm.md" 2>/dev/null | tr -d '[:space:]')
+fi
+REALM="${REALM:-}"
+# Never assume the company's slug: resolve the operator's realm neutrally.
+if [ -z "$REALM" ]; then . "$SCRIPT_DIR/realm-lib.sh"; ymir_active_realm "$ROOT" REALM; fi
+
+BACKUP_DIR="${BROKK_BACKUP_DIR:-$STATE/backups}"
+if [ -n "${BROKK_MEMORY_ROOTS:-}" ]; then
+  ROOTS="$BROKK_MEMORY_ROOTS"
+else
+  ROOTS="$BROKK_HOME/.agents/memory:${YMIR_HOME:-$HOME/Documents/Ymir}/hodd/memory:${YMIR_HOME:-$HOME/Documents/Ymir}/svartalfaheim/$REALM/workspace/memory"
+fi
+MIMIR_DB="${BROKK_MIMIR_DB:-$BROKK_HOME/.agents/memory/mimirsbrunn.db}"
+PRUNE_DAYS="${BROKK_MEMORY_PRUNE_DAYS:-7}"
+TODAY=$(date +%Y-%m-%d)
+STAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+printf 'MUNINN HOUSEKEEPING - %s\n' "$STAMP"
+
+# ---- 1. Engram / vector store state --------------------------------------
+if [ -r "$MIMIR_DB" ]; then
+  size=$(stat -c '%s' "$MIMIR_DB" 2>/dev/null || printf 0)
+  mtime=$(stat -c '%y' "$MIMIR_DB" 2>/dev/null | cut -d'.' -f1)
+  printf 'engram: present db=%s size=%sB mtime=%s\n' "$MIMIR_DB" "$size" "$mtime"
+  printf 'engram: decay skipped (no vector engine wired); compress handled by engine, not this job\n'
+else
+  printf 'engram: ABSENT (%s) — decay/compress skipped, nothing to age\n' "$MIMIR_DB"
+fi
+
+# ---- 2. Backup (required before any prune) -------------------------------
+backup_ok=0
+backup_file=""
+if ! mkdir -p "$BACKUP_DIR" 2>/dev/null; then
+  printf 'backup: FAILED — cannot create backup target %s; no pruning performed\n' "$BACKUP_DIR"
+else
+  existing=""
+  IFS=':' read -r -a roots_arr <<<"$ROOTS"
+  for r in "${roots_arr[@]}"; do
+    [ -n "$r" ] || continue
+    case "$r" in
+      "$BROKK_HOME"/*) rel=${r#"$BROKK_HOME"/}; [ -e "$BROKK_HOME/$rel" ] && existing="$existing $rel" ;;
+      *) [ -e "$r" ] && existing="$existing $r" ;;
+    esac
+  done
+  if [ -z "$existing" ]; then
+    printf 'backup: no memory roots exist yet (%s) — nothing to snapshot\n' "$ROOTS"
+  else
+    backup_file="$BACKUP_DIR/memory-$TODAY.tar.gz"
+    tmp_backup="$backup_file.tmp.$$"
+    # Archive relative paths so a restore is home-relative.
+    if tar -czf "$tmp_backup" -C "$BROKK_HOME" $existing 2>/dev/null; then
+      mv "$tmp_backup" "$backup_file"
+      backup_ok=1
+      printf 'backup: wrote %s (%s bytes) from:%s\n' "$backup_file" "$(wc -c <"$backup_file" | tr -d '[:space:]')" "$existing"
+    else
+      rm -f "$tmp_backup"
+      printf 'backup: FAILED to archive memory roots; no pruning performed\n'
+    fi
+  fi
+fi
+
+# ---- 3. Prune (opt-in, backup-gated, never runes/masterplan) -------------
+pruned=0
+if [ "${BROKK_MEMORY_PRUNE:-0}" = "1" ]; then
+  if [ "$backup_ok" != "1" ]; then
+    printf 'prune: skipped — backup did not succeed\n'
+  else
+    while IFS= read -r f; do
+      [ -n "$f" ] || continue
+      rm -f "$f" && { pruned=$((pruned + 1)); printf 'prune: removed %s\n' "$f"; }
+    done <<EOF
+$(find "$STATE" -maxdepth 1 \( -name '*.tmp' -o -name '*.tmp.*' -o -name '.brief-*.tmp*' \) -mtime +"$PRUNE_DAYS" 2>/dev/null)
+EOF
+    printf 'prune: removed %s ephemeral file(s) older than %s days\n' "$pruned" "$PRUNE_DAYS"
+  fi
+else
+  printf 'prune: disabled (set BROKK_MEMORY_PRUNE=1 to enable), backup retained\n'
+fi
+
+summary="engram=$([ -r "$MIMIR_DB" ] && printf present || printf absent) backup=$([ "$backup_ok" = "1" ] && printf "$backup_file" || printf failed) pruned=$pruned"
+printf 'muninn: %s\n' "$summary"
+runes_append "muninn" "memory.housekeeping" --realm "$REALM" --message "$summary" >/dev/null 2>&1 || printf 'muninn: rune append failed (non-fatal)\n'

package/bin/nornir-job-observer.sh

@@ -0,0 +1,166 @@
+#!/usr/bin/env bash
+# nornir-job-observer.sh - Huginn, the raven of observation.
+#
+# Read-only observation of the Ymir runtime into Runes. This job touches nothing
+# outside Ymir; every source below lives inside the repo (or the external worktree
+# root, which is read-only):
+#   docs/masterplan.md               open forge orders
+#   .agents/agents/*.md              the agent roster
+#   .agents/memory/well/             the well (episodes)
+#   workspace/memory/runes_audit.md  the ledger
+#   apps/smidja/smidja_data/smidja.db     Smíðja runs (read-only SQLite URI)
+#   ~/.treehouse                     external worktrees (read-only)
+#
+# CONTRACT: this job NEVER writes anywhere but state/observer.log and the Runes
+# ledger. It only reads manifests, SQLite databases in read-only mode, and small
+# state files. Every observation is carved as a Runes line and echoed to
+# state/observer.log. When a source is absent the job still carves an ABSENT
+# line — silence is never mistaken for health.
+#
+# Environment:
+#   BROKK_YGGDRASIL_ROOT  external worktree root to observe (default ~/.treehouse)
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="${BROKK_ROOT_OVERRIDE:-$(cd "$SCRIPT_DIR/.." && pwd)}"
+BROKK_HOME="${BROKK_HOME:-$ROOT}"
+STATE="${BROKK_STATE_OVERRIDE:-$BROKK_HOME/state}"
+# shellcheck source=bin/runes-append.sh
+. "$SCRIPT_DIR/runes-append.sh"
+
+WORKTREE_ROOT="${BROKK_YGGDRASIL_ROOT:-$HOME/.treehouse}"
+YMIR_HOME="${YMIR_HOME:-$HOME/Documents/Ymir}"
+SMIDJA_DB="${YMIR_HOME:+$YMIR_HOME/smidja/smidja.db}"
+[ -z "${SMIDJA_DB:-}" ] || [ ! -f "$SMIDJA_DB" ] && SMIDJA_DB="$ROOT/apps/smidja/smidja_data/smidja.db"
+MASTERPLAN="$ROOT/docs/masterplan.md"
+WELL_DIR="$ROOT/.agents/memory/well"
+AGENTS_DIR="$ROOT/.agents/agents"
+RUNES_LEDGER="${YMIR_HOME:+$YMIR_HOME/memory/runes_audit.md}"
+[ -z "${RUNES_LEDGER:-}" ] || [ ! -r "$RUNES_LEDGER" ] && RUNES_LEDGER="$ROOT/workspace/memory/runes_audit.md"
+OBS_LOG="$STATE/observer.log"
+OBS_LAST="$STATE/observer.last"
+
+mkdir -p "$STATE"
+LOG_TS=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+observe() {  # <source> <message>
+  local source=$1 message=$2
+  printf '%s observer %s: %s\n' "$LOG_TS" "$source" "$message" >>"$OBS_LOG"
+  runes_append "huginn" "observer.$source" --message "$message" >/dev/null 2>&1 || true
+}
+
+printf 'OBSERVER - %s\n' "$LOG_TS"
+printf 'root=%s worktrees=%s\n' "$ROOT" "$WORKTREE_ROOT"
+
+# ---- ymir: forge orders (masterplan) -------------------------------------
+if [ -r "$MASTERPLAN" ]; then
+  open=$(grep -cE '^- Status: ADDED' "$MASTERPLAN" 2>/dev/null | tr -d '[:space:]')
+  working=$(grep -cE '^- Status:.*WORKING' "$MASTERPLAN" 2>/dev/null | tr -d '[:space:]')
+  done=$(grep -cE '\. \+ <[0-9]{4}' "$MASTERPLAN" 2>/dev/null | tr -d '[:space:]')
+  msg="masterplan readable; open=${open:-0} working=${working:-0} completed_notes=${done:-0}"
+  printf 'ymir.orders open=%s working=%s\n' "${open:-0}" "${working:-0}"
+else
+  msg="masterplan ABSENT at $MASTERPLAN"
+  printf 'ymir.orders ABSENT\n'
+fi
+observe "ymir.orders" "$msg"
+
+# ---- ymir: agent roster ---------------------------------------------------
+if [ -d "$AGENTS_DIR" ]; then
+  n=$(find "$AGENTS_DIR" -maxdepth 1 -name '*.md' 2>/dev/null | wc -l | tr -d '[:space:]')
+  msg="agent roster readable; agents=${n:-0}"
+  printf 'ymir.agents count=%s\n' "${n:-0}"
+else
+  msg="agent roster ABSENT at $AGENTS_DIR"
+  printf 'ymir.agents ABSENT\n'
+fi
+observe "ymir.agents" "$msg"
+
+# ---- ymir: the well (episodes) -------------------------------------------
+if [ -d "$WELL_DIR" ]; then
+  episodes=0
+  for f in "$WELL_DIR"/*.jsonl; do
+    [ -r "$f" ] || continue
+    c=$(wc -l <"$f" 2>/dev/null | tr -d '[:space:]')
+    episodes=$((episodes + ${c:-0}))
+  done
+  msg="well readable; episodes=${episodes}"
+  printf 'ymir.well episodes=%s\n' "$episodes"
+else
+  msg="well ABSENT at $WELL_DIR"
+  printf 'ymir.well ABSENT\n'
+fi
+observe "ymir.well" "$msg"
+
+# ---- ymir: the ledger -----------------------------------------------------
+if [ -r "$RUNES_LEDGER" ]; then
+  lines=$(wc -l <"$RUNES_LEDGER" 2>/dev/null | tr -d '[:space:]')
+  msg="runes ledger readable; lines=${lines:-0}"
+  printf 'ymir.runes lines=%s\n' "${lines:-0}"
+else
+  msg="runes ledger ABSENT at $RUNES_LEDGER"
+  printf 'ymir.runes ABSENT\n'
+fi
+observe "ymir.runes" "$msg"
+
+# ---- smidja: runs (smidja.db, read-only) ---------------------------------
+if [ -r "$SMIDJA_DB" ] && command -v python3 >/dev/null 2>&1; then
+  smidja_summary=$(python3 - "$SMIDJA_DB" 2>/dev/null <<'PY'
+import sqlite3, sys
+db = sys.argv[1]
+try:
+    c = sqlite3.connect('file:' + db + '?mode=ro', uri=True, timeout=3)
+except Exception as e:
+    print("open_failed=%s" % e)
+    sys.exit(0)
+def q(sql, default=None):
+    try:
+        return c.execute(sql).fetchone()[0]
+    except Exception:
+        return default
+sessions = q("select count(*) from sessions", 0)
+phases = q("select count(*) from phases", 0)
+gates = q("select count(*) from gate_results", 0)
+gate_fail = q("select count(*) from gate_results where passed=0", 0)
+print("sessions=%s phases=%s gates=%s gate_fail=%s" % (sessions, phases, gates, gate_fail))
+try:
+    rows = c.execute("select smidja_id,status from sessions order by rowid desc limit 3").fetchall()
+    print("recent=" + ",".join("%s:%s" % (r[0], r[1]) for r in rows))
+except Exception as e:
+    print("recent=unavailable(%s)" % e)
+try:
+    rows = c.execute("select status,count(*) from phases group by status order by 2 desc limit 5").fetchall()
+    print("phase_status=" + ",".join("%s:%s" % (r[0], r[1]) for r in rows))
+except Exception as e:
+    print("phase_status=unavailable(%s)" % e)
+c.close()
+PY
+)
+  first_line=$(printf '%s' "$smidja_summary" | head -n 1)
+  msg="smidja.db read-only: ${first_line:-unreadable}"
+  printf 'smidja.runs %s\n' "$msg"
+  printf '%s\n' "$smidja_summary" | tail -n +2 | sed 's/^/  /'
+else
+  if [ ! -r "$SMIDJA_DB" ]; then
+    msg="smidja.db ABSENT at $SMIDJA_DB"
+  else
+    msg="smidja.db present but python3 unavailable for read-only query"
+  fi
+  printf 'smidja.runs ABSENT/UNREADABLE\n'
+fi
+observe "smidja.runs" "$msg"
+
+# ---- worktrees (external, read-only) -------------------------------------
+if [ -d "$WORKTREE_ROOT" ]; then
+  wt_count=$(find "$WORKTREE_ROOT" -mindepth 1 -maxdepth 1 -type d 2>/dev/null | wc -l | tr -d '[:space:]')
+  state_files=$(find "$WORKTREE_ROOT" -mindepth 2 -maxdepth 2 -name 'treehouse-state.json' 2>/dev/null | wc -l | tr -d '[:space:]')
+  msg="worktrees=${wt_count:-0} state_files=${state_files:-0}"
+  printf 'yggdrasil.worktrees trees=%s state_files=%s\n' "${wt_count:-0}" "${state_files:-0}"
+else
+  msg="worktree root ABSENT at $WORKTREE_ROOT"
+  printf 'yggdrasil.worktrees ABSENT\n'
+fi
+observe "yggdrasil.worktrees" "$msg"
+
+printf '%s\n' "observer summary written: $LOG_TS" >"$OBS_LAST"
+printf 'observer: observations carved (log=%s)\n' "$OBS_LOG"

package/bin/nornir-job-skillopt-sleep.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# nornir-job-skillopt-sleep.sh — SkillOpt overnight self-evolution.
+#
+# Runs SkillOpt-Sleep against Ymir's registered skills and Smíðja
+# prompt files. Harvests today's session trajectories, mines recurring
+# patterns, replays them, and consolidates validated skill edits behind
+# a held-out validation gate.
+#
+# OUTPUT: stages best_skill.md artifacts under .agents/skills/*/staging/
+#         — never auto-applies. Allfather reviews before merge.
+#
+# Environment:
+#   BROKK_HOME, BROKK_STATE_OVERRIDE
+#   SKILLOPT_PATH  path to the skillopt venv bin (default .venv/bin)
+#   SKILLOPT_SLEEP_OPTS  extra args to skillopt-sleep run
+#
+# Safety: writes only to staging dirs and Runes. Never touches
+# .agents/skills/*/SKILL.md directly. The Allfather approves adopted
+# skills before they go live.
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="${BROKK_ROOT_OVERRIDE:-$(cd "$SCRIPT_DIR/.." && pwd)}"
+BROKK_HOME="${BROKK_HOME:-$ROOT}"
+STATE="${BROKK_STATE_OVERRIDE:-$BROKK_HOME/state}"
+SKILLOPT_PATH="${SKILLOPT_PATH:-$BROKK_HOME/.venv/bin}"
+SLEEP_OPTS="${SKILLOPT_SLEEP_OPTS:-}"
+
+# shellcheck source=bin/runes-append.sh
+. "$SCRIPT_DIR/runes-append.sh"
+
+STAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+STAGING="$BROKK_HOME/.agents/skills/skillopt-staging"
+
+mkdir -p "$STATE" "$STAGING" 2>/dev/null || true
+
+printf 'SKILLOPT-SLEEP - %s\n' "$STAMP"
+
+# ---- 1. Pre-flight ----------------------------------------------------
+if [ ! -x "$SKILLOPT_PATH/skillopt-sleep" ]; then
+  msg="skillopt-sleep not found at $SKILLOPT_PATH/skillopt-sleep — run bin/skillopt-setup.sh first"
+  printf 'skillopt: %s\n' "$msg"
+  runes_append "skillopt" "sleep.skipped" --message "$msg" >/dev/null 2>&1 || true
+  exit 0
+fi
+
+# ---- 2. Run SkillOpt-Sleep -------------------------------------------
+# Harvests sessions from ~/.claude and ~/.codex (if present),
+# mines recurring tasks, replays them, and stages best_skill.md.
+# --dry-run: report only. --auto-adopt: never set (human-in-the-loop).
+if [ -d "$BROKK_HOME/.claude" ] || [ -d "$BROKK_HOME/.codex" ]; then
+  "$SKILLOPT_PATH/skillopt-sleep" run \
+    --project "$BROKK_HOME" \
+    --scope all \
+    --source auto \
+    --lookback-hours 24 \
+    --max-sessions 50 \
+    --max-tasks 20 \
+    --target-skill-path "$STAGING/best_skill.md" \
+    --progress \
+    $SLEEP_OPTS 2>&1 | tee "$STATE/skillopt-sleep-$STAMP.log" || true
+else
+  msg="no Claude/Codex session dirs found at $BROKK_HOME — SkillOpt-Sleep needs agent transcripts"
+  printf 'skillopt: %s\n' "$msg"
+  runes_append "skillopt" "sleep.skipped" --message "$msg" >/dev/null 2>&1 || true
+fi
+
+# ---- 3. Stage report --------------------------------------------------
+if [ -f "$STAGING/best_skill.md" ]; then
+  size=$(wc -c <"$STAGING/best_skill.md" | tr -d '[:space:]')
+  msg="staged best_skill.md (${size} bytes) — review before adopt"
+else
+  msg="no new proposals this cycle"
+fi
+printf 'skillopt: %s\n' "$msg"
+runes_append "skillopt" "sleep.completed" --message "$msg" >/dev/null 2>&1 || true

package/bin/omarchy-hook-install.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# omarchy-hook-install.sh — let Ymir notice when Omarchy updates.
+#
+# Omarchy runs `~/.config/omarchy/hooks/post-update.d/*` after `omarchy update`
+# applies packages and migrations. Installing our sensor there means Ymir learns
+# the machine again the moment Omarchy moves — no polling, no cron.
+#
+# This writes only into ~/.config/omarchy/hooks/ (user config, per the Omarchy
+# skill: never /usr/share/omarchy/).
+#
+# Usage:
+#   bin/omarchy-hook-install.sh install|status|remove
+#   bin/omarchy-hook-install.sh --version
+set -u
+
+VERSION="1.0.0"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+HOOK_DIR="$HOME/.config/omarchy/hooks/post-update.d"
+HOOK="$HOOK_DIR/ymir-omarchy-sense.sh"
+
+is_omarchy() { [ -d /usr/share/omarchy ]; }
+have() { command -v "$1" >/dev/null 2>&1; }
+
+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
+
+ACTION="${1:-status}"
+
+case "$ACTION" in
+  status)
+    if [ -f "$HOOK" ]; then
+      printf 'omarchy-hook[1]{hook,state}:\n  "%s","installed"\n' "$HOOK"
+    else
+      printf 'omarchy-hook[1]{hook,state}:\n  "%s","absent"\n' "$HOOK"
+    fi
+    ;;
+  install)
+    if ! is_omarchy; then
+      printf 'omarchy-hook[1]{state,detail}:\n  "skipped","not an Omarchy host (/usr/share/omarchy absent)"\n'
+      exit 0
+    fi
+    mkdir -p "$HOOK_DIR"
+    cat >"$HOOK" <<EOF
+#!/usr/bin/env bash
+# Installed by Ymir (bin/omarchy-hook-install.sh). Re-learns the machine after
+# an Omarchy update so the agent stays current with this user's setup.
+exec "$ROOT/bin/omarchy-sense.sh" observe --quiet
+EOF
+    chmod +x "$HOOK"
+    printf 'omarchy-hook[1]{hook,state}:\n  "%s","installed"\n' "$HOOK"
+    ;;
+  remove)
+    rm -f "$HOOK"
+    printf 'omarchy-hook[1]{hook,state}:\n  "%s","removed"\n' "$HOOK"
+    ;;
+  *) printf 'error: unknown action %s\nhelp: bin/omarchy-hook-install.sh [install|status|remove]\n' "$ACTION" >&2; exit 2 ;;
+esac