@arthai/agents 1.0.0

package/hook-defs.json

@@ -0,0 +1,104 @@
+{
+  "sync-agents": {
+    "script": "sync-agents.sh",
+    "entries": [
+      {
+        "event": "SessionStart",
+        "matcher": "",
+        "timeout": 30,
+        "command_override": "bash -c 'export HOME=$(eval echo ~$(id -un)); [ -x \"$HOME/.claude-agents/hooks/sync-agents.sh\" ] && \"$HOME/.claude-agents/hooks/sync-agents.sh\" || true'"
+      }
+    ]
+  },
+  "triage-router": {
+    "script": "triage-router.sh",
+    "entries": [
+      {"event": "UserPromptSubmit", "matcher": "", "timeout": 5}
+    ]
+  },
+  "session-bootstrap": {
+    "script": "session-bootstrap.sh",
+    "entries": [
+      {"event": "SessionStart", "matcher": "", "timeout": 15}
+    ]
+  },
+  "pre-bash-guard": {
+    "script": "pre-bash-guard.sh",
+    "entries": [
+      {"event": "PreToolUse", "matcher": "Bash", "timeout": 5}
+    ]
+  },
+  "pre-task-context": {
+    "script": "pre-task-context.sh",
+    "entries": [
+      {"event": "PreToolUse", "matcher": "Task", "timeout": 5}
+    ]
+  },
+  "pre-edit-guard": {
+    "script": "pre-edit-guard.sh",
+    "entries": [
+      {"event": "PreToolUse", "matcher": "Edit", "timeout": 5},
+      {"event": "PreToolUse", "matcher": "Write", "timeout": 5}
+    ]
+  },
+  "post-test-summary": {
+    "script": "post-test-summary.sh",
+    "entries": [
+      {"event": "PostToolUse", "matcher": "Bash", "timeout": 5}
+    ]
+  },
+  "post-edit-lint": {
+    "script": "post-edit-lint.sh",
+    "entries": [
+      {"event": "PostToolUse", "matcher": "Edit", "timeout": 10}
+    ]
+  },
+  "post-deploy-health": {
+    "script": "post-deploy-health.sh",
+    "entries": [
+      {"event": "PostToolUse", "matcher": "Bash", "timeout": 15}
+    ]
+  },
+  "post-diff-test-compare": {
+    "script": "post-diff-test-compare.sh",
+    "entries": [
+      {"event": "PostToolUse", "matcher": "Bash", "timeout": 10}
+    ]
+  },
+  "post-git-state": {
+    "script": "post-git-state.sh",
+    "entries": [
+      {"event": "PostToolUse", "matcher": "Bash", "timeout": 5}
+    ]
+  },
+  "post-merge-cleanup": {
+    "script": "post-merge-cleanup.sh",
+    "entries": [
+      {"event": "PostToolUse", "matcher": "Bash", "timeout": 5}
+    ]
+  },
+  "session-end": {
+    "script": "session-end.sh",
+    "entries": [
+      {"event": "SessionEnd", "matcher": "", "timeout": 15}
+    ]
+  },
+  "session-summary": {
+    "script": "session-summary.sh",
+    "entries": [
+      {"event": "SessionEnd", "matcher": "", "timeout": 15}
+    ]
+  },
+  "ensure-client-dir": {
+    "script": "ensure-client-dir.sh",
+    "entries": [
+      {"event": "SessionStart", "matcher": "", "timeout": 5}
+    ]
+  },
+  "check-deliverable": {
+    "script": "check-deliverable.sh",
+    "entries": [
+      {"event": "PostToolUse", "matcher": "Bash", "timeout": 5}
+    ]
+  }
+}

package/hooks/check-deliverable.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+# Hook: PostToolUse (Write)
+# Validates deliverable format after writing.
+# Prints warnings for missing version headers, dates, or executive summaries.
+# Always exits 0 — warnings only, never blocks.
+
+set -uo pipefail
+
+# Extract file_path from CLAUDE_TOOL_INPUT (JSON)
+FILE_PATH=""
+if [ -n "${CLAUDE_TOOL_INPUT:-}" ]; then
+  FILE_PATH=$(echo "$CLAUDE_TOOL_INPUT" | grep -o '"file_path"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"file_path"[[:space:]]*:[[:space:]]*"//;s/"$//')
+fi
+
+# Fall back to first argument
+if [ -z "$FILE_PATH" ] && [ $# -gt 0 ]; then
+  FILE_PATH="$1"
+fi
+
+# Nothing to check if we couldn't determine the file path
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+# Only check deliverables and proposals
+if ! echo "$FILE_PATH" | grep -qE 'clients/[^/]+/(deliverables|proposals)/'; then
+  exit 0
+fi
+
+# Resolve the actual file to check
+ACTUAL_FILE="$FILE_PATH"
+if [ ! -f "$ACTUAL_FILE" ]; then
+  # File might not exist yet or path might be relative
+  exit 0
+fi
+
+FILENAME=$(basename "$FILE_PATH")
+WARNINGS=0
+
+# Check for version header (vX.Y pattern) in first 5 lines
+if ! head -n 5 "$ACTUAL_FILE" | grep -qiE 'v[0-9]+\.[0-9]+'; then
+  echo "⚠️  Missing version header (vX.Y) in ${FILENAME}"
+  WARNINGS=$((WARNINGS + 1))
+fi
+
+# Check for date (YYYY-MM-DD pattern) in first 10 lines
+if ! head -n 10 "$ACTUAL_FILE" | grep -qE '[0-9]{4}-[0-9]{2}-[0-9]{2}'; then
+  echo "⚠️  Missing date (YYYY-MM-DD) in ${FILENAME}"
+  WARNINGS=$((WARNINGS + 1))
+fi
+
+# Check for executive summary if file has more than 50 lines
+LINE_COUNT=$(wc -l < "$ACTUAL_FILE" | tr -d ' ')
+if [ "$LINE_COUNT" -gt 50 ]; then
+  if ! grep -qiE '(executive summary|## summary)' "$ACTUAL_FILE"; then
+    echo "⚠️  Missing Executive Summary section in ${FILENAME} (${LINE_COUNT} lines)"
+    WARNINGS=$((WARNINGS + 1))
+  fi
+fi
+
+if [ "$WARNINGS" -gt 0 ]; then
+  echo "   ${WARNINGS} format warning(s) for ${FILENAME}"
+fi
+
+exit 0

package/hooks/ensure-client-dir.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+# Hook: PreToolUse (Write)
+# Blocks writes to client deliverable directories without profile.md
+# Ensures /client-discovery has been run before any deliverables are created.
+
+set -euo pipefail
+
+# Extract file_path from CLAUDE_TOOL_INPUT (JSON)
+FILE_PATH=""
+if [ -n "${CLAUDE_TOOL_INPUT:-}" ]; then
+  FILE_PATH=$(echo "$CLAUDE_TOOL_INPUT" | grep -o '"file_path"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"file_path"[[:space:]]*:[[:space:]]*"//;s/"$//')
+fi
+
+# Fall back to first argument if CLAUDE_TOOL_INPUT didn't yield a path
+if [ -z "$FILE_PATH" ] && [ $# -gt 0 ]; then
+  FILE_PATH="$1"
+fi
+
+# Nothing to check if we couldn't determine the file path
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+# Check if the path matches a client deliverable directory
+# Patterns: clients/<slug>/deliverables/*, clients/<slug>/assessment/*,
+#           clients/<slug>/proposals/*, clients/<slug>/architecture/*
+if echo "$FILE_PATH" | grep -qE 'clients/[^/]+/(deliverables|assessment|proposals|architecture)/'; then
+  # Extract the client slug (second path component after clients/)
+  CLIENT_SLUG=$(echo "$FILE_PATH" | sed -n 's|.*clients/\([^/]*\)/.*|\1|p')
+
+  if [ -z "$CLIENT_SLUG" ]; then
+    exit 0
+  fi
+
+  # Determine the project root by looking for clients/ relative to the file path
+  # Try common locations: working directory first, then walk up from the file path
+  PROFILE_FOUND=false
+
+  # Check relative to current working directory
+  if [ -f "clients/${CLIENT_SLUG}/profile.md" ]; then
+    PROFILE_FOUND=true
+  fi
+
+  # Check if FILE_PATH is absolute and derive project root
+  if [ "$PROFILE_FOUND" = false ] && echo "$FILE_PATH" | grep -q '^/'; then
+    PROJECT_ROOT=$(echo "$FILE_PATH" | sed "s|/clients/${CLIENT_SLUG}/.*||")
+    if [ -f "${PROJECT_ROOT}/clients/${CLIENT_SLUG}/profile.md" ]; then
+      PROFILE_FOUND=true
+    fi
+  fi
+
+  if [ "$PROFILE_FOUND" = false ]; then
+    echo "❌ Cannot write to ${FILE_PATH} — client profile not found."
+    echo "   Run /client-discovery ${CLIENT_SLUG} first to create the client profile."
+    exit 1
+  fi
+fi
+
+exit 0

package/hooks/hooks.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-start.sh",
+            "async": false
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/post-deploy-health.sh

@@ -0,0 +1,83 @@
+#!/bin/bash
+# PostToolUse hook (Bash): Auto-check health after deploy commands.
+# Detects deploy-related commands and hits health endpoints from CLAUDE.md.
+#
+# stdout is injected as context.
+
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+
+# Extract the command
+COMMAND="${CLAUDE_TOOL_INPUT_COMMAND:-}"
+if [ -z "$COMMAND" ] && [ -n "${CLAUDE_TOOL_INPUT:-}" ]; then
+    COMMAND=$(echo "$CLAUDE_TOOL_INPUT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('command',''))" 2>/dev/null) || true
+fi
+
+[ -z "$COMMAND" ] && exit 0
+
+# ---------------------------------------------------------------------------
+# Detect deploy-related commands
+# ---------------------------------------------------------------------------
+
+is_deploy=false
+
+# Railway deploys
+echo "$COMMAND" | grep -qE '\brailway\s+(deploy|redeploy)\b' && is_deploy=true
+
+# Vercel deploys
+echo "$COMMAND" | grep -qE '\bvercel\s+(deploy|--prod)\b' && is_deploy=true
+
+# Fly.io deploys
+echo "$COMMAND" | grep -qE '\bflyctl\s+deploy\b' && is_deploy=true
+
+# kubectl apply/rollout
+echo "$COMMAND" | grep -qE '\bkubectl\s+(apply|rollout)\b' && is_deploy=true
+
+# Git push to main (triggers auto-deploy on Railway/Vercel/etc.)
+echo "$COMMAND" | grep -qE 'git\s+push.*\b(main|master)\b' && is_deploy=true
+
+$is_deploy || exit 0
+
+# ---------------------------------------------------------------------------
+# Find health endpoints from CLAUDE.md
+# ---------------------------------------------------------------------------
+
+[ ! -f "$PROJECT_DIR/CLAUDE.md" ] && exit 0
+
+# Extract URLs that look like health endpoints
+health_urls=$(grep -oE 'https?://[^ ]+/health[^ ]*' "$PROJECT_DIR/CLAUDE.md" 2>/dev/null | head -3) || true
+
+if [ -z "$health_urls" ]; then
+    # Try to find any domain + /health pattern
+    health_urls=$(grep -oE 'https?://[a-zA-Z0-9._-]+\.(app|dev|io|com)[^ ]*/health' "$PROJECT_DIR/CLAUDE.md" 2>/dev/null | head -3) || true
+fi
+
+[ -z "$health_urls" ] && exit 0
+
+# ---------------------------------------------------------------------------
+# Wait briefly then check health
+# ---------------------------------------------------------------------------
+
+# Read deploy wait time from CLAUDE.md, default 30s for cloud deploys
+DEPLOY_WAIT=30
+if [ -f "$PROJECT_DIR/CLAUDE.md" ]; then
+    custom_wait=$(grep -oE 'deploy_health_wait:\s*([0-9]+)' "$PROJECT_DIR/CLAUDE.md" 2>/dev/null | head -1 | grep -oE '[0-9]+') || true
+    [ -n "$custom_wait" ] && DEPLOY_WAIT="$custom_wait"
+fi
+
+echo "DEPLOY DETECTED — checking health endpoints (waiting ${DEPLOY_WAIT}s for deploy to propagate)..."
+sleep "$DEPLOY_WAIT"
+
+while IFS= read -r url; do
+    [ -z "$url" ] && continue
+    status=$(timeout 10 curl -sf -o /dev/null -w "%{http_code}" "$url" 2>/dev/null) || status="timeout"
+
+    if [ "$status" = "200" ]; then
+        echo "  ✓ ${url} → ${status}"
+    else
+        echo "  ✗ ${url} → ${status}"
+    fi
+done <<< "$health_urls"
+
+exit 0

package/hooks/post-diff-test-compare.sh

@@ -0,0 +1,125 @@
+#!/bin/bash
+# PostToolUse hook (Bash): Auto-compare test results against /fix baseline.
+# When a /fix is in progress (baseline files exist), any test run is automatically
+# compared against the pre-fix baseline to detect regressions.
+#
+# Detects: pytest, jest, vitest, go test, cargo test, npm test
+# Compares: pass/fail counts + specific test name changes
+#
+# stdout is injected as context — flags PASS→FAIL regressions immediately.
+
+set -euo pipefail
+
+COMMAND="${CLAUDE_TOOL_INPUT_COMMAND:-}"
+if [ -z "$COMMAND" ] && [ -n "${CLAUDE_TOOL_INPUT:-}" ]; then
+    COMMAND=$(echo "$CLAUDE_TOOL_INPUT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('command',''))" 2>/dev/null) || true
+fi
+
+OUTPUT="${CLAUDE_TOOL_OUTPUT:-}"
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+
+[ -z "$COMMAND" ] && exit 0
+[ -z "$OUTPUT" ] && exit 0
+
+# ---------------------------------------------------------------------------
+# Only run if a /fix baseline exists
+# ---------------------------------------------------------------------------
+
+BASELINE_BACKEND="$PROJECT_DIR/.claude/.fix-baseline-backend.txt"
+BASELINE_FRONTEND="$PROJECT_DIR/.claude/.fix-baseline-frontend.txt"
+
+# No baselines = no /fix in progress = nothing to compare
+[ -f "$BASELINE_BACKEND" ] || [ -f "$BASELINE_FRONTEND" ] || exit 0
+
+# ---------------------------------------------------------------------------
+# Detect test runner
+# ---------------------------------------------------------------------------
+
+IS_TEST=false
+BASELINE_FILE=""
+
+# Python (pytest)
+if echo "$COMMAND" | grep -qE '\bpytest\b|python\s+-m\s+pytest'; then
+    IS_TEST=true
+    BASELINE_FILE="$BASELINE_BACKEND"
+fi
+
+# Node (jest, vitest, npm test)
+if echo "$COMMAND" | grep -qE '\bjest\b|\bvitest\b|npm\s+test|npx\s+(jest|vitest)'; then
+    IS_TEST=true
+    BASELINE_FILE="$BASELINE_FRONTEND"
+fi
+
+# Go
+if echo "$COMMAND" | grep -qE '\bgo\s+test\b'; then
+    IS_TEST=true
+    BASELINE_FILE="$BASELINE_BACKEND"
+fi
+
+# Rust
+if echo "$COMMAND" | grep -qE '\bcargo\s+test\b'; then
+    IS_TEST=true
+    BASELINE_FILE="$BASELINE_BACKEND"
+fi
+
+$IS_TEST || exit 0
+[ -f "$BASELINE_FILE" ] || exit 0
+
+# ---------------------------------------------------------------------------
+# Extract pass/fail from current run
+# ---------------------------------------------------------------------------
+
+extract_counts() {
+    local text="$1"
+    local passed=0 failed=0
+
+    # pytest: "X passed, Y failed"
+    passed=$(echo "$text" | grep -oE '[0-9]+ passed' | grep -oE '[0-9]+' | head -1) || true
+    failed=$(echo "$text" | grep -oE '[0-9]+ failed' | grep -oE '[0-9]+' | head -1) || true
+
+    # jest/vitest: "Tests: X passed, Y failed"
+    if [ -z "$passed" ]; then
+        passed=$(echo "$text" | grep -oE 'Tests:.*[0-9]+ passed' | grep -oE '[0-9]+ passed' | grep -oE '[0-9]+') || true
+        failed=$(echo "$text" | grep -oE 'Tests:.*[0-9]+ failed' | grep -oE '[0-9]+ failed' | grep -oE '[0-9]+') || true
+    fi
+
+    # go test: "ok" lines = passed, "FAIL" lines = failed
+    if [ -z "$passed" ]; then
+        passed=$(echo "$text" | grep -c "^ok" 2>/dev/null) || true
+        failed=$(echo "$text" | grep -c "^FAIL" 2>/dev/null) || true
+    fi
+
+    echo "${passed:-0} ${failed:-0}"
+}
+
+# Extract from baseline
+read BASELINE_PASSED BASELINE_FAILED <<< "$(extract_counts "$(cat "$BASELINE_FILE")")"
+
+# Extract from current run
+read CURRENT_PASSED CURRENT_FAILED <<< "$(extract_counts "$OUTPUT")"
+
+# ---------------------------------------------------------------------------
+# Compare and report
+# ---------------------------------------------------------------------------
+
+# Calculate changes
+NEW_FAILURES=$((${CURRENT_FAILED:-0} - ${BASELINE_FAILED:-0}))
+NEW_PASSES=$((${CURRENT_PASSED:-0} - ${BASELINE_PASSED:-0}))
+
+if [ "${NEW_FAILURES:-0}" -gt 0 ]; then
+    echo "⚠️ DIFFERENTIAL TEST WARNING: ${NEW_FAILURES} new failure(s) detected vs pre-fix baseline"
+    echo "  Baseline: ${BASELINE_PASSED} passed, ${BASELINE_FAILED} failed"
+    echo "  Current:  ${CURRENT_PASSED} passed, ${CURRENT_FAILED} failed"
+    echo "  → ${NEW_FAILURES} test(s) went from PASS → FAIL — fix may have side effects"
+    echo "  Check the behavior contract: are these expected changes or regressions?"
+elif [ "${NEW_PASSES:-0}" -gt 0 ] && [ "${NEW_FAILURES:-0}" -le 0 ]; then
+    echo "✓ Differential test: ${NEW_PASSES} new pass(es), 0 new failures (fix looks clean)"
+    echo "  Baseline: ${BASELINE_PASSED} passed, ${BASELINE_FAILED} failed"
+    echo "  Current:  ${CURRENT_PASSED} passed, ${CURRENT_FAILED} failed"
+elif [ "${CURRENT_PASSED:-0}" -eq "${BASELINE_PASSED:-0}" ] && [ "${CURRENT_FAILED:-0}" -eq "${BASELINE_FAILED:-0}" ]; then
+    echo "ℹ️ Differential test: no change from baseline (${CURRENT_PASSED} passed, ${CURRENT_FAILED} failed)"
+    echo "  If this is after applying the fix, the bug-related tests should have changed."
+    echo "  Check: did the fix actually change the test outcomes?"
+fi
+
+exit 0

package/hooks/post-edit-lint.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+# PostToolUse hook (Edit): Run linter on edited file and inject results.
+# Catches lint errors at the point of introduction.
+#
+# stdout is injected as context.
+# Only runs for known file types. Skips if linter not available.
+
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+
+# Extract file path
+FILE_PATH="${CLAUDE_TOOL_INPUT_FILE_PATH:-}"
+if [ -z "$FILE_PATH" ] && [ -n "${CLAUDE_TOOL_INPUT:-}" ]; then
+    FILE_PATH=$(echo "$CLAUDE_TOOL_INPUT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('file_path',''))" 2>/dev/null) || true
+fi
+
+[ -z "$FILE_PATH" ] && exit 0
+[ ! -f "$FILE_PATH" ] && exit 0
+
+# ---------------------------------------------------------------------------
+# Python files — ruff check
+# ---------------------------------------------------------------------------
+if echo "$FILE_PATH" | grep -qE '\.py$'; then
+    # Find ruff — check project venv first, then global
+    RUFF=""
+    for candidate in \
+        "$PROJECT_DIR/backend/.venv/bin/ruff" \
+        "$PROJECT_DIR/.venv/bin/ruff" \
+        "$PROJECT_DIR/venv/bin/ruff"; do
+        if [ -x "$candidate" ]; then
+            RUFF="$candidate"
+            break
+        fi
+    done
+    [ -z "$RUFF" ] && command -v ruff &>/dev/null && RUFF="ruff"
+    [ -z "$RUFF" ] && exit 0
+
+    errors=$($RUFF check "$FILE_PATH" --no-fix 2>&1) || true
+    error_count=$(echo "$errors" | grep -cE '^\S+:\d+:\d+:' 2>/dev/null) || true
+
+    if [ "${error_count:-0}" -gt 0 ]; then
+        echo "LINT (ruff): ${error_count} issue(s) in $(basename "$FILE_PATH")"
+        echo "$errors" | grep -E '^\S+:\d+:\d+:' | head -5
+    fi
+    exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# TypeScript/JavaScript — eslint (only if fast, single file)
+# ---------------------------------------------------------------------------
+if echo "$FILE_PATH" | grep -qE '\.(ts|tsx|js|jsx)$'; then
+    # Only run if eslint config exists nearby
+    eslint_config=""
+    for dir in "$(dirname "$FILE_PATH")" "$PROJECT_DIR" "$PROJECT_DIR/frontend"; do
+        for cfg in ".eslintrc" ".eslintrc.js" ".eslintrc.json" ".eslintrc.yml" "eslint.config.js" "eslint.config.mjs"; do
+            if [ -f "$dir/$cfg" ]; then
+                eslint_config="$dir/$cfg"
+                break 2
+            fi
+        done
+    done
+
+    # Also check package.json for eslintConfig
+    if [ -z "$eslint_config" ]; then
+        for dir in "$(dirname "$FILE_PATH")" "$PROJECT_DIR" "$PROJECT_DIR/frontend"; do
+            if [ -f "$dir/package.json" ] && grep -q '"eslintConfig"' "$dir/package.json" 2>/dev/null; then
+                eslint_config="$dir/package.json"
+                break
+            fi
+        done
+    fi
+
+    [ -z "$eslint_config" ] && exit 0
+
+    # Find npx
+    NPX=""
+    command -v npx &>/dev/null && NPX="npx"
+    [ -z "$NPX" ] && exit 0
+
+    # Run eslint on single file (with timeout to keep it fast)
+    errors=$(timeout 10 $NPX eslint "$FILE_PATH" --no-warn-ignored --format compact 2>&1) || true
+    error_count=$(echo "$errors" | grep -cE 'Error|Warning' 2>/dev/null) || true
+
+    if [ "${error_count:-0}" -gt 0 ]; then
+        echo "LINT (eslint): issues in $(basename "$FILE_PATH")"
+        echo "$errors" | grep -E 'Error|Warning' | head -5
+    fi
+    exit 0
+fi
+
+exit 0

package/hooks/post-git-state.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+# PostToolUse hook (Bash): Detect git merge/push events and update autopilot state.
+# When autopilot is active and a PR is merged or code is pushed, reset the workflow
+# phase to "assess" so the autopilot loop picks up the next work item.
+#
+# Also detects branch switches and stash operations that change project state.
+
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+WORKFLOW_STATE="$PROJECT_DIR/.claude/.workflow-state.json"
+
+# Only run if autopilot state file exists
+[ -f "$WORKFLOW_STATE" ] || exit 0
+
+# Read the tool input (the command that was executed)
+TOOL_INPUT="${CLAUDE_TOOL_INPUT:-}"
+
+# Detect state-changing git operations
+if echo "$TOOL_INPUT" | grep -qE 'gh pr merge|git push|git merge (main|master)'; then
+    # Check if autopilot is active
+    MODE=$(python3 -c "import json; print(json.load(open('$WORKFLOW_STATE')).get('mode',''))" 2>/dev/null || echo "")
+
+    if [ "$MODE" = "autopilot" ] || [ "$MODE" = "paused" ]; then
+        # Update state: signal re-assessment needed
+        python3 -c "
+import json, datetime
+with open('$WORKFLOW_STATE', 'r+') as f:
+    state = json.load(f)
+    # Move completed item to session summary
+    if state.get('current_item') and state.get('phase') == 'awaiting_merge':
+        item = state['current_item']
+        completed_entry = {
+            'item': f'#{item.get(\"number\", \"?\")}',
+            'title': item.get('title', ''),
+            'pr': state.get('pr_number')
+        }
+        state.setdefault('session_summary', {}).setdefault('completed', []).append(completed_entry)
+    # Reset for next iteration
+    state['phase'] = 'assess'
+    state['current_item'] = None
+    state['pr_number'] = None
+    state['planned_scope'] = None
+    state['actual_scope'] = {'files_changed': [], 'layers_touched': []}
+    state['attempts'] = {'qa_fixes': 0, 'stuck_turns': 0}
+    state['last_state_change'] = datetime.datetime.utcnow().isoformat() + 'Z'
+    f.seek(0)
+    json.dump(state, f, indent=2)
+    f.truncate()
+" 2>/dev/null
+
+        echo "AUTOPILOT: PR merged. Re-assessing priorities for next work item."
+    fi
+fi