autonomous-coding-toolkit 1.0.0

package/scripts/tests/test-failure-digest.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# Test failure-digest.sh
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DIGEST_SCRIPT="$SCRIPT_DIR/../failure-digest.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
+}
+
+WORK=$(mktemp -d)
+trap 'rm -rf "$WORK"' EXIT
+
+# Create a fake log with errors
+cat > "$WORK/batch-1-attempt-1.log" << 'LOG'
+Some setup output...
+FAILED tests/test_auth.py::test_login - AssertionError: expected 200 got 401
+FAILED tests/test_auth.py::test_signup - KeyError: 'email'
+Traceback (most recent call last):
+  File "src/auth.py", line 42, in login
+    token = generate_token(user)
+TypeError: generate_token() missing 1 required argument: 'secret'
+3 failed, 10 passed in 5.2s
+LOG
+
+# --- Test: extracts failed test names ---
+output=$(bash "$DIGEST_SCRIPT" "$WORK/batch-1-attempt-1.log")
+echo "$output" | grep -q "test_login" && echo "PASS: found test_login" && TESTS=$((TESTS + 1)) || {
+    echo "FAIL: missing test_login"; TESTS=$((TESTS + 1)); FAILURES=$((FAILURES + 1))
+}
+
+echo "$output" | grep -q "test_signup" && echo "PASS: found test_signup" && TESTS=$((TESTS + 1)) || {
+    echo "FAIL: missing test_signup"; TESTS=$((TESTS + 1)); FAILURES=$((FAILURES + 1))
+}
+
+# --- Test: extracts error types ---
+echo "$output" | grep -q "TypeError" && echo "PASS: found TypeError" && TESTS=$((TESTS + 1)) || {
+    echo "FAIL: missing TypeError"; TESTS=$((TESTS + 1)); FAILURES=$((FAILURES + 1))
+}
+
+# --- Test: help flag ---
+bash "$DIGEST_SCRIPT" --help >/dev/null 2>&1
+TESTS=$((TESTS + 1))
+echo "PASS: --help exits cleanly"
+
+# === 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-generate-ast-rules.sh

@@ -0,0 +1,145 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+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_contains() {
+    local desc="$1" needle="$2" haystack="$3"
+    TESTS=$((TESTS + 1))
+    if [[ "$haystack" == *"$needle"* ]]; then
+        echo "PASS: $desc"
+    else
+        echo "FAIL: $desc"
+        echo "  expected to contain: $needle"
+        FAILURES=$((FAILURES + 1))
+    fi
+}
+
+WORK=$(mktemp -d)
+trap 'rm -rf "$WORK"' EXIT
+
+# Create test lesson files
+mkdir -p "$WORK/lessons"
+
+# Syntactic lesson (should be SKIPPED — grep handles these)
+cat > "$WORK/lessons/0001-test.md" << 'LESSON'
+---
+id: 1
+title: "Bare except"
+severity: blocker
+languages: [python]
+category: silent-failures
+pattern:
+  type: syntactic
+  regex: "^\\s*except\\s*:"
+  description: "bare except"
+fix: "Use specific exception"
+example:
+  bad: |
+    except:
+        pass
+  good: |
+    except Exception as e:
+        logger.error(e)
+---
+LESSON
+
+# Semantic lesson with supported language (should generate rule)
+cat > "$WORK/lessons/0033-async.md" << 'LESSON'
+---
+id: 33
+title: "Async iteration mutable"
+severity: blocker
+languages: [python]
+category: async-traps
+pattern:
+  type: semantic
+  description: "async loop iterates over mutable instance attribute"
+fix: "Snapshot with list()"
+example:
+  bad: |
+    async for item in self.connections:
+        await item.send(data)
+  good: |
+    for item in list(self.connections):
+        await item.send(data)
+---
+LESSON
+
+# Unsupported language lesson (should be skipped)
+cat > "$WORK/lessons/0099-go.md" << 'LESSON'
+---
+id: 99
+title: "Go error ignore"
+severity: blocker
+languages: [go]
+category: silent-failures
+pattern:
+  type: semantic
+  description: "ignoring error return value"
+fix: "Handle the error"
+example:
+  bad: |
+    result, _ := doThing()
+  good: |
+    result, err := doThing()
+---
+LESSON
+
+# Test: generates pattern files from lessons
+"$SCRIPT_DIR/../generate-ast-rules.sh" --lessons-dir "$WORK/lessons" --output-dir "$WORK/patterns"
+
+# Syntactic lessons should NOT generate ast-grep rules (grep handles them)
+assert_eq "generate-ast-rules: skips syntactic patterns" "false" \
+    "$(test -f "$WORK/patterns/0001-test.yml" && echo true || echo false)"
+
+# Semantic lesson with supported language should generate a rule
+assert_eq "generate-ast-rules: generates for semantic python lesson" "true" \
+    "$(test -f "$WORK/patterns/0033-async.yml" && echo true || echo false)"
+
+# Unsupported language lesson should NOT generate
+assert_eq "generate-ast-rules: skips unsupported language" "false" \
+    "$(test -f "$WORK/patterns/0099-go.yml" && echo true || echo false)"
+
+# Generated rule should contain lesson metadata
+if [[ -f "$WORK/patterns/0033-async.yml" ]]; then
+    rule_content=$(cat "$WORK/patterns/0033-async.yml")
+    assert_contains "generate-ast-rules: rule has id" "0033-async" "$rule_content"
+    assert_contains "generate-ast-rules: rule has message" "Async iteration mutable" "$rule_content"
+    assert_contains "generate-ast-rules: rule has language" "python" "$rule_content"
+fi
+
+# Test: --list flag shows what would be generated
+output=$("$SCRIPT_DIR/../generate-ast-rules.sh" --lessons-dir "$WORK/lessons" --list 2>&1)
+assert_contains "generate-ast-rules: list shows lesson info" "lesson" "$output"
+assert_contains "generate-ast-rules: list shows summary" "syntactic" "$output"
+
+# Test: default output-dir falls back to scripts/patterns/ when --output-dir omitted
+# Use an empty lessons dir so nothing is written to the production patterns directory
+mkdir -p "$WORK/empty-lessons"
+default_output=$("$SCRIPT_DIR/../generate-ast-rules.sh" --lessons-dir "$WORK/empty-lessons" 2>&1)
+assert_contains "generate-ast-rules: default output-dir references scripts/patterns" "scripts/patterns" "$default_output"
+
+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-helpers.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+# test-helpers.sh — Shared test assertions for validator tests
+# Source this file, don't execute it directly.
+
+FAILURES=0
+TESTS=0
+
+pass() {
+    TESTS=$((TESTS + 1))
+    echo "PASS: $1"
+}
+
+fail() {
+    TESTS=$((TESTS + 1))
+    echo "FAIL: $1"
+    FAILURES=$((FAILURES + 1))
+}
+
+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
+}
+
+assert_contains() {
+    local desc="$1" needle="$2" haystack="$3"
+    TESTS=$((TESTS + 1))
+    if echo "$haystack" | grep -qF "$needle"; then
+        echo "PASS: $desc"
+    else
+        echo "FAIL: $desc"
+        echo "  expected to contain: $needle"
+        echo "  in: $(echo "$haystack" | head -5)"
+        FAILURES=$((FAILURES + 1))
+    fi
+}
+
+assert_not_contains() {
+    local desc="$1" needle="$2" haystack="$3"
+    TESTS=$((TESTS + 1))
+    if echo "$haystack" | grep -qF "$needle"; then
+        echo "FAIL: $desc"
+        echo "  should NOT contain: $needle"
+        FAILURES=$((FAILURES + 1))
+    else
+        echo "PASS: $desc"
+    fi
+}
+
+# Call at end of test file
+report_results() {
+    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-init.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+# Test scripts/init.sh — project bootstrapper
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+INIT_SCRIPT="$REPO_ROOT/scripts/init.sh"
+
+source "$SCRIPT_DIR/test-helpers.sh"
+
+# --- Setup temp project ---
+WORK=$(mktemp -d)
+trap 'rm -rf "$WORK"' EXIT
+cd "$WORK"
+git init -q
+
+# --- Test 1: init creates tasks/ directory ---
+bash "$INIT_SCRIPT" --project-root "$WORK" 2>&1 || true
+assert_eq "init creates tasks/ directory" "true" "$([ -d "$WORK/tasks" ] && echo true || echo false)"
+
+# --- Test 2: init creates progress.txt ---
+assert_eq "init creates progress.txt" "true" "$([ -f "$WORK/progress.txt" ] && echo true || echo false)"
+
+# --- Test 3: init creates logs/ directory ---
+assert_eq "init creates logs/ directory" "true" "$([ -d "$WORK/logs" ] && echo true || echo false)"
+
+# --- Test 4: init detects project type ---
+output=$(bash "$INIT_SCRIPT" --project-root "$WORK" 2>&1 || true)
+assert_contains "init detects project type" "Detected:" "$output"
+
+# --- Test 5: init with --quickstart copies quickstart plan ---
+mkdir -p "$WORK/docs/plans"
+bash "$INIT_SCRIPT" --project-root "$WORK" --quickstart 2>&1 || true
+assert_eq "quickstart creates plan file" "true" "$([ -f "$WORK/docs/plans/quickstart.md" ] && echo true || echo false)"
+
+# --- Test 6: init fails without --project-root ---
+exit_code=0
+bash "$INIT_SCRIPT" 2>/dev/null || exit_code=$?
+assert_eq "init fails without --project-root" "1" "$exit_code"
+
+# --- Test 7: init is idempotent ---
+bash "$INIT_SCRIPT" --project-root "$WORK" 2>&1 || true
+exit_code=0
+bash "$INIT_SCRIPT" --project-root "$WORK" 2>&1 || exit_code=$?
+assert_eq "init is idempotent (exit 0 on re-run)" "0" "$exit_code"
+
+report_results

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

@@ -0,0 +1,278 @@
+#!/usr/bin/env bash
+# Test lesson-check.sh — anti-pattern detector
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+LESSON_CHECK="$SCRIPT_DIR/../lesson-check.sh"
+
+FAILURES=0
+TESTS=0
+
+pass() {
+    TESTS=$((TESTS + 1))
+    echo "PASS: $1"
+}
+
+fail() {
+    TESTS=$((TESTS + 1))
+    echo "FAIL: $1"
+    FAILURES=$((FAILURES + 1))
+}
+
+# --- Setup temp workspace ---
+WORK=$(mktemp -d)
+trap 'rm -rf "$WORK"' EXIT
+
+# --- Test 1: Detects bare except in Python file (lesson 1, uses \s) ---
+cat > "$WORK/bad.py" <<'PY'
+try:
+    do_something()
+except:
+    pass
+PY
+
+# PROJECT_CLAUDE_MD=/dev/null isolates from toolkit's scope tags (language:bash would filter out python lessons)
+output=$(PROJECT_CLAUDE_MD="/dev/null" bash "$LESSON_CHECK" "$WORK/bad.py" 2>&1 || true)
+if echo "$output" | grep -q '\[lesson-1\]'; then
+    pass "Detects bare except in Python file (lesson 1, \\s ERE conversion)"
+else
+    fail "Should detect bare except in Python file, got: $output"
+fi
+
+# --- Test 2: Clean file passes ---
+cat > "$WORK/good.py" <<'PY'
+try:
+    do_something()
+except ValueError:
+    pass
+PY
+
+output=$(PROJECT_CLAUDE_MD="/dev/null" bash "$LESSON_CHECK" "$WORK/good.py" 2>&1 || true)
+if echo "$output" | grep -q 'clean'; then
+    pass "Clean file reports clean"
+else
+    fail "Should report clean for good file, got: $output"
+fi
+
+# --- Test 3: PCRE shorthand \d works via ERE conversion (lesson 28, hardcoded IP) ---
+cat > "$WORK/bad_ip.js" <<'JS'
+const url = "http://192.168.1.1/api";
+JS
+
+output=$(PROJECT_CLAUDE_MD="/dev/null" bash "$LESSON_CHECK" "$WORK/bad_ip.js" 2>&1 || true)
+if echo "$output" | grep -q '\[lesson-28\]'; then
+    pass "PCRE \\d converted to ERE [0-9] detects hardcoded IPs"
+else
+    fail "Should detect hardcoded IP via lesson 28, got: $output"
+fi
+
+# --- Test 4: Language filtering — Python lesson skips .sh files ---
+cat > "$WORK/not_python.sh" <<'SH'
+except:
+SH
+
+output=$(PROJECT_CLAUDE_MD="/dev/null" bash "$LESSON_CHECK" "$WORK/not_python.sh" 2>&1 || true)
+if echo "$output" | grep -q '\[lesson-1\]'; then
+    fail "Python-only lesson 1 should not match .sh files"
+else
+    pass "Python-only lesson correctly skips .sh files"
+fi
+
+# --- Test 5: --help works ---
+output=$(bash "$LESSON_CHECK" --help 2>&1 || true)
+if echo "$output" | grep -q 'Usage:'; then
+    pass "--help shows usage"
+else
+    fail "--help should show usage, got: $output"
+fi
+
+# --- Test 6: No files to check (no args, no pipe, no git diff) ---
+output=$(cd "$WORK" && bash "$LESSON_CHECK" 2>&1 || true)
+if echo "$output" | grep -q 'no files to check'; then
+    pass "No files gracefully reports nothing to check"
+else
+    fail "Should report no files to check, got: $output"
+fi
+
+# --- Test 6b: stdin pipe detection — uses -p /dev/stdin not -t 0 (#34) ---
+# This prevents hanging when stdin is a socket (e.g. systemd/cron).
+# The fix: only read stdin when [[ -p /dev/stdin ]] (a named pipe), not
+# whenever [[ ! -t 0 ]] (which includes sockets that never send EOF).
+TESTS=$((TESTS + 1))
+if grep -q '\-p /dev/stdin' "$LESSON_CHECK"; then
+    echo "PASS: lesson-check uses -p /dev/stdin (pipe-safe, not socket-blocking)"
+else
+    echo "FAIL: lesson-check should use [[ -p /dev/stdin ]] not [[ ! -t 0 ]] for stdin detection (bug #34)"
+    FAILURES=$((FAILURES + 1))
+fi
+
+# Verify the old ! -t 0 pattern is NOT present in executable code (it caused the socket hang).
+# Filter comment-only lines before checking.
+TESTS=$((TESTS + 1))
+if grep -v '^\s*#' "$LESSON_CHECK" | grep -q '! -t 0'; then
+    echo "FAIL: lesson-check still uses '! -t 0' in executable code, which blocks on socket stdin (bug #34)"
+    FAILURES=$((FAILURES + 1))
+else
+    echo "PASS: lesson-check does not use '! -t 0' in executable code (socket-safe)"
+fi
+
+# --- Test 7: No grep -P in any script (portability) ---
+TESTS=$((TESTS + 1))
+# Scan for grep -P or grep -<flags>P usage in scripts/ (excluding comments)
+offenders=$(grep -rn 'grep -[a-zA-Z]*P' "$REPO_ROOT/scripts/" \
+    --include='*.sh' \
+    | grep -v 'test-lesson-check.sh' \
+    | grep -v ':#' \
+    | grep -v ':.*# .*grep' \
+    || true)
+if [[ -z "$offenders" ]]; then
+    echo "PASS: No grep -P found in scripts/ (portability)"
+else
+    echo "FAIL: grep -P found in scripts/ — not portable to macOS:"
+    echo "$offenders"
+    FAILURES=$((FAILURES + 1))
+fi
+
+# --- Test 8: All scripts use #!/usr/bin/env bash shebang ---
+TESTS=$((TESTS + 1))
+bad_shebangs=""
+while IFS= read -r script; do
+    first_line=$(head -1 "$script")
+    if [[ "$first_line" == "#!/bin/bash" ]]; then
+        bad_shebangs+="  $script"$'\n'
+    fi
+done < <(find "$REPO_ROOT/scripts" -name '*.sh' -type f)
+if [[ -z "$bad_shebangs" ]]; then
+    echo "PASS: All scripts use #!/usr/bin/env bash"
+else
+    echo "FAIL: Scripts with non-portable #!/bin/bash shebang:"
+    echo "$bad_shebangs"
+    FAILURES=$((FAILURES + 1))
+fi
+
+# --- Test 9: Scope field parsed from lesson YAML ---
+# Create a lesson with scope: [language:python] and verify it's respected
+cat > "$WORK/0999-scoped-lesson.md" <<'LESSON'
+---
+id: 999
+title: "Test scoped lesson"
+severity: should-fix
+scope: [language:python]
+languages: [python]
+category: silent-failures
+pattern:
+  type: syntactic
+  regex: "test_scope_marker"
+  description: "test marker"
+fix: "test"
+---
+LESSON
+
+# Create a CLAUDE.md with scope tags
+cat > "$WORK/CLAUDE.md" <<'CMD'
+# Test Project
+
+## Scope Tags
+language:python, framework:pytest
+CMD
+
+# Python file with the marker — should be detected (scope matches)
+cat > "$WORK/scoped.py" <<'PY'
+test_scope_marker = True
+PY
+
+output=$(cd "$WORK" && LESSONS_DIR="$WORK" bash "$LESSON_CHECK" "$WORK/scoped.py" 2>&1 || true)
+if echo "$output" | grep -q '\[lesson-999\]'; then
+    pass "Scoped lesson detected when project scope matches"
+else
+    fail "Scoped lesson should detect violation when project scope matches, got: $output"
+fi
+
+# --- Test 10: Scoped lesson skipped when project scope doesn't match ---
+cat > "$WORK/CLAUDE-noscope.md" <<'CMD'
+# Different Project
+
+## Scope Tags
+domain:ha-aria
+CMD
+
+output=$(cd "$WORK" && LESSONS_DIR="$WORK" PROJECT_CLAUDE_MD="$WORK/CLAUDE-noscope.md" bash "$LESSON_CHECK" "$WORK/scoped.py" 2>&1 || true)
+if echo "$output" | grep -q '\[lesson-999\]'; then
+    fail "Scoped lesson should be SKIPPED when project scope doesn't match"
+else
+    pass "Scoped lesson correctly skipped for non-matching project scope"
+fi
+
+# --- Test 11: Lesson without scope defaults to universal (backward compat) ---
+# Use the real lesson 1 (no scope field) — should still work as before
+# Isolate from repo's own CLAUDE.md by pointing PROJECT_CLAUDE_MD to /dev/null
+output=$(PROJECT_CLAUDE_MD="/dev/null" bash "$LESSON_CHECK" "$WORK/bad.py" 2>&1 || true)
+if echo "$output" | grep -q '\[lesson-1\]'; then
+    pass "Lesson without scope: field defaults to universal (backward compatible)"
+else
+    fail "Missing scope: should default to universal, got: $output"
+fi
+
+# --- Test 12: --show-scope displays detected project scope ---
+output=$(cd "$WORK" && bash "$LESSON_CHECK" --show-scope 2>&1 || true)
+if echo "$output" | grep -q 'language:python'; then
+    pass "--show-scope displays detected project scope"
+else
+    fail "--show-scope should display detected scope from CLAUDE.md, got: $output"
+fi
+
+# --- Test 13: --all-scopes bypasses scope filtering ---
+# Use a lesson scoped to domain:ha-aria on a python project — should be skipped normally
+cat > "$WORK/0998-ha-lesson.md" <<'LESSON'
+---
+id: 998
+title: "HA-only test lesson"
+severity: should-fix
+scope: [domain:ha-aria]
+languages: [python]
+category: silent-failures
+pattern:
+  type: syntactic
+  regex: "ha_scope_marker"
+  description: "test marker"
+fix: "test"
+---
+LESSON
+
+cat > "$WORK/ha_file.py" <<'PY'
+ha_scope_marker = True
+PY
+
+# Without --all-scopes: lesson 998 should be skipped (project is python, not ha-aria)
+output=$(cd "$WORK" && LESSONS_DIR="$WORK" bash "$LESSON_CHECK" "$WORK/ha_file.py" 2>&1 || true)
+if echo "$output" | grep -q '\[lesson-998\]'; then
+    fail "domain:ha-aria lesson should be skipped on a python-only project"
+else
+    pass "domain:ha-aria lesson correctly skipped on non-matching project"
+fi
+
+# With --all-scopes: lesson 998 should fire
+output=$(cd "$WORK" && LESSONS_DIR="$WORK" bash "$LESSON_CHECK" --all-scopes "$WORK/ha_file.py" 2>&1 || true)
+if echo "$output" | grep -q '\[lesson-998\]'; then
+    pass "--all-scopes bypasses scope filtering"
+else
+    fail "--all-scopes should bypass scope filtering, got: $output"
+fi
+
+# --- Test 14: --scope override replaces CLAUDE.md detection ---
+output=$(cd "$WORK" && LESSONS_DIR="$WORK" bash "$LESSON_CHECK" --scope "domain:ha-aria" "$WORK/ha_file.py" 2>&1 || true)
+if echo "$output" | grep -q '\[lesson-998\]'; then
+    pass "--scope override enables matching for specified scope"
+else
+    fail "--scope override should enable domain:ha-aria matching, got: $output"
+fi
+
+# --- Summary ---
+echo ""
+echo "lesson-check tests: $TESTS run, $((TESTS - FAILURES)) passed, $FAILURES failed"
+
+if [[ $FAILURES -gt 0 ]]; then
+    exit 1
+fi
+exit 0

package/scripts/tests/test-lesson-local.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Test lesson-check.sh — project-local lesson loading (Tier 3)
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+LESSON_CHECK="$REPO_ROOT/scripts/lesson-check.sh"
+
+source "$SCRIPT_DIR/test-helpers.sh"
+
+# --- Setup: project with local lessons ---
+WORK=$(mktemp -d)
+trap 'rm -rf "$WORK"' EXIT
+
+# Create a project-local lesson
+mkdir -p "$WORK/docs/lessons"
+cat > "$WORK/docs/lessons/9901-local-test.md" <<'LESSON'
+---
+id: 9901
+title: "Test local lesson"
+severity: error
+languages: [python]
+scope: [universal]
+category: testing
+pattern:
+  type: syntactic
+  regex: "LOCALTEST_BAD_PATTERN"
+fix: "Use LOCALTEST_GOOD_PATTERN instead"
+positive_alternative: "LOCALTEST_GOOD_PATTERN"
+---
+LESSON
+
+# Create a file that triggers the local lesson
+cat > "$WORK/bad.py" <<'PY'
+x = LOCALTEST_BAD_PATTERN
+PY
+
+# --- Test: project-local lesson is loaded ---
+output=$(PROJECT_ROOT="$WORK" PROJECT_CLAUDE_MD="/dev/null" bash "$LESSON_CHECK" "$WORK/bad.py" 2>&1 || true)
+if echo "$output" | grep -q 'lesson-9901'; then
+    pass "Project-local lesson detected violation"
+else
+    fail "Project-local lesson not loaded, got: $output"
+fi
+
+# --- Test: clean file passes with local lessons ---
+cat > "$WORK/good.py" <<'PY'
+x = LOCALTEST_GOOD_PATTERN
+PY
+
+exit_code=0
+PROJECT_ROOT="$WORK" PROJECT_CLAUDE_MD="/dev/null" bash "$LESSON_CHECK" "$WORK/good.py" 2>/dev/null || exit_code=$?
+assert_eq "Clean file passes with local lessons" "0" "$exit_code"
+
+report_results