create-egregore 0.19.32 → 0.20.0

package/runtime/prime/bin/search.sh

@@ -0,0 +1,240 @@
+#!/usr/bin/env bash
+# Hybrid search over shared memory — powered by qmd (BM25 + vector + rerank, fully local).
+# Usage:
+#   bash bin/search.sh query "text" [-n N] [--fast|--semantic] [--all]
+#   bash bin/search.sh reindex [--embed]
+#   bash bin/search.sh status
+#
+# The memory repo is registered as a qmd collection named "{slug}-memory".
+# Every call is scoped to that collection with -c, so other qmd collections
+# on the machine are never read or modified.
+#
+# Modes:
+#   (default)   qmd query   — hybrid BM25 + vector + rerank (needs local models, ~2GB one-time download)
+#   --fast      qmd search  — BM25 keyword only, instant, no models
+#   --semantic  qmd vsearch — vector similarity only (needs embeddings: reindex --embed)
+# Hybrid/semantic fall back to BM25 automatically if models or embeddings are missing.
+
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+export NODE_NO_WARNINGS=1
+# Do NOT set CI=1 here — it disables qmd's LLM ops (query expansion, rerank).
+
+# qmd's progress spinner can leak into stdout when it misdetects a TTY;
+# strip ANSI escapes and spinner frames from anything we return.
+_clean() {
+  sed -E $'s/\x1b\\[[0-9;?]*[A-Za-z]//g' | grep -v 'Gathering information' || true
+}
+
+SLUG=$(jq -r '.slug // "egregore"' "$SCRIPT_DIR/egregore.json" 2>/dev/null || echo "egregore")
+COLLECTION="${SLUG}-memory"
+MEM_PATH="$(readlink -f "$SCRIPT_DIR/memory" 2>/dev/null || true)"
+
+QMD_VERSION="2.5.3"  # pinned — bump deliberately, never float @latest
+
+_qmd() {
+  if command -v qmd >/dev/null 2>&1; then
+    qmd "$@"
+  else
+    npx -y "@tobilu/qmd@${QMD_VERSION}" "$@"
+  fi
+}
+
+# --- Weight ladder ----------------------------------------------------------
+# Three tiers, chosen by what is already on disk — no mode ever triggers a
+# model download in a session's critical path:
+#   keyword   0 MB    BM25, works at install, forever
+#   semantic  ~334 MB embed model, fetched silently by the background warm
+#   hybrid    ~2.2 GB rerank + expansion — org opt-in (features.search_hybrid),
+#                     prefetched by the background warm, never inline
+MODELS_DIR="${XDG_CACHE_HOME:-$HOME/.cache}/qmd/models"
+_have_embed()  { ls "$MODELS_DIR"/*embedding* >/dev/null 2>&1; }
+_have_hybrid() { ls "$MODELS_DIR"/*reranker* >/dev/null 2>&1 && ls "$MODELS_DIR"/*expansion* >/dev/null 2>&1; }
+_hybrid_opted() { [ "$(jq -r '.features.search_hybrid // false' "$SCRIPT_DIR/egregore.json" 2>/dev/null)" = "true" ]; }
+
+_ensure() {
+  if [ -z "$MEM_PATH" ] || [ ! -d "$MEM_PATH" ]; then
+    echo "memory/ not found — run bin/search.sh from an Egregore instance with a memory symlink" >&2
+    exit 1
+  fi
+  if ! _qmd collection list 2>/dev/null | grep -q "^${COLLECTION} "; then
+    _qmd collection add "$MEM_PATH" --name "$COLLECTION" >/dev/null 2>&1 || true
+  fi
+  # Incremental re-index so new handoffs/decisions are searchable immediately.
+  # NEVER swallow a failure silently: a dead path in ANY registered collection
+  # (e.g. a deleted side-project dir) crashes `qmd update` for every collection,
+  # and the index quietly stops absorbing new documents. Caught in dogfooding
+  # 2026-07-07 — results looked fine while missing three days of handoffs.
+  if ! _qmd update >/dev/null 2>&1; then
+    echo "(search: index update FAILED — results may be missing recent documents. A registered qmd collection likely points at a deleted path: run 'qmd collection list', remove the dead one, retry.)" >&2
+  fi
+  _embed_bg
+}
+
+# Keep vector embeddings warm without anyone running a manual step: fire a
+# detached, lock-guarded `qmd embed` on every query. Nothing pending → exits
+# in ~1s. First run on a machine → downloads models + embeds in the
+# background while queries fall back to keyword mode.
+_embed_bg() {
+  [ "${EGREGORE_SEARCH_NO_WARM:-0}" = "1" ] && return 0
+  local lock="${TMPDIR:-/tmp}/egregore-qmd-embed-${COLLECTION}.lock"
+  if [ -f "$lock" ]; then
+    # A crashed embed shouldn't block warming forever — expire the lock after 60 min.
+    if [ -n "$(find "$lock" -mmin +60 2>/dev/null)" ]; then rm -f "$lock"; else return 0; fi
+  fi
+  touch "$lock"
+  if ! _have_embed; then
+    echo "(first run: building the semantic index in the background — searches use keyword mode until it finishes)" >&2
+  fi
+  # Background fetch policy: `qmd embed` pulls only the ~334MB embed model
+  # (the semantic tier). The ~1.9GB hybrid pack is prefetched here ONLY when
+  # the org opted in — a session never waits on either.
+  ( ( _qmd embed >/dev/null 2>&1
+      if _hybrid_opted && ! _have_hybrid; then
+        _qmd query "warmup" -c "$COLLECTION" -n 1 >/dev/null 2>&1
+      fi
+      rm -f "$lock" ) & ) >/dev/null 2>&1
+}
+
+# Annotate results with live graph state (connected mode): each hit that the
+# graph knows (Session by filePath = handoffs; Artifact by filePath = knowledge)
+# gets one "↳ graph:" line — search finds the artifact, the graph tells you its
+# state, in a single call. Fails soft everywhere: local mode / graph offline /
+# unknown paths simply produce no annotations.
+_enrich() {
+  local results paths params out
+  results=$(cat)
+  echo "$results"
+  paths=$(echo "$results" | grep -o "qmd://${COLLECTION}/[^: ]*\.md" | sed "s|qmd://${COLLECTION}/||" | sort -u)
+  [ -z "$paths" ] && return 0
+  params=$(printf '%s\n' "$paths" | jq -R . | jq -sc '{paths: .}')
+  out=$(bash "$SCRIPT_DIR/bin/graph.sh" query "UNWIND \$paths AS fp
+    OPTIONAL MATCH (s:Session {filePath: fp})
+    OPTIONAL MATCH (a:Artifact {filePath: fp})
+    WITH fp, s, a WHERE s IS NOT NULL OR a IS NOT NULL
+    RETURN fp,
+      CASE WHEN s IS NOT NULL THEN coalesce(s.handoffStatus, s.status) ELSE null END AS sessionStatus,
+      s.handedTo AS handedTo, a.type AS artifactType,
+      CASE WHEN a IS NOT NULL THEN [q IN [(a)-[:PART_OF]->(qq:Quest) | qq.id] | q][0] ELSE null END AS quest" \
+    "$params" 2>/dev/null)
+  echo "$out" | jq -r '.values[]? | @tsv' 2>/dev/null | while IFS=$'\t' read -r fp sstat sto atype quest; do
+    local ann=""
+    [ -n "$sstat" ] && [ "$sstat" != "null" ] && ann="status: $sstat"
+    [ -n "$sto" ] && [ "$sto" != "null" ] && ann="$ann${ann:+ · }to: $sto"
+    [ -n "$atype" ] && [ "$atype" != "null" ] && ann="$ann${ann:+ · }artifact: $atype"
+    [ -n "$quest" ] && [ "$quest" != "null" ] && ann="$ann${ann:+ · }quest: $quest"
+    [ -n "$ann" ] && echo "↳ graph · $fp — $ann"
+  done
+}
+
+cmd_query() {
+  local mode="query" n=6 enrich=auto all=()
+  local -a words=()
+  while [ $# -gt 0 ]; do
+    case "$1" in
+      --fast) mode="search" ;;
+      --semantic) mode="vsearch" ;;
+      --enrich) enrich=1 ;;
+      --no-enrich) enrich=0 ;;
+      --all) all=(--all) ;;
+      -n) n="$2"; shift ;;
+      *) words+=("$1") ;;
+    esac
+    shift
+  done
+  # Default mode rides the weight ladder: use the heaviest tier whose models
+  # are already local. Explicit flags always win; nothing downloads inline.
+  if [ "$mode" = "query" ] && ! _have_hybrid; then
+    if _have_embed; then mode="vsearch"; else mode="search"; fi
+  fi
+  # Enrichment is managed, not a user choice: on wherever a graph exists
+  # (connected mode), silently off everywhere else. Flags only override.
+  if [ "$enrich" = "auto" ]; then
+    if [ "$(jq -r '.mode // "connected"' "$SCRIPT_DIR/egregore.json" 2>/dev/null)" != "local" ] && \
+       [ -n "$(jq -r '.api_url // empty' "$SCRIPT_DIR/egregore.json" 2>/dev/null)" ]; then
+      enrich=1
+    else
+      enrich=0
+    fi
+  fi
+  local q="${words[*]}"
+  if [ -z "$q" ]; then
+    echo "usage: bash bin/search.sh query \"text\" [-n N] [--fast|--semantic] [--all]" >&2
+    exit 1
+  fi
+  _ensure
+  local emit="cat"
+  [ "$enrich" = 1 ] && emit="_enrich"
+  local t0 out label
+  t0=$(date +%s)
+  if [ "$mode" != "search" ]; then
+    out=$(_qmd "$mode" "$q" -c "$COLLECTION" -n "$n" --format md --full-path "${all[@]}" 2>/dev/null | _clean)
+    if [ -n "$out" ] && [ "$out" != "No results found." ]; then
+      [ "$mode" = "query" ] && label="hybrid" || label="semantic"
+      _banner_and_emit "$label" "$t0" "$emit" "$q" "$out"
+      return 0
+    fi
+    echo "_(hybrid/semantic returned nothing — showing keyword results. If this persists, run: bash bin/search.sh reindex --embed)_"
+    echo ""
+  fi
+  out=$(_qmd search "$q" -c "$COLLECTION" -n "$n" --format md --full-path "${all[@]}" | _clean)
+  _banner_and_emit "keyword" "$t0" "$emit" "$q" "$out"
+}
+
+# One visible product-attribution line per search — the tell that Egregore's
+# organizational retrieval layer (not an improvised agent grep loop) answered.
+# It names the graph only when enrichment actually ran, then reports mode,
+# hit count, and latency. Colored when stdout is a terminal; plain glyph in
+# harness transcripts. Also appends to ~/.egregore/search.log (local only,
+# never uploaded) so dogfooding can measure search-first rate and latency.
+_banner_and_emit() {
+  local label="$1" t0="$2" emit="$3" q="$4" out="$5"
+  local hits dur modef product surface plural=""
+  hits=$(printf '%s\n' "$out" | grep -c '^qmd://' 2>/dev/null | tr -d ' ')
+  dur=$(( $(date +%s) - t0 ))
+  modef="$label"
+  product="Egregore"
+  surface="searching your organization’s memory"
+  if [ "$emit" = "_enrich" ] && [ "$hits" -gt 0 ]; then
+    modef="${label}+graph"
+    product="Egregore Connect"
+    surface="${surface} and relationships"
+  fi
+  [ "$hits" != "1" ] && plural="s"
+  local line="⌕ ${product} · ${surface} · ${label} · ${hits} hit${plural} · ${dur}s"
+  if [ -t 1 ]; then
+    printf '\033[1;38;5;30m%s\033[0m\n\n' "$line"
+  else
+    printf '%s\n\n' "$line"
+  fi
+  printf '%s\n' "$out" | $emit
+  mkdir -p "$HOME/.egregore" 2>/dev/null
+  echo "$(date '+%Y-%m-%d %H:%M:%S') mode=${modef} hits=${hits} dur=${dur}s q=\"$(printf '%.80s' "$q")\"" >> "$HOME/.egregore/search.log" 2>/dev/null || true
+}
+
+cmd_reindex() {
+  _ensure
+  _qmd update
+  if [ "${1:-}" = "--embed" ]; then
+    _qmd embed
+    # Hybrid pack prefetch only when the org opted in (features.search_hybrid).
+    if _hybrid_opted && ! _have_hybrid; then
+      _qmd query "warmup" -c "$COLLECTION" -n 1 >/dev/null 2>&1 || true
+    fi
+  fi
+}
+
+cmd_status() {
+  _qmd status 2>/dev/null
+  echo ""
+  echo "collection: $COLLECTION → $MEM_PATH"
+}
+
+case "${1:-}" in
+  query)   shift; cmd_query "$@" ;;
+  reindex) shift; cmd_reindex "$@" ;;
+  status)  shift; cmd_status ;;
+  *)
+    echo "usage: bash bin/search.sh {query|reindex|status}" >&2
+    exit 1
+    ;;
+esac

package/runtime/prime/bin/session-autosave.sh

@@ -0,0 +1,209 @@
+#!/usr/bin/env bash
+# session-autosave.sh — save non-coding session work without an explicit /save.
+#
+# Terminal-close is the design constraint: no single "session end" event is
+# reliable (people just close the window), so durability comes from three
+# overlapping triggers:
+#   - Stop hook, debounced (Claude Code): saves DURING the session, after a
+#     turn completes — a killed terminal loses at most the debounce window.
+#   - Session-start sweep (--sweep, all runtimes): the next launch on this
+#     machine rescues leftovers in the main checkout and lingering worktrees.
+#   - SessionEnd hook / agent.sh wrap (Codex, Pi): immediate save on clean exit.
+#
+# Gate: acts ONLY when every pending change — uncommitted files AND commits
+# ahead of origin/develop — is non-coding per bin/lib/noncode.sh. Any code in
+# the pending set → exit silently; code always goes through explicit /save and
+# review. Never auto-commits half-finished code.
+#
+# When the gate passes, delegates commit→push→PR→auto-merge to
+# handoff-save-egregore.sh (--kind autosave), and pushes the memory repo.
+#
+# Usage:
+#   session-autosave.sh [--dir <repo-dir>] [--author <name>]
+#                       [--debounce <sec>] [--min-idle <sec>] [--sweep]
+#   --debounce  skip if this dir was autosaved less than <sec> ago (Stop hook)
+#   --min-idle  skip if any dirty file was modified less than <sec> ago
+#               (don't commit prose someone is actively typing)
+#   --sweep     iterate main checkout + .claude/worktrees/* (session start)
+#   (Hook invocations pass nothing; stdin JSON supplies cwd.)
+
+set -uo pipefail
+
+DIR=""
+AUTHOR=""
+DEBOUNCE=0
+MIN_IDLE=0
+SWEEP=0
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --dir) DIR="${2:-}"; shift 2 ;;
+    --author) AUTHOR="${2:-}"; shift 2 ;;
+    --debounce) DEBOUNCE="${2:-0}"; shift 2 ;;
+    --min-idle) MIN_IDLE="${2:-0}"; shift 2 ;;
+    --sweep) SWEEP=1; shift ;;
+    *) shift ;;
+  esac
+done
+
+SCRIPT_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+
+# --- Sweep mode: rescue abandoned checkouts, then exit -------------------
+if [ "$SWEEP" = "1" ]; then
+  # Let session-start's own git syncs settle before touching the checkout.
+  sleep 15
+  for d in "$SCRIPT_ROOT" "$SCRIPT_ROOT"/.claude/worktrees/*/; do
+    d="${d%/}"
+    [ -d "$d" ] || continue
+    # min-idle protects live sessions in other terminals: never commit files
+    # someone touched in the last 10 minutes. debounce dedupes concurrent
+    # session launches sweeping the same dirs.
+    bash "$0" --dir "$d" --min-idle 600 --debounce 120 >/dev/null 2>&1 || true
+  done
+  exit 0
+fi
+
+# Hook invocations deliver JSON on stdin (cwd = where the session worked).
+if [ -z "$DIR" ] && [ ! -t 0 ]; then
+  HOOK_INPUT=$(cat 2>/dev/null || true)
+  DIR=$(echo "$HOOK_INPUT" | jq -r '.cwd // empty' 2>/dev/null || true)
+fi
+
+[ -n "$DIR" ] && [ -d "$DIR" ] || DIR="$SCRIPT_ROOT"
+cd "$DIR" 2>/dev/null || exit 0
+git rev-parse --git-dir >/dev/null 2>&1 || exit 0
+
+# --- Debounce (per-dir stamp) --------------------------------------------
+# NB: `cmd | cut || fallback` doesn't work — cut succeeds on empty input, so
+# the fallback never fires and every dir collapses to one stamp (macOS has
+# md5, not md5sum). Group the hash commands, then cut.
+DIR_HASH=$( { md5sum <<<"$DIR" 2>/dev/null || md5 -q -s "$DIR" 2>/dev/null || echo default; } | cut -c1-8 )
+STAMP="/tmp/.egregore-autosave-${DIR_HASH}"
+if [ "$DEBOUNCE" -gt 0 ] && [ -f "$STAMP" ]; then
+  LAST=$(stat -f %m "$STAMP" 2>/dev/null || stat -c %Y "$STAMP" 2>/dev/null || echo 0)
+  [ $(( $(date +%s) - LAST )) -lt "$DEBOUNCE" ] && exit 0
+fi
+touch "$STAMP" 2>/dev/null || true
+
+# shellcheck source=bin/lib/noncode.sh
+. "$SCRIPT_ROOT/bin/lib/noncode.sh" 2>/dev/null || exit 0
+
+# --- Per-user consent settings (bin/autosave.sh / the /autosave skill) ----
+# enabled=false  → fully off, nothing captured ambiently
+# scope=handoffs → memory repo only; the core repo is never touched ambiently
+# publish=gate   → PR is opened but NEVER merged without the user's word
+# NB: jq's `//` swallows false (falsy) — `.k // empty` on k:false yields the
+# default, silently re-enabling autosave. Test key presence instead (this is
+# the same trap that broke auto_update:false).
+_as_conf() { # key default
+  local v
+  v=$(jq -r "if (.$1 != null) then (.$1|tostring) else empty end" "$DIR/.egregore-state.json" 2>/dev/null)
+  [ -n "$v" ] || v=$(jq -r "if (.$1 != null) then (.$1|tostring) else empty end" "$SCRIPT_ROOT/.egregore-state.json" 2>/dev/null)
+  [ -n "$v" ] && echo "$v" || echo "$2"
+}
+# Autosave is an opt-in experiment: enabled defaults to FALSE. Nothing is
+# captured ambiently until the user runs `/autosave on` (or autosave.sh on).
+AS_ENABLED=$(_as_conf autosave_enabled false)
+AS_SCOPE=$(_as_conf autosave_scope all)
+AS_PUBLISH=$(_as_conf autosave_publish gate)
+[ "$AS_ENABLED" = "true" ] || exit 0
+
+if [ -z "$AUTHOR" ]; then
+  AUTHOR=$(jq -r '.github_username // .name // empty' "$DIR/.egregore-state.json" 2>/dev/null || true)
+  [ -n "$AUTHOR" ] || AUTHOR=$(jq -r '.github_username // .name // empty' "$SCRIPT_ROOT/.egregore-state.json" 2>/dev/null || true)
+  [ -n "$AUTHOR" ] || AUTHOR=$(git config user.name 2>/dev/null | tr '[:upper:] ' '[:lower:]-' || true)
+  [ -n "$AUTHOR" ] || AUTHOR="egregore"
+fi
+
+# --- Memory repo: markdown by definition, push straight to main ----------
+if git -C "$DIR/memory" rev-parse --git-dir >/dev/null 2>&1; then
+  if [ -n "$(git -C "$DIR/memory" status --porcelain 2>/dev/null)" ]; then
+    git -C "$DIR/memory" add -A >/dev/null 2>&1 || true
+    git -C "$DIR/memory" commit -m "Auto-save: session content" --quiet 2>/dev/null || true
+  fi
+  if [ -n "$(git -C "$DIR/memory" log origin/main..HEAD --oneline 2>/dev/null)" ]; then
+    for _try in 1 2 3; do
+      if git -C "$DIR/memory" pull --rebase origin main --quiet 2>/dev/null \
+         && git -C "$DIR/memory" push origin main --quiet 2>/dev/null; then
+        break
+      fi
+      sleep 1
+    done
+  fi
+fi
+
+# scope=handoffs: memory (above) is the handoff channel; stop before the
+# core repo — it is never captured ambiently under this scope.
+[ "$AS_SCOPE" = "handoffs" ] && exit 0
+
+# --- Core repo gate: everything pending must be non-coding ---------------
+# -uall expands untracked dirs to individual files: a collapsed "docs/" entry
+# would defeat both the classifier (code nested under a content dir) and the
+# idle guard (directory mtime, not file mtime).
+DIRTY_PATHS=$(git status --porcelain -uall 2>/dev/null | cut -c4- | sed 's/.* -> //' | sed '/^$/d')
+PENDING=$(
+  {
+    printf '%s\n' "$DIRTY_PATHS"
+    git diff origin/develop...HEAD --name-only 2>/dev/null
+  } | sed '/^$/d'
+)
+[ -n "$PENDING" ] || exit 0
+
+BLOCKER=$(printf '%s\n' "$PENDING" | noncode_filter)
+if [ -n "$BLOCKER" ]; then
+  # Code in the pending set — leave it for an explicit /save + review.
+  exit 0
+fi
+
+# --- Idle guard: don't commit files someone is actively editing ----------
+if [ "$MIN_IDLE" -gt 0 ] && [ -n "$DIRTY_PATHS" ]; then
+  NOW=$(date +%s)
+  while IFS= read -r f; do
+    [ -e "$f" ] || continue
+    M=$(stat -f %m "$f" 2>/dev/null || stat -c %Y "$f" 2>/dev/null || echo 0)
+    [ $(( NOW - M )) -lt "$MIN_IDLE" ] && exit 0
+  done <<< "$DIRTY_PATHS"
+fi
+
+ORIG_BRANCH=$(git branch --show-current 2>/dev/null || echo "")
+
+bash "$SCRIPT_ROOT/bin/handoff-save-egregore.sh" "$AUTHOR" \
+  "session content $(date +%Y-%m-%d)" --kind autosave --repo-dir "$DIR" \
+  --branch-suffix "$DIR_HASH" --publish "$AS_PUBLISH" \
+  >/dev/null 2>&1 || true
+
+# Tell the user what just happened. Under the Stop hook this line surfaces in
+# the Claude Code UI; sweep/SessionEnd invocations discard stdout (their trail
+# is the ledger, reported by the next greeting).
+LEDGER="${EGREGORE_AUTOSAVE_LOG:-$HOME/.egregore/autosave.log}"
+LAST=$(grep -F "|autosave|$DIR|" "$LEDGER" 2>/dev/null | tail -1 || true)
+if [ -n "$LAST" ]; then
+  TS=$(echo "$LAST" | cut -d'|' -f1)
+  PR=$(echo "$LAST" | cut -d'|' -f5)
+  RESULT=$(echo "$LAST" | cut -d'|' -f6)
+  NF=$(echo "$LAST" | cut -d'|' -f7)
+  NOW_EPOCH=$(date +%s)
+  TS_EPOCH=$(date -u -j -f %Y-%m-%dT%H:%M:%SZ "$TS" +%s 2>/dev/null || date -u -d "$TS" +%s 2>/dev/null || echo 0)
+  if [ $(( NOW_EPOCH - TS_EPOCH )) -lt 120 ]; then
+    case "$RESULT" in
+      merged) echo "⟲ auto-saved: $NF non-coding file(s) → develop (PR #$PR merged)" ;;
+      staged) echo "⟲ auto-saved: $NF non-coding file(s) → PR #$PR — yours to merge (say \"merge my auto-saves\" or /autosave)" ;;
+      open)   echo "⟲ auto-saved: $NF non-coding file(s) → PR #$PR (merge pending)" ;;
+      *)      echo "⟲ auto-saved: $NF non-coding file(s) → branch pushed (PR pending)" ;;
+    esac
+  fi
+fi
+
+# The helper branches off protected branches before committing. If this
+# checkout was on develop/main (e.g. the main checkout during a sweep),
+# restore it so the next session doesn't land on a stray autosave branch.
+case "$ORIG_BRANCH" in
+  develop|main|master)
+    CUR=$(git branch --show-current 2>/dev/null || echo "")
+    if [ "$CUR" != "$ORIG_BRANCH" ]; then
+      git checkout "$ORIG_BRANCH" --quiet 2>/dev/null || true
+      git pull --ff-only origin "$ORIG_BRANCH" --quiet 2>/dev/null || true
+    fi
+    ;;
+esac
+
+exit 0

package/runtime/prime/bin/session-log.sh

@@ -0,0 +1,199 @@
+#!/usr/bin/env bash
+# Graceful session-end adapter: write a structured session log to memory/sessions/.
+# Receives runtime-neutral JSON on stdin from Claude Code or Pi.
+# Runs BEFORE transcript-archive.sh (needs obs buffer + worktree intact).
+# Makes sessions visible in local-mode without requiring /handoff or /wrap.
+set -euo pipefail
+
+# Suppress all output — hook scripts must not leak to terminal
+exec >/dev/null 2>&1
+
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." 2>/dev/null && pwd)" || SCRIPT_DIR=""
+if [ -z "$SCRIPT_DIR" ] || [ ! -d "$SCRIPT_DIR" ]; then
+  SCRIPT_DIR="${CLAUDE_PROJECT_DIR:-}"
+fi
+if [ -z "$SCRIPT_DIR" ] || [ ! -d "$SCRIPT_DIR" ]; then
+  exit 0
+fi
+
+# --- Read hook input from stdin ---
+INPUT=$(cat /dev/stdin 2>/dev/null || echo "{}")
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty' 2>/dev/null || true)
+TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // empty' 2>/dev/null || true)
+
+if [ -z "$SESSION_ID" ]; then
+  exit 0
+fi
+
+# Sanitize SESSION_ID
+SESSION_ID=$(echo "$SESSION_ID" | tr -cd 'a-zA-Z0-9_-')
+if [ -z "$SESSION_ID" ] || [ ${#SESSION_ID} -gt 128 ]; then
+  exit 0
+fi
+
+# --- Gate: memory must exist ---
+if [ ! -L "$SCRIPT_DIR/memory" ] && [ ! -d "$SCRIPT_DIR/memory" ]; then
+  exit 0
+fi
+
+# --- Read identity ---
+STATE_FILE="$SCRIPT_DIR/.egregore-state.json"
+AUTHOR=""
+DISPLAY_NAME=""
+if [ -f "$STATE_FILE" ]; then
+  AUTHOR=$(jq -r '.github_username // empty' "$STATE_FILE" 2>/dev/null || true)
+  DISPLAY_NAME=$(jq -r '.display_name // empty' "$STATE_FILE" 2>/dev/null || true)
+fi
+AUTHOR=$(echo "$AUTHOR" | tr -cd 'a-zA-Z0-9_-')
+if [ -z "$AUTHOR" ]; then
+  exit 0
+fi
+
+# --- Git metadata ---
+BRANCH=$(git -C "$SCRIPT_DIR" branch --show-current 2>/dev/null || echo "")
+
+# --- Derive topic from branch name ---
+TOPIC=""
+if [ -n "$BRANCH" ] && [ "$BRANCH" != "develop" ] && [ "$BRANCH" != "main" ]; then
+  TOPIC=$(echo "$BRANCH" | sed 's|^dev/[^/]*/||; s|^feature/||; s|^bugfix/||' | tr '-' ' ')
+fi
+[ -z "$TOPIC" ] && TOPIC="session"
+
+# --- Read baseline (written by session-start.sh) ---
+BASELINE_FILE="/tmp/egregore-baseline-${SESSION_ID}.json"
+BASELINE_COMMIT=""
+BASELINE_STARTED=""
+if [ -f "$BASELINE_FILE" ]; then
+  BASELINE_COMMIT=$(jq -r '.commit // empty' "$BASELINE_FILE" 2>/dev/null || true)
+  BASELINE_STARTED=$(jq -r '.started_at // empty' "$BASELINE_FILE" 2>/dev/null || true)
+fi
+
+# --- Extract timestamps from transcript ---
+STARTED_AT=""
+ENDED_AT=""
+if [ -n "$TRANSCRIPT_PATH" ]; then
+  TRANSCRIPT_PATH="${TRANSCRIPT_PATH/#\~/$HOME}"
+  TRANSCRIPT_PATH=$(realpath "$TRANSCRIPT_PATH" 2>/dev/null || echo "")
+  if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
+    STARTED_AT=$(head -1 "$TRANSCRIPT_PATH" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null || echo "")
+    ENDED_AT=$(tail -1 "$TRANSCRIPT_PATH" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null || echo "")
+  fi
+fi
+
+# Use baseline start time if transcript didn't provide one
+[ -z "$STARTED_AT" ] && STARTED_AT="$BASELINE_STARTED"
+# Fallback to now
+[ -z "$ENDED_AT" ] && ENDED_AT=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+[ -z "$STARTED_AT" ] && STARTED_AT="$ENDED_AT"
+
+# --- Compute duration ---
+DURATION=""
+DURATION_MIN=0
+if [ -n "$STARTED_AT" ] && [ -n "$ENDED_AT" ]; then
+  S_EPOCH=$(python3 -c "from datetime import datetime; print(int(datetime.fromisoformat('$STARTED_AT'.replace('Z','+00:00')).timestamp()))" 2>/dev/null || echo "0")
+  E_EPOCH=$(python3 -c "from datetime import datetime; print(int(datetime.fromisoformat('$ENDED_AT'.replace('Z','+00:00')).timestamp()))" 2>/dev/null || echo "0")
+  if [ "$S_EPOCH" -gt 0 ] 2>/dev/null && [ "$E_EPOCH" -gt 0 ] 2>/dev/null; then
+    DURATION_MIN=$(( (E_EPOCH - S_EPOCH) / 60 ))
+    if [ "$DURATION_MIN" -lt 1 ] 2>/dev/null; then
+      DURATION="<1min"
+    elif [ "$DURATION_MIN" -lt 60 ] 2>/dev/null; then
+      DURATION="${DURATION_MIN}min"
+    else
+      HOURS=$(( DURATION_MIN / 60 ))
+      MINS=$(( DURATION_MIN % 60 ))
+      if [ "$MINS" -gt 0 ] 2>/dev/null; then
+        DURATION="${HOURS}h ${MINS}min"
+      else
+        DURATION="${HOURS}h"
+      fi
+    fi
+  fi
+fi
+[ -z "$DURATION" ] && DURATION="unknown"
+
+# --- Read obs buffer for files touched ---
+OBS_BUFFER="/tmp/egregore-obs-${SESSION_ID}.jsonl"
+OBS_FILES=""
+OBS_COUNT=0
+if [ -f "$OBS_BUFFER" ] && [ -s "$OBS_BUFFER" ]; then
+  OBS_COUNT=$(wc -l < "$OBS_BUFFER" 2>/dev/null | tr -d ' ')
+  OBS_FILES=$(jq -r '.path // empty' "$OBS_BUFFER" 2>/dev/null | grep -v '^$' | grep -v '^unknown$' | sort -u | head -10 || true)
+fi
+
+# --- Count commits since baseline ---
+COMMIT_COUNT=0
+if [ -n "$BASELINE_COMMIT" ] && git -C "$SCRIPT_DIR" rev-parse "$BASELINE_COMMIT" >/dev/null 2>&1; then
+  COMMIT_COUNT=$(git -C "$SCRIPT_DIR" rev-list "${BASELINE_COMMIT}..HEAD" --count 2>/dev/null || echo "0")
+fi
+
+# --- Empty session guard ---
+# Skip if: duration < 2 min AND no commits AND no obs buffer activity
+if [ "$DURATION_MIN" -lt 2 ] 2>/dev/null && [ "$COMMIT_COUNT" -eq 0 ] 2>/dev/null && [ "$OBS_COUNT" -eq 0 ] 2>/dev/null; then
+  rm -f "$BASELINE_FILE" 2>/dev/null
+  exit 0
+fi
+
+# --- Deduplication: explicit /handoff or /wrap wins over baseline capture ---
+TODAY=$(date +%d)
+MONTH=$(date +%Y-%m)
+if [ -n "$STARTED_AT" ]; then
+  MONTH=$(echo "$STARTED_AT" | grep -oE '^[0-9]{4}-[0-9]{2}' || date +%Y-%m)
+  TODAY=$(echo "$STARTED_AT" | grep -oE '^[0-9]{4}-[0-9]{2}-([0-9]{2})' | tail -c3 | sed 's/^-//' || date +%d)
+fi
+
+AUTHOR_LC=$(echo "$AUTHOR" | tr '[:upper:]' '[:lower:]')
+DISPLAY_LC=$(echo "$DISPLAY_NAME" | tr '[:upper:]' '[:lower:]')
+AUTHOR_PATTERN="-${AUTHOR_LC}-"
+[ -n "$DISPLAY_LC" ] && AUTHOR_PATTERN="${AUTHOR_PATTERN}|-${DISPLAY_LC}-"
+for CAPTURE_DIR in \
+  "$SCRIPT_DIR/memory/handoffs/$MONTH" \
+  "$SCRIPT_DIR/memory/wraps/$MONTH"; do
+  [ -d "$CAPTURE_DIR" ] || continue
+  # Match the canonical handle or display name in today's filename.
+  EXISTING=""
+  for CANDIDATE in "$CAPTURE_DIR/${TODAY}-"*.md; do
+    [ -e "$CANDIDATE" ] || continue
+    CANDIDATE_NAME="$(basename "$CANDIDATE" | tr '[:upper:]' '[:lower:]')"
+    if printf '%s\n' "$CANDIDATE_NAME" | grep -Eq -- "$AUTHOR_PATTERN"; then
+      EXISTING="$CANDIDATE_NAME"
+      break
+    fi
+  done
+  if [ -n "$EXISTING" ]; then
+    rm -f "$BASELINE_FILE" 2>/dev/null
+    exit 0
+  fi
+done
+
+# --- Write through the shared capture engine -----------------------------
+SUMMARY="${DURATION} session on ${TOPIC}; ${COMMIT_COUNT} commit(s), ${OBS_COUNT} observed action(s)."
+{
+  if [ -n "$OBS_FILES" ]; then
+    echo "## Files"
+    echo "$OBS_FILES" | while read -r F; do
+      [ -n "$F" ] && echo "- $F"
+    done
+    echo ""
+  fi
+
+  if [ "$COMMIT_COUNT" -gt 0 ] 2>/dev/null; then
+    echo "## Commits"
+    echo "$COMMIT_COUNT commits on ${BRANCH:-develop}"
+    echo ""
+  fi
+} | bash "$SCRIPT_DIR/bin/capture-run.sh" \
+      --mode baseline \
+      --author "$AUTHOR" \
+      --display-name "$DISPLAY_NAME" \
+      --topic "$TOPIC" \
+      --summary "$SUMMARY" \
+      --session-id "$SESSION_ID" \
+      --branch "${BRANCH:-develop}" \
+      --date "$STARTED_AT" \
+      --duration "$DURATION" \
+      --async-push >/dev/null 2>&1 || true
+
+# --- Clean up baseline ---
+rm -f "$BASELINE_FILE" 2>/dev/null
+
+exit 0