create-egregore 0.21.6 → 0.22.0

package/runtime/claude/bin/search.sh

@@ -10,6 +10,7 @@
 #   bash bin/search.sh start
 #   bash bin/search.sh stop
 #   bash bin/search.sh open memory/path/to/source.md
+#   bash bin/search.sh mind publish
 #
 # The shell owns the established user-facing output. Retrieval infrastructure
 # is isolated behind the Egregore Retriever adapter.
@@ -47,6 +48,28 @@ _elapsed_s() {
   awk -v ms="$(( $(_now_ms) - $1 ))" 'BEGIN { printf "%.1f", ms / 1000 }'
 }
 
+# Run a Runtime operation as an OpenTelemetry span when the harness traces
+# this process (it exports TRACEPARENT). Untraced calls take the plain path.
+# Usage: _traced <span-name> <original-args-array-name> <command...>
+_traced() {
+  local name="$1" argv_ref="$2[@]"; shift 2
+  if [ -z "${TRACEPARENT:-}" ]; then "$@"; return $?; fi
+  local start out rc results degraded stale
+  start=$(_now_ms)
+  out=$(mktemp "${TMPDIR:-/tmp}/egregore-span.XXXXXX")
+  "$@" | tee "$out"
+  rc=${PIPESTATUS[0]}
+  results=$(grep -cE '^[0-9]+\. ' "$out" 2>/dev/null)
+  degraded=false; grep -q 'Search degraded' "$out" 2>/dev/null && degraded=true
+  stale=$(sed -nE 's/^Note: ([0-9]+) eligible document.*/\1/p' "$out" 2>/dev/null | head -1)
+  rm -f "$out"
+  ( python3 "$SCRIPT_DIR/bin/lib/otel_span.py" --name "$name" --start-ms "$start" \
+      --end-ms "$(_now_ms)" --rc "$rc" --attr "egregore.search.results=${results:-0}" \
+      --attr "egregore.search.degraded=$degraded" --attr "egregore.search.stale_documents=${stale:-}" \
+      --argv -- ${!argv_ref+"${!argv_ref}"} >/dev/null 2>&1 & ) 2>/dev/null
+  return "$rc"
+}
+
 _result_paths() {
   local line path canonical_prefix
   canonical_prefix="**file:** \`memory/"
@@ -71,7 +94,7 @@ _result_paths() {
 # calls there. The dormant graph configuration is preserved untouched for
 # rollback only.
 _upgrade_instance_key() {
-  # Mirrors egregore_runtime.upgrade.instance_key: stable org identity
+  # Mirrors egregore_runtime.installation.installation_key: stable org identity
   # composed with the main installation path. No org_id → fail closed.
   local org main gitdir
   org=$(jq -r '.org_id // empty' "$SCRIPT_DIR/egregore.json" 2>/dev/null)
@@ -371,11 +394,12 @@ case "${1:-}" in
     for arg in "$@"; do
       if [ "$arg" = --context-packet ]; then FIND_ARGS+=(--private-result); else FIND_ARGS+=("$arg"); fi
     done
-    _runtime find "${FIND_ARGS[@]}"
+    _traced egregore.search.find FIND_ARGS _runtime find "${FIND_ARGS[@]}"
     ;;
   investigate) shift; cmd_investigate "$@" ;;
   start) shift; _runtime start "$@" ;;
   stop) shift; _runtime stop "$@" ;;
+  mind) shift; _runtime mind "$@" ;;
   open)
     shift
     OPEN_PACKET=0; OPEN_PATHS=()
@@ -393,19 +417,21 @@ case "${1:-}" in
     [ "$OPEN_PACKET" = 1 ] && OPEN_BINDING+=(--private-result)
     # Older Bash treats an empty array as unset under nounset. Optional flags
     # must expand to zero arguments without requiring an explicit episode ID.
-    _runtime open ${OPEN_PATHS[@]+"${OPEN_PATHS[@]}"} ${OPEN_BINDING[@]+"${OPEN_BINDING[@]}"}
+    OPEN_ARGS=(${OPEN_PATHS[@]+"${OPEN_PATHS[@]}"} ${OPEN_BINDING[@]+"${OPEN_BINDING[@]}"})
+    _traced egregore.search.open OPEN_ARGS _runtime open ${OPEN_ARGS[@]+"${OPEN_ARGS[@]}"}
     ;;
   help|-h|--help)
     cat <<'USAGE'
-usage: bash bin/search.sh {find|investigate|query|handoffs|reindex|install|start|stop|status|readiness|open}
+usage: bash bin/search.sh {find|investigate|query|handoffs|reindex|install|start|stop|status|readiness|open|mind}
   find "terms" [--kind keyword|semantic|hybrid|filename|literal|dates] [--recent-days N]
   open memory/path.md [memory/other.md ...] [--offset N] [--length N]
   handoffs --mine --status open --order newest --limit 1 --open
   handoffs [--addressed-to NAME|--sent|--sent-by NAME] [--status STATUS] [--order newest|oldest] [--limit N] [--json]
+  mind publish
 USAGE
     ;;
   *)
-    echo "usage: bash bin/search.sh {find|investigate|query|handoffs|reindex|install|start|stop|status|readiness|open}" >&2
+    echo "usage: bash bin/search.sh {find|investigate|query|handoffs|reindex|install|start|stop|status|readiness|open|mind}" >&2
     exit 1
     ;;
 esac

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

@@ -133,9 +133,12 @@ if git -C "$DIR/memory" rev-parse --git-dir >/dev/null 2>&1; then
   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
+      if git -C "$DIR/memory" pull --rebase origin main --quiet 2>/dev/null; then
+        if bash "$SCRIPT_ROOT/bin/memory-push.sh" --repository "$DIR/memory" --branch main >/dev/null 2>&1; then
+          break
+        else
+          case "$?" in 75) ;; *) break ;; esac
+        fi
       fi
       sleep 1
     done

package/runtime/claude/bin/session-id.sh

@@ -0,0 +1,147 @@
+#!/usr/bin/env bash
+# session-id.sh — the calling harness session's own Egregore session id.
+#
+# Every session start mints an Egregore session id and writes it to the
+# checkout's .egregore-session-id, which each worktree links to. With several
+# sessions open on one machine, the latest start owns that file, so a commit
+# that reads it can carry another session's Egregore-Session trailer. This
+# script keeps one small map file per harness session and resolves the
+# caller's own id from the native session id its harness exports.
+#
+#   session-id.sh [--root DIR]
+#       Print the caller's Egregore session id; print nothing and exit 1
+#       when there is none. A native id in the environment whose map was
+#       recorded for DIR's repository wins; otherwise DIR/.egregore-session-id.
+#   session-id.sh record <harness> <native-id> <egregore-id> [--root DIR]
+#       Map a starting session (bin/lib/identity.sh), replacing an old map.
+#   session-id.sh bind <harness> <native-id> [--root DIR]
+#       Map a session first seen after its start (a Codex thread, at its
+#       first prompt) to the id it resolves to now. A map this repository
+#       can use is kept; one recorded for a moved checkout is replaced.
+#
+# Native ids, in order: EGREGORE_NATIVE_SESSION_ID under
+# EGREGORE_NATIVE_HARNESS (Claude, Pi and Prime tool commands), then
+# CLAUDE_CODE_SESSION_ID, then CODEX_THREAD_ID. A Codex worker started from a
+# Claude or Pi shell inherits that shell's ids and so resolves to the session
+# that started it.
+#
+# Map files: ~/.egregore/sessions/<harness>-<native-id>.id, two lines: the
+# Egregore id and the repository's physical git common dir, so a map never
+# applies to another repository (a test fixture, another instance). Names are
+# checked, never rewritten. Each record prunes maps unused for 30 days; every
+# resolve and bind that uses a map marks it used.
+set -u
+export LC_ALL=C
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+MAP_DIR=""
+[ -z "${HOME:-}" ] || MAP_DIR="$HOME/.egregore/sessions"
+SCOPE=""
+
+usage() {
+  awk 'NR == 1 { next } /^#/ { sub(/^# ?/, ""); print; next } { exit }' "$0"
+}
+
+valid_harness() {
+  case "$1" in ''|*[!a-z0-9]*) return 1 ;; esac
+  [ "${#1}" -le 16 ]
+}
+
+valid_native() {
+  case "$1" in ''|.*|*[!A-Za-z0-9._-]*) return 1 ;; esac
+  [ "${#1}" -le 128 ]
+}
+
+valid_session() {
+  case "$1" in ''|*[[:cntrl:]]*) return 1 ;; esac
+  [ "${#1}" -le 200 ]
+}
+
+# The repository's git common dir, physical, so worktrees and every spelling
+# of one checkout agree.
+scope_of() {
+  local dir
+  dir="$(git -C "$1" rev-parse --git-common-dir 2>/dev/null)" || return 1
+  case "$dir" in /*) ;; *) dir="$1/$dir" ;; esac
+  (cd "$dir" 2>/dev/null && pwd -P)
+}
+
+# Print a map's Egregore id when the map belongs to this repository, and mark
+# it used so the age prune spares a session that is still working.
+lookup() {
+  local harness="$1" native="$2" file id="" scope=""
+  [ -n "$MAP_DIR" ] && valid_harness "$harness" && valid_native "$native" || return 1
+  file="$MAP_DIR/$harness-$native.id"
+  [ -f "$file" ] || return 1
+  { IFS= read -r id; IFS= read -r scope; } < "$file" 2>/dev/null
+  valid_session "$id" && [ -n "$scope" ] || return 1
+  [ -n "$SCOPE" ] || SCOPE="$(scope_of "$ROOT_DIR")" || return 1
+  [ "$scope" = "$SCOPE" ] || return 1
+  touch -c "$file" 2>/dev/null   # -c: a map pruned meanwhile stays gone, never empty
+  printf '%s\n' "$id"
+}
+
+resolve() {
+  local id=""
+  if [ -n "${EGREGORE_NATIVE_SESSION_ID:-}" ] && [ -n "${EGREGORE_NATIVE_HARNESS:-}" ]; then
+    if lookup "$EGREGORE_NATIVE_HARNESS" "$EGREGORE_NATIVE_SESSION_ID"; then return 0; fi
+  fi
+  if [ -n "${CLAUDE_CODE_SESSION_ID:-}" ]; then
+    if lookup claude "$CLAUDE_CODE_SESSION_ID"; then return 0; fi
+  fi
+  if [ -n "${CODEX_THREAD_ID:-}" ]; then
+    if lookup codex "$CODEX_THREAD_ID"; then return 0; fi
+  fi
+  [ -f "$ROOT_DIR/.egregore-session-id" ] || return 1
+  IFS= read -r id < "$ROOT_DIR/.egregore-session-id" 2>/dev/null
+  valid_session "$id" || return 1
+  printf '%s\n' "$id"
+}
+
+record() {
+  local harness="$1" native="$2" id="$3" scope tmp
+  [ -n "$MAP_DIR" ] && valid_harness "$harness" && valid_native "$native" && valid_session "$id" || return 1
+  scope="$(scope_of "$ROOT_DIR")" && [ -n "$scope" ] || return 1
+  mkdir -p "$MAP_DIR" 2>/dev/null || return 1
+  tmp="$MAP_DIR/.$harness-$native.$$"
+  printf '%s\n%s\n' "$id" "$scope" > "$tmp" 2>/dev/null \
+    && mv -f "$tmp" "$MAP_DIR/$harness-$native.id" 2>/dev/null || { rm -f "$tmp"; return 1; }
+  find "$MAP_DIR" -maxdepth 1 -type f \( -name '*.id' -o -name '.*' \) -mtime +30 \
+    -exec rm -f {} + 2>/dev/null
+  return 0
+}
+
+bind() {
+  local harness="$1" native="$2" id
+  [ -n "$MAP_DIR" ] && valid_harness "$harness" && valid_native "$native" || return 1
+  # A map this repository can use is kept; one recorded for a checkout that
+  # has since moved is replaced rather than left unusable.
+  lookup "$harness" "$native" >/dev/null && return 0
+  id="$(resolve)" || return 1
+  record "$harness" "$native" "$id"
+}
+
+ARGS=()
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --root)
+      [ -n "${2:-}" ] || { echo "session-id.sh: --root needs a directory" >&2; exit 2; }
+      ROOT_DIR="$2"; shift 2 ;;
+    -h|--help) usage; exit 0 ;;
+    *) ARGS+=("$1"); shift ;;
+  esac
+done
+set -- ${ARGS[@]+"${ARGS[@]}"}
+
+case "${1:-resolve}" in
+  resolve)
+    [ $# -le 1 ] || { usage >&2; exit 2; }
+    resolve ;;
+  record)
+    [ $# -eq 4 ] || { usage >&2; exit 2; }
+    record "$2" "$3" "$4" ;;
+  bind)
+    [ $# -eq 3 ] || { usage >&2; exit 2; }
+    bind "$2" "$3" ;;
+  *) usage >&2; exit 2 ;;
+esac

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

@@ -21,6 +21,25 @@ 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)
 
+# Route known native transcript locations before reading their contents.
+RUNTIME=$(printf '%s' "$INPUT" | jq -r '.runtime // empty' 2>/dev/null || true)
+RECORD_TRANSCRIPT=false
+if [ -n "${HOME:-}" ]; then
+  if [[ "$TRANSCRIPT_PATH" == "$HOME/.claude/projects/"* ]] && \
+      printf '%s' "$INPUT" | jq -e 'has("hook_event_name")' >/dev/null 2>&1; then
+    RECORD_TRANSCRIPT=true
+  elif { [ "$RUNTIME" = pi ] && [[ "$TRANSCRIPT_PATH" == "$HOME/.pi/agent/sessions/"* ]]; } || \
+       { [ "$RUNTIME" = prime ] && [[ "$TRANSCRIPT_PATH" == "$HOME/.prime/agent/sessions/"* ]]; }; then
+    RECORD_TRANSCRIPT=true
+  fi
+fi
+if [ "$RECORD_TRANSCRIPT" = true ]; then
+  source "$SCRIPT_DIR/bin/lib/config.sh"
+  if _session_records_enabled; then
+    exec bash "$SCRIPT_DIR/bin/session-record.sh" --mode end <<< "$INPUT"
+  fi
+fi
+
 if [ -z "$SESSION_ID" ]; then
   exit 0
 fi

package/runtime/claude/bin/session-record.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Session-record admission is silent and detached for hooks. Python uses only
+# the standard library. Summarizer flags (all checked against claude --help):
+# Private trails, durable holds, stamps and locks live in $HOME/.egregore/trails.
+# --tools "" --strict-mcp-config --mcp-config '{"mcpServers":{}}'
+# --setting-sources "" --model MODEL --output-format text -p PROMPT
+# Built-in tools, MCP servers, project settings, hooks and plugins are disabled,
+# so the call is a single turn without a separate turn-limit flag.
+# A CLI missing any isolation flag (including the empty --tools allowlist)
+# is never invoked for a build; the record is deterministic instead.
+# Checkpoints only write the record file in the memory working tree. Session
+# end commits and pushes it with this person's earlier uncommitted records.
+# --mode sweep always refreshes local counts in a detached worker. Publication
+# requires an answered offer and enabled recording; only publication is
+# debounced for six hours unless --force is supplied.
+# Publications and hold markers use the same canonical memory lock; holds wait
+# for an active publication, then redact going forward without rewriting history.
+# The one thing a hook prints: at a checkpoint, the session's cost line, once
+# per mark ($200 priced, or ten million Codex input tokens) at the next stop.
+# Descriptor 3 carries the hook's stdout past the silenced streams for it.
+set -uo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)" || exit 0
+command -v jq >/dev/null 2>&1 || exit 0
+command -v python3 >/dev/null 2>&1 || exit 0
+[ -n "${HOME:-}" ] || exit 0
+exec python3 "$SCRIPT_DIR/bin/lib/session_record.py" record --root "$SCRIPT_DIR" --notice-fd 3 "$@" 3>&1 >/dev/null 2>&1