source_monitor 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b65480547bf48a4cabf2d1c98dbd6c965a6b7342c3da362b3987b1bed3e59a5d
-  data.tar.gz: 775abb18c5c94b5cf11e78e01c296a618c7ef884cb328f4f5f886c2d144c2f75
+  metadata.gz: 135499910675f0d424b88ec25e1503f3068fdbd78ffa553942438efd886b72bd
+  data.tar.gz: a6b03ef217569a206d7521f2d8b42f3c300ab6ddf41e144cabaf24535f92b8dc
 SHA512:
-  metadata.gz: f75e313708962d167d7b362ed4f8af42be433e28d5a9e1aa59f290d82ed12103800abaf2f904098211c351f7c3b9265af05363d2364f477e22af3e7de2bc9755
-  data.tar.gz: ab0e7911a85c744f632d2fad3dbeb671ddb55b3e1f4cc0ed3a0dbc859e2dad21ccacdec8aff7ee45445cf84f3cfb3ddaf2ba803a7e533cacdc14b8cb3ee61ab6
+  metadata.gz: b4e0ebe10a0211760f42d6a131cbf61eb09bf3f268006fbefe51636137c10ba0afc0413e2c39a46a8d3ff39037db07ba680a6f059599d7751b56a79d5deef1a3
+  data.tar.gz: 7bdfa9ca0995bb91757be78271ca171a14ec83cc54aef8d13b083446e3c23a96d4568718b40a944c83c802173124823609a36c405a68b8a0c81bb138891aa65b

data/.claude/commands/release.md

@@ -15,8 +15,10 @@ These are real issues encountered in previous releases. Each step below accounts
 3. **VBW volatile files**: Files in `.vbw-planning/` (`.cost-ledger.json`, `.notification-log.jsonl`, `.session-log.jsonl`, `.hook-errors.log`) are continuously modified by VBW hooks. They should be in `.gitignore`. If they aren't, add them before proceeding.
 4. **Pre-push hook**: The VBW pre-push hook at `.git/hooks/pre-push` requires the `VERSION` file to appear in the diff for any push. For new branches, it compares the commit against the working tree -- any dirty files will trigger a false positive. For force-pushes to existing branches where `VERSION` hasn't changed since the last push, use `--no-verify`.
 5. **Single squashed commit**: Always create ONE commit on the release branch with ALL changes (version bump, changelog, Gemfile.lock, any fixes). Multiple commits cause pre-push hook issues.
-6. **Diff coverage CI gate**: The `test` CI job enforces diff coverage. Any changed lines in source code (not just test files) must have test coverage. If you change source code during the release (e.g., bug fixes), you must add corresponding tests.
-7. **Local main divergence after merge**: After the PR merges, local main will have different commits than origin/main (pre-squash vs merged). You must `git reset --hard origin/main` to sync -- this requires user approval since the sandbox blocks it.
+6. **Diff coverage CI gate**: The `test` CI job enforces diff coverage. Any changed lines in source code (not just test files) must have test coverage. **This applies to ALL changes in the PR diff vs main, including unpushed commits made before the release started.** If the release includes source code changes (bug fixes, features), every changed source line must be covered.
+7. **Local main divergence after merge**: After the PR merges, `gh pr merge --merge --delete-branch` will attempt to fast-forward local main. This usually succeeds automatically. If it doesn't (divergent history), you must `git reset --hard origin/main` to sync -- this requires user approval since the sandbox blocks it.
+8. **Run local checks BEFORE pushing**: Always run `bin/rubocop` and `PARALLEL_WORKERS=1 bin/rails test` locally before the first push to the release branch. Each CI roundtrip (fail → fix → amend → force-push → re-run) costs ~5 minutes. In v0.7.0, skipping local checks caused two wasted CI cycles: first for uncovered diff lines, then for a RuboCop violation in the fix.
+9. **Zsh glob nomatch**: Commands like `rm -f *.gem` fail in zsh when no files match. Always use `rm -f *.gem 2>/dev/null || true` or check existence first with `ls`.
 
 ## Step 1: Git Hygiene
 
@@ -112,7 +114,25 @@ The changelog follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) f
 2. Verify the output shows the new version: `Using source_monitor X.Y.Z (was X.Y.Z-1)`.
 3. If `bundle install` fails, resolve the issue before proceeding.
 
-## Step 5: Create Release Branch with Single Squashed Commit
+## Step 5: Local Pre-flight Checks
+
+**CRITICAL**: Run these checks BEFORE creating the release branch and pushing. Each CI failure → fix → amend → force-push cycle wastes ~5 minutes. In v0.7.0, skipping this step caused two wasted CI roundtrips.
+
+1. **RuboCop**: Run `bin/rubocop` and fix any violations. Auto-fix with `bin/rubocop -a` if needed. This catches lint issues (like `SpaceInsideArrayLiteralBrackets`) that would fail the CI lint job.
+
+2. **Tests**: Run `PARALLEL_WORKERS=1 bin/rails test` and ensure all tests pass.
+
+3. **Diff coverage pre-check**: If the release includes source code changes beyond version/changelog/lockfile (check with `git diff --name-only origin/main`), review those files for uncovered branches. The CI diff coverage gate will reject any changed source lines without test coverage. Common blind spots:
+   - Fallback/else branches in new methods
+   - Error handling paths
+   - Guard clauses
+   If you find uncovered source lines, write tests for them NOW before creating the release commit — it's far cheaper than a CI roundtrip.
+
+4. **Brakeman**: Run `bin/brakeman --no-pager` and ensure zero warnings.
+
+Only proceed to Step 6 when all local checks pass.
+
+## Step 6: Create Release Branch with Single Squashed Commit
 
 **IMPORTANT**: All release changes MUST be in a single commit on the release branch. This avoids pre-push hook issues where individual commits are checked for VERSION changes.
 
@@ -124,13 +144,13 @@ The changelog follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) f
    Also stage any other files that were changed (updated skills, docs, etc.).
 3. Create a single commit:
    ```
-   chore: release vX.Y.Z
+   chore(release): release vX.Y.Z
    ```
 4. Push the branch: `git push -u origin release/vX.Y.Z`
    - If the pre-push hook blocks with a false positive (e.g., VBW files dirty in working tree despite being gitignored), use `git push -u --no-verify origin release/vX.Y.Z`. This is safe because we've verified VERSION is in the commit.
 5. If the push fails for other reasons, diagnose and fix before proceeding.
 
-## Step 6: Create PR
+## Step 7: Create PR
 
 1. Create the PR using `gh pr create`:
    - Title: `Release vX.Y.Z`
@@ -152,7 +172,7 @@ The changelog follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) f
    - Base: `main`
 2. Report the PR URL to the user.
 
-## Step 7: Monitor CI Pipeline
+## Step 8: Monitor CI Pipeline
 
 Poll the CI status using repeated `gh pr checks <PR_NUMBER>` calls. The CI has 4 required jobs: `lint`, `security`, `test`, `release_verification` (release_verification only runs after test passes).
 
@@ -163,7 +183,7 @@ Poll the CI status using repeated `gh pr checks <PR_NUMBER>` calls. The CI has 4
 
 ### If CI PASSES (all checks green):
 
-Continue to Step 8.
+Continue to Step 9. If Step 5 (local pre-flight) was done properly, CI should pass on the first attempt.
 
 ### If CI FAILS:
 
@@ -173,32 +193,32 @@ Continue to Step 8.
    gh run view <RUN_ID> --log-failed | tail -80
    ```
 3. **Common failure: diff coverage** -- If the `test` job fails on "Enforce diff coverage", it means changed source lines lack test coverage. Read the error to identify uncovered files/lines, write tests, and add them to the release commit.
-4. **Common failure: Gemfile.lock frozen** -- If `bundle install` fails in CI with "frozen mode", you forgot to run `bundle install` locally (Step 4).
-5. Present failure details to the user and ask what to do:
-   - "Fix the issues and re-push" -- Fix issues, amend the commit (`git commit --amend --no-edit`), force push (`git push --force-with-lease --no-verify origin release/vX.Y.Z`), and restart CI monitoring.
+4. **Common failure: Gemfile.lock frozen** -- If `bundle install` fails in CI with "frozen mode", you forgot to run `bundle install` locally (Step 4). Amend the commit with the updated lockfile.
+5. **Common failure: RuboCop lint** -- If the `lint` job fails, a RuboCop violation slipped through. This should have been caught in Step 5.
+6. **IMPORTANT: When fixing CI failures, run ALL local checks again before re-pushing.** Don't just fix the one failure — run `bin/rubocop` AND `PARALLEL_WORKERS=1 bin/rails test` to catch cascading issues. In v0.7.0, fixing a diff coverage failure introduced a RuboCop violation, requiring a third CI cycle.
+7. Present failure details to the user and ask what to do:
+   - "Fix the issues and re-push" -- Fix issues, run ALL local checks (rubocop + tests), amend the commit (`git commit --amend --no-edit`), force push (`git push --force-with-lease --no-verify origin release/vX.Y.Z`), and restart CI monitoring.
    - "Close the PR and abort" -- Close the PR, delete the branch, switch back to main.
    - "Investigate manually" -- Stop and let the user handle it.
 
 **Note on force pushes**: When force-pushing the release branch after amending, always use `--no-verify` because the pre-push hook will see the diff between old and new branch tips, and `VERSION` won't appear as changed (it's the same in both). This is expected and safe.
 
-## Step 8: Auto-Merge PR
+## Step 9: Auto-Merge PR
 
 Once CI is green:
 
 1. Merge the PR: `gh pr merge <PR_NUMBER> --merge --delete-branch`
+   - The `--delete-branch` flag also fetches and fast-forwards local main in most cases.
 
-2. **Sync local main with remote** (this is the tricky part):
-   - The merge creates a merge commit on origin/main that doesn't exist locally.
-   - Local main may have different commits (pre-squash) than what was merged.
+2. **Sync local main with remote**:
    - Switch to main: `git checkout main`
-   - Try `git pull origin main`. If it fails with conflicts or divergence:
-     - Ask the user to run `git reset --hard origin/main` (the sandbox blocks this command).
-     - Explain this is safe because the PR is merged and all changes are on origin/main.
-   - Verify with `git log --oneline -3` that local matches remote.
+   - The `gh pr merge` command usually auto-syncs local main via fast-forward. Verify with `git log --oneline -3` that local matches remote (`git rev-parse HEAD` == `git rev-parse origin/main`).
+   - If local is behind or diverged, try `git pull origin main`.
+   - If pull fails with conflicts or divergence (rare): ask the user to run `git reset --hard origin/main` (the sandbox blocks this command). Explain this is safe because the PR is merged and all changes are on origin/main.
 
 3. Report: "PR #N merged successfully."
 
-## Step 9: Tag the Release
+## Step 10: Tag the Release
 
 1. Verify you're on main and synced with origin.
 2. Create an annotated tag:
@@ -212,14 +232,17 @@ Once CI is green:
    ```
 5. Report the release URL.
 
-## Step 10: Build the Gem
+## Step 11: Build the Gem
 
-1. Clean any old gem files: `ls source_monitor-*.gem` and remove them if found (don't error if none exist).
+1. Clean any old gem files. **Note**: zsh fails on `rm -f *.gem` when no files match due to `nomatch`. Use:
+   ```
+   find . -maxdepth 1 -name 'source_monitor-*.gem' -delete
+   ```
 2. Build the gem: `gem build source_monitor.gemspec`
 3. Verify the gem was built: check for `source_monitor-X.Y.Z.gem` in the project root.
 4. Show the file size: `ls -la source_monitor-X.Y.Z.gem`
 
-## Step 11: Gem Push Instructions
+## Step 12: Gem Push Instructions
 
 Present the final instructions to the user:
 

data/.vbw-planning/ROADMAP.md

@@ -5,6 +5,7 @@
 ### Phases
 
 1. [x] **AIA Certificate Resolution** -- Fix SSL failures for feeds with missing intermediate certificates by implementing AIA (Authority Information Access) resolution
+2. [x] **Test Performance** -- Reduce test suite runtime from ~133s to ~50s by splitting monolithic test classes, enabling parallelism, reducing log IO, and adopting before_all
 
 ### Phase Details
 
@@ -25,8 +26,28 @@
 - [ ] All existing tests pass (1003+), new tests cover AIA paths
 - [ ] RuboCop zero offenses, Brakeman zero warnings
 
+#### Phase 2: Test Performance
+
+**Goal:** Reduce test suite wall-clock time from ~133s to ~50s through structural optimizations. The 3-agent investigation identified that FeedFetcherTest (71 tests, 84.8s, 64% of total) is a monolithic class that cannot be parallelized, integration tests add 31s, and 95MB of debug logging adds 5-15s.
+
+**Requirements:**
+- REQ-PERF-01: Split FeedFetcherTest into 5+ smaller classes by concern (success paths, error handling, adaptive interval, dirty-check, content fingerprint, utilities)
+- REQ-PERF-02: Set test log level to :warn in test/dummy/config/environments/test.rb (eliminates 95MB log IO)
+- REQ-PERF-03: Tag integration tests (host_install_flow, release_packaging) so they can be excluded during dev with --exclude-pattern
+- REQ-PERF-04: Switch default parallelism from forks to threads (avoids PG segfault, enables splitting benefit)
+- REQ-PERF-05: Adopt before_all/setup_once in top DB-heavy test files (dashboard/queries_test.rb, etc.)
+
+**Success Criteria:**
+- [ ] FeedFetcherTest split into 5+ files, each independently runnable
+- [ ] All 1031+ tests pass with PARALLEL_WORKERS=1 and default workers
+- [ ] Test suite completes in <70s locally (down from 133s)
+- [ ] `bin/rails test --exclude-pattern="**/integration/**"` runs <50s
+- [ ] RuboCop zero offenses, Brakeman zero warnings
+- [ ] No test isolation regressions (parallel runs still green)
+
 ### Progress
 
 | Phase | Status | Plans | Completed |
 |-------|--------|-------|-----------|
-| 1. AIA Certificate Resolution | Planned | 3 | 0 |
+| 1. AIA Certificate Resolution | Complete | 3 | 3 |
+| 2. Test Performance | Complete | 4 | 4 |

data/.vbw-planning/STATE.md

@@ -3,7 +3,7 @@
 ## Current Position
 
 - **Milestone:** aia-ssl-fix
-- **Phase:** 1 -- AIA Certificate Resolution
+- **Phase:** 2 -- Test Performance
 - **Status:** Complete
 - **Progress:** 100%
 

data/.vbw-planning/phases/02-test-performance/.context-dev.md

@@ -0,0 +1,75 @@
+## Phase 02 Context
+
+### Goal
+Not available
+
+### Codebase Map Available
+Codebase mapping exists in `.vbw-planning/codebase/`. Key files:
+- `ARCHITECTURE.md`
+- `CONCERNS.md`
+- `PATTERNS.md`
+- `DEPENDENCIES.md`
+- `STRUCTURE.md`
+- `CONVENTIONS.md`
+- `TESTING.md`
+- `STACK.md`
+
+Read CONVENTIONS.md, PATTERNS.md, STRUCTURE.md, and DEPENDENCIES.md first to bootstrap codebase understanding.
+
+### Research Findings
+# Phase 2: Test Performance - Research
+
+## Investigation Method
+3-agent competing hypothesis team (H1: DB/parallelism, H2: HTTP/VCR, H3: test helpers)
+
+## Findings
+
+### Time Budget (133s total, 1031 tests)
+| Component | Time | % | Root Cause |
+|-----------|------|---|------------|
+| FeedFetcherTest (71 tests) | 84.8s | 64% | Monolithic class, CPU-bound (Feedjira parse, SHA256, content extraction) |
+| Integration tests (9 tests) | 30.8s | 23% | Subprocess spawning (bundle exec rails g) |
+| System tests (22 tests) | ~5s | 4% | Selenium/Chrome |
+| Debug log IO | 5-15s | 8% | 95MB :debug output to disk |
+| Everything else (~930 tests) | ~15s | 11% | Fast |
+
+### Why Parallelism Doesn't Help Today
+- Minitest distributes by CLASS, not by test
+- FeedFetcherTest = 1 class with 71 tests = 1 worker gets all 84.8s
+- With 8 workers: max(84.8, 25.6, ~3) ≈ 85s + overhead
+
+### DB Is NOT the Bottleneck
+- SQL: 3.639s of 69.4s (5.25%) via EventProf
+- schema.rb used (fast load)
+- Transactional tests enabled (proper rollback)
+
+### HTTP Mocking Is NOT the Bottleneck
+- Only 4 VCR cassettes (456KB total), 83 WebMock stubs across 9 files
+- WebMock configured once globally, auto-resets
+- Only finding: default_cert_store recreated per connection (~0.5s total)
+
+### Test Helpers Are Cheap
+- reset_configuration!: microseconds per call (pure Ruby)
+- create_source!: 1 INSERT per call, 158 calls total
+- with_inline_jobs: 4 calls total, negligible
+
+### Profiling Data (tmp/test_prof/)
+- TagProf: lib tests 38.0s (55%), integration 28.5s (41%), controllers 0.97s, jobs 0.53s, models 0.47s
+- EventProf: FeedFetcherTest 0.888s SQL in 34.3s total (2.6% SQL)
+
+## Relevant Patterns
+- TestProf before_all available but used in only 1 of 54 eligible files
+- Thread-based parallelism already proven in coverage mode
+- PG fork segfault only on single-file runs, NOT full suite
+
+## Risks
+- Thread safety: reset_configuration! may need thread-local config or mutex
+- Test isolation: splitting FeedFetcherTest must preserve test independence
+- before_all: only safe for tests that don't mutate shared data
+
+## Recommendations (by impact)
+1. Split FeedFetcherTest into 5-6 classes → enables parallelism, -50s
+2. Set config.log_level = :warn → -5-15s
+3. Tag/skip integration tests in dev → -30s dev experience
+4. Switch to thread-based parallelism → enables splitting benefit
+5. Adopt before_all in DB-heavy test files → -3-5s

data/.vbw-planning/phases/02-test-performance/.context-lead.md

@@ -0,0 +1,89 @@
+## Phase 02 Context (Compiled)
+
+### Goal
+Not available
+
+### Success Criteria
+Not available
+
+### Requirements (Not available)
+No matching requirements found
+
+
+### Active Decisions
+
+| Decision | Date | Context |
+|----------|------|---------|
+| Single-phase milestone for AIA fix | 2026-02-17 | Complete plan already validated; no scoping needed |
+| 3 plans with wave parallelism | 2026-02-17 | Plans 01+02 (wave 1, disjoint files), Plan 03 (wave 2, integration) |
+
+### Codebase Map Available
+Codebase mapping exists in `.vbw-planning/codebase/`. Key files:
+- `ARCHITECTURE.md`
+- `CONCERNS.md`
+- `PATTERNS.md`
+- `DEPENDENCIES.md`
+- `STRUCTURE.md`
+- `CONVENTIONS.md`
+- `TESTING.md`
+- `STACK.md`
+
+Read ARCHITECTURE.md, CONCERNS.md, and STRUCTURE.md first to bootstrap codebase understanding.
+
+### Research Findings
+# Phase 2: Test Performance - Research
+
+## Investigation Method
+3-agent competing hypothesis team (H1: DB/parallelism, H2: HTTP/VCR, H3: test helpers)
+
+## Findings
+
+### Time Budget (133s total, 1031 tests)
+| Component | Time | % | Root Cause |
+|-----------|------|---|------------|
+| FeedFetcherTest (71 tests) | 84.8s | 64% | Monolithic class, CPU-bound (Feedjira parse, SHA256, content extraction) |
+| Integration tests (9 tests) | 30.8s | 23% | Subprocess spawning (bundle exec rails g) |
+| System tests (22 tests) | ~5s | 4% | Selenium/Chrome |
+| Debug log IO | 5-15s | 8% | 95MB :debug output to disk |
+| Everything else (~930 tests) | ~15s | 11% | Fast |
+
+### Why Parallelism Doesn't Help Today
+- Minitest distributes by CLASS, not by test
+- FeedFetcherTest = 1 class with 71 tests = 1 worker gets all 84.8s
+- With 8 workers: max(84.8, 25.6, ~3) ≈ 85s + overhead
+
+### DB Is NOT the Bottleneck
+- SQL: 3.639s of 69.4s (5.25%) via EventProf
+- schema.rb used (fast load)
+- Transactional tests enabled (proper rollback)
+
+### HTTP Mocking Is NOT the Bottleneck
+- Only 4 VCR cassettes (456KB total), 83 WebMock stubs across 9 files
+- WebMock configured once globally, auto-resets
+- Only finding: default_cert_store recreated per connection (~0.5s total)
+
+### Test Helpers Are Cheap
+- reset_configuration!: microseconds per call (pure Ruby)
+- create_source!: 1 INSERT per call, 158 calls total
+- with_inline_jobs: 4 calls total, negligible
+
+### Profiling Data (tmp/test_prof/)
+- TagProf: lib tests 38.0s (55%), integration 28.5s (41%), controllers 0.97s, jobs 0.53s, models 0.47s
+- EventProf: FeedFetcherTest 0.888s SQL in 34.3s total (2.6% SQL)
+
+## Relevant Patterns
+- TestProf before_all available but used in only 1 of 54 eligible files
+- Thread-based parallelism already proven in coverage mode
+- PG fork segfault only on single-file runs, NOT full suite
+
+## Risks
+- Thread safety: reset_configuration! may need thread-local config or mutex
+- Test isolation: splitting FeedFetcherTest must preserve test independence
+- before_all: only safe for tests that don't mutate shared data
+
+## Recommendations (by impact)
+1. Split FeedFetcherTest into 5-6 classes → enables parallelism, -50s
+2. Set config.log_level = :warn → -5-15s
+3. Tag/skip integration tests in dev → -30s dev experience
+4. Switch to thread-based parallelism → enables splitting benefit
+5. Adopt before_all in DB-heavy test files → -3-5s

data/.vbw-planning/phases/02-test-performance/.context-qa.md

@@ -0,0 +1,23 @@
+## Phase 02 Verification Context
+
+### Goal
+Not available
+
+### Success Criteria
+Not available
+
+### Requirements to Verify
+No matching requirements found
+
+### Codebase Map Available
+Codebase mapping exists in `.vbw-planning/codebase/`. Key files:
+- `ARCHITECTURE.md`
+- `CONCERNS.md`
+- `PATTERNS.md`
+- `DEPENDENCIES.md`
+- `STRUCTURE.md`
+- `CONVENTIONS.md`
+- `TESTING.md`
+- `STACK.md`
+
+Read TESTING.md, CONCERNS.md, and ARCHITECTURE.md first to bootstrap codebase understanding.

data/.vbw-planning/phases/02-test-performance/02-RESEARCH.md

@@ -0,0 +1,56 @@
+# Phase 2: Test Performance - Research
+
+## Investigation Method
+3-agent competing hypothesis team (H1: DB/parallelism, H2: HTTP/VCR, H3: test helpers)
+
+## Findings
+
+### Time Budget (133s total, 1031 tests)
+| Component | Time | % | Root Cause |
+|-----------|------|---|------------|
+| FeedFetcherTest (71 tests) | 84.8s | 64% | Monolithic class, CPU-bound (Feedjira parse, SHA256, content extraction) |
+| Integration tests (9 tests) | 30.8s | 23% | Subprocess spawning (bundle exec rails g) |
+| System tests (22 tests) | ~5s | 4% | Selenium/Chrome |
+| Debug log IO | 5-15s | 8% | 95MB :debug output to disk |
+| Everything else (~930 tests) | ~15s | 11% | Fast |
+
+### Why Parallelism Doesn't Help Today
+- Minitest distributes by CLASS, not by test
+- FeedFetcherTest = 1 class with 71 tests = 1 worker gets all 84.8s
+- With 8 workers: max(84.8, 25.6, ~3) ≈ 85s + overhead
+
+### DB Is NOT the Bottleneck
+- SQL: 3.639s of 69.4s (5.25%) via EventProf
+- schema.rb used (fast load)
+- Transactional tests enabled (proper rollback)
+
+### HTTP Mocking Is NOT the Bottleneck
+- Only 4 VCR cassettes (456KB total), 83 WebMock stubs across 9 files
+- WebMock configured once globally, auto-resets
+- Only finding: default_cert_store recreated per connection (~0.5s total)
+
+### Test Helpers Are Cheap
+- reset_configuration!: microseconds per call (pure Ruby)
+- create_source!: 1 INSERT per call, 158 calls total
+- with_inline_jobs: 4 calls total, negligible
+
+### Profiling Data (tmp/test_prof/)
+- TagProf: lib tests 38.0s (55%), integration 28.5s (41%), controllers 0.97s, jobs 0.53s, models 0.47s
+- EventProf: FeedFetcherTest 0.888s SQL in 34.3s total (2.6% SQL)
+
+## Relevant Patterns
+- TestProf before_all available but used in only 1 of 54 eligible files
+- Thread-based parallelism already proven in coverage mode
+- PG fork segfault only on single-file runs, NOT full suite
+
+## Risks
+- Thread safety: reset_configuration! may need thread-local config or mutex
+- Test isolation: splitting FeedFetcherTest must preserve test independence
+- before_all: only safe for tests that don't mutate shared data
+
+## Recommendations (by impact)
+1. Split FeedFetcherTest into 5-6 classes → enables parallelism, -50s
+2. Set config.log_level = :warn → -5-15s
+3. Tag/skip integration tests in dev → -30s dev experience
+4. Switch to thread-based parallelism → enables splitting benefit
+5. Adopt before_all in DB-heavy test files → -3-5s

data/.vbw-planning/phases/02-test-performance/02-VERIFICATION.md

@@ -0,0 +1,51 @@
+# Phase 02 Verification: Test Performance
+
+**Verdict: PASS**
+**Date:** 2026-02-18
+**Tier:** Deep
+
+## Requirements Verification
+
+| Requirement | Status | Evidence |
+|-------------|--------|----------|
+| REQ-PERF-01: FeedFetcherTest split into 5+ classes | PASS | 6 files created in test/lib/source_monitor/fetching/ (success, error_handling, adaptive_interval, retry_circuit, entry_processing, utilities) |
+| REQ-PERF-02: Test log level set to :warn | PASS | config.log_level = :warn in test/dummy/config/environments/test.rb |
+| REQ-PERF-03: Integration tests excludable | PASS | lib/tasks/test_fast.rake provides test:fast task (1022 tests vs 1033 full) |
+| REQ-PERF-04: Default parallelism switched to threads | PASS | parallelize(workers: worker_count, with: :threads) in test_helper.rb |
+| REQ-PERF-05: DB-heavy files use setup_once/before_all | PASS | 5 files now use setup_once (up from 1) |
+
+## Checks Performed
+
+### Structural Checks
+- [x] 6 split test files exist in test/lib/source_monitor/fetching/
+- [x] Original feed_fetcher_test.rb deleted
+- [x] Shared helper module exists (feed_fetcher_test_helper.rb)
+- [x] Each split file includes FeedFetcherTestHelper
+- [x] Test count preserved: 71 tests across 6 files (5+13+6+6+8+33)
+- [x] config.log_level = :warn present in test.rb
+- [x] lib/tasks/test_fast.rake exists and is valid Ruby
+- [x] parallelize uses with: :threads for all modes
+- [x] setup_once used in 5 files (sources_index_metrics, source_activity_rates, source_fetch_interval_distribution, upcoming_fetch_schedule, query_test)
+
+### Runtime Checks
+- [x] Full test suite: 1033 tests, 0 failures, 0 errors
+- [x] Single-file runs work without PARALLEL_WORKERS=1 (PG segfault eliminated)
+- [x] Each split file passes individually with PARALLEL_WORKERS=1
+- [x] test:fast runs 1022 tests (excludes 11 integration/system tests)
+- [x] Two consecutive full suite runs: 0 flaky failures
+
+### Quality Checks
+- [x] RuboCop: 0 offenses across all modified files
+- [x] Brakeman: 0 warnings
+- [x] No test isolation regressions
+
+### Commits
+- 912665f: perf(02-03): adopt setup_once/before_all in DB-heavy test files
+- a951c95: feat(02-01): split FeedFetcherTest into 6 concern-based test classes
+- edbfe23: perf(02-02): reduce test log IO and add test:fast rake task
+- eceb06d: perf(test): switch default parallelism from forks to threads
+
+## Notes
+
+- TestProf emits cosmetic warning "before_all is not implemented for parallalization with threads" — does not affect correctness. before_all/setup_once works correctly because single-file runs stay below parallelization threshold, and full suite distributes by class.
+- PLAN-02 deviated from plan: --exclude-pattern is not a Minitest feature, so Dir glob approach was used instead. Functionally equivalent.

data/.vbw-planning/phases/02-test-performance/PLAN-01-SUMMARY.md

@@ -0,0 +1,37 @@
+---
+status: complete
+phase: "02"
+plan: "01"
+title: "Split FeedFetcherTest into Concern-Based Classes"
+commits:
+  - hash: a951c95
+    message: "feat(02-01): split FeedFetcherTest into 6 concern-based test classes"
+tasks_completed: 4
+tasks_total: 4
+deviations: []
+---
+
+## What Was Built
+
+Split the monolithic `FeedFetcherTest` (71 tests, 1350 lines, single class) into 6 independent test classes plus a shared helper module. Each file is independently runnable with `PARALLEL_WORKERS=1`. All 1033 tests pass, RuboCop zero offenses.
+
+Test distribution:
+- `FeedFetcherSuccessTest`: 5 tests (RSS/Atom/JSON fetching, ETag/304, Netflix cassette)
+- `FeedFetcherErrorHandlingTest`: 13 tests (Faraday error wrapping, AIA resolution, failure recording)
+- `FeedFetcherAdaptiveIntervalTest`: 6 tests (interval increase/decrease, min/max bounds, disabled mode)
+- `FeedFetcherRetryCircuitTest`: 6 tests (retry state, circuit breaker, policy error handling)
+- `FeedFetcherEntryProcessingTest`: 8 tests (entry creation/update tracking, error normalization, digest fallbacks)
+- `FeedFetcherUtilitiesTest`: 33 tests (headers, jitter, metadata, signature, config helpers, parsing)
+
+## Files Modified
+
+| Action | Path |
+|--------|------|
+| CREATE | `test/lib/source_monitor/fetching/feed_fetcher_test_helper.rb` |
+| CREATE | `test/lib/source_monitor/fetching/feed_fetcher_success_test.rb` |
+| CREATE | `test/lib/source_monitor/fetching/feed_fetcher_error_handling_test.rb` |
+| CREATE | `test/lib/source_monitor/fetching/feed_fetcher_adaptive_interval_test.rb` |
+| CREATE | `test/lib/source_monitor/fetching/feed_fetcher_retry_circuit_test.rb` |
+| CREATE | `test/lib/source_monitor/fetching/feed_fetcher_entry_processing_test.rb` |
+| CREATE | `test/lib/source_monitor/fetching/feed_fetcher_utilities_test.rb` |
+| DELETE | `test/lib/source_monitor/fetching/feed_fetcher_test.rb` |