shipwright-cli 2.0.0 → 2.1.1

package/scripts/sw-pipeline.sh

@@ -11,7 +11,7 @@ unset CLAUDECODE 2>/dev/null || true
 # Ignore SIGHUP so tmux attach/detach doesn't kill long-running plan/design/review stages
 trap '' HUP
 
-VERSION="2.0.0"
+VERSION="2.1.1"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
@@ -202,7 +202,9 @@ PIPELINE_CONFIG=""
 TEST_CMD=""
 MODEL=""
 AGENTS=""
+PIPELINE_AGENT_ID="${PIPELINE_AGENT_ID:-pipeline-$$}"
 SKIP_GATES=false
+HEADLESS=false
 GIT_BRANCH=""
 GITHUB_ISSUE=""
 TASK_TYPE=""
@@ -223,7 +225,9 @@ AUTO_WORKTREE=false
 WORKTREE_NAME=""
 CLEANUP_WORKTREE=false
 ORIGINAL_REPO_DIR=""
+REPO_OVERRIDE=""
 _cleanup_done=""
+PIPELINE_EXIT_CODE=1  # assume failure until run_pipeline succeeds
 
 # GitHub metadata (populated during intake)
 ISSUE_LABELS=""
@@ -264,11 +268,14 @@ show_help() {
     echo -e "${BOLD}START OPTIONS${RESET}"
     echo -e "  ${DIM}--goal \"description\"${RESET}     What to build (required unless --issue)"
     echo -e "  ${DIM}--issue <number>${RESET}          Fetch goal from GitHub issue"
+    echo -e "  ${DIM}--repo <path>${RESET}             Change to directory before running (must be a git repo)"
+    echo -e "  ${DIM}--local${RESET}                   Alias for --no-github --no-github-label (local-only mode)"
     echo -e "  ${DIM}--pipeline <name>${RESET}         Pipeline template (default: standard)"
     echo -e "  ${DIM}--test-cmd \"command\"${RESET}     Override test command (auto-detected if omitted)"
     echo -e "  ${DIM}--model <model>${RESET}           Override AI model (opus, sonnet, haiku)"
     echo -e "  ${DIM}--agents <n>${RESET}              Override agent count"
     echo -e "  ${DIM}--skip-gates${RESET}              Auto-approve all gates (fully autonomous)"
+    echo -e "  ${DIM}--headless${RESET}                Full headless mode (skip gates, no prompts)"
     echo -e "  ${DIM}--base <branch>${RESET}           Base branch for PR (default: main)"
     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)"
@@ -346,11 +353,14 @@ parse_args() {
         case "$1" in
             --goal)        GOAL="$2"; shift 2 ;;
             --issue)       ISSUE_NUMBER="$2"; shift 2 ;;
+            --repo)        REPO_OVERRIDE="$2"; shift 2 ;;
+            --local)       NO_GITHUB=true; NO_GITHUB_LABEL=true; shift ;;
             --pipeline|--template) PIPELINE_NAME="$2"; shift 2 ;;
             --test-cmd)    TEST_CMD="$2"; shift 2 ;;
             --model)       MODEL="$2"; shift 2 ;;
             --agents)      AGENTS="$2"; shift 2 ;;
             --skip-gates)  SKIP_GATES=true; shift ;;
+            --headless)    HEADLESS=true; SKIP_GATES=true; shift ;;
             --base)        BASE_BRANCH="$2"; shift 2 ;;
             --reviewers)   REVIEWERS="$2"; shift 2 ;;
             --labels)      LABELS="$2"; shift 2 ;;
@@ -387,6 +397,20 @@ parse_args() {
 PIPELINE_NAME_ARG=""
 parse_args "$@"
 
+# ─── Non-Interactive Detection ──────────────────────────────────────────────
+# When stdin is not a terminal (background, pipe, nohup, tmux send-keys),
+# auto-enable headless mode to prevent read prompts from killing the script.
+if [[ ! -t 0 ]]; then
+    HEADLESS=true
+    if [[ "$SKIP_GATES" != "true" ]]; then
+        SKIP_GATES=true
+    fi
+fi
+# --worktree implies headless when stdin is not a terminal
+if [[ "$AUTO_WORKTREE" == "true" && "$SKIP_GATES" != "true" && ! -t 0 ]]; then
+    SKIP_GATES=true
+fi
+
 # ─── Directory Setup ────────────────────────────────────────────────────────
 
 setup_dirs() {
@@ -396,6 +420,7 @@ setup_dirs() {
     ARTIFACTS_DIR="$STATE_DIR/pipeline-artifacts"
     TASKS_FILE="$STATE_DIR/pipeline-tasks.md"
     mkdir -p "$STATE_DIR" "$ARTIFACTS_DIR"
+    export SHIPWRIGHT_PIPELINE_ID="pipeline-$$-${ISSUE_NUMBER:-0}"
 }
 
 # ─── Pipeline Config Loading ───────────────────────────────────────────────
@@ -404,10 +429,11 @@ find_pipeline_config() {
     local name="$1"
     local locations=(
         "$REPO_DIR/templates/pipelines/${name}.json"
+        "${PROJECT_ROOT:-}/templates/pipelines/${name}.json"
         "$HOME/.shipwright/pipelines/${name}.json"
     )
     for loc in "${locations[@]}"; do
-        if [[ -f "$loc" ]]; then
+        if [[ -n "$loc" && -f "$loc" ]]; then
             echo "$loc"
             return 0
         fi
@@ -1155,6 +1181,21 @@ get_stage_timing() {
     fi
 }
 
+# Raw seconds for a stage (for memory baseline updates)
+get_stage_timing_seconds() {
+    local stage_id="$1"
+    local start_e end_e
+    start_e=$(echo "$STAGE_TIMINGS" | grep "^${stage_id}_start:" | cut -d: -f2 | tail -1 || true)
+    end_e=$(echo "$STAGE_TIMINGS" | grep "^${stage_id}_end:" | cut -d: -f2 | tail -1 || true)
+    if [[ -n "$start_e" && -n "$end_e" ]]; then
+        echo $(( end_e - start_e ))
+    elif [[ -n "$start_e" ]]; then
+        echo $(( $(now_epoch) - start_e ))
+    else
+        echo "0"
+    fi
+}
+
 get_stage_description() {
     local stage_id="$1"
 
@@ -1250,6 +1291,22 @@ mark_stage_complete() {
     log_stage "$stage_id" "complete (${timing})"
     write_state
 
+    record_stage_effectiveness "$stage_id" "complete"
+    # Update memory baselines and predictive baselines for stage durations
+    if [[ "$stage_id" == "test" || "$stage_id" == "build" ]]; then
+        local secs
+        secs=$(get_stage_timing_seconds "$stage_id")
+        if [[ -n "$secs" && "$secs" != "0" ]]; then
+            [[ -x "$SCRIPT_DIR/sw-memory.sh" ]] && bash "$SCRIPT_DIR/sw-memory.sh" metric "${stage_id}_duration_s" "$secs" 2>/dev/null || true
+            if [[ -x "$SCRIPT_DIR/sw-predictive.sh" ]]; then
+                local anomaly_sev
+                anomaly_sev=$(bash "$SCRIPT_DIR/sw-predictive.sh" anomaly "$stage_id" "duration_s" "$secs" 2>/dev/null || echo "normal")
+                [[ "$anomaly_sev" == "critical" || "$anomaly_sev" == "warning" ]] && emit_event "pipeline.anomaly" "stage=$stage_id" "metric=duration_s" "value=$secs" "severity=$anomaly_sev" 2>/dev/null || true
+                bash "$SCRIPT_DIR/sw-predictive.sh" baseline "$stage_id" "duration_s" "$secs" 2>/dev/null || true
+            fi
+        fi
+    fi
+
     # Update GitHub progress comment
     if [[ -n "$ISSUE_NUMBER" ]]; then
         local body
@@ -1346,9 +1403,40 @@ verify_stage_artifacts() {
     return "$missing"
 }
 
+# Self-aware pipeline: record stage effectiveness for meta-cognition
+STAGE_EFFECTIVENESS_FILE="${HOME}/.shipwright/stage-effectiveness.jsonl"
+record_stage_effectiveness() {
+    local stage_id="$1" outcome="${2:-failed}"
+    mkdir -p "${HOME}/.shipwright"
+    echo "{\"stage\":\"$stage_id\",\"outcome\":\"$outcome\",\"ts\":\"$(now_iso)\"}" >> "${STAGE_EFFECTIVENESS_FILE}"
+    # Keep last 100 entries
+    tail -100 "${STAGE_EFFECTIVENESS_FILE}" > "${STAGE_EFFECTIVENESS_FILE}.tmp" 2>/dev/null && mv "${STAGE_EFFECTIVENESS_FILE}.tmp" "${STAGE_EFFECTIVENESS_FILE}" 2>/dev/null || true
+}
+get_stage_self_awareness_hint() {
+    local stage_id="$1"
+    [[ ! -f "$STAGE_EFFECTIVENESS_FILE" ]] && return 0
+    local recent
+    recent=$(grep "\"stage\":\"$stage_id\"" "$STAGE_EFFECTIVENESS_FILE" 2>/dev/null | tail -10 || true)
+    [[ -z "$recent" ]] && return 0
+    local failures=0 total=0
+    while IFS= read -r line; do
+        [[ -z "$line" ]] && continue
+        total=$((total + 1))
+        echo "$line" | grep -q '"outcome":"failed"' && failures=$((failures + 1)) || true
+    done <<< "$recent"
+    if [[ "$total" -ge 3 ]] && [[ $((failures * 100 / total)) -ge 50 ]]; then
+        case "$stage_id" in
+            plan)  echo "Recent plan stage failures: consider adding more context or breaking the goal into smaller steps." ;;
+            build) echo "Recent build stage failures: consider adding test expectations or simplifying the change." ;;
+            *)     echo "Recent $stage_id failures: review past logs and adjust approach." ;;
+        esac
+    fi
+}
+
 mark_stage_failed() {
     local stage_id="$1"
     record_stage_end "$stage_id"
+    record_stage_effectiveness "$stage_id" "failed"
     set_stage_status "$stage_id" "failed"
     local timing
     timing=$(get_stage_timing "$stage_id")
@@ -1779,6 +1867,28 @@ ${memory_summary}
         fi
     fi
 
+    # Self-aware pipeline: inject hint when plan stage has been failing recently
+    local plan_hint
+    plan_hint=$(get_stage_self_awareness_hint "plan" 2>/dev/null || true)
+    if [[ -n "$plan_hint" ]]; then
+        plan_prompt="${plan_prompt}
+## Self-Assessment (recent plan stage performance)
+${plan_hint}
+"
+    fi
+
+    # Inject cross-pipeline discoveries (from other concurrent/similar pipelines)
+    if [[ -x "$SCRIPT_DIR/sw-discovery.sh" ]]; then
+        local plan_discoveries
+        plan_discoveries=$("$SCRIPT_DIR/sw-discovery.sh" inject "*.md,*.json" 2>/dev/null | head -20 || true)
+        if [[ -n "$plan_discoveries" ]]; then
+            plan_prompt="${plan_prompt}
+## Discoveries from Other Pipelines
+${plan_discoveries}
+"
+        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")
@@ -2151,6 +2261,12 @@ stage_design() {
         memory_context=$(bash "$SCRIPT_DIR/sw-memory.sh" inject "design" 2>/dev/null) || true
     fi
 
+    # Inject cross-pipeline discoveries for design stage
+    local design_discoveries=""
+    if [[ -x "$SCRIPT_DIR/sw-discovery.sh" ]]; then
+        design_discoveries=$("$SCRIPT_DIR/sw-discovery.sh" inject "*.md,*.ts,*.tsx,*.js" 2>/dev/null | head -20 || true)
+    fi
+
     # Inject architecture model patterns if available
     local arch_context=""
     local repo_hash
@@ -2210,7 +2326,10 @@ ${memory_context}
 }${arch_context:+
 ## Architecture Model (from previous designs)
 ${arch_context}
-}${design_antipatterns}
+}${design_antipatterns}${design_discoveries:+
+## Discoveries from Other Pipelines
+${design_discoveries}
+}
 ## Required Output — Architecture Decision Record
 
 Produce this EXACT format:
@@ -2334,6 +2453,18 @@ Historical context (lessons from previous pipelines):
 ${memory_context}"
     fi
 
+    # Inject cross-pipeline discoveries for build stage
+    if [[ -x "$SCRIPT_DIR/sw-discovery.sh" ]]; then
+        local build_discoveries
+        build_discoveries=$("$SCRIPT_DIR/sw-discovery.sh" inject "src/*,*.ts,*.tsx,*.js" 2>/dev/null | head -20 || true)
+        if [[ -n "$build_discoveries" ]]; then
+            enriched_goal="${enriched_goal}
+
+Discoveries from other pipelines:
+${build_discoveries}"
+        fi
+    fi
+
     # Add task list context
     if [[ -s "$TASKS_FILE" ]]; then
         enriched_goal="${enriched_goal}
@@ -2380,6 +2511,19 @@ Coverage baseline: ${coverage_baseline}% — do not decrease coverage."
         fi
     fi
 
+    # Predictive: inject prevention hints when risk/memory patterns suggest build-stage failures
+    if [[ -x "$SCRIPT_DIR/sw-predictive.sh" ]]; then
+        local issue_json_build="{}"
+        [[ -n "${ISSUE_NUMBER:-}" ]] && issue_json_build=$(jq -n --arg title "${GOAL:-}" --arg num "${ISSUE_NUMBER:-}" '{title: $title, number: $num}')
+        local prevention_text
+        prevention_text=$(bash "$SCRIPT_DIR/sw-predictive.sh" inject-prevention "build" "$issue_json_build" 2>/dev/null || true)
+        if [[ -n "$prevention_text" ]]; then
+            enriched_goal="${enriched_goal}
+
+${prevention_text}"
+        fi
+    fi
+
     loop_args+=("$enriched_goal")
 
     # Build loop args from pipeline config + CLI overrides
@@ -2432,6 +2576,23 @@ Coverage baseline: ${coverage_baseline}% — do not decrease coverage."
         build_model="$CLAUDE_MODEL"
     fi
 
+    # Recruit-powered model selection (when no explicit override)
+    if [[ -z "$MODEL" ]] && [[ -x "$SCRIPT_DIR/sw-recruit.sh" ]]; then
+        local _recruit_goal="${GOAL:-}"
+        if [[ -n "$_recruit_goal" ]]; then
+            local _recruit_match
+            _recruit_match=$(bash "$SCRIPT_DIR/sw-recruit.sh" match --json "$_recruit_goal" 2>/dev/null) || true
+            if [[ -n "$_recruit_match" ]]; then
+                local _recruit_model
+                _recruit_model=$(echo "$_recruit_match" | jq -r '.model // ""' 2>/dev/null) || true
+                if [[ -n "$_recruit_model" && "$_recruit_model" != "null" && "$_recruit_model" != "" ]]; then
+                    info "Recruit recommends model: ${CYAN}${_recruit_model}${RESET} for this task"
+                    build_model="$_recruit_model"
+                fi
+            fi
+        fi
+    fi
+
     [[ -n "$test_cmd" && "$test_cmd" != "null" ]] && loop_args+=(--test-cmd "$test_cmd")
     loop_args+=(--max-iterations "$max_iter")
     loop_args+=(--model "$build_model")
@@ -2488,6 +2649,23 @@ Coverage baseline: ${coverage_baseline}% — do not decrease coverage."
     }
     parse_claude_tokens "$_token_log"
 
+    # Read accumulated token counts from build loop (written by sw-loop.sh)
+    local _loop_token_file="${PROJECT_ROOT}/.claude/loop-logs/loop-tokens.json"
+    if [[ -f "$_loop_token_file" ]] && command -v jq &>/dev/null; then
+        local _loop_in _loop_out _loop_cost
+        _loop_in=$(jq -r '.input_tokens // 0' "$_loop_token_file" 2>/dev/null || echo "0")
+        _loop_out=$(jq -r '.output_tokens // 0' "$_loop_token_file" 2>/dev/null || echo "0")
+        _loop_cost=$(jq -r '.cost_usd // 0' "$_loop_token_file" 2>/dev/null || echo "0")
+        TOTAL_INPUT_TOKENS=$(( TOTAL_INPUT_TOKENS + ${_loop_in:-0} ))
+        TOTAL_OUTPUT_TOKENS=$(( TOTAL_OUTPUT_TOKENS + ${_loop_out:-0} ))
+        if [[ -n "$_loop_cost" && "$_loop_cost" != "0" && "$_loop_cost" != "null" ]]; then
+            TOTAL_COST_USD="${_loop_cost}"
+        fi
+        if [[ "${_loop_in:-0}" -gt 0 || "${_loop_out:-0}" -gt 0 ]]; then
+            info "Build loop tokens: in=${_loop_in} out=${_loop_out} cost=\$${_loop_cost:-0}"
+        fi
+    fi
+
     # Count commits made during build
     local commit_count
     commit_count=$(git log --oneline "${BASE_BRANCH}..HEAD" 2>/dev/null | wc -l | xargs)
@@ -2792,6 +2970,22 @@ $(cat "$diff_file")"
         success "Review clean"
     fi
 
+    # ── Oversight gate: pipeline review/quality stages block on verdict ──
+    if [[ -x "$SCRIPT_DIR/sw-oversight.sh" ]] && [[ "${SKIP_GATES:-false}" != "true" ]]; then
+        local reject_reason=""
+        local _sec_count
+        _sec_count=$(grep -ciE '\*\*\[?Security\]?\*\*' "$review_file" 2>/dev/null || true)
+        _sec_count="${_sec_count:-0}"
+        local _blocking=$((critical_count + _sec_count))
+        [[ "$_blocking" -gt 0 ]] && reject_reason="Review found ${_blocking} critical/security issue(s)"
+        if ! bash "$SCRIPT_DIR/sw-oversight.sh" gate --diff "$diff_file" --description "${GOAL:-Pipeline review}" --reject-if "$reject_reason" >/dev/null 2>&1; then
+            error "Oversight gate rejected — blocking pipeline"
+            emit_event "review.oversight_blocked" "issue=${ISSUE_NUMBER:-0}"
+            log_stage "review" "BLOCKED: oversight gate rejected"
+            return 1
+        fi
+    fi
+
     # ── Review Blocking Gate ──
     # Block pipeline on critical/security issues unless compound_quality handles them
     local security_count
@@ -3771,6 +3965,8 @@ stage_monitor() {
     fi
 
     local report_file="$ARTIFACTS_DIR/monitor-report.md"
+    local deploy_log_file="$ARTIFACTS_DIR/deploy-logs.txt"
+    : > "$deploy_log_file"
     local total_errors=0
     local poll_interval=30  # seconds between polls
     local total_polls=$(( (duration_minutes * 60) / poll_interval ))
@@ -3818,10 +4014,11 @@ stage_monitor() {
             fi
         fi
 
-        # Log command check
+        # Log command check (accumulate deploy logs for feedback collect)
         if [[ -n "$log_cmd" ]]; then
             local log_output
             log_output=$(bash -c "$log_cmd" 2>/dev/null || true)
+            [[ -n "$log_output" ]] && echo "$log_output" >> "$deploy_log_file"
             local error_count=0
             if [[ -n "$log_output" ]]; then
                 error_count=$(echo "$log_output" | grep -cE "$log_pattern" 2>/dev/null || true)
@@ -3856,13 +4053,24 @@ stage_monitor() {
                 "total_errors=$total_errors" \
                 "threshold=$error_threshold"
 
-            # Auto-rollback if configured
-            if [[ "$auto_rollback" == "true" && -n "$rollback_cmd" ]]; then
+            # Feedback loop: collect deploy logs and optionally create issue
+            if [[ -f "$deploy_log_file" ]] && [[ -s "$deploy_log_file" ]] && [[ -x "$SCRIPT_DIR/sw-feedback.sh" ]]; then
+                (cd "$PROJECT_ROOT" && ARTIFACTS_DIR="$ARTIFACTS_DIR" bash "$SCRIPT_DIR/sw-feedback.sh" collect "$deploy_log_file" 2>/dev/null) || true
+                (cd "$PROJECT_ROOT" && ARTIFACTS_DIR="$ARTIFACTS_DIR" bash "$SCRIPT_DIR/sw-feedback.sh" create-issue 2>/dev/null) || true
+            fi
+
+            # Auto-rollback: feedback rollback (GitHub Deployments API) and/or config rollback_cmd
+            if [[ "$auto_rollback" == "true" ]]; then
                 warn "Auto-rolling back..."
                 echo "" >> "$report_file"
                 echo "## Rollback" >> "$report_file"
 
-                if bash -c "$rollback_cmd" >> "$report_file" 2>&1; then
+                # Trigger feedback rollback (calls sw-github-deploy.sh rollback)
+                if [[ -x "$SCRIPT_DIR/sw-feedback.sh" ]]; then
+                    (cd "$PROJECT_ROOT" && ARTIFACTS_DIR="$ARTIFACTS_DIR" bash "$SCRIPT_DIR/sw-feedback.sh" rollback production "Monitor threshold exceeded (${total_errors} errors)" >> "$report_file" 2>&1) || true
+                fi
+
+                if [[ -n "$rollback_cmd" ]] && bash -c "$rollback_cmd" >> "$report_file" 2>&1; then
                     success "Rollback executed"
                     echo "Rollback: ✅ success" >> "$report_file"
 
@@ -7076,6 +7284,12 @@ Focus on fixing the failing tests while keeping all passing tests working."
                 _snap_error="${_snap_error:-}"
                 pipeline_emit_progress_snapshot "${ISSUE_NUMBER}" "${CURRENT_STAGE_ID:-test}" "${cycle:-0}" "${_diff_count:-0}" "${_snap_files}" "${_snap_error}" 2>/dev/null || true
             fi
+            # Record fix outcome when tests pass after a retry with memory injection (pipeline path)
+            if [[ "$cycle" -gt 1 && -n "${last_test_error:-}" ]] && [[ -x "$SCRIPT_DIR/sw-memory.sh" ]]; then
+                local _sig
+                _sig=$(echo "$last_test_error" | head -3 | tr '\n' ' ' | sed 's/^ *//;s/ *$//')
+                [[ -n "$_sig" ]] && bash "$SCRIPT_DIR/sw-memory.sh" fix-outcome "$_sig" "true" "true" 2>/dev/null || true
+            fi
             return 0  # Tests passed!
         fi
 
@@ -7285,7 +7499,9 @@ run_pipeline() {
             if [[ "$build_gate" == "approve" && "$SKIP_GATES" != "true" ]]; then
                 show_stage_preview "build"
                 local answer=""
-                read -rp "  Proceed with build+test (self-healing)? [Y/n] " answer
+                if [[ -t 0 ]]; then
+                    read -rp "  Proceed with build+test (self-healing)? [Y/n] " answer || true
+                fi
                 if [[ "$answer" =~ ^[Nn] ]]; then
                     update_status "paused" "build"
                     info "Pipeline paused. Resume with: ${DIM}shipwright pipeline resume${RESET}"
@@ -7323,7 +7539,12 @@ run_pipeline() {
         if [[ "$gate" == "approve" && "$SKIP_GATES" != "true" ]]; then
             show_stage_preview "$id"
             local answer=""
-            read -rp "  Proceed with ${id}? [Y/n] " answer
+            if [[ -t 0 ]]; then
+                read -rp "  Proceed with ${id}? [Y/n] " answer || true
+            else
+                # Non-interactive: auto-approve (shouldn't reach here if headless detection works)
+                info "Non-interactive mode — auto-approving ${id}"
+            fi
             if [[ "$answer" =~ ^[Nn] ]]; then
                 update_status "paused" "$id"
                 info "Pipeline paused at ${BOLD}$id${RESET}. Resume with: ${DIM}shipwright pipeline resume${RESET}"
@@ -7426,11 +7647,29 @@ run_pipeline() {
         if run_stage_with_retry "$id"; then
             mark_stage_complete "$id"
             completed=$((completed + 1))
+            # Capture project pattern after intake (for memory context in later stages)
+            if [[ "$id" == "intake" ]] && [[ -x "$SCRIPT_DIR/sw-memory.sh" ]]; then
+                (cd "$REPO_DIR" && bash "$SCRIPT_DIR/sw-memory.sh" pattern "project" "{}" 2>/dev/null) || true
+            fi
             local timing stage_dur_s
             timing=$(get_stage_timing "$id")
             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"
+            # Broadcast discovery for cross-pipeline learning
+            if [[ -x "$SCRIPT_DIR/sw-discovery.sh" ]]; then
+                local _disc_cat _disc_patterns _disc_text
+                _disc_cat="$id"
+                case "$id" in
+                    plan)   _disc_patterns="*.md"; _disc_text="Plan completed: ${GOAL:-goal}" ;;
+                    design) _disc_patterns="*.md,*.ts,*.tsx,*.js"; _disc_text="Design completed for ${GOAL:-goal}" ;;
+                    build)  _disc_patterns="src/*,*.ts,*.tsx,*.js"; _disc_text="Build completed" ;;
+                    test)   _disc_patterns="*.test.*,*_test.*"; _disc_text="Tests passed" ;;
+                    review) _disc_patterns="*.md,*.ts,*.tsx"; _disc_text="Review completed" ;;
+                    *)      _disc_patterns="*"; _disc_text="Stage $id completed" ;;
+                esac
+                bash "$SCRIPT_DIR/sw-discovery.sh" broadcast "$_disc_cat" "$_disc_patterns" "$_disc_text" "" 2>/dev/null || true
+            fi
             # Log model used for prediction feedback
             echo "${id}|${stage_model_used}|true" >> "${ARTIFACTS_DIR}/model-routing.log"
         else
@@ -7613,8 +7852,14 @@ pipeline_cleanup_worktree() {
 
     if [[ -n "${ORIGINAL_REPO_DIR:-}" && "$worktree_path" != "$ORIGINAL_REPO_DIR" ]]; then
         cd "$ORIGINAL_REPO_DIR" 2>/dev/null || cd /
-        info "Cleaning up worktree: ${DIM}${worktree_path}${RESET}"
-        git worktree remove --force "$worktree_path" 2>/dev/null || true
+        # Only clean up worktree on success — preserve on failure for inspection
+        if [[ "${PIPELINE_EXIT_CODE:-1}" -eq 0 ]]; then
+            info "Cleaning up worktree: ${DIM}${worktree_path}${RESET}"
+            git worktree remove --force "$worktree_path" 2>/dev/null || true
+        else
+            warn "Pipeline failed — worktree preserved for inspection: ${DIM}${worktree_path}${RESET}"
+            warn "Clean up manually: ${DIM}git worktree remove --force ${worktree_path}${RESET}"
+        fi
     fi
 }
 
@@ -7787,6 +8032,24 @@ run_dry_run() {
 # ─── Subcommands ────────────────────────────────────────────────────────────
 
 pipeline_start() {
+    # Handle --repo flag: change to directory before running
+    if [[ -n "$REPO_OVERRIDE" ]]; then
+        if [[ ! -d "$REPO_OVERRIDE" ]]; then
+            error "Directory does not exist: $REPO_OVERRIDE"
+            exit 1
+        fi
+        if ! cd "$REPO_OVERRIDE" 2>/dev/null; then
+            error "Cannot cd to: $REPO_OVERRIDE"
+            exit 1
+        fi
+        if ! git rev-parse --show-toplevel >/dev/null 2>&1; then
+            error "Not a git repository: $REPO_OVERRIDE"
+            exit 1
+        fi
+        ORIGINAL_REPO_DIR="$(pwd)"
+        info "Using repository: $ORIGINAL_REPO_DIR"
+    fi
+
     if [[ -z "$GOAL" && -z "$ISSUE_NUMBER" ]]; then
         error "Must provide --goal or --issue"
         echo -e "  Example: ${DIM}shipwright pipeline start --goal \"Add JWT auth\"${RESET}"
@@ -7879,7 +8142,9 @@ pipeline_start() {
 
     local gate_count
     gate_count=$(jq '[.stages[] | select(.gate == "approve" and .enabled == true)] | length' "$PIPELINE_CONFIG")
-    if [[ "$SKIP_GATES" == "true" ]]; then
+    if [[ "$HEADLESS" == "true" ]]; then
+        echo -e "  ${BOLD}Gates:${RESET}       ${YELLOW}all auto (headless — non-interactive stdin detected)${RESET}"
+    elif [[ "$SKIP_GATES" == "true" ]]; then
         echo -e "  ${BOLD}Gates:${RESET}       ${YELLOW}all auto (--skip-gates)${RESET}"
     else
         echo -e "  ${BOLD}Gates:${RESET}       ${gate_count} approval gate(s)"
@@ -7931,6 +8196,7 @@ pipeline_start() {
 
     run_pipeline
     local exit_code=$?
+    PIPELINE_EXIT_CODE="$exit_code"
 
     # Send completion notification + event
     local total_dur_s=""
@@ -7946,9 +8212,15 @@ pipeline_start() {
             "result=success" \
             "duration_s=${total_dur_s:-0}" \
             "pr_url=${pr_url:-}" \
+            "agent_id=${PIPELINE_AGENT_ID}" \
             "input_tokens=$TOTAL_INPUT_TOKENS" \
             "output_tokens=$TOTAL_OUTPUT_TOKENS" \
             "self_heal_count=$SELF_HEAL_COUNT"
+
+        # Auto-ingest pipeline outcome into recruit profiles
+        if [[ -x "$SCRIPT_DIR/sw-recruit.sh" ]]; then
+            bash "$SCRIPT_DIR/sw-recruit.sh" ingest-pipeline 1 2>/dev/null || true
+        fi
     else
         notify "Pipeline Failed" "Goal: ${GOAL}\nFailed at: ${CURRENT_STAGE_ID:-unknown}" "error"
         emit_event "pipeline.completed" \
@@ -7956,10 +8228,16 @@ pipeline_start() {
             "result=failure" \
             "duration_s=${total_dur_s:-0}" \
             "failed_stage=${CURRENT_STAGE_ID:-unknown}" \
+            "agent_id=${PIPELINE_AGENT_ID}" \
             "input_tokens=$TOTAL_INPUT_TOKENS" \
             "output_tokens=$TOTAL_OUTPUT_TOKENS" \
             "self_heal_count=$SELF_HEAL_COUNT"
 
+        # Auto-ingest pipeline outcome into recruit profiles
+        if [[ -x "$SCRIPT_DIR/sw-recruit.sh" ]]; then
+            bash "$SCRIPT_DIR/sw-recruit.sh" ingest-pipeline 1 2>/dev/null || true
+        fi
+
         # Capture failure learnings to memory
         if [[ -x "$SCRIPT_DIR/sw-memory.sh" ]]; then
             bash "$SCRIPT_DIR/sw-memory.sh" capture "$STATE_FILE" "$ARTIFACTS_DIR" 2>/dev/null || true
@@ -8015,18 +8293,24 @@ pipeline_start() {
         memory_finalize_pipeline "$STATE_FILE" "$ARTIFACTS_DIR" 2>/dev/null || true
     fi
 
-    # Emit cost event
+    # Emit cost event — prefer actual cost from Claude CLI when available
     local model_key="${MODEL:-sonnet}"
-    local input_cost output_cost total_cost
-    input_cost=$(awk -v tokens="$TOTAL_INPUT_TOKENS" -v rate="$(echo "$COST_MODEL_RATES" | jq -r ".${model_key}.input // 3")" 'BEGIN{printf "%.4f", (tokens / 1000000) * rate}')
-    output_cost=$(awk -v tokens="$TOTAL_OUTPUT_TOKENS" -v rate="$(echo "$COST_MODEL_RATES" | jq -r ".${model_key}.output // 15")" 'BEGIN{printf "%.4f", (tokens / 1000000) * rate}')
-    total_cost=$(awk -v i="$input_cost" -v o="$output_cost" 'BEGIN{printf "%.4f", i + o}')
+    local total_cost
+    if [[ -n "${TOTAL_COST_USD:-}" && "${TOTAL_COST_USD}" != "0" && "${TOTAL_COST_USD}" != "null" ]]; then
+        total_cost="${TOTAL_COST_USD}"
+    else
+        # Fallback: estimate from token counts and model rates
+        local input_cost output_cost
+        input_cost=$(awk -v tokens="$TOTAL_INPUT_TOKENS" -v rate="$(echo "$COST_MODEL_RATES" | jq -r ".${model_key}.input // 3")" 'BEGIN{printf "%.4f", (tokens / 1000000) * rate}')
+        output_cost=$(awk -v tokens="$TOTAL_OUTPUT_TOKENS" -v rate="$(echo "$COST_MODEL_RATES" | jq -r ".${model_key}.output // 15")" 'BEGIN{printf "%.4f", (tokens / 1000000) * rate}')
+        total_cost=$(awk -v i="$input_cost" -v o="$output_cost" 'BEGIN{printf "%.4f", i + o}')
+    fi
 
     emit_event "pipeline.cost" \
         "input_tokens=$TOTAL_INPUT_TOKENS" \
         "output_tokens=$TOTAL_OUTPUT_TOKENS" \
         "model=$model_key" \
-        "estimated_cost_usd=$total_cost"
+        "cost_usd=$total_cost"
 
     return $exit_code
 }