dispatch_policy 0.1.0

data/app/views/dispatch_policy/policies/show.html.erb

@@ -0,0 +1,241 @@
+<p class="back"><%= link_to "← All policies", root_path %></p>
+<h1><%= @policy_name %> <small class="muted"><%= @job_class.name %></small></h1>
+
+<div class="summary">
+  <div class="summary-item">
+    <div class="label">Pending</div>
+    <div class="value"><%= @pending_count %></div>
+    <div class="sub"><%= @pending_eligible_count %> eligible · <%= @pending_scheduled_count %> scheduled</div>
+  </div>
+  <div class="summary-item">
+    <div class="label">Admitted</div>
+    <div class="value"><%= @admitted_count %></div>
+  </div>
+  <div class="summary-item">
+    <div class="label">Completed (24h)</div>
+    <div class="value"><%= @completed_24h %></div>
+  </div>
+  <div class="summary-item">
+    <div class="label">Gates</div>
+    <div class="value" style="font-size: 1em;">
+      <% (@policy&.gates || []).each do |g| %>
+        <span class="badge"><%= g.name %></span>
+      <% end %>
+    </div>
+  </div>
+</div>
+
+<% if @adaptive_global.any? { |v| !v.nil? } %>
+  <h2>Adaptive — EWMA queue lag (avg across partitions, last hour)</h2>
+  <div class="chart-global">
+    <canvas data-chart="line"
+            data-label="avg ewma_latency_ms"
+            data-labels='<%= @chart_labels.to_json %>'
+            data-values='<%= @adaptive_global.to_json %>'
+            data-counts='<%= @completions_global.to_json %>'></canvas>
+  </div>
+<% end %>
+
+<h2>Watched partitions <small class="muted">(<%= @partition_breakdown.size %>)</small></h2>
+
+<% if @partition_breakdown.empty? %>
+  <p class="muted">No partitions watched yet. Pick some from the list below with <strong>+ watch</strong>; your selection is stored locally in the browser.</p>
+<% else %>
+  <table data-watched-table data-policy-name="<%= @policy_name %>">
+    <thead>
+      <tr>
+        <th></th>
+        <th>Source</th>
+        <th>Partition</th>
+        <th class="text-end">Pending (eligible)</th>
+        <th class="text-end">Pending (scheduled)</th>
+        <th class="text-end">In-flight</th>
+        <th class="text-end">Completed (24h)</th>
+        <th class="text-end">Adaptive cap</th>
+        <th class="text-end">EWMA latency (ms)</th>
+      </tr>
+    </thead>
+    <tbody>
+      <% @partition_breakdown.each do |row| %>
+        <tr>
+          <td><button type="button" class="chip" data-unwatch="<%= row[:partition] %>" title="Stop watching">×</button></td>
+          <td><%= row[:source] %></td>
+          <td><code><%= row[:partition] %></code></td>
+          <td class="text-end"><%= row[:eligible] %></td>
+          <td class="text-end"><%= row[:scheduled] %></td>
+          <td class="text-end"><%= row[:in_flight] %></td>
+          <td class="text-end"><%= row[:completed_24h] %></td>
+          <td class="text-end">
+            <% if row[:current_max] %><strong><%= row[:current_max] %></strong><% else %><span class="muted">—</span><% end %>
+          </td>
+          <td class="text-end">
+            <% if row[:ewma_latency_ms] %><%= row[:ewma_latency_ms] %><% else %><span class="muted">—</span><% end %>
+          </td>
+        </tr>
+        <%
+          series      = @adaptive_samples[row[:partition]]    || Array.new(@chart_slots.size)
+          counts      = @completions_samples[row[:partition]] || Array.new(@chart_slots.size, 0)
+          has_samples = series.any? { |v| !v.nil? } || counts.any? { |c| c.positive? }
+        %>
+        <tr>
+          <td colspan="9" class="sparkline-cell">
+            <% if has_samples %>
+              <div class="sparkline-wrap">
+                <canvas data-chart="sparkline"
+                        data-labels='<%= @chart_labels.to_json %>'
+                        data-values='<%= series.to_json %>'
+                        data-counts='<%= counts.to_json %>'></canvas>
+              </div>
+            <% else %>
+              <div class="sparkline-wrap sparkline-empty"><span class="muted">no completions in the last hour yet</span></div>
+            <% end %>
+          </td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% end %>
+
+<h2>All partitions <small class="muted">(<%= @partition_total_list %>)</small></h2>
+
+<turbo-frame id="partitions_list" data-turbo-action="advance">
+  <% if @partition_total_list.to_i.zero? && @partition_search.blank? %>
+    <p class="muted">This policy declares no partitioning (no gate with <code>partition_by</code> and no <code>round_robin_by</code>).</p>
+  <% else %>
+    <%= form_with url: url_for, method: :get, local: true, html: { class: "partition-search" } do %>
+      <% if params[:watch].present? %>
+        <%= hidden_field_tag :watch, params[:watch] %>
+      <% end %>
+      <%= text_field_tag :q, @partition_search, placeholder: "filter by partition key…", size: 30, autofocus: @partition_search.present? %>
+      <%= submit_tag "Search", name: nil %>
+      <% if @partition_search.present? %>
+        <%= link_to "clear", url_for(q: nil, page: nil, watch: params[:watch]), class: "muted" %>
+      <% end %>
+    <% end %>
+
+    <% if @partition_list.empty? %>
+      <p class="muted">No matches.</p>
+    <% else %>
+      <%
+        sort_link = lambda { |label, col, align_end: false|
+          active = @partition_sort == col
+          next_dir = active && @partition_dir == "desc" ? "asc" : "desc"
+          arrow = active ? (@partition_dir == "asc" ? " ▲" : " ▼") : ""
+          content_tag(:th, class: (align_end ? "text-end" : nil)) do
+            link_to "#{label}#{arrow}",
+              url_for(sort: col, dir: next_dir, q: @partition_search.presence, page: nil, watch: params[:watch]),
+              class: (active ? "sorted" : nil)
+          end
+        }
+      %>
+      <table data-policy-name="<%= @policy_name %>">
+        <thead>
+          <tr>
+            <th></th>
+            <%= sort_link.call("Source",         "source") %>
+            <%= sort_link.call("Partition",      "partition") %>
+            <%= sort_link.call("Pending",        "pending",            align_end: true) %>
+            <%= sort_link.call("In-flight",      "in_flight",          align_end: true) %>
+            <%= sort_link.call("Completed (24h)", "completed_24h",     align_end: true) %>
+            <%= sort_link.call("Last enqueue",   "last_enqueued_at") %>
+            <%= sort_link.call("Last dispatch",  "last_dispatched_at") %>
+          </tr>
+        </thead>
+        <tbody>
+          <% @partition_list.each do |row| %>
+            <% pending_total = row[:eligible] + row[:scheduled] %>
+            <tr>
+              <td>
+                <% if @watched_keys.include?(row[:partition]) %>
+                  <span class="chip on" title="Watched">✓</span>
+                <% else %>
+                  <button type="button" class="chip" data-watch="<%= row[:partition] %>" data-turbo-frame="_top" title="Watch this partition">+</button>
+                <% end %>
+              </td>
+              <td><%= row[:source] %></td>
+              <td><code><%= row[:partition] %></code></td>
+              <td class="text-end"><%= pending_total %></td>
+              <td class="text-end"><%= row[:in_flight] %></td>
+              <td class="text-end"><%= row[:completed_24h] %></td>
+              <td>
+                <% if row[:last_enqueued_at] %>
+                  <span title="<%= row[:last_enqueued_at] %>"><%= time_ago_in_words(row[:last_enqueued_at]) %> ago</span>
+                <% else %>
+                  <span class="muted">—</span>
+                <% end %>
+              </td>
+              <td>
+                <% if row[:last_dispatched_at] %>
+                  <span title="<%= row[:last_dispatched_at] %>"><%= time_ago_in_words(row[:last_dispatched_at]) %> ago</span>
+                <% else %>
+                  <span class="muted">—</span>
+                <% end %>
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+
+      <% total_pages = (@partition_total_list / DispatchPolicy::PoliciesController::PARTITION_LIST_PAGE_SIZE.to_f).ceil %>
+      <% if total_pages > 1 %>
+        <% page_params = { q: @partition_search.presence, watch: params[:watch], sort: params[:sort], dir: params[:dir] } %>
+        <div class="pagination">
+          <% if @partition_page > 1 %>
+            <%= link_to "← prev", url_for(page_params.merge(page: @partition_page - 1)) %>
+          <% end %>
+          <span class="muted">page <%= @partition_page %> / <%= total_pages %></span>
+          <% if @partition_page < total_pages %>
+            <%= link_to "next →", url_for(page_params.merge(page: @partition_page + 1)) %>
+          <% end %>
+        </div>
+      <% end %>
+    <% end %>
+  <% end %>
+</turbo-frame>
+
+<h2>Throttle buckets</h2>
+<% if @throttle_buckets.empty? %>
+  <p class="muted">No throttle buckets yet.</p>
+<% else %>
+  <table>
+    <thead>
+      <tr><th>Gate</th><th>Partition</th><th>Tokens</th><th>Refilled at</th></tr>
+    </thead>
+    <tbody>
+      <% @throttle_buckets.each do |b| %>
+        <tr>
+          <td><%= b.gate_name %></td>
+          <td><code><%= b.partition_key %></code></td>
+          <td><%= b.tokens.round(2) %></td>
+          <td><%= b.refilled_at.to_s(:short) rescue b.refilled_at %></td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% end %>
+
+<h2>Pending (first 50)</h2>
+<% if @pending_jobs.empty? %>
+  <p class="muted">Nothing waiting.</p>
+<% else %>
+  <table>
+    <thead>
+      <tr>
+        <th>ID</th><th>Dedupe key</th><th>Round-robin key</th>
+        <th>Priority</th><th>Staged at</th><th>Not before</th>
+      </tr>
+    </thead>
+    <tbody>
+      <% @pending_jobs.each do |job| %>
+        <tr>
+          <td><%= job.id %></td>
+          <td><%= job.dedupe_key ? content_tag(:code, job.dedupe_key) : content_tag(:span, '—', class: 'muted') %></td>
+          <td><%= job.round_robin_key ? content_tag(:code, job.round_robin_key) : content_tag(:span, '—', class: 'muted') %></td>
+          <td><%= job.priority %></td>
+          <td><%= job.staged_at %></td>
+          <td><%= job.not_before_at || content_tag(:span, '—', class: 'muted') %></td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% end %>

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

@@ -0,0 +1,266 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>DispatchPolicy</title>
+    <%= csrf_meta_tags %>
+    <meta name="turbo-refresh-method" content="morph">
+    <meta name="turbo-refresh-scroll" content="preserve">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/@hotwired/turbo@8.0.12/dist/turbo.es2017-umd.min.js"></script>
+    <style>
+      body { font-family: -apple-system, system-ui, sans-serif; max-width: 1200px; margin: 2em auto; padding: 0 1em; color: #222; }
+      h1 { font-size: 1.6em; margin-bottom: 0.25em; }
+      h2 { font-size: 1.2em; margin-top: 2em; border-bottom: 1px solid #ddd; padding-bottom: 0.25em; }
+      table { border-collapse: collapse; width: 100%; margin: 0.5em 0 1em; }
+      th, td { text-align: left; padding: 0.4em 0.6em; border-bottom: 1px solid #eee; }
+      th { font-size: 0.85em; text-transform: uppercase; color: #666; letter-spacing: 0.02em; }
+      code { background: #f4f4f4; padding: 0.1em 0.3em; border-radius: 3px; font-size: 0.9em; }
+      .muted { color: #888; }
+      .summary { display: flex; gap: 2em; margin: 1em 0; flex-wrap: wrap; }
+      .summary-item { min-width: 120px; }
+      .summary-item .value { font-size: 1.5em; font-weight: 600; }
+      .summary-item .label { font-size: 0.8em; color: #666; text-transform: uppercase; }
+      .summary-item .sub { font-size: 0.75em; color: #888; margin-top: 0.25em; }
+      .back { font-size: 0.9em; }
+      .stale { color: #c92a2a; }
+      .badge { display: inline-block; padding: 0.1em 0.5em; background: #eee; border-radius: 3px; font-size: 0.8em; margin-right: 0.25em; }
+      .text-end { text-align: right; }
+      .refresh-bar { display: flex; gap: 0.5em; align-items: center; justify-content: flex-end; font-size: 0.85em; margin-bottom: 0.5em; }
+      .refresh-bar button { font: inherit; background: transparent; text-decoration: none; padding: 0.15em 0.5em; border: 1px solid #ddd; border-radius: 3px; color: #555; cursor: pointer; }
+      .refresh-bar button.on { background: #e3f0d6; border-color: #b7d59c; color: #2b5a18; }
+      .refresh-bar button:hover { background: #f4f4f4; }
+      .refresh-bar button.on:hover { background: #d7e7c5; }
+      .chart-global { height: 220px; position: relative; margin: 0.5em 0 1em; }
+      .sparkline-cell { padding: 0.2em 0.6em 0.4em !important; border-bottom: 1px solid #eee !important; background: #fafafa; }
+      .sparkline-wrap { height: 70px; position: relative; }
+      .sparkline-empty { display: flex; align-items: center; justify-content: center; font-size: 0.85em; }
+      .chip { font: inherit; padding: 0.1em 0.5em; min-width: 1.6em; border: 1px solid #ccc; background: #fff; border-radius: 3px; cursor: pointer; font-size: 0.85em; color: #555; }
+      .chip:hover { background: #f4f4f4; }
+      .chip.on { background: #e3f0d6; border-color: #b7d59c; color: #2b5a18; cursor: default; }
+      .partition-search { margin: 0.75em 0; display: flex; gap: 0.5em; align-items: center; }
+      .partition-search input[type="text"] { font: inherit; padding: 0.25em 0.5em; border: 1px solid #ccc; border-radius: 3px; }
+      .partition-search input[type="submit"] { font: inherit; padding: 0.25em 0.75em; border: 1px solid #bbb; background: #f4f4f4; border-radius: 3px; cursor: pointer; }
+      .pagination { display: flex; gap: 1em; align-items: center; margin-top: 0.5em; font-size: 0.9em; }
+      th a { color: inherit; text-decoration: none; }
+      th a:hover { color: #0057b7; }
+      th a.sorted { color: #0057b7; }
+    </style>
+  </head>
+  <body>
+    <div class="refresh-bar">
+      <span class="muted">Auto-refresh:</span>
+      <% [ [ "off", 0 ], [ "2s", 2 ], [ "5s", 5 ], [ "15s", 15 ] ].each do |label, seconds| %>
+        <button type="button" data-refresh="<%= seconds %>"><%= label %></button>
+      <% end %>
+    </div>
+
+    <%= yield %>
+
+    <script>
+      (function () {
+        const KEY = "dispatch_policy_refresh_seconds";
+        let refreshTimer = null;
+
+        function scheduleRefresh() {
+          clearTimeout(refreshTimer);
+          const seconds = parseInt(localStorage.getItem(KEY) || "0", 10);
+          if (seconds <= 0) return;
+          refreshTimer = setTimeout(() => {
+            // Turbo.visit fetches + morphs thanks to the turbo-refresh-method
+            // meta tag, so the page updates in place without a full reload —
+            // scroll position, chart tooltips, form focus stay put.
+            if (window.Turbo) {
+              Turbo.visit(location.href, { action: "replace" });
+            } else {
+              location.reload();
+            }
+          }, seconds * 1000);
+        }
+
+        function wireRefreshButtons() {
+          const current = parseInt(localStorage.getItem(KEY) || "0", 10);
+          document.querySelectorAll(".refresh-bar button[data-refresh]").forEach(btn => {
+            btn.classList.toggle("on", parseInt(btn.dataset.refresh, 10) === current);
+            if (btn.dataset.wired) return;
+            btn.dataset.wired = "true";
+            btn.addEventListener("click", () => {
+              const v = parseInt(btn.dataset.refresh, 10);
+              if (v === 0) localStorage.removeItem(KEY);
+              else         localStorage.setItem(KEY, String(v));
+              wireRefreshButtons();
+              scheduleRefresh();
+            });
+          });
+        }
+
+        // Charts get destroyed + rebuilt on each render because Chart.js
+        // keeps a registry keyed by canvas element; the morphed canvases
+        // are fresh DOM, so previous Chart instances would leak listeners.
+        function destroyExistingCharts() {
+          if (!window.Chart) return;
+          Chart.instances && Object.values(Chart.instances).forEach(c => c.destroy && c.destroy());
+        }
+
+        // Chart.js initialization for canvases with data-chart.
+        const BLUE        = "#0057b7";
+        const BAR_FILL    = "rgba(0, 87, 183, 0.18)";
+        const TOOLTIP_FMT = {
+          titleFont: { size: 11 },
+          bodyFont:  { size: 11 },
+          padding:   6,
+          displayColors: false,
+          boxPadding: 3
+        };
+
+        function parseJSON(s, fallback) {
+          try { return JSON.parse(s); } catch (e) { return fallback; }
+        }
+
+        function renderCharts() {
+          if (!window.Chart) return;
+        document.querySelectorAll("canvas[data-chart]").forEach(canvas => {
+          const kind   = canvas.dataset.chart;
+          const values = parseJSON(canvas.dataset.values, []);
+          const labels = parseJSON(canvas.dataset.labels, []);
+          const counts = parseJSON(canvas.dataset.counts, []);
+          const label  = canvas.dataset.label || "";
+
+          const datasets = [];
+          if (counts.length) {
+            datasets.push({
+              type: "bar",
+              label: "completions/min",
+              data: counts,
+              backgroundColor: BAR_FILL,
+              borderWidth: 0,
+              yAxisID: "y1",
+              order: 2
+            });
+          }
+          datasets.push({
+            type: "line",
+            label: label || "ewma ms",
+            data: values,
+            borderColor: BLUE,
+            backgroundColor: "rgba(0, 87, 183, 0.1)",
+            tension: 0.25,
+            fill: kind === "line",
+            pointRadius: 0,
+            pointHoverRadius: 4,
+            pointHitRadius: 10,
+            borderWidth: kind === "sparkline" ? 1.5 : 2,
+            spanGaps: false,
+            yAxisID: "y",
+            order: 1
+          });
+
+          const isSpark = kind === "sparkline";
+          const config = {
+            data: { labels: labels.length ? labels : values.map((_, i) => i), datasets },
+            options: {
+              responsive: true, maintainAspectRatio: false,
+              interaction: { mode: "index", intersect: false },
+              plugins: {
+                legend: { display: false },
+                tooltip: Object.assign({}, TOOLTIP_FMT, {
+                  enabled: true,
+                  callbacks: {
+                    title: items => items[0].label,
+                    label: ctx => {
+                      if (ctx.dataset.yAxisID === "y1") {
+                        return `${ctx.parsed.y} completions`;
+                      }
+                      return ctx.parsed.y != null ? `${ctx.parsed.y} ms` : "no data";
+                    }
+                  }
+                })
+              },
+              scales: {
+                x: isSpark
+                  ? { display: false, min: 0, max: values.length - 1 }
+                  : { ticks: { maxTicksLimit: 12, autoSkip: true } },
+                y: isSpark
+                  ? { display: false, beginAtZero: true }
+                  : { beginAtZero: true, ticks: { callback: v => v + "ms" } },
+                y1: {
+                  position: "right",
+                  display: !isSpark,
+                  beginAtZero: true,
+                  grid: { drawOnChartArea: false },
+                  ticks: { callback: v => v + "/m" }
+                }
+              },
+              animation: false
+            }
+          };
+          new Chart(canvas, config);
+        });
+        }
+
+        // Watched-partitions manager. Scopes the localStorage list to the
+        // current policy (via [data-policy-name]); watch/unwatch clicks
+        // rewrite the URL's `watch` param and Turbo.visit into it.
+        function policyKey() {
+          const el = document.querySelector("[data-policy-name]");
+          return el ? `dp_watched:${el.dataset.policyName}` : null;
+        }
+        function getWatched() {
+          const key = policyKey(); if (!key) return [];
+          try { return JSON.parse(localStorage.getItem(key) || "[]"); } catch (_) { return []; }
+        }
+        function setWatched(arr) {
+          const key = policyKey(); if (!key) return;
+          localStorage.setItem(key, JSON.stringify(arr));
+          const url = new URL(location.href);
+          if (arr.length) url.searchParams.set("watch", arr.join(","));
+          else            url.searchParams.delete("watch");
+          if (window.Turbo) Turbo.visit(url.toString(), { action: "replace" });
+          else              location.href = url.toString();
+        }
+
+        function wireWatch() {
+          document.addEventListener("click", (e) => {
+            const add = e.target.closest("[data-watch]");
+            const rm  = e.target.closest("[data-unwatch]");
+            if (!add && !rm) return;
+            e.preventDefault();
+            const arr = getWatched();
+            if (add) {
+              if (!arr.includes(add.dataset.watch)) arr.push(add.dataset.watch);
+            } else {
+              const idx = arr.indexOf(rm.dataset.unwatch);
+              if (idx >= 0) arr.splice(idx, 1);
+            }
+            setWatched(arr);
+          }, { once: true });
+        }
+
+        // On first load, if localStorage has a watched list but the URL
+        // doesn't, inject it so the page renders the right partitions.
+        function syncWatchedIntoUrl() {
+          const arr = getWatched();
+          if (!arr.length) return;
+          const url = new URL(location.href);
+          if (url.searchParams.get("watch") === arr.join(",")) return;
+          url.searchParams.set("watch", arr.join(","));
+          if (window.Turbo) Turbo.visit(url.toString(), { action: "replace" });
+          else              location.replace(url.toString());
+        }
+
+        function boot() {
+          destroyExistingCharts();
+          wireRefreshButtons();
+          wireWatch();
+          renderCharts();
+          scheduleRefresh();
+          syncWatchedIntoUrl();
+        }
+
+        // Run on the initial load + whenever Turbo renders (morph or full).
+        document.addEventListener("DOMContentLoaded", boot);
+        document.addEventListener("turbo:render", boot);
+        document.addEventListener("turbo:load",   boot);
+      })();
+    </script>
+  </body>
+</html>

data/config/routes.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+DispatchPolicy::Engine.routes.draw do
+  root to: "policies#index"
+  resources :policies, only: %i[index show], param: :policy_name, constraints: { policy_name: %r{[^/]+} }
+end

data/db/migrate/20260424000001_create_dispatch_policy_tables.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class CreateDispatchPolicyTables < ActiveRecord::Migration[7.1]
+  def change
+    create_table :dispatch_policy_staged_jobs do |t|
+      t.string   :job_class,       null: false
+      t.string   :policy_name,     null: false
+      t.jsonb    :arguments,       null: false
+      t.jsonb    :snapshot,        null: false, default: {}
+      t.jsonb    :context,         null: false, default: {}
+      t.integer  :priority,        null: false, default: 100
+      t.datetime :not_before_at
+      t.datetime :staged_at,       null: false
+      t.datetime :admitted_at
+      t.datetime :completed_at
+      t.datetime :lease_expires_at
+      t.string   :active_job_id
+      t.string   :dedupe_key
+      t.string   :round_robin_key
+      t.jsonb    :partitions,      null: false, default: {}
+
+      t.timestamps
+    end
+
+    add_index :dispatch_policy_staged_jobs,
+      %i[policy_name priority staged_at],
+      where: "admitted_at IS NULL",
+      name: "idx_dp_staged_dispatch_order"
+
+    add_index :dispatch_policy_staged_jobs,
+      %i[policy_name dedupe_key],
+      unique: true,
+      where: "dedupe_key IS NOT NULL AND completed_at IS NULL",
+      name: "idx_dp_staged_dedupe_active"
+
+    add_index :dispatch_policy_staged_jobs,
+      %i[lease_expires_at],
+      where: "admitted_at IS NOT NULL",
+      name: "idx_dp_staged_lease_expires"
+
+    add_index :dispatch_policy_staged_jobs,
+      %i[completed_at],
+      where: "completed_at IS NOT NULL",
+      name: "idx_dp_staged_completed_at"
+
+    add_index :dispatch_policy_staged_jobs,
+      %i[policy_name round_robin_key priority staged_at],
+      where: "admitted_at IS NULL AND round_robin_key IS NOT NULL",
+      name: "idx_dp_staged_round_robin"
+
+    create_table :dispatch_policy_partition_counts do |t|
+      t.string  :policy_name,   null: false
+      t.string  :gate_name,     null: false
+      t.string  :partition_key, null: false, default: "default"
+      t.integer :in_flight,     null: false, default: 0
+
+      t.timestamps
+    end
+
+    add_index :dispatch_policy_partition_counts,
+      %i[policy_name gate_name partition_key],
+      unique: true,
+      name: "idx_dp_partition_counts_unique"
+
+    create_table :dispatch_policy_throttle_buckets do |t|
+      t.string   :policy_name,   null: false
+      t.string   :gate_name,     null: false
+      t.string   :partition_key, null: false, default: "default"
+      t.float    :tokens,        null: false
+      t.datetime :refilled_at,   null: false
+
+      t.timestamps
+    end
+
+    add_index :dispatch_policy_throttle_buckets,
+      %i[policy_name gate_name partition_key],
+      unique: true,
+      name: "idx_dp_throttle_buckets_unique"
+  end
+end

data/db/migrate/20260424000002_create_adaptive_concurrency_stats.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class CreateAdaptiveConcurrencyStats < ActiveRecord::Migration[7.1]
+  def change
+    create_table :dispatch_policy_adaptive_concurrency_stats do |t|
+      t.string   :policy_name,     null: false
+      t.string   :gate_name,       null: false
+      t.string   :partition_key,   null: false, default: "default"
+      t.integer  :current_max,     null: false
+      t.float    :ewma_latency_ms, null: false, default: 0
+      t.integer  :sample_count,    null: false, default: 0
+      t.datetime :last_observed_at
+
+      t.timestamps
+    end
+
+    add_index :dispatch_policy_adaptive_concurrency_stats,
+      %i[policy_name gate_name partition_key],
+      unique: true,
+      name: "idx_dp_adaptive_concurrency_stats_unique"
+  end
+end

data/db/migrate/20260424000003_create_adaptive_concurrency_samples.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class CreateAdaptiveConcurrencySamples < ActiveRecord::Migration[7.1]
+  def change
+    create_table :dispatch_policy_adaptive_concurrency_samples do |t|
+      t.string   :policy_name,     null: false
+      t.string   :gate_name,       null: false
+      t.string   :partition_key,   null: false
+      t.datetime :minute_bucket,   null: false
+      t.float    :ewma_latency_ms, null: false, default: 0
+      t.integer  :current_max,     null: false
+
+      t.timestamps
+    end
+
+    add_index :dispatch_policy_adaptive_concurrency_samples,
+      %i[policy_name gate_name partition_key minute_bucket],
+      unique: true,
+      name: "idx_dp_adaptive_concurrency_samples_unique"
+
+    add_index :dispatch_policy_adaptive_concurrency_samples,
+      :minute_bucket,
+      name: "idx_dp_adaptive_concurrency_samples_time"
+  end
+end

data/db/migrate/20260424000004_rename_samples_to_partition_observations.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class RenameSamplesToPartitionObservations < ActiveRecord::Migration[7.1]
+  def up
+    drop_table :dispatch_policy_adaptive_concurrency_samples, if_exists: true
+
+    create_table :dispatch_policy_partition_observations do |t|
+      t.string   :policy_name,       null: false
+      t.string   :partition_key,     null: false
+      t.datetime :minute_bucket,     null: false
+      t.bigint   :total_lag_ms,      null: false, default: 0
+      t.integer  :observation_count, null: false, default: 0
+      t.integer  :max_lag_ms,        null: false, default: 0
+      t.integer  :current_max
+
+      t.timestamps
+    end
+
+    add_index :dispatch_policy_partition_observations,
+      %i[policy_name partition_key minute_bucket],
+      unique: true,
+      name: "idx_dp_partition_observations_unique"
+
+    add_index :dispatch_policy_partition_observations,
+      :minute_bucket,
+      name: "idx_dp_partition_observations_time"
+  end
+
+  def down
+    drop_table :dispatch_policy_partition_observations
+  end
+end