shipwright-cli 1.7.1 → 1.9.0

package/scripts/{cct-pipeline.sh → sw-pipeline.sh}

@@ -4,8 +4,9 @@
 # ║  Full GitHub integration · Auto-detection · Task tracking · Metrics    ║
 # ╚═══════════════════════════════════════════════════════════════════════════╝
 set -euo pipefail
+trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="1.7.1"
+VERSION="1.9.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
@@ -20,6 +21,40 @@ DIM='\033[2m'
 BOLD='\033[1m'
 RESET='\033[0m'
 
+# ─── Cross-platform compatibility ──────────────────────────────────────────
+# shellcheck source=lib/compat.sh
+[[ -f "$SCRIPT_DIR/lib/compat.sh" ]] && source "$SCRIPT_DIR/lib/compat.sh"
+
+# ─── Intelligence Engine (optional) ──────────────────────────────────────────
+# shellcheck source=sw-intelligence.sh
+if [[ -f "$SCRIPT_DIR/sw-intelligence.sh" ]]; then
+    source "$SCRIPT_DIR/sw-intelligence.sh"
+fi
+# shellcheck source=sw-pipeline-composer.sh
+if [[ -f "$SCRIPT_DIR/sw-pipeline-composer.sh" ]]; then
+    source "$SCRIPT_DIR/sw-pipeline-composer.sh"
+fi
+# shellcheck source=sw-developer-simulation.sh
+if [[ -f "$SCRIPT_DIR/sw-developer-simulation.sh" ]]; then
+    source "$SCRIPT_DIR/sw-developer-simulation.sh"
+fi
+# shellcheck source=sw-architecture-enforcer.sh
+if [[ -f "$SCRIPT_DIR/sw-architecture-enforcer.sh" ]]; then
+    source "$SCRIPT_DIR/sw-architecture-enforcer.sh"
+fi
+# shellcheck source=sw-adversarial.sh
+if [[ -f "$SCRIPT_DIR/sw-adversarial.sh" ]]; then
+    source "$SCRIPT_DIR/sw-adversarial.sh"
+fi
+
+# ─── GitHub API Modules (optional) ─────────────────────────────────────────
+# shellcheck source=sw-github-graphql.sh
+[[ -f "$SCRIPT_DIR/sw-github-graphql.sh" ]] && source "$SCRIPT_DIR/sw-github-graphql.sh"
+# shellcheck source=sw-github-checks.sh
+[[ -f "$SCRIPT_DIR/sw-github-checks.sh" ]] && source "$SCRIPT_DIR/sw-github-checks.sh"
+# shellcheck source=sw-github-deploy.sh
+[[ -f "$SCRIPT_DIR/sw-github-deploy.sh" ]] && source "$SCRIPT_DIR/sw-github-deploy.sh"
+
 # ─── Output Helpers ─────────────────────────────────────────────────────────
 info()    { echo -e "${CYAN}${BOLD}▸${RESET} $*"; }
 success() { echo -e "${GREEN}${BOLD}✓${RESET} $*"; }
@@ -29,6 +64,30 @@ error()   { echo -e "${RED}${BOLD}✗${RESET} $*" >&2; }
 now_iso() { date -u +"%Y-%m-%dT%H:%M:%SZ"; }
 now_epoch() { date +%s; }
 
+# Parse coverage percentage from test output — multi-framework patterns
+# Usage: parse_coverage_from_output <log_file>
+# Outputs coverage percentage or empty string
+parse_coverage_from_output() {
+    local log_file="$1"
+    [[ ! -f "$log_file" ]] && return
+    local cov=""
+    # Jest/Istanbul: "Statements : 85.5%"
+    cov=$(grep -oE 'Statements\s*:\s*[0-9.]+' "$log_file" 2>/dev/null | grep -oE '[0-9.]+$' || true)
+    # Istanbul table: "All files | 85.5"
+    [[ -z "$cov" ]] && cov=$(grep -oE 'All files\s*\|\s*[0-9.]+' "$log_file" 2>/dev/null | grep -oE '[0-9.]+$' || true)
+    # pytest-cov: "TOTAL    500    75    85%"
+    [[ -z "$cov" ]] && cov=$(grep -oE 'TOTAL\s+[0-9]+\s+[0-9]+\s+[0-9]+%' "$log_file" 2>/dev/null | grep -oE '[0-9]+%' | tr -d '%' | tail -1 || true)
+    # Vitest: "All files  |  85.5  |"
+    [[ -z "$cov" ]] && cov=$(grep -oE 'All files\s*\|\s*[0-9.]+\s*\|' "$log_file" 2>/dev/null | grep -oE '[0-9.]+' | head -1 || true)
+    # Go coverage: "coverage: 85.5% of statements"
+    [[ -z "$cov" ]] && cov=$(grep -oE 'coverage:\s*[0-9.]+%' "$log_file" 2>/dev/null | grep -oE '[0-9.]+' | tail -1 || true)
+    # Cargo tarpaulin: "85.50% coverage"
+    [[ -z "$cov" ]] && cov=$(grep -oE '[0-9.]+%\s*coverage' "$log_file" 2>/dev/null | grep -oE '[0-9.]+' | head -1 || true)
+    # Generic: "Coverage: 85.5%"
+    [[ -z "$cov" ]] && cov=$(grep -oiE 'coverage:?\s*[0-9.]+%' "$log_file" 2>/dev/null | grep -oE '[0-9.]+' | tail -1 || true)
+    echo "$cov"
+}
+
 format_duration() {
     local secs="$1"
     if [[ "$secs" -ge 3600 ]]; then
@@ -41,9 +100,9 @@ format_duration() {
 }
 
 # ─── Structured Event Log ──────────────────────────────────────────────────
-# Appends JSON events to ~/.claude-teams/events.jsonl for metrics/traceability
+# Appends JSON events to ~/.shipwright/events.jsonl for metrics/traceability
 
-EVENTS_DIR="${HOME}/.claude-teams"
+EVENTS_DIR="${HOME}/.shipwright"
 EVENTS_FILE="${EVENTS_DIR}/events.jsonl"
 
 emit_event() {
@@ -94,13 +153,18 @@ REVIEWERS=""
 LABELS=""
 BASE_BRANCH="main"
 NO_GITHUB=false
+NO_GITHUB_LABEL=false
+CI_MODE=false
 DRY_RUN=false
 IGNORE_BUDGET=false
+COMPLETED_STAGES=""
+MAX_ITERATIONS_OVERRIDE=""
 PR_NUMBER=""
 AUTO_WORKTREE=false
 WORKTREE_NAME=""
 CLEANUP_WORKTREE=false
 ORIGINAL_REPO_DIR=""
+_cleanup_done=""
 
 # GitHub metadata (populated during intake)
 ISSUE_LABELS=""
@@ -150,11 +214,15 @@ show_help() {
     echo -e "  ${DIM}--reviewers \"a,b\"${RESET}        Request PR reviewers (auto-detected if omitted)"
     echo -e "  ${DIM}--labels \"a,b\"${RESET}            Add labels to PR (inherited from issue if omitted)"
     echo -e "  ${DIM}--no-github${RESET}               Disable GitHub integration"
+    echo -e "  ${DIM}--no-github-label${RESET}         Don't modify issue labels"
+    echo -e "  ${DIM}--ci${RESET}                      CI mode (skip gates, non-interactive)"
     echo -e "  ${DIM}--ignore-budget${RESET}           Skip budget enforcement checks"
     echo -e "  ${DIM}--worktree [=name]${RESET}         Run in isolated git worktree (parallel-safe)"
     echo -e "  ${DIM}--dry-run${RESET}                 Show what would happen without executing"
     echo -e "  ${DIM}--slack-webhook <url>${RESET}     Send notifications to Slack"
     echo -e "  ${DIM}--self-heal <n>${RESET}            Build→test retry cycles on failure (default: 2)"
+    echo -e "  ${DIM}--max-iterations <n>${RESET}       Override max build loop iterations"
+    echo -e "  ${DIM}--completed-stages \"a,b\"${RESET}   Skip these stages (CI resume)"
     echo ""
     echo -e "${BOLD}STAGES${RESET}  ${DIM}(configurable per pipeline template)${RESET}"
     echo -e "  intake → plan → design → build → test → review → pr → deploy → validate → monitor"
@@ -217,7 +285,7 @@ parse_args() {
         case "$1" in
             --goal)        GOAL="$2"; shift 2 ;;
             --issue)       ISSUE_NUMBER="$2"; shift 2 ;;
-            --pipeline)    PIPELINE_NAME="$2"; shift 2 ;;
+            --pipeline|--template) PIPELINE_NAME="$2"; shift 2 ;;
             --test-cmd)    TEST_CMD="$2"; shift 2 ;;
             --model)       MODEL="$2"; shift 2 ;;
             --agents)      AGENTS="$2"; shift 2 ;;
@@ -226,7 +294,11 @@ parse_args() {
             --reviewers)   REVIEWERS="$2"; shift 2 ;;
             --labels)      LABELS="$2"; shift 2 ;;
             --no-github)   NO_GITHUB=true; shift ;;
+            --no-github-label) NO_GITHUB_LABEL=true; shift ;;
+            --ci)          CI_MODE=true; SKIP_GATES=true; shift ;;
             --ignore-budget) IGNORE_BUDGET=true; shift ;;
+            --max-iterations) MAX_ITERATIONS_OVERRIDE="$2"; shift 2 ;;
+            --completed-stages) COMPLETED_STAGES="$2"; shift 2 ;;
             --worktree=*) AUTO_WORKTREE=true; WORKTREE_NAME="${1#--worktree=}"; WORKTREE_NAME="${WORKTREE_NAME//[^a-zA-Z0-9_-]/}"; if [[ -z "$WORKTREE_NAME" ]]; then error "Invalid worktree name (alphanumeric, hyphens, underscores only)"; exit 1; fi; shift ;;
             --worktree)   AUTO_WORKTREE=true; shift ;;
             --dry-run)     DRY_RUN=true; shift ;;
@@ -262,7 +334,7 @@ find_pipeline_config() {
     local name="$1"
     local locations=(
         "$REPO_DIR/templates/pipelines/${name}.json"
-        "$HOME/.claude-teams/pipelines/${name}.json"
+        "$HOME/.shipwright/pipelines/${name}.json"
     )
     for loc in "${locations[@]}"; do
         if [[ -f "$loc" ]]; then
@@ -274,6 +346,28 @@ find_pipeline_config() {
 }
 
 load_pipeline_config() {
+    # Check for intelligence-composed pipeline first
+    local composed_pipeline="${ARTIFACTS_DIR}/composed-pipeline.json"
+    if [[ -f "$composed_pipeline" ]] && type composer_validate_pipeline &>/dev/null; then
+        # Use composed pipeline if fresh (< 1 hour old)
+        local composed_age=99999
+        local composed_mtime
+        composed_mtime=$(stat -f %m "$composed_pipeline" 2>/dev/null || stat -c %Y "$composed_pipeline" 2>/dev/null || echo "0")
+        if [[ "$composed_mtime" -gt 0 ]]; then
+            composed_age=$(( $(now_epoch) - composed_mtime ))
+        fi
+        if [[ "$composed_age" -lt 3600 ]]; then
+            local validate_json
+            validate_json=$(cat "$composed_pipeline" 2>/dev/null || echo "")
+            if [[ -n "$validate_json" ]] && composer_validate_pipeline "$validate_json" 2>/dev/null; then
+                PIPELINE_CONFIG="$composed_pipeline"
+                info "Pipeline: ${BOLD}composed${RESET} ${DIM}(intelligence-driven)${RESET}"
+                emit_event "pipeline.composed_loaded" "issue=${ISSUE_NUMBER:-0}"
+                return
+            fi
+        fi
+    fi
+
     PIPELINE_CONFIG=$(find_pipeline_config "$PIPELINE_NAME") || {
         error "Pipeline template not found: $PIPELINE_NAME"
         echo -e "  Available templates: ${DIM}shipwright pipeline list${RESET}"
@@ -298,11 +392,72 @@ TOTAL_INPUT_TOKENS=0
 TOTAL_OUTPUT_TOKENS=0
 COST_MODEL_RATES='{"opus":{"input":15,"output":75},"sonnet":{"input":3,"output":15},"haiku":{"input":0.25,"output":1.25}}'
 
+# ─── Heartbeat ────────────────────────────────────────────────────────────────
+HEARTBEAT_PID=""
+
+start_heartbeat() {
+    local job_id="${PIPELINE_NAME:-pipeline-$$}"
+    (
+        while true; do
+            "$SCRIPT_DIR/sw-heartbeat.sh" write "$job_id" \
+                --pid $$ \
+                --issue "${ISSUE_NUMBER:-0}" \
+                --stage "${CURRENT_STAGE_ID:-unknown}" \
+                --iteration "0" \
+                --activity "$(get_stage_description "${CURRENT_STAGE_ID:-}" 2>/dev/null || echo "Running pipeline")" 2>/dev/null || true
+            sleep 30
+        done
+    ) >/dev/null 2>&1 &
+    HEARTBEAT_PID=$!
+}
+
+stop_heartbeat() {
+    if [[ -n "${HEARTBEAT_PID:-}" ]]; then
+        kill "$HEARTBEAT_PID" 2>/dev/null || true
+        wait "$HEARTBEAT_PID" 2>/dev/null || true
+        "$SCRIPT_DIR/sw-heartbeat.sh" clear "${PIPELINE_NAME:-pipeline-$$}" 2>/dev/null || true
+        HEARTBEAT_PID=""
+    fi
+}
+
+# ─── CI Helpers ───────────────────────────────────────────────────────────
+
+ci_push_partial_work() {
+    [[ "${CI_MODE:-false}" != "true" ]] && return 0
+    [[ -z "${ISSUE_NUMBER:-}" ]] && return 0
+
+    local branch="shipwright/issue-${ISSUE_NUMBER}"
+
+    # Only push if we have uncommitted changes
+    if ! git diff --quiet 2>/dev/null || ! git diff --cached --quiet 2>/dev/null; then
+        git add -A 2>/dev/null || true
+        git commit -m "WIP: partial pipeline progress for #${ISSUE_NUMBER}" --no-verify 2>/dev/null || true
+    fi
+
+    # Push branch (create if needed, force to overwrite previous WIP)
+    git push origin "HEAD:refs/heads/$branch" --force 2>/dev/null || true
+}
+
+ci_post_stage_event() {
+    [[ "${CI_MODE:-false}" != "true" ]] && return 0
+    [[ -z "${ISSUE_NUMBER:-}" ]] && return 0
+    [[ "${GH_AVAILABLE:-false}" != "true" ]] && return 0
+
+    local stage="$1" status="$2" elapsed="${3:-0s}"
+    local comment="<!-- SHIPWRIGHT-STAGE: ${stage}:${status}:${elapsed} -->"
+    gh issue comment "$ISSUE_NUMBER" --body "$comment" 2>/dev/null || true
+}
+
 # ─── Signal Handling ───────────────────────────────────────────────────────
 
 cleanup_on_exit() {
+    [[ "${_cleanup_done:-}" == "true" ]] && return 0
+    _cleanup_done=true
     local exit_code=$?
 
+    # Stop heartbeat writer
+    stop_heartbeat
+
     # Save state if we were running
     if [[ "$PIPELINE_STATUS" == "running" && -n "$STATE_FILE" ]]; then
         PIPELINE_STATUS="interrupted"
@@ -311,6 +466,9 @@ cleanup_on_exit() {
         echo ""
         warn "Pipeline interrupted — state saved."
         echo -e "  Resume: ${DIM}shipwright pipeline resume${RESET}"
+
+        # Push partial work in CI mode so retries can pick it up
+        ci_push_partial_work
     fi
 
     # Restore stashed changes
@@ -373,7 +531,7 @@ preflight_checks() {
         echo -e "  ${YELLOW}⚠${RESET} $dirty_files uncommitted change(s)"
         if [[ "$SKIP_GATES" == "true" ]]; then
             info "Auto-stashing uncommitted changes..."
-            git stash push -m "cct-pipeline: auto-stash before pipeline" --quiet 2>/dev/null && STASHED_CHANGES=true
+            git stash push -m "sw-pipeline: auto-stash before pipeline" --quiet 2>/dev/null && STASHED_CHANGES=true
             if [[ "$STASHED_CHANGES" == "true" ]]; then
                 echo -e "  ${GREEN}✓${RESET} Changes stashed (will restore on exit)"
             fi
@@ -409,11 +567,11 @@ preflight_checks() {
         errors=$((errors + 1))
     fi
 
-    # 5. cct loop (needed for build stage)
-    if [[ -x "$SCRIPT_DIR/cct-loop.sh" ]]; then
+    # 5. sw loop (needed for build stage)
+    if [[ -x "$SCRIPT_DIR/sw-loop.sh" ]]; then
         echo -e "  ${GREEN}✓${RESET} shipwright loop available"
     else
-        echo -e "  ${RED}✗${RESET} cct-loop.sh not found at $SCRIPT_DIR"
+        echo -e "  ${RED}✗${RESET} sw-loop.sh not found at $SCRIPT_DIR"
         errors=$((errors + 1))
     fi
 
@@ -580,19 +738,21 @@ gh_get_issue_meta() {
 gh_build_progress_body() {
     local body="## 🤖 Pipeline Progress — \`${PIPELINE_NAME}\`
 
-| Stage | Status | Duration |
-|-------|--------|----------|"
+**Delivering:** ${GOAL}
+
+| Stage | Status | Duration | |
+|-------|--------|----------|-|"
 
     local stages
     stages=$(jq -c '.stages[]' "$PIPELINE_CONFIG" 2>/dev/null)
-    while IFS= read -r stage; do
+    while IFS= read -r -u 3 stage; do
         local id enabled
         id=$(echo "$stage" | jq -r '.id')
         enabled=$(echo "$stage" | jq -r '.enabled')
 
         if [[ "$enabled" != "true" ]]; then
             body="${body}
-| ${id} | ⏭️ skipped | — |"
+| ${id} | ⏭️ skipped | — | |"
             continue
         fi
 
@@ -601,21 +761,20 @@ gh_build_progress_body() {
         local duration
         duration=$(get_stage_timing "$id")
 
-        local icon
+        local icon detail_col
         case "$sstatus" in
-            complete)  icon="✅" ;;
-            running)   icon="🔄" ;;
-            failed)    icon="❌" ;;
-            *)         icon="⬜" ;;
+            complete)  icon="✅"; detail_col="" ;;
+            running)   icon="🔄"; detail_col=$(get_stage_description "$id") ;;
+            failed)    icon="❌"; detail_col="" ;;
+            *)         icon="⬜"; detail_col=$(get_stage_description "$id") ;;
         esac
 
         body="${body}
-| ${id} | ${icon} ${sstatus:-pending} | ${duration:-—} |"
-    done <<< "$stages"
+| ${id} | ${icon} ${sstatus:-pending} | ${duration:-—} | ${detail_col} |"
+    done 3<<< "$stages"
 
     body="${body}
 
-**Goal:** ${GOAL}
 **Branch:** \`${GIT_BRANCH}\`"
 
     [[ -n "${GITHUB_ISSUE:-}" ]] && body="${body}
@@ -628,10 +787,19 @@ gh_build_progress_body() {
 **Elapsed:** ${total_dur}"
     fi
 
+    # Artifacts section
+    local artifacts=""
+    [[ -f "$ARTIFACTS_DIR/plan.md" ]] && artifacts="${artifacts}[Plan](.claude/pipeline-artifacts/plan.md)"
+    [[ -f "$ARTIFACTS_DIR/design.md" ]] && { [[ -n "$artifacts" ]] && artifacts="${artifacts} · "; artifacts="${artifacts}[Design](.claude/pipeline-artifacts/design.md)"; }
+    [[ -n "${PR_NUMBER:-}" ]] && { [[ -n "$artifacts" ]] && artifacts="${artifacts} · "; artifacts="${artifacts}PR #${PR_NUMBER}"; }
+    [[ -n "$artifacts" ]] && body="${body}
+
+📎 **Artifacts:** ${artifacts}"
+
     body="${body}
 
 ---
-_Updated: $(now_iso) · Generated by \`shipwright pipeline\`_"
+_Updated: $(now_iso) · shipwright pipeline_"
     echo "$body"
 }
 
@@ -725,36 +893,58 @@ detect_test_cmd() {
 # Detect project language/framework
 detect_project_lang() {
     local root="$PROJECT_ROOT"
+    local detected=""
+
+    # Fast heuristic detection (grep-based)
     if [[ -f "$root/package.json" ]]; then
         if grep -q "typescript" "$root/package.json" 2>/dev/null; then
-            echo "typescript"
+            detected="typescript"
         elif grep -q "\"next\"" "$root/package.json" 2>/dev/null; then
-            echo "nextjs"
+            detected="nextjs"
         elif grep -q "\"react\"" "$root/package.json" 2>/dev/null; then
-            echo "react"
+            detected="react"
         else
-            echo "nodejs"
+            detected="nodejs"
         fi
     elif [[ -f "$root/Cargo.toml" ]]; then
-        echo "rust"
+        detected="rust"
     elif [[ -f "$root/go.mod" ]]; then
-        echo "go"
+        detected="go"
     elif [[ -f "$root/pyproject.toml" || -f "$root/setup.py" || -f "$root/requirements.txt" ]]; then
-        echo "python"
+        detected="python"
     elif [[ -f "$root/Gemfile" ]]; then
-        echo "ruby"
+        detected="ruby"
     elif [[ -f "$root/pom.xml" || -f "$root/build.gradle" ]]; then
-        echo "java"
+        detected="java"
     else
-        echo "unknown"
+        detected="unknown"
+    fi
+
+    # Intelligence: holistic analysis for polyglot/monorepo detection
+    if [[ "$detected" == "unknown" ]] && type intelligence_search_memory &>/dev/null 2>&1 && command -v claude &>/dev/null; then
+        local config_files
+        config_files=$(ls "$root" 2>/dev/null | grep -E '\.(json|toml|yaml|yml|xml|gradle|lock|mod)$' | head -15)
+        if [[ -n "$config_files" ]]; then
+            local ai_lang
+            ai_lang=$(claude --print --output-format text -p "Based on these config files in a project root, what is the primary language/framework? Reply with ONE word (e.g., typescript, python, rust, go, java, ruby, nodejs):
+
+Files: ${config_files}" --model haiku < /dev/null 2>/dev/null || true)
+            ai_lang=$(echo "$ai_lang" | tr -d '[:space:]' | tr '[:upper:]' '[:lower:]')
+            case "$ai_lang" in
+                typescript|python|rust|go|java|ruby|nodejs|react|nextjs|kotlin|swift|elixir|scala)
+                    detected="$ai_lang" ;;
+            esac
+        fi
     fi
+
+    echo "$detected"
 }
 
 # Detect likely reviewers from CODEOWNERS or git log
 detect_reviewers() {
     local root="$PROJECT_ROOT"
 
-    # Check CODEOWNERS
+    # Check CODEOWNERS — common paths first, then broader search
     local codeowners=""
     for f in "$root/.github/CODEOWNERS" "$root/CODEOWNERS" "$root/docs/CODEOWNERS"; do
         if [[ -f "$f" ]]; then
@@ -762,6 +952,10 @@ detect_reviewers() {
             break
         fi
     done
+    # Broader search if not found at common locations
+    if [[ -z "$codeowners" ]]; then
+        codeowners=$(find "$root" -maxdepth 3 -name "CODEOWNERS" -type f 2>/dev/null | head -1 || true)
+    fi
 
     if [[ -n "$codeowners" ]]; then
         # Extract GitHub usernames from CODEOWNERS (lines like: * @user1 @user2)
@@ -774,22 +968,54 @@ detect_reviewers() {
         fi
     fi
 
-    # Fallback: top contributors from recent git log (excluding self)
+    # Fallback: try to extract GitHub usernames from recent commit emails
+    # Format: user@users.noreply.github.com → user, or noreply+user@... → user
     local current_user
-    current_user=$(gh api user --jq '.login' 2>/dev/null || git config user.name 2>/dev/null || true)
+    current_user=$(gh api user --jq '.login' 2>/dev/null || true)
     local contributors
-    contributors=$(git log --format='%aN' -100 2>/dev/null | \
+    contributors=$(git log --format='%aE' -100 2>/dev/null | \
+        grep -oE '[a-zA-Z0-9_-]+@users\.noreply\.github\.com' | \
+        sed 's/@users\.noreply\.github\.com//' | sed 's/^[0-9]*+//' | \
         sort | uniq -c | sort -rn | \
         awk '{print $NF}' | \
-        grep -v "^${current_user}$" 2>/dev/null | \
+        grep -v "^${current_user:-___}$" 2>/dev/null | \
         head -2 | tr '\n' ',')
     contributors="${contributors%,}"
     echo "$contributors"
 }
 
-# Get branch prefix from task type
+# Get branch prefix from task type — checks git history for conventions first
 branch_prefix_for_type() {
-    case "$1" in
+    local task_type="$1"
+
+    # Analyze recent branches for naming conventions
+    local branch_prefixes
+    branch_prefixes=$(git branch -r 2>/dev/null | sed 's#origin/##' | grep -oE '^[a-z]+/' | sort | uniq -c | sort -rn | head -5 || true)
+    if [[ -n "$branch_prefixes" ]]; then
+        local total_branches dominant_prefix dominant_count
+        total_branches=$(echo "$branch_prefixes" | awk '{s+=$1} END {print s}' || echo "0")
+        dominant_prefix=$(echo "$branch_prefixes" | head -1 | awk '{print $2}' | tr -d '/' || true)
+        dominant_count=$(echo "$branch_prefixes" | head -1 | awk '{print $1}' || echo "0")
+        # If >80% of branches use a pattern, adopt it for the matching type
+        if [[ "$total_branches" -gt 5 ]] && [[ "$dominant_count" -gt 0 ]]; then
+            local pct=$(( (dominant_count * 100) / total_branches ))
+            if [[ "$pct" -gt 80 && -n "$dominant_prefix" ]]; then
+                # Map task type to the repo's convention
+                local mapped=""
+                case "$task_type" in
+                    bug)      mapped=$(echo "$branch_prefixes" | awk '{print $2}' | tr -d '/' | grep -E '^(fix|bug|hotfix)$' | head -1 || true) ;;
+                    feature)  mapped=$(echo "$branch_prefixes" | awk '{print $2}' | tr -d '/' | grep -E '^(feat|feature)$' | head -1 || true) ;;
+                esac
+                if [[ -n "$mapped" ]]; then
+                    echo "$mapped"
+                    return
+                fi
+            fi
+        fi
+    fi
+
+    # Fallback: hardcoded mapping
+    case "$task_type" in
         bug)          echo "fix" ;;
         refactor)     echo "refactor" ;;
         testing)      echo "test" ;;
@@ -855,6 +1081,84 @@ get_stage_timing() {
     fi
 }
 
+get_stage_description() {
+    local stage_id="$1"
+
+    # Try to generate dynamic description from pipeline config
+    if [[ -n "${PIPELINE_CONFIG:-}" && -f "${PIPELINE_CONFIG:-/dev/null}" ]]; then
+        local stage_cfg
+        stage_cfg=$(jq -c --arg id "$stage_id" '.stages[] | select(.id == $id) | .config // {}' "$PIPELINE_CONFIG" 2>/dev/null || echo "{}")
+        case "$stage_id" in
+            test)
+                local cfg_test_cmd cfg_cov_min
+                cfg_test_cmd=$(echo "$stage_cfg" | jq -r '.test_cmd // empty' 2>/dev/null || true)
+                cfg_cov_min=$(echo "$stage_cfg" | jq -r '.coverage_min // empty' 2>/dev/null || true)
+                if [[ -n "$cfg_test_cmd" ]]; then
+                    echo "Running ${cfg_test_cmd}${cfg_cov_min:+ with ${cfg_cov_min}% coverage gate}"
+                    return
+                fi
+                ;;
+            build)
+                local cfg_max_iter cfg_model
+                cfg_max_iter=$(echo "$stage_cfg" | jq -r '.max_iterations // empty' 2>/dev/null || true)
+                cfg_model=$(jq -r '.defaults.model // empty' "$PIPELINE_CONFIG" 2>/dev/null || true)
+                if [[ -n "$cfg_max_iter" ]]; then
+                    echo "Building with ${cfg_max_iter} max iterations${cfg_model:+ using ${cfg_model}}"
+                    return
+                fi
+                ;;
+            monitor)
+                local cfg_dur cfg_thresh
+                cfg_dur=$(echo "$stage_cfg" | jq -r '.duration_minutes // empty' 2>/dev/null || true)
+                cfg_thresh=$(echo "$stage_cfg" | jq -r '.error_threshold // empty' 2>/dev/null || true)
+                if [[ -n "$cfg_dur" ]]; then
+                    echo "Monitoring for ${cfg_dur}m${cfg_thresh:+ (threshold: ${cfg_thresh} errors)}"
+                    return
+                fi
+                ;;
+        esac
+    fi
+
+    # Static fallback descriptions
+    case "$stage_id" in
+        intake)           echo "Extracting requirements and auto-detecting project setup" ;;
+        plan)             echo "Creating implementation plan with architecture decisions" ;;
+        design)           echo "Designing interfaces, data models, and API contracts" ;;
+        build)            echo "Writing production code with self-healing iteration" ;;
+        test)             echo "Running test suite and validating coverage" ;;
+        review)           echo "Code quality, security audit, performance review" ;;
+        compound_quality) echo "Adversarial testing, E2E validation, DoD checklist" ;;
+        pr)               echo "Creating pull request with CI integration" ;;
+        merge)            echo "Merging PR with branch cleanup" ;;
+        deploy)           echo "Deploying to staging/production" ;;
+        validate)         echo "Smoke tests and health checks post-deploy" ;;
+        monitor)          echo "Production monitoring with auto-rollback" ;;
+        *)                echo "" ;;
+    esac
+}
+
+# Build inline stage progress string (e.g. "intake:complete plan:running test:pending")
+build_stage_progress() {
+    local progress=""
+    local stages
+    stages=$(jq -c '.stages[]' "$PIPELINE_CONFIG" 2>/dev/null) || return 0
+    while IFS= read -r -u 3 stage; do
+        local id enabled
+        id=$(echo "$stage" | jq -r '.id')
+        enabled=$(echo "$stage" | jq -r '.enabled')
+        [[ "$enabled" != "true" ]] && continue
+        local sstatus
+        sstatus=$(get_stage_status "$id")
+        sstatus="${sstatus:-pending}"
+        if [[ -n "$progress" ]]; then
+            progress="${progress} ${id}:${sstatus}"
+        else
+            progress="${id}:${sstatus}"
+        fi
+    done 3<<< "$stages"
+    echo "$progress"
+}
+
 update_status() {
     local status="$1" stage="$2"
     PIPELINE_STATUS="$status"
@@ -877,6 +1181,20 @@ mark_stage_complete() {
         local body
         body=$(gh_build_progress_body)
         gh_update_progress "$body"
+
+        # Notify tracker (Linear/Jira) of stage completion
+        local stage_desc
+        stage_desc=$(get_stage_description "$stage_id")
+        "$SCRIPT_DIR/sw-tracker.sh" notify "stage_complete" "$ISSUE_NUMBER" \
+            "${stage_id}|${timing}|${stage_desc}" 2>/dev/null || true
+
+        # Post structured stage event for CI sweep/retry intelligence
+        ci_post_stage_event "$stage_id" "complete" "$timing"
+    fi
+
+    # Update GitHub Check Run for this stage
+    if [[ "${NO_GITHUB:-false}" != "true" ]] && type gh_checks_stage_update &>/dev/null 2>&1; then
+        gh_checks_stage_update "$stage_id" "completed" "success" "Stage $stage_id: ${timing}" 2>/dev/null || true
     fi
 }
 
@@ -899,6 +1217,22 @@ mark_stage_failed() {
 \`\`\`
 $(tail -5 "$ARTIFACTS_DIR/${stage_id}"*.log 2>/dev/null || echo 'No log available')
 \`\`\`"
+
+        # Notify tracker (Linear/Jira) of stage failure
+        local error_context
+        error_context=$(tail -5 "$ARTIFACTS_DIR/${stage_id}"*.log 2>/dev/null || echo "No log")
+        "$SCRIPT_DIR/sw-tracker.sh" notify "stage_failed" "$ISSUE_NUMBER" \
+            "${stage_id}|${error_context}" 2>/dev/null || true
+
+        # Post structured stage event for CI sweep/retry intelligence
+        ci_post_stage_event "$stage_id" "failed" "$timing"
+    fi
+
+    # Update GitHub Check Run for this stage
+    if [[ "${NO_GITHUB:-false}" != "true" ]] && type gh_checks_stage_update &>/dev/null 2>&1; then
+        local fail_summary
+        fail_summary=$(tail -3 "$ARTIFACTS_DIR/${stage_id}"*.log 2>/dev/null | head -c 500 || echo "Stage $stage_id failed")
+        gh_checks_stage_update "$stage_id" "completed" "failure" "$fail_summary" 2>/dev/null || true
     fi
 }
 
@@ -920,10 +1254,13 @@ initialize_state() {
     STAGE_STATUSES=""
     STAGE_TIMINGS=""
     LOG_ENTRIES=""
+    # Clear per-run tracking files
+    rm -f "$ARTIFACTS_DIR/model-routing.log" "$ARTIFACTS_DIR/.plan-failure-sig.txt"
     write_state
 }
 
 write_state() {
+    [[ -z "${STATE_FILE:-}" || -z "${ARTIFACTS_DIR:-}" ]] && return 0
     local stages_yaml=""
     while IFS=: read -r sid sstatus; do
         [[ -z "$sid" ]] && continue
@@ -936,6 +1273,16 @@ write_state() {
         total_dur=$(format_duration $(( $(now_epoch) - PIPELINE_START_EPOCH )))
     fi
 
+    # Stage description and progress for dashboard enrichment
+    local cur_stage_desc=""
+    if [[ -n "${CURRENT_STAGE:-}" ]]; then
+        cur_stage_desc=$(get_stage_description "$CURRENT_STAGE")
+    fi
+    local stage_progress=""
+    if [[ -n "${PIPELINE_CONFIG:-}" && -f "${PIPELINE_CONFIG:-/dev/null}" ]]; then
+        stage_progress=$(build_stage_progress)
+    fi
+
     cat > "$STATE_FILE" <<EOF
 ---
 pipeline: $PIPELINE_NAME
@@ -945,6 +1292,8 @@ issue: "${GITHUB_ISSUE:-}"
 branch: "${GIT_BRANCH:-}"
 template: "${TASK_TYPE:+$(template_for_type "$TASK_TYPE")}"
 current_stage: $CURRENT_STAGE
+current_stage_description: "${cur_stage_desc}"
+stage_progress: "${stage_progress}"
 started_at: ${STARTED_AT:-$(now_iso)}
 updated_at: $(now_iso)
 elapsed: ${total_dur:-0s}
@@ -980,6 +1329,8 @@ resume_state() {
                 issue:*)               GITHUB_ISSUE="$(echo "${line#issue:}" | sed 's/^ *"//;s/" *$//')" ;;
                 branch:*)              GIT_BRANCH="$(echo "${line#branch:}" | sed 's/^ *"//;s/" *$//')" ;;
                 current_stage:*)       CURRENT_STAGE="$(echo "${line#current_stage:}" | xargs)" ;;
+                current_stage_description:*) ;; # computed field — skip on resume
+                stage_progress:*)      ;; # computed field — skip on resume
                 started_at:*)          STARTED_AT="$(echo "${line#started_at:}" | xargs)" ;;
                 pr_number:*)           PR_NUMBER="$(echo "${line#pr_number:}" | xargs)" ;;
                 progress_comment_id:*) PROGRESS_COMMENT_ID="$(echo "${line#progress_comment_id:}" | xargs)" ;;
@@ -1037,6 +1388,32 @@ ${sid}:${sst}"
 
 detect_task_type() {
     local goal="$1"
+
+    # Intelligence: Claude classification with confidence score
+    if type intelligence_search_memory &>/dev/null 2>&1 && command -v claude &>/dev/null; then
+        local ai_result
+        ai_result=$(claude --print --output-format text -p "Classify this task into exactly ONE category. Reply in format: CATEGORY|CONFIDENCE (0-100)
+
+Categories: bug, refactor, testing, security, docs, devops, migration, architecture, feature
+
+Task: ${goal}" --model haiku < /dev/null 2>/dev/null || true)
+        if [[ -n "$ai_result" ]]; then
+            local ai_type ai_conf
+            ai_type=$(echo "$ai_result" | head -1 | cut -d'|' -f1 | tr -d '[:space:]' | tr '[:upper:]' '[:lower:]')
+            ai_conf=$(echo "$ai_result" | head -1 | cut -d'|' -f2 | grep -oE '[0-9]+' | head -1 || echo "0")
+            # Use AI classification if confidence >= 70
+            case "$ai_type" in
+                bug|refactor|testing|security|docs|devops|migration|architecture|feature)
+                    if [[ "${ai_conf:-0}" -ge 70 ]] 2>/dev/null; then
+                        echo "$ai_type"
+                        return
+                    fi
+                    ;;
+            esac
+        fi
+    fi
+
+    # Fallback: keyword matching
     local lower
     lower=$(echo "$goal" | tr '[:upper:]' '[:lower:]')
     case "$lower" in
@@ -1091,6 +1468,7 @@ show_stage_preview() {
 # ─── Stage Functions ────────────────────────────────────────────────────────
 
 stage_intake() {
+    CURRENT_STAGE_ID="intake"
     local project_lang
     project_lang=$(detect_project_lang)
     info "Project: ${BOLD}$project_lang${RESET}"
@@ -1188,6 +1566,7 @@ Test cmd: ${TEST_CMD:-none detected}"
 }
 
 stage_plan() {
+    CURRENT_STAGE_ID="plan"
     local plan_file="$ARTIFACTS_DIR/plan.md"
 
     if ! command -v claude &>/dev/null; then
@@ -1212,6 +1591,62 @@ ${ISSUE_BODY}
 "
     fi
 
+    # Inject intelligence memory context for similar past plans
+    if type intelligence_search_memory &>/dev/null 2>&1; then
+        local plan_memory
+        plan_memory=$(intelligence_search_memory "plan stage for ${TASK_TYPE:-feature}: ${GOAL:-}" "${HOME}/.shipwright/memory" 5 2>/dev/null) || true
+        if [[ -n "$plan_memory" && "$plan_memory" != *'"results":[]'* && "$plan_memory" != *'"error"'* ]]; then
+            local memory_summary
+            memory_summary=$(echo "$plan_memory" | jq -r '.results[]? | "- \(.)"' 2>/dev/null | head -10 || true)
+            if [[ -n "$memory_summary" ]]; then
+                plan_prompt="${plan_prompt}
+## Historical Context (from previous pipelines)
+Previous similar issues were planned as:
+${memory_summary}
+"
+            fi
+        fi
+    fi
+
+    # Inject architecture patterns from intelligence layer
+    local repo_hash_plan
+    repo_hash_plan=$(echo -n "$PROJECT_ROOT" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown")
+    local arch_file_plan="${HOME}/.shipwright/memory/${repo_hash_plan}/architecture.json"
+    if [[ -f "$arch_file_plan" ]]; then
+        local arch_patterns
+        arch_patterns=$(jq -r '
+            "Language: \(.language // "unknown")",
+            "Framework: \(.framework // "unknown")",
+            "Patterns: \((.patterns // []) | join(", "))",
+            "Rules: \((.rules // []) | join("; "))"
+        ' "$arch_file_plan" 2>/dev/null || true)
+        if [[ -n "$arch_patterns" ]]; then
+            plan_prompt="${plan_prompt}
+## Architecture Patterns
+${arch_patterns}
+"
+        fi
+    fi
+
+    # Task-type-specific guidance
+    case "${TASK_TYPE:-feature}" in
+        bug)
+            plan_prompt="${plan_prompt}
+## Task Type: Bug Fix
+Focus on: reproducing the bug, identifying root cause, minimal targeted fix, regression tests.
+" ;;
+        refactor)
+            plan_prompt="${plan_prompt}
+## Task Type: Refactor
+Focus on: preserving all existing behavior, incremental changes, comprehensive test coverage.
+" ;;
+        security)
+            plan_prompt="${plan_prompt}
+## Task Type: Security
+Focus on: threat modeling, OWASP top 10, input validation, authentication/authorization.
+" ;;
+    esac
+
     # Add project context
     local project_lang
     project_lang=$(detect_project_lang)
@@ -1247,10 +1682,14 @@ Checklist of completion criteria.
     plan_model=$(jq -r --arg id "plan" '(.stages[] | select(.id == $id) | .config.model) // .defaults.model // "opus"' "$PIPELINE_CONFIG" 2>/dev/null) || true
     [[ -n "$MODEL" ]] && plan_model="$MODEL"
     [[ -z "$plan_model" || "$plan_model" == "null" ]] && plan_model="opus"
+    # Intelligence model routing (when no explicit CLI --model override)
+    if [[ -z "$MODEL" && -n "${CLAUDE_MODEL:-}" ]]; then
+        plan_model="$CLAUDE_MODEL"
+    fi
 
     local _token_log="${ARTIFACTS_DIR}/.claude-tokens-plan.log"
-    claude --print --model "$plan_model" --max-turns 10 \
-        "$plan_prompt" > "$plan_file" 2>"$_token_log" || true
+    claude --print --model "$plan_model" --max-turns 25 \
+        "$plan_prompt" < /dev/null > "$plan_file" 2>"$_token_log" || true
     parse_claude_tokens "$_token_log"
 
     if [[ ! -s "$plan_file" ]]; then
@@ -1342,6 +1781,163 @@ CC_TASKS_EOF
     # Extract definition of done for quality gates
     sed -n '/[Dd]efinition [Oo]f [Dd]one/,/^#/p' "$plan_file" | head -20 > "$ARTIFACTS_DIR/dod.md" 2>/dev/null || true
 
+    # ── Plan Validation Gate ──
+    # Ask Claude to validate the plan before proceeding
+    if command -v claude &>/dev/null && [[ -s "$plan_file" ]]; then
+        local validation_attempts=0
+        local max_validation_attempts=2
+        local plan_valid=false
+
+        while [[ "$validation_attempts" -lt "$max_validation_attempts" ]]; do
+            validation_attempts=$((validation_attempts + 1))
+            info "Validating plan (attempt ${validation_attempts}/${max_validation_attempts})..."
+
+            # Build enriched validation prompt with learned context
+            local validation_extra=""
+
+            # Inject rejected plan history from memory
+            if type intelligence_search_memory &>/dev/null 2>&1; then
+                local rejected_plans
+                rejected_plans=$(intelligence_search_memory "rejected plan validation failures for: ${GOAL:-}" "${HOME}/.shipwright/memory" 3 2>/dev/null) || true
+                if [[ -n "$rejected_plans" ]]; then
+                    validation_extra="${validation_extra}
+## Previously Rejected Plans
+These issues were found in past plan validations for similar tasks:
+${rejected_plans}
+"
+                fi
+            fi
+
+            # Inject repo conventions contextually
+            local claudemd="$PROJECT_ROOT/.claude/CLAUDE.md"
+            if [[ -f "$claudemd" ]]; then
+                local conventions_summary
+                conventions_summary=$(head -100 "$claudemd" 2>/dev/null | grep -E '^##|^-|^\*' | head -15 || true)
+                if [[ -n "$conventions_summary" ]]; then
+                    validation_extra="${validation_extra}
+## Repo Conventions
+${conventions_summary}
+"
+                fi
+            fi
+
+            # Inject complexity estimate
+            local complexity_hint=""
+            if [[ -n "${INTELLIGENCE_COMPLEXITY:-}" && "${INTELLIGENCE_COMPLEXITY:-0}" -gt 0 ]]; then
+                complexity_hint="This is estimated as complexity ${INTELLIGENCE_COMPLEXITY}/10. Plans for this complexity typically need ${INTELLIGENCE_COMPLEXITY} or more tasks."
+            fi
+
+            local validation_prompt="You are a plan validator. Review this implementation plan and determine if it is valid.
+
+## Goal
+${GOAL}
+${complexity_hint:+
+## Complexity Estimate
+${complexity_hint}
+}
+## Plan
+$(cat "$plan_file")
+${validation_extra}
+Evaluate:
+1. Are all requirements from the goal addressed?
+2. Is the plan decomposed into clear, achievable tasks?
+3. Are the implementation steps specific enough to execute?
+
+Respond with EXACTLY one of these on the first line:
+VALID: true
+VALID: false
+
+Then explain your reasoning briefly."
+
+            local validation_model="${plan_model:-opus}"
+            local validation_result
+            validation_result=$(claude --print --output-format text -p "$validation_prompt" --model "$validation_model" < /dev/null 2>"${ARTIFACTS_DIR}/.claude-tokens-plan-validate.log" || true)
+            parse_claude_tokens "${ARTIFACTS_DIR}/.claude-tokens-plan-validate.log"
+
+            # Save validation result
+            echo "$validation_result" > "$ARTIFACTS_DIR/plan-validation.md"
+
+            if echo "$validation_result" | head -5 | grep -qi "VALID: true"; then
+                success "Plan validation passed"
+                plan_valid=true
+                break
+            fi
+
+            warn "Plan validation failed (attempt ${validation_attempts}/${max_validation_attempts})"
+
+            # Analyze failure mode to decide how to recover
+            local failure_mode="unknown"
+            local validation_lower
+            validation_lower=$(echo "$validation_result" | tr '[:upper:]' '[:lower:]')
+            if echo "$validation_lower" | grep -qE 'requirements? unclear|goal.*vague|ambiguous|underspecified'; then
+                failure_mode="requirements_unclear"
+            elif echo "$validation_lower" | grep -qE 'insufficient detail|not specific|too high.level|missing.*steps|lacks.*detail'; then
+                failure_mode="insufficient_detail"
+            elif echo "$validation_lower" | grep -qE 'scope too (large|broad)|too many|overly complex|break.*down'; then
+                failure_mode="scope_too_large"
+            fi
+
+            emit_event "plan.validation_failure" \
+                "issue=${ISSUE_NUMBER:-0}" \
+                "attempt=$validation_attempts" \
+                "failure_mode=$failure_mode"
+
+            # Track repeated failures — escalate if stuck in a loop
+            if [[ -f "$ARTIFACTS_DIR/.plan-failure-sig.txt" ]]; then
+                local prev_sig
+                prev_sig=$(cat "$ARTIFACTS_DIR/.plan-failure-sig.txt" 2>/dev/null || true)
+                if [[ "$failure_mode" == "$prev_sig" && "$failure_mode" != "unknown" ]]; then
+                    warn "Same validation failure mode repeated ($failure_mode) — escalating"
+                    emit_event "plan.validation_escalated" \
+                        "issue=${ISSUE_NUMBER:-0}" \
+                        "failure_mode=$failure_mode"
+                    break
+                fi
+            fi
+            echo "$failure_mode" > "$ARTIFACTS_DIR/.plan-failure-sig.txt"
+
+            if [[ "$validation_attempts" -lt "$max_validation_attempts" ]]; then
+                info "Regenerating plan with validation feedback (mode: ${failure_mode})..."
+
+                # Tailor regeneration prompt based on failure mode
+                local failure_guidance=""
+                case "$failure_mode" in
+                    requirements_unclear)
+                        failure_guidance="The validator found the requirements unclear. Add more specific acceptance criteria, input/output examples, and concrete success metrics." ;;
+                    insufficient_detail)
+                        failure_guidance="The validator found the plan lacks detail. Break each task into smaller, more specific implementation steps with exact file paths and function names." ;;
+                    scope_too_large)
+                        failure_guidance="The validator found the scope too large. Focus on the minimal viable implementation and defer non-essential features to follow-up tasks." ;;
+                esac
+
+                local regen_prompt="${plan_prompt}
+
+IMPORTANT: A previous plan was rejected by validation. Issues found:
+$(echo "$validation_result" | tail -20)
+${failure_guidance:+
+GUIDANCE: ${failure_guidance}}
+
+Fix these issues in the new plan."
+
+                claude --print --model "$plan_model" --max-turns 25 \
+                    "$regen_prompt" < /dev/null > "$plan_file" 2>"$_token_log" || true
+                parse_claude_tokens "$_token_log"
+
+                line_count=$(wc -l < "$plan_file" | xargs)
+                info "Regenerated plan: ${DIM}$plan_file${RESET} (${line_count} lines)"
+            fi
+        done
+
+        if [[ "$plan_valid" != "true" ]]; then
+            warn "Plan validation did not pass after ${max_validation_attempts} attempts — proceeding anyway"
+        fi
+
+        emit_event "plan.validated" \
+            "issue=${ISSUE_NUMBER:-0}" \
+            "valid=${plan_valid}" \
+            "attempts=${validation_attempts}"
+    fi
+
     log_stage "plan" "Generated plan.md (${line_count} lines, $(echo "$checklist" | wc -l | xargs) tasks)"
 }
 
@@ -1364,8 +1960,49 @@ stage_design() {
 
     # Memory integration — inject context if memory system available
     local memory_context=""
-    if [[ -x "$SCRIPT_DIR/cct-memory.sh" ]]; then
-        memory_context=$(bash "$SCRIPT_DIR/cct-memory.sh" inject "design" 2>/dev/null) || true
+    if type intelligence_search_memory &>/dev/null 2>&1; then
+        local mem_dir="${HOME}/.shipwright/memory"
+        memory_context=$(intelligence_search_memory "design stage architecture patterns for: ${GOAL:-}" "$mem_dir" 5 2>/dev/null) || true
+    fi
+    if [[ -z "$memory_context" ]] && [[ -x "$SCRIPT_DIR/sw-memory.sh" ]]; then
+        memory_context=$(bash "$SCRIPT_DIR/sw-memory.sh" inject "design" 2>/dev/null) || true
+    fi
+
+    # Inject architecture model patterns if available
+    local arch_context=""
+    local repo_hash
+    repo_hash=$(echo -n "$PROJECT_ROOT" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown")
+    local arch_model_file="${HOME}/.shipwright/memory/${repo_hash}/architecture.json"
+    if [[ -f "$arch_model_file" ]]; then
+        local arch_patterns
+        arch_patterns=$(jq -r '
+            [.patterns // [] | .[] | "- \(.name // "unnamed"): \(.description // "no description")"] | join("\n")
+        ' "$arch_model_file" 2>/dev/null) || true
+        local arch_layers
+        arch_layers=$(jq -r '
+            [.layers // [] | .[] | "- \(.name // "unnamed"): \(.path // "")"] | join("\n")
+        ' "$arch_model_file" 2>/dev/null) || true
+        if [[ -n "$arch_patterns" || -n "$arch_layers" ]]; then
+            arch_context="Previous designs in this repo follow these patterns:
+${arch_patterns:+Patterns:
+${arch_patterns}
+}${arch_layers:+Layers:
+${arch_layers}}"
+        fi
+    fi
+
+    # Inject rejected design approaches and anti-patterns from memory
+    local design_antipatterns=""
+    if type intelligence_search_memory &>/dev/null 2>&1; then
+        local rejected_designs
+        rejected_designs=$(intelligence_search_memory "rejected design approaches anti-patterns for: ${GOAL:-}" "${HOME}/.shipwright/memory" 3 2>/dev/null) || true
+        if [[ -n "$rejected_designs" ]]; then
+            design_antipatterns="
+## Rejected Approaches (from past reviews)
+These design approaches were rejected in past reviews. Avoid repeating them:
+${rejected_designs}
+"
+        fi
     fi
 
     # Build design prompt with plan + project context
@@ -1387,7 +2024,10 @@ $(cat "$plan_file")
 ${memory_context:+
 ## Historical Context (from memory)
 ${memory_context}
-}
+}${arch_context:+
+## Architecture Model (from previous designs)
+${arch_context}
+}${design_antipatterns}
 ## Required Output — Architecture Decision Record
 
 Produce this EXACT format:
@@ -1420,10 +2060,14 @@ Be concrete and specific. Reference actual file paths in the codebase. Consider
     design_model=$(jq -r --arg id "design" '(.stages[] | select(.id == $id) | .config.model) // .defaults.model // "opus"' "$PIPELINE_CONFIG" 2>/dev/null) || true
     [[ -n "$MODEL" ]] && design_model="$MODEL"
     [[ -z "$design_model" || "$design_model" == "null" ]] && design_model="opus"
+    # Intelligence model routing (when no explicit CLI --model override)
+    if [[ -z "$MODEL" && -n "${CLAUDE_MODEL:-}" ]]; then
+        design_model="$CLAUDE_MODEL"
+    fi
 
     local _token_log="${ARTIFACTS_DIR}/.claude-tokens-design.log"
-    claude --print --model "$design_model" --max-turns 10 \
-        "$design_prompt" > "$design_file" 2>"$_token_log" || true
+    claude --print --model "$design_model" --max-turns 25 \
+        "$design_prompt" < /dev/null > "$design_file" 2>"$_token_log" || true
     parse_claude_tokens "$_token_log"
 
     if [[ ! -s "$design_file" ]]; then
@@ -1475,8 +2119,12 @@ stage_build() {
 
     # Memory integration — inject context if memory system available
     local memory_context=""
-    if [[ -x "$SCRIPT_DIR/cct-memory.sh" ]]; then
-        memory_context=$(bash "$SCRIPT_DIR/cct-memory.sh" inject "build" 2>/dev/null) || true
+    if type intelligence_search_memory &>/dev/null 2>&1; then
+        local mem_dir="${HOME}/.shipwright/memory"
+        memory_context=$(intelligence_search_memory "build stage for: ${GOAL:-}" "$mem_dir" 5 2>/dev/null) || true
+    fi
+    if [[ -z "$memory_context" ]] && [[ -x "$SCRIPT_DIR/sw-memory.sh" ]]; then
+        memory_context=$(bash "$SCRIPT_DIR/sw-memory.sh" inject "build" 2>/dev/null) || true
     fi
 
     # Build enriched goal with full context
@@ -1512,6 +2160,44 @@ Task tracking (check off items as you complete them):
 $(cat "$TASKS_FILE")"
     fi
 
+    # Inject file hotspots from GitHub intelligence
+    if [[ "${NO_GITHUB:-}" != "true" ]] && type gh_file_change_frequency &>/dev/null 2>&1; then
+        local build_hotspots
+        build_hotspots=$(gh_file_change_frequency 2>/dev/null | head -5 || true)
+        if [[ -n "$build_hotspots" ]]; then
+            enriched_goal="${enriched_goal}
+
+File hotspots (most frequently changed — review these carefully):
+${build_hotspots}"
+        fi
+    fi
+
+    # Inject security alerts context
+    if [[ "${NO_GITHUB:-}" != "true" ]] && type gh_security_alerts &>/dev/null 2>&1; then
+        local build_alerts
+        build_alerts=$(gh_security_alerts 2>/dev/null | head -3 || true)
+        if [[ -n "$build_alerts" ]]; then
+            enriched_goal="${enriched_goal}
+
+Active security alerts (do not introduce new vulnerabilities):
+${build_alerts}"
+        fi
+    fi
+
+    # Inject coverage baseline
+    local repo_hash_build
+    repo_hash_build=$(echo -n "$PROJECT_ROOT" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown")
+    local coverage_file_build="${HOME}/.shipwright/baselines/${repo_hash_build}/coverage.json"
+    if [[ -f "$coverage_file_build" ]]; then
+        local coverage_baseline
+        coverage_baseline=$(jq -r '.coverage_percent // empty' "$coverage_file_build" 2>/dev/null || true)
+        if [[ -n "$coverage_baseline" ]]; then
+            enriched_goal="${enriched_goal}
+
+Coverage baseline: ${coverage_baseline}% — do not decrease coverage."
+        fi
+    fi
+
     loop_args+=("$enriched_goal")
 
     # Build loop args from pipeline config + CLI overrides
@@ -1530,6 +2216,8 @@ $(cat "$TASKS_FILE")"
     local max_iter
     max_iter=$(jq -r --arg id "build" '(.stages[] | select(.id == $id) | .config.max_iterations) // 20' "$PIPELINE_CONFIG" 2>/dev/null) || true
     [[ -z "$max_iter" || "$max_iter" == "null" ]] && max_iter=20
+    # CLI --max-iterations override (from CI strategy engine)
+    [[ -n "${MAX_ITERATIONS_OVERRIDE:-}" ]] && max_iter="$MAX_ITERATIONS_OVERRIDE"
 
     local agents="${AGENTS}"
     if [[ -z "$agents" ]]; then
@@ -1537,6 +2225,16 @@ $(cat "$TASKS_FILE")"
         [[ -z "$agents" || "$agents" == "null" ]] && agents=1
     fi
 
+    # Intelligence: suggest parallelism if design indicates independent work
+    if [[ "${agents:-1}" -le 1 ]] && [[ -s "$ARTIFACTS_DIR/design.md" ]]; then
+        local design_lower
+        design_lower=$(tr '[:upper:]' '[:lower:]' < "$ARTIFACTS_DIR/design.md" 2>/dev/null || true)
+        if echo "$design_lower" | grep -qE 'independent (files|modules|components|services)|separate (modules|packages|directories)|parallel|no shared state'; then
+            info "Design mentions independent modules — consider --agents 2 for parallelism"
+            emit_event "build.parallelism_suggested" "issue=${ISSUE_NUMBER:-0}" "current_agents=$agents"
+        fi
+    fi
+
     local audit
     audit=$(jq -r --arg id "build" '(.stages[] | select(.id == $id) | .config.audit) // false' "$PIPELINE_CONFIG" 2>/dev/null) || true
     local quality
@@ -1547,15 +2245,30 @@ $(cat "$TASKS_FILE")"
         build_model=$(jq -r '.defaults.model // "opus"' "$PIPELINE_CONFIG" 2>/dev/null) || true
         [[ -z "$build_model" || "$build_model" == "null" ]] && build_model="opus"
     fi
+    # Intelligence model routing (when no explicit CLI --model override)
+    if [[ -z "$MODEL" && -n "${CLAUDE_MODEL:-}" ]]; then
+        build_model="$CLAUDE_MODEL"
+    fi
 
     [[ -n "$test_cmd" && "$test_cmd" != "null" ]] && loop_args+=(--test-cmd "$test_cmd")
     loop_args+=(--max-iterations "$max_iter")
     loop_args+=(--model "$build_model")
     [[ "$agents" -gt 1 ]] 2>/dev/null && loop_args+=(--agents "$agents")
-    [[ "$audit" == "true" ]] && loop_args+=(--audit --audit-agent)
-    [[ "$quality" == "true" ]] && loop_args+=(--quality-gates)
+
+    # Quality gates: always enabled in CI, otherwise from template config
+    if [[ "${CI_MODE:-false}" == "true" ]]; then
+        loop_args+=(--audit --audit-agent --quality-gates)
+    else
+        [[ "$audit" == "true" ]] && loop_args+=(--audit --audit-agent)
+        [[ "$quality" == "true" ]] && loop_args+=(--quality-gates)
+    fi
+
+    # Definition of Done: use plan-extracted DoD if available
     [[ -s "$dod_file" ]] && loop_args+=(--definition-of-done "$dod_file")
 
+    # Skip permissions in CI (no interactive terminal)
+    [[ "${CI_MODE:-false}" == "true" ]] && loop_args+=(--skip-permissions)
+
     info "Starting build loop: ${DIM}shipwright loop${RESET} (max ${max_iter} iterations, ${agents} agent(s))"
 
     # Post build start to GitHub
@@ -1564,7 +2277,8 @@ $(cat "$TASKS_FILE")"
     fi
 
     local _token_log="${ARTIFACTS_DIR}/.claude-tokens-build.log"
-    cct loop "${loop_args[@]}" 2>"$_token_log" || {
+    export PIPELINE_JOB_ID="${PIPELINE_NAME:-pipeline-$$}"
+    sw loop "${loop_args[@]}" < /dev/null 2>"$_token_log" || {
         parse_claude_tokens "$_token_log"
         error "Build loop failed"
         return 1
@@ -1576,6 +2290,29 @@ $(cat "$TASKS_FILE")"
     commit_count=$(git log --oneline "${BASE_BRANCH}..HEAD" 2>/dev/null | wc -l | xargs)
     info "Build produced ${BOLD}$commit_count${RESET} commit(s)"
 
+    # Commit quality evaluation when intelligence is enabled
+    if type intelligence_search_memory &>/dev/null 2>&1 && command -v claude &>/dev/null && [[ "${commit_count:-0}" -gt 0 ]]; then
+        local commit_msgs
+        commit_msgs=$(git log --format="%s" "${BASE_BRANCH}..HEAD" 2>/dev/null | head -20)
+        local quality_score
+        quality_score=$(claude --print --output-format text -p "Rate the quality of these git commit messages on a scale of 0-100. Consider: focus (one thing per commit), clarity (describes the why), atomicity (small logical units). Reply with ONLY a number 0-100.
+
+Commit messages:
+${commit_msgs}" --model haiku < /dev/null 2>/dev/null || true)
+        quality_score=$(echo "$quality_score" | grep -oE '^[0-9]+' | head -1 || true)
+        if [[ -n "$quality_score" ]]; then
+            emit_event "build.commit_quality" \
+                "issue=${ISSUE_NUMBER:-0}" \
+                "score=$quality_score" \
+                "commit_count=$commit_count"
+            if [[ "$quality_score" -lt 40 ]] 2>/dev/null; then
+                warn "Commit message quality low (score: ${quality_score}/100)"
+            else
+                info "Commit quality score: ${quality_score}/100"
+            fi
+        fi
+    fi
+
     log_stage "build" "Build loop completed ($commit_count commits)"
 }
 
@@ -1603,34 +2340,53 @@ stage_test() {
 
     info "Running tests: ${DIM}$test_cmd${RESET}"
     local test_exit=0
-    eval "$test_cmd" > "$test_log" 2>&1 || test_exit=$?
+    bash -c "$test_cmd" > "$test_log" 2>&1 || test_exit=$?
 
     if [[ "$test_exit" -eq 0 ]]; then
         success "Tests passed"
     else
         error "Tests failed (exit code: $test_exit)"
-        tail -20 "$test_log"
+        # Extract most relevant error section (assertion failures, stack traces)
+        local relevant_output=""
+        relevant_output=$(grep -A5 -E 'FAIL|AssertionError|Expected.*but.*got|Error:|panic:|assert' "$test_log" 2>/dev/null | tail -40 || true)
+        if [[ -z "$relevant_output" ]]; then
+            relevant_output=$(tail -40 "$test_log")
+        fi
+        echo "$relevant_output"
 
-        # Post failure to GitHub
+        # Post failure to GitHub with more context
         if [[ -n "$ISSUE_NUMBER" ]]; then
-            gh_comment_issue "$ISSUE_NUMBER" "❌ **Tests failed**
+            local log_lines
+            log_lines=$(wc -l < "$test_log" 2>/dev/null || echo "0")
+            local log_excerpt
+            if [[ "$log_lines" -lt 60 ]]; then
+                log_excerpt="$(cat "$test_log" 2>/dev/null || true)"
+            else
+                log_excerpt="$(head -20 "$test_log" 2>/dev/null || true)
+... (${log_lines} lines total, showing head + tail) ...
+$(tail -30 "$test_log" 2>/dev/null || true)"
+            fi
+            gh_comment_issue "$ISSUE_NUMBER" "❌ **Tests failed** (exit code: $test_exit, ${log_lines} lines)
 \`\`\`
-$(tail -20 "$test_log")
+${log_excerpt}
 \`\`\`"
         fi
         return 1
     fi
 
-    # Coverage check
+    # Coverage check — only enforce when coverage data is actually detected
     local coverage=""
     if [[ "$coverage_min" -gt 0 ]] 2>/dev/null; then
-        coverage=$(grep -oE 'Statements\s*:\s*[0-9.]+' "$test_log" 2>/dev/null | grep -oE '[0-9.]+$' || \
-                   grep -oE 'All files\s*\|\s*[0-9.]+' "$test_log" 2>/dev/null | grep -oE '[0-9.]+$' || echo "0")
-        if awk -v cov="$coverage" -v min="$coverage_min" 'BEGIN{exit !(cov < min)}' 2>/dev/null; then
+        coverage=$(parse_coverage_from_output "$test_log")
+        if [[ -z "$coverage" ]]; then
+            # No coverage data found — skip enforcement (project may not have coverage tooling)
+            info "No coverage data detected — skipping coverage check (min: ${coverage_min}%)"
+        elif awk -v cov="$coverage" -v min="$coverage_min" 'BEGIN{exit !(cov < min)}' 2>/dev/null; then
             warn "Coverage ${coverage}% below minimum ${coverage_min}%"
             return 1
+        else
+            info "Coverage: ${coverage}% (min: ${coverage_min}%)"
         fi
-        info "Coverage: ${coverage}% (min: ${coverage_min}%)"
     fi
 
     # Post test results to GitHub
@@ -1675,10 +2431,34 @@ stage_review() {
     diff_stats=$(git diff --stat "${BASE_BRANCH}...${GIT_BRANCH}" 2>/dev/null | tail -1 || echo "")
     info "Running AI code review... ${DIM}($diff_stats)${RESET}"
 
+    # Semantic risk scoring when intelligence is enabled
+    if type intelligence_search_memory &>/dev/null 2>&1 && command -v claude &>/dev/null; then
+        local diff_files
+        diff_files=$(git diff --name-only "${BASE_BRANCH}...${GIT_BRANCH}" 2>/dev/null || true)
+        local risk_score="low"
+        # Fast heuristic: flag high-risk file patterns
+        if echo "$diff_files" | grep -qiE 'migration|schema|auth|crypto|security|password|token|secret|\.env'; then
+            risk_score="high"
+        elif echo "$diff_files" | grep -qiE 'api|route|controller|middleware|hook'; then
+            risk_score="medium"
+        fi
+        emit_event "review.risk_assessed" \
+            "issue=${ISSUE_NUMBER:-0}" \
+            "risk=$risk_score" \
+            "files_changed=$(echo "$diff_files" | wc -l | xargs)"
+        if [[ "$risk_score" == "high" ]]; then
+            warn "High-risk changes detected (DB schema, auth, crypto, or secrets)"
+        fi
+    fi
+
     local review_model="${MODEL:-opus}"
+    # Intelligence model routing (when no explicit CLI --model override)
+    if [[ -z "$MODEL" && -n "${CLAUDE_MODEL:-}" ]]; then
+        review_model="$CLAUDE_MODEL"
+    fi
 
-    claude --print --model "$review_model" --max-turns 15 \
-        "You are a senior code reviewer. Review this git diff thoroughly.
+    # Build review prompt with project context
+    local review_prompt="You are a senior code reviewer. Review this git diff thoroughly.
 
 For each issue found, use this format:
 - **[SEVERITY]** file:line — description
@@ -1691,24 +2471,102 @@ Focus on:
 3. Error handling gaps
 4. Performance issues
 5. Missing validation
+6. Project convention violations (see conventions below)
 
 Be specific. Reference exact file paths and line numbers. Only flag genuine issues.
+If no issues are found, write: \"Review clean — no issues found.\"
+"
+
+    # Inject previous review findings and anti-patterns from memory
+    if type intelligence_search_memory &>/dev/null 2>&1; then
+        local review_memory
+        review_memory=$(intelligence_search_memory "code review findings anti-patterns for: ${GOAL:-}" "${HOME}/.shipwright/memory" 5 2>/dev/null) || true
+        if [[ -n "$review_memory" ]]; then
+            review_prompt+="
+## Known Issues from Previous Reviews
+These anti-patterns and issues have been found in past reviews of this codebase. Flag them if they recur:
+${review_memory}
+"
+        fi
+    fi
+
+    # Inject project conventions if CLAUDE.md exists
+    local claudemd="$PROJECT_ROOT/.claude/CLAUDE.md"
+    if [[ -f "$claudemd" ]]; then
+        local conventions
+        conventions=$(grep -A2 'Common Pitfalls\|Shell Standards\|Bash 3.2' "$claudemd" 2>/dev/null | head -20 || true)
+        if [[ -n "$conventions" ]]; then
+            review_prompt+="
+## Project Conventions
+${conventions}
+"
+        fi
+    fi
+
+    # Inject CODEOWNERS focus areas for review
+    if [[ "${NO_GITHUB:-}" != "true" ]] && type gh_codeowners &>/dev/null 2>&1; then
+        local review_owners
+        review_owners=$(gh_codeowners 2>/dev/null | head -10 || true)
+        if [[ -n "$review_owners" ]]; then
+            review_prompt+="
+## Code Owners (focus areas)
+${review_owners}
+"
+        fi
+    fi
+
+    # Inject Definition of Done if present
+    local dod_file="$PROJECT_ROOT/.claude/DEFINITION-OF-DONE.md"
+    if [[ -f "$dod_file" ]]; then
+        review_prompt+="
+## Definition of Done (verify these)
+$(cat "$dod_file")
+"
+    fi
+
+    review_prompt+="
+## Diff to Review
+$(cat "$diff_file")"
+
+    # Build claude args — add --dangerously-skip-permissions in CI
+    local review_args=(--print --model "$review_model" --max-turns 25)
+    if [[ "${CI_MODE:-false}" == "true" ]]; then
+        review_args+=(--dangerously-skip-permissions)
+    fi
 
-$(cat "$diff_file")" > "$review_file" 2>"${ARTIFACTS_DIR}/.claude-tokens-review.log" || true
+    claude "${review_args[@]}" "$review_prompt" < /dev/null > "$review_file" 2>"${ARTIFACTS_DIR}/.claude-tokens-review.log" || true
     parse_claude_tokens "${ARTIFACTS_DIR}/.claude-tokens-review.log"
 
     if [[ ! -s "$review_file" ]]; then
-        warn "Review produced no output"
+        warn "Review produced no output — check ${ARTIFACTS_DIR}/.claude-tokens-review.log for errors"
         return 0
     fi
 
-    local critical_count bug_count warning_count
-    critical_count=$(grep -ciE '\*\*\[?Critical\]?\*\*' "$review_file" 2>/dev/null || true)
-    critical_count="${critical_count:-0}"
-    bug_count=$(grep -ciE '\*\*\[?(Bug|Security)\]?\*\*' "$review_file" 2>/dev/null || true)
-    bug_count="${bug_count:-0}"
-    warning_count=$(grep -ciE '\*\*\[?(Warning|Suggestion)\]?\*\*' "$review_file" 2>/dev/null || true)
-    warning_count="${warning_count:-0}"
+    # Extract severity counts — try JSON structure first, then grep fallback
+    local critical_count=0 bug_count=0 warning_count=0
+
+    # Check if review output is structured JSON (e.g. from structured review tools)
+    local json_parsed=false
+    if head -1 "$review_file" 2>/dev/null | grep -q '^{' 2>/dev/null; then
+        local j_critical j_bug j_warning
+        j_critical=$(jq -r '.issues | map(select(.severity == "Critical")) | length' "$review_file" 2>/dev/null || echo "")
+        if [[ -n "$j_critical" && "$j_critical" != "null" ]]; then
+            critical_count="$j_critical"
+            bug_count=$(jq -r '.issues | map(select(.severity == "Bug" or .severity == "Security")) | length' "$review_file" 2>/dev/null || echo "0")
+            warning_count=$(jq -r '.issues | map(select(.severity == "Warning" or .severity == "Suggestion")) | length' "$review_file" 2>/dev/null || echo "0")
+            json_parsed=true
+        fi
+    fi
+
+    # Grep fallback for markdown-formatted review output
+    if [[ "$json_parsed" != "true" ]]; then
+        critical_count=$(grep -ciE '\*\*\[?Critical\]?\*\*' "$review_file" 2>/dev/null || true)
+        critical_count="${critical_count:-0}"
+        bug_count=$(grep -ciE '\*\*\[?(Bug|Security)\]?\*\*' "$review_file" 2>/dev/null || true)
+        bug_count="${bug_count:-0}"
+        warning_count=$(grep -ciE '\*\*\[?(Warning|Suggestion)\]?\*\*' "$review_file" 2>/dev/null || true)
+        warning_count="${warning_count:-0}"
+    fi
     local total_issues=$((critical_count + bug_count + warning_count))
 
     if [[ "$critical_count" -gt 0 ]]; then
@@ -1721,6 +2579,68 @@ $(cat "$diff_file")" > "$review_file" 2>"${ARTIFACTS_DIR}/.claude-tokens-review.
         success "Review clean"
     fi
 
+    # ── Review Blocking Gate ──
+    # Block pipeline on critical/security issues unless compound_quality handles them
+    local security_count
+    security_count=$(grep -ciE '\*\*\[?Security\]?\*\*' "$review_file" 2>/dev/null || true)
+    security_count="${security_count:-0}"
+
+    local blocking_issues=$((critical_count + security_count))
+
+    if [[ "$blocking_issues" -gt 0 ]]; then
+        # Check if compound_quality stage is enabled — if so, let it handle issues
+        local compound_enabled="false"
+        if [[ -n "${PIPELINE_CONFIG:-}" && -f "${PIPELINE_CONFIG:-/dev/null}" ]]; then
+            compound_enabled=$(jq -r '.stages[] | select(.id == "compound_quality") | .enabled' "$PIPELINE_CONFIG" 2>/dev/null) || true
+            [[ -z "$compound_enabled" || "$compound_enabled" == "null" ]] && compound_enabled="false"
+        fi
+
+        # Check if this is a fast template (don't block fast pipelines)
+        local is_fast="false"
+        if [[ "${PIPELINE_NAME:-}" == "fast" || "${PIPELINE_NAME:-}" == "hotfix" ]]; then
+            is_fast="true"
+        fi
+
+        if [[ "$compound_enabled" == "true" ]]; then
+            info "Review found ${blocking_issues} critical/security issue(s) — compound_quality stage will handle"
+        elif [[ "$is_fast" == "true" ]]; then
+            warn "Review found ${blocking_issues} critical/security issue(s) — fast template, not blocking"
+        elif [[ "${SKIP_GATES:-false}" == "true" ]]; then
+            warn "Review found ${blocking_issues} critical/security issue(s) — skip-gates mode, not blocking"
+        else
+            error "Review found ${BOLD}${blocking_issues} critical/security issue(s)${RESET} — blocking pipeline"
+            emit_event "review.blocked" \
+                "issue=${ISSUE_NUMBER:-0}" \
+                "critical=${critical_count}" \
+                "security=${security_count}"
+
+            # Save blocking issues for self-healing context
+            grep -iE '\*\*\[?(Critical|Security)\]?\*\*' "$review_file" > "$ARTIFACTS_DIR/review-blockers.md" 2>/dev/null || true
+
+            # Post review to GitHub before failing
+            if [[ -n "$ISSUE_NUMBER" ]]; then
+                local review_summary
+                review_summary=$(head -40 "$review_file")
+                gh_comment_issue "$ISSUE_NUMBER" "## 🔍 Code Review — ❌ Blocked
+
+**Stats:** $diff_stats
+**Blocking issues:** ${blocking_issues} (${critical_count} critical, ${security_count} security)
+
+<details>
+<summary>Review details</summary>
+
+${review_summary}
+
+</details>
+
+_Pipeline will attempt self-healing rebuild._"
+            fi
+
+            log_stage "review" "BLOCKED: $blocking_issues critical/security issues found"
+            return 1
+        fi
+    fi
+
     # Post review to GitHub issue
     if [[ -n "$ISSUE_NUMBER" ]]; then
         local review_summary
@@ -1747,6 +2667,47 @@ stage_pr() {
     local test_log="$ARTIFACTS_DIR/test-results.log"
     local review_file="$ARTIFACTS_DIR/review.md"
 
+    # ── PR Hygiene Checks (informational) ──
+    local hygiene_commit_count
+    hygiene_commit_count=$(git log --oneline "${BASE_BRANCH}..HEAD" 2>/dev/null | wc -l | xargs)
+    hygiene_commit_count="${hygiene_commit_count:-0}"
+
+    if [[ "$hygiene_commit_count" -gt 20 ]]; then
+        warn "PR has ${hygiene_commit_count} commits — consider squashing before merge"
+    fi
+
+    # Check for WIP/fixup/squash commits (expanded patterns)
+    local wip_commits
+    wip_commits=$(git log --oneline "${BASE_BRANCH}..HEAD" 2>/dev/null | grep -ciE '^[0-9a-f]+ (WIP|fixup!|squash!|TODO|HACK|TEMP|BROKEN|wip[:-]|temp[:-]|broken[:-]|do not merge)' || true)
+    wip_commits="${wip_commits:-0}"
+    if [[ "$wip_commits" -gt 0 ]]; then
+        warn "Branch has ${wip_commits} WIP/fixup/squash/temp commit(s) — consider cleaning up"
+    fi
+
+    # ── PR Quality Gate: reject PRs with no real code changes ──
+    local real_files
+    real_files=$(git diff --name-only "${BASE_BRANCH}...HEAD" 2>/dev/null | grep -v '^\.claude/' | grep -v '^\.github/' || true)
+    if [[ -z "$real_files" ]]; then
+        error "No real code changes detected — only pipeline artifacts (.claude/ logs)."
+        error "The build agent did not produce meaningful changes. Skipping PR creation."
+        emit_event "pr.rejected" "issue=${ISSUE_NUMBER:-0}" "reason=no_real_changes"
+        # Mark issue so auto-retry knows not to retry empty builds
+        if [[ -n "${ISSUE_NUMBER:-}" && "${ISSUE_NUMBER:-0}" != "0" ]]; then
+            gh issue comment "$ISSUE_NUMBER" --body "<!-- SHIPWRIGHT-NO-CHANGES: true -->" 2>/dev/null || true
+        fi
+        return 1
+    fi
+    local real_file_count
+    real_file_count=$(echo "$real_files" | wc -l | xargs)
+    info "PR quality gate: ${real_file_count} real file(s) changed"
+
+    # Commit any uncommitted changes left by the build agent
+    if ! git diff --quiet 2>/dev/null || ! git diff --cached --quiet 2>/dev/null; then
+        info "Committing remaining uncommitted changes..."
+        git add -A 2>/dev/null || true
+        git commit -m "chore: pipeline cleanup — commit remaining build changes" --no-verify 2>/dev/null || true
+    fi
+
     # Auto-rebase onto latest base branch before PR
     auto_rebase || {
         warn "Rebase/merge failed — pushing as-is"
@@ -1762,27 +2723,105 @@ stage_pr() {
         }
     }
 
-    # Build PR title
-    local pr_title
-    pr_title=$(head -1 "$plan_file" 2>/dev/null | sed 's/^#* *//' | cut -c1-70)
-    [[ -z "$pr_title" ]] && pr_title="$GOAL"
-
-    # Build comprehensive PR body
-    local plan_summary=""
-    if [[ -s "$plan_file" ]]; then
-        plan_summary=$(head -20 "$plan_file" 2>/dev/null | tail -15)
-    fi
-
-    local test_summary=""
-    if [[ -s "$test_log" ]]; then
-        test_summary=$(tail -10 "$test_log")
+    # ── Developer Simulation (pre-PR review) ──
+    local simulation_summary=""
+    if type simulation_review &>/dev/null 2>&1; then
+        local sim_enabled
+        sim_enabled=$(jq -r '.intelligence.simulation_enabled // false' "$PIPELINE_CONFIG" 2>/dev/null || echo "false")
+        # Also check daemon-config
+        local daemon_cfg=".claude/daemon-config.json"
+        if [[ "$sim_enabled" != "true" && -f "$daemon_cfg" ]]; then
+            sim_enabled=$(jq -r '.intelligence.simulation_enabled // false' "$daemon_cfg" 2>/dev/null || echo "false")
+        fi
+        if [[ "$sim_enabled" == "true" ]]; then
+            info "Running developer simulation review..."
+            local diff_for_sim
+            diff_for_sim=$(git diff "${BASE_BRANCH}...HEAD" 2>/dev/null || true)
+            if [[ -n "$diff_for_sim" ]]; then
+                local sim_result
+                sim_result=$(simulation_review "$diff_for_sim" "${GOAL:-}" 2>/dev/null || echo "")
+                if [[ -n "$sim_result" && "$sim_result" != *'"error"'* ]]; then
+                    echo "$sim_result" > "$ARTIFACTS_DIR/simulation-review.json"
+                    local sim_count
+                    sim_count=$(echo "$sim_result" | jq 'length' 2>/dev/null || echo "0")
+                    simulation_summary="**Developer simulation:** ${sim_count} reviewer concerns pre-addressed"
+                    success "Simulation complete: ${sim_count} concerns found and addressed"
+                    emit_event "simulation.complete" "issue=${ISSUE_NUMBER:-0}" "concerns=${sim_count}"
+                else
+                    info "Simulation returned no actionable concerns"
+                fi
+            fi
+        fi
+    fi
+
+    # ── Architecture Validation (pre-PR check) ──
+    local arch_summary=""
+    if type architecture_validate_changes &>/dev/null 2>&1; then
+        local arch_enabled
+        arch_enabled=$(jq -r '.intelligence.architecture_enabled // false' "$PIPELINE_CONFIG" 2>/dev/null || echo "false")
+        local daemon_cfg=".claude/daemon-config.json"
+        if [[ "$arch_enabled" != "true" && -f "$daemon_cfg" ]]; then
+            arch_enabled=$(jq -r '.intelligence.architecture_enabled // false' "$daemon_cfg" 2>/dev/null || echo "false")
+        fi
+        if [[ "$arch_enabled" == "true" ]]; then
+            info "Validating architecture..."
+            local diff_for_arch
+            diff_for_arch=$(git diff "${BASE_BRANCH}...HEAD" 2>/dev/null || true)
+            if [[ -n "$diff_for_arch" ]]; then
+                local arch_result
+                arch_result=$(architecture_validate_changes "$diff_for_arch" "" 2>/dev/null || echo "")
+                if [[ -n "$arch_result" && "$arch_result" != *'"error"'* ]]; then
+                    echo "$arch_result" > "$ARTIFACTS_DIR/architecture-validation.json"
+                    local violation_count
+                    violation_count=$(echo "$arch_result" | jq '[.violations[]? | select(.severity == "critical" or .severity == "high")] | length' 2>/dev/null || echo "0")
+                    arch_summary="**Architecture validation:** ${violation_count} violations"
+                    if [[ "$violation_count" -gt 0 ]]; then
+                        warn "Architecture: ${violation_count} high/critical violations found"
+                    else
+                        success "Architecture validation passed"
+                    fi
+                    emit_event "architecture.validated" "issue=${ISSUE_NUMBER:-0}" "violations=${violation_count}"
+                else
+                    info "Architecture validation returned no results"
+                fi
+            fi
+        fi
+    fi
+
+    # Build PR title — prefer GOAL over plan file first line
+    # (plan file first line often contains Claude analysis text, not a clean title)
+    local pr_title=""
+    if [[ -n "${GOAL:-}" ]]; then
+        pr_title=$(echo "$GOAL" | cut -c1-70)
+    fi
+    if [[ -z "$pr_title" ]] && [[ -s "$plan_file" ]]; then
+        pr_title=$(head -1 "$plan_file" 2>/dev/null | sed 's/^#* *//' | cut -c1-70)
+    fi
+    [[ -z "$pr_title" ]] && pr_title="Pipeline changes for issue ${ISSUE_NUMBER:-unknown}"
+
+    # Build comprehensive PR body
+    local plan_summary=""
+    if [[ -s "$plan_file" ]]; then
+        plan_summary=$(head -20 "$plan_file" 2>/dev/null | tail -15)
+    fi
+
+    local test_summary=""
+    if [[ -s "$test_log" ]]; then
+        test_summary=$(tail -10 "$test_log")
     fi
 
     local review_summary=""
     if [[ -s "$review_file" ]]; then
-        local total_issues
-        total_issues=$(grep -ciE '\*\*\[?(Critical|Bug|Security|Warning|Suggestion)\]?\*\*' "$review_file" 2>/dev/null || true)
-        total_issues="${total_issues:-0}"
+        local total_issues=0
+        # Try JSON structured output first
+        if head -1 "$review_file" 2>/dev/null | grep -q '^{' 2>/dev/null; then
+            total_issues=$(jq -r '.issues | length' "$review_file" 2>/dev/null || echo "0")
+        fi
+        # Grep fallback for markdown
+        if [[ "${total_issues:-0}" -eq 0 ]]; then
+            total_issues=$(grep -ciE '\*\*\[?(Critical|Bug|Security|Warning|Suggestion)\]?\*\*' "$review_file" 2>/dev/null || true)
+            total_issues="${total_issues:-0}"
+        fi
         review_summary="**Code review:** $total_issues issues found"
     fi
 
@@ -1815,6 +2854,8 @@ ${test_summary:-No test output}
 \`\`\`
 
 ${review_summary}
+${simulation_summary}
+${arch_summary}
 
 ${closes_line}
 
@@ -1863,12 +2904,35 @@ EOF
         info "Milestone: ${DIM}$ISSUE_MILESTONE${RESET}"
     fi
 
-    info "Creating PR..."
-    local pr_url
-    pr_url=$(gh pr create "${pr_args[@]}" 2>&1) || {
-        error "PR creation failed: $pr_url"
-        return 1
-    }
+    # Check for existing open PR on this branch to avoid duplicates (issue #12)
+    local pr_url=""
+    local existing_pr
+    existing_pr=$(gh pr list --head "$GIT_BRANCH" --state open --json number,url --jq '.[0]' 2>/dev/null || echo "")
+    if [[ -n "$existing_pr" && "$existing_pr" != "null" ]]; then
+        local existing_pr_number existing_pr_url
+        existing_pr_number=$(echo "$existing_pr" | jq -r '.number' 2>/dev/null || echo "")
+        existing_pr_url=$(echo "$existing_pr" | jq -r '.url' 2>/dev/null || echo "")
+        info "Updating existing PR #$existing_pr_number instead of creating duplicate"
+        gh pr edit "$existing_pr_number" --title "$pr_title" --body "$pr_body" 2>/dev/null || true
+        pr_url="$existing_pr_url"
+    else
+        info "Creating PR..."
+        local pr_stderr pr_exit=0
+        pr_url=$(gh pr create "${pr_args[@]}" 2>/tmp/shipwright-pr-stderr.txt) || pr_exit=$?
+        pr_stderr=$(cat /tmp/shipwright-pr-stderr.txt 2>/dev/null || true)
+        rm -f /tmp/shipwright-pr-stderr.txt
+
+        # gh pr create may return non-zero for reviewer issues but still create the PR
+        if [[ "$pr_exit" -ne 0 ]]; then
+            if [[ "$pr_url" == *"github.com"* ]]; then
+                # PR was created but something non-fatal failed (e.g., reviewer not found)
+                warn "PR created with warnings: ${pr_stderr:-unknown}"
+            else
+                error "PR creation failed: ${pr_stderr:-$pr_url}"
+                return 1
+            fi
+        fi
+    fi
 
     success "PR created: ${BOLD}$pr_url${RESET}"
     echo "$pr_url" > "$ARTIFACTS_DIR/pr-url.txt"
@@ -1876,6 +2940,54 @@ EOF
     # Extract PR number
     PR_NUMBER=$(echo "$pr_url" | grep -oE '[0-9]+$' || true)
 
+    # ── Intelligent Reviewer Selection (GraphQL-enhanced) ──
+    if [[ "${NO_GITHUB:-false}" != "true" && -n "$PR_NUMBER" && -z "$reviewers" ]]; then
+        local reviewer_assigned=false
+
+        # Try CODEOWNERS-based routing via GraphQL API
+        if type gh_codeowners &>/dev/null 2>&1 && [[ -n "$REPO_OWNER" && -n "$REPO_NAME" ]]; then
+            local codeowners_json
+            codeowners_json=$(gh_codeowners "$REPO_OWNER" "$REPO_NAME" 2>/dev/null || echo "[]")
+            if [[ "$codeowners_json" != "[]" && -n "$codeowners_json" ]]; then
+                local changed_files
+                changed_files=$(git diff --name-only "${BASE_BRANCH}...HEAD" 2>/dev/null || true)
+                if [[ -n "$changed_files" ]]; then
+                    local co_reviewers
+                    co_reviewers=$(echo "$codeowners_json" | jq -r '.[].owners[]' 2>/dev/null | sort -u | head -3 || true)
+                    if [[ -n "$co_reviewers" ]]; then
+                        local rev
+                        while IFS= read -r rev; do
+                            rev="${rev#@}"
+                            [[ -n "$rev" ]] && gh pr edit "$PR_NUMBER" --add-reviewer "$rev" 2>/dev/null || true
+                        done <<< "$co_reviewers"
+                        info "Requested review from CODEOWNERS: $(echo "$co_reviewers" | tr '\n' ',' | sed 's/,$//')"
+                        reviewer_assigned=true
+                    fi
+                fi
+            fi
+        fi
+
+        # Fallback: contributor-based routing via GraphQL API
+        if [[ "$reviewer_assigned" != "true" ]] && type gh_contributors &>/dev/null 2>&1 && [[ -n "$REPO_OWNER" && -n "$REPO_NAME" ]]; then
+            local contributors_json
+            contributors_json=$(gh_contributors "$REPO_OWNER" "$REPO_NAME" 2>/dev/null || echo "[]")
+            local top_contributor
+            top_contributor=$(echo "$contributors_json" | jq -r '.[0].login // ""' 2>/dev/null || echo "")
+            local current_user
+            current_user=$(gh api user --jq '.login' 2>/dev/null || echo "")
+            if [[ -n "$top_contributor" && "$top_contributor" != "$current_user" ]]; then
+                gh pr edit "$PR_NUMBER" --add-reviewer "$top_contributor" 2>/dev/null || true
+                info "Requested review from top contributor: $top_contributor"
+                reviewer_assigned=true
+            fi
+        fi
+
+        # Final fallback: auto-approve if no reviewers assigned
+        if [[ "$reviewer_assigned" != "true" ]]; then
+            gh pr review "$PR_NUMBER" --approve 2>/dev/null || warn "Could not auto-approve PR"
+        fi
+    fi
+
     # Update issue with PR link
     if [[ -n "$ISSUE_NUMBER" ]]; then
         gh_remove_label "$ISSUE_NUMBER" "pipeline/in-progress"
@@ -1883,6 +2995,9 @@ EOF
         gh_comment_issue "$ISSUE_NUMBER" "🎉 **PR created:** ${pr_url}
 
 Pipeline duration so far: ${total_dur:-unknown}"
+
+        # Notify tracker of review/PR creation
+        "$SCRIPT_DIR/sw-tracker.sh" notify "review" "$ISSUE_NUMBER" "$pr_url" 2>/dev/null || true
     fi
 
     # Wait for CI if configured
@@ -1904,11 +3019,69 @@ stage_merge() {
         return 0
     fi
 
+    # ── Branch Protection Check ──
+    if type gh_branch_protection &>/dev/null 2>&1 && [[ -n "$REPO_OWNER" && -n "$REPO_NAME" ]]; then
+        local protection_json
+        protection_json=$(gh_branch_protection "$REPO_OWNER" "$REPO_NAME" "${BASE_BRANCH:-main}" 2>/dev/null || echo '{"protected": false}')
+        local is_protected
+        is_protected=$(echo "$protection_json" | jq -r '.protected // false' 2>/dev/null || echo "false")
+        if [[ "$is_protected" == "true" ]]; then
+            local required_reviews
+            required_reviews=$(echo "$protection_json" | jq -r '.required_pull_request_reviews.required_approving_review_count // 0' 2>/dev/null || echo "0")
+            local required_checks
+            required_checks=$(echo "$protection_json" | jq -r '[.required_status_checks.contexts // [] | .[]] | length' 2>/dev/null || echo "0")
+
+            info "Branch protection: ${required_reviews} required review(s), ${required_checks} required check(s)"
+
+            if [[ "$required_reviews" -gt 0 ]]; then
+                # Check if PR has enough approvals
+                local prot_pr_number
+                prot_pr_number=$(gh pr list --head "$GIT_BRANCH" --json number --jq '.[0].number' 2>/dev/null || echo "")
+                if [[ -n "$prot_pr_number" ]]; then
+                    local approvals
+                    approvals=$(gh pr view "$prot_pr_number" --json reviews --jq '[.reviews[] | select(.state == "APPROVED")] | length' 2>/dev/null || echo "0")
+                    if [[ "$approvals" -lt "$required_reviews" ]]; then
+                        warn "PR has $approvals approval(s), needs $required_reviews — skipping auto-merge"
+                        info "PR is ready for manual merge after required reviews"
+                        emit_event "merge.blocked" "issue=${ISSUE_NUMBER:-0}" "reason=insufficient_reviews" "have=$approvals" "need=$required_reviews"
+                        return 0
+                    fi
+                fi
+            fi
+        fi
+    fi
+
     local merge_method wait_ci_timeout auto_delete_branch auto_merge auto_approve merge_strategy
     merge_method=$(jq -r --arg id "merge" '(.stages[] | select(.id == $id) | .config.merge_method) // "squash"' "$PIPELINE_CONFIG" 2>/dev/null) || true
     [[ -z "$merge_method" || "$merge_method" == "null" ]] && merge_method="squash"
-    wait_ci_timeout=$(jq -r --arg id "merge" '(.stages[] | select(.id == $id) | .config.wait_ci_timeout_s) // 600' "$PIPELINE_CONFIG" 2>/dev/null) || true
-    [[ -z "$wait_ci_timeout" || "$wait_ci_timeout" == "null" ]] && wait_ci_timeout=600
+    wait_ci_timeout=$(jq -r --arg id "merge" '(.stages[] | select(.id == $id) | .config.wait_ci_timeout_s) // 0' "$PIPELINE_CONFIG" 2>/dev/null) || true
+    [[ -z "$wait_ci_timeout" || "$wait_ci_timeout" == "null" ]] && wait_ci_timeout=0
+
+    # Adaptive CI timeout: 90th percentile of historical times × 1.5 safety margin
+    if [[ "$wait_ci_timeout" -eq 0 ]] 2>/dev/null; then
+        local repo_hash_ci
+        repo_hash_ci=$(echo -n "$PROJECT_ROOT" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown")
+        local ci_times_file="${HOME}/.shipwright/baselines/${repo_hash_ci}/ci-times.json"
+        if [[ -f "$ci_times_file" ]]; then
+            local p90_time
+            p90_time=$(jq '
+                .times | sort |
+                (length * 0.9 | floor) as $idx |
+                .[$idx] // 600
+            ' "$ci_times_file" 2>/dev/null || echo "0")
+            if [[ -n "$p90_time" ]] && awk -v t="$p90_time" 'BEGIN{exit !(t > 0)}' 2>/dev/null; then
+                # 1.5x safety margin, clamped to [120, 1800]
+                wait_ci_timeout=$(awk -v p90="$p90_time" 'BEGIN{
+                    t = p90 * 1.5;
+                    if (t < 120) t = 120;
+                    if (t > 1800) t = 1800;
+                    printf "%d", t
+                }')
+            fi
+        fi
+        # Default fallback if no history
+        [[ "$wait_ci_timeout" -eq 0 ]] && wait_ci_timeout=600
+    fi
     auto_delete_branch=$(jq -r --arg id "merge" '(.stages[] | select(.id == $id) | .config.auto_delete_branch) // "true"' "$PIPELINE_CONFIG" 2>/dev/null) || true
     [[ -z "$auto_delete_branch" || "$auto_delete_branch" == "null" ]] && auto_delete_branch="true"
     auto_merge=$(jq -r --arg id "merge" '(.stages[] | select(.id == $id) | .config.auto_merge) // false' "$PIPELINE_CONFIG" 2>/dev/null) || true
@@ -1958,6 +3131,26 @@ stage_merge() {
         elapsed=$((elapsed + check_interval))
     done
 
+    # Record CI wait time for adaptive timeout calculation
+    if [[ "$elapsed" -gt 0 ]]; then
+        local repo_hash_ci_rec
+        repo_hash_ci_rec=$(echo -n "$PROJECT_ROOT" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown")
+        local ci_times_dir="${HOME}/.shipwright/baselines/${repo_hash_ci_rec}"
+        local ci_times_rec_file="${ci_times_dir}/ci-times.json"
+        mkdir -p "$ci_times_dir"
+        local ci_history="[]"
+        if [[ -f "$ci_times_rec_file" ]]; then
+            ci_history=$(jq '.times // []' "$ci_times_rec_file" 2>/dev/null || echo "[]")
+        fi
+        local updated_ci
+        updated_ci=$(echo "$ci_history" | jq --arg t "$elapsed" '. + [($t | tonumber)] | .[-20:]' 2>/dev/null || echo "[$elapsed]")
+        local tmp_ci
+        tmp_ci=$(mktemp "${ci_times_dir}/ci-times.json.XXXXXX")
+        jq -n --argjson times "$updated_ci" --arg updated "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+            '{times: $times, updated: $updated}' > "$tmp_ci" 2>/dev/null
+        mv "$tmp_ci" "$ci_times_rec_file" 2>/dev/null || true
+    fi
+
     if [[ "$elapsed" -ge "$wait_ci_timeout" ]]; then
         warn "CI check timeout (${wait_ci_timeout}s) — proceeding with merge anyway"
     fi
@@ -2026,6 +3219,16 @@ stage_deploy() {
         return 0
     fi
 
+    # Create GitHub deployment tracking
+    local gh_deploy_env="production"
+    [[ -n "$staging_cmd" && -z "$prod_cmd" ]] && gh_deploy_env="staging"
+    if [[ "${NO_GITHUB:-false}" != "true" ]] && type gh_deploy_pipeline_start &>/dev/null 2>&1; then
+        if [[ -n "$REPO_OWNER" && -n "$REPO_NAME" ]]; then
+            gh_deploy_pipeline_start "$REPO_OWNER" "$REPO_NAME" "${GIT_BRANCH:-HEAD}" "$gh_deploy_env" 2>/dev/null || true
+            info "GitHub Deployment: tracking as $gh_deploy_env"
+        fi
+    fi
+
     # Post deploy start to GitHub
     if [[ -n "$ISSUE_NUMBER" ]]; then
         gh_comment_issue "$ISSUE_NUMBER" "🚀 **Deploy started**"
@@ -2033,9 +3236,13 @@ stage_deploy() {
 
     if [[ -n "$staging_cmd" ]]; then
         info "Deploying to staging..."
-        eval "$staging_cmd" > "$ARTIFACTS_DIR/deploy-staging.log" 2>&1 || {
+        bash -c "$staging_cmd" > "$ARTIFACTS_DIR/deploy-staging.log" 2>&1 || {
             error "Staging deploy failed"
             [[ -n "$ISSUE_NUMBER" ]] && gh_comment_issue "$ISSUE_NUMBER" "❌ Staging deploy failed"
+            # Mark GitHub deployment as failed
+            if [[ "${NO_GITHUB:-false}" != "true" ]] && type gh_deploy_pipeline_complete &>/dev/null 2>&1; then
+                gh_deploy_pipeline_complete "$REPO_OWNER" "$REPO_NAME" "$gh_deploy_env" false "Staging deploy failed" 2>/dev/null || true
+            fi
             return 1
         }
         success "Staging deploy complete"
@@ -2043,13 +3250,17 @@ stage_deploy() {
 
     if [[ -n "$prod_cmd" ]]; then
         info "Deploying to production..."
-        eval "$prod_cmd" > "$ARTIFACTS_DIR/deploy-prod.log" 2>&1 || {
+        bash -c "$prod_cmd" > "$ARTIFACTS_DIR/deploy-prod.log" 2>&1 || {
             error "Production deploy failed"
             if [[ -n "$rollback_cmd" ]]; then
                 warn "Rolling back..."
-                eval "$rollback_cmd" 2>&1 || error "Rollback also failed!"
+                bash -c "$rollback_cmd" 2>&1 || error "Rollback also failed!"
             fi
             [[ -n "$ISSUE_NUMBER" ]] && gh_comment_issue "$ISSUE_NUMBER" "❌ Production deploy failed — rollback ${rollback_cmd:+attempted}"
+            # Mark GitHub deployment as failed
+            if [[ "${NO_GITHUB:-false}" != "true" ]] && type gh_deploy_pipeline_complete &>/dev/null 2>&1; then
+                gh_deploy_pipeline_complete "$REPO_OWNER" "$REPO_NAME" "$gh_deploy_env" false "Production deploy failed" 2>/dev/null || true
+            fi
             return 1
         }
         success "Production deploy complete"
@@ -2060,6 +3271,13 @@ stage_deploy() {
         gh_add_labels "$ISSUE_NUMBER" "deployed"
     fi
 
+    # Mark GitHub deployment as successful
+    if [[ "${NO_GITHUB:-false}" != "true" ]] && type gh_deploy_pipeline_complete &>/dev/null 2>&1; then
+        if [[ -n "$REPO_OWNER" && -n "$REPO_NAME" ]]; then
+            gh_deploy_pipeline_complete "$REPO_OWNER" "$REPO_NAME" "$gh_deploy_env" true "" 2>/dev/null || true
+        fi
+    fi
+
     log_stage "deploy" "Deploy complete"
 }
 
@@ -2079,7 +3297,7 @@ stage_validate() {
     # Smoke tests
     if [[ -n "$smoke_cmd" ]]; then
         info "Running smoke tests..."
-        eval "$smoke_cmd" > "$ARTIFACTS_DIR/smoke.log" 2>&1 || {
+        bash -c "$smoke_cmd" > "$ARTIFACTS_DIR/smoke.log" 2>&1 || {
             error "Smoke tests failed"
             if [[ -n "$ISSUE_NUMBER" ]]; then
                 gh issue create --title "Deploy validation failed: $GOAL" \
@@ -2171,6 +3389,24 @@ stage_monitor() {
     [[ "$health_url" == "null" ]] && health_url=""
     error_threshold=$(jq -r --arg id "monitor" '(.stages[] | select(.id == $id) | .config.error_threshold) // 5' "$PIPELINE_CONFIG" 2>/dev/null) || true
     [[ -z "$error_threshold" || "$error_threshold" == "null" ]] && error_threshold=5
+
+    # Adaptive monitor: use historical baselines if available
+    local repo_hash
+    repo_hash=$(echo "${PROJECT_ROOT:-$(pwd)}" | cksum | awk '{print $1}')
+    local baseline_file="${HOME}/.shipwright/baselines/${repo_hash}/deploy-monitor.json"
+    if [[ -f "$baseline_file" ]]; then
+        local hist_duration hist_threshold
+        hist_duration=$(jq -r '.p90_stabilization_minutes // empty' "$baseline_file" 2>/dev/null || true)
+        hist_threshold=$(jq -r '.p90_error_threshold // empty' "$baseline_file" 2>/dev/null || true)
+        if [[ -n "$hist_duration" && "$hist_duration" != "null" ]]; then
+            duration_minutes="$hist_duration"
+            info "Monitor duration: ${duration_minutes}m ${DIM}(from baseline)${RESET}"
+        fi
+        if [[ -n "$hist_threshold" && "$hist_threshold" != "null" ]]; then
+            error_threshold="$hist_threshold"
+            info "Error threshold: ${error_threshold} ${DIM}(from baseline)${RESET}"
+        fi
+    fi
     log_pattern=$(jq -r --arg id "monitor" '(.stages[] | select(.id == $id) | .config.log_pattern) // "ERROR|FATAL|PANIC"' "$PIPELINE_CONFIG" 2>/dev/null) || true
     [[ -z "$log_pattern" || "$log_pattern" == "null" ]] && log_pattern="ERROR|FATAL|PANIC"
     log_cmd=$(jq -r --arg id "monitor" '(.stages[] | select(.id == $id) | .config.log_cmd) // ""' "$PIPELINE_CONFIG" 2>/dev/null) || true
@@ -2237,7 +3473,7 @@ stage_monitor() {
         # Log command check
         if [[ -n "$log_cmd" ]]; then
             local log_output
-            log_output=$(eval "$log_cmd" 2>/dev/null || true)
+            log_output=$(bash -c "$log_cmd" 2>/dev/null || true)
             local error_count=0
             if [[ -n "$log_output" ]]; then
                 error_count=$(echo "$log_output" | grep -cE "$log_pattern" 2>/dev/null || true)
@@ -2278,7 +3514,7 @@ stage_monitor() {
                 echo "" >> "$report_file"
                 echo "## Rollback" >> "$report_file"
 
-                if eval "$rollback_cmd" >> "$report_file" 2>&1; then
+                if bash -c "$rollback_cmd" >> "$report_file" 2>&1; then
                     success "Rollback executed"
                     echo "Rollback: ✅ success" >> "$report_file"
 
@@ -2289,7 +3525,7 @@ stage_monitor() {
 
                     if [[ -n "$smoke_cmd" ]]; then
                         info "Verifying rollback with smoke tests..."
-                        if eval "$smoke_cmd" > "$ARTIFACTS_DIR/rollback-smoke.log" 2>&1; then
+                        if bash -c "$smoke_cmd" > "$ARTIFACTS_DIR/rollback-smoke.log" 2>&1; then
                             success "Rollback verified — smoke tests pass"
                             echo "Rollback verification: ✅ smoke tests pass" >> "$report_file"
                             emit_event "monitor.rollback_verified" \
@@ -2369,6 +3605,30 @@ _Created automatically by \`shipwright pipeline\` monitor stage_" 2>/dev/null ||
     fi
 
     log_stage "monitor" "Clean — ${total_errors} errors in ${duration_minutes}m"
+
+    # Record baseline for adaptive monitoring on future runs
+    local baseline_dir="${HOME}/.shipwright/baselines/${repo_hash}"
+    mkdir -p "$baseline_dir" 2>/dev/null || true
+    local baseline_tmp
+    baseline_tmp="$(mktemp)"
+    if [[ -f "${baseline_dir}/deploy-monitor.json" ]]; then
+        # Append to history and recalculate p90
+        jq --arg dur "$duration_minutes" --arg errs "$total_errors" \
+            '.history += [{"duration_minutes": ($dur | tonumber), "errors": ($errs | tonumber)}] |
+             .p90_stabilization_minutes = ([.history[].duration_minutes] | sort | .[length * 9 / 10 | floor]) |
+             .p90_error_threshold = (([.history[].errors] | sort | .[length * 9 / 10 | floor]) + 2) |
+             .updated_at = now' \
+            "${baseline_dir}/deploy-monitor.json" > "$baseline_tmp" 2>/dev/null && \
+            mv "$baseline_tmp" "${baseline_dir}/deploy-monitor.json" || rm -f "$baseline_tmp"
+    else
+        jq -n --arg dur "$duration_minutes" --arg errs "$total_errors" \
+            '{history: [{"duration_minutes": ($dur | tonumber), "errors": ($errs | tonumber)}],
+              p90_stabilization_minutes: ($dur | tonumber),
+              p90_error_threshold: (($errs | tonumber) + 2),
+              updated_at: now}' \
+            > "$baseline_tmp" 2>/dev/null && \
+            mv "$baseline_tmp" "${baseline_dir}/deploy-monitor.json" || rm -f "$baseline_tmp"
+    fi
 }
 
 # ─── Multi-Dimensional Quality Checks ─────────────────────────────────────
@@ -2427,13 +3687,33 @@ quality_check_bundle_size() {
     local bundle_size=0
     local bundle_dir=""
 
-    # Find build output directory
-    for dir in dist build out .next; do
-        if [[ -d "$dir" ]]; then
-            bundle_dir="$dir"
-            break
+    # Find build output directory — check config files first, then common dirs
+    # Parse tsconfig.json outDir
+    if [[ -z "$bundle_dir" && -f "tsconfig.json" ]]; then
+        local ts_out
+        ts_out=$(jq -r '.compilerOptions.outDir // empty' tsconfig.json 2>/dev/null || true)
+        [[ -n "$ts_out" && -d "$ts_out" ]] && bundle_dir="$ts_out"
+    fi
+    # Parse package.json build script for output hints
+    if [[ -z "$bundle_dir" && -f "package.json" ]]; then
+        local build_script
+        build_script=$(jq -r '.scripts.build // ""' package.json 2>/dev/null || true)
+        if [[ -n "$build_script" ]]; then
+            # Check for common output flags: --outDir, -o, --out-dir
+            local parsed_out
+            parsed_out=$(echo "$build_script" | grep -oE '(--outDir|--out-dir|-o)\s+[^ ]+' 2>/dev/null | awk '{print $NF}' | head -1 || true)
+            [[ -n "$parsed_out" && -d "$parsed_out" ]] && bundle_dir="$parsed_out"
         fi
-    done
+    fi
+    # Fallback: check common directories
+    if [[ -z "$bundle_dir" ]]; then
+        for dir in dist build out .next target; do
+            if [[ -d "$dir" ]]; then
+                bundle_dir="$dir"
+                break
+            fi
+        done
+    fi
 
     if [[ -z "$bundle_dir" ]]; then
         info "No build output directory found — skipping bundle check"
@@ -2453,23 +3733,106 @@ quality_check_bundle_size() {
         "size_kb=$bundle_size" \
         "directory=$bundle_dir"
 
-    # Check against memory baseline if available
-    local baseline_size=""
-    if [[ -x "$SCRIPT_DIR/cct-memory.sh" ]]; then
-        baseline_size=$(bash "$SCRIPT_DIR/cct-memory.sh" get "bundle_size_kb" 2>/dev/null) || true
+    # Adaptive bundle size check: statistical deviation from historical mean
+    local repo_hash_bundle
+    repo_hash_bundle=$(echo -n "$PROJECT_ROOT" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown")
+    local bundle_baselines_dir="${HOME}/.shipwright/baselines/${repo_hash_bundle}"
+    local bundle_history_file="${bundle_baselines_dir}/bundle-history.json"
+
+    local bundle_history="[]"
+    if [[ -f "$bundle_history_file" ]]; then
+        bundle_history=$(jq '.sizes // []' "$bundle_history_file" 2>/dev/null || echo "[]")
+    fi
+
+    local bundle_hist_count
+    bundle_hist_count=$(echo "$bundle_history" | jq 'length' 2>/dev/null || echo "0")
+
+    if [[ "$bundle_hist_count" -ge 3 ]]; then
+        # Statistical check: alert on growth > 2σ from historical mean
+        local mean_size stddev_size
+        mean_size=$(echo "$bundle_history" | jq 'add / length' 2>/dev/null || echo "0")
+        stddev_size=$(echo "$bundle_history" | jq '
+            (add / length) as $mean |
+            (map(. - $mean | . * .) | add / length | sqrt)
+        ' 2>/dev/null || echo "0")
+
+        # Adaptive tolerance: small repos (<1MB mean) get wider tolerance (3σ), large repos get 2σ
+        local sigma_mult
+        sigma_mult=$(awk -v mean="$mean_size" 'BEGIN{ print (mean < 1024 ? 3 : 2) }')
+        local adaptive_max
+        adaptive_max=$(awk -v mean="$mean_size" -v sd="$stddev_size" -v mult="$sigma_mult" \
+            'BEGIN{ t = mean + mult*sd; min_t = mean * 1.1; printf "%.0f", (t > min_t ? t : min_t) }')
+
+        echo "History: ${bundle_hist_count} runs | Mean: ${mean_size}KB | StdDev: ${stddev_size}KB | Max: ${adaptive_max}KB (${sigma_mult}σ)" >> "$metrics_log"
+
+        if [[ "$bundle_size" -gt "$adaptive_max" ]] 2>/dev/null; then
+            local growth_pct
+            growth_pct=$(awk -v cur="$bundle_size" -v mean="$mean_size" 'BEGIN{printf "%d", ((cur - mean) / mean) * 100}')
+            warn "Bundle size ${growth_pct}% above average (${mean_size}KB → ${bundle_size}KB, ${sigma_mult}σ threshold: ${adaptive_max}KB)"
+            return 1
+        fi
+    else
+        # Fallback: legacy memory baseline with hardcoded 20% (not enough history)
+        local baseline_size=""
+        if [[ -x "$SCRIPT_DIR/sw-memory.sh" ]]; then
+            baseline_size=$(bash "$SCRIPT_DIR/sw-memory.sh" get "bundle_size_kb" 2>/dev/null) || true
+        fi
+        if [[ -n "$baseline_size" && "$baseline_size" -gt 0 ]] 2>/dev/null; then
+            local growth_pct
+            growth_pct=$(awk -v cur="$bundle_size" -v base="$baseline_size" 'BEGIN{printf "%d", ((cur - base) / base) * 100}')
+            echo "Baseline: ${baseline_size}KB | Growth: ${growth_pct}%" >> "$metrics_log"
+            if [[ "$growth_pct" -gt 20 ]]; then
+                warn "Bundle size grew ${growth_pct}% (${baseline_size}KB → ${bundle_size}KB)"
+                return 1
+            fi
+        fi
     fi
 
-    if [[ -n "$baseline_size" && "$baseline_size" -gt 0 ]] 2>/dev/null; then
-        local growth_pct
-        growth_pct=$(awk -v cur="$bundle_size" -v base="$baseline_size" 'BEGIN{printf "%d", ((cur - base) / base) * 100}')
-        echo "Baseline: ${baseline_size}KB | Growth: ${growth_pct}%" >> "$metrics_log"
-        if [[ "$growth_pct" -gt 20 ]]; then
-            warn "Bundle size grew ${growth_pct}% (${baseline_size}KB → ${bundle_size}KB)"
-            return 1
+    # Append current size to rolling history (keep last 10)
+    mkdir -p "$bundle_baselines_dir"
+    local updated_bundle_hist
+    updated_bundle_hist=$(echo "$bundle_history" | jq --arg sz "$bundle_size" '
+        . + [($sz | tonumber)] | .[-10:]
+    ' 2>/dev/null || echo "[$bundle_size]")
+    local tmp_bundle_hist
+    tmp_bundle_hist=$(mktemp "${bundle_baselines_dir}/bundle-history.json.XXXXXX")
+    jq -n --argjson sizes "$updated_bundle_hist" --arg updated "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+        '{sizes: $sizes, updated: $updated}' > "$tmp_bundle_hist" 2>/dev/null
+    mv "$tmp_bundle_hist" "$bundle_history_file" 2>/dev/null || true
+
+    # Intelligence: identify top dependency bloaters
+    if type intelligence_search_memory &>/dev/null 2>&1 && [[ -f "package.json" ]] && command -v jq &>/dev/null; then
+        local dep_sizes=""
+        local deps
+        deps=$(jq -r '.dependencies // {} | keys[]' package.json 2>/dev/null || true)
+        if [[ -n "$deps" ]]; then
+            while IFS= read -r dep; do
+                [[ -z "$dep" ]] && continue
+                local dep_dir="node_modules/${dep}"
+                if [[ -d "$dep_dir" ]]; then
+                    local dep_size
+                    dep_size=$(du -sk "$dep_dir" 2>/dev/null | cut -f1 || echo "0")
+                    dep_sizes="${dep_sizes}${dep_size} ${dep}
+"
+                fi
+            done <<< "$deps"
+            if [[ -n "$dep_sizes" ]]; then
+                local top_bloaters
+                top_bloaters=$(echo "$dep_sizes" | sort -rn | head -3)
+                if [[ -n "$top_bloaters" ]]; then
+                    echo "" >> "$metrics_log"
+                    echo "Top 3 dependency sizes:" >> "$metrics_log"
+                    echo "$top_bloaters" | while IFS=' ' read -r sz nm; do
+                        [[ -z "$nm" ]] && continue
+                        echo "  ${nm}: ${sz}KB" >> "$metrics_log"
+                    done
+                    info "Top bloaters: $(echo "$top_bloaters" | head -1 | awk '{print $2 ": " $1 "KB"}')"
+                fi
+            fi
         fi
     fi
 
-    info "Bundle size: ${bundle_size_human}"
+    info "Bundle size: ${bundle_size_human}${bundle_hist_count:+ (${bundle_hist_count} historical samples)}"
     return 0
 }
 
@@ -2484,11 +3847,39 @@ quality_check_perf_regression() {
         return 0
     fi
 
-    # Extract test suite duration (common patterns)
+    # Extract test suite duration — multi-framework patterns
     local duration_ms=""
+    # Jest/Vitest: "Time: 12.34 s" or "Duration  12.34s"
     duration_ms=$(grep -oE 'Time:\s*[0-9.]+\s*s' "$test_log" 2>/dev/null | grep -oE '[0-9.]+' | tail -1 || true)
+    [[ -z "$duration_ms" ]] && duration_ms=$(grep -oE 'Duration\s+[0-9.]+\s*s' "$test_log" 2>/dev/null | grep -oE '[0-9.]+' | tail -1 || true)
+    # pytest: "passed in 12.34s" or "====== 5 passed in 12.34 seconds ======"
+    [[ -z "$duration_ms" ]] && duration_ms=$(grep -oE 'passed in [0-9.]+s' "$test_log" 2>/dev/null | grep -oE '[0-9.]+' | tail -1 || true)
+    # Go test: "ok  pkg  12.345s"
+    [[ -z "$duration_ms" ]] && duration_ms=$(grep -oE '^ok\s+\S+\s+[0-9.]+s' "$test_log" 2>/dev/null | grep -oE '[0-9.]+s' | grep -oE '[0-9.]+' | tail -1 || true)
+    # Cargo test: "test result: ok. ... finished in 12.34s"
+    [[ -z "$duration_ms" ]] && duration_ms=$(grep -oE 'finished in [0-9.]+s' "$test_log" 2>/dev/null | grep -oE '[0-9.]+' | tail -1 || true)
+    # Generic: "12.34 seconds" or "12.34s"
     [[ -z "$duration_ms" ]] && duration_ms=$(grep -oE '[0-9.]+ ?s(econds?)?' "$test_log" 2>/dev/null | grep -oE '[0-9.]+' | tail -1 || true)
 
+    # Claude fallback: parse test output when no pattern matches
+    if [[ -z "$duration_ms" ]]; then
+        local intel_enabled="false"
+        local daemon_cfg="${PROJECT_ROOT}/.claude/daemon-config.json"
+        if [[ -f "$daemon_cfg" ]]; then
+            intel_enabled=$(jq -r '.intelligence.enabled // false' "$daemon_cfg" 2>/dev/null || echo "false")
+        fi
+        if [[ "$intel_enabled" == "true" ]] && command -v claude &>/dev/null; then
+            local tail_output
+            tail_output=$(tail -30 "$test_log" 2>/dev/null || true)
+            if [[ -n "$tail_output" ]]; then
+                duration_ms=$(claude --print -p "Extract ONLY the total test suite duration in seconds from this output. Reply with ONLY a number (e.g. 12.34). If no duration found, reply NONE.
+
+$tail_output" < /dev/null 2>/dev/null | grep -oE '^[0-9.]+$' | head -1 || true)
+                [[ "$duration_ms" == "NONE" ]] && duration_ms=""
+            fi
+        fi
+    fi
+
     if [[ -z "$duration_ms" ]]; then
         info "Could not extract test duration — skipping perf check"
         echo "Duration not parseable" > "$metrics_log"
@@ -2501,23 +3892,73 @@ quality_check_perf_regression() {
         "issue=${ISSUE_NUMBER:-0}" \
         "duration_s=$duration_ms"
 
-    # Check against memory baseline if available
-    local baseline_dur=""
-    if [[ -x "$SCRIPT_DIR/cct-memory.sh" ]]; then
-        baseline_dur=$(bash "$SCRIPT_DIR/cct-memory.sh" get "test_duration_s" 2>/dev/null) || true
-    fi
-
-    if [[ -n "$baseline_dur" ]] && awk -v cur="$duration_ms" -v base="$baseline_dur" 'BEGIN{exit !(base > 0)}' 2>/dev/null; then
-        local slowdown_pct
-        slowdown_pct=$(awk -v cur="$duration_ms" -v base="$baseline_dur" 'BEGIN{printf "%d", ((cur - base) / base) * 100}')
-        echo "Baseline: ${baseline_dur}s | Slowdown: ${slowdown_pct}%" >> "$metrics_log"
-        if [[ "$slowdown_pct" -gt 30 ]]; then
-            warn "Tests ${slowdown_pct}% slower (${baseline_dur}s → ${duration_ms}s)"
+    # Adaptive performance check: 2σ from rolling 10-run average
+    local repo_hash_perf
+    repo_hash_perf=$(echo -n "$PROJECT_ROOT" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown")
+    local perf_baselines_dir="${HOME}/.shipwright/baselines/${repo_hash_perf}"
+    local perf_history_file="${perf_baselines_dir}/perf-history.json"
+
+    # Read historical durations (rolling window of last 10 runs)
+    local history_json="[]"
+    if [[ -f "$perf_history_file" ]]; then
+        history_json=$(jq '.durations // []' "$perf_history_file" 2>/dev/null || echo "[]")
+    fi
+
+    local history_count
+    history_count=$(echo "$history_json" | jq 'length' 2>/dev/null || echo "0")
+
+    if [[ "$history_count" -ge 3 ]]; then
+        # Calculate mean and standard deviation from history
+        local mean_dur stddev_dur
+        mean_dur=$(echo "$history_json" | jq 'add / length' 2>/dev/null || echo "0")
+        stddev_dur=$(echo "$history_json" | jq '
+            (add / length) as $mean |
+            (map(. - $mean | . * .) | add / length | sqrt)
+        ' 2>/dev/null || echo "0")
+
+        # Threshold: mean + 2σ (but at least 10% above mean)
+        local adaptive_threshold
+        adaptive_threshold=$(awk -v mean="$mean_dur" -v sd="$stddev_dur" \
+            'BEGIN{ t = mean + 2*sd; min_t = mean * 1.1; printf "%.2f", (t > min_t ? t : min_t) }')
+
+        echo "History: ${history_count} runs | Mean: ${mean_dur}s | StdDev: ${stddev_dur}s | Threshold: ${adaptive_threshold}s" >> "$metrics_log"
+
+        if awk -v cur="$duration_ms" -v thresh="$adaptive_threshold" 'BEGIN{exit !(cur > thresh)}' 2>/dev/null; then
+            local slowdown_pct
+            slowdown_pct=$(awk -v cur="$duration_ms" -v mean="$mean_dur" 'BEGIN{printf "%d", ((cur - mean) / mean) * 100}')
+            warn "Tests ${slowdown_pct}% slower than rolling average (${mean_dur}s → ${duration_ms}s, threshold: ${adaptive_threshold}s)"
             return 1
         fi
+    else
+        # Fallback: legacy memory baseline with hardcoded 30% (not enough history)
+        local baseline_dur=""
+        if [[ -x "$SCRIPT_DIR/sw-memory.sh" ]]; then
+            baseline_dur=$(bash "$SCRIPT_DIR/sw-memory.sh" get "test_duration_s" 2>/dev/null) || true
+        fi
+        if [[ -n "$baseline_dur" ]] && awk -v cur="$duration_ms" -v base="$baseline_dur" 'BEGIN{exit !(base > 0)}' 2>/dev/null; then
+            local slowdown_pct
+            slowdown_pct=$(awk -v cur="$duration_ms" -v base="$baseline_dur" 'BEGIN{printf "%d", ((cur - base) / base) * 100}')
+            echo "Baseline: ${baseline_dur}s | Slowdown: ${slowdown_pct}%" >> "$metrics_log"
+            if [[ "$slowdown_pct" -gt 30 ]]; then
+                warn "Tests ${slowdown_pct}% slower (${baseline_dur}s → ${duration_ms}s)"
+                return 1
+            fi
+        fi
     fi
 
-    info "Test duration: ${duration_ms}s"
+    # Append current duration to rolling history (keep last 10)
+    mkdir -p "$perf_baselines_dir"
+    local updated_history
+    updated_history=$(echo "$history_json" | jq --arg dur "$duration_ms" '
+        . + [($dur | tonumber)] | .[-10:]
+    ' 2>/dev/null || echo "[$duration_ms]")
+    local tmp_perf_hist
+    tmp_perf_hist=$(mktemp "${perf_baselines_dir}/perf-history.json.XXXXXX")
+    jq -n --argjson durations "$updated_history" --arg updated "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+        '{durations: $durations, updated: $updated}' > "$tmp_perf_hist" 2>/dev/null
+    mv "$tmp_perf_hist" "$perf_history_file" 2>/dev/null || true
+
+    info "Test duration: ${duration_ms}s${history_count:+ (${history_count} historical samples)}"
     return 0
 }
 
@@ -2525,7 +3966,7 @@ quality_check_api_compat() {
     info "API compatibility check..."
     local compat_log="$ARTIFACTS_DIR/api-compat.log"
 
-    # Look for OpenAPI/Swagger specs
+    # Look for OpenAPI/Swagger specs — search beyond hardcoded paths
     local spec_file=""
     for candidate in openapi.json openapi.yaml swagger.json swagger.yaml api/openapi.json docs/openapi.yaml; do
         if [[ -f "$candidate" ]]; then
@@ -2533,6 +3974,10 @@ quality_check_api_compat() {
             break
         fi
     done
+    # Broader search if nothing found at common paths
+    if [[ -z "$spec_file" ]]; then
+        spec_file=$(find . -maxdepth 4 \( -name "openapi*.json" -o -name "openapi*.yaml" -o -name "openapi*.yml" -o -name "swagger*.json" -o -name "swagger*.yaml" -o -name "swagger*.yml" \) -type f 2>/dev/null | head -1 || true)
+    fi
 
     if [[ -z "$spec_file" ]]; then
         info "No OpenAPI/Swagger spec found — skipping API compat check"
@@ -2571,21 +4016,64 @@ quality_check_api_compat() {
         removed_endpoints=$(comm -23 <(echo "$old_paths") <(echo "$new_paths") 2>/dev/null || true)
     fi
 
+    # Enhanced schema diff: parameter changes, response schema, auth changes
+    local param_changes="" schema_changes=""
+    if command -v jq &>/dev/null && [[ "$spec_file" == *.json ]]; then
+        # Detect parameter changes on existing endpoints
+        local common_paths
+        common_paths=$(comm -12 <(echo "$old_spec" | jq -r '.paths | keys[]' 2>/dev/null | sort) <(jq -r '.paths | keys[]' "$spec_file" 2>/dev/null | sort) 2>/dev/null || true)
+        if [[ -n "$common_paths" ]]; then
+            while IFS= read -r path; do
+                [[ -z "$path" ]] && continue
+                local old_params new_params
+                old_params=$(echo "$old_spec" | jq -r --arg p "$path" '.paths[$p] | to_entries[] | .value.parameters // [] | .[].name' 2>/dev/null | sort || true)
+                new_params=$(jq -r --arg p "$path" '.paths[$p] | to_entries[] | .value.parameters // [] | .[].name' "$spec_file" 2>/dev/null | sort || true)
+                local removed_params
+                removed_params=$(comm -23 <(echo "$old_params") <(echo "$new_params") 2>/dev/null || true)
+                [[ -n "$removed_params" ]] && param_changes="${param_changes}${path}: removed params: ${removed_params}
+"
+            done <<< "$common_paths"
+        fi
+    fi
+
+    # Intelligence: semantic API diff for complex changes
+    local semantic_diff=""
+    if type intelligence_search_memory &>/dev/null 2>&1 && command -v claude &>/dev/null; then
+        local spec_git_diff
+        spec_git_diff=$(git diff "${BASE_BRANCH}...HEAD" -- "$spec_file" 2>/dev/null | head -200 || true)
+        if [[ -n "$spec_git_diff" ]]; then
+            semantic_diff=$(claude --print --output-format text -p "Analyze this API spec diff for breaking changes. List: removed endpoints, changed parameters, altered response schemas, auth changes. Be concise.
+
+${spec_git_diff}" --model haiku < /dev/null 2>/dev/null || true)
+        fi
+    fi
+
     {
         echo "Spec: $spec_file"
         echo "Changed: yes"
         if [[ -n "$removed_endpoints" ]]; then
             echo "BREAKING — Removed endpoints:"
             echo "$removed_endpoints"
-        else
+        fi
+        if [[ -n "$param_changes" ]]; then
+            echo "BREAKING — Parameter changes:"
+            echo "$param_changes"
+        fi
+        if [[ -n "$semantic_diff" ]]; then
+            echo ""
+            echo "Semantic analysis:"
+            echo "$semantic_diff"
+        fi
+        if [[ -z "$removed_endpoints" && -z "$param_changes" ]]; then
             echo "No breaking changes detected"
         fi
     } > "$compat_log"
 
-    if [[ -n "$removed_endpoints" ]]; then
-        local removed_count
-        removed_count=$(echo "$removed_endpoints" | wc -l | xargs)
-        warn "API breaking changes: ${removed_count} endpoint(s) removed"
+    if [[ -n "$removed_endpoints" || -n "$param_changes" ]]; then
+        local issue_count=0
+        [[ -n "$removed_endpoints" ]] && issue_count=$((issue_count + $(echo "$removed_endpoints" | wc -l | xargs)))
+        [[ -n "$param_changes" ]] && issue_count=$((issue_count + $(echo "$param_changes" | grep -c '.' || true)))
+        warn "API breaking changes: ${issue_count} issue(s) found"
         return 1
     fi
 
@@ -2602,11 +4090,28 @@ quality_check_coverage() {
         return 0
     fi
 
-    # Extract coverage percentage
+    # Extract coverage percentage using shared parser
     local coverage=""
-    coverage=$(grep -oE 'Statements\s*:\s*[0-9.]+' "$test_log" 2>/dev/null | grep -oE '[0-9.]+$' || \
-               grep -oE 'All files\s*\|\s*[0-9.]+' "$test_log" 2>/dev/null | grep -oE '[0-9.]+$' || \
-               grep -oE 'TOTAL\s+[0-9]+\s+[0-9]+\s+([0-9]+)%' "$test_log" 2>/dev/null | grep -oE '[0-9]+%' | tr -d '%' || echo "")
+    coverage=$(parse_coverage_from_output "$test_log")
+
+    # Claude fallback: parse test output when no pattern matches
+    if [[ -z "$coverage" ]]; then
+        local intel_enabled_cov="false"
+        local daemon_cfg_cov="${PROJECT_ROOT}/.claude/daemon-config.json"
+        if [[ -f "$daemon_cfg_cov" ]]; then
+            intel_enabled_cov=$(jq -r '.intelligence.enabled // false' "$daemon_cfg_cov" 2>/dev/null || echo "false")
+        fi
+        if [[ "$intel_enabled_cov" == "true" ]] && command -v claude &>/dev/null; then
+            local tail_cov_output
+            tail_cov_output=$(tail -40 "$test_log" 2>/dev/null || true)
+            if [[ -n "$tail_cov_output" ]]; then
+                coverage=$(claude --print -p "Extract ONLY the overall code coverage percentage from this test output. Reply with ONLY a number (e.g. 85.5). If no coverage found, reply NONE.
+
+$tail_cov_output" < /dev/null 2>/dev/null | grep -oE '^[0-9.]+$' | head -1 || true)
+                [[ "$coverage" == "NONE" ]] && coverage=""
+            fi
+        fi
+    fi
 
     if [[ -z "$coverage" ]]; then
         info "Could not extract coverage — skipping"
@@ -2622,16 +4127,30 @@ quality_check_coverage() {
     coverage_min=$(jq -r --arg id "test" '(.stages[] | select(.id == $id) | .config.coverage_min) // 0' "$PIPELINE_CONFIG" 2>/dev/null) || true
     [[ -z "$coverage_min" || "$coverage_min" == "null" ]] && coverage_min=0
 
-    # Check against memory baseline (detect coverage drops)
+    # Adaptive baseline: read from baselines file, enforce no-regression (>= baseline - 2%)
+    local repo_hash_cov
+    repo_hash_cov=$(echo -n "$PROJECT_ROOT" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown")
+    local baselines_dir="${HOME}/.shipwright/baselines/${repo_hash_cov}"
+    local coverage_baseline_file="${baselines_dir}/coverage.json"
+
     local baseline_coverage=""
-    if [[ -x "$SCRIPT_DIR/cct-memory.sh" ]]; then
-        baseline_coverage=$(bash "$SCRIPT_DIR/cct-memory.sh" get "coverage_pct" 2>/dev/null) || true
+    if [[ -f "$coverage_baseline_file" ]]; then
+        baseline_coverage=$(jq -r '.baseline // empty' "$coverage_baseline_file" 2>/dev/null) || true
+    fi
+    # Fallback: try legacy memory baseline
+    if [[ -z "$baseline_coverage" ]] && [[ -x "$SCRIPT_DIR/sw-memory.sh" ]]; then
+        baseline_coverage=$(bash "$SCRIPT_DIR/sw-memory.sh" get "coverage_pct" 2>/dev/null) || true
     fi
 
     local dropped=false
-    if [[ -n "$baseline_coverage" ]] && awk -v cur="$coverage" -v base="$baseline_coverage" 'BEGIN{exit !(cur < base)}' 2>/dev/null; then
-        warn "Coverage dropped: ${baseline_coverage}% → ${coverage}%"
-        dropped=true
+    if [[ -n "$baseline_coverage" && "$baseline_coverage" != "0" ]] && awk -v cur="$coverage" -v base="$baseline_coverage" 'BEGIN{exit !(base > 0)}' 2>/dev/null; then
+        # Adaptive: allow 2% regression tolerance from baseline
+        local min_allowed
+        min_allowed=$(awk -v base="$baseline_coverage" 'BEGIN{printf "%d", base - 2}')
+        if awk -v cur="$coverage" -v min="$min_allowed" 'BEGIN{exit !(cur < min)}' 2>/dev/null; then
+            warn "Coverage regression: ${baseline_coverage}% → ${coverage}% (adaptive min: ${min_allowed}%)"
+            dropped=true
+        fi
     fi
 
     if [[ "$coverage_min" -gt 0 ]] 2>/dev/null && awk -v cov="$coverage" -v min="$coverage_min" 'BEGIN{exit !(cov < min)}' 2>/dev/null; then
@@ -2643,7 +4162,17 @@ quality_check_coverage() {
         return 1
     fi
 
-    info "Coverage: ${coverage}%"
+    # Update baseline on success (first run or improvement)
+    if [[ -z "$baseline_coverage" ]] || awk -v cur="$coverage" -v base="$baseline_coverage" 'BEGIN{exit !(cur >= base)}' 2>/dev/null; then
+        mkdir -p "$baselines_dir"
+        local tmp_cov_baseline
+        tmp_cov_baseline=$(mktemp "${baselines_dir}/coverage.json.XXXXXX")
+        jq -n --arg baseline "$coverage" --arg updated "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+            '{baseline: ($baseline | tonumber), updated: $updated}' > "$tmp_cov_baseline" 2>/dev/null
+        mv "$tmp_cov_baseline" "$coverage_baseline_file" 2>/dev/null || true
+    fi
+
+    info "Coverage: ${coverage}%${baseline_coverage:+ (baseline: ${baseline_coverage}%)}"
     return 0
 }
 
@@ -2660,6 +4189,57 @@ run_adversarial_review() {
         return 0
     fi
 
+    # Delegate to sw-adversarial.sh module when available (uses intelligence cache)
+    if type adversarial_review &>/dev/null 2>&1; then
+        info "Using intelligence-backed adversarial review..."
+        local json_result
+        json_result=$(adversarial_review "$diff_content" "${GOAL:-}" 2>/dev/null || echo "[]")
+
+        # Save raw JSON result
+        echo "$json_result" > "$ARTIFACTS_DIR/adversarial-review.json"
+
+        # Convert JSON findings to markdown for compatibility with compound_rebuild_with_feedback
+        local critical_count high_count
+        critical_count=$(echo "$json_result" | jq '[.[] | select(.severity == "critical")] | length' 2>/dev/null || echo "0")
+        high_count=$(echo "$json_result" | jq '[.[] | select(.severity == "high")] | length' 2>/dev/null || echo "0")
+        local total_findings
+        total_findings=$(echo "$json_result" | jq 'length' 2>/dev/null || echo "0")
+
+        # Generate markdown report from JSON
+        {
+            echo "# Adversarial Review (Intelligence-backed)"
+            echo ""
+            echo "Total findings: ${total_findings} (${critical_count} critical, ${high_count} high)"
+            echo ""
+            echo "$json_result" | jq -r '.[] | "- **[\(.severity // "unknown")]** \(.location // "unknown") — \(.description // .concern // "no description")"' 2>/dev/null || true
+        } > "$ARTIFACTS_DIR/adversarial-review.md"
+
+        emit_event "adversarial.delegated" \
+            "issue=${ISSUE_NUMBER:-0}" \
+            "findings=$total_findings" \
+            "critical=$critical_count" \
+            "high=$high_count"
+
+        if [[ "$critical_count" -gt 0 ]]; then
+            warn "Adversarial review: ${critical_count} critical, ${high_count} high"
+            return 1
+        elif [[ "$high_count" -gt 0 ]]; then
+            warn "Adversarial review: ${high_count} high-severity issues"
+            return 1
+        fi
+
+        success "Adversarial review: clean"
+        return 0
+    fi
+
+    # Fallback: inline Claude call when module not loaded
+
+    # Inject previous adversarial findings from memory
+    local adv_memory=""
+    if type intelligence_search_memory &>/dev/null 2>&1; then
+        adv_memory=$(intelligence_search_memory "adversarial review security findings for: ${GOAL:-}" "${HOME}/.shipwright/memory" 5 2>/dev/null) || true
+    fi
+
     local prompt="You are a hostile code reviewer. Your job is to find EVERY possible issue in this diff.
 Look for:
 - Bugs (logic errors, off-by-one, null/undefined access, race conditions)
@@ -2672,12 +4252,16 @@ Look for:
 
 Be thorough and adversarial. List every issue with severity [Critical/Bug/Warning].
 Format: **[Severity]** file:line — description
-
+${adv_memory:+
+## Known Security Issues from Previous Reviews
+These security issues have been found in past reviews. Check if any recur:
+${adv_memory}
+}
 Diff:
 $diff_content"
 
     local review_output
-    review_output=$(claude --print "$prompt" 2>"${ARTIFACTS_DIR}/.claude-tokens-adversarial.log" || true)
+    review_output=$(claude --print "$prompt" < /dev/null 2>"${ARTIFACTS_DIR}/.claude-tokens-adversarial.log" || true)
     parse_claude_tokens "${ARTIFACTS_DIR}/.claude-tokens-adversarial.log"
 
     echo "$review_output" > "$ARTIFACTS_DIR/adversarial-review.md"
@@ -2721,6 +4305,12 @@ $(head -200 "$file" 2>/dev/null || true)
         fi
     done <<< "$changed_files"
 
+    # Inject previous negative prompting findings from memory
+    local neg_memory=""
+    if type intelligence_search_memory &>/dev/null 2>&1; then
+        neg_memory=$(intelligence_search_memory "negative prompting findings common concerns for: ${GOAL:-}" "${HOME}/.shipwright/memory" 5 2>/dev/null) || true
+    fi
+
     local prompt="You are a pessimistic engineer who assumes everything will break.
 Review these changes and answer:
 1. What could go wrong in production?
@@ -2730,7 +4320,11 @@ Review these changes and answer:
 5. What happens under load/stress?
 6. What happens with malicious input?
 7. Are there any implicit dependencies that could break?
-
+${neg_memory:+
+## Known Concerns from Previous Reviews
+These issues have been found in past reviews of this codebase. Check if any apply to the current changes:
+${neg_memory}
+}
 Be specific. Reference actual code. Categorize each concern as [Critical/Concern/Minor].
 
 Files changed: $changed_files
@@ -2738,7 +4332,7 @@ Files changed: $changed_files
 $file_contents"
 
     local review_output
-    review_output=$(claude --print "$prompt" 2>"${ARTIFACTS_DIR}/.claude-tokens-negative.log" || true)
+    review_output=$(claude --print "$prompt" < /dev/null 2>"${ARTIFACTS_DIR}/.claude-tokens-negative.log" || true)
     parse_claude_tokens "${ARTIFACTS_DIR}/.claude-tokens-negative.log"
 
     echo "$review_output" > "$ARTIFACTS_DIR/negative-review.md"
@@ -2768,7 +4362,7 @@ run_e2e_validation() {
     fi
 
     info "Running E2E validation: $test_cmd"
-    if eval "$test_cmd" > "$ARTIFACTS_DIR/e2e-validation.log" 2>&1; then
+    if bash -c "$test_cmd" > "$ARTIFACTS_DIR/e2e-validation.log" 2>&1; then
         success "E2E validation passed"
         return 0
     else
@@ -2782,7 +4376,7 @@ run_dod_audit() {
 
     if [[ ! -f "$dod_file" ]]; then
         # Check for alternative locations
-        for alt in "$PROJECT_ROOT/DEFINITION-OF-DONE.md" "$HOME/.claude-teams/templates/definition-of-done.example.md"; do
+        for alt in "$PROJECT_ROOT/DEFINITION-OF-DONE.md" "$HOME/.shipwright/templates/definition-of-done.example.md"; do
             if [[ -f "$alt" ]]; then
                 dod_file="$alt"
                 break
@@ -2936,6 +4530,9 @@ stage_compound_quality() {
     strict_quality=$(jq -r --arg id "compound_quality" '(.stages[] | select(.id == $id) | .config.strict_quality) // false' "$PIPELINE_CONFIG" 2>/dev/null) || true
     [[ -z "$strict_quality" || "$strict_quality" == "null" ]] && strict_quality="false"
 
+    # Convergence tracking
+    local prev_issue_count=-1
+
     local cycle=0
     while [[ "$cycle" -lt "$max_cycles" ]]; do
         cycle=$((cycle + 1))
@@ -2966,7 +4563,87 @@ stage_compound_quality() {
             fi
         fi
 
-        # 3. E2E Validation
+        # 3. Developer Simulation (intelligence module)
+        if type simulation_review &>/dev/null 2>&1; then
+            local sim_enabled
+            sim_enabled=$(jq -r '.intelligence.simulation_enabled // false' "$PIPELINE_CONFIG" 2>/dev/null || echo "false")
+            local daemon_cfg="${PROJECT_ROOT}/.claude/daemon-config.json"
+            if [[ "$sim_enabled" != "true" && -f "$daemon_cfg" ]]; then
+                sim_enabled=$(jq -r '.intelligence.simulation_enabled // false' "$daemon_cfg" 2>/dev/null || echo "false")
+            fi
+            if [[ "$sim_enabled" == "true" ]]; then
+                echo ""
+                info "Running developer simulation review..."
+                local sim_diff
+                sim_diff=$(git diff "${BASE_BRANCH}...HEAD" 2>/dev/null || true)
+                if [[ -n "$sim_diff" ]]; then
+                    local sim_result
+                    sim_result=$(simulation_review "$sim_diff" "${GOAL:-}" 2>/dev/null || echo "[]")
+                    if [[ -n "$sim_result" && "$sim_result" != "[]" && "$sim_result" != *'"error"'* ]]; then
+                        echo "$sim_result" > "$ARTIFACTS_DIR/compound-simulation-review.json"
+                        local sim_critical
+                        sim_critical=$(echo "$sim_result" | jq '[.[] | select(.severity == "critical" or .severity == "high")] | length' 2>/dev/null || echo "0")
+                        local sim_total
+                        sim_total=$(echo "$sim_result" | jq 'length' 2>/dev/null || echo "0")
+                        if [[ "$sim_critical" -gt 0 ]]; then
+                            warn "Developer simulation: ${sim_critical} critical/high concerns (${sim_total} total)"
+                            all_passed=false
+                        else
+                            success "Developer simulation: ${sim_total} concerns (none critical/high)"
+                        fi
+                        emit_event "compound.simulation" \
+                            "issue=${ISSUE_NUMBER:-0}" \
+                            "cycle=$cycle" \
+                            "total=$sim_total" \
+                            "critical=$sim_critical"
+                    else
+                        success "Developer simulation: no concerns"
+                    fi
+                fi
+            fi
+        fi
+
+        # 4. Architecture Enforcer (intelligence module)
+        if type architecture_validate_changes &>/dev/null 2>&1; then
+            local arch_enabled
+            arch_enabled=$(jq -r '.intelligence.architecture_enabled // false' "$PIPELINE_CONFIG" 2>/dev/null || echo "false")
+            local daemon_cfg="${PROJECT_ROOT}/.claude/daemon-config.json"
+            if [[ "$arch_enabled" != "true" && -f "$daemon_cfg" ]]; then
+                arch_enabled=$(jq -r '.intelligence.architecture_enabled // false' "$daemon_cfg" 2>/dev/null || echo "false")
+            fi
+            if [[ "$arch_enabled" == "true" ]]; then
+                echo ""
+                info "Running architecture validation..."
+                local arch_diff
+                arch_diff=$(git diff "${BASE_BRANCH}...HEAD" 2>/dev/null || true)
+                if [[ -n "$arch_diff" ]]; then
+                    local arch_result
+                    arch_result=$(architecture_validate_changes "$arch_diff" "" 2>/dev/null || echo "[]")
+                    if [[ -n "$arch_result" && "$arch_result" != "[]" && "$arch_result" != *'"error"'* ]]; then
+                        echo "$arch_result" > "$ARTIFACTS_DIR/compound-architecture-validation.json"
+                        local arch_violations
+                        arch_violations=$(echo "$arch_result" | jq '[.[] | select(.severity == "critical" or .severity == "high")] | length' 2>/dev/null || echo "0")
+                        local arch_total
+                        arch_total=$(echo "$arch_result" | jq 'length' 2>/dev/null || echo "0")
+                        if [[ "$arch_violations" -gt 0 ]]; then
+                            warn "Architecture validation: ${arch_violations} critical/high violations (${arch_total} total)"
+                            all_passed=false
+                        else
+                            success "Architecture validation: ${arch_total} violations (none critical/high)"
+                        fi
+                        emit_event "compound.architecture" \
+                            "issue=${ISSUE_NUMBER:-0}" \
+                            "cycle=$cycle" \
+                            "total=$arch_total" \
+                            "violations=$arch_violations"
+                    else
+                        success "Architecture validation: no violations"
+                    fi
+                fi
+            fi
+        fi
+
+        # 5. E2E Validation
         if [[ "$e2e_enabled" == "true" ]]; then
             echo ""
             info "Running E2E validation..."
@@ -2975,7 +4652,7 @@ stage_compound_quality() {
             fi
         fi
 
-        # 4. DoD Audit
+        # 6. DoD Audit
         if [[ "$dod_enabled" == "true" ]]; then
             echo ""
             info "Running Definition of Done audit..."
@@ -2984,7 +4661,7 @@ stage_compound_quality() {
             fi
         fi
 
-        # 5. Multi-dimensional quality checks
+        # 7. Multi-dimensional quality checks
         echo ""
         info "Running multi-dimensional quality checks..."
         local quality_failures=0
@@ -3016,15 +4693,37 @@ stage_compound_quality() {
             success "Multi-dimensional quality: all checks passed"
         fi
 
+        # ── Convergence Detection ──
+        # Count critical/high issues from all review artifacts
+        local current_issue_count=0
+        if [[ -f "$ARTIFACTS_DIR/adversarial-review.md" ]]; then
+            local adv_issues
+            adv_issues=$(grep -ciE '\*\*\[?(Critical|Bug|critical|high)\]?\*\*' "$ARTIFACTS_DIR/adversarial-review.md" 2>/dev/null || true)
+            current_issue_count=$((current_issue_count + ${adv_issues:-0}))
+        fi
+        if [[ -f "$ARTIFACTS_DIR/adversarial-review.json" ]]; then
+            local adv_json_issues
+            adv_json_issues=$(jq '[.[] | select(.severity == "critical" or .severity == "high")] | length' "$ARTIFACTS_DIR/adversarial-review.json" 2>/dev/null || echo "0")
+            current_issue_count=$((current_issue_count + ${adv_json_issues:-0}))
+        fi
+        if [[ -f "$ARTIFACTS_DIR/negative-review.md" ]]; then
+            local neg_issues
+            neg_issues=$(grep -ciE '\[Critical\]' "$ARTIFACTS_DIR/negative-review.md" 2>/dev/null || true)
+            current_issue_count=$((current_issue_count + ${neg_issues:-0}))
+        fi
+        current_issue_count=$((current_issue_count + quality_failures))
+
         emit_event "compound.cycle" \
             "issue=${ISSUE_NUMBER:-0}" \
             "cycle=$cycle" \
             "max_cycles=$max_cycles" \
             "passed=$all_passed" \
+            "critical_issues=$current_issue_count" \
             "self_heal_count=$SELF_HEAL_COUNT"
 
-        if $all_passed; then
-            success "Compound quality passed on cycle ${cycle}"
+        # Early exit: zero critical/high issues
+        if [[ "$current_issue_count" -eq 0 ]] && $all_passed; then
+            success "Compound quality passed on cycle ${cycle} — zero critical/high issues"
 
             if [[ -n "$ISSUE_NUMBER" ]]; then
                 gh_comment_issue "$ISSUE_NUMBER" "✅ **Compound quality passed** — cycle ${cycle}/${max_cycles}
@@ -3032,6 +4731,8 @@ stage_compound_quality() {
 All quality checks clean:
 - Adversarial review: ✅
 - Negative prompting: ✅
+- Developer simulation: ✅
+- Architecture validation: ✅
 - E2E validation: ✅
 - DoD audit: ✅
 - Security audit: ✅
@@ -3045,6 +4746,36 @@ All quality checks clean:
             return 0
         fi
 
+        if $all_passed; then
+            success "Compound quality passed on cycle ${cycle}"
+
+            if [[ -n "$ISSUE_NUMBER" ]]; then
+                gh_comment_issue "$ISSUE_NUMBER" "✅ **Compound quality passed** — cycle ${cycle}/${max_cycles}" 2>/dev/null || true
+            fi
+
+            log_stage "compound_quality" "Passed on cycle ${cycle}/${max_cycles}"
+            return 0
+        fi
+
+        # Check for plateau: issue count unchanged between cycles
+        if [[ "$prev_issue_count" -ge 0 && "$current_issue_count" -eq "$prev_issue_count" && "$cycle" -gt 1 ]]; then
+            warn "Convergence: quality plateau — ${current_issue_count} issues unchanged between cycles"
+            emit_event "compound.plateau" \
+                "issue=${ISSUE_NUMBER:-0}" \
+                "cycle=$cycle" \
+                "issue_count=$current_issue_count"
+
+            if [[ -n "$ISSUE_NUMBER" ]]; then
+                gh_comment_issue "$ISSUE_NUMBER" "⚠️ **Compound quality plateau** — ${current_issue_count} issues unchanged after cycle ${cycle}. Stopping early." 2>/dev/null || true
+            fi
+
+            log_stage "compound_quality" "Plateau at cycle ${cycle}/${max_cycles} (${current_issue_count} issues)"
+            return 1
+        fi
+        prev_issue_count="$current_issue_count"
+
+        info "Convergence: ${current_issue_count} critical/high issues remaining"
+
         # Not all passed — rebuild if we have cycles left
         if [[ "$cycle" -lt "$max_cycles" ]]; then
             warn "Quality checks failed — rebuilding with feedback (cycle $((cycle + 1))/${max_cycles})"
@@ -3074,6 +4805,100 @@ Quality issues remain. Check artifacts for details." 2>/dev/null || true
     return 1
 }
 
+# ─── Error Classification ──────────────────────────────────────────────────
+# Classifies errors to determine whether retrying makes sense.
+# Returns: "infrastructure", "logic", "configuration", or "unknown"
+
+classify_error() {
+    local stage_id="$1"
+    local log_file="${ARTIFACTS_DIR}/${stage_id}-results.log"
+    [[ ! -f "$log_file" ]] && log_file="${ARTIFACTS_DIR}/test-results.log"
+    [[ ! -f "$log_file" ]] && { echo "unknown"; return; }
+
+    local log_tail
+    log_tail=$(tail -50 "$log_file" 2>/dev/null || echo "")
+
+    # Generate error signature for history lookup
+    local error_sig
+    error_sig=$(echo "$log_tail" | grep -iE 'error|fail|exception|fatal' 2>/dev/null | head -3 | cksum | awk '{print $1}' || echo "0")
+
+    # Check classification history first (learned from previous runs)
+    local class_history="${HOME}/.shipwright/optimization/error-classifications.json"
+    if [[ -f "$class_history" ]]; then
+        local cached_class
+        cached_class=$(jq -r --arg sig "$error_sig" '.[$sig].classification // empty' "$class_history" 2>/dev/null || true)
+        if [[ -n "$cached_class" && "$cached_class" != "null" ]]; then
+            echo "$cached_class"
+            return
+        fi
+    fi
+
+    local classification="unknown"
+
+    # Infrastructure errors: timeout, OOM, network — retry makes sense
+    if echo "$log_tail" | grep -qiE 'timeout|timed out|ETIMEDOUT|ECONNREFUSED|ECONNRESET|network|socket hang up|OOM|out of memory|killed|signal 9|Cannot allocate memory'; then
+        classification="infrastructure"
+    # Configuration errors: missing env, wrong path — don't retry, escalate
+    elif echo "$log_tail" | grep -qiE 'ENOENT|not found|No such file|command not found|MODULE_NOT_FOUND|Cannot find module|missing.*env|undefined variable|permission denied|EACCES'; then
+        classification="configuration"
+    # Logic errors: assertion failures, type errors — retry won't help without code change
+    elif echo "$log_tail" | grep -qiE 'AssertionError|assert.*fail|Expected.*but.*got|TypeError|ReferenceError|SyntaxError|CompileError|type mismatch|cannot assign|incompatible type'; then
+        classification="logic"
+    # Build errors: compilation failures
+    elif echo "$log_tail" | grep -qiE 'error\[E[0-9]+\]|error: aborting|FAILED.*compile|build failed|tsc.*error|eslint.*error'; then
+        classification="logic"
+    # Intelligence fallback: Claude classification for unknown errors
+    elif [[ "$classification" == "unknown" ]] && type intelligence_search_memory &>/dev/null 2>&1 && command -v claude &>/dev/null; then
+        local ai_class
+        ai_class=$(claude --print --output-format text -p "Classify this error as exactly one of: infrastructure, configuration, logic, unknown.
+
+Error output:
+$(echo "$log_tail" | tail -20)
+
+Reply with ONLY the classification word, nothing else." --model haiku < /dev/null 2>/dev/null || true)
+        ai_class=$(echo "$ai_class" | tr -d '[:space:]' | tr '[:upper:]' '[:lower:]')
+        case "$ai_class" in
+            infrastructure|configuration|logic) classification="$ai_class" ;;
+        esac
+    fi
+
+    # Map retry categories to shared taxonomy (from lib/compat.sh SW_ERROR_CATEGORIES)
+    # Retry uses: infrastructure, configuration, logic, unknown
+    # Shared uses: test_failure, build_error, lint_error, timeout, dependency, flaky, config, security, permission, unknown
+    local canonical_category="unknown"
+    case "$classification" in
+        infrastructure) canonical_category="timeout" ;;
+        configuration)  canonical_category="config" ;;
+        logic)
+            case "$stage_id" in
+                test) canonical_category="test_failure" ;;
+                *)    canonical_category="build_error" ;;
+            esac
+            ;;
+    esac
+
+    # Record classification for future runs (using both retry and canonical categories)
+    if [[ -n "$error_sig" && "$error_sig" != "0" ]]; then
+        local class_dir="${HOME}/.shipwright/optimization"
+        mkdir -p "$class_dir" 2>/dev/null || true
+        local tmp_class
+        tmp_class="$(mktemp)"
+        if [[ -f "$class_history" ]]; then
+            jq --arg sig "$error_sig" --arg cls "$classification" --arg canon "$canonical_category" --arg stage "$stage_id" \
+                '.[$sig] = {"classification": $cls, "canonical": $canon, "stage": $stage, "recorded_at": now}' \
+                "$class_history" > "$tmp_class" 2>/dev/null && \
+                mv "$tmp_class" "$class_history" || rm -f "$tmp_class"
+        else
+            jq -n --arg sig "$error_sig" --arg cls "$classification" --arg canon "$canonical_category" --arg stage "$stage_id" \
+                '{($sig): {"classification": $cls, "canonical": $canon, "stage": $stage, "recorded_at": now}}' \
+                > "$tmp_class" 2>/dev/null && \
+                mv "$tmp_class" "$class_history" || rm -f "$tmp_class"
+        fi
+    fi
+
+    echo "$classification"
+}
+
 # ─── Stage Runner ───────────────────────────────────────────────────────────
 
 run_stage_with_retry() {
@@ -3083,6 +4908,7 @@ run_stage_with_retry() {
     [[ -z "$max_retries" || "$max_retries" == "null" ]] && max_retries=0
 
     local attempt=0
+    local prev_error_class=""
     while true; do
         if "stage_${stage_id}"; then
             return 0
@@ -3093,8 +4919,53 @@ run_stage_with_retry() {
             return 1
         fi
 
-        warn "Stage $stage_id failed (attempt $attempt/$((max_retries + 1))) — retrying..."
-        sleep 2
+        # Classify the error to decide whether retry makes sense
+        local error_class
+        error_class=$(classify_error "$stage_id")
+
+        emit_event "retry.classified" \
+            "issue=${ISSUE_NUMBER:-0}" \
+            "stage=$stage_id" \
+            "attempt=$attempt" \
+            "error_class=$error_class"
+
+        case "$error_class" in
+            infrastructure)
+                info "Error classified as infrastructure (timeout/network/OOM) — retry makes sense"
+                ;;
+            configuration)
+                error "Error classified as configuration (missing env/path) — skipping retry, escalating"
+                emit_event "retry.escalated" \
+                    "issue=${ISSUE_NUMBER:-0}" \
+                    "stage=$stage_id" \
+                    "reason=configuration_error"
+                return 1
+                ;;
+            logic)
+                if [[ "$error_class" == "$prev_error_class" ]]; then
+                    error "Error classified as logic (assertion/type error) with same class — retry won't help without code change"
+                    emit_event "retry.skipped" \
+                        "issue=${ISSUE_NUMBER:-0}" \
+                        "stage=$stage_id" \
+                        "reason=repeated_logic_error"
+                    return 1
+                fi
+                warn "Error classified as logic — retrying once in case build fixes it"
+                ;;
+            *)
+                info "Error classification: unknown — retrying"
+                ;;
+        esac
+        prev_error_class="$error_class"
+
+        warn "Stage $stage_id failed (attempt $attempt/$((max_retries + 1)), class: $error_class) — retrying..."
+        # Exponential backoff with jitter to avoid thundering herd
+        local backoff=$((2 ** attempt))
+        [[ "$backoff" -gt 16 ]] && backoff=16
+        local jitter=$(( RANDOM % (backoff + 1) ))
+        local total_sleep=$((backoff + jitter))
+        info "Backing off ${total_sleep}s before retry..."
+        sleep "$total_sleep"
     done
 }
 
@@ -3107,6 +4978,25 @@ self_healing_build_test() {
     local max_cycles="$BUILD_TEST_RETRIES"
     local last_test_error=""
 
+    # Convergence tracking
+    local prev_error_sig="" consecutive_same_error=0
+    local prev_fail_count=0 zero_convergence_streak=0
+
+    # Intelligence: adaptive iteration limit
+    if type composer_estimate_iterations &>/dev/null 2>&1; then
+        local estimated
+        estimated=$(composer_estimate_iterations \
+            "${INTELLIGENCE_ANALYSIS:-{}}" \
+            "${HOME}/.shipwright/optimization/iteration-model.json" 2>/dev/null || echo "")
+        if [[ -n "$estimated" && "$estimated" =~ ^[0-9]+$ && "$estimated" -gt 0 ]]; then
+            max_cycles="$estimated"
+            emit_event "intelligence.adaptive_iterations" \
+                "issue=${ISSUE_NUMBER:-0}" \
+                "estimated=$estimated" \
+                "original=$BUILD_TEST_RETRIES"
+        fi
+    fi
+
     while [[ "$cycle" -le "$max_cycles" ]]; do
         cycle=$((cycle + 1))
 
@@ -3182,6 +5072,9 @@ Focus on fixing the failing tests while keeping all passing tests working."
             local timing
             timing=$(get_stage_timing "test")
             success "Stage ${BOLD}test${RESET} complete ${DIM}(${timing})${RESET}"
+            emit_event "convergence.tests_passed" \
+                "issue=${ISSUE_NUMBER:-0}" \
+                "cycle=$cycle"
             return 0  # Tests passed!
         fi
 
@@ -3190,6 +5083,59 @@ Focus on fixing the failing tests while keeping all passing tests working."
         last_test_error=$(tail -30 "$test_log" 2>/dev/null || echo "Test command failed with no output")
         mark_stage_failed "test"
 
+        # ── Convergence Detection ──
+        # Hash the error output to detect repeated failures
+        local error_sig
+        error_sig=$(echo "$last_test_error" | shasum -a 256 2>/dev/null | cut -c1-16 || echo "unknown")
+
+        # Count failing tests (extract from common patterns)
+        local current_fail_count=0
+        current_fail_count=$(grep -ciE 'fail|error|FAIL' "$test_log" 2>/dev/null || true)
+        current_fail_count="${current_fail_count:-0}"
+
+        if [[ "$error_sig" == "$prev_error_sig" ]]; then
+            consecutive_same_error=$((consecutive_same_error + 1))
+        else
+            consecutive_same_error=1
+        fi
+        prev_error_sig="$error_sig"
+
+        # Check: same error 3 times consecutively → stuck
+        if [[ "$consecutive_same_error" -ge 3 ]]; then
+            error "Convergence: stuck on same error for 3 consecutive cycles — exiting early"
+            emit_event "convergence.stuck" \
+                "issue=${ISSUE_NUMBER:-0}" \
+                "cycle=$cycle" \
+                "error_sig=$error_sig" \
+                "consecutive=$consecutive_same_error"
+            notify "Build Convergence" "Stuck on unfixable error after ${cycle} cycles" "error"
+            return 1
+        fi
+
+        # Track convergence rate: did we reduce failures?
+        if [[ "$cycle" -gt 1 && "$prev_fail_count" -gt 0 ]]; then
+            if [[ "$current_fail_count" -ge "$prev_fail_count" ]]; then
+                zero_convergence_streak=$((zero_convergence_streak + 1))
+            else
+                zero_convergence_streak=0
+            fi
+
+            # Check: zero convergence for 2 consecutive iterations → plateau
+            if [[ "$zero_convergence_streak" -ge 2 ]]; then
+                error "Convergence: no progress for 2 consecutive cycles (${current_fail_count} failures remain) — exiting early"
+                emit_event "convergence.plateau" \
+                    "issue=${ISSUE_NUMBER:-0}" \
+                    "cycle=$cycle" \
+                    "fail_count=$current_fail_count" \
+                    "streak=$zero_convergence_streak"
+                notify "Build Convergence" "No progress after ${cycle} cycles — plateau reached" "error"
+                return 1
+            fi
+        fi
+        prev_fail_count="$current_fail_count"
+
+        info "Convergence: error_sig=${error_sig:0:8} repeat=${consecutive_same_error} failures=${current_fail_count} no_progress=${zero_convergence_streak}"
+
         if [[ "$cycle" -le "$max_cycles" ]]; then
             warn "Tests failed — will attempt self-healing (cycle $((cycle + 1))/$((max_cycles + 1)))"
             notify "Self-Healing" "Tests failed on cycle ${cycle}, retrying..." "warn"
@@ -3256,7 +5202,7 @@ run_pipeline() {
         use_self_healing=true
     fi
 
-    while IFS= read -r stage; do
+    while IFS= read -r -u 3 stage; do
         local id enabled gate
         id=$(echo "$stage" | jq -r '.id')
         enabled=$(echo "$stage" | jq -r '.enabled')
@@ -3264,6 +5210,34 @@ run_pipeline() {
 
         CURRENT_STAGE_ID="$id"
 
+        # Human intervention: check for skip-stage directive
+        if [[ -f "$ARTIFACTS_DIR/skip-stage.txt" ]]; then
+            local skip_list
+            skip_list="$(cat "$ARTIFACTS_DIR/skip-stage.txt" 2>/dev/null || true)"
+            if echo "$skip_list" | grep -qx "$id" 2>/dev/null; then
+                info "Stage ${BOLD}${id}${RESET} skipped by human directive"
+                emit_event "stage.skipped" "issue=${ISSUE_NUMBER:-0}" "stage=$id" "reason=human_skip"
+                # Remove this stage from the skip file
+                local tmp_skip
+                tmp_skip="$(mktemp)"
+                grep -vx "$id" "$ARTIFACTS_DIR/skip-stage.txt" > "$tmp_skip" 2>/dev/null || true
+                mv "$tmp_skip" "$ARTIFACTS_DIR/skip-stage.txt"
+                continue
+            fi
+        fi
+
+        # Human intervention: check for human message
+        if [[ -f "$ARTIFACTS_DIR/human-message.txt" ]]; then
+            local human_msg
+            human_msg="$(cat "$ARTIFACTS_DIR/human-message.txt" 2>/dev/null || true)"
+            if [[ -n "$human_msg" ]]; then
+                echo ""
+                echo -e "  ${PURPLE}${BOLD}💬 Human message:${RESET} $human_msg"
+                emit_event "pipeline.human_message" "issue=${ISSUE_NUMBER:-0}" "stage=$id" "message=$human_msg"
+                rm -f "$ARTIFACTS_DIR/human-message.txt"
+            fi
+        fi
+
         if [[ "$enabled" != "true" ]]; then
             echo -e "  ${DIM}○ ${id} — skipped (disabled)${RESET}"
             continue
@@ -3277,6 +5251,15 @@ run_pipeline() {
             continue
         fi
 
+        # CI resume: skip stages marked as completed from previous run
+        if [[ -n "${COMPLETED_STAGES:-}" ]] && echo "$COMPLETED_STAGES" | tr ',' '\n' | grep -qx "$id"; then
+            echo -e "  ${GREEN}✓ ${id}${RESET} ${DIM}— skipped (CI resume)${RESET}"
+            set_stage_status "$id" "complete"
+            completed=$((completed + 1))
+            emit_event "stage.skipped" "issue=${ISSUE_NUMBER:-0}" "stage=$id" "reason=ci_resume"
+            continue
+        fi
+
         # Self-healing build→test loop: when we hit build, run both together
         if [[ "$id" == "build" && "$use_self_healing" == "true" ]]; then
             # Gate check for build
@@ -3325,9 +5308,9 @@ run_pipeline() {
         fi
 
         # Budget enforcement check (skip with --ignore-budget)
-        if [[ "$IGNORE_BUDGET" != "true" ]] && [[ -x "$SCRIPT_DIR/cct-cost.sh" ]]; then
+        if [[ "$IGNORE_BUDGET" != "true" ]] && [[ -x "$SCRIPT_DIR/sw-cost.sh" ]]; then
             local budget_rc=0
-            bash "$SCRIPT_DIR/cct-cost.sh" check-budget 2>/dev/null || budget_rc=$?
+            bash "$SCRIPT_DIR/sw-cost.sh" check-budget 2>/dev/null || budget_rc=$?
             if [[ "$budget_rc" -eq 2 ]]; then
                 warn "Daily budget exceeded — pausing pipeline before stage ${BOLD}$id${RESET}"
                 warn "Resume with --ignore-budget to override, or wait until tomorrow"
@@ -3337,6 +5320,71 @@ run_pipeline() {
             fi
         fi
 
+        # Intelligence: per-stage model routing with A/B testing
+        if type intelligence_recommend_model &>/dev/null 2>&1; then
+            local stage_complexity="${INTELLIGENCE_COMPLEXITY:-5}"
+            local budget_remaining=""
+            if [[ -x "$SCRIPT_DIR/sw-cost.sh" ]]; then
+                budget_remaining=$(bash "$SCRIPT_DIR/sw-cost.sh" remaining-budget 2>/dev/null || echo "")
+            fi
+            local recommended_model
+            recommended_model=$(intelligence_recommend_model "$id" "$stage_complexity" "$budget_remaining" 2>/dev/null || echo "")
+            if [[ -n "$recommended_model" && "$recommended_model" != "null" ]]; then
+                # A/B testing: decide whether to use the recommended model
+                local ab_ratio=20  # default 20% use recommended model
+                local daemon_cfg="${PROJECT_ROOT}/.claude/daemon-config.json"
+                if [[ -f "$daemon_cfg" ]]; then
+                    local cfg_ratio
+                    cfg_ratio=$(jq -r '.intelligence.ab_test_ratio // 0.2' "$daemon_cfg" 2>/dev/null || echo "0.2")
+                    # Convert ratio (0.0-1.0) to percentage (0-100)
+                    ab_ratio=$(awk -v r="$cfg_ratio" 'BEGIN{printf "%d", r * 100}' 2>/dev/null || echo "20")
+                fi
+
+                # Check if we have enough data points to graduate from A/B testing
+                local routing_file="${HOME}/.shipwright/optimization/model-routing.json"
+                local use_recommended=false
+                local ab_group="control"
+
+                if [[ -f "$routing_file" ]]; then
+                    local stage_samples
+                    stage_samples=$(jq -r --arg s "$id" '.[$s].sonnet_samples // 0' "$routing_file" 2>/dev/null || echo "0")
+                    local total_samples
+                    total_samples=$(jq -r --arg s "$id" '((.[$s].sonnet_samples // 0) + (.[$s].opus_samples // 0))' "$routing_file" 2>/dev/null || echo "0")
+
+                    if [[ "$total_samples" -ge 50 ]]; then
+                        # Enough data — use optimizer's recommendation as default
+                        use_recommended=true
+                        ab_group="graduated"
+                    fi
+                fi
+
+                if [[ "$use_recommended" != "true" ]]; then
+                    # A/B test: RANDOM % 100 < ab_ratio → use recommended
+                    local roll=$((RANDOM % 100))
+                    if [[ "$roll" -lt "$ab_ratio" ]]; then
+                        use_recommended=true
+                        ab_group="experiment"
+                    else
+                        ab_group="control"
+                    fi
+                fi
+
+                if [[ "$use_recommended" == "true" ]]; then
+                    export CLAUDE_MODEL="$recommended_model"
+                else
+                    export CLAUDE_MODEL="opus"
+                fi
+
+                emit_event "intelligence.model_ab" \
+                    "issue=${ISSUE_NUMBER:-0}" \
+                    "stage=$id" \
+                    "recommended=$recommended_model" \
+                    "applied=$CLAUDE_MODEL" \
+                    "ab_group=$ab_group" \
+                    "ab_ratio=$ab_ratio"
+            fi
+        fi
+
         echo ""
         echo -e "${CYAN}${BOLD}▸ Stage: ${id}${RESET} ${DIM}[$((completed + 1))/${enabled_count}]${RESET}"
         update_status "running" "$id"
@@ -3345,6 +5393,12 @@ run_pipeline() {
         stage_start_epoch=$(now_epoch)
         emit_event "stage.started" "issue=${ISSUE_NUMBER:-0}" "stage=$id"
 
+        # Mark GitHub Check Run as in-progress
+        if [[ "${NO_GITHUB:-false}" != "true" ]] && type gh_checks_stage_update &>/dev/null 2>&1; then
+            gh_checks_stage_update "$id" "in_progress" "" "Stage $id started" 2>/dev/null || true
+        fi
+
+        local stage_model_used="${CLAUDE_MODEL:-${MODEL:-opus}}"
         if run_stage_with_retry "$id"; then
             mark_stage_complete "$id"
             completed=$((completed + 1))
@@ -3353,6 +5407,8 @@ run_pipeline() {
             stage_dur_s=$(( $(now_epoch) - stage_start_epoch ))
             success "Stage ${BOLD}$id${RESET} complete ${DIM}(${timing})${RESET}"
             emit_event "stage.completed" "issue=${ISSUE_NUMBER:-0}" "stage=$id" "duration_s=$stage_dur_s"
+            # Log model used for prediction feedback
+            echo "${id}|${stage_model_used}|true" >> "${ARTIFACTS_DIR}/model-routing.log"
         else
             mark_stage_failed "$id"
             local stage_dur_s
@@ -3360,9 +5416,11 @@ run_pipeline() {
             error "Pipeline failed at stage: ${BOLD}$id${RESET}"
             update_status "failed" "$id"
             emit_event "stage.failed" "issue=${ISSUE_NUMBER:-0}" "stage=$id" "duration_s=$stage_dur_s"
+            # Log model used for prediction feedback
+            echo "${id}|${stage_model_used}|false" >> "${ARTIFACTS_DIR}/model-routing.log"
             return 1
         fi
-    done <<< "$stages"
+    done 3<<< "$stages"
 
     # Pipeline complete!
     update_status "complete" ""
@@ -3388,8 +5446,8 @@ run_pipeline() {
     echo ""
 
     # Capture learnings to memory (success or failure)
-    if [[ -x "$SCRIPT_DIR/cct-memory.sh" ]]; then
-        bash "$SCRIPT_DIR/cct-memory.sh" capture "$STATE_FILE" "$ARTIFACTS_DIR" 2>/dev/null || true
+    if [[ -x "$SCRIPT_DIR/sw-memory.sh" ]]; then
+        bash "$SCRIPT_DIR/sw-memory.sh" capture "$STATE_FILE" "$ARTIFACTS_DIR" 2>/dev/null || true
     fi
 
     # Final GitHub progress update
@@ -3482,7 +5540,7 @@ pipeline_start() {
     # Register worktree cleanup on exit (chain with existing cleanup)
     if [[ "$CLEANUP_WORKTREE" == "true" ]]; then
         trap 'pipeline_cleanup_worktree; cleanup_on_exit' SIGINT SIGTERM
-        trap 'pipeline_cleanup_worktree' EXIT
+        trap 'pipeline_cleanup_worktree; cleanup_on_exit' EXIT
     fi
 
     setup_dirs
@@ -3508,6 +5566,30 @@ pipeline_start() {
     load_pipeline_config
     initialize_state
 
+    # CI resume: restore branch + goal context when intake is skipped
+    if [[ -n "${COMPLETED_STAGES:-}" ]] && echo "$COMPLETED_STAGES" | tr ',' '\n' | grep -qx "intake"; then
+        # Intake was completed in a previous run — restore context
+        # The workflow merges the partial work branch, so code changes are on HEAD
+
+        # Restore GOAL from issue if not already set
+        if [[ -z "$GOAL" && -n "$ISSUE_NUMBER" ]]; then
+            GOAL=$(gh issue view "$ISSUE_NUMBER" --json title -q .title 2>/dev/null || echo "Issue #${ISSUE_NUMBER}")
+            info "CI resume: goal from issue — ${GOAL}"
+        fi
+
+        # Restore branch context
+        if [[ -z "$GIT_BRANCH" ]]; then
+            local ci_branch="ci/issue-${ISSUE_NUMBER}"
+            info "CI resume: creating branch ${ci_branch} from current HEAD"
+            git checkout -b "$ci_branch" 2>/dev/null || git checkout "$ci_branch" 2>/dev/null || true
+            GIT_BRANCH="$ci_branch"
+        elif [[ "$(git branch --show-current 2>/dev/null)" != "$GIT_BRANCH" ]]; then
+            info "CI resume: checking out branch ${GIT_BRANCH}"
+            git checkout -b "$GIT_BRANCH" 2>/dev/null || git checkout "$GIT_BRANCH" 2>/dev/null || true
+        fi
+        write_state 2>/dev/null || true
+    fi
+
     echo ""
     echo -e "${PURPLE}${BOLD}╔═══════════════════════════════════════════════════════════════════╗${RESET}"
     echo -e "${PURPLE}${BOLD}║  shipwright pipeline — Autonomous Feature Delivery               ║${RESET}"
@@ -3556,6 +5638,21 @@ pipeline_start() {
         return 0
     fi
 
+    # Start background heartbeat writer
+    start_heartbeat
+
+    # Initialize GitHub Check Runs for all pipeline stages
+    if [[ "${NO_GITHUB:-false}" != "true" ]] && type gh_checks_pipeline_start &>/dev/null 2>&1; then
+        local head_sha
+        head_sha=$(git rev-parse HEAD 2>/dev/null || echo "")
+        if [[ -n "$head_sha" && -n "$REPO_OWNER" && -n "$REPO_NAME" ]]; then
+            local stages_json
+            stages_json=$(jq -c '[.stages[] | select(.enabled == true) | .id]' "$PIPELINE_CONFIG" 2>/dev/null || echo '[]')
+            gh_checks_pipeline_start "$REPO_OWNER" "$REPO_NAME" "$head_sha" "$stages_json" >/dev/null 2>/dev/null || true
+            info "GitHub Checks: created check runs for pipeline stages"
+        fi
+    fi
+
     # Send start notification
     notify "Pipeline Started" "Goal: ${GOAL}\nPipeline: ${PIPELINE_NAME}" "info"
 
@@ -3597,12 +5694,56 @@ pipeline_start() {
             "self_heal_count=$SELF_HEAL_COUNT"
 
         # Capture failure learnings to memory
-        if [[ -x "$SCRIPT_DIR/cct-memory.sh" ]]; then
-            bash "$SCRIPT_DIR/cct-memory.sh" capture "$STATE_FILE" "$ARTIFACTS_DIR" 2>/dev/null || true
-            bash "$SCRIPT_DIR/cct-memory.sh" analyze-failure "$ARTIFACTS_DIR/.claude-tokens-${CURRENT_STAGE_ID:-build}.log" "${CURRENT_STAGE_ID:-unknown}" 2>/dev/null || true
+        if [[ -x "$SCRIPT_DIR/sw-memory.sh" ]]; then
+            bash "$SCRIPT_DIR/sw-memory.sh" capture "$STATE_FILE" "$ARTIFACTS_DIR" 2>/dev/null || true
+            bash "$SCRIPT_DIR/sw-memory.sh" analyze-failure "$ARTIFACTS_DIR/.claude-tokens-${CURRENT_STAGE_ID:-build}.log" "${CURRENT_STAGE_ID:-unknown}" 2>/dev/null || true
         fi
     fi
 
+    # ── Prediction Validation Events ──
+    # Compare predicted vs actual outcomes for feedback loop calibration
+    local pipeline_success="false"
+    [[ "$exit_code" -eq 0 ]] && pipeline_success="true"
+
+    # Complexity prediction vs actual iterations
+    emit_event "prediction.validated" \
+        "issue=${ISSUE_NUMBER:-0}" \
+        "predicted_complexity=${INTELLIGENCE_COMPLEXITY:-0}" \
+        "actual_iterations=$SELF_HEAL_COUNT" \
+        "success=$pipeline_success"
+
+    # Template outcome tracking
+    emit_event "template.outcome" \
+        "issue=${ISSUE_NUMBER:-0}" \
+        "template=${PIPELINE_NAME}" \
+        "success=$pipeline_success" \
+        "duration_s=${total_dur_s:-0}"
+
+    # Risk prediction vs actual failure
+    local predicted_risk="${INTELLIGENCE_RISK_SCORE:-0}"
+    emit_event "risk.outcome" \
+        "issue=${ISSUE_NUMBER:-0}" \
+        "predicted_risk=$predicted_risk" \
+        "actual_failure=$([[ "$exit_code" -ne 0 ]] && echo "true" || echo "false")"
+
+    # Per-stage model outcome events (read from stage timings)
+    local routing_log="${ARTIFACTS_DIR}/model-routing.log"
+    if [[ -f "$routing_log" ]]; then
+        while IFS='|' read -r s_stage s_model s_success; do
+            [[ -z "$s_stage" ]] && continue
+            emit_event "model.outcome" \
+                "issue=${ISSUE_NUMBER:-0}" \
+                "stage=$s_stage" \
+                "model=$s_model" \
+                "success=$s_success"
+        done < "$routing_log"
+    fi
+
+    # Record pipeline outcome for model routing feedback loop
+    if type optimize_analyze_outcome &>/dev/null 2>&1; then
+        optimize_analyze_outcome "$STATE_FILE" 2>/dev/null || true
+    fi
+
     # Emit cost event
     local model_key="${MODEL:-sonnet}"
     local input_cost output_cost total_cost
@@ -3754,7 +5895,7 @@ pipeline_abort() {
 pipeline_list() {
     local locations=(
         "$REPO_DIR/templates/pipelines"
-        "$HOME/.claude-teams/pipelines"
+        "$HOME/.shipwright/pipelines"
     )
 
     echo ""
@@ -3832,7 +5973,7 @@ case "$SUBCOMMAND" in
     show)           pipeline_show ;;
     test)
         SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-        exec "$SCRIPT_DIR/cct-pipeline-test.sh" "$@"
+        exec "$SCRIPT_DIR/sw-pipeline-test.sh" "$@"
         ;;
     help|--help|-h) show_help ;;
     *)