claude-flow-novice 2.5.2 → 2.8.1

package/.claude/skills/loop2-output-processing/parse-feedback.sh

@@ -0,0 +1,147 @@
+#!/bin/bash
+set -euo pipefail
+
+# Loop 2 Output Processing: Feedback Parsing
+# Supports both old (stdin) and new (--extract-*) interfaces
+
+detect_confidence() {
+    local input="$1"
+
+    # Pattern 1: Explicit numeric in header (## Validation Confidence: 0.XX)
+    if echo "$input" | grep -qoE "Validation Confidence:?\s*0?\.[0-9]+"; then
+        echo "$input" | grep -oE "Validation Confidence:?\s*0?\.[0-9]+" | grep -oE "0?\.[0-9]+" | head -1
+        return 0
+    fi
+
+    # Pattern 2: Generic confidence field (confidence: 0.XX or Confidence: 0.XX)
+    if echo "$input" | grep -qoiE "confidence:?\s*0?\.[0-9]+"; then
+        echo "$input" | grep -oiE "confidence:?\s*0?\.[0-9]+" | grep -oE "0?\.[0-9]+" | head -1
+        return 0
+    fi
+
+    # Pattern 3: Percentage (XX% or XX percent)
+    if echo "$input" | grep -qoE "[0-9]+%|[0-9]+\s*percent"; then
+        PERCENT=$(echo "$input" | grep -oE "[0-9]+%|[0-9]+\s*percent" | grep -oE "[0-9]+" | head -1)
+        echo "scale=2; $PERCENT / 100" | bc
+        return 0
+    fi
+
+    # Pattern 4: Decimal without prefix (e.g., "0.87" in context of confidence)
+    if echo "$input" | grep -qE "(score|rating|level).{0,10}0?\.[0-9]{2}"; then
+        echo "$input" | grep -oE "(score|rating|level).{0,10}0?\.[0-9]{2}" | grep -oE "0?\.[0-9]{2}" | head -1
+        return 0
+    fi
+
+    # Pattern 5: Qualitative (high/medium/low) - check word boundaries
+    if echo "$input" | grep -qiE "(high|strong|excellent)[[:space:]]*(confidence|validation)|(confidence|validation)[[:space:]]*(high|strong|excellent)"; then
+        echo "0.90"
+        return 0
+    fi
+    if echo "$input" | grep -qiE "(medium|moderate|good)[[:space:]]*(confidence|validation)|(confidence|validation)[[:space:]]*(medium|moderate|good)"; then
+        echo "0.75"
+        return 0
+    fi
+    if echo "$input" | grep -qiE "(low|weak|poor)[[:space:]]*(confidence|validation)|(confidence|validation)[[:space:]]*(low|weak|poor)"; then
+        echo "0.50"
+        return 0
+    fi
+
+    # Default: not found
+    echo "0.0"
+}
+
+extract_feedback_items() {
+    local input="$1"
+    local category="$2"
+
+    # BUG #27 FIX: Enhanced feedback extraction with multiple patterns
+
+    # Pattern 1: Look for categorized sections (### CRITICAL Issues)
+    # Use awk to extract section between header and next ### or EOF
+    local items=$(echo "$input" | awk -v cat="$category" '
+        BEGIN { in_section=0; IGNORECASE=1 }
+        /^###/ {
+            if ($0 ~ cat) { in_section=1; next }
+            else { in_section=0 }
+        }
+        in_section && /^[-*0-9]/ {
+            # Remove bullet prefix and trim
+            gsub(/^[- *0-9.]+/, "")
+            gsub(/^[[:space:]]+|[[:space:]]+$/, "")
+            if (length($0) > 0) print
+        }
+    ')
+
+    # Pattern 2: If no structured sections, look for inline mentions (Critical:, Warning:, etc.)
+    if [[ -z "$items" ]]; then
+        items=$(echo "$input" | grep -iA3 "${category}:" | tail -n +2 | grep -E "^-|^\*|^[0-9]" | sed 's/^[- \*0-9.]*//g' | sed 's/^[[:space:]]*//' | grep -v "^$" | head -5)
+    fi
+
+    # Pattern 3: Extract from sentences containing category keyword (e.g., "Critical: error found")
+    if [[ -z "$items" ]]; then
+        # Look for sentences like "Critical: missing error handling"
+        items=$(echo "$input" | grep -iE "^${category}:" | sed "s/^${category}://i" | sed 's/^[[:space:]]*//' | grep -v "^$" | head -3)
+    fi
+
+    if [[ -n "$items" ]]; then
+        # Convert to JSON array, filtering empty lines and "No issues found"
+        echo "$items" | jq -R -s -c 'split("\n") | map(select(length > 0 and . != "No issues found" and . != "Issues"))'
+    else
+        echo "[]"
+    fi
+}
+
+# Check if using new interface (--extract-*)
+if [[ "${1:-}" == "--extract-confidence" ]]; then
+    # New interface: --extract-confidence "output text"
+    INPUT="${2:-}"
+    detect_confidence "$INPUT"
+    exit 0
+elif [[ "${1:-}" == "--extract-feedback" ]]; then
+    # New interface: --extract-feedback "output text"
+    INPUT="${2:-}"
+
+    CRITICAL=$(extract_feedback_items "$INPUT" "Critical")
+    WARNINGS=$(extract_feedback_items "$INPUT" "Warning")
+    SUGGESTIONS=$(extract_feedback_items "$INPUT" "Suggestion")
+
+    # Output JSON feedback object
+    jq -n \
+        --argjson critical "$CRITICAL" \
+        --argjson warnings "$WARNINGS" \
+        --argjson suggestions "$SUGGESTIONS" \
+        '{critical: $critical, warnings: $warnings, suggestions: $suggestions}'
+    exit 0
+fi
+
+# Old interface (backward compatibility): read from stdin
+RAW_INPUT=$(cat | xargs)
+
+# If input is empty, use a default
+if [[ -z "$RAW_INPUT" ]]; then
+    RAW_INPUT="No specific feedback"
+fi
+
+# Detect confidence
+CONFIDENCE=$(detect_confidence "$RAW_INPUT")
+
+# Extract feedback
+CRITICAL=$(extract_feedback_items "$RAW_INPUT" "Critical")
+WARNING=$(extract_feedback_items "$RAW_INPUT" "Warning")
+SUGGESTION=$(extract_feedback_items "$RAW_INPUT" "Suggestion")
+
+# Output JSON (old format for backward compatibility)
+jq -n \
+    --arg confidence "$CONFIDENCE" \
+    --argjson critical "$CRITICAL" \
+    --argjson warning "$WARNING" \
+    --argjson suggestion "$SUGGESTION" \
+    '{
+        confidence: ($confidence | tonumber),
+        confidence_source: "extracted",
+        feedback: {
+            critical: $critical,
+            warning: $warning,
+            suggestion: $suggestion
+        }
+    }'

package/.claude/skills/loop2-output-processing/process-validator-output.sh

@@ -0,0 +1,275 @@
+#!/bin/bash
+set -euo pipefail
+
+# Loop 2 Output Processing: Enhanced Validator Output Processing
+# BUG #27 FIX: Enforce structured output template and reject defaults
+# BUG #30 FIX: Add context sanitization and environment validation
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Parse arguments (SAME AS execute-and-extract.sh)
+AGENT_TYPE=""
+TASK_ID=""
+AGENT_ID=""
+CONTEXT=""
+ITERATION=1
+TIMEOUT=900
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --agent-type) AGENT_TYPE="$2"; shift 2 ;;
+    --task-id) TASK_ID="$2"; shift 2 ;;
+    --agent-id) AGENT_ID="$2"; shift 2 ;;
+    --context) CONTEXT="$2"; shift 2 ;;
+    --iteration) ITERATION="$2"; shift 2 ;;
+    --timeout) TIMEOUT="$2"; shift 2 ;;
+    *) echo "ERROR: Unknown parameter: $1" >&2; exit 1 ;;
+  esac
+done
+
+# Validate required parameters
+if [ -z "$AGENT_TYPE" ] || [ -z "$TASK_ID" ] || [ -z "$AGENT_ID" ] || [ -z "$CONTEXT" ]; then
+  echo "ERROR: Missing required parameters" >&2
+  echo "Usage: $0 --agent-type TYPE --task-id ID --agent-id ID --context CONTEXT [--iteration N] [--timeout SECONDS]" >&2
+  exit 1
+fi
+
+# BUG #30 FIX: Context sanitization function
+# Sanitizes context by removing dangerous characters and validating JSON structure
+validate_and_sanitize_context() {
+  local context="$1"
+  local timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+  echo "[Validator] [$timestamp] Sanitizing context (length: ${#context} chars)" >&2
+  echo "[Validator] [$timestamp] Context preview: ${context:0:100}..." >&2
+
+  # Strip dangerous characters: null bytes, backticks, $, backslash
+  # Also strip control characters and other special chars that can break shell parsing
+  local sanitized=$(echo "$context" | tr -d '\0' | sed 's/[`$\\]//g' | sed 's/[[:cntrl:]]/ /g')
+
+  # Log sanitization results
+  local removed_chars=$((${#context} - ${#sanitized}))
+  if [ "$removed_chars" -gt 0 ]; then
+    echo "[Validator] [$timestamp] Sanitized context: removed $removed_chars dangerous characters" >&2
+  else
+    echo "[Validator] [$timestamp] No dangerous characters found in context" >&2
+  fi
+
+  # Validate that context is not empty after sanitization
+  if [ -z "$sanitized" ]; then
+    echo "ERROR: Context became empty after sanitization" >&2
+    return 1
+  fi
+
+  echo "$sanitized"
+}
+
+# BUG #30 FIX: Environment validation function
+# Validates that required environment variables exist before spawning agents
+validate_environment() {
+  local timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+  local missing_vars=()
+
+  echo "[Validator] [$timestamp] Validating environment variables" >&2
+
+  # Check required variables
+  if [ -z "${REDIS_HOST:-}" ]; then
+    missing_vars+=("REDIS_HOST")
+  fi
+
+  if [ -z "${HOME:-}" ]; then
+    missing_vars+=("HOME")
+  fi
+
+  if [ -z "${PATH:-}" ]; then
+    missing_vars+=("PATH")
+  fi
+
+  # Log validation results
+  if [ ${#missing_vars[@]} -gt 0 ]; then
+    echo "ERROR: Missing required environment variables: ${missing_vars[*]}" >&2
+    echo "[Validator] [$timestamp] Current environment state:" >&2
+    echo "[Validator] REDIS_HOST=${REDIS_HOST:-<not set>}" >&2
+    echo "[Validator] HOME=${HOME:-<not set>}" >&2
+    echo "[Validator] PATH=${PATH:-<not set>}" >&2
+    return 1
+  fi
+
+  echo "[Validator] [$timestamp] Environment validation passed" >&2
+  echo "[Validator] REDIS_HOST=${REDIS_HOST}" >&2
+  echo "[Validator] HOME=${HOME}" >&2
+  echo "[Validator] PATH=${PATH:0:100}..." >&2
+
+  return 0
+}
+
+# BUG #27 FIX: Add structured output template to context
+ENHANCED_CONTEXT="$CONTEXT
+
+**REQUIRED OUTPUT FORMAT:**
+
+You MUST structure your validation output as follows:
+
+## Validation Confidence: [0.00-1.00]
+
+### CRITICAL Issues
+- [List any critical issues that must be fixed]
+- [Use bullet points with dash prefix]
+
+### WARNING Issues
+- [List warnings that should be addressed]
+- [Each on a new line with dash prefix]
+
+### SUGGESTION Items
+- [List improvement suggestions]
+- [Optional enhancements]
+
+**Example:**
+## Validation Confidence: 0.87
+
+### CRITICAL Issues
+- Missing error handling in invoke-gate-ack.sh:88
+- Security vulnerability in input validation
+
+### WARNING Issues
+- Inconsistent naming convention in test file
+- Missing JSDoc comments
+
+### SUGGESTION Items
+- Consider adding retry backoff strategy
+- Could use Promise.all for parallel operations
+
+**Important:**
+- Confidence MUST be explicit numeric value (0.00-1.00)
+- Categorize ALL feedback items by severity
+- If no issues found, state \"No issues found\" under each category
+- Do NOT use default confidence scores without justification
+"
+
+# BUG #30 FIX: Validate environment before spawning
+if ! validate_environment; then
+  echo "ERROR: Environment validation failed, cannot spawn validator agent" >&2
+  exit 1
+fi
+
+# BUG #30 FIX: Sanitize context before passing to agent
+SANITIZED_CONTEXT=$(validate_and_sanitize_context "$ENHANCED_CONTEXT")
+if [ $? -ne 0 ]; then
+  echo "ERROR: Context sanitization failed" >&2
+  exit 1
+fi
+
+# BUG #30 FIX: Enhanced agent spawning with controlled environment and error capture
+TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+echo "[Validator] [$TIMESTAMP] Spawning $AGENT_TYPE with sanitized context" >&2
+echo "[Validator] [$TIMESTAMP] Sanitized context length: ${#SANITIZED_CONTEXT} chars" >&2
+
+# Capture both stdout and stderr separately, plus exit code
+SPAWN_TMP_OUT=$(mktemp)
+SPAWN_TMP_ERR=$(mktemp)
+EXIT_CODE=0
+
+# Use env -i for controlled environment with explicit variable passing
+env -i \
+  HOME="$HOME" \
+  PATH="$PATH" \
+  REDIS_HOST="$REDIS_HOST" \
+  timeout "$TIMEOUT" npx claude-flow-novice agent "$AGENT_TYPE" \
+    --task-id "$TASK_ID" \
+    --agent-id "$AGENT_ID" \
+    --context "$SANITIZED_CONTEXT" \
+  > "$SPAWN_TMP_OUT" 2> "$SPAWN_TMP_ERR" || EXIT_CODE=$?
+
+AGENT_OUTPUT=$(cat "$SPAWN_TMP_OUT")
+AGENT_STDERR=$(cat "$SPAWN_TMP_ERR")
+
+# BUG #30 FIX: Enhanced error logging on spawn failure
+if [ $EXIT_CODE -ne 0 ]; then
+  TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+  echo "[Validator] [$TIMESTAMP] ⚠️  Agent spawn failed with exit code: $EXIT_CODE" >&2
+  echo "[Validator] [$TIMESTAMP] Agent STDOUT (length: ${#AGENT_OUTPUT}):" >&2
+  echo "$AGENT_OUTPUT" >&2
+  echo "[Validator] [$TIMESTAMP] Agent STDERR (length: ${#AGENT_STDERR}):" >&2
+  echo "$AGENT_STDERR" >&2
+  echo "[Validator] [$TIMESTAMP] Context used (first 200 chars): ${SANITIZED_CONTEXT:0:200}..." >&2
+fi
+
+# Cleanup temp files
+rm -f "$SPAWN_TMP_OUT" "$SPAWN_TMP_ERR"
+
+# Log successful spawn
+if [ $EXIT_CODE -eq 0 ]; then
+  TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+  echo "[Validator] [$TIMESTAMP] Agent spawn successful (output length: ${#AGENT_OUTPUT} chars)" >&2
+fi
+
+# Parse confidence using multi-pattern detection
+CONFIDENCE=$("$SCRIPT_DIR/parse-feedback.sh" --extract-confidence "$AGENT_OUTPUT" 2>/dev/null || echo "0.0")
+
+# BUG #27 FIX: Enhanced confidence validation
+CONFIDENCE_SOURCE="unknown"
+if [ -z "$CONFIDENCE" ] || [ "$CONFIDENCE" = "null" ] || (( $(echo "$CONFIDENCE == 0.0" | bc -l) )); then
+  CONFIDENCE=0.70
+  CONFIDENCE_SOURCE="default-fallback"
+  echo "[Validator] WARNING: No confidence found in output, using default 0.70" >&2
+elif (( $(echo "$CONFIDENCE == 0.70" | bc -l) )); then
+  # Check if this is explicit 0.70 or default
+  if echo "$AGENT_OUTPUT" | grep -qE "confidence:?\s*0?\.70"; then
+    CONFIDENCE_SOURCE="explicit-0.70"
+  else
+    CONFIDENCE_SOURCE="default-fallback"
+    echo "[Validator] WARNING: Confidence defaulted to 0.70 (no explicit score found)" >&2
+  fi
+else
+  CONFIDENCE_SOURCE="explicit"
+fi
+
+# Parse feedback from output
+FEEDBACK_RAW=$("$SCRIPT_DIR/parse-feedback.sh" --extract-feedback "$AGENT_OUTPUT" 2>/dev/null || echo '{"critical":[],"warnings":[],"suggestions":[]}')
+
+# Ensure feedback is valid JSON
+if ! echo "$FEEDBACK_RAW" | jq empty 2>/dev/null; then
+  echo "[Validator] WARNING: Invalid feedback JSON, using default" >&2
+  FEEDBACK_RAW='{"critical":[],"warnings":[],"suggestions":[]}'
+fi
+
+# BUG #27 FIX: Count feedback items
+CRITICAL_COUNT=$(echo "$FEEDBACK_RAW" | jq '.critical | length')
+WARNING_COUNT=$(echo "$FEEDBACK_RAW" | jq '.warnings | length')
+SUGGESTION_COUNT=$(echo "$FEEDBACK_RAW" | jq '.suggestions | length')
+TOTAL_FEEDBACK=$((CRITICAL_COUNT + WARNING_COUNT + SUGGESTION_COUNT))
+
+# BUG #27 FIX: Detect default output pattern (0.70 confidence + zero feedback)
+if (( $(echo "$CONFIDENCE == 0.70" | bc -l) )) && [ "$TOTAL_FEEDBACK" -eq 0 ]; then
+  echo "[Validator] ⚠️  WARNING: Validator produced default output (0.70 confidence, 0 feedback items)" >&2
+  echo "[Validator] This may indicate the validator didn't properly analyze the code" >&2
+  VALIDATION_WARNING="default-output-detected"
+else
+  VALIDATION_WARNING="none"
+fi
+
+# BUG #27 FIX: If feedback exists but confidence is default, log warning
+if [ "$TOTAL_FEEDBACK" -gt 0 ] && (( $(echo "$CONFIDENCE == 0.70" | bc -l) )) && [ "$CONFIDENCE_SOURCE" = "default-fallback" ]; then
+  echo "[Validator] ⚠️  WARNING: Feedback found ($TOTAL_FEEDBACK items) but confidence defaulted to 0.70" >&2
+  echo "[Validator] Validator may not be using structured output format" >&2
+fi
+
+# Build output JSON with enhanced metadata
+cat <<EOF
+{
+  "agent_id": "$AGENT_ID",
+  "agent_type": "$AGENT_TYPE",
+  "confidence": $CONFIDENCE,
+  "confidence_source": "$CONFIDENCE_SOURCE",
+  "feedback": $FEEDBACK_RAW,
+  "feedback_counts": {
+    "critical": $CRITICAL_COUNT,
+    "warnings": $WARNING_COUNT,
+    "suggestions": $SUGGESTION_COUNT,
+    "total": $TOTAL_FEEDBACK
+  },
+  "validation_warning": "$VALIDATION_WARNING",
+  "iteration": $ITERATION,
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+}
+EOF

package/.claude/skills/loop2-output-processing/test-bug27-fix.sh

@@ -0,0 +1,200 @@
+#!/bin/bash
+set -e
+
+# BUG #27 FIX TEST: Validate enhanced validator output processing
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PARSE_SCRIPT="$SCRIPT_DIR/parse-feedback.sh"
+
+echo "=========================================="
+echo "BUG #27 FIX: Validator Output Processing Tests"
+echo "=========================================="
+echo ""
+
+PASSED=0
+FAILED=0
+
+# Test Case 1: Structured output with explicit confidence
+echo "[TEST 1] Structured output with explicit confidence"
+MOCK_OUTPUT='## Validation Confidence: 0.87
+
+### CRITICAL Issues
+- Missing error handling in invoke-gate-ack.sh:88
+- Security vulnerability in auth module
+
+### WARNING Issues
+- Inconsistent naming convention in test file
+- Missing JSDoc comments
+
+### SUGGESTION Items
+- Consider adding retry backoff strategy
+- Could use Promise.all for parallel operations'
+
+CONFIDENCE=$("$PARSE_SCRIPT" --extract-confidence "$MOCK_OUTPUT")
+FEEDBACK=$("$PARSE_SCRIPT" --extract-feedback "$MOCK_OUTPUT")
+
+if [ "$CONFIDENCE" = "0.87" ]; then
+  echo "✅ PASS: Confidence correctly parsed as 0.87"
+  PASSED=$((PASSED + 1))
+else
+  echo "❌ FAIL: Expected 0.87, got $CONFIDENCE"
+  FAILED=$((FAILED + 1))
+fi
+
+CRITICAL_COUNT=$(echo "$FEEDBACK" | jq '.critical | length')
+WARNING_COUNT=$(echo "$FEEDBACK" | jq '.warnings | length')
+SUGGESTION_COUNT=$(echo "$FEEDBACK" | jq '.suggestions | length')
+
+if [ "$CRITICAL_COUNT" -eq 2 ] && [ "$WARNING_COUNT" -eq 2 ] && [ "$SUGGESTION_COUNT" -eq 2 ]; then
+  echo "✅ PASS: Feedback counts correct (2C/2W/2S)"
+  PASSED=$((PASSED + 1))
+else
+  echo "❌ FAIL: Expected 2C/2W/2S, got ${CRITICAL_COUNT}C/${WARNING_COUNT}W/${SUGGESTION_COUNT}S"
+  FAILED=$((FAILED + 1))
+fi
+
+echo ""
+
+# Test Case 2: Default output pattern (0.70 confidence, zero feedback)
+echo "[TEST 2] Default output pattern detection"
+MOCK_OUTPUT_DEFAULT='The code looks good. Confidence: 0.70'
+
+CONFIDENCE=$("$PARSE_SCRIPT" --extract-confidence "$MOCK_OUTPUT_DEFAULT")
+FEEDBACK=$("$PARSE_SCRIPT" --extract-feedback "$MOCK_OUTPUT_DEFAULT")
+
+TOTAL_FEEDBACK=$(echo "$FEEDBACK" | jq '.critical + .warnings + .suggestions | length')
+
+if [ "$CONFIDENCE" = "0.70" ] && [ "$TOTAL_FEEDBACK" -eq 0 ]; then
+  echo "✅ PASS: Default pattern detected (0.70 + 0 feedback)"
+  PASSED=$((PASSED + 1))
+else
+  echo "❌ FAIL: Pattern detection failed ($CONFIDENCE confidence, $TOTAL_FEEDBACK feedback)"
+  FAILED=$((FAILED + 1))
+fi
+
+echo ""
+
+# Test Case 3: Percentage-based confidence
+echo "[TEST 3] Percentage confidence parsing"
+MOCK_OUTPUT_PERCENT='Overall validation: 92%
+
+### CRITICAL Issues
+- Missing input validation
+
+### WARNING Issues
+- No issues found
+
+### SUGGESTION Items
+- Improve documentation'
+
+CONFIDENCE=$("$PARSE_SCRIPT" --extract-confidence "$MOCK_OUTPUT_PERCENT")
+
+if [ "$CONFIDENCE" = ".92" ]; then
+  echo "✅ PASS: Percentage converted to decimal (0.92)"
+  PASSED=$((PASSED + 1))
+else
+  echo "❌ FAIL: Expected .92, got $CONFIDENCE"
+  FAILED=$((FAILED + 1))
+fi
+
+FEEDBACK=$("$PARSE_SCRIPT" --extract-feedback "$MOCK_OUTPUT_PERCENT")
+CRITICAL_COUNT=$(echo "$FEEDBACK" | jq '.critical | length')
+
+if [ "$CRITICAL_COUNT" -eq 1 ]; then
+  echo "✅ PASS: Critical issue extracted from percentage output"
+  PASSED=$((PASSED + 1))
+else
+  echo "❌ FAIL: Expected 1 critical, got $CRITICAL_COUNT"
+  FAILED=$((FAILED + 1))
+fi
+
+echo ""
+
+# Test Case 4: Qualitative confidence
+echo "[TEST 4] Qualitative confidence mapping"
+MOCK_OUTPUT_QUAL='Validation complete with high confidence.
+
+### CRITICAL Issues
+- No issues found
+
+### WARNING Issues
+- Minor style inconsistencies
+
+### SUGGESTION Items
+- Add unit tests'
+
+CONFIDENCE=$("$PARSE_SCRIPT" --extract-confidence "$MOCK_OUTPUT_QUAL")
+
+if [ "$CONFIDENCE" = "0.90" ]; then
+  echo "✅ PASS: 'high confidence' mapped to 0.90"
+  PASSED=$((PASSED + 1))
+else
+  echo "❌ FAIL: Expected 0.90, got $CONFIDENCE"
+  FAILED=$((FAILED + 1))
+fi
+
+echo ""
+
+# Test Case 5: No confidence found (should default to 0.0 for detection)
+echo "[TEST 5] Missing confidence detection"
+MOCK_OUTPUT_NONE='Review complete.
+
+Some issues found:
+- Missing tests
+- No documentation'
+
+CONFIDENCE=$("$PARSE_SCRIPT" --extract-confidence "$MOCK_OUTPUT_NONE")
+
+if [ "$CONFIDENCE" = "0.0" ]; then
+  echo "✅ PASS: Missing confidence returns 0.0 for detection"
+  PASSED=$((PASSED + 1))
+else
+  echo "❌ FAIL: Expected 0.0, got $CONFIDENCE"
+  FAILED=$((FAILED + 1))
+fi
+
+echo ""
+
+# Test Case 6: Unstructured feedback extraction
+echo "[TEST 6] Unstructured feedback extraction"
+MOCK_OUTPUT_UNSTRUCTURED='Validation Confidence: 0.82
+
+Critical: Missing error handling in line 88
+Warning: Inconsistent variable naming
+Suggestion: Add more comments'
+
+CONFIDENCE=$("$PARSE_SCRIPT" --extract-confidence "$MOCK_OUTPUT_UNSTRUCTURED")
+FEEDBACK=$("$PARSE_SCRIPT" --extract-feedback "$MOCK_OUTPUT_UNSTRUCTURED")
+
+CRITICAL_COUNT=$(echo "$FEEDBACK" | jq '.critical | length')
+WARNING_COUNT=$(echo "$FEEDBACK" | jq '.warnings | length')
+SUGGESTION_COUNT=$(echo "$FEEDBACK" | jq '.suggestions | length')
+
+if [ "$CONFIDENCE" = "0.82" ]; then
+  echo "✅ PASS: Confidence parsed from unstructured format"
+  PASSED=$((PASSED + 1))
+else
+  echo "❌ FAIL: Expected 0.82, got $CONFIDENCE"
+  FAILED=$((FAILED + 1))
+fi
+
+if [ "$CRITICAL_COUNT" -ge 1 ] && [ "$WARNING_COUNT" -ge 1 ] && [ "$SUGGESTION_COUNT" -ge 1 ]; then
+  echo "✅ PASS: Feedback extracted from unstructured format (${CRITICAL_COUNT}C/${WARNING_COUNT}W/${SUGGESTION_COUNT}S)"
+  PASSED=$((PASSED + 1))
+else
+  echo "❌ FAIL: Expected at least 1C/1W/1S, got ${CRITICAL_COUNT}C/${WARNING_COUNT}W/${SUGGESTION_COUNT}S"
+  FAILED=$((FAILED + 1))
+fi
+
+echo ""
+echo "=========================================="
+echo "Test Results: $PASSED passed, $FAILED failed"
+echo "=========================================="
+
+if [ $FAILED -eq 0 ]; then
+  echo "✅ All tests passed!"
+  exit 0
+else
+  echo "❌ Some tests failed"
+  exit 1
+fi