autonomous-coding-toolkit 1.0.0

package/scripts/tests/test-policy-check.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+# Tests for policy-check.sh
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+POLICY_CHECK="$SCRIPT_DIR/../policy-check.sh"
+PASS=0 FAIL=0 TOTAL=0
+
+assert() {
+    local desc="$1" expected="$2" actual="$3"
+    TOTAL=$((TOTAL + 1))
+    if [[ "$expected" == "$actual" ]]; then
+        echo "PASS: $desc"
+        PASS=$((PASS + 1))
+    else
+        echo "FAIL: $desc (expected=$expected, actual=$actual)"
+        FAIL=$((FAIL + 1))
+    fi
+}
+
+tmpdir=$(mktemp -d)
+trap 'rm -rf "$tmpdir"' EXIT
+
+# Test 1: --help exits 0
+exit_code=0
+output=$("$POLICY_CHECK" --help 2>&1) || exit_code=$?
+assert "--help: exit 0" "0" "$exit_code"
+echo "$output" | grep -q "USAGE"
+assert "--help: shows usage" "0" "$?"
+
+# Test 2: Missing project dir exits 1
+exit_code=0
+"$POLICY_CHECK" --project-root "$tmpdir/nonexistent" > /dev/null 2>&1 || exit_code=$?
+assert "missing dir: exit 1" "1" "$exit_code"
+
+# Test 3: Clean bash project (with strict mode)
+mkdir -p "$tmpdir/clean-bash"
+cat > "$tmpdir/clean-bash/example.sh" <<'SCRIPT'
+#!/usr/bin/env bash
+set -euo pipefail
+echo "hello"
+SCRIPT
+exit_code=0
+output=$("$POLICY_CHECK" --project-root "$tmpdir/clean-bash" 2>&1) || exit_code=$?
+assert "clean bash: exit 0" "0" "$exit_code"
+echo "$output" | grep -q "no violations"
+assert "clean bash: clean output" "0" "$?"
+
+# Test 4: Bash script missing strict mode (advisory)
+mkdir -p "$tmpdir/bad-bash"
+cat > "$tmpdir/bad-bash/bad.sh" <<'SCRIPT'
+#!/usr/bin/env bash
+echo "no strict mode"
+SCRIPT
+exit_code=0
+output=$("$POLICY_CHECK" --project-root "$tmpdir/bad-bash" 2>&1) || exit_code=$?
+assert "bad bash advisory: exit 0" "0" "$exit_code"
+echo "$output" | grep -q "missing strict mode"
+assert "bad bash advisory: shows violation" "0" "$?"
+
+# Test 5: Bash script missing strict mode (strict mode)
+exit_code=0
+"$POLICY_CHECK" --project-root "$tmpdir/bad-bash" --strict > /dev/null 2>&1 || exit_code=$?
+assert "bad bash strict: exit 1" "1" "$exit_code"
+
+# Test 6: Python project with sqlite but no closing()
+mkdir -p "$tmpdir/bad-python"
+touch "$tmpdir/bad-python/requirements.txt"
+cat > "$tmpdir/bad-python/db.py" <<'PYCODE'
+import sqlite3
+conn = sqlite3.connect("test.db")
+cursor = conn.execute("SELECT 1")
+conn.close()
+PYCODE
+exit_code=0
+output=$("$POLICY_CHECK" --project-root "$tmpdir/bad-python" 2>&1) || exit_code=$?
+assert "python sqlite no closing: exit 0 (advisory)" "0" "$exit_code"
+echo "$output" | grep -q "closing"
+assert "python sqlite: shows violation" "0" "$?"
+
+# Test 7: Python project with closing() (clean)
+mkdir -p "$tmpdir/good-python"
+touch "$tmpdir/good-python/requirements.txt"
+cat > "$tmpdir/good-python/db.py" <<'PYCODE'
+import sqlite3
+from contextlib import closing
+with closing(sqlite3.connect("test.db")) as conn:
+    cursor = conn.execute("SELECT 1")
+PYCODE
+exit_code=0
+output=$("$POLICY_CHECK" --project-root "$tmpdir/good-python" 2>&1) || exit_code=$?
+assert "python sqlite with closing: exit 0" "0" "$exit_code"
+
+# Test 8: Empty directory (no language detected)
+mkdir -p "$tmpdir/empty"
+exit_code=0
+output=$("$POLICY_CHECK" --project-root "$tmpdir/empty" 2>&1) || exit_code=$?
+assert "empty dir: exit 0" "0" "$exit_code"
+
+# Test 9: Test file with hardcoded count
+mkdir -p "$tmpdir/bad-tests"
+cat > "$tmpdir/bad-tests/test-example.sh" <<'SCRIPT'
+#!/usr/bin/env bash
+set -euo pipefail
+count=42
+assert "test count" -eq 42
+SCRIPT
+exit_code=0
+output=$("$POLICY_CHECK" --project-root "$tmpdir/bad-tests" 2>&1) || exit_code=$?
+assert "hardcoded count: exit 0 (advisory)" "0" "$exit_code"
+
+# Test 10: Strict mode with no violations
+exit_code=0
+output=$("$POLICY_CHECK" --project-root "$tmpdir/clean-bash" --strict 2>&1) || exit_code=$?
+assert "strict clean: exit 0" "0" "$exit_code"
+
+echo ""
+echo "Results: $PASS/$TOTAL passed"
+if [[ $FAIL -gt 0 ]]; then
+    echo "FAILURES: $FAIL"
+    exit 1
+fi
+echo "ALL PASSED"

package/scripts/tests/test-prior-art-search.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+# Test prior-art-search.sh
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SEARCH_SCRIPT="$SCRIPT_DIR/../prior-art-search.sh"
+
+FAILURES=0
+TESTS=0
+
+assert_eq() {
+    local desc="$1" expected="$2" actual="$3"
+    TESTS=$((TESTS + 1))
+    if [[ "$expected" != "$actual" ]]; then
+        echo "FAIL: $desc"
+        echo "  expected: $expected"
+        echo "  actual:   $actual"
+        FAILURES=$((FAILURES + 1))
+    else
+        echo "PASS: $desc"
+    fi
+}
+
+assert_exit() {
+    local desc="$1" expected_exit="$2"
+    shift 2
+    local actual_exit=0
+    "$@" >/dev/null 2>&1 || actual_exit=$?
+    TESTS=$((TESTS + 1))
+    if [[ "$expected_exit" != "$actual_exit" ]]; then
+        echo "FAIL: $desc"
+        echo "  expected exit: $expected_exit"
+        echo "  actual exit:   $actual_exit"
+        FAILURES=$((FAILURES + 1))
+    else
+        echo "PASS: $desc"
+    fi
+}
+
+# --- Test: --help exits 0 ---
+assert_exit "prior-art-search --help exits 0" 0 \
+    bash "$SEARCH_SCRIPT" --help
+
+# --- Test: --dry-run produces output without calling gh ---
+output=$(bash "$SEARCH_SCRIPT" --dry-run "implement webhook handler" 2>&1)
+echo "$output" | grep -q "Search query:" && TESTS=$((TESTS + 1)) && echo "PASS: dry-run shows search query" || {
+    TESTS=$((TESTS + 1)); echo "FAIL: dry-run missing search query"; FAILURES=$((FAILURES + 1))
+}
+
+# --- Test: dry-run shows what would be searched ---
+TESTS=$((TESTS + 1))
+if echo "$output" | grep -q "Would search:"; then
+    echo "PASS: dry-run shows would-search list"
+else
+    echo "FAIL: dry-run shows would-search list"
+    FAILURES=$((FAILURES + 1))
+fi
+
+# --- Test: --dry-run exits 0 ---
+assert_exit "prior-art-search --dry-run exits 0" 0 \
+    bash "$SEARCH_SCRIPT" --dry-run "test query"
+
+# --- Test: missing query shows usage ---
+assert_exit "prior-art-search: no args exits 1" 1 \
+    bash "$SEARCH_SCRIPT"
+
+# --- Test: --local-only flag accepted ---
+assert_exit "prior-art-search --local-only --dry-run exits 0" 0 \
+    bash "$SEARCH_SCRIPT" --local-only --dry-run "test query"
+
+# --- Test: --github-only flag accepted ---
+assert_exit "prior-art-search --github-only --dry-run exits 0" 0 \
+    bash "$SEARCH_SCRIPT" --github-only --dry-run "test query"
+
+# --- Test: unknown option exits 1 ---
+assert_exit "prior-art-search: unknown option exits 1" 1 \
+    bash "$SEARCH_SCRIPT" --bogus-flag
+
+# --- Test: dry-run includes ast-grep section ---
+output=$(bash "$SEARCH_SCRIPT" --dry-run "error handling patterns" 2>&1)
+TESTS=$((TESTS + 1))
+if echo "$output" | grep -qi "ast-grep\|structural"; then
+    echo "PASS: prior-art: dry-run mentions ast-grep/structural search"
+else
+    echo "FAIL: prior-art: dry-run should mention ast-grep/structural search"
+    FAILURES=$((FAILURES + 1))
+fi
+
+# === Summary ===
+echo ""
+echo "Results: $((TESTS - FAILURES))/$TESTS passed"
+if [[ $FAILURES -gt 0 ]]; then
+    echo "FAILURES: $FAILURES"
+    exit 1
+fi
+echo "ALL PASSED"

package/scripts/tests/test-progress-writer.sh

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/test-helpers.sh"
+source "$SCRIPT_DIR/../lib/progress-writer.sh"
+
+WORK=$(mktemp -d)
+trap 'rm -rf "$WORK"' EXIT
+
+# === write_batch_progress tests ===
+
+# Test: writes batch header with timestamp
+write_batch_progress "$WORK" 1 "Foundation setup"
+content=$(cat "$WORK/progress.txt")
+assert_contains "write_batch_progress: creates progress.txt" "## Batch 1: Foundation setup" "$content"
+assert_contains "write_batch_progress: includes timestamp" "T" "$content"
+
+# Test: appending second batch header
+write_batch_progress "$WORK" 2 "Add tests"
+content=$(cat "$WORK/progress.txt")
+assert_contains "write_batch_progress: batch 2 header present" "## Batch 2: Add tests" "$content"
+assert_contains "write_batch_progress: batch 1 still present" "## Batch 1: Foundation setup" "$content"
+
+# === append_progress_section tests ===
+
+# Test: append Files Modified section
+append_progress_section "$WORK" "Files Modified" "- scripts/lib/foo.sh (created)
+- scripts/lib/bar.sh (modified)"
+content=$(cat "$WORK/progress.txt")
+assert_contains "append_progress_section: Files Modified header" "### Files Modified" "$content"
+assert_contains "append_progress_section: file list content" "scripts/lib/foo.sh (created)" "$content"
+
+# Test: append Decisions section
+append_progress_section "$WORK" "Decisions" "- Used awk for parsing: simpler than sed for multi-line extraction"
+content=$(cat "$WORK/progress.txt")
+assert_contains "append_progress_section: Decisions header" "### Decisions" "$content"
+assert_contains "append_progress_section: decision content" "Used awk for parsing" "$content"
+
+# Test: append Issues Encountered section
+append_progress_section "$WORK" "Issues Encountered" "- shellcheck warning → added quotes"
+content=$(cat "$WORK/progress.txt")
+assert_contains "append_progress_section: Issues header" "### Issues Encountered" "$content"
+
+# Test: append State section
+append_progress_section "$WORK" "State" "- Tests: 12 passing
+- Duration: 45s
+- Cost: \$0.03"
+content=$(cat "$WORK/progress.txt")
+assert_contains "append_progress_section: State header" "### State" "$content"
+assert_contains "append_progress_section: test count" "Tests: 12 passing" "$content"
+
+# === read_batch_progress tests ===
+
+# Test: read batch 1
+batch1=$(read_batch_progress "$WORK" 1)
+assert_contains "read_batch_progress: returns batch 1 header" "## Batch 1: Foundation setup" "$batch1"
+assert_not_contains "read_batch_progress: excludes batch 2" "## Batch 2" "$batch1"
+
+# Test: read batch 2 — should include all sections we appended
+batch2=$(read_batch_progress "$WORK" 2)
+assert_contains "read_batch_progress: returns batch 2 header" "## Batch 2: Add tests" "$batch2"
+assert_contains "read_batch_progress: includes Files Modified" "### Files Modified" "$batch2"
+assert_contains "read_batch_progress: includes Decisions" "### Decisions" "$batch2"
+assert_contains "read_batch_progress: includes State" "### State" "$batch2"
+assert_not_contains "read_batch_progress: excludes batch 1" "## Batch 1" "$batch2"
+
+# Test: read nonexistent batch — returns empty, exit 1
+batch99=""
+batch99_exit=0
+batch99=$(read_batch_progress "$WORK" 99) || batch99_exit=$?
+assert_eq "read_batch_progress: nonexistent batch returns exit 1" "1" "$batch99_exit"
+assert_eq "read_batch_progress: nonexistent batch returns empty" "" "$batch99"
+
+# Test: read from nonexistent worktree — returns empty, exit 2
+batch_none=""
+batch_none_exit=0
+batch_none=$(read_batch_progress "/tmp/nonexistent-worktree-$$" 1) || batch_none_exit=$?
+assert_eq "read_batch_progress: missing progress.txt returns exit 2" "2" "$batch_none_exit"
+assert_eq "read_batch_progress: missing progress.txt returns empty" "" "$batch_none"
+
+# Test: invalid batch_num — returns exit 1 with error message
+invalid_exit=0
+invalid_out=""
+invalid_out=$(read_batch_progress "$WORK" "abc" 2>&1) || invalid_exit=$?
+assert_eq "read_batch_progress: invalid batch_num exits 1" "1" "$invalid_exit"
+assert_contains "read_batch_progress: invalid batch_num prints error" "batch_num must be a positive integer" "$invalid_out"
+
+# === Round-trip test with fresh worktree ===
+
+WORK2=$(mktemp -d)
+trap 'rm -rf "$WORK2"' EXIT
+write_batch_progress "$WORK2" 1 "Round trip test"
+append_progress_section "$WORK2" "Files Modified" "- a.sh (created)"
+append_progress_section "$WORK2" "State" "- Tests: 5 passing"
+
+roundtrip=$(read_batch_progress "$WORK2" 1)
+assert_contains "round-trip: header preserved" "## Batch 1: Round trip test" "$roundtrip"
+assert_contains "round-trip: files preserved" "a.sh (created)" "$roundtrip"
+assert_contains "round-trip: state preserved" "Tests: 5 passing" "$roundtrip"
+
+# === Multi-batch isolation test ===
+
+WORK3=$(mktemp -d)
+trap 'rm -rf "$WORK3"' EXIT
+write_batch_progress "$WORK3" 1 "First"
+append_progress_section "$WORK3" "State" "- Tests: 3 passing"
+write_batch_progress "$WORK3" 2 "Second"
+append_progress_section "$WORK3" "State" "- Tests: 7 passing"
+write_batch_progress "$WORK3" 3 "Third"
+append_progress_section "$WORK3" "State" "- Tests: 12 passing"
+
+b1=$(read_batch_progress "$WORK3" 1)
+b2=$(read_batch_progress "$WORK3" 2)
+b3=$(read_batch_progress "$WORK3" 3)
+
+assert_contains "multi-batch: batch 1 has 3 tests" "Tests: 3 passing" "$b1"
+assert_not_contains "multi-batch: batch 1 excludes batch 2 state" "Tests: 7 passing" "$b1"
+assert_contains "multi-batch: batch 2 has 7 tests" "Tests: 7 passing" "$b2"
+assert_not_contains "multi-batch: batch 2 excludes batch 3 state" "Tests: 12 passing" "$b2"
+assert_contains "multi-batch: batch 3 has 12 tests" "Tests: 12 passing" "$b3"
+
+# === False-match prevention: content that looks like a batch header ===
+# Content mentioning "## Batch N:" should NOT stop extraction early
+# because the timestamp anchoring prevents it (#55)
+
+WORK4=$(mktemp -d)
+trap 'rm -rf "$WORK4"' EXIT
+write_batch_progress "$WORK4" 1 "Content test"
+# Manually write content that looks like a batch header (without timestamp)
+echo "## Batch 2: This is just a note, not a real header" >> "$WORK4/progress.txt"
+echo "- some progress note" >> "$WORK4/progress.txt"
+write_batch_progress "$WORK4" 2 "Real second batch"
+append_progress_section "$WORK4" "State" "- Tests: 9 passing"
+
+b1_content=$(read_batch_progress "$WORK4" 1)
+assert_contains "false-match: batch 1 includes embedded note" "This is just a note" "$b1_content"
+assert_not_contains "false-match: batch 1 stops at real batch 2 header" "Tests: 9 passing" "$b1_content"
+
+report_results

package/scripts/tests/test-promote-mab-lessons.sh

@@ -0,0 +1,110 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/test-helpers.sh"
+
+PROMOTE="$SCRIPT_DIR/../promote-mab-lessons.sh"
+
+# --- Setup ---
+TEST_TMPDIR=$(mktemp -d)
+trap 'rm -rf "$TEST_TMPDIR"' EXIT
+
+mkdir -p "$TEST_TMPDIR/logs" "$TEST_TMPDIR/docs/lessons"
+
+# --- Test: --help exits 0 ---
+assert_exit "--help exits 0" 0 "$PROMOTE" --help
+
+# --- Test: no promotions when all below threshold ---
+cat > "$TEST_TMPDIR/logs/mab-lessons.json" <<'JSON'
+[
+  {"pattern": "rare pattern", "context": "new-file", "winner": "superpowers", "occurrences": 1, "promoted": false},
+  {"pattern": "another rare", "context": "refactoring", "winner": "ralph", "occurrences": 2, "promoted": false}
+]
+JSON
+
+output=$("$PROMOTE" --worktree "$TEST_TMPDIR" --min-occurrences 3 2>&1) || true
+lesson_count=$(find "$TEST_TMPDIR/docs/lessons" -name "*.md" -newer "$TEST_TMPDIR/logs/mab-lessons.json" 2>/dev/null | wc -l)
+assert_eq "no promotions below threshold" "0" "$lesson_count"
+
+# --- Test: promotes at 3+ occurrences ---
+cat > "$TEST_TMPDIR/logs/mab-lessons.json" <<'JSON'
+[
+  {"pattern": "check imports before tests", "context": "integration", "winner": "superpowers", "occurrences": 5, "promoted": false},
+  {"pattern": "rare pattern", "context": "new-file", "winner": "ralph", "occurrences": 1, "promoted": false}
+]
+JSON
+
+"$PROMOTE" --worktree "$TEST_TMPDIR" --min-occurrences 3 > /dev/null 2>&1 || true
+
+# Check a lesson file was created
+promoted_files=$(find "$TEST_TMPDIR/docs/lessons" -name "*.md" 2>/dev/null)
+TESTS=$((TESTS + 1))
+if [[ -n "$promoted_files" ]]; then
+    echo "PASS: promotes at 3+ occurrences"
+else
+    echo "FAIL: no lesson file created for pattern with 5 occurrences"
+    FAILURES=$((FAILURES + 1))
+fi
+
+# --- Test: promoted file has YAML frontmatter ---
+if [[ -n "$promoted_files" ]]; then
+    first_file=$(echo "$promoted_files" | head -1)
+    first_line=$(head -1 "$first_file")
+    assert_eq "promoted file starts with YAML frontmatter" "---" "$first_line"
+
+    file_content=$(cat "$first_file")
+    assert_contains "promoted file has pattern field" "pattern:" "$file_content"
+fi
+
+# --- Test: marks lessons as promoted in JSON ---
+promoted_count=$(jq '[.[] | select(.promoted == true)] | length' "$TEST_TMPDIR/logs/mab-lessons.json" 2>/dev/null || echo "0")
+assert_eq "promoted lesson marked in JSON" "1" "$promoted_count"
+
+# --- Test: --dry-run creates no files ---
+# Reset
+rm -f "$TEST_TMPDIR/docs/lessons"/*.md
+cat > "$TEST_TMPDIR/logs/mab-lessons.json" <<'JSON'
+[
+  {"pattern": "should not create file", "context": "test-only", "winner": "ralph", "occurrences": 10, "promoted": false}
+]
+JSON
+
+"$PROMOTE" --worktree "$TEST_TMPDIR" --min-occurrences 3 --dry-run > /dev/null 2>&1 || true
+dry_files=$(find "$TEST_TMPDIR/docs/lessons" -name "*.md" 2>/dev/null | wc -l)
+assert_eq "--dry-run creates no files" "0" "$dry_files"
+
+# Verify JSON not modified either
+dry_promoted=$(jq '[.[] | select(.promoted == true)] | length' "$TEST_TMPDIR/logs/mab-lessons.json" 2>/dev/null || echo "0")
+assert_eq "--dry-run does not mark as promoted" "0" "$dry_promoted"
+
+# --- Test: idempotency — second promotion creates no new files ---
+# Reset directory
+rm -f "$TEST_TMPDIR/docs/lessons"/*.md
+
+cat > "$TEST_TMPDIR/logs/mab-lessons.json" <<'JSON'
+[
+  {"pattern": "idempotent test pattern", "context": "new-file", "winner": "superpowers", "occurrences": 5, "promoted": false}
+]
+JSON
+
+# First run — should create lesson file and mark as promoted
+"$PROMOTE" --worktree "$TEST_TMPDIR" --min-occurrences 3 > /dev/null 2>&1 || true
+first_count=$(find "$TEST_TMPDIR/docs/lessons" -name "*.md" 2>/dev/null | wc -l)
+first_promoted=$(jq '[.[] | select(.promoted == true)] | length' "$TEST_TMPDIR/logs/mab-lessons.json" 2>/dev/null || echo "0")
+
+TESTS=$((TESTS + 1))
+if [[ "$first_count" -ge 1 && "$first_promoted" == "1" ]]; then
+    echo "PASS: idempotency: first run creates file and marks promoted"
+else
+    echo "FAIL: idempotency: first run should create file ($first_count) and mark promoted ($first_promoted)"
+    FAILURES=$((FAILURES + 1))
+fi
+
+# Second run — promoted=true guard should prevent new files
+"$PROMOTE" --worktree "$TEST_TMPDIR" --min-occurrences 3 > /dev/null 2>&1 || true
+second_count=$(find "$TEST_TMPDIR/docs/lessons" -name "*.md" 2>/dev/null | wc -l)
+
+assert_eq "idempotency: second run creates no additional files" "$first_count" "$second_count"
+
+report_results

package/scripts/tests/test-pull-community-lessons.sh

@@ -0,0 +1,149 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/test-helpers.sh"
+
+PULL="$SCRIPT_DIR/../pull-community-lessons.sh"
+
+# --- Test: --help exits 0 ---
+assert_exit "--help exits 0" 0 "$PULL" --help
+
+# --- Test: missing upstream remote exits 1 gracefully ---
+TEST_TMPDIR=$(mktemp -d)
+trap 'rm -rf "$TEST_TMPDIR"' EXIT
+
+cd "$TEST_TMPDIR" && git init -q && git commit --allow-empty -m "init" -q
+pull_output=$("$PULL" --remote nonexistent 2>&1) || true
+pull_exit=0
+"$PULL" --remote nonexistent > /dev/null 2>&1 || pull_exit=$?
+assert_eq "missing remote exits 1" "1" "$pull_exit"
+assert_contains "missing remote error message" "not found" "$pull_output"
+
+# --- Test: --dry-run without remote shows status ---
+dry_output=$("$PULL" --remote nonexistent --dry-run 2>&1) || true
+# Should still fail because remote doesn't exist (dry-run doesn't skip validation)
+assert_contains "--dry-run mentions remote name" "nonexistent" "$dry_output"
+
+# --- Test: happy path — copies new lessons from upstream ---
+# Create an "upstream" bare repo with a lesson file
+UPSTREAM_DIR=$(mktemp -d)
+LOCAL_DIR=$(mktemp -d)
+trap 'rm -rf "$TEST_TMPDIR" "$UPSTREAM_DIR" "$LOCAL_DIR"' EXIT
+
+# Set up upstream repo with a lesson
+git init -q --bare "$UPSTREAM_DIR/upstream.git"
+CLONE_DIR=$(mktemp -d)
+git clone -q "$UPSTREAM_DIR/upstream.git" "$CLONE_DIR/work"
+cd "$CLONE_DIR/work"
+git config user.email "test@test.com"
+git config user.name "Test"
+mkdir -p docs/lessons
+cat > docs/lessons/0099-upstream-lesson.md << 'LESSON'
+---
+title: Test upstream lesson
+tier: lesson
+scope: universal
+---
+## Key Takeaway
+This came from upstream.
+LESSON
+git add docs/lessons/0099-upstream-lesson.md
+git commit -q -m "add upstream lesson"
+git push -q origin main 2>/dev/null
+cd - > /dev/null
+
+# Set up local repo with upstream remote pointing to bare repo
+git clone -q "$UPSTREAM_DIR/upstream.git" "$LOCAL_DIR/local"
+cd "$LOCAL_DIR/local"
+git config user.email "test@test.com"
+git config user.name "Test"
+git remote add upstream "$UPSTREAM_DIR/upstream.git"
+
+# Remove the lesson locally (simulate it being new)
+rm -f docs/lessons/0099-upstream-lesson.md
+git add -u && git commit -q -m "remove lesson locally" || true
+
+# Run pull-community-lessons
+pull_output=$("$PULL" --remote upstream 2>&1) || true
+
+TESTS=$((TESTS + 1))
+if [[ -f "docs/lessons/0099-upstream-lesson.md" ]]; then
+    echo "PASS: happy path: upstream lesson copied to local"
+else
+    echo "FAIL: happy path: upstream lesson should be copied to local docs/lessons/"
+    echo "  output: $pull_output"
+    FAILURES=$((FAILURES + 1))
+fi
+
+# Verify content
+TESTS=$((TESTS + 1))
+if grep -q "This came from upstream" "docs/lessons/0099-upstream-lesson.md" 2>/dev/null; then
+    echo "PASS: happy path: lesson content is correct"
+else
+    echo "FAIL: happy path: lesson content should match upstream"
+    FAILURES=$((FAILURES + 1))
+fi
+
+cd - > /dev/null
+rm -rf "$CLONE_DIR"
+
+# --- Test: strategy-perf.json max() merge ---
+# Local has (3W, 2L), upstream has (5W, 1L) → merged should be (5W, 2L) per max()
+MERGE_DIR=$(mktemp -d)
+trap 'rm -rf "$TEST_TMPDIR" "$UPSTREAM_DIR" "$LOCAL_DIR" "$MERGE_DIR"' EXIT
+
+# Setup upstream with perf data
+git init -q --bare "$MERGE_DIR/upstream.git"
+MERGE_CLONE=$(mktemp -d)
+git clone -q "$MERGE_DIR/upstream.git" "$MERGE_CLONE/work"
+cd "$MERGE_CLONE/work"
+git config user.email "test@test.com"
+git config user.name "Test"
+mkdir -p logs docs/lessons
+cat > logs/strategy-perf.json << 'PERF'
+{
+  "new-file": {"superpowers": {"wins": 5, "losses": 1}, "ralph": {"wins": 2, "losses": 3}},
+  "refactoring": {"superpowers": {"wins": 0, "losses": 0}, "ralph": {"wins": 0, "losses": 0}},
+  "integration": {"superpowers": {"wins": 0, "losses": 0}, "ralph": {"wins": 0, "losses": 0}},
+  "test-only": {"superpowers": {"wins": 0, "losses": 0}, "ralph": {"wins": 0, "losses": 0}},
+  "calibration_count": 0,
+  "calibration_complete": false
+}
+PERF
+git add . && git commit -q -m "add perf data" && git push -q origin main 2>/dev/null
+cd - > /dev/null
+
+# Local repo with different perf data
+git clone -q "$MERGE_DIR/upstream.git" "$MERGE_DIR/local"
+cd "$MERGE_DIR/local"
+git config user.email "test@test.com"
+git config user.name "Test"
+git remote add upstream "$MERGE_DIR/upstream.git"
+mkdir -p logs
+cat > logs/strategy-perf.json << 'PERF_LOCAL'
+{
+  "new-file": {"superpowers": {"wins": 3, "losses": 2}, "ralph": {"wins": 4, "losses": 1}},
+  "refactoring": {"superpowers": {"wins": 0, "losses": 0}, "ralph": {"wins": 0, "losses": 0}},
+  "integration": {"superpowers": {"wins": 0, "losses": 0}, "ralph": {"wins": 0, "losses": 0}},
+  "test-only": {"superpowers": {"wins": 0, "losses": 0}, "ralph": {"wins": 0, "losses": 0}},
+  "calibration_count": 0,
+  "calibration_complete": false
+}
+PERF_LOCAL
+
+"$PULL" --remote upstream > /dev/null 2>&1 || true
+
+# Check max() merge: max(3,5)=5 for sp wins, max(2,1)=2 for sp losses
+sp_wins=$(jq '."new-file".superpowers.wins' logs/strategy-perf.json 2>/dev/null)
+sp_losses=$(jq '."new-file".superpowers.losses' logs/strategy-perf.json 2>/dev/null)
+ralph_wins=$(jq '."new-file".ralph.wins' logs/strategy-perf.json 2>/dev/null)
+
+assert_eq "max merge: superpowers wins = max(3,5) = 5" "5" "$sp_wins"
+assert_eq "max merge: superpowers losses = max(2,1) = 2" "2" "$sp_losses"
+assert_eq "max merge: ralph wins = max(4,2) = 4" "4" "$ralph_wins"
+
+cd - > /dev/null
+rm -rf "$MERGE_CLONE" "$MERGE_DIR"
+
+report_results