kairos-chain 3.79.0 → 3.80.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22b92a50151e63d6f243858700e0a0982dd569ce6df05133362dcda4077d6fd6
-  data.tar.gz: d6d5559901257355633ba3a9d26a43af62293757b67f98c011bd795be4dee8f7
+  metadata.gz: e2c2d4657c313e3452dbdfaa619a7949d9682961fe4e9ccc15e772ff580f300a
+  data.tar.gz: f276e35c55991a4ea269309e7ff6f2a94208a4e86967dc9754685a258525645c
 SHA512:
-  metadata.gz: 8f1bdd48fc2dd110b151e1bc2a8aff18278ea2bc0d97d801dcf3bdd086462e8d6d97b27fdd0a81b75dac820f84aa0786a076eeef84b8ae44d5012e1e435141c0
-  data.tar.gz: 0c401f4330cff3dc4af3bf6a4277fcf68412e93fec79acc6eb50a12f7e19c84c6eec298ba5527938e8fc8e2dc983a192383f7babec0c1741dde0e47aca993985
+  metadata.gz: d10d880b482015c17e13014e432bf383cb8003f947ce1caabc4f3f24e775228facb81f042466917f530aa4c4018443cb33567c7fd8ba41c2e3a56149a4db2417
+  data.tar.gz: 2f4b29826187f483df3a95d601623f587e28eb5575670a235706c4bc7bc8bbc73d285f3ab60f9012fd0ae391a36f294c6a28866fb9a777d60bd1b361c7e9e987

data/CHANGELOG.md

@@ -4,6 +4,65 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.80.0] - 2026-08-27
+
+### Changed
+
+- **`readable_gate`: the measurement bound is the hook's own remaining time,
+  not a mode's declaration.** `measure_timeout_seconds` is retired, and its
+  whole observable surface goes with it — the clamp, the type-error clause,
+  and the silent death where `0` or a negative passed the Integer check,
+  reached `Regexp.timeout=` and killed the gate with exit 0, empty stdout and
+  no log file. A mode file must not be able to silence the gate by arithmetic
+  (operator ruling, 2026-08-27). A config still declaring the key flows
+  through `checked()` as an unknown key and is read by nobody.
+
+  Time protection is now `bounded_match`, the one seam every mode-supplied
+  match passes through: remaining computed from an absolute deadline fixed at
+  `main`'s first statement, a floor at one millisecond (`Regexp.timeout=`
+  silently stores nil for positive values under 1e-9), the grant set to the
+  remaining time, and the grant revoked as the match ends — no match runs
+  under an authorisation granted to another. Announce, specimen, shorthand and
+  both gloss operands route through it; `each_match` starts every match inside
+  the seam, so no ordering exists in which a match begins before the clock is
+  read. The recheck's poll is charged as time actually spent, which retires
+  the old static arithmetic that billed a first read for the four seconds only
+  a recheck uses. `HOOK_TIMEOUT_MARGIN` drops from 1.0 to 0.5 (start-up
+  measured at a 0.033s median), recovering half the band the old margin
+  discarded.
+
+  **Three declared output differences** against the pre-bound gate: a config
+  declaring the key loses its problem clause and the gate runs when no other
+  problem remains; the measurement-exceeded banner quotes elapsed time against
+  the live budget instead of a mode-declared value; and the budget itself
+  grows from a flat 5s to the deadline's remainder (≈9.4s on a first read,
+  ≈5.4s on a recheck), so a measurement finishing between 5s and the budget
+  now yields a verdict where it used to yield NOT RUN. Probed at 10, 12 and 14
+  configurations by three independent contexts: no undeclared difference.
+
+  Design frozen at v0.7 after six review rounds; implementation conformance
+  round 1 REVISE, round 2 APPROVE 3/3 with zero DOES NOT HOLD. Suite 152 runs
+  / 948 assertions green; the mutation harness gains 19 rows paired one-to-one
+  with the design's table (anchors verified 72/72), plus a label filter and
+  early exit so a narrowed sweep is possible and says so in its summary.
+
+### Fixed
+
+- **`readable_gate`: the carry-over note's truncation fallback refuses to
+  follow a symlink.** When a stale note cannot be deleted the gate empties it
+  in place, and that write followed whatever the note's name pointed at: with
+  a symlink planted at the note key and the notes directory made unwritable so
+  the unlink is refused, the emptying truncated a file outside the notes
+  directory. The open now carries `File::NOFOLLOW`, so a final-component
+  symlink fails with `ELOOP` and lands in the existing refusal arm — the
+  leaning is to refuse, never to write through a name to somewhere the path
+  did not say. The leftover link stays unspent and every later recheck refuses
+  it. A hard link and an intermediate-component symlink still reach through;
+  both need the same outside hand and are declared rather than closed.
+
+- `kairos_hook_projector` SkillSet version 0.5.0 → 0.6.0, so instances
+  actually receive the two changes above on `skillset upgrade`.
+
 ## [3.79.0] - 2026-08-26
 
 ### Fixed

data/lib/kairos_mcp/version.rb

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

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

@@ -64,30 +64,26 @@ module KairosHookProjector
     # the limit emits nothing at all — no verdict, no banner, no log line — so
     # the gate stops enforcing and the measurement loses rows, both silently.
     HOOK_TIMEOUT = 10.0
-    # Held back from the pair for interpreter start-up and for the poll's own
-    # overhead. Measured 2026-08-22 on Ruby 3.4.10: 0.030s for the first read's
-    # 15 tail reads, 0.075s for the recheck's 40 plus turn_marker, and roughly
-    # 0.3s more for interpreter start-up. An earlier version of this line said
-    # 0.2-0.6s for the poll alone, which the shipped code cannot reproduce.
-    #
-    # Round 5 measured start-up itself at a median 0.033s through the projected
-    # `sh -c ruby …` form, so 1.0 is about thirty times what it holds back. Left
-    # as it stands: the value is the measurement bound's, and the bound is no
-    # longer part of this design. See docs/drafts on the bound.
-    HOOK_TIMEOUT_MARGIN = 1.0
-    # What is left for measurement once the recheck has spent its budget. A mode
-    # asking for more than this is honoured up to here and no further: the
-    # alternative is a mode file being able to silence the gate by arithmetic.
-    #
-    # A constant, and wrong in a way that is known and recorded: it charges a
-    # first read for the four seconds only a recheck spends. Rounds 4 and 5
-    # replaced it twice — one ceiling per read, then a clock read at the top of
-    # main — and round 5's review falsified both, the second because a bound
-    # applied per match bounds the number this file quotes and not the time it
-    # spends. The bound is therefore carved out of this design and carried in
-    # its own, and this line is back to the shape shipped since 6d7fe02.
-    MEASURE_TIMEOUT_CEILING =
-      HOOK_TIMEOUT - HOOK_TIMEOUT_MARGIN - (RECHECK_POLL_ATTEMPTS * POLL_DELAY)
+    # Held back for what the deadline cannot see: interpreter start-up before
+    # main's first clock read, and the output written after measurement ends.
+    # Start-up measured at 0.033s median over 8 runs through the projected
+    # `sh -c ruby …` form (2026-08-27, consistent with round 5's 0.033-0.039s);
+    # the log append and JSON emit are under 10ms. The previous value, 1.0, was
+    # about thirty times the measured start-up and discarded ~0.95s in which
+    # the pre-bound gate would have measured and blocked. Pinned by an equality
+    # assert, not by the wall-time band: the band's flake headroom and kill
+    # margin always sum to exactly this value, so no band can pin it robustly
+    # from both sides.
+    HOOK_TIMEOUT_MARGIN = 0.5
+    # The least remaining time bounded_match will grant. Two grounds. First,
+    # Regexp.timeout= silently stores nil — no bound at all — for positive
+    # values below 1e-9 (measured on Ruby 3.4.10: 1e-9 is kept, 7.5e-10 reads
+    # back nil), so a remaining that small must refuse rather than arm nothing.
+    # Second, a measurement with under a millisecond left cannot produce a
+    # verdict anyway; raising is the honest outcome. Pinned by equality in both
+    # directions: lowering it re-opens the silent-nil window, raising it
+    # quietly shrinks every budget.
+    MIN_TIMEOUT = 0.001
 
     # Built from single-quoted strings so that `#{` in a pattern stays literal
     # rather than becoming interpolation, and anchored with \A because Python's
@@ -110,12 +106,14 @@ module KairosHookProjector
       'specimen_patterns' => [],
       'vocab_min_lines' => 1,
       'blocking' => true,
-      # A mode-supplied pattern with nested quantifiers backtracks without
-      # bound: one such pattern had not returned after two minutes on a
-      # 74-character line, burning the hook's whole budget every turn. Ruby
-      # bounds each match with Regexp.timeout; the deadline in measure() keeps
-      # the total bounded too, which is what the Python SIGALRM did.
-      'measure_timeout_seconds' => 5,
+      # measure_timeout_seconds is deliberately absent. It was a mode-declared
+      # bound on measurement time, and its whole observable surface — the
+      # clamp, the type-error clause, the 0-or-negative silent death, and the
+      # 5-second budget itself — was retired by the 2026-08-27 operator ruling
+      # ("no mode-facing bound setting"): a mode file must not be able to
+      # silence the gate by arithmetic. A config still declaring it is passed
+      # through checked() as an unknown key and read by nobody. Time protection
+      # is bounded_match's, derived from the hook's own remaining time.
       'log_max_bytes' => 1024 * 1024,
       'banner_prefix' => 'gate',
       # nil, and pinned here, because nil is what note() reads as "this mode
@@ -126,7 +124,7 @@ module KairosHookProjector
     }.freeze
 
     INT_KEYS = %w[max_lines max_headings max_tables diagram_required_over_lines
-                  vocab_min_lines measure_timeout_seconds log_max_bytes].freeze
+                  vocab_min_lines log_max_bytes].freeze
     LIST_KEYS = %w[announce_patterns shorthand_patterns gloss_patterns
                    specimen_patterns].freeze
     # log_path is deliberately absent. It was added here once, and the cost was
@@ -151,7 +149,7 @@ module KairosHookProjector
                   :max_lines, :max_headings, :max_tables, :diagram_over_lines,
                   :vocab_min_lines,
                   :blocking, :banner_prefix, :rewrite_instruction, :log_path,
-                  :announce, :shorthand, :gloss, :specimen, :measure_timeout,
+                  :announce, :shorthand, :gloss, :specimen,
                   :log_max_bytes
 
       def initialize(raw, path)
@@ -188,18 +186,6 @@ module KairosHookProjector
         # list. Text explaining the vocabulary rule has to name the shapes it
         # governs, and naming them is not using them.
         @specimen = merged['specimen_patterns'].map { |p| Regexp.new(p) }
-        # Clamped, not rejected: a mode that asks for 6 seconds gets what fits
-        # rather than a refusal it cannot act on. 4 seconds of recheck poll plus
-        # 6 of measurement is 10.4 against a 10-second hook limit, and the hook
-        # dies with no output, so the gate would silently stop enforcing for
-        # exactly the modes whose patterns are expensive enough to need the time.
-        requested = merged['measure_timeout_seconds']
-        @measure_timeout =
-          if requested.is_a?(Numeric) && requested > MEASURE_TIMEOUT_CEILING
-            MEASURE_TIMEOUT_CEILING
-          else
-            requested
-          end
         @log_max_bytes = merged['log_max_bytes']
       end
 
@@ -474,6 +460,16 @@ module KairosHookProjector
     # 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.
+    #
+    # The truncation refuses to follow a symlink. The note's name sits in
+    # operator space, and round 4 planted a link there — the directory then
+    # made unwritable so the unlink cannot spend it — and pointed the old
+    # File.write at a file outside the notes directory. NOFOLLOW turns that
+    # open into an ELOOP, which lands in the refusal arm below: the leaning is
+    # to refuse, never to write through a name to somewhere the path did not
+    # say. A hard link, or a link planted higher up the path, still reaches
+    # through — each needs the same outside hand that plants the link, and both
+    # are declared rather than closed.
     def spend_stale_note(path, reason)
       File.unlink(path)
       "#{reason}; a stale note was deleted"
@@ -481,7 +477,7 @@ module KairosHookProjector
       reason
     rescue StandardError
       begin
-        File.write(path, '')
+        File.open(path, File::WRONLY | File::TRUNC | File::NOFOLLOW).close
         "#{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})"
@@ -694,44 +690,74 @@ module KairosHookProjector
 
     # --- measurement ---------------------------------------------------------
 
-    # The deadline reaches here because one pattern can produce many matches on
-    # one line, and the specimen scan runs its own patterns before the shorthand
-    # loop is entered at all. Bounding only the shorthand loop, which is what the
-    # first fix did, left both of those unbounded — the same invariant-as-an-AND
-    # with one half done that this work keeps producing.
-    def each_match(regexp, string, deadline = nil)
-      pos = 0
-      while pos <= string.length && (m = regexp.match(string, pos))
-        raise MeasureTimeout if deadline && monotonic > deadline
+    # The one gate every mode-supplied match passes through. The invariant is
+    # over match operations, not call sites: no mode pattern ever starts a
+    # match without a bound computed from the time actually remaining, and no
+    # match runs under an authorisation granted to another — the grant is
+    # revoked as the match ends, whichever way it ends. Both halves are
+    # review-taught: naming three sites and bounding those left announce and
+    # both gloss operands unbounded, and granting without revoking let a match
+    # outside the seam inherit the previous grant, which made every bypass
+    # unobservable (measured at +65µs against a band needing +0.25s).
+    #
+    # The floor: a remaining below MIN_TIMEOUT raises instead of arming the
+    # bound, because Regexp.timeout= silently stores nil — no bound at all —
+    # for positive values under 1e-9, and a sub-millisecond measurement cannot
+    # finish regardless. The check precedes the match, so no ordering exists
+    # in which a match starts and the clock is read only after it.
+    #
+    # A nil deadline is the --report path: offline calibration, run by the
+    # operator outside the hook limit, deliberately unbounded.
+    #
+    # monotonic is read through the module helper and must stay that way: the
+    # floor fixture stubs it and counts the calls, so inlining the clock here
+    # is a mutation that fixture kills.
+    def bounded_match(regexp, string, pos, deadline)
+      return regexp.match(string, pos) if deadline.nil?
+
+      remaining = deadline - monotonic
+      raise MeasureTimeout if remaining < MIN_TIMEOUT
+
+      Regexp.timeout = remaining
+      begin
+        regexp.match(string, pos)
+      ensure
+        Regexp.timeout = nil
+      end
+    end
+
+    # In a named helper so the formula is assertable: an assert against an
+    # inline expression only re-derives it, which is a test that cannot fail.
+    def deadline_for(started)
+      started + (HOOK_TIMEOUT - HOOK_TIMEOUT_MARGIN)
+    end
 
+    def each_match(regexp, string, deadline)
+      pos = 0
+      while pos <= string.length && (m = bounded_match(regexp, string, pos, deadline))
         yield m
         pos = m.end(0) > m.begin(0) ? m.end(0) : m.begin(0) + 1
       end
     end
 
-    def specimen_spans(line, cfg, deadline = nil)
+    def specimen_spans(line, cfg, deadline)
       spans = []
       cfg.specimen.each do |pattern|
-        raise MeasureTimeout if deadline && monotonic > deadline
-
         each_match(pattern, line, deadline) { |m| spans << [m.begin(0), m.end(0)] }
       end
       spans
     end
 
-    # measure() under a wall-clock bound.
-    #
-    # Two bounds, because they catch different things. Regexp.timeout stops one
-    # pattern that backtracks without returning. The deadline inside measure
-    # stops many patterns that each return slowly — which is what the Python
-    # SIGALRM bounded, and what a per-operation limit alone would not.
-    def measure_bounded(text, cfg)
-      return measure(text, cfg, nil) unless cfg.measure_timeout
-
+    # measure() with the deadline threaded through. This wrapper owns the two
+    # things that sit outside any single match: whatever Regexp.timeout the
+    # caller had is saved and restored here, outside every per-match grant,
+    # and a match cut by Ruby's own Regexp::TimeoutError maps to the same
+    # MeasureTimeout the deadline raises — one banner for both ways of
+    # running out.
+    def measure_bounded(text, cfg, deadline)
       previous = Regexp.timeout
-      Regexp.timeout = cfg.measure_timeout
       begin
-        measure(text, cfg, monotonic + cfg.measure_timeout)
+        measure(text, cfg, deadline)
       rescue Regexp::TimeoutError
         raise MeasureTimeout
       ensure
@@ -744,7 +770,7 @@ module KairosHookProjector
     end
 
     # Pure. [metrics, failures]. The whole judgement lives here.
-    def measure(text, cfg, deadline = nil)
+    def measure(text, cfg, deadline)
       raw = text.split("\n", -1)
 
       prose = []
@@ -765,27 +791,20 @@ module KairosHookProjector
       tables = prose.count { |l| TABLE_SEP.match(l) }
 
       first = raw.find { |l| !l.strip.empty? } || ''
-      announced = !(cfg.announce && cfg.announce.match(first)).nil?
+      announced = !(cfg.announce && bounded_match(cfg.announce, first, 0, deadline)).nil?
 
       seen = {}
       unglossed = []
       if !cfg.shorthand.empty? && prose.length >= cfg.vocab_min_lines
         prose.each_with_index do |line, i|
-          # No per-line check. There was one here, and round 3 showed nothing
-          # could falsify it: the specimen scan and the loop between patterns
-          # both read the clock, and one of them runs before anything on a line
-          # can be slow. An unfalsifiable guard is not defence, it is a claim,
-          # so it is deleted rather than given a test that cannot fail.
+          # No per-line or per-pattern check. Every match on this line starts
+          # inside bounded_match, which reads the clock before it; a check here
+          # would be a guard no fixture can redden — the shape this file
+          # deleted once already ("an unfalsifiable guard is not defence, it
+          # is a claim") and declines to reintroduce.
           nxt = i + 1 < prose.length ? prose[i + 1] : ''
           spans = specimen_spans(line, cfg, deadline)
           cfg.shorthand.each do |pattern|
-            # Per pattern, not only per line. Regexp.timeout bounds one match,
-            # so a line carrying n patterns could overshoot the deadline by
-            # n times that bound while the clock was read only once, between
-            # lines. The check above still stands: it catches a line whose
-            # specimen scan alone is what runs long.
-            raise MeasureTimeout if deadline && monotonic > deadline
-
             each_match(pattern, line, deadline) do |m|
               tok = m.size > 1 ? m[1] : m[0]
               next if tok.nil? || seen.key?(tok)
@@ -794,7 +813,8 @@ module KairosHookProjector
 
               seen[tok] = true
               after = line[m.end(0)..] || ''
-              if cfg.gloss && !(cfg.gloss.match(after) || cfg.gloss.match(nxt))
+              if cfg.gloss && !(bounded_match(cfg.gloss, after, 0, deadline) ||
+                                bounded_match(cfg.gloss, nxt, 0, deadline))
                 unglossed << tok
               end
             end
@@ -990,6 +1010,14 @@ module KairosHookProjector
     end
 
     def main(argv = ARGV, stdin = $stdin)
+      # The first executable statement, before config or stdin are read: the
+      # deadline is absolute, so everything main does — config load, transcript
+      # reads, the recheck's poll sleeps — is charged against it as time
+      # actually spent, and measurement bounds itself by whatever is left.
+      # This is what retires the old static arithmetic that pre-charged a
+      # first read for the four seconds only a recheck spends.
+      started = monotonic
+      deadline = deadline_for(started)
       config_path, report_paths = parse_args(argv)
       if config_path.nil?
         # Zero, not two. The header two hundred lines up says the exit status is
@@ -1084,13 +1112,18 @@ module KairosHookProjector
       end
 
       begin
-        metrics, failures = measure_bounded(text, cfg)
+        metrics, failures = measure_bounded(text, cfg, deadline)
       rescue MeasureTimeout
         lost = note(cfg, 'SKIP-measure-timeout')
+        # Quotes the time actually spent and the budget it ran out of. The old
+        # banner quoted the mode's declared bound — post-clamp, so a declared
+        # 60 read "exceeded 5.0s" — and both the declaration and the clamp are
+        # gone with the key.
         emit(
           'systemMessage' =>
-            "#{cfg.banner_prefix}: NOT RUN — measurement exceeded #{cfg.measure_timeout}s; " \
-            "check the mode's patterns for unbounded backtracking" +
+            format('%s: NOT RUN — measurement ran out of the hook budget (%.1fs elapsed ' \
+                   "of %.1fs); check the mode's patterns for unbounded backtracking",
+                   cfg.banner_prefix, monotonic - started, deadline - started) +
             (lost ? "; #{log_note(lost)}" : '')
         )
         return 0

data/templates/skillsets/kairos_hook_projector/skillset.json

@@ -1,6 +1,6 @@
 {
   "name": "kairos_hook_projector",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Projects an instruction mode's declared hooks into the harness configuration. Stage 1 compiles a mode_hooks declaration to a hook artifact plus a compile record. Stage 2 installs it: mode_hooks_project proposes by default and writes nothing, applying only when the caller echoes back the artifact hash from the proposal, and rewriting only hook groups carrying this SkillSet's marker for that mode — hand-added hooks and other modes' hooks are counted and left alone. Ships the generic readable_gate implementation; a mode supplies its own thresholds, the core supplies none.",
   "author": "Masaomi Hatakeyama",
   "layer": "L1",

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

@@ -17,7 +17,14 @@
 # The harness is this SkillSet's own suite, unmodified: `SCRIPT` in the test
 # files resolves from `__dir__`, so the copied tests drive the copied hook.
 #
-#   ruby test/mutation_check_readable_gate.rb
+#   ruby test/mutation_check_readable_gate.rb           # full sweep
+#   ruby test/mutation_check_readable_gate.rb 'B\\d+'    # rows whose label matches
+#
+# A label filter narrows the sweep to the rows named; the summary line then
+# says FILTERED so a narrowed run can never be mistaken for a full one. The
+# per-mutation suite run stops at the first file with a red — the question
+# per row is binary — and the hook's own test file runs first, which is where
+# a readable_gate mutation reds if it reds at all.
 #
 require 'fileutils'
 require 'tmpdir'
@@ -58,9 +65,11 @@ MUTATIONS = [
   ['M27 HOOK_TIMEOUT drifts from the limit the compiler declares',
    %q{    HOOK_TIMEOUT = 10.0},
    %q{    HOOK_TIMEOUT = 20.0}],
-  ['M28 the interpreter start-up headroom is deleted',
-   %q{    HOOK_TIMEOUT_MARGIN = 1.0},
-   %q{    HOOK_TIMEOUT_MARGIN = 0.0}],
+  # M28 and M30 were the margin mutations against the old constant (1.0). The
+  # 2026-08-27 bound redesign moved the margin to 0.5 and pinned it by
+  # equality, and B14/B15 below carry both directions against the new value.
+  # Retired rather than retargeted: keeping two rows per direction would
+  # double-count one anchor.
 
   # --- round 3: the instrument the design reads its own evidence through -----
   ['M22 the waited token stops telling a wait from no wait',
@@ -74,9 +83,6 @@ MUTATIONS = [
           sleep(POLL_DELAY)
           next
         end}],
-  ['M30 the start-up headroom shrinks but stays positive',
-   %q{    HOOK_TIMEOUT_MARGIN = 1.0},
-   %q{    HOOK_TIMEOUT_MARGIN = 0.05}],
   ['M31 the recheck budget grows instead of shrinking',
    %q{    RECHECK_POLL_ATTEMPTS = 40},
    %q{    RECHECK_POLL_ATTEMPTS = 95}],
@@ -306,7 +312,7 @@ MUTATIONS = [
   ['N32 the truncation fallback is deleted, so a lifted window revives the leftover',
    %q{    rescue StandardError
       begin
-        File.write(path, '')
+        File.open(path, File::WRONLY | File::TRUNC | File::NOFOLLOW).close
         "#{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})"
@@ -315,10 +321,118 @@ MUTATIONS = [
    %q{    rescue StandardError => e
       "#{reason}; a stale note could not be deleted (#{e.class})"
     end}],
+
+  # --- what round 4 of the conformance review found --------------------------
+  #
+  # The truncation is a write through a name in operator space. Two seats
+  # planted a symlink at the note key, made the directory unwritable so the
+  # unlink fails, and watched the old File.write empty a file outside the notes
+  # directory. This restores that write; the fix's NOFOLLOW is what it deletes.
+  ['N33 the truncation follows a symlink to whatever it names',
+   %q{        File.open(path, File::WRONLY | File::TRUNC | File::NOFOLLOW).close},
+   %q{        File.write(path, '')}],
+
+  # --- the measurement bound: the seam and its witnesses (design v0.7 §5-12) --
+  #
+  # Every mutation here is paired with the fixture the design names as its
+  # killer; the pairing is the §5-12 table, and anchor verification before a
+  # sweep is what keeps it honest. Mutations that unbound a runaway make the
+  # affected fixtures run to run_script's 30s outer kill, so those rows cost
+  # minutes each in a sweep — declared, not accidental.
+  ['B1  the floor predicate is loosened to <= 0',
+   %q{      raise MeasureTimeout if remaining < MIN_TIMEOUT},
+   %q{      raise MeasureTimeout if remaining <= 0}],
+  ['B2  the raise (floor included) is deleted',
+   %q{      raise MeasureTimeout if remaining < MIN_TIMEOUT},
+   %q{      # raise deleted}],
+  ['B3  the floor constant is lowered into the silent-nil window',
+   %q{    MIN_TIMEOUT = 0.001},
+   %q{    MIN_TIMEOUT = 1.0e-12}],
+  ['B4  the floor constant is raised, quietly shrinking every budget',
+   %q{    MIN_TIMEOUT = 0.001},
+   %q{    MIN_TIMEOUT = 1.0}],
+  ['B5  the grant is never armed',
+   %q{      Regexp.timeout = remaining
+      begin},
+   %q{      begin}],
+  ['B6  the TimeoutError-to-MeasureTimeout mapping is deleted',
+   %q{      rescue Regexp::TimeoutError
+        raise MeasureTimeout},
+   %q{      rescue Regexp::TimeoutError
+        raise}],
+  ['B7  the clock read is dropped from the remaining computation',
+   %q{      remaining = deadline - monotonic},
+   %q{      remaining = deadline}],
+  ['B8  each_match reverts to matching before the seam checks',
+   %q{      while pos <= string.length && (m = bounded_match(regexp, string, pos, deadline))
+        yield m},
+   %q{      while pos <= string.length && (m = regexp.match(string, pos))
+        raise MeasureTimeout if deadline && monotonic > deadline
+        yield m}],
+  ['B19 the seam inlines the clock, putting it beyond the floor fixture stub',
+   %q{      remaining = deadline - monotonic},
+   %q{      remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)}],
+  # Five bypass targets, three dedicated rows: specimen and shorthand have no
+  # independent seam call site — both reach bounded_match only through
+  # each_match's single call — so their bypass IS the each_match reversion,
+  # which is B8. B10-B12 carry the three families with call sites of their own.
+  ['B9  the announce call drops its deadline argument',
+   %q{      announced = !(cfg.announce && bounded_match(cfg.announce, first, 0, deadline)).nil?},
+   %q{      announced = !(cfg.announce && bounded_match(cfg.announce, first, 0, nil)).nil?}],
+  ['B10 the announce match bypasses the seam entirely',
+   %q{      announced = !(cfg.announce && bounded_match(cfg.announce, first, 0, deadline)).nil?},
+   %q{      announced = !(cfg.announce && cfg.announce.match(first)).nil?}],
+  ['B11 the gloss after-operand bypasses the seam',
+   %q{              if cfg.gloss && !(bounded_match(cfg.gloss, after, 0, deadline) ||
+                                bounded_match(cfg.gloss, nxt, 0, deadline))},
+   %q{              if cfg.gloss && !(cfg.gloss.match(after) ||
+                                bounded_match(cfg.gloss, nxt, 0, deadline))}],
+  ['B12 the gloss nxt-operand bypasses the seam behind the short-circuit',
+   %q{              if cfg.gloss && !(bounded_match(cfg.gloss, after, 0, deadline) ||
+                                bounded_match(cfg.gloss, nxt, 0, deadline))},
+   %q{              if cfg.gloss && !(bounded_match(cfg.gloss, after, 0, deadline) ||
+                                cfg.gloss.match(nxt))}],
+  ['B13 the deadline is recomputed at the measurement call instead of main head',
+   %q{        metrics, failures = measure_bounded(text, cfg, deadline)},
+   %q{        metrics, failures = measure_bounded(text, cfg, deadline_for(monotonic))}],
+  ['B14 the margin collapses to zero',
+   %q{    HOOK_TIMEOUT_MARGIN = 0.5},
+   %q{    HOOK_TIMEOUT_MARGIN = 0.0}],
+  ['B15 the margin swallows half the budget',
+   %q{    HOOK_TIMEOUT_MARGIN = 0.5},
+   %q{    HOOK_TIMEOUT_MARGIN = 5.0}],
+  ['B16 the report path loses the nil-deadline passthrough',
+   %q{      return regexp.match(string, pos) if deadline.nil?
+
+      remaining = deadline - monotonic},
+   %q{      remaining = deadline - monotonic}],
+  ['B17 the revocation is deleted, so a grant outlives its match',
+   %q{      Regexp.timeout = remaining
+      begin
+        regexp.match(string, pos)
+      ensure
+        Regexp.timeout = nil
+      end},
+   %q{      Regexp.timeout = remaining
+      regexp.match(string, pos)}],
+  ['B18 the revocation is demoted to a trailing statement, leaking on the cut exit',
+   %q{      Regexp.timeout = remaining
+      begin
+        regexp.match(string, pos)
+      ensure
+        Regexp.timeout = nil
+      end},
+   %q{      Regexp.timeout = remaining
+      m = regexp.match(string, pos)
+      Regexp.timeout = nil
+      m}],
 ].freeze
 
-def run_suite(root)
+def run_suite(root, early_exit: true)
   files = Dir[File.join(root, 'test', 'test_*.rb')].sort
+  # The hook's own suite first: a readable_gate mutation reds there if it reds
+  # at all, and the early exit below then skips the unrelated files.
+  files = files.partition { |f| File.basename(f) == 'test_readable_gate.rb' }.flatten
   runs = 0
   bad = 0
   unparseable = []
@@ -332,11 +446,18 @@ def run_suite(root)
       unparseable << File.basename(f)
       bad += 1 unless st.success?
     end
+    break if early_exit && bad.positive?
   end
   [runs, bad, unparseable, files.length]
 end
 
 exit_code = 0
+label_filter = ARGV[0] && Regexp.new(ARGV[0])
+selected = label_filter ? MUTATIONS.select { |l, _, _| l.match?(label_filter) } : MUTATIONS
+if label_filter
+  puts format('FILTERED sweep: %d of %d rows match %s — NOT a full sweep',
+              selected.length, MUTATIONS.length, label_filter.inspect)
+end
 
 Dir.mktmpdir do |tmp|
   root = File.join(tmp, File.basename(SKILLSET_ROOT))
@@ -344,7 +465,7 @@ Dir.mktmpdir do |tmp|
   hook = File.join(root, 'hooks', 'readable_gate.rb')
   pristine = File.read(hook)
 
-  runs, bad, unparseable, nfiles = run_suite(root)
+  runs, bad, unparseable, nfiles = run_suite(root, early_exit: false)
   puts format('BASELINE (unmutated copy): %d test files, %d runs, %d failures+errors%s',
               nfiles, runs, bad, unparseable.empty? ? '' : " [unparseable: #{unparseable.join(', ')}]")
   puts
@@ -356,7 +477,7 @@ Dir.mktmpdir do |tmp|
   killed = 0
   survived = 0
   not_applied = 0
-  MUTATIONS.each do |label, from, to|
+  selected.each do |label, from, to|
     unless pristine.include?(from)
       not_applied += 1
       puts format('%-70s  ANCHOR NOT FOUND', label)
@@ -381,7 +502,8 @@ Dir.mktmpdir do |tmp|
 
   puts
   puts "source restored byte-identical: #{File.read(hook) == pristine}"
-  puts "killed #{killed}/#{MUTATIONS.length}, survived #{survived}, anchor-not-found #{not_applied}"
+  scope = label_filter ? "FILTERED #{selected.length} of #{MUTATIONS.length}" : MUTATIONS.length.to_s
+  puts "killed #{killed}/#{scope}, survived #{survived}, anchor-not-found #{not_applied}"
   exit_code = 1 if survived.positive? || not_applied.positive?
 end