kairos-chain 3.77.0 → 3.78.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca968a084e8868b9cbeaa3283850dd7e56095a503d661ce6e74158ec7555f0e3
-  data.tar.gz: 7a410b2edb98cd9bf02c8396f11d1d411e9b190456ea87402789d9a95aea5f16
+  metadata.gz: 3bdf5a0932b91258ccacf0520ca20eb252b7080c7ef3682f87edb8fdb07144c6
+  data.tar.gz: '09f911f59d0aba91f246f5ec6721cc4ee11f8534bd96ed73fc31edd3df1a78ff'
 SHA512:
-  metadata.gz: 5cea432521cb70bcc7ed1f354bb0a4abe1165d16a25ed185d8b3c46af5db0d00d57c459737e3a52f290a356d29356033cce8e6ef4c56e7526438eb6f7eba30d3
-  data.tar.gz: cf536e54e866a943d95d0209741c1a6658e6df62421f9a5e0e082983e98025057aa4e4dfc04ad08a4f96e7acfd9a982e69bde253d6f3986302325d9dd7ab65f3
+  metadata.gz: 884fe864157b0c5ea27cc9249de0378f4c8e53d0b724ef6c92e9adc85dd1a092e8c7291c1e0e778a20d3edf4058da92801968733f38017a73df60eb7b552ade3
+  data.tar.gz: c9061d247bee27b8525dae1d14f4acd1036e27d2c024b74228c43bc23211329285d418689aa6314c70f2e5f6060b9df4ad68e118870b680f6c411ab5d2de5cc7

data/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.78.0] - 2026-08-26
+
+### Fixed
+
+- **`readable_gate` — a failed note write no longer leaves an earlier turn's
+  note in place.** The carry-over note (shipped in 3.77.0) records which
+  record the gate blocked, so the recheck measures only what came after it. A
+  leftover note from an interrupted turn — 28 of 240 blocks draw no recheck —
+  survived the next block's failed note write, checked out as valid, and the
+  recheck judged the message that block had just made. A record with no uuid
+  was input enough. Every write failure now spends the leftover: deleted, or —
+  when deletion is refused — truncated in place, since deletion needs
+  directory-write while truncation needs only file-write, and an emptied note
+  fails the parse on every later read whatever the directory permits by then.
+  Only a leftover refusing both deletion and truncation survives, and the
+  design declares that state rather than claiming it closed. Found by
+  conformance review rounds 2-4: six reading contexts per round answering a
+  fixed claim list (21 → 4 → 2 → 1 claims), each finding reproduced end-to-end
+  before its fix, and round 4 closing with zero claims disputed. 133 tests /
+  815 assertions; 54 mutations killed 54/54; first-read stdout byte-identical
+  to the 3.74.0 baseline across up to 2,520 inputs measured by four
+  independent contexts.
+
 ## [3.77.0] - 2026-08-26
 
 ### Added

data/lib/kairos_mcp/version.rb

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

data/templates/skillsets/kairos_hook_projector/hooks/readable_gate.rb

@@ -431,27 +431,61 @@ module KairosHookProjector
     # Written to a temporary name and renamed, so a reader can never see a
     # half-written note. The pid is in the temporary name because two modes'
     # gates can run against one session at the same moment.
+    #
+    # After a block, the note is this block's or absent. A write that succeeds
+    # replaces any earlier note through the rename; a write that fails must not
+    # leave one either, because a leftover from an interrupted turn checks out
+    # as valid — fresh, same session, deletable — and the recheck then measures
+    # against the wrong block: round 2 of the conformance review demonstrated
+    # the message this turn blocked being judged a second time. So every
+    # failure path spends whatever note is already at the key.
     def write_note(transcript_path, cfg, uuid)
-      return 'no uuid to record' if uuid.nil? || uuid.to_s.empty?
-
       path = note_path(transcript_path, cfg)
       return nil if path.nil? # no log declared: not a failure, a declared absence
 
-      FileUtils.mkdir_p(File.dirname(path))
-      tmp = "#{path}.#{Process.pid}.tmp"
-      File.write(
-        tmp,
-        JSON.generate(
-          'transcript' => note_key_path(transcript_path).scrub,
-          'mode' => cfg.mode_name.to_s.scrub,
-          'blocked_uuid' => uuid.to_s.scrub,
-          'at' => Time.now.to_f
+      return spend_stale_note(path, 'no uuid to record') if uuid.nil? || uuid.to_s.empty?
+
+      begin
+        FileUtils.mkdir_p(File.dirname(path))
+        tmp = "#{path}.#{Process.pid}.tmp"
+        File.write(
+          tmp,
+          JSON.generate(
+            'transcript' => note_key_path(transcript_path).scrub,
+            'mode' => cfg.mode_name.to_s.scrub,
+            'blocked_uuid' => uuid.to_s.scrub,
+            'at' => Time.now.to_f
+          )
         )
-      )
-      File.rename(tmp, path)
-      nil
-    rescue StandardError => e
-      "#{e.class}: #{e.message}"
+        File.rename(tmp, path)
+        nil
+      rescue StandardError => e
+        spend_stale_note(path, "#{e.class}: #{e.message}")
+      end
+    end
+
+    # Deletion first, truncation as the fallback. "A leftover that cannot be
+    # deleted here cannot be spent at the recheck either" was round 3's found
+    # assumption: it identifies write-time state with read-time state, and a
+    # directory made writable again inside the block-to-recheck window let the
+    # recheck spend a leftover this path had already failed to delete. Deleting
+    # needs directory-write; truncating needs only file-write, so the fallback
+    # usually works exactly where the unlink fails, and an emptied note fails
+    # the parse on every later read whatever the directory permits by then.
+    # Only when both are refused does the leftover stay valid, and that state
+    # is declared in design §7 rather than closed.
+    def spend_stale_note(path, reason)
+      File.unlink(path)
+      "#{reason}; a stale note was deleted"
+    rescue Errno::ENOENT
+      reason
+    rescue StandardError
+      begin
+        File.write(path, '')
+        "#{reason}; a stale note could not be deleted and was emptied instead"
+      rescue StandardError => e
+        "#{reason}; a stale note could not be deleted (#{e.class})"
+      end
     end
 
     # [uuid this gate blocked, nil] or [nil, why not].

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

@@ -233,8 +233,10 @@ MUTATIONS = [
           note(cfg, "NOTE-WRITE-FAILED: #{failure}")
           out.delete('decision')
         end}],
+  # Retargeted after round 2: the no-uuid return now spends the leftover first,
+  # so the anchor moved with it. The mutation is unchanged in spirit.
   ['N18 write_note records a uuid it was not given',
-   %q{      return 'no uuid to record' if uuid.nil? || uuid.to_s.empty?},
+   %q{      return spend_stale_note(path, 'no uuid to record') if uuid.nil? || uuid.to_s.empty?},
    %q{      uuid = 'unknown' if uuid.nil? || uuid.to_s.empty?}],
   ['N19 the note is written whole rather than renamed into place',
    %q{      File.rename(tmp, path)},
@@ -272,6 +274,47 @@ MUTATIONS = [
         blocked_uuid, why_not = take_note(transcript_path, cfg)
         blocked_uuid, why_not = take_note(transcript_path, cfg) if blocked_uuid},
    ],
+
+  # --- what round 2 of the conformance review found --------------------------
+  #
+  # A leftover note from an interrupted turn is valid on its face, so a block
+  # whose own note write fails must spend it — otherwise the recheck reads the
+  # leftover and judges the message this turn just blocked. One seat of six
+  # found it, by composing two declared behaviours (the 11.7% unconsumed-note
+  # population and the no-uuid write failure) that every fixture had exercised
+  # only in isolation.
+  ['N29 the spend is a no-op that still reports success',
+   %q{    def spend_stale_note(path, reason)
+      File.unlink(path)},
+   %q{    def spend_stale_note(path, reason)
+      return reason if path
+      File.unlink(path)}],
+  ['N30 the no-uuid failure path stops spending the leftover',
+   %q{      return spend_stale_note(path, 'no uuid to record') if uuid.nil? || uuid.to_s.empty?},
+   %q{      return 'no uuid to record' if uuid.nil? || uuid.to_s.empty?}],
+  ['N31 the write\'s exception path stops spending the leftover',
+   %q{        spend_stale_note(path, "#{e.class}: #{e.message}")},
+   %q{        "#{e.class}: #{e.message}"}],
+
+  # --- what round 3 of the conformance review found --------------------------
+  #
+  # Unspendability is not stable: a directory that refuses the unlink at block
+  # time and permits it again before the recheck let the recheck spend the
+  # leftover this block had failed to delete. Three of five verifying contexts
+  # reached the same window independently. The truncation fallback is what
+  # closes it; this deletes the fallback and the window reopens.
+  ['N32 the truncation fallback is deleted, so a lifted window revives the leftover',
+   %q{    rescue StandardError
+      begin
+        File.write(path, '')
+        "#{reason}; a stale note could not be deleted and was emptied instead"
+      rescue StandardError => e
+        "#{reason}; a stale note could not be deleted (#{e.class})"
+      end
+    end},
+   %q{    rescue StandardError => e
+      "#{reason}; a stale note could not be deleted (#{e.class})"
+    end}],
 ].freeze
 
 def run_suite(root)

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

@@ -2479,4 +2479,148 @@ class TestReadableGate < Minitest::Test
       assert_includes message, 'stamped ahead of the clock', message
     end
   end
+
+  # --- what round 2 of the conformance review found ---------------------------
+  #
+  # A leftover note from an interrupted turn checks out as valid: fresh, same
+  # session, deletable. When the next block's own note write fails, the recheck
+  # read that leftover and judged the message this turn had just blocked — no
+  # foreign hook involved, no filesystem failure needed (a record with no uuid
+  # is enough). After a block, the note must be this block's or absent.
+
+  def test_a_failed_note_write_also_spends_the_note_an_earlier_turn_left
+    Dir.mktmpdir do |tmp|
+      cfg_path = File.join(tmp, 'cfg.json')
+      tx_path = File.join(tmp, 't.jsonl')
+      log_path = File.join(tmp, 'gate.log')
+      raw = { 'mode_name' => 'test', 'log_path' => log_path, 'max_headings' => 3 }
+      File.write(cfg_path, JSON.generate(raw), encoding: 'UTF-8')
+      File.write(tx_path, rows_json([row_for('assistant', text: BLOCKED, uuid: 'AAA'),
+                                     row_for('assistant', text: BLOCKED)]),
+                 encoding: 'UTF-8')
+      cfg_obj = G::Config.new(raw, cfg_path)
+      assert_nil G.write_note(tx_path, cfg_obj, 'AAA'), 'the interrupted turn left its note'
+
+      out, = run_script(cfg_path, JSON.generate('transcript_path' => tx_path,
+                                                'stop_hook_active' => false))
+      assert_equal 'block', JSON.parse(out)['decision'], 'the turn is still blocked'
+      log = File.read(log_path, encoding: 'UTF-8')
+      assert_includes log, 'NOTE-WRITE-FAILED: no uuid to record; a stale note was deleted', log
+      assert_empty Dir.glob(File.join(File.dirname(G.note_path(tx_path, cfg_obj)), '*')),
+                   'the leftover would name a block this turn did not make'
+
+      _out2, = run_script(cfg_path, JSON.generate('transcript_path' => tx_path,
+                                                  'stop_hook_active' => true))
+      log = File.read(log_path, encoding: 'UTF-8')
+      assert_includes log, 'SKIP-nonote', "the recheck must decline, not judge: #{log}"
+      refute_includes log, 'RECHECK-',
+                      "a verdict here re-judges the message this turn blocked: #{log}"
+    end
+  end
+
+  # When the leftover cannot be spent either, the two failures must compose to
+  # the same refusal: the leftover stays, and the recheck refuses it as the
+  # note it cannot delete.
+  def test_a_leftover_the_failed_write_cannot_spend_is_refused_at_the_recheck
+    Dir.mktmpdir do |tmp|
+      cfg_path = File.join(tmp, 'cfg.json')
+      tx_path = File.join(tmp, 't.jsonl')
+      logs = File.join(tmp, 'logs')
+      FileUtils.mkdir_p(logs)
+      log_path = File.join(logs, 'gate.log')
+      raw = { 'mode_name' => 'test', 'log_path' => log_path, 'max_headings' => 3 }
+      File.write(cfg_path, JSON.generate(raw), encoding: 'UTF-8')
+      File.write(tx_path, rows_json([row_for('assistant', text: BLOCKED, uuid: 'AAA'),
+                                     row_for('assistant', text: BLOCKED, uuid: 'BBB')]),
+                 encoding: 'UTF-8')
+      cfg_obj = G::Config.new(raw, cfg_path)
+      assert_nil G.write_note(tx_path, cfg_obj, 'AAA'), 'the interrupted turn left its note'
+      notes = File.dirname(G.note_path(tx_path, cfg_obj))
+
+      File.chmod(0o555, notes) # neither the new write nor the spend can touch it
+      begin
+        out, = run_script(cfg_path, JSON.generate('transcript_path' => tx_path,
+                                                  'stop_hook_active' => false))
+        assert_equal 'block', JSON.parse(out)['decision'], 'the turn is still blocked'
+        log = File.read(log_path, encoding: 'UTF-8')
+        assert_includes log, 'a stale note could not be deleted',
+                        "the second failure must be visible too: #{log}"
+
+        run_script(cfg_path, JSON.generate('transcript_path' => tx_path,
+                                           'stop_hook_active' => true))
+      ensure
+        File.chmod(0o755, notes)
+      end
+
+      log = File.read(log_path, encoding: 'UTF-8')
+      assert_includes log, 'SKIP-nonote-unspent',
+                      "the unspendable leftover must be refused: #{log}"
+      refute_includes log, 'RECHECK-',
+                      "a verdict here re-judges the message this turn blocked: #{log}"
+    end
+  end
+
+  # Round 3: unspendability is not stable. A directory that refuses the unlink
+  # at block time and permits it again before the recheck let the recheck spend
+  # the leftover this block had failed to delete — round 2's defect through a
+  # transient window. Deleting needs directory-write; truncating needs only
+  # file-write; an emptied note fails the parse on every later read, whatever
+  # the directory permits by then.
+  def test_a_leftover_spent_by_truncation_stays_spent_after_the_window_lifts
+    Dir.mktmpdir do |tmp|
+      cfg_path = File.join(tmp, 'cfg.json')
+      tx_path = File.join(tmp, 't.jsonl')
+      logs = File.join(tmp, 'logs')
+      FileUtils.mkdir_p(logs)
+      log_path = File.join(logs, 'gate.log')
+      raw = { 'mode_name' => 'test', 'log_path' => log_path, 'max_headings' => 3 }
+      File.write(cfg_path, JSON.generate(raw), encoding: 'UTF-8')
+      File.write(tx_path, rows_json([row_for('assistant', text: BLOCKED, uuid: 'AAA'),
+                                     row_for('assistant', text: BLOCKED, uuid: 'BBB')]),
+                 encoding: 'UTF-8')
+      cfg_obj = G::Config.new(raw, cfg_path)
+      assert_nil G.write_note(tx_path, cfg_obj, 'AAA'), 'the interrupted turn left its note'
+      notes = File.dirname(G.note_path(tx_path, cfg_obj))
+
+      File.chmod(0o555, notes) # the write and the unlink both fail; file-write does not
+      begin
+        out, = run_script(cfg_path, JSON.generate('transcript_path' => tx_path,
+                                                  'stop_hook_active' => false))
+        assert_equal 'block', JSON.parse(out)['decision'], 'the turn is still blocked'
+      ensure
+        File.chmod(0o755, notes) # the window lifts before the recheck
+      end
+      log = File.read(log_path, encoding: 'UTF-8')
+      assert_includes log, 'a stale note could not be deleted and was emptied instead', log
+
+      run_script(cfg_path, JSON.generate('transcript_path' => tx_path,
+                                         'stop_hook_active' => true))
+      log = File.read(log_path, encoding: 'UTF-8')
+      refute_includes log, 'RECHECK-',
+                      "the emptied leftover must not yield a verdict once the window lifts: #{log}"
+      assert_includes log, 'SKIP-nonote-mismatch',
+                      "an emptied note fails the parse and is refused by name: #{log}"
+    end
+  end
+
+  # The exception path of the write — not just the no-uuid return — must spend
+  # the leftover too. Driven in-process because the deterministic failure is a
+  # directory squatting the temporary name, and that name carries the pid.
+  def test_a_write_that_raises_spends_the_leftover_before_reporting
+    Dir.mktmpdir do |tmp|
+      c = G::Config.new({ 'mode_name' => 'test', 'log_path' => File.join(tmp, 'gate.log') },
+                        '<inline>')
+      tx = File.join(tmp, 't.jsonl')
+      assert_nil G.write_note(tx, c, 'AAA'), 'the interrupted turn left its note'
+      path = G.note_path(tx, c)
+      FileUtils.mkdir_p("#{path}.#{Process.pid}.tmp") # the write raises, the spend can work
+
+      failure = G.write_note(tx, c, 'BBB')
+      refute_nil failure, 'the write must report its failure'
+      assert_includes failure, 'a stale note was deleted', failure
+      refute File.exist?(path), 'the leftover would name a block this turn did not make'
+      assert_equal [nil, 'nonote'], G.take_note(tx, c),
+                   'the recheck must find nothing rather than the wrong block'
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kairos-chain
 version: !ruby/object:Gem::Version
-  version: 3.77.0
+  version: 3.78.0
 platform: ruby
 authors:
 - Masaomi Hatakeyama