kairos-chain 3.42.0 → 3.42.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07f782a3ef998bf91435a2e35cde051338c6f1c2fa8f2e037fbba4427c400ccf
-  data.tar.gz: 8cd549860f69e91fa94bf50a41121cb3b7625686f2438c2c665c83192f081f27
+  metadata.gz: 7d6b5abadc2727f37c441c8d0442da6470438537ad47f387e6c4021769c678dd
+  data.tar.gz: f5c625947d73fb41251829cf638b397308294daa4fed7ed94cae945ad6086b72
 SHA512:
-  metadata.gz: e1ec23c12c08cff2ce324b34715d8eedd0277863a4e561b439c7161bd6e1b08eb10936c36db603ba621544e424953fe24247fe553917d3d4fcb6e844867d7f42
-  data.tar.gz: 738519ef9bc54544c058f59661d08288b22d60904527dbfb7f99f501f89b35d1a80c095b2b5090750f9aff69d592acc46357fe4069064302db344659b68b5642
+  metadata.gz: 4948c9a12280c2ccc7e0083e056d0ad99d457fcb11d86761f060a891d2033924395521364b5f867ca30eec2cc806f5d539ccc22282657c31e31a0695a5270f55
+  data.tar.gz: 789de8f265c7d1dbbde4969643e26f3359887b3417ddd76fe5567348b41c9dc8c37b2f062f6e77d382abc49becd4a2703ac4de29cf8d2f63b62c9fef272a5db1

data/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.42.1] - 2026-07-14
+
+### Fixed — SectionWriter auto-chunk completeness & duplicate tail
+
+Two follow-ups to the v3.42.0 auto-chunk on output-uncapped providers
+(e.g. the `claude_code` CLI):
+
+- **Completeness.** v3.42.0 added a per-chunk "rewrite ONLY these paragraphs"
+  bound to avoid a trailing duplicate. On `claude_code` that bound backfired —
+  the model under-produced and dropped the section tail, leaving long sections
+  incomplete. Removed the bound.
+- **Duplicate tail (provider-agnostic).** Some providers "finish the section"
+  from the first chunk; the remaining passes then appended duplicate content.
+  `SectionWriter` now stops chunking once the assembled output already covers
+  ~the whole source (`section_complete_fraction`, default 0.85). Providers that
+  rewrite each chunk faithfully (e.g. API adapters, where `max_tokens` is
+  honoured) never trip this and still run every chunk. Net: a single clean,
+  complete section on both provider kinds. `chunks` in the result now reports
+  the number of passes actually run.
+
 ## [3.42.0] - 2026-07-14
 
 ### Fixed / Improved — agent SkillSet self-drive on long document sections

data/lib/kairos_mcp/version.rb

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

data/templates/skillsets/document_authoring/lib/document_authoring/section_writer.rb

@@ -23,20 +23,27 @@ module KairosMcp
           # paragraph boundaries and generate each chunk in its own pass, appending the
           # results. Short contexts stay a single pass (chunks == [context_text]).
           chunks = split_context(context_text, chunk_target)
+          source_chars = context_text.to_s.gsub(/\s+/, '').length
+          complete_at = (source_chars * complete_fraction).ceil
 
           total_units = 0
           total_chars = 0
+          chunks_written = 0
           chunks.each_with_index do |chunk, idx|
             first = idx.zero?
+            # Provider-agnostic de-duplication: some output-uncapped providers (e.g. the
+            # claude_code CLI) "finish the section" from the first chunk. Once the assembled
+            # output already covers ~the whole source, stop — further passes would only
+            # append duplicate content. Providers that rewrite each chunk faithfully never
+            # trip this (their per-chunk output tracks per-chunk input), so all chunks run.
+            break if !first && total_chars >= complete_at
+
+            # Continuation chunks must not repeat the section heading. (A stronger
+            # "rewrite only these paragraphs" bound was tried but backfired on the
+            # claude_code CLI — it then under-produced and dropped the section tail.)
             chunk_instructions =
-              if chunks.length > 1
-                # Bound EVERY chunk to its own paragraphs. Without this, providers that
-                # "finish the section" (e.g. claude_code) regenerate the whole section from
-                # the first chunk, so later chunks duplicate content. Continuation chunks
-                # also must not repeat the heading.
-                notes = [bounded_note(language)]
-                notes << continuation_note(language) unless first
-                "#{instructions}\n\n#{notes.join("\n")}"
+              if chunks.length > 1 && !first
+                "#{instructions}\n\n#{continuation_note(language)}"
               else
                 instructions
               end
@@ -49,6 +56,7 @@ module KairosMcp
             write_chunk(output_file, gen['content'], first ? append_mode : true)
             total_units += count_units(gen['content'], language)
             total_chars += gen['content'].gsub(/\s+/, '').length
+            chunks_written += 1
           end
 
           {
@@ -60,7 +68,7 @@ module KairosMcp
             # non-whitespace char count so callers never size output from a bogus metric.
             'word_count' => total_units,
             'char_count' => total_chars,
-            'chunks' => chunks.length
+            'chunks' => chunks_written
           }
         end
 
@@ -167,24 +175,20 @@ module KairosMcp
         end
 
         # Auto-chunk threshold. Sized so each pass is small enough that output-uncapped
-        # providers (e.g. claude_code CLI) emit the whole chunk without stopping early —
+        # providers (e.g. claude_code CLI) emit a full section without stopping early —
         # empirically a larger single pass truncates, while ~3000-char passes complete.
-        # The bounded_note keeps chunks from overlapping. Overridable via config.
+        # On such providers the first chunk may "finish the section", so the output can
+        # carry a trailing duplicate fragment; completeness is favoured over that cosmetic
+        # cost. API providers (with max_tokens honoured) produce a clean single section.
+        # Overridable via config.
         def chunk_target
           (@config['section_chunk_target_chars'] || 3000).to_i
         end
 
-        # Appended to EVERY chunk (when chunking) so the model rewrites only the paragraphs
-        # it was given and does not "finish the section" — which would make chunks overlap.
-        def bounded_note(language)
-          if %w[ja zh ko].include?(language.to_s)
-            '重要: 以下に与えた段落だけを推敲せよ。節はいくつかに分けて処理される。' \
-              '与えられていない段落を書き足したり、節の続きをここで完成させたりしてはならない。'
-          else
-            'IMPORTANT: Rewrite ONLY the paragraphs given below. The section is processed ' \
-              'in several passes; do NOT add paragraphs that are not in this input or ' \
-              'finish the rest of the section here.'
-          end
+        # Fraction of the source (by non-whitespace chars) at which the assembled output is
+        # considered to already cover the whole section, so remaining chunks are skipped.
+        def complete_fraction
+          (@config['section_complete_fraction'] || 0.85).to_f
         end
 
         # Appended to a continuation chunk's instructions so the model does not repeat the

data/templates/skillsets/document_authoring/test/test_document_authoring.rb

@@ -468,6 +468,40 @@ assert("T18g: append_mode applies only to the first chunk; later chunks append")
   content.start_with?('PRE') && content.include?("c1\n\nc2\n\nc3")
 end
 
+assert("T18h: stops chunking once output already covers the whole source (no duplicate tail)") do
+  caller = MockCallerTool.new
+  calls = 0
+  caller.define_singleton_method(:invoke_tool) do |tool_name, arguments = {}, context: nil|
+    calls += 1
+    # First pass "finishes the section" (output >= source); a later pass would be a dup.
+    body = calls == 1 ? ('な' * 500) : 'DUPLICATE'
+    [{ text: JSON.generate({ 'status' => 'ok', 'response' => { 'content' => body }, 'snapshot' => {} }) }]
+  end
+  writer = SW.new(caller, { 'section_chunk_target_chars' => 100 })
+  ctx = (1..5).map { ('あ' * 80) }.join("\n\n") # ~400 non-ws source chars, would be 5 chunks
+  out = File.join(TMPDIR, 'earlystop.md')
+  r = writer.write(section_name: 's', instructions: 'i', context_text: ctx,
+                   output_file: out, max_words: 100, language: 'ja', append_mode: false)
+  # chunk1 output (500) >= 0.85 * 400 = 340 → stop after the first pass
+  r['chunks'] == 1 && calls == 1 && !File.read(out).include?('DUPLICATE')
+end
+
+assert("T18i: faithful per-chunk provider still runs all chunks (no premature stop)") do
+  caller = MockCallerTool.new
+  calls = 0
+  caller.define_singleton_method(:invoke_tool) do |tool_name, arguments = {}, context: nil|
+    calls += 1
+    [{ text: JSON.generate({ 'status' => 'ok', 'response' => { 'content' => "p#{calls}" }, 'snapshot' => {} }) }]
+  end
+  writer = SW.new(caller, { 'section_chunk_target_chars' => 100 })
+  ctx = (1..4).map { ('あ' * 80) }.join("\n\n")
+  out = File.join(TMPDIR, 'faithful.md')
+  r = writer.write(section_name: 's', instructions: 'i', context_text: ctx,
+                   output_file: out, max_words: 100, language: 'ja', append_mode: false)
+  # short per-chunk output never reaches the completeness threshold → all chunks run
+  r['chunks'] > 1 && calls == r['chunks'] && File.read(out).include?("p#{calls}")
+end
+
 assert("T18d: max_tokens respects config ceiling override") do
   caller = MockCallerTool.new
   captured = {}

metadata

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