create-egregore 0.19.23 → 0.19.24

package/runtime/codex/bin/handoff-run.sh

@@ -12,6 +12,8 @@ set -euo pipefail
 #     [--recipient <name>] \
 #     [--project <name>] \
 #     [--intent <action|feedback|fyi>] \
+#     [--content-mode <supplied|generated>] \
+#     [--include-session-artifacts] \
 #     <<'HANDOFFEOF'
 #   ...full markdown body of the handoff...
 #   HANDOFFEOF
@@ -19,7 +21,7 @@ set -euo pipefail
 # The full file body is read from stdin. The script:
 #   1. Computes the file path: memory/handoffs/YYYY-MM/DD-author-slug.md
 #   2. Writes the file
-#   3. Appends ## Repo State section (from bin/repo-state.sh) if non-empty
+#   3. In generated mode, appends ## Repo State when non-empty
 #   4. Prepends memory/handoffs/index.md with a new entry
 #   5. Runs bin/index-handoff.sh (connected mode only) — creates Session node
 #      and returns a subgraph snapshot in the result JSON
@@ -51,6 +53,8 @@ NO_PUSH=0
 NO_NOTIFY=0
 NO_PUBLISH=0
 COMPOSED=""    # optional house-kit JSON — the agent-composed render spec
+CONTENT_MODE="generated"
+INCLUDE_SESSION_ARTIFACTS=0
 
 while [ $# -gt 0 ]; do
   case "$1" in
@@ -60,6 +64,8 @@ while [ $# -gt 0 ]; do
     --project)    PROJECT="${2:-}";   shift 2 ;;
     --intent)     INTENT="${2:-}";    shift 2 ;;
     --composed)   COMPOSED="${2:-}";  shift 2 ;;
+    --content-mode) CONTENT_MODE="${2:-}"; shift 2 ;;
+    --include-session-artifacts) INCLUDE_SESSION_ARTIFACTS=1; shift ;;
     --no-push)    NO_PUSH=1;          shift ;;
     --no-notify)  NO_NOTIFY=1;        shift ;;
     --no-publish) NO_PUBLISH=1;       shift ;;
@@ -72,7 +78,7 @@ done
 # markdown file is ALWAYS the memory record + graph index either way.
 RENDER_TYPE="handoff"
 RENDER_SRC=""   # resolved to $ABS_FILE after the file is written, unless composed
-if [ -n "$COMPOSED" ] && [ -f "$COMPOSED" ]; then
+if [ "$CONTENT_MODE" = "generated" ] && [ -n "$COMPOSED" ] && [ -f "$COMPOSED" ]; then
   RENDER_TYPE="composed"
   RENDER_SRC="$COMPOSED"
 fi
@@ -83,6 +89,14 @@ case "$INTENT" in
   action|feedback|fyi) ;;
   *) echo "Invalid --intent: $INTENT (action|feedback|fyi)" >&2; exit 1 ;;
 esac
+case "$CONTENT_MODE" in
+  supplied|generated) ;;
+  *) echo "Invalid --content-mode: $CONTENT_MODE (supplied|generated)" >&2; exit 1 ;;
+esac
+if [ "$CONTENT_MODE" = "supplied" ] && [ -n "$COMPOSED" ]; then
+  echo "--composed cannot be used with --content-mode supplied" >&2
+  exit 1
+fi
 
 MODE=$(jq -r '.mode // "connected"' "$CONFIG" 2>/dev/null || echo "connected")
 TODAY=$(date +%Y-%m-%d)
@@ -140,6 +154,7 @@ MISSING_FROM=0;      _has_frontmatter_key from || _has_frontmatter_key author ||
 MISSING_DATE=0;      _has_frontmatter_key date || MISSING_DATE=1
 MISSING_TOPIC=0;     _has_frontmatter_key topic || MISSING_TOPIC=1
 MISSING_INTENT=0;    _has_frontmatter_key intent || MISSING_INTENT=1
+MISSING_CONTENT_MODE=0; _has_frontmatter_key content_mode || MISSING_CONTENT_MODE=1
 MISSING_RECIPIENT=0
 if [ -n "$RECIPIENT" ]; then
   _has_frontmatter_key addressed_to || _has_frontmatter_key to || MISSING_RECIPIENT=1
@@ -150,9 +165,10 @@ awk \
   -v schema="$MISSING_SCHEMA" -v mode="$MISSING_MODE" -v kind="$MISSING_KIND" \
   -v from="$MISSING_FROM" -v date_missing="$MISSING_DATE" \
   -v topic_missing="$MISSING_TOPIC" -v intent_missing="$MISSING_INTENT" \
+  -v content_mode_missing="$MISSING_CONTENT_MODE" \
   -v recipient_missing="$MISSING_RECIPIENT" \
   -v author="$AUTHOR" -v date="$TODAY" -v topic="$TOPIC" \
-  -v intent="$INTENT" -v recipient="$RECIPIENT" '
+  -v intent="$INTENT" -v recipient="$RECIPIENT" -v content_mode="$CONTENT_MODE" '
   function metadata() {
     if (schema) print "capture_schema: egregore-capture/v1"
     if (mode) print "capture_mode: addressed"
@@ -162,13 +178,14 @@ awk \
     if (date_missing) print "date: " date
     if (topic_missing) print "topic: " topic
     if (intent_missing) print "intent: " intent
+    if (content_mode_missing) print "content_mode: " content_mode
   }
   BEGIN {
     if (!has_frontmatter) {
       print "---"
       metadata()
       print "---"
-      print ""
+      if (content_mode != "supplied") print ""
     }
   }
   has_frontmatter && NR == 1 {
@@ -182,7 +199,10 @@ awk \
 # --- Append repo state ---------------------------------------------------
 # --no-pr skips `gh pr list` (~400–600ms per repo). A detached PR backfill
 # after the parallel phase rewrites `—` → `#N` and re-pushes memory.
-REPO_STATE=$(bash "$SCRIPT_DIR/bin/repo-state.sh" --no-pr 2>/dev/null || true)
+REPO_STATE=""
+if [ "$CONTENT_MODE" = "generated" ] || [ "$INCLUDE_SESSION_ARTIFACTS" = "1" ]; then
+  REPO_STATE=$(bash "$SCRIPT_DIR/bin/repo-state.sh" --no-pr 2>/dev/null || true)
+fi
 if [ -n "$REPO_STATE" ]; then
   printf '\n%s\n' "$REPO_STATE" >> "$ABS_FILE"
 fi

package/runtime/codex/bin/lib/context.sh

@@ -33,6 +33,71 @@ elif [ "$HOUR" -lt 17 ]; then TIME_OF_DAY="afternoon"
 else TIME_OF_DAY="evening"
 fi
 
+# --- Attendant-baked seed ---------------------------------------------------
+# bin/attendant.sh pre-bakes a context snapshot tar every warm cycle
+# (_prebake_context). When the bake is fresh and its provenance matches, reuse
+# its purely graph-bound results — todos, lifecycle, pulse, service health —
+# and run every collector with local git/file inputs live below (handoffs,
+# quests, activity, soul, addressed, questions, team presence, metrics), so
+# everything file/git-derived reflects this instant. Purely graph-derived
+# fields are then at most one warm cycle stale, and the boot path pays
+# near-zero blocking graph round-trips (live collectors ride the warm cache).
+#
+# The seed is trusted only when ALL of these hold — otherwise fall back to a
+# full live gather:
+#   - the tar extracts cleanly (atomic rename on the writer side means we see
+#     a whole bake or none, never a half-written directory)
+#   - .baked-author matches this session's author (shared machines)
+#   - .baked-local-mode matches this session's mode (a connected bake must
+#     not leak graph data into a session that switched to local)
+#   - .baked-config matches this checkout's egregore.json (org/API repoint,
+#     or a worktree branch carrying a different config)
+#   - .baked-scope matches the EFFECTIVE endpoint/credential fingerprint
+#     (EGREGORE_API_URL/KEY overrides can point at a different tenant than
+#     the committed config names)
+#   - .baked-schema matches this checkout's context.sh revision (a bake from
+#     another collector schema may be missing or misformatting files)
+#   - .baked-ts is numeric, not in the future, and younger than 15min
+#   - every seeded collector's file actually landed in CTX_DIR (a partial
+#     copy must not suppress live collectors)
+CTX_SEED_USED="false"
+if [ -n "${CTX_SEED_TAR:-}" ] && [ -f "${CTX_SEED_TAR:-}" ]; then
+  _SEED_TMP=$(mktemp -d)
+  if tar -xf "$CTX_SEED_TAR" -C "$_SEED_TMP" 2>/dev/null; then
+    _SEED_TS=$(cat "$_SEED_TMP/.baked-ts" 2>/dev/null || echo 0)
+    case "$_SEED_TS" in ''|*[!0-9]*) _SEED_TS=0 ;; esac
+    _SEED_AUTHOR=$(cat "$_SEED_TMP/.baked-author" 2>/dev/null || echo "")
+    _SEED_MODE=$(cat "$_SEED_TMP/.baked-local-mode" 2>/dev/null || echo "")
+    _SEED_CONFIG=$(cat "$_SEED_TMP/.baked-config" 2>/dev/null || echo "")
+    _SEED_SCOPE=$(cat "$_SEED_TMP/.baked-scope" 2>/dev/null || echo "")
+    _SEED_SCHEMA=$(cat "$_SEED_TMP/.baked-schema" 2>/dev/null || echo "")
+    _NOW_CONFIG=$(cksum "${CONFIG:-$SCRIPT_DIR/egregore.json}" 2>/dev/null | cut -d' ' -f1)
+    _NOW_SCHEMA=$(cksum "$SCRIPT_DIR/bin/lib/context.sh" 2>/dev/null | cut -d' ' -f1)
+    # Effective endpoint/credential, mirroring bin/graph.sh's resolution order
+    # (process env → .env → committed api_url).
+    _NOW_URL="${EGREGORE_API_URL:-$(grep '^EGREGORE_API_URL=' "${ENV_FILE:-$SCRIPT_DIR/.env}" 2>/dev/null | cut -d'=' -f2- || true)}"
+    _NOW_KEY="${EGREGORE_API_KEY:-$(grep '^EGREGORE_API_KEY=' "${ENV_FILE:-$SCRIPT_DIR/.env}" 2>/dev/null | cut -d'=' -f2- || true)}"
+    [ -n "$_NOW_URL" ] || _NOW_URL=$(jq -r '.api_url // empty' "${CONFIG:-$SCRIPT_DIR/egregore.json}" 2>/dev/null)
+    _NOW_SCOPE=$(echo -n "${_NOW_URL}|${_NOW_KEY}" | cksum | cut -d' ' -f1)
+    _SEED_AGE=$(( $(date +%s) - _SEED_TS ))
+    if [ -n "$_SEED_AUTHOR" ] && [ "$_SEED_AUTHOR" = "$AUTHOR" ] \
+      && [ "$_SEED_MODE" = "${LOCAL_MODE:-false}" ] \
+      && [ -n "$_SEED_CONFIG" ] && [ "$_SEED_CONFIG" = "$_NOW_CONFIG" ] \
+      && [ -n "$_SEED_SCOPE" ] && [ "$_SEED_SCOPE" = "$_NOW_SCOPE" ] \
+      && [ -n "$_SEED_SCHEMA" ] && [ "$_SEED_SCHEMA" = "$_NOW_SCHEMA" ] \
+      && [ "$_SEED_AGE" -ge 0 ] && [ "$_SEED_AGE" -lt 900 ]; then
+      if cp "$_SEED_TMP"/* "$CTX_DIR/" 2>/dev/null; then
+        # Completeness: every collector this seed replaces must be present.
+        CTX_SEED_USED="true"
+        for _SEED_REQ in todos lifecycle pulse_brief graph_health telegram_health; do
+          [ -f "$CTX_DIR/$_SEED_REQ" ] || { CTX_SEED_USED="false"; break; }
+        done
+      fi
+    fi
+  fi
+  rm -rf "$_SEED_TMP"
+fi
+
 # 1. Recent handoffs (background)
 (
   JSON="[]"
@@ -61,7 +126,7 @@ fi
     FIRST=true
     for F in "$SCRIPT_DIR/memory/quests/"*.md; do
       [ -e "$F" ] || continue
-      echo "$F" | grep -q draft && continue
+      case "$F" in *draft*) continue ;; esac
       NAME=$(basename "$F" .md)
       $FIRST || JSON="$JSON,"
       JSON="$JSON\"$NAME\""
@@ -77,8 +142,8 @@ fi
   git log --author="$AUTHOR" --format="%ar|%s" -1 2>/dev/null > "$CTX_DIR/activity" || echo "" > "$CTX_DIR/activity"
 ) &
 
-# 3b. Personal todos from graph (background)
-(
+# 3b. Personal todos from graph (background; seeded)
+[ "$CTX_SEED_USED" != "true" ] && (
   _API_URL=$(jq -r '.api_url // empty' "$SCRIPT_DIR/egregore.json" 2>/dev/null)
   _API_KEY=$(grep '^EGREGORE_API_KEY=' "${ENV_FILE:-$SCRIPT_DIR/.env}" 2>/dev/null | cut -d'=' -f2-)
   if [ -n "$_API_URL" ] && [ -n "$_API_KEY" ]; then
@@ -96,6 +161,9 @@ fi
 ) > "$CTX_DIR/todos" 2>/dev/null &
 
 # 4. Team presence — last seen + active branches (background)
+# Always live, even when seeded: its branch/file inputs are local and cheap
+# (single awk/jq passes), and stale "last seen 2m ago" lines are the most
+# user-visible form of drift. The one graph query inside rides the warm cache.
 (
   # --- Read config inside subshell ---
   _API_URL=$(jq -r '.api_url // empty' "$SCRIPT_DIR/egregore.json" 2>/dev/null)
@@ -104,7 +172,13 @@ fi
   # --- Graph: last-seen per person (excluding self) ---
   GRAPH_DATA="[]"
   if [ -n "$_API_URL" ] && [ -n "$_API_KEY" ]; then
-    CYPHER="MATCH (s:Session)-[:BY]->(p:Person) WHERE p.github <> \$me RETURN p.name AS name, toString(max(coalesce(s.startedAt, datetime(s.date)))) AS lastSeen ORDER BY lastSeen DESC"
+    # String-compare the temporals: `datetime(s.date)` is an invalid cast when
+    # s.date is a Date (Neo.ClientError.Statement.TypeError), which made this
+    # query fail silently on every boot — GRAPH_DATA stayed empty, the greeting
+    # fell back to git/file presence, and the FILE_PRESENCE scan below ran in
+    # connected mode too. ISO-8601 strings order lexicographically, so max()
+    # over toString() is correct across DateTime, Date, and legacy string rows.
+    CYPHER="MATCH (s:Session)-[:BY]->(p:Person) WHERE p.github <> \$me RETURN p.name AS name, max(coalesce(toString(s.startedAt), toString(s.date))) AS lastSeen ORDER BY lastSeen DESC"
     GRAPH_RAW=$(bash "$SCRIPT_DIR/bin/graph.sh" query "$CYPHER" "$(jq -n --arg me "$AUTHOR" '{me: $me}')" 2>/dev/null || echo "")
     if [ -n "$GRAPH_RAW" ]; then
       GRAPH_DATA=$(echo "$GRAPH_RAW" | jq '[.values[] | {name: .[0], lastSeen: .[1]}]' 2>/dev/null || echo "[]")
@@ -112,19 +186,26 @@ fi
   fi
 
   # --- Git: branch tip commit dates per person (primary recency signal) ---
-  # git for-each-ref is fast and gives the actual last commit date per branch
+  # git for-each-ref is fast and gives the actual last commit date per branch.
+  # Single awk pass — the previous per-branch cut+tr loop spawned 3 processes
+  # per ref, and busy orgs carry hundreds of origin/dev/* refs. Refs arrive
+  # sorted by -committerdate, so the first epoch per author is their newest.
   GIT_COMMIT_DATA="{}"
   GIT_REF_DATA=$(git -C "$SCRIPT_DIR" for-each-ref --sort=-committerdate \
     --format='%(refname:short)|%(committerdate:unix)' refs/remotes/origin/dev/ 2>/dev/null || echo "")
   if [ -n "$GIT_REF_DATA" ]; then
-    GIT_COMMIT_DATA=$(echo "$GIT_REF_DATA" | sed 's|^origin/dev/||' | while IFS='|' read -r REF_PATH REF_EPOCH || [ -n "$REF_PATH" ]; do
-      [ -z "$REF_PATH" ] && continue
-      REF_AUTHOR=$(echo "$REF_PATH" | cut -d'/' -f1 | tr '[:upper:]' '[:lower:]')
-      echo "${REF_AUTHOR}|${REF_EPOCH}"
-    done | sort -t'|' -k1,1 -k2,2rn | sort -t'|' -k1,1 -u | jq -Rn '
+    GIT_COMMIT_DATA=$(printf '%s\n' "$GIT_REF_DATA" | awk -F'|' '
+      {
+        p = $1; sub(/^origin\/dev\//, "", p)
+        split(p, seg, "/"); a = tolower(seg[1])
+        if (a != "" && !(a in best)) best[a] = $2
+      }
+      END { for (a in best) printf "%s|%s\n", a, best[a] }
+    ' 2>/dev/null | jq -Rn '
       [inputs | split("|") | {(.[0]): .[1]}]
       | add // {}
     ' 2>/dev/null || echo "{}")
+    [ -z "$GIT_COMMIT_DATA" ] && GIT_COMMIT_DATA="{}"
   fi
 
   # --- Git: active dev/* branches (excluding self) ---
@@ -137,178 +218,142 @@ fi
 
   BRANCH_MAP="{}"
   if [ -n "$BRANCH_DATA" ]; then
-    BRANCH_MAP=$(echo "$BRANCH_DATA" | while IFS='/' read -r B_AUTHOR B_SLUG_REST || [ -n "$B_AUTHOR" ]; do
-      [ -z "$B_AUTHOR" ] && continue
-      B_AUTHOR_LC=$(echo "$B_AUTHOR" | tr '[:upper:]' '[:lower:]')
-      [ "$B_AUTHOR_LC" = "$SELF_LC" ] && continue
-      [ -n "$SELF_DISPLAY_LC" ] && [ "$B_AUTHOR_LC" = "$SELF_DISPLAY_LC" ] && continue
-      B_HUMAN=$(echo "$B_SLUG_REST" | tr '-' ' ')
-      echo "${B_AUTHOR_LC}|${B_HUMAN}"
-    done | jq -Rn '
-      [inputs | split("|") | {author: .[0], branch: .[1]}]
+    # Single awk pass — the previous per-branch echo+tr loop spawned 2-4
+    # processes per branch over hundreds of refs.
+    BRANCH_MAP=$(printf '%s\n' "$BRANCH_DATA" | awk -v self="$SELF_LC" -v selfd="$SELF_DISPLAY_LC" '
+      {
+        if (split($0, seg, "/") < 2) next
+        a = tolower(seg[1])
+        if (a == "" || a == self || (selfd != "" && a == selfd)) next
+        h = $0; sub(/^[^\/]*\//, "", h); gsub(/-/, " ", h)
+        printf "%s|%s\n", a, h
+      }
+    ' 2>/dev/null | jq -Rn '
+      [inputs | split("|") | {author: .[0], branch: (.[1:] | join("|"))}]
       | group_by(.author)
       | map({(.[0].author): [.[] | .branch]})
       | add // {}
     ' 2>/dev/null || echo "{}")
+    [ -z "$BRANCH_MAP" ] && BRANCH_MAP="{}"
   fi
 
   # --- Local-mode presence: scan session + wrap files for lastSeen ---
-  # When graph has no data, these files provide temporal presence information
+  # When graph has no data, these files provide temporal presence information.
+  # Single awk pass over all candidate files — the previous per-file
+  # grep+sed loop spawned 2-3 processes per file (~60 files) on every boot.
   FILE_PRESENCE="{}"
   if [ "$GRAPH_DATA" = "[]" ]; then
-    FILE_PRESENCE=$(
-      {
-        # Scan session logs, wraps, and handoffs (all use **Author**: / **Date**: format)
-        for DIR in "$SCRIPT_DIR/memory/sessions" "$SCRIPT_DIR/memory/wraps" "$SCRIPT_DIR/memory/handoffs"; do
-          [ -d "$DIR" ] || continue
-          find -L "$DIR" -name '*.md' -type f 2>/dev/null | xargs ls -t 2>/dev/null | head -20 | while read -r SFILE; do
-            [ -z "$SFILE" ] && continue
-            S_AUTH=$(grep -m1 '^\*\*Author\*\*:' "$SFILE" 2>/dev/null | sed 's/^\*\*Author\*\*:[[:space:]]*//')
-            S_DATE=$(grep -m1 '^\*\*Date\*\*:' "$SFILE" 2>/dev/null | sed 's/^\*\*Date\*\*:[[:space:]]*//')
-            [ -z "$S_AUTH" ] && continue
-            echo "${S_AUTH}|${S_DATE}"
-          done
-        done
-      } | sort -t'|' -k1,1 -k2,2r | sort -t'|' -k1,1 -u | while IFS='|' read -r FP_NAME FP_DATE; do
-        [ -z "$FP_NAME" ] && continue
-        FP_LC=$(echo "$FP_NAME" | tr '[:upper:]' '[:lower:]')
-        echo "${FP_LC}|${FP_DATE}"
-      done | jq -Rn '
-        [inputs | split("|") | {(.[0]): .[1]}]
-        | add // {}
-      ' 2>/dev/null || echo "{}"
-    )
+    FP_FILES=$(for DIR in "$SCRIPT_DIR/memory/sessions" "$SCRIPT_DIR/memory/wraps" "$SCRIPT_DIR/memory/handoffs"; do
+      [ -d "$DIR" ] || continue
+      find -L "$DIR" -name '*.md' -type f 2>/dev/null | xargs ls -t 2>/dev/null | head -20
+    done)
+    if [ -n "$FP_FILES" ]; then
+      FILE_PRESENCE=$(printf '%s\n' "$FP_FILES" | tr '\n' '\0' | xargs -0 awk '
+        function flush() { if (a != "") printf "%s|%s\n", a, d }
+        FNR == 1 { if (NR != 1) flush(); a=""; d="" }
+        a == "" && /^\*\*Author\*\*:/ { s = $0; sub(/^\*\*Author\*\*:[ \t]*/, "", s); a = s }
+        d == "" && /^\*\*Date\*\*:/   { s = $0; sub(/^\*\*Date\*\*:[ \t]*/, "", s); d = s }
+        END { flush() }
+      ' 2>/dev/null \
+        | sort -t'|' -k1,1 -k2,2r | sort -t'|' -k1,1 -u \
+        | awk -F'|' '{ print tolower($1) "|" $2 }' \
+        | jq -Rn '
+          [inputs | split("|") | {(.[0]): .[1]}]
+          | add // {}
+        ' 2>/dev/null || echo "{}")
+      [ -z "$FILE_PRESENCE" ] && FILE_PRESENCE="{}"
+    fi
   fi
 
   # --- "Working on": latest session/handoff/wrap topic per person (file-based) ---
   # Gives every team surface (greeting "around", dashboard) something legible in
   # local mode, where git branches are usually empty for teammates.
+  # Single awk pass — the previous per-file grep+sed loop spawned ~6 processes
+  # per file over ~90 files on every boot.
   _WM_TAB=$(printf '\t')
-  WORK_MAP=$(
-    {
-      for DIR in "$SCRIPT_DIR/memory/sessions" "$SCRIPT_DIR/memory/handoffs" "$SCRIPT_DIR/memory/wraps"; do
-        [ -d "$DIR" ] || continue
-        find -L "$DIR" -name '*.md' -not -name 'index*' -type f 2>/dev/null | xargs ls -t 2>/dev/null | head -30 | while read -r WFILE; do
-          [ -z "$WFILE" ] && continue
-          W_AUTH=$(grep -m1 '^\*\*Author\*\*:' "$WFILE" 2>/dev/null | sed 's/^\*\*Author\*\*:[[:space:]]*//')
-          W_DATE=$(grep -m1 '^\*\*Date\*\*:' "$WFILE" 2>/dev/null | sed 's/^\*\*Date\*\*:[[:space:]]*//')
-          W_TOPIC=$(grep -m1 '^# ' "$WFILE" 2>/dev/null | sed 's/^#[[:space:]]*//; s/^Session:[[:space:]]*//; s/^Handoff:[[:space:]]*//; s/^Wrap:[[:space:]]*//')
-          [ -z "$W_AUTH" ] && continue
-          [ -z "$W_TOPIC" ] && continue
-          printf '%s%s%s%s%s\n' "$W_AUTH" "$_WM_TAB" "$W_DATE" "$_WM_TAB" "$W_TOPIC"
-        done
-      done
-    } | sort -t"$_WM_TAB" -k1,1 -k2,2r | sort -t"$_WM_TAB" -k1,1 -u | while IFS="$_WM_TAB" read -r WM_NAME WM_DATE WM_TOPIC; do
-      [ -z "$WM_NAME" ] && continue
-      WM_LC=$(echo "$WM_NAME" | tr '[:upper:]' '[:lower:]')
-      printf '%s%s%s\n' "$WM_LC" "$_WM_TAB" "$WM_TOPIC"
-    done | jq -Rn --arg tab "$_WM_TAB" '[inputs | split($tab) | select(length>=2) | {(.[0]): (.[1] // "")}] | add // {}' 2>/dev/null || echo "{}"
-  )
-
-  # --- Relative time + epoch helpers (cross-platform) ---
-  NOW_EPOCH=$(date +%s)
-
-  iso_to_epoch() {
-    local iso="$1"
-    local clean=$(echo "$iso" | sed 's/Z$//; s/+00:00$//; s/\.[0-9]*//')
-    [[ "$clean" != *T* ]] && clean="${clean}T00:00:00"
-    TZ=UTC date -j -f "%Y-%m-%dT%H:%M:%S" "$clean" "+%s" 2>/dev/null || \
-      TZ=UTC date -d "$clean" +%s 2>/dev/null || echo "0"
-  }
-
-  epoch_to_relative() {
-    local epoch="$1"
-    [ "$epoch" = "0" ] && echo "--" && return
-    local delta=$(( NOW_EPOCH - epoch ))
-    if [ "$delta" -lt 60 ]; then echo "just now"
-    elif [ "$delta" -lt 3600 ]; then echo "$(( delta / 60 ))m ago"
-    elif [ "$delta" -lt 86400 ]; then echo "$(( delta / 3600 ))h ago"
-    else
-      # Calendar-day based comparison for accurate "yesterday" / "Xd ago"
-      local event_date today_date
-      event_date=$(date -r "$epoch" +%Y-%m-%d 2>/dev/null || \
-                   date -d "@$epoch" +%Y-%m-%d 2>/dev/null || echo "")
-      today_date=$(date +%Y-%m-%d)
-      if [ -z "$event_date" ] || [ "$event_date" = "$today_date" ]; then echo "today"
-      else
-        local today_e event_e
-        today_e=$(date -j -f "%Y-%m-%d" "$today_date" +%s 2>/dev/null || \
-                  date -d "$today_date" +%s 2>/dev/null || echo "$NOW_EPOCH")
-        event_e=$(date -j -f "%Y-%m-%d" "$event_date" +%s 2>/dev/null || \
-                  date -d "$event_date" +%s 2>/dev/null || echo "$epoch")
-        local days=$(( (today_e - event_e) / 86400 ))
-        [ "$days" -lt 1 ] && days=1
-        if [ "$days" -eq 1 ]; then echo "yesterday"
-        else echo "${days}d ago"
-        fi
-      fi
-    fi
-  }
-
-  # --- Merge git commits + graph + file presence + branches into presence array ---
-  ALL_NAMES=$(echo "$GRAPH_DATA" | jq -r '.[].name' 2>/dev/null || echo "")
-  FILE_NAMES=$(echo "$FILE_PRESENCE" | jq -r 'keys[]' 2>/dev/null || echo "")
-  BRANCH_NAMES=$(echo "$BRANCH_MAP" | jq -r 'keys[]' 2>/dev/null || echo "")
-  GIT_NAMES=$(echo "$GIT_COMMIT_DATA" | jq -r 'keys[]' 2>/dev/null || echo "")
-
-  UNION_NAMES=$(printf "%s\n%s\n%s\n%s" "$ALL_NAMES" "$FILE_NAMES" "$BRANCH_NAMES" "$GIT_NAMES" | tr '[:upper:]' '[:lower:]' | sort -u | grep -v '^$' | grep -v "^${SELF_LC}$" | grep -v "^${SELF_DISPLAY_LC}$" || echo "")
-
-  if [ -z "$UNION_NAMES" ]; then
-    echo "[]" > "$CTX_DIR/team"
-    exit 0
+  WM_FILES=$(for DIR in "$SCRIPT_DIR/memory/sessions" "$SCRIPT_DIR/memory/handoffs" "$SCRIPT_DIR/memory/wraps"; do
+    [ -d "$DIR" ] || continue
+    find -L "$DIR" -name '*.md' -not -name 'index*' -type f 2>/dev/null | xargs ls -t 2>/dev/null | head -30
+  done)
+  WORK_MAP="{}"
+  if [ -n "$WM_FILES" ]; then
+    WORK_MAP=$(printf '%s\n' "$WM_FILES" | tr '\n' '\0' | xargs -0 awk '
+      function flush() { if (a != "" && t != "") printf "%s\t%s\t%s\n", a, d, t }
+      FNR == 1 { if (NR != 1) flush(); a=""; d=""; t="" }
+      a == "" && /^\*\*Author\*\*:/ { s = $0; sub(/^\*\*Author\*\*:[ \t]*/, "", s); a = s }
+      d == "" && /^\*\*Date\*\*:/   { s = $0; sub(/^\*\*Date\*\*:[ \t]*/, "", s); d = s }
+      t == "" && /^# / {
+        s = $0; sub(/^#[ \t]*/, "", s)
+        sub(/^Session:[ \t]*/, "", s); sub(/^Handoff:[ \t]*/, "", s); sub(/^Wrap:[ \t]*/, "", s)
+        t = s
+      }
+      END { flush() }
+    ' 2>/dev/null \
+      | sort -t"$_WM_TAB" -k1,1 -k2,2r | sort -t"$_WM_TAB" -k1,1 -u \
+      | awk -F"$_WM_TAB" '{ print tolower($1) "\t" $3 }' \
+      | jq -Rn '[inputs | split("\t") | select(length >= 2) | {(.[0]): (.[1] // "")}] | add // {}' 2>/dev/null || echo "{}")
+    [ -z "$WORK_MAP" ] && WORK_MAP="{}"
   fi
 
-  # --- Build presence JSON ---
-  PRESENCE="["
-  FIRST=true
-  for PNAME in $UNION_NAMES; do
-    # Git commit date is authoritative (actual work shipped).
-    # Graph/file presence are fallbacks only (session opens ≠ real activity).
-    GIT_EPOCH=$(echo "$GIT_COMMIT_DATA" | jq -r --arg n "$PNAME" '.[$n] // empty' 2>/dev/null || true)
-
-    LAST_SEEN_EPOCH="0"
-    if [ -n "$GIT_EPOCH" ] && [ "$GIT_EPOCH" -gt 0 ] 2>/dev/null; then
-      LAST_SEEN_EPOCH="$GIT_EPOCH"
-    else
-      # Fallback: graph session startedAt
-      GRAPH_ISO=$(echo "$GRAPH_DATA" | jq -r --arg n "$PNAME" '.[] | select((.name | ascii_downcase) == $n) | .lastSeen // empty' 2>/dev/null | head -1)
-      if [ -n "$GRAPH_ISO" ]; then
-        LAST_SEEN_EPOCH=$(iso_to_epoch "$GRAPH_ISO")
-      fi
-      # Fallback: file-based presence (local mode)
-      if [ "$LAST_SEEN_EPOCH" -le 0 ] 2>/dev/null; then
-        FILE_ISO=$(echo "$FILE_PRESENCE" | jq -r --arg n "$PNAME" '.[$n] // empty' 2>/dev/null || true)
-        if [ -n "$FILE_ISO" ]; then
-          LAST_SEEN_EPOCH=$(iso_to_epoch "$FILE_ISO")
-        fi
-      fi
-    fi
-
-    if [ "$LAST_SEEN_EPOCH" -gt 0 ] 2>/dev/null; then
-      LAST_SEEN_REL=$(epoch_to_relative "$LAST_SEEN_EPOCH")
-    else
-      LAST_SEEN_EPOCH="0"
-      LAST_SEEN_REL="--"
-    fi
-
-    BRANCHES_JSON=$(echo "$BRANCH_MAP" | jq --arg n "$PNAME" '.[$n] // []' 2>/dev/null || echo "[]")
-    BR_COUNT=$(echo "$BRANCHES_JSON" | jq 'length' 2>/dev/null || echo "0")
-    if [ "$BR_COUNT" -gt 2 ]; then
-      EXTRA=$((BR_COUNT - 2))
-      BRANCHES_JSON=$(echo "$BRANCHES_JSON" | jq --arg e "+${EXTRA} more" '[.[0:2][], $e]' 2>/dev/null || echo "$BRANCHES_JSON")
-    fi
-
-    WORK=$(echo "$WORK_MAP" | jq -r --arg n "$PNAME" '.[$n] // ""' 2>/dev/null)
-    ENTRY=$(jq -n --arg name "$PNAME" --arg seen "$LAST_SEEN_REL" --argjson sort "$LAST_SEEN_EPOCH" --argjson branches "$BRANCHES_JSON" --arg work "$WORK" \
-      '{name: $name, last_seen: $seen, last_seen_sort: $sort, branches: $branches, working_on: $work}')
-    $FIRST || PRESENCE="$PRESENCE,"
-    PRESENCE="$PRESENCE$ENTRY"
-    FIRST=false
-  done
-  PRESENCE="$PRESENCE]"
-
-  PRESENCE=$(echo "$PRESENCE" | jq 'sort_by(-.last_seen_sort)' 2>/dev/null || echo "$PRESENCE")
-  echo "$PRESENCE" > "$CTX_DIR/team"
+  # --- Merge git commits + graph + file presence + branches into presence array ---
+  # One jq pass. The previous version looped over the name union in bash,
+  # spawning ~8 jq/date processes per teammate — at 16+ teammates that was the
+  # single largest block of session-start's boot time (~5s). All epoch parsing,
+  # relative-time formatting, merging, and sorting now happens inside jq.
+  # Git commit date is authoritative (actual work shipped); graph/file presence
+  # are fallbacks only (session opens ≠ real activity).
+  NOW_EPOCH=$(date +%s)
+  PRESENCE=$(jq -nc \
+    --argjson graph "$GRAPH_DATA" \
+    --argjson git "$GIT_COMMIT_DATA" \
+    --argjson branches "$BRANCH_MAP" \
+    --argjson files "$FILE_PRESENCE" \
+    --argjson work "$WORK_MAP" \
+    --arg now "$NOW_EPOCH" --arg self "$SELF_LC" --arg selfdisp "$SELF_DISPLAY_LC" '
+    def iso2e:
+      if . == null or . == "" then 0
+      else (sub("Z$"; "") | sub("\\+00:00$"; "") | sub("\\.[0-9]+"; "")
+            | (if test("T") then . else . + "T00:00:00" end)
+            | (try (strptime("%Y-%m-%dT%H:%M:%S") | mktime) catch 0))
+      end;
+    def day: (try strflocaltime("%Y-%m-%d") catch (gmtime | strftime("%Y-%m-%d")));
+    def rel($nowe): . as $e |
+      if $e <= 0 then "--"
+      else ($nowe - $e) as $d |
+        if $d < 60 then "just now"
+        elif $d < 3600 then "\($d / 60 | floor)m ago"
+        elif $d < 86400 then "\($d / 3600 | floor)h ago"
+        elif ($e | day) == ($nowe | day) then "today"
+        else
+          ((try (($nowe | day | strptime("%Y-%m-%d") | mktime)
+               - ($e | day | strptime("%Y-%m-%d") | mktime)) catch $d) / 86400
+           | floor | if . < 1 then 1 else . end) as $days |
+          if $days == 1 then "yesterday" else "\($days)d ago" end
+        end
+      end;
+    ($now | tonumber) as $nowe |
+    ($graph
+      | map({key: ((.name // "") | ascii_downcase), value: (.lastSeen // "")})
+      | group_by(.key)
+      | map({key: .[0].key, value: (map(.value) | max)})
+      | from_entries) as $g |
+    ([($g, $files, $branches, $git) | keys[]] | map(ascii_downcase) | unique
+      | map(select(. != "" and . != $self and . != $selfdisp))) as $names |
+    [ $names[] | . as $n |
+      (($git[$n] // "0") | (try tonumber catch 0)) as $ge |
+      (if $ge > 0 then $ge
+       else ((($g[$n] // "") | iso2e) as $gge |
+             if $gge > 0 then $gge else (($files[$n] // "") | iso2e) end)
+       end) as $epoch |
+      ($branches[$n] // []) as $b |
+      { name: $n,
+        last_seen: ($epoch | rel($nowe)),
+        last_seen_sort: $epoch,
+        branches: (if ($b | length) > 2 then ($b[0:2] + ["+\(($b | length) - 2) more"]) else $b end),
+        working_on: ($work[$n] // "") }
+    ] | sort_by(-.last_seen_sort)
+  ' 2>/dev/null || echo "[]")
+  echo "${PRESENCE:-[]}" > "$CTX_DIR/team"
 ) &
 
 # 5. Soul self-summary (background)
@@ -437,8 +482,8 @@ fi
   echo "$PENDING_JSON" > "$CTX_DIR/pending_questions"
 ) &
 
-# 7. Graph health (background — zero added latency, runs in parallel)
-(
+# 7. Graph health (background — zero added latency, runs in parallel; seeded)
+[ "$CTX_SEED_USED" != "true" ] && (
   if [ "$LOCAL_MODE" = "true" ]; then
     echo "skip"
   elif bash "$SCRIPT_DIR/bin/graph.sh" test 2>/dev/null | grep -q "Connected"; then
@@ -454,7 +499,7 @@ fi
 # status field — an earlier grep for the word "connected" read a human sentence
 # that the consent rewrite removed, so the footer showed telegram ✗ while the
 # bot was answering.
-(
+[ "$CTX_SEED_USED" != "true" ] && (
   if [ "$LOCAL_MODE" = "true" ]; then
     echo "skip"
   elif bash "$SCRIPT_DIR/bin/notify.sh" test 2>/dev/null \
@@ -465,8 +510,8 @@ fi
   fi
 ) > "$CTX_DIR/telegram_health" 2>/dev/null &
 
-# 9. Lifecycle events: merged PRs + implemented handoffs (background)
-(
+# 9. Lifecycle events: merged PRs + implemented handoffs (background; seeded)
+[ "$CTX_SEED_USED" != "true" ] && (
   GH_USER_LC=""
   if [ -f "$STATE_FILE" ]; then
     GH_USER_LC=$(jq -r '.github_username // empty' "$STATE_FILE" 2>/dev/null)
@@ -501,8 +546,8 @@ fi
     '{merged_prs: $merged, implemented_handoffs: $impl}' 2>/dev/null || echo '{"merged_prs":[],"implemented_handoffs":[]}'
 ) > "$CTX_DIR/lifecycle" 2>/dev/null &
 
-# 10. Last Pulse brief (background) — gated on feature flag + API key
-(
+# 10. Last Pulse brief (background) — gated on feature flag + API key; seeded
+[ "$CTX_SEED_USED" != "true" ] && (
   PULSE_ENABLED=$(jq -r '.features.pulse // "false"' "$CONFIG" 2>/dev/null || echo "false")
   HAS_API_KEY=false
   _env_file="${ENV_FILE:-$SCRIPT_DIR/.env}"
@@ -533,6 +578,9 @@ fi
 ) > "$CTX_DIR/pulse_brief" 2>/dev/null &
 
 # 11. Momentum metrics (background)
+# Always live, even when seeded: _metrics_gather mixes graph reads (which ride
+# the warm cache) with local git/file scans — sessions, commits, handoffs,
+# knowledge — whose freshness the greeting should reflect this instant.
 (
   source "$SCRIPT_DIR/bin/lib/metrics.sh"
   _metrics_gather