principles 0.0.1

data/lib/principles/models/ignored_candidates.rb

@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Principles
+  # The domain logic, which loads and saves itself through data/. models/CLAUDE.md owns the boundary.
+  module Models
+    # The candidate files git ignores, which this tool names but never reads. A folder git ignores can hold many
+    # copies of instruction files written there by specs or builds, and listing each buries a file ignored on
+    # its own, such as personal settings (#406). So a file under a folder git ignores is counted under the
+    # shallowest such folder, and only the rest are listed.
+    class IgnoredCandidates
+      # paths are the ignored candidates; folders are every folder above one that git ignores, each ending in "/".
+      #: (paths: Array[String], folders: Array[String]) -> void
+      def initialize(paths:, folders:)
+        @paths = paths #: Array[String]
+        @folders = folders #: Array[String]
+        freeze
+      end
+
+      # The inventory's ignored files and ignored folders.
+      #: () -> Hash[String, untyped]
+      def listing = { "ignored" => on_their_own, "ignored_folders" => by_folder }
+
+      # Each ignored candidate with no folder above it that git ignores.
+      #: () -> Array[String]
+      def on_their_own
+        @paths.reject { |path| shallowest_folder(path) }.sort
+      end
+
+      # Each shallowest folder git ignores, and how many ignored candidates it holds.
+      #: () -> Array[Hash[String, untyped]]
+      def by_folder
+        @paths.filter_map { |path| shallowest_folder(path) }.tally.sort.map do |folder, count|
+          { "folder" => folder, "candidates" => count }
+        end
+      end
+
+      private
+
+      #: (String) -> String?
+      def shallowest_folder(path)
+        @folders.select { |folder| path.start_with?(folder) }.min_by(&:length)
+      end
+    end
+  end
+end

data/lib/principles/models/json_digest.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module Principles
+  # The domain logic, and the mediation of persistence. models/CLAUDE.md owns the boundary.
+  module Models
+    # The digest of what a JSON value says: its objects' keys in sorted order at every depth and its lists in their
+    # own, so a formatter or a hand edit that only reorders a file's keys leaves it unchanged (#656). A map's
+    # version and an audit record's revision are each one (D51).
+    class JsonDigest
+      #: (untyped) -> void
+      def initialize(value)
+        @text = JSON.generate(in_key_order(value)) #: String
+        freeze
+      end
+
+      #: () -> String
+      def to_s = Digest::SHA256.hexdigest(@text)
+
+      private
+
+      #: (untyped) -> untyped
+      def in_key_order(value)
+        case value
+        when Hash then value.sort.to_h { |key, inner| [key, in_key_order(inner)] }
+        when Array then value.map { |inner| in_key_order(inner) }
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/principles/models/json_path_query.rb

@@ -0,0 +1,131 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "strscan"
+require_relative "../error"
+require_relative "json_path_string"
+require_relative "json_path_selectors"
+
+module Principles
+  # The domain logic, which loads and saves itself through data/. models/CLAUDE.md owns the boundary.
+  module Models
+    # A query in this tool's own profile of RFC 9535 JSONPath (D32): from $, name selectors in dot or bracket
+    # form, wildcards, and filters that keep the children whose relative paths equal strings, joined by &&.
+    # A query outside the profile is refused whole, never half-read, so an id always holds standard JSONPath
+    # and a later full implementation changes no map. It only evaluates over values already parsed as JSON.
+    class JsonPathQuery
+      # A member-name shorthand, as RFC 9535 defines it for ASCII.
+      SHORTHAND = /[A-Za-z_][A-Za-z0-9_]*/ #: Regexp
+
+      # The repair this tool gives when it has no exact rewrite to offer.
+      GRAMMAR = "Use $ followed by .name, ['name'], .* or [*], and [?@.field=='text' && ...] filters." #: String
+
+      #: (String) -> void
+      def initialize(query)
+        @query = query
+        @segments = parsed(StringScanner.new(query)) #: Array[(JsonPathName | JsonPathWildcard | JsonPathFilter)]
+        freeze
+      end
+
+      # The nodes this query selects from value, in document order.
+      #: (untyped) -> Array[untyped]
+      def select(value)
+        @segments.reduce([value]) { |nodes, selector| nodes.flat_map { |node| selector.select(node) } }
+      end
+
+      # The name of the one top-level member this query selects, or nil when it selects anything else.
+      #: () -> String?
+      def top_level_name
+        only = @segments.first
+        only.name if @segments.length == 1 && only.is_a?(JsonPathName)
+      end
+
+      private
+
+      #: (StringScanner) -> Array[(JsonPathName | JsonPathWildcard | JsonPathFilter)]
+      def parsed(scanner)
+        refuse("it does not start with $") unless scanner.scan("$")
+        segments = [] #: Array[(JsonPathName | JsonPathWildcard | JsonPathFilter)]
+        segments << segment(scanner) until scanner.eos?
+        segments
+      end
+
+      #: (StringScanner) -> (JsonPathName | JsonPathWildcard | JsonPathFilter)
+      def segment(scanner)
+        refuse("descendant segments (..) are outside the profile") if scanner.check("..")
+        return dotted(scanner) if scanner.scan(".")
+        return bracketed(scanner) if scanner.scan("[")
+
+        refuse("it has #{scanner.rest.inspect} where a segment should start")
+      end
+
+      #: (StringScanner) -> (JsonPathName | JsonPathWildcard | JsonPathFilter)
+      def dotted(scanner)
+        return JsonPathWildcard.new if scanner.scan("*")
+
+        start = scanner.pos - 1
+        name = scanner.scan(SHORTHAND) or refuse("a . must be followed by a name or *")
+        refuse_hyphenated(scanner, start, name) if scanner.check(/-/)
+        JsonPathName.new(name)
+      end
+
+      # A name with a hyphen cannot follow a dot in RFC 9535, so the repair gives the query with it bracketed.
+      #: (StringScanner, Integer, String) -> bot
+      def refuse_hyphenated(scanner, start, name)
+        name += scanner.scan(/[A-Za-z0-9_-]+/).to_s
+        rewritten = "#{@query[0...start]}['#{name}']#{scanner.rest}"
+        refuse("a name with a hyphen cannot follow a dot", "Put the name in brackets: write it #{rewritten}.")
+      end
+
+      #: (StringScanner) -> (JsonPathName | JsonPathWildcard | JsonPathFilter)
+      def bracketed(scanner)
+        selector = if scanner.scan("*") then JsonPathWildcard.new
+                   elsif scanner.scan("?") then JsonPathFilter.new(conditions(scanner))
+                   elsif scanner.check(/['"]/) then JsonPathName.new(JsonPathString.new(@query).read(scanner))
+                   else refuse("this selector is outside the profile, which takes names, * and ?filters")
+                   end
+        refuse("this selector is outside the profile, or not closed") unless scanner.scan("]")
+        selector
+      end
+
+      # The filter's conditions: @-relative paths each equal to a string, joined by &&.
+      #: (StringScanner) -> Array[[Array[String], String]]
+      def conditions(scanner)
+        found = [condition(scanner)]
+        found << condition(scanner) while scanner.scan(/\s*&&\s*/)
+        scanner.skip(/\s*/)
+        found
+      end
+
+      #: (StringScanner) -> [Array[String], String]
+      def condition(scanner)
+        scanner.skip(/\s*/)
+        refuse("a filter must compare an @ path") unless scanner.scan("@")
+        path = [] #: Array[String]
+        path << relative_name(scanner) while scanner.check(/\.|\[/)
+        refuse("a filter compares with == only") unless scanner.scan(/\s*==\s*/)
+        refuse("a filter compares with a quoted string only") unless scanner.check(/['"]/)
+        [path, JsonPathString.new(@query).read(scanner)]
+      end
+
+      #: (StringScanner) -> String
+      def relative_name(scanner)
+        if scanner.scan(".")
+          scanner.scan(SHORTHAND) or refuse("a . in a filter path must be followed by a name")
+        else
+          scanner.scan("[")
+          refuse("a [ in a filter path must hold a quoted name") unless scanner.check(/['"]/)
+          name = JsonPathString.new(@query).read(scanner)
+          refuse("a [ in a filter path is not closed") unless scanner.scan("]")
+          name
+        end
+      end
+
+      #: (String, ?String) -> bot
+      def refuse(why, repair = GRAMMAR)
+        raise Error.new("unsupported_query", "#{@query.inspect} is outside the supported JSONPath profile: #{why}",
+                        repair)
+      end
+    end
+  end
+end

data/lib/principles/models/json_path_selectors.rb

@@ -0,0 +1,64 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Principles
+  # The domain logic, which loads and saves itself through data/. models/CLAUDE.md owns the boundary.
+  module Models
+    # The selector * in a JSONPath query: every member value of an object, or every element of an array.
+    class JsonPathWildcard
+      #: () -> void
+      def initialize
+        freeze
+      end
+
+      #: (untyped) -> Array[untyped]
+      def select(node)
+        return node.values if node.is_a?(Hash)
+
+        node.is_a?(Array) ? node : []
+      end
+    end
+
+    # A name selector in a JSONPath query: the member of an object with that name, if it has one.
+    class JsonPathName
+      #: String
+      attr_reader :name
+
+      #: (String) -> void
+      def initialize(name)
+        @name = name
+        freeze
+      end
+
+      #: (untyped) -> Array[untyped]
+      def select(node)
+        node.is_a?(Hash) && node.key?(@name) ? [node.fetch(@name)] : []
+      end
+    end
+
+    # A filter selector in this tool's profile: the children for which every condition holds, each condition an
+    # @-relative path of names leading to a string equal to the condition's string.
+    class JsonPathFilter
+      #: (Array[[Array[String], String]]) -> void
+      def initialize(conditions)
+        @conditions = conditions
+        freeze
+      end
+
+      #: (untyped) -> Array[untyped]
+      def select(node)
+        JsonPathWildcard.new.select(node).select { |child| holds_for?(child) }
+      end
+
+      private
+
+      #: (untyped) -> bool
+      def holds_for?(child)
+        @conditions.all? do |path, expected|
+          found = path.reduce(child) { |value, name| value.is_a?(Hash) ? value[name] : nil }
+          found.is_a?(String) && found == expected
+        end
+      end
+    end
+  end
+end

data/lib/principles/models/json_path_string.rb

@@ -0,0 +1,76 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "strscan"
+require_relative "../error"
+
+module Principles
+  # The domain logic, which loads and saves itself through data/. models/CLAUDE.md owns the boundary.
+  module Models
+    # One quoted name or string in a JSONPath query, read as RFC 9535 writes it: single or double quotes, the
+    # escapes it defines, and no raw control character. Anything else refuses the whole query.
+    class JsonPathString
+      # The escapes a quoted name or string may hold, and what each stands for.
+      ESCAPES = { "b" => "\b", "f" => "\f", "n" => "\n", "r" => "\r", "t" => "\t", "/" => "/", "\\" => "\\",
+                  "'" => "'", "\"" => "\"" }.freeze #: Hash[String, String]
+
+      # query is the whole query, which a refusal names.
+      #: (String) -> void
+      def initialize(query)
+        @query = query
+        freeze
+      end
+
+      # The string that starts at scanner, its quotes and escapes read; scanner is left after its closing quote.
+      #: (StringScanner) -> String
+      def read(scanner)
+        string(scanner)
+      end
+
+      private
+
+      # A quoted string, single or double, with its escapes read.
+      #: (StringScanner) -> String
+      def string(scanner)
+        quote = scanner.getch.to_s
+        text = +""
+        until scanner.scan(quote)
+          refuse("a quoted string is not closed") if scanner.eos?
+          text << (scanner.scan("\\") ? escaped(scanner, quote) : unescaped(scanner))
+        end
+        text
+      end
+
+      # One escape after a backslash. A quote may be escaped only inside quotes of its own kind, and a \u escape
+      # naming half of a surrogate pair is outside the profile.
+      #: (StringScanner, String) -> String
+      def escaped(scanner, quote)
+        if scanner.scan(/u\h{4}/)
+          point = scanner.matched.to_s[1, 4].to_s.hex
+          refuse("a \\u escape for a surrogate is outside the profile") if point.between?(0xD800, 0xDFFF)
+          return [point].pack("U")
+        end
+        char = scanner.getch.to_s
+        other_quote = quote == "'" ? '"' : "'"
+        refuse("a string holds an escape JSONPath does not define") if char == other_quote
+
+        ESCAPES.fetch(char) { refuse("a string holds an escape JSONPath does not define") }
+      end
+
+      # One character as written; a control character must be escaped.
+      #: (StringScanner) -> String
+      def unescaped(scanner)
+        char = scanner.getch.to_s
+        refuse("a string holds an unescaped control character") if char.ord < 0x20
+
+        char
+      end
+
+      #: (String) -> bot
+      def refuse(why)
+        raise Error.new("unsupported_query", "#{@query.inspect} is outside the supported JSONPath profile: #{why}",
+                        "Quote names with ' or \", escaping only what RFC 9535 defines.")
+      end
+    end
+  end
+end

data/lib/principles/models/kept_prior_finding.rb

@@ -0,0 +1,70 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "first_raised_claim"
+require_relative "map_members"
+require_relative "open_finding"
+require_relative "waits_on"
+
+module Principles
+  # The domain logic, and the mediation of persistence. models/CLAUDE.md owns the boundary.
+  module Models
+    # A prior finding a still_holds decision kept (D35): the finding as the next record keeps it, and what the decision
+    # dropped or replaced of it, which the completed result names so a change not meant can be seen and put back.
+    class KeptPriorFinding
+      # decision is the checked still_holds decision on finding, the prior finding as its record left it open; members
+      # are the map's members now, under whose ids it is recorded.
+      #: (Hash[String, untyped], OpenFinding, MapMembers) -> void
+      def initialize(decision, finding, members)
+        @decision = decision
+        @finding = finding
+        @record = record(members) #: Hash[String, untyped]
+        freeze
+      end
+
+      # The finding as the record keeps it, with any problem, action or pointer its decision gave, and any earlier
+      # first_raised_at it claimed with the commit it cited (D53); a null pointer drops the one it had. Its evidence is
+      # as OpenFinding#evidence_after says, from its own state rather than as the request printed it (D64, D70).
+      #: () -> Hash[String, untyped]
+      def to_h = @record
+
+      # The pointer it had that its decision dropped with a null recorded_at, or nil when it dropped none (#374).
+      #: () -> Hash[String, untyped]?
+      def dropped_write_up
+        had = @finding.recorded_at
+        return unless had && @decision.key?("recorded_at") && @decision["recorded_at"].nil?
+
+        { "finding_id" => @finding.id, "recorded_at" => had.to_h }
+      end
+
+      # What it waited on that its decision dropped, with null or by accepting it, or nil when it dropped nothing (D52).
+      #: () -> Hash[String, untyped]?
+      def waits_on_dropped
+        return if @finding.without_waits_on? || @record.key?("waits_on")
+
+        { "finding_id" => @finding.id, **@finding.waiting }
+      end
+
+      # Each kept evidence item its decision gave a new place, as it was and is now (D70).
+      #: () -> Array[Hash[String, untyped]]
+      def swaps = @finding.replacements(@decision["problem_evidence"]).swaps(@finding.id)
+
+      private
+
+      #: (MapMembers) -> Hash[String, untyped]
+      def record(members)
+        kept = @finding.kept_against(members)
+                       .merge(@decision.slice("problem", "action", "recorded_at", *FirstRaisedClaim::FIELDS),
+                              { "evidence" => @finding.evidence_after(@decision["problem_evidence"]) }).compact
+        kept.merge(waiting_after(kept))
+      end
+
+      # What it waits on, and since when, after its decision (D52).
+      #: (Hash[String, untyped]) -> Hash[String, untyped]
+      def waiting_after(kept)
+        WaitsOn.new(@decision.fetch("waits_on", @finding.waits_on), action: kept.fetch("action"))
+               .kept_over(@finding.waiting)
+      end
+    end
+  end
+end

data/lib/principles/models/last_completed_revision.rb

@@ -0,0 +1,70 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../error"
+require_relative "audit_record"
+
+module Principles
+  # The domain logic, which loads and saves itself through data/. models/CLAUDE.md owns the boundary.
+  module Models
+    # The revision of a principle's last completed audit record when a request was printed, or nil when there was
+    # none. An assessment's basis and a correction's carry it, so either answer is refused once that record changed,
+    # by another audit completing or a member's acknowledgement, rather than replacing it and what it left open
+    # (#646, #653).
+    class LastCompletedRevision
+      #: (String?) -> void
+      def initialize(revision)
+        @revision = revision
+        freeze
+      end
+
+      # Refuses an answer of principle_id that would write changes, when record, the record now, changed since the
+      # request was printed. An answer that writes nothing, as an identical retry does, is accepted (D24).
+      #: (String, AuditRecord?, Array[untyped]) -> void
+      def confirm_writable(principle_id, record, changes)
+        confirm_unchanged(principle_id, record) unless changes.empty?
+      end
+
+      # What the block gives, judging an answer of principle_id; but when the block refuses the answer while record,
+      # the record now, changed since the request was printed, the refusal is that the request is stale, so the agent
+      # does not repair an answer it must start again (#669). An answer the block refuses is not D24's identical
+      # retry, which passed every check, so the stale refusal always wins over it.
+      #: [T] (String, AuditRecord?) { () -> T } -> T
+      def refusing_stale_first(principle_id, record, &)
+        yield
+      rescue Error
+        confirm_unchanged(principle_id, record)
+        raise
+      end
+
+      # Refuses any answer of principle_id when record, the record now, changed since the request was printed.
+      #: (String, AuditRecord?) -> void
+      def confirm_unchanged(principle_id, record)
+        last = record&.last_completed
+        return if @revision == last&.revision
+
+        raise Error.new("audit_completed_since_request",
+                        "The record of #{principle_id}'s last audit changed after this request was printed: " \
+                        "#{what_changed(last)}, and answering it would replace that record and what it left open",
+                        "To see what the record now leaves open: " \
+                        "#{Error::EXECUTABLE} list-open-findings #{principle_id}\n" \
+                        "Then start the audit again and answer the new request: " \
+                        "#{Error::EXECUTABLE} start-audit #{principle_id}")
+      end
+
+      private
+
+      # What changed the record last: its removal, the newest acknowledgement since its audit, or else the audit.
+      # Acknowledgements are dropped when a full audit completes, so any kept is newer than the audit (D33).
+      #: (AuditRecord?) -> String
+      def what_changed(last)
+        return "the record was removed" unless last
+
+        id, at = last.members.latest_acknowledgement
+        return "#{id} was acknowledged at #{at}" if id
+
+        "an audit completed at #{last.to_h.fetch("audited_at")}"
+      end
+    end
+  end
+end

data/lib/principles/models/line_span.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Principles
+  # The domain logic, which loads and saves itself through data/. models/CLAUDE.md owns the boundary.
+  module Models
+    # The lines a member spans in its file, first to last, as a LocatedText gives them, and whether the member is
+    # its whole file, so two members' spans are compared in one place.
+    class LineSpan
+      #: Integer
+      attr_reader :first_line, :last_line
+
+      #: (Integer, Integer, ?whole_file: bool) -> void
+      def initialize(first_line, last_line, whole_file: false)
+        @first_line = first_line
+        @last_line = last_line
+        @whole_file = whole_file
+        freeze
+      end
+
+      # Whether the two spans share a line.
+      #: (LineSpan) -> bool
+      def shares_a_line_with?(other)
+        first_line <= other.last_line && other.first_line <= last_line
+      end
+
+      # Whether every line of other is one of this span's lines. Lines are not text: where the two share a first or
+      # last line, a passage can start or end partway through it, so this span may not hold all of other's text.
+      #: (LineSpan) -> bool
+      def holds?(other)
+        first_line <= other.first_line && other.last_line <= last_line
+      end
+
+      # Whether this span surely holds all of other's text: it holds other's lines and is a whole file, which holds
+      # every line's text, where a passage may start or end partway through a line (#756).
+      #: (LineSpan) -> bool
+      def holds_all_text_of?(other)
+        @whole_file && holds?(other)
+      end
+
+      # Whether the two spans begin and end on the same lines. Equal lines are not equal text: a passage can end
+      # within its last line.
+      #: (LineSpan) -> bool
+      def same_lines_as?(other)
+        first_line == other.first_line && last_line == other.last_line
+      end
+    end
+  end
+end

data/lib/principles/models/loaded_files.rb

@@ -0,0 +1,60 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "member_loads"
+
+module Principles
+  # The domain logic, and the mediation of persistence. models/CLAUDE.md owns the boundary.
+  module Models
+    # The files a principle's members load, each once however many of its members it holds, since every member's
+    # loads gives its whole file's size and summing members counts a shared file once per member (second alpha
+    # user on #481, #483). Only session start loads its files together, so only those are totalled; a file that
+    # loads on files, on invocation or on delegation loads apart from the rest. A file that cannot be read has no
+    # size and is not totalled.
+    class LoadedFiles
+      # The files members load, each read whole once, as files hold it.
+      #: (Data::ProjectFiles, MapMembers, hooks: HookCommands) -> LoadedFiles
+      def self.read(files, members, hooks:)
+        new(members.paths.to_h { |path| [path, MemberLoads.of_file(files, path, hooks: hooks)] })
+      end
+
+      # loads holds each file's whole-file MemberLoads by path.
+      #: (Hash[String, MemberLoads]) -> void
+      def initialize(loads)
+        @loads = loads.select { |_path, file| file.carried? } #: Hash[String, MemberLoads]
+        freeze
+      end
+
+      # files_loaded and session_start_total, each left out when it would be empty.
+      #: () -> Hash[String, untyped]
+      def to_h
+        return {} if @loads.empty?
+
+        total = session_start_total
+        { "files_loaded" => @loads.map { |path, file| { "path" => path }.merge(file.claude_code) },
+          **(total ? { "session_start_total" => total } : {}) }
+      end
+
+      private
+
+      # The files that load whole at session start and their summed size, beside the descriptions that load at start
+      # while their bodies wait; each left out when there is none, and nil when there is neither.
+      #: () -> Hash[String, untyped]?
+      def session_start_total
+        files = summed(@loads.values.select(&:at_session_start?).map(&:size), "files", MemberLoads::FILE_SIZE_FIELDS)
+        descriptions = summed(@loads.values.map(&:description_at_start), "count", MemberLoads::DESCRIPTION_SIZE_FIELDS)
+        total = files.merge(descriptions.empty? ? {} : { "descriptions" => descriptions })
+        total unless total.empty?
+      end
+
+      # How many of sizes were measured, under counted, and their sum under each of fields; empty when none was.
+      #: (Array[Hash[String, Integer]], String, [String, String]) -> Hash[String, Integer]
+      def summed(sizes, counted, fields)
+        measured = sizes.reject(&:empty?)
+        return {} if measured.empty?
+
+        { counted => measured.size }.merge(fields.to_h { |field| [field, measured.sum { it.fetch(field) }] })
+      end
+    end
+  end
+end

data/lib/principles/models/loading_decision.rb

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../error"
+require_relative "answer_text"
+
+module Principles
+  # The domain logic, and the mediation of persistence. models/CLAUDE.md owns the boundary.
+  module Models
+    # One decision in an assessment's loading_decisions on a member the audit listed to check against the
+    # activation (#355). Whether the member should load as it does is the agent's judgement; this tool checks the
+    # decision's shape.
+    class LoadingDecision
+      # decision is as the answer gave it; index is its place in loading_decisions.
+      #: (untyped, Integer) -> void
+      def initialize(decision, index)
+        @decision = decision.is_a?(Hash) ? decision : {} #: Hash[String, untyped]
+        @index = index
+        freeze
+      end
+
+      # The member this decides, or "" when the decision names none.
+      #: () -> String
+      def member_id = @decision["member_id"].to_s
+
+      # What the record keeps of this decision once checked: its reason and the loads it accepted, from its
+      # member's row in the listing.
+      #: (Hash[String, untyped]) -> Hash[String, untyped]
+      def kept(row) = { "reason" => @decision["reason"], "loads" => row.fetch("loads") }
+
+      # Refuses the decision unless it is accepted with a one-line reason.
+      #: () -> void
+      def check
+        return if @decision["decision"] == "accepted" && AnswerText.new(@decision["reason"]).written?
+
+        raise Error.new("invalid_loading_decision",
+                        "loading_decisions[#{@index}] for #{@decision["member_id"]} needs decision accepted with a " \
+                        "reason",
+                        "Give decision accepted with a one-line reason why the member loads as it does, or, if the " \
+                        "activation is what is wrong, change it with change-activation and run start-audit again, " \
+                        "as the request's loads_to_check_instruction says; a finding decision is not built yet.")
+      end
+    end
+  end
+end