shipwright-cli 2.0.0 → 2.1.0

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.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
@@ -202,6 +202,7 @@ PIPELINE_CONFIG=""
 TEST_CMD=""
 MODEL=""
 AGENTS=""
+PIPELINE_AGENT_ID="${PIPELINE_AGENT_ID:-pipeline-$$}"
 SKIP_GATES=false
 GIT_BRANCH=""
 GITHUB_ISSUE=""
@@ -223,6 +224,7 @@ AUTO_WORKTREE=false
 WORKTREE_NAME=""
 CLEANUP_WORKTREE=false
 ORIGINAL_REPO_DIR=""
+REPO_OVERRIDE=""
 _cleanup_done=""
 
 # GitHub metadata (populated during intake)
@@ -264,6 +266,8 @@ 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)"
@@ -346,6 +350,8 @@ 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 ;;
@@ -396,6 +402,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 ───────────────────────────────────────────────
@@ -1155,6 +1162,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 +1272,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 +1384,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 +1848,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 +2242,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 +2307,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 +2434,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 +2492,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 +2557,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 +2630,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 +2951,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 +3946,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 +3995,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 +4034,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 +7265,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
 
@@ -7426,11 +7621,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
@@ -7787,6 +8000,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}"
@@ -7946,9 +8177,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 +8193,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 +8258,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
 }

package/scripts/sw-pm.sh

@@ -6,7 +6,7 @@
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="2.0.0"
+VERSION="2.1.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # ─── Colors (matches Seth's tmux theme) ─────────────────────────────────────
@@ -223,9 +223,57 @@ analyze_issue() {
 
 # ─── recommend_team <analysis_json> ──────────────────────────────────────────
 # Based on analysis, recommend team composition
+# Tries recruit's AI/heuristic team composition first, falls back to hardcoded rules.
 recommend_team() {
     local analysis="$1"
 
+    # ── Try recruit-powered team composition first ──
+    if [[ -x "${SCRIPT_DIR:-}/sw-recruit.sh" ]]; then
+        local issue_title
+        issue_title=$(echo "$analysis" | jq -r '.title // .recommendation // ""' 2>/dev/null || true)
+        if [[ -n "$issue_title" ]]; then
+            local recruit_result
+            recruit_result=$(bash "$SCRIPT_DIR/sw-recruit.sh" team --json "$issue_title" 2>/dev/null) || true
+            if [[ -n "$recruit_result" ]] && echo "$recruit_result" | jq -e '.team' &>/dev/null 2>&1; then
+                local recruit_roles recruit_model recruit_agents recruit_cost
+                recruit_roles=$(echo "$recruit_result" | jq -r '.team | join(",")')
+                recruit_model=$(echo "$recruit_result" | jq -r '.model // "sonnet"')
+                recruit_agents=$(echo "$recruit_result" | jq -r '.agents // 2')
+                recruit_cost=$(echo "$recruit_result" | jq -r '.estimated_cost // 0')
+
+                # Map recruit roles/model to PM output format
+                local max_iterations=5
+                local template="standard"
+                if [[ "$recruit_agents" -ge 4 ]]; then template="full"; max_iterations=8;
+                elif [[ "$recruit_agents" -le 1 ]]; then template="fast"; max_iterations=3;
+                fi
+
+                local team_rec
+                team_rec=$(jq -n \
+                    --arg roles "$recruit_roles" \
+                    --arg template "$template" \
+                    --arg model "$recruit_model" \
+                    --arg max_iter "$max_iterations" \
+                    --arg agents "$recruit_agents" \
+                    --arg cost "$recruit_cost" \
+                    '{
+                        roles: ($roles | split(",")),
+                        template: $template,
+                        model: $model,
+                        max_iterations: ($max_iter | tonumber),
+                        estimated_agents: ($agents | tonumber),
+                        confidence_percent: 80,
+                        risk_factors: "recruit-powered recommendation",
+                        mitigation_strategies: "AI-optimized team composition",
+                        source: "recruit"
+                    }')
+                echo "$team_rec"
+                return 0
+            fi
+        fi
+    fi
+
+    # ── Fallback: hardcoded heuristic team composition ──
     local complexity risk is_security is_perf file_scope
     complexity=$(echo "$analysis" | jq -r '.complexity')
     risk=$(echo "$analysis" | jq -r '.risk')
@@ -442,15 +490,22 @@ cmd_orchestrate() {
     emit_event "pm.orchestrate" "issue=${issue_num}"
 }
 
-# ─── cmd_recommend <issue_num> ──────────────────────────────────────────────
+# ─── cmd_recommend <issue_num> [--json] ──────────────────────────────────────
 cmd_recommend() {
-    local issue_num="${1:-}"
+    local json_mode="false"
+    local issue_num=""
+    if [[ "${1:-}" == "--json" ]]; then
+        json_mode="true"
+        issue_num="${2:-}"
+    else
+        issue_num="${1:-}"
+    fi
     if [[ -z "$issue_num" ]]; then
-        error "Usage: shipwright pm recommend <issue-num>"
+        error "Usage: shipwright pm recommend <issue-num> [--json]"
         return 1
     fi
 
-    info "Generating full PM recommendation for issue #${issue_num}..."
+    [[ "$json_mode" != "true" ]] && info "Generating full PM recommendation for issue #${issue_num}..."
     local analysis team_rec stages
 
     analysis=$(analyze_issue "$issue_num")
@@ -472,6 +527,16 @@ cmd_recommend() {
             recommendation_timestamp: "'$(now_iso)'"
         }')
 
+    if [[ "$json_mode" == "true" ]]; then
+        echo "$recommendation"
+        ensure_pm_history
+        local tmp_hist
+        tmp_hist=$(mktemp)
+        jq --argjson rec "$recommendation" '.decisions += [$rec]' "$PM_HISTORY" > "$tmp_hist" && mv "$tmp_hist" "$PM_HISTORY"
+        emit_event "pm.recommend" "issue=${issue_num}"
+        return 0
+    fi
+
     # Pretty-print
     echo ""
     echo -e "${BOLD}PM RECOMMENDATION FOR ISSUE #${issue_num}${RESET}"

package/scripts/sw-pr-lifecycle.sh

@@ -6,7 +6,7 @@
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="2.0.0"
+VERSION="2.1.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 

package/scripts/sw-predictive.sh

@@ -6,7 +6,7 @@
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="2.0.0"
+VERSION="2.1.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
@@ -810,6 +810,13 @@ main() {
         confirm-anomaly) predictive_confirm_anomaly "$@" ;;
         patrol)      patrol_ai_analyze "$@" ;;
         baseline)    predict_update_baseline "$@" ;;
+        inject-prevention)
+            local stage="${1:-build}"
+            local issue_json="${2:-{}}"
+            local mem_ctx="${3:-}"
+            [[ -n "$mem_ctx" && -f "$mem_ctx" ]] && mem_ctx=$(cat "$mem_ctx" 2>/dev/null || true)
+            predict_inject_prevention "$stage" "$issue_json" "$mem_ctx" || true
+            ;;
         help|--help|-h) show_help ;;
         *) error "Unknown command: $cmd"; exit 1 ;;
     esac

package/scripts/sw-prep.sh

@@ -6,7 +6,7 @@
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="2.0.0"
+VERSION="2.1.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # ─── Handle subcommands ───────────────────────────────────────────────────────

package/scripts/sw-ps.sh

@@ -5,7 +5,7 @@
 # ║  Displays a table of agents running in claude-* tmux windows with       ║
 # ║  PID, status, idle time, and pane references.                           ║
 # ╚═══════════════════════════════════════════════════════════════════════════╝
-VERSION="2.0.0"
+VERSION="2.1.0"
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 

package/scripts/sw-public-dashboard.sh

@@ -6,7 +6,7 @@
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="2.0.0"
+VERSION="2.1.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 

package/scripts/sw-quality.sh

@@ -6,7 +6,7 @@
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="2.0.0"
+VERSION="2.1.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"