hecks 7.0.0 → 7.1.0

data/lib/hecks/pipeline_board/adapters/pipeline_jobs.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require_relative "cache"
+
+module Hecks
+  module Adapters
+    # The `Jobs` port's adapter: answers `Sessions` with the dispatched sessions of the last day,
+    # from each job's own `state.json` and `timeline.jsonl` and from `claude agents --json`. It
+    # reads the job's state and never the ledger, and writes nothing.
+    class PipelineJobs
+      WINDOW_SECONDS = 24 * 3600
+      FRESH_SECONDS = 600
+
+      # @param aggregate [Object, nil] unused
+      # @param settings [Hash] `jobs_dir:` the directory of jobs, `agents:` a callable answering
+      #   the parsed `claude agents --json`, `runs:` a callable answering session id => `{row:}`,
+      #   `now:` a callable answering the time
+      # @param root [String, nil] unused
+      def initialize(aggregate: nil, settings: {}, root: nil)
+        @dir = settings[:jobs_dir] || File.join(Dir.home, ".claude", "jobs")
+        @agents = settings[:agents] || -> { PipelineBoard::Probe.json("claude", "agents", "--json") }
+        @runs = settings[:runs] || -> { {} }
+        @now = settings[:now] || -> { Time.now }
+        @cache = PipelineBoard::Cache.new(ttl: settings.fetch(:ttl, 15))
+      end
+
+      # @return [Hash{Symbol => String}] `text:` the sessions as JSON, busy first, then newest first
+      def sessions = { text: JSON.generate(rows) }
+
+      # @return [Array<Hash>] the sessions, each with `id`, `name`, `status`, `state`, `detail`,
+      #   `started`, `ended` and the `row` it was dispatched for
+      def rows
+        agents = listed
+        found = Dir.glob(File.join(@dir, "*", "state.json")).filter_map { |path| session(path, agents) }
+        found.sort_by { |row| [row[:status] == "busy" ? 0 : 1, row[:started].to_s] }.reverse
+      end
+
+      private
+
+      def listed
+        @cache.fetch(:agents) { Array(@agents.call).to_h { |agent| [agent["id"].to_s, agent] } }
+      rescue PipelineBoard::Unavailable
+        {}
+      end
+
+      def session(path, agents)
+        id = File.basename(File.dirname(path))
+        age = @now.call - File.mtime(path)
+        agent = agents[id]
+        return if age > WINDOW_SECONDS && !agent
+
+        build(id, JSON.parse(File.read(path)), agent, age, File.join(File.dirname(path), "timeline.jsonl"))
+      rescue JSON::ParserError, SystemCallError
+        nil
+      end
+
+      def build(id, state, agent, age, timeline)
+        edges = edges_of(timeline)
+        status = status_of(state, agent, age)
+        { id: id, name: name_of(id, agent), status: status, state: state["state"].to_s,
+          detail: state["detail"].to_s.slice(0, 140), started: stamp(agent, edges),
+          ended: status == "busy" ? nil : edges.last, row: @runs.call.dig(id, :row).to_s }
+      end
+
+      def name_of(id, agent) = (agent && agent["name"]) || id
+
+      def status_of(state, agent, age)
+        return "busy" if (agent && agent["status"] == "busy") || (state["state"] == "working" && age < FRESH_SECONDS)
+
+        %w[failed error].include?(state["state"]) ? "failed" : "done"
+      end
+
+      def stamp(agent, edges)
+        agent ? Time.at(agent["startedAt"].to_i / 1000).utc.iso8601 : edges.first
+      end
+
+      def edges_of(timeline)
+        lines = File.readlines(timeline)
+        [lines.first, lines.last].map { |line| JSON.parse(line)["at"] }
+      rescue SystemCallError, JSON::ParserError
+        []
+      end
+    end
+  end
+end

data/lib/hecks/pipeline_board/adapters/pipeline_journal/chain.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hecks
+  module Adapters
+    module PipelineBoard
+      # Turns an event-trace report into board rows: the event, each policy that reacted with the
+      # outcome of its delivery and the command it reached, and the events that followed on the same
+      # record (the ones the command emitted, read from the journal's own order).
+      module Chain
+        FOLLOWING = 3
+
+        private
+
+        def chained(report)
+          events = JSON.parse(JSON.generate(report)).fetch("events", [])
+          events.map.with_index { |entry, index| row(entry, events.drop(index + 1)) }
+        end
+
+        def row(entry, later)
+          event = entry["event"]
+          { key: "journal:#{File.basename(entry["database"].to_s)}:#{event["id"]}", source: "journal",
+            at: event["occurred_at"], aggregate: event["aggregate"], id: event["aggregate_id"],
+            name: event["name"], reactions: entry["subscribers"].to_a.map { |sub| reaction(sub, event, later) } }
+        end
+
+        def reaction(sub, event, later)
+          { policy: sub["consumer"].to_s.sub("policy:", ""), command: sub["reaches"].to_s,
+            outcome: sub["outcome"].to_s, emitted: following(event, later) }
+        end
+
+        def following(event, later)
+          same = later.map { |entry| entry["event"] }.select { |other| other["aggregate_id"] == event["aggregate_id"] }
+          same.first(FOLLOWING).map { |other| other["name"] }
+        end
+      end
+    end
+  end
+end

data/lib/hecks/pipeline_board/adapters/pipeline_journal/tap.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hecks
+  module Adapters
+    module PipelineBoard
+      # Reads the runtime's opt-in event log (`Hecks::Runtime::EventTap`): one JSON line per event
+      # and one per policy delivery, which this reader attaches to the event it answered. A line
+      # that carries its own `policy` is an event with its reaction. It opens the file for reading
+      # only; a missing file holds no events.
+      class Tap
+        TAIL_LINES = 600
+        FOLLOWING = 3
+
+        # @param path [String] the log's path
+        def initialize(path)
+          @path = path
+        end
+
+        # @return [Array<Hash>] the newest events as board rows, oldest first, each with the
+        #   reactions the log holds for it
+        def rows
+          return [] unless File.file?(@path)
+
+          events = parse(File.readlines(@path).last(TAIL_LINES))
+          link(events)
+        rescue SystemCallError
+          []
+        end
+
+        private
+
+        def parse(lines) = lines.filter_map { |line| decode(line) }
+
+        def decode(line)
+          JSON.parse(line)
+        rescue JSON::ParserError
+          nil
+        end
+
+        def link(lines)
+          rows = []
+          lines.each { |line| line["kind"] == "reaction" ? attach(rows, line) : rows << event_row(line, rows.size) }
+          rows.each_with_index { |row, index| follow(row, rows.drop(index + 1)) }
+        end
+
+        def event_row(data, index)
+          { key: "tap:#{data["at"]}:#{data["aggregate"]}:#{data["id"]}:#{data["event"]}:#{index}", source: "tap",
+            at: data["at"], aggregate: data["aggregate"], id: data["id"], name: data["event"], reactions: inline(data) }
+        end
+
+        def inline(data) = data["policy"] ? [reaction(data)] : []
+
+        def reaction(data)
+          { policy: data["policy"], command: data["command"].to_s, outcome: data["outcome"].to_s,
+            emitted: Array(data["emitted"]) }
+        end
+
+        def attach(rows, line)
+          row = rows.reverse.find { |held| held[:id].to_s == line["id"].to_s && held[:name] == bare(line["event"]) }
+          row[:reactions] << reaction(line) if row
+        end
+
+        def bare(name) = name.to_s.split(".").last
+
+        def follow(row, later)
+          names = later.select { |other| other[:id] == row[:id] && other[:name] != row[:name] }.first(FOLLOWING)
+          row[:reactions].each { |reaction| reaction[:emitted] = names.map { |other| other[:name] } if reaction[:emitted].empty? }
+          row
+        end
+      end
+    end
+  end
+end

data/lib/hecks/pipeline_board/adapters/pipeline_journal.adapter

@@ -0,0 +1,7 @@
+# Binds the `Journal` port to `PipelineJournal`, which answers `Events` from the journal stores, read-only.
+# Required by name, not relative, so a copy of this directory shares the one implementation loaded.
+require "hecks/pipeline_board/adapters/pipeline_journal"
+
+Hecks.adapter "PipelineJournal" do
+  port "Journal"
+end

data/lib/hecks/pipeline_board/adapters/pipeline_journal.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "cache"
+require_relative "pipeline_journal/tap"
+require_relative "pipeline_journal/chain"
+
+module Hecks
+  module Adapters
+    # The `Journal` port's adapter: answers `Events` with the newest events the tooling recorded
+    # and, for each, the policies that reacted, what became of the delivery and the command it
+    # reached. The persisted stores are read by the same reader `era.event_trace` uses, opened
+    # read-only; an opt-in local event log (`events.jsonl`) is tailed for the domains that persist
+    # nothing. The board writes to neither.
+    class PipelineJournal
+      include PipelineBoard::Chain
+
+      DEFAULT_DOMAIN = "lib/hecks/hecks"
+
+      # Where the opt-in event log is written when a world turns it on.
+      TAP_PATH = File.join(Dir.home, ".claude", "hecks-dev", "events.jsonl")
+
+      # @param aggregate [Object, nil] unused
+      # @param settings [Hash] `trace:` stands in for the reader (a callable taking the row
+      #   count and answering its report), `tap:` the event log's path, `ttl:` how long a read
+      #   is kept
+      # @param root [String, nil] the checkout whose domain directory is read
+      def initialize(aggregate: nil, settings: {}, root: nil)
+        @root = root || Dir.pwd
+        @trace = settings[:trace] || method(:trace)
+        @tap = PipelineBoard::Tap.new(settings.fetch(:tap) { TAP_PATH })
+        @cache = PipelineBoard::Cache.new(ttl: settings.fetch(:ttl, 2))
+      end
+
+      # @param limit [Hash, Integer, nil] how many events (40 when none is named)
+      # @return [Hash{Symbol => String}] `text:` the events as JSON, newest first
+      def events(limit: nil)
+        { text: JSON.generate(recent(limit.is_a?(Hash) ? limit[:value] : limit)) }
+      end
+
+      # @param limit [Integer, nil] how many events
+      # @return [Array<Hash>] the events, newest first, each with its `key`, `reactions` and
+      #   `source`
+      # @raise [PipelineBoard::Unavailable] when no store can be read and the log holds nothing
+      def recent(limit = nil)
+        count = limit.to_i.positive? ? limit.to_i : 40
+        found = journal(count) + @tap.rows
+        raise PipelineBoard::Unavailable, "no store was readable and no event log exists" if found.empty?
+
+        found.sort_by { |row| row[:at].to_s }.reverse.first(count)
+      end
+
+      private
+
+      def journal(count)
+        @cache.fetch([:trace, count]) { chained(@trace.call(count)) }
+      rescue PipelineBoard::Unavailable
+        []
+      end
+
+      def trace(count)
+        require "hecks"
+        require "hecks/hecks/adapters/journal_store"
+        reading = Adapters::JournalStore::Readings::EventTrace
+        selection = reading::Selection.new(nil, nil, count, nil)
+        reading::Report.new(registry, selection).to_h
+      rescue StandardError => e
+        raise PipelineBoard::Unavailable, "journal: #{e.message[0, 80]}"
+      end
+
+      def registry = @registry ||= Hecks.describe(File.join(owner_root, DEFAULT_DOMAIN)).registry
+
+      # The checkout whose local overlays name the stores: a linked worktree has none, so its main
+      # checkout is read instead.
+      def owner_root
+        common = PipelineBoard::Probe.run("git", "-C", @root, "rev-parse", "--git-common-dir").strip
+        File.basename(common) == ".git" ? File.dirname(File.expand_path(common, @root)) : @root
+      rescue PipelineBoard::Unavailable
+        @root
+      end
+    end
+  end
+end

data/lib/hecks/pipeline_board/adapters/pipeline_stages/ci_tiles.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "tile_kit"
+
+module Hecks
+  module Adapters
+    module PipelineBoard
+      # The tiles that read CI: success rate, wall time against the goal, failed jobs on the head,
+      # how long main has been red, and how long a commit takes to get a green CI.
+      module CiTiles
+        include TileKit
+
+        GOAL_MINUTES = 3
+
+        # @param runs [Array<Hash>] CI runs, oldest first
+        def success(runs)
+          spec = { id: "success", label: "CI success", unit: "%", detail: "last #{runs.size} main runs" }
+          built = windowed(spec, runs) { |list| success_rate(list) }
+          built.merge(state: band(built[:value], 80, 50))
+        end
+
+        def wall(runs)
+          spec = { id: "wall", label: "Median CI wall", unit: "min", lower: true, detail: "goal #{GOAL_MINUTES} min" }
+          built = windowed(spec, runs.select { |run| run[:status] == "completed" }) do |list|
+            median(list.map { |run| run[:wall_minutes] })
+          end
+          built.merge(state: over(built[:value], GOAL_MINUTES))
+        end
+
+        def failed_head(runs)
+          head, before = runs.last(2).reverse
+          return unlisted(head) if head[:failed_jobs].nil?
+
+          change = before && trend(before[:failed_jobs], head[:failed_jobs], "jobs", lower_is_better: true)
+          state = head[:failed_jobs].zero? ? "ok" : "failed"
+          tile("failed_head", "Failed jobs on head", head[:failed_jobs], "jobs",
+               detail: "run #{head[:sha]}", trend: change, state: state)
+        end
+
+        def unlisted(head)
+          unknown_tile("failed_head", "Failed jobs on head", { unknown: "GitHub would not list the jobs of #{head[:sha]}" })
+        end
+
+        def red_for(runs, now)
+          return tile("red", "Main red for", 0, "h", detail: "main is green") if runs.last[:conclusion] == "success"
+
+          green = runs.reverse.find { |run| run[:conclusion] == "success" }
+          hours = green && ((now - finished(green)) / 3600.0).round(1)
+          note = green ? "since #{green[:sha]} went green" : "no green run in the window"
+          tile("red", "Main red for", hours, "h", state: "failed", detail: note)
+        end
+
+        def lead(data, runs)
+          times = data[:commit_times].to_h
+          spec = { id: "lead", label: "Commit to green CI", unit: "min", lower: true,
+                   detail: "landed to pushed is not recorded" }
+          windowed(spec, runs.select { |run| times[run[:sha]] }) do |list|
+            median(list.map { |run| (finished(run) - Time.parse(times[run[:sha]])) / 60.0 })
+          end
+        end
+
+        # @param spec [Hash] `id`, `label`, `unit`, `detail` and `lower` (a fall is an improvement)
+        def windowed(spec, list)
+          early, late = halves(list)
+          change = trend(yield(early), yield(late), spec[:unit], lower_is_better: spec[:lower] || false)
+          tile(spec[:id], spec[:label], yield(list), spec[:unit], detail: spec[:detail], trend: change)
+        end
+
+        def band(value, good, fair)
+          return "unknown" if value.nil?
+          return "ok" if value >= good
+
+          value >= fair ? "attention" : "failed"
+        end
+
+        def over(value, goal)
+          return "unknown" if value.nil?
+          return "ok" if value <= goal
+
+          value <= goal * 2 ? "attention" : "failed"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/pipeline_board/adapters/pipeline_stages/fanout.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    module PipelineBoard
+      # How the work fans out across sessions: which row each session runs, who claimed each row,
+      # and the flags that say the two disagree. It reads rows and answers rows; it decides nothing.
+      module Fanout
+        module_function
+
+        # @param sessions [Array<Hash>] the board's sessions
+        # @param work [Array<Hash>] the open Work items
+        # @param landed [Array<String>] the branches the Landing records say were merged
+        # @param fill [Hash, nil] the Dispatch.Fill preview
+        # @return [Array<Hash>] one row per open Work row: its claim, its sessions and its flags
+        def mapping(sessions:, work:, landed:, fill:)
+          busy = sessions.select { |s| s[:status] == "busy" }
+          world = { busy: busy, landed: landed, fill: fill, areas: work.to_h { |w| [w[:slug], w[:area].to_a] } }
+          work.map { |row| mapped(row, world) }
+        end
+
+        # @return [Array<Hash>] every flag of every row, each with its `row`, `kind` and `detail`
+        def flags_of(mapped) = mapped.flat_map { |m| m[:flags].map { |flag| flag.merge(row: m[:slug]) } }
+
+        def mapped(row, world)
+          on = world[:busy].select { |s| s[:row] == row[:slug] }
+          { slug: row[:slug], status: row[:status], claimed_by: row[:claimed_by], claimed_at: row[:claimed_at],
+            sessions: on.map { |s| s[:id] }, flags: flags(row, on, world) }
+        end
+
+        def flags(row, on, world)
+          found = []
+          found << unclaimed(row, on) if on.any? && row[:claimed_by].to_s.empty?
+          found << twice(on) if on.size > 1
+          found.concat(overlapping(row, on, world))
+          found.concat(stale(row, world))
+        end
+
+        def unclaimed(row, on)
+          { kind: "unclaimed", detail: "#{on.first[:id]} runs on #{row[:slug]}, which has no claimed_by" }
+        end
+
+        def twice(on)
+          { kind: "duplicate", detail: "#{on.size} sessions run on one work item: #{on.map { |s| s[:id] }.join(", ")}" }
+        end
+
+        def overlapping(row, on, world)
+          return [] if on.empty?
+
+          clash = world[:busy].select { |s| s[:row] != row[:slug] && clashes?(s, row, world) }
+          clash.map { |s| { kind: "overlap", detail: "#{s[:id]} (#{s[:row]}) works an area that overlaps #{row[:slug]}" } }
+        end
+
+        def clashes?(session, row, world) = touches?(world[:areas][session[:row]], row[:area].to_a)
+
+        def touches?(mine, theirs)
+          mine.to_a.any? { |a| theirs.any? { |b| a.start_with?(b) || b.start_with?(a) } }
+        end
+
+        def stale(row, world)
+          return [] unless world[:landed].include?(row[:slug]) && %w[planned started].include?(row[:status])
+
+          [{ kind: "landed", detail: "#{row[:slug]} already landed but is still #{row[:status]}#{restart(row, world)}" }]
+        end
+
+        def restart(row, world)
+          again = world[:fill].to_h.fetch(:would_start, []).any? { |pick| pick[:slug] == row[:slug] }
+          again ? "; Dispatch.Fill would start another session on it" : ""
+        end
+      end
+    end
+  end
+end

data/lib/hecks/pipeline_board/adapters/pipeline_stages/gather.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hecks
+  module Adapters
+    module PipelineBoard
+      # Asks each reader its question and keeps the answer, or `{unknown: <reason>}` when the reader
+      # could not answer, so one failed read never takes the others down. The reads run side by
+      # side, so a page takes as long as its slowest read.
+      module Gather
+        # Each section: the reader, its method, whether it answers a query document, and arguments.
+        READS = {
+          ci_runs: [:github, :ci_runs, :query], slowest_jobs: [:github, :slowest_jobs, :query],
+          release: %i[github latest_release plain], local: %i[git local_main plain],
+          train: %i[git train plain], stable: %i[git stable plain],
+          open_work: [:tickets, :open_work, :query], counts: %i[tickets counts plain],
+          landed: %i[tickets landed_branches plain], sessions: [:jobs, :sessions, :query],
+          red_flag: %i[git red_flag plain], fill: %i[fill preview plain], events: [:journal, :recent, :plain, 40],
+          history: [:journal, :recent, :plain, 300]
+        }.freeze
+
+        private
+
+        def guard
+          yield
+        rescue PipelineBoard::Unavailable => e
+          { unknown: e.message }
+        rescue StandardError => e
+          { unknown: "#{e.class}: #{e.message.to_s.slice(0, 100)}" }
+        end
+
+        def queried
+          guard { JSON.parse(yield[:text], symbolize_names: true) }
+        end
+
+        def read(spec)
+          reader, method, kind, *args = spec
+          ask = -> { instance_variable_get("@#{reader}").public_send(method, *args) }
+          kind == :query ? queried(&ask) : guard(&ask)
+        end
+
+        def gathered
+          threads = READS.transform_values { |spec| Thread.new { read(spec) } }
+          threads.transform_values(&:value)
+        end
+
+        def dated(data)
+          runs = data[:ci_runs]
+          return {} unless runs.is_a?(Array)
+
+          { commit_times: guard { @git.commit_times(runs.map { |run| run[:sha] }) } }
+        end
+      end
+    end
+  end
+end

data/lib/hecks/pipeline_board/adapters/pipeline_stages/metrics.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "ci_tiles"
+require_relative "work_tiles"
+
+module Hecks
+  module Adapters
+    module PipelineBoard
+      # The key-metric tiles: each a number, its unit, a state word and a trend against the earlier
+      # half of the same window. A section that could not be read gives a tile that says `unknown`.
+      module Metrics
+        extend CiTiles
+        extend WorkTiles
+
+        # @param data [Hash] the board's sections, each an answer or `{unknown: reason}`
+        # @param now [Time] the time the tiles are read at
+        # @return [Array<Hash>] the tiles, in the order the page shows them
+        def self.tiles(data, now)
+          runs = data[:ci_runs]
+          return [unknown_tile("ci", "CI", runs)] + work(data, now) unless runs.is_a?(Array) && !runs.empty?
+
+          ci(data, runs, now) + work(data, now)
+        end
+
+        def self.ci(data, runs, now)
+          [success(runs), wall(runs), failed_head(runs), red_for(runs, now), lead(data, runs)]
+        end
+
+        def self.work(data, now)
+          [ahead(data[:local], now), working(data), throughput(data[:history], now), release(data[:release], now)]
+        end
+      end
+    end
+  end
+end

data/lib/hecks/pipeline_board/adapters/pipeline_stages/strip.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "time"
+require "hecks/hecks/adapters/red_flag_report"
+
+module Hecks
+  module Adapters
+    module PipelineBoard
+      # The pipeline strip: one row per stage, left to right, each with a state word, a count and a
+      # one-line detail. A stage whose section could not be read says `unknown: <reason>` and the
+      # others still answer.
+      module Strip
+        module_function
+
+        # @param data [Hash] the board's sections
+        # @param now [Time] the time the stages are read at
+        # @return [Array<Hash>] `name`, `state`, `count` and `detail` for each stage
+        def build(data, now)
+          [*flag(data[:red_flag], now), work(data[:counts]), sessions(data[:sessions]), local(data[:local]),
+           train(data[:train], now), ci(data[:ci_runs]), promote(data[:stable]), release(data[:release])]
+        end
+
+        # The red flag row, first in the strip while a flag stands: its commit, the minutes main has
+        # been red, and who has checked in. Nothing while main is not flagged or the read failed.
+        def flag(standing, now)
+          return [] unless standing.is_a?(Hash) && standing.key?("id")
+
+          report = Hecks::Adapters::RedFlagReport.new(standing, now: now)
+          [row("Red flag", "failed", standing["id"], report.text.tr("\n", "; "))]
+        end
+
+        def row(name, state, count, detail) = { name: name, state: state, count: count.to_s, detail: detail }
+
+        def unknown(name, section)
+          reason = section.is_a?(Hash) ? section[:unknown] : "no data"
+          row(name, "unknown", "-", "unknown: #{reason}")
+        end
+
+        def bad?(section) = section.nil? || (section.is_a?(Hash) && section.key?(:unknown))
+
+        def work(counts)
+          return unknown("Work items", counts) if bad?(counts)
+
+          planned, started, done = %w[planned started done].map { |status| counts.fetch(status, 0) }
+          row("Work items", started.positive? ? "working" : "ok", "#{planned}/#{started}/#{done}", "planned / started / done")
+        end
+
+        def sessions(list)
+          return unknown("Sessions", list) unless list.is_a?(Array)
+
+          busy = list.count { |s| s[:status] == "busy" }
+          row("Sessions", busy.positive? ? "working" : "ok", busy, "#{busy} busy of #{list.size} in the last day")
+        end
+
+        def local(main)
+          return unknown("Local main", main) if bad?(main)
+
+          tree = main[:dirty].zero? ? "clean" : "#{main[:dirty]} changed files"
+          note = "#{main[:ahead]} ahead, #{main[:behind]} behind origin/main; #{tree}"
+          row("Local main", main[:ahead].zero? ? "ok" : "attention", main[:ahead], note)
+        end
+
+        def train(info, now)
+          return unknown("Train", info) if bad?(info)
+
+          age = info[:at] ? ((now - Time.parse(info[:at])) / 3600.0).round(1) : "?"
+          note = "last push #{age} h ago#{"; not on origin/main" unless info[:pushed]}"
+          row("Train", info[:pushed] ? "ok" : "attention", info[:sha], note)
+        end
+
+        def ci(runs)
+          return unknown("CI", runs) unless runs.is_a?(Array) && runs.any?
+
+          last = runs.last
+          verdict = last[:conclusion].empty? ? last[:status] : last[:conclusion]
+          failed = last[:failed_jobs] || "?"
+          note = "#{last[:sha]} #{verdict}, #{last[:wall_minutes]} min, #{failed} failed jobs"
+          row("CI", ci_state(last), failed, note)
+        end
+
+        def ci_state(run)
+          return "working" unless run[:status] == "completed"
+
+          run[:conclusion] == "success" ? "ok" : "failed"
+        end
+
+        def promote(stable)
+          return unknown("Promote", stable) if bad?(stable)
+
+          note = "stable #{stable[:sha]}; #{stable[:behind]} commits behind main"
+          row("Promote", stable[:behind].zero? ? "ok" : "attention", stable[:behind], note)
+        end
+
+        def release(info)
+          return unknown("Release", info) if bad?(info)
+
+          row("Release", info[:published] ? "ok" : "attention", info[:tag], info[:published] ? "published" : "not published")
+        end
+      end
+    end
+  end
+end