create-egregore 0.17.4 → 0.18.1

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

@@ -0,0 +1,431 @@
+#!/bin/bash
+set -euo pipefail
+# handoff-run.sh — atomic orchestrator for /handoff.
+#
+# Everything mechanical happens here, in one bash process, so the main
+# session renders a single collapsed Bash tool block instead of 6+.
+#
+# Usage:
+#   bash bin/handoff-run.sh \
+#     --author <handle> \
+#     --topic  "<short topic>" \
+#     [--recipient <name>] \
+#     [--project <name>] \
+#     <<'HANDOFFEOF'
+#   ...full markdown body of the handoff...
+#   HANDOFFEOF
+#
+# 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
+#   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
+#   6. Commits + pushes memory repo (with orphan-stash dance if needed)
+#   7. Publishes HTML artifact via bin/publish-artifact.sh
+#   8. Sends Telegram notification via bin/notify.sh (if recipient)
+#   9. Emits ONE status line and ONE JSON blob on stdout
+#
+# Exit codes:
+#   0 on success (even if graph/publish/notify individually fail — they are
+#     non-blocking and reported in the JSON).
+#   1 on unrecoverable failure (file write, memory push, bad args).
+
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CONFIG="$SCRIPT_DIR/egregore.json"
+
+if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
+  sed -n '2,30p' "$0"
+  exit 0
+fi
+
+# --- Parse args ----------------------------------------------------------
+AUTHOR=""
+TOPIC=""
+RECIPIENT=""
+PROJECT=""
+NO_PUSH=0
+NO_NOTIFY=0
+NO_PUBLISH=0
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --author)     AUTHOR="${2:?}";    shift 2 ;;
+    --topic)      TOPIC="${2:?}";     shift 2 ;;
+    --recipient)  RECIPIENT="${2:-}"; shift 2 ;;
+    --project)    PROJECT="${2:-}";   shift 2 ;;
+    --no-push)    NO_PUSH=1;          shift ;;
+    --no-notify)  NO_NOTIFY=1;        shift ;;
+    --no-publish) NO_PUBLISH=1;       shift ;;
+    *) echo "Unknown arg: $1" >&2; exit 1 ;;
+  esac
+done
+
+[ -z "$AUTHOR" ] && { echo "Missing --author" >&2; exit 1; }
+[ -z "$TOPIC" ]  && { echo "Missing --topic"  >&2; exit 1; }
+
+MODE=$(jq -r '.mode // "connected"' "$CONFIG" 2>/dev/null || echo "connected")
+TODAY=$(date +%Y-%m-%d)
+YYYY_MM=$(date +%Y-%m)
+DD=$(date +%d)
+
+# --- Derive slug + file path --------------------------------------------
+_slugify() {
+  echo "$1" \
+    | tr '[:upper:]' '[:lower:]' \
+    | sed -E 's/[^a-z0-9]+/-/g' \
+    | sed -E 's/^-+|-+$//g' \
+    | cut -c1-50
+}
+
+SLUG=$(_slugify "$TOPIC")
+REL_FILE="handoffs/${YYYY_MM}/${DD}-${AUTHOR}-${SLUG}.md"
+ABS_FILE="$SCRIPT_DIR/memory/${REL_FILE}"
+
+# Collision avoidance: append -N if file already exists
+N=2
+while [ -e "$ABS_FILE" ]; do
+  REL_FILE="handoffs/${YYYY_MM}/${DD}-${AUTHOR}-${SLUG}-${N}.md"
+  ABS_FILE="$SCRIPT_DIR/memory/${REL_FILE}"
+  N=$((N+1))
+  [ $N -gt 99 ] && { echo "Too many collisions for $SLUG" >&2; exit 1; }
+done
+
+mkdir -p "$(dirname "$ABS_FILE")"
+
+# --- Write the file from stdin ------------------------------------------
+cat > "$ABS_FILE"
+
+if [ ! -s "$ABS_FILE" ]; then
+  echo "Empty stdin — handoff body is required" >&2
+  rm -f "$ABS_FILE"
+  exit 1
+fi
+
+# --- Inject **To**: line if --recipient given and body omits it -----
+# index-handoff.sh parses recipients from the file body. Skills
+# normally write the To line themselves, but callers that invoke
+# handoff-run.sh directly often skip it. Inject after the Author
+# line so the graph gets the HANDED_TO edge.
+if [ -n "$RECIPIENT" ] && ! grep -qi "^\*\*[Tt]o\*\*:" "$ABS_FILE"; then
+  awk -v r="$RECIPIENT" '
+    !injected && /^\*\*[Aa]uthor\*\*:/ {
+      print
+      print "**To**: " r
+      injected=1
+      next
+    }
+    { print }
+  ' "$ABS_FILE" > "$ABS_FILE.new" && mv "$ABS_FILE.new" "$ABS_FILE"
+fi
+
+# --- 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)
+if [ -n "$REPO_STATE" ]; then
+  printf '\n%s\n' "$REPO_STATE" >> "$ABS_FILE"
+fi
+
+# --- Prepend memory/handoffs/index.md -----------------------------------
+INDEX="$SCRIPT_DIR/memory/handoffs/index.md"
+mkdir -p "$(dirname "$INDEX")"
+[ -f "$INDEX" ] || printf '# Handoffs\n\n' > "$INDEX"
+
+if [ -n "$RECIPIENT" ]; then
+  IDX_LINE="- **${TODAY}** — ${AUTHOR}: ${TOPIC} (handoff to ${RECIPIENT})"
+else
+  IDX_LINE="- **${TODAY}** — ${AUTHOR}: ${TOPIC} (handoff)"
+fi
+
+# Insert after the first blank line (keeping the # header intact)
+awk -v line="$IDX_LINE" '
+  BEGIN { inserted = 0 }
+  /^$/ && !inserted { print; print line; inserted = 1; next }
+  { print }
+  END { if (!inserted) print line }
+' "$INDEX" > "$INDEX.new" && mv "$INDEX.new" "$INDEX"
+
+# --- Parallel stage: graph + memory + (publish → notify) ----------------
+#
+# Three independent branches fork here and join before we emit the result:
+#   A. Graph index     — reads ABS_FILE, writes Session node to Neo4j, and
+#                        returns the handoff's neighborhood as subgraph JSON.
+#   B. Memory push     — commits + pushes memory repo (orphan-stash dance).
+#   C. Publish+notify  — publishes HTML artifact, then (if recipient is set)
+#                        sends Telegram with the artifact URL embedded.
+#
+# Each branch writes its result to a tmpfile. Wall-clock is max(A,B,C).
+#
+# The published artifact runs its own live re-query via bin/graph.sh at
+# render time, so it picks up the subgraph even though Branch A may not
+# have indexed the session yet by the time Branch C fires publish.
+
+MEMORY_DIR="$SCRIPT_DIR/memory"
+
+TMPD=$(mktemp -d -t handoff-run-XXXXXX)
+trap 'rm -rf "$TMPD"' EXIT
+
+# Extract briefing text once (used by publish and notify) so we don't
+# re-awk the same file inside multiple workers.
+BRIEFING_LEAD=$(awk '/^## Briefing/{found=1; next} found && /^##/{exit} found && NF{print}' "$ABS_FILE" 2>/dev/null \
+  | head -2 | tr '\n' ' ' | cut -c1-200 || true)
+BRIEFING_SHORT=$(awk '/^## Briefing/{found=1; next} found && /^##/{exit} found && NF{print}' "$ABS_FILE" 2>/dev/null \
+  | head -3 | tr '\n' ' ' | cut -c1-280 || true)
+
+# --- Branch A: Graph index ---
+(
+  if [ "$MODE" = "connected" ]; then
+    GJ=$(bash "$SCRIPT_DIR/bin/index-handoff.sh" "$ABS_FILE" 2>/dev/null || echo '{}')
+    SID=$(echo "$GJ" | jq -r '.sessionId // ""' 2>/dev/null || echo "")
+    RES=$(echo "$GJ" | jq -r '.resolved // 0' 2>/dev/null || echo 0)
+    SG=$(echo "$GJ" | jq -c '.subgraph // null' 2>/dev/null || echo "null")
+    echo "$SG" > "$TMPD/subgraph"
+    if [ -n "$SID" ]; then
+      printf '%s\n%s\nok\n' "$SID" "$RES" > "$TMPD/graph"
+    else
+      printf '\n0\noffline\n' > "$TMPD/graph"
+    fi
+  else
+    echo "null" > "$TMPD/subgraph"
+    printf '\n0\nskipped\n' > "$TMPD/graph"
+  fi
+) &
+PID_GRAPH=$!
+
+# --- Branch D: Today's artifacts (connected mode only) ---
+# The graph is the right tool for this: indexed by date + author + excluded
+# tag, returns a small structured list. The filesystem would require a full
+# walk of memory/knowledge/* to answer. Runs in parallel; Branch B waits on
+# this before committing so the file always has the section.
+(
+  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 '{}')
+    # Response shape: {"fields":[...], "values":[[...], ...]}. Convert to
+    # an array of {title, type, path} objects.
+    ARTIFACTS_JSON=$(echo "$RAW" | jq -c '
+      (.fields // []) as $f
+      | (.values // [])
+      | map(. as $row | reduce range(0; ($f | length)) as $i ({}; .[$f[$i]] = $row[$i]))
+    ' 2>/dev/null || echo '[]')
+    [ -z "$ARTIFACTS_JSON" ] && ARTIFACTS_JSON="[]"
+  fi
+  echo "$ARTIFACTS_JSON" > "$TMPD/artifacts"
+) &
+PID_ARTIFACTS=$!
+
+# --- Branch B: Memory commit + push ---
+(
+  if [ "$NO_PUSH" = "1" ]; then
+    echo "skipped (--no-push)" > "$TMPD/memory"
+  else
+    # Wait for Branch D (artifacts query) so the committed file has the
+    # `## Session Artifacts` section. D is fast (~1s) and runs parallel
+    # with Branch A; this wait doesn't extend the critical path because
+    # Branch C (publish) is the bottleneck.
+    wait "$PID_ARTIFACTS" 2>/dev/null || true
+    if [ -s "$TMPD/artifacts" ]; then
+      ART_COUNT=$(jq 'length' "$TMPD/artifacts" 2>/dev/null || echo 0)
+      if [ "${ART_COUNT:-0}" -gt 0 ]; then
+        {
+          printf '\n## Session Artifacts\n\n'
+          jq -r '.[] | "- \(.type // "Artifact"): \(.title) -> \(.path // "")"' "$TMPD/artifacts" 2>/dev/null
+        } >> "$ABS_FILE"
+      fi
+    fi
+
+    cd "$MEMORY_DIR"
+    git add "$REL_FILE" handoffs/index.md >/dev/null 2>&1
+
+    if [ -n "$RECIPIENT" ]; then
+      MSG_COMMIT="Handoff: ${TOPIC} (to ${RECIPIENT})"
+    else
+      MSG_COMMIT="Handoff: ${TOPIC}"
+    fi
+
+    git commit -m "$MSG_COMMIT" >/dev/null 2>&1 || true
+
+    STASHED=0
+    if [ -n "$(git status --porcelain 2>/dev/null)" ]; then
+      git stash push -u -m "handoff-run pre-pull stash" >/dev/null 2>&1 && STASHED=1
+    fi
+
+    MEM_OK=0
+    for i in 1 2 3; do
+      if git pull --rebase origin main --quiet >/dev/null 2>&1 \
+         && git push origin main --quiet >/dev/null 2>&1; then
+        MEM_OK=1
+        break
+      fi
+      sleep 1
+    done
+
+    [ "$STASHED" = "1" ] && git stash pop >/dev/null 2>&1 || true
+
+    if [ "$MEM_OK" = "1" ]; then
+      echo "ok" > "$TMPD/memory"
+    else
+      echo "failed" > "$TMPD/memory"
+    fi
+  fi
+) &
+PID_MEMORY=$!
+
+# --- Branch C: Publish artifact → Notify ---
+(
+  AURL=""
+  if [ "$NO_PUBLISH" = "0" ] && [ -x "$SCRIPT_DIR/bin/publish-artifact.sh" ]; then
+    AURL=$(bash "$SCRIPT_DIR/bin/publish-artifact.sh" handoff "$ABS_FILE" \
+      --title "$TOPIC" \
+      --author "$AUTHOR" \
+      --description "$BRIEFING_LEAD" 2>/dev/null || echo "")
+  fi
+  echo "$AURL" > "$TMPD/artifact"
+
+  NS="skipped"
+  if [ "$NO_NOTIFY" = "0" ]; then
+    if [ -n "$AURL" ]; then
+      MSG_NOTIFY="Handoff from ${AUTHOR}: ${TOPIC}
+
+\"${BRIEFING_SHORT}\"
+
+View: ${AURL}"
+    else
+      MSG_NOTIFY="Handoff from ${AUTHOR}: ${TOPIC}
+
+\"${BRIEFING_SHORT}\""
+    fi
+
+    # Always notify. With a recipient (connected mode) → DM. Otherwise → group.
+    # Self-handoffs still post to the group so they're visible on /activity
+    # and in the Telegram feed — a handoff without a Telegram beat is invisible.
+    if [ -n "$RECIPIENT" ] && [ "$MODE" = "connected" ]; then
+      NR=$(bash "$SCRIPT_DIR/bin/notify.sh" send "$RECIPIENT" "$MSG_NOTIFY" 2>/dev/null || echo "Failed")
+    else
+      NR=$(bash "$SCRIPT_DIR/bin/notify.sh" group "$MSG_NOTIFY" 2>/dev/null || echo "Failed")
+    fi
+
+    if echo "$NR" | grep -qi "^Sent"; then
+      NS="sent"
+    elif echo "$NR" | grep -qi "^Failed"; then
+      NS="failed"
+    else
+      NS="unknown"
+    fi
+  fi
+  echo "$NS" > "$TMPD/notify"
+) &
+PID_PUBNOT=$!
+
+# Join (never fail parent — each branch reports its own status).
+# Branch D (PID_ARTIFACTS) is already awaited inside Branch B, but we wait
+# again here to be safe if B skipped the wait (--no-push path).
+wait "$PID_GRAPH"     2>/dev/null || true
+wait "$PID_MEMORY"    2>/dev/null || true
+wait "$PID_PUBNOT"    2>/dev/null || true
+wait "$PID_ARTIFACTS" 2>/dev/null || true
+
+# --- Collect results from tmpfiles --------------------------------------
+SESSION_ID=""
+RESOLVED=0
+GRAPH_STATUS="skipped"
+if [ -s "$TMPD/graph" ]; then
+  SESSION_ID=$(sed -n '1p' "$TMPD/graph")
+  RESOLVED=$(sed -n '2p' "$TMPD/graph")
+  GRAPH_STATUS=$(sed -n '3p' "$TMPD/graph")
+fi
+[ -z "$RESOLVED" ] && RESOLVED=0
+
+SUBGRAPH_JSON=$(cat "$TMPD/subgraph" 2>/dev/null || echo "null")
+[ -z "$SUBGRAPH_JSON" ] && SUBGRAPH_JSON="null"
+
+MEMORY_STATUS=$(cat "$TMPD/memory"   2>/dev/null || echo "skipped")
+ARTIFACT_URL=$(cat "$TMPD/artifact"  2>/dev/null || echo "")
+NOTIFY_STATUS=$(cat "$TMPD/notify"   2>/dev/null || echo "skipped")
+ARTIFACTS_ARR=$(cat "$TMPD/artifacts" 2>/dev/null || echo "[]")
+[ -z "$ARTIFACTS_ARR" ] && ARTIFACTS_ARR="[]"
+
+# --- Detached PR-number backfill ----------------------------------------
+# repo-state.sh was called with --no-pr for speed; now fire the backfill in
+# the background so PR columns get populated without blocking this script.
+# Reparented to init via `( cmd & ) >/dev/null 2>&1` — survives our exit.
+if [ "$MEMORY_STATUS" = "ok" ] && grep -q '^## Repo State' "$ABS_FILE" 2>/dev/null; then
+  ( bash "$SCRIPT_DIR/bin/handoff-pr-backfill.sh" "$ABS_FILE" "$TOPIC" >/dev/null 2>&1 & ) >/dev/null 2>&1
+fi
+
+# --- Emit minimal stdout, stash structured data in a tmpfile ------------
+#
+# The Bash tool block shows stdout verbatim and collapses after ~3 lines.
+# We keep stdout to exactly one compact status line so the block is
+# visually quiet. Full structured data goes to a well-known tmpfile that
+# the caller (skill) reads to render the rich card.
+STATUS_BITS=("saved")
+[ "$GRAPH_STATUS"  = "ok" ]    && STATUS_BITS+=("graphed")
+[ "$MEMORY_STATUS" = "ok" ]    && STATUS_BITS+=("pushed")
+if [ "$NOTIFY_STATUS" = "sent" ]; then
+  if [ -n "$RECIPIENT" ]; then
+    STATUS_BITS+=("${RECIPIENT} notified")
+  else
+    STATUS_BITS+=("group notified")
+  fi
+elif [ "$NOTIFY_STATUS" = "unknown" ] && [ -n "$RECIPIENT" ]; then
+  STATUS_BITS+=("${RECIPIENT} relayed to group")
+fi
+[ -n "$ARTIFACT_URL" ]         && STATUS_BITS+=("published")
+
+STATUS_LINE=""
+for bit in "${STATUS_BITS[@]}"; do
+  if [ -z "$STATUS_LINE" ]; then
+    STATUS_LINE="$bit"
+  else
+    STATUS_LINE="${STATUS_LINE} · ${bit}"
+  fi
+done
+
+# Stash structured result for the caller
+RESULT_FILE="${TMPDIR:-/tmp}/handoff-run-result.json"
+jq -cn \
+  --arg mode "$MODE" \
+  --arg file "$REL_FILE" \
+  --arg absFile "$ABS_FILE" \
+  --arg sessionId "$SESSION_ID" \
+  --argjson resolved "${RESOLVED:-0}" \
+  --arg graphStatus "$GRAPH_STATUS" \
+  --arg memoryStatus "$MEMORY_STATUS" \
+  --arg notifyStatus "$NOTIFY_STATUS" \
+  --arg artifactUrl "$ARTIFACT_URL" \
+  --arg recipient "$RECIPIENT" \
+  --arg topic "$TOPIC" \
+  --arg author "$AUTHOR" \
+  --argjson subgraph "$SUBGRAPH_JSON" \
+  --argjson artifacts "$ARTIFACTS_ARR" \
+  '{
+    mode:$mode,
+    file:$file,
+    absFile:$absFile,
+    sessionId:$sessionId,
+    resolved:$resolved,
+    graphStatus:$graphStatus,
+    memoryStatus:$memoryStatus,
+    notifyStatus:$notifyStatus,
+    artifactUrl:$artifactUrl,
+    recipient:$recipient,
+    topic:$topic,
+    author:$author,
+    subgraph:$subgraph,
+    artifacts:$artifacts
+  }' > "$RESULT_FILE"
+
+# One clean line for the Bash tool block.
+# The caller reads structured data from $TMPDIR/handoff-run-result.json.
+echo "⇌ ${STATUS_LINE}"

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

@@ -0,0 +1,131 @@
+#!/bin/bash
+# handoff-save-egregore.sh — background save+auto-merge for the core repo after a handoff.
+#
+# /handoff renders its card first, then fires this detached. The user never waits on git.
+#
+# Behavior:
+#   - If nothing to save (clean working tree + up-to-date with origin) → exit silently.
+#   - If on develop/main/master → create dev/{author}/handoff-{YYYY-MM-DD} branch from origin/develop.
+#   - Commit all changes, rebase onto origin/develop, push.
+#   - If push succeeds: create PR to develop (or reuse existing), then:
+#     - Markdown-only diff → `gh pr merge --auto --merge` (auto-merges when checks pass).
+#     - Code/config present → leave PR open for review (no auto-merge).
+#
+# Usage:
+#   handoff-save-egregore.sh <author> <topic> [--repo-dir <path>]
+#
+# --repo-dir overrides the default working directory (normally the script's
+# own repo root, resolved from $0). Tests and sandbox runs MUST pass it;
+# without it, the script operates on the real repo regardless of caller cwd.
+#
+# Detached usage (the skill calls it this way):
+#   ( bash bin/handoff-save-egregore.sh "$AUTHOR" "$TOPIC" >/dev/null 2>&1 & ) >/dev/null 2>&1
+#
+# Exit 0 on any non-fatal outcome. The caller never reads stdout/stderr — all status
+# lives in the PR itself and in `git log`.
+
+set -uo pipefail
+
+AUTHOR="${1:-}"
+TOPIC="${2:-session work}"
+shift 2 2>/dev/null || true
+
+REPO_DIR=""
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --repo-dir) REPO_DIR="${2:-}"; shift 2 ;;
+    *) shift ;;
+  esac
+done
+
+[ -n "$AUTHOR" ] || { echo "handoff-save-egregore: missing author" >&2; exit 1; }
+
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+# If --repo-dir wasn't given, default to the script's own repo root.
+[ -z "$REPO_DIR" ] && REPO_DIR="$SCRIPT_DIR"
+cd "$REPO_DIR" || exit 1
+
+# --- Early exit if nothing to do -----------------------------------------
+DIRTY=0
+[ -n "$(git status --porcelain 2>/dev/null)" ] && DIRTY=1
+
+CURRENT_BRANCH=$(git branch --show-current 2>/dev/null || echo "")
+AHEAD=0
+if [ -n "$CURRENT_BRANCH" ]; then
+  # Count commits ahead of origin/develop on the current branch (works from any
+  # dev/* branch or from develop itself).
+  AHEAD=$(git rev-list --count "origin/develop..HEAD" 2>/dev/null || echo 0)
+fi
+
+if [ "$DIRTY" = "0" ] && [ "$AHEAD" = "0" ]; then
+  exit 0
+fi
+
+# --- Protect the protected branches: create a working branch if needed --
+case "$CURRENT_BRANCH" in
+  develop|main|master|"")
+    SLUG_DATE=$(date +%Y-%m-%d)
+    NEW_BRANCH="dev/${AUTHOR}/handoff-${SLUG_DATE}"
+    git fetch origin develop --quiet 2>/dev/null || true
+    git checkout -b "$NEW_BRANCH" origin/develop --quiet 2>/dev/null || \
+      git checkout "$NEW_BRANCH" --quiet 2>/dev/null || exit 0
+    CURRENT_BRANCH="$NEW_BRANCH"
+    ;;
+esac
+
+# --- Commit whatever is uncommitted --------------------------------------
+if [ -n "$(git status --porcelain 2>/dev/null)" ]; then
+  git add -A 2>/dev/null || true
+  git commit -m "Handoff: ${TOPIC}" --quiet 2>/dev/null || true
+fi
+
+# --- Rebase onto develop, fall back to merge if rebase conflicts ---------
+git fetch origin develop --quiet 2>/dev/null || true
+if ! git rebase origin/develop --quiet 2>/dev/null; then
+  git rebase --abort 2>/dev/null || true
+  if ! git merge origin/develop --quiet -m "Sync with develop" 2>/dev/null; then
+    # Conflicts we can't auto-resolve. Leave the branch as-is; the user will see it
+    # next session or when they run /save explicitly.
+    git merge --abort 2>/dev/null || true
+    exit 0
+  fi
+fi
+
+# --- Push ---------------------------------------------------------------
+if ! git push -u origin "$CURRENT_BRANCH" --quiet 2>/dev/null; then
+  # Push failed (network, auth). Commits are safe locally.
+  exit 0
+fi
+
+# --- PR: reuse open PR on this branch, or create one --------------------
+command -v gh >/dev/null 2>&1 || exit 0
+
+PR_NUMBER=""
+EXISTING=$(gh pr list --head "$CURRENT_BRANCH" --state open --json number,baseRefName --jq '.[0]' 2>/dev/null)
+EXISTING_NUMBER=$(echo "$EXISTING" | jq -r '.number // empty' 2>/dev/null)
+EXISTING_BASE=$(echo "$EXISTING" | jq -r '.baseRefName // empty' 2>/dev/null)
+
+if [ -n "$EXISTING_NUMBER" ]; then
+  PR_NUMBER="$EXISTING_NUMBER"
+  if [ "$EXISTING_BASE" != "develop" ]; then
+    gh pr edit "$PR_NUMBER" --base develop >/dev/null 2>&1 || true
+  fi
+else
+  PR_URL=$(gh pr create \
+    --base develop \
+    --head "$CURRENT_BRANCH" \
+    --title "Handoff: ${TOPIC}" \
+    --body "Auto-created by /handoff. Session work for: ${TOPIC}" \
+    2>/dev/null || echo "")
+  PR_NUMBER=$(echo "$PR_URL" | grep -oE '[0-9]+$' || echo "")
+fi
+
+[ -n "$PR_NUMBER" ] || exit 0
+
+# --- Auto-merge iff markdown-only ---------------------------------------
+NON_MD=$(git diff origin/develop --name-only 2>/dev/null | grep -v '\.md$' | head -1 || echo "")
+if [ -z "$NON_MD" ]; then
+  gh pr merge "$PR_NUMBER" --auto --merge >/dev/null 2>&1 || true
+fi
+
+exit 0