Almirah 0.4.2 → 0.4.3

data/lib/almirah/doc_types/decisions_overview.rb

@@ -3,8 +3,18 @@
 require 'date'
 require 'json'
 require_relative 'base_document'
+require_relative 'decision_grouping'
+require_relative 'planning_dates'
+require_relative '../html_safe'
+require_relative '../project/work_item_scheduler'
+require_relative '../project/critical_chain'
+require_relative '../project/working_calendar'
+
+class DecisionsOverview < BaseDocument
+  include HtmlSafe
+  include DecisionGrouping
+  include PlanningDates
 
-class DecisionsOverview < BaseDocument # rubocop:disable Style/Documentation,Metrics/ClassLength
   attr_accessor :project
 
   def initialize(project)
@@ -14,16 +24,21 @@ class DecisionsOverview < BaseDocument # rubocop:disable Style/Documentation,Met
     @id = 'overview'
   end
 
+  def needs_chartjs?
+    true
+  end
+
   def to_console
     puts "\e[36mDecisions Overview: #{@id}\e[0m"
   end
 
-  def to_html(output_file_path) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+  def to_html(output_file_path)
     html_rows = []
     html_rows.append('')
     html_rows.append "<h1>#{@title}</h1>\n"
 
     html_rows.append render_charts_grid
+    html_rows.append render_workitem_gantt
 
     html_rows.append "<table class=\"controlled decisions_overview\">\n"
     html_rows.append "\t<thead>\n"
@@ -35,6 +50,7 @@ class DecisionsOverview < BaseDocument # rubocop:disable Style/Documentation,Met
     html_rows.append "\t\t<th>Target Date</th>\n"
     html_rows.append "\t\t<th title=\"Target Release Version\">Release</th>\n"
     html_rows.append "\t\t<th>Owner</th>\n"
+    html_rows.append "\t\t<th title=\"Cross-record full-kit readiness\">Kit</th>\n"
     html_rows.append "</thead>\n"
 
     sorted_items = @project.project_data.decisions.sort_by do |d|
@@ -57,7 +73,8 @@ class DecisionsOverview < BaseDocument # rubocop:disable Style/Documentation,Met
       target_date_html = doc.target_date ? doc.target_date.strftime('%d-%m-%Y') : ''
       s += "\t\t<td class=\"item_meta\">#{target_date_html}</td>\n"
       s += "\t\t<td class=\"item_meta\">#{doc.target_release_version}</td>\n"
-      s += "\t\t<td class=\"item_meta\"></td>\n"
+      s += "\t\t<td class=\"item_meta\">#{doc.owners.join(', ')}</td>\n"
+      s += kit_overview_cell(doc)
       s += "</tr>\n"
       html_rows.append s
     end
@@ -68,6 +85,446 @@ class DecisionsOverview < BaseDocument # rubocop:disable Style/Documentation,Met
 
   private
 
+  # Cross-record full-kit readiness for a record (ADR-194), rendered as text:
+  # empty when the record declares no Depends On prerequisites, "Ready" when
+  # every Scope row is kitted, "Blocked" (warning colour) otherwise. A record
+  # blocked while having a started row (a cross-record violation) is emphasised,
+  # matching the console warning.
+  def kit_overview_cell(doc)
+    return "\t\t<td class=\"item_kit\"></td>\n" unless doc.declared_dependencies?
+    return "\t\t<td class=\"item_kit kit_ready\">Ready</td>\n" if doc.fully_kitted?
+
+    weight = doc.kit_started_violation? ? ' font-weight: bold;' : ''
+    "\t\t<td class=\"item_kit kit_blocked\" style=\"color: #c0392b;#{weight}\">Blocked</td>\n"
+  end
+
+  # Gutter columns between adjacent group blocks so they never abut (ADR-201).
+  GANTT_GUTTER_DAYS = 1
+
+  # The group-segmented resource-swimlane Gantt of the WorkItem network (ADR-198,
+  # segmented by ADR-201), placed between the charts grid and the records table.
+  # Each decision group (ADR-197) becomes a block laid left to right; within a
+  # block, one lane per owner (the shared WIP roster) carries a constant-duration
+  # bar per work item positioned by WorkItemScheduler. A group band row labels
+  # each block and a Buffer lane closes the grid below the owner lanes. Omitted
+  # when there is nothing to schedule.
+  def render_workitem_gantt
+    blocks = gantt_blocks
+    owners = consensus_owner_order
+    return '' if blocks.empty? || owners.empty?
+
+    total_days = blocks.map { |b| b[:offset] + b[:cal_width] }.max
+    grid = gantt_grid(owners, blocks, total_days)
+    grid += gantt_pulse_script if gantt_any_blocked?(blocks)
+    %(<div class="gantt_container">\n) + gantt_toolbar + grid + %(</div>\n)
+  end
+
+  # The control strip above the chart (ADR-213): a right-aligned button that
+  # toggles the tracking lanes by flipping the `show-actuals` class on the chart
+  # and swapping its own label. Sits outside the scrolling grid so it stays in
+  # view; future Gantt controls share this strip.
+  def gantt_toolbar
+    toggle = "var g=this.closest('.gantt_container').querySelector('.workitem_gantt');" \
+             "this.textContent=g.classList.toggle('show-actuals')?'Hide Actuals':'Show Actuals';"
+    %(\t<div class="gantt_toolbar">\n) +
+      %(\t\t<button type="button" class="gantt_actuals_toggle" onclick="#{toggle}">Show Actuals</button>\n) +
+      %(\t</div>\n)
+  end
+
+  # True when any scheduled work item is a started-but-blocked cross-record
+  # violation, so the pulse script is worth emitting.
+  def gantt_any_blocked?(blocks)
+    blocks.any? { |b| b[:items].any?(&:cross_record_violation?) }
+  end
+
+  # One block per decision group (ADR-197) that has work items, in decision_groups
+  # (folder-encounter) order. Each block runs WorkItemScheduler over only its own
+  # items, so a cross-group predecessor falls away as an already-available input
+  # (ADR-201); blocks are laid out left to right with a one-column gutter between
+  # them, never overlapping. Each block's calendar is anchored at its group's
+  # configured planning.groups start date, falling back to the project start date,
+  # so the block's day columns are labelled with that group's real dates (ADR-211).
+  def gantt_blocks
+    ratio = @project.configuration.get_buffer_ratio
+    holidays = @project.configuration.get_holidays
+    group_starts = @project.configuration.get_group_start_dates
+    origin = @project.configuration.get_start_date
+    offset = 0
+    grouped_work_items.each_with_object([]) do |(name, items), blocks|
+      scheduler = GanttScheduler.new(items)
+      next if scheduler.day_count.zero?
+
+      calendar = WorkingCalendar.new(anchor: group_starts[name] || origin, holidays: holidays)
+      offset += GANTT_GUTTER_DAYS unless blocks.empty?
+      block = gantt_block(name, items, scheduler, offset, ratio, calendar)
+      blocks << block
+      offset += block[:cal_width]
+    end
+  end
+
+  # One block descriptor: its group name, work items, schedule, per-work-item
+  # start days, the set of work items on the schedule's critical chain (ADR-212),
+  # the working span and computed project buffer (ADR-195), the shared working
+  # calendar (ADR-205), the business-day column dates and their count (ADR-206,
+  # extended past the schedule to cover authored actuals, ADR-213), and the
+  # left-to-right column offset of the block's first day.
+  def gantt_block(name, items, scheduler, offset, ratio, calendar) # rubocop:disable Metrics/ParameterLists
+    work_days = scheduler.day_count
+    buffer = CriticalChain.new(items, buffer_ratio: ratio).buffer
+    width = work_days + buffer
+    columns = calendar.business_axis(block_column_count(items, calendar, width))
+    { name:, items:, scheduler:, starts: scheduler.start_days, chain: scheduler.critical_chain.to_set,
+      work_days:, buffer:, width:, calendar:, columns:, cal_width: columns.length, offset: }
+  end
+
+  # The number of business-day columns the block needs: enough for the computed
+  # schedule plus buffer, widened so the latest authored actual date (a committed
+  # window end or a logged-effort date, ADR-213) still falls on a real column
+  # rather than being clipped at the buffer edge.
+  def block_column_count(items, calendar, width)
+    planned = calendar.business_columns(width).length
+    latest = actual_dates(items).max
+    actual = latest ? calendar.business_column_for(latest) + 1 : 0
+    [planned, actual].max
+  end
+
+  # Slow background pulse for blocked bars (cosmetic; no decision record). A
+  # small inline script eases each blocked bar between its own status colour and
+  # the Chart.js red over a 2.4s, six-phase cycle. The bar's border is untouched,
+  # and the pulse is skipped under prefers-reduced-motion.
+  def gantt_pulse_script
+    <<~'JS'
+      <script>
+      (function () {
+        if (window.matchMedia && window.matchMedia('(prefers-reduced-motion: reduce)').matches) { return; }
+        var target = [255, 99, 132];
+        var steps = [0, 1 / 5, 1 / 3, 1, 1 / 3, 1 / 5];
+        var bars = document.querySelectorAll('.workitem_gantt .gantt_blocked');
+        if (!bars.length) { return; }
+        var items = [];
+        bars.forEach(function (el) {
+          var m = getComputedStyle(el).backgroundColor.match(/\d+/g);
+          if (!m) { return; }
+          var base = [parseInt(m[0], 10), parseInt(m[1], 10), parseInt(m[2], 10)];
+          var phases = steps.map(function (t) {
+            return 'rgb(' + Math.round(base[0] + (target[0] - base[0]) * t) + ',' +
+                            Math.round(base[1] + (target[1] - base[1]) * t) + ',' +
+                            Math.round(base[2] + (target[2] - base[2]) * t) + ')';
+          });
+          el.style.transition = 'background-color 0.4s linear';
+          items.push({ el: el, phases: phases });
+        });
+        var i = 0;
+        setInterval(function () {
+          i = (i + 1) % 6;
+          items.forEach(function (it) { it.el.style.backgroundColor = it.phases[i]; });
+        }, 400);
+      })();
+      </script>
+    JS
+  end
+
+  # Each owner occupies two adjacent lanes (ADR-213): the planned lane and, right
+  # below it, the hidden tracking lane. The three header rows (months, days, group
+  # band) precede them, and the Buffer lane closes the grid, so the total row count
+  # is owners.length * 2 + 4. The full-height background and today rules span every
+  # row; a hidden tracking lane collapses to a zero-height track they cross harmlessly.
+  def gantt_grid(owners, blocks, total_days)
+    cols = "var(--gantt-owner-width) repeat(#{total_days}, var(--gantt-day-width))"
+    rows = [%(<div class="workitem_gantt">\n), %(\t<div class="gantt_grid" style="grid-template-columns: #{cols};">\n)]
+    total_rows = owners.length * 2 + 4
+    rows.concat(gantt_background_columns(blocks, total_rows))
+    rows.concat(gantt_month_header(blocks))
+    rows.concat(gantt_day_header(blocks))
+    rows.concat(gantt_group_band(blocks))
+    owners.each_with_index do |owner, i|
+      rows.concat(gantt_lane(owner, 4 + i * 2, blocks))
+      rows.concat(gantt_tracking_lane(owner, 5 + i * 2, blocks))
+    end
+    rows.concat(gantt_buffer_lane(blocks, owners.length * 2 + 4))
+    rows.concat(gantt_today_lines(blocks, total_rows))
+    rows << "\t</div>\n" << "</div>\n"
+    rows.join
+  end
+
+  # The "today" marker (ADR-205 / ADR-211): a thin full-height vertical rule drawn
+  # only in the block whose calendar range actually contains the current date, at
+  # that date's business-day column. Blocks the current date falls outside (past or
+  # future groups) get no rule, so the sequential blocks never sprout edge-clamped
+  # lines mid-chart. Emitted last so it paints over the bars; it is inert
+  # (pointer-events: none) and never blocks a bar's tooltip.
+  def gantt_today_lines(blocks, total_rows)
+    today = Date.today
+    blocks.filter_map do |b|
+      col = gantt_today_column(b, today)
+      next unless col
+
+      style = %(grid-row: 1 / span #{total_rows}; grid-column: #{col};)
+      %(\t\t<div class="gantt_today" style="#{style}"></div>\n)
+    end
+  end
+
+  # The grid-column of today's business-day column within a block, or nil when the
+  # block's calendar range does not contain today (today before its first or after
+  # its last column, or the block has no columns).
+  def gantt_today_column(block, today)
+    dates = block[:columns]
+    return nil if dates.empty? || today < dates.first || today > dates.last
+
+    block[:offset] + dates.index { |d| d >= today } + 2
+  end
+
+  # Full-height background columns behind the business-day axis (ADR-206),
+  # spanning the lane rows so the shading shows under the bars: weekday holidays
+  # keep the grey non-working shade, working Fridays get the week-rhythm tint.
+  # Emitted first so the bars paint on top.
+  def gantt_background_columns(blocks, total_rows)
+    cells = []
+    blocks.each do |b|
+      b[:columns].each_with_index do |date, i|
+        klass = background_column_class(b[:calendar], date)
+        next unless klass
+
+        style = %(grid-row: 3 / span #{total_rows - 2}; grid-column: #{b[:offset] + i + 2};)
+        cells << %(\t\t<div class="#{klass}" style="#{style}"></div>\n)
+      end
+    end
+    cells
+  end
+
+  # Grey for a weekday holiday, the Friday tint for a working Friday, nil
+  # otherwise. Weekends never reach here (they are off the business-day axis).
+  def background_column_class(calendar, date)
+    return 'gantt_nonworking_col' if calendar.non_working?(date)
+    return 'gantt_friday_col' if calendar.friday?(date)
+
+    nil
+  end
+
+  # Month band (row 1): the sticky corner over the Owner column spanning both
+  # header rows, then one cell per month spanning that month's business-day
+  # columns within each block (ADR-206).
+  def gantt_month_header(blocks)
+    cells = [%(\t\t<div class="gantt_corner" style="grid-row: 1 / span 2; grid-column: 1;">Owner</div>\n)]
+    blocks.each do |b|
+      month_spans(b[:columns]).each do |label, start_i, len|
+        style = %(grid-row: 1; grid-column: #{b[:offset] + start_i + 2} / span #{len};)
+        cells << %(\t\t<div class="gantt_month_head" style="#{style}">#{label}</div>\n)
+      end
+    end
+    cells
+  end
+
+  # Day-of-month row (row 2): one numbered cell per business-day column within
+  # each block (weekends omitted, ADR-206), flagged non-working for weekday
+  # holidays and tinted for working Fridays.
+  def gantt_day_header(blocks)
+    cells = []
+    blocks.each do |b|
+      b[:columns].each_with_index do |date, i|
+        col = b[:offset] + i + 2
+        klass = "gantt_day_head#{day_head_modifier(b[:calendar], date)}"
+        cells << %(\t\t<div class="#{klass}" style="grid-row: 2; grid-column: #{col};">#{date.day}</div>\n)
+      end
+    end
+    cells
+  end
+
+  # The extra class on a day-of-month header cell: non-working for a weekday
+  # holiday, the Friday tint for a working Friday, none otherwise.
+  def day_head_modifier(calendar, date)
+    return ' gantt_nonworking' if calendar.non_working?(date)
+    return ' gantt_friday' if calendar.friday?(date)
+
+    ''
+  end
+
+  # Group consecutive calendar dates by month into [label, start_index, length].
+  def month_spans(dates)
+    dates.each_with_index.each_with_object([]) do |(date, i), spans|
+      label = date.strftime('%b %Y')
+      if spans.last && spans.last[0] == label
+        spans.last[2] += 1
+      else
+        spans << [label, i, 1]
+      end
+    end
+  end
+
+  # The group band row (ADR-201), now row 3 below the two calendar header rows:
+  # one labelled cell per block spanning that block's calendar columns, with a
+  # sticky-left corner over the Owner column.
+  def gantt_group_band(blocks)
+    cells = [%(\t\t<div class="gantt_band_corner" style="grid-row: 3; grid-column: 1;"></div>\n)]
+    blocks.each do |b|
+      style = %(grid-row: 3; grid-column: #{b[:offset] + 2} / span #{b[:cal_width]};)
+      cells << %(\t\t<div class="gantt_release_band" style="#{style}">#{escape_text(b[:name])}</div>\n)
+    end
+    cells
+  end
+
+  # The Buffer lane (ADR-201), the last row below the owner lanes: one buffer bar
+  # per block, placed on the calendar columns of the working days immediately
+  # after that group's last work item and spanning its buffer (ADR-195/205).
+  def gantt_buffer_lane(blocks, row)
+    cells = [%(\t\t<div class="gantt_buffer" style="grid-row: #{row}; grid-column: 1;">Buffer</div>\n)]
+    blocks.each do |b|
+      next if b[:buffer].zero?
+
+      grid_col, span = calendar_span(b, b[:work_days] + 1, b[:buffer])
+      tip = "Project buffer (#{b[:buffer]} working days)"
+      style = %(grid-row: #{row}; grid-column: #{grid_col} / span #{span};)
+      cells << %(\t\t<div class="gantt_buffer_bar" style="#{style}" title="#{escape_attr(tip)}">buffer</div>\n)
+    end
+    cells
+  end
+
+  # One owner lane across all blocks: the sticky owner label plus that owner's
+  # scheduled bars in each block, offset into the block's day columns.
+  def gantt_lane(owner, row, blocks)
+    cells = [%(\t\t<div class="gantt_owner" style="grid-row: #{row}; grid-column: 1;">#{escape_text(owner)}</div>\n)]
+    blocks.each do |b|
+      b[:items].select { |wi| wi.owner == owner }.each do |wi|
+        cells << gantt_bar(wi, row, b)
+      end
+    end
+    cells
+  end
+
+  # The owner's hidden tracking lane (ADR-213), directly below its planned lane:
+  # a "(tracking)" label and, per work item, a grey committed-window layer and a
+  # blue logged-effort layer. Every cell carries gantt_tracking_lane so the toolbar
+  # toggle shows or collapses the whole lane as one.
+  def gantt_tracking_lane(owner, row, blocks)
+    label = "#{owner} (tracking)"
+    cells = [%(\t\t<div class="gantt_owner_tracking gantt_tracking_lane" style="grid-row: #{row}; ) +
+      %(grid-column: 1;">#{escape_text(label)}</div>\n)]
+    blocks.each do |b|
+      b[:items].select { |wi| wi.owner == owner }.each do |wi|
+        cells.concat(tracking_bars(wi, row, b))
+      end
+    end
+    cells
+  end
+
+  # The 0-2 tracking layers for one work item: the grey committed window (drawn
+  # behind) and the blue logged span (drawn in front, second so it paints on top).
+  # Each is omitted when its dates are absent (ADR-213).
+  def tracking_bars(work_item, row, block)
+    bars = []
+    cs, ce = committed_window(work_item)
+    bars << tracking_bar(work_item, row, block, cs, ce, 'gantt_track_committed', 'Committed') if cs
+    ls, le = logged_window(work_item)
+    bars << tracking_bar(work_item, row, block, ls, le, 'gantt_track_logged', 'Logged') if ls
+    bars
+  end
+
+  def tracking_bar(work_item, row, block, start_date, end_date, klass, kind) # rubocop:disable Metrics/ParameterLists
+    grid_col, span = date_span(block, start_date, end_date)
+    label = "#{work_item.record_id.upcase} #{work_item.activity}"
+    tip = "#{work_item_tip_label(work_item)}\n#{kind}: " \
+          "#{start_date.strftime('%d-%m-%Y')} to #{end_date.strftime('%d-%m-%Y')}"
+    style = %(grid-row: #{row}; grid-column: #{grid_col} / span #{span};)
+    %(\t\t<div class="gantt_track_bar gantt_tracking_lane #{klass}" style="#{style}" ) +
+      %(title="#{escape_attr(tip)}">#{escape_text(label)}</div>\n)
+  end
+
+  # The committed window (ADR-213) of a work item as [start, finish] real dates, or
+  # [nil, nil] when it has no Scope Start Date. A row with a start but no target is
+  # an open commitment: it runs to today (or to its start if that is still ahead),
+  # so a missing target reads as an overrun rather than a point.
+  def committed_window(work_item)
+    return [nil, nil] unless work_item.start_date
+
+    finish = work_item.target_date || [Date.today, work_item.start_date].max
+    [work_item.start_date, finish]
+  end
+
+  # The logged span (ADR-213) of a work item as [earliest, latest] dated effort
+  # crediting its Scope Item, recovered through its owning record, or [nil, nil]
+  # when none is logged.
+  def logged_window(work_item)
+    doc = decisions_by_id[work_item.record_id]
+    doc&.effort_date_range(work_item.activity) || [nil, nil]
+  end
+
+  # Every real actual date the block must keep on the axis (ADR-213): each item's
+  # committed-window end and its logged span. Used to widen the block's columns.
+  def actual_dates(items)
+    items.flat_map do |wi|
+      [committed_window(wi)[1], *logged_window(wi)]
+    end.compact
+  end
+
+  # Decision records keyed by id, so a work item (which carries only its record_id)
+  # can reach its record's effort log (ADR-213).
+  def decisions_by_id
+    @decisions_by_id ||= @project.project_data.decisions.to_h { |d| [d.id, d] }
+  end
+
+  # The [grid-column start, span] covering the business-day columns from start_date
+  # to end_date inclusive (ADR-213). Both dates snap to a business column via the
+  # calendar; an end before the start collapses to a single column.
+  def date_span(block, start_date, end_date)
+    col_start = block[:calendar].business_column_for(start_date)
+    col_end = [block[:calendar].business_column_for(end_date), col_start].max
+    [block[:offset] + col_start + 2, col_end - col_start + 1]
+  end
+
+  # A single work-item bar spanning, on the business-day axis (ADR-206), from its
+  # first to its last working day inclusive -- covering any weekday-holiday columns
+  # it crosses without counting them. Coloured by row Status, outlined when it lies
+  # on the group's critical chain (ADR-212), and emphasised when it is a
+  # started-but-blocked cross-record violation.
+  def gantt_bar(work_item, row, block)
+    grid_col, span = calendar_span(block, block[:starts][work_item], block[:scheduler].duration_for(work_item))
+    classes = ['gantt_bar', gantt_status_class(work_item)]
+    classes << 'gantt_critical' if block[:chain].include?(work_item)
+    classes << 'gantt_blocked' if work_item.cross_record_violation?
+    label = "#{work_item.record_id.upcase} #{work_item.activity}"
+    style = %(grid-row: #{row}; grid-column: #{grid_col} / span #{span};)
+    %(\t\t<div class="#{classes.join(' ')}" style="#{style}" title="#{escape_attr(bar_tooltip(work_item))}">) +
+      %(#{escape_text(label)}</div>\n)
+  end
+
+  # The dependency hint shown on a bar's native title tooltip: the work item's own
+  # name, a blank line, then an "After:" list of every predecessor (ADR-194) it
+  # waits on -- internal (intra-record phase order) first, then external
+  # (cross-record Depends On) -- each as RECORD-ID.Activity on its own line. The
+  # blank line separates the item from its prerequisites for readability; newlines
+  # render as line breaks in the native title tooltip.
+  def bar_tooltip(work_item)
+    name = work_item_tip_label(work_item)
+    preds = work_item.intra_record_predecessors + work_item.cross_record_predecessors
+    deps = preds.map { |p| work_item_tip_label(p) }.uniq
+    return name if deps.empty?
+
+    "#{name}\n\nAfter:\n#{deps.join("\n")}"
+  end
+
+  # A work item named for the tooltip as RECORD-ID (upper-case) dot activity,
+  # e.g. "ADR-201.Analysis" -- the step number is intentionally omitted.
+  def work_item_tip_label(work_item)
+    "#{work_item.record_id.upcase}.#{work_item.activity}"
+  end
+
+  # The [grid-column start, span] of a run of `duration` working days beginning at
+  # working day start_wd, projected onto the block's business-day columns so the
+  # run covers any weekday-holiday columns it crosses, but not weekends (ADR-206).
+  def calendar_span(block, start_wd, duration)
+    col_start = block[:calendar].business_index(start_wd)
+    span = block[:calendar].business_index(start_wd + duration - 1) - col_start + 1
+    [block[:offset] + col_start + 2, span]
+  end
+
+  def gantt_status_class(work_item)
+    case work_item.status
+    when 'Done' then 'gantt_done'
+    when 'In-Progress' then 'gantt_inprogress'
+    else 'gantt_todo'
+    end
+  end
+
   CHART_PALETTE = [
     [54, 162, 235], [255, 99, 132], [255, 159, 64], [255, 205, 86],
     [75, 192, 192], [153, 102, 255], [201, 203, 207]
@@ -77,34 +534,29 @@ class DecisionsOverview < BaseDocument # rubocop:disable Style/Documentation,Met
   # this category as a data-quality indicator rather than being silently dropped.
   UNDEFINED_STATUS_LABEL = 'Undefined'
 
-  def render_charts_grid # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-    counts = @project.project_data.decisions.each_with_object(Hash.new(0)) do |item, cntr|
-      cntr[item.record_type] += 1 if item.record_type
-    end
-    labels = counts.keys.sort
-    data = labels.map { |k| counts[k] }
-    pie_colors = labels.each_with_index.map { |_, i| palette_rgba(i, 0.5) }
-
+  def render_charts_grid
+    wip = wip_by_owner_chart_data
     velocity = velocity_chart_data
     status_dist = status_distribution_chart_data
 
     <<~HTML
       <div class="decisions_overview_charts">
       \t<div class="chart_cell">
-      \t\t<canvas id="decisions_type_pie"></canvas>
+      \t\t<canvas id="decisions_wip_bar"></canvas>
       \t\t<script>
-      \t\t\tnew Chart(document.getElementById('decisions_type_pie'), {
-      \t\t\t\ttype: 'pie',
+      \t\t\tnew Chart(document.getElementById('decisions_wip_bar'), {
+      \t\t\t\ttype: 'bar',
       \t\t\t\tdata: {
-      \t\t\t\t\tlabels: #{labels.to_json},
-      \t\t\t\t\tdatasets: [{
-      \t\t\t\t\t\tlabel: 'Decision records',
-      \t\t\t\t\t\tdata: #{data.to_json},
-      \t\t\t\t\t\tbackgroundColor: #{pie_colors.to_json},
-      \t\t\t\t\t\tborderWidth: 0
-      \t\t\t\t\t}]
+      \t\t\t\t\tlabels: #{wip[:labels].to_json},
+      \t\t\t\t\tdatasets: [
+      \t\t\t\t\t\t{ label: 'In-progress items', data: #{wip[:bars].to_json}, backgroundColor: #{wip[:bar_colors].to_json}, borderWidth: 0, order: 2 },
+      \t\t\t\t\t\t{ type: 'line', label: 'WIP limit', data: #{wip[:limit_line].to_json}, borderColor: 'rgba(255, 99, 132, 1)', borderDash: [6, 4], pointRadius: 0, fill: false, order: 1 }
+      \t\t\t\t\t]
       \t\t\t\t},
-      \t\t\t\toptions: { plugins: { title: { display: true, text: 'Decision Records by Type' } } }
+      \t\t\t\toptions: {
+      \t\t\t\t\tplugins: { title: { display: true, text: 'Work In Progress by Owner' } },
+      \t\t\t\t\tscales: { y: { beginAtZero: true, ticks: { precision: 0 } } }
+      \t\t\t\t}
       \t\t\t});
       \t\t</script>
       \t</div>
@@ -139,7 +591,122 @@ class DecisionsOverview < BaseDocument # rubocop:disable Style/Documentation,Met
     HTML
   end
 
-  def velocity_chart_data(reference_date: Date.today, weeks: 6) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+  # Show a bar for EVERY owner named in any decision record's Scope table, its
+  # height being that owner's count of In-Progress Scope rows across all records
+  # (zero when the owner has none). Rendering the full roster of roles keeps the
+  # freeze line spanning the chart even when only one owner is currently busy --
+  # a single bar would otherwise leave the category-aligned limit line with one
+  # point and nothing to draw. Bars are ordered by descending count, idle owners
+  # (tied at zero) last in first-seen order; an owner over the limit uses the
+  # warning colour. The limit is a flat line dataset so the threshold needs no plugin.
+  def wip_by_owner_chart_data
+    tally = in_progress_tally
+    owners = ordered_owners(tally)
+    limit = @project.configuration.get_wip_limit
+    {
+      labels: owners,
+      bars: owners.map { |owner| tally[owner] },
+      bar_colors: owners.map { |owner| tally[owner] > limit ? palette_rgba(1, 0.7) : palette_rgba(0, 0.5) },
+      limit_line: Array.new(owners.length, limit)
+    }
+  end
+
+  # In-Progress Scope-row count per owner, across all decision records.
+  def in_progress_tally
+    tally = Hash.new(0)
+    @project.project_data.decisions.each do |doc|
+      doc.in_progress_owner_tally.each { |owner| tally[owner] += 1 }
+    end
+    tally
+  end
+
+  # Every owner named in any Scope table, ordered by descending in-progress count;
+  # idle owners (tied at zero) fall to the end in first-seen order.
+  def ordered_owners(tally)
+    first_seen = []
+    @project.project_data.decisions.each do |doc|
+      doc.owners.each { |owner| first_seen << owner unless first_seen.include?(owner) }
+    end
+    first_seen.sort_by { |owner| [-tally[owner], first_seen.index(owner)] }
+  end
+
+  # The owner order for the Gantt lanes (ADR-204): the workflow sequence the
+  # records collectively describe, rather than the heatmap's current-load order.
+  # Each record's distinct owner sequence (doc.owners) votes on every ordered
+  # owner pair into a pairwise-precedence tally (before[[a, b]] = records placing
+  # a before b); owners are then ranked by Copeland score, with the first-seen
+  # order as a deterministic tiebreak so the lanes are identical across runs.
+  # Opposite-order records are simply outvoted, a missing role abstains, and an
+  # added role is placed by the pairs it does appear in -- no special-casing.
+  def consensus_owner_order
+    first_seen, before = owner_precedence
+    first_seen.sort_by { |owner| [-copeland_score(owner, first_seen, before), first_seen.index(owner)] }
+  end
+
+  # One pass over the records yielding both the first-seen owner roster and the
+  # pairwise-precedence tally before[[a, b]] -- the number of records placing a
+  # before b across every ordered pair of a record's distinct owners. Shared so
+  # the consensus order needs no second iteration over the records (ADR-204).
+  def owner_precedence
+    first_seen = []
+    before = Hash.new(0)
+    @project.project_data.decisions.each do |doc|
+      owners = doc.owners
+      owners.each_with_index do |owner, i|
+        first_seen << owner unless first_seen.include?(owner)
+        owners.drop(i + 1).each { |later| before[[owner, later]] += 1 }
+      end
+    end
+    [first_seen, before]
+  end
+
+  # Copeland score for one owner against the roster: +1 for every other owner it
+  # precedes more often than it follows, -1 for the reverse, 0 when tied. One
+  # integer per owner keeps the sort well-defined even if the pairwise majorities
+  # form a cycle, so no cycle detection is needed (ADR-204).
+  def copeland_score(owner, roster, before)
+    roster.sum do |other|
+      next 0 if other == owner
+
+      before[[owner, other]] <=> before[[other, owner]]
+    end
+  end
+
+  # Retained for re-enablement: the original "Decision Records by Type" pie chart.
+  # Its cell is no longer emitted into the charts grid (the WIP-by-Owner chart took
+  # the left slot), but the builder is kept intact so the pie can be restored by
+  # emitting this cell again, with no data work.
+  def pie_chart_cell
+    counts = @project.project_data.decisions.each_with_object(Hash.new(0)) do |item, cntr|
+      cntr[item.record_type] += 1 if item.record_type
+    end
+    labels = counts.keys.sort
+    data = labels.map { |k| counts[k] }
+    pie_colors = labels.each_with_index.map { |_, i| palette_rgba(i, 0.5) }
+
+    <<~HTML
+      \t<div class="chart_cell">
+      \t\t<canvas id="decisions_type_pie"></canvas>
+      \t\t<script>
+      \t\t\tnew Chart(document.getElementById('decisions_type_pie'), {
+      \t\t\t\ttype: 'pie',
+      \t\t\t\tdata: {
+      \t\t\t\t\tlabels: #{labels.to_json},
+      \t\t\t\t\tdatasets: [{
+      \t\t\t\t\t\tlabel: 'Decision records',
+      \t\t\t\t\t\tdata: #{data.to_json},
+      \t\t\t\t\t\tbackgroundColor: #{pie_colors.to_json},
+      \t\t\t\t\t\tborderWidth: 0
+      \t\t\t\t\t}]
+      \t\t\t\t},
+      \t\t\t\toptions: { plugins: { title: { display: true, text: 'Decision Records by Type' } } }
+      \t\t\t});
+      \t\t</script>
+      \t</div>
+    HTML
+  end
+
+  def velocity_chart_data(reference_date: Date.today, weeks: 6)
     fridays = recent_fridays(reference_date, weeks)
     segments = []
     counts = {}
@@ -168,7 +735,7 @@ class DecisionsOverview < BaseDocument # rubocop:disable Style/Documentation,Met
   # is ordered last; real statuses keep first-seen order. The count is baked into
   # each label so small categories stay legible on a linear axis next to a
   # dominant one.
-  def status_distribution_chart_data # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+  def status_distribution_chart_data
     counts = Hash.new(0)
     keys = []
     @project.project_data.decisions.each do |doc|
@@ -193,11 +760,4 @@ class DecisionsOverview < BaseDocument # rubocop:disable Style/Documentation,Met
     r, g, b = CHART_PALETTE[index % CHART_PALETTE.length]
     "rgba(#{r}, #{g}, #{b}, #{alpha})"
   end
-
-  def recent_fridays(reference_date, count)
-    friday_wday = 5
-    days_back = (reference_date.wday - friday_wday) % 7
-    most_recent = reference_date - days_back
-    (0...count).to_a.reverse.map { |i| most_recent - (7 * i) }
-  end
 end