hecks 6.0.0 → 7.0.0

data/lib/hecks/quality_control/adapters/image_roll.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require_relative "../cli/qa_main_gate"
+
+module Hecks
+  module Adapters
+    # The `ImageRoll` port's adapter. `classify` reads a green commit of embryonaut_platform's
+    # change set
+    # and answers whether only the console container's inputs changed; `roll` builds the console
+    # image
+    # and rolls it with the platform's own `make deploy-service`. Both answer the event their
+    # policy
+    # waits for, or raise, which the runtime records as the refusal.
+    class ImageRoll
+      # The repository this adapter rolls, and the one service it rolls.
+      PLATFORM_REPO = "heckslabs/embryonaut_platform"
+      APP = "console"
+
+      # The console container's inputs, as the platform's Dockerfile copies them. A path outside
+      # them is
+      # infrastructure: default-deny, so a new top-level directory waits for a person.
+      IMAGE_FILES = %w[Dockerfile Gemfile Gemfile.lock lib/telemetry_ingress.rb lib/site_roster.rb].freeze
+      IMAGE_DIRS = %w[bluebook/ vendor/ deploy/console/ lib/telemetry_ingress/ lib/site_roster/].freeze
+
+      # The bluebook's translation edges move a box's data, so a person releases them even under a
+      # bluebook.
+      OUTSIDE_IMAGE_DIRS = %w[bluebook/translations/].freeze
+
+      # The default platform checkout the roll builds from; `platform_root:` overrides it.
+      PLATFORM_ROOT = File.expand_path("~/Projects/embryonaut_platform")
+
+      # Raised when a step refuses; its message is the refusal's reason.
+      class Refused < RuntimeError; end
+
+      # The outside-world commands; a spec injects a stub in their place.
+      module Commands
+        module_function
+
+        # @return [Array(String, Boolean)] the build's output and whether it exited 0
+        def docker_build(dir)
+          output, status = Open3.capture2e("docker", "build", "--platform", "linux/arm64",
+                                           "-t", "embryonaut-platform-console:latest", ".", chdir: dir)
+          [output, status.success?]
+        end
+
+        # @return [Array(String, Boolean)] the roll's output and whether it exited 0
+        def deploy_service(dir)
+          output, status = Open3.capture2e("make", "deploy-service", "SERVICE=#{APP}",
+                                           chdir: File.join(dir, "deploy-aws/box-generated"))
+          [output, status.success?]
+        end
+      end
+
+      # Whether one changed path is part of the console container's inputs.
+      #
+      # @param path [String] a repository-relative path
+      # @return [Boolean]
+      def self.image_path?(path)
+        return false if OUTSIDE_IMAGE_DIRS.any? { |dir| path.start_with?(dir) }
+
+        IMAGE_FILES.include?(path) || IMAGE_DIRS.any? { |dir| path.start_with?(dir) }
+      end
+
+      # @param root [String, nil] the Hecks checkout, whose QA ledger holds the quick gate's
+      # records
+      # @param platform_root [String] the embryonaut_platform checkout the roll builds from
+      # @param commands [Module] the outside-world commands; a spec injects a stub
+      # @param ledger [#query, nil] the QA ledger the quick gate's records are read from; booted
+      # from
+      #   `root` when nil
+      def initialize(root: nil, platform_root: PLATFORM_ROOT, commands: Commands, ledger: nil, **)
+        @root = root || Dir.pwd
+        @platform_root = platform_root
+        @commands = commands
+        @ledger = ledger
+      end
+
+      # Classifies one green commit: `image` when every changed path is a container input, `infra`
+      # otherwise. The classifier reads no quick gate: an image-only commit rolls on its green
+      # remote CI alone, and an infra commit is held for a person.
+      #
+      # @param commit [Hash, String] the commit
+      # @param branch [Hash, String] the branch; only main rolls
+      # @param repo [Hash, String] `owner/name`; only embryonaut_platform rolls
+      # @return [Hash] `commit`, `app`, `kind` and `paths`
+      def classify(commit:, branch:, repo:, **)
+        sha = value_of(commit)
+        refuse_unless_rollable(value_of(branch), value_of(repo))
+        paths = changed_paths(sha)
+        kind = image_only?(paths) ? "image" : "infra"
+        { commit: wrap(sha), app: wrap(APP), kind: wrap(kind), paths: wrap(paths.join("\n")) }
+      end
+
+      # Builds the console image and rolls it. An infra commit rolls only when the quick gate on
+      # record for it is green; a failed build refuses; a failed roll answers `failed`.
+      #
+      # @param commit [Hash, String] the commit being rolled
+      # @param app [Hash, String] the service; only the console rolls
+      # @return [Hash] `commit`, `app` and `status` (`done` or `failed`)
+      def roll(commit:, app:, **)
+        refuse_infra_without_gate(value_of(commit))
+        output, built = @commands.docker_build(@platform_root)
+        raise Refused, "the console image did not build: #{tail(output)}" unless built
+
+        output, rolled = @commands.deploy_service(@platform_root)
+        { commit: wrap(value_of(commit)), app: wrap(value_of(app)), status: { value: rolled ? "done" : "failed" },
+          output: output }
+      end
+
+      private
+
+      def refuse_unless_rollable(branch, repo)
+        raise Refused, "only main rolls, not #{branch}" unless branch == "main"
+        raise Refused, "only #{PLATFORM_REPO} rolls, not #{repo}" unless repo == PLATFORM_REPO
+      end
+
+      # An infra commit is the fail-closed case: its roll needs the quick gate on record green. An
+      # image-only commit rolls on remote CI's green verdict alone.
+      def refuse_infra_without_gate(sha)
+        return if image_only?(changed_paths(sha))
+        return if gate_green?(sha)
+
+        raise Refused, "#{sha[0, 7]} changes paths outside the console image and the quick gate on record for it is not green"
+      end
+
+      def image_only?(paths) = paths.all? { |path| self.class.image_path?(path) }
+
+      def changed_paths(sha)
+        output, status = Open3.capture2e("gh", "api", "repos/#{PLATFORM_REPO}/commits/#{sha}",
+                                         "--jq", ".files[].filename")
+        raise Refused, "gh could not list the changes of #{sha[0, 7]}: #{output.lines.first&.strip}" unless status.success?
+
+        paths = output.lines.map(&:strip).reject(&:empty?)
+        raise Refused, "#{sha[0, 7]} changes no path" if paths.empty?
+
+        paths
+      end
+
+      # The most recent quick-gate record for the commit, read from the QA ledger. A commit with no
+      # record is not green: the gate has not said so.
+      def gate_green?(sha)
+        row = ledger.query("QualityControl::MainCheck.All").find { |check| check[:reference][:value] == sha }
+        row&.dig(:verdict, :value) == "green"
+      end
+
+      def ledger = @ledger ||= Hecks.boot(File.join(@root, "qa/bluebook"))
+
+      def wrap(value) = { value: value }
+
+      # The last lines of a command's output, which is where its failure is named.
+      def tail(text) = text.lines.last(3).join
+
+      def value_of(value) = value.is_a?(Hash) ? value.transform_keys(&:to_s)["value"] : value
+    end
+  end
+end

data/lib/hecks/quality_control/adapters/main_maintenance.adapter

@@ -0,0 +1,8 @@
+# Binds the `MainMaintenance` port to `MainMaintenance` for any boot that loads the QualityControl bluebook.
+# The implementation is required by name, not relative to this file, so a copy of this directory shares
+# the one implementation already loaded.
+require "hecks/quality_control/adapters/main_maintenance"
+
+Hecks.adapter "MainMaintenance" do
+  port "MainMaintenance"
+end

data/lib/hecks/quality_control/adapters/main_maintenance.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "fileutils"
+require_relative "../cli/qa_main_gate"
+require_relative "qa_era_mint"
+require_relative "qa_auto_mint"
+
+module Hecks
+  module Adapters
+    # The `MainMaintenance` port adapter: the bodies of the steps a maintenance run asks for. `gate`
+    # runs the quick gate on local main through `QaMainGate`; `reconcile` runs `Era.Reconcile`'s
+    # read-only
+    # plan and writes only when the `maintenance_confirm` dial is true; `push` moves the push
+    # train's
+    # checkout to main's head and sends it with the full gate and confirmation. Each answers the
+    # event its
+    # policy waits for, or raises, which the runtime records as the refusal.
+    class MainMaintenance
+      # Raised when a step refuses; its message is the refusal's reason.
+      class Refused < RuntimeError; end
+
+      # Where a stranded landing is recorded. The owner resolves it by removing the file.
+      STRANDED_DIR = ENV.fetch("HECKS_MINT_STATE", File.expand_path("~/.claude/hecks-dev/mint")).freeze
+
+      # The launcher commands the steps run outside the ledger: the reconcile plan and write, the
+      # mint, the
+      # landing, and the push train. A spec injects a stub in their place.
+      module Commands
+        # The push train's own launcher and its detached checkout.
+        TRAIN_CHECKOUT = File.expand_path("~/.claude/hecks-train")
+        TRAIN_LAUNCHER = File.join(TRAIN_CHECKOUT, "exe/hecks")
+
+        module_function
+
+        # The mint of one era of a domain, through the era check with the mint command's request.
+        #
+        # @return [Array(String, Boolean)] the minted era's label or the refusal, and whether it
+        #   minted
+        def mint_era(root, domain:, era:, request:, ledger: nil)
+          QaEraMint.call(root, domain: domain, era: era, request: request, ledger: ledger)
+        end
+
+        # The auto-mint rule's facts of one ledger: its live watermark, the edge and the shape diff.
+        #
+        # @return [Hash] see `QaAutoMint.facts`
+        def auto_mint_facts(ledger)
+          QaAutoMint.facts(ledger)
+        end
+
+        # The journal rows a run's own record wrote above a watermark.
+        #
+        # @return [Integer]
+        def own_rows_after(ledger, run, watermark)
+          QaAutoMint.own_rows_after(ledger, run, watermark)
+        end
+
+        # Lands a minted era's branch on main through the landing command, with confirmation.
+        #
+        # @return [Array(String, Boolean)]
+        def land(root, branch)
+          launch(root, root, "landing.land!", "checkout.value=#{root}", "branch.value=#{branch}", "--confirm",
+                 "--wait")
+        end
+
+        # The read-only dry run of `Era.Reconcile`.
+        #
+        # @return [Array(String, Boolean)] the plan's output and whether it exited 0
+        def reconcile_plan(root)
+          launch(root, root, "query", "era.reconcile_plan")
+        end
+
+        # Writes the reconciliation, confirmed, for one run.
+        #
+        # @return [Array(String, Boolean)]
+        def reconcile_write(root, run)
+          launch(root, root, "era.reconcile!", "run.value=#{run}", "confirm.value=true", "--wait")
+        end
+
+        # Moves the train checkout to a commit, detached, and sends the branch through the train
+        # with the
+        # full gate and confirmation.
+        #
+        # @return [Array(String, Boolean)] the train's output and whether it exited 0
+        def train_push(root, sha)
+          output, status = Open3.capture2e("git", "-C", TRAIN_CHECKOUT, "checkout", "--detach", sha)
+          return [output, false] unless status.success?
+
+          launch(TRAIN_CHECKOUT, root, "SendTrain.board!", "checkout.value=#{root}", "remote.value=origin",
+                 "branch.value=main", "full_gate.value=true", "confirm.value=true", "--wait")
+        end
+
+        # @return [Array(String, Boolean)]
+        def launch(dir, root, *argv)
+          output, status = Open3.capture2e(File.join(dir, "exe/hecks"), *argv, chdir: root)
+          [output, status.success?]
+        end
+      end
+
+      # @param aggregate [Object, nil] unused; the runtime passes the held record
+      # @param settings [Hash] unused
+      # @param root [String, nil] the repository root whose local main the steps act on
+      # @param commands [Module] the outside-world commands; a spec injects a stub
+      def initialize(aggregate: nil, settings: {}, root: nil, commands: Commands)
+        @root = root || Dir.pwd
+        @commands = commands
+      end
+
+      # Runs the quick gate on main and answers its verdict.
+      #
+      # @param run [Hash, String] the run key, as a value object or a bare string
+      # @param sha [Hash, String] the commit the run is for
+      # @return [Hash] `run`, `sha` and `color`
+      def gate(run:, sha:, **)
+        exit_code = Hecks::QualityControlCli::QaMainGate.call([], root: @root)
+        raise Refused, "the quick gate could not run (exit #{exit_code})" if exit_code == 1
+
+        { run: wrap(run), sha: wrap(sha), color: { value: exit_code.zero? ? "green" : "red" } }
+      end
+
+      # Plans the reconcile read-only, then writes it only when `maintenance_confirm` is true.
+      #
+      # @return [Hash] `run`, `sha`, `color` and `verdict` (`reported` or `written`)
+      def reconcile(run:, sha:, color:, **)
+        output, planned = @commands.reconcile_plan(@root)
+        raise Refused, "the reconcile plan refused: #{output.strip}" unless planned
+
+        verdict = write_reconcile?(run) ? "written" : "reported"
+        { run: wrap(run), sha: wrap(sha), color: wrap(color), verdict: { value: verdict } }
+      end
+
+      # Mints one era of a domain. Refuses while a stranded landing is unresolved, and unless the
+      # rehearsal
+      # said would_mint. A mint runs when the owner confirmed it or the auto-mint rule holds
+      # (`authorize!`); a mint the rule does not cover is refused as "needs owner approval".
+      #
+      # @param request [Hash] the `MintRequested` attributes: `run`, `domain`, `era`, `sha`,
+      #   `branch`,
+      #   `watermark`, `rehearsal_verdict`, `refusal_total`, `ledger_dir` and `confirm`
+      # @return [Hash] `run`, `domain`, `era`, `sha`, `branch` and `label`
+      def mint(**request)
+        refuse_while_stranded!
+        refuse_unrehearsed!(value_of(request[:rehearsal_verdict]))
+        label = run_mint!(request, authorize!(request))
+        %i[run domain era sha branch].to_h { |key| [key, wrap(request[key])] }.merge(label: wrap(label))
+      end
+
+      # Answers a held mint's approval request: the mint waits for the owner, and nothing follows
+      # it.
+      #
+      # @return [Hash] `domain`, `era` and `reason`
+      def approval(domain:, era:, reason:, **)
+        { domain: wrap(domain), era: wrap(era), reason: wrap(reason) }
+      end
+
+      # Lands the branch that carries a minted era onto main in the same step. A landing that fails
+      # leaves
+      # the ledger ahead of main, so the run is stranded: the marker is written, and every later
+      # mint
+      # refuses until the owner removes it.
+      #
+      # @return [Hash] `run`, `era`, `sha` and `branch`, which `MintStranded` takes on refusal
+      def land(run:, era:, sha:, branch:, **)
+        output, landed = @commands.land(@root, value_of(branch))
+        strand!(run, era, sha, output) unless landed
+        { run: wrap(run), era: wrap(era), sha: wrap(sha), branch: wrap(branch) }
+      end
+
+      # Pushes local main through the train, after the most recent gate verdict on this commit is
+      # green and
+      # origin is an ancestor of main.
+      #
+      # @return [Hash] `run`, `sha` and `origin_sha`
+      def push(run:, sha:, **)
+        commit = value_of(sha)
+        raise Refused, "the most recent gate on #{commit[0, 7]} is not green" unless green_recorded?(commit)
+        raise Refused, "origin/main is not an ancestor of main" unless origin_ancestor?
+
+        output, passed = @commands.train_push(@root, commit)
+        raise Refused, "the train refused the push: #{output.strip}" unless passed
+
+        { run: wrap(run), sha: wrap(commit), origin_sha: { value: git("rev-parse", "origin/main") } }
+      end
+
+      private
+
+      def write_reconcile?(run)
+        return false unless defined?(::QualityControlDials) && ::QualityControlDials.const_defined?(:MAINTENANCE_CONFIRM)
+        return false unless ::QualityControlDials::MAINTENANCE_CONFIRM == true
+
+        output, written = @commands.reconcile_write(@root, value_of(run))
+        raise Refused, "the reconcile write refused: #{output.strip}" unless written
+
+        true
+      end
+
+      def wrap(value) = { value: value_of(value) }
+
+      def refuse_unrehearsed!(verdict)
+        raise Refused, "the rehearsal said #{verdict}, not would_mint" unless verdict == "would_mint"
+      end
+
+      # Lets a mint through when the owner confirmed it, or when the auto-mint rule holds on the
+      # ledger's
+      # facts at the live watermark, and answers that watermark. A stale watermark is a refusal; any
+      # other unmet rule holds the mint.
+      def authorize!(request)
+        ledger = ledger_of(request)
+        facts = @commands.auto_mint_facts(ledger)
+        stale = QaAutoMint.stale_for(@commands, ledger, value_of(request[:run]), value_of(request[:watermark]), facts[:watermark])
+        raise Refused, stale if stale
+
+        held = QaAutoMint.hold_reason(facts, value_of(request[:confirm]), value_of(request[:refusal_total]))
+        raise Refused, "needs owner approval: #{held}" if held
+
+        facts[:watermark]
+      end
+
+      def ledger_of(request) = QaAutoMint.mintable_ledger_for(@root, value_of(request[:ledger_dir]))
+
+      # Runs the era check's mint through the mint command, and answers the label it minted. The
+      # mint is
+      # confirmed here, because `authorize!` has let it through.
+      def run_mint!(request, watermark)
+        output, minted = @commands.mint_era(@root, domain:  value_of(request[:domain]),
+                                                   era:     value_of(request[:era]),
+                                                   ledger:  ledger_of(request),
+                                                   request: {
+                                                     confirm:   true,
+                                                     verdict:   value_of(request[:rehearsal_verdict]),
+                                                     watermark: watermark
+                                                   })
+        raise Refused, output.strip unless minted
+
+        output.strip
+      end
+
+      def stranded_path = File.join(STRANDED_DIR, "stranded.json")
+
+      def refuse_while_stranded!
+        return unless File.exist?(stranded_path)
+
+        raise Refused, "mints are refused until the stranded landing is resolved: #{File.read(stranded_path).strip}"
+      end
+
+      def strand!(run, era, sha, output)
+        FileUtils.mkdir_p(STRANDED_DIR)
+        record = { run: value_of(run), era: value_of(era), sha: value_of(sha), reason: output.strip }
+        File.write(stranded_path, JSON.generate(record))
+        raise Refused, "the landing failed after the mint of era #{value_of(era)}: #{output.strip}"
+      end
+
+      def value_of(value) = value.is_a?(Hash) ? value.transform_keys(&:to_s)["value"] : value
+
+      # The most recent MainCheck record for the commit, read from the QA ledger.
+      def green_recorded?(commit)
+        row = ledger.query("QualityControl::MainCheck.All").find { |check| check[:reference][:value] == commit }
+        row&.dig(:verdict, :value) == "green"
+      end
+
+      def ledger = @ledger ||= Hecks.boot(File.join(@root, "qa/bluebook"))
+
+      def origin_ancestor?
+        _, status = Open3.capture2e("git", "-C", @root, "merge-base", "--is-ancestor", "origin/main", "main")
+        status.success?
+      end
+
+      def git(*argv)
+        output = Open3.capture2e("git", "-C", @root, *argv).first
+        output.strip
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/adapters/pump_tools.adapter

@@ -0,0 +1,7 @@
+# Binds the `PumpTools` port to `PumpTools`, which runs the event pump once for a requested `EventPump.Pump`.
+# Required by name, not relative, so a copy of this directory shares the one implementation loaded.
+require "hecks/quality_control/adapters/pump_tools"
+
+Hecks.adapter "PumpTools" do
+  port "PumpTools"
+end

data/lib/hecks/quality_control/adapters/pump_tools.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "qa_tool"
+
+module Hecks
+  module Adapters
+    # The `PumpTools` port's adapter: answers an `EventPump`'s request by running the pump once, as
+    # its own process. An answer of 0 is a pump that ran, refusals included; anything else is an
+    # operational error and is refused with its report.
+    class PumpTools < QaTool
+      # @param run [Hash, String, nil] the pump run's name; the pump itself takes no arguments
+      # @return [Hash] `text:` what the pump printed
+      def execute(run: nil)
+        run_command("qa_event_pump", answers: [0])
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/adapters/push_due_reader.adapter

@@ -0,0 +1,8 @@
+# Binds the `PushDue` port of `PushNudge` to `PushDueReader`, which asks the rehearsal adapter's `Due`
+# whether a push of local main is due. Required by name, not relative, so a copy of this directory shares
+# the one implementation loaded.
+require "hecks/quality_control/adapters/push_due_reader"
+
+Hecks.adapter "PushDueReader" do
+  port "PushDue"
+end

data/lib/hecks/quality_control/adapters/push_due_reader.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "hecks/runtime/asking"
+require "hecks/runtime/errors"
+require "hecks/runtime/row_sweep"
+require "hecks/hecks/adapters/git_rehearsal"
+require "hecks/hecks/adapters/push_size"
+
+module Hecks
+  module Adapters
+    # The `PushDue` port's adapter for `PushNudge`: reads whether a push of local main is due and
+    # whether the `push-due` Work row is already open, and answers the flags and numbers the
+    # bluebook's policies file, revise or finish the row from.
+    #
+    # The git reading is `GitRehearsal#due`, called as it is: this class only parses the line it
+    # answers and applies the thresholds. It fetches, pushes and merges nothing. The thresholds are
+    # the QualityControl world's `push_nudge` setting (`commits:` ahead, `hours:` old,
+    # `urgent_commits:`), else `PushSize::DEFAULTS`.
+    class PushDueReader
+      # The thresholds when the world declares none.
+      DEFAULTS = PushSize::DEFAULTS
+
+      # The world verb that carries the thresholds.
+      VERB = PushSize::VERB
+
+      # The key of the one Work row.
+      WORK = "push-due"
+
+      # The title of the Work row.
+      TITLE = "a push of main is due"
+
+      AHEAD = /(\d+) commit\(s\) ahead/
+      OLDEST = /oldest unpushed ([\d.]+) hours/
+      # Everything up to the first line break.
+      FIRST_LINE = /[^\n]*/
+
+      RED_NOW = /last (?:rehearsal|quick): red [^;\n]*\(the current /
+
+      # The thresholds a registry's QualityControl world declares.
+      #
+      # @param registry [Runtime::Registry, nil]
+      # @return [Hash{Symbol => Integer, Float}] `commits:`, `hours:` and `urgent_commits:`
+      def self.thresholds(registry) = PushSize.thresholds(registry)
+
+      # @param aggregate [Object, nil] unused
+      # @param settings [Hash] unused
+      # @param root [String, nil] a directory inside the repository; this repository when nil
+      # @param rehearsal [#due, nil] the rehearsal adapter; `GitRehearsal` when nil
+      def initialize(aggregate: nil, settings: {}, root: nil, rehearsal: nil)
+        @root = root || File.expand_path("../../../..", __dir__)
+        @rehearsal = rehearsal || GitRehearsal.new
+      end
+
+      # @param _held [Hash] the `PushNudge` record
+      # @return [Hash{Symbol => Hash}] `due:` and `raised:` ("yes"/"no"), `work:`, `title:`,
+      #   `detail:`
+      # @raise [Runtime::GivenNotMet] when the refs cannot be read
+      def read(**_held)
+        text = @rehearsal.due(checkout: @root).fetch(:text)
+        limits = self.class.thresholds(registry)
+        { due: flag(due?(text, limits)), raised: flag(raised?), work: { value: WORK }, title: { value: title(text, limits) },
+          detail: { value: detail(text, limits) } }
+      rescue ConsoleCapture::Failure => e
+        raise Runtime::GivenNotMet, "the refs could not be read: #{first_line(e.message)}"
+      end
+
+      private
+
+      def detail(text, limits)
+        "#{text.delete_prefix("push due: ")} (thresholds: #{limits[:commits]} commits, #{limits[:hours]} hours, " \
+          "urgent at #{limits[:urgent_commits]})"
+      end
+
+      # The row's title, naming the size class once the commits ahead pass a threshold.
+      def title(text, limits) = PushSize.title(TITLE, text[AHEAD, 1].to_i, limits)
+
+      def first_line(text) = text[FIRST_LINE].strip
+
+      def due?(text, limits)
+        return false unless text.start_with?("push due: yes")
+
+        text[AHEAD, 1].to_i >= limits[:commits] || text[OLDEST, 1].to_f >= limits[:hours] || text.match?(RED_NOW)
+      end
+
+      def flag(value) = { value: value ? "yes" : "no" }
+
+      # Whether the push-due row is open now: planned or started.
+      def raised?
+        sweep = Runtime::RowSweep.new(registry)
+        aggregate = sweep.query_aggregate("Tickets", "Work", verb: "Work.Undone")
+        sweep.rows("Tickets", aggregate, "Undone", {}).any? { |row| row[:id].to_s == WORK }
+      end
+
+      def registry
+        Runtime::Asking.registry or raise Runtime::GivenNotMet, "a push is checked only when its PushNudge asks"
+      end
+    end
+  end
+end