fun_ci 2.0.1-aarch64-linux → 2.1.0-aarch64-linux

data/lib/fun_ci/agent/status_text.rb

@@ -3,6 +3,7 @@
 require_relative "run_report"
 require_relative "verdict"
 require_relative "digest"
+require_relative "trunk_text"
 
 module FunCi
   module Agent
@@ -11,10 +12,19 @@ module FunCi
     module StatusText
       WORDS = { "failed" => "FAILED", "over_budget" => "OVER BUDGET" }.freeze
 
-      def self.lines(report)
+      # trunk: whether the agent asked about the trunk, which says so while its check is going.
+      def self.lines(report, trunk: false)
         needed = Verdict::LEVELS.fetch(report.need)
         [header(report), *report.stages.map { |stage| stage_line(stage, needed) }, *Digest.lines(report.stages, needed),
-         *footer(report)]
+         *trunk(report, trunk), *footer(report)]
+      end
+
+      # The trunk lines; nothing while the check is going, unless asked about
+      # (right after a commit it would say nothing useful).
+      def self.trunk(report, asked)
+        return [] if report.trunk.nil? || (report.trunk.state == "checking" && !asked)
+
+        TrunkText.lines(report.trunk, branch: report.branch, next_step: report.deciding.nil?)
       end
 
       def self.header(report) = %(fun-ci: #{report.sha[0, 7]} "#{report.subject}" on #{report.branch})
@@ -27,6 +37,7 @@ module FunCi
 
       def self.footer(report)
         return ["fun-ci why #{report.sha[0, 7]} #{report.deciding}"] if report.deciding
+        return ["fun-ci why #{report.sha[0, 7]} trunk"] if report.trunk&.state == "conflicts"
         return [] unless report.verdict == :superseded && report.superseded_by
 
         ["Superseded by #{report.superseded_by[0, 7]}."]

data/lib/fun_ci/agent/trunk_json.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../trunk/shown"
+
+module FunCi
+  module Agent
+    # A run's trunk as the object of `status --json` (architecture.md, Checking against the trunk,
+    # status --json): every field in every state, nil where it doesn't apply.
+    # Fields once published keep their names.
+    module TrunkJson
+      def self.document(shown)
+        { state: shown.state, **tip(shown.check&.tip), stale: shown.stale?, fetch: fetch(shown.fetch),
+          fetch_error: shown.fetch_error, **merge(shown.check&.merge), moved_to: shown.moved_to }
+      end
+
+      NO_TIP = { ref: nil, sha: nil, as_of: nil }.freeze
+
+      def self.tip(tip) = tip ? { ref: tip.ref, sha: tip.sha, as_of: tip.seen_at.utc.iso8601 } : NO_TIP
+
+      def self.merge(merge)
+        { ahead: merge&.ahead, behind: merge&.behind, files: merge&.files || [], reason: merge&.reason }
+      end
+
+      def self.fetch(last)
+        return "none" unless last
+
+        last.error ? "failed" : "ok"
+      end
+      private_class_method :tip, :merge, :fetch
+    end
+  end
+end

data/lib/fun_ci/agent/trunk_reading.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "../persistence/trunk_checks"
+require_relative "../persistence/trunk_fetches"
+require_relative "../trunk/shown"
+
+module FunCi
+  module Agent
+    # How a run's commit stands against the project's trunk, as recorded:
+    # its latest check, how old that is, why the last fetch failed, and
+    # where the trunk has moved to since, which it reads and never checks.
+    class TrunkReading
+      # Where the trunk is now, unread: for a reader polling every second, which mustn't run git each time.
+      UNREAD = Object.new.tap { |unread| def unread.now_at(_tip) = nil }.freeze
+
+      # trunk: where the trunk is now (#now_at(tip)).
+      def initialize(db, project, clock, trunk)
+        @checks = Persistence::TrunkChecks.new(db, project)
+        @fetches = Persistence::TrunkFetches.new(db, project)
+        @clock = clock
+        @trunk = trunk
+      end
+
+      # A Trunk::Shown, or nil for a run that began no check.
+      def for(run)
+        check = @checks.latest(run[:commit_hash])
+        return shown(check) if check
+
+        started = run[:trunk_started_at]
+        started && Trunk::Shown.unchecked(started: Time.parse(started), now: @clock.now)
+      end
+
+      # Checks the commit against where the trunk is now, without fetching, and keeps the check,
+      # unless the project checks no trunk any more.
+      def recheck(sha)
+        check = @trunk.check(sha, @fetches)
+        @checks.record(check, checked_at: @clock.now) if check
+      end
+
+      private
+
+      def shown(check)
+        Trunk::Shown.of(check, now: @clock.now, fetch: @fetches.last, moved_to: moved(check))
+      end
+
+      def moved(check)
+        now = check.tip && @trunk.now_at(check.tip)
+        now == check.tip&.sha ? nil : now
+      end
+    end
+  end
+end

data/lib/fun_ci/agent/trunk_text.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../trunk/shown"
+require_relative "age"
+require_relative "next_step"
+
+module FunCi
+  module Agent
+    # How a run's commit stands against the trunk, as `status` and `wait`
+    # print it (design.md, The trunk).
+    module TrunkText
+      # next_step: whether to say how to integrate a conflict; not while a needed stage has failed.
+      def self.lines(shown, branch:, next_step:)
+        return ["  trunk  checking"] unless shown.check
+
+        files = shown.check.merge.files
+        ["  trunk  #{shown.state.tr("_", " ").ljust(12)} #{detail(shown)}".rstrip, *files.map { |file| "    #{file}" },
+         *moved(shown),
+         *(next_step && shown.state == "conflicts" ? [NextStep.line(shown.check.tip, files, branch: branch)] : [])]
+      end
+
+      def self.moved(shown)
+        return [] unless shown.moved_to
+
+        ["    #{shown.check.tip.ref} has moved to #{shown.moved_to[0, 7]} since; fun-ci status --trunk checks again"]
+      end
+
+      def self.detail(shown)
+        merge = shown.check.merge
+        return merge.reason if shown.state == "unknown"
+        return "" if shown.state == "in_trunk"
+
+        seen = seen(shown)
+        shown.state == "up_to_date" ? seen : "#{seen}, #{merge.ahead} ahead, #{merge.behind} behind"
+      end
+
+      def self.seen(shown)
+        tip = shown.check.tip
+        "#{tip.ref} #{tip.sha[0, 7]}, fetched #{Age.words(shown.age)}#{stale(shown)}"
+      end
+
+      def self.stale(shown)
+        return "" unless shown.stale?
+
+        shown.fetch_error ? ", STALE (fetch failed: #{shown.fetch_error})" : ", STALE"
+      end
+      private_class_method :moved, :detail, :seen, :stale
+    end
+  end
+end

data/lib/fun_ci/agent/trunk_verdict.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Agent
+    # The verdict for an agent that asks with --trunk (architecture.md, Checking against the trunk,
+    # status and wait): a failure stays one whatever the trunk says; a passed
+    # run is undecided while its check is going and in conflict when it
+    # conflicts. A trunk that couldn't be checked leaves the verdict alone:
+    # its causes are the project's, and would fail every run until fixed.
+    module TrunkVerdict
+      BY_STATE = { "checking" => :undecided, "conflicts" => :conflicts }.freeze
+
+      def self.of(verdict, shown)
+        return verdict unless verdict == :passed && shown
+
+        BY_STATE.fetch(shown.state, verdict)
+      end
+    end
+  end
+end

data/lib/fun_ci/agent/trunk_why.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../evidence/document"
+require_relative "../trunk/check"
+require_relative "../trunk/regions"
+
+module FunCi
+  module Agent
+    # A conflict with the trunk, merged again, as the evidence `why REV trunk`
+    # prints (design.md, The trunk): git's messages, then
+    # each conflicted region under its file, its lines numbered as the file's.
+    module TrunkWhy
+      EXTRACTOR = "merge-tree"
+
+      # explained: a Trunk::Explained, or nil when the commits are gone.
+      def self.document(explained, tip)
+        return gone(tip) unless explained
+
+        Evidence::Document.new(chosen: [], facts: [], failures: [], problems: [],
+                               excerpts: [messages(explained.messages), *explained.files.flat_map do |path, text|
+                                 regions(path, text, tip)
+                               end])
+      end
+
+      def self.messages(lines) = { title: "Git's messages", location: "merge", lines: lines, extractor: EXTRACTOR }
+
+      MARKER = /\A(<{7}|>{7}) (\h{40})\z/
+
+      # A conflict marker names its side by the trunk's name or the commit's short SHA, not a full SHA.
+      def self.labelled(line, tip)
+        marker, sha = MARKER.match(line)&.captures
+        return line unless marker
+
+        "#{marker} #{sha == tip.sha ? tip.ref : sha[0, 7]}"
+      end
+
+      def self.regions(path, text, tip)
+        Trunk::Regions.of(text).map do |region|
+          { title: path, location: "lines #{region.first}-#{region.last}", extractor: EXTRACTOR,
+            lines: region.lines.map { |number, line| "#{number.to_s.rjust(4)}  #{labelled(line, tip)}" } }
+        end
+      end
+
+      def self.gone(tip)
+        problem = { extractor: EXTRACTOR,
+                    message: "#{tip.ref} #{tip.sha[0, 7]} or the commit is no longer in this repository" }
+        Evidence::Document.new(chosen: [], facts: [], failures: [], excerpts: [], problems: [problem])
+      end
+      private_class_method :messages, :labelled, :regions, :gone
+    end
+  end
+end

data/lib/fun_ci/agent/trunk_why_json.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "run_report"
+require_relative "trunk_json"
+require_relative "../evidence/caps"
+
+module FunCi
+  module Agent
+    # `why REV trunk --json` (design.md, The trunk): the
+    # run's trunk, and the conflict as evidence, capped as a stage's is, or
+    # why there is none. Fields once published keep their names.
+    module TrunkWhyJson
+      SCHEMA = 1
+
+      # evidence: an Evidence::Document, or nil when the run's commit doesn't conflict.
+      def self.document(report, evidence)
+        { schema: SCHEMA, commit: { sha: report.sha, branch: report.branch, subject: report.subject }, stage: "trunk",
+          trunk: report.trunk && TrunkJson.document(report.trunk), evidence: evidence && Evidence::Caps.new.apply(evidence).to_h,
+          no_evidence: evidence ? nil : "no conflict" }
+      end
+    end
+  end
+end

data/lib/fun_ci/agent/wait_command.rb

@@ -23,9 +23,9 @@ module FunCi
       end
 
       def run(args)
-        options = Options.parse(args, takes: %i[need json within follow_branch])
+        options = Options.parse(args, takes: %i[need json within follow_branch trunk])
         sha = resolve(options.rev)
-        output = Output.new(@context.io.stdout, json: options.json)
+        output = output(options)
         answer(sha, wait_for(sha, options, deadline(options), output), output)
       rescue Options::Invalid => e
         usage(e.message)
@@ -37,7 +37,7 @@ module FunCi
 
       # Follows a superseded run on to the commit that superseded it, when asked to.
       def wait_for(sha, options, deadline, output)
-        report = Waiting.new(@context.clock, deadline: deadline) { poll(sha, options.need) }.until_decided
+        report = Waiting.new(@context.clock, deadline: deadline) { poll(sha, options) }.until_decided
         return report unless options.follow_branch && report&.superseded_by
 
         output.following(sha, report)
@@ -52,10 +52,10 @@ module FunCi
         ExitCode::FOR.fetch(report.verdict)
       end
 
-      def poll(sha, need)
+      def poll(sha, options)
         @context.pipeline.watch(@context.db)
         reports.mark_waited(sha, @context.clock.now)
-        reports.for(sha, need) || start_after_grace(sha)
+        report_for(sha, options) || start_after_grace(sha)
       end
 
       # Nil while waiting for a run; NOT_SET_UP once one can't be started.

data/lib/fun_ci/agent/why_command.rb

@@ -2,6 +2,7 @@
 
 require_relative "command_support"
 require_relative "output"
+require_relative "trunk_why"
 
 module FunCi
   module Agent
@@ -33,10 +34,20 @@ module FunCi
         return output.unknown(sha) unless report
 
         stage_name = options.stage || report.deciding
+        return why_trunk(report, output) if stage_name == "trunk"
+
         options.raw ? raw(report, stage_name) : output.why(report, stage_name)
         ExitCode::FOR.fetch(report.verdict)
       end
 
+      # The conflict merged again; nothing to explain unless the run's commit conflicts.
+      def why_trunk(report, output)
+        trunk = report.trunk
+        tip = trunk&.state == "conflicts" ? trunk.check.tip : nil
+        output.why_trunk(report, tip && TrunkWhy.document(@context.trunk.explain(report.sha, tip), tip))
+        ExitCode::FOR.fetch(report.verdict)
+      end
+
       def raw(report, stage_name)
         stage = report.stages.find { |candidate| candidate.name == stage_name }
         text = stage && reports.raw_output(stage)

data/lib/fun_ci/cli.rb

@@ -88,7 +88,7 @@ module FunCi
 
     def agent_context(db)
       Agent::Context.new(db: db, git: Agent::Git.new(Dir.pwd), io: @io, clock: Agent::SystemClock.new,
-                         pipeline: Agent::LivePipeline.new(Dir.pwd))
+                         pipeline: Agent::LivePipeline.new(Dir.pwd), trunk: Trunk::Local.new(Dir.pwd))
     end
 
     def run_init(args) = setup_commands.init(args)

data/lib/fun_ci/cli_help.rb

@@ -30,7 +30,7 @@ module FunCi
         runs           List this project's recent runs, newest first
         wait           Wait for a commit's verdict, then exit with it as status does
         events         Print this project's runs' events as JSON lines
-        why            Print everything kept about why a commit's stage failed
+        why            Print everything kept about why a commit's stage failed, or its conflict with the trunk
         extract        Try a stage's evidence extractors on a saved output
 
       Options:
@@ -44,13 +44,15 @@ module FunCi
         --need LEVEL   (status, wait, why) What must pass: build, fast (default) or all
         --within TIME  (wait) Give up undecided after 30, 30s or 5m
         --follow-branch  (wait) Move on to the newer commit that superseded the run
+        --trunk        (status, wait) Exit 6 when the run passed but conflicts with the trunk
+        --raw          (why) Print the stage's whole output as it was kept
         -n N           (runs) How many runs to list (default 10)
         --branch NAME  (runs) Only runs on this branch
         --follow       (events) Keep printing events as they happen, until stopped
         --only failures  (events) Print only failed stages and superseded runs
         --json         Print JSON instead of text (events always print JSON lines)
         Exit codes: 0 passed, 1 failed, 2 over budget, 3 undecided,
-        4 superseded, 5 no run, 64 usage error
+        4 superseded, 5 no run, 6 conflicts with the trunk (--trunk), 64 usage error
 
       Init options:
         --everything   Run init + install-hooks + check in one step

data/lib/fun_ci/console/board_data.rb

@@ -6,10 +6,17 @@ require_relative "../persistence/stage_job"
 require_relative "../persistence/active_runs"
 require_relative "../pipeline/run_canceller"
 require_relative "streak_counter"
+require_relative "trunk_marks"
+require_relative "cancelled_folding"
+require_relative "row_order"
 
 module FunCi
   module Console
     class BoardData
+      # How many of a branch's runs are read to fold its cancelled ones and
+      # find its standing against the trunk.
+      BRANCH_WINDOW = 100
+
       def initialize(db, limit: 15, page_size: nil, run_canceller: Pipeline::RunCanceller.new)
         @db = db
         @page_size = page_size || limit
@@ -27,18 +34,19 @@ module FunCi
         @limit = [@limit, page_size].max
       end
 
-      # Whether the store holds runs beyond those `runs` loads.
-      def more?
-        Persistence::PipelineRun.recent(@db, limit: @limit + 1).size > @limit
-      end
+      # Whether there are branches beyond those `runs` loads.
+      def more? = Persistence::PipelineRun.branch_heads(@db, limit: @limit + 1).size > @limit
 
       # Records failed each slow suite whose process died (acceptance-tests.md, AT-8.3).
       def record_dead_slow_suites = @run_canceller.record_dead(@db)
 
-      def runs
-        pipeline_runs = Persistence::PipelineRun.recent(@db, limit: @limit)
-        pipeline_runs.map { |run| enrich_with_stages(run) }
-      end
+      # One row per branch, its newest run, for the branches that most need you
+      # and then those run most recently, in RowOrder: a run of cancelled
+      # runs folded into one, with its stages and the branch's standing against the trunk.
+      def runs = RowOrder.of(Persistence::PipelineRun.branch_heads(@db, limit: @limit).map { |head| branch_row(head) })
+
+      # The projects among `runs` whose trunk is stale.
+      def stale_trunks(runs, now:) = TrunkMarks.new(@db).stale(runs, now: now)
 
       def streak
         pipeline_runs = Persistence::PipelineRun.recent(@db, limit: @limit)
@@ -53,6 +61,12 @@ module FunCi
 
       private
 
+      def branch_row(head)
+        branch_runs = Persistence::PipelineRun.of_branch(@db, head[:project_path], head[:branch], limit: BRANCH_WINDOW)
+        row = CancelledFolding.fold(branch_runs).first
+        enrich_with_stages(row.merge(trunk: TrunkMarks.new(@db).mark(branch_runs).first[:trunk]))
+      end
+
       def enrich_with_stages(run)
         run.merge(stages: Persistence::StageJob.for_run(@db, run[:id]).map { |job| stage(job) })
       end

data/lib/fun_ci/console/cancelled_folding.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Console
+    # Runs of one project's branch cancelled one after another, as a rebase or
+    # a burst of commits leaves them, as one: the newest of them, with
+    # `folded:` saying how many it stands for (design.md, The console).
+    module CancelledFolding
+      # `runs` newest first, each run of cancelled ones folded into its newest.
+      def self.fold(runs) = runs.slice_when { |newer, older| !one_stream?(newer, older) }.map { |group| kept(group) }
+
+      def self.one_stream?(newer, older) = cancelled?(newer) && cancelled?(older) && key(newer) == key(older)
+      def self.cancelled?(run) = run[:status] == "cancelled"
+      def self.key(run) = [run[:project_path], run[:branch]]
+      def self.kept(group) = group.size > 1 ? group.first.merge(folded: group.size) : group.first
+      private_class_method :one_stream?, :cancelled?, :key, :kept
+    end
+  end
+end

data/lib/fun_ci/console/console_events.rb

@@ -2,19 +2,22 @@
 
 require_relative "stage_events"
 require_relative "milestone_events"
+require_relative "trunk_events"
 
 module FunCi
   module Console
     # Every protocol `event` since the last poll of the runs: the stages that
     # changed (for the effects on a stage's column), then the milestones the
-    # runs reached (for the header).
+    # runs reached, then branches starting or stopping conflicting with the
+    # trunk (both for the header).
     class ConsoleEvents
       def initialize
         @stages = StageEvents.new
         @milestones = MilestoneEvents.new
+        @trunk = TrunkEvents.new
       end
 
-      def since_last(runs) = @stages.since_last(runs) + @milestones.since_last(runs)
+      def since_last(runs) = @stages.since_last(runs) + @milestones.since_last(runs) + @trunk.since_last(runs)
     end
   end
 end

data/lib/fun_ci/console/console_log.rb

@@ -7,7 +7,8 @@ module FunCi
   module Console
     # The project's .fun-ci/console.log, where the console notes what the
     # renderer got wrong: the terminal is the renderer's, so stderr would
-    # draw over it.
+    # draw over it. A .gitignore beside it, unless the project has one there,
+    # keeps the log out of the project's commits.
     class ConsoleLog
       attr_reader :path
 
@@ -19,6 +20,8 @@ module FunCi
       # Appends `text` as one line, stamped with the clock's time in UTC.
       def write(text)
         FileUtils.mkdir_p(File.dirname(@path))
+        ignore_file = File.join(File.dirname(@path), ".gitignore")
+        File.write(ignore_file, "console.log\n") unless File.exist?(ignore_file)
         File.open(@path, "a") { |file| file.puts("#{@clock.call.utc.iso8601} #{text}") }
       end
     end

data/lib/fun_ci/console/console_state.rb

@@ -35,7 +35,13 @@ module FunCi
       def board(runs)
         page = @view.page(runs, more: @board_data.more?)
         { t: "board", now: @clock.call.to_i, streak: @board_data.streak, **page,
-          runs: page[:runs].map { |run| RunMessage.from(run) } }
+          runs: page[:runs].map { |run| RunMessage.from(run) }, **stale_trunks(runs) }
+      end
+
+      # Only when a trunk is stale, as the protocol lets a board leave it out.
+      def stale_trunks(runs)
+        stale = @board_data.stale_trunks(runs, now: @clock.call)
+        stale.empty? ? {} : { stale_trunks: stale }
       end
     end
   end

data/lib/fun_ci/console/row_order.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Console
+    # The order of the console's rows (design.md, The console): a project's
+    # branches together, the project that most needs you first, and within it
+    # the branch that most needs you first, newest first among equals. Ruby
+    # decides it, since the cursor moves through the rows in this order.
+    module RowOrder
+      URGENCY = { "failed" => 0, "timed_out" => 1, "running" => 2, "scheduled" => 3, "completed" => 4 }.freeze
+      # A conflict with the trunk needs you as much as a timeout.
+      CONFLICT = 1
+      LEAST = 5
+
+      # `rows`, one per branch and newest first, in the order the console shows them.
+      def self.of(rows)
+        projects = rows.group_by { |row| row[:project_path] }.values
+        projects.sort_by.with_index { |branches, i| [most(branches), i] }.flat_map { |branches| ordered(branches) }
+      end
+
+      def self.ordered(branches) = branches.sort_by.with_index { |row, i| [urgency(row), i] }
+      def self.most(branches) = branches.map { |row| urgency(row) }.min
+
+      def self.urgency(row)
+        by_status = URGENCY.fetch(row[:status], LEAST)
+        row.dig(:trunk, :branch_state) == "conflicts" ? [by_status, CONFLICT].min : by_status
+      end
+      private_class_method :ordered, :most, :urgency
+    end
+  end
+end

data/lib/fun_ci/console/run_message.rb

@@ -13,15 +13,22 @@ module FunCi
       def self.from(run)
         { id: run[:id], sha: run[:commit_hash], branch: run[:branch], project: run[:project_path],
           status: status(run[:status]), started_at: epoch(run[:created_at]), updated_at: epoch(run[:updated_at]),
-          stages: run[:stages].map { |stage| stage(stage) } }.compact
+          stages: run[:stages].map { |stage| stage(stage) }, **marks(run) }.compact
       end
 
+      # What the row marks beyond the run itself: a conflict with the trunk, and
+      # how many cancelled runs it stands for.
+      def self.marks(run) = { trunk: conflict(run[:trunk]), folded: run[:folded] }
+
+      # The branch's standing against the trunk, sent only where the row shows it: a conflict.
+      def self.conflict(trunk) = trunk && trunk[:branch_state] == "conflicts" ? trunk : nil
+
       def self.stage(stage)
         { stage: stage[:stage], status: status(stage[:status]),
           duration_ms: stage[:duration] && (stage[:duration] * 1000).round,
           started_at: (epoch(stage[:started_at]) if stage[:status] == "running") }.compact
       end
-      private_class_method :stage
+      private_class_method :stage, :conflict, :marks
 
       def self.status(name) = STATUS.fetch(name, name)
       private_class_method :status

data/lib/fun_ci/console/trunk_events.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Console
+    # The header's events for the trunk (design.md, The
+    # trunk): trunk_conflict when a branch's standing becomes conflicts,
+    # trunk_clear when it moves from conflicts to another settled standing,
+    # each at most once a poll however many branches changed, naming one
+    # branch's newest run and how many. A branch keeps its standing through
+    # a poll that shows none, and the first poll has nothing to compare with.
+    class TrunkEvents
+      def initialize
+        @standing = nil
+      end
+
+      # runs: as TrunkMarks marks them, newest first.
+      def since_last(runs)
+        now = standings(runs)
+        events = @standing ? [started(now), stopped(now)].compact : []
+        @standing = (@standing || {}).merge(now)
+        events
+      end
+
+      private
+
+      # { [project, branch] => [newest run id, standing] }
+      def standings(runs)
+        runs.select { |run| run[:trunk] }.to_h do |run|
+          [run.values_at(:project_path, :branch), [run[:id], run[:trunk][:branch_state]]]
+        end
+      end
+
+      def started(now) = event("trunk_conflict", now.select { |key, (_, state)| conflicts?(state) && !was?(key) })
+      def stopped(now) = event("trunk_clear", now.select { |key, (_, state)| !conflicts?(state) && was?(key) })
+      def was?(key) = conflicts?(@standing.dig(key, 1))
+      def conflicts?(state) = state == "conflicts"
+
+      def event(name, branches)
+        branches.empty? ? nil : { t: "event", name: name, run_id: branches.values.first.first, branches: branches.size }
+      end
+    end
+  end
+end