@pennyfarthing/core 11.1.1 → 11.2.1

package/pennyfarthing-dist/scripts/core/phase-check-start.sh

@@ -1,90 +1,8 @@
 #!/bin/bash
-# Start an agent with phase check
-# If the current story's phase belongs to a different agent, emit handoff marker instead
+# DEPRECATED: Use `pf handoff phase-check <agent>` instead.
+# This shim delegates to the Python implementation.
 #
-# Usage: .pennyfarthing/scripts/core/phase-check-start.sh <agent>
-# Example: phase-check-start.sh dev
+# Usage: phase-check-start.sh <agent>
 
-set -euo pipefail
-
-AGENT="${1:-}"
-
-if [[ -z "$AGENT" ]]; then
-  echo "Usage: phase-check-start.sh <agent>" >&2
-  exit 1
-fi
-
-# Self-locate and set up PROJECT_ROOT
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-source "$SCRIPT_DIR/../lib/find-root.sh"
-
-SCRIPTS_DIR="$SCRIPT_DIR/.."
-SESSION_DIR="$PROJECT_ROOT/.session"
-
-# Find active session file
-SESSION_FILE=$(find "$SESSION_DIR" -maxdepth 1 -name "*-session.md" 2>/dev/null | head -1)
-
-if [[ -z "$SESSION_FILE" || ! -f "$SESSION_FILE" ]]; then
-  # No session - just start the agent normally
-  exec "$SCRIPTS_DIR/core/agent-session.sh" start "$AGENT"
-fi
-
-# Extract workflow and phase from session (handles multiple formats)
-# Format 1: **Workflow:** value
-# Format 2: - **Workflow**: value
-WORKFLOW=$(grep -E "\*\*Workflow\*?\*?:" "$SESSION_FILE" 2>/dev/null | head -1 | sed 's/.*\*\*Workflow\*\*[:\*]* *//' | tr -d ' ' || echo "")
-PHASE=$(grep -E "\*\*Phase\*?\*?:" "$SESSION_FILE" 2>/dev/null | head -1 | sed 's/.*\*\*Phase\*\*[:\*]* *//' | tr -d ' ' || echo "")
-
-if [[ -z "$WORKFLOW" ]]; then
-  # Can't determine workflow - start normally
-  exec "$SCRIPTS_DIR/core/agent-session.sh" start "$AGENT"
-fi
-
-# If no Phase field, try to infer from status patterns
-if [[ -z "$PHASE" ]]; then
-  # Check for approval status (story is done, needs SM to close)
-  if grep -qE "\*\*Status\*\*:.*APPROVED" "$SESSION_FILE" 2>/dev/null; then
-    PHASE="approved"
-  # Check for review status
-  elif grep -qE "Reviewer Assessment|Review.*REJECTED\|Review.*APPROVED" "$SESSION_FILE" 2>/dev/null; then
-    PHASE="review"
-  # Check for green/implementation complete
-  elif grep -qE "Dev Assessment|\*\*Status\*\*:.*GREEN" "$SESSION_FILE" 2>/dev/null; then
-    # Has dev assessment - could be in review or approved
-    if grep -qE "Reviewer Assessment" "$SESSION_FILE" 2>/dev/null; then
-      PHASE="approved"  # Reviewer already assessed
-    else
-      PHASE="review"    # Needs reviewer
-    fi
-  # Check for red/test phase
-  elif grep -qE "TEA Assessment|\*\*Status\*\*:.*RED" "$SESSION_FILE" 2>/dev/null; then
-    PHASE="green"  # TEA done, Dev's turn
-  else
-    # Can't determine phase - start normally
-    exec "$SCRIPTS_DIR/core/agent-session.sh" start "$AGENT"
-  fi
-fi
-
-# Get the owner of this phase
-OWNER=$("$SCRIPTS_DIR/workflow/phase-owner.sh" "$WORKFLOW" "$PHASE" 2>/dev/null || echo "")
-
-if [[ -z "$OWNER" ]]; then
-  # Phase owner lookup failed - start normally
-  exec "$SCRIPTS_DIR/core/agent-session.sh" start "$AGENT"
-fi
-
-# Check if this agent owns the phase
-if [[ "$OWNER" == "$AGENT" ]]; then
-  # Correct agent - start normally
-  exec "$SCRIPTS_DIR/core/agent-session.sh" start "$AGENT"
-fi
-
-# Wrong agent! Output the handoff marker and info
-STORY_ID=$(basename "$SESSION_FILE" -session.md)
-
-echo "Phase check: Story $STORY_ID is in '$PHASE' phase (workflow: $WORKFLOW)"
-echo "Phase owner: $OWNER (you requested: $AGENT)"
-echo ""
-
-# Generate and output the handoff marker
-pf handoff marker "$OWNER"
+echo "DEPRECATED: phase-check-start.sh — use 'pf handoff phase-check $1' instead" >&2
+exec pf handoff phase-check "$@"

package/pennyfarthing-dist/scripts/git/README.md

@@ -1,23 +1,33 @@
 # Git Scripts
 
-Scripts for Git operations, branching, and release management.
+Scripts for Git operations, branching, and worktree management.
 
-## Scripts
+## CLI Commands (preferred)
 
-| Script | Purpose |
-|--------|---------|
-| `create-feature-branches.sh` | Create feature branches in repos |
-| `git-status-all.sh` | Show git status across all repos |
-| `worktree-manager.sh` | Manage git worktrees for parallel work |
-| `install-git-hooks.sh` | Install git hooks in project |
-| `release.sh` | Release workflow (merge develop to main) |
+All git operations are available via the `pf git` CLI:
 
-## Usage
+| Command | Purpose |
+|---------|---------|
+| `pf git status [--brief]` | Show git status across all repos |
+| `pf git branches <name> [--repos all\|api\|ui]` | Create feature branches in repos |
+| `pf git worktree create <name> <branch>` | Create worktrees for parallel work |
+| `pf git worktree remove <name>` | Remove worktree and clean up |
+| `pf git worktree list` | List all active worktrees |
+| `pf git worktree status` | Show detailed worktree status |
+| `pf git install-hooks` | Install git hooks with .d/ dispatcher |
+| `pf git cleanup` | Organize changes into commits/branches |
 
-```bash
-.pennyfarthing/scripts/git/create-feature-branches.sh feat/my-feature
-.pennyfarthing/scripts/git/release.sh
-```
+## Legacy Scripts (deprecated shims)
+
+These scripts now forward to `pf git` commands:
+
+| Script | Forwards to |
+|--------|-------------|
+| `git-status-all.sh` | `pf git status` |
+| `create-feature-branches.sh` | `pf git branches` |
+| `worktree-manager.sh` | `pf git worktree` |
+| `install-git-hooks.sh` | `pf git install-hooks` |
+| `release.sh` | Release workflow (use `/pf-workflow start release`) |
 
 ## Ownership
 

package/pennyfarthing-dist/scripts/git/create-feature-branches.sh

@@ -1,267 +1,6 @@
-#!/usr/bin/env zsh
-# Create or checkout feature branches in Pennyfarthing repos
-# Idempotent, worktree-aware, branches from develop
-
+#!/usr/bin/env bash
+# DEPRECATED: Use `pf git branches` instead.
+# This shim forwards to the Python CLI.
 set -e
-
-# Load environment
-if [ -f .env ]; then
-    set -a; source .env; set +a
-elif [ -f ../.env ]; then
-    set -a; source ../.env; set +a
-fi
-
-show_help() {
-    cat << EOF
-Create Feature Branches - Idempotent branch creation/checkout
-
-Usage: ./create-feature-branches.sh <branch-name> [repos]
-
-Arguments:
-  branch-name    Branch name (e.g., feat/11-2-file-preview)
-  repos          Which repos to branch (default: all)
-                 Options: api, ui, all
-
-Repo Options:
-  api     - Pennyfarthing-api only
-  ui      - Pennyfarthing-ui only
-  all     - both repos (default)
-
-Examples:
-  # All repos (default)
-  ./create-feature-branches.sh feat/cross-repo-feature
-
-  # Pennyfarthing UI only
-  ./create-feature-branches.sh feat/11-2-ui-component ui
-
-  # Pennyfarthing API only
-  ./create-feature-branches.sh fix/validation-bug api
-
-Behavior:
-  - Idempotent: Checks out existing branches or creates new ones
-  - Worktree-aware: Detects main checkout vs worktree
-  - Always branches from develop
-  - Fetches latest develop before branching
-
-EOF
-}
-
-if [ -z "$1" ] || [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
-    show_help
-    exit 0
-fi
-
-BRANCH_NAME="$1"
-REPOS="${2:-all}"
-
-# Validate repos parameter
-if [[ ! "$REPOS" =~ ^(api|ui|all)$ ]]; then
-    echo "❌ Error: repos must be one of: api, ui, all"
-    echo "   Got: $REPOS"
-    echo ""
-    echo "Options:"
-    echo "  api     - Pennyfarthing-api only"
-    echo "  ui      - Pennyfarthing-ui only"
-    echo "  all     - both repos (default)"
-    exit 1
-fi
-
-# Detect if we're in a worktree
-CURRENT_DIR=$(pwd)
-if [[ "$CURRENT_DIR" == *"/worktrees/"* ]]; then
-    # Extract worktree name from path
-    WORKTREE_NAME=$(echo "$CURRENT_DIR" | sed -E 's|.*/worktrees/([^/]+).*|\1|')
-    REPO_BASE="$PROJECT_ROOT/worktrees/$WORKTREE_NAME"
-    echo "📂 Detected worktree: $WORKTREE_NAME"
-else
-    REPO_BASE="$PROJECT_ROOT"
-    echo "📂 Using main checkout"
-fi
-
-# Array to track processed repos for verification
-declare -a PROCESSED_REPOS
-
-# Function to create or checkout branch in a repo
-create_or_checkout_branch() {
-    local repo_path=$1
-    local repo_name=$2
-
-    if [ ! -d "$repo_path" ]; then
-        echo "⚠️  Skipping $repo_name: directory not found at $repo_path"
-        return
-    fi
-
-    cd "$repo_path"
-
-    echo ""
-    echo "🔧 Processing $repo_name..."
-
-    # Fetch latest from remote
-    echo "   Fetching from origin..."
-    git fetch origin --quiet
-
-    # Check if branch exists locally
-    if git show-ref --verify --quiet "refs/heads/$BRANCH_NAME"; then
-        echo "   ✅ Branch exists locally, checking out: $BRANCH_NAME"
-        git checkout "$BRANCH_NAME"
-    # Check if branch exists on remote
-    elif git show-ref --verify --quiet "refs/remotes/origin/$BRANCH_NAME"; then
-        echo "   ✅ Branch exists on remote, checking out and tracking: $BRANCH_NAME"
-        git checkout -b "$BRANCH_NAME" "origin/$BRANCH_NAME"
-    else
-        # Branch doesn't exist, create from develop
-        echo "   🌿 Creating new branch from develop: $BRANCH_NAME"
-
-        # Make sure we have latest develop
-        git fetch origin develop:develop --quiet 2>/dev/null || true
-
-        # Checkout develop first
-        if git show-ref --verify --quiet "refs/heads/develop"; then
-            git checkout develop --quiet
-            git pull origin develop --quiet
-        else
-            echo "   ⚠️  Local develop doesn't exist, fetching from remote"
-            git fetch origin develop:develop --quiet
-            git checkout develop --quiet
-        fi
-
-        # Create new branch
-        git checkout -b "$BRANCH_NAME"
-        echo "   ✅ Created: $BRANCH_NAME"
-    fi
-
-    # Show current status
-    CURRENT_BRANCH=$(git branch --show-current)
-    echo "   📍 Now on: $CURRENT_BRANCH"
-
-    # Track this repo for verification
-    PROCESSED_REPOS+=("$repo_path:$repo_name")
-}
-
-echo "🌿 Creating/checking out feature branches..."
-echo "   Branch: $BRANCH_NAME"
-echo "   Repos: $REPOS"
-
-# Process repos based on selection
-# When processing multiple repos, run in parallel for faster network I/O
-case "$REPOS" in
-    api)
-        create_or_checkout_branch "$REPO_BASE/Pennyfarthing-api" "Pennyfarthing-api"
-        ;;
-    ui)
-        create_or_checkout_branch "$REPO_BASE/Pennyfarthing-ui" "Pennyfarthing-ui"
-        ;;
-    all)
-        # Parallel execution for both repos
-        tmpdir=$(mktemp -d)
-        trap "rm -rf '$tmpdir'" EXIT
-        HAD_ERRORS=false
-
-        # Run both in parallel, capturing output
-        # Write to separate files to avoid race condition on shared file
-        (
-            create_or_checkout_branch "$REPO_BASE/Pennyfarthing-api" "Pennyfarthing-api"
-            echo "$REPO_BASE/Pennyfarthing-api:Pennyfarthing-api" > "$tmpdir/api.processed"
-        ) > "$tmpdir/api.out" 2>&1 &
-        pid_api=$!
-
-        (
-            create_or_checkout_branch "$REPO_BASE/Pennyfarthing-ui" "Pennyfarthing-ui"
-            echo "$REPO_BASE/Pennyfarthing-ui:Pennyfarthing-ui" > "$tmpdir/ui.processed"
-        ) > "$tmpdir/ui.out" 2>&1 &
-        pid_ui=$!
-
-        # Wait for both and capture exit codes
-        wait $pid_api; rc_api=$?
-        wait $pid_ui; rc_ui=$?
-
-        # Show output in order
-        [ -f "$tmpdir/api.out" ] && cat "$tmpdir/api.out"
-        [ -f "$tmpdir/ui.out" ] && cat "$tmpdir/ui.out"
-
-        # Rebuild PROCESSED_REPOS from separate files (avoids race condition)
-        [ -f "$tmpdir/api.processed" ] && PROCESSED_REPOS+=("$(cat "$tmpdir/api.processed")")
-        [ -f "$tmpdir/ui.processed" ] && PROCESSED_REPOS+=("$(cat "$tmpdir/ui.processed")")
-
-        # Check for failures
-        if [ $rc_api -ne 0 ] || [ $rc_ui -ne 0 ]; then
-            echo "⚠️  Some repos had errors"
-            HAD_ERRORS=true
-        fi
-        ;;
-esac
-
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "🔍 Verification Summary"
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-
-# Verify each processed repo
-for repo_info in "${PROCESSED_REPOS[@]}"; do
-    repo_path="${repo_info%%:*}"
-    repo_name="${repo_info##*:}"
-
-    if [ -d "$repo_path" ]; then
-        cd "$repo_path"
-
-        echo ""
-        echo "📦 $repo_name"
-        echo "   Path: $repo_path"
-
-        # Current branch
-        CURRENT_BRANCH=$(git branch --show-current)
-        echo "   Branch: $CURRENT_BRANCH"
-
-        # Check if branch matches expected
-        if [ "$CURRENT_BRANCH" = "$BRANCH_NAME" ]; then
-            echo "   ✅ Branch matches: $BRANCH_NAME"
-        else
-            echo "   ⚠️  Branch mismatch! Expected: $BRANCH_NAME, Got: $CURRENT_BRANCH"
-        fi
-
-        # Latest commit
-        COMMIT_INFO=$(git log -1 --format="%h - %s" 2>/dev/null)
-        echo "   Commit: $COMMIT_INFO"
-
-        # Check remote tracking
-        UPSTREAM=$(git rev-parse --abbrev-ref --symbolic-full-name @{u} 2>/dev/null || echo "none")
-        if [ "$UPSTREAM" != "none" ]; then
-            echo "   Remote: $UPSTREAM"
-
-            # Check if up to date with remote
-            git fetch origin "$CURRENT_BRANCH" --quiet 2>/dev/null || true
-            LOCAL=$(git rev-parse @ 2>/dev/null)
-            REMOTE=$(git rev-parse @{u} 2>/dev/null || echo "none")
-
-            if [ "$LOCAL" = "$REMOTE" ]; then
-                echo "   Status: ✅ Up to date with remote"
-            elif [ "$REMOTE" = "none" ]; then
-                echo "   Status: ⚠️  No remote branch yet (push needed)"
-            else
-                BEHIND=$(git rev-list --count HEAD..@{u} 2>/dev/null || echo "0")
-                AHEAD=$(git rev-list --count @{u}..HEAD 2>/dev/null || echo "0")
-                if [ "$AHEAD" -gt 0 ] && [ "$BEHIND" -gt 0 ]; then
-                    echo "   Status: ⚠️  Diverged ($AHEAD ahead, $BEHIND behind)"
-                elif [ "$AHEAD" -gt 0 ]; then
-                    echo "   Status: ⬆️  $AHEAD commit(s) ahead of remote"
-                elif [ "$BEHIND" -gt 0 ]; then
-                    echo "   Status: ⬇️  $BEHIND commit(s) behind remote"
-                fi
-            fi
-        else
-            echo "   Remote: none (local branch only)"
-            echo "   Status: ⚠️  Not tracking remote (push with -u needed)"
-        fi
-    fi
-done
-
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-if [ "$HAD_ERRORS" = true ]; then
-    echo "⚠️  Done with errors. Check output above."
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    exit 1
-else
-    echo "✅ Done! All branches verified and ready."
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-fi
+echo "DEPRECATED: create-feature-branches.sh — use 'pf git branches' instead" >&2
+exec pf git branches "$@"

package/pennyfarthing-dist/scripts/git/git-status-all.sh

@@ -1,152 +1,6 @@
-#!/usr/bin/env zsh
-# Show git status across all repos
-# Usage: ./scripts/git-status-all.sh [--brief]
-#
-# Shows: branch, status, unpushed commits for all repos
-# Reads repo configuration from .pennyfarthing/repos.yaml
-
+#!/usr/bin/env bash
+# DEPRECATED: Use `pf git status` instead.
+# This shim forwards to the Python CLI.
 set -e
-
-# Source environment (inline to avoid argument passing issues)
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-if [ -f "$SCRIPT_DIR/../.env" ]; then
-    set -a; source "$SCRIPT_DIR/../.env"; set +a
-fi
-
-# Fallback if PROJECT_ROOT not set
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-# Source repo utilities for dynamic repo configuration
-source "$SCRIPT_DIR/../misc/repo-utils.sh"
-
-# Colors
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-RED='\033[0;31m'
-NC='\033[0m'
-
-BRIEF=false
-if [ "${1:-}" = "--brief" ] || [ "${1:-}" = "-b" ]; then
-    BRIEF=true
-fi
-
-cd "$PROJECT_ROOT"
-
-show_repo_status() {
-    local repo_name=$1
-    local repo_dir=$2  # Note: can't use 'path' - it's a zsh special variable
-
-    if [ ! -d "$repo_dir/.git" ] && [ ! -d "$repo_dir" ]; then
-        return
-    fi
-
-    local branch=$(git -C "$repo_dir" branch --show-current 2>/dev/null || echo "detached")
-    local git_status=$(git -C "$repo_dir" status --short 2>/dev/null)
-    local git_status_count=$(echo "$git_status" | grep -c . 2>/dev/null); git_status_count=${git_status_count:-0}
-    local unpushed=$(git -C "$repo_dir" log origin/develop..HEAD --oneline 2>/dev/null | head -5)
-    local unpushed_count=$(git -C "$repo_dir" log origin/develop..HEAD --oneline 2>/dev/null | wc -l | tr -d ' ')
-
-    if $BRIEF; then
-        # One-line format
-        local status_indicator=""
-        [ "$git_status_count" -gt 0 ] && status_indicator="${YELLOW}M${NC}" || status_indicator="${GREEN}✓${NC}"
-        local push_indicator=""
-        [ "$unpushed_count" -gt 0 ] && push_indicator=" ${BLUE}↑${unpushed_count}${NC}"
-        echo -e "$repo_name: $branch $status_indicator$push_indicator"
-    else
-        echo -e "${BLUE}=== $repo_name ===${NC}"
-        echo -e "Branch: ${GREEN}$branch${NC}"
-
-        if [ -n "$git_status" ]; then
-            echo -e "${YELLOW}Changes:${NC}"
-            echo "$git_status" | head -10 | sed 's/^/  /'
-            [ "$git_status_count" -gt 10 ] && echo "  ... and $((git_status_count - 10)) more"
-        else
-            echo -e "${GREEN}Clean${NC}"
-        fi
-
-        if [ "$unpushed_count" -gt 0 ]; then
-            echo -e "${BLUE}Unpushed ($unpushed_count):${NC}"
-            echo "$unpushed" | sed 's/^/  /'
-            [ "$unpushed_count" -gt 5 ] && echo "  ... and $((unpushed_count - 5)) more"
-        fi
-        echo ""
-    fi
-}
-
-if ! $BRIEF; then
-    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-    echo -e "${BLUE}  Git Status - All Repos${NC}"
-    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-    echo ""
-fi
-
-# Check each repo from configuration (parallelized for performance)
-repo_count=$(get_repo_count)
-if [[ "$repo_count" -eq 0 ]]; then
-    # No repos configured, just show current directory
-    show_repo_status "Project" "$PROJECT_ROOT"
-else
-    # Create temp dir for parallel output capture
-    tmpdir=$(mktemp -d)
-    trap "rm -rf '$tmpdir'" EXIT
-
-    # Launch status checks in parallel
-    for repo in $(get_repos); do
-        repo_path=$(get_repo_full_path "$repo")
-        (show_repo_status "$repo" "$repo_path" > "$tmpdir/$repo.out" 2>&1) &
-    done
-    wait
-
-    # Output results in order
-    for repo in $(get_repos); do
-        [ -f "$tmpdir/$repo.out" ] && cat "$tmpdir/$repo.out"
-    done
-fi
-
-if ! $BRIEF; then
-    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-    # Summary
-    total_changes=0
-    total_unpushed=0
-
-    if [[ "$repo_count" -eq 0 ]]; then
-        # No repos configured, just check current directory
-        count=$(git -C "$PROJECT_ROOT" status --short 2>/dev/null | wc -l | tr -d ' ')
-        total_changes=$((total_changes + count))
-        unpushed=$(git -C "$PROJECT_ROOT" log origin/develop..HEAD --oneline 2>/dev/null | wc -l | tr -d ' ')
-        total_unpushed=$((total_unpushed + unpushed))
-    else
-        # Parallelize summary collection
-        summary_tmp=$(mktemp -d)
-        for repo in $(get_repos); do
-            repo_path=$(get_repo_full_path "$repo")
-            (
-                [ -d "$repo_path/.git" ] || [ -d "$repo_path" ] || exit 0
-                count=$(git -C "$repo_path" status --short 2>/dev/null | wc -l | tr -d ' ')
-                unpushed=$(git -C "$repo_path" log origin/develop..HEAD --oneline 2>/dev/null | wc -l | tr -d ' ')
-                echo "$count $unpushed" > "$summary_tmp/$repo.count"
-            ) &
-        done
-        wait
-
-        # Aggregate results
-        for repo in $(get_repos); do
-            if [ -f "$summary_tmp/$repo.count" ]; then
-                read count unpushed < "$summary_tmp/$repo.count"
-                total_changes=$((total_changes + count))
-                total_unpushed=$((total_unpushed + unpushed))
-            fi
-        done
-        rm -rf "$summary_tmp"
-    fi
-
-    if [ "$total_changes" -eq 0 ] && [ "$total_unpushed" -eq 0 ]; then
-        echo -e "${GREEN}✅ All repos clean and pushed${NC}"
-    else
-        [ "$total_changes" -gt 0 ] && echo -e "${YELLOW}$total_changes uncommitted change(s)${NC}"
-        [ "$total_unpushed" -gt 0 ] && echo -e "${BLUE}$total_unpushed unpushed commit(s)${NC}"
-    fi
-fi
+echo "DEPRECATED: git-status-all.sh — use 'pf git status' instead" >&2
+exec pf git status "$@"