create-egregore 0.17.4 → 0.18.0

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

@@ -0,0 +1,511 @@
+# shellcheck shell=bash
+# context.sh — Context gathering for session-start.sh
+#
+# Runs 10 parallel background subshells to gather session context:
+#   1. Recent handoffs
+#   2. Active quests
+#   3. User's last git activity
+#   3b. Personal todos from graph
+#   4. Team presence (graph + git branches)
+#   5. Soul self-summary
+#   6. Handoffs addressed to user
+#   7. Graph health check
+#   8. Telegram health check
+#   9. Lifecycle events (merged PRs, implemented handoffs)
+#   10. Last Pulse brief
+#
+# All subshells write to $CTX_DIR (a temp directory).
+# Ends with `wait` + reading health results back.
+#
+# Inputs:  SCRIPT_DIR, AUTHOR, LOCAL_MODE, STATE_FILE, CONFIG, ENV_FILE,
+#          HEALTH_GRAPH, HEALTH_TELEGRAM
+# Outputs: CTX_DIR (populated), TIME_OF_DAY, HEALTH_GRAPH, HEALTH_TELEGRAM
+
+CTX_DIR=$(mktemp -d)
+
+# Time of day
+HOUR=$(date +%H)
+if [ "$HOUR" -lt 12 ]; then TIME_OF_DAY="morning"
+elif [ "$HOUR" -lt 17 ]; then TIME_OF_DAY="afternoon"
+else TIME_OF_DAY="evening"
+fi
+
+# 1. Recent handoffs (background)
+(
+  JSON="[]"
+  if [ -d "$SCRIPT_DIR/memory/handoffs" ]; then
+    FILES=$(find -L "$SCRIPT_DIR/memory/handoffs" -name '*.md' -not -name 'index*' -type f 2>/dev/null | xargs ls -t 2>/dev/null | head -3)
+    JSON="["
+    FIRST=true
+    for F in $FILES; do
+      [ -z "$F" ] && continue
+      NAME=$(basename "$F" .md)
+      PREVIEW=$(head -c 120 "$F" 2>/dev/null | tr '\n' ' ' | sed 's/"/\\"/g')
+      $FIRST || JSON="$JSON,"
+      JSON="$JSON{\"name\":\"$NAME\",\"preview\":\"$PREVIEW\"}"
+      FIRST=false
+    done
+    JSON="$JSON]"
+  fi
+  echo "$JSON" > "$CTX_DIR/handoffs"
+) &
+
+# 2. Quests (background)
+(
+  JSON="[]"
+  if [ -d "$SCRIPT_DIR/memory/quests" ]; then
+    JSON="["
+    FIRST=true
+    for F in "$SCRIPT_DIR/memory/quests/"*.md; do
+      [ -e "$F" ] || continue
+      echo "$F" | grep -q draft && continue
+      NAME=$(basename "$F" .md)
+      $FIRST || JSON="$JSON,"
+      JSON="$JSON\"$NAME\""
+      FIRST=false
+    done
+    JSON="$JSON]"
+  fi
+  echo "$JSON" > "$CTX_DIR/quests"
+) &
+
+# 3. User's last activity (background)
+(
+  git log --author="$AUTHOR" --format="%ar|%s" -1 2>/dev/null > "$CTX_DIR/activity" || echo "" > "$CTX_DIR/activity"
+) &
+
+# 3b. Personal todos from graph (background)
+(
+  _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
+    TODO_RAW=$(bash "$SCRIPT_DIR/bin/graph.sh" query \
+      "MATCH (t:Todo)-[:BY]->(p:Person {github: \$me}) WHERE t.status IN ['open', 'blocked'] OPTIONAL MATCH (t)-[:PART_OF]->(q:Quest) RETURN t.text AS text, t.priority AS priority, t.status AS status, t.created AS created, q.id AS quest ORDER BY t.priority DESC, t.created DESC LIMIT 5" \
+      "$(jq -n --arg me "$AUTHOR" '{me: $me}')" 2>/dev/null || echo "")
+    if [ -n "$TODO_RAW" ]; then
+      echo "$TODO_RAW" | jq '[.values[] | {text: .[0], priority: (.[1] // 0), status: .[2], created: .[3], quest: (.[4] // "")}]' 2>/dev/null || echo "[]"
+    else
+      echo "[]"
+    fi
+  else
+    echo "[]"
+  fi
+) > "$CTX_DIR/todos" 2>/dev/null &
+
+# 4. Team presence — last seen + active branches (background)
+(
+  # --- Read config inside subshell ---
+  _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-)
+
+  # --- 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"
+    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 "[]")
+    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_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 '
+      [inputs | split("|") | {(.[0]): .[1]}]
+      | add // {}
+    ' 2>/dev/null || echo "{}")
+  fi
+
+  # --- Git: active dev/* branches (excluding self) ---
+  SELF_LC=$(echo "$AUTHOR" | tr '[:upper:]' '[:lower:]')
+  SELF_DISPLAY_LC=""
+  if [ -f "$SCRIPT_DIR/.egregore-state.json" ]; then
+    SELF_DISPLAY_LC=$(jq -r '.display_name // empty' "$SCRIPT_DIR/.egregore-state.json" 2>/dev/null | tr '[:upper:]' '[:lower:]')
+  fi
+  BRANCH_DATA=$(git -C "$SCRIPT_DIR" branch -r --format='%(refname:short)' 2>/dev/null | grep "^origin/dev/" | sed 's|^origin/dev/||' || echo "")
+
+  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]}]
+      | group_by(.author)
+      | map({(.[0].author): [.[] | .branch]})
+      | add // {}
+    ' 2>/dev/null || echo "{}")
+  fi
+
+  # --- Local-mode presence: scan session + wrap files for lastSeen ---
+  # When graph has no data, these files provide temporal presence information
+  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 "{}"
+    )
+  fi
+
+  # --- 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
+  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
+
+    ENTRY=$(jq -n --arg name "$PNAME" --arg seen "$LAST_SEEN_REL" --argjson sort "$LAST_SEEN_EPOCH" --argjson branches "$BRANCHES_JSON" \
+      '{name: $name, last_seen: $seen, last_seen_sort: $sort, branches: $branches}')
+    $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"
+) &
+
+# 5. Soul self-summary (background)
+(
+  SUMMARY=""
+  if [ -f "$SCRIPT_DIR/egregore.md" ]; then
+    SUMMARY=$(sed -n '/^## Self-Summary/,/^##/p' "$SCRIPT_DIR/egregore.md" | sed '1d;/^##/d' | sed 's/^[[:space:]]*//' | tr '\n' ' ' | sed 's/[[:space:]]*$//')
+  fi
+  echo "$SUMMARY" > "$CTX_DIR/soul_summary"
+) &
+
+# 6. Handoffs addressed to user (background, enriched with author/topic)
+(
+  JSON="[]"
+  RICH="[]"
+  if [ -d "$SCRIPT_DIR/memory/handoffs" ]; then
+    # Match github username, display name, github_name first word, and people-file name
+    # Handoff files may use "to: name", "**To**: name", or "To: name"
+    _DISPLAY=$(jq -r '.display_name // empty' "$STATE_FILE" 2>/dev/null)
+    _GH_NAME=$(jq -r '.github_name // empty' "$STATE_FILE" 2>/dev/null)
+    _FIRST_NAME=$(echo "$_GH_NAME" | awk '{print $1}')
+    # Also check people file: memory/people/{author}.md has "# Name" on first line
+    _PEOPLE_NAME=""
+    _PEOPLE_FILE="$SCRIPT_DIR/memory/people/$(echo "$AUTHOR" | tr '[:upper:]' '[:lower:]').md"
+    [ -f "$_PEOPLE_FILE" ] && _PEOPLE_NAME=$(sed -n 's/^# *//p' "$_PEOPLE_FILE" 2>/dev/null | head -1)
+    _GREP_PAT="[Tt]o[*]*: *$AUTHOR\|[Tt]o[*]*:$AUTHOR"
+    for _VARIANT in "$_DISPLAY" "$_FIRST_NAME" "$_PEOPLE_NAME"; do
+      [ -z "$_VARIANT" ] && continue
+      [ "$_VARIANT" = "$AUTHOR" ] && continue
+      # Skip if already in pattern (avoid duplicates)
+      echo "$_GREP_PAT" | grep -qF "$_VARIANT" && continue
+      _GREP_PAT="$_GREP_PAT\|[Tt]o[*]*: *$_VARIANT\|[Tt]o[*]*:$_VARIANT"
+    done
+    ADDRESSED=$(grep -rli "$_GREP_PAT" "$SCRIPT_DIR/memory/handoffs/" 2>/dev/null | sort -r | head -5 || true)
+    JSON="["
+    RICH="["
+    FIRST=true
+    for AF in $ADDRESSED; do
+      [ -z "$AF" ] && continue
+      AF_NAME=$(basename "$AF" .md)
+      AF_AUTHOR=$(sed -n 's/^\*\*Author\*\*: *//p' "$AF" 2>/dev/null | head -1)
+      if [ -z "$AF_AUTHOR" ]; then
+        AF_AUTHOR=$(sed -n 's/^From: *//p' "$AF" 2>/dev/null | head -1)
+      fi
+      AF_TOPIC=$(sed -n 's/^# Handoff: *//p' "$AF" 2>/dev/null | head -1)
+      if [ -z "$AF_TOPIC" ]; then
+        AF_TOPIC=$(sed -n 's/^# *//p' "$AF" 2>/dev/null | head -1)
+      fi
+      AF_DATE=$(sed -n 's/^\*\*Date\*\*: *//p' "$AF" 2>/dev/null | head -1)
+      if [ -z "$AF_DATE" ]; then
+        AF_DATE=$(sed -n 's/^Date: *//p' "$AF" 2>/dev/null | head -1)
+      fi
+      # Extract repo state table if present
+      AF_REPO_STATE="[]"
+      AF_REPO_TABLE=$(awk '/^## Repo State/{found=1; next} found && /^#/{exit} found && /^\|[^-]/ && !/^\| Repo/{print}' "$AF" 2>/dev/null || true)
+      if [ -n "$AF_REPO_TABLE" ]; then
+        AF_REPO_STATE=$(echo "$AF_REPO_TABLE" | while IFS='|' read -r _ R_REPO R_BRANCH R_PR R_BASE _; do
+          R_REPO=$(echo "$R_REPO" | xargs 2>/dev/null || true)
+          R_BRANCH=$(echo "$R_BRANCH" | xargs 2>/dev/null || true)
+          R_PR=$(echo "$R_PR" | xargs 2>/dev/null | sed 's/^#//' | sed 's/—//' || true)
+          R_BASE=$(echo "$R_BASE" | xargs 2>/dev/null || true)
+          [ -z "$R_REPO" ] && continue
+          if [ -n "$R_PR" ] && [ "$R_PR" -eq "$R_PR" ] 2>/dev/null; then
+            printf '{"repo":"%s","branch":"%s","pr":%s,"base":"%s"}\n' "$R_REPO" "$R_BRANCH" "$R_PR" "$R_BASE"
+          else
+            printf '{"repo":"%s","branch":"%s","pr":null,"base":"%s"}\n' "$R_REPO" "$R_BRANCH" "$R_BASE"
+          fi
+        done | jq -sc '.' 2>/dev/null || echo "[]")
+      fi
+      $FIRST || JSON="$JSON,"
+      $FIRST || RICH="$RICH,"
+      JSON="$JSON\"$AF_NAME\""
+      AF_TOPIC_ESC=$(echo "$AF_TOPIC" | sed 's/"/\\"/g')
+      AF_AUTHOR_ESC=$(echo "$AF_AUTHOR" | sed 's/"/\\"/g')
+      RICH="$RICH{\"name\":\"$AF_NAME\",\"author\":\"$AF_AUTHOR_ESC\",\"topic\":\"$AF_TOPIC_ESC\",\"date\":\"$AF_DATE\",\"repoState\":$AF_REPO_STATE}"
+      FIRST=false
+    done
+    JSON="$JSON]"
+    RICH="$RICH]"
+  fi
+  echo "$JSON" > "$CTX_DIR/addressed"
+  echo "$RICH" > "$CTX_DIR/addressed_rich"
+) &
+
+# 6.5. Pending questions addressed to user (background)
+(
+  PENDING_JSON="[]"
+  QDIR="$SCRIPT_DIR/memory/knowledge/questions"
+  if [ -d "$QDIR" ]; then
+    # Match against the same identity variants used for handoffs (display name,
+    # github first-name, people-file name) so "to: oz" matches author "oguzhan".
+    _DISPLAY_Q=$(jq -r '.display_name // empty' "$STATE_FILE" 2>/dev/null)
+    _GH_NAME_Q=$(jq -r '.github_name // empty' "$STATE_FILE" 2>/dev/null)
+    _FIRST_NAME_Q=$(echo "$_GH_NAME_Q" | awk '{print tolower($1)}')
+    _PEOPLE_FILE_Q="$SCRIPT_DIR/memory/people/$(echo "$AUTHOR" | tr '[:upper:]' '[:lower:]').md"
+    _PEOPLE_NAME_Q=""
+    [ -f "$_PEOPLE_FILE_Q" ] && _PEOPLE_NAME_Q=$(sed -n 's/^# *//p' "$_PEOPLE_FILE_Q" 2>/dev/null | head -1 | awk '{print tolower($1)}')
+
+    LINES=""
+    for QF in "$QDIR"/*.md; do
+      [ -f "$QF" ] || continue
+      Q_TO=$(sed -n 's/^to:[[:space:]]*//p' "$QF" 2>/dev/null | head -1 | tr -d '"' | tr '[:upper:]' '[:lower:]' | awk '{print $1}')
+      [ -z "$Q_TO" ] && continue
+      _MATCH="false"
+      for _V in "$AUTHOR" "$_DISPLAY_Q" "$_FIRST_NAME_Q" "$_PEOPLE_NAME_Q"; do
+        [ -z "$_V" ] && continue
+        _V_LC=$(echo "$_V" | tr '[:upper:]' '[:lower:]')
+        [ "$Q_TO" = "$_V_LC" ] && _MATCH="true" && break
+      done
+      [ "$_MATCH" = "true" ] || continue
+      Q_STATUS=$(sed -n 's/^status:[[:space:]]*//p' "$QF" 2>/dev/null | head -1 | tr -d '"')
+      [ "$Q_STATUS" = "pending" ] || continue
+      Q_FROM=$(sed -n 's/^from:[[:space:]]*//p' "$QF" 2>/dev/null | head -1 | tr -d '"')
+      Q_TOPIC=$(sed -n 's/^topic:[[:space:]]*//p' "$QF" 2>/dev/null | head -1 | tr -d '"')
+      Q_HID=$(sed -n 's/^harvest_id:[[:space:]]*//p' "$QF" 2>/dev/null | head -1 | tr -d '"')
+      Q_REL="${QF#$SCRIPT_DIR/}"
+      LINE=$(jq -nc \
+        --arg from "$Q_FROM" \
+        --arg topic "$Q_TOPIC" \
+        --arg hid "$Q_HID" \
+        --arg file "$Q_REL" \
+        '{from:$from, topic:$topic, harvest_id:$hid, file:$file}' 2>/dev/null)
+      [ -n "$LINE" ] && LINES="$LINES$LINE
+"
+    done
+    if [ -n "$LINES" ]; then
+      PENDING_JSON=$(echo "$LINES" | jq -sc '.' 2>/dev/null || echo "[]")
+    fi
+  fi
+  echo "$PENDING_JSON" > "$CTX_DIR/pending_questions"
+) &
+
+# 7. Graph health (background — zero added latency, runs in parallel)
+(
+  if [ "$LOCAL_MODE" = "true" ]; then
+    echo "skip"
+  elif bash "$SCRIPT_DIR/bin/graph.sh" test 2>/dev/null | grep -q "Connected"; then
+    echo "ok"
+  else
+    echo "fail"
+  fi
+) > "$CTX_DIR/graph_health" 2>/dev/null &
+
+# 8. Telegram health (background)
+(
+  if [ "$LOCAL_MODE" = "true" ]; then
+    echo "skip"
+  elif bash "$SCRIPT_DIR/bin/notify.sh" test 2>/dev/null | grep -q "connected"; then
+    echo "ok"
+  else
+    echo "fail"
+  fi
+) > "$CTX_DIR/telegram_health" 2>/dev/null &
+
+# 9. Lifecycle events: merged PRs + implemented handoffs (background)
+(
+  GH_USER_LC=""
+  if [ -f "$STATE_FILE" ]; then
+    GH_USER_LC=$(jq -r '.github_username // empty' "$STATE_FILE" 2>/dev/null)
+  fi
+  DISPLAY_NAME_LC=""
+  if [ -f "$STATE_FILE" ]; then
+    DISPLAY_NAME_LC=$(jq -r '.display_name // empty' "$STATE_FILE" 2>/dev/null)
+  fi
+  # Get last session end date (use 7 days ago as fallback)
+  LAST_END=$(bash "$SCRIPT_DIR/bin/graph.sh" query "
+    MATCH (s:Session)-[:BY]->(p:Person {github: \$gh})
+    WHERE s.wrappedAt IS NOT NULL
+    RETURN toString(s.wrappedAt) AS t
+    ORDER BY s.wrappedAt DESC SKIP 1 LIMIT 1
+  " "$(jq -n --arg gh "$GH_USER_LC" '{gh: $gh}')" 2>/dev/null | jq -r '.values[0][0] // empty' 2>/dev/null)
+  if [ -z "$LAST_END" ]; then
+    LAST_END="$(date -v-7d +%Y-%m-%d 2>/dev/null || date -d '7 days ago' +%Y-%m-%d 2>/dev/null || echo '2026-03-03')T00:00:00Z"
+  fi
+
+  MERGED_JSON="[]"
+  if [ -n "$GH_USER_LC" ]; then
+    MERGED_JSON=$(bash "$SCRIPT_DIR/bin/graph-op.sh" my-merged-prs "$GH_USER_LC" "$(echo "$LAST_END" | cut -dT -f1)" 2>/dev/null || echo "[]")
+  fi
+
+  IMPL_JSON="[]"
+  IMPL_NAME="${DISPLAY_NAME_LC:-$GH_USER_LC}"
+  if [ -n "$IMPL_NAME" ]; then
+    IMPL_JSON=$(bash "$SCRIPT_DIR/bin/graph-op.sh" my-implemented-handoffs "$IMPL_NAME" "$(echo "$LAST_END" | cut -dT -f1)" 2>/dev/null || echo "[]")
+  fi
+
+  jq -n --argjson merged "$MERGED_JSON" --argjson impl "$IMPL_JSON" \
+    '{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
+(
+  PULSE_ENABLED=$(jq -r '.features.pulse // "false"' "$CONFIG" 2>/dev/null || echo "false")
+  HAS_API_KEY=false
+  _env_file="${ENV_FILE:-$SCRIPT_DIR/.env}"
+  if [ -f "$_env_file" ]; then
+    _key=$(grep '^EGREGORE_API_KEY=' "$_env_file" 2>/dev/null | cut -d'=' -f2- || true)
+    [ -n "$_key" ] && HAS_API_KEY=true
+  fi
+
+  if [ "$PULSE_ENABLED" = "true" ] && [ "$HAS_API_KEY" = "true" ] && [ -n "$GH_USER_LC" ]; then
+    BRIEF_RESULT=$(bash "$SCRIPT_DIR/bin/graph.sh" query "
+      MATCH (p:Person {github: \$gh})
+      WHERE p.lastBrief IS NOT NULL
+        AND p.lastBriefDate >= date() - duration('P7D')
+      RETURN p.lastBrief, toString(p.lastBriefDate), p.lastRecommendations
+    " "$(jq -n --arg gh "$GH_USER_LC" '{gh: $gh}')" 2>/dev/null || echo '{"values":[]}')
+    BRIEF=$(echo "$BRIEF_RESULT" | jq -r '.values[0][0] // empty' 2>/dev/null || true)
+    BRIEF_DATE=$(echo "$BRIEF_RESULT" | jq -r '.values[0][1] // empty' 2>/dev/null || true)
+    RECS=$(echo "$BRIEF_RESULT" | jq -c '.values[0][2] // []' 2>/dev/null || echo '[]')
+    if [ -n "$BRIEF" ]; then
+      jq -n --arg brief "$BRIEF" --arg date "$BRIEF_DATE" --argjson recs "$RECS" \
+        '{brief: $brief, date: $date, recommendations: $recs}'
+    else
+      echo '{}'
+    fi
+  else
+    echo '{}'
+  fi
+) > "$CTX_DIR/pulse_brief" 2>/dev/null &
+
+# Wait for all context gathering + health checks to finish
+wait
+
+# --- Read service health results ---
+GRAPH_RESULT=$(cat "$CTX_DIR/graph_health" 2>/dev/null || echo "")
+if [ -n "$GRAPH_RESULT" ]; then HEALTH_GRAPH="$GRAPH_RESULT"; fi
+TELEGRAM_RESULT=$(cat "$CTX_DIR/telegram_health" 2>/dev/null || echo "")
+if [ -n "$TELEGRAM_RESULT" ]; then HEALTH_TELEGRAM="$TELEGRAM_RESULT"; fi

package/runtime/codex/bin/lib/dashboard-artifact.sh

@@ -0,0 +1,142 @@
+# shellcheck shell=bash
+# dashboard-artifact.sh — Generate a session dashboard artifact with a shareable URL
+#
+# Runs after context.sh (all $CTX_DIR/* files populated), before greeting.sh.
+# Compiles gathered context into a markdown document, generates HTML via
+# egregore-artifacts, publishes it, and exports DASHBOARD_URL for greeting.sh.
+#
+# Inputs:  SCRIPT_DIR, CTX_DIR, AUTHOR, GREETING_NAME, LOCAL_MODE,
+#          EGREGORE_SESSION_ID, FIRST_SESSION
+# Outputs: DASHBOARD_URL (exported for greeting.sh)
+
+DASHBOARD_URL=""
+
+# Skip conditions: first session, onboarding incomplete, no session ID
+if [ "${FIRST_SESSION:-false}" = "true" ]; then
+  return 0 2>/dev/null || exit 0
+fi
+if [ -z "${EGREGORE_SESSION_ID:-}" ]; then
+  return 0 2>/dev/null || exit 0
+fi
+
+# --- Read gathered context ---
+_DB_ADDRESSED=$(cat "$CTX_DIR/addressed_rich" 2>/dev/null || echo "[]")
+_DB_ADDR_COUNT=$(echo "$_DB_ADDRESSED" | jq 'length' 2>/dev/null || echo "0")
+_DB_QUESTS=$(cat "$CTX_DIR/quests" 2>/dev/null || echo "[]")
+_DB_QUEST_COUNT=$(echo "$_DB_QUESTS" | jq 'length' 2>/dev/null || echo "0")
+_DB_TEAM=$(cat "$CTX_DIR/team" 2>/dev/null || echo "[]")
+_DB_TEAM_COUNT=$(echo "$_DB_TEAM" | jq 'length' 2>/dev/null || echo "0")
+_DB_LIFECYCLE=$(cat "$CTX_DIR/lifecycle" 2>/dev/null || echo '{}')
+_DB_MERGED_COUNT=$(echo "$_DB_LIFECYCLE" | jq '.merged_prs.values // [] | length' 2>/dev/null || echo "0")
+_DB_IMPL_COUNT=$(echo "$_DB_LIFECYCLE" | jq '.implemented_handoffs.values // [] | length' 2>/dev/null || echo "0")
+_DB_PULSE=$(cat "$CTX_DIR/pulse_brief" 2>/dev/null || echo '{}')
+_DB_PULSE_BRIEF=$(echo "$_DB_PULSE" | jq -r '.brief // empty' 2>/dev/null || true)
+
+# Skip if all context is empty — nothing worth showing
+_DB_HAS_CONTENT="false"
+if [ "$_DB_ADDR_COUNT" -gt 0 ] 2>/dev/null; then _DB_HAS_CONTENT="true"; fi
+if [ "$_DB_QUEST_COUNT" -gt 0 ] 2>/dev/null; then _DB_HAS_CONTENT="true"; fi
+if [ "$_DB_TEAM_COUNT" -gt 0 ] 2>/dev/null; then _DB_HAS_CONTENT="true"; fi
+if [ "$_DB_MERGED_COUNT" -gt 0 ] 2>/dev/null; then _DB_HAS_CONTENT="true"; fi
+if [ "$_DB_IMPL_COUNT" -gt 0 ] 2>/dev/null; then _DB_HAS_CONTENT="true"; fi
+
+if [ "$_DB_HAS_CONTENT" = "false" ]; then
+  return 0 2>/dev/null || exit 0
+fi
+
+# --- Compile markdown ---
+_DB_DATE=$(date +%Y-%m-%d)
+_DB_ORG=$(jq -r '.org_name // "Egregore"' "$SCRIPT_DIR/egregore.json" 2>/dev/null || echo "Egregore")
+_DB_MD="/tmp/egregore-dashboard-${EGREGORE_SESSION_ID}.md"
+mkdir -p /tmp
+
+{
+  printf '# Session Dashboard — %s\n\n' "$_DB_ORG"
+
+  # --- Pulse Brief (first — sets the tone) ---
+  if [ -n "$_DB_PULSE_BRIEF" ]; then
+    printf '## Pulse\n\n'
+    printf '✦ %s\n\n' "$_DB_PULSE_BRIEF"
+  fi
+
+  # --- Handoffs & Asks (dense format matching terminal TUI) ---
+  if [ "$_DB_ADDR_COUNT" -gt 0 ] 2>/dev/null; then
+    printf '## Handoffs & Asks\n\n'
+    _DB_NOW_SEC=$(date +%s)
+    echo "$_DB_ADDRESSED" | jq -r '.[] | "\(.author // "unknown")\t\(.topic // "Untitled")\t\(.date // "--")"' 2>/dev/null | while IFS=$'\t' read -r _HF_AUTHOR _HF_TOPIC _HF_DATE; do
+      [ -z "$_HF_AUTHOR" ] && continue
+      # Compute relative time
+      _HF_DATE_ONLY="${_HF_DATE%%T*}"
+      _HF_EPOCH=$(date -j -f "%Y-%m-%d" "$_HF_DATE_ONLY" +%s 2>/dev/null || \
+                  date -d "$_HF_DATE_ONLY" +%s 2>/dev/null || echo "0")
+      _HF_DAYS=$(( (_DB_NOW_SEC - _HF_EPOCH) / 86400 ))
+      if [ "$_HF_DAYS" -le 0 ] 2>/dev/null; then _HF_AGO="today"
+      elif [ "$_HF_DAYS" -eq 1 ] 2>/dev/null; then _HF_AGO="yesterday"
+      else _HF_AGO="${_HF_DAYS}d ago"
+      fi
+      _HF_NAME_LC=$(printf '%s' "$_HF_AUTHOR" | awk '{print tolower($1)}')
+      printf '● %s → you: %s (%s)\n\n' "$_HF_NAME_LC" "$_HF_TOPIC" "$_HF_AGO"
+    done
+  fi
+
+  # --- Team Activity (right after handoffs, recent only) ---
+  if [ "$_DB_TEAM_COUNT" -gt 0 ] 2>/dev/null; then
+    _DB_NOW=$(date +%s)
+    _DB_RECENCY=$((7 * 86400))
+    _DB_TEAM_FILTERED=$(echo "$_DB_TEAM" | jq --argjson now "$_DB_NOW" --argjson window "$_DB_RECENCY" \
+      '[.[] | select(.last_seen_sort > 0 and ($now - .last_seen_sort) < $window)]' 2>/dev/null || echo "[]")
+    _DB_TEAM_FCOUNT=$(echo "$_DB_TEAM_FILTERED" | jq 'length' 2>/dev/null || echo "0")
+    if [ "$_DB_TEAM_FCOUNT" -gt 0 ] 2>/dev/null; then
+      printf '## Team Activity\n\n'
+      printf '| Name | Last Seen | Working On |\n'
+      printf '|------|-----------|------------|\n'
+      echo "$_DB_TEAM_FILTERED" | jq -r '.[] | "| \(.name) | \(.last_seen) | \(.branches | join(", ")) |"' 2>/dev/null || true
+      printf '\n'
+    fi
+  fi
+
+  # --- What Changed ---
+  if [ "$_DB_MERGED_COUNT" -gt 0 ] 2>/dev/null || [ "$_DB_IMPL_COUNT" -gt 0 ] 2>/dev/null; then
+    printf '## What Changed\n\n'
+    if [ "$_DB_MERGED_COUNT" -gt 0 ] 2>/dev/null; then
+      echo "$_DB_LIFECYCLE" | jq -r '.merged_prs.values[]? | "- ✓ PR #\(.[0]) \(.[2] // .[1] // "")"' 2>/dev/null || true
+    fi
+    if [ "$_DB_IMPL_COUNT" -gt 0 ] 2>/dev/null; then
+      echo "$_DB_LIFECYCLE" | jq -r '.implemented_handoffs.values[]? | "- ✓ \(.[1] // "someone") worked on: \(.[0] // "handoff")"' 2>/dev/null || true
+    fi
+    printf '\n'
+  fi
+
+  # --- Active Quests (bottom — reference, exclude meta entries) ---
+  if [ "$_DB_QUEST_COUNT" -gt 0 ] 2>/dev/null; then
+    _DB_QUESTS_FILTERED=$(echo "$_DB_QUESTS" | jq '[.[] | select(. != "_template" and . != "index")][:10]' 2>/dev/null || echo "[]")
+    _DB_QF_COUNT=$(echo "$_DB_QUESTS_FILTERED" | jq 'length' 2>/dev/null || echo "0")
+    if [ "$_DB_QF_COUNT" -gt 0 ] 2>/dev/null; then
+      printf '## Active Quests\n\n'
+      echo "$_DB_QUESTS_FILTERED" | jq -r '.[] | "- \(.)"' 2>/dev/null || true
+      printf '\n'
+    fi
+  fi
+
+} > "$_DB_MD" 2>/dev/null
+
+# --- Publish markdown → HTML → hosted URL ---
+# publish-artifact.sh handles HTML generation internally (npx egregore-artifacts)
+# then uploads. Don't pre-generate HTML — that causes double-wrapping.
+# https:// URLs are universally cmd+clickable across all terminal emulators.
+# publish-artifact.sh may output npx progress lines before the URL — extract just the URL
+_DB_PUBLISH_OUT=$(bash "$SCRIPT_DIR/bin/publish-artifact.sh" document "$_DB_MD" \
+  --title "Session Dashboard" \
+  --author "${GREETING_NAME:-$AUTHOR}" 2>/dev/null || true)
+DASHBOARD_URL=$(echo "$_DB_PUBLISH_OUT" | grep -o 'https://[^ ]*' | tail -1)
+
+# Fallback: generate HTML locally and use file:// URL (offline, no API key, etc.)
+if [ -z "$DASHBOARD_URL" ]; then
+  _DB_HTML="/tmp/egregore-artifacts/dashboard-${EGREGORE_SESSION_ID}.html"
+  mkdir -p /tmp/egregore-artifacts
+  if npx egregore-artifacts document "$_DB_MD" --output "$_DB_HTML" --no-open >/dev/null 2>&1 && [ -f "$_DB_HTML" ]; then
+    DASHBOARD_URL="file://${_DB_HTML}"
+  fi
+fi
+
+rm -f "$_DB_MD"