specweave 1.0.550 → 1.0.552

package/plugins/specweave/hooks/stop-auto-v5.sh

@@ -1,276 +0,0 @@
-#!/bin/bash
-# stop-auto-v5.sh - Auto Mode Stop Hook (v5.0 - Gate Only)
-# ADR-0225: "Increments ARE the state. Hooks ARE the sync."
-# Hook = simple gate. Quality gates (tests, build, coverage) belong in /sw:done.
-# Sourceable: set __STOP_AUTO_V5_SOURCED=1 to load functions only.
-set +e
-
-# ── Timing ───────────────────────────────────────────────────────────────
-if [[ "$OSTYPE" == "darwin"* ]]; then _START_MS=$(($(date +%s) * 1000))
-else _START_MS=$(($(date +%s) * 1000 + $(date +%N 2>/dev/null | cut -c1-3 || echo "0"))); fi
-_get_duration_ms() {
-    local n; if [[ "$OSTYPE" == "darwin"* ]]; then n=$(($(date +%s) * 1000))
-    else n=$(($(date +%s) * 1000 + $(date +%N 2>/dev/null | cut -c1-3 || echo "0"))); fi
-    echo $((n - _START_MS))
-}
-
-# ── Stdin & paths ────────────────────────────────────────────────────────
-if [ -z "${__STOP_AUTO_V5_SOURCED:-}" ]; then
-    STDIN_DATA=$(cat)
-    CLAUDE_SESSION_ID=$(echo "$STDIN_DATA" | jq -r '.session_id // ""' 2>/dev/null || echo "")
-else
-    STDIN_DATA=""
-    CLAUDE_SESSION_ID=""
-fi
-
-# Project root detection (walk up to find .specweave/ — prevents pollution of subdirectories)
-if [[ -n "${PROJECT_ROOT:-}" ]] && [[ -f "$PROJECT_ROOT/.specweave/config.json" ]]; then
-    : # env var already set and valid
-else
-    PROJECT_ROOT="$PWD"
-    while [[ "$PROJECT_ROOT" != "/" ]] && [[ ! -f "$PROJECT_ROOT/.specweave/config.json" ]]; do
-        PROJECT_ROOT=$(dirname "$PROJECT_ROOT")
-    done
-fi
-
-# Not a SpecWeave project — approve and exit (MUST be before any mkdir)
-if [[ ! -f "$PROJECT_ROOT/.specweave/config.json" ]]; then
-    echo '{"decision":"approve"}'
-    exit 0
-fi
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-[ -f "$SCRIPT_DIR/log-decision.sh" ] && source "$SCRIPT_DIR/log-decision.sh"
-
-SW="$PROJECT_ROOT/.specweave"
-STATE_DIR="$SW/state"
-LOGS_DIR="$SW/logs"
-LOG_FILE="$LOGS_DIR/stop-auto.log"
-
-log() {
-    mkdir -p "$LOGS_DIR" 2>/dev/null
-    echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] $1" >> "$LOG_FILE" 2>/dev/null
-    [ "${SPECWEAVE_DEBUG_HOOKS:-0}" = "1" ] && echo -e "\033[36m[stop-auto-v5]\033[0m $1" >&2
-}
-
-# ── Helpers ──────────────────────────────────────────────────────────────
-count_pending_tasks() {
-    local f="$1"; [ ! -f "$f" ] && echo "0" && return
-    local c; c=$(grep -c '\[ \]' "$f" 2>/dev/null) || true; echo "${c:-0}"
-}
-count_completed_tasks() {
-    local f="$1"; [ ! -f "$f" ] && echo "0" && return
-    local c; c=$(grep -c '\[x\]' "$f" 2>/dev/null) || true; echo "${c:-0}"
-}
-count_open_acs() {
-    local f="$1"; [ ! -f "$f" ] && echo "0" && return
-    local c; c=$(grep -c '\[ \]' "$f" 2>/dev/null) || true; echo "${c:-0}"
-}
-get_next_task_title() {
-    local f="$1"; [ ! -f "$f" ] && echo "" && return
-    local lnum; lnum=$(grep -n '\[ \]' "$f" 2>/dev/null | head -1 | cut -d: -f1)
-    [ -z "$lnum" ] && echo "" && return
-    # Search backwards from [ ] line to find ### T-NNN: Title heading
-    local title; title=$(head -n "$lnum" "$f" | grep '### T-' | tail -1 | sed 's/^### T-[0-9]*: //')
-    echo "${title}" | head -c 80
-}
-silent_approve() {
-    local reason="$1" rc="${2:-session_inactive}" ctx="${3:-"{}"}"
-    log "APPROVE: $reason"
-    type log_decision &>/dev/null && log_decision "stop-auto" "approve" "$rc" "$reason" "$ctx" "$(_get_duration_ms)"
-    echo '{"decision":"approve"}'; exit 0
-}
-loud_approve() {
-    local reason="$1" rc="${2:-session_complete}" ctx="${3:-"{}"}" msg="$4"
-    log "APPROVE (loud): $reason"
-    type log_decision &>/dev/null && log_decision "stop-auto" "approve" "$rc" "$reason" "$ctx" "$(_get_duration_ms)"
-    jq -n --arg d "approve" --arg r "$reason" --arg m "$msg" '{decision:$d,reason:$r,systemMessage:$m}'; exit 0
-}
-block() {
-    local reason="$1" rc="${2:-work_remaining}" ctx="${3:-"{}"}" msg="$4"
-    log "BLOCK: $reason"
-    type log_decision &>/dev/null && log_decision "stop-auto" "block" "$rc" "$reason" "$ctx" "$(_get_duration_ms)"
-    jq -n --arg d "block" --arg r "$reason" --arg rc "$rc" --arg m "$msg" '{decision:$d,reason:$r,reasonCode:$rc,systemMessage:$m}'; exit 0
-}
-
-# ── Source-only guard ────────────────────────────────────────────────────
-[ "${__STOP_AUTO_V5_SOURCED:-}" = "1" ] && return 0 2>/dev/null || true
-[ "${__STOP_AUTO_V5_SOURCED:-}" = "1" ] && exit 0
-
-# ═════════════════════════════════════════════════════════════════════════
-# MAIN
-# ═════════════════════════════════════════════════════════════════════════
-INC_DIR="$SW/increments"
-CFG="$SW/config.json"
-SESSION="$STATE_DIR/auto-mode.json"
-
-# Per-session auto-mode.json takes priority over global
-if [ -n "$CLAUDE_SESSION_ID" ] && [ -f "$STATE_DIR/sessions/$CLAUDE_SESSION_ID/auto-mode.json" ]; then
-    SESSION="$STATE_DIR/sessions/$CLAUDE_SESSION_ID/auto-mode.json"
-    log "Using per-session auto-mode: $CLAUDE_SESSION_ID"
-fi
-
-# Per-session turn counter and dedup files when session ID is available
-if [ -n "$CLAUDE_SESSION_ID" ] && [ -d "$STATE_DIR/sessions/$CLAUDE_SESSION_ID" ]; then
-    TURN_FILE="$STATE_DIR/sessions/$CLAUDE_SESSION_ID/.stop-auto-turns"
-    DEDUP_PREV="$STATE_DIR/sessions/$CLAUDE_SESSION_ID/.stop-auto-dedup-prev"
-else
-    TURN_FILE="$STATE_DIR/.stop-auto-turns"
-    DEDUP_PREV="$STATE_DIR/.stop-auto-dedup-prev"
-fi
-
-# 1. Quick exits
-[ ! -d "$SW" ] && silent_approve "Not a SpecWeave project" "not_specweave_project"
-[ ! -d "$INC_DIR" ] && silent_approve "No increments directory" "no_increments_dir"
-
-# 2. Config
-MAX_TURNS=20; MAX_AGE=7200; AUTO_ON="true"; DEDUP_WIN="${SPECWEAVE_STOP_HOOK_DEDUP:-30}"
-if [ -f "$CFG" ]; then
-    AUTO_ON=$(jq -r '.auto.enabled // true' "$CFG" 2>/dev/null || echo "true")
-    MAX_TURNS=$(jq -r '.auto.maxTurns // 20' "$CFG" 2>/dev/null || echo "20")
-    MAX_AGE=$(jq -r '.auto.maxSessionAge // 7200' "$CFG" 2>/dev/null || echo "7200")
-fi
-[ "$AUTO_ON" != "true" ] && silent_approve "Auto mode disabled" "auto_disabled"
-
-# 3. Session marker
-[ ! -f "$SESSION" ] && silent_approve "No auto session" "session_inactive" '{"sessionActive":false}'
-ACTIVE=$(jq -r '.active // false' "$SESSION" 2>/dev/null || echo "false")
-[ "$ACTIVE" != "true" ] && silent_approve "Session not active" "session_inactive" '{"sessionActive":false}'
-
-# 4. Staleness
-MTIME=$(stat -f%m "$SESSION" 2>/dev/null || stat -c%Y "$SESSION" 2>/dev/null || echo "0")
-NOW=$(date +%s); AGE=$((NOW - MTIME))
-if [ "$AGE" -gt "$MAX_AGE" ]; then
-    rm -f "$SESSION" "$DEDUP_PREV" "$TURN_FILE" 2>/dev/null
-    silent_approve "Stale session (${AGE}s)" "session_stale" \
-        "$(jq -n --argjson a "$AGE" --argjson m "$MAX_AGE" '{sessionAge:$a,maxSessionAge:$m}')"
-fi
-touch "$SESSION" 2>/dev/null
-
-# 5. Turn counter (never resets during session)
-TURN=1
-if [ -f "$TURN_FILE" ]; then
-    S=$(cat "$TURN_FILE" 2>/dev/null || echo "0")
-    [[ "$S" =~ ^[0-9]+$ ]] && TURN=$((S + 1))
-fi
-mkdir -p "$STATE_DIR" 2>/dev/null
-echo "$TURN" > "$TURN_FILE.tmp" && mv "$TURN_FILE.tmp" "$TURN_FILE" 2>/dev/null
-
-if [ "$TURN" -ge "$MAX_TURNS" ]; then
-    rm -f "$SESSION" "$DEDUP_PREV" "$TURN_FILE" 2>/dev/null
-    loud_approve "Turn limit ($TURN/$MAX_TURNS)" "turn_limit" \
-        "$(jq -n --argjson c "$TURN" --argjson m "$MAX_TURNS" '{turn:{current:$c,max:$m}}')" \
-        "Turn limit reached ($TURN/$MAX_TURNS). Run /sw:auto to start a new session."
-fi
-
-# 6. Dedup (write-first prevents race)
-if [ -f "$DEDUP_PREV" ]; then
-    LAST=$(cat "$DEDUP_PREV" 2>/dev/null || echo "0")
-    EL=$((NOW - LAST))
-    if [ "$EL" -lt "$DEDUP_WIN" ]; then
-        silent_approve "Deduplicated (${EL}s)" "deduplicated" \
-            "$(jq -n --argjson e "$EL" --argjson w "$DEDUP_WIN" '{elapsed:$e,dedupWindow:$w}')"
-    fi
-fi
-echo "$NOW" > "$DEDUP_PREV" 2>/dev/null
-
-# 7. Read userGoal and simple mode from session marker
-USER_GOAL=$(jq -r '.userGoal // ""' "$SESSION" 2>/dev/null || echo "")
-SIMPLE=$(jq -r '.simple // false' "$SESSION" 2>/dev/null || echo "false")
-
-# 8. Scan active increments (enriched: next task, progress fraction)
-TP=0; TAC=0; IC=0; ILIST=""
-_SCORE_SCRIPT="$SCRIPT_DIR/lib/score-increment.sh"
-for meta in $(find "$INC_DIR" -maxdepth 2 -name "metadata.json" 2>/dev/null); do
-    st=$(jq -r '.status // "unknown"' "$meta" 2>/dev/null || echo "unknown")
-    [ "$st" != "active" ] && [ "$st" != "in-progress" ] && continue
-    d=$(dirname "$meta"); id=$(basename "$d")
-    p=$(count_pending_tasks "$d/tasks.md"); a=$(count_open_acs "$d/spec.md")
-    if [ "$p" -gt 0 ] || [ "$a" -gt 0 ]; then
-        TP=$((TP + p)); TAC=$((TAC + a)); IC=$((IC + 1))
-        # Extract next pending task title using helper
-        _next_task=$(get_next_task_title "$d/tasks.md")
-        # Count completed tasks for progress fraction
-        _done=$(grep -c '\[x\]' "$d/tasks.md" 2>/dev/null) || _done=0
-        _total=$((_done + p))
-        # Score against userGoal if set and scoring script available
-        _score=""
-        if [ -n "$USER_GOAL" ] && [ -f "$_SCORE_SCRIPT" ]; then
-            _score=$(bash "$_SCORE_SCRIPT" "$d" "$USER_GOAL" 2>/dev/null || echo "0")
-        fi
-        # Extended ILIST format: id|pending|acs|next_task|done|total|score
-        _entry="$id|$p|$a|$_next_task|$_done|$_total|${_score:-0}"
-        [ -z "$ILIST" ] && ILIST="$_entry" || ILIST="$ILIST,$_entry"
-    fi
-done
-
-# 9. All work items complete → check if closure needed
-if [ "$IC" -eq 0 ]; then
-    # Count active/in-progress increments (regardless of task completion)
-    _ACTIVE_COUNT=0; _ACTIVE_IDS=""
-    for _meta in $(find "$INC_DIR" -maxdepth 2 -name "metadata.json" 2>/dev/null); do
-        _st=$(jq -r '.status // "unknown"' "$_meta" 2>/dev/null || echo "unknown")
-        if [ "$_st" = "active" ] || [ "$_st" = "in-progress" ]; then
-            _ACTIVE_COUNT=$((_ACTIVE_COUNT + 1))
-            _d=$(dirname "$_meta"); _id=$(basename "$_d")
-            [ -z "$_ACTIVE_IDS" ] && _ACTIVE_IDS="$_id" || _ACTIVE_IDS="$_ACTIVE_IDS, $_id"
-        fi
-    done
-
-    if [ "$_ACTIVE_COUNT" -gt 0 ]; then
-        # Active increments with all tasks done → block for closure (do NOT clean up state)
-        _CLOSE_MSG="All tasks and ACs complete. Run \`/sw:done --auto <id>\` to close: ${_ACTIVE_IDS}"
-        block "All work complete, needs closure" "all_complete_needs_closure" \
-            "$(jq -n --argjson t "$TURN" --arg ids "$_ACTIVE_IDS" '{turn:$t,incrementIds:$ids}')" \
-            "$_CLOSE_MSG"
-    else
-        # All increments already closed (completed/archived) → approve and clean up
-        rm -f "$SESSION" "$DEDUP_PREV" "$TURN_FILE" 2>/dev/null
-        loud_approve "All increments closed" "all_complete" \
-            "$(jq -n --argjson t "$TURN" '{turn:$t}')" \
-            "All increments are closed. Auto session complete."
-    fi
-fi
-
-# 10. Work remains → block with context message (simple or enriched)
-# Sort entries by score descending (highest-relevance first) when userGoal is set
-SORTED_ILIST="$ILIST"
-if [ -n "$USER_GOAL" ] && [ "$IC" -gt 1 ]; then
-    # Sort by score field (7th field) descending
-    SORTED_ILIST=$(echo "$ILIST" | tr ',' '\n' | sort -t'|' -k7 -nr | tr '\n' ',')
-    SORTED_ILIST="${SORTED_ILIST%,}"  # trim trailing comma
-fi
-
-# Extract best increment ID (first entry after sorting)
-_BEST_ID=""
-IFS=',' read -ra ENTRIES <<< "$SORTED_ILIST"
-IFS='|' read -r _BEST_ID _rest <<< "${ENTRIES[0]}"
-
-if [ "$SIMPLE" = "true" ]; then
-    # Simple mode: minimal message to reduce context tokens per turn
-    BMSG="Continue: /sw:do ${_BEST_ID} ($TP tasks left, turn $TURN/$MAX_TURNS)"
-    BMSG=$(echo -e "$BMSG")
-else
-    # Full mode: enriched context with per-increment progress and next task
-    DETAILS=""
-    for entry in "${ENTRIES[@]}"; do
-        IFS='|' read -r eid ep ea enext edone etotal escore <<< "$entry"
-        _progress="${edone:-0}/${etotal:-0} tasks"
-        _next_info=""
-        [ -n "$enext" ] && _next_info=" | Next: $enext"
-        DETAILS="${DETAILS}\n  ▸ ${eid}: ${_progress}${_next_info}"
-    done
-
-    BMSG=""
-    [ -n "$USER_GOAL" ] && BMSG="Goal: ${USER_GOAL}\n"
-    BMSG="${BMSG}Auto Mode: ${IC} increment(s) need work${DETAILS}"
-    BMSG="${BMSG}\nTurn $TURN/$MAX_TURNS | Continue: /sw:do ${_BEST_ID}"
-    BMSG=$(echo -e "$BMSG")
-fi
-
-block "Work remaining: $TP tasks, $TAC ACs" "work_remaining" \
-    "$(jq -n --argjson p "$TP" --argjson a "$TAC" --argjson i "$IC" \
-        --argjson t "$TURN" --argjson mt "$MAX_TURNS" --arg il "$ILIST" \
-        --arg goal "$USER_GOAL" --arg best "$_BEST_ID" \
-        '{pendingTasks:$p,openAcs:$a,incompleteIncrements:$i,increments:$il,turn:{current:$t,max:$mt},userGoal:$goal,recommended:$best}')" \
-    "$BMSG"

package/plugins/specweave/hooks/stop-reflect.sh

@@ -1,336 +0,0 @@
-#!/bin/bash
-# stop-reflect.sh - Session Reflection Hook (v3.1 - Structured Decision Logging)
-#
-# ARCHITECTURE (v3.1):
-# - Uses specweave CLI (TypeScript) for reflection
-# - Learnings go to CLAUDE.md under "## Skill Memories" section
-# - User can disable via config: { "reflect": { "enabled": false } }
-# - Structured decision logging to .specweave/logs/decisions.jsonl
-#
-# This hook ALWAYS approves (never blocks sessions) but may trigger
-# background learning extraction if enabled.
-
-set +e  # Never fail - this is a non-critical hook
-
-# Capture start time for duration tracking (macOS doesn't support %N, fallback to seconds only)
-if [[ "$OSTYPE" == "darwin"* ]]; then
-    _START_TIME_MS=$(($(date +%s) * 1000))
-else
-    _START_TIME_MS=$(($(date +%s) * 1000 + $(date +%N 2>/dev/null | cut -c1-3 || echo "0")))
-fi
-
-# Read input from stdin (required by Claude Code hooks)
-INPUT=$(cat)
-
-# Parse input fields
-TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // ""' 2>/dev/null)
-
-# Project root detection (walk up to find .specweave/ — prevents pollution of subdirectories)
-if [[ -n "${PROJECT_ROOT:-}" ]] && [[ -f "$PROJECT_ROOT/.specweave/config.json" ]]; then
-    : # env var already set and valid
-else
-    PROJECT_ROOT="$PWD"
-    while [[ "$PROJECT_ROOT" != "/" ]] && [[ ! -f "$PROJECT_ROOT/.specweave/config.json" ]]; do
-        PROJECT_ROOT=$(dirname "$PROJECT_ROOT")
-    done
-fi
-
-# Not a SpecWeave project — approve and exit (MUST be before any mkdir)
-if [[ ! -f "$PROJECT_ROOT/.specweave/config.json" ]]; then
-    echo '{"decision":"approve"}'
-    exit 0
-fi
-
-CONFIG_FILE="$PROJECT_ROOT/.specweave/config.json"
-LOGS_DIR="$PROJECT_ROOT/.specweave/logs/reflect"
-STATE_DIR="$PROJECT_ROOT/.specweave/state"
-
-# Source the shared decision logging utility
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-if [ -f "$SCRIPT_DIR/log-decision.sh" ]; then
-    source "$SCRIPT_DIR/log-decision.sh"
-fi
-
-# Get duration in milliseconds
-_get_duration_ms() {
-    local end_time_ms
-    if [[ "$OSTYPE" == "darwin"* ]]; then
-        end_time_ms=$(($(date +%s) * 1000))
-    else
-        end_time_ms=$(($(date +%s) * 1000 + $(date +%N 2>/dev/null | cut -c1-3 || echo "0")))
-    fi
-    echo $((end_time_ms - _START_TIME_MS))
-}
-
-# Ensure logs directory exists
-mkdir -p "$LOGS_DIR" 2>/dev/null || true
-
-# Logging function
-log_reflect() {
-    local level="$1"
-    shift
-    local timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date +%Y-%m-%dT%H:%M:%SZ)
-    local log_file="$LOGS_DIR/reflect.log"
-
-    # Rotate if too large (keep last 50 lines)
-    if [ -f "$log_file" ]; then
-        local lines=$(wc -l < "$log_file" 2>/dev/null || echo "0")
-        if [ "$lines" -gt 100 ]; then
-            tail -n 50 "$log_file" > "$log_file.tmp" 2>/dev/null && mv "$log_file.tmp" "$log_file" 2>/dev/null || true
-        fi
-    fi
-
-    echo "[$timestamp] [$level] $*" >> "$log_file" 2>/dev/null || true
-}
-
-# Log decision with context for structured logging
-log_reflect_decision() {
-    local reason_code="$1"
-    local reason="$2"
-    local transcript_lines="${3:-0}"
-    local reflection_enabled="${4:-true}"
-    local learnings_extracted="${5:-0}"
-    local learning_categories_json="${6:-[]}"
-
-    if type log_decision &>/dev/null; then
-        local context_json
-        context_json=$(jq -n \
-            --argjson transcriptLines "$transcript_lines" \
-            --argjson reflectionEnabled "$reflection_enabled" \
-            --argjson learningsExtracted "$learnings_extracted" \
-            --argjson learningCategories "$learning_categories_json" \
-            --arg exitReason "$reason_code" \
-            --arg triggerReason "session_end" \
-            '{
-                transcriptLines: $transcriptLines,
-                reflectionEnabled: $reflectionEnabled,
-                learningsExtracted: $learningsExtracted,
-                learningCategories: $learningCategories,
-                exitReason: $exitReason,
-                triggerReason: $triggerReason
-            }')
-
-        log_decision "stop-reflect" "approve" "$reason_code" "$reason" "$context_json" "$(_get_duration_ms)"
-    fi
-}
-
-# Check if reflection is enabled
-is_reflect_enabled() {
-    if [ ! -f "$CONFIG_FILE" ]; then
-        return 0  # Default to enabled if no config
-    fi
-
-    # Note: can't use // true because jq treats false as falsy
-    local enabled=$(jq -r 'if .reflect.enabled == false then "false" else "true" end' "$CONFIG_FILE" 2>/dev/null)
-    [ "$enabled" = "true" ]
-}
-
-# Cleanup ephemeral state files
-cleanup_session_state() {
-    rm -f "$STATE_DIR/.current-agent-type" 2>/dev/null || true
-}
-
-# Cross-platform timeout function
-# macOS doesn't have GNU timeout - needs gtimeout (coreutils) or perl fallback
-run_with_timeout() {
-    local timeout_sec="$1"
-    shift
-
-    # Try gtimeout first (macOS with coreutils: brew install coreutils)
-    if command -v gtimeout >/dev/null 2>&1; then
-        gtimeout "$timeout_sec" "$@"
-        return $?
-    fi
-
-    # Try GNU timeout (Linux, or macOS with coreutils in PATH)
-    if command -v timeout >/dev/null 2>&1; then
-        timeout "$timeout_sec" "$@"
-        return $?
-    fi
-
-    # Perl fallback (available on all macOS/Linux by default)
-    # alarm() sends SIGALRM after N seconds, which terminates the exec'd process
-    perl -e 'alarm shift; exec @ARGV' "$timeout_sec" "$@"
-    return $?
-}
-
-# Run reflection using TypeScript implementation
-run_reflection() {
-    local transcript="$1"
-
-    # Check if reflect is enabled
-    if ! is_reflect_enabled; then
-        log_reflect "info" "Reflection disabled in config"
-        return 0
-    fi
-
-    # Ensure transcript exists
-    if [ -z "$transcript" ] || [ ! -f "$transcript" ]; then
-        log_reflect "info" "No transcript available"
-        return 0
-    fi
-
-    # Check transcript has meaningful content
-    local lines=$(wc -l < "$transcript" 2>/dev/null | tr -d ' ')
-    if [ "$lines" -lt 10 ]; then
-        log_reflect "info" "Transcript too short ($lines lines)"
-        return 0
-    fi
-
-    log_reflect "info" "Starting reflection ($lines lines)"
-
-    # Use specweave CLI (TypeScript implementation)
-    if command -v specweave >/dev/null 2>&1; then
-        (
-            cd "$PROJECT_ROOT"
-            run_with_timeout 60 specweave reflect-stop "$transcript" --silent >> "$LOGS_DIR/auto-reflect.log" 2>&1
-            local result=$?
-
-            if [ $result -eq 0 ]; then
-                log_reflect "info" "Reflection completed successfully"
-            elif [ $result -eq 124 ]; then
-                log_reflect "warn" "Reflection timed out"
-            else
-                log_reflect "warn" "Reflection completed with exit code $result"
-            fi
-        ) &
-        disown 2>/dev/null
-        log_reflect "info" "Reflection started in background (detached)"
-    else
-        log_reflect "warn" "specweave CLI not found"
-    fi
-
-    return 0
-}
-
-# Run reflection with structured logging (synchronous for test purposes, captures learnings)
-run_reflection_with_logging() {
-    local transcript="$1"
-    local transcript_lines="$2"
-    local learnings_extracted=0
-    local learning_categories="[]"
-    local exit_reason="nothing_to_learn"
-    local reason_msg="No learnings extracted"
-
-    log_reflect "info" "Starting reflection ($transcript_lines lines)"
-
-    # Use specweave CLI (TypeScript implementation)
-    if command -v specweave >/dev/null 2>&1; then
-        # Create a temp file to capture output
-        local temp_output
-        temp_output=$(mktemp)
-
-        (
-            cd "$PROJECT_ROOT"
-            run_with_timeout 60 specweave reflect-stop "$transcript" --silent 2>&1 | tee "$temp_output" >> "$LOGS_DIR/auto-reflect.log"
-            local result=$?
-
-            # Parse learnings from output
-            if [ -f "$temp_output" ]; then
-                # Try to extract learnings count from output
-                local count_line
-                count_line=$(grep -i "learnings extracted:" "$temp_output" 2>/dev/null | head -1)
-                if [ -n "$count_line" ]; then
-                    learnings_extracted=$(echo "$count_line" | grep -oE '[0-9]+' | head -1)
-                    learnings_extracted=${learnings_extracted:-0}
-                fi
-
-                # Try to extract categories from output
-                local cat_line
-                cat_line=$(grep -i "categories:" "$temp_output" 2>/dev/null | head -1)
-                if [ -n "$cat_line" ]; then
-                    # Convert "Categories: devops, logging" to JSON array
-                    local cats
-                    cats=$(echo "$cat_line" | sed 's/.*[Cc]ategories:[[:space:]]*//' | tr ',' '\n' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' | grep -v '^$' | jq -R . | jq -s .)
-                    learning_categories=${cats:-"[]"}
-                fi
-            fi
-
-            # Determine exit reason based on result and learnings
-            if [ $result -eq 124 ]; then
-                exit_reason="timeout"
-                reason_msg="Reflection timed out"
-                log_reflect "warn" "Reflection timed out"
-            elif [ $result -ne 0 ]; then
-                exit_reason="error"
-                reason_msg="Reflection error (exit $result)"
-                log_reflect "warn" "Reflection completed with exit code $result"
-            elif [ "$learnings_extracted" -gt 0 ]; then
-                exit_reason="learnings_saved"
-                reason_msg="Extracted $learnings_extracted learnings"
-                log_reflect "info" "Reflection completed successfully"
-            else
-                exit_reason="nothing_to_learn"
-                reason_msg="No learnings to extract"
-                log_reflect "info" "Reflection completed - no learnings"
-            fi
-
-            # Log the decision with full context
-            log_reflect_decision "$exit_reason" "$reason_msg" "$transcript_lines" true "$learnings_extracted" "$learning_categories"
-
-            rm -f "$temp_output" 2>/dev/null
-        ) &
-        disown 2>/dev/null
-        log_reflect "info" "Reflection started in background (detached)"
-    else
-        log_reflect "warn" "specweave CLI not found"
-        log_reflect_decision "error" "specweave CLI not found" "$transcript_lines" true 0 "[]"
-    fi
-
-    return 0
-}
-
-# Main execution
-main() {
-    # SILENT approve - prevents UI feedback loops
-    local silent_approve='{"decision":"approve"}'
-
-    # Always cleanup ephemeral session state
-    cleanup_session_state
-
-    # Check if reflection is enabled first
-    local reflect_enabled=true
-    if [ -f "$CONFIG_FILE" ]; then
-        local enabled_val
-        # Note: can't use // true because jq treats false as falsy
-        # Use if-then-else to properly handle boolean false
-        enabled_val=$(jq -r 'if .reflect.enabled == false then "false" else "true" end' "$CONFIG_FILE" 2>/dev/null)
-        if [ "$enabled_val" = "false" ]; then
-            reflect_enabled=false
-        fi
-    fi
-
-    # Quick bail if no transcript
-    if [ -z "$TRANSCRIPT_PATH" ] || [ ! -f "$TRANSCRIPT_PATH" ]; then
-        log_reflect_decision "no_transcript" "No transcript available" 0 "$reflect_enabled" 0 "[]"
-        echo "$silent_approve"
-        exit 0
-    fi
-
-    # Get transcript line count
-    local transcript_lines
-    transcript_lines=$(wc -l < "$TRANSCRIPT_PATH" 2>/dev/null | tr -d ' ') || transcript_lines=0
-
-    # Check if reflection is disabled
-    if [ "$reflect_enabled" = "false" ]; then
-        log_reflect_decision "disabled" "Reflection disabled in config" "$transcript_lines" false 0 "[]"
-        echo "$silent_approve"
-        exit 0
-    fi
-
-    # Check if transcript is too short
-    if [ "$transcript_lines" -lt 10 ]; then
-        log_reflect_decision "transcript_too_short" "Transcript too short ($transcript_lines lines)" "$transcript_lines" true 0 "[]"
-        echo "$silent_approve"
-        exit 0
-    fi
-
-    # Run reflection (async, non-blocking) and capture learnings
-    run_reflection_with_logging "$TRANSCRIPT_PATH" "$transcript_lines"
-
-    # Always approve
-    echo "$silent_approve"
-    exit 0
-}
-
-main