create-egregore 0.19.3 → 0.19.6

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

@@ -48,6 +48,7 @@ PROJECT=""
 NO_PUSH=0
 NO_NOTIFY=0
 NO_PUBLISH=0
+COMPOSED=""    # optional house-kit JSON — the agent-composed render spec
 
 while [ $# -gt 0 ]; do
   case "$1" in
@@ -55,6 +56,7 @@ while [ $# -gt 0 ]; do
     --topic)      TOPIC="${2:?}";     shift 2 ;;
     --recipient)  RECIPIENT="${2:-}"; shift 2 ;;
     --project)    PROJECT="${2:-}";   shift 2 ;;
+    --composed)   COMPOSED="${2:-}";  shift 2 ;;
     --no-push)    NO_PUSH=1;          shift ;;
     --no-notify)  NO_NOTIFY=1;        shift ;;
     --no-publish) NO_PUBLISH=1;       shift ;;
@@ -62,6 +64,16 @@ while [ $# -gt 0 ]; do
   esac
 done
 
+# The render source: the agent-composed house-kit JSON when supplied (rich
+# component render), else the markdown handoff (deterministic floor). The
+# 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
+  RENDER_TYPE="composed"
+  RENDER_SRC="$COMPOSED"
+fi
+
 [ -z "$AUTHOR" ] && { echo "Missing --author" >&2; exit 1; }
 [ -z "$TOPIC" ]  && { echo "Missing --topic"  >&2; exit 1; }
 
@@ -203,14 +215,13 @@ PID_GRAPH=$!
   ARTIFACTS_JSON="[]"
   if [ "$MODE" = "connected" ]; then
     YY=$(date +%Y); MM=$(date +%-m); DD_NUM=$(date +%-d)
-    PARAMS=$(jq -nc --arg gh "$AUTHOR" '{gh:$gh}')
     RAW=$(bash "$SCRIPT_DIR/bin/graph.sh" query "
       MATCH (a:Artifact)-[:CONTRIBUTED_BY]->(p:Person {github: \$gh})
       WHERE a.created >= datetime({year: $YY, month: $MM, day: $DD_NUM})
         AND NOT 'tutorial-generated' IN coalesce(a.topics, [])
       RETURN a.title AS title, a.type AS type, a.filePath AS path
       ORDER BY a.created DESC
-      LIMIT 5" "$PARAMS" 2>/dev/null || echo '{}')
+      LIMIT 5" "$(jq -nc --arg gh "$AUTHOR" '{gh:$gh}')" 2>/dev/null || echo '{}')
     # Response shape: {"fields":[...], "values":[[...], ...]}. Convert to
     # an array of {title, type, path} objects.
     ARTIFACTS_JSON=$(echo "$RAW" | jq -c '
@@ -282,24 +293,145 @@ PID_ARTIFACTS=$!
 PID_MEMORY=$!
 
 # --- Branch C: Publish artifact → Notify ---
+#
+# Strategy: handoffs publish ONCE, through the emissary write API, using
+# `render_mode: "custom"` so the server serves OUR pre-rendered HTML
+# verbatim (the same egregore-artifacts handoff template /view/ has
+# always used). This gives us:
+#   - one artifact, one URL (no legacy + new double-publish)
+#   - permanent egregore.xyz/emissary/e/<id> URL with /raw endpoint
+#   - handoff design fully owned client-side (egregore-artifacts) — the
+#     emissary server template is never invoked for handoffs and remains
+#     completely untouched
+#
+# Fallback: if emissary publish fails (token missing, network, size cap,
+# rendering failure), fall back to the legacy publish-artifact.sh path so
+# a handoff still gets a Telegram-able URL.
 (
+  V1URL=""
   AURL=""
-  if [ "$NO_PUBLISH" = "0" ] && [ -x "$SCRIPT_DIR/bin/publish-artifact.sh" ]; then
-    AURL=$(bash "$SCRIPT_DIR/bin/publish-artifact.sh" handoff "$ABS_FILE" \
+  if [ "$NO_PUBLISH" = "0" ]; then
+    EMISSARY_CONFIG="$HOME/.egregore/emissary-config.json"
+    EMISSARY_TOKEN=""
+    if [ -f "$EMISSARY_CONFIG" ]; then
+      EMISSARY_TOKEN=$(jq -r '.auth_token // empty' "$EMISSARY_CONFIG" 2>/dev/null)
+    fi
+    EMISSARY_API_URL="${EMISSARY_API_URL:-https://egregore-production-55f2.up.railway.app/api/v1/emissary}"
+
+    if [ -n "$EMISSARY_TOKEN" ]; then
+      # Step 1: render the handoff to HTML locally using egregore-artifacts.
+      # Same renderer + template publish-artifact.sh uses today — handoffs
+      # keep their familiar look.
+      RENDERED_HTML="$TMPD/handoff.html"
+      RENDER_OK=0
+      LOCAL_CLI="$SCRIPT_DIR/packages/egregore-artifacts/bin/cli.js"
+      if [ "${EGREGORE_USE_PUBLISHED:-0}" != "1" ] && [ -f "$LOCAL_CLI" ] && [ -d "$SCRIPT_DIR/packages/egregore-artifacts/node_modules/react" ]; then
+        if node "$LOCAL_CLI" "$RENDER_TYPE" "${RENDER_SRC:-$ABS_FILE}" --output "$RENDERED_HTML" >/dev/null 2>&1; then
+          RENDER_OK=1
+        fi
+      else
+        if npx egregore-artifacts "$RENDER_TYPE" "${RENDER_SRC:-$ABS_FILE}" --output "$RENDERED_HTML" >/dev/null 2>&1; then
+          RENDER_OK=1
+        fi
+      fi
+
+      # Step 2: build the emissary payload. If rendering succeeded AND the
+      # HTML fits the server's 100KB cap, send it with render_mode=custom.
+      # If not, fall through to the structured-only path (server-rendered
+      # via the emissary template — undesirable for handoffs but still
+      # better than no URL).
+      if [ "$RENDER_OK" = "1" ] && [ -f "$RENDERED_HTML" ]; then
+        RENDER_SIZE=$(wc -c < "$RENDERED_HTML" | tr -d ' ')
+        if [ "$RENDER_SIZE" -gt 0 ] && [ "$RENDER_SIZE" -lt 100000 ]; then
+          # Author display name
+          DISPLAY_NAME="$AUTHOR"
+          PERSON_FILE="$SCRIPT_DIR/memory/people/${AUTHOR}.md"
+          if [ -f "$PERSON_FILE" ]; then
+            DISPLAY_NAME=$(head -1 "$PERSON_FILE" | sed 's/^# //')
+          fi
+
+          # addressed_to: only set if there's a recipient
+          ADDRESSED_TO="[]"
+          if [ -n "$RECIPIENT" ]; then
+            RECIP_HANDLE=$(echo "$RECIPIENT" | tr '[:upper:]' '[:lower:]' | awk '{print $1}')
+            ADDRESSED_TO=$(jq -nc --arg h "$RECIP_HANDLE" --arg d "$RECIPIENT" '[{"handle":$h,"display":$d}]')
+          fi
+
+          CLAIM=$(echo "$BRIEFING_LEAD" | cut -c1-200)
+
+          # body.prose is schema-required non-empty even when render_mode is
+          # "custom" (server validates structurally regardless of render
+          # mode). The visible page is the custom HTML; prose just needs to
+          # be non-empty plain text for /raw consumers and validation. Use
+          # the briefing lead (which the lead/claim is already derived from).
+          PROSE_TEXT="${BRIEFING_LEAD:-$TOPIC}"
+
+          # Use --rawfile so the rendered HTML is read directly from disk
+          # into a JSON-string. Faster than shell-var roundtrip and avoids
+          # any quoting headaches for HTML.
+          V1JSON=$(jq -nc \
+            --arg topic "$TOPIC" \
+            --arg claim "$CLAIM" \
+            --arg summary "$CLAIM" \
+            --arg prose "$PROSE_TEXT" \
+            --argjson addressed "$ADDRESSED_TO" \
+            --rawfile render_html "$RENDERED_HTML" \
+            '{
+              kind: "continuation",
+              topic: $topic,
+              claim: $claim,
+              summary: $summary,
+              body: { prose: $prose },
+              audience: {
+                addressed_to: $addressed,
+                visible_to: "public",
+                extendable_by: "anyone"
+              },
+              parents: [],
+              render_mode: "custom",
+              render_html: $render_html
+            }')
+
+          V1RESULT=$(curl -sf -X POST "$EMISSARY_API_URL/emissaries" \
+            -H "Content-Type: application/json" \
+            -H "Authorization: Bearer $EMISSARY_TOKEN" \
+            -d "$V1JSON" 2>/dev/null || echo '{}')
+
+          V1URL=$(echo "$V1RESULT" | jq -r '.url // ""' 2>/dev/null || echo "")
+        fi
+      fi
+    fi
+  fi
+
+  # Fallback: if the emissary publish didn't produce a URL (no token, no
+  # network, size cap, render failure), fire the legacy publish-artifact.sh
+  # so handoffs still get a Telegram-able URL.
+  if [ -z "$V1URL" ] && [ "$NO_PUBLISH" = "0" ] && [ -x "$SCRIPT_DIR/bin/publish-artifact.sh" ]; then
+    AURL=$(bash "$SCRIPT_DIR/bin/publish-artifact.sh" "$RENDER_TYPE" "${RENDER_SRC:-$ABS_FILE}" \
       --title "$TOPIC" \
       --author "$AUTHOR" \
       --description "$BRIEFING_LEAD" 2>/dev/null || echo "")
   fi
-  echo "$AURL" > "$TMPD/artifact"
+
+  # Prefer v1 (emissary-rendered) URL when available; fall back to the
+  # legacy egregore-artifacts URL only if the v1 publish failed.
+  NOTIFY_URL=""
+  if [ -n "$V1URL" ]; then
+    echo "$V1URL" > "$TMPD/artifact"
+    NOTIFY_URL="$V1URL"
+  else
+    echo "$AURL" > "$TMPD/artifact"
+    NOTIFY_URL="$AURL"
+  fi
 
   NS="skipped"
   if [ "$NO_NOTIFY" = "0" ]; then
-    if [ -n "$AURL" ]; then
+    if [ -n "$NOTIFY_URL" ]; then
       MSG_NOTIFY="Handoff from ${AUTHOR}: ${TOPIC}
 
 \"${BRIEFING_SHORT}\"
 
-View: ${AURL}"
+View: ${NOTIFY_URL}"
     else
       MSG_NOTIFY="Handoff from ${AUTHOR}: ${TOPIC}
 
@@ -345,9 +477,27 @@ if [ -s "$TMPD/graph" ]; then
   GRAPH_STATUS=$(sed -n '3p' "$TMPD/graph")
 fi
 [ -z "$RESOLVED" ] && RESOLVED=0
+# Sanitize: --argjson requires a number. If RESOLVED came back as a slug or
+# anything non-numeric (the index-handoff.sh output format has drifted in
+# the past — defensive guard), fall back to 0 so the result file still builds.
+if ! echo "$RESOLVED" | grep -qE '^[0-9]+$'; then
+  RESOLVED=0
+fi
 
 SUBGRAPH_JSON=$(cat "$TMPD/subgraph" 2>/dev/null || echo "null")
 [ -z "$SUBGRAPH_JSON" ] && SUBGRAPH_JSON="null"
+# Sanitize: --argjson requires valid JSON. Multiple writes to the same
+# tmpfile have produced concatenated values in the past (e.g. "null\n{...}"),
+# which jq rejects on multi-document input. Validate; on failure, take the
+# LAST non-empty line and re-validate; if still bad, fall back to null.
+if ! printf '%s' "$SUBGRAPH_JSON" | jq -s 'length == 1' 2>/dev/null | grep -q '^true$'; then
+  LAST_LINE=$(printf '%s\n' "$SUBGRAPH_JSON" | awk 'NF{last=$0} END{print last}')
+  if printf '%s' "$LAST_LINE" | jq -e '.' >/dev/null 2>&1; then
+    SUBGRAPH_JSON="$LAST_LINE"
+  else
+    SUBGRAPH_JSON="null"
+  fi
+fi
 
 MEMORY_STATUS=$(cat "$TMPD/memory"   2>/dev/null || echo "skipped")
 ARTIFACT_URL=$(cat "$TMPD/artifact"  2>/dev/null || echo "")

package/runtime/codex/bin/handoff-save-egregore.sh

@@ -45,6 +45,11 @@ SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
 [ -z "$REPO_DIR" ] && REPO_DIR="$SCRIPT_DIR"
 cd "$REPO_DIR" || exit 1
 
+# Shared safe-staging guard — never auto-commit stray sibling-repo gitlinks.
+# shellcheck source=bin/lib/git-safe.sh
+. "$SCRIPT_DIR/bin/lib/git-safe.sh" 2>/dev/null || true
+type git_add_guarded >/dev/null 2>&1 || git_add_guarded() { git add -A 2>/dev/null || true; }
+
 # --- Early exit if nothing to do -----------------------------------------
 DIRTY=0
 [ -n "$(git status --porcelain 2>/dev/null)" ] && DIRTY=1
@@ -75,7 +80,7 @@ esac
 
 # --- Commit whatever is uncommitted --------------------------------------
 if [ -n "$(git status --porcelain 2>/dev/null)" ]; then
-  git add -A 2>/dev/null || true
+  git_add_guarded
   git commit -m "Handoff: ${TOPIC}" --quiet 2>/dev/null || true
 fi
 

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

@@ -131,6 +131,10 @@ fi
 PROJECT="$(md_field 'Project')"
 [ -z "$PROJECT" ] && PROJECT="$(yaml_extract 'project')"
 
+# Handoff kind: used by readers to distinguish automatic captures from manual handoffs.
+KIND="$(md_field 'Kind')"
+[ -z "$KIND" ] && KIND="$(yaml_extract 'kind')"
+
 # Summary: 5-level precedence chain
 # 1. Frontmatter summary field
 SUMMARY="$(yaml_extract 'summary')"
@@ -198,8 +202,9 @@ fi
 
 Q1_CYPHER="MATCH (p:Person) WHERE toLower(p.name) = \$author OR p.github = \$author OR toLower(p.fullName) = \$author OR \$author IN [x IN coalesce(p.previousNames, []) | toLower(x)]
 MERGE (s:Session {id: \$sessionId})
-ON CREATE SET s.date = date(\$date), s.topic = \$topic, s.summary = \$summary, s.filePath = \$filePath, s.handoffStatus = 'pending', s.repoState = \$repoState, s.startedAt = datetime(\$date + 'T00:00:00Z')
-ON MATCH SET s.topic = \$topic, s.summary = \$summary, s.filePath = \$filePath, s.repoState = \$repoState
+ON CREATE SET s.date = date(\$date), s.topic = \$topic, s.summary = \$summary, s.filePath = \$filePath, s.author = \$author, s.handoffKind = CASE WHEN \$kind = '' THEN null ELSE \$kind END, s.handoffStatus = 'pending', s.repoState = \$repoState, s.startedAt = datetime(\$date + 'T00:00:00Z')
+ON MATCH SET s.topic = \$topic, s.summary = \$summary, s.filePath = \$filePath, s.author = \$author, s.handoffKind = CASE WHEN \$kind = '' THEN null ELSE \$kind END, s.repoState = \$repoState
+WITH s, p
 MERGE (s)-[:BY]->(p)${PROJECT_CYPHER}${HANDED_TO_CYPHER}
 RETURN s.id AS sessionId"
 
@@ -210,6 +215,7 @@ Q1_PARAMS=$(jq -n \
   --arg topic "$TOPIC" \
   --arg summary "$SUMMARY" \
   --arg filePath "$REL_PATH" \
+  --arg kind "$KIND" \
   --arg repoState "$REPO_STATE_JSON" \
   "${_PROJECT_ARGS[@]:+${_PROJECT_ARGS[@]}}" \
   "${_RECIP_ARGS[@]:+${_RECIP_ARGS[@]}}" \
@@ -273,7 +279,7 @@ CURRENT_SID=$(cat "$HOME/.egregore/session-${PROJ_HASH}.id" 2>/dev/null || echo
 if [ -n "$CURRENT_SID" ]; then
   bash "$SCRIPT_DIR/bin/graph.sh" query \
     "MATCH (s:Session {id: \$sid}) SET s.status = 'handed_off' RETURN s.id" \
-    "$(jq -n --arg sid "$CURRENT_SID" '{sid: $sid}')" 2>/dev/null || true
+    "$(jq -n --arg sid "$CURRENT_SID" '{sid: $sid}')" >/dev/null 2>&1 || true
 fi
 
 # --- Parse response ---

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

@@ -1,7 +1,7 @@
 # shellcheck shell=bash
 # context.sh — Context gathering for session-start.sh
 #
-# Runs 10 parallel background subshells to gather session context:
+# Runs 11 parallel background subshells to gather session context:
 #   1. Recent handoffs
 #   2. Active quests
 #   3. User's last git activity
@@ -13,6 +13,7 @@
 #   8. Telegram health check
 #   9. Lifecycle events (merged PRs, implemented handoffs)
 #   10. Last Pulse brief
+#   11. Momentum metrics
 #
 # All subshells write to $CTX_DIR (a temp directory).
 # Ends with `wait` + reading health results back.
@@ -23,6 +24,8 @@
 
 CTX_DIR=$(mktemp -d)
 
+source "$SCRIPT_DIR/bin/lib/handoff-meta.sh" >/dev/null 2>/dev/null || true
+
 # Time of day
 HOUR=$(date +%H)
 if [ "$HOUR" -lt 12 ]; then TIME_OF_DAY="morning"
@@ -177,6 +180,31 @@ 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.
+  _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)
 
@@ -270,8 +298,9 @@ fi
       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}')
+    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
@@ -320,18 +349,9 @@ fi
     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
+      AF_AUTHOR=$(eg_handoff_author "$AF")
+      AF_TOPIC=$(eg_handoff_topic "$AF")
+      AF_DATE=$(eg_handoff_date "$AF")
       # 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)
@@ -352,9 +372,14 @@ 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}"
+      AF_ENTRY=$(jq -cn \
+        --arg name "$AF_NAME" \
+        --arg author "$AF_AUTHOR" \
+        --arg topic "$AF_TOPIC" \
+        --arg date "$AF_DATE" \
+        --argjson repoState "$AF_REPO_STATE" \
+        '{name:$name, author:$author, topic:$topic, date:$date, repoState:$repoState}' 2>/dev/null || echo "{}")
+      RICH="$RICH$AF_ENTRY"
       FIRST=false
     done
     JSON="$JSON]"
@@ -364,6 +389,54 @@ fi
   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
@@ -453,6 +526,12 @@ fi
   fi
 ) > "$CTX_DIR/pulse_brief" 2>/dev/null &
 
+# 11. Momentum metrics (background)
+(
+  source "$SCRIPT_DIR/bin/lib/metrics.sh"
+  _metrics_gather
+) > "$CTX_DIR/metrics" 2>/dev/null &
+
 # Wait for all context gathering + health checks to finish
 wait
 

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

@@ -90,7 +90,7 @@ mkdir -p /tmp
       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
+      echo "$_DB_TEAM_FILTERED" | jq -r '.[] | ((.working_on // "")) as $w | (.branches // []) as $b | "| \(.name) | \(.last_seen) | \(if $w != "" then $w else ($b | join(", ")) end) |"' 2>/dev/null || true
       printf '\n'
     fi
   fi

package/runtime/codex/bin/lib/git-sync.sh

@@ -26,7 +26,20 @@ git config pull.rebase true 2>/dev/null || true
 export GIT_HTTP_LOW_SPEED_LIMIT=1000  # abort if <1KB/s
 export GIT_HTTP_LOW_SPEED_TIME=10     # for 10 seconds
 
-git fetch origin --quiet 2>/dev/null &
+# Attendant fast path: the ambient daemon (bin/attendant.sh) fetches origin,
+# memory, and managed repos every few minutes. If its warm marker is fresh,
+# refs are already up to date — skip the network fetches and launch on local
+# ops only. Upstream fetch (framework update check) is not covered by the
+# attendant and stays unconditional below.
+_REFS_FRESH="false"
+_ATT_SLUG=$(jq -r '.slug // "egregore"' "$SCRIPT_DIR/egregore.json" 2>/dev/null || echo "egregore")
+_ATT_MARKER="$HOME/.egregore/attendant/${_ATT_SLUG}-$(echo -n "$SCRIPT_DIR" | cksum | cut -d' ' -f1).warm-ts"
+if [ -f "$_ATT_MARKER" ]; then
+  _ATT_AGE=$(( $(date +%s) - $(cat "$_ATT_MARKER" 2>/dev/null || echo 0) ))
+  [ "$_ATT_AGE" -lt 360 ] && _REFS_FRESH="true"
+fi
+
+[ "$_REFS_FRESH" != "true" ] && git fetch origin --quiet 2>/dev/null &
 
 # Fetch upstream framework (for update check — non-blocking)
 # Default: official egregore-core repo. Set upstream_url in egregore.json to override,
@@ -40,17 +53,19 @@ fi
 
 # Sync memory in parallel (symlink or direct directory — both valid)
 MEMORY_SYNCED="false"
-if [ -d "$SCRIPT_DIR/memory/.git" ]; then
+if [ -d "$SCRIPT_DIR/memory/.git" ] && [ "$_REFS_FRESH" != "true" ]; then
   git -C "$SCRIPT_DIR/memory" fetch origin --quiet 2>/dev/null &
 fi
 
 # Fetch managed repos in parallel
 MANAGED_REPOS=$(jq -r '(.repos[]? // empty) | if type == "object" then .name else . end' "$SCRIPT_DIR/egregore.json" 2>/dev/null)
-for REPO in $MANAGED_REPOS; do
-  if [ -d "$SCRIPT_DIR/../$REPO/.git" ]; then
-    git -C "$SCRIPT_DIR/../$REPO" fetch origin --quiet 2>/dev/null &
-  fi
-done
+if [ "$_REFS_FRESH" != "true" ]; then
+  for REPO in $MANAGED_REPOS; do
+    if [ -d "$SCRIPT_DIR/../$REPO/.git" ]; then
+      git -C "$SCRIPT_DIR/../$REPO" fetch origin --quiet 2>/dev/null &
+    fi
+  done
+fi
 
 # Wait for all fetches
 wait 2>/dev/null || true
@@ -93,6 +108,16 @@ else
   HEALTH_GIT="fail"
 fi
 
+# --- Guarded staging -------------------------------------------------------
+# git_add_guarded() lives in the shared lib so the /handoff auto-save uses the
+# exact same logic. Fallback to plain `git add -A` if the lib can't be sourced,
+# so an unattended auto-save never silently no-ops.
+# shellcheck source=bin/lib/git-safe.sh
+. "$SCRIPT_DIR/bin/lib/git-safe.sh" 2>/dev/null || true
+if ! type git_add_guarded >/dev/null 2>&1; then
+  git_add_guarded() { git add -A 2>/dev/null || true; }
+fi
+
 # --- Setup develop (wrapped — failures set HEALTH_GIT but don't crash) ---
 setup_develop() {
   # Ensure develop branch exists locally
@@ -143,8 +168,9 @@ setup_develop() {
   if [[ "$CURRENT_BRANCH" != "develop" ]]; then
     # Check for uncommitted work (staged + unstaged + untracked in tracked dirs)
     if [ -n "$(git status --porcelain 2>/dev/null | head -1)" ]; then
-      # Save uncommitted work so nothing is lost
-      git add -A 2>/dev/null
+      # Save uncommitted work so nothing is lost (guarded: never auto-commit
+      # stray submodule pointers from sibling repos in the checkout)
+      git_add_guarded
       git commit -m "Auto-save: uncommitted work from $CURRENT_BRANCH" --quiet 2>/dev/null || true
       SAVED_BRANCH="$CURRENT_BRANCH"
     fi