create-egregore 0.20.2 → 0.21.0-runtime-mvp.2

package/runtime/pi/.pi/extensions/egregore.ts

@@ -3,6 +3,7 @@ import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { isConsentCommand, isMutatingBash, isRuntimeStatePath, mutatesOnlyRuntimeState } from "../../bin/pi-branch-policy.mjs";
+import { registerObserveHook } from "../../bin/pi-observe-context.mjs";
 import {
   activityDataPath,
   captureSessionEnd,
@@ -84,6 +85,12 @@ export default function egregore(pi) {
   let activeWorkflow = "";
   const hasEntryRenderer = typeof pi.registerEntryRenderer === "function";
 
+  registerObserveHook(pi, {
+    root,
+    harness: "pi",
+    shouldObserve: () => !activeWorkflow,
+  });
+
   const appendCard = (kind, text) => {
     const content = String(text || "").trimEnd();
     if (hasEntryRenderer) {

package/runtime/pi/.pi/spec-manifest.json

@@ -1,8 +1,8 @@
 {
   "generatedBy": "bin/pi-render-spec.mjs",
   "source": "AGENTS.md generated Codex spec",
-  "sourceHash": "b0b4451961ef",
-  "outputHash": "52773e6edfc8",
+  "sourceHash": "76c76679f791",
+  "outputHash": "cf5aa8ffd739",
   "adaptations": [
     "Pi project trust and APPEND_SYSTEM delivery",
     "Pi tool_call branch gate",

package/runtime/pi/AGENTS.md

@@ -9,16 +9,11 @@
 > Egregore skill already covers. This file exists only for runtimes that cannot
 > read `CLAUDE.md`.
 >
-> **If you are Pi** (the `pi` coding-agent harness): **stop here.** Your
-> authoritative Egregore instructions are loaded from
-> `.pi/APPEND_SYSTEM.md`, and your workflows are exposed through the
-> project-local `.pi/` runtime. Do not follow the Codex-specific block below.
->
-> **If you are Prime Agent** (the `prime-agent` harness): **stop here.** Your
-> authoritative Egregore instructions are loaded from
-> `.prime/agent/APPEND_SYSTEM.md`, and your workflows are exposed through the
-> project-local `.prime/agent/` runtime. Do not follow the Codex-specific
-> block below.
+> **If you are Pi or Prime Agent:** **stop here.** Your authoritative
+> Egregore instructions are loaded from `.pi/APPEND_SYSTEM.md` (Pi) or
+> `.prime/agent/APPEND_SYSTEM.md` (Prime), and your workflows are exposed
+> through that project-local runtime. Do not follow the Codex-specific block
+> below.
 >
 > **If you are Codex or another shell-only agent:** this file is yours — continue.
 
@@ -166,7 +161,7 @@ Sequence: **intent → safe workspace → relevant context → consequential ass
 When the user continues the current branch's work or asks to resume — sequence: **continuation intent → prior workspace → restored context → open threads → resumed execution**:
 
 - Do not create a new workspace for the same topic. After confirming relevance, say: `I found your previous work on **{topic}** and restored its workspace and context.` Show `Workspace: {branch} (worktree).` secondarily.
-- Retrieve relevant decisions, handoffs, or prior work; keep the Retrieval Beat and `↳ Context restored:` receipt. Never claim context was restored from a branch name alone.
+- Interpret continuation from meaning, not fixed phrases. Reuse sufficient `EGREGORE_ORG_CONTEXT_V1`; otherwise make exactly one `bash bin/search.sh query "<concept>" -n 6 --compact` call. Keep the Retrieval Beat and `↳ Context restored:` receipt. Never infer context from a branch or substitute status dashboards, Git, Graph, or raw memory scans.
 - Name only unresolved items that could change the next move, state the next outcome briefly, and continue without replaying setup.
 
 ### Handoff claiming
@@ -235,22 +230,20 @@ In connected mode, infrastructure credentials (Neo4j, Telegram) live on the API
 
 ---
 
-## Knowledge Graph
-
-**Connected mode only.** For the following intents, the named read must be the
-first retrieval action. Run the exact command with its safe default limit before
-opening files, running broad grep, inspecting `graph-op.sh`, or writing Cypher:
+## Optional Knowledge Graph Projection
 
-- current work addressed to someone → `bash bin/graph-op.sh open-handoffs "<user>"`
-- unanswered questions for someone → `bash bin/graph-op.sh pending-questions "<user>"`
-- handoff → implementation → branch/PR/direction → `bash bin/graph-op.sh lineage "<topic>"`
-- company/person/topic across meetings → `bash bin/graph-op.sh meeting-history "<entity-or-topic>"`
+**Connected mode only, explicit opt-in only, and never part of default
+retrieval.** Egregore Runtime Observe backed by the instance-owned QMD adapter
+is the default organizational retrieval path in every mode. Never infer graph
+use from words such as handoff, question, meeting, status, current work, or
+lineage. Those intents still enter Runtime/QMD unless the user explicitly asks
+for graph relationships or a workflow explicitly requests optional Connected
+enrichment.
 
-A question about calls, meetings, transcripts, demos, or how a conversation
-evolved is always `meeting-history` intent when it names a company, person, or
-topic—even when it does not ask for "current" or "live" state. Pass the shortest
-discriminative entity or topic (for example, `meeting-history "42CAP"`), not the
-whole question.
+For an explicit graph-projection request, use the smallest named read that
+answers it: `open-handoffs`, `pending-questions`, `lineage`, or
+`meeting-history`. Verify projection freshness/coverage and open its canonical
+`evidencePath` before acting. Canonical Markdown wins on disagreement.
 
 Run `catalog` only when the route is unclear. Named reads return bounded stable fields and exact canonical `evidencePath` pointers; open only the returned files needed to answer. When a read reports partial coverage, use `unprojectedPaths` rather than claiming those files are represented in the graph. Use `bin/graph.sh` for unsupported Neo4j queries and never construct curl calls directly. See DEVELOPMENT.md §1 for the schema. In local mode there is no graph; read `memory/` directly.
 
@@ -258,47 +251,52 @@ Run `catalog` only when the route is unclear. Named reads return bounded stable
 
 ## Egregore Retrieval Beat
 
-Egregore's organizational search is a product surface, not indistinguishable
-agent tool use. For each user-directed lookup of organizational knowledge,
-show exactly one visible attribution line:
+For each user-directed organizational lookup, show exactly one visible line:
 
 - memory-only retrieval:
   `⌕ Egregore · searching your organization’s memory`
 - retrieval that actually queries the connected graph:
   `⌕ Egregore Connect · searching your organization’s memory and relationships`
 
-**Visibility is the contract.** Emit the applicable line verbatim as a
+Runtime owns retrieval; no agent feature flag does. `EGREGORE_ORG_CONTEXT_V1`
+is only the schema label. When attached, authorized retrieval is complete:
+never query again that turn, and state any evidence gap. `OPENED_BY_OBSERVE`
+means the evidence is open. A later explicit search starts a new turn.
+
+**Visibility is the contract.** Emit it verbatim as a
 standalone assistant message before the first Bash, Grep, Glob, Read, or other
-retrieval tool call. Shell/tool output does not satisfy this requirement:
-Claude Code and other harnesses may collapse it. Do not paraphrase the line or
-replace it with generic narration such as “I’ll search org memory.”
+retrieval tool call.
+Shell/tool output does not satisfy this requirement. Do not paraphrase the line.
 
-Use the memory form for local/filesystem-only organizational retrieval. Use the
-Connect form when the retrieval route will query the connected graph, including
-automatic graph enrichment in `bin/search.sh query`, a graph-only named read,
-or exploratory Cypher. Emit once for the whole retrieval episode, not once per
-hop. The banner printed by `bin/search.sh` remains a direct-shell fallback and
-does not replace the assistant-visible beat.
+Use the memory form normally; use Connect only for an explicit graph traversal
+that actually runs. Emit once per episode. A `bin/search.sh` banner is only a
+shell fallback and does not replace this visible beat.
 
-**Routing is part of the contract.** For organizational history, decisions,
-handoffs, meetings, people, pricing, strategy, or other shared-memory content,
-the first retrieval action is:
+**Routing:** Organizational recall always enters Egregore Runtime. The model is
+the semantic intent authority, deciding from meaning rather than fixed phrases.
+Observe is optional prefetch; a prefetch miss never means recall is unnecessary.
+Without sufficient attached context, make exactly one Runtime/QMD call:
 
 ```bash
-bash bin/search.sh query "<concept>" -n 6
+bash bin/search.sh query "<concept>" -n 6 --compact
 ```
 
-Do not start by resolving `memory/` to its sibling repository, changing
-directory into that absolute path, or improvising `grep`/`ls` over it. The
-search entry point owns keyword/semantic selection and automatically attaches
-graph state in connected mode. Read or grep the returned `memory/...` source
-paths only after the ranked call when verification needs the full document.
-Native Grep/Glob remain the right first action for repository code, filenames,
-and exact error strings—not organizational recall.
-
-Do not emit the beat for native repository/code search, Git inspection, startup
-context hydration, graph writes, ingestion projection, background sync,
-maintenance, or command-internal queries that are not answering a user lookup.
+Search output is model-internal: show only the retrieval line and receipts —
+never ranked blocks, file/rank/excerpt metadata, or raw JSON.
+
+Do not resolve `memory/` to its sibling repo or start with raw `grep`/`ls`.
+Search owns lexical/semantic selection and attaches no graph by default. Open a
+source only when its excerpt cannot support a necessary claim. For current
+team/person synthesis, retain known organization/member names and choose
+`--recent-days` plus `--min-evidence`. Use native
+Grep/Glob for code and exact errors. `$activity`, `$dashboard`, and `$project`
+display bounded status surfaces only when named or directly requested as a
+card. Questions asking for an explained synthesis of current organizational
+work are Runtime/QMD recall, as is prior-work discovery. Do not run full
+hybrid retrieval on unrelated prompts or infer graph from recall intent.
+
+Do not emit the beat for code search, Git inspection, startup hydration, graph
+writes, ingestion, background sync, maintenance, or internal queries.
 Never name `Egregore Connect` unless a graph read will actually run.
 
 ---
@@ -398,7 +396,7 @@ Repos in `egregore.json` → `repos[]` are cloned as siblings (`../{repo}/`). Ea
 
 ## Working Conventions
 
-- Check memory before starting unfamiliar work — `bash bin/search.sh query "topic"` (hybrid search over all of `memory/`)
+- For unfamiliar org work, use Observe context; if absent, run `bash bin/search.sh query "topic" --compact`.
 - Document significant decisions in `memory/knowledge/decisions/`
 - After substantial sessions, log to `memory/handoffs/` and update `index.md`
 
@@ -422,10 +420,16 @@ Invoke commands from user intent — don't wait for the slash. Each command file
 
 **Disambiguation:**
 - Knowledge: `$reflect` (share-ready) · `$note` (half-baked) · `$deep-reflect` (deep research over memory — questions AND cross-referencing) · `$archive` (AI patterns) · `$audit` (evidence-mined forensic sweep of the org's own record — any target)
-- Finding things — **organizational recall starts with `bash bin/search.sh query`** (ranked filesystem retrieval in OSS; automatic relationship/status enrichment in Connect). Use `bin/graph.sh` named reads first only for a pure relationship/status traversal. Use Grep/Glob first for repository code, filenames, and exact error strings—not shared-memory recall. Do not `cd` into the sibling memory repository.
-- Finding **something you generated** (a scroll, handoff, emissary, decision, any hosted egregore.xyz link): `bash bin/artifacts.sh find <query>`. Every generative surface already records into memory — hosted artifacts self-register into `memory/artifacts/` at publish (and the record is committed+pushed, so it's findable from *any* session, not just the one that made it); handoffs land in `memory/handoffs/`, emissaries in `memory/handoffs/outbound/`, decisions/findings/patterns in `memory/knowledge/`. The finder searches **all** of them, ranks title/topic matches above passing body mentions, tags each hit by type (`[document]`/`[handoff]`/`[emissary]`/`[decision]`), and surfaces the shareable URL. Findable by **content, not just name**, across all three layers — grep-first for OSS, folding in search + graph when available. *"bring me the artifact where I laid out our GTM plan"* → this.
+- Finding things — **organizational recall starts with automatic Observe**.
+  Never query twice in one prompt. Without its context block, use
+  `bash bin/search.sh query`. Use Grep/Glob for code and exact errors, not org
+  recall. Do not `cd` into the sibling memory repository.
+- Finding **something you generated** (a scroll, handoff, emissary, decision, any hosted egregore.xyz link): `bash bin/artifacts.sh find <query>`. Every generative surface records into memory — hosted artifacts self-register into `memory/artifacts/` at publish (committed+pushed, findable from any session); handoffs in `memory/handoffs/`, emissaries in `memory/handoffs/outbound/`, decisions/findings/patterns in `memory/knowledge/`. The finder searches all of them by **content, not just name**, ranks title/topic matches above body mentions, tags hits by type (`[document]`/`[handoff]`/`[emissary]`/`[decision]`), and surfaces the shareable URL — grep-first in OSS, search + graph when available. *"bring me the artifact where I laid out our GTM plan"* → this.
 - Artifacts with questions: `$scroll` (living paper + embedded harvest, updates in place) · `$view` (static render) · `$harvest` (elicitation, no published face) · `$mock` (pre-build walkthrough of decided design — gauge per stop, verdict copy-back)
-- Status: `$dashboard` (personal) · `$activity` (org-wide)
+- Explicit bounded status: `$dashboard` (personal) · `$activity` (org-wide) ·
+  `$project` (named project). These display cards when named or directly
+  requested. Analytical questions about organizational work and specific
+  prior-work continuation route through Runtime/QMD recall.
 - Ending: `$wrap` (personal closure) · `$handoff` (notes for others) · `$save` (still working)
 - Tasks: `$todo` (personal) · `$quest` (team exploration) · `$issue` (something broken)
 - Questions: `$ask [person]` (async) · just ask (agent answers from context)
@@ -475,7 +479,7 @@ Egregore runs in one of two configurations, set by `mode` in `egregore.json`. De
 - If a feature requires the hosted service and has no upsell gate, say so plainly ("this isn't available in this configuration") and stop.
 - Calling `bin/graph.sh` or `bin/notify.sh` in local mode is harmless — they fail soft and return empty results — but there is no need to call them; prefer reading `memory/` directly.
 
-**Connected mode** (`"mode": "connected"`, `api_url` set) — the hosted configuration, used by organizations on the hosted service. Full feature set: Neo4j knowledge graph via `bin/graph.sh`, Telegram notifications via `bin/notify.sh`, dashboard publication, API-backed context gathering on session start. Use `$env` to check API key, `$checkup` for diagnostics. If the graph is offline, show troubleshooting.
+**Connected mode** (`"mode": "connected"`, `api_url` set) — the hosted configuration, used by organizations on the hosted service. Shared control-plane services include accounts, organizations, memberships, invitations, and entitlements. Optional derived graph projection, notifications, and hosted surfaces remain explicit adapters. Local organizational content and retrieval stay local unless a future capability is explicitly enabled. Use `$env` to check API key and `$checkup` for diagnostics.
 
 ---
 

package/runtime/pi/bin/activity-action.sh

@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Recipient-scoped lifecycle actions used by /activity.
+# Usage: bash bin/activity-action.sh <read|claim|done|expire|reopen|review> <artifact-id>
+#        [--user HANDLE]
+
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+ACTION="${1:-}"
+SID="${2:-}"
+shift 2 2>/dev/null || true
+USER_REF=""
+EXPECTED_REVISION=""
+USE_LEGACY_GRAPH=false
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --user) USER_REF="${2:?missing user}"; shift 2 ;;
+    --expected-revision) EXPECTED_REVISION="${2:?missing lifecycle revision}"; shift 2 ;;
+    --graph) USE_LEGACY_GRAPH=true; shift ;;
+    *) jq -n --arg option "$1" '{error:"unknown option",option:$option}'; exit 2 ;;
+  esac
+done
+
+case "$ACTION" in
+  read|claim|done|expire|reopen|review) ;;
+  *) jq -n '{error:"unsupported lifecycle action"}'; exit 2 ;;
+esac
+[[ -n "$SID" ]] || { jq -n '{error:"missing session id"}'; exit 2; }
+
+if [[ "$USE_LEGACY_GRAPH" != true ]]; then
+  export PYTHONPATH="$SCRIPT_DIR${PYTHONPATH:+:$PYTHONPATH}"
+  ARGS=(action "$ACTION" "$SID" --reason explicit_user_action)
+  [ -z "$USER_REF" ] || ARGS+=(--user "$USER_REF")
+  [ -z "$EXPECTED_REVISION" ] || ARGS+=(--expected-revision "$EXPECTED_REVISION")
+  exec python3 -m egregore_runtime.lifecycle_cli "${ARGS[@]}"
+fi
+
+case "$ACTION" in
+  read|done|expire|reopen) ;;
+  *) jq -n '{error:"legacy graph compatibility supports read, done, expire, and reopen only"}'; exit 2 ;;
+esac
+
+MODE="$(jq -r '.mode // "connected"' "$SCRIPT_DIR/egregore.json" 2>/dev/null || echo connected)"
+if [[ "$MODE" == "local" ]]; then
+  jq -n '{
+    applied:false,
+    availability:"unavailable_in_this_configuration",
+    reason:"handoff lifecycle state is graph-backed"
+  }'
+  exit 0
+fi
+
+if [[ -z "$USER_REF" ]]; then
+  USER_REF="$(jq -r '.github_username // empty' "$SCRIPT_DIR/.egregore-state.json" 2>/dev/null || true)"
+fi
+if [[ -z "$USER_REF" ]]; then
+  USER_REF="$(git -C "$SCRIPT_DIR" config user.name 2>/dev/null || true)"
+fi
+[[ -n "$USER_REF" ]] || { jq -n '{error:"could not resolve current user"}'; exit 2; }
+
+case "$ACTION" in
+  read) OP="mark-read"; EXPECTED="read" ;;
+  done) OP="mark-done"; EXPECTED="done" ;;
+  expire) OP="mark-expired"; EXPECTED="expired" ;;
+  reopen) OP="reopen-handoff"; EXPECTED="pending" ;;
+esac
+
+RESULT="$(bash "$SCRIPT_DIR/bin/graph-op.sh" "$OP" "$SID" "$USER_REF")"
+if ! printf '%s\n' "$RESULT" | jq -e '.values[0][0] != null' >/dev/null 2>&1; then
+  jq -n \
+    --arg action "$ACTION" \
+    --arg id "$SID" \
+    --arg user "$USER_REF" \
+    '{applied:false,action:$action,id:$id,user:$user,
+      error:"handoff not found, not addressed to this user, or transition not allowed"}'
+  exit 3
+fi
+
+printf '%s\n' "$RESULT" | jq \
+  --arg action "$ACTION" \
+  --arg expected "$EXPECTED" \
+  --arg user "$USER_REF" '
+    {
+      applied:true,
+      action:$action,
+      id:.values[0][0],
+      topic:(.values[0][1] // ""),
+      status:(.values[0][2] // $expected),
+      user:$user
+    }
+  '

package/runtime/pi/bin/activity-data.sh

@@ -1,238 +1,17 @@
 #!/usr/bin/env bash
-# Fetches all activity dashboard data: single API call + parallel git/disk ops.
-# Usage: bash bin/activity-data.sh [username]
-# Returns a single JSON object with all query results.
+# One bounded, authorized, canonical Runtime snapshot for the activity ritual.
+set -euo pipefail
 
-SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
-TMPDIR=$(mktemp -d)
-trap "rm -rf $TMPDIR" EXIT
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 
-# --- Read config ---
-API_URL=$(jq -r '.api_url // empty' "$SCRIPT_DIR/egregore.json" 2>/dev/null)
-API_KEY="${EGREGORE_API_KEY:-$(grep '^EGREGORE_API_KEY=' "$SCRIPT_DIR/.env" 2>/dev/null | cut -d'=' -f2-)}"
-ORG=$(jq -r '.org_name // "Egregore"' "$SCRIPT_DIR/egregore.json" 2>/dev/null || echo "Egregore")
-DATE=$(date '+%b %d')
-
-source "$SCRIPT_DIR/bin/lib/handoff-meta.sh" >/dev/null 2>/dev/null || true
-
-# --- Detect user ---
-GH_USER="${1:-}"
-if [ -z "$GH_USER" ]; then
-  STATE_FILE="$SCRIPT_DIR/.egregore-state.json"
-  if [ -f "$STATE_FILE" ]; then
-    GH_USER=$(jq -r '.github_username // empty' "$STATE_FILE" 2>/dev/null)
-  fi
-  if [ -z "$GH_USER" ]; then
-    GH_USER=$(git -C "$SCRIPT_DIR" config user.name 2>/dev/null || echo "unknown")
-  fi
+# Compatibility: the positional handle is intentionally ignored. Identity is
+# resolved by Egregore Runtime, not by a GitHub username supplied by a harness.
+if [ "${1:-}" = "--help" ]; then
+  echo "usage: bash bin/activity-data.sh"
+  exit 0
 fi
 
-EMPTY='{"fields":[],"values":[]}'
-
-# --- Fire API call + git/disk ops in parallel ---
-
-# Graph data: single API call (all queries run server-side)
-(
-  GRAPH_STATUS="offline"
-  GRAPH_REASON=""
-  if [ -z "$API_URL" ] || [ -z "$API_KEY" ]; then
-    GRAPH_REASON="missing_config"
-  else
-    # Store HTTP status code alongside response body. curl already emits 000
-    # on transport failure; keep the exit status separate so it cannot become
-    # 000000 and fall through as an invalid JSON response.
-    CURL_STATUS=0
-    HTTP_CODE=$(curl -s -o "$TMPDIR/activity_raw.json" -w "%{http_code}" \
-      "${API_URL}/api/activity/dashboard?github_username=$(printf '%s' "$GH_USER" | jq -sRr @uri)" \
-      -H "Authorization: Bearer $API_KEY" \
-      --connect-timeout 5 --max-time 15 2>/dev/null) || CURL_STATUS=$?
-
-    if [ "$CURL_STATUS" -ne 0 ] || [ "$HTTP_CODE" = "000" ] || ! [[ "$HTTP_CODE" =~ ^[0-9][0-9][0-9]$ ]]; then
-      GRAPH_REASON="unreachable"
-    elif [ "$HTTP_CODE" = "401" ] || [ "$HTTP_CODE" = "403" ]; then
-      GRAPH_REASON="auth_error"
-    elif [ "$HTTP_CODE" -ge 500 ] 2>/dev/null; then
-      GRAPH_REASON="server_error"
-    elif [ -s "$TMPDIR/activity_raw.json" ] && jq -e '.me' "$TMPDIR/activity_raw.json" >/dev/null 2>&1; then
-      cp "$TMPDIR/activity_raw.json" "$TMPDIR/activity.json"
-      GRAPH_STATUS="connected"
-    else
-      GRAPH_REASON="invalid_response"
-    fi
-  fi
-
-  # If not connected, write status-only response
-  if [ "$GRAPH_STATUS" != "connected" ]; then
-    jq -n --arg status "$GRAPH_STATUS" --arg reason "$GRAPH_REASON" \
-      '{graph_status: $status, graph_reason: $reason}' > "$TMPDIR/activity.json"
-  else
-    # Inject graph_status into successful response
-    jq --arg status "$GRAPH_STATUS" '. + {graph_status: $status}' \
-      "$TMPDIR/activity.json" > "$TMPDIR/activity_merged.json" \
-      && mv "$TMPDIR/activity_merged.json" "$TMPDIR/activity.json"
-  fi
-) &
-API_PID=$!
-
-# Git/disk: runs in parallel (stays client-side)
-(
-  # Refresh remote refs only. A data read must never mutate the working
-  # branch: the rebase this block used to run rewrote users' task branches as
-  # a side effect of /activity (observed rewinding a pushed branch mid-session).
-  # Workspace sync belongs to agent.sh sync / the session-start path.
-  git -C "$SCRIPT_DIR" fetch origin --quiet 2>/dev/null || true
-
-  # Memory sync
-  if [ -d "$SCRIPT_DIR/memory/.git" ] || [ -L "$SCRIPT_DIR/memory" ]; then
-    git -C "$SCRIPT_DIR/memory" fetch origin main --quiet 2>/dev/null || true
-    LOCAL=$(git -C "$SCRIPT_DIR/memory" rev-parse HEAD 2>/dev/null || echo "")
-    REMOTE=$(git -C "$SCRIPT_DIR/memory" rev-parse origin/main 2>/dev/null || echo "")
-    if [ -n "$LOCAL" ] && [ -n "$REMOTE" ] && [ "$LOCAL" != "$REMOTE" ]; then
-      git -C "$SCRIPT_DIR/memory" pull origin main --quiet 2>/dev/null || true
-    fi
-  fi
-
-  # PRs
-  PRS=$(cd "$SCRIPT_DIR" && gh pr list --base develop --state open --json number,title,author 2>/dev/null || echo "[]")
-  echo "$PRS" > "$TMPDIR/prs.json"
-
-  # Disk cross-reference
-  MONTH=$(date +%Y-%m)
-  TODAY=$(date +%d)
-  YESTERDAY=$(date -v-1d +%d 2>/dev/null || date -d 'yesterday' +%d 2>/dev/null || echo "00")
-  HANDOFFS=$(ls -1 "$SCRIPT_DIR/memory/handoffs/$MONTH/" 2>/dev/null | grep "^${TODAY}-\|^${YESTERDAY}-" 2>/dev/null | head -10 || echo "")
-  echo "$HANDOFFS" > "$TMPDIR/disk_handoffs.txt"
-
-  DECISIONS=$(ls -1t "$SCRIPT_DIR/memory/knowledge/decisions/" 2>/dev/null | head -5 || echo "")
-  echo "$DECISIONS" > "$TMPDIR/disk_decisions.txt"
-) &
-GIT_PID=$!
-
-# Local sessions: parse memory files when graph is offline (parallel)
-(
-  GH_LC=$(echo "$GH_USER" | tr '[:upper:]' '[:lower:]')
-  DISPLAY_LC=""
-  if [ -f "$SCRIPT_DIR/.egregore-state.json" ]; then
-    DISPLAY_LC=$(jq -r '.display_name // empty' "$SCRIPT_DIR/.egregore-state.json" 2>/dev/null | tr '[:upper:]' '[:lower:]')
-  fi
-
-  CUTOFF=$(date -v-14d +%Y-%m-%d 2>/dev/null || date -d '14 days ago' +%Y-%m-%d 2>/dev/null || echo "2000-01-01")
-  MY="[]"
-  TEAM="[]"
-
-  # Scan sessions, wraps, and handoffs
-  ALL_ENTRIES=""
-  for DIR in "$SCRIPT_DIR/memory/sessions" "$SCRIPT_DIR/memory/wraps" "$SCRIPT_DIR/memory/handoffs"; do
-    [ -d "$DIR" ] || continue
-    TYPE=$(basename "$DIR")
-    find -L "$DIR" -name '*.md' -not -name 'index*' -type f 2>/dev/null | xargs ls -t 2>/dev/null | head -20 | while read -r MFILE; do
-      [ -z "$MFILE" ] && continue
-      M_AUTH=$(head -10 "$MFILE" 2>/dev/null | grep -m1 '^\*\*Author\*\*:' | sed 's/^\*\*Author\*\*:[[:space:]]*//')
-      M_DATE=$(head -10 "$MFILE" 2>/dev/null | grep -m1 '^\*\*Date\*\*:' | sed 's/^\*\*Date\*\*:[[:space:]]*//')
-      M_BRANCH=$(head -10 "$MFILE" 2>/dev/null | grep -m1 '^\*\*Branch\*\*:' | sed 's/^\*\*Branch\*\*:[[:space:]]*//')
-      M_DURATION=$(head -10 "$MFILE" 2>/dev/null | grep -m1 '^\*\*Duration\*\*:' | sed 's/^\*\*Duration\*\*:[[:space:]]*//')
-      M_TOPIC=$(head -3 "$MFILE" 2>/dev/null | grep -m1 '^# ' | sed 's/^# [^:]*:[[:space:]]*//')
-      [ -z "$M_AUTH" ] && continue
-      # Date filter
-      M_DAY="${M_DATE%%T*}"
-      [ -n "$M_DAY" ] && [ "$M_DAY" \< "$CUTOFF" ] && continue
-      echo "${M_AUTH}|${M_DATE}|${M_BRANCH}|${M_TOPIC}|${M_DURATION}|${TYPE}"
-    done
-  done | jq -Rn --arg gh "$GH_LC" --arg dn "$DISPLAY_LC" '
-    [inputs | split("|") |
-      {author: .[0], date: .[1], branch: .[2], topic: .[3], duration: .[4], type: .[5]}
-    ] | {
-      my_sessions: [.[] | select((.author | ascii_downcase) == $gh or (.author | ascii_downcase) == $dn) | select($dn != "" or (.author | ascii_downcase) == $gh)],
-      team_sessions: [.[] | select((.author | ascii_downcase) != $gh and (if $dn != "" then (.author | ascii_downcase) != $dn else true end))]
-    }
-  ' 2>/dev/null > "$TMPDIR/local_sessions.json" || echo '{"my_sessions":[],"team_sessions":[]}' > "$TMPDIR/local_sessions.json"
-) &
-LOCAL_PID=$!
-
-# --- Wait for all ---
-wait $API_PID $GIT_PID $LOCAL_PID 2>/dev/null || true
-
-# --- Read results ---
-PRS=$(cat "$TMPDIR/prs.json" 2>/dev/null || echo "[]")
-echo "$PRS" | jq . >/dev/null 2>&1 || PRS="[]"
-
-# Resolve PR author GitHub logins -> egregore display names. `gh pr list` returns
-# the raw github login (e.g. "alice-gh"); without this it leaks into activity
-# instead of the person's display name ("Alice"). Map via the graph when connected;
-# fall back to the github profile name, then the login. Author becomes a string.
-if [ -n "$PRS" ] && [ "$PRS" != "[]" ]; then
-  AUTHOR_MAP='{}'
-  if [ -n "$API_URL" ] && [ -n "$API_KEY" ]; then
-    MAP_RAW=$(bash "$SCRIPT_DIR/bin/graph.sh" query \
-      "MATCH (p:Person) WHERE p.github IS NOT NULL RETURN p.github AS gh, p.name AS name" 2>/dev/null)
-    AUTHOR_MAP=$(printf '%s' "$MAP_RAW" | jq -c \
-      'reduce (.values[]?) as $v ({}; .[($v[0]|ascii_downcase)] = $v[1])' 2>/dev/null || echo '{}')
-  fi
-  PRS=$(printf '%s' "$PRS" | jq -c --argjson map "$AUTHOR_MAP" '
-    map(
-      (if (.author|type)=="object" then .author else {login: (.author|tostring), name: null} end) as $a
-      | .author = ([$map[(($a.login // "") | ascii_downcase)], $a.name, $a.login]
-                   | map(select(. != null and . != "")) | first // "unknown")
-    )' 2>/dev/null || printf '%s' "$PRS")
-fi
-DISK_HANDOFFS=$(cat "$TMPDIR/disk_handoffs.txt" 2>/dev/null || echo "")
-DISK_DECISIONS=$(cat "$TMPDIR/disk_decisions.txt" 2>/dev/null || echo "")
-LOCAL_SESSIONS=$(cat "$TMPDIR/local_sessions.json" 2>/dev/null || echo '{"my_sessions":[],"team_sessions":[]}')
-echo "$LOCAL_SESSIONS" | jq . >/dev/null 2>&1 || LOCAL_SESSIONS='{"my_sessions":[],"team_sessions":[]}'
-
-handoff_metadata_map() {
-  local json="$1"
-
-  if ! declare -F eg_handoff_metadata_json >/dev/null 2>&1; then
-    echo "{}"
-    return
-  fi
-
-  printf '%s\n' "$json" | jq -r '
-    [(.handoffs_to_me[]?.filePath // empty), (.all_handoffs[]?.filePath // empty)]
-    | map(select(. != ""))
-    | unique[]
-  ' 2>/dev/null | while IFS= read -r rel; do
-    [ -z "$rel" ] && continue
-    file="$SCRIPT_DIR/memory/$rel"
-    [ -f "$file" ] || continue
-    eg_handoff_metadata_json "$file" | jq -c --arg rel "$rel" '{key:$rel, value:{author:.author, topic:.topic, date:.date}}'
-  done | jq -sc 'map({(.key): .value}) | add // {}' 2>/dev/null || echo "{}"
-}
-
-# --- Merge server response + local git/disk data ---
-FINAL_JSON=$(jq -n \
-  --arg org "$ORG" \
-  --arg date "$DATE" \
-  --slurpfile activity "$TMPDIR/activity.json" \
-  --argjson prs "$PRS" \
-  --arg disk_handoffs "$DISK_HANDOFFS" \
-  --arg disk_decisions "$DISK_DECISIONS" \
-  --argjson local_sessions "$LOCAL_SESSIONS" \
-  '$activity[0] + {
-    org: $org,
-    date: $date,
-    prs: $prs,
-    disk: {handoffs: $disk_handoffs, decisions: $disk_decisions},
-    local_sessions: $local_sessions
-  }')
-
-HANDOFF_META="$(handoff_metadata_map "$FINAL_JSON")"
-[ -z "$HANDOFF_META" ] && HANDOFF_META="{}"
-
-printf '%s\n' "$FINAL_JSON" | jq --argjson handoff_meta "$HANDOFF_META" '
-  def enrich_handoff_sender:
-    (.filePath // "") as $file
-    | if $file != "" and ($handoff_meta[$file] // null) != null then
-        ($handoff_meta[$file] // {}) as $meta
-        | .author = ($meta.author // .author)
-        | .from = ($meta.author // .from)
-        | .topic = (.topic // $meta.topic)
-        | .date = (.date // $meta.date)
-      else
-        .
-      end;
-
-  .handoffs_to_me = ((.handoffs_to_me // []) | map(enrich_handoff_sender))
-  | .all_handoffs = ((.all_handoffs // []) | map(enrich_handoff_sender))
-'
+ARGS=(activity --time-range P7D)
+[ "${EGREGORE_STATUS_CONNECTED_ENRICH:-0}" = "1" ] && ARGS+=(--connected-enrichment)
+EGREGORE_ROOT="$ROOT" PYTHONPATH="$ROOT${PYTHONPATH:+:$PYTHONPATH}" \
+  exec python3 -m egregore_runtime.status_cli "${ARGS[@]}"