create-egregore 0.21.6 → 0.22.0

package/runtime/prime/bin/lib/settings-drift.sh

@@ -122,7 +122,7 @@ export SETTINGS_CP_SYNCED="false"
 
 settings_drift_pull() {
   local api_url api_key resp revision applied local_subset server_settings
-  api_url=$(jq -r '.api_url // empty' egregore.json 2>/dev/null)
+  api_url=$(_hosted_api_url "$(jq -r '.api_url // empty' egregore.json 2>/dev/null)") || return 0
   [ -n "$api_url" ] || return 0
   api_key=$(grep '^EGREGORE_API_KEY=' .env 2>/dev/null | cut -d'=' -f2-)
   [ -n "$api_key" ] || return 0
@@ -145,7 +145,7 @@ settings_drift_pull() {
       SETTINGS_POSTURE_HELD="$incoming_posture"
       export SETTINGS_POSTURE_HELD
     fi
-    local merged tmp
+    local merged tmp state_file
     merged=$(printf '%s' "$server_settings" | jq -c \
       --argjson keys "$_SETTINGS_OWNED_KEYS" --argjson hold "$hold" --slurpfile cfg egregore.json '
       . as $s | $cfg[0] as $local |
@@ -163,9 +163,12 @@ settings_drift_pull() {
       export SETTINGS_SYNCED_FROM_ORG
       # A held posture keeps the revision unapplied so the next start retries.
       if [ "$hold" = "false" ] && [ -f .egregore-state.json ]; then
-        tmp=$(mktemp ".egregore-state.json.XXXXXX") || return 0
-        jq --arg rev "$revision" '.org_settings_revision = $rev' .egregore-state.json > "$tmp" 2>/dev/null \
-          && [ -s "$tmp" ] && mv "$tmp" .egregore-state.json || rm -f "$tmp"
+        # A worktree links the checkout's state file: the rename lands on the
+        # file it points to, so the link stays and the installation keeps one state.
+        state_file=$(realpath .egregore-state.json 2>/dev/null) || state_file=.egregore-state.json
+        tmp=$(mktemp "$state_file.XXXXXX") || return 0
+        jq --arg rev "$revision" '.org_settings_revision = $rev' "$state_file" > "$tmp" 2>/dev/null \
+          && [ -s "$tmp" ] && mv "$tmp" "$state_file" || rm -f "$tmp"
         SETTINGS_CP_SYNCED="true"; export SETTINGS_CP_SYNCED
       fi
     fi

package/runtime/prime/bin/lib/startup-restart.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Finish a startup on the script its own sync just pulled.
+#
+# The startup sync (bin/lib/git-sync.sh) can fast-forward this checkout onto a
+# newer framework. Bash keeps reading the copy of the startup script it opened,
+# while every library sourced after the sync is the new version, so the rest
+# of the run would mix both. When the sync moved HEAD and changed the startup
+# itself, start the new script once, with the same session id. Shared by the
+# Claude startup (bin/session-start.sh) and the Codex, Pi and Prime startup
+# (bin/codex-session-start.sh).
+#
+# Usage (sourced, before the sync):
+#   _STARTUP_HEAD=$(egregore_startup_head)
+#   source "$SCRIPT_DIR/bin/lib/git-sync.sh"
+#   egregore_startup_restart "$_STARTUP_HEAD" "$SCRIPT_DIR/bin/<script>" "$@"
+
+# Empty outside a Git checkout (.git is a directory, or a file in a worktree):
+# nothing there can be synced, so nothing restarts and Git is never called.
+egregore_startup_head() {
+  [ -e "${SCRIPT_DIR:-.}/.git" ] || return 0
+  git rev-parse HEAD 2>/dev/null || true
+}
+
+# egregore_startup_restart <head-before-sync> <script> [args...]
+# Returns when no restart is needed; otherwise replaces this process. Callers
+# export anything else the new run must inherit before calling.
+egregore_startup_restart() {
+  local before="$1" script="$2"
+  shift 2
+  if [ -z "${_EGREGORE_STARTUP_REEXEC:-}" ] && [ -n "$before" ] \
+    && [ "$(git rev-parse HEAD 2>/dev/null)" != "$before" ] \
+    && ! git diff --quiet "$before" HEAD -- \
+      bin/session-start.sh bin/codex-session-start.sh bin/lib 2>/dev/null; then
+    egregore_trace_end 2>/dev/null || true
+    # The hook's stdin was read before the sync and its session id mapped.
+    export _EGREGORE_STARTUP_REEXEC=1 _EGREGORE_REUSE_SESSION_ID="$EGREGORE_SESSION_ID"
+    exec bash "$script" "$@" < /dev/null
+  fi
+  # One restart per launch, and never inherited by what this run starts.
+  export -n _EGREGORE_STARTUP_REEXEC 2>/dev/null || true
+}

package/runtime/prime/bin/lib/worktree-links.sh

@@ -5,6 +5,8 @@
 # which links memory/, .env, and local state from the main checkout. Portable
 # runtimes such as Codex can land in a plain git worktree, so startup and
 # agent.sh use this helper to self-heal those links before reading context.
+# Both creation paths (the hook and worktree.sh setup) also link installed
+# tools through egregore_link_tools.
 
 egregore_main_project_dir() {
   local project_dir="${1:?project dir required}"
@@ -59,6 +61,96 @@ egregore_link_shared_state() {
   done
 }
 
+# Link the main checkout's installed tools into a new worktree: the root
+# node_modules, each packages/<name>/node_modules the main checkout has, and
+# .egregore/tools (the managed artifact renderer). All are gitignored, so a
+# fresh worktree has none, and its tests and renderer fail before the work
+# starts; a link shares the one install instead. A source the main checkout
+# lacks is the normal state on many machines, so it is skipped silently.
+#
+# Anything already at a link's path stays, so a worktree's own install is
+# never replaced. Nothing goes to stdout, which the WorktreeCreate hook
+# reserves for the worktree path.
+egregore_link_tools() {
+  local worktree_dir="${1:?worktree dir required}"
+  local main_dir="${2:?main checkout dir required}"
+  local rel src
+
+  for rel in node_modules .egregore/tools; do
+    [ -d "$main_dir/$rel" ] || continue
+    _egregore_link_tool "$worktree_dir" "$rel" "$main_dir/$rel"
+  done
+  for src in "$main_dir"/packages/*/node_modules; do
+    rel="${src#"$main_dir"/}"
+    [ -d "$src" ] && [ -d "$worktree_dir/${rel%/node_modules}" ] || continue
+    _egregore_link_tool "$worktree_dir" "$rel" "$src"
+  done
+  return 0
+}
+
+# One tool link at <worktree>/<rel>. Git must ignore it, or the next save
+# commits it as an untracked file. A trailing-slash pattern such as
+# `node_modules/` matches only directories, never a link, and installed
+# instances keep their own .gitignore (/update does not sync it), so a miss
+# is hidden through info/exclude instead. Only when that file cannot take the
+# pattern is the link taken back, with the one line this helper prints.
+_egregore_link_tool() {
+  local worktree_dir="$1" rel="$2" src="$3"
+  local dst="$worktree_dir/$rel"
+
+  if [ -e "$dst" ] || [ -L "$dst" ]; then
+    return 0
+  fi
+  mkdir -p "${dst%/*}" 2>/dev/null || return 0
+  ln -s "$src" "$dst" 2>/dev/null || return 0
+  _egregore_git -C "$worktree_dir" check-ignore -q -- "$rel" && return 0
+  if _egregore_exclude "$worktree_dir" "/$rel" \
+     && _egregore_git -C "$worktree_dir" check-ignore -q -- "$rel"; then
+    return 0
+  fi
+  rm -f "$dst"
+  echo "worktree: not linking $rel; add \"$rel\" (no trailing slash) to .gitignore to keep the link out of commits" >&2
+}
+
+# Record one pattern in the checkout's info/exclude, the way
+# packages/create-egregore records /.egregore/secret-entry/
+# (recordRuntimeGitExcludes): git names the file, which a linked worktree
+# shares with its main repository; only a regular file is written; the
+# pattern goes in once, on its own line, under a comment. Returns 1 when the
+# file cannot take the pattern.
+_egregore_exclude() {
+  local worktree_dir="$1" pattern="$2" exclude prefix=""
+
+  exclude="$(_egregore_git -C "$worktree_dir" rev-parse --git-path info/exclude)" || return 1
+  [ -n "$exclude" ] || return 1
+  case "$exclude" in
+    /*) ;;
+    *) exclude="$worktree_dir/$exclude" ;;
+  esac
+  if [ -L "$exclude" ] || { [ -e "$exclude" ] && [ ! -f "$exclude" ]; }; then
+    return 1
+  fi
+  if [ -f "$exclude" ]; then
+    grep -qxF -e "$pattern" -e "$pattern"$'\r' "$exclude" && return 0
+    if [ -s "$exclude" ] && [ -n "$(tail -c 1 "$exclude")" ]; then
+      prefix=$'\n'
+    fi
+  fi
+  mkdir -p "${exclude%/*}" 2>/dev/null || return 1
+  { printf '%s# Egregore worktree tool link\n%s\n' "$prefix" "$pattern" >> "$exclude"; } 2>/dev/null
+}
+
+# git without inherited GIT_* overrides, which would point a worktree's
+# answers, and the exclude write, at another repository.
+_egregore_git() {
+  (
+    for name in $(compgen -e); do
+      case "$name" in GIT_*) unset "$name" 2>/dev/null ;; esac
+    done
+    git "$@" 2>/dev/null
+  )
+}
+
 # Resolve the .env that governs a checkout. A worktree can be missing its .env
 # symlink (created before .env existed, or by a runtime that skipped worktree
 # setup) — self-heal the links, then fall back to the main checkout's .env so

package/runtime/prime/bin/memory-push.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# One managed push, guarded in this process at dispatch. No raw-push fallback.
+set -eu
+SCRIPT_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+PYTHONSAFEPATH=1 PYTHONPATH="$SCRIPT_ROOT${PYTHONPATH:+:$PYTHONPATH}" \
+  exec python3 -m egregore_runtime.memory_push "$@"