good_pipeline 0.4.0 → 0.6.0

data/app/views/layouts/good_pipeline/application.html.erb

@@ -1,155 +1,26 @@
-<!DOCTYPE html>
-<html lang="en" data-theme="light">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>GoodPipeline</title>
-  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css">
-  <link rel="stylesheet" href="<%= frontend_static_path(id: 'style', format: :css) %>">
-</head>
-<body>
-  <header class="dashboard-header">
-    <span class="header-left">
-      <%= link_to "GoodPipeline", root_path %>
-      <%= link_to "Definitions", definitions_pipelines_path, class: "header-nav-link" %>
-    </span>
-    <span class="header-right">
-      <span class="header-version">v<%= GoodPipeline::VERSION %></span>
-      <a href="https://github.com/milkstrawai/good_pipeline" target="_blank" rel="noopener" class="header-github" title="GitHub">
-        <svg height="18" width="18" viewBox="0 0 16 16" fill="currentColor"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"/></svg>
-      </a>
-    </span>
-  </header>
-  <main class="dashboard-content">
+<% theme = %w[dark light].include?(cookies[:good_pipeline_theme]) ? cookies[:good_pipeline_theme] : "dark" %>
+<!doctype html>
+<html lang="en" data-gp-theme="<%= theme %>">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="csrf-token" content="<%= form_authenticity_token %>">
+    <meta name="good-pipeline-theme-url" content="<%= theme_path %>">
+    <meta name="turbo-visit-control" content="reload">
+    <title>GoodPipeline</title>
+    <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='6' fill='%23111317'/%3E%3Ctext x='5' y='22' fill='%23e6e9ef' font-family='monospace' font-size='16'%3Egp%3C/text%3E%3C/svg%3E">
+
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&amp;family=JetBrains+Mono:wght@400;500&amp;display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="<%= frontend_static_path(id: "dashboard", format: :css) %>">
+    <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js" defer nonce="<%= content_security_policy_nonce %>"></script>
+    <script src="<%= frontend_static_path(id: "dashboard", format: :js) %>" defer nonce="<%= content_security_policy_nonce %>"></script>
+  </head>
+  <body>
+    <% if flash[:notice] %><div class="gp-flash gp-flash--notice" role="status"><%= flash[:notice] %></div><% end %>
+    <% if flash[:alert] %><div class="gp-flash gp-flash--alert" role="alert"><%= flash[:alert] %></div><% end %>
     <%= yield %>
-  </main>
-  <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
-  <script>
-    mermaid.initialize({
-      startOnLoad: true,
-      theme: 'neutral',
-      flowchart: { curve: 'basis', nodeSpacing: 30, rankSpacing: 50 }
-    });
-    document.querySelectorAll('tr[data-href]').forEach(function(row) {
-      row.addEventListener('click', function() {
-        window.location = this.dataset.href;
-      });
-    });
-  </script>
-  <script>
-    (function() {
-      var MIN_SCALE = 0.5, MAX_SCALE = 4, ZOOM_STEP = 0.25;
-      var states = new WeakMap();
-
-      function getState(container) {
-        if (!states.has(container)) states.set(container, { scale: 1, panX: 0, panY: 0 });
-        return states.get(container);
-      }
-
-      function applyTransform(container) {
-        var s = getState(container);
-        var canvas = container.querySelector('.diagram-canvas');
-        if (canvas) canvas.style.transform = 'translate(' + s.panX + 'px, ' + s.panY + 'px) scale(' + s.scale + ')';
-      }
-
-      function clampScale(val) {
-        return Math.min(MAX_SCALE, Math.max(MIN_SCALE, val));
-      }
-
-      function zoomAroundPoint(s, centerX, centerY, newScale) {
-        var oldScale = s.scale;
-        newScale = clampScale(newScale);
-        if (newScale === oldScale) return;
-        var ratio = newScale / oldScale;
-        s.panX = centerX - (centerX - s.panX) * ratio;
-        s.panY = centerY - (centerY - s.panY) * ratio;
-        s.scale = newScale;
-      }
-
-      // Button actions via event delegation
-      document.addEventListener('click', function(e) {
-        var btn = e.target.closest('[data-action]');
-        if (!btn) return;
-        var container = btn.closest('.diagram-container');
-        if (!container) return;
-        var s = getState(container);
-        var action = btn.dataset.action;
-
-        if (action === 'zoom-in' || action === 'zoom-out') {
-          var viewport = container.querySelector('.diagram-viewport');
-          var rect = viewport.getBoundingClientRect();
-          var centerX = rect.width / 2;
-          var centerY = rect.height / 2;
-          var delta = action === 'zoom-in' ? ZOOM_STEP : -ZOOM_STEP;
-          zoomAroundPoint(s, centerX, centerY, s.scale + delta);
-        } else if (action === 'zoom-reset') {
-          s.scale = 1; s.panX = 0; s.panY = 0;
-        } else if (action === 'fullscreen') {
-          if (document.fullscreenElement === container) {
-            document.exitFullscreen();
-          } else {
-            container.requestFullscreen();
-          }
-          return;
-        }
-        applyTransform(container);
-      });
-
-      // Mouse wheel zoom toward cursor
-      document.querySelectorAll('.diagram-viewport').forEach(function(viewport) {
-        viewport.addEventListener('wheel', function(e) {
-          e.preventDefault();
-          var container = viewport.closest('.diagram-container');
-          var s = getState(container);
-          var rect = viewport.getBoundingClientRect();
-          var cursorX = e.clientX - rect.left;
-          var cursorY = e.clientY - rect.top;
-          var delta = e.deltaY < 0 ? ZOOM_STEP : -ZOOM_STEP;
-          zoomAroundPoint(s, cursorX, cursorY, s.scale + delta);
-          applyTransform(container);
-        }, { passive: false });
-      });
-
-      // Click-drag pan
-      document.querySelectorAll('.diagram-viewport').forEach(function(viewport) {
-        viewport.addEventListener('mousedown', function(e) {
-          if (e.button !== 0) return;
-          var container = viewport.closest('.diagram-container');
-          var canvas = container.querySelector('.diagram-canvas');
-          var s = getState(container);
-          var startX = e.clientX - s.panX;
-          var startY = e.clientY - s.panY;
-          canvas.classList.add('dragging');
-
-          function onMove(ev) {
-            s.panX = ev.clientX - startX;
-            s.panY = ev.clientY - startY;
-            applyTransform(container);
-          }
-          function onUp() {
-            canvas.classList.remove('dragging');
-            document.removeEventListener('mousemove', onMove);
-            document.removeEventListener('mouseup', onUp);
-          }
-          document.addEventListener('mousemove', onMove);
-          document.addEventListener('mouseup', onUp);
-        });
-      });
-
-      // Reset zoom when switching definitions
-      document.querySelectorAll('.definition-item').forEach(function(btn) {
-        btn.addEventListener('click', function() {
-          var type = btn.dataset.pipeline;
-          var panel = document.querySelector('.definition-panel[data-pipeline="' + type + '"]');
-          if (!panel) return;
-          var container = panel.querySelector('.diagram-container');
-          if (!container) return;
-          var s = getState(container);
-          s.scale = 1; s.panX = 0; s.panY = 0;
-          applyTransform(container);
-        });
-      });
-    })();
-  </script>
-</body>
+    <div id="gp-aria-live" class="gp-sr-only" aria-live="polite" aria-atomic="true"></div>
+  </body>
 </html>

data/config/routes.rb

@@ -5,8 +5,12 @@ GoodPipeline::Engine.routes.draw do
 
   resources :pipelines, only: %i[index show] do
     get :definitions, on: :collection
+    post :cancel, on: :member
+    post :rerun, on: :member
   end
 
+  patch :theme, to: "themes#update", as: :theme
+
   scope :frontend, controller: :frontends, defaults: { version: GoodPipeline::VERSION.tr(".", "-") } do
     get "static/:version/:id", action: :static, as: :frontend_static
   end

data/demo/config/environments/development.rb

@@ -7,3 +7,6 @@ Rails.application.configure do
   config.active_support.deprecation = :log
   config.good_job.execution_mode = :async
 end
+
+# The demo is a local development application; expose its pipeline controls.
+GoodPipeline.dashboard_mutations_enabled = true

data/demo/config/environments/test.rb

@@ -4,7 +4,8 @@ Rails.application.configure do
   config.cache_classes = true
   config.eager_load = false
   config.consider_all_requests_local = true
-  config.action_controller.perform_caching = false if config.respond_to?(:action_controller)
+  config.action_controller.perform_caching = true if config.respond_to?(:action_controller)
+  config.cache_store = :memory_store
   config.active_support.deprecation = :stderr
   config.good_job.execution_mode = :external
 end

data/demo/db/migrate/20260319205325_create_good_jobs.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class CreateGoodJobs < ActiveRecord::Migration[8.1]
+class CreateGoodJobs < ActiveRecord::Migration[7.2]
   def change
     # Uncomment for Postgres v12 or earlier to enable gen_random_uuid() support
     # enable_extension 'pgcrypto'

data/demo/db/migrate/20260319205326_create_good_pipeline_tables.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class CreateGoodPipelineTables < ActiveRecord::Migration[8.1]
+class CreateGoodPipelineTables < ActiveRecord::Migration[7.2]
   def change
     # Uncomment for Postgres v12 or earlier to enable gen_random_uuid() support
     # enable_extension 'pgcrypto'

data/demo/db/migrate/20260810000000_add_good_pipeline_dashboard_indexes.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class AddGoodPipelineDashboardIndexes < ActiveRecord::Migration[7.2]
+  disable_ddl_transaction!
+
+  def change
+    add_index :good_pipeline_pipelines, %i[type created_at id],
+              order: { created_at: :desc, id: :desc },
+              name: :index_gp_pipelines_on_type_created_at_id,
+              algorithm: :concurrently, if_not_exists: true
+    add_index :good_pipeline_pipelines, %i[status created_at id],
+              order: { created_at: :desc, id: :desc },
+              name: :index_gp_pipelines_on_status_created_at_id,
+              algorithm: :concurrently, if_not_exists: true
+    add_index :good_pipeline_pipelines, %i[created_at id],
+              order: { created_at: :desc, id: :desc },
+              name: :index_gp_pipelines_on_created_at_id,
+              algorithm: :concurrently, if_not_exists: true
+  end
+end

data/demo/db/seeds.rb

@@ -1,36 +1,115 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 puts "Seeding GoodPipeline demo data..."
 
+SEED_JOB_QUEUE = "good_pipeline_demo_seed"
+SEED_FUTURE = Time.utc(2100, 1, 1)
+NOW = Time.current.change(usec: 0)
+
+# GoodJob rows have no foreign key from GoodPipeline, so tag synthetic rows by
+# queue name and remove them explicitly before rebuilding the demo fixtures.
+GoodJob::Job.where(queue_name: SEED_JOB_QUEUE).delete_all
 GoodPipeline::ChainRecord.delete_all
 GoodPipeline::DependencyRecord.delete_all
 GoodPipeline::StepRecord.delete_all
 GoodPipeline::PipelineRecord.delete_all
 
-NOW = Time.current # rubocop:disable Lint/ConstantDefinitionInBlock
-
-def create_pipeline(type:, status:, params:, strategy: "halt", age:, duration: nil, halt_triggered: false) # rubocop:disable Metrics/ParameterLists
+def create_pipeline(type:, status:, params:, strategy: "halt", age: nil, created_at: nil, duration: nil,
+                    halt_triggered: false)
+  timestamp = created_at || (NOW - age)
   pipeline = GoodPipeline::PipelineRecord.create!(
     type: type, status: status, params: params,
     on_failure_strategy: strategy, halt_triggered: halt_triggered
   )
   pipeline.update_columns(
-    created_at: NOW - age,
-    updated_at: duration ? NOW - age + duration : NOW - age
+    created_at: timestamp,
+    updated_at: duration ? timestamp + duration : timestamp
   )
   pipeline
 end
 
+def active_job_payload(job_id:, job_class:, scheduled_at:, enqueued_at:)
+  {
+    "job_class" => job_class,
+    "job_id" => job_id,
+    "provider_job_id" => job_id,
+    "queue_name" => SEED_JOB_QUEUE,
+    "priority" => 0,
+    "arguments" => [],
+    "executions" => 0,
+    "exception_executions" => {},
+    "locale" => "en",
+    "timezone" => "UTC",
+    "enqueued_at" => enqueued_at.utc.iso8601(9),
+    "scheduled_at" => scheduled_at.utc.iso8601(9)
+  }
+end
+
+def create_seed_job(job_class:, state:, created_at:, duration:, error: nil)
+  job_id = SecureRandom.uuid
+  unfinished = %i[running queued].include?(state)
+  scheduled_at = unfinished ? SEED_FUTURE : created_at
+  performed_at = %i[completed running].include?(state) ? created_at : nil
+  finished_at = state == :completed ? created_at + duration : nil
+
+  GoodJob::Job.create!(
+    id: job_id,
+    active_job_id: job_id,
+    queue_name: SEED_JOB_QUEUE,
+    priority: 0,
+    serialized_params: active_job_payload(
+      job_id: job_id,
+      job_class: job_class,
+      scheduled_at: scheduled_at,
+      enqueued_at: created_at
+    ),
+    scheduled_at: scheduled_at,
+    performed_at: performed_at,
+    finished_at: finished_at,
+    error: error,
+    executions_count: state == :queued ? 0 : 1,
+    job_class: job_class,
+    created_at: created_at,
+    updated_at: finished_at || created_at
+  )
+end
+
+def inferred_job_state(status)
+  case status
+  when "succeeded", "failed", "halted" then :completed
+  when "enqueued" then :queued
+  else :none
+  end
+end
+
 def add_steps(pipeline, *step_defs)
   records = {}
-  step_defs.each do |definition|
+  step_defs.each_with_index do |definition, index|
     branch_hash = definition.slice(:decides, :branch_result, :empty_arms, :branch_key, :branch_arm).transform_keys(&:to_s)
+    status = definition.fetch(:status, "succeeded")
+    job_state = definition.fetch(:job_state, inferred_job_state(status))
+    started_at = pipeline.created_at + definition.fetch(:start_after, (index + 1) * 5).seconds
+    job_duration = definition.fetch(:duration, 10).seconds
+    error = if status == "failed"
+              "#{definition.fetch(:error_class, 'RuntimeError')}: #{definition.fetch(:error_message, 'Synthetic failure')}"
+            end
+    good_job = if %i[completed running queued].include?(job_state)
+                 create_seed_job(
+                   job_class: definition[:job], state: job_state, created_at: started_at,
+                   duration: job_duration, error: error
+                 )
+               end
+    good_job_id = job_state == :dangling ? SecureRandom.uuid : good_job&.id
 
     records[definition[:key]] = GoodPipeline::StepRecord.create!(
       pipeline: pipeline, key: definition[:key], job_class: definition[:job],
-      coordination_status: definition.fetch(:status, "succeeded"),
+      coordination_status: status, good_job_id: good_job_id,
       error_class: definition[:error_class], error_message: definition[:error_message],
-      branch: branch_hash
+      branch: branch_hash,
+      created_at: pipeline.created_at + index.fdiv(1_000_000),
+      updated_at: pipeline.created_at + index.fdiv(1_000_000)
     )
   end
   records
@@ -40,6 +119,63 @@ def add_edges(pipeline, steps, *edges)
   edges.each do |from, to|
     GoodPipeline::DependencyRecord.create!(pipeline: pipeline, step: steps[to], depends_on_step: steps[from])
   end
+  normalize_job_timings(pipeline)
+end
+
+def normalize_job_timings(pipeline)
+  ordered_steps = pipeline.steps.order(:created_at, :id).to_a
+  dependencies = pipeline.dependencies.to_a
+  jobs = GoodJob::Job.where(id: ordered_steps.filter_map(&:good_job_id)).index_by(&:id)
+  parents = dependencies.group_by(&:step_id).transform_values do |records|
+    records.map(&:depends_on_step_id)
+  end
+  by_id = ordered_steps.index_by(&:id)
+  remaining = ordered_steps.to_h { |step| [step.id, parents.fetch(step.id, []).length] }
+  children = dependencies.group_by(&:depends_on_step_id)
+  ready = ordered_steps.select { |step| remaining.fetch(step.id).zero? }
+
+  until ready.empty?
+    step = ready.shift
+    job = jobs[step.good_job_id]
+    upstream_finishes = parents.fetch(step.id, []).filter_map do |id|
+      upstream = by_id[id]
+      jobs[upstream&.good_job_id]&.finished_at
+    end
+    shift_seed_job_after(job, upstream_finishes.max) if job&.performed_at && upstream_finishes.any?
+
+    children.fetch(step.id, []).each do |dependency|
+      remaining[dependency.step_id] -= 1
+      ready << by_id.fetch(dependency.step_id) if remaining.fetch(dependency.step_id).zero?
+    end
+  end
+end
+
+def shift_seed_job_after(job, earliest_start)
+  return unless earliest_start && job.performed_at < earliest_start
+
+  duration = job.finished_at && (job.finished_at - job.performed_at)
+  attributes = { performed_at: earliest_start }
+  attributes[:finished_at] = earliest_start + duration if duration
+  if job.finished_at
+    attributes[:scheduled_at] = earliest_start
+    attributes[:updated_at] = attributes[:finished_at]
+    payload = job.serialized_params.deep_dup
+    payload["enqueued_at"] = earliest_start.utc.iso8601(9)
+    payload["scheduled_at"] = earliest_start.utc.iso8601(9)
+    attributes[:serialized_params] = payload
+  end
+  job.update_columns(attributes)
+end
+
+def recent_seed_time(day_offset, slot)
+  day_start = NOW.beginning_of_day - day_offset.days
+  return day_start + (30 + (slot * 73)).minutes unless day_offset.zero?
+
+  # Always stay inside today's calendar bucket without creating future rows,
+  # including when seeds run just after midnight.
+  elapsed = [(NOW - day_start).to_i - 1, 0].max
+  offset = elapsed.zero? ? 0 : ((slot + 1) * elapsed / 14.0).floor
+  day_start + [offset, elapsed].min.seconds
 end
 
 # 1. VideoProcessingPipeline (succeeded) — fan-out + fan-in DAG
@@ -70,7 +206,7 @@ report = create_pipeline(type: "ReportGenerationPipeline", status: "running",
                           params: { report_type: "monthly_revenue", month: "2026-02" }, age: 15.minutes)
 report_steps = add_steps(report,
                          { key: "query_data", job: "QueryDataJob" },
-                         { key: "aggregate", job: "AggregateJob", status: "enqueued" },
+                         { key: "aggregate", job: "AggregateJob", status: "enqueued", job_state: :running },
                          { key: "render_pdf", job: "RenderPdfJob", status: "pending" },
                          { key: "email_report", job: "EmailReportJob", status: "pending" })
 add_edges(report, report_steps, %w[query_data aggregate], %w[aggregate render_pdf], %w[render_pdf email_report])
@@ -148,7 +284,7 @@ ingest2 = create_pipeline(type: "DataIngestionPipeline", status: "running",
                            strategy: "continue", age: 3.minutes)
 ingest2_steps = add_steps(ingest2,
                           { key: "extract", job: "ExtractJob" },
-                          { key: "validate", job: "ValidateJob", status: "enqueued" },
+                          { key: "validate", job: "ValidateJob", status: "enqueued", job_state: :queued },
                           { key: "transform", job: "TransformJob", status: "pending" },
                           { key: "load", job: "LoadJob", status: "pending" })
 add_edges(ingest2, ingest2_steps, %w[extract validate], %w[validate transform], %w[transform load])
@@ -374,4 +510,182 @@ add_edges(notif_routing, notif_routing_steps,
           %w[load_preferences notification_channel],
           %w[notification_channel send_email], %w[notification_channel send_push])
 
-puts "Done! #{GoodPipeline::PipelineRecord.count} pipelines seeded."
+# Fixture A: 139 steps and 224 edges. This independently exercises the
+# dashboard's large-pipeline threshold without exceeding Mermaid's edge cap.
+warehouse = create_pipeline(
+  type: "DataWarehouseRebuildPipeline",
+  status: "running",
+  params: { warehouse: "analytics", shards: 48 },
+  strategy: "continue",
+  age: 2.hours
+)
+warehouse_defs = [
+  { key: "plan", job: "WarehousePlanJob", start_after: 10, duration: 20 }
+]
+
+48.times do |index|
+  suffix = index.to_s.rjust(2, "0")
+  warehouse_defs << {
+    key: "extract_#{suffix}", job: "WarehouseExtractJob",
+    start_after: 35 + ((index % 8) * 2), duration: 20 + (index % 5)
+  }
+end
+
+48.times do |index|
+  suffix = index.to_s.rjust(2, "0")
+  attributes = {
+    key: "transform_#{suffix}", job: "WarehouseTransformJob",
+    start_after: 90 + ((index % 8) * 3), duration: 30 + (index % 7)
+  }
+  if index < 36
+    warehouse_defs << attributes
+  elsif index < 39
+    warehouse_defs << attributes.merge(status: "enqueued", job_state: :running)
+  elsif index < 42
+    warehouse_defs << attributes.merge(status: "enqueued", job_state: :queued)
+  else
+    warehouse_defs << attributes.merge(status: "pending", job_state: :none)
+  end
+end
+
+warehouse_defs << {
+  key: "merge", job: "WarehouseMergeJob", status: "pending", job_state: :none,
+  start_after: 160, duration: 15
+}
+40.times do |index|
+  warehouse_defs << {
+    key: "load_#{index.to_s.rjust(2, '0')}", job: "WarehouseLoadJob",
+    status: "pending", job_state: :none, start_after: 180 + index, duration: 10
+  }
+end
+warehouse_defs << {
+  key: "finalize", job: "WarehouseFinalizeJob", status: "pending", job_state: :none,
+  start_after: 230, duration: 10
+}
+
+warehouse_steps = add_steps(warehouse, *warehouse_defs)
+warehouse_edges = []
+48.times do |index|
+  suffix = index.to_s.rjust(2, "0")
+  warehouse_edges << ["plan", "extract_#{suffix}"]
+  warehouse_edges << ["extract_#{suffix}", "transform_#{suffix}"]
+  warehouse_edges << ["transform_#{suffix}", "merge"]
+end
+40.times do |index|
+  suffix = index.to_s.rjust(2, "0")
+  warehouse_edges << ["merge", "load_#{suffix}"]
+  warehouse_edges << ["load_#{suffix}", "finalize"]
+end
+add_edges(warehouse, warehouse_steps, *warehouse_edges)
+
+# Fixture B: 46 nodes connected to every subsequent node, producing exactly
+# C(46, 2) = 1,035 edges while remaining below the 60-step large-pipeline gate.
+dense = create_pipeline(
+  type: "DenseFanoutPipeline",
+  status: "succeeded",
+  params: { nodes: 46, topology: "fully_connected_forward" },
+  strategy: "ignore",
+  age: 26.hours,
+  duration: 12.minutes
+)
+dense_defs = 46.times.map do |index|
+  {
+    key: "node_#{index.to_s.rjust(2, '0')}", job: "DenseFanoutNodeJob",
+    start_after: 5 + (index * 10), duration: 5
+  }
+end
+dense_steps = add_steps(dense, *dense_defs)
+dense_edges = 46.times.flat_map do |from|
+  ((from + 1)...46).map do |to|
+    ["node_#{from.to_s.rjust(2, '0')}", "node_#{to.to_s.rjust(2, '0')}"]
+  end
+end
+add_edges(dense, dense_steps, *dense_edges)
+
+# A non-terminal execution is intentionally older than GoodJob's normal
+# retention window. Its dangling IDs model job rows that cleanup has removed.
+retention_gap = create_pipeline(
+  type: "LongRunningArchivePipeline",
+  status: "running",
+  params: { archive: "legal-hold", partitions: 4 },
+  strategy: "continue",
+  age: 20.days
+)
+retention_steps = add_steps(
+  retention_gap,
+  { key: "scan", job: "ArchiveScanJob", job_state: :dangling },
+  { key: "compact", job: "ArchiveCompactJob", job_state: :dangling },
+  { key: "verify", job: "ArchiveVerifyJob", status: "enqueued", job_state: :dangling },
+  { key: "publish", job: "ArchivePublishJob", status: "pending", job_state: :dangling }
+)
+add_edges(retention_gap, retention_steps, %w[scan compact], %w[compact verify], %w[verify publish])
+
+# Add 180 compact historical executions. Together with the original 20 and the
+# three scale/retention fixtures above, the dashboard has 203 rows to paginate.
+# The generated set is exactly 80/8/5/4/3 percent (rounded) across statuses.
+history_statuses = (["succeeded"] * 144) + (["running"] * 14) + (["failed"] * 9) +
+                   (["halted"] * 7) + (["skipped"] * 6)
+history_types = %w[
+  CatalogRefreshPipeline CustomerImportPipeline DailyMetricsPipeline
+  InventorySnapshotPipeline SearchReindexPipeline WebhookReplayPipeline
+]
+
+180.times do |index|
+  status = history_statuses[(index * 73) % history_statuses.length]
+  day_offset = index % 14
+  slot = index / 14
+  duration = status == "running" ? nil : (45 + ((index * 17) % 480)).seconds
+  pipeline = create_pipeline(
+    type: history_types[index % history_types.length],
+    status: status,
+    params: { run: index + 1, shard: index % 12, source: "demo" },
+    strategy: %w[halt continue ignore][index % 3],
+    created_at: recent_seed_time(day_offset, slot),
+    duration: duration,
+    halt_triggered: status == "halted"
+  )
+
+  step_defs = case status
+              when "succeeded"
+                [
+                  { key: "prepare", job: "DemoPrepareJob", start_after: 5, duration: 8 },
+                  { key: "process", job: "DemoProcessJob", start_after: 18, duration: 12 },
+                  { key: "commit", job: "DemoCommitJob", start_after: 35, duration: 7 }
+                ]
+              when "running"
+                active_state = index.even? ? :running : :queued
+                [
+                  { key: "prepare", job: "DemoPrepareJob", start_after: 5, duration: 8 },
+                  { key: "process", job: "DemoProcessJob", status: "enqueued",
+                    job_state: active_state, start_after: 18, duration: 12 },
+                  { key: "commit", job: "DemoCommitJob", status: "pending", job_state: :none }
+                ]
+              when "failed"
+                [
+                  { key: "prepare", job: "DemoPrepareJob", start_after: 5, duration: 8 },
+                  { key: "process", job: "DemoProcessJob", status: "failed", start_after: 18, duration: 12,
+                    error_class: "DemoImportError", error_message: "Synthetic row #{index + 1} could not be imported" },
+                  { key: "commit", job: "DemoCommitJob", status: "skipped", job_state: :none }
+                ]
+              when "halted"
+                [
+                  { key: "prepare", job: "DemoPrepareJob", status: "failed", start_after: 5, duration: 8,
+                    error_class: "DemoHalt", error_message: "Synthetic safety check halted the execution" },
+                  { key: "process", job: "DemoProcessJob", status: "halted", start_after: 18, duration: 4 },
+                  { key: "commit", job: "DemoCommitJob", status: "skipped", job_state: :none }
+                ]
+              else
+                [
+                  { key: "prepare", job: "DemoPrepareJob", status: "skipped", job_state: :none },
+                  { key: "process", job: "DemoProcessJob", status: "skipped", job_state: :none },
+                  { key: "commit", job: "DemoCommitJob", status: "skipped", job_state: :none }
+                ]
+              end
+
+  steps = add_steps(pipeline, *step_defs)
+  add_edges(pipeline, steps, %w[prepare process], %w[process commit])
+end
+
+puts "Done! #{GoodPipeline::PipelineRecord.count} pipelines, " \
+     "#{GoodPipeline::StepRecord.count} steps, and " \
+     "#{GoodJob::Job.where(queue_name: SEED_JOB_QUEUE).count} synthetic jobs seeded."