reanimator 0.1.0

data/lib/reanimator/reports/portfolio_drift.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Drift across a portfolio, rendered as a triage list rather than a pile of
+    # diffs. The ordering is the point: repositories that need a human come
+    # first and carry the reason for each policy change, repositories that
+    # merely changed follow as information, and repositories with nothing
+    # recorded are named rather than quietly counted as fine.
+    class PortfolioDrift
+      def initialize(drift)
+        @drift = drift
+      end
+
+      def render
+        ([banner] + sections + [verdict, footer]).compact.join("\n\n")
+      end
+
+      private
+
+      def banner
+        [
+          "REANIMATOR DRIFT",
+          "Portfolio: #{@drift.name}",
+          "Generated: #{@drift.generated_at.strftime("%Y-%m-%d %H:%M %Z")}",
+          "Mode: read-only"
+        ].join("\n")
+      end
+
+      def sections
+        [
+          review_section,
+          listing("CHANGED, BENIGN", @drift.benign) { |entry| change_lines(entry.report.benign_changes, "·", 4) },
+          listing("UNCHANGED", @drift.unchanged),
+          listing("NOT RECORDED", @drift.unrecorded) { ["    nothing to compare against yet"] },
+          listing("COULD NOT READ", @drift.failed) { |entry| ["    #{entry.error}"] }
+        ].compact
+      end
+
+      # The only section that spells out *why* each change matters: these are
+      # the ones somebody has to decide about.
+      def review_section
+        listing("REVIEW REQUIRED", @drift.policy_changed) do |entry|
+          changes = entry.report.policy_changes
+          ["    #{Reports.count(changes.size, "policy change")}"] + change_lines(changes, "!", 6, explain: true)
+        end
+      end
+
+      def listing(title, entries)
+        return if entries.empty?
+
+        lines = ["#{title} — #{Reports.count(entries.size, "repository", "repositories")}"]
+        entries.each do |entry|
+          lines << "  #{entry.name}"
+          lines.concat(block_given? ? yield(entry) : [])
+        end
+        lines.join("\n")
+      end
+
+      def change_lines(changes, marker, indent, explain: false)
+        pad = " " * indent
+        changes.flat_map do |change|
+          lines = ["#{pad}#{marker} #{change.summary}"]
+          lines << "#{pad}  #{change.explanation}" if explain
+          lines
+        end
+      end
+
+      # Two separate reasons a portfolio can need a human, reported separately
+      # because they call for different things: drift somebody has to approve,
+      # and a snapshot nobody can read.
+      def verdict
+        return "No policy changes across the portfolio; nothing here needs a decision." unless @drift.requires_review?
+
+        [policy_verdict, failure_verdict].compact.join("\n\n")
+      end
+
+      def policy_verdict
+        repositories = @drift.policy_changed
+        return if repositories.empty?
+
+        total = repositories.sum { |entry| entry.report.policy_changes.size }
+        "REVIEW REQUIRED: #{Reports.count(total, "policy change")} across " \
+          "#{Reports.count(repositories.size, "repository", "repositories")} — less is being proven than before.\n" \
+          "Intended? Re-record with: #{@drift.store.record_command}"
+      end
+
+      def failure_verdict
+        failures = @drift.failed
+        return if failures.empty?
+
+        "REVIEW REQUIRED: #{Reports.count(failures.size, "repository", "repositories")} could not be read, " \
+          "so drift could not be ruled out there."
+      end
+
+      # The read-only promise, stated precisely. Recording writes snapshot
+      # files and nothing else, so the report says which it did rather than
+      # claiming nothing happened.
+      def footer
+        recorded = @drift.entries.count { |entry| entry.recorded_to }
+        return "NO FILES WERE WRITTEN. NO SOURCE CHANGES WERE MADE." if recorded.zero?
+
+        "Recorded #{Reports.count(recorded, "snapshot")}. NO SOURCE CHANGES WERE MADE."
+      end
+    end
+  end
+end

data/lib/reanimator/reports/run.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Renders a run ledger entry (specification section 17). It leads with the
+    # outcome, records the agent and policy version, and - for a proposed repair
+    # - shows the draft PR that was produced but not submitted, reaffirming that
+    # no source was written.
+    class Run
+      OUTCOME_LABEL = {
+        no_op: "NO-OP (healthy)",
+        report: "REPORT",
+        draft_pr: "DRAFT PR (proposed, not submitted)",
+        escalation: "ESCALATION",
+        safe_stop: "SAFE STOP"
+      }.freeze
+
+      def initialize(run)
+        @run = run
+      end
+
+      def render
+        lines = [
+          "Run — #{@run.repository.full_name}",
+          "Outcome:  #{OUTCOME_LABEL.fetch(@run.outcome, @run.outcome.to_s.upcase)}",
+          "Trigger:  #{@run.trigger}",
+          "Policy:   #{@run.policy_version}"
+        ]
+        lines << "Objective: #{@run.objective.id} — #{@run.objective.claim}" if @run.objective
+        lines << "Agent:    #{@run.provider}" if @run.provider
+        lines << "Evidence: #{@run.pre_state} → #{@run.post_state}" if @run.post_state
+        lines << "Reason:   #{@run.reason}" if @run.reason
+        lines.concat(proposed_change_lines) if @run.proposed_change
+        lines << "NO SOURCE WAS WRITTEN TO THE REPOSITORY."
+        lines.join("\n")
+      end
+
+      private
+
+      def proposed_change_lines
+        change = @run.proposed_change
+        [
+          "",
+          "Proposed draft PR:",
+          "  branch: #{change.branch}",
+          "  title:  #{change.title}",
+          "  files:  #{change.patch.paths.join(", ")}"
+        ]
+      end
+    end
+  end
+end

data/lib/reanimator/reports/snapshot.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Renders a recorded contract snapshot for a person rather than a machine:
+    # what this repository is currently required to prove, and how to put that
+    # on record so later drift has something to be measured against.
+    class Snapshot
+      def initialize(snapshot, saved_to: nil, record_with: "reanimator drift --record")
+        @snapshot = snapshot
+        @saved_to = saved_to
+        @record_with = record_with
+      end
+
+      def render
+        ([header] + [policy, proves, evidence].compact + [footer]).join("\n")
+      end
+
+      private
+
+      def header
+        "Contract snapshot — #{@snapshot.repository}\nTaken:    #{@snapshot.taken_at}"
+      end
+
+      def policy
+        "Intent:   #{@snapshot.intent}   Profile: #{@snapshot.profile}   " \
+          "Security: #{@snapshot.security_posture} posture"
+      end
+
+      def proves
+        required = @snapshot.criteria.count { |criterion| criterion[:required] }
+        line = "Proves:   #{Reports.count(@snapshot.criteria.size, "criterion", "criteria")} (#{required} required)"
+        return line if @snapshot.waivers.empty?
+
+        "#{line}, #{Reports.count(@snapshot.waivers.size, "accepted risk")}"
+      end
+
+      # The evidence half of the snapshot: the facts that drift can narrow
+      # without anyone editing .reanimator.yml.
+      def evidence
+        parts = []
+        parts << "runtimes #{@snapshot.support_matrix.join(", ")}" if @snapshot.support_matrix.any?
+        parts << "security gates #{@snapshot.security_controls.join(", ")}" if @snapshot.security_controls.any?
+        "Evidence: #{parts.join(" · ")}" if parts.any?
+      end
+
+      # Whichever way this snapshot was recorded, the next thing a maintainer
+      # wants is the command that compares against it - so the footer names
+      # that, not the flag they happened to use.
+      def footer
+        return "\nRecorded to #{@saved_to}. Compare later with: reanimator drift" if @saved_to
+
+        "\nNothing was written. Record this with `#{@record_with}` so later drift " \
+          "has something to be measured against."
+      end
+    end
+  end
+end

data/lib/reanimator/reports.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Reanimator
+  # Plain-text reporters. They build deterministic strings with no color or
+  # TTY dependency so they are trivially testable; the CLI layers on boxes and
+  # color when a human is watching. The output style mirrors the specification's
+  # own artifacts (the section 15 GitHub check and the Appendix A baseline).
+  module Reports
+    # Status glyphs shared across reporters.
+    GLYPH = {
+      verified: "✓",
+      failed: "✗",
+      missing_evidence: "•",
+      skipped: "◦",
+      accepted_risk: "!",
+      planned: "…",
+      error: "✗"
+    }.freeze
+
+    module_function
+
+    def glyph(status) = GLYPH.fetch(status.to_sym, "·")
+
+    # Human-readable label for a result status.
+    def status_label(status)
+      status.to_s.tr("_", " ")
+    end
+
+    # "1 repository" / "3 repositories". Every reporter needs to put a number
+    # in front of a noun, and each had grown its own spelling of it - which is
+    # how a user eventually reads "1 repositorys".
+    def count(size, singular, plural = "#{singular}s")
+      "#{size} #{(size == 1) ? singular : plural}"
+    end
+  end
+end

data/lib/reanimator/repository.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Reanimator
+  # A single repository under (potential) stewardship: its location, its
+  # read-only metadata, any owner-declared contract, and the lifecycle intent
+  # currently assigned to it. Detectors read a repository through the file
+  # helpers here so they never reach outside its root, and so a future
+  # non-filesystem source could satisfy the same surface.
+  class Repository
+    # @return [String] absolute path to the working tree
+    attr_reader :path
+    # @return [RepositoryMetadata]
+    attr_reader :metadata
+    # @return [ContractFile, nil] parsed .reanimator.yml, when present
+    attr_reader :declared
+    # @return [Symbol, nil] assigned lifecycle intent (mutable during onboarding)
+    attr_accessor :intent
+
+    # Builds a repository from a path on disk.
+    # @raise [RepositoryError] when the path is not a directory
+    def self.at(path)
+      root = File.expand_path(path.to_s)
+      unless File.directory?(root)
+        raise RepositoryError, "#{path.inspect} is not a directory."
+      end
+
+      declared = ContractFile.load(root)
+      new(
+        path: root,
+        metadata: RepositoryMetadata.from_local(root),
+        declared: declared,
+        intent: declared&.intent
+      )
+    end
+
+    def initialize(path:, metadata:, declared: nil, intent: nil)
+      @path = path
+      @metadata = metadata
+      @declared = declared
+      @intent = intent
+    end
+
+    def name = metadata.name
+
+    def full_name = metadata.full_name || metadata.name
+
+    def fork? = metadata.fork?
+
+    # Whether the owner committed a contract file. When true, the declared
+    # profile and intent win over inference (section 06 conflict resolution).
+    def declared? = !declared.nil?
+
+    # @return [Symbol, nil] the profile the owner declared, if any
+    def declared_profile = declared&.profile
+
+    # --- read-only file access used by detectors -----------------------------
+
+    # @return [String] absolute path for a repository-relative path
+    def absolute(relative) = File.join(path, relative)
+
+    # @return [Boolean] whether a repository-relative path exists
+    def exist?(relative) = File.exist?(absolute(relative))
+
+    # @return [Array<String>] repository-relative paths matching a glob
+    def glob(pattern)
+      Dir.glob(File.join(path, pattern), File::FNM_DOTMATCH)
+        .map { |absolute| absolute.delete_prefix("#{path}/") }
+        .sort
+    end
+
+    # @return [Boolean] whether any path matches the glob
+    def any?(pattern) = !glob(pattern).empty?
+
+    # @return [String, nil] contents of a repository-relative file, or nil.
+    #   Repository content is untrusted and may not be valid UTF-8; it is read
+    #   as UTF-8 and scrubbed so a detector's regex or slice can never raise on
+    #   a stray byte (which would otherwise be swallowed as a "detector failed"
+    #   and silently drop facts), including under a C/US-ASCII locale.
+    def read(relative)
+      return unless exist?(relative)
+
+      File.read(absolute(relative), encoding: "UTF-8").scrub
+    end
+
+    def to_h
+      {
+        name: name,
+        full_name: full_name,
+        path: path,
+        intent: intent,
+        declared: declared?,
+        metadata: metadata.to_h
+      }
+    end
+  end
+end

data/lib/reanimator/repository_metadata.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Reanimator
+  # The read-only facts about a repository that exist before any detector runs
+  # (specification section 04 inventory inputs): name, ownership, default
+  # branch, primary language, fork status, and last activity. This object is
+  # the seam between "where the repository lives" and "what it is": a local
+  # working tree fills it from git today, and a GitHub inventory source can
+  # fill the very same shape tomorrow without touching the rest of the system.
+  class RepositoryMetadata
+    attr_reader :name, :full_name, :default_branch, :primary_language,
+      :last_activity, :commit_count, :topics
+
+    def initialize(name:, full_name: nil, default_branch: nil, primary_language: nil,
+      fork: false, archived: false, last_activity: nil, commit_count: nil, topics: [], has_git: false)
+      @name = name
+      @full_name = full_name
+      @default_branch = default_branch
+      @primary_language = primary_language
+      @fork = fork
+      @archived = archived
+      @last_activity = last_activity
+      @commit_count = commit_count
+      @topics = topics
+      @has_git = has_git
+    end
+
+    def fork? = @fork
+
+    def archived? = @archived
+
+    def has_git? = @has_git
+
+    # Days since the last commit, or nil when unknown. Feeds the "old
+    # unarchived repository" and "recent experiment" cohort heuristics.
+    def days_since_activity(now: Time.now)
+      return nil unless last_activity
+      ((now - last_activity) / 86_400).floor
+    end
+
+    # Builds metadata from a local working tree. Everything is best-effort:
+    # a directory that is not a git repository still yields a usable object.
+    def self.from_local(root)
+      has_git = Git.repository?(root)
+      origin = has_git ? Git.origin_url(root) : nil
+      new(
+        name: File.basename(root),
+        full_name: full_name_from_url(origin),
+        default_branch: has_git ? Git.current_branch(root) : nil,
+        primary_language: LanguageInference.call(root),
+        fork: has_git && Git.upstream_remote?(root),
+        archived: false,
+        last_activity: has_git ? Git.last_commit_at(root) : nil,
+        commit_count: has_git ? Git.commit_count(root) : nil,
+        topics: [],
+        has_git: has_git
+      )
+    end
+
+    # Parses "owner/repo" from a git remote URL in either SSH or HTTPS form.
+    def self.full_name_from_url(url)
+      return nil unless url
+      cleaned = url.sub(/\.git\z/, "")
+      case cleaned
+      when %r{[:/]([^/:]+)/([^/]+)\z}
+        "#{$1}/#{$2}"
+      end
+    end
+
+    def to_h
+      {
+        name: name, full_name: full_name, default_branch: default_branch,
+        primary_language: primary_language, fork: fork?, archived: archived?,
+        last_activity: last_activity&.iso8601, commit_count: commit_count, topics: topics
+      }
+    end
+  end
+end

data/lib/reanimator/repository_state.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Reanimator
+  # The proof-of-life states a repository can hold (specification section 15).
+  # These make "healthy silence" visible: Alive is an earned, evidence-backed
+  # status, not the absence of alarms, and Unproven is never allowed to masquerade
+  # as green.
+  class RepositoryState
+    attr_reader :key, :meaning, :color
+
+    def initialize(key:, meaning:, color:)
+      @key = key
+      @meaning = meaning
+      @color = color
+      freeze
+    end
+
+    def to_sym = key
+
+    def to_s = key.to_s
+
+    # @return [Boolean] whether this state counts as verified vitality
+    def alive? = key == :alive
+
+    ALL = {
+      alive: new(key: :alive, color: :green,
+        meaning: "All due obligations have fresh passing evidence and no unapproved blocking risk."),
+      at_risk: new(key: :at_risk, color: :yellow,
+        meaning: "A deadline, support window, vulnerability, or degrading signal requires attention soon."),
+      needs_you: new(key: :needs_you, color: :magenta,
+        meaning: "A decision, permission, secret, environment, or domain judgment blocks safe progress."),
+      recovering: new(key: :recovering, color: :cyan,
+        meaning: "A repair or coordinated migration is active."),
+      unproven: new(key: :unproven, color: :yellow,
+        meaning: "A claim exists but sufficient executable evidence is absent or stale."),
+      sleeping: new(key: :sleeping, color: :blue,
+        meaning: "The repository is intentionally monitored or preserved rather than actively maintained."),
+      diverged: new(key: :diverged, color: :magenta,
+        meaning: "A maintained fork has meaningful upstream drift or unique commits requiring review."),
+      retired: new(key: :retired, color: :white,
+        meaning: "End-of-life is explicit and its retirement checklist is complete.")
+    }.freeze
+
+    def self.fetch(key)
+      ALL.fetch(key.to_sym) { raise UnknownError, "Unknown repository state #{key.inspect}." }
+    end
+  end
+end

data/lib/reanimator/routing/decision.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Routing
+    # The outcome of routing one task to one profile (specification section 08).
+    # A decision is never silent: it carries the human-readable explanation the
+    # spec insists on ("Selected Codex because ... Amp was excluded because
+    # ...") and the declared fallbacks - fallback is never implied.
+    class Decision
+      attr_reader :profile, :strategy, :explanation, :excluded, :fallbacks
+
+      def initialize(profile:, strategy:, explanation:, excluded: [], fallbacks: [])
+        @profile = profile
+        @strategy = strategy
+        @explanation = explanation
+        @excluded = excluded
+        @fallbacks = fallbacks
+      end
+
+      def selected? = !profile.nil?
+
+      def provider = profile&.provider
+
+      def to_h
+        {
+          strategy: strategy,
+          selected: provider,
+          explanation: explanation,
+          fallbacks: fallbacks.map(&:provider),
+          excluded: excluded
+        }
+      end
+    end
+  end
+end

data/lib/reanimator/routing/router.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Routing
+    # Chooses which ready profile performs a task (specification section 08
+    # routing strategies). Provider choice is an execution concern, not the
+    # repository's definition of life, so routing operates entirely on
+    # commissioned profiles and always produces a visible explanation. Fallback
+    # is considered only when explicitly declared, and only across profiles that
+    # share a data-handling policy.
+    class Router
+      STRATEGIES = %i[auto pinned ordered task_routed local_only manual].freeze
+
+      def initialize(profiles, strategy: :auto, order: [], pin: nil, fallback: [], task_routes: {})
+        @profiles = profiles
+        @strategy = strategy.to_sym
+        @order = Array(order).map(&:to_sym)
+        @pin = pin&.to_sym
+        @fallback = Array(fallback)
+        @task_routes = task_routes
+        raise UnknownError, "Unknown routing strategy #{strategy.inspect}." unless STRATEGIES.include?(@strategy)
+      end
+
+      # @param required_capabilities [Array<Symbol>]
+      # @param task_class [Symbol, nil]
+      # @return [Decision]
+      def select(required_capabilities: [], task_class: nil)
+        excluded = []
+        eligible = @profiles.select do |profile|
+          reason = ineligibility(profile, required_capabilities, task_class)
+          excluded << {provider: profile.provider, reason: reason} if reason
+          reason.nil?
+        end
+
+        chosen = choose(eligible, task_class)
+        fallbacks = chosen ? declared_fallbacks(chosen) : []
+
+        Decision.new(
+          profile: chosen, strategy: @strategy, excluded: excluded, fallbacks: fallbacks,
+          explanation: explain(chosen, excluded, fallbacks, required_capabilities, task_class)
+        )
+      end
+
+      private
+
+      # Returns a reason string when a profile cannot be used, else nil.
+      def ineligibility(profile, required_capabilities, task_class)
+        return "it is not commissioned ready (#{profile.readiness})" unless profile.ready?
+
+        missing = required_capabilities.map(&:to_sym) - profile.capabilities
+        return "it lacks required capabilities: #{missing.join(", ")}" if missing.any?
+
+        case @strategy
+        when :local_only
+          "it is not a local profile" unless profile.connection.local?
+        when :pinned
+          "it is not the pinned provider (#{@pin})" unless profile.provider == @pin
+        when :task_routed
+          expected = @task_routes[task_class]
+          "task #{task_class} routes to #{expected}, not #{profile.provider}" if expected && profile.provider != expected
+        end
+      end
+
+      def choose(eligible, task_class)
+        return nil if @strategy == :manual
+
+        case @strategy
+        when :ordered
+          @order.filter_map { |provider| eligible.find { |p| p.provider == provider } }.first
+        when :pinned
+          eligible.find { |p| p.provider == @pin }
+        when :task_routed
+          eligible.find { |p| p.provider == @task_routes[task_class] } || prefer(eligible)
+        else # auto, local_only
+          prefer(eligible)
+        end
+      end
+
+      # Prefer local (cheapest, most private), then declared order, else stable.
+      def prefer(eligible)
+        eligible.min_by.with_index do |profile, index|
+          [profile.connection.local? ? 0 : 1, order_rank(profile), index]
+        end
+      end
+
+      def order_rank(profile)
+        rank = @order.index(profile.provider)
+        rank || @order.size
+      end
+
+      # Fallback is never implied: only explicitly declared profiles that are
+      # ready and share the chosen profile's data-handling policy qualify.
+      def declared_fallbacks(chosen)
+        @fallback.select { |f| f.ready? && f != chosen && f.same_data_handling?(chosen) }
+      end
+
+      def explain(chosen, excluded, fallbacks, required_capabilities, task_class)
+        parts = []
+        if chosen
+          because = ["it is commissioned ready"]
+          because << "offers #{required_capabilities.join(", ")}" if required_capabilities.any?
+          parts << "Selected #{chosen.provider} (#{@strategy}) because #{because.join(" and ")}."
+          parts << "Task class: #{task_class}." if task_class
+          parts << if fallbacks.any?
+            "#{fallbacks.map(&:provider).join(", ")} configured as fallback (same data-handling policy)."
+          else
+            "No fallback is configured; fallback is never implied."
+          end
+        else
+          parts << if @strategy == :manual
+            "No agent was auto-selected: manual routing defers the choice to you."
+          else
+            "No eligible agent profile was found."
+          end
+          parts << "Observation and baseline remain automatic."
+        end
+        excluded.each { |e| parts << "#{e[:provider]} was excluded because #{e[:reason]}." }
+        parts.join(" ")
+      end
+    end
+  end
+end

data/lib/reanimator/run.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Reanimator
+  # An immutable record of one stewardship attempt (specification section 17 run
+  # ledger). A run captures its trigger, objective, policy version, agent, the
+  # access it used, its evidence, and its outcome - the auditable story of what
+  # Reanimator did and why. Outcomes are drawn from the section 17 vocabulary:
+  # a healthy no-op, a report, a draft PR, an escalation, or a safe stop.
+  class Run
+    OUTCOMES = %i[no_op report draft_pr escalation safe_stop].freeze
+
+    attr_reader :outcome, :repository, :policy_version, :trigger, :objective,
+      :provider, :access, :pre_state, :post_state, :cost_usd, :proposed_change, :reason, :generated_at
+
+    def initialize(outcome:, repository:, policy_version:, trigger:, objective: nil, provider: nil,
+      access: {}, pre_state: nil, post_state: nil, cost_usd: 0.0, proposed_change: nil, reason: nil, now: nil)
+      @outcome = outcome.to_sym
+      @repository = repository
+      @policy_version = policy_version
+      @trigger = trigger
+      @objective = objective
+      @provider = provider
+      @access = access
+      @pre_state = pre_state
+      @post_state = post_state
+      @cost_usd = cost_usd
+      @proposed_change = proposed_change
+      @reason = reason
+      @generated_at = now || Time.now
+      raise UnknownError, "Unknown run outcome #{outcome.inspect}." unless OUTCOMES.include?(@outcome)
+    end
+
+    # The whole slice's guarantee: repair never writes to the repository. A
+    # proposed draft PR is an artifact, not a submission.
+    def wrote_to_repository? = false
+
+    def to_h
+      {
+        outcome: outcome, repository: repository.full_name, policy_version: policy_version,
+        trigger: trigger, objective: objective&.id, provider: provider, access: access,
+        pre_state: pre_state, post_state: post_state, cost_usd: cost_usd,
+        reason: reason, proposed_change: proposed_change&.to_h, generated_at: generated_at.iso8601
+      }.compact
+    end
+  end
+end