source_monitor 0.6.0 → 0.7.1

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` |

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

@@ -0,0 +1,156 @@
+---
+phase: "02"
+plan: "01"
+title: "Split FeedFetcherTest into Concern-Based Classes"
+wave: 1
+depends_on: []
+must_haves:
+  - "REQ-PERF-01: FeedFetcherTest split into 6+ independent test files by concern"
+  - "Original feed_fetcher_test.rb deleted or replaced with require-only shim"
+  - "Each new test file is independently runnable with PARALLEL_WORKERS=1"
+  - "All 71 FeedFetcherTest tests pass individually and in full suite"
+  - "Shared build_source and body_digest helpers extracted to shared module"
+  - "RuboCop zero offenses on all new/modified test files"
+skills_used: []
+---
+
+# Plan 01: Split FeedFetcherTest into Concern-Based Classes
+
+## Objective
+
+Split the monolithic `FeedFetcherTest` (71 tests, 84.8s, 64% of total runtime) into 6+ smaller test classes by concern. This is the single highest-impact optimization: Minitest parallelizes by class, so one 71-test class gets assigned to one worker. Splitting enables parallel distribution across all CPU cores.
+
+## Context
+
+- `@` `test/lib/source_monitor/fetching/feed_fetcher_test.rb` -- 1350-line monolithic test class (the file to split)
+- `@` `test/test_helper.rb` -- base test setup with `create_source!` and `clean_source_monitor_tables!`
+- `@` `test/test_prof.rb` -- TestProf `before_all` and `setup_once` support
+
+**Rationale:** The test file already has section comments (Task 1-6) that map to concern groups. The `build_source` and `body_digest` private helpers are shared across all tests and must be extracted to a module.
+
+## Tasks
+
+### Task 1: Create shared helper module for FeedFetcher tests
+
+Create `test/lib/source_monitor/fetching/feed_fetcher_test_helper.rb`:
+
+```ruby
+# frozen_string_literal: true
+
+module SourceMonitor
+  module Fetching
+    module FeedFetcherTestHelper
+      private
+
+      def build_source(name:, feed_url:, fetch_interval_minutes: 360, adaptive_fetching_enabled: true)
+        create_source!(
+          name: name,
+          feed_url: feed_url,
+          fetch_interval_minutes: fetch_interval_minutes,
+          adaptive_fetching_enabled: adaptive_fetching_enabled
+        )
+      end
+
+      def body_digest(body)
+        Digest::SHA256.hexdigest(body)
+      end
+    end
+  end
+end
+```
+
+### Task 2: Create the 6 split test files
+
+Split the 71 tests into these files, each requiring `test_helper` and `feed_fetcher_test_helper`:
+
+1. **`feed_fetcher_success_test.rb`** (~13 tests) -- Success paths: RSS/Atom/JSON fetching, log entries, instrumentation notifications, ETag/304 handling, Netflix cassette test. Tests: "continues processing when an item creation fails", "fetches an RSS feed and records log entries", "reuses etag and handles 304", "parses rss atom and json feeds via feedjira", "fetches Netflix Tech Blog feed via Medium RSS".
+
+2. **`feed_fetcher_error_handling_test.rb`** (~12 tests) -- Error wrapping and connection failures: all Faraday error type wrapping, AIA certificate resolution tests (retry on SSL, nil resolve, non-SSL skip), generic Faraday::Error, unexpected StandardError, HTTPError from ClientError, re-raise without double-wrap. Tests from "Task 2" section plus AIA tests.
+
+3. **`feed_fetcher_adaptive_interval_test.rb`** (~8 tests) -- Adaptive fetch interval: decrease on content change, increase on no change, configured settings, min/max bounds, failure increase with backoff, disabled adaptive fetching. Tests from the interval section.
+
+4. **`feed_fetcher_retry_circuit_test.rb`** (~7 tests) -- Retry strategy and circuit breaker: reset on success, reset on 304, apply retry state, circuit open when exhausted, next_fetch_at earliest logic, policy error handling. Tests from "Task 1" section.
+
+5. **`feed_fetcher_entry_processing_test.rb`** (~7 tests) -- Entry processing: empty entries, error normalization (with guid, without guid), created/updated tracking, unchanged items, entries_digest fallback (url, title), failure result empty processing. Tests from "Task 4" section plus "process_feed_entries tracks created and updated" and "unchanged items".
+
+6. **`feed_fetcher_utilities_test.rb`** (~16 tests) -- Utility methods: jitter_offset, adjusted_interval_with_jitter, body_digest, updated_metadata, feed_signature_changed?, configured_seconds, configured_positive, configured_non_negative, interval_minutes_for, parse_http_time, extract_numeric. Tests from "Task 5" section plus "Task 3" header tests (If-Modified-Since, custom_headers, ETag update, Last-Modified update/304/unparseable).
+
+Each file follows this pattern:
+```ruby
+# frozen_string_literal: true
+
+require "test_helper"
+require "faraday"
+require "uri"
+require "digest"
+require_relative "feed_fetcher_test_helper"
+
+module SourceMonitor
+  module Fetching
+    class FeedFetcherSuccessTest < ActiveSupport::TestCase
+      include FeedFetcherTestHelper
+      # tests here...
+    end
+  end
+end
+```
+
+### Task 3: Delete original feed_fetcher_test.rb
+
+After all 6 new files are created and verified, delete the original `test/lib/source_monitor/fetching/feed_fetcher_test.rb`. Do NOT keep a shim -- the new files are self-contained.
+
+### Task 4: Verify all tests pass and lint clean
+
+Run verification:
+```bash
+# Run each new file individually
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/fetching/feed_fetcher_success_test.rb
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/fetching/feed_fetcher_error_handling_test.rb
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/fetching/feed_fetcher_adaptive_interval_test.rb
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/fetching/feed_fetcher_retry_circuit_test.rb
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/fetching/feed_fetcher_entry_processing_test.rb
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/fetching/feed_fetcher_utilities_test.rb
+
+# Full suite
+bin/rails test
+
+# Lint
+bin/rubocop test/lib/source_monitor/fetching/
+```
+
+Ensure the total test count remains 1031+ (no tests lost or duplicated).
+
+## Files
+
+| 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` |
+
+## Verification
+
+```bash
+# Individual file runs (PARALLEL_WORKERS=1 due to PG fork segfault on single files)
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/fetching/feed_fetcher_success_test.rb
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/fetching/feed_fetcher_utilities_test.rb
+
+# Full suite (all 1031+ tests pass)
+bin/rails test
+
+# Lint
+bin/rubocop test/lib/source_monitor/fetching/
+```
+
+## Success Criteria
+
+- 6+ new test files exist in `test/lib/source_monitor/fetching/`
+- Original `feed_fetcher_test.rb` deleted
+- `grep -c "class Feed" test/lib/source_monitor/fetching/*_test.rb` shows 6+ classes
+- All 1031+ tests pass in full suite
+- Each file runnable independently with PARALLEL_WORKERS=1

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

@@ -0,0 +1,33 @@
+---
+plan: "02"
+phase: "02"
+title: "Log Level Reduction and Integration Test Tagging"
+status: complete
+commits:
+  - hash: edbfe23
+    message: "perf(02-02): reduce test log IO and add test:fast rake task"
+tasks_completed: 4
+tasks_total: 4
+files_modified:
+  - test/dummy/config/environments/test.rb
+files_created:
+  - lib/tasks/test_fast.rake
+---
+
+## What Was Built
+
+- Set `config.log_level = :warn` in test environment to eliminate ~95MB of debug log IO per test run
+- Created `lib/tasks/test_fast.rake` providing `test:fast` rake task that excludes integration/ and system/ directories
+- Verified all 4 integration test files already in `test/integration/` (no moves needed)
+- Full suite: 1033 runs, 0 failures; Fast mode: 1022 runs, 0 failures
+
+## Files Modified
+
+- `test/dummy/config/environments/test.rb` — added `config.log_level = :warn` after `config.cache_store = :null_store`
+- `lib/tasks/test_fast.rake` — new rake task `test:fast` using Dir glob to exclude integration and system test files
+
+## Deviations
+
+- Plan specified `--exclude-pattern` flag for minitest but this flag does not exist in Rails/Minitest. Replaced with Dir glob approach that rejects `test/integration/` and `test/system/` paths (DEVN-01 Minor).
+- Also excluded `test/system/` from fast mode since `bin/rails test` already excludes system tests by default — this makes `test:fast` equivalent to `bin/rails test` minus integration tests.
+- Rake task accessible as `bundle exec rake app:test:fast` from engine root (engine prefixes with `app:`).

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

@@ -0,0 +1,120 @@
+---
+phase: "02"
+plan: "02"
+title: "Log Level Reduction and Integration Test Tagging"
+wave: 1
+depends_on: []
+must_haves:
+  - "REQ-PERF-02: config.log_level = :warn in test/dummy/config/environments/test.rb"
+  - "REQ-PERF-03: Integration tests tagged so --exclude-pattern can skip them"
+  - "host_install_flow_test.rb and release_packaging_test.rb moved under test/integration/"
+  - "bin/rails test --exclude-pattern='**/integration/**' excludes slow integration tests"
+  - "bin/rails test runs all tests including integration (default behavior preserved)"
+  - "RuboCop zero offenses on modified files"
+skills_used: []
+---
+
+# Plan 02: Log Level Reduction and Integration Test Tagging
+
+## Objective
+
+Two quick wins that reduce test wall-clock time: (1) eliminate 95MB of debug log IO by setting test log level to `:warn` (saves 5-15s), and (2) ensure integration tests are organized under `test/integration/` so developers can exclude the 31s of subprocess-spawning tests during iterative development using `--exclude-pattern`.
+
+## Context
+
+- `@` `test/dummy/config/environments/test.rb` -- currently has no explicit log_level (defaults to :debug)
+- `@` `test/integration/host_install_flow_test.rb` -- slow integration test (subprocess spawning, ~15s)
+- `@` `test/integration/release_packaging_test.rb` -- slow integration test (gem build + subprocess, ~15s)
+- `@` `test/integration/engine_mounting_test.rb` -- fast integration test (route checks)
+- `@` `test/integration/navigation_test.rb` -- empty placeholder test
+- `@` `test/test_helper.rb` -- contains DEFAULT_TEST_EXCLUDE but does NOT need modification
+
+**Rationale:** The research found 95MB of :debug log output during tests. Setting :warn eliminates this IO without losing any test coverage. Integration tests already live under `test/integration/` -- we just need to verify the exclude pattern works and document it.
+
+## Tasks
+
+### Task 1: Set test log level to :warn
+
+In `test/dummy/config/environments/test.rb`, add after the `config.cache_store = :null_store` line:
+
+```ruby
+# Reduce log IO in tests -- :debug generates ~95MB of output.
+config.log_level = :warn
+```
+
+This is a single-line addition. The research confirmed this saves 5-15s per run by eliminating disk IO for debug/info log messages.
+
+### Task 2: Verify integration test directory organization
+
+Confirm all 4 integration test files are properly under `test/integration/`:
+- `test/integration/host_install_flow_test.rb` (slow -- subprocess spawning)
+- `test/integration/release_packaging_test.rb` (slow -- gem build)
+- `test/integration/engine_mounting_test.rb` (fast -- route assertions)
+- `test/integration/navigation_test.rb` (empty placeholder)
+
+No file moves needed -- they are already in the correct location. The `--exclude-pattern` flag works with glob patterns on the file path.
+
+### Task 3: Add Rake task for fast test runs
+
+Create `lib/tasks/test_fast.rake` with a convenience task:
+
+```ruby
+# frozen_string_literal: true
+
+namespace :test do
+  desc "Run tests excluding slow integration tests"
+  task fast: :environment do
+    $stdout.puts "Running tests excluding integration/ directory..."
+    system(
+      "bin/rails", "test",
+      "--exclude-pattern", "**/integration/**",
+      exception: true
+    )
+  end
+end
+```
+
+This provides `bin/rails test:fast` as a developer convenience that excludes the integration directory.
+
+### Task 4: Verify both test modes work
+
+Run verification:
+```bash
+# Full suite (all tests including integration)
+bin/rails test
+
+# Fast mode (excluding integration)
+bin/rails test --exclude-pattern="**/integration/**"
+
+# Lint modified files
+bin/rubocop test/dummy/config/environments/test.rb lib/tasks/test_fast.rake
+```
+
+Verify the fast mode excludes the integration tests and completes significantly faster.
+
+## Files
+
+| Action | Path |
+|--------|------|
+| MODIFY | `test/dummy/config/environments/test.rb` |
+| CREATE | `lib/tasks/test_fast.rake` |
+
+## Verification
+
+```bash
+# Full suite passes
+bin/rails test
+
+# Exclude pattern works (fewer tests, no integration)
+bin/rails test --exclude-pattern="**/integration/**"
+
+# Lint
+bin/rubocop test/dummy/config/environments/test.rb lib/tasks/test_fast.rake
+```
+
+## Success Criteria
+
+- `grep "log_level" test/dummy/config/environments/test.rb` shows `:warn`
+- `bin/rails test` runs all 1031+ tests (no regressions)
+- `bin/rails test --exclude-pattern="**/integration/**"` runs successfully with fewer tests
+- `lib/tasks/test_fast.rake` exists and is syntactically valid

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

@@ -0,0 +1,30 @@
+---
+phase: 2
+plan: 3
+status: complete
+---
+# Plan 03 Summary: Adopt before_all in DB-Heavy Test Files
+
+## Tasks Completed
+- [x] Task 1: Convert sources_index_metrics_test.rb to setup_once (17 read-only tests)
+- [x] Task 2: Convert 3 single-test files to setup_once for consistency
+- [x] Task 3: Verify all converted files individually (PARALLEL_WORKERS=1)
+- [x] Task 4: Full suite verification (1033 tests, 0 failures) and lint (0 offenses)
+
+## Commits
+- 912665f: perf(02-03): adopt setup_once/before_all in DB-heavy test files
+
+## Files Modified
+- test/lib/source_monitor/analytics/sources_index_metrics_test.rb (modified)
+- test/lib/source_monitor/analytics/source_activity_rates_test.rb (modified)
+- test/lib/source_monitor/analytics/source_fetch_interval_distribution_test.rb (modified)
+- test/lib/source_monitor/dashboard/upcoming_fetch_schedule_test.rb (modified)
+
+## What Was Built
+- Converted `sources_index_metrics_test.rb` from per-test setup to `setup_once` for shared fixture creation (3 sources + 3 items), following the reference pattern from `query_test.rb` (store IDs in setup_once, re-find records in per-test setup)
+- Kept `travel_to`/`travel_back` in regular setup/teardown for thread-local time safety
+- Converted 3 single-test files to `setup_once` for `clean_source_monitor_tables!` (functionally identical for single-test classes but normalizes the pattern)
+- `setup_once` usage increased from 1 file to 5 files across the test suite
+
+## Deviations
+- None