kairos-chain 3.74.0 → 3.76.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 730e325cdf2caf9ce68964d25d379511f5b1080aa86b86378c928a06156fc567
-  data.tar.gz: 3c7fd4cc597b1fefd8403bd976786eba4e3e02c6665c2097d35940e243d6a2dd
+  metadata.gz: 83162bcb26c033c10413fe1f25ffed382031dfebc115aa7041438d807177ef8c
+  data.tar.gz: eacc1ed007ad60d8429954c1d0e0bca228048a5a0438f177df892e72aae3e599
 SHA512:
-  metadata.gz: a78cf0336f37b5107f0991ca1f0e88a3cfeb911f1a998d1ffb5763e071d1ba9ffa88fde11d92fc2eaca9eeb0ffc948718e3bfa1f65ed0f87fa1adf3f1c36d40a
-  data.tar.gz: da3b0b85ec1518e1e07f4bd4199761128006fe57db205059b36f3145db7cd5ef8f51b9d95f24faa82a05756507244700d6fbe3655d3672d11b80e9b7eb4a697d
+  metadata.gz: e6e311e80bc090726582d7032aa87a0ac1a97ffea387b300306d609f19b0a38c4dbe2cd6a84dd36e924e66c3e9f579b56f91c1c25602cc2afdae21e8f8e2005c
+  data.tar.gz: 0ffddbff73ac05f8804b343e597495517b3872a0ceed500ef1370aab8f034a866b20585a5a03c46db179fbacfd18aff3862a70fc40c093f66389a69f2afdc4c2

data/CHANGELOG.md

@@ -4,6 +4,156 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.76.0] - 2026-08-22
+
+### Changed
+
+- **L1 `multi_llm_review_workflow` 3.10.2 → 3.11.0 — three norms and one
+  recorded open question, for three failures the operator named and one request
+  he made.** The failures: an orchestrator issuing different criteria each
+  round, the APPROVE ratio operating as the close condition, and design reviews
+  descending into code. The request: bound mutation experiments. Four rules were
+  drafted, reviewed over three rounds, applied, reviewed once more as applied
+  text — one APPROVE of four seats, eighteen blocking findings — and revised
+  subtractively. What ships is narrower than what was drafted, which is the
+  point: this entry's own § Revision Discipline records that deletions drew zero
+  new P0s in every measured case and additions became the next round's
+  battleground.
+
+  **§ Prompt Generation Rules gains a recording duty on the round's
+  instrument** — what a seat is told to look for, how much of the artifact it is
+  given, and which seats answer. It bounds nothing: narrowing criteria, cutting
+  scope and convening a different panel are each a documented remedy for
+  something. It forbids moving the instrument and then reading the resulting
+  change in finding counts as a property of the artifact. It was drafted around
+  criteria alone, which left scope and panel composition — two channels that
+  move the count just as well — outside it.
+
+  **§ Review Types gains the phase rule as an invariant with no branches**: a
+  review answers at the phase of its target and does not descend. Design and
+  Document reviews read code only to refute a factual claim and write none;
+  implementation review is where fixes are written. Two enumerated sentences
+  drafted with it are not here. "An implementation-phase finding that reopens
+  the design belongs to the backlog" collided with this entry's own "any (a) or
+  (b) REJECT or FAIL = revise and re-review" over exactly the
+  design-implementation seam it calls the most valuable layer, and pre-answered
+  the operator question § Revision Discipline rule 1 requires. "Fix plan and
+  Final/convergence reviews inherit the phase of the artifact they check" gave
+  those two nothing to inherit, no phase being assigned to a fix plan anywhere.
+  The `<structured_output_contract>` line drops "consider improving" without
+  enumerating review types, because the enumerated form left this entry's own
+  knowledge/documentation-update review unassigned.
+
+  **The mutation norm is one sentence inside the phase rule and assigns no
+  party**: a green suite is not evidence until its tests have been shown to
+  fail, and a pass whose sites the code's author chose measures the author's
+  attention, not the suite. It was drafted as a seventh item in Step -1 carrying
+  the duty "whoever chooses the sites is not whoever wrote the code", and no
+  party in this entry can discharge that — before dispatch the only actor is the
+  orchestrator, which § Roles makes the same context as the implementer, and
+  review seats run sandboxed read-only and cannot execute anything. Stated as a
+  property of evidence rather than a duty on someone, it holds wherever a
+  mutation result is read. The bound the operator asked for is not here and the
+  omission is open, not settled: the recorded decision is to accumulate three
+  runs and then judge.
+
+  **Withdrawn in the same version: a rule making each seat label its own
+  findings new or carryover.** A seat sees only its own priors, so a finding one
+  seat raises after another raised it is new to that seat and carryover to the
+  round, and a seat added or returning mid-thread has no priors at all, making
+  every finding it raises new by construction — the machine-side signal "new
+  (a)+(b) P0 = 0" is then not computable from seat labels. § Convergence Rules
+  records that who makes the label is undecided and that the orchestrator makes
+  it meanwhile, which is the biased judge the withdrawn rule was written to
+  replace. Its paired edits revert with it, which also removes "the round number
+  is never written into a prompt" — that sentence contradicted § Output
+  Directive's MUST that the prompt carry `review{N}` in the output path, and an
+  orchestrator obeying it would have had round N+1 overwrite round N.
+
+  A fifth proposed rule, an exception for self-referential reviews, was dropped
+  before the version was written, after four reviewer contexts — occupying two
+  of that round's three counted seats — shot it on three independent grounds.
+
+  Across all four review rounds the thing most often refuted was not the rules
+  but the change's account of itself. The pre-flight falsifier for the applied
+  round refuted 8 of 22 checked claims, three of them inside the version entry;
+  the correction to those three introduced a fourth false claim, which the round
+  then refuted. Every such claim is a record summarised without its denominator
+  or its condition.
+
+## [3.75.0] - 2026-08-21
+
+### Added
+
+- **`minimum_nomic` 0.3.0 — the post-game analysis is now a fixed four-stage
+  procedure, settled by running it after five rounds of design review failed to
+  converge.** Blocking findings across those rounds ran 22, 19, 26, 50, 47, and
+  the last two returned no APPROVE from any of the four reviewer seats, so the
+  measurement was implemented and observed instead of specified further. The
+  stages are: free scoring (`reanalyse.rb`), scoring under the analysts' own
+  distilled standards (`distil_criterion.rb` → `criterion_matrix.rb`), measures
+  the analysts propose as executable code (`propose_metric.rb`), and
+  repeatability plus mutation (`mutate.rb` / `mutate_rule.rb` →
+  `judge_change.rb`). No stage supplies a definition of metacognition; every
+  definition in play is written by an analyst.
+- **Stage 2 moves into the SkillSet from `log/minimum_nomic_gm_20260810/`,** where
+  a ten-game corpus list, a scoring-pass digest and a model-to-adapter table were
+  written into the source and made the scripts unusable on any other corpus.
+  `distil_criterion.rb` now takes a corpus directory, picks the guideline
+  covering the most games and prints the ones it leaves out, and reads each
+  model's adapter from the lineups — aborting when one model appears under two
+  adapters rather than choosing silently. `criterion_matrix.rb` takes
+  `--criteria` and reaches a judge through the adapter recorded when its standard
+  was distilled.
+- **`propose_metric.rb`** asks each analyst for a procedure that counts
+  metacognition, as code, and runs it once on a disposable copy of the corpus
+  under an environment carrying no credentials. It is not repaired, not
+  rewritten, not re-run; the ran/failed count is an observation and is never
+  compared. A submitted procedure runs with the invoking user's permissions —
+  the disposable copy protects the records and nothing protects the host.
+- **`mutate_rule.rb`** rewrites one initial rule body, editing only the rule set
+  carried in `lineup.jsonl`, so the utterances still describe conduct under the
+  original rule and `calls.jsonl` still holds what players were actually handed.
+  The lie sits in exactly one place. It refuses to overwrite an output directory,
+  to make more than one substitution, or to leave a scar, and re-reads the arm it
+  wrote to confirm exactly one rule body differs.
+- **`judge_change.rb`** puts two analyses of one game side by side, blinded as X
+  and Y from a recorded seed, and asks a model whether the assessment changed.
+  Both experiments of stage 4 need that one question answered.
+- **`test/test_propose_metric.rb`** — 16 checks over the extraction and the
+  runner without calling a model, 5 of them falsifications: a crashing submission
+  is not scored as having run even though it left output, a silent clean exit is,
+  an unfenced reply is not salvaged into code, a submission that deletes the
+  corpus cannot reach the original, and no environment variable crosses into the
+  child.
+
+### Measured, and recorded in the SkillSet README
+
+- **Stage 4's verdict does not work.** On one game with `Rule 105` rewritten from
+  unanimity to simple majority, the repeatability floor came back 9 of 9 CHANGED
+  and the mutated arm 9 of 9. What the judges pointed AT still separated them —
+  all 3 judges reading one analyst's pair named the Rule 105 misreading, none did
+  in the floor pair. Use the script for what its judges write, not for the tally
+  it prints. Counting occurrences of the substituted word does not work either:
+  one analyst says "majority" 4 and 2 times in the two clean readings and 5 in
+  the mutated one while detecting nothing.
+- **Stage 2's own premise failed.** Holding the standard fixed left a 1.94-point
+  spread across judges against a 1.12-point spread across standards, so the judge
+  still moves the number more than the standard does. The own-standard premium
+  did not appear either: 4 diagonal cells averaged 5.50 against 5.88 for the 12
+  off-diagonal ones. The GAPS block was answered NONE in 0 of 16 cells, every
+  judge converging on the same four holes — whether proposing implies an
+  affirmative vote, how to read a wholly empty turn, which side to weight when
+  private reasoning and public utterance diverge, and whether the game master's
+  narrower action space belongs on the same scale.
+- **Stage 3, first pass:** 2 of 3 submissions ran. The one that failed died on
+  `text.split()` against the 8 utterances of 391 whose text is null. One reply
+  contained 8 fabricated tool calls with fabricated results, citing a path that
+  exists but is empty and quoting lines that appear nowhere in the corpus.
+- Only 9 of 24 games carry `rules_initial` in their lineup, which
+  `mutate_rule.rb` needs. The other 15 predate recorded rule bodies. No
+  workaround is provided; run more games instead.
+
 ## [3.74.0] - 2026-08-18
 
 ### Fixed

data/lib/kairos_mcp/version.rb

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

data/templates/knowledge/multi_llm_review_workflow/multi_llm_review_workflow.md

@@ -1,7 +1,7 @@
 ---
 name: multi_llm_review_workflow
 description: "Multi-LLM review methodology and execution — workflow pattern, CLI tooling, consensus analysis, Persona Assembly. Applicable to design, implementation, documentation, or any artifact."
-version: "3.10.2"
+version: "3.11.0"
 tags:
   - workflow
   - review
@@ -53,7 +53,9 @@ write a review spec and declare it frozen for the round:
 3. **Cap fixes per round (≤5)** and write one line per fix: *what this fix
    newly claims* (values pinned, ranges narrowed, failure visibility
    changed). A fix that cannot state its new claims is doing more than the
-   finding asked.
+   finding asked. A round that moves its instrument records that it moved it
+   (§ Prompt Generation Rules). That is a recording duty; unlike the cap
+   above, it bounds nothing.
 4. **Pre-flight falsifier.** Before dispatch, one agent whose only job is to
    refute every factual claim in the spec and artifact — especially numbers
    and "X does not exist" claims. In this loop it caught real errors before
@@ -563,6 +565,13 @@ Rules:
 | Document review | Accuracy, completeness, consistency | Document text | Grant applications, papers |
 | Final/convergence review | All prior findings resolved, no new issues | Resolution matrix + revised artifact | Before merge |
 
+**A review answers at the phase of its target and does not descend.** Design
+review and Document review read code only to refute a factual claim the
+artifact makes about an existing system, and write none. Implementation review
+is where fixes are written, and is also where a green suite is not evidence
+until its tests have been shown to fail — a mutation pass whose sites the
+code's author chose measures the author's attention, not the suite.
+
 ## LLM Role Differentiation
 
 Without explicit instruction, different LLMs naturally focus on different verification layers:
@@ -601,9 +610,17 @@ numerator moved. Do not treat a reached ratio as sufficient on its own either:
 check what the approving replies actually said before counting them.
 
 **Count carryover and new (a)/(b) P0s separately; the machine-side signal of
-convergence is "new P0 = 0", not the APPROVE ratio.** Require each persona to
+convergence is "new P0 = 0", not the APPROVE ratio.** Require each **seat** to
 state a closure verdict on its own prior-round P0s — closed / open /
-half-closed, with grounds. This format is validated live (chain erasure
+half-closed, with grounds. **Who labels a finding new versus carryover is
+undecided.** The seat-side answer — each seat labelling against its own prior
+findings — was written into this section on 2026-08-22 and removed the same day:
+a seat sees only its own priors, so a finding one seat raises after another seat
+raised it is new to that seat and carryover to the round, and a seat added or
+returning mid-thread has no priors at all, making every finding it raises new by
+construction. Until this is answered, the orchestrator makes the call, knowing
+that it is the context whose artifact the call converges. This format is
+validated live (chain erasure
 R6–R8) and is what makes the carryover/new split computable. A round whose
 (a)+(b) findings are all carryover with closure verdicts, and whose revision
 drew zero new P0s (observed without exception when the revision was
@@ -1202,6 +1219,19 @@ Every review prompt MUST include these 7 items:
 
 All prompt content MUST be in **English** for consistent parsing across LLM tools.
 
+**A round that changes its instrument records the change.** The instrument is
+whatever bounds what the round can find: what a seat is told to look for, how
+much of the artifact it is given, and which seats answer. Some of a prompt
+varies by construction — the artifact itself, the prior findings a round asks a
+seat to verdict — and that is not the instrument. When a round moves the
+instrument, it says so on the record, in one line, naming what moved and why.
+
+This is a recording duty, not a prohibition. An orchestrator may narrow a
+seat's criteria mid-thread, cut the scope, or convene a different panel; each
+of those is a documented remedy for something. What it may not do is move the
+instrument and then read the resulting change in finding counts as a property
+of the artifact.
+
 ### Reviewer incentive rule
 
 **Never tell a reviewer — subprocess or persona — that its finding count is
@@ -1247,7 +1277,8 @@ For each finding:
 - **What can go wrong**: concrete failure scenario
 - **Why this is vulnerable**: code path or design gap
 - **Likely impact**: data loss, security breach, silent corruption, etc.
-- **Recommended fix**: specific change (not "consider improving")
+- **Recommended fix**: specific, never "consider improving" — the change where
+  this review writes changes, the claim that does not hold where it does not.
 </structured_output_contract>
 
 <grounding_rules>
@@ -1611,5 +1642,59 @@ Compression ratio: parallel agent raw → Assembly ≈ 2:1
   with zero new and one carryover (a) at 1 of 2 seats approving reports
   "GATE NOT PASSED" under the old rule and "FREEZE CANDIDATE" under this one.
 
+- Three norms, subtractively (v3.11.0, 2026-08-22): the operator named three
+  recurring failures — an orchestrator issuing different criteria each round,
+  the APPROVE ratio operating as the close condition, and design reviews
+  descending into code — and asked for mutation experiments to be bounded. Four
+  rules were written and reviewed; one was withdrawn in the same version and two
+  of the survivors are narrower than they were drafted, so what ships is three
+  norms and one recorded open question. **§ Prompt Generation Rules** gains a
+  recording duty on the round's instrument — what a seat is told to look for,
+  how much of the artifact it is given, and which seats answer. It bounds
+  nothing: narrowing criteria, cutting scope and convening a different panel are
+  each a documented remedy for something. What it forbids is moving the
+  instrument and then reading the resulting change in counts as a property of
+  the artifact. It was drafted around criteria alone, which left scope and panel
+  composition — two channels that move the count just as well — outside it.
+  **§ Review Types** gains the phase rule as an invariant with no branches: a
+  review answers at the phase of its target and does not descend. Two enumerated
+  sentences were drafted with it and are not here. "An implementation-phase
+  finding that reopens the design belongs to the backlog" collided with this
+  document's own "any (a) or (b) REJECT or FAIL = revise and re-review" over
+  exactly the design-implementation seam it calls the most valuable layer, and
+  pre-answered the operator question § Revision Discipline rule 1 requires. "Fix
+  plan and Final/convergence reviews inherit the phase of the artifact they
+  check" gave those two reviews nothing to inherit, since no phase is assigned to
+  a fix plan anywhere. The output contract at `<structured_output_contract>`
+  drops "consider improving" without enumerating review types, because the
+  enumerated form left this document's own knowledge/documentation-update review
+  unassigned. **The mutation norm** is one sentence inside the phase rule and
+  assigns no party: a green suite is not evidence until its tests have been shown
+  to fail, and a pass whose sites the code's author chose measures the author's
+  attention, not the suite. It was drafted as a seventh item in Step -1 with the
+  duty "whoever chooses the sites is not whoever wrote the code", and no party in
+  this document can discharge that — before dispatch the only actor is the
+  orchestrator, which § Roles makes the same context as the implementer, and the
+  seats are sandboxed read-only and cannot execute anything. Stated as a property
+  of evidence rather than a duty on someone, it holds wherever a mutation result
+  is read. The bound the operator asked for is not here and the omission is open,
+  not settled: the recorded decision is to accumulate three runs and then judge.
+  **Withdrawn in this version**: a rule making each seat label its own findings
+  new or carryover. A seat sees only its own priors, so a finding one seat raises
+  after another raised it is new to that seat and carryover to the round, and a
+  seat added or returning mid-thread has no priors at all. § Convergence Rules
+  now records that who makes the label is undecided and that the orchestrator
+  makes it meanwhile, which is the biased judge the withdrawn rule was written to
+  replace. A fifth proposed rule, an exception for self-referential reviews, was
+  dropped before this version was written, after four reviewer contexts —
+  occupying two of that round's three counted seats — shot it on three
+  independent grounds. Design history: three review rounds on the proposal
+  (closed by operator declaration, not convergence), then one round on the
+  applied text, which returned one APPROVE of four seats and eighteen blocking
+  findings — every rule above is narrower for it. What kept being shot across all
+  four rounds was the change's account of itself, not the rules it proposed.
+  Records: L2 `handoff_mlr_l1_norms_revision_three_rounds_and_switch_to_implementation_20260821`
+  and L2 `mlr_v3_11_0_applied_review_r1_and_subtractive_revision_20260822`
+
 **Key insight**: Design reviews and implementation reviews find
 **categorically different bugs**. Both phases are necessary.

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

@@ -31,6 +31,31 @@ module KairosHookProjector
     TAIL_BYTES = 512 * 1024
     POLL_ATTEMPTS = 15
     POLL_DELAY = 0.1
+    # The recheck waits longer than the first read, because it is waiting for a
+    # whole rewrite rather than for the tail of a record already being written.
+    # Bounded well under the hook's own timeout; the turn it lengthens is one
+    # that already spent a full regeneration.
+    RECHECK_POLL_ATTEMPTS = 40
+    # Claude Code's own wording, written into the transcript as a user record
+    # when a Stop hook blocks. Not this gate's string: if it changes, no marker
+    # is found and the read falls back to the pre-2026-08-20 behaviour, which
+    # the verdict names so the drift shows up in the log instead of silently.
+    BLOCK_MARKER = 'Stop hook feedback:'
+    # Claude Code's limit on how long a Stop hook may run, declared twice
+    # outside this file: in `.claude/settings.json` and in this SkillSet's
+    # `lib/mode_hooks_compiler.rb`. Named here because this file spends two
+    # budgets in sequence and neither knows about the other. A hook killed at
+    # 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, which measures 0.2-0.6s above the sleeps it accounts for.
+    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.
+    MEASURE_TIMEOUT_CEILING =
+      HOOK_TIMEOUT - HOOK_TIMEOUT_MARGIN - (RECHECK_POLL_ATTEMPTS * POLL_DELAY)
 
     # Built from single-quoted strings so that `#{` in a pattern stays literal
     # rather than becoming interpolation, and anchored with \A because Python's
@@ -131,7 +156,18 @@ 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) }
-        @measure_timeout = merged['measure_timeout_seconds']
+        # 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
 
@@ -275,32 +311,168 @@ module KairosHookProjector
       joined.empty? ? nil : joined
     end
 
+    # Index of the marker for THIS turn, or nil while it has not landed.
+    #
+    # The transcript records the block itself: a user record carrying Claude
+    # Code's feedback text, whose parentUuid names the assistant record that was
+    # judged. That pair is the entire state the recheck needs — which record has
+    # already had a verdict, and where the rewrite begins — so no state file and
+    # no config key are involved.
+    #
+    # The newest marker in the transcript is not necessarily this turn's, and
+    # taking it was a defect of its own. A session blocked once already carries
+    # an older marker; on the next block, before the new marker lands, the older
+    # one made the read believe a marker had arrived, so it skipped the wait and
+    # measured the message it had just blocked — returning in 0.06s with nothing
+    # in the log to say so. 128 of 170 real blocks are not a session's first.
+    # Between the previous block and this one there is always the operator's own
+    # message, so the test is which of the two is newer. Records carrying no
+    # text — tool results, images — belong to the turn being written and are
+    # stepped over.
+    def turn_marker(rows)
+      i = rows.length - 1
+      while i >= 0
+        row = rows[i]
+        if row['type'] == 'user'
+          text = text_of(row)
+          return text.start_with?(BLOCK_MARKER) ? i : nil if text.is_a?(String)
+        end
+
+        i -= 1
+      end
+      nil
+    end
+
+    # Compared only when a judged uuid is present: comparing it while nil made a
+    # record carrying no uuid look like the judged record and skipped a real
+    # rewrite.
+    def judged?(row, judged)
+      judged && row['uuid'] == judged
+    end
+
+    # The newest assistant record after `index` other than the judged one,
+    # whether or not it carries text yet. nil while none has landed.
+    #
+    # This is the first read's rule applied after the marker, and it is what the
+    # recheck uses while it still has budget. A rewrite that is mid-write shows
+    # up here as text-less and is waited for, rather than stepped over in favour
+    # of whatever text lies beneath it. Stepping over had a measured cost: a
+    # rewrite that called a tool was judged on its own two-line preamble and
+    # logged RECHECK-PASS in 0.04s, while the rewrite itself — a four-heading
+    # FAIL landing 0.6s later — was never read.
+    def newest_after(rows, index, judged)
+      i = rows.length - 1
+      while i > index
+        row = rows[i]
+        return [text_of(row), row['uuid']] if row['type'] == 'assistant' && !judged?(row, judged)
+
+        i -= 1
+      end
+      nil
+    end
+
+    # The newest text-bearing assistant record after `index`, stepping over
+    # records that carry none. Used only once the budget is spent.
+    #
+    # Over 3,248 transcripts and 170 real blocks, a completed rewrite sitting
+    # beneath a newer text-less record occurred 0 times, so this shape must not
+    # pre-empt the wait — that is what cost the preamble above. It is kept as a
+    # last resort because if the shape ever does occur, the alternative is the
+    # same skipped verdict this reaches past.
+    def deep_after(rows, index, judged)
+      i = rows.length - 1
+      while i > index
+        row = rows[i]
+        if row['type'] == 'assistant' && !judged?(row, judged)
+          text = text_of(row)
+          return [text, row['uuid']] if text
+        end
+
+        i -= 1
+      end
+      nil
+    end
+
+    # The newest assistant record, whether or not it carries text yet, or nil
+    # when the transcript holds none. The first read's rule, unchanged since
+    # before 2026-08-20, and the rule the recheck falls back to when no marker
+    # is found.
+    def newest_assistant(rows)
+      row = rows.reverse_each.find { |r| r['type'] == 'assistant' }
+      row && [text_of(row), row['uuid']]
+    end
+
     # Text of the turn's final assistant message, with the flush race handled.
     #
     # One response is written as several records (thinking, text, tool_use) at
     # different times. At Stop time the `text` record may not have landed yet,
     # so the newest assistant record is often thinking-only. Wait for the text
     # rather than judging an earlier message from the same turn.
-    def last_assistant_text(transcript_path)
-      POLL_ATTEMPTS.times do |attempt|
+    #
+    # On a recheck that wait never engaged, and that was the defect: the blocked
+    # message is still the newest record carrying text, so it satisfied the
+    # "has text" test immediately and was judged a second time. Measured over
+    # one instance's first 768 log records, 140 of 140 rechecks took the newest
+    # record without ever waiting, and 109 of 140 reported metrics identical to
+    # the verdict that had just blocked. The rewrite had passed in most of them.
+    # The invariant this restores, as long as the marker is found: a record that
+    # a verdict already named is never judged again.
+    def last_assistant_text(transcript_path, rechecked = false)
+      attempts = rechecked ? RECHECK_POLL_ATTEMPTS : POLL_ATTEMPTS
+      attempts.times do |attempt|
         rows = tail_records(transcript_path)
-        return [nil, 'unreadable'] if rows.nil?
+        return [nil, 'unreadable', nil] if rows.nil?
+
+        waited = attempt.zero? ? 'ok' : 'ok-after-wait'
+
+        if rechecked
+          # The marker is waited for on the same terms as the rewrite: both are
+          # written by the same process at nearly the same moment, so "not there
+          # yet" is as ordinary for one as for the other. Inside the budget the
+          # selection rule is the first read's — newest record, wait for its
+          # text — so the two reads agree wherever they can.
+          marker = turn_marker(rows)
+          if marker
+            found = newest_after(rows, marker, rows[marker]['parentUuid'])
+            return [found[0], waited, found[1]] if found && found[0]
+          end
+        else
+          newest = newest_assistant(rows)
+          return [nil, 'no-assistant-record', nil] if newest.nil?
+          return [newest[0], waited, newest[1]] if newest[0]
+        end
+        sleep(POLL_DELAY)
+      end
 
-        found_assistant = false
-        rows.reverse_each do |row|
-          next unless row['type'] == 'assistant'
+      return [nil, 'race-timeout', nil] unless rechecked
 
-          found_assistant = true
-          text = text_of(row)
-          return [text, attempt.zero? ? 'ok' : 'ok-after-wait'] if text
+      # The recheck's budget is spent. Either this turn's marker never appeared
+      # — Claude Code's wording is not this gate's to guarantee — or it appeared
+      # and the rewrite did not. Both are named, and every no-marker outcome
+      # carries the suffix, because a drift detector whose only visible trace is
+      # the exit that happens to find text reports nothing in the cases drift
+      # actually produces.
+      rows = tail_records(transcript_path)
+      return [nil, 'unreadable', nil] if rows.nil?
 
-          break
-        end
-        return [nil, 'no-assistant-record'] unless found_assistant
+      marker = turn_marker(rows)
+      if marker
+        # Last resort, and named apart so the log can say how often the ordinary
+        # rule was not enough.
+        found = deep_after(rows, marker, rows[marker]['parentUuid'])
+        return [found[0], 'ok-after-wait-deep', found[1]] if found
 
-        sleep(POLL_DELAY)
+        return [nil, 'awaiting-rewrite', nil]
       end
-      [nil, 'race-timeout']
+
+      # No marker for this turn, so nothing is judged. Falling back to the first
+      # read's rule here looked conservative and was the opposite: the newest
+      # record it reaches is the message this turn has just blocked, so the
+      # fallback re-judged it — the very behaviour this method exists to end,
+      # reachable on any block after a session's first. A recheck never blocks,
+      # so refusing to judge costs the operator nothing except the line, and it
+      # keeps both the invariant and the measurement intact.
+      newest_assistant(rows) ? [nil, 'nomarker', nil] : [nil, 'no-assistant-record-nomarker', nil]
     end
 
     # --- measurement ---------------------------------------------------------
@@ -460,15 +632,20 @@ module KairosHookProjector
     # have — an empty-string or directory log_path left the gate blocking and
     # passing exactly as normal while nothing was ever recorded, so the
     # operator's onboarding week produced no data and no complaint.
-    def note(cfg, verdict, metrics = nil)
+    def note(cfg, verdict, metrics = nil, record_id = nil)
       # nil alone means "no log declared". false, 0 and "" are declarations the
       # gate cannot honour, and each has to reach the rescue below to be named.
       return if cfg.log_path.nil?
 
       stamp = Time.now.strftime('%Y-%m-%dT%H:%M:%S')
       detail = ''
+      # Which record the verdict is about. Without it the log cannot answer the
+      # one question the fix above turns on — whether two verdicts in a row were
+      # about the same message — and it is also how a first read that grabbed a
+      # stale record becomes diagnosable rather than merely suspected.
+      detail += "\trec=#{record_id[0, 8]}" if record_id.is_a?(String) && !record_id.empty?
       if metrics
-        detail = format(
+        detail += format(
           "\tlines=%d\theadings=%d\ttables=%d\tdiagrams=%d\tunglossed=%s",
           metrics['lines'], metrics['headings'], metrics['tables'], metrics['diagrams'],
           metrics['unglossed'].empty? ? '-' : metrics['unglossed'].join(',')
@@ -643,9 +820,31 @@ module KairosHookProjector
       # reported, so its outcome is visible; it is simply never blocked again.
       rechecked = payload['stop_hook_active'] ? true : false
 
-      text, why = last_assistant_text(payload.fetch('transcript_path', ''))
+      text, why, record_id = last_assistant_text(payload.fetch('transcript_path', ''), rechecked)
       if text.nil? || text.strip.empty?
-        note(cfg, "SKIP-#{why}")
+        lost = note(cfg, "SKIP-#{why}")
+        # Every recheck that produces no verdict says so on screen. Naming only
+        # the two expected reasons left the others silent, and the ones it left
+        # out are live: a transcript momentarily unreadable, and a rewrite whose
+        # text is whitespace after the fallback found it. Both spent the budget
+        # and told the operator nothing. A first read keeps its old silence —
+        # there the turn goes out regardless and the log is the right place.
+        budget = format('%.1f', RECHECK_POLL_ATTEMPTS * POLL_DELAY)
+        tail = lost ? "; #{log_note(lost)}" : ''
+        reason =
+          case why
+          when 'awaiting-rewrite'
+            "the rewrite had not been recorded within #{budget}s"
+          when 'nomarker', 'no-assistant-record-nomarker'
+            "no block marker appeared within #{budget}s, so the rewrite could not be told " \
+            "apart from the message that was blocked. Claude Code's feedback wording may " \
+            'have changed'
+          when 'unreadable'
+            'the transcript could not be read'
+          else
+            "nothing measurable was found (#{why})"
+          end
+        emit('systemMessage' => "#{cfg.banner_prefix} (recheck): NOT RUN — #{reason}#{tail}") if rechecked
         return 0
       end
 
@@ -663,7 +862,7 @@ module KairosHookProjector
       end
 
       verdict = failures.empty? ? 'PASS' : 'FAIL'
-      lost = note(cfg, "#{rechecked ? 'RECHECK-' : ''}#{verdict}-#{why}", metrics)
+      lost = note(cfg, "#{rechecked ? 'RECHECK-' : ''}#{verdict}-#{why}", metrics, record_id)
 
       out = { 'systemMessage' => banner(cfg, verdict, metrics, failures, rechecked, lost) }
       if !failures.empty? && !rechecked && cfg.blocking