principles 0.0.1

data/lib/principles/models/open_finding.rb

@@ -0,0 +1,221 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "time"
+require_relative "audited_member_lines"
+require_relative "evidence_item"
+require_relative "evidence_replacements"
+require_relative "recorded_finding"
+require_relative "recorded_members"
+
+module Principles
+  # The domain logic, and the mediation of persistence. models/CLAUDE.md owns the boundary.
+  module Models
+    # One finding an audit record left open, deferred or accepted, with the principle and the time of that audit:
+    # what list-open-findings prints of it, and what the next full audit is asked to decide on it (D35).
+    # PriorFindings is the next audit's view of all of them, and checks its decisions. It carries the evidence it
+    # was raised with, which list-open-findings and the next full audit's request print, and which that audit keeps
+    # when it keeps the finding (D64, #839).
+    class OpenFinding
+      # members are the members as the audit that left this finding open recorded them, against which the next
+      # audit says whether each changed since.
+      #: (RecordedFinding, principle_id: String, audited_at: String?, members: RecordedMembers) -> void
+      def initialize(finding, principle_id:, audited_at:, members:)
+        @finding = finding
+        @principle_id = principle_id
+        @audited_at = audited_at
+        @members = members
+        freeze
+      end
+
+      # The finding as list-open-findings prints it, with its principle, when its audit was made and when it was
+      # first raised, so how long it has waited shows (#629), what it says it waits on, since when (D52), and the
+      # evidence its record keeps, or that it keeps none (D64, #839).
+      #: () -> Hash[String, untyped]
+      def listed
+        { "principle" => @principle_id, "finding_id" => id, "member_ids" => @finding.member_ids, **problem,
+          "action" => @finding.action, "recorded_at" => recorded_at&.to_h, "audited_at" => @audited_at,
+          "first_raised_at" => first_raised_at, **raised_in, **waiting, **kept_evidence }
+      end
+
+      # The finding as the next full audit's request lists it, with when it was first raised, and what it waits on,
+      # since when, for the agent to confirm (D52).
+      #: () -> Hash[String, untyped]
+      def for_next_audit
+        { "finding_id" => id, "member_ids" => @finding.member_ids, **problem,
+          **present("recorded_at", recorded_at&.to_h),
+          "action" => @finding.action,
+          "first_raised_at" => first_raised_at, **raised_in, **waiting }
+      end
+
+      # The finding as the next full audit's request lists it, against the map's members now and each one's hash
+      # now, hashes_now: under its members' ids now, with whether each changed since the audit that left it open,
+      # what its record did not keep of it, and the evidence it keeps, so the agent deciding it sees what it rests on
+      # (#839). Given since, each evidence item also carries what since says of it now (#858, #877).
+      #: (MapMembers, Hash[String, String]) ?{ (EvidenceItem) -> Hash[String, bool] }
+      #|  -> Hash[String, untyped]
+      def for_next_audit_against(members_now, hashes_now, &)
+        finding = for_next_audit
+        ids = ids_now(members_now)
+        since = ids.to_h { |id| [id, since_this_audit(members_now, hashes_now, id)] }
+        finding.merge("member_ids" => ids, "members_since" => since, **text_not_kept,
+                      **kept_evidence(evidence_since(&)))
+      end
+
+      # The finding as the next full audit's record keeps it, before that audit's decision on it: under its members'
+      # ids now, with its write-up, when it was first raised and the commit an earlier first_raised_at cited (D53).
+      #: (MapMembers) -> Hash[String, untyped]
+      def kept_against(members_now)
+        { "id" => id, "member_ids" => ids_now(members_now), **problem, "action" => @finding.action,
+          **present("recorded_at", recorded_at&.to_h), "first_raised_at" => first_raised_at, **raised_in }
+      end
+
+      # The principle whose record left it open.
+      #: String
+      attr_reader :principle_id
+
+      # The finding's id in its record.
+      #: () -> String
+      def id = @finding.id
+
+      # Where its write-up is, or nil when it was never written up.
+      #: () -> WriteUpPointer?
+      def recorded_at = @finding.recorded_at
+
+      # What its audit did about it: deferred or accepted.
+      #: () -> String?
+      def action = @finding.action
+
+      # Whether its record keeps what it says is wrong; one that keeps none is marked text_not_kept for the next full
+      # audit to supply.
+      #: () -> bool
+      def states_problem? = !@finding.problem.nil?
+
+      # The locators of the evidence it was raised with, or nil when its record keeps none (D64).
+      #: () -> Array[Hash[String, untyped]]?
+      def evidence = @finding.evidence
+
+      # Whether its record keeps the evidence it was raised with (D64).
+      #: () -> bool
+      def evidence_kept? = @finding.evidence_kept?
+
+      # The ids now, as the next full audit's request lists them, of its members no longer in the map, which its
+      # members_since calls removed.
+      #: (MapMembers) -> Array[String]
+      def removed_from(members_now) = ids_now(members_now).reject { |member_id| members_now.with_id(member_id) }
+
+      # The new places a decision's problem_evidence gives the evidence its record keeps, so the check that an item is
+      # no longer found and the swap read the same items (D70); none when its record keeps none, which problem_evidence
+      # gives instead (D64).
+      #: (Array[Hash[String, untyped]]?) -> EvidenceReplacements
+      def replacements(problem_evidence)
+        kept = evidence or return EvidenceReplacements.new([], [])
+
+        EvidenceReplacements.new(kept, problem_evidence || [])
+      end
+
+      # The evidence its next record keeps after a decision gives problem_evidence: the evidence it was raised with,
+      # each item the decision gave a new place swapped for it (D70), or, when its record keeps none, the evidence the
+      # decision gave, kept as plain evidence since the record does not care which audit gave it (D64).
+      #: (Array[Hash[String, untyped]]?) -> Array[Hash[String, untyped]]?
+      def evidence_after(problem_evidence) = evidence ? replacements(problem_evidence).evidence : problem_evidence
+
+      # Whether it names the member known by key, under whichever id its audit recorded that member, so a member
+      # renamed since is still found (#772).
+      #: (String) -> bool
+      def on?(key) = @finding.member_ids.any? { |member_id| @members.key_of(member_id) == key }
+
+      # The finding as another principle's full audit lists it, once, under open_findings_elsewhere, so the same
+      # problem is not raised again there (#772, D62), with each item of its evidence and what its lines are beside
+      # lines, that audit's members, where locate finds the item now, or that its record keeps none (D64).
+      #: (AuditedMemberLines) { (Locator) -> LocatedText } -> Hash[String, untyped]
+      def listed_elsewhere(lines, &)
+        located = items&.map { |item| lines.facts_of(item, &) }
+        { "principle_id" => @principle_id, "finding_id" => id, **problem, **present("action", @finding.action),
+          **kept_evidence(located) }
+      end
+
+      # When the finding was first raised, which orders the findings by how long each has waited.
+      #: () -> Time
+      def first_raised_time = Time.iso8601(first_raised_at.to_s)
+
+      # The finding as the session-start line names it: its principle and id, the whole days it has waited since it
+      # was first raised until now, and what it says it waits on, when it says (D47, D52).
+      #: (Time) -> Hash[String, untyped]
+      def waited_at(now)
+        { "principle" => @principle_id, "finding_id" => id,
+          "days_open" => ((now - first_raised_time) / 86_400).floor, **present("waits_on", @finding.waits_on) }
+      end
+
+      # Whether it records no waits_on, so the session-start line can count those whose line it cannot show (#736).
+      #: () -> bool
+      def without_waits_on? = !@finding.waits_on
+
+      # The one line it says it waits on, or nil when it says it waits on nothing (D52).
+      #: () -> String?
+      def waits_on = @finding.waits_on
+
+      # What the finding says it waits on, and since when: its own waits_on_since when an earlier audit asked it, or
+      # else this audit's time; nothing when it says it waits on nothing (D52).
+      #: () -> Hash[String, untyped]
+      def waiting
+        line = @finding.waits_on or return {}
+        { "waits_on" => line, "waits_on_since" => @finding.waits_on_since || @audited_at }
+      end
+
+      # Its own first_raised_at when an earlier audit kept it, or else this audit's time.
+      #: () -> String?
+      def first_raised_at = @finding.first_raised_at || @audited_at
+
+      private
+
+      # Its members' ids now, each member found by key so a member renamed since keeps its new id (#772).
+      #: (MapMembers) -> Array[String]
+      def ids_now(members_now) = @finding.member_ids.map { |id| id_now(members_now, @members.key_of(id)) || id }
+
+      #: (MapMembers, String) -> String?
+      def id_now(members_now, key) = members_now.with_key(key)&.id
+
+      #: (MapMembers, Hash[String, String], String) -> String
+      def since_this_audit(members_now, hashes_now, id)
+        member = members_now.with_id(id) or return "removed"
+        @members.freshness(member.key, hashes_now.fetch(id))
+      end
+
+      # The commit whose record an audit cited for an earlier first_raised_at, when one did (D53).
+      #: () -> Hash[String, untyped]
+      def raised_in = present("raised_in", @finding.raised_in)
+
+      # Its evidence items, each with what since says of it now, or as kept without it (#858, #877).
+      #: () ?{ (EvidenceItem) -> Hash[String, bool] } -> Array[Hash[String, untyped]]?
+      def evidence_since(&since)
+        return @finding.evidence unless since
+
+        items&.map { |item| item.with_facts(since.call(item)) }
+      end
+
+      # The evidence it was raised with, as items, or nil when its record keeps none (D64).
+      #: () -> Array[EvidenceItem]?
+      def items = @finding.evidence&.map { |fields| EvidenceItem.new(fields) }
+
+      # A mark when its record keeps no problem statement, for the next full audit to supply.
+      #: () -> Hash[String, untyped]
+      def text_not_kept = states_problem? ? {} : { "text_not_kept" => true }
+
+      # The evidence its record keeps, as items, which another principle's audit gives with each item's lines, or the
+      # mark that it keeps none, as a record written before this tool kept evidence does (D64, #839).
+      #: (?Array[Hash[String, untyped]]?) -> Hash[String, untyped]
+      def kept_evidence(listed = @finding.evidence)
+        evidence_kept? ? { "evidence" => listed } : { "evidence_not_kept" => true }
+      end
+
+      # What it says is wrong, under its key, or nothing when the record kept no text for it.
+      #: () -> Hash[String, untyped]
+      def problem = present("problem", @finding.problem)
+
+      # value under name, or nothing when there is none, as the record leaves out a field it has no value for.
+      #: (String, untyped) -> Hash[String, untyped]
+      def present(name, value) = value.nil? ? {} : { name => value }
+    end
+  end
+end

data/lib/principles/models/open_findings_elsewhere.rb

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../error"
+require_relative "members_elsewhere"
+require_relative "open_finding"
+
+module Principles
+  # The domain logic, which loads and saves itself through data/. models/CLAUDE.md owns the boundary.
+  module Models
+    # The findings other principles' records leave open on members sharing lines with a full audit's members, read
+    # once per principle: each member's mapped_elsewhere names them by id, and the request lists each once, since a
+    # whole file's findings printed in full beside every passage within it (#772, #786, D62).
+    class OpenFindingsElsewhere
+      # sharing gives, under each audited member's id, the other principles' members sharing its lines.
+      #: (Hash[String, MembersElsewhere], AuditRecords) -> OpenFindingsElsewhere
+      def self.of(sharing, records)
+        ids = sharing.values.flat_map(&:principle_ids).uniq
+        new(sharing, ids.to_h { |id| [id, records.left_open_or_none(id)] })
+      end
+
+      #: (Hash[String, MembersElsewhere], Hash[String, Array[OpenFinding]]) -> void
+      def initialize(sharing, left_open_by_principle)
+        @sharing = sharing
+        @left_open_by_principle = left_open_by_principle
+        freeze
+      end
+
+      # The other principles' members sharing the lines of the audited member member_id, each naming by id the
+      # findings left open on it.
+      #: (String) -> Array[Hash[String, untyped]]
+      def beside(member_id) = @sharing.fetch(member_id).naming(@left_open_by_principle)
+
+      # Each finding left open on any of them, once, with its principle, and what its evidence's lines are beside
+      # lines, this audit's members, where locate finds each item now (D64): a finding is the same one when its
+      # principle and id are.
+      #: (AuditedMemberLines) { (Locator) -> LocatedText } -> Array[Hash[String, untyped]]
+      def listed(lines, &)
+        @sharing.values.flat_map { |members| members.open_among(@left_open_by_principle) }
+                .uniq { |finding| [finding.principle_id, finding.id] }
+                .map { |finding| finding.listed_elsewhere(lines, &) }
+      end
+    end
+  end
+end

data/lib/principles/models/other_principles.rb

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "member_problems"
+require_relative "member_state"
+
+module Principles
+  # The domain logic, and the mediation of persistence. models/CLAUDE.md owns the boundary.
+  module Models
+    # Every principle of the project but one, each as list-member-problems reports its members, which an audit of
+    # that one names when their members need an audit of their own: a completed audit for those its fixes changed
+    # (#410, #823), and the meta-principle's full audit for those no audit has judged as they are now (D71).
+    class OtherPrinciples
+      # Each principle of project but the one id names, its members as MemberProblems gives them; a map this tool
+      # cannot read is among them, as list-member-problems lists it.
+      #: (Project, but: String) -> OtherPrinciples
+      def self.of(project, but:)
+        new((project.member_maps.ids - [but]).to_h { [it, MemberProblems.for(project, it, listing_all: true)] })
+      end
+
+      # problems maps each principle's id to its members' problems.
+      #: (Hash[String, MemberProblems]) -> void
+      def initialize(problems)
+        @problems = problems.freeze #: Hash[String, MemberProblems]
+        freeze
+      end
+
+      # Each principle with a member in paths whose own text changed or whose reference broke, by id, with those
+      # members; a principle with none is left out.
+      #: (Array[String]) -> Hash[String, Array[MemberState]]
+      def changed_or_broken_in(paths) = listed { it.changed_or_broken_in(paths) }
+
+      # Each principle with members no audit has judged as they are now, by id, with those members by id and state;
+      # a principle with none is left out.
+      #: () -> Hash[String, Array[Hash[String, untyped]]]
+      def unjudged = listed(&:unjudged)
+
+      private
+
+      # What the block gives for each principle's problems, by id, where it gives any.
+      #: [T] () { (MemberProblems) -> Array[T] } -> Hash[String, Array[T]]
+      def listed(&)
+        @problems.transform_values(&).reject { |_, members| members.empty? }
+      end
+    end
+  end
+end

data/lib/principles/models/placement.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Principles
+  # The domain logic, and the mediation of persistence. models/CLAUDE.md owns the boundary.
+  module Models
+    # Where a member may be read at a commit, and the hash of its text there, nil where it cannot be found. A
+    # one-member audit takes as the member's baseline the oldest placement that holds the text the audit record
+    # vouches for (#550).
+    class Placement
+      #: String
+      attr_reader :commit
+
+      #: Hash[String, untyped]
+      attr_reader :reference
+
+      #: String?
+      attr_reader :sha256
+
+      # Where the member is at commit, as the Locator MemberFile reads.
+      #: () -> Locator
+      def locator = Locator.new(reference)
+
+      #: (commit: String, reference: Hash[String, untyped], sha256: String?) -> void
+      def initialize(commit:, reference:, sha256:)
+        @commit = commit
+        @reference = reference
+        @sha256 = sha256
+        freeze
+      end
+
+      # Whether the member's text here is the text whose hash is recorded.
+      #: (String?) -> bool
+      def holds?(recorded) = !sha256.nil? && sha256 == recorded
+
+      # The paths a change from here to the member at now_path spans, this one first, so a diff over them follows
+      # a move (#551).
+      #: (String) -> Array[String]
+      def paths_to(now_path) = [reference.fetch("path"), now_path].uniq
+    end
+  end
+end

data/lib/principles/models/plain_text_file.rb

@@ -0,0 +1,32 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "member_file"
+
+module Principles
+  # The domain logic, which loads and saves itself through data/. models/CLAUDE.md owns the boundary.
+  module Models
+    # A file that is not Markdown, such as a script or a config file. It has no sections, so a member is the
+    # whole file or a passage of it, and a # line is never read as a heading.
+    class PlainTextFile < MemberFile
+      private
+
+      # The whole text; a heading is refused, since a # line here is a comment, not a heading.
+      #: (Array[String], Locator) -> [Integer, Integer]
+      def region(lines, locator)
+        if locator.heading
+          raise Error.new("section_needs_markdown", "#{@path} is not Markdown, so it has no sections",
+                          "Name the member by a passage with --starting-at TEXT [--ending-at TEXT], or map the " \
+                          "whole file.", @path)
+        end
+
+        if locator.query
+          raise Error.new("query_needs_frontmatter", "#{@path} is not Markdown, so it has no frontmatter to query",
+                          "Name the member by a passage with --starting-at TEXT, or map the whole file.", @path)
+        end
+
+        [0, lines.length]
+      end
+    end
+  end
+end

data/lib/principles/models/principles_folder_move.rb

@@ -0,0 +1,59 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../error"
+require_relative "../data/principles_subfolder"
+
+module Principles
+  # The domain logic, and the mediation of persistence. models/CLAUDE.md owns the boundary.
+  module Models
+    # Whether a project's maps and records have moved from .memeplex, the folder's earlier name, to .principles.
+    # Reading the new folder alone would show an unmoved project as unmapped, so every command that reads either
+    # refuses until the folder moves, or until one of two folders holding them is removed. A file an older version
+    # left in .memeplex beside no maps or records does not count (#536, rename brief findings 1 and 9).
+    class PrinciplesFolderMove
+      FOLDER = Data::PrinciplesSubfolder::FOLDER #: String
+      EARLIER = Data::PrinciplesSubfolder::EARLIER_FOLDER #: String
+
+      # held names the folders that hold maps/ or audits/.
+      #: (Array[String]) -> void
+      def initialize(held)
+        @held = held
+        freeze
+      end
+
+      # Refuses while the earlier folder holds maps or records.
+      #: () -> void
+      def refuse_while_pending
+        return unless @held.include?(EARLIER)
+
+        raise both_folders if @held.include?(FOLDER)
+
+        raise not_moved
+      end
+
+      private
+
+      #: () -> Error
+      def both_folders
+        Error.new("both_principles_folders",
+                  "Both #{EARLIER} and #{FOLDER} hold maps or audit records; this version reads #{FOLDER} only",
+                  "Removing either folder changes the user's project, so ask the user first. Compare the two " \
+                  "before removing either: move into #{FOLDER} each map or record that only " \
+                  "#{EARLIER} holds, and where both hold one, compare them and keep the current one; in git, " \
+                  "git log shows which changed last. Then remove #{EARLIER} and commit.", EARLIER)
+      end
+
+      #: () -> Error
+      def not_moved
+        Error.new("principles_folder_not_moved",
+                  "This project's maps or audit records are in #{EARLIER}, the folder's earlier name; this version " \
+                  "reads #{FOLDER}",
+                  "Moving the folder changes the user's project, so ask the user before moving it.\n" \
+                  "To move it in git: git mv #{EARLIER} #{FOLDER}\nOutside git: mv #{EARLIER} #{FOLDER}\n" \
+                  "Then commit the move. If anything untracked is left in #{EARLIER}, such as state.json and " \
+                  "lock, which an older version wrote, ask the user before deleting it.", EARLIER)
+      end
+    end
+  end
+end

data/lib/principles/models/principles_package.rb

@@ -0,0 +1,53 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "digest"
+
+module Principles
+  # The domain logic, and the mediation of persistence. models/CLAUDE.md owns the boundary.
+  module Models
+    # The release of principles an audit of the meta-principle ran under: its version, and a digest of the passage
+    # it proposes for setup, as printed. An upgrade can change the session-start hook, the skill and the passage,
+    # none of which a consuming project maps, so the meta-principle's record keeps this and its next audit states
+    # what changed since (D68, synthesis F3 and F12).
+    class PrinciplesPackage
+      # The key the passage's digest is kept under. The record keeps its digests by key, as releases before D71 kept
+      # one for each of two passage forms, so their records stay valid; neither form's key is this one, so a record
+      # one of them wrote reads as a passage change once, at the next audit (D71).
+      PASSAGE = "entry_file_passage"
+
+      # The release running now, from its version and the passage's text.
+      #: (version: String, passage: String) -> PrinciplesPackage
+      def self.of(version:, passage:)
+        new("version" => version, "passage_sha256" => { PASSAGE => Digest::SHA256.hexdigest(passage) })
+      end
+
+      # The release a record kept, or nil when it kept none, as a record of another principle or one an older
+      # version wrote does not.
+      #: (Hash[String, untyped]?) -> PrinciplesPackage?
+      def self.kept(fields) = fields ? new(fields) : nil
+
+      #: (Hash[String, untyped]) -> void
+      def initialize(fields)
+        @fields = fields.freeze #: Hash[String, untyped]
+        freeze
+      end
+
+      #: () -> String
+      def version = @fields.fetch("version")
+
+      # Whether the passage's text differs from the one earlier proposed, or earlier kept no digest of it.
+      #: (PrinciplesPackage) -> bool
+      def passage_changed_since?(earlier) = earlier.passage_sha256 != passage_sha256
+
+      # As a record keeps it.
+      #: () -> Hash[String, untyped]
+      def to_h = @fields
+
+      protected
+
+      #: () -> String?
+      def passage_sha256 = @fields.fetch("passage_sha256")[PASSAGE]
+    end
+  end
+end

data/lib/principles/models/prior_finding_decision.rb

@@ -0,0 +1,162 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../error"
+require_relative "answer_fields"
+require_relative "answer_place"
+require_relative "answer_text"
+require_relative "first_raised_claim"
+require_relative "kept_prior_finding"
+require_relative "open_finding"
+require_relative "still_holds_restatement"
+require_relative "waits_on"
+
+module Principles
+  # The domain logic, and the mediation of persistence. models/CLAUDE.md owns the boundary.
+  module Models
+    # One decision on a prior finding the request listed (D35), checked against that finding and this audit's
+    # new findings. Whether the finding still holds is the agent's judgement; this tool checks the decision's shape.
+    class PriorFindingDecision
+      KINDS = %w[still_holds resolved withdrawn raised_again].freeze
+      CLOSING = %w[resolved withdrawn].freeze
+      # What the completed result shows of each closed finding.
+      CLOSED_FIELDS = %w[finding_id decision reason evidence].freeze
+      REPAIR = "Decide it still_holds, raised_again with as, or resolved or withdrawn with a one-line reason."
+
+      # finding is the prior finding as its record left it open; at is the decision's place in the answer, such as
+      # /prior_finding_decisions/0, which a refusal about its pointers names; members are the map's members now, which
+      # a kept finding's members must still be among.
+      #: (Hash[String, untyped], OpenFinding, Array[String], at: String, members: MapMembers) -> void
+      def initialize(decision, finding, new_ids, at:, members:)
+        @decision = decision.reject { |key, value| key == "problem_evidence" && value == [] } #: Hash[String, untyped]
+        @finding = finding
+        @new_ids = new_ids
+        @members = members
+        @id = finding.id #: String
+        @place = AnswerPlace.new(at, "Prior finding #{@id}") #: AnswerPlace
+        freeze
+      end
+
+      # Refuses the decision unless its kind, reason, as, any evidence of a fix and any restated problem or pointer
+      # are sound. locate checks that each evidence pointer and a new recorded_at resolve, as a deferral's is checked.
+      #: (^(Locator) -> void) -> void
+      def check(locate)
+        kind = @decision["decision"]
+        invalid("#{kind.inspect} is not a decision") unless KINDS.include?(kind)
+        kind == "still_holds" ? holds : closed_or_raised(kind)
+        fix_shown(locate)
+        new_action
+        StillHoldsRestatement.new(@decision, @finding, @place, refuse: refusal).check(locate)
+        WaitsOn.new(@decision["waits_on"], action: kept_action).check(code: "invalid_decision",
+                                                                      subject: "Prior finding #{@id}")
+      end
+
+      # The prior finding it decides, as its record left it open.
+      #: OpenFinding
+      attr_reader :finding
+
+      # What it decides: still_holds, resolved, withdrawn or raised_again.
+      #: () -> String
+      def kind = @decision.fetch("decision")
+
+      # The id of the new finding a raised_again decision raises it as.
+      #: () -> String
+      def raised_as = @decision.fetch("as")
+
+      # The decision as the completed result shows a closed finding.
+      #: () -> Hash[String, untyped]
+      def closed = @decision.slice(*CLOSED_FIELDS)
+
+      # The finding a still_holds decision keeps, against the map's members now. Its problem_evidence is read with an
+      # empty list as none given: the template starts a marked finding's decision with one, which an agent leaves in
+      # whatever it decides (#838).
+      #: () -> KeptPriorFinding
+      def kept = KeptPriorFinding.new(@decision, @finding, @members)
+
+      # The earlier first_raised_at this decision claims, if any, to check against the record it cites (D53).
+      #: () -> FirstRaisedClaim
+      def first_raised_claim = FirstRaisedClaim.new(@decision, @finding)
+
+      private
+
+      # A still_holds decision may make its finding deferred or accepted, with a one-line reason, and a deferral
+      # says where it is written up, if only as null, as a correction's does (D35 brief, finding 14).
+      #: () -> void
+      def new_action
+        action = @decision["action"] or return
+        unless @decision["decision"] == "still_holds"
+          invalid("only still_holds may give action", "Drop action from #{@id}'s decision, or decide it still_holds.")
+        end
+        invalid("still_holds may make it only deferred or accepted") unless %w[deferred accepted].include?(action)
+        changed_action(action)
+      end
+
+      #: (String) -> void
+      def changed_action(action)
+        if action == @finding.action
+          invalid("it is already #{action}", "Drop action from #{@id}'s decision; it is already #{action}.")
+        end
+        invalid("a new action needs a one-line reason") unless one_line_reason?
+        unrecorded_deferral if action == "deferred" && !@decision.key?("recorded_at")
+      end
+
+      #: () -> bot
+      def unrecorded_deferral
+        invalid("deferring it needs recorded_at, or null when it is written up nowhere",
+                "Set recorded_at to where #{@id} is written up, as {\"path\": ..., \"heading\": ...}, or to null.")
+      end
+
+      # The action the finding keeps once decided, or nil when the decision closes it or raises it again (D52).
+      #: () -> String?
+      def kept_action
+        return nil unless @decision["decision"] == "still_holds"
+
+        @decision["action"] || @finding.action
+      end
+
+      #: () -> void
+      def holds
+        gone unless @finding.removed_from(@members).empty?
+      end
+
+      #: (String) -> void
+      def closed_or_raised(kind)
+        invalid("#{kind} needs a one-line reason") if CLOSING.include?(kind) && !one_line_reason?
+        invalid("raised_again needs as: the id of a new finding") if kind == "raised_again" && !raised_as_new?
+      end
+
+      #: () -> bool
+      def one_line_reason? = AnswerText.new(@decision["reason"]).one_line?
+
+      #: () -> bool
+      def raised_as_new? = @new_ids.include?(@decision["as"])
+
+      # A resolved decision may point at where its fix shows (D35 brief, finding 10).
+      #: (^(Locator) -> void) -> void
+      def fix_shown(locate)
+        return unless @decision.key?("evidence")
+
+        unless @decision["decision"] == "resolved"
+          invalid("only resolved may give evidence", "Drop evidence from #{@id}'s decision, or decide it resolved.")
+        end
+        AnswerFields.new(locate).evidence(@decision["evidence"], @place.child("evidence"))
+      end
+
+      # The decision's refusal, for a part that checks it apart: a reason and a repair, or REPAIR for nil.
+      #: () -> ^(String, String?) -> void
+      def refusal = ->(why, repair) { invalid(why, repair || REPAIR) }
+
+      #: (String, ?String) -> bot
+      def invalid(why, repair = REPAIR)
+        raise Error.new("invalid_decision", "Prior finding #{@id}: #{why}", repair)
+      end
+
+      #: () -> bot
+      def gone
+        removed = @finding.removed_from(@members)
+        raise Error.new("unknown_member", "Prior finding #{@id} names members no longer mapped: #{removed.join(", ")}",
+                        "Decide it resolved or withdrawn with a reason, or raise it again as a new finding.")
+      end
+    end
+  end
+end