shipwright-cli 3.1.0 → 3.3.0

package/scripts/sw-feedback.sh

@@ -6,7 +6,7 @@
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="3.1.0"
+VERSION="3.3.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
@@ -29,20 +29,25 @@ fi
 if [[ "$(type -t emit_event 2>/dev/null)" != "function" ]]; then
   emit_event() {
     local event_type="$1"; shift; mkdir -p "${HOME}/.shipwright"
-    local payload="{\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"type\":\"$event_type\""
+    local payload
+    payload="{\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"type\":\"$event_type\""
     while [[ $# -gt 0 ]]; do local key="${1%%=*}" val="${1#*=}"; payload="${payload},\"${key}\":\"${val}\""; shift; done
     echo "${payload}}" >> "${HOME}/.shipwright/events.jsonl"
   }
 fi
 # ─── Storage Paths ──────────────────────────────────────────────────────────
 INCIDENTS_FILE="${HOME}/.shipwright/incidents.jsonl"
+MERGE_OUTCOMES_FILE="${HOME}/.shipwright/optimization/merge-outcomes.jsonl"
 ERROR_THRESHOLD=5          # Create issue if error count >= threshold
+# shellcheck disable=SC2034
 ERROR_LOG_DIR="${REPO_DIR}/.claude/pipeline-artifacts"
 ARTIFACTS_DIR="${ARTIFACTS_DIR:-${REPO_DIR}/.claude/pipeline-artifacts}"
+POST_MERGE_MONITORING_FILE="${ARTIFACTS_DIR}/post-merge-monitoring.json"
 
 # ─── Initialize directories ────────────────────────────────────────────────
 ensure_dirs() {
     mkdir -p "${HOME}/.shipwright"
+    mkdir -p "${HOME}/.shipwright/optimization"
     mkdir -p "$ARTIFACTS_DIR"
 }
 
@@ -61,6 +66,7 @@ parse_error_patterns() {
     local log_file="$1"
     local error_count=0
     local error_types=""
+    # shellcheck disable=SC2034
     local stack_traces=""
 
     if [[ ! -f "$log_file" ]]; then
@@ -72,24 +78,28 @@ parse_error_patterns() {
         if [[ "$line" =~ (Error|Exception|panic|fatal).*: ]]; then
             error_count=$((error_count + 1))
             # Extract error message
-            local err_msg=$(echo "$line" | sed -E 's/^.*\[.*\] //; s/:.*//')
+            local err_msg
+            err_msg=$(echo "$line" | sed -E 's/^.*\[.*\] //; s/:.*//')
             error_types="${error_types}${err_msg};"
         fi
     done < "$log_file"
 
     # Output CSV: count|types|first_stack_trace
-    local first_stack=$(head -50 "$log_file" | tail -20)
+    local first_stack
+    first_stack=$(head -50 "$log_file" | tail -20)
     echo "$error_count|$error_types|$first_stack"
 }
 
 # ─── Find commit that likely introduced regression ───────────────────────────
 find_regression_commit() {
+    # shellcheck disable=SC2034
     local error_pattern="$1"
     local max_commits="${2:-20}"
 
     # Search recent commits for changes that might have introduced the error
     # Pattern: look for commits touching error-related code
     local commit_hash
+    # shellcheck disable=SC2034
     commit_hash=$(cd "$REPO_DIR" && git log --all -n "$max_commits" --pretty=format:"%H %s" | \
         while read -r hash subject; do
             # Simple heuristic: commits that touched multiple files or had large diffs
@@ -104,7 +114,505 @@ find_regression_commit() {
     echo "${commit_hash:0:7}"
 }
 
-# ─── Collect errors from monitor stage output ────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
+# POST-MERGE FEEDBACK FUNCTIONS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# ─── Monitor production after merge ─────────────────────────────────────────────
+feedback_post_merge_monitor() {
+    local merge_sha="${1:-}"
+    local environment="${2:-production}"
+    local monitoring_window="${3:-1800}"  # 30 minutes default
+    local poll_interval="${4:-60}"        # 60 seconds
+    local owner_repo="${5:-}"
+
+    if [[ -z "$merge_sha" ]]; then
+        error "Usage: feedback_post_merge_monitor <merge_sha> [environment] [window_secs] [poll_interval]"
+        return 1
+    fi
+
+    info "Starting post-merge production monitoring for: $merge_sha"
+    info "Environment: $environment | Window: $((monitoring_window / 60))m | Poll: ${poll_interval}s"
+
+    ensure_dirs
+
+    # Initialize monitoring data
+    local monitoring_data
+    local start_epoch
+    start_epoch=$(now_epoch)
+    monitoring_data=$(jq -n \
+        --arg ts "$(now_iso)" \
+        --arg merge_sha "$merge_sha" \
+        --arg env "$environment" \
+        --arg window "$monitoring_window" \
+        --arg start_ep "$start_epoch" \
+        '{
+            timestamp: $ts,
+            merge_sha: $merge_sha,
+            environment: $env,
+            monitoring_window_secs: ($window | tonumber),
+            start_epoch: ($start_ep | tonumber),
+            checks: [],
+            errors_detected: 0,
+            deployment_status: null,
+            monitoring_complete: false
+        }')
+
+    local start_time
+    start_time=$(now_epoch)
+    local elapsed=0
+    local iteration=0
+
+    # Poll for monitoring window duration
+    while [[ "$elapsed" -lt "$monitoring_window" ]]; do
+        iteration=$((iteration + 1))
+        local current_check
+
+        # Check GitHub deployment status (if NO_GITHUB not set)
+        local deploy_status="unknown"
+        local deploy_errors=0
+        if [[ "${NO_GITHUB:-}" != "true" && "${NO_GITHUB:-}" != "1" ]]; then
+            if [[ -z "$owner_repo" ]]; then
+                owner_repo=$(get_owner_repo) || true
+            fi
+            if [[ -n "$owner_repo" ]]; then
+                deploy_status=$(gh api "repos/${owner_repo}/deployments" \
+                    --jq '.[] | select(.ref == "'$merge_sha'") | .statuses[0].state // "unknown"' \
+                    2>/dev/null || echo "unknown")
+            fi
+        fi
+
+        # Simulate or check for error spikes (look at error log if available)
+        if [[ -f "${ARTIFACTS_DIR}/error-log.jsonl" ]]; then
+            deploy_errors=$(wc -l < "${ARTIFACTS_DIR}/error-log.jsonl" 2>/dev/null || echo "0")
+        fi
+
+        current_check=$(jq -n \
+            --arg ts "$(now_iso)" \
+            --argjson iter "$iteration" \
+            --arg deploy_st "$deploy_status" \
+            --argjson err_count "$deploy_errors" \
+            '{
+                timestamp: $ts,
+                iteration: $iter,
+                deployment_status: $deploy_st,
+                error_count: $err_count
+            }')
+
+        monitoring_data=$(echo "$monitoring_data" | jq \
+            --argjson check "$current_check" \
+            --argjson err_count "$deploy_errors" \
+            '.checks += [$check] | .errors_detected += ($err_count | tonumber)')
+
+        # Check for immediate failure
+        if [[ "$deploy_status" == "failure" || "$deploy_status" == "error" ]]; then
+            warn "Deployment failed detected at iteration $iteration!"
+            monitoring_data=$(echo "$monitoring_data" | jq '.deployment_status = "failed"')
+            break
+        fi
+
+        elapsed=$(($(now_epoch) - start_time))
+        if [[ "$elapsed" -lt "$monitoring_window" ]]; then
+            sleep "$poll_interval"
+        fi
+    done
+
+    # Mark monitoring complete
+    local end_epoch
+    end_epoch=$(now_epoch)
+    monitoring_data=$(echo "$monitoring_data" | jq \
+        --arg ts "$(now_iso)" \
+        --arg end_ep "$end_epoch" \
+        '.monitoring_complete = true | .end_timestamp = $ts | .end_epoch = ($end_ep | tonumber)')
+
+    # Write monitoring data atomically
+    local tmp_file
+    tmp_file=$(mktemp)
+    echo "$monitoring_data" > "$tmp_file"
+    mv "$tmp_file" "$POST_MERGE_MONITORING_FILE"
+
+    success "Post-merge monitoring complete: $POST_MERGE_MONITORING_FILE"
+    emit_event "feedback_post_merge_monitor" "merge_sha=$merge_sha" "environment=$environment" "errors=$( echo "$monitoring_data" | jq -r '.errors_detected')"
+}
+
+# ─── Detect regressions from monitoring data ────────────────────────────────────
+feedback_detect_regression() {
+    local monitoring_file="${1:-$POST_MERGE_MONITORING_FILE}"
+
+    if [[ ! -f "$monitoring_file" ]]; then
+        error "Monitoring file not found: $monitoring_file"
+        return 1
+    fi
+
+    local merge_sha
+    merge_sha=$(jq -r '.merge_sha' "$monitoring_file")
+    local errors_detected
+    errors_detected=$(jq -r '.errors_detected // 0' "$monitoring_file")
+    local deploy_status
+    deploy_status=$(jq -r '.deployment_status // "unknown"' "$monitoring_file")
+    local error_count_threshold=5
+
+    local regression="false"
+    local regression_type="none"
+    local severity="P3"
+    local evidence=""
+
+    # P0: Deployment failed
+    if [[ "$deploy_status" == "failed" ]]; then
+        regression="true"
+        regression_type="deploy_failure"
+        severity="P0"
+        evidence="Deployment failed after merge"
+    # P1: Error spike
+    elif [[ "$errors_detected" -ge "$error_count_threshold" ]]; then
+        regression="true"
+        regression_type="error_spike"
+        severity="P1"
+        evidence="Error count: $errors_detected (threshold: $error_count_threshold)"
+    # P2: Minor errors (below threshold but present)
+    elif [[ "$errors_detected" -gt 0 ]]; then
+        regression="true"
+        regression_type="minor_errors"
+        severity="P2"
+        evidence="Error count: $errors_detected"
+    fi
+
+    local regression_result
+    regression_result=$(jq -n \
+        --arg ts "$(now_iso)" \
+        --arg sha "$merge_sha" \
+        --arg regr "$regression" \
+        --arg type "$regression_type" \
+        --arg sev "$severity" \
+        --arg evid "$evidence" \
+        '{
+            timestamp: $ts,
+            merge_sha: $sha,
+            regression: ($regr == "true"),
+            type: $type,
+            severity: $sev,
+            evidence: $evid
+        }')
+
+    echo "$regression_result"
+    emit_event "feedback_detect_regression" "merge_sha=$merge_sha" "regression=$regression" "severity=$severity"
+}
+
+# ─── Correlate regressions with changed files ───────────────────────────────────
+feedback_correlate_with_changes() {
+    local pr_number="${1:-}"
+    local regression_json="${2:-}"
+
+    if [[ -z "$pr_number" ]]; then
+        error "Usage: feedback_correlate_with_changes <pr_number> [regression_json]"
+        return 1
+    fi
+
+    # Get PR's changed files from git log (if available)
+    local changed_files=""
+    local culprit_files=""
+    local confidence=0
+
+    # Try to get files from recent commits
+    if [[ "${NO_GITHUB:-}" != "true" && "${NO_GITHUB:-}" != "1" ]]; then
+        changed_files=$(git log --oneline --all -n 50 --pretty=format:%B 2>/dev/null | \
+            grep -i "pr #$pr_number\|merge.*$pr_number" | head -1 || echo "")
+    fi
+
+    # If no GitHub data, fall back to git history
+    if [[ -z "$changed_files" ]]; then
+        changed_files=$(cd "$REPO_DIR" && git diff HEAD~1..HEAD --name-only 2>/dev/null | head -10 || echo "")
+    fi
+
+    # Score likelihood of files being culprits (common patterns)
+    if [[ -n "$changed_files" ]]; then
+        # Files commonly correlated with regressions
+        while IFS= read -r file; do
+            if [[ "$file" =~ (auth|login|session|permission|access) ]]; then
+                culprit_files="${culprit_files}${file}:auth "
+                confidence=$((confidence + 25))
+            elif [[ "$file" =~ (api|endpoint|route|handler|request) ]]; then
+                culprit_files="${culprit_files}${file}:api "
+                confidence=$((confidence + 20))
+            elif [[ "$file" =~ (database|migration|schema|sql) ]]; then
+                culprit_files="${culprit_files}${file}:db "
+                confidence=$((confidence + 20))
+            elif [[ "$file" =~ (util|helper|core|lib) ]]; then
+                culprit_files="${culprit_files}${file}:shared "
+                confidence=$((confidence + 15))
+            fi
+        done <<< "$changed_files"
+    fi
+
+    # Cap confidence at 100
+    if [[ "$confidence" -gt 100 ]]; then
+        confidence=100
+    fi
+
+    local correlation_result
+    correlation_result=$(jq -n \
+        --arg pr "$pr_number" \
+        --arg files "$changed_files" \
+        --arg culprits "$culprit_files" \
+        --arg conf "$confidence" \
+        '{
+            pr_number: $pr,
+            changed_files: $files,
+            culprit_files: $culprits,
+            confidence_percent: ($conf | tonumber)
+        }')
+
+    echo "$correlation_result"
+    emit_event "feedback_correlate" "pr=$pr_number" "confidence=$confidence"
+}
+
+# ─── Auto-respond to regressions based on severity ──────────────────────────────
+feedback_auto_respond() {
+    local regression_json="${1:-}"
+    local pr_number="${2:-}"
+
+    if [[ -z "$regression_json" ]]; then
+        error "Usage: feedback_auto_respond <regression_json> [pr_number]"
+        return 1
+    fi
+
+    local severity
+    severity=$(echo "$regression_json" | jq -r '.severity // "P3"')
+    local regression_type
+    regression_type=$(echo "$regression_json" | jq -r '.type // "unknown"')
+    local evidence
+    evidence=$(echo "$regression_json" | jq -r '.evidence // ""')
+
+    info "Auto-responding to regression: $severity / $regression_type"
+
+    ensure_dirs
+
+    case "$severity" in
+        P0)
+            # Deploy failed: trigger rollback + create incident
+            info "P0 SEVERITY: Deployment failed — triggering rollback"
+            cmd_rollback "production" "Post-merge regression detected: $regression_type"
+
+            # Create incident issue if GitHub available
+            if [[ "${NO_GITHUB:-}" != "true" && "${NO_GITHUB:-}" != "1" ]]; then
+                local owner_repo
+                owner_repo=$(get_owner_repo) || true
+                if [[ -n "$owner_repo" && -n "$pr_number" ]]; then
+                    if command -v gh >/dev/null 2>&1; then
+                        gh issue create \
+                            --repo "$owner_repo" \
+                            --title "CRITICAL: Post-Merge Deployment Failed - PR #$pr_number" \
+                            --body "**Severity**: P0 - CRITICAL
+
+**Issue**: Deployment failed immediately after PR merge
+
+**Type**: $regression_type
+**Evidence**: $evidence
+
+**Action Taken**: Rollback initiated
+
+**Related PR**: #$pr_number
+
+---
+Auto-created by Shipwright Post-Merge Feedback System" \
+                            --label "shipwright" \
+                            --label "incident" \
+                            --label "p0" \
+                            2>&1 | grep -oE 'https://github.com/[^ ]+' | head -1 || true
+                    fi
+                fi
+            fi
+            ;;
+        P1)
+            # Error spike: create hotfix issue
+            info "P1 SEVERITY: Error spike detected — creating hotfix issue"
+            if [[ "${NO_GITHUB:-}" != "true" && "${NO_GITHUB:-}" != "1" ]]; then
+                local owner_repo
+                owner_repo=$(get_owner_repo) || true
+                if [[ -n "$owner_repo" && -n "$pr_number" ]]; then
+                    if command -v gh >/dev/null 2>&1; then
+                        gh issue create \
+                            --repo "$owner_repo" \
+                            --title "Hotfix Needed: Post-Merge Error Spike - PR #$pr_number" \
+                            --body "**Severity**: P1 - HIGH
+
+**Issue**: Error spike detected in production after PR merge
+
+**Type**: $regression_type
+**Evidence**: $evidence
+
+**Action Required**: Investigate and create hotfix
+
+**Related PR**: #$pr_number
+
+---
+Auto-created by Shipwright Post-Merge Feedback System" \
+                            --label "shipwright" \
+                            --label "hotfix" \
+                            --label "p1" \
+                            2>&1 | grep -oE 'https://github.com/[^ ]+' | head -1 || true
+                    fi
+                fi
+            fi
+            ;;
+        P2)
+            # Performance or minor regression: schedule for next sprint
+            info "P2 SEVERITY: Performance degradation — scheduling for next sprint"
+            ;;
+        P3|*)
+            # Minor: just record in memory
+            info "P3 SEVERITY: Minor regression — recorded for awareness"
+            ;;
+    esac
+
+    emit_event "feedback_auto_respond" "severity=$severity" "type=$regression_type"
+}
+
+# ─── Learn from post-merge outcomes ─────────────────────────────────────────────
+feedback_learn_from_outcome() {
+    local pr_number="${1:-}"
+    local merge_result="${2:-success}"
+    local deploy_result="${3:-unknown}"
+    local regression="${4:-false}"
+    local regression_type="${5:-none}"
+
+    if [[ -z "$pr_number" ]]; then
+        error "Usage: feedback_learn_from_outcome <pr_number> [merge_result] [deploy_result] [regression] [type]"
+        return 1
+    fi
+
+    info "Recording merge outcome for learning: PR #$pr_number"
+
+    ensure_dirs
+
+    # Calculate time-to-detect (from merge timestamp if available)
+    local time_to_detect=0
+    if [[ -f "$POST_MERGE_MONITORING_FILE" ]]; then
+        local start_epoch
+        start_epoch=$(jq -r '.start_epoch // 0' "$POST_MERGE_MONITORING_FILE")
+        local end_epoch
+        end_epoch=$(jq -r '.end_epoch // 0' "$POST_MERGE_MONITORING_FILE")
+        if [[ "$end_epoch" -gt 0 && "$start_epoch" -gt 0 ]]; then
+            time_to_detect=$((end_epoch - start_epoch))
+        fi
+    fi
+
+    local outcome_entry
+    outcome_entry=$(jq -c -n \
+        --arg ts "$(now_iso)" \
+        --arg pr "$pr_number" \
+        --arg merge_res "$merge_result" \
+        --arg deploy_res "$deploy_result" \
+        --arg regr "$regression" \
+        --arg regr_type "$regression_type" \
+        --arg ttd "$time_to_detect" \
+        --arg repo "$(basename "$REPO_DIR")" \
+        '{
+            timestamp: $ts,
+            pr_number: $pr,
+            repository: $repo,
+            merge_result: $merge_res,
+            deploy_result: $deploy_res,
+            regression_detected: ($regr == "true"),
+            regression_type: $regr_type,
+            time_to_detect_secs: ($ttd | tonumber)
+        }')
+
+    # Atomic write
+    local tmp_file
+    tmp_file=$(mktemp)
+    echo "$outcome_entry" >> "$tmp_file"
+    cat "$MERGE_OUTCOMES_FILE" >> "$tmp_file" 2>/dev/null || true
+    mv "$tmp_file" "$MERGE_OUTCOMES_FILE"
+
+    success "Learned outcome: PR #$pr_number ($merge_result / $deploy_result / regression=$regression)"
+    emit_event "feedback_learn_from_outcome" "pr=$pr_number" "merge_result=$merge_result" "regression=$regression"
+}
+
+# ─── Generate post-merge health report ──────────────────────────────────────────
+feedback_report() {
+    local days="${1:-30}"
+
+    info "Post-Merge Health Report (last $days days)"
+    echo ""
+
+    if [[ ! -f "$MERGE_OUTCOMES_FILE" ]]; then
+        warn "No merge outcomes recorded yet"
+        return 0
+    fi
+
+    # Calculate metrics
+    local total_merges=0
+    local successful_merges=0
+    local regressions=0
+    local p0_count=0
+    local p1_count=0
+    local p2_count=0
+    local total_detect_time=0
+    local avg_detect_time=0
+    local common_types=""
+
+    while IFS= read -r line; do
+        local merge_res
+        merge_res=$(echo "$line" | jq -r '.merge_result // "unknown"')
+        local regression
+        regression=$(echo "$line" | jq -r '.regression_detected // false')
+        local regr_type
+        regr_type=$(echo "$line" | jq -r '.regression_type // "none"')
+        local ttd
+        ttd=$(echo "$line" | jq -r '.time_to_detect_secs // 0')
+
+        total_merges=$((total_merges + 1))
+        [[ "$merge_res" == "success" ]] && successful_merges=$((successful_merges + 1))
+        [[ "$regression" == "true" ]] && regressions=$((regressions + 1))
+
+        total_detect_time=$((total_detect_time + ttd))
+
+        # Count severity (inferred from time-to-detect for now)
+        if [[ "$ttd" -lt 300 ]]; then
+            p0_count=$((p0_count + 1))
+        elif [[ "$ttd" -lt 900 ]]; then
+            p1_count=$((p1_count + 1))
+        else
+            p2_count=$((p2_count + 1))
+        fi
+
+        # Track common regression types
+        if [[ "$regr_type" != "none" ]]; then
+            common_types="${common_types}${regr_type};"
+        fi
+    done < "$MERGE_OUTCOMES_FILE"
+
+    if [[ "$total_merges" -gt 0 ]]; then
+        avg_detect_time=$((total_detect_time / total_merges))
+    fi
+
+    # Output report
+    echo "  ${CYAN}Merge Statistics${RESET}"
+    echo "    Total Merges:        $total_merges"
+    echo "    Success Rate:        $((successful_merges * 100 / total_merges))% ($successful_merges/$total_merges)"
+    echo "    Regressions:         $regressions ($((regressions * 100 / total_merges))%)"
+    echo ""
+    echo "  ${CYAN}Detection Metrics${RESET}"
+    echo "    Avg Detection Time:  ${avg_detect_time}s ($((avg_detect_time / 60))m)"
+    echo "    P0 Incidents:        $p0_count"
+    echo "    P1 Issues:           $p1_count"
+    echo "    P2 Items:            $p2_count"
+    echo ""
+    echo "  ${CYAN}Common Regression Types${RESET}"
+    if [[ -n "$common_types" ]]; then
+        echo "$common_types" | tr ';' '\n' | sort | uniq -c | sort -rn | head -5 | while read -r count type; do
+            [[ -n "$type" ]] && echo "    $type:         $count occurrences"
+        done
+    else
+        echo "    (None recorded)"
+    fi
+    echo ""
+    success "Report generated"
+    return 0
+}
+
+# ─── Collect errors from monitor stage output ────────────────────────────────────
 cmd_collect() {
     local log_path="${1:-.}"
 
@@ -127,6 +635,7 @@ cmd_collect() {
         while IFS= read -r file; do
             local result
             result=$(parse_error_patterns "$file") || continue
+            # shellcheck disable=SC2034
             IFS='|' read -r count types traces <<< "$result"
             total_errors=$((total_errors + count))
             error_summary="${error_summary}${types};"
@@ -398,20 +907,37 @@ ${BOLD}SUBCOMMANDS${RESET}
   ${CYAN}rollback${RESET} [env] [reason]     Trigger rollback via Deployments API
   ${CYAN}learn${RESET} [cause] [fix]         Capture incident in memory system
   ${CYAN}report${RESET} [days]               Show recent incidents (default: 7 days)
+
+  ${CYAN}post-merge${RESET} [sha] [env]     Monitor production after merge
+  ${CYAN}regressions${RESET} [file]          Detect regressions from monitoring data
+  ${CYAN}correlate${RESET} [pr] [json]       Link regressions to changed files
+  ${CYAN}outcomes${RESET} [pr] [...]         Record merge outcome for learning
+  ${CYAN}health${RESET} [days]               Post-merge health report
+
   ${CYAN}help${RESET}                        Show this help message
 
 ${BOLD}EXAMPLES${RESET}
+  ${DIM}# Traditional flow${RESET}
   ${DIM}shipwright feedback collect ./logs${RESET}
   ${DIM}shipwright feedback analyze${RESET}
   ${DIM}shipwright feedback create-issue${RESET}
   ${DIM}shipwright feedback rollback production "Hotfix v1.2.3 regression"${RESET}
-  ${DIM}shipwright feedback learn "Off-by-one error in pagination" "Fixed in PR #456"${RESET}
+  ${DIM}shipwright feedback learn "Off-by-one error" "Fixed in PR #456"${RESET}
   ${DIM}shipwright feedback report 30${RESET}
 
+  ${DIM}# Post-merge monitoring flow${RESET}
+  ${DIM}shipwright feedback post-merge abc1234 production${RESET}
+  ${DIM}shipwright feedback regressions${RESET}
+  ${DIM}shipwright feedback correlate 42${RESET}
+  ${DIM}shipwright feedback outcomes 42 success deployed true error_spike${RESET}
+  ${DIM}shipwright feedback health 30${RESET}
+
 ${BOLD}STORAGE${RESET}
-  Incidents: $INCIDENTS_FILE
-  Errors:    ${ARTIFACTS_DIR}/errors-collected.json
-  Rollbacks: ${ARTIFACTS_DIR}/rollbacks.jsonl
+  Incidents:       $INCIDENTS_FILE
+  Errors:          ${ARTIFACTS_DIR}/errors-collected.json
+  Rollbacks:       ${ARTIFACTS_DIR}/rollbacks.jsonl
+  Merge Outcomes:  $MERGE_OUTCOMES_FILE
+  Monitoring:      $POST_MERGE_MONITORING_FILE
 
 ${BOLD}VERSION${RESET}
   $VERSION
@@ -442,6 +968,21 @@ main() {
         report)
             cmd_report "$@"
             ;;
+        post-merge)
+            feedback_post_merge_monitor "$@"
+            ;;
+        regressions)
+            feedback_detect_regression "$@"
+            ;;
+        correlate)
+            feedback_correlate_with_changes "$@"
+            ;;
+        outcomes)
+            feedback_learn_from_outcome "$@"
+            ;;
+        health)
+            feedback_report "$@"
+            ;;
         help|-h|--help)
             show_help
             ;;