CURRENT_WORKTREE=$(git rev-parse --show-toplevel)
MAIN_REPO=$(dirname "$(git rev-parse --git-common-dir)")
 
# List all worktrees with their branch names, excluding current and main repo.
# Parsed in bash rather than awk: a skill body is not a safe place for `$N` of
# any kind (the harnesses disagree about substituting it — see
# ../../shared/config.sh). Prefix-stripping also keeps paths containing spaces
# intact, and a detached-HEAD worktree emits no `branch` line so it is skipped.
git worktree list --porcelain | while IFS= read -r line; do
  case "$line" in
    "worktree "*) wt_path="${line#worktree }" ;;
    "branch refs/heads/"*) printf '%s\t%s\n' "$wt_path" "${line#branch refs/heads/}" ;;
  esac
done | while IFS=$'\t' read -r wt br; do
  [ "$wt" = "$CURRENT_WORKTREE" ] && continue   # Never delete own worktree (would break session CWD)
  [ "$wt" = "$MAIN_REPO" ] && continue          # Never delete main repo
  [[ "$br" = "main" || "$br" = "master" ]] && continue
 
  # Only remove if the branch has a merged PR and no currently open PR
  # (open PR check guards against branch-name reuse: an older merged PR
  # with the same name must not cause deletion of an active worktree)
  OPEN_PR=$(gh pr list --state open --head "$br" --json number --jq '.[0].number' 2>/dev/null)
  [ -n "$OPEN_PR" ] && continue
  PR_NUM=$(gh pr list --state merged --head "$br" --json number --jq '.[0].number' 2>/dev/null)
  if [ -n "$PR_NUM" ]; then
    echo "Cleaning up stale worktree: $wt (branch: $br, PR #$PR_NUM merged)"
    git worktree remove --force "$wt" 2>/dev/null || true
    git branch -D "$br" 2>/dev/null || true
    git push origin --delete "$br" 2>/dev/null || true
  fi
done
 
# Prune stale entries in the worktree registry (directories deleted manually)
git worktree prune -v
 
echo "=== Step 0 complete ==="
git worktree list

BRANCH=$(git branch --show-current)
PR_NUMBER=$(gh pr view --json number --jq '.number' 2>/dev/null)
 
if [ -z "$PR_NUMBER" ]; then
  if [ -n "${CODEX_THREAD_ID:-}" ]; then
    echo "No open PR for the current branch — stopping without changes."
  else
    echo "No open PR for the current branch — cleanup only, not merging."
  fi
  exit 0
fi
 
echo "Ready to merge: branch=$BRANCH, PR=#$PR_NUMBER"

IS_WORKTREE=$([ "$(git rev-parse --git-common-dir)" != "$(git rev-parse --git-dir)" ] && echo yes || echo no)
 
if [ "$IS_WORKTREE" = "yes" ]; then
  # Refusal: the new flow commits everything intentionally, so anything
  # uncommitted at this point is unintentional and must be surfaced.
  if ! git diff --quiet HEAD; then
    echo "Worktree has uncommitted changes — refusing to merge."
    echo "Commit or stash first, then re-run /merge-pr."
    exit 1
  fi
fi

# --- solopreneur config helpers (sourced from shared/config.sh) ---
# One real shell file, so no harness rewrites the helpers on the way to the
# shell. Claude Code replaces the ${CLAUDE_SKILL_DIR} token below when it loads
# this body; Codex does not. It is SINGLE-quoted on purpose — it is a load-time
# token, not an environment variable, and letting the shell expand the name
# would source whatever an inherited value happened to point at. Unreplaced, it
# is not a directory, so substitute the absolute path of the directory holding
# THIS SKILL.md — every harness states that path to the model.
SOLO_SKILL_DIR='${CLAUDE_SKILL_DIR}'
[ -d "$SOLO_SKILL_DIR" ] || SOLO_SKILL_DIR="<absolute path of the directory holding this SKILL.md>"
SOLO_CONFIG_SH="$SOLO_SKILL_DIR/../../shared/config.sh"
# Three candidates, one contract. Inside the plugin the helpers sit at ../../shared/;
# authoring against this repo reaches them under src/solopreneur/shared/; and a
# skill republished on its own — any flattened skills directory — carries them
# at scripts/config.sh instead, because shared/ is a sibling of skills/ and does
# not travel with a per-skill copy. Try each in order, then STOP. Sourcing a
# file that is not there does not halt the shell: every helper stays undefined,
# every config read returns empty, and the 2026-08-11 A2 run showed where that
# leads — the model "rescued" it with a repo-relative path, which resolves only
# when the repo under review happens to be this plugin's own source repo.
# Canonical authoring keeps non-skill source under src/.
[ -f "$SOLO_CONFIG_SH" ] || SOLO_CONFIG_SH="$SOLO_SKILL_DIR/../../../src/solopreneur/shared/config.sh"
[ -f "$SOLO_CONFIG_SH" ] || SOLO_CONFIG_SH="$SOLO_SKILL_DIR/scripts/config.sh"
[ -f "$SOLO_CONFIG_SH" ] || { echo "HALT: solopreneur config helpers not found under $SOLO_SKILL_DIR — stop here, do not improvise a path"; exit 1; }
source "$SOLO_CONFIG_SH"
# --- end solopreneur config helpers ---
 
TODOS_CONFIG=$(read_solopreneur_config todos)
PLANS_CONFIG=$(read_solopreneur_config plans)
 
BACKLOG=$(echo "${TODOS_CONFIG:-{}}" | jq -r '.backlog // empty')
DOING=$(echo "${TODOS_CONFIG:-{}}"  | jq -r '.doing  // empty')
DONE_DIR=$(echo "${TODOS_CONFIG:-{}}" | jq -r '.done  // empty')
PLANS_DIR=$(echo "${PLANS_CONFIG:-{}}" | jq -r '.dir // empty')
PLANS_DIR="${PLANS_DIR:-docs/solopreneur/plans}"
 
BRANCH=$(git branch --show-current)

import re, sys, os
from datetime import date
def consolidate(path, branch):
    merge_date = date.today().isoformat()
    with open(path) as f:
        content = f.read()
    lines = content.split('\n')
    # 1. Update status line in first 20 lines
    for i in range(min(20, len(lines))):
        if re.match(r'^Status:', lines[i]):
            lines[i] = f'Status: merged {merge_date}'
            break
    content = '\n'.join(lines)
    # 2. Find all Handoff Context sections for this branch
    pattern = rf'^## Handoff Context \([^)]*branch: {re.escape(branch)}\)'
    matches = [(m.start(), m.group()) for m in re.finditer(pattern, content, re.MULTILINE)]
    if not matches:
        print(f'No Handoff Context sections found for branch {branch}')
        return content
    # 3. Rename the latest (last in file) to Final Progress
    latest_start, latest_heading = matches[-1]
    new_heading = f'## Final Progress (merged {merge_date}, branch: {branch})'
    content = content[:latest_start] + new_heading + content[latest_start + len(latest_heading):]
    # 4. Delete older same-branch Handoff Context sections (all except latest)
    # After rename, re-find remaining old headings (indices may have shifted)
    for old_start, old_heading in reversed(matches[:-1]):
        # Find the section extent: from heading to just before the next ## heading
        section_start = old_start
        after = content[section_start + len(old_heading):]
        next_h2 = re.search(r'\n## ', after)
        if next_h2:
            section_end = section_start + len(old_heading) + next_h2.start()
        else:
            section_end = len(content)
        # Delete the old section (trim leading newlines from what follows)
        rest = content[section_end:].lstrip('\n')
        content = content[:section_start] + rest
    return content
if __name__ == '__main__':
    path = sys.argv[1]
    branch = sys.argv[2]
    result = consolidate(path, branch)
    with open(path, 'w') as f:
        f.write(result)
    print('Consolidation complete')

TMPSCRIPT=$(mktemp /tmp/consolidate_XXXXXX.py)
cat > "$TMPSCRIPT" << 'PYEOF'
import re, sys, os
from datetime import date
 
def consolidate(path, branch):
    merge_date = date.today().isoformat()
    with open(path) as f:
        content = f.read()
 
    lines = content.split('\n')
 
    # 1. Update status line in first 20 lines
    for i in range(min(20, len(lines))):
        if re.match(r'^Status:', lines[i]):
            lines[i] = f'Status: merged {merge_date}'
            break
 
    content = '\n'.join(lines)
 
    # 2. Find all Handoff Context sections for this branch
    pattern = rf'^## Handoff Context \([^)]*branch: {re.escape(branch)}\)'
    matches = [(m.start(), m.group()) for m in re.finditer(pattern, content, re.MULTILINE)]
 
    if not matches:
        print(f'No Handoff Context sections found for branch {branch}')
        return content
 
    # 3. Rename the latest (last in file) to Final Progress
    # Safe: matches are sorted ascending by position; latest_start is always the highest
    # offset, so the rename does not affect byte offsets of earlier (old) headings.
    latest_start, latest_heading = matches[-1]
    new_heading = f'## Final Progress (merged {merge_date}, branch: {branch})'
    content = content[:latest_start] + new_heading + content[latest_start + len(latest_heading):]
 
    # 4. Delete older same-branch Handoff Context sections (all except latest)
    # Iterate in reverse so higher-offset deletions don't shift lower-offset positions.
    for old_start, old_heading in reversed(matches[:-1]):
        section_start = old_start
        after = content[section_start + len(old_heading):]
        next_h2 = re.search(r'\n## ', after)
        if next_h2:
            section_end = section_start + len(old_heading) + next_h2.start()
        else:
            section_end = len(content)
        rest = content[section_end:].lstrip('\n')
        content = content[:section_start] + rest
 
    return content
 
if __name__ == '__main__':
    path = sys.argv[1]
    branch = sys.argv[2]
    result = consolidate(path, branch)
    with open(path, 'w') as f:
        f.write(result)
    print('Consolidation complete')
PYEOF
python3 "$TMPSCRIPT" "$PLAN_FILE" "$BRANCH"
rm -f "$TMPSCRIPT"

git add "$PLAN_FILE"
git diff --cached --quiet || {
  git commit -m "docs: consolidate plan progress before merging PR #${PR_NUMBER}"
  git push
}

if [ -n "$DOING" ] && [ -n "$DONE_DIR" ]; then
  if [[ "$PLAN_FILE" == "$DOING"/* ]]; then
    FILENAME=$(basename "$PLAN_FILE")
    mkdir -p "$DONE_DIR"
    git mv "$PLAN_FILE" "$DONE_DIR/$FILENAME"
  fi
fi

if [ -n "$DOING" ] && [ -n "$DONE_DIR" ] && [[ "$PLAN_FILE" == "$DOING"/* ]]; then
  FILENAME=$(basename "$PLAN_FILE")
  git commit -m "chore: move $FILENAME to done/"
  git push
fi

# Pin every read to the exact commit we are about to merge. Passing the SHA
# in the API path (not `gh pr checks`, which reads the PR's current head and
# can lag behind a just-pushed commit) is what makes the stale-SHA race
# impossible: checks for an older commit can never be mistaken for this one's.
HEAD_SHA=$(gh pr view "$PR_NUMBER" --json headRefOid --jq '.headRefOid')
if [ -z "$HEAD_SHA" ]; then
  echo "Could not resolve head SHA for PR $PR_NUMBER — refusing to merge blind."
  exit 1
fi
echo "Gating merge on CI for head SHA: $HEAD_SHA"
 
# Verdict for a SHA: green | pending | failed | none. Reads BOTH the Checks
# API (GitHub Actions) and legacy commit statuses (external CI) so a
# status-only repo is neither mistaken for "no CI" nor merged over a red
# external check. `--paginate --slurp` pulls EVERY page of check-runs: a commit
# with >100 checks (large monorepos do) would otherwise hide failures on later
# pages and let the gate pass a red commit as green.
ci_verdict_for_sha() {
  local sha="$1" cr st
  # A failed API call must NEVER be mistaken for "zero checks". A rate-limit /
  # network / auth blip that returned no data would read as `none` and, after
  # the poll budget, merge a repo that actually HAS CI. Treat any fetch failure
  # as `pending` so the loop retries and ultimately aborts, never merges. (No
  # `2>/dev/null`: let gh's error surface for the operator.)
  cr=$(gh api --paginate --slurp "repos/{owner}/{repo}/commits/$sha/check-runs?per_page=100") || { echo pending; return; }
  st=$(gh api "repos/{owner}/{repo}/commits/$sha/status")                                     || { echo pending; return; }
 
  local cr_total cr_bad cr_incomplete st_total st_state
  # `--slurp` wraps the pages in an array: total_count is identical on every
  # page (read [0]); check-runs are flattened across all pages (.[].check_runs[]).
  cr_total=$(jq -r '.[0].total_count // 0' <<<"$cr")
  # "bad" = a completed run whose conclusion is not a pass (success/neutral/
  # skipped). Matches GitHub branch-protection semantics — cancelled,
  # timed_out, action_required and failure all count as not-passing.
  cr_bad=$(jq '[.[].check_runs[]? | select(.status=="completed") | select(.conclusion!="success" and .conclusion!="neutral" and .conclusion!="skipped")] | length' <<<"$cr")
  cr_incomplete=$(jq '[.[].check_runs[]? | select(.status!="completed")] | length' <<<"$cr")
  st_total=$(jq -r '.total_count // 0' <<<"$st")
  st_state=$(jq -r '.state // "pending"' <<<"$st")
 
  # Neither system reports anything for this SHA.
  if [ "$cr_total" -eq 0 ] && [ "$st_total" -eq 0 ]; then echo none; return; fi
  # Any hard failure wins. Legacy commit-status rolls up to success/pending/
  # failure/error — `error` (external CI infra failure) is a hard fail too, not
  # a pass, so catch it here or it falls through to green.
  if [ "$cr_bad" -gt 0 ] || [ "$st_state" = failure ] || [ "$st_state" = error ]; then echo failed; return; fi
  # Anything still running, or statuses rolled up pending — but only when
  # statuses actually exist: an empty status set reports state=pending, which
  # must NOT be read as an outstanding check (verified against the API).
  if [ "$cr_incomplete" -gt 0 ] || { [ "$st_total" -gt 0 ] && [ "$st_state" = pending ]; }; then echo pending; return; fi
  echo green
}
 
MAX_ATTEMPTS=10
ATTEMPT=0
EVER_SAW_CHECK=0
NO_CI_SIGNAL=0
 
while :; do
  VERDICT=$(ci_verdict_for_sha "$HEAD_SHA")
 
  if [ "$VERDICT" = green ]; then
    echo "CI green for $HEAD_SHA — proceeding to merge."
    break
  fi
 
  if [ "$VERDICT" = failed ]; then
    echo "CI FAILED for $HEAD_SHA — refusing to merge. Failing checks:"
    gh api --paginate "repos/{owner}/{repo}/commits/$HEAD_SHA/check-runs?per_page=100" \
      --jq '.check_runs[] | select(.status=="completed") | select(.conclusion!="success" and .conclusion!="neutral" and .conclusion!="skipped") | "  - \(.name): \(.conclusion)"'
    gh api "repos/{owner}/{repo}/commits/$HEAD_SHA/status" \
      --jq '.statuses[]? | select(.state=="failure" or .state=="error") | "  - \(.context): \(.state)"'
    exit 1
  fi
 
  # VERDICT is "pending" or "none" → not green yet.
  [ "$VERDICT" = pending ] && EVER_SAW_CHECK=1
  ATTEMPT=$((ATTEMPT + 1))
 
  if [ "$ATTEMPT" -ge "$MAX_ATTEMPTS" ]; then
    if [ "$EVER_SAW_CHECK" -eq 1 ]; then
      echo "CI still pending — not merging (waited ${MAX_ATTEMPTS}×60s for $HEAD_SHA)."
      exit 1
    fi
    # No check EVER reported across the whole window → treat as a repo with
    # zero CI configured. Proceed, but flag loudly — never silent.
    echo "FLAG: merged with no CI signal — no checks ever reported for $HEAD_SHA."
    NO_CI_SIGNAL=1
    break
  fi
 
  if [ "$EVER_SAW_CHECK" -eq 1 ]; then
    echo "CI pending for $HEAD_SHA (attempt $ATTEMPT/$MAX_ATTEMPTS) — waiting 60s..."
  else
    echo "No checks reported yet for $HEAD_SHA (attempt $ATTEMPT/$MAX_ATTEMPTS) — treating as pending, waiting 60s..."
  fi
  sleep 60
done

# Re-confirm the head has not advanced since the Step 4 gate. A commit pushed
# during the poll window would otherwise be merged while only the OLD SHA's CI
# was verified — the exact stale-green that head-SHA pinning exists to prevent.
LATEST_HEAD=$(gh pr view "$PR_NUMBER" --json headRefOid --jq '.headRefOid')
if [ "$LATEST_HEAD" != "$HEAD_SHA" ]; then
  echo "PR head moved ($HEAD_SHA → $LATEST_HEAD) since the CI gate — refusing to merge a commit CI hasn't cleared. Re-run /merge-pr to re-gate the new head."
  exit 1
fi
 
if [ -n "${CODEX_THREAD_ID:-}" ]; then
  MERGE_ARGS=(--squash --match-head-commit "$HEAD_SHA")
else
  MERGE_ARGS=(--squash --delete-branch)
fi
 
if ! gh pr merge "$PR_NUMBER" "${MERGE_ARGS[@]}"; then
  echo "Merge command failed (see gh error above) — stopping."
  exit 1
fi
 
# Verify the merge succeeded
STATE=$(gh pr view "$PR_NUMBER" --json state --jq '.state')
echo "PR state: $STATE"
[ "$STATE" = "MERGED" ] || { echo "Merge failed — stopping."; exit 1; }
 
CODEX_REMOTE_BRANCH_STATUS=""
if [ -n "${CODEX_THREAD_ID:-}" ]; then
  if git push origin --delete "$BRANCH"; then
    CODEX_REMOTE_BRANCH_STATUS="deleted"
  else
    CODEX_REMOTE_BRANCH_STATUS="retained (manual cleanup required)"
  fi
fi

PR #<N> merged to main (commit <sha>)
 
Current worktree retained (will be cleaned automatically when /merge-pr runs
from another session):
  worktree: <path>
  branch:   <branch>
 
To clean up immediately, run /merge-pr from the main repo or another worktree session.

[FLAG] merged with no CI signal — repo has no CI checks configured