@arthai/agents 1.0.0

package/dist/plugins/prime/hooks/session-bootstrap.sh

@@ -0,0 +1,379 @@
+#!/bin/bash
+# SessionStart hook: Gather project context and inject a compact briefing.
+# Runs once when Claude Code opens. Outputs 2-5 lines of context.
+# Non-blocking — degrades gracefully if tools are missing.
+#
+# stdout is injected as context into the conversation.
+
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+
+# ---------------------------------------------------------------------------
+# Clear triage marker — forces full routing table on first message
+# ---------------------------------------------------------------------------
+rm -f "$PROJECT_DIR/.claude/.triage-full-emitted" 2>/dev/null || true
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+# Check if a command exists silently
+has_cmd() { command -v "$1" &>/dev/null; }
+
+# Run a command with timeout, return empty on failure
+# Uses perl fallback on macOS where GNU timeout doesn't exist
+safe_run() {
+    local timeout_s="${1:-3}"
+    shift
+    if command -v timeout &>/dev/null; then
+        timeout "$timeout_s" "$@" 2>/dev/null || true
+    else
+        # macOS fallback: run directly (no timeout protection, but at least it works)
+        "$@" 2>/dev/null || true
+    fi
+}
+
+# ---------------------------------------------------------------------------
+# 1. Project detection
+# ---------------------------------------------------------------------------
+
+project_name=$(basename "$PROJECT_DIR")
+claude_md_exists=false
+[ -f "$PROJECT_DIR/CLAUDE.md" ] && claude_md_exists=true
+
+# Detect greenfield vs brownfield
+is_greenfield=true
+if $claude_md_exists; then
+    is_greenfield=false
+elif [ -f "$PROJECT_DIR/package.json" ] || [ -f "$PROJECT_DIR/requirements.txt" ] || \
+     [ -f "$PROJECT_DIR/go.mod" ] || [ -f "$PROJECT_DIR/Cargo.toml" ] || \
+     [ -d "$PROJECT_DIR/src" ] || [ -d "$PROJECT_DIR/app" ]; then
+    is_greenfield=false
+fi
+
+# ---------------------------------------------------------------------------
+# 2. Git context (fast — local only)
+# ---------------------------------------------------------------------------
+
+branch=""
+uncommitted=0
+ahead_behind=""
+last_commit=""
+stash_count=0
+has_git=false
+
+if [ -d "$PROJECT_DIR/.git" ]; then
+    has_git=true
+    cd "$PROJECT_DIR"
+
+    branch=$(safe_run 2 git rev-parse --abbrev-ref HEAD)
+    uncommitted=$(safe_run 2 git status --short | wc -l | tr -d ' ')
+
+    # Ahead/behind remote
+    upstream=$(safe_run 2 git rev-parse --abbrev-ref '@{upstream}') || true
+    if [ -n "$upstream" ]; then
+        local_rev=$(safe_run 2 git rev-parse HEAD)
+        remote_rev=$(safe_run 2 git rev-parse "$upstream")
+        if [ "$local_rev" != "$remote_rev" ]; then
+            ahead=$(safe_run 2 git rev-list --count "$upstream..HEAD")
+            behind=$(safe_run 2 git rev-list --count "HEAD..$upstream")
+            parts=()
+            [ "${ahead:-0}" -gt 0 ] && parts+=("${ahead} ahead")
+            [ "${behind:-0}" -gt 0 ] && parts+=("${behind} behind")
+            if [ ${#parts[@]} -gt 0 ]; then
+                ahead_behind=$(IFS=', '; echo "${parts[*]}")
+            fi
+        fi
+    fi
+
+    # Last commit (short)
+    last_commit=$(safe_run 2 git log -1 --format='%s (%cr)' 2>/dev/null) || true
+
+    # Stash count
+    stash_count=$(safe_run 2 git stash list | wc -l | tr -d ' ')
+
+    cd - >/dev/null 2>&1 || true
+fi
+
+# ---------------------------------------------------------------------------
+# 3. Environment health (from CLAUDE.md + docker + alembic)
+# ---------------------------------------------------------------------------
+
+docker_status=""
+alembic_status=""
+mcp_status=""
+
+# Docker container health (if docker is available and CLAUDE.md mentions docker)
+if has_cmd docker && docker info &>/dev/null 2>&1; then
+    running_containers=$(safe_run 3 docker ps --format '{{.Names}}' | tr '\n' ' ')
+    # Check common DB containers
+    for svc in postgres redis mysql mongo; do
+        if echo "$running_containers" | grep -qi "$svc"; then
+            docker_status="${docker_status}${svc} ✓ "
+        else
+            # Only flag if the project likely uses this service
+            if [ -f "$PROJECT_DIR/docker-compose.yml" ] && grep -qi "$svc" "$PROJECT_DIR/docker-compose.yml" 2>/dev/null; then
+                docker_status="${docker_status}${svc} ✗ "
+            fi
+        fi
+    done
+    docker_status=$(echo "$docker_status" | sed 's/ $//')
+fi
+
+# Alembic migration status (if alembic dir exists)
+if [ -d "$PROJECT_DIR/backend/migrations" ] || [ -d "$PROJECT_DIR/migrations" ] || [ -d "$PROJECT_DIR/alembic" ]; then
+    # Find the venv
+    venv_activate=""
+    for v in "$PROJECT_DIR/backend/.venv/bin/activate" "$PROJECT_DIR/.venv/bin/activate" "$PROJECT_DIR/venv/bin/activate"; do
+        if [ -f "$v" ]; then
+            venv_activate="$v"
+            break
+        fi
+    done
+
+    if [ -n "$venv_activate" ]; then
+        alembic_dir=""
+        for d in "$PROJECT_DIR/backend" "$PROJECT_DIR"; do
+            if [ -f "$d/alembic.ini" ]; then
+                alembic_dir="$d"
+                break
+            fi
+        done
+
+        if [ -n "$alembic_dir" ]; then
+            current=$(cd "$alembic_dir" && source "$venv_activate" && safe_run 3 alembic current 2>/dev/null | head -1 | awk '{print $1}') || true
+            head_rev=$(cd "$alembic_dir" && source "$venv_activate" && safe_run 3 alembic heads 2>/dev/null | head -1 | awk '{print $1}') || true
+            if [ -n "$current" ] && [ -n "$head_rev" ]; then
+                if [ "$current" = "$head_rev" ]; then
+                    alembic_status="✓"
+                else
+                    alembic_status="⚠ pending migrations"
+                fi
+            fi
+        fi
+    fi
+fi
+
+# Railway MCP check (if configured)
+if has_cmd railway; then
+    railway_check=$(safe_run 3 railway whoami 2>&1) || true
+    if echo "$railway_check" | grep -qi "error\|not logged\|unauthenticated"; then
+        mcp_status="Railway: expired (run railway login)"
+    fi
+fi
+
+# ---------------------------------------------------------------------------
+# 4. GitHub context (if gh available — PRs, issues)
+# ---------------------------------------------------------------------------
+
+pr_summary=""
+issue_summary=""
+
+if has_cmd gh && $has_git; then
+    cd "$PROJECT_DIR"
+
+    # My open PRs
+    my_prs=$(safe_run 5 gh pr list --author @me --json number,title,reviewDecision,comments --limit 5 2>/dev/null) || true
+    if [ -n "$my_prs" ] && [ "$my_prs" != "[]" ]; then
+        pr_count=$(echo "$my_prs" | python3 -c "import json,sys; print(len(json.load(sys.stdin)))" 2>/dev/null) || true
+        if [ "${pr_count:-0}" -gt 0 ]; then
+            pr_summary="${pr_count} open PR(s)"
+            # Check for unresolved review comments
+            needs_review=$(echo "$my_prs" | python3 -c "
+import json,sys
+prs=json.load(sys.stdin)
+needs=sum(1 for p in prs if p.get('reviewDecision') in ('CHANGES_REQUESTED',None) and p.get('comments',0)>0)
+if needs: print(f', {needs} need attention')
+" 2>/dev/null) || true
+            pr_summary="${pr_summary}${needs_review}"
+        fi
+    fi
+
+    # My assigned issues
+    my_issues=$(safe_run 5 gh issue list --assignee @me --json number,title --limit 5 2>/dev/null) || true
+    if [ -n "$my_issues" ] && [ "$my_issues" != "[]" ]; then
+        issue_count=$(echo "$my_issues" | python3 -c "import json,sys; print(len(json.load(sys.stdin)))" 2>/dev/null) || true
+        if [ "${issue_count:-0}" -gt 0 ]; then
+            issue_summary="${issue_count} assigned issue(s)"
+        fi
+    fi
+
+    cd - >/dev/null 2>&1 || true
+fi
+
+# ---------------------------------------------------------------------------
+# 5. Active plans
+# ---------------------------------------------------------------------------
+
+active_plan=""
+if [ -d "$PROJECT_DIR/.claude/plans" ]; then
+    plan_files=$(find "$PROJECT_DIR/.claude/plans" -name "*.md" -newer "$PROJECT_DIR/.claude" 2>/dev/null | head -1) || true
+    if [ -n "$plan_files" ]; then
+        active_plan=$(basename "$plan_files")
+    fi
+fi
+
+# ---------------------------------------------------------------------------
+# 6. Session continuity (previous session detection)
+# ---------------------------------------------------------------------------
+
+session_hint=""
+
+# Check for existing session-state summary (written by /continue skill)
+if [ -f "$PROJECT_DIR/.claude/session-state/latest.md" ]; then
+    # Check if it's less than 7 days old
+    if [ "$(uname)" = "Darwin" ]; then
+        file_age=$(( $(date +%s) - $(stat -f%m "$PROJECT_DIR/.claude/session-state/latest.md") ))
+    else
+        file_age=$(( $(date +%s) - $(stat -c%Y "$PROJECT_DIR/.claude/session-state/latest.md") ))
+    fi
+    if [ "$file_age" -lt 604800 ]; then
+        # Extract first "What Was Done" bullet for a preview
+        preview=$(grep -m1 "^- " "$PROJECT_DIR/.claude/session-state/latest.md" 2>/dev/null | head -c 80) || true
+        if [ -n "$preview" ]; then
+            session_hint="Previous session: ${preview}... — /continue for details"
+        else
+            session_hint="Previous session summary available — /continue for details"
+        fi
+    fi
+fi
+
+# If no session-state, check for recent transcript JSONL
+if [ -z "$session_hint" ]; then
+    TRANSCRIPT_DIR_NAME=$(echo "$PROJECT_DIR" | sed 's|/|-|g')
+    TRANSCRIPT_DIR="$HOME/.claude/projects/${TRANSCRIPT_DIR_NAME}"
+    if [ -d "$TRANSCRIPT_DIR" ]; then
+        # Find the 2nd newest JSONL (newest is current session)
+        prev_transcript=$(ls -t "$TRANSCRIPT_DIR"/*.jsonl 2>/dev/null | sed -n '2p') || true
+        if [ -n "$prev_transcript" ]; then
+            # Check if it's less than 3 days old
+            if [ "$(uname)" = "Darwin" ]; then
+                t_age=$(( $(date +%s) - $(stat -f%m "$prev_transcript") ))
+            else
+                t_age=$(( $(date +%s) - $(stat -c%Y "$prev_transcript") ))
+            fi
+            if [ "$t_age" -lt 259200 ]; then
+                session_hint="Recent session detected — /continue to pick up where you left off"
+            fi
+        fi
+    fi
+fi
+
+# ---------------------------------------------------------------------------
+# 7. Output — compact briefing (max 6 lines)
+# ---------------------------------------------------------------------------
+
+# Line 1: Project + branch
+line1="📋 ${project_name}"
+if $is_greenfield; then
+    line1="${line1} — new project (no code detected)"
+elif $has_git && [ -n "$branch" ]; then
+    line1="${line1} — ${branch}"
+    [ -n "$ahead_behind" ] && line1="${line1} (${ahead_behind})"
+fi
+echo "$line1"
+
+# Line 2: Red flags (only if there are problems)
+flags=()
+[ -n "$docker_status" ] && echo "$docker_status" | grep -q "✗" && flags+=("Docker: ${docker_status}")
+[ "$alembic_status" = "⚠ pending migrations" ] && flags+=("Alembic: ${alembic_status}")
+[ -n "$mcp_status" ] && flags+=("⚠ ${mcp_status}")
+
+if [ ${#flags[@]} -gt 0 ]; then
+    echo "   $(IFS=' · '; echo "${flags[*]}")"
+fi
+
+# Line 3: Context (uncommitted, plan, last commit)
+context_parts=()
+[ "${uncommitted:-0}" -gt 0 ] && context_parts+=("${uncommitted} uncommitted files")
+[ -n "$active_plan" ] && context_parts+=("Plan: ${active_plan}")
+[ "${stash_count:-0}" -gt 0 ] && context_parts+=("${stash_count} stash(es)")
+
+if [ ${#context_parts[@]} -gt 0 ]; then
+    echo "   $(IFS=' · '; echo "${context_parts[*]}")"
+fi
+
+# Line 4: GitHub context (PRs, issues)
+gh_parts=()
+[ -n "$pr_summary" ] && gh_parts+=("$pr_summary")
+[ -n "$issue_summary" ] && gh_parts+=("$issue_summary")
+
+if [ ${#gh_parts[@]} -gt 0 ]; then
+    echo "   $(IFS=' · '; echo "${gh_parts[*]}")"
+fi
+
+# Line 5: Toolkit status (show what's active)
+toolkit_parts=()
+if [ -f "$PROJECT_DIR/.claude/hooks/triage-router.sh" ] || [ -L "$PROJECT_DIR/.claude/hooks/triage-router.sh" ]; then
+    toolkit_parts+=("Triage router: active")
+fi
+if [ -f "$PROJECT_DIR/.claude/hooks/pre-bash-guard.sh" ] || [ -L "$PROJECT_DIR/.claude/hooks/pre-bash-guard.sh" ]; then
+    toolkit_parts+=("Guard rails: on")
+fi
+if [ ${#toolkit_parts[@]} -gt 0 ]; then
+    echo "   $(IFS=' · '; echo "${toolkit_parts[*]}")"
+fi
+
+# Session continuity hint (if not greenfield)
+if ! $is_greenfield && [ -n "$session_hint" ]; then
+    echo "   $session_hint"
+fi
+
+# Greenfield hint
+if $is_greenfield; then
+    echo "   Tip: describe what you're building, or type /onboard for guided setup"
+fi
+
+# Calibration hint — show for brownfield projects that haven't been calibrated
+if ! $is_greenfield; then
+    if [ ! -f "$PROJECT_DIR/.claude/project-profile.md" ]; then
+        # Only show if calibrate skill is installed
+        if [ -d "$PROJECT_DIR/.claude/skills/calibrate" ] || [ -L "$PROJECT_DIR/.claude/skills/calibrate" ]; then
+            echo "   Tip: run /calibrate to deep-learn your project and configure MCP servers + agents"
+        fi
+    else
+        # Check knowledge base change detection for drift
+        CHANGE_DETECT="$PROJECT_DIR/.claude/knowledge/meta/change-detection.md"
+        if [ -f "$CHANGE_DETECT" ]; then
+            drift_found=false
+            for keyfile in package.json requirements.txt pyproject.toml docker-compose.yml Podfile Package.swift build.gradle pubspec.yaml; do
+                if [ -f "$PROJECT_DIR/$keyfile" ]; then
+                    current_hash=$(shasum -a 256 "$PROJECT_DIR/$keyfile" 2>/dev/null | cut -c1-8)
+                    stored_hash=$(grep "$keyfile" "$CHANGE_DETECT" 2>/dev/null | awk '{print $4}' | head -1)
+                    if [ -n "$stored_hash" ] && [ -n "$current_hash" ] && [ "$stored_hash" != "$current_hash" ]; then
+                        drift_found=true
+                        break
+                    fi
+                fi
+            done
+            if $drift_found; then
+                echo "   ⚠ Project files changed since last calibration — run /calibrate rescan"
+            fi
+        fi
+    fi
+fi
+
+# ---------------------------------------------------------------------------
+# 8. Write project state cache (other hooks read this instead of re-computing)
+# ---------------------------------------------------------------------------
+
+CACHE_FILE="$PROJECT_DIR/.claude/.project-state-cache.json"
+_cache_json=$(cat <<CACHE_EOF
+{
+  "timestamp": $(date +%s),
+  "project_name": "$project_name",
+  "is_greenfield": $is_greenfield,
+  "has_git": $has_git,
+  "branch": "${branch:-}",
+  "uncommitted": ${uncommitted:-0},
+  "ahead_behind": "${ahead_behind:-}",
+  "stash_count": ${stash_count:-0},
+  "docker_status": "${docker_status:-}",
+  "alembic_status": "${alembic_status:-}",
+  "mcp_status": "${mcp_status:-}",
+  "active_plan": "${active_plan:-}"
+}
+CACHE_EOF
+)
+echo "$_cache_json" > "$CACHE_FILE" 2>/dev/null || true

package/dist/plugins/prime/hooks/session-end.sh

@@ -0,0 +1,107 @@
+#!/bin/bash
+# SessionEnd hook — saves session state to memory for next conversation
+# Receives JSON on stdin with: session_id, transcript_path, cwd, reason
+
+set -euo pipefail
+
+# Parse stdin
+INPUT=$(cat)
+TRANSCRIPT_PATH=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('transcript_path',''))" 2>/dev/null || echo "")
+SESSION_ID=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('session_id',''))" 2>/dev/null || echo "unknown")
+CWD=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('cwd',''))" 2>/dev/null || echo "")
+
+# Skip if no working directory
+if [ -z "$CWD" ]; then
+    exit 0
+fi
+
+# Derive project memory directory from CWD
+# Claude Code stores project memory at ~/.claude/projects/-<path-with-dashes>/memory/
+PROJECT_KEY=$(echo "$CWD" | sed 's|^/||' | sed 's|/|-|g')
+MEMORY_DIR="$HOME/.claude/projects/-${PROJECT_KEY}/memory"
+SESSION_STATE="$MEMORY_DIR/last-session.md"
+TASK_DIR="$HOME/.claude/tasks"
+
+mkdir -p "$MEMORY_DIR"
+
+# Get current git state
+BRANCH=$(cd "$CWD" 2>/dev/null && git branch --show-current 2>/dev/null || echo "unknown")
+UNCOMMITTED=$(cd "$CWD" 2>/dev/null && git diff --name-only 2>/dev/null | head -10 || echo "none")
+LAST_COMMIT=$(cd "$CWD" 2>/dev/null && git log --oneline -1 2>/dev/null || echo "unknown")
+
+# Get task list state (if any active team)
+TASKS=""
+for team_dir in "$TASK_DIR"/*/; do
+    if [ -d "$team_dir" ]; then
+        TEAM_NAME=$(basename "$team_dir")
+        for task_file in "$team_dir"*.json; do
+            if [ -f "$task_file" ]; then
+                TASK_INFO=$(python3 -c "
+import json, sys
+try:
+    with open('$task_file') as f:
+        t = json.load(f)
+    status = t.get('status', 'unknown')
+    subject = t.get('subject', 'unknown')
+    if status != 'completed':
+        print(f'- [{status}] {subject}')
+except: pass
+" 2>/dev/null)
+                if [ -n "$TASK_INFO" ]; then
+                    TASKS="$TASKS\n$TASK_INFO"
+                fi
+            fi
+        done
+    fi
+done
+
+# Extract last ~20 assistant messages from transcript for summary context
+RECENT_CONTEXT=""
+if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
+    RECENT_CONTEXT=$(tail -50 "$TRANSCRIPT_PATH" 2>/dev/null | python3 -c "
+import sys, json
+messages = []
+for line in sys.stdin:
+    line = line.strip()
+    if not line:
+        continue
+    try:
+        msg = json.loads(line)
+        role = msg.get('role', '')
+        if role == 'assistant':
+            content = msg.get('content', '')
+            if isinstance(content, list):
+                text_parts = [p.get('text','') for p in content if isinstance(p, dict) and p.get('type') == 'text']
+                content = ' '.join(text_parts)
+            if isinstance(content, str) and len(content) > 20:
+                # Take first 200 chars of each message
+                messages.append(content[:200])
+    except: pass
+# Show last 5 messages
+for m in messages[-5:]:
+    print(f'- {m}')
+" 2>/dev/null || echo "Could not parse transcript")
+fi
+
+# Write session state
+cat > "$SESSION_STATE" << ENDOFSTATE
+# Last Session State
+**Updated**: $(date -u +"%Y-%m-%d %H:%M UTC")
+**Session**: $SESSION_ID
+**Branch**: $BRANCH
+**Last Commit**: $LAST_COMMIT
+
+## Uncommitted Changes
+$UNCOMMITTED
+
+## Pending Tasks
+$(echo -e "$TASKS" | grep -v '^$' || echo "None")
+
+## Recent Activity (last 5 messages)
+$RECENT_CONTEXT
+
+## Next Steps
+Check /continue for full context restoration.
+ENDOFSTATE
+
+exit 0

package/dist/plugins/prime/hooks/session-summary.sh

@@ -0,0 +1,97 @@
+#!/bin/bash
+# Hook: Stop
+# Prints engagement session summary.
+# Shows files modified in the last 2 hours under clients/ directory,
+# grouped by client, with current phase from engagement.json if available.
+
+set -uo pipefail
+
+# Find the project root — look for clients/ directory
+PROJECT_ROOT=""
+if [ -d "clients" ]; then
+  PROJECT_ROOT="."
+elif [ -d "../clients" ]; then
+  PROJECT_ROOT=".."
+else
+  # Try to find it relative to known paths
+  for candidate in /Users/pganapathy80/pitch/consulting-toolkit /Users/pganapathy80/pitch; do
+    if [ -d "${candidate}/clients" ]; then
+      PROJECT_ROOT="$candidate"
+      break
+    fi
+  done
+fi
+
+# If no clients directory found, exit silently
+if [ -z "$PROJECT_ROOT" ]; then
+  exit 0
+fi
+
+CLIENTS_DIR="${PROJECT_ROOT}/clients"
+
+# Find markdown files modified in last 2 hours under clients/
+MODIFIED_FILES=$(find "$CLIENTS_DIR" -name '*.md' -mmin -120 -type f 2>/dev/null | sort)
+
+# Also check for JSON files (engagement.json, etc.)
+MODIFIED_JSON=$(find "$CLIENTS_DIR" -name '*.json' -mmin -120 -type f 2>/dev/null | sort)
+
+ALL_MODIFIED=$(printf '%s\n%s' "$MODIFIED_FILES" "$MODIFIED_JSON" | grep -v '^$' | sort -u)
+
+# If nothing was modified, exit silently
+if [ -z "$ALL_MODIFIED" ]; then
+  exit 0
+fi
+
+# Collect unique client slugs
+CLIENT_SLUGS=$(echo "$ALL_MODIFIED" | sed -n "s|${CLIENTS_DIR}/\([^/]*\)/.*|\1|p" | sort -u)
+
+# If no client slugs found, exit silently
+if [ -z "$CLIENT_SLUGS" ]; then
+  exit 0
+fi
+
+# Count totals
+TOTAL_FILES=$(echo "$ALL_MODIFIED" | wc -l | tr -d ' ')
+TOTAL_CLIENTS=$(echo "$CLIENT_SLUGS" | wc -l | tr -d ' ')
+
+# Print summary box
+echo ""
+echo "┌──────────────────────────────────────────────────┐"
+echo "│            SESSION SUMMARY                       │"
+echo "├──────────────────────────────────────────────────┤"
+printf "│  Files modified:  %-30s│\n" "$TOTAL_FILES"
+printf "│  Clients touched: %-30s│\n" "$TOTAL_CLIENTS"
+echo "├──────────────────────────────────────────────────┤"
+
+while IFS= read -r SLUG; do
+  [ -z "$SLUG" ] && continue
+
+  # Get current phase from engagement.json if it exists
+  PHASE=""
+  ENGAGEMENT_FILE="${CLIENTS_DIR}/${SLUG}/engagement.json"
+  if [ -f "$ENGAGEMENT_FILE" ]; then
+    PHASE=$(grep -o '"currentPhase"[[:space:]]*:[[:space:]]*"[^"]*"' "$ENGAGEMENT_FILE" 2>/dev/null | sed 's/.*"currentPhase"[[:space:]]*:[[:space:]]*"//;s/"$//' | head -1)
+  fi
+
+  if [ -n "$PHASE" ]; then
+    printf "│  CLIENT: %-20s Phase: %-10s│\n" "$SLUG" "$PHASE"
+  else
+    printf "│  CLIENT: %-40s│\n" "$SLUG"
+  fi
+
+  # List files for this client
+  CLIENT_FILES=$(echo "$ALL_MODIFIED" | grep "${CLIENTS_DIR}/${SLUG}/")
+  while IFS= read -r FPATH; do
+    [ -z "$FPATH" ] && continue
+    # Show path relative to clients/<slug>/
+    REL_PATH=$(echo "$FPATH" | sed "s|${CLIENTS_DIR}/${SLUG}/||")
+    printf "│    - %-44s│\n" "$REL_PATH"
+  done <<< "$CLIENT_FILES"
+
+  echo "│                                                  │"
+done <<< "$CLIENT_SLUGS"
+
+echo "└──────────────────────────────────────────────────┘"
+echo ""
+
+exit 0