shipwright-cli 1.7.1 → 1.10.0

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

@@ -4,8 +4,9 @@
 # ║  Captures learnings · Injects context · Searches memory · Tracks metrics║
 # ╚═══════════════════════════════════════════════════════════════════════════╝
 set -euo pipefail
+trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="1.7.1"
+VERSION="1.10.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
@@ -20,6 +21,14 @@ 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
+[[ -f "$SCRIPT_DIR/sw-intelligence.sh" ]] && source "$SCRIPT_DIR/sw-intelligence.sh"
+
 # ─── Output Helpers ─────────────────────────────────────────────────────────
 info()    { echo -e "${CYAN}${BOLD}▸${RESET} $*"; }
 success() { echo -e "${GREEN}${BOLD}✓${RESET} $*"; }
@@ -30,7 +39,7 @@ now_iso() { date -u +"%Y-%m-%dT%H:%M:%SZ"; }
 now_epoch() { date +%s; }
 
 # ─── Structured Event Log ──────────────────────────────────────────────────
-EVENTS_FILE="${HOME}/.claude-teams/events.jsonl"
+EVENTS_FILE="${HOME}/.shipwright/events.jsonl"
 
 emit_event() {
     local event_type="$1"
@@ -46,7 +55,7 @@ emit_event() {
             json_fields="${json_fields},\"${key}\":\"${val}\""
         fi
     done
-    mkdir -p "${HOME}/.claude-teams"
+    mkdir -p "${HOME}/.shipwright"
     echo "{\"ts\":\"$(now_iso)\",\"ts_epoch\":$(now_epoch),\"type\":\"${event_type}\"${json_fields}}" >> "$EVENTS_FILE"
 }
 
@@ -207,32 +216,272 @@ memory_capture_failure() {
         '[.failures[]] | to_entries | map(select(.value.pattern == $pat)) | .[0].key // -1' \
         "$failures_file" 2>/dev/null || echo "-1")
 
-    local tmp_file
-    tmp_file=$(mktemp)
+    (
+        if command -v flock &>/dev/null; then
+            flock -w 10 200 2>/dev/null || { warn "Memory lock timeout"; return 1; }
+        fi
+        local tmp_file
+        tmp_file=$(mktemp "${failures_file}.tmp.XXXXXX")
+
+        if [[ "$existing_idx" != "-1" && "$existing_idx" != "null" ]]; then
+            # Update existing entry
+            jq --argjson idx "$existing_idx" \
+               --arg ts "$(now_iso)" \
+               '.failures[$idx].seen_count += 1 | .failures[$idx].last_seen = $ts' \
+               "$failures_file" > "$tmp_file" && mv "$tmp_file" "$failures_file" || rm -f "$tmp_file"
+        else
+            # Add new failure entry
+            jq --arg stage "$stage" \
+               --arg pattern "$pattern" \
+               --arg ts "$(now_iso)" \
+               '.failures += [{
+                   stage: $stage,
+                   pattern: $pattern,
+                   root_cause: "",
+                   fix: "",
+                   seen_count: 1,
+                   last_seen: $ts
+               }] | .failures = (.failures | .[-100:])' \
+               "$failures_file" > "$tmp_file" && mv "$tmp_file" "$failures_file" || rm -f "$tmp_file"
+        fi
+    ) 200>"${failures_file}.lock"
+
+    emit_event "memory.failure" "stage=${stage}" "pattern=${pattern:0:80}"
+}
+
+# memory_record_fix_outcome <failure_hash_or_pattern> <fix_applied:bool> <fix_resolved:bool>
+# Tracks whether suggested fixes actually worked. Builds effectiveness data
+# so future memory injection can prioritize high-success-rate fixes.
+memory_record_fix_outcome() {
+    local pattern_match="${1:-}"
+    local fix_applied="${2:-false}"
+    local fix_resolved="${3:-false}"
+
+    [[ -z "$pattern_match" ]] && return 1
+
+    ensure_memory_dir
+    local mem_dir
+    mem_dir="$(repo_memory_dir)"
+    local failures_file="$mem_dir/failures.json"
 
-    if [[ "$existing_idx" != "-1" && "$existing_idx" != "null" ]]; then
-        # Update existing entry
-        jq --argjson idx "$existing_idx" \
+    [[ ! -f "$failures_file" ]] && return 1
+
+    # Find matching failure by pattern substring
+    local match_idx
+    match_idx=$(jq --arg pat "$pattern_match" \
+        '[.failures[]] | to_entries | map(select(.value.pattern | contains($pat))) | .[0].key // -1' \
+        "$failures_file" 2>/dev/null || echo "-1")
+
+    if [[ "$match_idx" == "-1" || "$match_idx" == "null" ]]; then
+        warn "No matching failure found for: ${pattern_match:0:60}"
+        return 1
+    fi
+
+    # Update fix outcome tracking fields
+    local applied_inc=0 resolved_inc=0
+    [[ "$fix_applied" == "true" ]] && applied_inc=1
+    [[ "$fix_resolved" == "true" ]] && resolved_inc=1
+
+    (
+        if command -v flock &>/dev/null; then
+            flock -w 10 200 2>/dev/null || { warn "Memory lock timeout"; return 1; }
+        fi
+        local tmp_file
+        tmp_file=$(mktemp "${failures_file}.tmp.XXXXXX")
+
+        jq --argjson idx "$match_idx" \
+           --argjson app "$applied_inc" \
+           --argjson res "$resolved_inc" \
            --arg ts "$(now_iso)" \
-           '.failures[$idx].seen_count += 1 | .failures[$idx].last_seen = $ts' \
-           "$failures_file" > "$tmp_file" && mv "$tmp_file" "$failures_file"
-    else
-        # Add new failure entry
-        jq --arg stage "$stage" \
-           --arg pattern "$pattern" \
+           '.failures[$idx].times_fix_suggested = ((.failures[$idx].times_fix_suggested // 0) + 1) |
+            .failures[$idx].times_fix_applied = ((.failures[$idx].times_fix_applied // 0) + $app) |
+            .failures[$idx].times_fix_resolved = ((.failures[$idx].times_fix_resolved // 0) + $res) |
+            .failures[$idx].fix_effectiveness_rate = (
+                if ((.failures[$idx].times_fix_applied // 0) + $app) > 0 then
+                    (((.failures[$idx].times_fix_resolved // 0) + $res) * 100 /
+                     ((.failures[$idx].times_fix_applied // 0) + $app))
+                else 0 end
+            ) |
+            .failures[$idx].last_outcome_at = $ts' \
+           "$failures_file" > "$tmp_file" && mv "$tmp_file" "$failures_file" || rm -f "$tmp_file"
+    ) 200>"${failures_file}.lock"
+
+    emit_event "memory.fix_outcome" \
+        "pattern=${pattern_match:0:60}" \
+        "applied=${fix_applied}" \
+        "resolved=${fix_resolved}"
+}
+
+# memory_track_fix <error_sig> <success_bool>
+# Convenience wrapper for memory_record_fix_outcome
+memory_track_fix() {
+    local error_sig="${1:-}"
+    local success="${2:-false}"
+    [[ -z "$error_sig" ]] && return 0
+    memory_record_fix_outcome "$error_sig" "true" "$success" 2>/dev/null || true
+}
+
+# memory_query_fix_for_error <error_pattern>
+# Searches failure memory for known fixes matching the given error pattern.
+# Returns JSON with the best fix (highest effectiveness rate) or empty.
+memory_query_fix_for_error() {
+    local error_pattern="$1"
+    [[ -z "$error_pattern" ]] && return 0
+
+    ensure_memory_dir
+    local mem_dir
+    mem_dir="$(repo_memory_dir)"
+    local failures_file="$mem_dir/failures.json"
+
+    [[ ! -f "$failures_file" ]] && return 0
+
+    # Search for matching failures with successful fixes
+    local matches
+    matches=$(jq -r --arg pat "$error_pattern" '
+        [.failures[]
+        | select(.pattern != null and .pattern != "")
+        | select(.pattern | test($pat; "i") // false)
+        | select(.fix != null and .fix != "")
+        | select((.fix_effectiveness_rate // 0) > 30)
+        | {fix, fix_effectiveness_rate, seen_count, category, stage, pattern}]
+        | sort_by(-.fix_effectiveness_rate)
+        | .[0] // null
+    ' "$failures_file" 2>/dev/null) || true
+
+    if [[ -n "$matches" && "$matches" != "null" ]]; then
+        echo "$matches"
+    fi
+}
+
+# memory_closed_loop_inject <error_sig>
+# Combines error → memory → fix into injectable text for build retries.
+# Returns a one-line summary suitable for goal augmentation.
+memory_closed_loop_inject() {
+    local error_sig="$1"
+    [[ -z "$error_sig" ]] && return 0
+
+    local fix_json
+    fix_json=$(memory_query_fix_for_error "$error_sig") || true
+    [[ -z "$fix_json" || "$fix_json" == "null" ]] && return 0
+
+    local fix_text success_rate category
+    fix_text=$(echo "$fix_json" | jq -r '.fix // ""')
+    success_rate=$(echo "$fix_json" | jq -r '.fix_effectiveness_rate // 0')
+    category=$(echo "$fix_json" | jq -r '.category // "unknown"')
+
+    [[ -z "$fix_text" ]] && return 0
+
+    echo "[$category, ${success_rate}% success rate] $fix_text"
+}
+
+memory_capture_failure_from_log() {
+    local artifacts_dir="${1:-}"
+    local error_log="${artifacts_dir}/error-log.jsonl"
+    [[ ! -f "$error_log" ]] && return 0
+
+    ensure_memory_dir
+    local mem_dir
+    mem_dir="$(repo_memory_dir)"
+    local failures_file="$mem_dir/failures.json"
+
+    # Read last 50 entries
+    local entries
+    entries=$(tail -50 "$error_log" 2>/dev/null) || return 0
+    [[ -z "$entries" ]] && return 0
+
+    local captured=0
+    while IFS= read -r line; do
+        [[ -z "$line" ]] && continue
+
+        local err_type err_text
+        err_type=$(echo "$line" | jq -r '.type // "unknown"' 2>/dev/null) || continue
+        err_text=$(echo "$line" | jq -r '.error // ""' 2>/dev/null) || continue
+        [[ -z "$err_text" ]] && continue
+
+        # Deduplicate: skip if this exact pattern already exists in failures
+        local pattern_short
+        pattern_short=$(echo "$err_text" | head -1 | cut -c1-200)
+        local already_exists
+        already_exists=$(jq --arg pat "$pattern_short" \
+            '[.failures[] | select(.pattern == $pat)] | length' \
+            "$failures_file" 2>/dev/null || echo "0")
+        if [[ "${already_exists:-0}" -gt 0 ]]; then
+            continue
+        fi
+
+        # Feed into memory_capture_failure with the error type as stage
+        memory_capture_failure "$err_type" "$err_text" 2>/dev/null || true
+        captured=$((captured + 1))
+    done <<< "$entries"
+
+    if [[ "$captured" -gt 0 ]]; then
+        emit_event "memory.error_log_processed" "captured=$captured"
+    fi
+}
+
+# _memory_aggregate_global
+# Promotes high-frequency failure patterns to global.json for cross-repo learning
+_memory_aggregate_global() {
+    ensure_memory_dir
+    local mem_dir
+    mem_dir="$(repo_memory_dir)"
+    local failures_file="$mem_dir/failures.json"
+    [[ ! -f "$failures_file" ]] && return 0
+
+    local global_file="$GLOBAL_MEMORY"
+    [[ ! -f "$global_file" ]] && return 0
+
+    # Find patterns with seen_count >= 3
+    local frequent_patterns
+    frequent_patterns=$(jq -r '.failures[] | select(.seen_count >= 3) | .pattern' \
+        "$failures_file" 2>/dev/null) || return 0
+    [[ -z "$frequent_patterns" ]] && return 0
+
+    local promoted=0
+    while IFS= read -r pattern; do
+        [[ -z "$pattern" ]] && continue
+
+        # Check if already in global
+        local exists
+        exists=$(jq --arg p "$pattern" \
+            '[.common_patterns[] | select(.pattern == $p)] | length' \
+            "$global_file" 2>/dev/null || echo "0")
+        if [[ "${exists:-0}" -gt 0 ]]; then
+            continue
+        fi
+
+        # Add to global, cap at 100 entries
+        local tmp_global
+        tmp_global=$(mktemp "${global_file}.tmp.XXXXXX")
+        jq --arg p "$pattern" \
            --arg ts "$(now_iso)" \
-           '.failures += [{
-               stage: $stage,
-               pattern: $pattern,
-               root_cause: "",
-               fix: "",
-               seen_count: 1,
-               last_seen: $ts
-           }] | .failures = (.failures | .[-100:])' \
-           "$failures_file" > "$tmp_file" && mv "$tmp_file" "$failures_file"
+           --arg cat "general" \
+           '.common_patterns += [{pattern: $p, promoted_at: $ts, category: $cat, source: "aggregate"}] |
+            .common_patterns = (.common_patterns | .[-100:])' \
+           "$global_file" > "$tmp_global" && mv "$tmp_global" "$global_file" || rm -f "$tmp_global"
+        promoted=$((promoted + 1))
+    done <<< "$frequent_patterns"
+
+    if [[ "$promoted" -gt 0 ]]; then
+        emit_event "memory.global_aggregated" "promoted=$promoted"
     fi
+}
 
-    emit_event "memory.failure" "stage=${stage}" "pattern=${pattern:0:80}"
+# memory_finalize_pipeline <state_file> <artifacts_dir>
+# Single call that closes multiple feedback loops at pipeline completion
+memory_finalize_pipeline() {
+    local state_file="${1:-}"
+    local artifacts_dir="${2:-}"
+    [[ -z "$state_file" || ! -f "$state_file" ]] && return 0
+
+    # Step 1: Capture pipeline-level learnings
+    memory_capture_pipeline "$state_file" "$artifacts_dir" 2>/dev/null || true
+
+    # Step 2: Process error log into failures.json
+    memory_capture_failure_from_log "$artifacts_dir" 2>/dev/null || true
+
+    # Step 3: Aggregate high-frequency patterns to global memory
+    _memory_aggregate_global 2>/dev/null || true
 }
 
 # memory_analyze_failure <log_file> <stage>
@@ -281,16 +530,41 @@ memory_analyze_failure() {
 
     info "Analyzing failure in ${CYAN}${stage}${RESET} stage..."
 
+    # Gather past successful analyses for the same stage/category as examples
+    local past_examples=""
+    if [[ -f "$failures_file" ]]; then
+        past_examples=$(jq -r --arg stg "$stage" \
+            '[.failures[] | select(.stage == $stg and .root_cause != "" and .fix != "")] |
+             sort_by(-.fix_effectiveness_rate // 0) | .[:2][] |
+             "- Pattern: \(.pattern[:80])\n  Root cause: \(.root_cause)\n  Fix: \(.fix)"' \
+            "$failures_file" 2>/dev/null || true)
+    fi
+
+    # Build valid categories list (from compat.sh if available, else hardcoded)
+    local valid_cats="test_failure, build_error, lint_error, timeout, dependency, flaky, config"
+    if [[ -n "${SW_ERROR_CATEGORIES:-}" ]]; then
+        valid_cats=$(echo "$SW_ERROR_CATEGORIES" | tr ' ' ', ')
+    fi
+
     # Build the analysis prompt
     local prompt
     prompt="Analyze this pipeline failure. The stage was: ${stage}.
 The error pattern is: ${last_pattern}
 
 Log output (last 200 lines):
-${log_tail}
+${log_tail}"
+
+    if [[ -n "$past_examples" ]]; then
+        prompt="${prompt}
+
+Here are examples of how similar failures were diagnosed in this repo:
+${past_examples}"
+    fi
+
+    prompt="${prompt}
 
 Return ONLY a JSON object with exactly these fields:
-{\"root_cause\": \"one-line root cause\", \"fix\": \"one-line fix suggestion\", \"category\": \"one of: test_failure, build_error, lint_error, timeout, dependency, flaky, config\"}
+{\"root_cause\": \"one-line root cause\", \"fix\": \"one-line fix suggestion\", \"category\": \"one of: ${valid_cats}\"}
 
 Return JSON only, no markdown fences, no explanation."
 
@@ -315,11 +589,17 @@ Return JSON only, no markdown fences, no explanation."
         return 1
     fi
 
-    # Validate category against allowed values
-    case "$category" in
-        test_failure|build_error|lint_error|timeout|dependency|flaky|config) ;;
-        *) category="unknown" ;;
-    esac
+    # Validate category against shared taxonomy (compat.sh) or built-in list
+    if type sw_valid_error_category &>/dev/null 2>&1; then
+        if ! sw_valid_error_category "$category"; then
+            category="unknown"
+        fi
+    else
+        case "$category" in
+            test_failure|build_error|lint_error|timeout|dependency|flaky|config) ;;
+            *) category="unknown" ;;
+        esac
+    fi
 
     # Update the most recent failure entry with root_cause, fix, category
     local tmp_file
@@ -478,9 +758,27 @@ memory_capture_pattern() {
 
 # memory_inject_context <stage_id>
 # Returns a text block of relevant memory for a given pipeline stage.
+# When intelligence engine is available, uses AI-ranked search for better relevance.
 memory_inject_context() {
     local stage_id="${1:-}"
 
+    # Try intelligence-ranked search first
+    if type intelligence_search_memory &>/dev/null 2>&1; then
+        local config="${REPO_DIR:-.}/.claude/daemon-config.json"
+        local intel_enabled="false"
+        if [[ -f "$config" ]]; then
+            intel_enabled=$(jq -r '.intelligence.enabled // false' "$config" 2>/dev/null || echo "false")
+        fi
+        if [[ "$intel_enabled" == "true" ]]; then
+            local ranked_result
+            ranked_result=$(intelligence_search_memory "$stage_id stage context" "$(repo_memory_dir)" 5 2>/dev/null || echo "")
+            if [[ -n "$ranked_result" ]] && [[ "$ranked_result" != *'"error"'* ]]; then
+                echo "$ranked_result"
+                return 0
+            fi
+        fi
+    fi
+
     ensure_memory_dir
     local mem_dir
     mem_dir="$(repo_memory_dir)"
@@ -537,12 +835,28 @@ memory_inject_context() {
             ;;
 
         build)
-            # Failure patterns to avoid + code conventions
+            # Failure patterns to avoid — ranked by relevance (recency + effectiveness + frequency)
             echo "## Failure Patterns to Avoid"
             if [[ -f "$mem_dir/failures.json" ]]; then
-                jq -r '.failures | sort_by(-.seen_count) | .[:10][] |
+                jq -r 'now as $now |
+                    .failures | map(. +
+                        { relevance_score:
+                            ((.seen_count // 1) * 1) +
+                            (if .fix_effectiveness_rate then (.fix_effectiveness_rate / 10) else 0 end) +
+                            (if .last_seen then
+                                (($now - ((.last_seen | sub("\\.[0-9]+Z$"; "Z") | strptime("%Y-%m-%dT%H:%M:%SZ") | mktime) // 0)) |
+                                 if . < 86400 then 5
+                                 elif . < 604800 then 3
+                                 elif . < 2592000 then 1
+                                 else 0 end)
+                            else 0 end)
+                        }
+                    ) | sort_by(-.relevance_score) | .[:10][] |
                     "- [\(.stage)] \(.pattern) (seen \(.seen_count)x)" +
-                    if .fix != "" then "\n  Fix: \(.fix)" else "" end' \
+                    if .fix != "" then
+                        "\n  Fix: \(.fix)" +
+                        if .fix_effectiveness_rate then " (effectiveness: \(.fix_effectiveness_rate)%)" else "" end
+                    else "" end' \
                     "$mem_dir/failures.json" 2>/dev/null || echo "- No failures recorded."
             fi
 
@@ -550,7 +864,8 @@ memory_inject_context() {
             echo "## Known Fixes"
             if [[ -f "$mem_dir/failures.json" ]]; then
                 jq -r '.failures[] | select(.root_cause != "" and .fix != "" and .stage == "build") |
-                    "- [\(.category // "unknown")] \(.root_cause)\n  Fix: \(.fix)"' \
+                    "- [\(.category // "unknown")] \(.root_cause)\n  Fix: \(.fix)" +
+                    if .fix_effectiveness_rate then " (effectiveness: \(.fix_effectiveness_rate)%)" else "" end' \
                     "$mem_dir/failures.json" 2>/dev/null || echo "- No analyzed fixes yet."
             else
                 echo "- No analyzed fixes yet."
@@ -618,19 +933,150 @@ memory_inject_context() {
             ;;
 
         *)
-            # Generic context for any other stage
+            # Generic context for any stage — inject top-K most relevant across all categories
             echo "## Repository Patterns"
             if [[ -f "$mem_dir/patterns.json" ]]; then
                 jq -r 'to_entries | map(select(.key != "known_issues")) | from_entries' \
                     "$mem_dir/patterns.json" 2>/dev/null || true
             fi
+
+            # Inject top failures regardless of category (ranked by relevance)
+            echo ""
+            echo "## Relevant Failure Patterns"
+            if [[ -f "$mem_dir/failures.json" ]]; then
+                jq -r --arg stg "$stage_id" \
+                    '.failures |
+                     map(. + { stage_match: (if .stage == $stg then 10 else 0 end) }) |
+                     sort_by(-(.seen_count + .stage_match + (.fix_effectiveness_rate // 0) / 10)) |
+                     .[:5][] |
+                     "- [\(.stage)] \(.pattern[:80]) (seen \(.seen_count)x)" +
+                     if .fix != "" then "\n  Fix: \(.fix)" else "" end' \
+                    "$mem_dir/failures.json" 2>/dev/null || echo "- None recorded."
+            fi
+
+            # Inject recent decisions
+            echo ""
+            echo "## Recent Decisions"
+            if [[ -f "$mem_dir/decisions.json" ]]; then
+                jq -r '.decisions[-3:][] |
+                    "- [\(.type // "decision")] \(.summary // "no description")"' \
+                    "$mem_dir/decisions.json" 2>/dev/null || echo "- None recorded."
+            fi
             ;;
     esac
 
+    # ── Cross-repo memory injection (global learnings) ──
+    if [[ -f "$GLOBAL_MEMORY" ]]; then
+        local global_patterns
+        global_patterns=$(jq -r --arg stage "$stage_id" '
+            .common_patterns // [] | .[] |
+            select(.category == $stage or .category == "general" or .category == null) |
+            .summary // .description // empty
+        ' "$GLOBAL_MEMORY" 2>/dev/null | head -5 || true)
+
+        local cross_repo_learnings
+        cross_repo_learnings=$(jq -r '
+            .cross_repo_learnings // [] | .[-5:][] |
+            "- [\(.repo // "unknown")] \(.type // "learning"): bugs=\(.bugs // 0), warnings=\(.warnings // 0)"
+        ' "$GLOBAL_MEMORY" 2>/dev/null | head -5 || true)
+
+        if [[ -n "$global_patterns" || -n "$cross_repo_learnings" ]]; then
+            echo ""
+            echo "## Cross-Repo Learnings (Global)"
+            [[ -n "$global_patterns" ]] && echo "$global_patterns"
+            [[ -n "$cross_repo_learnings" ]] && echo "$cross_repo_learnings"
+        fi
+    fi
+
     echo ""
     emit_event "memory.inject" "stage=${stage_id}"
 }
 
+# memory_get_actionable_failures [threshold]
+# Returns JSON array of failure patterns with seen_count >= threshold.
+# Used by daemon patrol to detect recurring failures worth fixing.
+memory_get_actionable_failures() {
+    local threshold="${1:-3}"
+
+    ensure_memory_dir
+    local mem_dir
+    mem_dir="$(repo_memory_dir)"
+    local failures_file="$mem_dir/failures.json"
+
+    if [[ ! -f "$failures_file" ]]; then
+        echo "[]"
+        return 0
+    fi
+
+    jq --argjson t "$threshold" \
+        '[.failures[] | select(.seen_count >= $t)] | sort_by(-.seen_count)' \
+        "$failures_file" 2>/dev/null || echo "[]"
+}
+
+# memory_get_dora_baseline [window_days] [offset_days]
+# Calculates DORA metrics for a time window from events.jsonl.
+# Returns JSON: {deploy_freq, cycle_time, cfr, mttr, total, grades: {df, ct, cfr, mttr}}
+memory_get_dora_baseline() {
+    local window_days="${1:-7}"
+    local offset_days="${2:-0}"
+
+    local events_file="${HOME}/.shipwright/events.jsonl"
+    if [[ ! -f "$events_file" ]]; then
+        echo '{"deploy_freq":0,"cycle_time":0,"cfr":0,"mttr":0,"total":0}'
+        return 0
+    fi
+
+    local now_e
+    now_e=$(now_epoch)
+    local window_end=$((now_e - offset_days * 86400))
+    local window_start=$((window_end - window_days * 86400))
+
+    # Extract pipeline events for the window
+    local metrics
+    metrics=$(jq -s --argjson start "$window_start" --argjson end "$window_end" '
+        [.[] | select(.ts_epoch >= $start and .ts_epoch < $end)] as $events |
+        [$events[] | select(.type == "pipeline.completed")] as $completed |
+        ($completed | length) as $total |
+        [$completed[] | select(.result == "success")] as $successes |
+        [$completed[] | select(.result == "failure")] as $failures |
+        ($successes | length) as $success_count |
+        ($failures | length) as $failure_count |
+
+        # Deploy frequency (per week)
+        (if $total > 0 then ($success_count * 7 / '"$window_days"') else 0 end) as $deploy_freq |
+
+        # Cycle time median
+        ([$successes[] | .duration_s] | sort |
+            if length > 0 then .[length/2 | floor] else 0 end) as $cycle_time |
+
+        # Change failure rate
+        (if $total > 0 then ($failure_count / $total * 100) else 0 end) as $cfr |
+
+        # MTTR
+        ($completed | sort_by(.ts_epoch // 0) |
+            [range(length) as $i |
+                if .[$i].result == "failure" then
+                    [.[$i+1:][] | select(.result == "success")][0] as $next |
+                    if $next and $next.ts_epoch and .[$i].ts_epoch then
+                        ($next.ts_epoch - .[$i].ts_epoch)
+                    else null end
+                else null end
+            ] | map(select(. != null)) |
+            if length > 0 then (add / length | floor) else 0 end
+        ) as $mttr |
+
+        {
+            deploy_freq: ($deploy_freq * 10 | floor / 10),
+            cycle_time: $cycle_time,
+            cfr: ($cfr * 10 | floor / 10),
+            mttr: $mttr,
+            total: $total
+        }
+    ' "$events_file" 2>/dev/null || echo '{"deploy_freq":0,"cycle_time":0,"cfr":0,"mttr":0,"total":0}')
+
+    echo "$metrics"
+}
+
 # memory_update_metrics <metric_name> <value>
 # Track performance baselines and flag regressions.
 memory_update_metrics() {
@@ -838,6 +1284,34 @@ memory_search() {
 
     local found=0
 
+    # ── Semantic search via intelligence (if available) ──
+    if type intelligence_search_memory &>/dev/null 2>&1; then
+        local semantic_results
+        semantic_results=$(intelligence_search_memory "$keyword" "$mem_dir" 5 2>/dev/null || echo "")
+        if [[ -n "$semantic_results" ]] && echo "$semantic_results" | jq -e '.results | length > 0' &>/dev/null; then
+            echo -e "  ${BOLD}${CYAN}Semantic Results (AI-ranked):${RESET}"
+            local result_count
+            result_count=$(echo "$semantic_results" | jq '.results | length')
+            local i=0
+            while [[ "$i" -lt "$result_count" ]]; do
+                local file rel summary
+                file=$(echo "$semantic_results" | jq -r ".results[$i].file // \"\"")
+                rel=$(echo "$semantic_results" | jq -r ".results[$i].relevance // 0")
+                summary=$(echo "$semantic_results" | jq -r ".results[$i].summary // \"\"")
+                echo -e "    ${GREEN}●${RESET} [${rel}%] ${BOLD}${file}${RESET} — ${summary}"
+                i=$((i + 1))
+            done
+            echo ""
+            found=$((found + 1))
+
+            # Also run grep search below for completeness
+            echo -e "  ${DIM}Grep results (supplemental):${RESET}"
+            echo ""
+        fi
+    fi
+
+    # ── Grep-based search (fallback / supplemental) ──
+
     # Search patterns
     if [[ -f "$mem_dir/patterns.json" ]]; then
         local pattern_matches
@@ -1083,6 +1557,7 @@ show_help() {
     echo -e "  ${CYAN}metric${RESET} <name> <value>           Update a performance baseline"
     echo -e "  ${CYAN}decision${RESET} <type> <summary>       Record a design decision"
     echo -e "  ${CYAN}analyze-failure${RESET} <log> <stage>    Analyze failure root cause via AI"
+    echo -e "  ${CYAN}fix-outcome${RESET} <pattern> <applied> <resolved>  Record fix effectiveness"
     echo ""
     echo -e "${BOLD}EXAMPLES${RESET}"
     echo -e "  ${DIM}shipwright memory show${RESET}                            # View repo memory"
@@ -1136,6 +1611,9 @@ case "$SUBCOMMAND" in
     analyze-failure)
         memory_analyze_failure "$@"
         ;;
+    fix-outcome)
+        memory_record_fix_outcome "$@"
+        ;;
     help|--help|-h)
         show_help
         ;;