source_monitor 0.3.0 → 0.3.2

data/.claude/skills/sm-configure/reference/configuration-reference.md

@@ -0,0 +1,321 @@
+# Configuration Reference
+
+Complete reference for every SourceMonitor configuration setting.
+
+Source: `lib/source_monitor/configuration.rb` and `lib/source_monitor/configuration/*.rb`
+
+## Top-Level Settings
+
+Defined on `SourceMonitor::Configuration`:
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `queue_namespace` | String | `"source_monitor"` | Prefix for queue names and instrumentation keys |
+| `fetch_queue_name` | String | `"source_monitor_fetch"` | Queue name for fetch jobs |
+| `scrape_queue_name` | String | `"source_monitor_scrape"` | Queue name for scrape jobs |
+| `fetch_queue_concurrency` | Integer | `2` | Advisory concurrency for fetch queue |
+| `scrape_queue_concurrency` | Integer | `2` | Advisory concurrency for scrape queue |
+| `recurring_command_job_class` | String/Class/nil | `nil` | Override Solid Queue recurring task job class |
+| `job_metrics_enabled` | Boolean | `true` | Toggle queue metrics on dashboard |
+| `mission_control_enabled` | Boolean | `false` | Show Mission Control link on dashboard |
+| `mission_control_dashboard_path` | String/Proc/nil | `nil` | Path or callable returning MC URL |
+
+### Methods
+
+| Method | Signature | Description |
+|---|---|---|
+| `queue_name_for` | `(role) -> String` | Returns resolved queue name with host prefix |
+| `concurrency_for` | `(role) -> Integer` | Returns concurrency for `:fetch` or `:scrape` |
+
+---
+
+## HTTP Settings (`config.http`)
+
+Class: `SourceMonitor::Configuration::HTTPSettings`
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `timeout` | Integer | `15` | Total request timeout (seconds) |
+| `open_timeout` | Integer | `5` | Connection open timeout (seconds) |
+| `max_redirects` | Integer | `5` | Maximum redirects to follow |
+| `user_agent` | String | `"SourceMonitor/<version>"` | User-Agent header |
+| `proxy` | String/Hash/nil | `nil` | HTTP proxy configuration |
+| `headers` | Hash | `{}` | Extra headers merged into every request |
+| `retry_max` | Integer | `4` | Maximum retry attempts |
+| `retry_interval` | Float | `0.5` | Initial retry delay (seconds) |
+| `retry_interval_randomness` | Float | `0.5` | Randomness factor for retry jitter |
+| `retry_backoff_factor` | Integer | `2` | Exponential backoff multiplier |
+| `retry_statuses` | Array/nil | `nil` | HTTP status codes to retry (nil = use defaults) |
+
+```ruby
+config.http.timeout = 30
+config.http.proxy = "http://proxy.example.com:8080"
+config.http.headers = { "X-Custom" => "value" }
+config.http.retry_statuses = [429, 500, 502, 503, 504]
+```
+
+---
+
+## Fetching Settings (`config.fetching`)
+
+Class: `SourceMonitor::Configuration::FetchingSettings`
+
+Controls adaptive fetch scheduling.
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `min_interval_minutes` | Integer | `5` | Minimum fetch interval (minutes) |
+| `max_interval_minutes` | Integer | `1440` | Maximum fetch interval (24 hours) |
+| `increase_factor` | Float | `1.25` | Multiplier when source trends slow (no new items) |
+| `decrease_factor` | Float | `0.75` | Multiplier when new items arrive |
+| `failure_increase_factor` | Float | `1.5` | Multiplier on consecutive failures |
+| `jitter_percent` | Float | `0.1` | Random jitter (+/-10%, 0 disables) |
+
+```ruby
+config.fetching.min_interval_minutes = 10
+config.fetching.max_interval_minutes = 720  # 12 hours
+config.fetching.jitter_percent = 0.15       # +/-15%
+```
+
+---
+
+## Health Settings (`config.health`)
+
+Class: `SourceMonitor::Configuration::HealthSettings`
+
+Tunes automatic pause/resume heuristics per source.
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `window_size` | Integer | `20` | Number of fetch attempts to evaluate |
+| `healthy_threshold` | Float | `0.8` | Success ratio for "healthy" badge |
+| `warning_threshold` | Float | `0.5` | Success ratio for "warning" badge |
+| `auto_pause_threshold` | Float | `0.2` | Auto-pause source below this ratio |
+| `auto_resume_threshold` | Float | `0.6` | Auto-resume source above this ratio |
+| `auto_pause_cooldown_minutes` | Integer | `60` | Grace period before re-enabling |
+
+```ruby
+config.health.window_size = 50
+config.health.auto_pause_threshold = 0.1
+config.health.auto_pause_cooldown_minutes = 120
+```
+
+---
+
+## Scraper Registry (`config.scrapers`)
+
+Class: `SourceMonitor::Configuration::ScraperRegistry`
+
+Manages scraper adapter registration. Adapters must inherit from `SourceMonitor::Scrapers::Base`.
+
+### Methods
+
+| Method | Signature | Description |
+|---|---|---|
+| `register` | `(name, adapter)` | Register adapter by name (symbol/string) |
+| `unregister` | `(name)` | Remove adapter by name |
+| `adapter_for` | `(name) -> Class/nil` | Look up adapter class |
+| `each` | `(&block)` | Iterate registered adapters |
+
+Names are normalized to lowercase alphanumeric + underscore.
+
+Adapters can be a Class or a String (constantized lazily).
+
+```ruby
+config.scrapers.register(:custom, MyApp::Scrapers::Custom)
+config.scrapers.register(:premium, "MyApp::Scrapers::Premium")
+config.scrapers.unregister(:readability)
+```
+
+---
+
+## Retention Settings (`config.retention`)
+
+Class: `SourceMonitor::Configuration::RetentionSettings`
+
+Global defaults inherited by sources with blank retention fields.
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `items_retention_days` | Integer/nil | `nil` | Prune items older than N days (nil = keep forever) |
+| `max_items` | Integer/nil | `nil` | Keep only N most recent items (nil = unlimited) |
+| `strategy` | Symbol | `:destroy` | Pruning strategy: `:destroy` or `:soft_delete` |
+
+```ruby
+config.retention.items_retention_days = 90
+config.retention.max_items = 1000
+config.retention.strategy = :soft_delete
+```
+
+---
+
+## Scraping Settings (`config.scraping`)
+
+Class: `SourceMonitor::Configuration::ScrapingSettings`
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `max_in_flight_per_source` | Integer/nil | `25` | Max concurrent scrapes per source |
+| `max_bulk_batch_size` | Integer/nil | `100` | Max items per bulk scrape enqueue |
+
+Values are normalized to positive integers. Set to `nil` to disable limits.
+
+```ruby
+config.scraping.max_in_flight_per_source = 50
+config.scraping.max_bulk_batch_size = 200
+```
+
+---
+
+## Events (`config.events`)
+
+Class: `SourceMonitor::Configuration::Events`
+
+Register lifecycle callbacks. See the `sm-event-handler` skill for full event documentation.
+
+### Callback Methods
+
+| Method | Signature | Description |
+|---|---|---|
+| `after_item_created` | `(handler=nil, &block)` | Called after a new item is created from a feed entry |
+| `after_item_scraped` | `(handler=nil, &block)` | Called after an item is scraped for content |
+| `after_fetch_completed` | `(handler=nil, &block)` | Called after a feed fetch finishes |
+| `register_item_processor` | `(processor=nil, &block)` | Register a post-processing pipeline step |
+| `callbacks_for` | `(name) -> Array` | Retrieve callbacks for an event |
+| `item_processors` | `-> Array` | Retrieve registered item processors |
+| `reset!` | `-> void` | Clear all callbacks and processors |
+
+Handlers must respond to `#call`. Can be a Proc, lambda, or any callable object.
+
+```ruby
+config.events.after_item_created ->(event) { log(event.item) }
+config.events.after_fetch_completed do |event|
+  StatsTracker.record(event.source, event.status)
+end
+```
+
+---
+
+## Models (`config.models`)
+
+Class: `SourceMonitor::Configuration::Models`
+
+Per-model extension points for host apps.
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `table_name_prefix` | String | `"sourcemon_"` | Table name prefix for all engine tables |
+
+### Model Accessors
+
+| Method | Key | Engine Model |
+|---|---|---|
+| `config.models.source` | `:source` | `SourceMonitor::Source` |
+| `config.models.item` | `:item` | `SourceMonitor::Item` |
+| `config.models.fetch_log` | `:fetch_log` | `SourceMonitor::FetchLog` |
+| `config.models.scrape_log` | `:scrape_log` | `SourceMonitor::ScrapeLog` |
+| `config.models.health_check_log` | `:health_check_log` | `SourceMonitor::HealthCheckLog` |
+| `config.models.item_content` | `:item_content` | `SourceMonitor::ItemContent` |
+| `config.models.log_entry` | `:log_entry` | `SourceMonitor::LogEntry` |
+
+Each accessor returns a `ModelDefinition` with:
+
+| Method | Signature | Description |
+|---|---|---|
+| `include_concern` | `(concern=nil, &block)` | Include a concern module |
+| `validate` | `(handler=nil, **options, &block)` | Register a validation |
+
+```ruby
+config.models.table_name_prefix = "sm_"
+config.models.source.include_concern "MyApp::SourceTagging"
+config.models.item.validate :check_content_length
+```
+
+---
+
+## Realtime Settings (`config.realtime`)
+
+Class: `SourceMonitor::Configuration::RealtimeSettings`
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `adapter` | Symbol | `:solid_cable` | One of `:solid_cable`, `:redis`, `:async` |
+| `redis_url` | String/nil | `nil` | Redis URL when using `:redis` adapter |
+
+### Solid Cable Options (`config.realtime.solid_cable`)
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `polling_interval` | String | `"0.1.seconds"` | Polling frequency |
+| `message_retention` | String | `"1.day"` | How long to retain messages |
+| `autotrim` | Boolean | `true` | Auto-trim old messages |
+| `silence_polling` | Boolean | `true` | Suppress polling log noise |
+| `use_skip_locked` | Boolean | `true` | Use PostgreSQL SKIP LOCKED |
+| `trim_batch_size` | Integer/nil | `nil` | Batch size for trim operations |
+| `connects_to` | Hash/nil | `nil` | Multi-database routing |
+
+### Methods
+
+| Method | Returns | Description |
+|---|---|---|
+| `action_cable_config` | Hash | Full configuration hash for cable.yml |
+
+```ruby
+config.realtime.adapter = :redis
+config.realtime.redis_url = "redis://localhost:6379/1"
+
+# Or with Solid Cable tuning:
+config.realtime.adapter = :solid_cable
+config.realtime.solid_cable.polling_interval = "0.05.seconds"
+config.realtime.solid_cable.connects_to = { database: { writing: :cable } }
+```
+
+---
+
+## Authentication Settings (`config.authentication`)
+
+Class: `SourceMonitor::Configuration::AuthenticationSettings`
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `current_user_method` | Symbol/nil | `nil` | Controller method to get current user |
+| `user_signed_in_method` | Symbol/nil | `nil` | Controller method to check sign-in status |
+
+### Methods
+
+| Method | Signature | Description |
+|---|---|---|
+| `authenticate_with` | `(handler=nil, &block)` | Set authentication handler |
+| `authorize_with` | `(handler=nil, &block)` | Set authorization handler |
+
+Handlers can be:
+- **Symbol**: Invoked as `controller.public_send(handler)`
+- **Callable**: Called with `callable.call(controller)` (or `instance_exec` if arity is 0)
+
+```ruby
+# Symbol handler (Devise)
+config.authentication.authenticate_with :authenticate_user!
+
+# Callable handler
+config.authentication.authorize_with ->(controller) {
+  controller.current_user&.feature_enabled?(:source_monitor)
+}
+
+# Block handler (instance_exec on controller)
+config.authentication.authorize_with do
+  redirect_to root_path unless current_user&.admin?
+end
+```
+
+---
+
+## Environment Variables
+
+| Variable | Purpose |
+|---|---|
+| `SOLID_QUEUE_SKIP_RECURRING` | Skip loading `config/recurring.yml` |
+| `SOLID_QUEUE_RECURRING_SCHEDULE_FILE` | Alternative schedule file path |
+| `SOFT_DELETE` | Override retention strategy in rake tasks |
+| `SOURCE_IDS` / `SOURCE_ID` | Scope cleanup rake tasks to specific sources |
+| `FETCH_LOG_DAYS` / `SCRAPE_LOG_DAYS` | Retention windows for log cleanup |
+| `SOURCE_MONITOR_SETUP_TELEMETRY` | Enable setup verification telemetry logging |

data/.claude/skills/sm-dashboard-widget/SKILL.md

@@ -0,0 +1,344 @@
+---
+name: sm-dashboard-widget
+description: Creates dashboard widgets with queries, presenters, and Turbo broadcasts for Source Monitor. Use when building dashboard metrics, stats panels, or real-time monitoring displays.
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+disable-model-invocation: true
+---
+
+# SourceMonitor Dashboard Widget
+
+## Overview
+
+The SourceMonitor dashboard lives at `DashboardController#index` and is composed of widgets: stat cards, recent activity feeds, job queue metrics, fetch schedules, and quick actions. Each widget follows a query-presenter-view pattern with optional Turbo Stream broadcasting for real-time updates.
+
+## Architecture
+
+```
+Controller (app/controllers/source_monitor/dashboard_controller.rb)
+  |
+  v
+Queries (lib/source_monitor/dashboard/queries.rb)        -- facade
+  |-- StatsQuery           -- single SQL for source counts + item/fetch totals
+  |-- RecentActivityQuery  -- UNION ALL across fetch_logs, scrape_logs, items
+  |-- UpcomingFetchSchedule -- groups active sources into time-window buckets
+  |-- job_metrics           -- delegates to Jobs::SolidQueueMetrics
+  |-- quick_actions         -- static QuickAction structs
+  |
+  v
+Presenters
+  |-- RecentActivityPresenter  -- maps Event structs to view-model hashes
+  |-- QuickActionsPresenter    -- maps QuickAction structs to path-resolved hashes
+  |
+  v
+Views (app/views/source_monitor/dashboard/)
+  |-- index.html.erb           -- layout shell with turbo_stream_from
+  |-- _stats.html.erb          -- grid of stat cards
+  |-- _stat_card.html.erb      -- single stat card partial (collection render)
+  |-- _recent_activity.html.erb
+  |-- _fetch_schedule.html.erb
+  |-- _job_metrics.html.erb
+  |
+  v
+TurboBroadcaster (lib/source_monitor/dashboard/turbo_broadcaster.rb)
+  |-- registers event callbacks (after_fetch_completed, after_item_created)
+  |-- broadcasts replace_to for stats, recent_activity, fetch_schedule
+```
+
+## Creating a New Dashboard Widget
+
+### Step 1: Define the Query
+
+Create a query class under `lib/source_monitor/dashboard/queries/`. Follow the existing pattern:
+
+```ruby
+# frozen_string_literal: true
+
+module SourceMonitor
+  module Dashboard
+    class Queries
+      class MyWidgetQuery
+        def initialize(reference_time:)
+          @reference_time = reference_time
+        end
+
+        def call
+          # Return a hash, array of structs, or value object
+          {
+            metric_a: compute_metric_a,
+            metric_b: compute_metric_b
+          }
+        end
+
+        private
+
+        attr_reader :reference_time
+
+        def compute_metric_a
+          # Use quoted_table_name for SQL safety
+          SourceMonitor::Source.connection.select_value(<<~SQL.squish).to_i
+            SELECT COUNT(*)
+            FROM #{SourceMonitor::Source.quoted_table_name}
+            WHERE some_condition
+          SQL
+        end
+
+        def compute_metric_b
+          SourceMonitor::Item.where("created_at >= ?", reference_time.beginning_of_day).count
+        end
+      end
+    end
+  end
+end
+```
+
+Key patterns:
+- Constructor takes `reference_time:` for time-relative queries
+- `call` returns the result (hash, array, or value object)
+- Use `quoted_table_name` for all SQL references
+- Use `connection.exec_query` for multi-column results
+- Use `connection.select_value` for single scalar values
+- Use ActiveRecord scopes when raw SQL is not needed
+
+### Step 2: Register in the Queries Facade
+
+Add a method in `lib/source_monitor/dashboard/queries.rb`:
+
+```ruby
+def my_widget
+  cache.fetch(:my_widget) do
+    measure(:my_widget) do
+      MyWidgetQuery.new(reference_time:).call
+    end
+  end
+end
+```
+
+The `cache` prevents duplicate computation within a single request. The `measure` wrapper:
+1. Records timing via `ActiveSupport::Notifications.instrument`
+2. Publishes gauge metrics via `SourceMonitor::Metrics.gauge`
+
+Add a require at the top of the file:
+```ruby
+require "source_monitor/dashboard/queries/my_widget_query"
+```
+
+### Step 3: Create a Presenter (if needed)
+
+Presenters live in `lib/source_monitor/dashboard/`. They transform query results into view-friendly hashes, resolving route paths using `url_helpers`.
+
+```ruby
+# frozen_string_literal: true
+
+module SourceMonitor
+  module Dashboard
+    class MyWidgetPresenter
+      def initialize(data, url_helpers:)
+        @data = data
+        @url_helpers = url_helpers
+      end
+
+      def to_a
+        data.map { |item| build_view_model(item) }
+      end
+
+      private
+
+      attr_reader :data, :url_helpers
+
+      def build_view_model(item)
+        {
+          label: item.name,
+          value: item.count,
+          path: url_helpers.source_path(item.source_id)
+        }
+      end
+    end
+  end
+end
+```
+
+Presenter conventions:
+- Constructor takes raw data + `url_helpers:` keyword
+- `to_a` returns array of plain hashes for the view
+- `url_helpers` comes from `SourceMonitor::Engine.routes.url_helpers`
+
+### Step 4: Wire into the Controller
+
+In `app/controllers/source_monitor/dashboard_controller.rb`:
+
+```ruby
+def index
+  queries = SourceMonitor::Dashboard::Queries.new
+  url_helpers = SourceMonitor::Engine.routes.url_helpers
+
+  # existing assigns...
+  @my_widget = MyWidgetPresenter.new(queries.my_widget, url_helpers:).to_a
+end
+```
+
+### Step 5: Create the View Partial
+
+Create `app/views/source_monitor/dashboard/_my_widget.html.erb`:
+
+```erb
+<div id="source_monitor_dashboard_my_widget" class="rounded-lg border border-slate-200 bg-white shadow-sm">
+  <div class="border-b border-slate-200 px-5 py-4">
+    <h2 class="text-lg font-medium">My Widget</h2>
+    <p class="mt-1 text-xs text-slate-500">Description of what this widget shows.</p>
+  </div>
+  <div class="divide-y divide-slate-100">
+    <%% if my_widget.any? %>
+      <%% my_widget.each do |item| %>
+        <div class="flex items-center justify-between px-5 py-4">
+          <div class="text-sm font-medium text-slate-900"><%%= item[:label] %></div>
+          <div class="text-sm text-slate-600"><%%= item[:value] %></div>
+        </div>
+      <%% end %>
+    <%% else %>
+      <div class="px-5 py-6 text-sm text-slate-500">No data available.</div>
+    <%% end %>
+  </div>
+</div>
+```
+
+Important: The outer div must have an `id` prefixed with `source_monitor_dashboard_` for Turbo Stream targeting.
+
+Render in `index.html.erb`:
+```erb
+<%%= render "my_widget", my_widget: @my_widget %>
+```
+
+### Step 6: Add Turbo Stream Broadcasting (optional)
+
+In `lib/source_monitor/dashboard/turbo_broadcaster.rb`, add a broadcast call inside `broadcast_dashboard_updates`:
+
+```ruby
+Turbo::StreamsChannel.broadcast_replace_to(
+  STREAM_NAME,
+  target: "source_monitor_dashboard_my_widget",
+  html: render_partial(
+    "source_monitor/dashboard/my_widget",
+    my_widget: MyWidgetPresenter.new(
+      queries.my_widget,
+      url_helpers:
+    ).to_a
+  )
+)
+```
+
+The broadcaster is triggered by event callbacks registered in `setup!`. Existing triggers:
+- `after_fetch_completed` -- fires after each feed fetch
+- `after_item_created` -- fires when a new item is persisted
+
+To add a new trigger, register another callback:
+```ruby
+register_callback(:after_scrape_completed, scrape_callback)
+```
+
+### Step 7: Add Metrics Recording
+
+In the `record_metrics` method of `queries.rb`, add a case for your widget:
+
+```ruby
+when :my_widget
+  SourceMonitor::Metrics.gauge(:dashboard_my_widget_count, result.size)
+```
+
+## Existing Widget Reference
+
+### Stat Cards
+- Query: `StatsQuery` returns `{ total_sources:, active_sources:, failed_sources:, total_items:, fetches_today: }`
+- View: `_stats.html.erb` renders `_stat_card.html.erb` as a collection
+- Turbo target: `source_monitor_dashboard_stats`
+
+### Recent Activity
+- Query: `RecentActivityQuery` uses UNION ALL across fetch_logs, scrape_logs, items
+- Struct: `RecentActivity::Event` (keyword_init Struct)
+- Presenter: `RecentActivityPresenter` maps events to `{ label:, description:, status:, type:, time:, path: }`
+- View: `_recent_activity.html.erb`
+- Turbo target: `source_monitor_dashboard_recent_activity`
+
+### Job Metrics
+- Query: `job_metrics` delegates to `Jobs::SolidQueueMetrics.call`
+- Returns array of `{ role:, queue_name:, summary: }` hashes
+- View: `_job_metrics.html.erb`
+- No Turbo broadcasting (refreshed on page load)
+
+### Fetch Schedule
+- Query: `UpcomingFetchSchedule` groups sources into time-window buckets
+- Struct: `UpcomingFetchSchedule::Group` with `:key, :label, :sources, :window_start, :window_end`
+- View: `_fetch_schedule.html.erb`
+- Turbo target: `source_monitor_dashboard_fetch_schedule`
+
+### Quick Actions
+- Static `QuickAction` structs defined in `Queries::QUICK_ACTIONS`
+- Presenter: `QuickActionsPresenter` resolves route names to paths
+- View: inline in `index.html.erb`
+
+## Data Structures
+
+### RecentActivity::Event (Struct)
+```ruby
+Struct.new(
+  :type, :id, :occurred_at, :success, :items_created,
+  :items_updated, :scraper_adapter, :item_title, :item_url,
+  :source_name, :source_id, keyword_init: true
+)
+```
+
+### UpcomingFetchSchedule::Group (Struct)
+```ruby
+Struct.new(
+  :key, :label, :min_minutes, :max_minutes,
+  :window_start, :window_end, :include_unscheduled, :sources,
+  keyword_init: true
+)
+```
+
+### QuickAction (Struct)
+```ruby
+Struct.new(:label, :description, :route_name, keyword_init: true)
+```
+
+## Turbo Stream Setup
+
+The dashboard view subscribes to the broadcast channel:
+```erb
+<%%= turbo_stream_from SourceMonitor::Dashboard::TurboBroadcaster::STREAM_NAME %>
+```
+
+Stream name: `"source_monitor_dashboard"`
+
+The broadcaster uses `DashboardController.render(partial:, locals:)` to render partials outside of a request context.
+
+## Caching
+
+The `Queries` class uses an in-memory `Cache` (simple hash store) scoped to the instance. Each `Queries.new` gets a fresh cache, so data is fresh per request but not duplicated within one request.
+
+## File Locations
+
+| Component | Path |
+|-----------|------|
+| Controller | `app/controllers/source_monitor/dashboard_controller.rb` |
+| Queries facade | `lib/source_monitor/dashboard/queries.rb` |
+| StatsQuery | `lib/source_monitor/dashboard/queries/stats_query.rb` |
+| RecentActivityQuery | `lib/source_monitor/dashboard/queries/recent_activity_query.rb` |
+| UpcomingFetchSchedule | `lib/source_monitor/dashboard/upcoming_fetch_schedule.rb` |
+| RecentActivity::Event | `lib/source_monitor/dashboard/recent_activity.rb` |
+| RecentActivityPresenter | `lib/source_monitor/dashboard/recent_activity_presenter.rb` |
+| QuickAction | `lib/source_monitor/dashboard/quick_action.rb` |
+| QuickActionsPresenter | `lib/source_monitor/dashboard/quick_actions_presenter.rb` |
+| TurboBroadcaster | `lib/source_monitor/dashboard/turbo_broadcaster.rb` |
+| Views | `app/views/source_monitor/dashboard/` |
+
+## Testing
+
+Dashboard queries should be tested with integration tests that verify SQL correctness against real records. See `test/lib/source_monitor/dashboard/` for existing test patterns.
+
+Presenters can be unit-tested with mock url_helpers:
+```ruby
+class FakeUrlHelpers
+  def source_path(id) = "/source_monitor/sources/#{id}"
+  def fetch_log_path(id) = "/source_monitor/fetch_logs/#{id}"
+end
+```