dispatch_policy 0.2.0 → 0.4.0

data/app/models/dispatch_policy/adaptive_concurrency_stats.rb

@@ -1,89 +1,19 @@
 # frozen_string_literal: true
 
 module DispatchPolicy
+  # One row per (policy_name, partition_key) for partitions whose policy
+  # declares an `:adaptive_concurrency` gate. Holds the AIMD-tuned
+  # `current_max` plus the EWMA of recent queue-lag observations the cap
+  # adapts on.
+  #
+  # Read by `Gates::AdaptiveConcurrency#evaluate` to learn how many jobs
+  # this partition may admit right now. Written atomically by
+  # `Repository.adaptive_record!` from `InflightTracker.track`'s ensure
+  # block after each perform — the EWMA + AIMD update lives in a single
+  # SQL statement so concurrent workers can't race on read-modify-write.
   class AdaptiveConcurrencyStats < ApplicationRecord
     self.table_name = "dispatch_policy_adaptive_concurrency_stats"
 
-    # Seed a stats row if one doesn't exist yet. Mirrors ThrottleBucket.lock.
-    def self.seed!(policy_name:, gate_name:, partition_key:, initial_max:)
-      now = Time.current
-      sql = <<~SQL.squish
-        INSERT INTO #{quoted_table_name}
-          (policy_name, gate_name, partition_key, current_max,
-           ewma_latency_ms, sample_count, created_at, updated_at)
-        VALUES (?, ?, ?, ?, 0, 0, ?, ?)
-        ON CONFLICT (policy_name, gate_name, partition_key) DO NOTHING
-      SQL
-      connection.exec_update(
-        sanitize_sql_array([
-          sql, policy_name, gate_name.to_s, partition_key.to_s,
-          initial_max.to_i, now, now
-        ])
-      )
-    end
-
-    def self.fetch_many(policy_name:, gate_name:, partition_keys:)
-      return {} if partition_keys.empty?
-      where(policy_name: policy_name, gate_name: gate_name.to_s, partition_key: partition_keys)
-        .pluck(:partition_key, :current_max, :ewma_latency_ms)
-        .each_with_object({}) { |(k, c, l), h| h[k] = { current_max: c, ewma_latency_ms: l } }
-    end
-
-    # Single-statement EWMA + AIMD update so concurrent performs can't race
-    # on read-modify-write. Seed first (INSERT ON CONFLICT DO NOTHING), then
-    # apply the adjustment.
-    def self.record_observation!(
-      policy_name:, gate_name:, partition_key:,
-      queue_lag_ms:, succeeded:,
-      alpha:, min:, target_lag_ms:,
-      fail_factor:, slow_factor:, initial_max:
-    )
-      seed!(
-        policy_name:   policy_name,
-        gate_name:     gate_name,
-        partition_key: partition_key,
-        initial_max:   initial_max
-      )
-
-      # Feedback signal is queue_lag (admitted_at → perform_start). When
-      # the adapter queue is empty, lag ≈ 0 → +1 grow. When the queue
-      # backs up, lag rises past target → multiplicative shrink. Failures
-      # shrink harder. Only `min` is enforced so a partition can't lock
-      # out entirely.
-      sql = <<~SQL.squish
-        UPDATE #{quoted_table_name}
-        SET
-          ewma_latency_ms = ewma_latency_ms * (1 - ?) + ? * ?,
-          sample_count    = sample_count + 1,
-          current_max = GREATEST(?, CASE
-            WHEN ? = FALSE                                THEN FLOOR(current_max * ?)::int
-            WHEN (ewma_latency_ms * (1 - ?) + ? * ?) > ?  THEN FLOOR(current_max * ?)::int
-            ELSE current_max + 1
-          END),
-          last_observed_at = ?,
-          updated_at       = ?
-        WHERE policy_name = ? AND gate_name = ? AND partition_key = ?
-      SQL
-
-      now = Time.current
-      connection.exec_update(
-        sanitize_sql_array([
-          sql,
-          alpha, alpha, queue_lag_ms,
-          min.to_i,
-          succeeded, fail_factor,
-          alpha, alpha, queue_lag_ms, target_lag_ms, slow_factor,
-          now, now,
-          policy_name, gate_name.to_s, partition_key.to_s
-        ])
-      )
-    end
-
-    # Quick lookup used by Dispatchable to denormalize current_max into
-    # the generic partition observation row.
-    def self.current_max_for(policy_name:, partition_key:)
-      where(policy_name: policy_name, partition_key: partition_key.to_s)
-        .limit(1).pick(:current_max)
-    end
+    scope :for_policy, ->(name) { where(policy_name: name) }
   end
 end

data/app/models/dispatch_policy/inflight_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DispatchPolicy
+  class InflightJob < ApplicationRecord
+    self.table_name = "dispatch_policy_inflight_jobs"
+
+    scope :for_partition, ->(policy_name, partition_key) {
+      where(policy_name: policy_name, partition_key: partition_key)
+    }
+    scope :stale, ->(cutoff) { where("heartbeat_at < ?", cutoff) }
+  end
+end

data/app/models/dispatch_policy/partition.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DispatchPolicy
+  class Partition < ApplicationRecord
+    self.table_name = "dispatch_policy_partitions"
+
+    scope :for_policy, ->(name) { where(policy_name: name) }
+    scope :for_shard,  ->(s)    { s ? where(shard: s) : all }
+    scope :active,     -> { where(status: "active") }
+    scope :paused,     -> { where(status: "paused") }
+    scope :pending,    -> { where("pending_count > 0") }
+    scope :stale_inactive, ->(cutoff) {
+      where("pending_count = 0 AND in_flight_count = 0")
+        .where("last_admit_at < ? OR (last_admit_at IS NULL AND created_at < ?)", cutoff, cutoff)
+    }
+
+    def paused?
+      status == "paused"
+    end
+  end
+end

data/app/models/dispatch_policy/staged_job.rb

@@ -4,102 +4,9 @@ module DispatchPolicy
   class StagedJob < ApplicationRecord
     self.table_name = "dispatch_policy_staged_jobs"
 
-    scope :pending,   -> { where(admitted_at: nil, completed_at: nil) }
-    scope :admitted,  -> { where.not(admitted_at: nil).where(completed_at: nil) }
-    scope :completed, -> { where.not(completed_at: nil) }
-    scope :active,    -> { where(completed_at: nil) }
-    scope :expired_leases, -> {
-      admitted.where("lease_expires_at IS NOT NULL AND lease_expires_at < ?", Time.current)
-    }
-
-    # Merge the job's ActiveJob metadata (queue_name, priority) into the
-    # context hash so gate lambdas can partition_by :queue_name without
-    # the user having to pass it as a kwarg. User-provided keys win.
-    def self.context_for(job_instance, policy)
-      built = policy.context_builder.call(job_instance.arguments)
-      return built unless built.is_a?(Hash)
-      {
-        queue_name: job_instance.queue_name,
-        priority:   job_instance.priority
-      }.merge(built.symbolize_keys)
-    end
-
-    # Stages a job in the admission queue. Returns the created row, or nil if
-    # the policy declares a dedupe_key and an active row already exists.
-    def self.stage!(job_instance:, policy:)
-      dedupe_key = policy.build_dedupe_key(job_instance.arguments)
-
-      if dedupe_key && exists?(policy_name: policy.name, dedupe_key: dedupe_key, completed_at: nil)
-        return nil
-      end
-
-      create!(
-        job_class:       job_instance.class.name,
-        policy_name:     policy.name,
-        arguments:       job_instance.serialize,
-        snapshot:        policy.build_snapshot(job_instance.arguments),
-        context:         context_for(job_instance, policy),
-        priority:        job_instance.priority || 100,
-        not_before_at:   job_instance.scheduled_at,
-        staged_at:       Time.current,
-        dedupe_key:      dedupe_key,
-        round_robin_key: policy.build_round_robin_key(job_instance.arguments)
-      )
-    rescue ActiveRecord::RecordNotUnique
-      nil
-    end
-
-    # Batch-insert variant of stage!.
-    def self.stage_many!(policy:, jobs:)
-      return 0 if jobs.empty?
-
-      now = Time.current
-      rows = jobs.map do |job_instance|
-        {
-          job_class:       job_instance.class.name,
-          policy_name:     policy.name,
-          arguments:       job_instance.serialize,
-          snapshot:        policy.build_snapshot(job_instance.arguments),
-          context:         context_for(job_instance, policy),
-          priority:        job_instance.priority || 100,
-          not_before_at:   job_instance.scheduled_at,
-          staged_at:       now,
-          dedupe_key:      policy.build_dedupe_key(job_instance.arguments),
-          round_robin_key: policy.build_round_robin_key(job_instance.arguments),
-          partitions:      {},
-          created_at:      now,
-          updated_at:      now
-        }
-      end
-
-      result = insert_all(rows, unique_by: :idx_dp_staged_dedupe_active)
-      result.rows.size
-    end
-
-    def self.mark_completed_by_active_job_id(active_job_id)
-      return 0 if active_job_id.blank?
-      where(active_job_id: active_job_id, completed_at: nil)
-        .update_all(completed_at: Time.current, lease_expires_at: nil)
-    end
-
-    def mark_admitted!(partitions:)
-      now = Time.current
-      job = instantiate_active_job
-      job._dispatch_partitions  = partitions
-      job._dispatch_admitted_at = now
-
-      update!(
-        admitted_at:      now,
-        lease_expires_at: now + DispatchPolicy.config.lease_duration,
-        active_job_id:    job.job_id,
-        partitions:       partitions
-      )
-
-      job
-    end
-
-    def instantiate_active_job
-      ActiveJob::Base.deserialize(arguments)
-    end
+    scope :for_policy,    ->(name) { where(policy_name: name) }
+    scope :for_partition, ->(name, key) { where(policy_name: name, partition_key: key) }
+    scope :due,           -> { where("scheduled_at IS NULL OR scheduled_at <= now()") }
+    scope :recent,        -> { order(enqueued_at: :desc) }
   end
 end

data/app/models/dispatch_policy/tick_sample.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DispatchPolicy
+  class TickSample < ApplicationRecord
+    self.table_name = "dispatch_policy_tick_samples"
+
+    scope :for_policy, ->(name) { where(policy_name: name) }
+    scope :since,      ->(time) { where("sampled_at >= ?", time) }
+    scope :recent,     -> { order(sampled_at: :desc) }
+  end
+end

data/app/views/dispatch_policy/dashboard/index.html.erb

@@ -0,0 +1,109 @@
+  <section class="dp-stats">
+    <div class="dp-stat"><span class="dp-stat-label">Staged</span><span class="dp-stat-value"><%= format_count(@totals[:staged]) %></span></div>
+    <div class="dp-stat"><span class="dp-stat-label">Partitions</span><span class="dp-stat-value"><%= format_count(@totals[:partitions]) %></span></div>
+    <div class="dp-stat"><span class="dp-stat-label">Active</span><span class="dp-stat-value"><%= format_count(@totals[:active_parts]) %></span></div>
+    <div class="dp-stat"><span class="dp-stat-label">Paused</span><span class="dp-stat-value <%= "dp-warn" if @totals[:paused_parts].positive? %>"><%= format_count(@totals[:paused_parts]) %></span></div>
+    <div class="dp-stat"><span class="dp-stat-label">In flight</span><span class="dp-stat-value"><%= format_count(@totals[:in_flight]) %></span></div>
+  </section>
+
+  <%= render "dispatch_policy/shared/hints", hints: @hints %>
+  <%= render "dispatch_policy/shared/capacity",
+             capacity: @capacity,
+             pending_trend: @pending_trend,
+             pending_buckets: @pending_buckets %>
+
+  <section class="dp-section">
+    <h2>Throughput</h2>
+    <table class="dp-table">
+      <thead>
+        <tr><th>Window</th><th class="dp-num">Jobs admitted</th><th class="dp-num">Ticks</th><th class="dp-num">Avg tick</th><th class="dp-num">Max tick</th><th class="dp-num">Forward fail</th></tr>
+      </thead>
+      <tbody>
+        <% @windows.each do |label, m| %>
+          <% fail_pct = m[:jobs_admitted].positive? ? (m[:forward_failures].to_f / m[:jobs_admitted] * 100) : 0.0 %>
+          <tr>
+            <td><strong><%= label %></strong></td>
+            <td class="dp-num"><%= format_count(m[:jobs_admitted]) %></td>
+            <td class="dp-num"><%= format_count(m[:ticks]) %></td>
+            <td class="dp-num"><%= format_duration_ms(m[:avg_duration_ms]) %></td>
+            <td class="dp-num"><%= format_duration_ms(m[:max_duration_ms]) %></td>
+            <td class="dp-num <%= "dp-warn" if fail_pct >= 1.0 %>">
+              <%= format_count(m[:forward_failures]) %>
+              <% if m[:jobs_admitted].positive? && m[:forward_failures].positive? %>
+                <span style="color:#9ca3af; font-size:11px;">(<%= format("%.2f%%", fail_pct) %>)</span>
+              <% end %>
+            </td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </section>
+
+  <section class="dp-section">
+    <h2>Round-trip across active partitions</h2>
+    <% if @round_trip[:active_partitions].zero? %>
+      <p class="dp-empty">No active partitions with pending jobs.</p>
+    <% else %>
+      <div class="dp-stats">
+        <div class="dp-stat"><span class="dp-stat-label">Active w/ pending</span><span class="dp-stat-value"><%= format_count(@round_trip[:active_partitions]) %></span></div>
+        <div class="dp-stat"><span class="dp-stat-label">Never checked</span><span class="dp-stat-value <%= "dp-warn" if @round_trip[:never_checked].positive? %>"><%= format_count(@round_trip[:never_checked]) %></span></div>
+        <div class="dp-stat"><span class="dp-stat-label">In backoff</span><span class="dp-stat-value"><%= format_count(@round_trip[:in_backoff]) %></span></div>
+        <div class="dp-stat"><span class="dp-stat-label">Oldest age</span><span class="dp-stat-value"><%= format_duration_seconds(@round_trip[:oldest_age_seconds]) %></span></div>
+        <div class="dp-stat"><span class="dp-stat-label">P50 age</span><span class="dp-stat-value"><%= format_duration_seconds(@round_trip[:p50_age_seconds]) %></span></div>
+        <div class="dp-stat"><span class="dp-stat-label">P95 age</span><span class="dp-stat-value"><%= format_duration_seconds(@round_trip[:p95_age_seconds]) %></span></div>
+      </div>
+      <p class="dp-hint">
+        If <strong>oldest age</strong> is bigger than your tolerable latency for the slowest partition, increase
+        <code>partition_batch_size</code> or shard ticks per <code>policy_name</code>.
+        If <strong>never checked</strong> stays positive across refreshes, the tick is not keeping up — same remedy.
+      </p>
+    <% end %>
+  </section>
+
+  <section class="dp-section">
+    <h2>Policies</h2>
+    <% if @policies.empty? %>
+      <p class="dp-empty">No policies have produced staged jobs yet.</p>
+    <% else %>
+      <table class="dp-table">
+        <thead>
+          <tr>
+            <th>Name</th>
+            <th class="dp-num">Pending</th>
+            <th class="dp-num">In flight</th>
+            <th class="dp-num">Admit/min (1m)</th>
+            <th class="dp-num">Ticks (1m)</th>
+            <th class="dp-num">Avg tick</th>
+            <th class="dp-num">P95 age</th>
+            <th class="dp-num">Backoff</th>
+            <th>Top denial</th>
+            <th>Last admit</th>
+            <th></th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @policies.each do |p| %>
+            <tr>
+              <td><%= link_to p[:name], policy_path(p[:name]), class: "dp-link" %></td>
+              <td class="dp-num"><%= format_count(p[:pending]) %></td>
+              <td class="dp-num"><%= format_count(p[:in_flight]) %></td>
+              <td class="dp-num"><%= format_count(p[:admitted_1m]) %></td>
+              <td class="dp-num"><%= format_count(p[:ticks_1m]) %></td>
+              <td class="dp-num"><%= format_duration_ms(p[:avg_tick_ms_1m]) %></td>
+              <td class="dp-num"><%= format_duration_seconds(p[:p95_age_seconds]) %></td>
+              <td class="dp-num <%= "dp-warn" if p[:in_backoff].to_i.positive? %>"><%= format_count(p[:in_backoff]) %></td>
+              <td>
+                <% if p[:top_denial_reason] %>
+                  <code><%= p[:top_denial_reason] %></code> ×<%= p[:top_denial_count] %>
+                <% else %>
+                  —
+                <% end %>
+              </td>
+              <td><%= format_time(p[:last_admit_at]) %></td>
+              <td><%= link_to "Partitions →", partitions_path(policy: p[:name]), class: "dp-link" %></td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    <% end %>
+  </section>

data/app/views/dispatch_policy/partitions/index.html.erb

@@ -0,0 +1,63 @@
+<h1>
+  Partitions<% if @policy %> · <code><%= @policy %></code><% end %><% if @shard %> · shard <code><%= @shard %></code><% end %>
+  <small style="font-weight:400; color:#6b7280; font-size:14px;">
+    <%= format_count(@total) %> match<%= @total == 1 ? "" : "es" %>
+  </small>
+</h1>
+
+<%= form_with url: partitions_path, method: :get, local: true, class: "dp-search-form" do |f| %>
+  <%= f.hidden_field :policy, value: @policy if @policy.present? %>
+  <% if @shards.size > 1 %>
+    <%= f.select :shard, [["all shards", ""]] + @shards.map { |s| [s, s] }, { selected: @shard }, class: "dp-input" %>
+  <% elsif @shards.size == 1 %>
+    <%= f.hidden_field :shard, value: @shard if @shard.present? %>
+  <% end %>
+  <%= f.text_field :q, value: @query, placeholder: "search partition_key…", class: "dp-input" %>
+  <%= f.select :sort,
+        DispatchPolicy::CursorPagination::SORTS.map { |k, defn| ["sort: #{defn[:label]}", k] },
+        { selected: @sort },
+        class: "dp-input" %>
+  <label style="font-size:12.5px; margin: 0 6px;">
+    <%= f.check_box :only_pending, { checked: @only_pending }, "1", "0" %>
+    only pending&gt;0
+  </label>
+  <%= f.submit "Apply", class: "dp-btn" %>
+<% end %>
+
+<% if @partitions.any? %>
+  <table class="dp-table">
+    <thead>
+      <tr>
+        <th>Policy</th><th>Shard</th><th>Queue</th><th>Partition key</th><th>Status</th>
+        <th class="dp-num">Pending</th><th class="dp-num">Lifetime</th>
+        <th>Next eligible</th><th>Last admit</th><th>Last enq</th>
+      </tr>
+    </thead>
+    <tbody>
+      <% @partitions.each do |p| %>
+        <%= render "dispatch_policy/shared/partition_row", partition: p %>
+      <% end %>
+    </tbody>
+  </table>
+
+  <div class="dp-pagination">
+    <span class="dp-pagination-info">
+      <%= format_count(@partitions.size) %> shown
+      <% if @cursor %> · paged via cursor — use the browser back button to go back <% end %>
+    </span>
+    <span class="dp-pagination-nav">
+      <% if @cursor %>
+        <%= link_to "« first", partitions_path(pagination_params(cursor: nil)), class: "dp-btn" %>
+      <% else %>
+        <span class="dp-btn dp-btn-disabled">« first</span>
+      <% end %>
+      <% if @next_cursor %>
+        <%= link_to "next ›",  partitions_path(pagination_params(cursor: @next_cursor)), class: "dp-btn" %>
+      <% else %>
+        <span class="dp-btn dp-btn-disabled">next ›</span>
+      <% end %>
+    </span>
+  </div>
+<% else %>
+  <p class="dp-empty">No partitions match.</p>
+<% end %>

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

@@ -0,0 +1,106 @@
+<h1>
+  <%= link_to "← all partitions", partitions_path(policy: @partition.policy_name), class: "dp-link" %>
+  /
+  <code><%= @partition.partition_key %></code>
+</h1>
+
+<% in_backoff = @partition.next_eligible_at && @partition.next_eligible_at > Time.current %>
+<% age_seconds = @partition.last_checked_at && (Time.current - @partition.last_checked_at) %>
+<% half_life = (DispatchPolicy.registry.fetch(@partition.policy_name)&.fairness_half_life_seconds || DispatchPolicy.config.fairness_half_life_seconds).to_f %>
+<%
+  decayed_now =
+    if @partition.decayed_admits_at && half_life.positive?
+      tau = half_life / Math.log(2)
+      elapsed = [Time.current.to_f - @partition.decayed_admits_at.to_f, 0.0].max
+      @partition.decayed_admits.to_f * Math.exp(-elapsed / tau)
+    else
+      @partition.decayed_admits.to_f
+    end
+  admits_per_min_estimate = decayed_now * (Math.log(2) / half_life) * 60.0 if half_life.positive?
+%>
+
+<section class="dp-stats">
+  <div class="dp-stat"><span class="dp-stat-label">Policy</span><span class="dp-stat-value"><%= @partition.policy_name %></span></div>
+  <div class="dp-stat"><span class="dp-stat-label">Shard</span><span class="dp-stat-value"><code><%= @partition.shard %></code></span></div>
+  <div class="dp-stat"><span class="dp-stat-label">Queue</span><span class="dp-stat-value"><%= @partition.queue_name || "—" %></span></div>
+  <div class="dp-stat"><span class="dp-stat-label">Status</span><span class="dp-stat-value <%= "dp-warn" if @partition.paused? %>"><%= @partition.status %></span></div>
+  <div class="dp-stat"><span class="dp-stat-label">Pending</span><span class="dp-stat-value"><%= format_count(@partition.pending_count) %></span></div>
+  <div class="dp-stat"><span class="dp-stat-label">Lifetime admitted</span><span class="dp-stat-value"><%= format_count(@partition.total_admitted) %></span></div>
+  <div class="dp-stat"><span class="dp-stat-label">Round-trip age</span><span class="dp-stat-value"><%= age_seconds ? format_duration_seconds(age_seconds) : "never" %></span></div>
+  <div class="dp-stat"><span class="dp-stat-label">Backoff</span><span class="dp-stat-value <%= "dp-warn" if in_backoff %>"><%= in_backoff ? "until #{format_time(@partition.next_eligible_at)}" : "—" %></span></div>
+  <div class="dp-stat">
+    <span class="dp-stat-label">Recent admits (EWMA)</span>
+    <span class="dp-stat-value"><%= format("%.2f", decayed_now) %></span>
+  </div>
+  <% if admits_per_min_estimate %>
+    <div class="dp-stat">
+      <span class="dp-stat-label">≈ admits/min</span>
+      <span class="dp-stat-value"><%= format("%.1f", admits_per_min_estimate) %></span>
+    </div>
+  <% end %>
+</section>
+
+<section class="dp-hint">
+  <strong>Recent admits (EWMA)</strong> is an exponentially weighted count of admissions for this partition,
+  with a half-life of <%= half_life.to_i %>s. The Tick reorders claimed partitions by this value ASC, so the
+  least-recently-active ones get first crack at the tick budget. The "≈ admits/min" line reads it as the
+  steady-state admission rate.
+</section>
+
+<section class="dp-section">
+  <h2>Timing</h2>
+  <ul class="dp-list">
+    <li>Last checked: <%= format_time(@partition.last_checked_at) %></li>
+    <li>Last admit: <%= format_time(@partition.last_admit_at) %></li>
+    <li>Last enqueued: <%= format_time(@partition.last_enqueued_at) %></li>
+    <li>Next eligible: <%= format_time(@partition.next_eligible_at) %></li>
+    <li>Context updated: <%= format_time(@partition.context_updated_at) %></li>
+  </ul>
+</section>
+
+<section class="dp-section">
+  <h2>Context (refreshed on each enqueue)</h2>
+  <pre class="dp-json"><%= JSON.pretty_generate(@partition.context || {}) %></pre>
+</section>
+
+<section class="dp-section">
+  <h2>Gate state</h2>
+  <pre class="dp-json"><%= JSON.pretty_generate(@partition.gate_state || {}) %></pre>
+</section>
+
+<section class="dp-section">
+  <h2>Recent staged jobs (max 50)</h2>
+  <% if @recent_jobs.any? %>
+    <table class="dp-table">
+      <thead><tr><th>id</th><th>Job class</th><th>Scheduled</th><th>Enqueued</th><th></th></tr></thead>
+      <tbody>
+        <% @recent_jobs.each do |j| %>
+          <tr>
+            <td><%= j.id %></td>
+            <td><code><%= j.job_class %></code></td>
+            <td><%= format_time(j.scheduled_at) %></td>
+            <td><%= format_time(j.enqueued_at) %></td>
+            <td><%= link_to "inspect", staged_job_path(j), class: "dp-link" %></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  <% else %>
+    <p class="dp-empty">No staged jobs in this partition.</p>
+  <% end %>
+</section>
+
+<section class="dp-section">
+  <h2>Actions</h2>
+  <%= button_to "Force admit 1",  admit_partition_path(@partition, count: 1),   class: "dp-btn", method: :post, form: { class: "dp-form-inline" } %>
+  <%= button_to "Force admit 10", admit_partition_path(@partition, count: 10),  class: "dp-btn", method: :post, form: { class: "dp-form-inline" } %>
+  <%= button_to "Drain partition", drain_partition_path(@partition),
+                class:  "dp-btn dp-btn-warn",
+                method: :post,
+                form: { class: "dp-form-inline",
+                        onsubmit: "return confirm('Force-admit every staged job in this partition, bypassing all gates? This sends them to the real adapter immediately.');" } %>
+  <p class="dp-hint">
+    <strong>Drain</strong> empties the partition by sending every staged job to the real adapter without consulting throttle/concurrency gates.
+    Capped at 10,000 jobs per click — click again for more.
+  </p>
+</section>

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

@@ -1,49 +1,27 @@
-<h1>DispatchPolicy</h1>
-<p class="muted">Admission-control policies registered in this app.</p>
+<h1>Policies</h1>
 
-<div class="summary">
-  <div class="summary-item">
-    <div class="label">Active partitions</div>
-    <div class="value"><%= @active_partitions %></div>
-  </div>
-  <div class="summary-item">
-    <div class="label">Expired leases</div>
-    <div class="value"><%= @expired_leases %></div>
-  </div>
-</div>
-
-<h2>Policies</h2>
-<% if @policies.empty? %>
-  <p class="muted">No policies registered yet.</p>
+<% if @rows.empty? %>
+  <p class="dp-empty">No policies registered or observed.</p>
 <% else %>
-  <table>
+  <table class="dp-table">
     <thead>
       <tr>
-        <th>Policy</th>
-        <th>Job class</th>
-        <th>Pending</th>
-        <th>Admitted</th>
-        <th>Completed (24h)</th>
-        <th>Oldest pending</th>
+        <th>Name</th><th class="dp-num">Pending</th><th class="dp-num">In flight</th>
+        <th class="dp-num">Partitions</th><th class="dp-num">Paused</th><th>Registered</th><th></th>
       </tr>
     </thead>
     <tbody>
-      <% @policies.each do |p| %>
+      <% @rows.each do |row| %>
         <tr>
-          <td><%= link_to p[:name], policy_path(policy_name: p[:name]) %></td>
-          <td><code><%= p[:job_class].name %></code></td>
-          <td><%= p[:pending_count] %></td>
-          <td><%= p[:admitted_count] %></td>
-          <td><%= p[:completed_24h] %></td>
+          <td><%= link_to row[:name], policy_path(row[:name]), class: "dp-link" %></td>
+          <td class="dp-num"><%= format_count(row[:pending]) %></td>
+          <td class="dp-num"><%= format_count(row[:in_flight]) %></td>
+          <td class="dp-num"><%= format_count(row[:partitions]) %></td>
+          <td class="dp-num"><%= row[:paused_count].positive? ? content_tag(:span, format_count(row[:paused_count]), class: "dp-warn") : 0 %></td>
+          <td><%= row[:registered] ? "yes" : content_tag(:span, "no (orphan)", class: "dp-warn") %></td>
           <td>
-            <% if p[:oldest_pending] %>
-              <% stale = p[:oldest_pending] < Time.current - p[:stale_threshold] %>
-              <span class="<%= 'stale' if stale %>">
-                <%= time_ago_in_words(p[:oldest_pending]) %> ago
-              </span>
-            <% else %>
-              <span class="muted">—</span>
-            <% end %>
+            <%= button_to "Pause",  pause_policy_path(row[:name]),  class: "dp-btn", method: :post, form: { class: "dp-form-inline" } %>
+            <%= button_to "Resume", resume_policy_path(row[:name]), class: "dp-btn dp-btn-ok", method: :post, form: { class: "dp-form-inline" } %>
           </td>
         </tr>
       <% end %>