reanimator 0.1.0

data/lib/reanimator/reports/agents.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Lists coding-agent adapters and whether each is available right now
+    # (specification section 08). Hosted providers report themselves unavailable
+    # with a reason until connected, so the surface is honest about what can
+    # actually run.
+    class Agents
+      def initialize(adapters)
+        @adapters = adapters
+      end
+
+      def render
+        (["Coding agents:"] + @adapters.map { |adapter| line(adapter) }).join("\n")
+      end
+
+      private
+
+      def line(adapter)
+        status = adapter.available? ? "available" : "unavailable"
+        detail = adapter.available? ? "" : " — #{adapter.unavailable_reason}"
+        "  #{Reports.glyph(adapter.available? ? :verified : :skipped)} #{adapter.provider} " \
+          "(#{status}) [#{adapter.capabilities.join(", ")}]#{detail}"
+      end
+    end
+  end
+end

data/lib/reanimator/reports/baseline.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # A full single-repository baseline report. It separates verified, failed,
+    # and unproven criteria the way section 14 requires, states the mode
+    # plainly (read-only/planned vs executed), and ends with the promise that
+    # nothing was changed.
+    class Baseline
+      def initialize(baseline)
+        @baseline = baseline
+      end
+
+      def render
+        [
+          header,
+          criteria_section,
+          accepted_risk_section,
+          notes_section,
+          "NO SOURCE CHANGES WERE MADE"
+        ].compact.join("\n\n")
+      end
+
+      private
+
+      def accepted_risk_section
+        risks = @baseline.accepted_risks
+        return if risks.empty?
+
+        lines = risks.map { |r| "  #{Reports.glyph(:accepted_risk)} #{r.criterion.id}: #{r.detail}" }
+        (["Accepted risk (waived) — counted as risk, not verified vitality:"] + lines).join("\n")
+      end
+
+      def header
+        contract = @baseline.contract
+        intent = "#{contract.intent} (#{contract.intent_confirmed? ? "confirmed" : "provisional"})"
+        # The baseline owns which criteria the rate is measured over, so the
+        # fraction and the percentage cannot drift apart.
+        rated = @baseline.rated_required
+        accepted = @baseline.accepted_risks.size
+        rate = (@baseline.verified_vitality_rate * 100).round
+        vvr = "Verified Vitality Rate: #{rate}% (#{rated.count(&:verified?)}/#{rated.size} required"
+        vvr += ", #{accepted} accepted risk" if accepted.positive?
+        vvr += ")"
+        [
+          "Baseline — #{@baseline.repository.full_name}",
+          "State:   #{@baseline.state.to_s.upcase.tr("_", " ")} — #{@baseline.state.meaning}",
+          "Mode:    #{@baseline.executed? ? "executed (bounded, read-only)" : "read-only (planned)"}",
+          "Intent:  #{intent}",
+          "Profile: #{contract.profile.id} (#{contract.profile_source})",
+          "Contract: #{@baseline.policy_version}",
+          vvr
+        ].join("\n")
+      end
+
+      def criteria_section
+        lines = @baseline.results.map do |result|
+          mark = result.required? ? "*" : " "
+          timing = result.duration ? " (#{result.duration}s)" : ""
+          detail = result.detail ? " — #{result.detail}" : ""
+          "  #{Reports.glyph(result.status)}#{mark} #{result.criterion.id}: #{result.criterion.claim}#{detail}#{timing}"
+        end
+        (["Criteria (* = required):"] + lines).join("\n")
+      end
+
+      def notes_section
+        return if @baseline.contract.notes.empty?
+
+        (["Notes:"] + @baseline.contract.notes.map { |n| "  - #{n}" }).join("\n")
+      end
+    end
+  end
+end

data/lib/reanimator/reports/commissioning.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Renders a commissioning report (specification section 08). It states the
+    # readiness verdict, the objective's before/after state, and the observable
+    # cost/latency/tools/network - and closes by affirming the slice's promise:
+    # a profile was proven ready without any repository write.
+    class Commissioning
+      def initialize(report)
+        @report = report
+      end
+
+      def render
+        lines = [
+          "Commissioning — #{@report.provider}",
+          "Readiness: #{@report.readiness.to_s.upcase}",
+          "Capabilities: #{present(@report.capabilities)}"
+        ]
+        lines << objective_line if @report.objective
+        lines << telemetry_line unless @report.readiness == :unavailable
+        lines << "Reason: #{@report.reason}" if @report.reason
+        lines << if @report.ready?
+          "A connected profile is proven ready. NO REPOSITORY WRITES WERE REQUIRED."
+        else
+          "No repository writes were made."
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      def objective_line
+        transition = [@report.pre_state, @report.post_state].compact.map { |s| s.to_s.tr("_", " ") }.join(" → ")
+        "Objective: #{@report.objective}#{" (#{transition})" unless transition.empty?}"
+      end
+
+      def telemetry_line
+        "Cost: $#{format("%.2f", @report.cost_usd)}  Latency: #{@report.latency_s}s  " \
+          "Tools: #{present(@report.tool_use)}  Network: #{present(@report.network)}"
+      end
+
+      def present(list)
+        (list.nil? || list.empty?) ? "none" : list.join(", ")
+      end
+    end
+  end
+end

data/lib/reanimator/reports/contract.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Renders an effective contract for review: the resolved value of every
+    # decision, where it came from, and what is protected. Section 07 requires
+    # the resolved value, its source, and any elevated-review surfaces to be
+    # visible - this is the "minimal view" of the policy explorer.
+    class Contract
+      def initialize(contract)
+        @contract = contract
+      end
+
+      def render
+        [header, autonomy_section, security_section, criteria_section,
+          protected_section, notes_section].compact.join("\n\n")
+      end
+
+      private
+
+      def header
+        [
+          "Effective contract — #{@contract.repository.full_name}",
+          "Intent:   #{@contract.intent} (#{@contract.intent_confirmed? ? "confirmed" : "provisional"})",
+          "Profile:  #{@contract.profile.id} (#{@contract.profile_source}) — #{@contract.profile.summary}",
+          "Policy version: #{@contract.policy_version}"
+        ].join("\n")
+      end
+
+      def autonomy_section
+        pairs = @contract.autonomy.map { |k, v| "#{k}=#{v}" }.join("  ")
+        "Autonomy: #{pairs}"
+      end
+
+      # Section 12 insists the posture is named and explained in plain language
+      # rather than hidden in settings, so it gets its own block: what it is,
+      # what it means, and exactly which controls it makes binding.
+      def security_section
+        posture = @contract.security_posture
+        [
+          "Security posture: #{posture}",
+          "  #{posture.description}",
+          "  Required: #{SecurityControl.labels(posture.required_controls)}",
+          "  Advisory: #{SecurityControl.labels(posture.advisory_controls)}"
+        ].join("\n")
+      end
+
+      def criteria_section
+        lines = @contract.criteria.map do |c|
+          mark = c.required? ? "*" : " "
+          elevated = c.elevated? ? " [elevated review]" : ""
+          how = c.run || c.evaluator
+          "  #{mark} #{c.id}: #{c.claim} — #{how}#{elevated}"
+        end
+        (["Criteria (* = required):"] + lines).join("\n")
+      end
+
+      def protected_section
+        (["Protected paths (elevated review to change):"] +
+          @contract.protected_paths.map { |p| "  - #{p}" }).join("\n")
+      end
+
+      def notes_section
+        return if @contract.notes.empty?
+
+        (["Notes:"] + @contract.notes.map { |n| "  - #{n}" }).join("\n")
+      end
+    end
+  end
+end

data/lib/reanimator/reports/discovery.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Renders discovered facts grouped by detector category, each with its
+    # confidence and provenance. This is the contract-review surface's core
+    # promise from section 06: the report can always answer "Why does
+    # Reanimator believe this?"
+    class Discovery
+      def initialize(discovery)
+        @discovery = discovery
+      end
+
+      def render
+        sections = [suggested_profile]
+        @discovery.by_category.each do |category, facts|
+          sections << category_section(category, facts)
+        end
+        sections << "No facts discovered." if @discovery.facts.empty?
+        sections.join("\n\n")
+      end
+
+      private
+
+      def suggested_profile
+        s = @discovery.suggestion
+        "Suggested profile: #{s.profile} (#{s.confidence}) — #{s.reason}"
+      end
+
+      def category_section(category, facts)
+        lines = facts.map do |fact|
+          "  [#{fact.confidence}] #{fact.claim}  ← #{fact.provenance.explanation}"
+        end
+        (["#{category.to_s.tr("_", " ")}:"] + lines).join("\n")
+      end
+    end
+  end
+end

data/lib/reanimator/reports/drift.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Renders configuration drift (specification section 06) so the two kinds of
+    # change never blur together: policy changes come first, under a heading
+    # that says a human is needed, and benign changes follow as information.
+    class Drift
+      def initialize(report, record_with: "reanimator drift --record")
+        @report = report
+        @record_with = record_with
+      end
+
+      def render
+        return quiet unless @report.drifted?
+
+        ([header] + sections + [verdict, next_step]).compact.join("\n\n")
+      end
+
+      private
+
+      def quiet
+        "#{header}\nNo drift — the contract still matches the recorded snapshot."
+      end
+
+      def header
+        "Configuration drift — #{@report.repository}\nSince: #{@report.since}"
+      end
+
+      def sections
+        [
+          section("Policy changes (review required)", @report.policy_changes, "!"),
+          section("Benign changes", @report.benign_changes, "·")
+        ].compact
+      end
+
+      def section(title, changes, marker)
+        return if changes.empty?
+
+        lines = ["#{title} — #{changes.size}"]
+        changes.each do |change|
+          lines << "  #{marker} #{change.summary}"
+          lines << "    #{change.explanation}"
+        end
+        lines.join("\n")
+      end
+
+      # A maintainer whose build just went red needs to know how to accept
+      # drift they meant to introduce; the report is the only place they are
+      # looking.
+      def next_step
+        "Intended? Re-record with: #{@record_with}"
+      end
+
+      def verdict
+        return "No policy changes; nothing here needs a decision." unless @report.requires_review?
+
+        changes = Reports.count(@report.policy_changes.size, "policy change")
+        "REVIEW REQUIRED: #{changes} — less is being proven than before."
+      end
+    end
+  end
+end

data/lib/reanimator/reports/families.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Renders a portfolio's compatibility graph (specification section 10):
+    # which repositories must stay alive together, what role each plays, and
+    # which edge each gate is there to prove.
+    class Families
+      def initialize(families)
+        @families = families
+      end
+
+      def render
+        return "No repository families detected." if @families.empty?
+
+        ([header] + @families.map { |family| section(family) }).join("\n\n")
+      end
+
+      private
+
+      def header
+        count = @families.size
+        "Repository families — #{Reports.count(count, "family", "families")} " \
+          "(#{@families.sum(&:size)} repositories that must stay alive together)"
+      end
+
+      def section(family)
+        lines = ["#{family.id}:"]
+        family.members.each do |member|
+          lines << "  - #{member.full_name} (#{member.role.to_s.tr("_", " ")})"
+        end
+        family.relationships.each do |relationship|
+          lines << "  edge: #{relationship.label}"
+          lines << "        #{relationship.description}"
+        end
+        family.gates.each { |gate| lines << "  gate: #{gate.label}" }
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/reanimator/reports/family_gates.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Renders cross-repository gate results. The point of section 10 is that a
+    # family failure names the *edge* that broke, so every line leads with the
+    # relationship rather than with whichever repository happened to run.
+    class FamilyGates
+      def initialize(family, results)
+        @family = family
+        @results = results
+      end
+
+      def render
+        ([header] + lines + [footer]).compact.join("\n")
+      end
+
+      private
+
+      def header = "Family gates — #{@family.id}"
+
+      def lines
+        return ["  (no gates declared or inferred)"] if @results.empty?
+
+        @results.map do |result|
+          detail = result.detail ? " — #{result.detail}" : ""
+          timing = result.duration ? " (#{result.duration}s)" : ""
+          "  #{Reports.glyph(result.status)} #{result.edge}#{detail}#{timing}"
+        end
+      end
+
+      def footer
+        broken = @results.select(&:failed?)
+        return "All family edges hold." if broken.empty? && @results.any?(&:verified?)
+        return nil if broken.empty?
+
+        "BROKEN EDGE#{"S" unless broken.size == 1}: #{broken.map(&:edge).join("; ")}"
+      end
+    end
+  end
+end

data/lib/reanimator/reports/github_check.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Renders a repository's vitality as the GitHub Check surface from section
+    # 15 - the compact, scannable artifact a maintainer sees on a commit. A
+    # healthy baseline that changed nothing says so explicitly: healthy silence
+    # made visible.
+    class GitHubCheck
+      def initialize(baseline)
+        @baseline = baseline
+      end
+
+      def render
+        lines = []
+        lines << "REANIMATOR / VITALITY"
+        lines << @baseline.state.to_s.upcase.tr("_", " ")
+        lines << "Verified: #{@baseline.generated_at.strftime("%Y-%m-%d %H:%M %Z")}"
+        lines << "Contract: #{@baseline.policy_version}"
+        lines << "Agent: none required"
+        @baseline.results.each do |result|
+          lines << "#{Reports.glyph(result.status)} #{result.criterion.claim}"
+        end
+        lines << checks_summary
+        lines.compact.join("\n")
+      end
+
+      private
+
+      def checks_summary
+        if unproven_or_failed.positive?
+          "Attention needed: #{unproven_or_failed} required check(s) are not yet proven."
+        elsif @baseline.executed?
+          "No maintenance change was required."
+        else
+          "No source changes were made. Evidence is read-only; run with execution to confirm."
+        end
+      end
+
+      def unproven_or_failed
+        @baseline.unresolved_required.size
+      end
+    end
+  end
+end

data/lib/reanimator/reports/inventory.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Renders a classified portfolio: repositories grouped by suggested cohort,
+    # each with the strongest evidence behind the grouping (section 04). It
+    # leads with the small recommended set, honoring the rule never to
+    # preselect everything.
+    class Inventory
+      def initialize(portfolio)
+        @portfolio = portfolio
+      end
+
+      def render
+        [header, cohort_sections].join("\n\n")
+      end
+
+      private
+
+      def header
+        recommended = @portfolio.recommended.map(&:name)
+        [
+          "Portfolio inventory — #{Reports.count(@portfolio.size, "repository", "repositories")}",
+          "Recommended for onboarding: #{recommended.empty? ? "(none yet)" : recommended.join(", ")}"
+        ].join("\n")
+      end
+
+      def cohort_sections
+        @portfolio.by_cohort.map do |key, entries|
+          cohort = Cohort.fetch(key)
+          lines = entries.map { |e| "  - #{e.name} — #{e.classification.reason}" }
+          (["#{cohort.title} → suggest #{cohort.default_intent}:"] + lines).join("\n")
+        end.join("\n\n")
+      end
+    end
+  end
+end

data/lib/reanimator/reports/permissions.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # Renders the resolved autonomy for a repository across every task class
+    # (specification section 11). It shows how the conservative defaults, the
+    # repository's enabled autonomy, and the safety floor combine into what an
+    # agent may actually do - and flags where elevated review applies.
+    class Permissions
+      def initialize(contract)
+        @contract = contract
+        @model = PermissionModel.new(contract)
+      end
+
+      def render
+        header = "Permissions — #{@contract.repository.full_name} " \
+          "(autonomy: #{@contract.autonomy.map { |k, v| "#{k}=#{v}" }.join(" ")})"
+        rows = TaskClass.keys.map { |key| row(TaskClass.fetch(key)) }
+        [header, "", *rows].join("\n")
+      end
+
+      private
+
+      def row(task_class)
+        resolution = @model.resolve(task_class)
+        actions = AutonomyLevel.keys.map { |level| "#{level}=#{resolution.actions[level]}" }.join(" ")
+        elevated = resolution.elevated_review? ? "  [elevated review]" : ""
+        "  #{task_class.title}: max=#{resolution.max_action} | #{actions}#{elevated}"
+      end
+    end
+  end
+end

data/lib/reanimator/reports/portfolio_baseline.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Reanimator
+  module Reports
+    # The tangible artifact onboarding must produce (Appendix A): a portfolio
+    # baseline that groups repositories by proof-of-life state and, for the ones
+    # with gaps, names exactly what remains unproven. It ends by stating that no
+    # source changed and no agent was required - the whole point of the first
+    # run.
+    class PortfolioBaseline
+      # State display order: proven first, then attention, then dormant.
+      STATE_ORDER = %i[alive at_risk needs_you unproven recovering diverged sleeping retired].freeze
+
+      def initialize(baselines, name: "portfolio", generated_at: nil)
+        @baselines = baselines
+        @name = name
+        @generated_at = generated_at || @baselines.map(&:generated_at).max || Time.now
+      end
+
+      def render
+        ([banner] + state_groups + [footer]).join("\n\n")
+      end
+
+      private
+
+      def banner
+        [
+          "REANIMATOR BASELINE",
+          "Portfolio: #{@name}",
+          "Generated: #{@generated_at.strftime("%Y-%m-%d %H:%M %Z")}",
+          "Mode: read-only",
+          "",
+          "SELECTED FOR CONTINUOUS CARE",
+          Reports.count(@baselines.size, "repository", "repositories")
+        ].join("\n")
+      end
+
+      def state_groups
+        grouped = @baselines.group_by { |b| b.state.to_sym }
+        STATE_ORDER.filter_map do |state|
+          entries = grouped[state]
+          next unless entries
+
+          ([state.to_s.upcase.tr("_", " ")] + entries.flat_map { |b| repository_lines(b) }).join("\n")
+        end
+      end
+
+      def repository_lines(baseline)
+        lines = ["  #{baseline.repository.name}"]
+        gaps(baseline).each { |gap| lines << "    - #{gap}" }
+        lines
+      end
+
+      # For a repository that is not fully Alive, the required criteria that are
+      # not yet verified, with their reason.
+      def gaps(baseline)
+        return [] if baseline.state.alive?
+
+        baseline.unresolved_required
+          .map { |r| r.detail || "#{r.criterion.id} #{Reports.status_label(r.status)}" }
+      end
+
+      def footer
+        ["NO SOURCE CHANGES WERE MADE", "No coding agent was required."].join("\n")
+      end
+    end
+  end
+end