chrono_forge-dashboard 0.1.0 → 0.2.0

data/app/presenters/chrono_forge/dashboard/cytoscape_graph.rb

@@ -0,0 +1,48 @@
+module ChronoForge
+  module Dashboard
+    # Builds Cytoscape.js "elements" (nodes + edges) from overlay node hashes and
+    # Definition edges. Unlike a text-DSL renderer, this emits STRUCTURED data the
+    # client consumes directly (via JSON.parse), so node labels and guard text need
+    # no escaping — the whole class of Mermaid string-grammar bugs disappears.
+    # Rendering-only: no DB, no analysis.
+    class CytoscapeGraph
+      def initialize(nodes, edges)
+        @nodes = nodes
+        @edges = edges
+      end
+
+      def to_h
+        {nodes: node_elements, edges: edge_elements}
+      end
+
+      private
+
+      def node_elements
+        real_ids = @nodes.map { |n| n[:id] }.to_set
+        real = @nodes.map do |n|
+          data = {id: n[:id], label: n[:label].to_s, step_name: n[:step_name]}
+          # Run aggregates the overlay computed for this node: a repeat's execution
+          # count and a branch fan-out's per-state child tally. Forwarded so the
+          # client can label them (nil/absent for other kinds).
+          data[:repetitions] = n[:repetitions] if n[:repetitions]
+          data[:counts] = n[:counts] if n[:counts]&.any?
+          {data: data, classes: "kind-#{n[:kind]} status-#{n[:status]}"}
+        end
+        # start/halt (and any other virtual endpoint) are edge targets but not in
+        # the node list; Cytoscape rejects edges to missing nodes, so synthesize
+        # them as endpoint nodes.
+        endpoints = @edges.flat_map { |e| [e.from, e.to] }.uniq.reject { |id| real_ids.include?(id) }
+        real + endpoints.map { |id| {data: {id: id, label: id}, classes: "kind-endpoint"} }
+      end
+
+      def edge_elements
+        @edges.each_with_index.map do |e, i|
+          {
+            data: {id: "e#{i}", source: e.from, target: e.to, label: e.guard.to_s},
+            classes: "kind-#{e.kind}"
+          }
+        end
+      end
+    end
+  end
+end

data/app/presenters/chrono_forge/dashboard/definition_overlay.rb

@@ -0,0 +1,128 @@
+module ChronoForge
+  module Dashboard
+    # Overlays a workflow run's execution_logs onto a static Definition, producing
+    # per-node hashes with a runtime :status (and fan-out/repeat aggregates).
+    # Read-only. The Definition is the static map; logs are the source of truth
+    # for a specific run.
+    class DefinitionOverlay
+      # ExecutionLog's state enum is only pending/completed/failed. "pending" means
+      # reached-but-unfinished (in progress), so it maps to :active; the fetch
+      # default below catches any state added later.
+      LOG_STATUS = {"completed" => :done, "failed" => :failed, "pending" => :active}.freeze
+
+      def initialize(definition, workflow)
+        @definition = definition
+        @workflow = workflow
+      end
+
+      def nodes
+        mapped = @definition.nodes.map { |n| overlay(n) }
+        mapped + unmapped_nodes(mapped)
+      end
+
+      def warnings = @definition.warnings
+
+      private
+
+      def overlay(node)
+        base = node.to_h.merge(status: :not_reached)
+        case node.kind
+        when :branch then base.merge(fanout_status(node))
+        when :repeat then base.merge(repeat_status(node))
+        when :dynamic then base.merge(dynamic_status(node))
+        else
+          log = logs_by_name[node.step_name]
+          log ? base.merge(status: LOG_STATUS.fetch(log_state(log), :active)) : base
+        end
+      end
+
+      # A dynamic node has no exact step_name (its name is computed at runtime).
+      # Bind it to the next log whose step_name matches its prefix pattern, in
+      # creation order for a stable binding. Skip logs already owned by an exact
+      # static node (reserved) or by an earlier dynamic node (consumed) so the same
+      # run log never surfaces on two nodes — that double-report was the gap.
+      def dynamic_status(node)
+        pattern = node.step_name_pattern
+        return {status: :not_reached} unless pattern
+        log = candidate_logs.find do |l|
+          l.step_name.start_with?(pattern) && !reserved.include?(l.step_name) &&
+            !consumed.include?(l.step_name) && !framework_log?(l)
+        end
+        return {status: :not_reached} unless log
+        consumed << log.step_name
+        {status: LOG_STATUS.fetch(log_state(log), :active), step_name: log.step_name}
+      end
+
+      # Exact step_names claimed by static nodes — a dynamic prefix node must not
+      # rebind these (its prefix, e.g. "durably_execute$", matches them all).
+      def reserved = @reserved ||= @definition.nodes.filter_map(&:step_name).to_set
+
+      # Loaded logs in a stable (creation) order, so dynamic prefix binding and
+      # `consumed` tracking are deterministic rather than DB-load-order dependent.
+      def candidate_logs = @candidate_logs ||= @workflow.execution_logs.sort_by(&:id)
+
+      def fanout_status(node)
+        log = logs_by_name[node.step_name]
+        return {status: :not_reached} unless log
+        counts = ChronoForge::Workflow
+          .where(parent_execution_log_id: log.id)
+          .group(:state).count
+          .transform_keys { |k| ChronoForge::Workflow.states.key(k) || k.to_s }
+        status = if counts["failed"].to_i.positive?
+          :failed
+        elsif counts.except("completed").values.sum.positive?
+          :active
+        elsif counts.any?
+          :done
+        else
+          :not_reached
+        end
+        {status: status, counts: counts}
+      end
+
+      def repeat_status(node)
+        coord = logs_by_name[node.step_name]
+        return {status: :not_reached} unless coord
+        # Repetition logs are "<coord.step_name>$<tick>". Count them in Ruby over
+        # already-loaded logs via an exact string prefix — a SQL LIKE would treat
+        # the "_" in names like "durably_repeat$reconcile_ledger" as wildcards and
+        # over-count rows from unrelated steps.
+        prefix = "#{node.step_name}$"
+        reps = candidate_logs.count { |l| l.step_name.start_with?(prefix) }
+        {status: (coord_done?(coord) ? :done : :active), repetitions: reps}
+      end
+
+      def consumed = @consumed ||= Set.new
+
+      def unmapped_nodes(mapped)
+        known = mapped.filter_map { |n| n[:step_name] }.to_set
+        @workflow.execution_logs
+          .select { |l| l.completed? }
+          .reject { |l| known.include?(l.step_name) || consumed.include?(l.step_name) || framework_log?(l) }
+          .map do |l|
+            {id: "log-#{l.id}", kind: :dynamic, label: l.step_name, step_name: l.step_name,
+             status: :unmapped, warnings: ["no matching static node"]}
+          end
+      end
+
+      # Skip framework-internal and fan-out child/rep logs (aggregated elsewhere).
+      def framework_log?(log)
+        log.step_name.start_with?("$") || log.step_name.count("$") >= 2
+      end
+
+      def logs_by_name
+        @logs_by_name ||= @workflow.execution_logs.index_by(&:step_name)
+      end
+
+      # ExecutionLog#state is a Rails enum with exactly three values
+      # (pending/completed/failed). A pending log is a step that has been reached
+      # but hasn't finished, so it reads as :active. Guard the Integer case too.
+      def log_state(log)
+        state = log.state
+        state.is_a?(String) ? state : ChronoForge::ExecutionLog.states.key(state).to_s
+      end
+
+      def coord_done?(log) = log_state(log) == "completed"
+    end
+  end
+end

data/app/queries/chrono_forge/dashboard/workflows_query.rb

@@ -10,7 +10,8 @@ module ChronoForge
       MAX_PER = 200
 
       def initialize(base: ChronoForge::Workflow.all, state: nil, job_class: nil, key: nil,
-        created_from: nil, created_to: nil, before: nil, after: nil, per: DEFAULT_PER)
+        created_from: nil, created_to: nil, before: nil, after: nil, per: DEFAULT_PER,
+        exclude_branched: false)
         @base = base
         @state = state.presence
         @job_class = job_class.presence
@@ -20,6 +21,11 @@ module ChronoForge
         @before = before.presence&.to_i
         @after = after.presence&.to_i
         @per = per.to_i.clamp(1, MAX_PER)
+        # Off by default: the branch-children view drives this same query with a
+        # base scoped to a branch's spawned_workflows (all of which ARE branch
+        # children), so excluding them there would empty the list. Only the main
+        # index opts in, to keep a large fan-out's children out of the top level.
+        @exclude_branched = exclude_branched
       end
 
       def records
@@ -83,6 +89,9 @@ module ChronoForge
         s = s.where("key LIKE ?", "#{ChronoForge::Workflow.sanitize_sql_like(@key)}%") if @key
         s = s.where(created_at: @created_from..) if @created_from
         s = s.where(created_at: ..@created_to) if @created_to
+        # Top-level workflows only: a spawned branch child carries a non-null
+        # parent_execution_log_id (its branch coordination log).
+        s = s.where(parent_execution_log_id: nil) if @exclude_branched
         s
       end
     end

data/app/views/chrono_forge/dashboard/branch_children/show.html.erb

@@ -9,22 +9,67 @@
         form: {data: {confirm: "Re-enqueue every failed/stalled child of this branch?"}}, class: "cf-btn cf-btn-primary shrink-0" %>
 </div>
 
-<div data-poll-region>
+<%# Live poll stats from the branch log's metadata (throughput/ETA while draining,
+    plus the never-started count and dropped-child recovery the poller records). %>
+<% if @branch.polled? %>
+  <dl class="mb-5 grid grid-cols-2 gap-x-6 gap-y-3 text-sm sm:grid-cols-4">
+    <% if @branch.throughput? %>
+      <div>
+        <dt class="text-xs uppercase tracking-wide text-zinc-400">Throughput</dt>
+        <dd class="font-mono text-zinc-700"><%= @branch.rate < 1 ? @branch.rate.round(1) : number_with_delimiter(@branch.rate.round) %>/s</dd>
+      </div>
+      <% if @branch.eta_seconds %>
+        <div>
+          <dt class="text-xs uppercase tracking-wide text-zinc-400">ETA</dt>
+          <dd class="font-mono text-zinc-700"><%= cf_secs(@branch.eta_seconds) %></dd>
+        </div>
+      <% end %>
+    <% end %>
+    <% if @branch.exact_spawned %>
+      <div>
+        <dt class="text-xs uppercase tracking-wide text-zinc-400">Spawned</dt>
+        <dd class="font-mono text-zinc-700"><%= number_with_delimiter(@branch.exact_spawned) %></dd>
+      </div>
+    <% end %>
+    <% if @branch.exact_pending %>
+      <div>
+        <dt class="text-xs uppercase tracking-wide text-zinc-400">Pending</dt>
+        <dd class="font-mono text-zinc-700"><%= number_with_delimiter(@branch.exact_pending) %></dd>
+      </div>
+    <% end %>
+    <div>
+      <dt class="text-xs uppercase tracking-wide text-zinc-400">Never started</dt>
+      <dd class="font-mono text-zinc-700"><%= @branch.exact_never_started ? number_with_delimiter(@branch.exact_never_started) : cf_capped(@branch.never_started, @branch.cap) %></dd>
+    </div>
+    <div>
+      <dt class="text-xs uppercase tracking-wide text-zinc-400">Recovered</dt>
+      <dd class="font-mono text-zinc-700"><%= @branch.rekicks %><% if @branch.last_rekick_at %> <span class="text-zinc-400">· last <%= cf_ago(@branch.last_rekick_at) %></span><% end %></dd>
+    </div>
+    <div>
+      <dt class="text-xs uppercase tracking-wide text-zinc-400">Last check</dt>
+      <dd class="font-mono text-zinc-700"><%= cf_ago(@branch.last_polled_at) %> · <%= pluralize(@branch.polls, "poll") %></dd>
+    </div>
+    <% if @branch.next_poll_at %>
+      <div>
+        <dt class="text-xs uppercase tracking-wide text-zinc-400">Next check</dt>
+        <dd class="font-mono <%= @branch.poll_overdue? ? "text-rose-600" : "text-zinc-700" %>"><%= cf_when(@branch.next_poll_at) %></dd>
+      </div>
+    <% end %>
+  </dl>
+<% end %>
+
+<div>
   <% current = params.key?(:state) ? params[:state].to_s : "blocked" %>
   <% blocked = @stats["failed"].to_i + @stats["stalled"].to_i %>
-  <% chip = ->(label, state, count, active) {
-       link_to workflow_branch_path(@workflow, @branch_log, state: state),
-         class: "flex items-center gap-2 rounded-md border px-3 py-1.5 text-sm transition #{active ? "border-zinc-900 bg-zinc-50" : "border-zinc-200 bg-white hover:bg-zinc-50"}" do
-         safe_join([tag.span(label, class: "text-zinc-500"),
-           (count ? tag.span(cf_capped(count, @stats_cap), class: "font-mono font-medium tabular-nums") : "".html_safe)])
-       end
-     } %>
+  <% branch_chip_href = ->(state) { workflow_branch_path(@workflow, @branch_log, state: state) } %>
   <div class="mb-4 flex flex-wrap gap-2">
-    <%= chip.call("blocked", "blocked", blocked, current == "blocked") %>
-    <%= chip.call("all", "", nil, current == "") %>
+    <%# "blocked" (failed+stalled) gets a red dot; "all" has no single state, so no
+        dot, and sits last as the catch-all/reset. %>
+    <%= cf_filter_chip(branch_chip_href.call("blocked"), label: "blocked", count: blocked, cap: @stats_cap, active: current == "blocked", dot: "failed") %>
     <% ChronoForge::Workflow.states.keys.each do |s| %>
-      <%= chip.call(s, s, @stats[s], current == s) %>
+      <%= cf_filter_chip(branch_chip_href.call(s), label: s, count: @stats[s], cap: @stats_cap, active: current == s, dot: s) %>
     <% end %>
+    <%= cf_filter_chip(branch_chip_href.call(""), label: "all", active: current == "") %>
   </div>
 
   <div class="cf-card overflow-hidden">

data/app/views/chrono_forge/dashboard/definitions/show.html.erb

@@ -0,0 +1,42 @@
+<%= link_to "‹ Back to workflow", workflow_path(@workflow), class: cf_chip("mb-2") %>
+
+<div class="mb-4">
+  <h1 class="text-lg font-semibold text-zinc-800">Definition graph</h1>
+  <p class="text-xs text-zinc-500"><%= @workflow.job_class %> — <%= @workflow.key %></p>
+</div>
+
+<% if @warnings.any? %>
+  <div class="mb-4 rounded border border-amber-300 bg-amber-50 p-3 text-xs text-amber-800">
+    <p class="font-medium mb-1">Static analysis notes</p>
+    <ul class="list-disc pl-4 space-y-0.5">
+      <% @warnings.each do |w| %><li><%= w %></li><% end %>
+    </ul>
+  </div>
+<% end %>
+
+<div class="overflow-hidden rounded-xl border border-zinc-200 bg-white shadow-sm">
+  <div class="flex flex-wrap items-center gap-x-4 gap-y-1.5 border-b border-zinc-100 px-4 py-2.5 text-[11px] text-zinc-500">
+    <% {done: "done", active: "in progress", pending: "pending", not_reached: "not yet reached", failed: "failed", unmapped: "unmapped"}.each do |status, label| %>
+      <span class="inline-flex items-center gap-1.5">
+        <span class="h-2.5 w-2.5 rounded-sm border cf-legend-<%= status %>"></span><%= label %>
+      </span>
+    <% end %>
+  </div>
+  <%# The graph is passed as JSON in a data attribute — ERB-escaped, so labels and
+      guard text (which contain (), <, &&) round-trip through the DOM untouched. %>
+  <div id="cf-graph" data-graph="<%= @graph.to_json %>" class="h-[72vh] w-full bg-zinc-50"></div>
+  <div id="cf-graph-detail" class="min-h-[3rem] border-t border-zinc-100 bg-white px-4 py-3 text-xs"></div>
+</div>
+
+<style>
+  .cf-legend-done{background:#ecfdf5;border-color:#10b981}
+  .cf-legend-active{background:#eff6ff;border-color:#3b82f6}
+  .cf-legend-pending{background:#fafafa;border-color:#d4d4d8}
+  .cf-legend-not_reached{background:#fff;border-color:#e4e4e7}
+  .cf-legend-failed{background:#fef2f2;border-color:#ef4444}
+  .cf-legend-unmapped{background:#fafaf9;border-color:#d6d3d1}
+</style>
+
+<% %w[cytoscape.min.js dagre.min.js cytoscape-dagre.js definition_graph.js].each do |asset| %>
+  <script src="<%= "#{request.script_name}/assets/#{asset}?v=#{ChronoForge::Dashboard.asset_digest(asset)}" %>"></script>
+<% end %>

data/app/views/chrono_forge/dashboard/workflows/_branches.html.erb

@@ -6,8 +6,9 @@
         <tr class="border-b border-zinc-200 text-left text-xs uppercase tracking-wide text-zinc-500">
           <th class="py-2 pr-4 font-medium">Branch</th>
           <th class="py-2 pr-4 font-medium">Status</th>
-          <th class="py-2 pr-4 text-right font-medium">Dispatched</th>
+          <th class="py-2 pr-4 text-right font-medium">Spawned</th>
           <th class="py-2 pr-4 text-right font-medium">Pending</th>
+          <th class="py-2 pr-4 text-right font-medium">Never started</th>
           <th class="py-2 pr-4 text-right font-medium">Blocked</th>
           <th class="py-2 font-medium"></th>
         </tr>
@@ -29,8 +30,9 @@
                 · <span class="text-zinc-400" title="<%= b.polls %> polls · next <%= b.next_poll_at&.iso8601 || "—" %>">polling</span>
               <% end %>
             </td>
-            <td class="py-2 pr-4 text-right font-mono tabular-nums text-zinc-600"><%= cf_capped(b.dispatched, b.cap) %></td>
-            <td class="py-2 pr-4 text-right font-mono tabular-nums text-zinc-600"><%= cf_capped(b.pending, b.cap) %></td>
+            <td class="py-2 pr-4 text-right font-mono tabular-nums text-zinc-600"><%= b.exact_spawned ? number_with_delimiter(b.exact_spawned) : cf_capped(b.spawned, b.cap) %></td>
+            <td class="py-2 pr-4 text-right font-mono tabular-nums text-zinc-600"><%= b.exact_pending ? number_with_delimiter(b.exact_pending) : cf_capped(b.pending, b.cap) %></td>
+            <td class="py-2 pr-4 text-right font-mono tabular-nums text-zinc-600"><%= b.exact_never_started ? number_with_delimiter(b.exact_never_started) : cf_capped(b.never_started, b.cap) %></td>
             <td class="py-2 pr-4 text-right font-mono tabular-nums <%= "font-medium text-rose-600" if b.blocked > 0 %>"><%= cf_capped(b.blocked, b.cap) %></td>
             <td class="py-2 text-right"><%= link_to "details →", workflow_branch_path(workflow, b.log), class: cf_chip %></td>
           </tr>
@@ -48,8 +50,16 @@
           <div class="min-w-0">
             <span class="break-all font-mono text-zinc-700"><%= m.names.join(" + ") %></span>
             <span class="ml-1.5 text-xs <%= m.merging? ? "text-amber-600" : "text-zinc-400" %>"><%= m.state %></span>
+            <% if m.poll_overdue? %><span class="ml-1.5 text-xs font-medium text-rose-600" title="next check is past due — the poller may have been dropped">poll overdue</span><% end %>
+          </div>
+          <div class="flex shrink-0 flex-wrap items-baseline gap-x-3 text-xs text-zinc-400">
+            <% if m.last_polled_at %><span>last check <%= cf_ago(m.last_polled_at) %></span><% end %>
+            <% if m.merging? && m.next_poll_at %><span class="<%= "font-medium text-rose-600" if m.poll_overdue? %>">next check <%= cf_when(m.next_poll_at) %></span><% end %>
+            <% if m.throughput? %><span title="measured over the last poll interval"><%= m.rate < 1 ? m.rate.round(1) : number_with_delimiter(m.rate.round) %>/s</span><% end %>
+            <% if m.throughput? && m.eta_seconds %><span>ETA <%= cf_secs(m.eta_seconds) %></span><% end %>
+            <% if m.polls&.positive? %><span><%= pluralize(m.polls, "poll") %></span><% end %>
+            <% if m.started_at %><span>started <%= cf_ago(m.started_at) %></span><% end %>
           </div>
-          <% if m.started_at %><span class="shrink-0 text-xs text-zinc-400">started <%= cf_ago(m.started_at) %></span><% end %>
         </div>
       <% end %>
     </div>

data/app/views/chrono_forge/dashboard/workflows/_filters.html.erb

@@ -1,6 +1,17 @@
-<%= form_with url: workflows_path, method: :get, class: "mb-4 flex flex-wrap items-center gap-2" do |f| %>
+<%# enforce_utf8: false keeps the legacy `utf8=✓` IE hack out of the GET query string. %>
+<%= form_with url: workflows_path, method: :get, enforce_utf8: false, class: "mb-4 flex flex-wrap items-center gap-2" do |f| %>
   <%= f.select :state, options_for_select([["All states", ""], *ChronoForge::Workflow.states.keys], params[:state]), {}, class: "rounded-md border border-zinc-300 bg-white px-2 py-1.5 text-sm", data: {autosubmit: true} %>
   <%= f.text_field :job_class, value: params[:job_class], placeholder: "Job class", class: "rounded-md border border-zinc-300 px-2.5 py-1.5 text-sm placeholder:text-zinc-400" %>
   <%= f.text_field :key, value: params[:key], placeholder: "Key", class: "rounded-md border border-zinc-300 px-2.5 py-1.5 text-sm placeholder:text-zinc-400" %>
   <%= f.submit "Filter", class: "cf-btn" %>
+
+  <%# Far right: hide spawned branch children (on by default) so a large fan-out
+      doesn't flood the top-level list. Hidden field makes "off" submit "0" so the
+      controller can default an absent param to on. Auto-applies on toggle. %>
+  <label class="ml-auto flex cursor-pointer items-center gap-1.5 text-sm text-zinc-600">
+    <%= hidden_field_tag :hide_branches, "0", id: nil %>
+    <%= check_box_tag :hide_branches, "1", params[:hide_branches] != "0",
+          data: {autosubmit: true}, class: "h-4 w-4 rounded border-zinc-300" %>
+    Hide branches
+  </label>
 <% end %>

data/app/views/chrono_forge/dashboard/workflows/_stats.html.erb

@@ -1,14 +1,10 @@
 <div class="mb-4 flex flex-wrap gap-2">
   <% base = request.query_parameters.except("before", "after") %>
+  <% chip_href = ->(state) { workflows_path(params[:state].to_s == state ? base.except("state") : base.merge(state: state)) } %>
+  <%# "blocked" = failed + stalled — the actionable subset, one click to triage. %>
+  <% blocked_count = stats["failed"].to_i + stats["stalled"].to_i %>
+  <%= cf_filter_chip(chip_href.call("blocked"), label: "blocked", count: blocked_count, cap: cap, active: params[:state].to_s == "blocked", dot: "failed") %>
   <% cf_state_order(stats.keys).each do |state| %>
-    <% count = stats[state] %>
-    <% active = params[:state].to_s == state %>
-    <% target = active ? base.except("state") : base.merge(state: state) %>
-    <%= link_to workflows_path(target),
-          class: "cf-stat flex items-center gap-2 rounded-md border px-3 py-1.5 text-sm transition #{active ? "border-zinc-900 bg-zinc-50" : "border-zinc-200 bg-white hover:bg-zinc-50"}" do %>
-      <%= cf_dot(state) %>
-      <span class="text-zinc-500"><%= state %></span>
-      <span class="font-mono font-medium tabular-nums"><%= cf_capped(count, cap) %></span>
-    <% end %>
+    <%= cf_filter_chip(chip_href.call(state), label: state, count: stats[state], cap: cap, active: params[:state].to_s == state, dot: state) %>
   <% end %>
 </div>

data/app/views/chrono_forge/dashboard/workflows/index.html.erb

@@ -1,10 +1,10 @@
 <div class="mb-5 flex items-center justify-between">
   <h1 class="text-lg font-semibold tracking-tight">Workflows</h1>
-  <%= button_to "Retry failed & stalled", bulk_retry_workflows_path, method: :post,
-        form: {data: {confirm: "Re-enqueue every failed and stalled workflow?"}}, class: "cf-btn" %>
+  <%= button_to "Retry blocked", bulk_retry_workflows_path, method: :post,
+        form: {data: {confirm: "Re-enqueue every blocked (failed and stalled) workflow?"}}, class: "cf-btn" %>
 </div>
 
-<div data-poll-region>
+<div>
   <%= render "stats", stats: @stats, cap: @stats_cap %>
   <%= render "filters", query: @query %>
 

data/app/views/chrono_forge/dashboard/workflows/show.html.erb

@@ -9,6 +9,7 @@
       <p class="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-sm text-zinc-500">
         <span class="break-all font-mono"><%= @workflow.job_class %></span>
         <%= link_to "metrics →", analytics_path(class: @workflow.job_class), class: cf_chip %>
+        <%= link_to "Definition graph", definition_workflow_path(@workflow), class: cf_chip %>
       </p>
     </div>
     <% if @workflow.retryable? || @workflow.running? || @workflow.idle? %>

data/app/views/layouts/chrono_forge/dashboard/application.html.erb

@@ -26,15 +26,19 @@
         <a href="<%= analytics_path %>" class="<%= controller_name == "analytics" ? "font-medium text-zinc-900" : "text-zinc-500 hover:text-zinc-900" %>">Analytics</a>
       </nav>
       <div class="ml-auto flex flex-wrap items-center gap-2">
-        <% current_poll = cf_poll_interval %>
-        <label class="flex items-center gap-1 text-xs text-zinc-400" title="Auto-refresh">
-          <span>refresh</span>
-          <select data-poll-select class="rounded-md border border-zinc-200 bg-white px-1.5 py-1 text-xs text-zinc-700">
-            <% (cf_poll_options | [current_poll]).sort.each do |secs| %>
-              <option value="<%= secs %>" <%= "selected" if secs == current_poll %>><%= cf_poll_label(secs) %></option>
-            <% end %>
-          </select>
-        </label>
+        <%# Hidden on pages that opt out of auto-refresh (cf_poll_region? false), so
+            a control that does nothing there doesn't confuse. %>
+        <% if cf_poll_region? %>
+          <% current_poll = cf_poll_interval %>
+          <label class="flex items-center gap-1 text-xs text-zinc-400" title="Auto-refresh">
+            <span>refresh</span>
+            <select data-poll-select class="rounded-md border border-zinc-200 bg-white px-1.5 py-1 text-xs text-zinc-700">
+              <% (cf_poll_options | [current_poll]).sort.each do |secs| %>
+                <option value="<%= secs %>" <%= "selected" if secs == current_poll %>><%= cf_poll_label(secs) %></option>
+              <% end %>
+            </select>
+          </label>
+        <% end %>
         <div class="flex items-center gap-0.5 rounded-md border border-zinc-200 p-0.5 text-xs" title="Timestamp display">
           <button type="button" data-time-set="relative" class="rounded px-2 py-0.5 <%= cf_absolute_time? ? "text-zinc-500 hover:text-zinc-900" : "bg-zinc-900 text-white" %>">relative</button>
           <button type="button" data-time-set="absolute" class="rounded px-2 py-0.5 <%= cf_absolute_time? ? "bg-zinc-900 text-white" : "text-zinc-500 hover:text-zinc-900" %>">absolute</button>
@@ -42,7 +46,11 @@
       </div>
     </div>
   </header>
-  <main class="mx-auto max-w-6xl px-4 py-6">
+  <%# data-poll-region: the JS auto-refreshes this region in place (preserving
+      filter text, focus, and scroll). Marking <main> makes pages refresh — the
+      nav and the refresh/time controls sit in <header>, outside the swap. A page
+      can opt out (cf_poll_region? false) when an in-place swap would break it. %>
+  <main class="mx-auto max-w-6xl px-4 py-6" <%= "data-poll-region" if cf_poll_region? %>>
     <%= yield %>
   </main>
   <script src="<%= "#{request.script_name}/assets/dashboard.js?v=#{ChronoForge::Dashboard.asset_digest("dashboard.js")}" %>"></script>

data/config/routes.rb

@@ -6,6 +6,7 @@ ChronoForge::Dashboard::Engine.routes.draw do
       post :resume, to: "actions#resume"
       post :unlock, to: "actions#unlock"
       get :repetitions, to: "repetitions#index"
+      get :definition, to: "definitions#show"
     end
     collection do
       post :bulk_retry, to: "actions#bulk_retry"
@@ -16,5 +17,9 @@ ChronoForge::Dashboard::Engine.routes.draw do
   end
   resources :wait_states, only: :index
   get "analytics", to: "analytics#index", as: :analytics
-  get "assets/:file", to: "assets#show", constraints: {file: /dashboard\.(css|js)/}
+  # Explicit allowlist (mirrors AssetsController::TYPES) so unknown assets 404 at
+  # the routing layer rather than reaching the controller.
+  get "assets/:file", to: "assets#show", constraints: {
+    file: /(dashboard\.(css|js)|cytoscape\.min\.js|dagre\.min\.js|cytoscape-dagre\.js|definition_graph\.js)/
+  }
 end

data/lib/chrono_forge/dashboard/configuration.rb

@@ -19,9 +19,9 @@ module ChronoForge
         @http_basic = nil
         @authentication = nil
         @auth_hook = nil
-        @polling_interval = 5
+        @polling_interval = 15
         # Selectable auto-refresh intervals (seconds; 0 = off) for the nav control.
-        @polling_interval_options = [0, 5, 10, 30, 60, 300]
+        @polling_interval_options = [0, 5, 10, 15, 30, 60, 300]
         @page_size = 50
         @long_wait_threshold = 3600
       end

data/lib/chrono_forge/dashboard/version.rb

@@ -1,5 +1,5 @@
 module ChronoForge
   module Dashboard
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chrono_forge-dashboard
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Stefan Froelich
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-27 00:00:00.000000000 Z
+date: 2026-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chrono_forge
@@ -162,14 +162,19 @@ files:
 - CHANGELOG.md
 - MIT-LICENSE
 - README.md
+- app/assets/chrono_forge/dashboard/cytoscape-dagre.js
+- app/assets/chrono_forge/dashboard/cytoscape.min.js
+- app/assets/chrono_forge/dashboard/dagre.min.js
 - app/assets/chrono_forge/dashboard/dashboard.css
 - app/assets/chrono_forge/dashboard/dashboard.js
+- app/assets/chrono_forge/dashboard/definition_graph.js
 - app/assets/chrono_forge/dashboard/tailwind.css
 - app/controllers/chrono_forge/dashboard/actions_controller.rb
 - app/controllers/chrono_forge/dashboard/analytics_controller.rb
 - app/controllers/chrono_forge/dashboard/assets_controller.rb
 - app/controllers/chrono_forge/dashboard/base_controller.rb
 - app/controllers/chrono_forge/dashboard/branch_children_controller.rb
+- app/controllers/chrono_forge/dashboard/definitions_controller.rb
 - app/controllers/chrono_forge/dashboard/repetitions_controller.rb
 - app/controllers/chrono_forge/dashboard/wait_states_controller.rb
 - app/controllers/chrono_forge/dashboard/workflows_controller.rb
@@ -177,6 +182,8 @@ files:
 - app/presenters/chrono_forge/dashboard/branch_presenter.rb
 - app/presenters/chrono_forge/dashboard/branches_presenter.rb
 - app/presenters/chrono_forge/dashboard/context_presenter.rb
+- app/presenters/chrono_forge/dashboard/cytoscape_graph.rb
+- app/presenters/chrono_forge/dashboard/definition_overlay.rb
 - app/presenters/chrono_forge/dashboard/periodic_health_presenter.rb
 - app/presenters/chrono_forge/dashboard/timeline_presenter.rb
 - app/presenters/chrono_forge/dashboard/wait_state_presenter.rb
@@ -186,6 +193,7 @@ files:
 - app/queries/chrono_forge/dashboard/workflows_query.rb
 - app/views/chrono_forge/dashboard/analytics/index.html.erb
 - app/views/chrono_forge/dashboard/branch_children/show.html.erb
+- app/views/chrono_forge/dashboard/definitions/show.html.erb
 - app/views/chrono_forge/dashboard/repetitions/index.html.erb
 - app/views/chrono_forge/dashboard/wait_states/index.html.erb
 - app/views/chrono_forge/dashboard/workflows/_branches.html.erb