kairos-chain 3.41.1 → 3.42.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e3b999308891ccbf76963cea480730833fc1d13289498ec80b7f11471d78148
-  data.tar.gz: 1158b528c37b571283fbf86ea8d16b6feb05604aed70f7ae356961d99e123752
+  metadata.gz: 7d6b5abadc2727f37c441c8d0442da6470438537ad47f387e6c4021769c678dd
+  data.tar.gz: f5c625947d73fb41251829cf638b397308294daa4fed7ed94cae945ad6086b72
 SHA512:
-  metadata.gz: cd647719bd49cd6a66f5836fc3c4acd98c07a5210876a83f4f5ed6cf76c100e801971b84289c515768c44754c5412db177e728c3fc00a0a34bee25b057281af4
-  data.tar.gz: 9bbd8eed34dc64daa0fd7265ec6d42ee97e018399f9c090908688c0edbc0afa245782316fb66c02f6e9af4d8a01a9eedfca2ad46d678eda4af92465dc4019bd4
+  metadata.gz: 4948c9a12280c2ccc7e0083e056d0ad99d457fcb11d86761f060a891d2033924395521364b5f867ca30eec2cc806f5d539ccc22282657c31e31a0695a5270f55
+  data.tar.gz: 789de8f265c7d1dbbde4969643e26f3359887b3417ddd76fe5567348b41c9dc8c37b2f062f6e77d382abc49becd4a2703ac4de29cf8d2f63b62c9fef272a5db1

data/CHANGELOG.md

@@ -4,6 +4,56 @@ 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
+
+Surfaced while running the governed agent OODA loop on a long Japanese
+naturalisation task. Four independent limitations:
+
+- **`document_authoring` context truncation (root cause).** `write_section`
+  handed the assembler a 4000-char `max_chars_per_source` cap, so long
+  `context_sources` were silently cut before generation. Raised the default to
+  500 000 (total 1 000 000); `SectionWriter` now bounds output size itself.
+- **`SectionWriter` output completeness.** `llm_call` was invoked without
+  `max_tokens`, so API providers truncated long sections at the ~4096 default —
+  now sized from context length. Providers without an output-length knob (e.g.
+  the `claude_code` CLI) are handled by **auto-chunking** the context at
+  paragraph boundaries (`section_chunk_target_chars`, default 3000) with a
+  bounded per-chunk instruction. `word_count` is now language-aware (character
+  count for JA/ZH/KO); a `char_count` field was added.
+- **Non-deterministic risk gate.** `Autonomos::Mandate.risk_exceeds_budget?`
+  used the DECIDE model's self-assigned per-step `risk`, so identical read-only
+  work gated inconsistently. Added a deterministic tool→risk map (`TOOL_RISK`),
+  authoritative for known tools (read-only ⇒ low, shell/destructive ⇒ high).
+- **DECIDE instruction drift & file reads.** The DECIDE prompt now (1) steers
+  disk reads to `safe_file_read` instead of `resource_read` with a `file://`
+  URI, and (2) requires verbatim pass-through of caller-supplied instructions
+  to sub-tools (no paraphrasing / re-scoping).
+
+Existing installs: run `system_upgrade` to pull the `external_tools` SkillSet
+(ships `safe_file_read`) into the runtime.
+
 ## [3.41.1] - 2026-07-13
 
 ### Fixed — Meeting Place Caddy healthcheck false-negative (deployment)

data/lib/kairos_mcp/version.rb

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

data/templates/skillsets/agent/test/test_decide_prompt_contract.rb

@@ -53,6 +53,27 @@ module KairosMcp
                        'DECIDE prompt should explain hint is advisory/additive')
         end
 
+        # Read-gap fix: DECIDE must be told to use safe_file_read for disk files and
+        # NOT to use resource_read with a file:// URI (which only accepts in-system URIs).
+        def test_prompt_steers_file_reads_to_safe_file_read
+          prompt = @step.send(:decide_system_prompt)
+          assert_match(/safe_file_read/, prompt,
+                       'DECIDE prompt should point disk reads at safe_file_read')
+          assert_match(/resource_read/, prompt)
+          assert_match(%r{file://}, prompt,
+                       'DECIDE prompt should warn against resource_read with file:// URIs')
+        end
+
+        # Instructions-drift fix: DECIDE must pass verbatim sub-tool instructions through
+        # unchanged rather than paraphrasing / re-scoping the task.
+        def test_prompt_requires_verbatim_instruction_passthrough
+          prompt = @step.send(:decide_system_prompt)
+          assert_match(/UNCHANGED|verbatim/i, prompt,
+                       'DECIDE prompt should require verbatim passthrough of instructions')
+          assert_match(/paraphrase|re-scope|re-target/i, prompt,
+                       'DECIDE prompt should forbid paraphrasing/re-scoping the task')
+        end
+
         # Simulate well-formed LLM output and verify it parses through ReviewHint
         def test_well_formed_llm_output_parses
           llm_output = {

data/templates/skillsets/agent/tools/agent_step.rb

@@ -1784,7 +1784,17 @@ module KairosMcp
             "reason: <string|null>, urgency: \"low\"|\"medium\"|\"high\"|null }. " \
             "Set needed:true to REQUEST multi-LLM review for subtle high-impact " \
             "decisions; set needed:false for routine plans. The hint is advisory " \
-            "and additive — structural rules may still fire review independently."
+            "and additive — structural rules may still fire review independently.\n" \
+            "Tool-use rules:\n" \
+            "  (1) To read a project file from disk, use `safe_file_read` with a " \
+            "workspace-relative `path`. Do NOT use `resource_read` with a `file://` URI " \
+            "or a bare filesystem path — `resource_read` only accepts `l0://`, " \
+            "`knowledge://`, or `context://` URIs and will fail on anything else.\n" \
+            "  (2) When the goal, orientation, or a prior step supplies a verbatim " \
+            "instructions string, term list, or content to hand to a sub-tool (e.g. the " \
+            "`instructions` for `write_section`), copy it through UNCHANGED into that " \
+            "tool's arguments. Do not paraphrase, summarise, re-scope, or re-target the " \
+            "task (e.g. do not invent a new audience or output format the goal did not ask for)."
           end
 
           def reflect_system_prompt

data/templates/skillsets/autonomos/lib/autonomos/mandate.rb

@@ -19,6 +19,29 @@ module Autonomos
 
     RISK_BUDGETS = %w[low medium].freeze
 
+    # Deterministic tool -> risk map. The per-step `risk` in a proposal is assigned by
+    # the DECIDE model and is therefore non-deterministic: identical read-only work was
+    # observed to be labelled `medium` in one run and `low` in another, making the risk
+    # gate fire inconsistently. For KNOWN tools this map is authoritative (it both floors
+    # AND caps the model's label), so read-only/drafting tools are always `low` and
+    # destructive/shell tools are always `high` regardless of how the model labelled them.
+    # Unknown tools fall back to the model-assigned risk (then `low`).
+    TOOL_RISK = {
+      # read-only / in-place drafting into working files → low
+      'resource_read' => 'low', 'resource_list' => 'low',
+      'knowledge_get' => 'low', 'knowledge_list' => 'low', 'skills_list' => 'low',
+      'skills_get' => 'low', 'context_save' => 'low', 'document_status' => 'low',
+      'write_section' => 'low', 'llm_call' => 'low', 'safe_file_read' => 'low',
+      'safe_file_list' => 'low', 'chain_status' => 'low', 'chain_verify' => 'low',
+      # durable / L0-L1 / external-effect writes → medium
+      'chain_record' => 'medium', 'safe_file_write' => 'medium', 'safe_file_edit' => 'medium',
+      'safe_file_copy' => 'medium', 'knowledge_update' => 'medium',
+      'instructions_update' => 'medium', 'skills_promote' => 'medium',
+      'safe_http_get' => 'medium', 'safe_http_post' => 'medium', 'safe_git_commit' => 'medium',
+      # destructive / shell / irreversible-external → high
+      'Bash' => 'high', 'safe_file_delete' => 'high', 'safe_git_push' => 'high'
+    }.freeze
+
     class LockError < StandardError; end
 
     class << self
@@ -174,7 +197,7 @@ module Autonomos
 
         steps = proposal[:autoexec_task][:steps] || []
         steps.any? do |step|
-          risk = step[:risk] || 'low'
+          risk = effective_risk(step)
           case risk_budget
           when 'low'
             %w[medium high].include?(risk)
@@ -186,6 +209,14 @@ module Autonomos
         end
       end
 
+      # Resolve a step's risk deterministically: the tool map wins for known tools
+      # (both raising and lowering the model's label), otherwise the model-assigned
+      # risk is used, defaulting to 'low'.
+      def effective_risk(step)
+        tool = step[:tool_name] || step['tool_name']
+        TOOL_RISK[tool] || step[:risk] || 'low'
+      end
+
       def list_active
         mandates_dir = Autonomos.storage_path('mandates')
         files = Dir.glob(File.join(mandates_dir, '*.json'))

data/templates/skillsets/autonomos/test/test_autonomos.rb

@@ -469,6 +469,37 @@ class TestAutonomosMandate < Minitest::Test
     assert_equal 0, mandate[:cycles_completed]
   end
 
+  # ---- deterministic tool -> risk map (risk_exceeds_budget?) ----
+
+  def test_risk_map_read_only_tools_forced_low
+    # model over-labelled read-only tools; the map must force them to low
+    proposal = { autoexec_task: { steps: [
+      { tool_name: 'write_section', risk: 'medium' },
+      { tool_name: 'resource_read', risk: 'high' }
+    ] } }
+    refute Autonomos::Mandate.risk_exceeds_budget?(proposal, 'low')
+  end
+
+  def test_risk_map_shell_forced_high_regardless_of_label
+    # model under-labelled Bash as low; the map must force it high
+    proposal = { autoexec_task: { steps: [{ tool_name: 'Bash', risk: 'low' }] } }
+    assert Autonomos::Mandate.risk_exceeds_budget?(proposal, 'low')
+    assert Autonomos::Mandate.risk_exceeds_budget?(proposal, 'medium')
+  end
+
+  def test_risk_map_durable_write_is_medium
+    # chain_record is medium in the map even if the model labelled it low
+    proposal = { autoexec_task: { steps: [{ tool_name: 'chain_record', risk: 'low' }] } }
+    assert Autonomos::Mandate.risk_exceeds_budget?(proposal, 'low')
+    refute Autonomos::Mandate.risk_exceeds_budget?(proposal, 'medium')
+  end
+
+  def test_risk_unknown_tool_falls_back_to_model_label
+    proposal = { autoexec_task: { steps: [{ tool_name: 'some_new_tool', risk: 'medium' }] } }
+    assert Autonomos::Mandate.risk_exceeds_budget?(proposal, 'low')
+    refute Autonomos::Mandate.risk_exceeds_budget?(proposal, 'medium')
+  end
+
   def test_load_mandate
     mandate = Autonomos::Mandate.create(
       goal_name: 'load_test',

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

@@ -17,56 +17,59 @@ module KairosMcp
         def write(section_name:, instructions:, context_text:, output_file:,
                   max_words: 500, language: 'en', append_mode: false,
                   invocation_context: nil)
-          messages = [{
-            'role' => 'user',
-            'content' => build_user_prompt(section_name, instructions, context_text, max_words, language)
-          }]
+          # Provider-independent completeness: some LLM providers (e.g. the claude_code
+          # CLI subprocess) have no output-length control, so a single pass over a long
+          # reference context stops early and drops the tail. Split the context at
+          # 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
 
-          llm_args = {
-            'messages' => messages,
-            'system' => system_prompt
-          }
-
-          # Forward InvocationContext via dispatch-level context: keyword only
-          # (not duplicated in arguments — llm_call uses dispatch context)
-          result = @caller.invoke_tool('llm_call', llm_args, context: invocation_context)
+          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
 
-          # Parse pinned response contract:
-          # { "status": "ok", "response": { "content": "..." }, "snapshot": {...} }
-          # { "status": "error", "error": { "type": "...", "message": "..." } }
-          raw = result.map { |b| b[:text] || b['text'] }.compact.join
-          parsed = JSON.parse(raw)
+            # 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 && !first
+                "#{instructions}\n\n#{continuation_note(language)}"
+              else
+                instructions
+              end
 
-          if parsed['status'] == 'error'
-            error = parsed['error'] || {}
-            error_msg = if error.is_a?(Hash)
-                          "#{error['type']}: #{error['message']}"
-                        else
-                          error.to_s
-                        end
-            return { 'error' => "LLM call failed: #{error_msg}" }
-          end
+            gen = generate_one(section_name, chunk_instructions, chunk, max_words, language, invocation_context)
+            return gen if gen['error']
 
-          generated_text = parsed.dig('response', 'content')
-          if generated_text.nil? || generated_text.strip.empty?
-            return { 'error' => 'LLM returned empty content' }
-          end
-
-          # Write to file
-          if append_mode
-            File.open(output_file, 'a') { |f| f.write("\n\n#{generated_text}") }
-          else
-            File.write(output_file, generated_text)
+            # First chunk honours the caller's append_mode; later chunks always append
+            # so the section is assembled in order.
+            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
 
           {
             'status' => 'ok',
             'section_name' => section_name,
             'output_file' => output_file,
-            'word_count' => generated_text.split.size
+            # `word_count` (whitespace split) is meaningless for space-less scripts (JA/ZH/KO)
+            # and misled progress judgement. Report a language-aware unit count plus a raw
+            # non-whitespace char count so callers never size output from a bogus metric.
+            'word_count' => total_units,
+            'char_count' => total_chars,
+            'chunks' => chunks_written
           }
-        rescue JSON::ParserError => e
-          { 'error' => "Failed to parse LLM response: #{e.message}" }
         end
 
         private
@@ -74,20 +77,139 @@ module KairosMcp
         def system_prompt
           "You are a professional document writer. Write the requested section " \
             "following the instructions precisely. Use the provided context for accuracy. " \
-            "Output ONLY the section content. You may use markdown formatting within the section."
+            "Output ONLY the section content. You may use markdown formatting within the section. " \
+            "When the instructions ask you to revise, translate, or rewrite the reference " \
+            "context, reproduce EVERY paragraph of that context — never summarise, merge, " \
+            "shorten, or omit a paragraph, and do not truncate. Preserve heading, list, and " \
+            "block-quote structure exactly."
         end
 
         def build_user_prompt(section_name, instructions, context_text, max_words, language)
           parts = [
             "## Section: #{section_name}",
             "## Instructions\n#{instructions}",
-            "## Word limit: approximately #{max_words} words",
+            # `max_words` is a soft target only; the hard cap is enforced via max_tokens.
+            # Fidelity to the reference context takes precedence over any word target.
+            "## Length: aim for about #{max_words} words, but completeness wins — " \
+              "reproduce all reference paragraphs even if that exceeds the target.",
             "## Language: #{language}"
           ]
           parts << "## Reference Context\n#{context_text}" if context_text && !context_text.empty?
           parts << "\nWrite the section now."
           parts.join("\n\n")
         end
+
+        # Derive a hard output token budget so faithful, full-length rewrites are not
+        # truncated. Sized from the reference context (rewrite output ≈ input length),
+        # clamped between a floor and a ceiling; the adapter clamps further to the
+        # model's own limit. Overridable via config for non-default models.
+        def resolve_max_tokens(max_words, context_text)
+          floor   = (@config['section_max_tokens_floor'] || 4096).to_i
+          ceiling = (@config['section_max_tokens_ceiling'] || 8192).to_i
+          # ~1 token/char is a safe-high estimate for CJK; +20% margin for markup/expansion.
+          est_context = context_text ? (context_text.length * 1.2).ceil : 0
+          est_words   = max_words.to_i * 3 # generous; CJK "words" undercount severely
+          [[est_context, est_words, floor].max, ceiling].min
+        end
+
+        # Language-aware unit count. Space-less scripts count non-whitespace characters;
+        # others fall back to whitespace-delimited words.
+        def count_units(text, language)
+          if %w[ja zh ko].include?(language.to_s)
+            text.gsub(/\s+/, '').length
+          else
+            text.split.size
+          end
+        end
+
+        # Single LLM pass over one chunk. Returns { 'content' => text } or { 'error' => msg }.
+        def generate_one(section_name, instructions, context_text, max_words, language, invocation_context)
+          messages = [{
+            'role' => 'user',
+            'content' => build_user_prompt(section_name, instructions, context_text, max_words, language)
+          }]
+          llm_args = {
+            'messages' => messages,
+            'system' => system_prompt,
+            'max_tokens' => resolve_max_tokens(max_words, context_text)
+          }
+          # Forward InvocationContext via dispatch-level context: keyword only.
+          result = @caller.invoke_tool('llm_call', llm_args, context: invocation_context)
+
+          raw = result.map { |b| b[:text] || b['text'] }.compact.join
+          parsed = JSON.parse(raw)
+          if parsed['status'] == 'error'
+            error = parsed['error'] || {}
+            error_msg = error.is_a?(Hash) ? "#{error['type']}: #{error['message']}" : error.to_s
+            return { 'error' => "LLM call failed: #{error_msg}" }
+          end
+
+          generated_text = parsed.dig('response', 'content')
+          if generated_text.nil? || generated_text.strip.empty?
+            return { 'error' => 'LLM returned empty content' }
+          end
+          { 'content' => generated_text }
+        rescue JSON::ParserError => e
+          { 'error' => "Failed to parse LLM response: #{e.message}" }
+        end
+
+        # Group the reference context into chunks no larger than `target` characters,
+        # splitting ONLY at blank-line paragraph boundaries (never mid-paragraph). A short
+        # or empty context returns a single element so behaviour is unchanged. A single
+        # paragraph larger than `target` stays whole (correctness over chunk size).
+        def split_context(text, target)
+          return [text] if text.nil? || text.strip.empty? || text.length <= target
+
+          chunks = []
+          current = +''
+          text.split(/\n{2,}/).each do |para|
+            if !current.empty? && (current.length + para.length + 2) > target
+              chunks << current
+              current = +''
+            end
+            current << "\n\n" unless current.empty?
+            current << para
+          end
+          chunks << current unless current.empty?
+          chunks
+        end
+
+        # Auto-chunk threshold. Sized so each pass is small enough that output-uncapped
+        # providers (e.g. claude_code CLI) emit a full section without stopping early —
+        # empirically a larger single pass truncates, while ~3000-char passes complete.
+        # 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
+
+        # 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
+        # section heading and continues the body under the same directives.
+        def continuation_note(language)
+          if %w[ja zh ko].include?(language.to_s)
+            'これは直前のチャンクの続きである。見出し（## …）を繰り返さず、' \
+              '本文の続きの段落だけを、同じ方針で自然化して書け。'
+          else
+            'This is a continuation of the previous chunk. Do NOT repeat the section ' \
+              'heading; continue with the next body paragraphs under the same instructions.'
+          end
+        end
+
+        def write_chunk(output_file, text, append)
+          if append
+            File.open(output_file, 'a') { |f| f.write("\n\n#{text}") }
+          else
+            File.write(output_file, text)
+          end
+        end
       end
     end
   end

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

@@ -392,6 +392,129 @@ assert("T18: parses llm_call error response correctly") do
     !File.exist?(File.join(TMPDIR, 'should_not_exist.md'))
 end
 
+assert("T18b: sizes max_tokens from context so long sections are not truncated") do
+  caller = MockCallerTool.new
+  captured = {}
+  caller.define_singleton_method(:invoke_tool) do |tool_name, arguments = {}, context: nil|
+    captured[tool_name] = arguments
+    [{ text: JSON.generate({ 'status' => 'ok', 'response' => { 'content' => 'x' }, 'snapshot' => {} }) }]
+  end
+  writer = SW.new(caller, {})
+  long_ctx = 'あ' * 6000
+  writer.write(section_name: 's', instructions: 'rewrite faithfully', context_text: long_ctx,
+               output_file: File.join(TMPDIR, 'mt.md'), max_words: 500, language: 'ja')
+  mt = captured['llm_call'] && captured['llm_call']['max_tokens']
+  # 6000 chars * 1.2 = 7200, clamped to the 8192 ceiling — well above the 4096 default
+  !mt.nil? && mt > 4096 && mt <= 8192
+end
+
+assert("T18c: word_count/char_count count characters for space-less scripts (JA)") do
+  caller = MockCallerTool.new
+  caller.invoke_results['llm_call'] = [{
+    text: JSON.generate({ 'status' => 'ok', 'response' => { 'content' => 'あいう えお' }, 'snapshot' => {} })
+  }]
+  writer = SW.new(caller, {})
+  r = writer.write(section_name: 's', instructions: 'i', context_text: '',
+                   output_file: File.join(TMPDIR, 'cu.md'), max_words: 100, language: 'ja')
+  r['word_count'] == 5 && r['char_count'] == 5
+end
+
+assert("T18e: long multi-paragraph context is auto-chunked into multiple passes and concatenated") 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' => "chunk#{calls}" }, 'snapshot' => {} }) }]
+  end
+  writer = SW.new(caller, { 'section_chunk_target_chars' => 100 })
+  ctx = (1..5).map { ('あ' * 80) }.join("\n\n") # 5 paragraphs, each > half the target
+  out = File.join(TMPDIR, 'chunked.md')
+  r = writer.write(section_name: 's', instructions: 'i', context_text: ctx,
+                   output_file: out, max_words: 100, language: 'ja', append_mode: false)
+  content = File.read(out)
+  r['status'] == 'ok' && r['chunks'] > 1 && calls > 1 &&
+    content.start_with?('chunk1') && content.include?("chunk#{calls}") &&
+    content.include?("chunk1\n\nchunk2")
+end
+
+assert("T18f: short context stays a single pass (no chunking)") 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' => 'once' }, 'snapshot' => {} }) }]
+  end
+  writer = SW.new(caller, { 'section_chunk_target_chars' => 100000 })
+  r = writer.write(section_name: 's', instructions: 'i', context_text: 'あ' * 500,
+                   output_file: File.join(TMPDIR, 'single.md'), max_words: 100, language: 'ja')
+  r['chunks'] == 1 && calls == 1
+end
+
+assert("T18g: append_mode applies only to the first chunk; later chunks append") 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' => "c#{calls}" }, 'snapshot' => {} }) }]
+  end
+  out = File.join(TMPDIR, 'append_first.md')
+  File.write(out, 'PRE')
+  writer = SW.new(caller, { 'section_chunk_target_chars' => 100 })
+  ctx = (1..3).map { ('あ' * 80) }.join("\n\n")
+  writer.write(section_name: 's', instructions: 'i', context_text: ctx,
+               output_file: out, max_words: 100, language: 'ja', append_mode: true)
+  # existing PRE preserved, first chunk appended (not overwriting), all chunks present in order
+  content = File.read(out)
+  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 = {}
+  caller.define_singleton_method(:invoke_tool) do |tool_name, arguments = {}, context: nil|
+    captured[tool_name] = arguments
+    [{ text: JSON.generate({ 'status' => 'ok', 'response' => { 'content' => 'x' }, 'snapshot' => {} }) }]
+  end
+  writer = SW.new(caller, { 'section_max_tokens_ceiling' => 5000 })
+  writer.write(section_name: 's', instructions: 'rewrite', context_text: 'あ' * 9000,
+               output_file: File.join(TMPDIR, 'mt2.md'), max_words: 500, language: 'ja')
+  captured['llm_call']['max_tokens'] == 5000
+end
+
 assert("T19: handles empty LLM content") do
   caller = MockCallerTool.new
   caller.invoke_results['llm_call'] = [{

data/templates/skillsets/document_authoring/tools/write_section.rb

@@ -120,11 +120,16 @@ module KairosMcp
               end
             end
 
-            # Assemble context
+            # Assemble context.
+            # Naturalisation/translation/rewrite tasks need the WHOLE source; SectionWriter
+            # chunks long context internally (per-chunk generation), so the assembler must
+            # NOT pre-truncate the source — a low per-source cap here silently dropped the
+            # tail of long sections before generation. Keep a high (still finite) bound and
+            # allow config override for constrained setups.
             assembler = ContextAssembler.new(
               self,
-              max_chars_per_source: config['max_context_chars'] || 4000,
-              max_total_chars: config['max_total_context_chars'] || 16_000,
+              max_chars_per_source: config['max_context_chars'] || 500_000,
+              max_total_chars: config['max_total_context_chars'] || 1_000_000,
               max_sources: config['max_context_sources'] || 10
             )
             ctx_result = assembler.assemble(context_sources, context: inv_ctx)

metadata

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