kairos-chain 3.66.0 → 3.68.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b16a89f65901c9eefc5b08e5c2b1503817625c35847304332316ddb01292f8da
-  data.tar.gz: 7724c71a90c96aa624003663b4e7a7381552a08d0afa857ca19969fdea997875
+  metadata.gz: 7ac682d1d3fc16af582fb7eadccc08c263b9a2161805de89859e0c0d036c694a
+  data.tar.gz: 5d5ebdcac2a80196a1ed4bdd322b69b5de9a027c23f384d315ab7ab5a5119e5f
 SHA512:
-  metadata.gz: 3dc1c2f28e0b5b515f89be1bf7eb6714c796deae4ab8382907b0248abcabefc74e2510c372c3a3fc18eb2b8c7d36accd58535d2b9528398b83e6d2b2618e3a8b
-  data.tar.gz: 5d33acb30a5c7510015d76c7d9d398597988e284e5420752385888e0814b19ba6332528cb701e925e82fb414f7c08bc3a3930ee990065070756701bcd07dc4ee
+  metadata.gz: 12b7c204a2e70e581d6746452e5faa64c991c8f07536d1531f3aebbae45dadcd783ccd75a736bd00bacecf92ffb00cd5dbb6cb1cba285fb8447d82c9899ca1d1
+  data.tar.gz: 63188706bfebce9144966aa795f26b875102ac66696e89100fd90e3b5fbca09705910a790cb0bf284dc20270a290e7a413cf7cb32413ec09fb55f2183f0ef991

data/CHANGELOG.md

@@ -4,6 +4,33 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.67.0] - 2026-08-15
+
+### Added
+
+- **The Minimum Nomic bench ships.** Three language models play a self-amending
+  game with nine changeable rules, no goal and no termination condition, while a
+  fourth decides only who speaks next. It lived at `bench/minimum_nomic/` in the
+  development checkout, which the gemspec never walked, so nobody outside this
+  repository could reproduce a run. It is now the `minimum_nomic` SkillSet under
+  `templates/skillsets/`, with the five scripts in `bin/`.
+
+  The single thing that kept it out was a hard-coded `../../.kairos/` path to the
+  `llm_client` adapters, which resolved only in the development checkout.
+  `llm_client` is now resolved as a **sibling SkillSet**
+  (`../../llm_client/lib/llm_client`), the same relative path in the gem's
+  templates and in a projected instance. When it is absent the run aborts naming
+  both directories it searched, rather than failing inside a `require`.
+
+  `bin/cross_model.rb` is new: it analyses a stored game with one named model at
+  one named reasoning effort, instead of the panel recorded in the game's own
+  line-up. Without it, a comparison between model generations reuses both stored
+  panels and confounds generation with effort — the stored games ran
+  `claude-opus-4-6` at medium and `claude-opus-5` at high.
+
+  Not yet demonstrated: no game has been played from an installed gem. Until one
+  has, treat distribution as untested.
+
 ## [3.65.0] - 2026-08-13
 
 ### Changed

data/bin/kairos-chain

@@ -406,6 +406,122 @@ 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
+    puts 'Installed, and reporting only — blocking is false, as the catalogue ships it.'
+    # 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.66.0"
+  VERSION = "3.68.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,112 @@
+# 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']
+          unless 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 }
+          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: '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,136 @@
+# 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
+
+  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

@@ -0,0 +1,150 @@
+# Minimum Nomic — a bench for watching language models build a system
+
+Minimum Nomic is a self-amending game. Nine initial rules, numbered 101 to 109,
+all of them changeable, and **no victory condition, no goal, no termination
+rule**. Three language models play it. A fourth is the game master.
+
+The bench does not measure whether the game runs. It watches **how participants
+think and act when the rules do not decide what happens** — what goals they
+invent, what system they build, where they cooperate and where they collide.
+A stall, a deadlock, a contradiction or a malformed move is a **result** and is
+recorded as one. A game that falls apart is either the game master's competence
+or a player's competence, and either way it is the measurement.
+
+**Do not make this robust.** Adding harness authority to prevent a foreseeable
+in-game failure is a regression, not a fix. The one thing that is protected is
+the record: an in-game failure is data, a lost record is nothing.
+
+## Running it
+
+Run from the project root — two of the three seats inherit that working
+directory, and what they can reach from it is part of the recorded lineup.
+
+It calls the command-line tools through the `llm_client` SkillSet's adapters.
+`llm_client` is a **sibling SkillSet**, so `bin/` resolves it as
+`../../llm_client/lib/llm_client` — the same relative path whether this copy is
+the gem's template under `templates/skillsets/` or an instance's projection
+under `.kairos/skillsets/`. It is a hard dependency: without `llm_client`
+projected alongside, `run_gm.rb` aborts naming both directories it looked in
+rather than failing inside a `require`.
+
+Paths below are written for an instance where this SkillSet has been projected.
+In the development checkout, substitute
+`KairosChain_mcp_server/templates/skillsets/minimum_nomic/bin/`.
+
+```
+ruby .kairos/skillsets/minimum_nomic/bin/run_gm.rb    --out log/nomic/g3 --turns 15
+ruby .kairos/skillsets/minimum_nomic/bin/check_gm.rb  log/nomic/g3 --falsify
+ruby .kairos/skillsets/minimum_nomic/bin/reanalyse.rb log/nomic/g3
+```
+
+One directory per game, a fresh one every time. A run refuses to start when the
+target already holds records, so a game is never destroyed and two games are
+never merged. Writing is append-only. A 15-turn game takes about 15 minutes and
+33 model calls.
+
+`check_gm.rb` runs mechanical checks over a finished game's own records and
+calls no model. `--falsify` poisons a temp copy and asserts each check goes red;
+a green check that has never been shown to go red is not evidence.
+
+`reanalyse.rb` re-reads a finished game and hands it to the analysts again under
+whatever the guideline currently says. The analysis is a pure function of the
+stored record, so changing the guideline costs no replay. Results append to
+`records/analyses_rescored.jsonl`, each row carrying the digest of the guideline
+that produced it, and the game's own record is never touched — two read-outs of
+the same game stay distinguishable instead of merging.
+
+`cross_model.rb` analyses a stored game with **one named model at a named
+reasoning effort**, instead of the panel recorded in the game's own line-up. It
+exists because `reanalyse.rb` reads the panel from the game, which is right for
+re-reading under a changed guideline and cannot answer "would a different model
+have caught this?". Results append to `records/analyses_crossmodel.jsonl`, kept
+separate so a cross-model read-out never merges with the game's own panel.
+
+```
+ruby .kairos/skillsets/minimum_nomic/bin/cross_model.rb log/nomic/g3 claude_code claude-opus-5 medium
+```
+
+Holding effort fixed is the point of the argument, not a convenience: the stored
+games ran `claude-opus-4-6` at medium and `claude-opus-5` at high, so any
+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.
+
+## What each participant is given
+
+```
+Player      → its own identity
+              + the INITIAL rule set (101-109)
+              + every player's utterances so far
+              + one line asking for its reasoning
+              Nothing else. It works out what is in force for itself.
+
+Game master → the roster
+              + the INITIAL rule set
+              + every player's utterances so far
+              Its only job is deciding who speaks next.
+              It renders nothing to anybody and tells no one what it concluded.
+
+Analyst     → the initial rules, both logs in full, the turn-control record
+              Runs after the game, as a fresh call with no memory of playing.
+              It is NOT told which seat it held.
+              Returns prose, then a 0-10 metacognitive competence score with
+              reasons for each player and for the game master.
+```
+
+The analysts are the same three models that played. They are not told which seat
+they held, because being told there is a self to find plants the conclusion — an
+analyst that recognises its own trace unprompted is showing something an
+instructed one cannot. Measured across five games: with the prompting sentence
+present, 3 of 3 analysts addressed it; with it removed, 0 of 12 did.
+
+The 0-10 scale is stated to the analysts as arbitrary and uncalibrated; the
+number is a coarse handle and the reasons are the substance. Read the scores
+knowing that **who did the scoring moves the number more than who was scored**.
+Over five games scored twice, the spread between judges was 1.35-1.50 points
+while the spread between the scored was 0.67-0.71, and re-scoring the same cell
+moved it 0.73 points on average. Judge severity is stable and real; a claim that
+one model is better at metacognition is not supportable at this sample size.
+
+No rule set compiled by the harness or by the game master reaches any
+participant. Under the older arrangement every player read one shared
+compilation, so players could not disagree about the rules — the divergence
+this bench most wants to observe was suppressed by the substrate. Every game
+recorded before 2026-08-12 was played that way and does not compare with a
+game played after it.
+
+## The corpus is never committed
+
+This directory is tracked by git and ships inside the gem, so that anyone who
+installs KairosChain can reproduce a run. The games are not, and are not to be.
+They live under `log/`, which is ignored. Protection of the record comes from
+append-only writing and from one directory per game, not from version control.
+
+## Known gaps, deliberately left
+
+- **No check asserts that the rule block in a player prompt is the initial set
+  and nothing else.** Measured 2026-08-12: a fabricated rule block injected into
+  every player prompt of a copied game leaves all six checks green. If the
+  harness ever regresses to delivering a compilation, nothing here notices.
+- **A public-log position number repeats across a failed call** (3 of the 13
+  games archived before this change). The number players cite is that position,
+  so renumbering either gaps what players see or moves what a citation points
+  at. Left until more games say which is worse.
+- **Two of the three seats could read the game's records if they looked** — one
+  runs read-only in the project root, one runs there with no sandbox at all.
+  Recorded in each game's lineup rather than solved.
+- **A mutation must not leave a grammatical scar.** Rewriting
+  `I vote **in favor** of X` as `I vote **against** of X` strands the *of*, and
+  that is a clue visible without consulting the record at all. It happened in 4
+  of 27 substitutions on 2026-08-15, and one analyst reverse-engineered the edit
+  from it. Check the grammar of the replacement, not only that exactly one
+  substitution was made.
+
+Seat and model used to be confounded — seat A was always the same model and
+always spoke first. Seat rotation landed on 2026-08-13, so games from the `s50`
+and `t100` series carry rotated line-ups while the `inv29` series does not. Read
+each game's own `lineup.jsonl` rather than assuming.
+
+Older copies of these scripts sit beside the games they produced, under
+`log/minimum_nomic_gm_20260810/`. **This directory is the live one.** Edit here.