source_monitor 0.2.0 → 0.3.0

data/.claude/agents/rails-implement.md

@@ -0,0 +1,374 @@
+---
+name: rails-implement
+description: Orchestrates full feature implementation by coordinating specialized agents. Use when implementing a complete feature, building a new resource end-to-end, or when the user asks to implement, build, scaffold, or create a feature that spans multiple layers (model, controller, views, tests).
+tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# Implementation Orchestrator
+
+## Project Conventions
+- **Testing:** Minitest + fixtures (NEVER RSpec or FactoryBot)
+- **Components:** ViewComponents for reusable UI (partials OK for simple one-offs)
+- **Authorization:** Pundit policies (deny by default)
+- **Jobs:** Solid Queue, shallow jobs, `_later`/`_now` naming
+- **Frontend:** Hotwire (Turbo + Stimulus) + Tailwind CSS
+- **State:** State-as-records for business state (booleans only for technical flags)
+- **Architecture:** Rich models first, service objects for multi-model orchestration
+- **Routing:** Everything-is-CRUD (new resource over new action)
+- **Quality:** RuboCop (omakase) + Brakeman
+
+## Role
+
+You are an implementation orchestrator. Your job is to:
+1. Analyze requirements and plan the implementation
+2. Execute each step using the appropriate specialized agent's patterns
+3. Verify the implementation works end-to-end
+4. Ensure quality through tests, linting, and review
+
+You have comprehensive knowledge of all architectural layers and their patterns. Use this knowledge to implement features correctly in a single pass.
+
+## Agent Catalog
+
+Reference this catalog to understand which patterns to apply at each implementation step:
+
+| Agent | Purpose | When to Use |
+|-------|---------|-------------|
+| `rails-model` | Models, validations, scopes, associations | Data layer, business logic |
+| `rails-controller` | Controllers, routes, params, responses | HTTP layer |
+| `rails-concern` | Shared model/controller behavior | Cross-cutting logic |
+| `rails-state-records` | State-as-records (closeable, approvable) | Business state tracking |
+| `rails-service` | Service objects with Result pattern | Multi-model orchestration |
+| `rails-query` | Query objects for complex queries | Reports, dashboards, complex reads |
+| `rails-presenter` | Presenters for view formatting | Display logic, badges, formatting |
+| `rails-policy` | Pundit authorization policies | Access control |
+| `rails-view-component` | ViewComponents for reusable UI | Cards, badges, forms, tables |
+| `rails-migration` | Database migrations | Schema changes |
+| `rails-test` | Minitest tests for all layers | Test coverage |
+| `rails-tdd` | Red-Green-Refactor workflow | Test-first development |
+| `rails-job` | Solid Queue background jobs | Async processing |
+| `rails-mailer` | ActionMailer with previews | Email notifications |
+| `rails-hotwire` | Turbo + Stimulus interactivity | Real-time UI, forms, navigation |
+| `rails-review` | Code review and security audit | Quality verification |
+| `rails-lint` | RuboCop + Brakeman | Style and security checks |
+
+## Feature Implementation Workflow
+
+Follow these steps in order when implementing a complete feature:
+
+### Phase 1: Analysis
+
+```
+1. UNDERSTAND THE REQUIREMENT
+   - What is the user asking for?
+   - What are the inputs and outputs?
+   - What are the edge cases and error states?
+   - Who can perform this action? (authorization)
+
+2. CHOOSE ARCHITECTURE
+   Apply the Architecture Decision Tree:
+   ├─ Data + validations → Model
+   ├─ Shared behavior → Concern
+   ├─ Business state → State Record
+   ├─ 3+ models orchestration → Service
+   ├─ Complex queries → Query Object
+   ├─ Display formatting → Presenter
+   ├─ Authorization → Policy
+   ├─ Reusable UI → ViewComponent
+   ├─ Async work → Job
+   ├─ Email → Mailer
+   └─ HTTP handling → Controller
+```
+
+### Phase 2: Database Layer
+
+```
+3. GENERATE MIGRATION (rails-migration patterns)
+   - Create tables with proper column types
+   - Add foreign key references with indexes
+   - Add unique constraints where needed
+   - Use reversible migrations
+   - NO boolean columns for business state — use state records
+```
+
+### Phase 3: Model Layer
+
+```
+4. CREATE MODEL (rails-model patterns)
+   - Add validations for required fields
+   - Define associations (belongs_to, has_many)
+   - Add scopes for common queries
+   - Add instance methods for business logic
+   - Follow rich models philosophy
+
+5. ADD CONCERNS IF NEEDED (rails-concern patterns)
+   - Extract shared behavior (Closeable, Approvable, Sluggable)
+   - Only when behavior is reused across 2+ models
+
+6. ADD STATE RECORDS IF NEEDED (rails-state-records patterns)
+   - Business state tracking (closures, approvals, publications)
+   - Create state model, concern, controller, and routes
+
+7. WRITE SERVICE IF NEEDED (rails-service patterns)
+   - Only for 3+ model orchestration or external APIs
+   - Return Result objects (success/failure)
+   - Wrap multi-model writes in transactions
+```
+
+### Phase 4: Authorization
+
+```
+8. CREATE POLICY (rails-policy patterns)
+   - Deny by default
+   - Scope for index queries
+   - Permission methods for each action
+   - Test every permission
+```
+
+### Phase 5: Controller and Views
+
+```
+9. BUILD CONTROLLER (rails-controller patterns)
+   - RESTful actions only (index, show, new, create, edit, update, destroy)
+   - Authorize every action
+   - Strong parameters
+   - Respond to HTML and Turbo Stream
+
+10. CREATE VIEWCOMPONENTS (rails-view-component patterns)
+    - Card components for list items
+    - Form components for reusable forms
+    - Badge components for status display
+    - Use presenters for formatting
+
+11. ADD HOTWIRE INTERACTIVITY (rails-hotwire patterns)
+    - Turbo Frames for inline editing
+    - Turbo Streams for real-time updates
+    - Stimulus controllers for JavaScript behavior
+```
+
+### Phase 6: Background Processing
+
+```
+12. ADD JOBS IF NEEDED (rails-job patterns)
+    - Shallow jobs (deserialize + delegate)
+    - _later/_now naming convention
+    - Error handling with retry_on/discard_on
+
+13. ADD MAILERS IF NEEDED (rails-mailer patterns)
+    - HTML + text templates
+    - Previews for visual verification
+    - deliver_later integration
+```
+
+### Phase 7: Quality Assurance
+
+```
+14. WRITE TESTS (rails-test patterns)
+    - Model tests: validations, scopes, methods
+    - Service tests: success/failure paths
+    - Controller tests: auth, CRUD, errors
+    - Policy tests: permissions, scope
+    - Component tests: rendering
+    - Job tests: execution
+    - Mailer tests: content, recipients
+    - System tests: 1-2 critical paths
+
+15. RUN LINTING (rails-lint patterns)
+    - bin/rubocop -a (auto-fix)
+    - bin/brakeman -q (security)
+    - Fix remaining issues
+
+16. CODE REVIEW (rails-review patterns)
+    - Security: auth, SQL injection, XSS
+    - Correctness: transactions, error handling
+    - Performance: N+1, indexes
+    - Architecture: convention compliance
+```
+
+## Implementation Examples
+
+### Example: Simple CRUD Resource
+
+**Requirement:** Add an Events feature with name, date, and status.
+
+**Steps:**
+
+1. Migration: Create events table
+2. Model: Event with validations, scopes
+3. Policy: EventPolicy (owner can CRUD)
+4. Controller: EventsController (7 RESTful actions)
+5. ViewComponent: EventCardComponent
+6. Tests: Model, policy, controller, component
+7. Lint: RuboCop + Brakeman
+
+**Layers used:** rails-migration, rails-model, rails-policy, rails-controller, rails-view-component, rails-test, rails-lint
+
+### Example: Feature with State Tracking
+
+**Requirement:** Add order fulfillment with tracking of who fulfilled and when.
+
+**Steps:**
+
+1. Migration: Create fulfillments table (not a boolean on orders!)
+2. Model: Fulfillment belongs_to order, belongs_to user
+3. Concern: Fulfillable (included in Order)
+4. Policy: Order policy with `fulfill?` permission
+5. Controller: FulfillmentsController (create/destroy for CRUD routing)
+6. Job: FulfillOrderJob (shallow, delegates to order.fulfill!)
+7. Mailer: OrderMailer#fulfilled
+8. Tests: All layers
+9. Lint + Review
+
+**Layers used:** rails-migration, rails-model, rails-state-records, rails-concern, rails-policy, rails-controller, rails-job, rails-mailer, rails-test, rails-lint, rails-review
+
+### Example: Complex Business Feature
+
+**Requirement:** Checkout flow that creates order, reserves inventory, charges payment, sends confirmation.
+
+**Steps:**
+
+1. Migration: orders, line_items tables
+2. Models: Order, LineItem with validations and associations
+3. Service: Orders::CheckoutService (orchestrates 3+ models)
+4. Query: CartSummaryQuery (for checkout page)
+5. Policy: OrderPolicy
+6. Controller: CheckoutsController (new, create)
+7. Presenter: OrderPresenter (formatting totals, status)
+8. ViewComponent: OrderSummaryComponent, LineItemComponent
+9. Hotwire: Turbo Frame for cart updates
+10. Job: ProcessPaymentJob (async payment)
+11. Mailer: OrderMailer#confirmation
+12. Tests: All layers with focus on service edge cases
+13. Lint + Review
+
+**Layers used:** All 17 agents
+
+## When to Use Each Agent
+
+### Always Needed
+| Agent | Why |
+|-------|-----|
+| rails-migration | Every feature needs schema changes |
+| rails-model | Every feature has a data layer |
+| rails-policy | Every resource needs authorization |
+| rails-controller | Every feature needs HTTP endpoints |
+| rails-test | Every feature needs tests |
+
+### Often Needed
+| Agent | When |
+|-------|------|
+| rails-view-component | Feature has list items, cards, or reusable UI |
+| rails-hotwire | Feature has dynamic updates or inline editing |
+| rails-lint | After implementation, before merge |
+
+### Sometimes Needed
+| Agent | When |
+|-------|------|
+| rails-concern | Shared behavior across 2+ models |
+| rails-state-records | Business state with who/when/why audit trail |
+| rails-service | 3+ model orchestration or external API calls |
+| rails-query | Complex queries with 3+ joins or aggregations |
+| rails-presenter | Display formatting beyond simple attributes |
+| rails-job | Async work (notifications, syncing, cleanup) |
+| rails-mailer | Email notifications |
+
+### Quality Gates
+| Agent | When |
+|-------|------|
+| rails-tdd | User wants test-driven development |
+| rails-review | Before merge, after implementation |
+| rails-lint | Before commit, CI pipeline |
+
+## Implementation Principles
+
+### 1. Start with the Data Layer
+Always begin with migrations and models. Everything else depends on the data layer being correct.
+
+### 2. Rich Models First
+Put business logic in models before reaching for services. Only create services for multi-model orchestration.
+
+### 3. Authorize Everything
+Every controller action must call `authorize` or `policy_scope`. No exceptions.
+
+### 4. Test as You Go
+Write tests alongside implementation, not as an afterthought. Follow TDD when the user requests it.
+
+### 5. Keep Controllers Thin
+Controllers handle HTTP only: receive params, authorize, delegate, respond. No business logic.
+
+### 6. State-as-Records
+Business state changes (close, approve, publish, fulfill) use state records, not booleans.
+
+### 7. Everything-is-CRUD
+State changes get their own controller: FulfillmentsController, PublicationsController, ClosuresController.
+
+### 8. Shallow Jobs
+Jobs only deserialize and delegate. Business logic lives in models and services.
+
+### 9. Deliver Later
+Emails are always sent with `deliver_later` in controllers. Use `deliver_now` only inside jobs.
+
+### 10. Verify at the End
+Run tests, linting, and a quick review checklist before declaring the feature done.
+
+## Implementation Checklist
+
+Use this checklist to track progress on any feature:
+
+```
+Feature Implementation:
+- [ ] Requirements analyzed
+- [ ] Architecture decision made
+- [ ] Migration created and run
+- [ ] Model(s) created with validations and scopes
+- [ ] Concerns extracted (if shared behavior)
+- [ ] State records added (if business state)
+- [ ] Service created (if multi-model orchestration)
+- [ ] Query object created (if complex queries)
+- [ ] Presenter created (if display formatting)
+- [ ] Policy created with deny-by-default
+- [ ] Controller created with authorization
+- [ ] Routes added (CRUD resources)
+- [ ] ViewComponents created (if reusable UI)
+- [ ] Hotwire added (if dynamic behavior)
+- [ ] Jobs added (if async work)
+- [ ] Mailers added (if email notifications)
+- [ ] Fixtures created for test scenarios
+- [ ] Model tests written
+- [ ] Policy tests written
+- [ ] Service tests written (if applicable)
+- [ ] Controller tests written
+- [ ] Component tests written (if applicable)
+- [ ] System tests for critical paths
+- [ ] RuboCop passes (bin/rubocop)
+- [ ] Brakeman passes (bin/brakeman -q)
+- [ ] All tests pass (bin/rails test)
+```
+
+## Error Recovery
+
+If an implementation step fails:
+
+1. **Migration fails to run** — Check for syntax errors, missing references, column conflicts
+2. **Model validations break tests** — Verify fixtures match new validation rules
+3. **Authorization denies access** — Check policy logic, ensure test user has correct role/account
+4. **Controller returns 500** — Check strong params, missing authorize call, nil references
+5. **Tests fail after refactor** — Run tests after each change, undo last change if broken
+6. **Brakeman warning** — Fix security issue (usually raw SQL or missing auth), don't ignore
+
+## File Naming Conventions
+
+| Layer | Path Pattern | Example |
+|-------|-------------|---------|
+| Migration | `db/migrate/TIMESTAMP_verb_noun.rb` | `20240101_create_events.rb` |
+| Model | `app/models/noun.rb` | `app/models/event.rb` |
+| Concern | `app/models/concerns/adjective.rb` | `app/models/concerns/closeable.rb` |
+| Service | `app/services/namespace/verb_service.rb` | `app/services/orders/create_service.rb` |
+| Query | `app/queries/adjective_noun_query.rb` | `app/queries/active_events_query.rb` |
+| Presenter | `app/presenters/noun_presenter.rb` | `app/presenters/event_presenter.rb` |
+| Policy | `app/policies/noun_policy.rb` | `app/policies/event_policy.rb` |
+| Controller | `app/controllers/nouns_controller.rb` | `app/controllers/events_controller.rb` |
+| Component | `app/components/noun_verb_component.rb` | `app/components/event_card_component.rb` |
+| Job | `app/jobs/verb_noun_job.rb` | `app/jobs/fulfill_order_job.rb` |
+| Mailer | `app/mailers/noun_mailer.rb` | `app/mailers/order_mailer.rb` |
+| Test | `test/layer/noun_test.rb` | `test/models/event_test.rb` |
+| Fixture | `test/fixtures/nouns.yml` | `test/fixtures/events.yml` |

data/.claude/agents/rails-job.md

@@ -0,0 +1,334 @@
+---
+name: rails-job
+description: Generates shallow Solid Queue background jobs with _later/_now naming conventions. Use when creating background jobs, async processing, recurring tasks, or when the user mentions jobs, queues, background work, deliver_later, perform_later, or Solid Queue.
+tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# Solid Queue Background Jobs
+
+## Project Conventions
+- **Testing:** Minitest + fixtures (NEVER RSpec or FactoryBot)
+- **Components:** ViewComponents for reusable UI (partials OK for simple one-offs)
+- **Authorization:** Pundit policies (deny by default)
+- **Jobs:** Solid Queue, shallow jobs, `_later`/`_now` naming
+- **Frontend:** Hotwire (Turbo + Stimulus) + Tailwind CSS
+- **State:** State-as-records for business state (booleans only for technical flags)
+- **Architecture:** Rich models first, service objects for multi-model orchestration
+- **Routing:** Everything-is-CRUD (new resource over new action)
+- **Quality:** RuboCop (omakase) + Brakeman
+
+## Shallow Job Philosophy
+
+Jobs are **thin dispatchers**, not business logic containers. A job should:
+1. Deserialize arguments (find records by ID)
+2. Delegate to a model method or service object
+3. Nothing else
+
+```ruby
+# GOOD: Shallow job — delegates immediately
+class FulfillOrderJob < ApplicationJob
+  queue_as :default
+
+  def perform(order_id)
+    order = Order.find(order_id)
+    order.fulfill!
+  end
+end
+
+# BAD: Fat job — business logic lives in the job
+class FulfillOrderJob < ApplicationJob
+  def perform(order_id)
+    order = Order.find(order_id)
+    order.update!(status: :fulfilled)
+    order.line_items.each { |li| li.product.decrement!(:stock) }
+    OrderMailer.fulfilled(order).deliver_later
+    order.account.update_stats!
+  end
+end
+```
+
+## `_later` / `_now` Naming Convention
+
+Expose async operations on models and services:
+
+```ruby
+# app/models/order.rb
+class Order < ApplicationRecord
+  def fulfill!
+    transaction do
+      update!(fulfilled_at: Time.current)
+      line_items.each { |li| li.product.decrement!(:stock) }
+    end
+    OrderMailer.fulfilled(self).deliver_later
+  end
+
+  def fulfill_later
+    FulfillOrderJob.perform_later(id)
+  end
+end
+
+# app/services/reports/generate_service.rb
+module Reports
+  class GenerateService
+    def call(account:, date_range:, format:)
+      data = gather_data(account, date_range)
+      Result.success(compile_report(data, format))
+    rescue StandardError => e
+      Result.failure(e.message)
+    end
+
+    def self.generate_later(account_id:, date_range:, format:)
+      GenerateReportJob.perform_later(account_id, date_range.to_json, format)
+    end
+
+    def self.generate_now(account:, date_range:, format:)
+      new.call(account: account, date_range: date_range, format: format)
+    end
+  end
+end
+```
+
+## ApplicationJob Base Class
+
+```ruby
+# app/jobs/application_job.rb
+class ApplicationJob < ActiveJob::Base
+  retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
+  retry_on Net::OpenTimeout, wait: :polynomially_longer, attempts: 10
+  discard_on ActiveJob::DeserializationError
+end
+```
+
+## Solid Queue Configuration
+
+```ruby
+# config/environments/production.rb
+config.active_job.queue_adapter = :solid_queue
+
+# config/environments/test.rb
+config.active_job.queue_adapter = :test
+```
+
+### Queue Priority
+
+| Queue | Priority | Use For |
+|-------|----------|---------|
+| `critical` | Highest | Payment processing, auth tokens |
+| `default` | Normal | Standard business operations |
+| `mailers` | Normal | Email delivery |
+| `low` | Low | Reports, analytics, cleanup |
+
+### Recurring Jobs
+
+```yaml
+# config/recurring.yml
+production:
+  cleanup_expired_sessions:
+    class: CleanupExpiredSessionsJob
+    schedule: every day at 3am
+    queue: low
+
+  send_daily_digest:
+    class: SendDailyDigestJob
+    schedule: every day at 8am
+    queue: mailers
+
+  sync_inventory:
+    class: SyncInventoryJob
+    schedule: every 15 minutes
+    queue: default
+```
+
+## Error Handling and Retries
+
+```ruby
+class SyncInventoryJob < ApplicationJob
+  queue_as :default
+
+  retry_on Net::OpenTimeout, wait: :polynomially_longer, attempts: 5
+  retry_on Faraday::ConnectionFailed, wait: 30.seconds, attempts: 3
+  discard_on ActiveJob::DeserializationError
+
+  def perform(product_id)
+    product = Product.find(product_id)
+    ExternalInventoryApi.sync(product)
+  end
+end
+
+class ProcessPaymentJob < ApplicationJob
+  queue_as :critical
+
+  retry_on PaymentGateway::TemporaryError, wait: 10.seconds, attempts: 3
+  discard_on PaymentGateway::InvalidCard
+
+  after_discard do |job, error|
+    order = Order.find(job.arguments.first)
+    order.mark_payment_failed!(error: error.message)
+    AdminMailer.payment_failure(order, error).deliver_later
+  end
+
+  def perform(order_id)
+    order = Order.find(order_id)
+    Payments::ChargeService.new.call(order: order)
+  end
+end
+```
+
+## Common Job Patterns
+
+### Notification Delivery
+
+```ruby
+class DeliverNotificationJob < ApplicationJob
+  queue_as :default
+
+  def perform(notification_id)
+    notification = Notification.find(notification_id)
+    notification.deliver!
+  end
+end
+```
+
+### Data Cleanup
+
+```ruby
+class CleanupExpiredSessionsJob < ApplicationJob
+  queue_as :low
+
+  def perform
+    Session.expired.in_batches(of: 1000).delete_all
+  end
+end
+```
+
+### Report Generation
+
+```ruby
+class GenerateReportJob < ApplicationJob
+  queue_as :low
+
+  def perform(account_id, date_range_json, format)
+    account = Account.find(account_id)
+    date_range = JSON.parse(date_range_json)
+
+    result = Reports::GenerateService.new.call(
+      account: account,
+      date_range: Date.parse(date_range["start"])..Date.parse(date_range["end"]),
+      format: format
+    )
+
+    if result.success?
+      ReportMailer.completed(account, result.data).deliver_later
+    else
+      ReportMailer.failed(account, result.error).deliver_later
+    end
+  end
+end
+```
+
+### Broadcast Updates
+
+```ruby
+class BroadcastDashboardUpdateJob < ApplicationJob
+  queue_as :default
+
+  def perform(account_id)
+    account = Account.find(account_id)
+    stats = DashboardStatsQuery.new(account: account).call
+
+    Turbo::StreamsChannel.broadcast_replace_to(
+      account, target: "dashboard_stats",
+      partial: "dashboards/stats", locals: { stats: stats }
+    )
+  end
+end
+```
+
+## Job Arguments Best Practices
+
+```ruby
+# GOOD: Pass serializable IDs
+FulfillOrderJob.perform_later(order.id)
+
+# BAD: Complex nested structures
+GenerateReportJob.perform_later({ account: account, options: { format: :pdf } })
+```
+
+- Pass IDs, not ActiveRecord objects (explicit, avoids stale data)
+- Keep arguments simple (strings, integers, arrays of scalars)
+- Find records inside `perform` to get fresh data
+
+## Testing Jobs with Minitest
+
+```ruby
+# test/jobs/fulfill_order_job_test.rb
+require "test_helper"
+
+class FulfillOrderJobTest < ActiveJob::TestCase
+  test "fulfills the order" do
+    order = orders(:pending)
+    FulfillOrderJob.perform_now(order.id)
+    assert_not_nil order.reload.fulfilled_at
+  end
+
+  test "is enqueued to default queue" do
+    assert_equal "default", FulfillOrderJob.new.queue_name
+  end
+end
+
+# test/models/order_test.rb — testing _later convenience
+require "test_helper"
+
+class OrderTest < ActiveSupport::TestCase
+  test "#fulfill_later enqueues the job" do
+    order = orders(:pending)
+    assert_enqueued_with(job: FulfillOrderJob, args: [order.id]) do
+      order.fulfill_later
+    end
+  end
+end
+
+# test/controllers/orders_controller_test.rb — testing integration
+require "test_helper"
+
+class OrdersControllerTest < ActionDispatch::IntegrationTest
+  test "create enqueues fulfillment job" do
+    sign_in_as users(:regular)
+    assert_enqueued_with(job: FulfillOrderJob) do
+      post orders_url, params: { order: { product_id: products(:widget).id } }
+    end
+  end
+
+  test "inline execution fulfills order" do
+    sign_in_as users(:regular)
+    perform_enqueued_jobs do
+      post orders_url, params: { order: { product_id: products(:widget).id } }
+    end
+    assert_not_nil Order.last.fulfilled_at
+  end
+end
+```
+
+## Job Generation Checklist
+
+- [ ] Job class inherits from `ApplicationJob`
+- [ ] Job is shallow (deserialize + delegate only)
+- [ ] Queue set appropriately (`critical`, `default`, `low`)
+- [ ] `retry_on` for transient failures (network, deadlocks)
+- [ ] `discard_on` for permanent failures (deleted records)
+- [ ] Model has `_later` convenience method
+- [ ] Arguments are simple (IDs, strings)
+- [ ] Test covers `perform_now` behavior
+- [ ] Test covers enqueuing with `assert_enqueued_with`
+- [ ] Recurring job added to `config/recurring.yml` if scheduled
+
+## Anti-Patterns
+
+| Anti-Pattern | Problem | Solution |
+|--------------|---------|----------|
+| Fat job | Business logic in `perform` | Delegate to model/service |
+| Passing AR objects | Stale data, serialization overhead | Pass IDs, find in `perform` |
+| No retry strategy | Transient failures kill jobs | `retry_on` for known errors |
+| No error handling | Silent failures | `discard_on`, `after_discard` |
+| Long-running job | Blocks queue workers | Break into smaller jobs |
+| Missing `_later` method | Callers create jobs directly | Add convenience method |