Almirah 0.4.4 → 0.4.5

data/lib/almirah/doc_types/critical_chain_page.rb

@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-require 'date'
-require 'json'
-require_relative 'base_document'
-require_relative 'decision_grouping'
-require_relative 'planning_dates'
-require_relative '../html_safe'
-require_relative '../project/critical_chain'
-require_relative '../project/fever_chart'
-require_relative '../project/working_calendar'
-
-# The dedicated Critical Chain & Project Buffer page (ENH-202): one block per
-# decision group, each showing the ordered critical chain rows, the project
-# buffer, and the projected duration; a group with no estimates is marked
-# unestimated. The chain and buffer are ADR-195's CriticalChain, reused
-# unchanged -- this page only relocates the rendering off the overview.
-class CriticalChainPage < BaseDocument
-  include HtmlSafe
-  include DecisionGrouping
-  include PlanningDates
-
-  # Recent Fridays sampled for the fever-chart trail (ADR-196), matching the
-  # velocity chart's window.
-  FEVER_TRAIL_WEEKS = 6
-
-  attr_accessor :project
-
-  def initialize(project)
-    super()
-    @project = project
-    @title = 'Critical Chain & Project Buffer'
-    @id = 'critical-chain'
-  end
-
-  def to_console
-    puts "\e[36mCritical Chain: #{@id}\e[0m"
-  end
-
-  def needs_chartjs?
-    true
-  end
-
-  def to_html(output_file_path)
-    html_rows = ['', "<h1>#{@title}</h1>\n", render_critical_chain]
-    save_html_to_file(html_rows, nil, output_file_path)
-  end
-
-  private
-
-  def render_critical_chain
-    ratio = @project.configuration.get_buffer_ratio
-    hours_per_day = @project.configuration.get_hours_per_day
-    lookup = record_lookup
-    blocks = grouped_work_items.each_with_index.map do |(name, items), index|
-      critical_chain_block(name, items, ratio, lookup, hours_per_day, index)
-    end
-    blocks << %(\t<p class="cc_unestimated">No decision records to plan.</p>\n) if blocks.empty?
-    %(<div class="critical_chain">\n#{blocks.join}</div>\n)
-  end
-
-  # The calendar a group's projected completion date is measured on (ADR-211):
-  # one anchored at the group's declared planning.groups start date, or the
-  # shared project-anchored calendar when the group declares none. Memoised per
-  # group name so each group reuses one calendar.
-  def group_calendar(name)
-    @group_calendars ||= {}
-    @group_calendars[name] ||= begin
-      start = @project.configuration.get_group_start_dates[name]
-      start ? WorkingCalendar.new(anchor: start, holidays: @project.configuration.get_holidays) : working_calendar
-    end
-  end
-
-  # An upcased-record-id => Decision map, so a chain row can reach its owning
-  # record's effort log (ADR-196).
-  def record_lookup
-    @project.project_data.decisions.to_h { |doc| [doc.id.to_s.upcase, doc] }
-  end
-
-  # The shared working calendar (ADR-205) projecting the working-day projected
-  # duration onto a real completion date.
-  def working_calendar
-    @working_calendar ||= WorkingCalendar.new(anchor: @project.configuration.get_start_date,
-                                              holidays: @project.configuration.get_holidays)
-  end
-
-  def critical_chain_block(name, items, ratio, lookup, hours_per_day, index) # rubocop:disable Metrics/ParameterLists
-    plan = CriticalChain.new(items, buffer_ratio: ratio)
-    header = %(\t<div class="cc_group">\n\t\t<h3>#{escape_text(name)}</h3>\n)
-    body = if plan.estimated?
-             cc_group_body(plan, lookup, hours_per_day, index, group_calendar(name))
-           else
-             %(\t\t<p class="cc_unestimated">No estimates — plan not sized.</p>\n)
-           end
-    "#{header}#{body}\t</div>\n"
-  end
-
-  # The estimated group's plan (chain table + buffer + projected duration) on the
-  # left and its buffer-consumption fever chart on the right, side by side
-  # (ADR-196). The chart is omitted when no chain row carries a positive estimate.
-  def cc_group_body(plan, lookup, hours_per_day, index, calendar)
-    fever = FeverChart.new(plan, lookup, hours_per_day: hours_per_day)
-    left = %(\t\t<div class="cc_plan">\n#{cc_chain_html(plan, fever, calendar)}\t\t</div>\n)
-    right = fever.plottable? ? %(\t\t<div class="cc_fever">\n#{fever_chart_html(fever, index)}\t\t</div>\n) : ''
-    %(\t\t<div class="cc_group_body">\n#{left}#{right}\t\t</div>\n)
-  end
-
-  def cc_chain_html(plan, fever, calendar)
-    lines = [%(\t\t<table class="cc_chain">\n),
-             "\t\t\t<thead><th>Record</th><th>Item</th><th>Owner</th><th>Duration</th></thead>\n"]
-    plan.chain.each { |wi| lines << cc_chain_row(wi) }
-    lines << "\t\t</table>\n"
-    projected = format_days(plan.projected_duration)
-    finish = calendar.date_for(plan.projected_duration)
-    lines << %(\t\t<p class="cc_buffer">Project buffer: #{plan.buffer} working days</p>\n)
-    lines << cc_consumed_html(plan, fever)
-    lines << %(\t\t<p class="cc_projected">Projected duration: #{projected} working days</p>\n)
-    lines << %(\t\t<p class="cc_finish">Projected completion: #{finish.strftime('%d-%m-%Y')}</p>\n)
-    lines.join
-  end
-
-  # The live buffer-health line shown under the buffer figure: how much of the
-  # project buffer the chain's overruns have eaten so far, as a percentage and as
-  # days of the baseline buffer. The percentage and day count both come from the
-  # fever chart, so the figure and the chart's live point always agree, and the
-  # "of N baseline days" makes explicit that the denominator is the baseline
-  # buffer -- not the (remaining-work) "Project buffer" figure above it. Empty
-  # when the plan carries no buffer to consume (no positive-estimate chain row, or
-  # zero baseline buffer).
-  def cc_consumed_html(plan, fever)
-    return '' unless fever.plottable? && plan.baseline_buffer.positive?
-
-    today = Date.today
-    consumed_pct = fever.live_point(today).last.round
-    consumed_days = format_days(fever.consumed_days(today).round(1))
-    baseline = plan.baseline_buffer
-    unit = baseline == 1 ? 'day' : 'days'
-    detail = "#{consumed_days} of #{baseline} baseline #{unit}"
-    %(\t\t<p class="cc_consumed">Buffer consumed: #{consumed_pct}% (#{detail})</p>\n)
-  end
-
-  def cc_chain_row(work_item)
-    cells = [work_item.record_id.upcase, work_item.activity, work_item.owner, format_days(work_item.focused_estimate)]
-    "\t\t\t<tr>#{cells.map { |c| "<td>#{escape_text(c.to_s)}</td>" }.join}</tr>\n"
-  end
-
-  # A working-day count without a trailing ".0" when it is whole.
-  def format_days(value)
-    value == value.to_i ? value.to_i.to_s : value.to_s
-  end
-
-  # The fever chart: the effort-only historical trail over recent Fridays plus the
-  # live point (which credits Done rows), drawn over the green/yellow/red zones.
-  def fever_chart_html(fever, index)
-    today = Date.today
-    fridays = recent_fridays(today, FEVER_TRAIL_WEEKS)
-    dates = fridays + [today]
-    points = fever.trail(fridays) + [fever.live_point(today)]
-    coords = points.zip(dates).map do |(completion, consumption), date|
-      { x: completion.round(2), y: consumption.round(2), d: date.strftime('%b %-d') }
-    end
-    radii = Array.new(coords.length - 1, 3) + [6]
-    colors = points.map { |completion, consumption| zone_color(completion, consumption) }
-    fever_canvas_script("fever_chart_#{index}", coords, radii, colors)
-  end
-
-  def fever_canvas_script(canvas_id, coords, radii, colors)
-    <<~HTML
-      \t\t\t<canvas id="#{canvas_id}" class="fever_canvas"></canvas>
-      \t\t\t<script>
-      \t\t\t#{fever_zone_plugin_js}
-      \t\t\tnew Chart(document.getElementById('#{canvas_id}'), {
-      \t\t\t\ttype: 'scatter',
-      \t\t\t\tdata: { datasets: [{ label: 'Buffer health', data: #{coords.to_json}, showLine: true,
-      \t\t\t\t\tborderColor: 'rgba(80,80,80,0.7)', pointRadius: #{radii.to_json},
-      \t\t\t\t\tpointBackgroundColor: #{colors.to_json}, pointBorderColor: '#333' }] },
-      \t\t\t\toptions: { responsive: true, maintainAspectRatio: false, plugins: { legend: { display: false },
-      \t\t\t\t\ttooltip: { callbacks: { label: (ctx) => ctx.raw.d + ': (' + ctx.parsed.x + ', ' + ctx.parsed.y + ')' } } },
-      \t\t\t\t\tscales: { x: { title: { display: true, text: 'Chain completion %' }, min: 0, max: 100 },
-      \t\t\t\t\t\ty: { title: { display: true, text: 'Buffer consumption %' }, min: 0, suggestedMax: 100 } } },
-      \t\t\t\tplugins: [window.feverZonesPlugin]
-      \t\t\t});
-      \t\t\t</script>
-    HTML
-  end
-
-  # The conventional CCPM zone for a point: green below the lower one-third
-  # diagonal, red above the upper, yellow between (ADR-196).
-  def zone_color(completion, consumption)
-    lower = (2.0 / 3.0) * completion
-    upper = (100.0 / 3.0) + (2.0 / 3.0) * completion
-    return '#2e9e2e' if consumption <= lower
-    return '#e0a200' if consumption <= upper
-
-    '#d33'
-  end
-
-  # A page-global Chart.js plugin (declared once, idempotently) that paints the
-  # three fever zones behind every fever chart on the page.
-  def fever_zone_plugin_js
-    <<~JS.strip
-      window.feverZonesPlugin = window.feverZonesPlugin || { id: 'feverZones', beforeDraw(chart) {
-        const a = chart.chartArea; if (!a) return; const x = chart.scales.x, y = chart.scales.y;
-        const px = v => x.getPixelForValue(v), py = v => y.getPixelForValue(v);
-        const lower = c => (2/3)*c, upper = c => 100/3 + (2/3)*c, ctx = chart.ctx;
-        ctx.save();
-        ctx.fillStyle = 'rgba(224,162,0,0.10)'; ctx.fillRect(a.left, a.top, a.width, a.height);
-        ctx.fillStyle = 'rgba(46,158,46,0.12)'; ctx.beginPath();
-        ctx.moveTo(px(0), py(0)); ctx.lineTo(px(100), py(lower(100)));
-        ctx.lineTo(px(100), py(y.min)); ctx.lineTo(px(0), py(y.min)); ctx.closePath(); ctx.fill();
-        ctx.fillStyle = 'rgba(221,51,51,0.12)'; ctx.beginPath();
-        ctx.moveTo(px(0), py(upper(0))); ctx.lineTo(px(100), py(100));
-        ctx.lineTo(px(100), py(y.max)); ctx.lineTo(px(0), py(y.max)); ctx.closePath(); ctx.fill();
-        ctx.restore();
-      } };
-    JS
-  end
-end

data/lib/almirah/doc_types/decision_grouping.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-# Shared helper for the planning views: the non-empty decision groups (ADR-197)
-# paired with their Scope-row work items. Used by the overview's group-segmented
-# Gantt (ADR-201) and the dedicated Critical Chain page (ADR-195 / ENH-202).
-module DecisionGrouping
-  # [[group-name, [WorkItem, ...]], ...] in decision_groups (folder-encounter)
-  # order, only groups that have at least one work item.
-  def grouped_work_items
-    by_record = @project.project_data.work_items.values.group_by(&:record_id)
-    @project.project_data.decision_groups.filter_map do |group|
-      name = group.keys.first
-      items = group.values.first.flat_map { |doc| by_record[doc.id] || [] }
-      [name, items] unless items.empty?
-    end
-  end
-end

data/lib/almirah/project/critical_chain.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'work_item_scheduler'
-
-# Resource-levelled scheduler variant for the critical chain (ADR-195): each
-# row's duration is its focused estimate, and rows are prioritised by the longest
-# downstream chain of focused durations (ties: record sequence, then step). The
-# forward pass, resource levelling, binding-predecessor tracking, and chain
-# tracing are all inherited from WorkItemScheduler.
-class ChainScheduler < WorkItemScheduler
-  def duration_for(work_item)
-    work_item.focused_estimate
-  end
-
-  private
-
-  def priority_key(work_item, memo)
-    [-downstream_length(work_item, memo, []), work_item.record_sequence, work_item.step]
-  end
-
-  # The longest path of focused durations from this row through its in-scope
-  # successors to a sink. Memoised and cycle-guarded.
-  def downstream_length(work_item, memo, stack)
-    return memo[work_item] if memo.key?(work_item)
-    return duration_for(work_item) if stack.include?(work_item)
-
-    stack.push(work_item)
-    tail = scoped_successors(work_item).map { |s| downstream_length(s, memo, stack) }.max || 0
-    stack.pop
-    memo[work_item] = duration_for(work_item) + tail
-  end
-end
-
-# The Gantt's scheduler (ADR-201/195): real focused-estimate durations like the
-# critical-chain scheduler, but rounded up to whole day columns with a one-day
-# minimum so an unestimated row (focused 0) still shows a visible bar. The chain
-# and buffer keep their exact-duration math in ChainScheduler / CriticalChain.
-class GanttScheduler < ChainScheduler
-  def duration_for(work_item)
-    [work_item.focused_estimate.ceil, 1].max
-  end
-end
-
-# The critical chain and project buffer for one decision group's Scope rows
-# (ADR-195). This object serves two distinct jobs that want opposite treatment of
-# completed work, so it keeps two views of the same Scope rows:
-#
-# - the *scheduling* chain (`chain` / `buffer` / `projected_duration`) excludes
-#   Done rows as finished work — you do not re-schedule what is already done — and
-#   reports the duration of the work still remaining;
-# - the *baseline* chain (`baseline_chain` / `baseline_buffer`) keeps every row,
-#   Done included, as the plan was originally sized. Buffer-consumption accounting
-#   (the fever chart, ADR-196) reads this view so that a chain row which overran
-#   and then completed keeps consuming buffer instead of vanishing the moment it
-#   is marked Done, and so the consumption denominator stays a stable plan-time
-#   baseline rather than shrinking as rows finish (issue-207).
-#
-# A predecessor outside the given set (a row in another group) drops out and is
-# treated as an already-available input. The buffer aggregates the safety
-# (safe - focused, clamped at 0) along a chain and cuts it by buffer_ratio,
-# rounded up.
-class CriticalChain
-  def initialize(work_items, buffer_ratio: 0.5)
-    @all_items = work_items
-    @items = work_items.reject(&:done?)
-    @buffer_ratio = buffer_ratio
-    @scheduler = ChainScheduler.new(@items)
-    @baseline_scheduler = ChainScheduler.new(@all_items)
-  end
-
-  # The remaining chain (Done rows excluded) in start order — drives the chain
-  # table and the projected completion of the work still to do.
-  def chain
-    @scheduler.critical_chain
-  end
-
-  # The chain as originally planned, completed rows included (issue-207). Buffer
-  # consumption is accounted against this set so completed overruns stay visible.
-  def baseline_chain
-    @baseline_scheduler.critical_chain
-  end
-
-  # Chain length in working days (the latest finish).
-  def length
-    @scheduler.makespan
-  end
-
-  # ceil(buffer_ratio * Σ_chain max(safe - focused, 0)) over the remaining chain.
-  def buffer
-    buffer_for(chain)
-  end
-
-  # The plan-time buffer over the full baseline chain — the stable denominator for
-  # buffer-consumption %, unaffected by rows completing (issue-207).
-  def baseline_buffer
-    buffer_for(baseline_chain)
-  end
-
-  def projected_duration
-    length + buffer
-  end
-
-  # False when no row carries a positive focused estimate, so the overview marks
-  # the group "unestimated" rather than reporting a misleadingly short plan.
-  # Reads the baseline so a fully-completed group still reports as estimated and
-  # keeps its (100%-complete) fever chart instead of collapsing to "not sized".
-  def estimated?
-    @all_items.any? { |wi| wi.focused_estimate.positive? }
-  end
-
-  private
-
-  def buffer_for(rows)
-    safety = rows.sum { |wi| [wi.safe_estimate - wi.focused_estimate, 0].max }
-    (@buffer_ratio * safety).ceil
-  end
-end

data/lib/almirah/project/fever_chart.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-# The buffer-consumption fever chart for one decision group (ADR-196): given the
-# group's CriticalChain plan, the effort logged on its records, and the working-
-# hours-per-day conversion, it produces the (completion%, consumption%) point and
-# the historical trail the Critical Chain page plots.
-#
-# It tracks only chain rows with a positive focused estimate (a zero-estimate row
-# carries no schedule weight). Per-row actual effort is read from the owning
-# Decision's append-only # Effort log via row_actual_hours_on, converted to days;
-# the chart never consults the record lifecycle status.
-#
-# It reads the plan's *baseline* chain and buffer (completed rows included,
-# issue-207), not the remaining-work chain: a chain row that overran and then was
-# marked Done has consumed real buffer that must stay accounted, and the
-# consumption denominator must not shrink as rows finish. The live point still
-# credits a Done row in full via its per-row Status (ADR-196); historical trail
-# points reconstruct even a completed row's progress and overrun from its dated
-# # Effort log, which a per-row Status (no dated history) could not.
-class FeverChart
-  # record_lookup maps an upcased record id (e.g. "ADR-196") to its Decision.
-  def initialize(plan, record_lookup, hours_per_day: 8)
-    @rows = plan.baseline_chain.select { |wi| wi.focused_estimate.positive? }
-    @buffer = plan.baseline_buffer
-    @record_lookup = record_lookup
-    @hours_per_day = hours_per_day.to_f
-  end
-
-  # True when there is anything to plot (at least one positive-estimate chain row).
-  def plottable?
-    @rows.any?
-  end
-
-  # The live fever point [completion%, consumption%] as of `date`: a Done row
-  # credits full completion regardless of logged effort, matching the bounded
-  # per-row Status (ADR-193); other rows credit logged effort only.
-  def live_point(date)
-    [completion(date, live: true), consumption(date)]
-  end
-
-  # A historical point [completion%, consumption%] as of `date`, from logged
-  # effort only (the per-row Status has no dated history to replay).
-  def point_on(date)
-    [completion(date, live: false), consumption(date)]
-  end
-
-  # One historical point per date (recent Fridays), in the given order.
-  def trail(dates)
-    dates.map { |d| point_on(d) }
-  end
-
-  # The baseline buffer days these overruns have consumed as of `date` -- the
-  # numerator behind the consumption percentage (its denominator is the baseline
-  # buffer). Lets the Critical Chain page report "X of Y baseline days".
-  def consumed_days(date)
-    @rows.sum { |wi| [actual_days(wi, date) - wi.focused_estimate, 0].max }
-  end
-
-  private
-
-  def completion(date, live:)
-    total = @rows.sum(&:focused_estimate)
-    return 0.0 if total.zero?
-
-    credited = @rows.sum { |wi| credit(wi, date, live: live) * wi.focused_estimate }
-    100.0 * credited / total
-  end
-
-  def credit(work_item, date, live:)
-    return 1.0 if live && work_item.done?
-
-    clamp01(actual_days(work_item, date) / work_item.focused_estimate)
-  end
-
-  # Percentage of the project buffer consumed: the aggregate amount by which chain
-  # rows overran their focused estimate, over the buffer. May exceed 100. A group
-  # whose chain carries no safety (buffer 0) has nothing to consume, so 0.
-  def consumption(date)
-    return 0.0 if @buffer.zero?
-
-    100.0 * consumed_days(date) / @buffer
-  end
-
-  def actual_days(work_item, date)
-    record = @record_lookup[work_item.record_id.to_s.upcase]
-    return 0.0 if record.nil? || @hours_per_day.zero?
-
-    record.row_actual_hours_on(work_item.activity, date) / @hours_per_day
-  end
-
-  def clamp01(value)
-    value.clamp(0.0, 1.0)
-  end
-end

data/lib/almirah/project/work_item_scheduler.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-# Lays the WorkItem network (ADR-194) on an abstract day axis for the overview
-# swimlane Gantt (ADR-198). It performs a deterministic forward pass over the
-# dependency edges and then levels each owner's lane so two work items of the
-# same owner never overlap. Levelling backfills: a row may be slotted into an
-# idle gap left between rows placed earlier, so a low-priority short row does
-# not queue behind the whole lane when a gap already fits it.
-#
-# Durations are a constant placeholder (3 days) while no per-row estimates
-# exist; `duration_for` is the single hook ADR-195 overrides to feed real
-# estimates without changing the scheduling logic.
-#
-# Days are 1-based. A work item starting on day `s` with duration `d` occupies
-# the inclusive day span `s .. s + d - 1`; its *finish* (the next free day,
-# returned in the ends map) is `s + d`, the earliest a successor or the same
-# owner's next item may start.
-class WorkItemScheduler
-  # Placeholder duration for every work item until ADR-195 supplies estimates.
-  DEFAULT_DURATION = 3
-
-  def initialize(work_items, duration: DEFAULT_DURATION)
-    @items = work_items
-    @duration = duration
-    @item_set = work_items.to_set
-  end
-
-  # { work_item => start_day }, day index 1-based. Empty when there are no items.
-  def start_days
-    schedule unless @starts
-    @starts
-  end
-
-  # The number of day columns the chart needs: the latest finish minus one
-  # (finishes are the exclusive next-free day). Zero when there are no items.
-  def day_count
-    schedule unless @ends
-    @ends.empty? ? 0 : (@ends.values.max - 1)
-  end
-
-  # The schedule length in working days (the latest finish, day 1 being the start).
-  def makespan
-    day_count
-  end
-
-  # The critical chain: the row with the latest finish, traced back through its
-  # binding predecessors (the dependency and resource hand-offs that set each
-  # row's start), returned in start order. Empty when nothing is scheduled.
-  def critical_chain
-    schedule unless @starts
-    return [] if @ends.empty?
-
-    max_end = @ends.values.max
-    node = @items.select { |wi| @ends[wi] == max_end }.min_by { |wi| [wi.record_id, wi.step] }
-    chain = []
-    while node
-      chain.unshift(node)
-      node = @binding[node]
-    end
-    chain
-  end
-
-  def duration_for(_work_item)
-    @duration
-  end
-
-  private
-
-  # Greedy list-scheduler. Items are processed in a deterministic priority order
-  # (resource-free earliest start, then activity rank, record id, step) so that
-  # every item's predecessors are placed before it. Each item starts at the
-  # earliest day at or after its dependency finish where its owner's lane has an
-  # idle gap wide enough for it (resource levelling with backfill).
-  def schedule
-    @starts = {}
-    @ends = {}
-    @binding = {}
-    @owner_rows = Hash.new { |hash, owner| hash[owner] = [] }
-    return if @items.empty?
-
-    priority_order.each { |wi| place(wi) }
-  end
-
-  # Assigns one work item its start day, records the predecessor that bound that
-  # start, then marks the span as occupied in its owner's lane.
-  def place(work_item)
-    preds = scoped_predecessors(work_item)
-    dep_finish = preds.map { |p| @ends[p] || 1 }.max || 1
-    start, lane_pred = earliest_fit(work_item.owner, dep_finish, duration_for(work_item))
-    @starts[work_item] = start
-    @ends[work_item] = start + duration_for(work_item)
-    @binding[work_item] = binding_predecessor(preds, start, lane_pred)
-    @owner_rows[work_item.owner] << work_item unless work_item.owner.empty?
-  end
-
-  # The earliest start at or after `from` where the owner's lane stays clear for
-  # `duration` days, plus the lane row whose finish that start had to wait behind
-  # (nil when the row starts at `from` itself). A blank owner holds no resource,
-  # so it never serialises.
-  def earliest_fit(owner, from, duration)
-    return [from, nil] if owner.empty?
-
-    start = from
-    lane_pred = nil
-    @owner_rows[owner].sort_by { |row| @starts[row] }.each do |row|
-      break if start + duration <= @starts[row]
-      next if @ends[row] <= start
-
-      start = @ends[row]
-      lane_pred = row
-    end
-    [start, lane_pred]
-  end
-
-  # The already-placed predecessor whose finish coincides with this row's start --
-  # the dependency or same-owner hand-off the critical chain is traced back
-  # through. nil when the row starts at the origin with no such predecessor.
-  def binding_predecessor(preds, start, lane_pred)
-    candidates = preds.select { |p| @ends[p] == start }
-    candidates << lane_pred if lane_pred
-    candidates.min_by { |c| [c.record_id, c.step] }
-  end
-
-  def priority_order
-    memo = {}
-    @items.sort_by { |wi| priority_key(wi, memo) }
-  end
-
-  # The deterministic scheduling priority for a row. Overridden by the critical-
-  # chain scheduler (ADR-195) to prioritise the longest downstream duration.
-  def priority_key(work_item, memo)
-    [dependency_start(work_item, memo, []), work_item.activity_rank, work_item.record_id, work_item.step]
-  end
-
-  # The earliest day this item could start ignoring resource contention: 1 when
-  # it has no predecessors, else one past the latest predecessor finish. Memoised
-  # and cycle-guarded — a back-edge (which the DAG-by-construction network should
-  # never have) is treated as start 1 so scheduling still completes.
-  def dependency_start(work_item, memo, stack)
-    return memo[work_item] if memo.key?(work_item)
-    return 1 if stack.include?(work_item)
-
-    preds = scoped_predecessors(work_item)
-    return memo[work_item] = 1 if preds.empty?
-
-    stack.push(work_item)
-    earliest = preds.map { |p| dependency_start(p, memo, stack) + duration_for(p) }.max
-    stack.pop
-    memo[work_item] = earliest
-  end
-
-  # Predecessors inside this scheduler's own item set. A predecessor scheduled in
-  # another scope (e.g. a different decision group, ADR-201) is treated as an
-  # already-available external input: it is dropped here and imposes no finish
-  # constraint, so the dependent simply starts at day 1 with respect to it.
-  def scoped_predecessors(work_item)
-    work_item.predecessor_items.select { |p| @item_set.include?(p) }
-  end
-
-  # Successors inside this scheduler's own item set (the mirror of
-  # scoped_predecessors), used by the critical-chain priority.
-  def scoped_successors(work_item)
-    work_item.successor_items.select { |s| @item_set.include?(s) }
-  end
-end