kairos-chain 3.82.0 → 3.83.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4da090fdc44c60e73073401b9987dbe17377bda02e95048966ecdf187f63b71e
-  data.tar.gz: 6d24ce2aeab418e8c2a012ec7f1dd43285ede720db03bc5802f75defde87507b
+  metadata.gz: e601238b25375836907f7eec155beb0297e940cd5fd419ea855b7d48a3335993
+  data.tar.gz: 1c720eaa88d3204eedc436e38cdabaa3e79df3b9b5aca6260c925ec4173c6e62
 SHA512:
-  metadata.gz: 5f50569f19bf383b545aab43f6a831419f60cb3d156e15a385e98c68d175fc1ae1c6b7fd4bf288af49b975fcaec18b212ed0aecfcc77df09125aed8b29e2599b
-  data.tar.gz: 5782f2d19a495a354d62a622c7fa25d3494e10aafeb0513f9c8c47677a511c5615cbe6ef8065687113ac5482278c9b85dea44aad80cc21abd81154de49557a17
+  metadata.gz: d13dbb392110ebc2f5f913bc38e370f7c4c36ee8067d69d060ab4379f1a34cc9db98a37ee09b845d633a4c76821194bb5aa8eaeef6db6c77e43784f7831150f7
+  data.tar.gz: 34eca89babce68b01e805b6510967f0d1e2dca0faa0a856d1ec7a8881fd7e4a00cf90932c69ed7685cefe89e482144566ca4733d1efc433c2bf0b0038d9080af

data/CHANGELOG.md

@@ -4,6 +4,71 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.83.0] - 2026-09-01
+
+### Added — readable_gate measures sentence length
+
+`kairos_hook_projector` 0.6.0 → 0.7.0. The gate now reports three sentence
+metrics on every turn (`sentences`, `sentence_p90`, `sentence_max`) and honours
+two new thresholds, both off unless a mode names them:
+`max_sentence_chars_p90` and `sentence_min_count`.
+
+Why it was missing: the readable-output norm this gate exists to enforce names
+long sentences as its first observed failure form, and says "split overlong
+sentences" outright. Nothing in `measure()` was sentence-aware. The one symptom
+the norm names by hand was the one nothing measured, while the line cap — which
+the same norm calls a soft target rather than a gate — was enforced as a hard
+block.
+
+The cap is on the 90th percentile, not the mean and not the maximum: a mean
+hides the tail that does the damage, and a maximum fails a good answer for its
+one long sentence. Nearest-rank, so the number reported is the length of a
+sentence actually in the message. The length announcement does not clear it,
+for the diagram floor's reason — announcing that a message is long says nothing
+about whether its sentences are.
+
+`sentence_min_count` is not a convenience. Nearest-rank puts the 90th
+percentile at the last element for every count under ten, so below that floor
+the cap would be a maximum cap under another name.
+
+What counts as a sentence, each rule with a killed mutation behind it:
+
+- Sentences never span a line. A bullet with no terminating punctuation is one
+  sentence the length of its line, which is what it costs to read rather than
+  an artefact of the author's punctuation.
+- Headings, table rows, horizontal rules and blockquotes are not sentences. A
+  seven-column table row measured as one reads as a single 200-character
+  sentence and takes over every percentile in the message; and a quotation
+  cannot be shortened without cutting quoted facts, which a mode's own rewrite
+  instruction is likely to forbid — leaving "stop quoting sources" as the only
+  compliance.
+- A list marker is stripped rather than skipped. The text after it is prose the
+  reader reads, and skipping list items would exempt most bullet-written output.
+- A URL collapses to one character: it is clicked, not read.
+- An ASCII full stop splits only before whitespace. Without that condition
+  `readable_gate.rb`, `v0.4.6` and `3.82.0` shatter into fragments and the
+  measured tail collapses towards zero — a metric reporting every message as
+  readable.
+
+Declared and not closed: prose moved inside a fenced block is not measured.
+That is the hole the line count has always had, and closing it for one metric
+only would leave the two disagreeing about what the message contains.
+
+The core ships no number. `--report` gained `sent`, `sent_p90` and `sent_max`
+columns and is where a mode's cap comes from; `mode_hooks/_EXAMPLE.json`
+documents both keys and deliberately omits values, since the right one depends
+on what the author writes and in which script.
+
+- Cost: 0.9 ms of a 3.2 ms full measurement on a 25,719-character message,
+  against the hook's 9.5 s budget.
+- Tests: 168 runs, 997 assertions, 0 failures (was 152 runs; 16 new fixtures).
+  Mutation sweep filtered to the new family — 19/19 killed, 0 survived, 0
+  anchor-not-found, source restored byte-identical, 11-file baseline green at
+  325 runs.
+- One existing mutation anchor (M39) was retargeted: the sentence columns were
+  inserted into the argument list it points at, and a stale anchor reports
+  ANCHOR NOT FOUND rather than a survivor.
+
 ## [3.82.0] - 2026-08-31
 
 ### Added — L1 knowledge: html_slide_deck_authoring

data/lib/kairos_mcp/version.rb

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

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

@@ -92,6 +92,47 @@ module KairosHookProjector
     HEADING = Regexp.new('\A#{1,6}\s+\S')
     TABLE_SEP = Regexp.new('\A\s*\|?[\s:|-]*-[\s:|-]*\|[\s:|-]*\z')
 
+    # --- sentence measurement ------------------------------------------------
+    #
+    # Every pattern below is the core's own and fixed, so none of it goes
+    # through bounded_match. That seam exists for mode-supplied patterns, whose
+    # backtracking the core cannot bound by inspection; these are constant and
+    # linear, exactly like FENCE, HEADING and TABLE_SEP above.
+    #
+    # A table row and a horizontal rule carry no sentence, and measuring one as
+    # a sentence is the first thing that goes wrong when a length metric meets
+    # this project's output: a seven-column row reads as a single 200-character
+    # sentence and dominates every percentile taken over the message.
+    TABLE_ROW = Regexp.new('\A\s*\|')
+    RULE = Regexp.new('\A\s*(?:[-*_]\s*){3,}\z')
+    # A blockquote is not the author's sentence. Dropping it is not leniency:
+    # the mode's own rewrite instruction forbids cutting quoted facts, so a cap
+    # that fires on a quotation demands the one repair the instruction refuses,
+    # and the only compliance left is to stop quoting sources. Verbatim source
+    # text was one of the two false-positive classes in the 2026-09-01
+    # calibration.
+    QUOTE = Regexp.new('\A\s*>')
+    # A URL is one token however long it is: it is clicked, not read. Collapsed
+    # rather than dropped, so the sentence around it is still measured — the
+    # other false-positive class was the citation list, 226 to 333 characters
+    # of which almost none was prose.
+    URL = Regexp.new('(?:https?|ftp)://[^\s)]*')
+    # A list marker is stripped, not skipped. The text after it is prose the
+    # reader reads, and a bullet that runs to 150 characters is precisely what
+    # this metric exists to catch; skipping list items would have exempted most
+    # of this instance's output, which is written in bullets.
+    LIST_MARKER = Regexp.new('\A\s*(?:[-*+]|[0-9]+[.)])\s+')
+    # Where one sentence ends and the next begins. Two arms, because the corpus
+    # is mixed script. A CJK full stop needs no following space; an ASCII one
+    # does, and without that condition `readable_gate.rb`, `v0.4.6` and `3.82.0`
+    # each split into fragments and the measured tail collapses. Both arms are
+    # fixed-width lookbehind, which is all Ruby permits.
+    #
+    # Sentences never span a line. A bullet with no terminating punctuation is
+    # then one sentence the length of its line, which is the honest measure of
+    # what it costs to read rather than an artefact of the author's punctuation.
+    SENTENCE_BREAK = Regexp.new('(?<=[。．！？])|(?<=[.!?])(?=\s)')
+
     DEFAULTS = {
       'max_lines' => nil,
       'max_headings' => nil,
@@ -100,6 +141,20 @@ module KairosHookProjector
       # diagram is what the rule is about. Off unless the mode names a number,
       # like every other threshold here.
       'diagram_required_over_lines' => nil,
+      # The tail of the sentence-length distribution. The mode body names long
+      # sentences as the first observed failure form and says "split overlong
+      # sentences" in so many words, and until 2026-09-01 nothing here was
+      # sentence-aware: the one symptom the norm names by hand was the one
+      # nothing measured. Off unless the mode names a number, like every other
+      # threshold here.
+      'max_sentence_chars_p90' => nil,
+      # Below this many measured sentences the cap above does not apply. Not a
+      # convenience. Nearest-rank puts the 90th percentile at index
+      # ceil(0.9n) - 1, which is the last element for every n under ten — so on
+      # a short message the percentile IS the maximum, and a cap applied there
+      # is a maximum cap by another name, failing a good answer for one long
+      # sentence. That is the instrument the metric was chosen to avoid.
+      'sentence_min_count' => 1,
       'announce_patterns' => [],
       'shorthand_patterns' => [],
       'gloss_patterns' => [],
@@ -124,6 +179,7 @@ module KairosHookProjector
     }.freeze
 
     INT_KEYS = %w[max_lines max_headings max_tables diagram_required_over_lines
+                  max_sentence_chars_p90 sentence_min_count
                   vocab_min_lines log_max_bytes].freeze
     LIST_KEYS = %w[announce_patterns shorthand_patterns gloss_patterns
                    specimen_patterns].freeze
@@ -147,6 +203,7 @@ module KairosHookProjector
     class Config
       attr_reader :problems, :path, :mode_name, :mode_version, :section,
                   :max_lines, :max_headings, :max_tables, :diagram_over_lines,
+                  :max_sentence_p90, :sentence_min_count,
                   :vocab_min_lines,
                   :blocking, :banner_prefix, :rewrite_instruction, :log_path,
                   :announce, :shorthand, :gloss, :specimen,
@@ -169,6 +226,12 @@ module KairosHookProjector
         @max_headings = merged['max_headings']
         @max_tables = merged['max_tables']
         @diagram_over_lines = merged['diagram_required_over_lines']
+        # Named max_sentence_p90 on this side and max_sentence_chars_p90 on the
+        # mode's. The config key says what the number is measured in, because a
+        # mode author writing `"max_sentence_p90": 90` has no way to know from
+        # the name whether 90 is characters or a rank.
+        @max_sentence_p90 = merged['max_sentence_chars_p90']
+        @sentence_min_count = merged['sentence_min_count']
         @vocab_min_lines = merged['vocab_min_lines']
         # Declared by the mode, written into this config by the compiler, and
         # honoured here. A mode that declares blocking:false gets the verdict
@@ -769,6 +832,45 @@ module KairosHookProjector
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
+    # The character length of every sentence in the measured prose, unsorted.
+    #
+    # Fenced blocks never reach here — `prose` has already dropped them — which
+    # is a way past this metric: prose moved inside a fence stops being
+    # measured. Declared rather than closed, because it is the same hole
+    # `lines` has had since the gate was written, and closing it for one metric
+    # only would leave the two disagreeing about what the message contains.
+    def sentence_lengths(prose)
+      out = []
+      prose.each do |line|
+        next if HEADING.match(line) || TABLE_ROW.match(line) ||
+                RULE.match(line) || QUOTE.match(line)
+
+        body = line.sub(LIST_MARKER, '').gsub(URL, '#').strip
+        next if body.empty?
+
+        body.split(SENTENCE_BREAK).each do |sentence|
+          sentence = sentence.strip
+          out << sentence.length unless sentence.empty?
+        end
+      end
+      out
+    end
+
+    # Nearest-rank percentile over an unsorted list, and 0 for an empty one.
+    #
+    # A percentile rather than a mean or a maximum: a mean hides the tail that
+    # does the damage, and a maximum fails a good answer for its one long
+    # sentence. Nearest-rank rather than an interpolating definition, so the
+    # number the operator is shown is the length of a sentence that is actually
+    # in the message and can be found by reading it.
+    def percentile(values, fraction)
+      return 0 if values.empty?
+
+      sorted = values.sort
+      index = (fraction * sorted.length).ceil - 1
+      sorted[index.clamp(0, sorted.length - 1)]
+    end
+
     # Pure. [metrics, failures]. The whole judgement lives here.
     def measure(text, cfg, deadline)
       raw = text.split("\n", -1)
@@ -789,6 +891,7 @@ module KairosHookProjector
 
       headings = prose.count { |l| HEADING.match(l) }
       tables = prose.count { |l| TABLE_SEP.match(l) }
+      lengths = sentence_lengths(prose)
 
       first = raw.find { |l| !l.strip.empty? } || ''
       announced = !(cfg.announce && bounded_match(cfg.announce, first, 0, deadline)).nil?
@@ -827,6 +930,9 @@ module KairosHookProjector
         'headings' => headings,
         'tables' => tables,
         'diagrams' => diagrams,
+        'sentences' => lengths.length,
+        'sentence_p90' => percentile(lengths, 0.9),
+        'sentence_max' => lengths.max || 0,
         'announced' => announced,
         'unglossed' => unglossed
       }
@@ -844,6 +950,21 @@ module KairosHookProjector
       if cfg.max_tables && tables > cfg.max_tables
         failures << format('TABLES: %d (cap %d).', tables, cfg.max_tables)
       end
+      # The announcement does not clear this one either, for the diagram
+      # floor's reason: saying a message is long says nothing about whether its
+      # sentences are, and the two exemptions must not be shared. The count and
+      # the maximum travel with the verdict because the cap alone does not say
+      # how far off the message is, or whether one sentence or twenty carried it
+      # there.
+      if cfg.max_sentence_p90 && metrics['sentences'] >= cfg.sentence_min_count &&
+         metrics['sentence_p90'] > cfg.max_sentence_p90
+        failures << format(
+          'SENTENCES: the 90th-percentile sentence is %d characters (cap %d); ' \
+          'the longest is %d, over %d sentences. Split the long ones.',
+          metrics['sentence_p90'], cfg.max_sentence_p90,
+          metrics['sentence_max'], metrics['sentences']
+        )
+      end
       # A floor, and the announcement does not clear it: announcing that a
       # message is long says nothing about whether prose was the right carrier
       # for what is in it.
@@ -883,8 +1004,10 @@ module KairosHookProjector
       detail += "\trec=#{record_id[0, 8]}" if record_id.is_a?(String) && !record_id.empty?
       if metrics
         detail += format(
-          "\tlines=%d\theadings=%d\ttables=%d\tdiagrams=%d\tunglossed=%s",
+          "\tlines=%d\theadings=%d\ttables=%d\tdiagrams=%d" \
+          "\tsent=%d\tsent_p90=%d\tsent_max=%d\tunglossed=%s",
           metrics['lines'], metrics['headings'], metrics['tables'], metrics['diagrams'],
+          metrics['sentences'], metrics['sentence_p90'], metrics['sentence_max'],
           metrics['unglossed'].empty? ? '-' : metrics['unglossed'].join(',')
         )
       end
@@ -936,9 +1059,10 @@ module KairosHookProjector
     end
 
     def banner(cfg, verdict, metrics, failures, rechecked, log_failure = nil)
-      shape = format('%d lines / %d headings / %d tables / %d diagrams',
+      shape = format('%d lines / %d headings / %d tables / %d diagrams / ' \
+                     'sentence p90 %d chars',
                      metrics['lines'], metrics['headings'], metrics['tables'],
-                     metrics['diagrams'])
+                     metrics['diagrams'], metrics['sentence_p90'])
       notes = []
       notes << failures.map { |f| f.split(':').first }.join(' / ') unless failures.empty?
       notes << log_note(log_failure) if log_failure
@@ -977,8 +1101,15 @@ module KairosHookProjector
           next unless text
 
           m, f = measure(text, cfg, nil)
-          puts format("%s\tlines=%d\theadings=%d\ttables=%d\tFAIL=%s",
+          # The sentence columns are here for the reason the whole metric was
+          # added off: no number was proposed with it, and the distribution
+          # these three columns produce over a real corpus is where one comes
+          # from. A cap picked from anything smaller repeats the mistake the
+          # metric was written to correct.
+          puts format("%s\tlines=%d\theadings=%d\ttables=%d" \
+                      "\tsent=%d\tsent_p90=%d\tsent_max=%d\tFAIL=%s",
                       path, m['lines'], m['headings'], m['tables'],
+                      m['sentences'], m['sentence_p90'], m['sentence_max'],
                       f.empty? ? '-' : f.map { |x| x.split(':').first }.join(','))
         end
       end

data/templates/skillsets/kairos_hook_projector/mode_hooks/_EXAMPLE.json

@@ -50,7 +50,7 @@
     "Stop": [
       {
         "gate": "readable_gate",
-        "_description": "Measures the turn's last message against declared readability limits — length, headings, tables, undefined shorthand, a missing diagram — and reports to its log, or blocks the turn once blocking is true.",
+        "_description": "Measures the turn's last message against declared readability limits — length, headings, tables, sentence length, undefined shorthand, a missing diagram — and reports to its log, or blocks the turn once blocking is true.",
         "section": "§ Readable output",
 
         "_blocking_note": "false on purpose in the example. The vocabulary rule below is the one thing here that cannot be got right by reading: whether a shape is coined shorthand or an ordinary technical word depends on what you write about. Start in report-only mode, read your log for a week, then set this to true. Shipping the example with true meant a consumer who copied it as instructed was blocked on the first message mentioning a character encoding.",
@@ -63,6 +63,8 @@
           "_diagram_note": "A floor rather than a cap: over this many lines of prose, a message carrying no fenced block is reported. Omit the key to leave the floor off. Announcing the length does not clear it — an announcement says the message is long, not that prose was the right carrier.",
           "diagram_required_over_lines": 30,
 
+          "_sentence_note": "A cap on the 90th percentile of sentence length in characters, not the mean and not the maximum: a mean hides the tail that does the damage, and a maximum fails a good answer for its one long sentence. Both keys are omitted here on purpose, because the right number depends entirely on what you write — a Japanese sentence, an English one and a line of dense technical prose are not the same length at the same reading cost. Run `readable_gate.rb --config <cfg> --report <transcript.jsonl>` over your own answers first: it prints sent, sent_p90 and sent_max per message, and the number to set is read off that distribution. To turn it on, add: \"max_sentence_chars_p90\": <number>, \"sentence_min_count\": 10. The floor is not a convenience — nearest-rank puts the 90th percentile at the last element for every count under ten, so below it the cap is a maximum cap under another name. Table rows, headings, horizontal rules and blockquotes are not measured as sentences, a URL counts as one token however long, and a list marker is stripped rather than skipped so a long bullet is still measured.",
+
           "vocab_min_lines": 8,
           "banner_prefix": "readable gate",
           "announce_patterns": [

data/templates/skillsets/kairos_hook_projector/skillset.json

@@ -1,6 +1,6 @@
 {
   "name": "kairos_hook_projector",
-  "version": "0.6.0",
+  "version": "0.7.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

@@ -89,11 +89,21 @@ MUTATIONS = [
   ['M32 the first read waits a third as long',
    %q{    POLL_ATTEMPTS = 15},
    %q{    POLL_ATTEMPTS = 5}],
+  # Retargeted 2026-09-01 when the three sentence columns were inserted between
+  # diagrams= and unglossed=. The anchor is the whole argument list, so an
+  # anchor left pointing at the four-column form would have reported ANCHOR NOT
+  # FOUND rather than a survivor — visible, but only to someone reading the
+  # sweep output rather than its summary line.
   ['M39 the log swaps the headings and tables columns',
-   %q{          "\tlines=%d\theadings=%d\ttables=%d\tdiagrams=%d\tunglossed=%s",
-          metrics['lines'], metrics['headings'], metrics['tables'], metrics['diagrams'],},
-   %q{          "\tlines=%d\theadings=%d\ttables=%d\tdiagrams=%d\tunglossed=%s",
-          metrics['lines'], metrics['tables'], metrics['headings'], metrics['diagrams'],}],
+   %q{          metrics['lines'], metrics['headings'], metrics['tables'], metrics['diagrams'],
+          metrics['sentences'], metrics['sentence_p90'], metrics['sentence_max'],},
+   %q{          metrics['lines'], metrics['tables'], metrics['headings'], metrics['diagrams'],
+          metrics['sentences'], metrics['sentence_p90'], metrics['sentence_max'],}],
+  ['M60 the log swaps the sentence p90 and max columns',
+   %q{          metrics['sentences'], metrics['sentence_p90'], metrics['sentence_max'],
+          metrics['unglossed'].empty? ? '-' : metrics['unglossed'].join(',')},
+   %q{          metrics['sentences'], metrics['sentence_max'], metrics['sentence_p90'],
+          metrics['unglossed'].empty? ? '-' : metrics['unglossed'].join(',')}],
   ['M42 the unreadable exit polls before giving up',
    %q{        rows = tail_records(transcript_path)
         return [nil, 'unreadable', nil] if rows.nil?},
@@ -415,6 +425,81 @@ MUTATIONS = [
       end},
    %q{      Regexp.timeout = remaining
       regexp.match(string, pos)}],
+  # --- sentence length: the metric added 2026-09-01 --------------------------
+  #
+  # The norm this gate enforces names long sentences as its first failure form
+  # and says "split overlong sentences" outright, and nothing here was
+  # sentence-aware until now. Each row below is paired with the fixture that
+  # kills it; the pairing is what keeps "the metric is witnessed" from being a
+  # claim about assertion count.
+  ['S1  the sentence cap is never applied',
+   %q{      if cfg.max_sentence_p90 && metrics['sentences'] >= cfg.sentence_min_count &&},
+   %q{      if false && metrics['sentences'] >= cfg.sentence_min_count &&}],
+  ['S2  the cap reads the maximum instead of the 90th percentile',
+   %q{         metrics['sentence_p90'] > cfg.max_sentence_p90},
+   %q{         metrics['sentence_max'] > cfg.max_sentence_p90}],
+  ['S3  the count floor is ignored, so a short message is judged by its maximum',
+   %q{      if cfg.max_sentence_p90 && metrics['sentences'] >= cfg.sentence_min_count &&},
+   %q{      if cfg.max_sentence_p90 && true &&}],
+  ['S4  the cap boundary fires at the cap instead of above it',
+   %q{         metrics['sentence_p90'] > cfg.max_sentence_p90},
+   %q{         metrics['sentence_p90'] >= cfg.max_sentence_p90}],
+  ['S5  the announcement is made to clear the sentence cap too',
+   %q{      if cfg.max_sentence_p90 && metrics['sentences'] >= cfg.sentence_min_count &&},
+   %q{      if cfg.max_sentence_p90 && !announced && metrics['sentences'] >= cfg.sentence_min_count &&}],
+  ['S6  the percentile index loses its rank correction',
+   %q{      index = (fraction * sorted.length).ceil - 1},
+   %q{      index = (fraction * sorted.length).ceil}],
+  ['S7  the empty message is given a sentence length rather than none',
+   %q{      return 0 if values.empty?},
+   %q{      return 1 if values.empty?}],
+  ['S8  a table row is measured as a sentence',
+   %q{        next if HEADING.match(line) || TABLE_ROW.match(line) ||
+                RULE.match(line) || QUOTE.match(line)},
+   %q{        next if HEADING.match(line) ||
+                RULE.match(line) || QUOTE.match(line)}],
+  ['S9  a heading is measured as a sentence',
+   %q{        next if HEADING.match(line) || TABLE_ROW.match(line) ||
+                RULE.match(line) || QUOTE.match(line)},
+   %q{        next if TABLE_ROW.match(line) ||
+                RULE.match(line) || QUOTE.match(line)}],
+  ['S10 a quotation is measured as the author\'s own sentence',
+   %q{        next if HEADING.match(line) || TABLE_ROW.match(line) ||
+                RULE.match(line) || QUOTE.match(line)},
+   %q{        next if HEADING.match(line) || TABLE_ROW.match(line) ||
+                RULE.match(line)}],
+  ['S11 the list marker is skipped instead of stripped, exempting every bullet',
+   %q{        body = line.sub(LIST_MARKER, '').gsub(URL, '#').strip},
+   %q{        next if LIST_MARKER.match(line)
+        body = line.gsub(URL, '#').strip}],
+  ['S12 a URL carries its own length into the sentence',
+   %q{        body = line.sub(LIST_MARKER, '').gsub(URL, '#').strip},
+   %q{        body = line.sub(LIST_MARKER, '').strip}],
+  ['S13 a line is never split at its terminators',
+   %q{        body.split(SENTENCE_BREAK).each do |sentence|},
+   %q{        [body].each do |sentence|}],
+  ['S14 the ASCII arm loses its whitespace condition, shattering identifiers',
+   %q{    SENTENCE_BREAK = Regexp.new('(?<=[。．！？])|(?<=[.!?])(?=\s)')},
+   %q{    SENTENCE_BREAK = Regexp.new('(?<=[。．！？])|(?<=[.!?])')}],
+  ['S15 the CJK arm is dropped, so Japanese reads as one sentence per line',
+   %q{    SENTENCE_BREAK = Regexp.new('(?<=[。．！？])|(?<=[.!?])(?=\s)')},
+   %q{    SENTENCE_BREAK = Regexp.new('(?<=[.!?])(?=\s)')}],
+  ['S16 sentence_max reports the percentile, so the log has two of one column',
+   %q{        'sentence_max' => lengths.max || 0,},
+   %q{        'sentence_max' => percentile(lengths, 0.9),}],
+  ['S17 the banner stops naming the sentence measurement',
+   %q{                     'sentence p90 %d chars',},
+   %q{                     'sentence p90 unmeasured',}],
+  ['S18 the two sentence thresholds leave the type check',
+   %q{    INT_KEYS = %w[max_lines max_headings max_tables diagram_required_over_lines
+                  max_sentence_chars_p90 sentence_min_count
+                  vocab_min_lines log_max_bytes].freeze},
+   %q{    INT_KEYS = %w[max_lines max_headings max_tables diagram_required_over_lines
+                  vocab_min_lines log_max_bytes].freeze}],
+  ['S19 the --report path stops printing the columns a cap is calibrated from',
+   %q{                      "\tsent=%d\tsent_p90=%d\tsent_max=%d\tFAIL=%s",},
+   %q{                      "\tFAIL=%s%s%s%s",}],
+
   ['B18 the revocation is demoted to a trailing statement, leaking on the cut exit',
    %q{      Regexp.timeout = remaining
       begin

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

@@ -201,6 +201,107 @@ class TestReadableGate < Minitest::Test
     assert_empty f, 'the core supplies no floor of its own'
   end
 
+  # --- sentence length ------------------------------------------------------
+  #
+  # The mode body names long sentences as the first observed failure form and
+  # says "split overlong sentences" outright, and until 2026-09-01 nothing here
+  # was sentence-aware. The rewrite that occasioned this metric met every cap
+  # and kept 36% of its sentences over 60 characters with a 177-character
+  # maximum: the caps were met by packing more into each line, and per-line
+  # effort is what the reader experienced.
+
+  # Three rules at once, on one fixture: a line splits at its terminators, a
+  # bullet is measured with its marker stripped rather than skipped, and a
+  # heading or a table row is not a sentence at all. Four different numbers so
+  # that dropping any one rule moves a count.
+  def test_what_counts_as_a_sentence
+    text = "これはテスト。次の文です。\n- 箇条書きの行\n| a | b |\n|---|---|\n# 見出し\n"
+    m, = measure(text)
+    assert_equal 3, m['sentences'],
+                 "two sentences on the first line and the bullet: #{m.inspect}"
+    assert_equal 7, m['sentence_max'], 'これはテスト。 is the longest of the three'
+  end
+
+  # A table row measured as a sentence is what goes wrong first when a length
+  # metric meets this project's output: one seven-column row reads as a single
+  # 200-character sentence and takes over every percentile in the message.
+  def test_a_table_row_never_becomes_the_longest_sentence
+    row = "| #{(['very long cell text here'] * 7).join(' | ')} |"
+    m, = measure("短い文です。\n#{row}\n")
+    assert_equal 1, m['sentences'], "the row is not a sentence: #{m.inspect}"
+    assert_equal 6, m['sentence_max'], m.inspect
+  end
+
+  # The ASCII arm requires whitespace after the stop. Without that condition a
+  # file name, a version and a dotted number each shatter into fragments, and
+  # the measured tail collapses towards zero — a metric that reports every
+  # message as readable.
+  def test_an_identifier_full_stop_does_not_end_a_sentence
+    m, = measure("See readable_gate.rb now. Then v0.4.6 ships.\n")
+    assert_equal 2, m['sentences'], m.inspect
+    assert_equal 25, m['sentence_max'], 'See readable_gate.rb now. is the longer'
+  end
+
+  # Sentences do not span lines. A bullet with no terminating punctuation is
+  # one sentence the length of its line, which is what it costs to read; the
+  # alternative measures the author's punctuation habits instead.
+  def test_an_unterminated_line_is_one_sentence_of_its_own_length
+    m, = measure("- 終止符のない箇条書き\n- 二つ目\n")
+    assert_equal 2, m['sentences'], m.inspect
+    assert_equal 10, m['sentence_max'], 'the marker is stripped before the length is taken'
+  end
+
+  # Quoted source text is not the author's sentence, and the mode's own rewrite
+  # instruction forbids cutting quoted facts — so a cap that fired here would
+  # demand the one repair the instruction refuses, leaving "stop quoting
+  # sources" as the only compliance.
+  def test_a_blockquote_is_not_the_authors_sentence
+    m, = measure("短い文です。\n> #{'x' * 400}\n")
+    assert_equal 1, m['sentences'], m.inspect
+    assert_equal 6, m['sentence_max'], m.inspect
+  end
+
+  # A URL is clicked, not read. Collapsed rather than dropped, so the sentence
+  # around it is still measured: the citation list was one of the two
+  # false-positive classes the 2026-09-01 calibration turned up.
+  def test_a_url_counts_as_one_token_however_long
+    m, = measure("出典は https://example.com/#{'a' * 300} です。\n")
+    assert_equal 1, m['sentences'], m.inspect
+    assert_operator m['sentence_max'], :<, 20, "the URL must not carry its length: #{m.inspect}"
+  end
+
+  # The cap reads the 90th percentile, not the maximum. Every boundary fixture
+  # above uses sentences of one length, where the two coincide; this one is the
+  # only place they differ, and it is what tells a p90 cap from a max cap.
+  def test_the_cap_reads_the_percentile_and_not_the_maximum
+    text = (['x' * 10] * 9).join("\n") + "\n#{'y' * 400}"
+    m, f = measure(text, 'max_sentence_chars_p90' => 60, 'sentence_min_count' => 10)
+    assert_equal 10, m['sentence_p90'], m.inspect
+    assert_equal 400, m['sentence_max'], m.inspect
+    assert_empty f.select { |x| x.start_with?('SENTENCES') },
+                 'one long sentence among ten must not fail a good answer'
+  end
+
+  # The cap is type-checked where every other threshold is. A mode writing
+  # `"max_sentence_chars_p90": "160"` used to be the shape that raised on every
+  # turn: non-zero exit, no verdict, no log line.
+  def test_a_mistyped_sentence_cap_reports_instead_of_enforcing
+    out = decide((['x' * 100] * 12).join("\n"),
+                 max_sentence_chars_p90: '60', sentence_min_count: '10')
+    refute out.key?('decision'), out.inspect
+    assert_includes out.fetch('systemMessage', ''), 'max_sentence_chars_p90'
+    assert_includes out.fetch('systemMessage', ''), 'sentence_min_count'
+  end
+
+  # Nearest-rank, and the degeneracy it carries. Below ten sentences the 90th
+  # percentile IS the maximum, which is the whole ground for sentence_min_count
+  # and the reason a short message must not be judged by this cap.
+  def test_the_percentile_is_nearest_rank_and_degenerates_under_ten
+    assert_equal 9, G.percentile((1..10).to_a, 0.9), 'the ninth of ten'
+    assert_equal 9, G.percentile((1..9).to_a, 0.9), 'under ten it is the maximum'
+    assert_equal 0, G.percentile([], 0.9), 'and an empty message has no sentence'
+  end
+
   # --- vocabulary: the case that misfired in production ---------------------
 
   MASA_SHORTHAND =
@@ -1925,6 +2026,84 @@ class TestReadableGate < Minitest::Test
     assert f.any? { |x| x.start_with?('DIAGRAM') }, f.inspect
   end
 
+  def test_the_sentence_cap_boundary
+    at_cap = (['x' * 60] * 10).join("\n")
+    _, f = measure(at_cap, 'max_sentence_chars_p90' => 60, 'sentence_min_count' => 10)
+    assert_empty f.select { |x| x.start_with?('SENTENCES') },
+                 'a 60-character p90 at cap 60 is within the cap'
+    over = (['x' * 61] * 10).join("\n")
+    _, f = measure(over, 'max_sentence_chars_p90' => 60, 'sentence_min_count' => 10)
+    assert f.any? { |x| x.start_with?('SENTENCES') }, f.inspect
+  end
+
+  # The count floor under its own name. Its whole ground is that nearest-rank
+  # puts the 90th percentile at the last element for every n under ten, so a
+  # short message judged by this cap is judged by its maximum — the instrument
+  # the metric was chosen over.
+  def test_the_sentence_count_floor_boundary
+    overrides = { 'max_sentence_chars_p90' => 60, 'sentence_min_count' => 10 }
+    _, f = measure((['x' * 100] * 10).join("\n"), overrides)
+    assert f.any? { |x| x.start_with?('SENTENCES') },
+           "10 sentences at floor 10 is judged: #{f.inspect}"
+    _, f = measure((['x' * 100] * 9).join("\n"), overrides)
+    assert_empty f.select { |x| x.start_with?('SENTENCES') },
+                 '9 stays below the floor'
+  end
+
+  # The length cap yields to an announcement; this one does not, for the
+  # diagram floor's reason. Saying a message is long says nothing about whether
+  # its sentences are, so the two exemptions must not be shared.
+  def test_announcing_the_length_does_not_clear_the_sentence_cap
+    text = "長いです。\n" + (['x' * 100] * 10).join("\n")
+    _, f = measure(text, 'max_sentence_chars_p90' => 60, 'sentence_min_count' => 10,
+                         'max_lines' => 5, 'announce_patterns' => ['長い'])
+    assert_empty f.select { |x| x.start_with?('LENGTH') }, 'the announcement clears length'
+    assert f.any? { |x| x.start_with?('SENTENCES') }, f.inspect
+  end
+
+  def test_the_sentence_cap_is_off_unless_the_mode_names_a_number
+    m, f = measure((['x' * 300] * 20).join("\n"))
+    assert_empty f, 'the core supplies no sentence cap of its own'
+    assert_equal 300, m['sentence_p90'], 'and measures anyway, which is what calibration reads'
+  end
+
+  # The block a mode with this cap declared actually issues, driven end to end,
+  # plus the banner shape the operator reads every turn.
+  def test_a_message_whose_sentences_run_long_is_blocked
+    out = decide((['x' * 100] * 12).join("\n"),
+                 max_sentence_chars_p90: 60, sentence_min_count: 10)
+    assert_equal 'block', out['decision'], out.inspect
+    assert_includes out.fetch('reason', ''), 'SENTENCES'
+    assert_includes out.fetch('systemMessage', ''), 'sentence p90 100 chars'
+  end
+
+  # Three different numbers, so a transposition of any pair is visible. p90 and
+  # max coincide on any message under ten sentences, which is why this fixture
+  # has ten.
+  def test_the_log_names_each_sentence_metric_in_its_own_column
+    text = (['ab。'] * 9).join("\n") + "\nabcdefghijk"
+    _out, log = drive([row_for('assistant', text: text, uuid: 'AAA')],
+                      rechecked: false, max_headings: 3)
+    assert_includes log, "\tsent=10\tsent_p90=3\tsent_max=11\t",
+                    "ten sentences, a p90 of 3 and a maximum of 11: #{log.inspect}"
+  end
+
+  # The offline path is where a number for this cap comes from, so its columns
+  # are load-bearing rather than decorative.
+  def test_the_report_path_prints_the_sentence_columns
+    Dir.mktmpdir do |tmp|
+      cfg_path = File.join(tmp, 'cfg.json')
+      tx = File.join(tmp, 't.jsonl')
+      File.write(cfg_path, JSON.generate('mode_name' => 't'), encoding: 'UTF-8')
+      text = (['ab。'] * 9).join("\n") + "\nabcdefghijk"
+      File.write(tx, rows_json([row_for('assistant', text: text)]), encoding: 'UTF-8')
+
+      out, _err, status = run_script(cfg_path, '', ['--report', tx])
+      assert_equal 0, status.exitstatus
+      assert_includes out, "\tsent=10\tsent_p90=3\tsent_max=11\t", out.inspect
+    end
+  end
+
   # The floor under its own name. Until now its loss reddened only tests about
   # the timeout machinery, so a maintainer who broke it was shown the wrong
   # defect entirely.
@@ -1976,6 +2155,7 @@ class TestReadableGate < Minitest::Test
     G.define_singleton_method(:measure) do |*|
       seen = Regexp.timeout
       [{ 'lines' => 1, 'headings' => 0, 'tables' => 0, 'diagrams' => 0,
+         'sentences' => 1, 'sentence_p90' => 1, 'sentence_max' => 1,
          'announced' => false, 'unglossed' => [] }, []]
     end
     begin

metadata

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