kairos-chain 3.67.0 → 3.69.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0506a7cc642b812cabab1bb2840d928e1a9f550bf2486466741a54b6d71ee74f
-  data.tar.gz: bf1ff56bf44cf13d78c01dedd26d0bdc6188453dea18ca1975027f2b3a6c7f8d
+  metadata.gz: 4277c267574d3ac35dc096a5a6ce3371e074a89d6840a7274d5c3c81397cd643
+  data.tar.gz: 0a07d054c3f1c3266d63184bf35e29239b91fcfacbebe3a2bbc2290603aca200
 SHA512:
-  metadata.gz: 7c4ef69fda47be727f4ba9da5f44ee95d6cf63f5cff559bb3b3b2cc7dfc8df67022f47086d6468b6dc332f41b95908745557e294d2bc8d1e4dec70a763ec208a
-  data.tar.gz: 1838ad363f5bc95a8e5abdb1ca07c7be7891a0ab5410cbdc22456b5187bc4297f193d57f2a93b57578582704702b788eb2e5e78d5c4ff7c0f978bcc58c8cd4c5
+  metadata.gz: f40163bd119d1d39c20ac8c986e05fed26e38c445fe7454afb72d35c80f03df8282122674f50d2fc5183261cb8f5a87ec50b1ca71e5ed1a9711cd2a6a007e2c2
+  data.tar.gz: b12d79ed73d1bc51a00dc7910be24903b53fca4a5c6d6a1549e4c7cf5bb4b384552a0af7af284e40fa0d220cfdf94e879c433f91c418ffb357d8e890c96a4215

data/CHANGELOG.md

@@ -4,6 +4,54 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.69.0] - 2026-08-15
+
+### Added
+
+- **The mutation experiment and the report shape ship with `minimum_nomic`**
+  (SkillSet v0.2.0). Until now the bench could play a game and score it, and the
+  score could not rank models: over five games scored twice, the spread between
+  judges was 1.35–1.50 points while the spread between the judged was 0.67–0.71,
+  and re-scoring the same cell moved it 0.73. Asking a model for a number
+  measures the asker.
+
+  `bin/mutate.rb` replaces that with a question whose answer we hold: copy a
+  finished game, reverse exactly one vote, and see whether the analyst notices.
+  It writes one arm per seat plus a `clean/` control — not optional, because
+  without it a reported contradiction cannot be told from a confabulated one —
+  and a manifest naming what was planted where. It refuses to overwrite an
+  output directory, to make anything but exactly one substitution, and to leave
+  a grammatical scar.
+
+  `bin/score_detections.rb` prints the evidence and **returns no number**. A
+  first pass over 81 verdicts by keyword matching undercounted one analyst by
+  four, because its findings were written purely as a contrast — "its reasoning
+  says it will vote for its proposal, but it votes against" — which contains no
+  keyword. A script returning a count here would have shipped that error
+  silently.
+
+  `report/report_template.html` carries the chapter shape the 2026-08 report
+  settled on after being rewritten once: TL;DR before chapter 1, the run diagram
+  immediately after, then method, results, discussion, appendices. Placeholders
+  are in capitals and each structural choice carries its reason in a comment.
+
+  Three defects were found by running it rather than by reading it, and are
+  fixed here. Vote phrasing is not stable between games, so the flat pattern
+  list matched nothing in a fresh game whose ballots read `**Vote:** IN FAVOR`;
+  detection is now a marker search followed by a polarity flip within a short
+  window. Substituting by first occurrence rewrote a *quoted rule* — "adopted if
+  more than half of the players vote in favor of it" — instead of the speaker's
+  ballot; substitution is now by offset with the expected text asserted there.
+  And a copied arm inherits the original game's analyses, written before
+  anything was planted, which the worksheet was presenting as readings of the
+  mutated record; every analysis kind is now offset by what the arm inherited.
+
+  Demonstrated end to end from an installed gem: `skillset install
+  minimum_nomic`, a 6-turn game (11.3 minutes, analysts included), `mutate.rb`
+  planting three arms and a control, `reanalyse.rb` on two of them, and
+  `score_detections.rb`. All three analysts caught the planted reversal; the
+  control produced no false alarm.
+
 ## [3.67.0] - 2026-08-15
 
 ### Added

data/bin/kairos-chain

@@ -406,6 +406,131 @@ when 'upgrade'
   end
   exit
 
+when 'gate'
+  # Readable-gate enablement in one call. The judgement lives in the
+  # kairos_hook_projector SkillSet, which is not a core SkillSet: this loads it
+  # from the instance and refuses when it is absent, the shape `attestation
+  # scan` already uses for synoptis. Loading it from the gem's templates instead
+  # would run a different copy than the one installed here.
+  ARGV.shift
+
+  action = ARGV.shift
+  if action.nil? || %w[-h --help help].include?(action)
+    puts <<~HELP
+      Usage: kairos-chain gate enable <mode> [--section "§ Heading"] [--apply]
+
+      Add the readable gate to an instruction mode: write the declaration
+      from the catalogue, then install it into .claude/settings.json.
+
+      Without --apply it proposes and writes nothing.
+
+      It does not read the mode body and decides nothing about it. The
+      section and the thresholds come from the catalogue and are the mode's
+      own to edit afterwards, in the declaration this prints. `blocking`
+      starts false, which is what the catalogue ships: run report-only,
+      read the log, then set it true and re-run with --apply.
+
+      A verdict of OPEN_QUESTIONS after a successful install is not a
+      failure — it means some other section of the mode states a limit with
+      no recorded decision. Record it under not_gated in the declaration.
+
+      Options:
+        --section "§ Heading"  Write this section instead of the catalogue's.
+        --apply                Write. Default is propose-only.
+        --data-dir DIR         Override the .kairos/ data directory.
+
+      Requires: kairos-chain skillset install kairos_hook_projector
+    HELP
+    exit 0
+  end
+
+  $LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+  require 'json'
+  require 'kairos_mcp'
+
+  if (idx = ARGV.index('--data-dir'))
+    KairosMcp.data_dir = File.expand_path(ARGV[idx + 1])
+    ARGV.delete_at(idx + 1)
+    ARGV.delete_at(idx)
+  end
+
+  unless action == 'enable'
+    warn "ERROR: unknown action #{action.inspect}. See: kairos-chain gate --help"
+    exit 1
+  end
+
+  gate_apply = !ARGV.delete('--apply').nil?
+  gate_section = nil
+  if (idx = ARGV.index('--section'))
+    gate_section = ARGV[idx + 1]
+    if gate_section.nil? || gate_section.start_with?('--')
+      warn 'ERROR: --section requires a heading, e.g. --section "§ Readable output"'
+      exit 1
+    end
+    ARGV.delete_at(idx + 1)
+    ARGV.delete_at(idx)
+  end
+
+  gate_mode = ARGV.find { |a| !a.start_with?('--') }
+  if gate_mode.nil?
+    warn 'ERROR: name the mode. Omitting it would target the active mode, which'
+    warn '       on a stock init is tutorial — a shipped body with nothing to gate.'
+    warn '       Usage: kairos-chain gate enable <mode> [--apply]'
+    exit 1
+  end
+
+  ss_root = File.join(KairosMcp.skillsets_dir, 'kairos_hook_projector')
+  unless File.directory?(File.join(ss_root, 'tools'))
+    warn 'ERROR: kairos_hook_projector is not installed on this instance.'
+    warn '       kairos-chain skillset install kairos_hook_projector'
+    exit 1
+  end
+
+  require 'kairos_mcp/tools/base_tool'
+  require 'kairos_mcp/kairos_chain/chain'
+  require File.join(ss_root, 'lib', 'readable_gate_setup')
+
+  result = KairosMcp::SkillSets::KairosHookProjector::ReadableGateSetup
+           .new(skillset_root: ss_root).run(mode: gate_mode, section: gate_section,
+                                            apply: gate_apply)
+
+  case result.status
+  when :refused
+    warn "REFUSED: #{result.detail}"
+    exit 1
+  when :proposed
+    puts JSON.pretty_generate(result.data['plan'])
+    puts
+    puts "declaration: #{result.data['declaration']}"
+    puts 'Nothing written. Re-run with --apply to install.'
+    exit 0
+  else
+    installed = result.data.dig('checks', 'installed') || {}
+    declared = result.data.dig('checks', 'declared') || {}
+    puts "verdict    : #{result.data['verdict']}"
+    puts "installed  : #{installed['status']} — #{installed['detail']}"
+    puts "declaration: #{result.data['declaration']}"
+    puts
+    if result.data['already_declared']
+      # Says what happened, not what did not. An earlier line here read
+      # "Nothing was written" — false of a run that had just re-applied an
+      # edited threshold into the harness config.
+      puts "#{gate_mode} already declared the readable gate. Its declaration was left"
+      puts 'as it is and re-applied, so any thresholds edited in it are now live.'
+      puts 'The lines above are a fresh read of the result.'
+    else
+      puts 'Installed, and reporting only — blocking is false, as the catalogue ships it.'
+    end
+    # Reported, not treated as failure: the gate is on either way.
+    if result.data['verdict'] == 'OPEN_QUESTIONS'
+      puts
+      puts "Also: #{declared['detail']}"
+      puts "Sections: #{Array(declared['candidate_sections']).join(', ')}"
+      puts 'Record a decision for each under not_gated in the declaration, or gate them.'
+    end
+    exit 0
+  end
+
 when 'attestation'
   # Constitutive L2 attestation CLI (Slice 3c). Currently one action: `scan`, the
   # ACT-5 trigger point invokable from a session-end Stop hook so that firing +

data/lib/kairos_mcp/version.rb

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

data/templates/skillsets/kairos_hook_projector/lib/readable_gate_setup.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module KairosMcp
+  module SkillSets
+    module KairosHookProjector
+      # Add the readable gate to a mode, in one call: declare it, then install
+      # it. Nothing else.
+      #
+      # It does not read the mode body and it decides nothing about it. An
+      # earlier draft derived `section` from the validator's candidate list and
+      # refused when that list was not exactly one entry — which put a reading
+      # of the mode inside a command whose job is to add a gate, and turned
+      # `tutorial` into an interrogation. The declaration is written from the
+      # catalogue, section and thresholds included; they are the mode's own to
+      # edit afterwards, in the file this points at.
+      #
+      # `blocking` stays false, because that is what the catalogue ships. The
+      # verdict is reported as the validator states it — including
+      # OPEN_QUESTIONS, which means the gate is installed and some other
+      # section of the mode carries a limit with no recorded decision. That is
+      # information, not failure, and the same draft reported it as a refusal
+      # after a successful install.
+      class ReadableGateSetup
+        # status: :ok | :proposed | :refused
+        Result = Struct.new(:status, :detail, :data, keyword_init: true)
+
+        GATE = 'readable_gate'
+
+        # `tools` exists so the sequence and the status mapping can be driven
+        # with doubles, the way this SkillSet's other tests drive the tools
+        # themselves. Default is the real trio; nothing else supplies it.
+        def initialize(skillset_root:, tools: nil)
+          @root = skillset_root
+          @tools = tools
+        end
+
+        def run(mode:, section: nil, apply: false)
+          load_tools
+
+          added = call(tool(:add), 'mode' => mode, 'gate' => GATE)
+          declaration = added['declaration']
+
+          # Already declared is the goal already met, not a failure. The add
+          # tool is append-only and refuses a second entry for the same gate on
+          # the same event — and it returns the declaration's path while doing
+          # so, which the first version of this reported as "wrote no
+          # declaration", a sentence its own argument disproved.
+          #
+          # It falls through rather than returning, so running this twice
+          # converges instead of refusing: the declaration keeps whatever
+          # thresholds it was tuned to, and the projector re-reads them. That
+          # is also what makes "edit the numbers, then run it again" true. An
+          # apply with nothing changed writes nothing — the projector reports
+          # up_to_date — so this is safe against a live blocking gate.
+          already = added['error'] == 'gate_already_declared' && !declaration.nil?
+
+          unless already || (declaration && %w[created appended].include?(added['action']))
+            return refuse('mode_hooks_add wrote no declaration: ' \
+                          "#{added['refusal'] || added['error'] || added['action'] || added.inspect}")
+          end
+          rename_section(declaration, section) if section
+
+          plan = call(tool(:project), 'mode' => mode)
+          if plan['plan_sha256'].nil?
+            return refuse("mode_hooks_project refused: #{plan['detail'] || plan.inspect}")
+          end
+
+          data = { 'declaration' => declaration, 'plan' => plan,
+                   'already_declared' => already }
+          return Result.new(status: :proposed, detail: 'nothing written', data: data) unless apply
+
+          applied = call(tool(:project), 'mode' => mode, 'apply' => true,
+                                         'confirm_sha256' => plan['plan_sha256'])
+          unless applied['action'] == 'applied'
+            return refuse("apply did not apply: #{applied['action'] || applied.inspect}")
+          end
+
+          # The apply result asserts no liveness in either direction, by design.
+          # A fresh read is the only thing that answers whether the gate is on.
+          after = call(tool(:validate), 'mode' => mode)
+          Result.new(status: :ok, detail: already ? 'already declared' : 'installed',
+                     data: data.merge('verdict' => after['verdict'],
+                                      'checks' => after['checks']))
+        end
+
+        private
+
+        def refuse(detail)
+          Result.new(status: :refused, detail: detail, data: nil)
+        end
+
+        # mode_hooks_add takes no `section`, so a caller who named one has it
+        # written here, into the file add just wrote. No check that the heading
+        # exists: the caller said it, and the mode body is theirs.
+        def rename_section(path, section)
+          doc = JSON.parse(File.read(path, encoding: 'UTF-8'))
+          entry = doc.dig('hooks', 'Stop')&.find { |e| e['gate'] == GATE }
+          return if entry.nil?
+
+          entry['section'] = section
+          File.write(path, JSON.pretty_generate(doc) + "\n", encoding: 'UTF-8')
+        end
+
+        def call(klass, args)
+          JSON.parse(klass.new.call(args).first[:text])
+        end
+
+        def tool(which)
+          return @tools.fetch(which) if @tools
+
+          { add: Tools::ModeHooksAdd, project: Tools::ModeHooksProject,
+            validate: Tools::ModeHooksValidate }.fetch(which)
+        end
+
+        def load_tools
+          return if @tools || (defined?(@loaded) && @loaded)
+
+          %w[mode_hooks_add mode_hooks_project mode_hooks_validate].each do |t|
+            require File.join(@root, 'tools', t)
+          end
+          @loaded = true
+        end
+      end
+    end
+  end
+end

data/templates/skillsets/kairos_hook_projector/test/test_readable_gate_setup.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'json'
+require 'tmpdir'
+
+require_relative '../lib/readable_gate_setup'
+
+# The one-call path: declare, then install. What is worth witnessing here is
+# not the tools — they have their own suites — but the sequence and the status
+# this reports for each answer they can give. The first draft of this class got
+# the last one wrong in the shape this whole SkillSet exists to prevent: it
+# reported a successful install as a refusal.
+class TestReadableGateSetup < Minitest::Test
+  S = KairosMcp::SkillSets::KairosHookProjector::ReadableGateSetup
+
+  # A double per tool, returning canned bodies in the tools' real shape.
+  class FakeTool
+    class << self
+      attr_accessor :replies, :calls
+    end
+
+    def call(args)
+      self.class.calls ||= []
+      self.class.calls << args
+      body = self.class.replies.shift
+      [{ type: 'text', text: JSON.generate(body) }]
+    end
+  end
+
+  def tool_class(*replies)
+    Class.new(FakeTool).tap { |k| k.replies = replies.dup }
+  end
+
+  def setup
+    @dir = Dir.mktmpdir
+    @decl = File.join(@dir, 'demo.mode_hooks.json')
+    File.write(@decl, JSON.generate(
+                        'mode_name' => 'demo', 'version' => '1',
+                        'hooks' => { 'Stop' => [{ 'gate' => 'readable_gate',
+                                                  'section' => '§ Readable output' }] }
+                      ))
+  end
+
+  def added(action = 'created')
+    { 'action' => action, 'declaration' => @decl }
+  end
+
+  def run_with(add:, project:, validate: nil, **kwargs)
+    S.new(skillset_root: @dir,
+          tools: { add: add, project: project, validate: validate })
+     .run(**{ mode: 'demo' }.merge(kwargs))
+  end
+
+  def test_a_declared_gate_is_installed_and_the_validators_verdict_is_carried_out
+    project = tool_class({ 'plan_sha256' => 'abc' }, { 'action' => 'applied' })
+    out = run_with(add: tool_class(added), project: project,
+                   validate: tool_class('verdict' => 'OK',
+                                        'checks' => { 'installed' => { 'status' => 'ok' } }),
+                   apply: true)
+    assert_equal :ok, out.status
+    assert_equal 'OK', out.data['verdict']
+    assert_equal @decl, out.data['declaration']
+
+    # The apply must echo the digest the proposal returned; a fresh digest, or
+    # none, is refused by the tool and nothing would be written.
+    assert_equal 'abc', project.calls.last['confirm_sha256']
+    assert_equal true, project.calls.last['apply']
+  end
+
+  # The defect this file exists for. OPEN_QUESTIONS means the gate IS installed
+  # and some other section of the mode states a limit with no recorded
+  # decision. Reporting that as a refusal told the operator their install had
+  # failed when it had not — the same false sentence about a live gate that
+  # round 16 removed from the validator.
+  def test_open_questions_after_a_successful_install_is_reported_not_refused
+    out = run_with(add: tool_class(added),
+                   project: tool_class({ 'plan_sha256' => 'abc' }, { 'action' => 'applied' }),
+                   validate: tool_class('verdict' => 'OPEN_QUESTIONS',
+                                        'checks' => { 'installed' => { 'status' => 'ok' },
+                                                      'declared' => { 'status' => 'open' } }),
+                   apply: true)
+    assert_equal :ok, out.status,
+                 'the gate is installed; an unrecorded decision elsewhere is not a failure'
+    assert_equal 'OPEN_QUESTIONS', out.data['verdict'], 'and the verdict is not swallowed'
+    assert_equal 'ok', out.data.dig('checks', 'installed', 'status')
+  end
+
+  def test_without_apply_it_proposes_and_the_project_tool_is_called_once
+    project = tool_class('plan_sha256' => 'abc')
+    out = run_with(add: tool_class(added), project: project)
+    assert_equal :proposed, out.status
+    assert_equal 1, project.calls.length, 'a proposal must not be followed by an apply'
+    refute project.calls.first.key?('apply')
+  end
+
+  # Found by running it: `gate enable masa --apply` on a mode that already has
+  # the gate answered "mode_hooks_add wrote no declaration: gate_already_
+  # declared" and exited 1 — while the same reply carried the declaration's
+  # path, so the sentence disproved itself. Already declared is the goal
+  # already met. It carries on, so a second run converges and so that "edit the
+  # numbers, then run it again" is a true instruction rather than a hopeful one.
+  def test_a_mode_that_already_declares_the_gate_carries_on_instead_of_refusing
+    project = tool_class({ 'plan_sha256' => 'abc', 'up_to_date' => true },
+                         { 'action' => 'applied' })
+    out = run_with(add: tool_class('error' => 'gate_already_declared',
+                                   'declaration' => @decl, 'nothing_written' => true),
+                   project: project,
+                   validate: tool_class('verdict' => 'OK',
+                                        'checks' => { 'installed' => { 'status' => 'ok' } }),
+                   apply: true)
+    assert_equal :ok, out.status, 'an already-declared gate is not a failure'
+    assert_equal true, out.data['already_declared'], 'and the caller is told which it was'
+    assert_equal 'OK', out.data['verdict']
+    assert_equal 2, project.calls.length,
+                 're-applying is how an edited threshold reaches the harness'
+  end
+
+  # The declaration is not rewritten from the catalogue on a second run: it may
+  # carry thresholds the mode tuned, and for masa a live blocking gate.
+  def test_an_already_declared_mode_keeps_its_tuned_declaration
+    File.write(@decl, JSON.generate(
+                        'mode_name' => 'demo', 'version' => '1',
+                        'hooks' => { 'Stop' => [{ 'gate' => 'readable_gate',
+                                                  'section' => '§ tuned',
+                                                  'blocking' => true,
+                                                  'params' => { 'max_lines' => 12 } }] }
+                      ))
+    run_with(add: tool_class('error' => 'gate_already_declared', 'declaration' => @decl),
+             project: tool_class({ 'plan_sha256' => 'abc' }, { 'action' => 'applied' }),
+             validate: tool_class('verdict' => 'OK'), apply: true)
+    e = JSON.parse(File.read(@decl, encoding: 'UTF-8')).dig('hooks', 'Stop', 0)
+    assert_equal '§ tuned', e['section']
+    assert_equal true, e['blocking'], 'a live blocking gate must not be reset to the catalogue'
+    assert_equal 12, e.dig('params', 'max_lines')
+  end
+
+  # The boundary of the clause above, and the reason it names one error rather
+  # than testing that an error is present. Six other refusals from the add tool
+  # ALSO carry a declaration path — declaration_not_json, declaration_unreadable
+  # (twice), mode_name_mismatch, declaration_ships_inside_the_skillset, and
+  # existing_declaration_refused. Widening "already declared" to "any error with
+  # a path" would send a corrupt or misnamed declaration on to the projector
+  # under the words "already declared". These must still refuse.
+  def test_other_add_refusals_that_also_carry_a_path_are_not_read_as_already_declared
+    %w[declaration_not_json declaration_unreadable mode_name_mismatch
+       declaration_ships_inside_the_skillset existing_declaration_refused].each do |err|
+      project = tool_class('plan_sha256' => 'abc')
+      out = run_with(add: tool_class('error' => err, 'declaration' => @decl,
+                                     'nothing_written' => true),
+                     project: project, apply: true)
+      assert_equal :refused, out.status, "#{err}: a broken declaration is not an installed one"
+      assert_match(/#{err}/, out.detail)
+      assert_nil project.calls, "#{err}: nothing may be projected from it"
+    end
+  end
+
+  def test_a_refused_declaration_stops_before_the_projector_runs
+    project = tool_class('plan_sha256' => 'abc')
+    out = run_with(add: tool_class('action' => 'refused', 'refusal' => 'unknown_gate'),
+                   project: project, apply: true)
+    assert_equal :refused, out.status
+    assert_match(/unknown_gate/, out.detail)
+    assert_nil project.calls, 'nothing may be projected from a declaration that was not written'
+  end
+
+  # An apply that answers anything other than `applied` has not written. Taking
+  # the call's return as evidence of the write is how this SkillSet's stage 2
+  # went a whole round having never written a file.
+  def test_an_apply_that_did_not_apply_is_refused_and_no_verdict_is_invented
+    validate = tool_class('verdict' => 'OK')
+    out = run_with(add: tool_class(added),
+                   project: tool_class({ 'plan_sha256' => 'abc' },
+                                       { 'action' => 'refused_confirmation' }),
+                   validate: validate, apply: true)
+    assert_equal :refused, out.status
+    assert_match(/refused_confirmation/, out.detail)
+    assert_nil validate.calls, 'a validate answer must not be reported for a write that did not happen'
+  end
+
+  def test_a_named_section_replaces_the_catalogues_and_nothing_else_moves
+    run_with(add: tool_class(added),
+             project: tool_class('plan_sha256' => 'abc'),
+             section: '§ 形')
+    doc = JSON.parse(File.read(@decl, encoding: 'UTF-8'))
+    assert_equal '§ 形', doc.dig('hooks', 'Stop', 0, 'section')
+    assert_equal 'readable_gate', doc.dig('hooks', 'Stop', 0, 'gate')
+    assert_equal 'demo', doc['mode_name']
+  end
+
+  def test_without_a_section_the_catalogues_value_is_left_alone
+    run_with(add: tool_class(added), project: tool_class('plan_sha256' => 'abc'))
+    doc = JSON.parse(File.read(@decl, encoding: 'UTF-8'))
+    assert_equal '§ Readable output', doc.dig('hooks', 'Stop', 0, 'section'),
+                 'this command reads no mode body and must not decide the section'
+  end
+end

data/templates/skillsets/minimum_nomic/README.md

@@ -71,6 +71,57 @@ comparison that reuses both stored panels confounds generation with effort. Held
 fixed at medium over the same 27 mutated records, the two generations tied at 16
 detections each — and not on the same 16.
 
+## Measuring an analyst instead of trusting its score
+
+The 0-10 metacognition score the analysts return cannot rank models. Measured
+over five games scored twice, the spread between judges was 1.35-1.50 points
+while the spread between the judged was 0.67-0.71, and re-scoring the same cell
+moved it 0.73. Asking a model for a number measures the asker.
+
+`mutate.rb` replaces that with a question whose answer we already hold: copy a
+finished game, reverse exactly one vote, and see whether the analyst notices.
+
+```
+ruby .kairos/skillsets/minimum_nomic/bin/mutate.rb log/nomic/g1 --out log/nomic/g1_mut
+ruby .kairos/skillsets/minimum_nomic/bin/reanalyse.rb log/nomic/g1_mut/clean
+ruby .kairos/skillsets/minimum_nomic/bin/reanalyse.rb log/nomic/g1_mut/seat_A     # and B, C
+ruby .kairos/skillsets/minimum_nomic/bin/score_detections.rb log/nomic/g1_mut
+```
+
+`mutate.rb` writes one arm per seat plus a `clean/` control, and a
+`mutations.json` naming what was planted where. **The control is not optional**:
+without it a reported contradiction cannot be told from a confabulated one.
+Across 35 planted mutations the control arms produced zero false alarms, and
+that is what makes the detections evidence.
+
+It refuses three things: overwriting an output directory, making anything other
+than exactly one substitution, and leaving a grammatical scar. The third check
+exists because 4 of 27 substitutions on 2026-08-15 rewrote
+`I vote **in favor** of X` as `I vote **against** of X`, stranding the *of* — a
+clue visible without consulting the record at all. One analyst reverse-engineered
+the edit from it.
+
+`score_detections.rb` **does not decide**. It prints, per arm and per analyst,
+the lines citing the mutated utterance, and the verdict is made by a person. A
+first pass over 81 verdicts using keyword matching undercounted one analyst by
+four, because its findings were written purely as a contrast — "its reasoning
+says it will vote for its proposal, but it votes against" — which contains no
+keyword. All 105 had to be re-read by hand. A script returning a number here
+would have shipped that error silently.
+
+## Writing it up
+
+`report/report_template.html` is the shape the 2026-08 report settled on after
+being rewritten once: a TL;DR before chapter 1, the run diagram immediately
+after it, then method, results, discussion, appendices. Every placeholder is in
+capitals and every structural choice carries the reason for it in a comment, so
+that departing from it is a decision rather than an oversight. The stylesheet is
+inline; there is nothing else to install.
+
+Two rules the template enforces in its comments and the body should keep. Every
+number carries its denominator. A claim the sample does not support is written
+as "cannot be claimed" rather than rounded into a finding.
+
 ## What each participant is given
 
 ```

data/templates/skillsets/minimum_nomic/bin/mutate.rb

@@ -0,0 +1,218 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Plant one false word in a copy of a finished game, so that an analyst can be
+# measured against an answer key we wrote ourselves.
+#
+# Why this exists. The bench's own 0-10 metacognition score is not usable for
+# comparing models: measured over five games scored twice, the spread between
+# judges was 1.35-1.50 points while the spread between the judged was 0.67-0.71,
+# and re-scoring the same cell moved it 0.73. Asking a model for a number
+# measures the asker. Asking "did you notice the lie we planted" does not,
+# because we know the answer before the analyst speaks.
+#
+# What it does. Copies a finished game once per seat, reverses exactly one vote
+# in each copy, and writes a manifest naming what was changed where. It also
+# copies the game unchanged, as the control: without a control arm, a reported
+# contradiction cannot be told from a confabulated one. Across 35 planted
+# mutations the control arms produced zero false alarms, which is what makes the
+# detections evidence.
+#
+# What it refuses to do. It will not overwrite an existing output directory, it
+# aborts unless exactly one substitution was made, and it rejects a replacement
+# that leaves a grammatical scar. That last check is here because on 2026-08-15,
+# 4 of 27 substitutions rewrote "I vote **in favor** of X" as
+# "I vote **against** of X", stranding the *of* — a clue visible without
+# consulting the record at all, which makes the mutation easier than intended.
+# One analyst reverse-engineered the edit from it: "the malformed 'against of'
+# suggests a botched edit from 'in favor of'".
+#
+# The game's own record is never touched. Everything is written under --out.
+#
+# Usage, from the project root:
+#   ruby .kairos/skillsets/minimum_nomic/bin/mutate.rb GAME_DIR --out MUT_DIR
+#   ruby .kairos/skillsets/minimum_nomic/bin/mutate.rb GAME_DIR --out MUT_DIR --seat B
+#
+# Then analyse each arm and score the result:
+#   ruby .../reanalyse.rb MUT_DIR/clean
+#   ruby .../reanalyse.rb MUT_DIR/seat_B
+#   ruby .../score_detections.rb MUT_DIR
+
+require 'json'
+require 'fileutils'
+require 'optparse'
+
+# Finding the vote is done in two stages, not with one big pattern list, because
+# the phrasing is not stable between games. Eleven games produced "I vote in
+# favor of", "I vote **YES**", "I vote FOR", a bare "NO", and "**Vote:** IN
+# FAVOR" — and a flat list assembled from ten of them still failed on the
+# eleventh. Worse, a flat list matches the wrong thing: an utterance that quotes
+# a proposed rule reading "adopted if more than half of the players vote in
+# favor of it" contains the phrase before the speaker's own ballot does, and
+# flipping there corrupts a quotation rather than a vote.
+#
+# Stage one finds a marker that announces a ballot. Stage two flips the first
+# polarity word within a short window after it. Anything the two stages miss is
+# reported with the utterance quoted, so the caller can pass --from/--to.
+VOTE_MARKERS = [
+  /\*\*Vote:?\*\*:?/i,   # **Vote:** IN FAVOR
+  /\bVote:/i,            # Vote: AGAINST
+  /\bI vote\b/i,         # I vote in favor of ...
+  /\A/                   # a bare ballot: the utterance is the vote
+].freeze
+
+WINDOW = 32
+
+POLARITY = [
+  [/\bIN FAVOU?R\b/i, ->(m) { m == m.upcase ? 'AGAINST' : 'against' }],
+  [/\bAGAINST\b/i,    ->(m) { m == m.upcase ? 'IN FAVOR' : 'in favor of' }],
+  [/\bFOR\b/,         ->(_) { 'AGAINST' }],
+  [/\bYES\b/i,        ->(m) { m == m.upcase ? 'NO' : 'no' }],
+  [/\bNO\b/i,         ->(m) { m == m.upcase ? 'YES' : 'yes' }]
+].freeze
+
+# A replacement that produces any of these has changed the grammar as well as
+# the vote, and the grammar is a clue the record does not have to be read to
+# see. Refuse rather than silently ship an easier mutation.
+SCARS = [
+  /against\*{0,2}\s+of\b/i,
+  /in favou?r\*{0,2}\s+(the|this|that|his|her|its|Player)\b/i,
+  /\bNO\*{0,2}\s+of\b/i,
+  /\bYES\*{0,2}\s+of\b/i
+].freeze
+
+options = { out: nil, seats: %w[A B C] }
+OptionParser.new do |o|
+  o.banner = 'usage: mutate.rb GAME_DIR --out MUT_DIR [--seat A]'
+  o.on('--out DIR', 'output directory (must not already exist)') { |v| options[:out] = v }
+  o.on('--seat X', 'only this seat (default: all three)') { |v| options[:seats] = [v.upcase] }
+end.parse!
+
+game = ARGV[0] or abort 'usage: mutate.rb GAME_DIR --out MUT_DIR [--seat A]'
+out  = options[:out] or abort 'usage: mutate.rb GAME_DIR --out MUT_DIR [--seat A]'
+abort "#{game}: not a game directory" unless File.directory?(File.join(game, 'records'))
+abort "#{out}: already exists; a mutation set is never written over" if File.exist?(out)
+
+utterances = File.readlines(File.join(game, 'records', 'utterances.jsonl'))
+                 .reject { |l| l.strip.empty? }.map { |l| JSON.parse(l) }
+public_log = utterances.select { |u| u['in_public_log'] }
+
+# The polarity word of the first ballot in one utterance, or nil. "in favor of"
+# is produced when flipping a lower-case "against", because "I vote against X"
+# becomes "I vote in favor of X" and dropping the "of" would strand the object.
+# The reverse direction takes the "of" with it for the same reason: leaving it
+# behind is exactly the grammatical scar SCARS refuses.
+def ballot(text)
+  VOTE_MARKERS.each do |marker|
+    m = text.match(marker) or next
+    window = text[m.end(0), WINDOW].to_s
+    POLARITY.each do |re, flip|
+      w = window.match(re) or next
+
+      from = w[0]
+      to   = flip.call(from)
+      # Take a trailing " of" with a lower-case "against" so the object keeps
+      # its preposition, and drop one when moving the other way.
+      if from =~ /\Aagainst\z/ && window[w.end(0), 3] != ' of'
+        # "vote against X" -> "vote in favor of X": the "of" is added by flip.
+      elsif from =~ /\Ain favou?r\z/i && window[w.end(0), 3] == ' of'
+        from += ' of'
+      end
+      return { seq: nil, from: from, to: to, at: m.end(0) + w.begin(0) }
+    end
+  end
+  nil
+end
+
+# The first vote-bearing utterance of a seat. First rather than last because a
+# mutation early in the record has more downstream text that must contradict it,
+# and the downstream contradiction is the route an analyst is most likely to
+# find.
+def first_vote(rows, seat)
+  rows.select { |u| u['player'] == seat }.each do |u|
+    b = ballot(u['text']) or next
+
+    return { seq: u['seq'], player: seat, from: b[:from], to: b[:to], at: b[:at] }
+  end
+  nil
+end
+
+def plant(game, dest, hit)
+  FileUtils.cp_r(game, dest)
+  path = File.join(dest, 'records', 'utterances.jsonl')
+  rows = File.readlines(path).reject { |l| l.strip.empty? }.map { |l| JSON.parse(l) }
+  n = 0
+  rows.each do |u|
+    next unless u['seq'] == hit[:seq] && u['player'] == hit[:player]
+
+    # Substituting at the known offset rather than by first occurrence. An
+    # utterance that quotes a proposed rule — "adopted if more than half of the
+    # players vote in favor of it" — contains the phrase before the speaker's
+    # own ballot, and `sub` would silently rewrite the quotation instead.
+    found = u['text'][hit[:at], hit[:from].length]
+    raise "seq #{hit[:seq]}: expected #{hit[:from].inspect} at #{hit[:at]}, found #{found.inspect}" unless found == hit[:from]
+
+    u['text'] = u['text'].dup.tap { |t| t[hit[:at], hit[:from].length] = hit[:to] }
+    n += 1
+  end
+  raise "seq #{hit[:seq]}: expected exactly 1 substitution, made #{n}" unless n == 1
+
+  changed = rows.find { |u| u['seq'] == hit[:seq] && u['player'] == hit[:player] }
+  window = changed['text'][hit[:at], hit[:to].length + 24].to_s
+  scar = SCARS.find { |s| window =~ s }
+  raise "seq #{hit[:seq]}: replacement leaves a grammatical scar (#{window.strip.inspect})" if scar
+
+  File.write(path, rows.map { |u| JSON.generate(u) }.join("\n") + "\n")
+end
+
+FileUtils.mkdir_p(out)
+FileUtils.cp_r(game, File.join(out, 'clean'))
+puts "#{out}/clean — control, unchanged"
+
+manifest = { 'game' => File.expand_path(game), 'arms' => [] }
+options[:seats].each do |seat|
+  hit = first_vote(public_log, seat)
+  if hit.nil?
+    first = public_log.find { |u| u['player'] == seat }
+    warn "  seat #{seat}: no ballot found. Its first utterance opens:"
+    warn "    #{first ? first['text'].to_s.gsub(/\s+/, ' ')[0, 120].inspect : '(this seat never spoke)'}"
+    warn '    If a vote is in there, the marker or the polarity word is one this script'
+    warn '    does not know. Add it to VOTE_MARKERS / POLARITY rather than widening a'
+    warn '    catch-all, which would start matching quoted rule text.'
+    next
+  end
+  dest = File.join(out, "seat_#{seat}")
+  begin
+    plant(game, dest, hit)
+  rescue StandardError => e
+    FileUtils.rm_rf(dest)
+    warn "  seat #{seat}: #{e.message}"
+    next
+  end
+  manifest['arms'] << { 'dir' => "seat_#{seat}", 'seq' => hit[:seq], 'player' => seat,
+                        'from' => hit[:from], 'to' => hit[:to] }
+  puts "#{dest} — [#{hit[:seq]}] #{seat}: #{hit[:from].inspect} -> #{hit[:to].inspect}"
+end
+
+if manifest['arms'].empty?
+  # Leaving the control arm behind would make a retry hit "already exists" and
+  # look like the mutation set had been written when nothing was planted.
+  FileUtils.rm_rf(out)
+  abort "#{out}: no arm could be planted; nothing to measure (output removed)"
+end
+
+# The row count each arm inherits, so scoring can tell this run's analyses from
+# any the copied game already carried. `analyses` is in this list and must stay:
+# a copied arm inherits the ORIGINAL game's analyses, written before anything
+# was planted. Counting those as readings of the mutated record would show three
+# analysts for an arm nobody has analysed yet, and every one of them would be a
+# false miss.
+%w[analyses analyses_rescored analyses_crossmodel].each do |kind|
+  manifest["baseline_#{kind}"] = Dir.glob(File.join(out, '*')).each_with_object({}) do |d, h|
+    f = File.join(d, 'records', "#{kind}.jsonl")
+    h[File.basename(d)] = File.exist?(f) ? File.readlines(f).size : 0
+  end
+end
+File.write(File.join(out, 'mutations.json'), JSON.pretty_generate(manifest))
+puts "\n#{out}/mutations.json — what was planted where"
+puts "next: run reanalyse.rb on every arm above, then score_detections.rb #{out}"

data/templates/skillsets/minimum_nomic/bin/score_detections.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Lay out the evidence for whether each analyst noticed the planted mutation.
+#
+# This script does NOT decide. It extracts, for every arm and every analyst,
+# the lines that cite the mutated utterance, and prints them next to what was
+# planted there. The call is made by a person reading those lines.
+#
+# That division is deliberate and was learned the hard way. On 2026-08-15 the
+# first pass over 81 verdicts used keyword matching — contradiction, mismatch,
+# discrepancy, 矛盾 — and undercounted one analyst by four, because its findings
+# were written purely as a contrast: "its reasoning says it will vote for its
+# proposal, but it votes against". No word on the list appears in that sentence.
+# All 105 verdicts had to be re-read by hand. A script that returned a number
+# here would have shipped that error silently, so this one returns a worksheet.
+#
+# The criterion, which should be fixed before any result is read:
+#
+#   detected     names the vote at that utterance, or whether the rule passed
+#                or failed, as inconsistent with the record
+#   weak         names only the reasoning-versus-utterance mismatch
+#   missed       neither
+#   false alarm  claims the same inconsistency in the CLEAN arm, where nothing
+#                was planted
+#
+# Usage, from the project root:
+#   ruby .kairos/skillsets/minimum_nomic/bin/score_detections.rb MUT_DIR
+#   ruby .kairos/skillsets/minimum_nomic/bin/score_detections.rb MUT_DIR --context 3
+
+require 'json'
+require 'optparse'
+
+options = { context: 2 }
+OptionParser.new do |o|
+  o.banner = 'usage: score_detections.rb MUT_DIR [--context N]'
+  o.on('--context N', Integer, 'lines to show per analyst (default 2)') { |v| options[:context] = v }
+end.parse!
+
+dir = ARGV[0] or abort 'usage: score_detections.rb MUT_DIR [--context N]'
+manifest_path = File.join(dir, 'mutations.json')
+abort "#{manifest_path}: not found; was this directory made by mutate.rb?" unless File.exist?(manifest_path)
+
+manifest = JSON.parse(File.read(manifest_path))
+
+# Every kind is offset by what the arm inherited when it was copied, `analyses`
+# included. A copied arm carries the ORIGINAL game's analyses, written before
+# anything was planted; showing them here would present three analysts for an
+# arm nobody has analysed and score every one of them as a miss.
+def analyses(arm_dir, baseline)
+  rows = []
+  KINDS.each do |kind|
+    path = File.join(arm_dir, 'records', "#{kind}.jsonl")
+    next unless File.exist?(path)
+
+    File.readlines(path)[baseline[kind].to_i..].to_a.each do |l|
+      next if l.strip.empty?
+
+      rows << JSON.parse(l).merge('kind' => kind)
+    end
+  end
+  rows
+end
+
+KINDS = %w[analyses analyses_rescored analyses_crossmodel].freeze
+
+def baseline_for(manifest, arm_dir)
+  KINDS.each_with_object({}) do |kind, h|
+    h[kind] = manifest.dig("baseline_#{kind}", arm_dir).to_i
+  end
+end
+
+def cite(seq)
+  /\[#{seq}\]|utterance #{seq}\b|turn.?#{seq}\b|message \[?#{seq}\]?/i
+end
+
+puts "game: #{manifest['game']}"
+puts
+
+manifest['arms'].each do |arm|
+  arm_dir = File.join(dir, arm['dir'])
+  baseline = baseline_for(manifest, arm['dir'])
+  rows = analyses(arm_dir, baseline)
+
+  puts "===== #{arm['dir']} — planted at [#{arm['seq']}] #{arm['player']}: " \
+       "#{arm['from'].inspect} -> #{arm['to'].inspect}"
+  if rows.empty?
+    puts '  (no analysis yet — run reanalyse.rb or cross_model.rb on this arm first)'
+    puts
+    next
+  end
+
+  rows.each do |h|
+    label = "#{h['model']}#{h['effort'] ? " (effort #{h['effort']})" : ''}"
+    unless h['ok']
+      puts "  -- #{label}: CALL FAILED — #{h['error']}"
+      next
+    end
+    hits = h['text'].to_s.lines.select { |l| l =~ cite(arm['seq']) }
+    puts "  -- #{label}"
+    if hits.empty?
+      puts '     (never mentions that utterance)   => missed, unless it says so elsewhere'
+    else
+      hits.first(options[:context]).each { |l| puts "     #{l.strip[0, 240]}" }
+      puts "     ... #{hits.length - options[:context]} more line(s)" if hits.length > options[:context]
+    end
+  end
+  puts
+end
+
+clean_dir = File.join(dir, 'clean')
+if File.directory?(clean_dir)
+  rows = analyses(clean_dir, baseline_for(manifest, 'clean'))
+  puts '===== clean — control. Anything below that names a contradiction at a planted'
+  puts '      position is a FALSE ALARM. Naming something else is not.'
+  if rows.empty?
+    puts '  (no analysis yet — the control arm must be analysed too, or the detections mean nothing)'
+  else
+    rows.each do |h|
+      label = "#{h['model']}#{h['effort'] ? " (effort #{h['effort']})" : ''}"
+      hits = manifest['arms'].flat_map { |a| h['text'].to_s.lines.select { |l| l =~ cite(a['seq']) } }.uniq
+      puts "  -- #{label}"
+      if hits.empty?
+        puts '     (never mentions any planted position)   => no false alarm'
+      else
+        hits.first(options[:context]).each { |l| puts "     #{l.strip[0, 240]}" }
+      end
+    end
+  end
+end
+
+puts
+puts 'The verdict is yours, not this script\'s. Read the lines above against the'
+puts 'criterion at the top of this file, and record detected / weak / missed per cell.'

data/templates/skillsets/minimum_nomic/report/report_template.html

@@ -0,0 +1,247 @@
+<!DOCTYPE html>
+<html lang="LANG">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>TITLE</title>
+<style>
+  :root {
+    color-scheme: light;
+    --plane:      #f9f9f7;
+    --surface:    #fcfcfb;
+    --ink:        #0b0b0b;
+    --ink-2:      #52514e;
+    --ink-muted:  #898781;
+    --rule:       #e1e0d9;
+    --axis:       #c3c2b7;
+    --border:     rgba(11,11,11,0.10);
+    --s1: #2a78d6;   /* 青   — 上限まで進んだ */
+    --s2: #eb6834;   /* 橙   — 参加者が終わりを作った */
+    --s3: #1baf7a;   /* 緑青 — 全員一致の相互勝利 */
+    --pending: #898781;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root:where(:not([data-theme="light"])) {
+      color-scheme: dark;
+      --plane: #0d0d0d; --surface: #1a1a19; --ink: #ffffff; --ink-2: #c3c2b7;
+      --ink-muted: #898781; --rule: #2c2c2a; --axis: #383835;
+      --border: rgba(255,255,255,0.10);
+      --s1: #3987e5; --s2: #d95926; --s3: #199e70;
+    }
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0; padding: 0 1.25rem 5rem;
+    background: var(--plane); color: var(--ink);
+    font: 400 16px/1.85 system-ui, -apple-system, "Hiragino Sans", "Noto Sans JP", sans-serif;
+  }
+  main { max-width: 46rem; margin: 0 auto; }
+  header { padding: 3rem 0 1.5rem; border-bottom: 2px solid var(--ink); margin-bottom: 2rem; }
+  h1 { font-size: 1.75rem; line-height: 1.4; margin: 0 0 .6rem; }
+  .sub { color: var(--ink-2); font-size: 1.02rem; margin: 0 0 1rem; }
+  .meta { color: var(--ink-muted); font-size: .85rem; margin: 0; }
+  h2 {
+    font-size: 1.25rem; margin: 3rem 0 .25rem; padding-top: 1.5rem;
+    border-top: 1px solid var(--rule);
+  }
+  h2 .num { color: var(--ink-muted); font-weight: 400; margin-right: .5rem; }
+  h3 { font-size: 1.02rem; margin: 2rem 0 .5rem; }
+  p { margin: 0 0 1rem; }
+  .lede { font-size: 1.02rem; color: var(--ink-2); margin-bottom: 1.5rem; }
+  .banner {
+    background: var(--surface); border: 1px solid var(--border); border-left: 3px solid var(--s2);
+    padding: .9rem 1.1rem; border-radius: 6px; font-size: .9rem; color: var(--ink-2);
+    margin: 0 0 2rem;
+  }
+  .banner strong { color: var(--ink); }
+  figure {
+    margin: 1.75rem 0; padding: 1.25rem; background: var(--surface);
+    border: 1px solid var(--border); border-radius: 8px;
+  }
+  figcaption { font-size: .85rem; color: var(--ink-2); margin-top: .9rem; line-height: 1.75; }
+  figcaption b { color: var(--ink); font-weight: 600; }
+  svg { display: block; width: 100%; height: auto; overflow: visible; }
+  table { width: 100%; border-collapse: collapse; font-size: .88rem; margin: 1.25rem 0; }
+  th, td { text-align: left; padding: .5rem .6rem; border-bottom: 1px solid var(--rule); vertical-align: top; }
+  th { color: var(--ink-2); font-weight: 600; font-size: .82rem; }
+  td.num, th.num { text-align: right; font-variant-numeric: tabular-nums; }
+  code {
+    font: 400 .85em/1.5 ui-monospace, SFMono-Regular, Menlo, monospace;
+    background: var(--surface); border: 1px solid var(--border);
+    border-radius: 4px; padding: .1em .35em;
+  }
+  blockquote {
+    margin: 1.25rem 0; padding: .25rem 0 .25rem 1.1rem;
+    border-left: 3px solid var(--axis); color: var(--ink-2);
+  }
+  .key {
+    background: var(--surface); border: 1px solid var(--border);
+    border-radius: 8px; padding: 1.1rem 1.25rem; margin: 1.5rem 0;
+  }
+  .key p:last-child { margin-bottom: 0; }
+  .legend { display: flex; flex-wrap: wrap; gap: 1rem; font-size: .82rem; color: var(--ink-2); margin-top: .9rem; }
+  .legend span { display: inline-flex; align-items: center; gap: .4rem; }
+  .swatch { width: 11px; height: 11px; border-radius: 3px; display: inline-block; }
+  ul { margin: 0 0 1rem; padding-left: 1.3rem; }
+  li { margin-bottom: .6rem; }
+  details { margin-top: .9rem; font-size: .88rem; }
+  summary { cursor: pointer; color: var(--ink-2); }
+  pre { background: var(--surface); border: 1px solid var(--border); border-radius: 6px;
+        padding: .9rem 1.1rem; margin: 1.25rem 0; overflow-x: auto; line-height: 1.5;
+        font-size: .8rem; color: var(--ink-2);
+        font-family: ui-monospace, "SFMono-Regular", Menlo, Consolas, monospace; }
+  .tldr ol { margin: .2rem 0 0; padding-left: 1.4rem; }
+  .tldr li { margin-bottom: .55rem; }
+  .foot { margin-top: 4rem; padding-top: 1.5rem; border-top: 1px solid var(--rule);
+          font-size: .82rem; color: var(--ink-muted); }
+</style>
+</head>
+<body>
+<main>
+
+<!-- ══════════════════════════════════════════════════════════════════════════
+     Minimum Nomic — report template.
+
+     Fill every ALL-CAPS placeholder and delete every comment. The chapter
+     numbering, the class names and the order below are the shape the 2026-08
+     report settled on after being rewritten once; the reasons are stated in
+     each comment so that a departure is a decision rather than an oversight.
+
+     Rule for the whole document: every number carries its denominator, and a
+     claim the sample does not support is written as "cannot be claimed"
+     rather than rounded into a finding.
+     ══════════════════════════════════════════════════════════════════════ -->
+
+<header>
+  <h1>TITLE</h1>
+  <p class="sub">ONE SENTENCE SAYING WHAT IS BEING MEASURED, NOT WHAT WAS BUILT.</p>
+  <p class="meta">DRAFT vX.Y ・ KairosChain Bench ・ GAMES PLAYED YYYY-MM-DD TO YYYY-MM-DD</p>
+</header>
+
+<div class="banner">
+  <strong>Provisional.</strong> STATE THE SAMPLE SIZE AND THE HONESTY RULE: every figure
+  measured rather than estimated, and anything the sample does not support written as
+  "cannot be claimed".
+</div>
+
+<!-- TL;DR — put this before chapter 1, never after. A reader who stops here
+     should still leave with the findings, each with its denominator. Eight to
+     ten items; if an item needs a paragraph, it belongs in chapter 3. -->
+<div class="key tldr">
+<p style="margin:0 0 .7rem"><b>TL;DR</b> — before reading the rest.</p>
+<ol>
+<li><b>The setup.</b> WHAT WAS GIVEN TO WHOM, AND WHAT WAS DELIBERATELY WITHHELD.</li>
+<li><b>FINDING.</b> CLAIM, WITH ITS DENOMINATOR.</li>
+<li><b>FINDING.</b> ...</li>
+<li><b>What could not be claimed.</b> THE STRONGEST NEGATIVE RESULT.</li>
+</ol>
+</div>
+
+<!-- The run diagram. Prose cannot carry a pipeline; replace the prose with
+     this rather than printing both. One line per stage, cost on the right. -->
+<h3 style="margin-top:2.5rem">How a run proceeds</h3>
+
+<pre>
+1  PLAY A GAME                       one game = N turns / N model calls / ~N min
+      Player A ─┐
+      Player B ─┼──→ the game master decides only who speaks next
+      Player C ─┘      it compiles no rule set and adjudicates no legality
+         ↓
+2  RECORDS ACCUMULATE                append-only, one directory per game
+      ├ utterance log                … every player reads this
+      ├ reasoning log                … shown to no player, ever
+      └ turn-control record          … the game master's decisions and reasons
+         ↓
+3  MECHANICAL CHECKS                 check_gm.rb --falsify; no model is called
+         ↓
+4  ANALYSTS                          reanalyse.rb; the same models, fresh calls
+         ↓
+5  AUDIT                             audit_scores.rb; self-audit as the control
+         ↓
+6  MUTATION EXPERIMENT               mutate.rb then score_detections.rb
+      the answer key is ours, so no model decides whether a detection happened
+</pre>
+
+<h2><span class="num">1</span>Introduction</h2>
+
+<p class="lede">WHY THE ORDINARY EVALUATION SHAPE DOES NOT REACH WHAT IS BEING LOOKED FOR.</p>
+
+<p>WHAT NOMIC IS, IN TWO SENTENCES, FOR A READER WHO HAS NEVER HEARD OF IT.</p>
+
+<blockquote>THE QUESTION, STATED ONCE, IN ONE SENTENCE.</blockquote>
+
+<p><b>The design rule.</b> STATE IT: what is to be observed is not written into the system.
+Nothing instructs a participant to do the thing being measured, and nothing detects, scores
+or reacts to it during play. A stall, a deadlock, a malformed move is a result.</p>
+
+<h2><span class="num">2</span>Method</h2>
+
+<h3>2.1 The game</h3>
+<p>THE INITIAL RULES, AND WHICH ONE DOES WHAT. LINK TO THE APPENDIX FOR THE FULL TEXT.</p>
+
+<h3>2.2 Who is at the table</h3>
+<table>
+  <thead><tr><th>Seat</th><th>Tool</th><th>Model</th><th>Reasoning effort</th></tr></thead>
+  <tbody>
+    <tr><td>SEAT</td><td>CLI</td><td><code>MODEL</code></td><td>EFFORT OR "not settable"</td></tr>
+  </tbody>
+</table>
+<p><b>Record the effort setting even when it cannot be set.</b> A comparison that reuses two
+stored panels confounds model with effort, and the confound is invisible unless both were
+written down at the time.</p>
+
+<h3>2.3 What each participant is given — and what it is not</h3>
+<pre>
+Player      → its own identity + the INITIAL rules + every utterance so far
+              + one line asking for its reasoning. Nothing else.
+Game master → the roster + the INITIAL rules + every utterance so far.
+              Decides who speaks next. Renders nothing to anybody.
+Analyst     → the initial rules, both logs in full, the turn-control record.
+              A fresh call. NOT told which seat it held.
+</pre>
+
+<h3>2.4 What the game master is, exactly</h3>
+<h3>2.5 Analysis and scoring</h3>
+
+<h2><span class="num">3</span>Results</h2>
+
+<!-- One subsection per finding. Each opens with the finding, then the evidence,
+     then what it does not show. Quote the record verbatim; a summary removes
+     the material a reader needs to disagree with you. -->
+
+<h3>3.1 SHORTEST TRUE HEADLINE</h3>
+
+<h3>3.N The scoring instrument</h3>
+<p>IF A 0-10 SCORE IS USED, MEASURE IT BEFORE TRUSTING IT: judge-to-judge spread against
+judged-to-judged spread, and the movement when the same cell is scored twice. Where the
+first exceeds the second, say plainly that the score cannot rank models.</p>
+
+<h3>3.N+1 Planting one lie in a record</h3>
+<p>THE MUTATION RESULT. Include, without exception: the criterion declared BEFORE any result
+was read; the control arm and its false-alarm count; the per-game spread as well as the
+per-model rate; and the limits of the mutations themselves.</p>
+
+<h2><span class="num">4</span>Discussion</h2>
+
+<h3>4.1 What the games show</h3>
+<h3>4.2 What cannot be claimed</h3>
+<!-- Not a disclaimer section. Each item names the specific measurement that
+     would settle it, so the next round has a work list. -->
+<h3>4.3 What comes next</h3>
+
+<h2 id="appendix"><span class="num">A</span>Appendix A — the nine initial rules</h2>
+<p>Verbatim. Participants read the original wording; a translation goes beside it, never
+in place of it.</p>
+
+<h2 id="appendix-b"><span class="num">B</span>Appendix B — QUOTED MATERIAL IN FULL</h2>
+<p>Whatever the body quotes selectively belongs here in full, so that a reader who distrusts
+the selection can check it.</p>
+
+<div class="foot">
+  Records under <code>log/</code>, one directory per game, append-only.
+  Scripts: <code>.kairos/skillsets/minimum_nomic/bin/</code>.
+</div>
+
+</main>
+</body>
+</html>

data/templates/skillsets/minimum_nomic/skillset.json

@@ -1,6 +1,6 @@
 {
   "name": "minimum_nomic",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Minimum Nomic bench: three language models play a self-amending game with nine changeable rules, no goal and no termination condition, while a fourth acts as game master. Runnable scripts, not MCP tools — a game is started from the command line and its record is analysed, audited and mutation-tested afterwards.",
   "author": "Masaomi Hatakeyama",
   "layer": "L1",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kairos-chain
 version: !ruby/object:Gem::Version
-  version: 3.67.0
+  version: 3.69.0
 platform: ruby
 authors:
 - Masaomi Hatakeyama
@@ -594,6 +594,7 @@ files:
 - templates/skillsets/kairos_hook_projector/lib/mode_hooks_compiler.rb
 - templates/skillsets/kairos_hook_projector/lib/mode_hooks_locator.rb
 - templates/skillsets/kairos_hook_projector/lib/mode_hooks_schema.rb
+- templates/skillsets/kairos_hook_projector/lib/readable_gate_setup.rb
 - templates/skillsets/kairos_hook_projector/mode_hooks/_EXAMPLE.json
 - templates/skillsets/kairos_hook_projector/mode_hooks/_record_schema.json
 - templates/skillsets/kairos_hook_projector/mode_hooks/_schema.json
@@ -608,6 +609,7 @@ files:
 - templates/skillsets/kairos_hook_projector/test/test_mode_hooks_schema.rb
 - templates/skillsets/kairos_hook_projector/test/test_mode_hooks_validate.rb
 - templates/skillsets/kairos_hook_projector/test/test_readable_gate.rb
+- templates/skillsets/kairos_hook_projector/test/test_readable_gate_setup.rb
 - templates/skillsets/kairos_hook_projector/test/test_skillset_json.rb
 - templates/skillsets/kairos_hook_projector/tools/hooks_status.rb
 - templates/skillsets/kairos_hook_projector/tools/mode_hooks_add.rb
@@ -658,9 +660,12 @@ files:
 - templates/skillsets/minimum_nomic/bin/audit_scores.rb
 - templates/skillsets/minimum_nomic/bin/check_gm.rb
 - templates/skillsets/minimum_nomic/bin/cross_model.rb
+- templates/skillsets/minimum_nomic/bin/mutate.rb
 - templates/skillsets/minimum_nomic/bin/reanalyse.rb
 - templates/skillsets/minimum_nomic/bin/rules_initial.json
 - templates/skillsets/minimum_nomic/bin/run_gm.rb
+- templates/skillsets/minimum_nomic/bin/score_detections.rb
+- templates/skillsets/minimum_nomic/report/report_template.html
 - templates/skillsets/minimum_nomic/skillset.json
 - templates/skillsets/mmp/config/meeting.yml
 - templates/skillsets/mmp/knowledge/meeting_protocol_core/meeting_protocol_core.md