kairos-chain 3.45.0 → 3.46.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea7401710d6467287e35146c84d731c08733f184fac36be13e76de11d7af5433
-  data.tar.gz: a823ba8bf1bb1157394ff04466cdcf96c0347eee50796816fe8c2fd1d188792c
+  metadata.gz: 372dd921a298d45c97b957ae724a253bb22da73b5bb211025fe894eab5de4ff7
+  data.tar.gz: f15e37a2caeef2d4d08b92f49608aa52307b1a93124a1742d3f40c10ae145bf8
 SHA512:
-  metadata.gz: a11ba74c10eb1c56ef15b57992755083b6d36bd4fef1ea73bf1cae64afc1f07ad26f8774ee703c3c98eefa25c8a422441c5c5af032b9ae523d7518c7dc50193d
-  data.tar.gz: 26f95dd3245e9e39311349ef540954d200985a59bf9da38b3b08256d11ec50a445d60cc3f0c41538b6a0c0bfb2eb591ce742dc4523950d9ffe8f06471d22e50a
+  metadata.gz: c9fc60d9acee8dcb8b7a2bfb43021d3c8b129cb94471fe8488092683ade4755665faa72860fb8c1bed77d254e977226c3d8cd85bec4dfe95eea2d0dc12352190
+  data.tar.gz: e5769c4b23ce1daef9704423f41e097d8969f5b86442ab1592beab4e3dc7623a3a79e30aba51d7ca2d5621e55fd635db740b5489761995bc2b9b33de8eb0b80e

data/CHANGELOG.md

@@ -4,6 +4,43 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.46.0] - 2026-07-22
+
+### Synoptis — reproduction endorsement rpr-1 (AUD-L3 slice 1)
+
+Implements AUD-L3 design v0.4 (RPR-1..5, review-converged) slice 1 in the
+synoptis SkillSet. All additive: rpr-1 builds on map-1/khab-1 exactly as
+map-1 built on khab-1; no pre-existing file changed.
+
+- `conventions/rpr-1.md`: content-addressed reproduction-endorsement
+  convention — re-execution target (inputs/environment/pipeline/output
+  digests; the first three form the committed computation identification,
+  output excluded), target-bound result-free tolerance declaration
+  (bit-identity at rpr-1), reproduction endorsement carrying the adjudicated
+  verdict (reproduced / not-reproduced) and its adjudication mode
+  (hand / procedure), declaration-set assessment (order-independent, sibling
+  targets pooled by computation identification, residue disclosed), map-1 §3
+  retraction reused unchanged.
+- `reproduction.rb`: build/parse/digest for target, tolerance, endorsement
+  (closed schemas, canonical-serialization equality, refuse-not-coerce);
+  endorsement signing/verification via the unchanged map-1 §1.1 attestation
+  signature (ChainCredential); foreignness conformance check (RPR-4);
+  declaration-set assessment reporting invoked commitment (earliest
+  anterior), posterior commitments, digest-tiebroken rank, distinct-digest
+  multiplicity, and unresolved-equivalence residue.
+- `bin/rpr_verify.rb`: offline auditor verifier (target / tolerance /
+  endorsement / assess / convention). Strict intake (at most one trailing
+  LF via delete_suffix — CRLF refused), canonical base-10 numerals only,
+  exit-code discipline (0 verified/report, 1 rejected, 2 unresolvable),
+  RPR-1/RPR-4 condition disclosure in output.
+- `test/test_rpr_reproduction.rb`: 37 design-constraint assertions
+  (RPR-1..5), including presentation-order independence of the assessment
+  and rank, CRLF/padding refusal, and map-1 non-interference (75/75
+  regression green).
+
+Implementation review: 3 rounds, R3 5/5 APPROVE, zero remaining P0/P1
+(executable-probe personas; dispositions in docs/drafts/).
+
 ## [3.45.0] - 2026-07-21
 
 ### Synoptis — mutual anchoring protocol MAP-1..4 (map-1, AUD-L2)

data/lib/kairos_mcp/version.rb

@@ -1,4 +1,4 @@
 module KairosMcp
-  VERSION = "3.45.0"
+  VERSION = "3.46.0"
   CHANGELOG_URL = "https://github.com/masaomi/KairosChain_2026/blob/main/CHANGELOG.md"
 end

data/templates/skillsets/synoptis/bin/rpr_verify.rb

@@ -0,0 +1,171 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# rpr_verify — offline auditor verifier for rpr-1 reproduction-endorsement
+# artifacts (RPR-1..5, aud_l3_reproducibility_design v0.4).
+#
+# Verifies with EXACTLY the disclosed trust base: the artifacts named on the
+# command line plus the shipped rpr-1 and map-1 convention definitions. No
+# registry, no network, no operator cooperation. (Authentic chain views are
+# the caller's inputs; their integrity is the khab-1/map-1 surfaces' business.)
+#
+# Usage:
+#   rpr_verify.rb target      <target.json>
+#   rpr_verify.rb tolerance   <tolerance.json> [target.json]
+#       with target.json: additionally checks the binding matches that target.
+#   rpr_verify.rb endorsement <endorsement.json> <endorser_credential.json> <signature-hex> [operator_credential.json]
+#       with operator credential: additionally checks foreignness (RPR-4).
+#   rpr_verify.rb assess      <targets.json> <declarations.json> <invoked_tolerance_sha256> <endorsement_position>
+#       targets.json      = JSON array of target record STRINGS
+#       declarations.json = JSON array of {"tolerance": "<record string>", "position": <int>}
+#   rpr_verify.rb convention
+#       prints the shipped rpr-1 convention digest.
+#
+# Exit status: 0 = VERIFIED/REPORT, 1 = REJECTED, 2 = usage / unresolvable.
+
+require 'json'
+require 'digest'
+require_relative '../lib/synoptis/anchoring/entry'
+require_relative '../lib/synoptis/anchoring/chain_credential'
+require_relative '../lib/synoptis/anchoring/reproduction'
+
+CRED = Synoptis::Anchoring::ChainCredential
+REPRO = Synoptis::Anchoring::Reproduction
+
+def die(msg)
+  warn "rpr_verify: #{msg}"
+  exit 2
+end
+
+def reject(msg)
+  puts "REJECTED: #{msg}"
+  exit 1
+end
+
+# Read a record artifact: at most one trailing newline is tolerated (file
+# convenience); any other surrounding bytes stay in the string and fail the
+# canonical check downstream (refuse-not-coerce — a padded artifact is not
+# the canonical record).
+def read_file(path)
+  # delete_suffix, not chomp: chomp("\n") also swallows "\r\n" and a bare
+  # trailing "\r", which would coerce CRLF artifacts into canonical form.
+  File.read(path).delete_suffix("\n")
+rescue SystemCallError => e
+  die "cannot read #{path}: #{e.message}"
+end
+
+def load_json(path)
+  JSON.parse(File.read(path))
+rescue JSON::ParserError, SystemCallError => e
+  die "cannot read #{path}: #{e.message}"
+end
+
+def load_json_hash(path, label)
+  parsed = load_json(path)
+  die "#{path}: #{label} must be a JSON object, got #{parsed.class}" unless parsed.is_a?(Hash)
+  parsed
+end
+
+# Canonical base-10 numerals only: leading zeros are refused, not
+# reinterpreted (a non-canonical numeral is a malformed input, exit 2).
+def strict_int(value, label)
+  die "#{label} must be a canonical base-10 integer, got #{value.inspect}" unless value.is_a?(String) && value.match?(/\A(0|[1-9]\d*)\z/)
+  Integer(value, 10)
+end
+
+HEX64 = /\A[a-f0-9]{64}\z/
+
+mode = ARGV.shift
+
+case mode
+when 'target'
+  die 'usage: rpr_verify.rb target <target.json>' unless ARGV.size == 1
+  record = read_file(ARGV[0])
+  begin
+    REPRO.parse_target!(record)
+  rescue REPRO::ReproductionError => e
+    reject e.message
+  end
+  puts "VERIFIED: target digest #{REPRO.target_digest(record)}"
+  puts "  computation identification: #{REPRO.computation_id(record).split('|').map { |h| h[0, 12] }.join('… | ')}… (output excluded, rpr-1 §1)"
+  puts 'NOTE: binding fixes referents, never validates them (RPR-2, MPR-4).'
+
+when 'tolerance'
+  die 'usage: rpr_verify.rb tolerance <tolerance.json> [target.json]' unless (1..2).cover?(ARGV.size)
+  record = read_file(ARGV[0])
+  tol = begin
+    REPRO.parse_tolerance!(record)
+  rescue REPRO::ReproductionError => e
+    reject e.message
+  end
+  if ARGV[1]
+    target = read_file(ARGV[1])
+    begin
+      digest = REPRO.target_digest(target)
+    rescue REPRO::ReproductionError => e
+      reject e.message
+    end
+    reject "tolerance binds target #{tol['target_sha256'][0, 12]}…, not the supplied target #{digest[0, 12]}…" unless tol['target_sha256'] == digest
+  end
+  puts "VERIFIED: tolerance digest #{Digest::SHA256.hexdigest(record)} (kind #{tol['kind']}, target #{tol['target_sha256'][0, 12]}…)"
+  puts 'NOTE: anteriority to any endorsement is decided by committed order (MPR-8), not by this tool.'
+
+when 'endorsement'
+  die 'usage: rpr_verify.rb endorsement <endorsement.json> <endorser_credential.json> <signature-hex> [operator_credential.json]' unless (3..4).cover?(ARGV.size)
+  record = read_file(ARGV[0])
+  cred = load_json_hash(ARGV[1], 'endorser credential')
+  ok = begin
+    REPRO.verify_endorsement(record, cred, ARGV[2])
+  rescue REPRO::ReproductionError, CRED::CredentialError => e
+    reject e.message
+  end
+  reject 'endorsement signature does not verify under the endorser credential' unless ok
+  e = REPRO.parse_endorsement!(record)
+  if ARGV[3]
+    operator = load_json_hash(ARGV[3], 'operator credential')
+    begin
+      reject 'endorser credential equals operator credential — same-party, not a conforming rpr-1 endorsement (RPR-4)' unless REPRO.foreign?(cred, operator)
+    rescue CRED::CredentialError => err
+      # An unresolvable operator credential is a caller-input problem, not a
+      # verdict about the endorsement (exit-code discipline: 2, not 1).
+      die "operator credential unresolvable: #{err.message}"
+    end
+  end
+  puts "VERIFIED: #{e['verdict']} endorsement of target #{e['target_sha256'][0, 12]}… under tolerance #{e['tolerance_sha256'][0, 12]}…"
+  puts "  adjudication mode: #{e['adjudication_mode']}#{e['procedure_sha256'] ? " (procedure #{e['procedure_sha256'][0, 12]}…)" : ''}"
+  puts 'CONDITIONS (travel with every stronger reading, rpr-1 §3):'
+  puts '  - the verdict asserts reproduction or its failure, never correctness (RPR-1, MPR-6)'
+  puts '  - evidence of a committed claim, never proof a re-execution happened (RPR-4)'
+  puts '  - distinctness is not independence; a colluding pair can fabricate (RPR-4)'
+  puts '  - the named mode is a declaration, not a proof (map-1 §3 non-self-certifying)'
+  if ARGV[3]
+    puts '  - foreignness checked against the SUPPLIED operator credential only'
+  else
+    puts '  - foreignness (RPR-4 conformance condition) NOT assessed — no operator credential supplied'
+  end
+
+when 'assess'
+  die 'usage: rpr_verify.rb assess <targets.json> <declarations.json> <invoked_tolerance_sha256> <endorsement_position>' unless ARGV.size == 4
+  targets = load_json(ARGV[0])
+  die "#{ARGV[0]}: expected a JSON array of target record strings" unless targets.is_a?(Array) && targets.all? { |t| t.is_a?(String) }
+  declarations = load_json(ARGV[1])
+  die "#{ARGV[1]}: expected a JSON array of {tolerance, position} objects" unless declarations.is_a?(Array)
+  invoked = ARGV[2]
+  die 'invoked_tolerance_sha256 must be 64-char lowercase hex' unless invoked.match?(HEX64)
+  position = strict_int(ARGV[3], 'endorsement_position')
+  begin
+    report = REPRO.assess_declarations(targets: targets, declarations: declarations,
+                                       invoked_tolerance_sha256: invoked, endorsement_position: position)
+  rescue REPRO::ReproductionError => e
+    reject e.message
+  end
+  puts JSON.pretty_generate(report)
+  puts 'NOTE: the assessment reports, the reader prices (RPR-3: exposure, not prevention).'
+  puts 'NOTE: a produced report always exits 0; the conformance bit is invoked_conforming in the report.'
+
+when 'convention'
+  puts "rpr-1 convention sha256: #{REPRO.convention_sha256}"
+
+else
+  die 'usage: rpr_verify.rb target|tolerance|endorsement|assess|convention ... (see header)'
+end

data/templates/skillsets/synoptis/lib/synoptis/anchoring/conventions/rpr-1.md

@@ -0,0 +1,141 @@
+# rpr-1 — KairosChain Reproduction Endorsement Convention, version 1
+
+Status: committed verification convention (RPR-1..5 of
+aud_l3_reproducibility_design v0.4). The SHA-256 over this file's raw bytes is
+the convention integrity digest; every artifact that names `rpr-1` commits it
+as its convention reference. A verifier holding a definition whose digest does
+not match the committed one MUST treat the artifact's convention as
+unresolvable and refuse to verify under it. Any change to this convention is a
+new identifier (`rpr-2`, ...); this file is never edited in place.
+rpr-1 builds on map-1 (credentials, attestation signatures, attestation types,
+retraction) and khab-1 (committed identity, committed order) and modifies
+neither: a map-1 artifact is valid with or without any rpr-1 artifact present.
+
+All record literals below are canonical JSON (keys sorted recursively,
+`JSON.generate` compact form). A record is valid only in its canonical
+serialization with exactly the fields shown — a non-canonical or extra-field
+record is not an rpr-1 artifact and is ignored as noise (map-1 §4 precedent).
+
+## 1. Re-execution target (RPR-2)
+
+    {"environment_sha256":"<64-hex>","format":"rpr-1/target",
+     "input_sha256":"<64-hex>","output_sha256":"<64-hex>",
+     "pipeline_sha256":"<64-hex>"}
+
+The target commits both halves of the verdict's referent: what is re-run
+(inputs, environment, pipeline version) and what the re-run output is judged
+against (the committed output). The first three digests — `input_sha256`,
+`environment_sha256`, `pipeline_sha256` — constitute the target's **committed
+computation identification** (design §3(b)): the identification of what is
+re-run, which two targets can share while naming different committed outputs.
+`output_sha256` completes the target but does not participate in that
+identification. The target digest is the SHA-256 of the target's canonical
+JSON. What the digests are digests OF (file formats, environment pinning,
+pipeline identity) is the referenced material's business; rpr-1 commits
+references, it does not validate referents (MPR-4 asymmetry, RPR-2 limit).
+
+## 2. Tolerance declaration (RPR-3)
+
+    {"format":"rpr-1/tolerance","kind":"bit-identity","target_sha256":"<64-hex>"}
+
+A tolerance declaration is bound to a named target and is result-free by
+construction: the schema is closed and `kind` is the only expressive field, so
+no outcome-referencing content can be expressed. At rpr-1 the only kind is
+`bit-identity` (re-run output matches the committed output byte for byte);
+richer tolerance grammars (numerical bounds, domain equivalence) are a new
+convention — this narrowness is disclosed, not hidden. The declaration is
+committed as an internal-chain record ahead of the endorsements it governs;
+committed position provides decidable anteriority (MPR-8). One declaration has
+exactly one digest (canonical serialization).
+
+### 2.1 Declaration-set assessment (RPR-3)
+
+Conformance of an endorsement's tolerance is assessed against the record, not
+the endorser's selection. Given target records, tolerance declarations with
+their committed positions, and the endorsement's committed position, the
+assessment reports:
+
+- every anterior declaration bound to the endorsement's target;
+- every anterior declaration bound to any sibling target sharing the same
+  committed computation identification (§1) — a menu spread across
+  near-duplicate targets is the same menu and is read as one set (at rpr-1,
+  sharing = equality of the three computation-identification digests);
+- the multiplicity of that pooled set and the invoked declaration's place in
+  it;
+- the unresolved residue: declarations whose `target_sha256` resolves to no
+  supplied target record (sharing undecidable there), disclosed rather than
+  silently dropped.
+
+The assessment reports; the reader prices. A verdict judged under one of many
+anterior declarations is conforming and wears the multiplicity openly; a
+tolerance chosen after the result is non-conforming (its posteriority is
+decidable from committed order). The assessment is a function of the committed
+record alone, never of presentation order: a declaration committed at several
+positions is one declaration (one digest) with several commitments; the
+invoked declaration conforms iff any of its commitments is anterior,
+represented by the earliest, with posterior commitments disclosed alongside;
+multiplicity counts distinct declarations, and the invoked declaration's
+place is reported as its rank in the pooled anterior set ordered by earliest
+anterior position, with equal positions ordered by declaration digest — so
+every reported quantity, ranks included, is decidable from the committed
+record alone.
+
+## 3. Reproduction endorsement (RPR-1, RPR-4)
+
+hand-adjudicated:
+
+    {"adjudication_mode":"hand","format":"rpr-1/endorsement",
+     "target_sha256":"<64-hex>","tolerance_sha256":"<64-hex>",
+     "verdict":"reproduced"}
+
+procedure-adjudicated:
+
+    {"adjudication_mode":"procedure","format":"rpr-1/endorsement",
+     "procedure_sha256":"<64-hex>","target_sha256":"<64-hex>",
+     "tolerance_sha256":"<64-hex>","verdict":"not-reproduced"}
+
+`verdict` is `reproduced` or `not-reproduced`: the affirmative and the
+negative verdict are the same kind of record under the same bindings, so the
+record has a conforming place for failure as well as success (RPR-1).
+`adjudication_mode` names the gate behind the verdict (RPR-4): `hand`, or
+`procedure` with `procedure_sha256` naming the committed adjudication
+procedure whose anterior adoption is the judgment act. `procedure_sha256` is
+present exactly when the mode is `procedure` (closed schema per mode). The
+named mode, like the attestation type itself, is a declaration and not a
+proof (map-1 §3 non-self-certifying).
+
+The endorsement is signed under the endorser's map-1 credential using the
+map-1 §1.1 attestation signature, with the payload being the endorsement
+record string. Verification needs only the credential, the record, and the
+signature. The endorsement is carried with `attestation_type` =
+`quality-endorsement` (map-1 §3, unchanged).
+
+Foreignness (RPR-4) is a conformance condition: an endorsement whose issuer
+credential digest equals the operator credential digest for the target's
+chain is not a conforming rpr-1 endorsement, whatever else it may be as an
+ordinary same-party claim. Distinctness is not independence: a colluding pair
+can fabricate an endorsement, affirmative or negative, without any run having
+occurred — the endorsement is evidence of a committed claim, never proof that
+a re-execution happened (RPR-4 disclosed limit).
+
+What a verified endorsement asserts is exactly: this endorser claimed, at a
+committed moment, that the target was re-run and its output did or did not
+match the target's committed output within the named tolerance — and nothing
+else. No claim of correctness, validity, fitness, or significance (RPR-1,
+MPR-6); absence of any endorsement proves nothing (MPR-9 non-production).
+
+## 4. Retraction (RPR-5)
+
+A mistaken endorsement is withdrawn by the map-1 §3 `retraction` unchanged:
+same issuer, unambiguous target, appended. A retracted endorsement still
+stands as a committed record that the verdict was once claimed and later
+taken back; nothing is unsaid by deletion and no anchored commitment's
+coverage is subtracted (AHM-4).
+
+## 5. Verification procedure and trust base
+
+All rpr-1 verification needs only: the artifacts named above, this
+definition, the map-1 definition (for credentials, signatures, types, and
+retraction), and authentic views of the logs/chains the artifacts reference.
+No registry, no network, no operator cooperation for verification —
+production of artifacts remains the endorser's act (MPR-4 asymmetry).

data/templates/skillsets/synoptis/lib/synoptis/anchoring/reproduction.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+require_relative 'entry'
+require_relative 'chain_credential'
+
+module Synoptis
+  module Anchoring
+    # Reproduction endorsement artifacts (aud_l3_reproducibility_design v0.4,
+    # RPR-1..5) under the rpr-1 convention: re-execution target, tolerance
+    # declaration, reproduction endorsement, and the declaration-set
+    # assessment. rpr-1 builds on map-1 (credentials, §1.1 attestation
+    # signatures, types, retraction) and modifies nothing there: signing and
+    # verification are ChainCredential calls, retraction is the map-1 §3 act
+    # unchanged. Refuse-not-coerce for authored artifacts; the assessment is
+    # diagnostic and reports rather than enforces (RPR-3: exposure, not
+    # prevention).
+    module Reproduction
+      CONVENTION_ID = 'rpr-1'
+      CONVENTION_PATH = File.expand_path('conventions/rpr-1.md', __dir__)
+      TARGET_FORMAT = 'rpr-1/target'
+      TOLERANCE_FORMAT = 'rpr-1/tolerance'
+      ENDORSEMENT_FORMAT = 'rpr-1/endorsement'
+      TOLERANCE_KINDS = %w[bit-identity].freeze
+      VERDICTS = %w[reproduced not-reproduced].freeze
+      MODES = %w[hand procedure].freeze
+      HEX_DIGEST = /\A[a-f0-9]{64}\z/
+
+      # Exactly these fields, sorted (closed schemas; extension = rpr-2).
+      TARGET_FIELDS = %w[environment_sha256 format input_sha256 output_sha256 pipeline_sha256].freeze
+      # The first three digests in field-name-independent terms: what is
+      # re-run. output_sha256 completes the target but is OUTSIDE the
+      # committed computation identification (design §3(b)).
+      COMPUTATION_ID_FIELDS = %w[environment_sha256 input_sha256 pipeline_sha256].freeze
+      TOLERANCE_FIELDS = %w[format kind target_sha256].freeze
+      ENDORSEMENT_FIELDS_HAND = %w[adjudication_mode format target_sha256 tolerance_sha256 verdict].freeze
+      ENDORSEMENT_FIELDS_PROCEDURE = %w[adjudication_mode format procedure_sha256 target_sha256 tolerance_sha256 verdict].freeze
+
+      class ReproductionError < StandardError; end
+
+      module_function
+
+      # SHA-256 of the shipped rpr-1 convention definition's raw bytes.
+      def convention_sha256
+        @convention_sha256 ||= begin
+          Digest::SHA256.hexdigest(File.binread(CONVENTION_PATH))
+        rescue SystemCallError => e
+          raise ReproductionError, "rpr-1 convention definition unreadable at #{CONVENTION_PATH}: #{e.message}"
+        end
+      end
+
+      # -- re-execution target (rpr-1 §1, RPR-2) --
+
+      def build_target(input_sha256:, environment_sha256:, pipeline_sha256:, output_sha256:)
+        record = {
+          'environment_sha256' => environment_sha256,
+          'format' => TARGET_FORMAT,
+          'input_sha256' => input_sha256,
+          'output_sha256' => output_sha256,
+          'pipeline_sha256' => pipeline_sha256
+        }
+        %w[input_sha256 environment_sha256 pipeline_sha256 output_sha256].each do |k|
+          unless record[k].is_a?(String) && record[k].match?(HEX_DIGEST)
+            raise ReproductionError, "target.#{k} must be 64-char lowercase hex, got #{record[k].inspect}"
+          end
+        end
+        Entry.canonical_json(record)
+      end
+
+      def parse_target!(target_string)
+        parse_record!(target_string, TARGET_FORMAT, TARGET_FIELDS, 'target') do |t|
+          (TARGET_FIELDS - %w[format]).each do |k|
+            raise ReproductionError, "target.#{k} must be 64-char lowercase hex" unless t[k].is_a?(String) && t[k].match?(HEX_DIGEST)
+          end
+        end
+      end
+
+      def target_digest(target_string)
+        parse_target!(target_string)
+        Digest::SHA256.hexdigest(target_string.to_s)
+      end
+
+      # The committed computation identification (design §3(b)): the first
+      # three digests. Two targets SHARE a computation iff these are equal;
+      # output_sha256 never participates.
+      def computation_id(target_string)
+        t = parse_target!(target_string)
+        COMPUTATION_ID_FIELDS.map { |k| t[k] }.join('|')
+      end
+
+      # -- tolerance declaration (rpr-1 §2, RPR-3) --
+
+      def build_tolerance(target_sha256:, kind: 'bit-identity')
+        raise ReproductionError, "tolerance.kind must be one of #{TOLERANCE_KINDS.join(', ')}, got #{kind.inspect}" unless TOLERANCE_KINDS.include?(kind.to_s)
+        unless target_sha256.is_a?(String) && target_sha256.match?(HEX_DIGEST)
+          raise ReproductionError, 'tolerance.target_sha256 must be 64-char lowercase hex'
+        end
+
+        Entry.canonical_json('format' => TOLERANCE_FORMAT, 'kind' => kind.to_s, 'target_sha256' => target_sha256)
+      end
+
+      def parse_tolerance!(tolerance_string)
+        parse_record!(tolerance_string, TOLERANCE_FORMAT, TOLERANCE_FIELDS, 'tolerance') do |t|
+          raise ReproductionError, "tolerance.kind must be one of #{TOLERANCE_KINDS.join(', ')}" unless TOLERANCE_KINDS.include?(t['kind'])
+          unless t['target_sha256'].is_a?(String) && t['target_sha256'].match?(HEX_DIGEST)
+            raise ReproductionError, 'tolerance.target_sha256 must be 64-char lowercase hex'
+          end
+        end
+      end
+
+      def tolerance_digest(tolerance_string)
+        parse_tolerance!(tolerance_string)
+        Digest::SHA256.hexdigest(tolerance_string.to_s)
+      end
+
+      # -- reproduction endorsement (rpr-1 §3, RPR-1/RPR-4) --
+
+      def build_endorsement(target_sha256:, tolerance_sha256:, verdict:, adjudication_mode:, procedure_sha256: nil)
+        mode = adjudication_mode.to_s
+        raise ReproductionError, "verdict must be one of #{VERDICTS.join(', ')}, got #{verdict.inspect}" unless VERDICTS.include?(verdict.to_s)
+        raise ReproductionError, "adjudication_mode must be one of #{MODES.join(', ')}, got #{mode.inspect}" unless MODES.include?(mode)
+
+        record = {
+          'adjudication_mode' => mode,
+          'format' => ENDORSEMENT_FORMAT,
+          'target_sha256' => target_sha256,
+          'tolerance_sha256' => tolerance_sha256,
+          'verdict' => verdict.to_s
+        }
+        if mode == 'procedure'
+          unless procedure_sha256.is_a?(String) && procedure_sha256.match?(HEX_DIGEST)
+            raise ReproductionError, 'procedure mode requires procedure_sha256 as 64-char lowercase hex (RPR-4: the adopted procedure is named)'
+          end
+          record['procedure_sha256'] = procedure_sha256
+        elsif !procedure_sha256.nil?
+          raise ReproductionError, 'hand mode must not carry procedure_sha256 (closed schema per mode)'
+        end
+        %w[target_sha256 tolerance_sha256].each do |k|
+          raise ReproductionError, "endorsement.#{k} must be 64-char lowercase hex" unless record[k].is_a?(String) && record[k].match?(HEX_DIGEST)
+        end
+        Entry.canonical_json(record)
+      end
+
+      def parse_endorsement!(endorsement_string)
+        parsed = json_object!(endorsement_string, 'endorsement')
+        e = parsed.transform_keys(&:to_s)
+        raise ReproductionError, "unknown format #{e['format'].inspect} (#{ENDORSEMENT_FORMAT} only)" unless e['format'] == ENDORSEMENT_FORMAT
+        raise ReproductionError, "adjudication_mode must be one of #{MODES.join(', ')}" unless MODES.include?(e['adjudication_mode'])
+
+        expected = e['adjudication_mode'] == 'procedure' ? ENDORSEMENT_FIELDS_PROCEDURE : ENDORSEMENT_FIELDS_HAND
+        keys = e.keys.sort
+        raise ReproductionError, "endorsement fields must be exactly #{expected.join(', ')}, got #{keys.join(', ')}" unless keys == expected
+        raise ReproductionError, "verdict must be one of #{VERDICTS.join(', ')}" unless VERDICTS.include?(e['verdict'])
+        (expected - %w[format verdict adjudication_mode]).each do |k|
+          raise ReproductionError, "endorsement.#{k} must be 64-char lowercase hex" unless e[k].is_a?(String) && e[k].match?(HEX_DIGEST)
+        end
+        unless Entry.canonical_json(e) == endorsement_string.to_s
+          raise ReproductionError, 'endorsement is not in canonical serialization (one record, one digest)'
+        end
+
+        e
+      end
+
+      # Sign an endorsement under the endorser's map-1 credential (map-1 §1.1
+      # attestation signature; the payload is the endorsement record string).
+      def sign_endorsement(endorsement_string, credential, key)
+        parse_endorsement!(endorsement_string)
+        ChainCredential.sign_attestation(credential, key, endorsement_string.to_s)
+      end
+
+      # Verify signature + structure. Returns true/false for the signature;
+      # malformed endorsement raises (a verdict about an unresolvable record
+      # would be noise dressed as judgment).
+      def verify_endorsement(endorsement_string, credential, signature_hex)
+        parse_endorsement!(endorsement_string)
+        ChainCredential.verify_attestation(credential, endorsement_string.to_s, signature_hex)
+      end
+
+      # Foreignness conformance (RPR-4): a conforming rpr-1 endorsement's
+      # issuer credential is NOT the operator credential of the chain the
+      # target belongs to. Digest equality is the decidable surface at rpr-1;
+      # distinctness is not independence (disclosed in the convention).
+      def foreign?(endorser_credential, operator_credential)
+        ChainCredential.credential_digest(endorser_credential) !=
+          ChainCredential.credential_digest(operator_credential)
+      end
+
+      # -- declaration-set assessment (rpr-1 §2.1, RPR-3) --
+      #
+      # +targets+       Array of target record STRINGS (the resolvable universe).
+      # +declarations+  Array of {'tolerance' => record string, 'position' => Integer}.
+      # +invoked_tolerance_sha256+  digest the endorsement names.
+      # +endorsement_position+      committed position of the endorsement.
+      #
+      # Reports the pooled anterior declaration set for the endorsement's
+      # target AND its computation-identification siblings, multiplicity, the
+      # invoked declaration's standing, and the unresolved residue. Diagnostic:
+      # malformed declarations land in the residue, never raise.
+      def assess_declarations(targets:, declarations:, invoked_tolerance_sha256:, endorsement_position:)
+        pos = endorsement_position
+        raise ReproductionError, 'endorsement_position must be an Integer' unless pos.is_a?(Integer)
+
+        by_digest = {}
+        Array(targets).each do |t|
+          by_digest[Digest::SHA256.hexdigest(t.to_s)] = computation_id(t)
+        rescue ReproductionError
+          next # an unparsable target resolves nothing; bindings to it fall to residue
+        end
+
+        pooled = []
+        residue = []
+        seen = {}
+        Array(declarations).each do |d|
+          h = d.is_a?(Hash) ? d.transform_keys(&:to_s) : {}
+          decl = h['tolerance'].to_s
+          position = h['position']
+          digest = Digest::SHA256.hexdigest(decl)
+          begin
+            t = parse_tolerance!(decl)
+          rescue ReproductionError => e
+            residue << { tolerance_sha256: digest, reason: "malformed declaration: #{e.message}" }
+            next
+          end
+          unless position.is_a?(Integer)
+            residue << { tolerance_sha256: digest, reason: 'no committed position supplied (anteriority undecidable)' }
+            next
+          end
+          # A commitment is (digest, position); the same pair supplied twice is
+          # one commitment, not two (one declaration, one digest — rpr-1 §2).
+          next if seen[[digest, position]]
+
+          seen[[digest, position]] = true
+          comp = by_digest[t['target_sha256']]
+          if comp.nil?
+            residue << { tolerance_sha256: digest, target_sha256: t['target_sha256'],
+                         reason: 'target unresolvable in supplied view (computation sharing undecidable)' }
+            next
+          end
+          pooled << { tolerance_sha256: digest, target_sha256: t['target_sha256'],
+                      computation_id: comp, position: position, anterior: position < pos }
+        end
+
+        # The invoked digest may be committed at several positions; anteriority
+        # is a property of the committed record, not of presentation order
+        # (RPR-3): conforming iff ANY anterior commitment exists, represented
+        # by the earliest one, with posterior commitments disclosed.
+        invoked_commitments = pooled.select { |e| e[:tolerance_sha256] == invoked_tolerance_sha256 }
+        invoked_anterior = invoked_commitments.select { |e| e[:anterior] }.min_by { |e| e[:position] }
+        invoked = invoked_anterior || invoked_commitments.min_by { |e| e[:position] }
+        invoked_posterior = invoked_commitments.reject { |e| e[:anterior] }
+
+        invoked_comp = invoked && invoked[:computation_id]
+        set = invoked_comp.nil? ? [] : pooled.select { |e| e[:computation_id] == invoked_comp && e[:anterior] }
+        # Deterministic report order (position, then digest): the report's
+        # bytes, not just its quantities, are presentation-order-free.
+        set = set.sort_by { |e| [e[:position], e[:tolerance_sha256]] }
+        # Multiplicity counts distinct declarations (digests), not commitments;
+        # rank is the invoked declaration's place in the pooled anterior set,
+        # ordered by each declaration's earliest anterior position (rpr-1 §2.1).
+        earliest = set.group_by { |e| e[:tolerance_sha256] }.transform_values { |es| es.map { |e| e[:position] }.min }
+        # Digest tiebreak: equal earliest positions must not fall back to hash
+        # insertion (= presentation) order — the rank, like the verdict, is a
+        # function of the committed record alone (rpr-1 §2.1).
+        ranked = earliest.sort_by { |d, p| [p, d] }.map(&:first)
+        rank = invoked_anterior && (ranked.index(invoked_tolerance_sha256) + 1)
+        {
+          invoked: invoked,
+          invoked_conforming: !invoked_anterior.nil?,
+          invoked_posterior: invoked_posterior,
+          invoked_rank: rank,
+          declaration_set: set,
+          multiplicity: ranked.size,
+          residue: residue,
+          note: if invoked.nil?
+                  'invoked tolerance not found among supplied declarations (or unresolvable); nothing to assess'
+                elsif invoked_anterior.nil?
+                  'no anterior commitment of the invoked tolerance (RPR-3: non-conforming)'
+                elsif ranked.size > 1
+                  "#{ranked.size} anterior declaration(s) share the invoked computation identification; the menu is visible and priced by the reader (RPR-3)"
+                else
+                  'single anterior declaration for this computation'
+                end
+        }
+      end
+
+      # -- internal helpers --
+
+      def json_object!(string, label)
+        parsed = begin
+          JSON.parse(string.to_s)
+        rescue JSON::ParserError => e
+          raise ReproductionError, "#{label} is not valid JSON: #{e.message}"
+        end
+        raise ReproductionError, "#{label} must be a JSON object, got #{parsed.class}" unless parsed.is_a?(Hash)
+
+        parsed
+      end
+
+      def parse_record!(string, format, fields, label)
+        parsed = json_object!(string, label)
+        r = parsed.transform_keys(&:to_s)
+        keys = r.keys.sort
+        raise ReproductionError, "#{label} fields must be exactly #{fields.join(', ')}, got #{keys.join(', ')}" unless keys == fields
+        raise ReproductionError, "unknown format #{r['format'].inspect} (#{format} only)" unless r['format'] == format
+
+        yield r if block_given?
+        unless Entry.canonical_json(r) == string.to_s
+          raise ReproductionError, "#{label} is not in canonical serialization (one record, one digest)"
+        end
+
+        r
+      end
+    end
+  end
+end

data/templates/skillsets/synoptis/test/test_rpr_reproduction.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+# Design-constraint tests for the AUD-L3 reproduction-endorsement slice
+# (aud_l3_reproducibility_design v0.4, freeze candidate; invariants RPR-1..5).
+# Each block names the invariant whose implementable consequence it pins.
+
+require 'json'
+require 'digest'
+
+anchoring = File.expand_path('../lib/synoptis/anchoring', __dir__)
+require File.join(anchoring, 'entry')
+require File.join(anchoring, 'chain_credential')
+require File.join(anchoring, 'attestation_types')
+require File.join(anchoring, 'reproduction')
+
+Entry = Synoptis::Anchoring::Entry
+Cred = Synoptis::Anchoring::ChainCredential
+AType = Synoptis::Anchoring::AttestationTypes
+Repro = Synoptis::Anchoring::Reproduction
+
+$pass = 0
+$fail = 0
+
+def assert(condition, message)
+  if condition
+    $pass += 1
+    puts "  PASS: #{message}"
+  else
+    $fail += 1
+    puts "  FAIL: #{message}"
+  end
+end
+
+def assert_raises(klass, message)
+  yield
+  assert(false, "#{message} (no exception raised)")
+rescue klass
+  assert(true, message)
+rescue StandardError => e
+  assert(false, "#{message} (raised #{e.class}: #{e.message})")
+end
+
+HEX_A = 'a' * 64
+HEX_B = 'b' * 64
+HEX_C = 'c' * 64
+HEX_D = 'd' * 64
+HEX_E = 'e' * 64
+
+OPERATOR_IDENTITY = "block1-sha256:#{'1' * 64}"
+ENDORSER_IDENTITY = "block1-sha256:#{'2' * 64}"
+OPERATOR_KEY = Cred.generate_key
+ENDORSER_KEY = Cred.generate_key
+OPERATOR_CRED = Cred.build(OPERATOR_IDENTITY, OPERATOR_KEY)
+ENDORSER_CRED = Cred.build(ENDORSER_IDENTITY, ENDORSER_KEY)
+
+puts '== rpr-1 convention is content-addressed =='
+
+assert(Repro.convention_sha256.match?(/\A[a-f0-9]{64}\z/), 'rpr-1 convention digest is 64-hex (content-addressed)')
+
+puts '== RPR-2: re-execution target, output included, closed schema =='
+
+target = Repro.build_target(input_sha256: HEX_A, environment_sha256: HEX_B,
+                            pipeline_sha256: HEX_C, output_sha256: HEX_D)
+assert(Repro.parse_target!(target).is_a?(Hash), 'a built target parses (canonical, exact fields)')
+assert(Repro.target_digest(target).match?(/\A[a-f0-9]{64}\z/), 'target digest is 64-hex of canonical JSON')
+
+assert_raises(Repro::ReproductionError, 'extra field is refused, not coerced (closed schema)') do
+  extra = JSON.parse(target).merge('note' => 'x')
+  Repro.parse_target!(Entry.canonical_json(extra))
+end
+
+assert_raises(Repro::ReproductionError, 'non-canonical serialization is refused (one record, one digest)') do
+  Repro.parse_target!(JSON.pretty_generate(JSON.parse(target)))
+end
+
+assert_raises(Repro::ReproductionError, 'mutable/uncommitted referent (bad hex) is refused (RPR-2)') do
+  Repro.build_target(input_sha256: 'not-a-digest', environment_sha256: HEX_B,
+                     pipeline_sha256: HEX_C, output_sha256: HEX_D)
+end
+
+puts '== §3(b): computation identification excludes the output digest =='
+
+sibling = Repro.build_target(input_sha256: HEX_A, environment_sha256: HEX_B,
+                             pipeline_sha256: HEX_C, output_sha256: HEX_E)
+other = Repro.build_target(input_sha256: HEX_E, environment_sha256: HEX_B,
+                           pipeline_sha256: HEX_C, output_sha256: HEX_D)
+assert(Repro.computation_id(target) == Repro.computation_id(sibling),
+       'targets differing only in output share the computation identification')
+assert(Repro.computation_id(target) != Repro.computation_id(other),
+       'targets differing in input do not share the computation identification')
+assert(Repro.target_digest(target) != Repro.target_digest(sibling),
+       'sibling targets remain distinct targets (identification is coarser than identity)')
+
+puts '== RPR-3: tolerance is target-bound, result-free, closed schema =='
+
+tol = Repro.build_tolerance(target_sha256: Repro.target_digest(target))
+assert(Repro.parse_tolerance!(tol)['kind'] == 'bit-identity', 'rpr-1 tolerance kind is bit-identity (narrowness disclosed)')
+assert(Repro.parse_tolerance!(tol)['target_sha256'] == Repro.target_digest(target), 'tolerance binds its target by digest')
+
+assert_raises(Repro::ReproductionError, 'unknown tolerance kind is refused (closed schema = result-free by construction)') do
+  Repro.build_tolerance(target_sha256: Repro.target_digest(target), kind: 'whatever-fits')
+end
+
+puts '== RPR-1: verdict both ways, nothing else =='
+
+endo = Repro.build_endorsement(target_sha256: Repro.target_digest(target),
+                               tolerance_sha256: Repro.tolerance_digest(tol),
+                               verdict: 'reproduced', adjudication_mode: 'hand')
+nendo = Repro.build_endorsement(target_sha256: Repro.target_digest(target),
+                                tolerance_sha256: Repro.tolerance_digest(tol),
+                                verdict: 'not-reproduced', adjudication_mode: 'hand')
+assert(Repro.parse_endorsement!(endo)['verdict'] == 'reproduced', 'affirmative verdict is a conforming record')
+assert(Repro.parse_endorsement!(nendo)['verdict'] == 'not-reproduced', 'negative verdict is the same kind of record (RPR-1: no publication bias by vocabulary)')
+
+assert_raises(Repro::ReproductionError, 'a verdict outside reproduced/not-reproduced is refused') do
+  Repro.build_endorsement(target_sha256: Repro.target_digest(target),
+                          tolerance_sha256: Repro.tolerance_digest(tol),
+                          verdict: 'correct', adjudication_mode: 'hand')
+end
+
+puts '== RPR-4: adjudication mode is named, per mode closed schema =='
+
+pendo = Repro.build_endorsement(target_sha256: Repro.target_digest(target),
+                                tolerance_sha256: Repro.tolerance_digest(tol),
+                                verdict: 'reproduced', adjudication_mode: 'procedure',
+                                procedure_sha256: HEX_E)
+assert(Repro.parse_endorsement!(pendo)['procedure_sha256'] == HEX_E, 'procedure mode names the adopted procedure')
+
+assert_raises(Repro::ReproductionError, 'procedure mode without procedure_sha256 is refused (gate must be readable)') do
+  Repro.build_endorsement(target_sha256: Repro.target_digest(target),
+                          tolerance_sha256: Repro.tolerance_digest(tol),
+                          verdict: 'reproduced', adjudication_mode: 'procedure')
+end
+
+assert_raises(Repro::ReproductionError, 'hand mode carrying procedure_sha256 is refused (closed schema per mode)') do
+  Repro.build_endorsement(target_sha256: Repro.target_digest(target),
+                          tolerance_sha256: Repro.tolerance_digest(tol),
+                          verdict: 'reproduced', adjudication_mode: 'hand',
+                          procedure_sha256: HEX_E)
+end
+
+puts '== map-1 §1.1 signature reuse: sign/verify endorsement =='
+
+sig = Repro.sign_endorsement(endo, ENDORSER_CRED, ENDORSER_KEY)
+assert(Repro.verify_endorsement(endo, ENDORSER_CRED, sig), 'endorsement verifies with credential+record+signature only (MAP-2 self-authentication)')
+assert(!Repro.verify_endorsement(nendo, ENDORSER_CRED, sig), 'signature does not transfer to a different verdict record')
+assert(!Repro.verify_endorsement(endo, OPERATOR_CRED, sig), 'signature does not verify under a foreign credential')
+
+puts '== RPR-4: foreignness is a conformance condition =='
+
+assert(Repro.foreign?(ENDORSER_CRED, OPERATOR_CRED), 'distinct endorser credential is foreign (conforming)')
+assert(!Repro.foreign?(OPERATOR_CRED, OPERATOR_CRED), 'operator self-endorsement is not foreign (non-conforming as rpr-1)')
+
+puts '== RPR-3: declaration-set assessment (menu + siblings + residue) =='
+
+tol_sib = Repro.build_tolerance(target_sha256: Repro.target_digest(sibling))
+tol_other = Repro.build_tolerance(target_sha256: Repro.target_digest(other))
+tol_orphan = Repro.build_tolerance(target_sha256: HEX_E) # target not in supplied view
+
+report = Repro.assess_declarations(
+  targets: [target, sibling, other],
+  declarations: [
+    { 'tolerance' => tol, 'position' => 10 },
+    { 'tolerance' => tol_sib, 'position' => 11 },
+    { 'tolerance' => tol_other, 'position' => 12 },
+    { 'tolerance' => tol_orphan, 'position' => 13 }
+  ],
+  invoked_tolerance_sha256: Repro.tolerance_digest(tol),
+  endorsement_position: 20
+)
+assert(report[:invoked_conforming], 'anterior invoked tolerance is conforming (RPR-3)')
+assert(report[:multiplicity] == 2, 'sibling-target declaration pools into the same set (target-splitting exposed)')
+assert(report[:declaration_set].none? { |e| e[:target_sha256] == Repro.target_digest(other) },
+       'a different computation does not pool into the set')
+assert(report[:residue].size == 1 && report[:residue][0][:reason].include?('unresolvable'),
+       'unresolvable target binding is disclosed as residue, not silently dropped')
+
+posterior = Repro.assess_declarations(
+  targets: [target],
+  declarations: [{ 'tolerance' => tol, 'position' => 30 }],
+  invoked_tolerance_sha256: Repro.tolerance_digest(tol),
+  endorsement_position: 20
+)
+assert(!posterior[:invoked_conforming], 'a tolerance committed after the endorsement is non-conforming (anteriority, MPR-8)')
+
+puts '== RPR-3: assessment is order-independent over commitments =='
+
+both_orders = [
+  [{ 'tolerance' => tol, 'position' => 5 }, { 'tolerance' => tol, 'position' => 30 }],
+  [{ 'tolerance' => tol, 'position' => 30 }, { 'tolerance' => tol, 'position' => 5 }]
+].map do |decls|
+  Repro.assess_declarations(targets: [target], declarations: decls,
+                            invoked_tolerance_sha256: Repro.tolerance_digest(tol),
+                            endorsement_position: 20)
+end
+assert(both_orders.all? { |r| r[:invoked_conforming] },
+       'a digest committed anterior AND posterior conforms in both presentation orders (committed order, not array order)')
+assert(both_orders.all? { |r| r[:invoked][:position] == 5 },
+       'the earliest anterior commitment represents the invoked declaration in both orders')
+assert(both_orders.all? { |r| r[:invoked_posterior].size == 1 && r[:invoked_posterior][0][:position] == 30 },
+       'the posterior commitment of the invoked digest is disclosed, not dropped')
+
+dup = Repro.assess_declarations(
+  targets: [target],
+  declarations: [{ 'tolerance' => tol, 'position' => 10 }, { 'tolerance' => tol, 'position' => 10 }],
+  invoked_tolerance_sha256: Repro.tolerance_digest(tol),
+  endorsement_position: 20
+)
+assert(dup[:multiplicity] == 1, 'the same (digest, position) supplied twice is one commitment; multiplicity counts distinct declarations')
+assert(dup[:invoked_rank] == 1, 'the invoked declaration reports its rank in the pooled anterior set (rpr-1 §2.1)')
+
+tol_a = Repro.build_tolerance(target_sha256: Repro.target_digest(target))
+tol_b = Repro.build_tolerance(target_sha256: Repro.target_digest(sibling))
+tie_orders = [
+  [{ 'tolerance' => tol_a, 'position' => 5 }, { 'tolerance' => tol_b, 'position' => 5 }],
+  [{ 'tolerance' => tol_b, 'position' => 5 }, { 'tolerance' => tol_a, 'position' => 5 }]
+].map do |decls|
+  Repro.assess_declarations(targets: [target, sibling], declarations: decls,
+                            invoked_tolerance_sha256: Repro.tolerance_digest(tol_a),
+                            endorsement_position: 20)
+end
+assert(tie_orders[0][:invoked_rank] == tie_orders[1][:invoked_rank],
+       'equal earliest positions rank identically in both presentation orders (digest tiebreak, rpr-1 §2.1)')
+
+puts '== RPR-5: retraction is the map-1 §3 act unchanged =='
+
+retraction_ok = AType.validate_intake!('retraction', { 'target_entry_hash' => HEX_A })
+assert(retraction_ok, 'a reproduction-endorsement retraction rides map-1 §3 intake unchanged')
+assert(AType::VOCABULARY.include?('quality-endorsement'), 'endorsements are carried by the unchanged map-1 quality-endorsement type')
+
+puts '== additive-only: rpr-1 leaves map-1 vocabulary untouched =='
+
+assert(AType::VOCABULARY == %w[observation quality-endorsement succession-designation retraction],
+       'map-1 vocabulary unchanged by the rpr-1 slice (extension would be a new convention)')
+
+puts
+puts "#{$pass} passed, #{$fail} failed"
+exit($fail.zero? ? 0 : 1)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kairos-chain
 version: !ruby/object:Gem::Version
-  version: 3.45.0
+  version: 3.46.0
 platform: ruby
 authors:
 - Masaomi Hatakeyama
@@ -654,6 +654,7 @@ files:
 - templates/skillsets/skillset_exchange/tools/skillset_withdraw.rb
 - templates/skillsets/synoptis/bin/khab_verify.rb
 - templates/skillsets/synoptis/bin/map_verify.rb
+- templates/skillsets/synoptis/bin/rpr_verify.rb
 - templates/skillsets/synoptis/config/synoptis.yml
 - templates/skillsets/synoptis/knowledge/synoptis_protocol/synoptis_protocol.md
 - templates/skillsets/synoptis/lib/synoptis.rb
@@ -663,6 +664,7 @@ files:
 - templates/skillsets/synoptis/lib/synoptis/anchoring/containment.rb
 - templates/skillsets/synoptis/lib/synoptis/anchoring/conventions/khab-1.md
 - templates/skillsets/synoptis/lib/synoptis/anchoring/conventions/map-1.md
+- templates/skillsets/synoptis/lib/synoptis/anchoring/conventions/rpr-1.md
 - templates/skillsets/synoptis/lib/synoptis/anchoring/cumulative_commitment.rb
 - templates/skillsets/synoptis/lib/synoptis/anchoring/deposit_board.rb
 - templates/skillsets/synoptis/lib/synoptis/anchoring/entry.rb
@@ -671,6 +673,7 @@ files:
 - templates/skillsets/synoptis/lib/synoptis/anchoring/public_read.rb
 - templates/skillsets/synoptis/lib/synoptis/anchoring/public_verifier.rb
 - templates/skillsets/synoptis/lib/synoptis/anchoring/read_path.rb
+- templates/skillsets/synoptis/lib/synoptis/anchoring/reproduction.rb
 - templates/skillsets/synoptis/lib/synoptis/anchoring/succession.rb
 - templates/skillsets/synoptis/lib/synoptis/anchoring/write_budget.rb
 - templates/skillsets/synoptis/lib/synoptis/anchoring/write_path.rb
@@ -699,6 +702,7 @@ files:
 - templates/skillsets/synoptis/test/test_l2_constitutive_slice2.rb
 - templates/skillsets/synoptis/test/test_l2_constitutive_slice3.rb
 - templates/skillsets/synoptis/test/test_map_anchoring.rb
+- templates/skillsets/synoptis/test/test_rpr_reproduction.rb
 - templates/skillsets/synoptis/test/test_synoptis.rb
 - templates/skillsets/synoptis/tools/attestation_issue.rb
 - templates/skillsets/synoptis/tools/attestation_list.rb