create-egregore 0.19.8 → 0.19.12

package/runtime/pi/bin/capture-run.sh

@@ -0,0 +1,341 @@
+#!/bin/bash
+set -euo pipefail
+
+# Shared capture engine for the three ways an Egregore session leaves a trace.
+#
+#   addressed  /handoff: rich team handoff (delegates to the addressed worker)
+#   personal   /wrap:    explicit personal close
+#   baseline   SessionEnd: automatic, loss-prevention trace
+#
+# Lifecycle reconciliation is never performed on the caller's critical path.
+# Connected-mode captures append idempotent graph statements to graph-wal.sh
+# and optionally start capture-reconcile.sh as a detached worker.
+
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CONFIG="$SCRIPT_DIR/egregore.json"
+CAPTURE_SCHEMA="egregore-capture/v1"
+
+queue_handoff_completion() {
+  local session_id="$1"
+  [ -n "$session_id" ] || return 0
+  # shellcheck disable=SC2016 # $name tokens are Cypher parameters.
+  local cypher='
+    MATCH (impl:Session {id: $sessionId})-[:IMPLEMENTS]->(ho:Session)
+    MATCH (impl)-[:BY]->(recipient:Person)
+    MATCH (ho)-[:HANDED_TO]->(recipient)
+    WHERE coalesce(ho.handoffStatus, "pending") IN ["pending","read","claimed"]
+      AND coalesce(ho.handoffLifecycleVersion, 0) >= 1
+    WITH DISTINCT ho, size([(ho)-[:HANDED_TO]->(:Person) | 1]) AS recipientCount
+    WHERE recipientCount = 1
+    SET ho.handoffStatus = "done",
+        ho.handoffDoneAt = coalesce(ho.handoffDoneAt, datetime()),
+        ho.handoffUpdatedAt = datetime(),
+        ho.handoffLifecycleReason = "single_recipient_implemented",
+        ho.handoffLifecycleVersion = 1
+    RETURN ho.id AS id'
+  local params
+  params="$(jq -nc --arg sessionId "$session_id" '{sessionId:$sessionId}')"
+  GRAPH_WAL_LOCK_ATTEMPTS=1 \
+    bash "$SCRIPT_DIR/bin/graph-wal.sh" append "$cypher" "$params" >/dev/null 2>&1 || true
+}
+
+start_reconcile() {
+  local session_id="$1"
+  local author="$2"
+  local summary="$3"
+  [ -n "$session_id" ] || return 0
+  (
+    bash "$SCRIPT_DIR/bin/capture-reconcile.sh" \
+      --session-id "$session_id" \
+      --author "$author" \
+      --summary "$summary" >/dev/null 2>&1 &
+  ) >/dev/null 2>&1
+}
+
+usage() {
+  cat <<'EOF'
+Usage:
+  capture-run.sh --mode addressed [handoff-run options] < handoff.md
+  capture-run.sh --mode personal|baseline --author HANDLE --topic TOPIC
+    --summary SUMMARY [--session-id ID] [--branch BRANCH] [--date ISO]
+    [--duration TEXT] [--open-threads-json JSON] [--no-push]
+    [--async-push] [--no-reconcile] < details.md
+EOF
+}
+
+if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
+  usage
+  exit 0
+fi
+
+CAPTURE_MODE=""
+if [ "${1:-}" = "--mode" ]; then
+  CAPTURE_MODE="${2:-}"
+  shift 2
+fi
+[ -n "$CAPTURE_MODE" ] || {
+  echo "Missing --mode (addressed|personal|baseline)" >&2
+  exit 1
+}
+
+case "$CAPTURE_MODE" in
+  addressed)
+    # Keep the mature publishing/notification worker intact behind the shared
+    # entry point. It continues writing its compatibility result file.
+    ADDRESSED_AUTHOR=""
+    ADDRESSED_TOPIC=""
+    PREV=""
+    for VALUE in "$@"; do
+      if [ "$PREV" = "--author" ]; then ADDRESSED_AUTHOR="$VALUE"; fi
+      if [ "$PREV" = "--topic" ]; then ADDRESSED_TOPIC="$VALUE"; fi
+      PREV="$VALUE"
+    done
+
+    if bash "$SCRIPT_DIR/bin/handoff-run.sh" "$@"; then
+      status=0
+    else
+      status=$?
+    fi
+    old_result="${TMPDIR:-/tmp}/handoff-run-result.json"
+    capture_result="${TMPDIR:-/tmp}/capture-run-result.json"
+    if [ -s "$old_result" ]; then
+      jq --arg schema "$CAPTURE_SCHEMA" --arg captureMode "$CAPTURE_MODE" \
+        '. + {captureSchema:$schema,captureMode:$captureMode}' \
+        "$old_result" > "$capture_result" 2>/dev/null || cp "$old_result" "$capture_result"
+    fi
+
+    # Addressed capture is also explicit session-close evidence. Queue the
+    # same guarded transition as /wrap after the addressed worker has marked
+    # the current Session handed_off.
+    ADDRESSED_CONFIG_MODE="$(jq -r '.mode // "connected"' "$CONFIG" 2>/dev/null || echo connected)"
+    if [ "$status" = "0" ] && [ "$ADDRESSED_CONFIG_MODE" = "connected" ]; then
+      CURRENT_SID="$(cat "$SCRIPT_DIR/.egregore-session-id" 2>/dev/null || true)"
+      if [ -z "$CURRENT_SID" ]; then
+        PROJ_HASH="$(printf '%s' "$SCRIPT_DIR" | md5 2>/dev/null || printf '%s' "$SCRIPT_DIR" | md5sum 2>/dev/null | cut -d' ' -f1)"
+        CURRENT_SID="$(cat "$HOME/.egregore/session-${PROJ_HASH}.id" 2>/dev/null || true)"
+      fi
+      queue_handoff_completion "$CURRENT_SID"
+      start_reconcile "$CURRENT_SID" "$ADDRESSED_AUTHOR" "$ADDRESSED_TOPIC"
+    fi
+    exit "$status"
+    ;;
+  personal|baseline) ;;
+  *)
+    echo "Invalid --mode: $CAPTURE_MODE (addressed|personal|baseline)" >&2
+    exit 1
+    ;;
+esac
+
+AUTHOR=""
+DISPLAY_NAME=""
+TOPIC=""
+SUMMARY=""
+SESSION_ID=""
+BRANCH=""
+CAPTURE_DATE=""
+DURATION=""
+OPEN_THREADS_JSON="[]"
+NO_PUSH=0
+ASYNC_PUSH=0
+NO_RECONCILE=0
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --author) AUTHOR="${2:-}"; shift 2 ;;
+    --display-name) DISPLAY_NAME="${2:-}"; shift 2 ;;
+    --topic) TOPIC="${2:-}"; shift 2 ;;
+    --summary) SUMMARY="${2:-}"; shift 2 ;;
+    --session-id) SESSION_ID="${2:-}"; shift 2 ;;
+    --branch) BRANCH="${2:-}"; shift 2 ;;
+    --date) CAPTURE_DATE="${2:-}"; shift 2 ;;
+    --duration) DURATION="${2:-}"; shift 2 ;;
+    --open-threads-json) OPEN_THREADS_JSON="${2:-[]}"; shift 2 ;;
+    --no-push) NO_PUSH=1; shift ;;
+    --async-push) ASYNC_PUSH=1; shift ;;
+    --no-reconcile) NO_RECONCILE=1; shift ;;
+    *) echo "Unknown capture option: $1" >&2; exit 1 ;;
+  esac
+done
+
+AUTHOR="$(printf '%s' "$AUTHOR" | tr -cd 'a-zA-Z0-9_-')"
+[ -n "$AUTHOR" ] || { echo "Missing --author" >&2; exit 1; }
+[ -n "$TOPIC" ] || { echo "Missing --topic" >&2; exit 1; }
+[ -n "$SUMMARY" ] || SUMMARY="$TOPIC"
+if ! printf '%s' "$OPEN_THREADS_JSON" | jq -e 'type == "array"' >/dev/null 2>&1; then
+  echo "Invalid --open-threads-json: expected an array" >&2
+  exit 1
+fi
+
+DETAILS="$(cat /dev/stdin 2>/dev/null || true)"
+NOW="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+[ -n "$CAPTURE_DATE" ] || CAPTURE_DATE="$NOW"
+DATE_ONLY="$(printf '%s' "$CAPTURE_DATE" | grep -oE '^[0-9]{4}-[0-9]{2}-[0-9]{2}' || true)"
+[ -n "$DATE_ONLY" ] || DATE_ONLY="$(date +%Y-%m-%d)"
+YYYY_MM="${DATE_ONLY%??}"
+YYYY_MM="${YYYY_MM%-}"
+DD="${DATE_ONLY##*-}"
+[ -n "$BRANCH" ] || BRANCH="$(git -C "$SCRIPT_DIR" branch --show-current 2>/dev/null || true)"
+[ -n "$BRANCH" ] || BRANCH="develop"
+
+slugify() {
+  printf '%s' "$1" \
+    | tr '[:upper:]' '[:lower:]' \
+    | sed -E 's/[^a-z0-9]+/-/g; s/^-+|-+$//g' \
+    | cut -c1-50
+}
+
+SLUG="$(slugify "$TOPIC")"
+[ -n "$SLUG" ] || SLUG="session"
+AUTHOR_LC="$(printf '%s' "$AUTHOR" | tr '[:upper:]' '[:lower:]')"
+
+if [ "$CAPTURE_MODE" = "personal" ]; then
+  REL_FILE="wraps/${YYYY_MM}/${DD}-${AUTHOR_LC}-${SLUG}.md"
+  TITLE_PREFIX="Wrap"
+else
+  REL_FILE="sessions/${YYYY_MM}/${DD}-${AUTHOR_LC}-${SLUG}.md"
+  TITLE_PREFIX="Session"
+fi
+ABS_FILE="$SCRIPT_DIR/memory/$REL_FILE"
+mkdir -p "$(dirname "$ABS_FILE")"
+
+# Never overwrite an existing capture. Session IDs make concurrent same-topic
+# sessions deterministic while retaining the human-readable prefix.
+if [ -e "$ABS_FILE" ]; then
+  suffix="$(printf '%s' "${SESSION_ID:-$NOW}" | tr -cd 'a-zA-Z0-9' | tail -c 7)"
+  [ -n "$suffix" ] || suffix="2"
+  ABS_FILE="${ABS_FILE%.md}-${suffix}.md"
+  REL_FILE="${REL_FILE%.md}-${suffix}.md"
+fi
+
+{
+  printf '# %s: %s\n\n' "$TITLE_PREFIX" "$TOPIC"
+  printf '**Capture Schema**: %s\n' "$CAPTURE_SCHEMA"
+  printf '**Capture Mode**: %s\n' "$CAPTURE_MODE"
+  printf '**Date**: %s\n' "$CAPTURE_DATE"
+  printf '**Author**: %s\n' "${DISPLAY_NAME:-$AUTHOR}"
+  printf '**To**: %s\n' "$AUTHOR"
+  printf '**Branch**: %s\n' "$BRANCH"
+  [ -n "$SESSION_ID" ] && printf '**Session**: %s\n' "$SESSION_ID"
+  [ -n "$DURATION" ] && printf '**Duration**: %s\n' "$DURATION"
+  printf '\n## Summary\n\n%s\n' "$SUMMARY"
+  if [ -n "$DETAILS" ]; then
+    if [ "$CAPTURE_MODE" = "personal" ]; then
+      printf '\n## Notes\n\n%s\n' "$DETAILS"
+    else
+      printf '\n%s\n' "$DETAILS"
+    fi
+  fi
+} > "$ABS_FILE"
+
+memory_save() {
+  local message="$1"
+  (
+    cd "$SCRIPT_DIR/memory" 2>/dev/null || exit 0
+    git add "$REL_FILE" >/dev/null 2>&1 || exit 0
+    git commit --only --quiet -m "$message" -- "$REL_FILE" >/dev/null 2>&1 || true
+    if git remote get-url origin >/dev/null 2>&1; then
+      local _
+      for _ in 1 2 3; do
+        git pull --rebase origin main --quiet >/dev/null 2>&1 || true
+        git push origin main --quiet >/dev/null 2>&1 && exit 0
+        sleep 1
+      done
+      exit 1
+    fi
+  )
+}
+
+MEMORY_STATUS="skipped"
+if [ "$NO_PUSH" = "0" ]; then
+  if [ "$ASYNC_PUSH" = "1" ]; then
+    ( memory_save "Capture: ${AUTHOR} — ${TOPIC}" >/dev/null 2>&1 & ) >/dev/null 2>&1
+    MEMORY_STATUS="queued"
+  elif memory_save "Capture: ${AUTHOR} — ${TOPIC}"; then
+    MEMORY_STATUS="ok"
+  else
+    MEMORY_STATUS="failed"
+  fi
+fi
+
+GRAPH_STATUS="skipped"
+MODE="$(jq -r '.mode // "connected"' "$CONFIG" 2>/dev/null || echo connected)"
+if [ "$MODE" = "connected" ] && [ -n "$SESSION_ID" ]; then
+  # shellcheck disable=SC2016 # $name tokens are Cypher parameters.
+  CAPTURE_CYPHER='
+    MERGE (s:Session {id: $sessionId})
+    ON CREATE SET s.date = date($date), s.startedAt = datetime($capturedAt)
+    SET s.topic = $topic,
+        s.summary = $summary,
+        s.filePath = $filePath,
+        s.branch = $branch,
+        s.captureSchema = $captureSchema,
+        s.captureMode = $captureMode,
+        s.captureUpdatedAt = datetime()
+    FOREACH (_ IN CASE WHEN $captureMode = "personal" THEN [1] ELSE [] END |
+      SET s.status = "wrapped",
+          s.wrappedAt = coalesce(s.wrappedAt, datetime()),
+          s.openThreads = $openThreads)
+    FOREACH (_ IN CASE WHEN $captureMode = "baseline" THEN [1] ELSE [] END |
+      SET s.status = CASE
+            WHEN s.status IN ["wrapped","handed_off","completed"] THEN s.status
+            ELSE "captured"
+          END,
+          s.endedAt = coalesce(s.endedAt, datetime()))
+    WITH s
+    OPTIONAL MATCH (p:Person)
+    WHERE toLower(p.name) = toLower($author)
+       OR toLower(coalesce(p.github, "")) = toLower($author)
+    FOREACH (_ IN CASE WHEN p IS NOT NULL THEN [1] ELSE [] END |
+      MERGE (s)-[:BY]->(p))
+    RETURN s.id AS id'
+  CAPTURE_PARAMS="$(jq -nc \
+    --arg sessionId "$SESSION_ID" \
+    --arg date "$DATE_ONLY" \
+    --arg capturedAt "$NOW" \
+    --arg topic "$TOPIC" \
+    --arg summary "$SUMMARY" \
+    --arg filePath "$REL_FILE" \
+    --arg branch "$BRANCH" \
+    --arg captureSchema "$CAPTURE_SCHEMA" \
+    --arg captureMode "$CAPTURE_MODE" \
+    --arg author "$AUTHOR_LC" \
+    --argjson openThreads "$OPEN_THREADS_JSON" \
+    '{sessionId:$sessionId,date:$date,capturedAt:$capturedAt,topic:$topic,
+      summary:$summary,filePath:$filePath,branch:$branch,
+      captureSchema:$captureSchema,captureMode:$captureMode,author:$author,
+      openThreads:$openThreads}')"
+  GRAPH_WAL_LOCK_ATTEMPTS=1 \
+    bash "$SCRIPT_DIR/bin/graph-wal.sh" append "$CAPTURE_CYPHER" "$CAPTURE_PARAMS" >/dev/null 2>&1 || true
+  GRAPH_STATUS="queued"
+
+  # An explicit wrap is strong completion evidence. Queue the transition after
+  # the Session update; do not query the graph or wait for reconciliation here.
+  if [ "$CAPTURE_MODE" = "personal" ]; then
+    queue_handoff_completion "$SESSION_ID"
+  fi
+
+  if [ "$NO_RECONCILE" = "0" ] && [ "$CAPTURE_MODE" = "personal" ]; then
+    start_reconcile "$SESSION_ID" "$AUTHOR_LC" "$SUMMARY"
+  fi
+fi
+
+RESULT_FILE="${TMPDIR:-/tmp}/capture-run-result.json"
+jq -nc \
+  --arg schema "$CAPTURE_SCHEMA" \
+  --arg captureMode "$CAPTURE_MODE" \
+  --arg file "$REL_FILE" \
+  --arg absFile "$ABS_FILE" \
+  --arg sessionId "$SESSION_ID" \
+  --arg memoryStatus "$MEMORY_STATUS" \
+  --arg graphStatus "$GRAPH_STATUS" \
+  '{
+    captureSchema:$schema,
+    captureMode:$captureMode,
+    file:$file,
+    absFile:$absFile,
+    sessionId:$sessionId,
+    memoryStatus:$memoryStatus,
+    graphStatus:$graphStatus
+  }' > "$RESULT_FILE"
+
+printf 'capture: memory/%s\n' "$REL_FILE"

package/runtime/pi/bin/codex-render-spec.mjs

@@ -79,7 +79,8 @@ Use the runtime-neutral bridge instead of Claude Code slash commands:
 
 \`\`\`bash
 bin/agent.sh branch --topic "auth review"
-bin/agent.sh save --message "Save: auth review" --topic "auth review"
+bin/agent.sh save --message "Save: auth review" --topic "auth review" \\
+  --pr-body "$PR_BODY"   # body per .claude/context/pr-format.md (auto-skeleton if omitted)
 bin/agent.sh wrap --from alice --topic "auth review" \\
   --summary "Implemented the OAuth callback parser and documented follow-ups." \\
   --body "Open threads: review error cases and browser redirects."
@@ -218,19 +219,22 @@ If on develop after two messages, create a branch immediately from whatever cont
 
 ### Branch-guard protocol
 
-The \`.codex/hooks/branch-guard.js\` PreToolUse hook (enabled by the launcher via \`--enable hooks\`) denies writes, patches, and commits on \`develop\`/\`main\`/\`master\`. When it fires, choose between two paths based on how clear the topic is:
+The \`.codex/hooks/branch-guard.js\` PreToolUse hook (enabled by the launcher via \`--enable hooks\`) protects project writes on \`develop\`/\`main\`/\`master\`. Its block message is operational guidance, not a reason to interrupt the user with routine Git choices:
 
-- **Topic is obvious from the last turn** (user said "fix X", "add Y feature") → auto-branch silently with \`bin/agent.sh branch --topic "<topic>"\` (or the git checkout fallback), then continue. Say one sentence ("Creating \`dev/{author}/{slug}\`.") so the user isn't confused about why a new branch appeared.
-- **Topic is ambiguous** (open-ended exploration, user didn't specify what we're building yet) → ask **before** branching, in plain text with numbered options (Codex has no structured question tool):
+- **Topic is clear** (the user said "fix X", "add Y feature") → run \`bin/agent.sh branch --topic "<topic>"\` automatically, continue in the printed worktree, and say one short sentence so the branch change is visible. Do not ask the user to approve routine branching.
+- **Topic is genuinely ambiguous** → ask only for the topic, using compact numbered options:
 
   \`\`\`text
-  Need a working branch first. Topic?
+  What should I call this work?
     1. <suggested slug from context>
     2. <alternative slug>
     3. Other: (name it)
   \`\`\`
 
   Wait for the reply, then branch.
+- **The user explicitly requested the protected branch** → that request is consent. Record it with \`echo '{branch}' > .egregore-branch-consent\`, then retry. Never create the marker merely to silence the hook.
+
+Memory, managed-repo, and runtime-state writes should bypass the project guard. If one triggers it, correct the operation target/context instead of asking for protected-branch consent.
 
 If this Codex build does not support hooks, follow the same discipline as a standing instruction: never write or commit on develop/main/master.
 
@@ -248,20 +252,23 @@ Codex has no structured question tool — render each batch as compact numbered
 
 const LOOM_ROUTING_BODY = `Loom routes commands across model tiers on the Claude Code runtime (\`loom/routes.json\` + \`bin/loom.sh\` + a model-pinned executor subagent). Codex has no subagent delegation — every command runs inline in the current session. Ignore "Loom routing" preambles if you encounter them in a skill spec, and skip \`bin/loom.sh\` calls; \`loom/\` and \`.claude/agents/\` are framework files synced for the Claude runtime.`;
 
-const ISOLATION_BODY = `Sessions are confined to this project + memory + managed repos. On Codex this boundary is a standing instruction, not an enforced hook — hold it yourself.
+const ISOLATION_BODY = `Sessions are confined to this project + memory + managed repos, with a **two-tier boundary** — a hard wall between Egregore instances, a consent gate for everything else. On Codex the boundary is a standing instruction, not an enforced hook — hold it yourself.
 
-- **Never modify \`~/.egregore/instances.json\`** — managed by session-start.sh
-- **Never access another instance's files** — refuse even if asked
-- When a request points outside the boundary, do not improvise a workaround. Ask in plain text with numbered options:
+- **Hard tier — other Egregore instances.** Denied for every tool, always. There is no consent path. Never access another instance's files — refuse even if asked. Never modify \`~/.egregore/instances.json\` (managed by session-start.sh). When a request points at another instance's files there is nothing to ask — refuse and explain.
+- **Soft tier — paths outside the boundary.** Consent-gated. Inbox dirs (\`~/Downloads\`, \`~/Desktop\`) are readable without consent under the default posture; writes outside the project always need consent. Posture (\`strict | standard | open\`) and extra read roots come from \`egregore.json\` -> \`boundary { posture, read[], locked }\` (org, committed) merged with \`.egregore-boundary.local.json\` (personal, gitignored). \`locked: true\` removes the consent path entirely.
+- When a request needs soft-tier consent, do not improvise a workaround. Ask in plain text with numbered options:
 
   \`\`\`text
   That path is outside this Egregore's boundary. How should we proceed?
-    1. Paste the contents inline
-    2. Move the file into the repo and point me at the new path
-    3. Cancel
+    1. Allow its directory for this session (recorded in .egregore-boundary-consent)
+    2. Always allow on this instance (added to read[] in .egregore-boundary.local.json)
+    3. Paste the contents inline
+    4. Cancel
   \`\`\`
 
-See DEVELOPMENT.md §3 for boundary details.`;
+  Never record a consent grant without the user's explicit choice of option 1 or 2 in that exchange. Session grants are cleared on session start; \`locked: true\` removes options 1 and 2.
+
+See DEVELOPMENT.md §3 for boundary details and \`memory/knowledge/decisions/2026-07-08-boundary-hook-consent-design.md\` for the design decisions.`;
 
 // ── per-section rules ────────────────────────────────────────────────────
 const RULES = {
@@ -274,6 +281,14 @@ const RULES = {
     action: 'keep',
     note: 'Kept; /update, /contribute, /save tokens rendered as $skill tokens.',
   },
+  'Cross-Runtime Compatibility': {
+    action: 'keep',
+    note: 'Kept verbatim — framework parity applies equally to Claude Code, Codex, and Pi.',
+  },
+  'Voice': {
+    action: 'keep',
+    note: 'Kept — all runtimes can consult the shared voice rules and register-specific skills.',
+  },
   'On Launch — MANDATORY FIRST ACTION': {
     action: 'replace',
     body: ON_LAUNCH_BODY,
@@ -315,7 +330,7 @@ const RULES = {
   'Environment Isolation': {
     action: 'replace',
     body: ISOLATION_BODY,
-    note: 'boundary-check is a Claude PreToolUse hook with no .codex equivalent — behavior stated as a standing instruction; AskUserQuestion remediation -> numbered options.',
+    note: 'boundary-check is a Claude PreToolUse hook with no .codex equivalent — two-tier model stated as a standing instruction; AskUserQuestion remediation -> numbered options, now including the two consent-grant options (session grant -> .egregore-boundary-consent, instance grant -> .egregore-boundary.local.json read[]).',
   },
 };
 

package/runtime/pi/bin/codex-session-start.sh

@@ -6,7 +6,7 @@ set -o pipefail
 # libraries as Claude's SessionStart, then renders a terminal greeting before
 # Codex itself starts.
 
-FRAMEWORK_VERSION="6"
+FRAMEWORK_VERSION="7"
 SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
 cd "$SCRIPT_DIR" || exit 1
 
@@ -21,6 +21,9 @@ fi
 # Clear any branch-guard consent from a previous session — consent to write on
 # a protected branch is asked fresh each session (see AGENTS.md branch-guard protocol).
 rm -f "$SCRIPT_DIR/.egregore-branch-consent" "$MAIN_PROJECT_DIR/.egregore-branch-consent" 2>/dev/null
+# Same for boundary-crossing consent — grants are session-scoped (AGENTS.md
+# environment-isolation protocol); durable grants belong in .egregore-boundary.local.json.
+rm -f "$SCRIPT_DIR/.egregore-boundary-consent" "$MAIN_PROJECT_DIR/.egregore-boundary-consent" 2>/dev/null
 
 if [ -f "$SCRIPT_DIR/bin/lib/worktree-links.sh" ]; then
   source "$SCRIPT_DIR/bin/lib/worktree-links.sh" >/dev/null 2>/dev/null || true
@@ -43,6 +46,15 @@ source "$SCRIPT_DIR/bin/lib/hash.sh"
 source "$SCRIPT_DIR/bin/lib/time.sh"
 source "$SCRIPT_DIR/bin/lib/identity.sh" >/dev/null 2>/dev/null
 
+# Keep the durable local identity current before gathering context, then project
+# it to Supabase + Neo4j in the background so startup is never network-blocked.
+if [ -f "$STATE_FILE" ] && [ -f "$SCRIPT_DIR/bin/person.py" ]; then
+  python3 "$SCRIPT_DIR/bin/person.py" sync-local >/dev/null 2>&1 || true
+fi
+if [ -f "$SCRIPT_DIR/bin/person.sh" ]; then
+  ( bash "$SCRIPT_DIR/bin/person.sh" sync >/dev/null 2>&1 & ) 2>/dev/null
+fi
+
 LOCAL_MODE="false"
 [ "$(_detect_mode)" = "local" ] && LOCAL_MODE="true"
 
@@ -59,6 +71,10 @@ source "$SCRIPT_DIR/bin/lib/context.sh" >/dev/null 2>/dev/null
 source "$SCRIPT_DIR/bin/lib/metrics.sh" >/dev/null 2>/dev/null
 trap 'rm -rf "${CTX_DIR:-}"' EXIT
 
+# Rescue non-coding leftovers from sessions that died without ceremony
+# (terminal closed). Gated + idle-guarded inside the script; fire-and-forget.
+( bash "$SCRIPT_DIR/bin/session-autosave.sh" --sweep >/dev/null 2>&1 & ) 2>/dev/null
+
 read_json() {
   local file="$1"
   local expr="$2"
@@ -95,8 +111,9 @@ render_pending_line() {
     else
       printf '  ◐ %s pending %s - bin/agent.sh answer\n' "$PENDING_Q_COUNT" "$noun"
     fi
-  elif [ "$ADDRESSED_COUNT" -gt 0 ] 2>/dev/null; then
-    printf '  ◇ %s handoffs for %s - bin/agent.sh activity --for %s\n' "$ADDRESSED_COUNT" "$AUTHOR" "$AUTHOR"
+  fi
+  if [ "$ADDRESSED_COUNT" -gt 0 ] 2>/dev/null; then
+    printf '  ◇ %s handoffs for %s - say "show my handoffs" to review or close\n' "$ADDRESSED_COUNT" "$AUTHOR"
   fi
 }
 
@@ -154,7 +171,35 @@ render_card() {
     printf '%s%*s%s\n' "$footer_left" "$pad" "" "$footer_right"
   fi
 
-  if [ -n "$SLUG" ]; then
+  # Autosave trail — background saves since the last greeting (same ledger
+  # the Claude greeting reads; sweep rescues become visible here).
+  autosave_log="${EGREGORE_AUTOSAVE_LOG:-$HOME/.egregore/autosave.log}"
+  autosave_seen="${autosave_log}.seen"
+  if [ -f "$autosave_log" ]; then
+    total_as=$(grep -c '|autosave|' "$autosave_log" 2>/dev/null || echo 0)
+    seen_as=$(cat "$autosave_seen" 2>/dev/null || echo 0)
+    case "$seen_as" in ''|*[!0-9]*) seen_as=0 ;; esac
+    if [ "$total_as" -gt "$seen_as" ]; then
+      new_as=$((total_as - seen_as))
+      merged_as=$(grep '|autosave|' "$autosave_log" 2>/dev/null | tail -n "$new_as" | grep -c '|merged|' || echo 0)
+      if [ "$merged_as" -ge "$new_as" ]; then
+        printf '  ⟲ auto-saved %s non-coding save(s) → develop while you were away\n' "$new_as"
+      else
+        printf '  ⟲ auto-saved %s non-coding save(s) — %s merged, rest in open PRs\n' "$new_as" "$merged_as"
+      fi
+    fi
+    printf '%s' "$total_as" > "$autosave_seen" 2>/dev/null || true
+  fi
+
+  # Greeting links. Org config `pinned_links` in egregore.json replaces the
+  # default board link — same contract as bin/lib/greeting.sh.
+  pinned_links=$(jq -c '.pinned_links // []' "$CONFIG" 2>/dev/null || echo "[]")
+  if [ "$(printf '%s' "$pinned_links" | jq 'length' 2>/dev/null || echo 0)" -gt 0 ]; then
+    printf '%s' "$pinned_links" | jq -r '.[] |
+      if type == "string" then "  ◆ \(.)"
+      elif (.label // "") != "" then "  ◆ \(.label): \(.url)"
+      else "  ◆ \(.url)" end' 2>/dev/null
+  elif [ -n "$SLUG" ]; then
     board_url="https://egregore.xyz/view/${SLUG}/board"
     printf '  ◆ %s\n' "$board_url"
   fi

package/runtime/pi/bin/codex-skill-render.mjs

@@ -143,7 +143,9 @@ function renderActivity(data) {
   const graph = classifyGraph(data, { mode: data.mode || 'connected', attempt: 'retry' });
   const org = data.org || data.organization || 'Egregore';
   const date = data.date || '';
-  const me = data.me?.github || data.me?.name || data.github_username || '';
+  const me = typeof data.me === 'string'
+    ? data.me
+    : data.me?.github || data.me?.name || data.github_username || '';
   const handoffs = firstArray(data, ['handoffs_to_me', 'handoffs', 'pending_handoffs', 'me.handoffs', 'addressed_handoffs']);
   const questions = firstArray(data, ['questions', 'pending_questions', 'me.questions']);
   const prs = asArray(data.prs);
@@ -169,8 +171,20 @@ function renderActivity(data) {
     }
     if (handoffs.length > 0) {
       lines.push(padLine('HANDOFFS'));
-      handoffs.slice(0, 4).forEach((h) => {
-        lines.push(padLine(`○ ${valueOf(h, ['author', 'from'], 'someone')}: ${valueOf(h, ['topic', 'title'], 'handoff')}`));
+      const glyph = { pending: '●', read: '◐', claimed: '◆', done: '✓', completed: '✓', expired: '×' };
+      handoffs.slice(0, 6).forEach((h, index) => {
+        const status = valueOf(h, ['status'], 'pending');
+        const age = valueOf(h, ['ageDays', 'age_days'], '');
+        const intent = valueOf(h, ['intent'], '');
+        const meta = [
+          age === '' ? '' : `${age}d`,
+          intent && intent !== 'unclassified' ? intent : '',
+          status,
+        ].filter(Boolean).join(' · ');
+        lines.push(padLine(
+          `[${index + 1}] ${glyph[status] || '○'} ⇌ ${valueOf(h, ['author', 'from'], 'someone')}: ${valueOf(h, ['topic', 'title'], 'handoff')}`,
+          meta,
+        ));
       });
     }
   }
@@ -197,7 +211,12 @@ function renderActivity(data) {
   }
 
   lines.push(rule());
-  lines.push(padLine('Focus choices: handoffs, questions, recent work, dashboard, done'));
+  if (handoffs.length > 0) {
+    lines.push(padLine('Handoff actions: done N · expire N · reopen N'));
+    lines.push(padLine('Type a number to act, or keep working.'));
+  } else {
+    lines.push(padLine('Focus choices: questions, recent work, dashboard, done'));
+  }
   lines.push(bottomRule());
   return lines.join('\n');
 }