kairos-chain 3.96.0 → 3.96.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9378e59ddbeb6127f907b009d5c74f362932d3ded7669e75975d9e4e000285b
-  data.tar.gz: f5153b3a2034f5ad9f68d1ee5d31f4a7295e8b4e1cdf48cf90283744886d0355
+  metadata.gz: faa4327412fbbe72c412e3e4cccd41173a346e488366b0d4963023cb389ce97e
+  data.tar.gz: 13767304ee185463ac1a1de1293873762c3658f81e8a5c6d007023ca29970377
 SHA512:
-  metadata.gz: 2a9ca012c529a7523e68bb0dde4fd08b20bda1e08a540d98714ae169efc1268946faeb6d16ad1a0926382a480177c60c736a383f8747b2dbcf0225bac5ad522a
-  data.tar.gz: 9e39c4801fef0169431db7c23e6f1e45099b11b0a482b12254fef0a90cf7de7787f6d3b6414824fddb86c0f04c246a2b488cda4741e450366841ee7d2f706b52
+  metadata.gz: 657b3094d640bd4876964d3ffd88f47fd57fda12147c77d882293c68662d66a791c306d8eaae4fd4238041f641c318dc7825bb0ff6c314b2c963086146a7eb17
+  data.tar.gz: 2f765af6b6122a2a3627678f3481a410be0bc0f359bb7b479a6e726fe6f1891264c023d42007840d1fd75e03d175109b78a164647d6402f771322fff8a3783d6

data/CHANGELOG.md

@@ -6,6 +6,43 @@ This project follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [3.96.1] - 2026-10-22
+
+### Fixed — agent runs convene the persona seat their reviews declared none for (agent 1.0.2)
+
+A run review dispatched multi_llm_review with `persona_count_declared: 0` and collected with no persona reviews,
+so every round counted four seats where the operator's roster has five, and the report said so in one line.
+
+- Each review round declares three personas (design: architect, security, operability; implementation:
+  correctness, performance, api-design; document: ontologist, skeptic, integration) and stores their prompts —
+  multi_llm_review's own canonical prompt for the same bundle, under a persona header — in run storage.
+- The actor launches each seat with a one-line marker that the PreToolUse hook replaces with the seat's prompt.
+  From then on the subagent is a seat for its whole life, recognised by the host's meta file naming that launch;
+  it may read only its prompt file and hand back. Messages and stops aimed at a seat are refused.
+- Each seat is settled at its SubagentStop from the hand-back the hooks kept, before the hazard and question
+  readers; agent_advance settles launches the host never started or never stopped. A seat whose transcript
+  shows another prompt is not submitted.
+- agent_advance waits about 540 s per call for running seats, submits each settled reply with the verdict and
+  findings multi_llm_review's own parser reads from it, one per line the seat wrote, so a finding's severity
+  and consequence come from the same line, and gives the stand-in each persona's own reply. A finding whose
+  consequence clause (or location) lies past the point where multi_llm_review cuts a persona finding is
+  rebuilt with the clause and its location after a shortened body, so the cut does not record a P0 as one
+  that stated no consequence. A seat never launched holds the round only until the first reminder; missing
+  seats become a shortfall named in the report, and seats launched late or never are named on the review's
+  closure item. Until the round collects or its token expires the Stop hook sends the actor back to
+  agent_advance (three times without an advance between, and once more after a turn in which a seat started or
+  ended, then the run rests), so the round collects before its token expires. From ten minutes before the
+  token's end no seat is launched or asked for. Collect closes the round's seats under the lock that admits
+  launches and settles its remaining launches, so no launch outlives the round and the seat refusals end with
+  it; agent_stop closes the seats of a round that never collected. A close that fails because the seat lock
+  cannot be taken is journaled as such (`seats_close_failed`) and the settled replies are still submitted. A settled seat may be stopped; it is
+  never messaged.
+- The seats run on the session's own plan; no policy spend counter counts them.
+- `depends_on` pins multi_llm_review >= 0.12.0. L1 multi_llm_review_workflow 3.17.1.
+- Design: `log/agent_persona_seats_design_v0.3_20261022.md` (two design review rounds, four implementation
+  review rounds and one falsification check; the P1s of each fixed). Probed live on one host: three seats
+  launched through the rewrite, all three submitted, five seats counted.
+
 ## [3.96.0] - 2026-10-21
 
 ### Changed — multi_llm_review says what the roster was when a result is read (multi_llm_review 0.12.0, llm_client 0.4.0)

data/lib/kairos_mcp/version.rb

@@ -1,4 +1,4 @@
 module KairosMcp
-  VERSION = "3.96.0"
+  VERSION = "3.96.1"
   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.17.0"
+version: "3.17.1"
 tags:
   - workflow
   - review
@@ -896,9 +896,11 @@ A counted seat's maker is observed (the seat reported its model), configured (th
 roster pins the model and the seat ran on its own provider — this holds while the
 CLI's own configuration does not route that name to another maker), or
 caller-declared (a persona seat that was not observed). Only the first two
-establish diversity. Two kinds of round always carry the line: an `exclude` round
-whose caller names a slot (that slot does not count), and an agent SkillSet round
-(it submits no personas). None of this changes the verdict or the quorum
+establish diversity. One kind of round always carries the line: an `exclude` round
+whose caller names a slot (that slot does not count). An agent SkillSet round no
+longer always carries it: agent 1.0.2 convenes three personas on the host and
+submits the replies the host handed back, where 1.0.1 submitted none, so its line
+follows the same rule as any other round. None of this changes the verdict or the quorum
 (`min_quorum`, 2 shipped). An INSUFFICIENT result also says how many seats counted
 and how many were needed, that a seat can be added in config, and the restoring
 action for each reason in the table above.
@@ -2117,6 +2119,13 @@ Compression ratio: parallel agent raw → Assembly ≈ 2:1
   multi_llm_review 0.12.0 and llm_client 0.4.0. Design
   `log/mlr_non_claude_host_design_v0.3.3_20261021.md`, frozen after four rounds.
 
+- Agent runs convene persona seats (v3.17.1, 2026-10-22, operator request:
+  「Agent SkillSet1.0.1でreview時にpersona数が0に決め打ちされてるそうですが、MLRの設定と異なるので
+  修正して下さい」). § Reduced rosters no longer says an agent SkillSet round always
+  carries the roster line: agent 1.0.2 declares and convenes three personas, launched
+  by the run's actor through a marker the SkillSet's hook rewrites, and submits the
+  replies the host handed back. Design `log/agent_persona_seats_design_v0.3_20261022.md`.
+
 **Key insight**: Design reviews and implementation reviews find
 **categorically different bugs**. Both phases are necessary. The corollary that
 cost eight rounds to learn: **which of the two you are in is readable from the

data/templates/skillsets/agent/lib/agent/hooks.rb

@@ -10,6 +10,7 @@ require_relative 'stand_in'
 require_relative 'precedents'
 require_relative 'policies'
 require_relative 'transcript'
+require_relative 'seats'
 
 module KairosMcp
   module SkillSets
@@ -32,6 +33,13 @@ module KairosMcp
               "(#{run.target_repo}) as a new file — each version is a new file. Then call " \
               "agent_advance(run_id: '#{id}', phase: '#{phase.name}')."
           when :review
+            seats = Seats.instruction(run, phase.name.to_s)
+            return seats if seats
+            if run.in_flight_review
+              return "Phase #{phase.name}: a review round is running. Call agent_advance(run_id: '#{id}', " \
+                     "phase: '#{phase.name}') to collect it."
+            end
+
             answer = plan.phase(phase.args[:of])&.kind == :produce ? 'writing the next version as a new file' : 'new commits on the run branch'
             "Phase #{phase.name}: call agent_advance(run_id: '#{id}', phase: '#{phase.name}'). It dispatches the next " \
               "review round of the latest #{phase.args[:of]} artifact and, on the next call, returns the seats' findings " \
@@ -136,6 +144,11 @@ module KairosMcp
           sid = input['session_id']
           touch_guard_seen(sid)
           tool = input['tool_name'].to_s
+          # A review seat's own calls are placed before anything else, the
+          # agent-tool shortcut included (design v0.3 §3.5).
+          if input['agent_id'] && (out = seat_tool_gate(input, tool))
+            return out
+          end
           if Hooks.agent_tool?(tool)
             # The operator's words after an ending release the guard before the
             # agent tool runs (agent_start right after them is not refused).
@@ -150,6 +163,9 @@ module KairosMcp
           return nil unless run
           return nil if release_if_typed(run, sid)
 
+          seat = seat_launch_gate(run, input, tool)
+          return seat if seat
+
           policy = policy_for(run)
           unless policy
             return deny("the policy pinned by run #{run.id} changed or is missing; the guard cannot decide. " \
@@ -379,6 +395,9 @@ module KairosMcp
         def stop(input, subagent:)
           run = Run.bound_to(@paths, input['session_id'])
           return nil unless run
+          # A review seat's end settles it, before any other Stop-hook path:
+          # its reply is a review, not a hazard report or a question.
+          return nil if subagent && seat_stop(run, input) == :seat
           return nil if release_if_typed(run, input['session_id'])
           return nil if run.status == 'finished'
 
@@ -401,7 +420,10 @@ module KairosMcp
             end
             return out if out
           end
-          return nil if !subagent && Array(input['background_tasks']).any?
+          # Background tasks let the actor rest, except while persona seats of
+          # a dispatch are out: then the round must reach agent_advance before
+          # its token expires.
+          return nil if !subagent && Array(input['background_tasks']).any? && !Seats.holding_dispatch(run.journal.entries)
           if live && QUESTION_END.match?(tail.strip)
             answer = prose_question(run, policy, tail)
             return block("Stand-in answer (provisional, journaled): #{answer}. Continue the run.") if answer
@@ -430,11 +452,28 @@ module KairosMcp
           progressed = run.last_block_seq.nil? || run.last_progress_seq.to_i > run.last_block_seq.to_i ||
                        (last_block && last_block['fingerprint'] && last_block['fingerprint'] != fingerprint)
           if run.in_flight_review
+            # While persona seats are out, each agent_advance call (which waits
+            # for them) earns one more block, until the round collects.
+            entries = run.journal.entries
+            if Seats.holding_dispatch(entries)
+              # Blocked every time until the round collects, so the call that
+              # collects comes before the token expires; three blocks with no
+              # agent_advance between them is an actor not following, and the
+              # run rests rather than spin. Only what an agent_advance call
+              # journals counts as one between them: a seat launching or
+              # settling is not the actor calling it.
+              last_wait = entries.reverse.find { |e| %w[seats_prompted seats_waited review_dispatched].include?(e['kind']) }
+              since = entries.count { |e| e['kind'] == 'stop_blocked' && e['for'] == 'persona_seats' && e['seq'] > last_wait.to_h['seq'].to_i }
+              if since < Seats::HOLD_BLOCKS
+                run.append(:stop_blocked, for: 'persona_seats', fingerprint: fingerprint)
+                return block("Run #{run.id}: #{Guidance.next_step(run)}")
+              end
+            end
             # Once per progress: a round that never comes back rests the run.
-            last = run.journal.entries.reverse.find { |e| e['kind'] == 'stop_blocked' }
-            unless last && last['for'] == 'review_in_flight' && !progressed
+            last = entries.reverse.find { |e| e['kind'] == 'stop_blocked' }
+            unless last && %w[review_in_flight persona_seats].include?(last['for']) && !progressed
               run.append(:stop_blocked, for: 'review_in_flight', fingerprint: fingerprint)
-              return block("Run #{run.id}: a review round is running. Call agent_advance(run_id: '#{run.id}') to collect it.")
+              return block("Run #{run.id}: #{Guidance.next_step(run)}")
             end
           end
           if progressed
@@ -523,6 +562,141 @@ module KairosMcp
           File.exist?(f) && (Time.now - File.mtime(f)) <= within
         end
 
+        # --- persona seats (design log/agent_persona_seats_design_v0.3) ------------
+
+        # A subagent's own tool call while the run has seat launches: a seat
+        # may hand back and read its own prompt file, nothing else, and a
+        # subagent whose launch cannot be read is held to that while a seat is
+        # out. nil when the call is not a seat's.
+        def seat_tool_gate(input, tool)
+          run = Run.bound_to(@paths, input['session_id'])
+          return nil unless run
+
+          entries = run.journal.entries
+          return nil unless Seats.any_launch?(entries)
+
+          kind, launch = Seats.identify(entries, input)
+          return nil if kind == :other
+          return nil if kind == :unknown && Seats.unsettled_launches(entries).empty?
+
+          if tool == Seats::HANDBACK
+            Seats.keep_handback(run, input['agent_id'], input.dig('tool_input', 'message')) if kind == :seat
+            return allow
+          end
+          return allow if kind == :seat && tool == 'Read' && seat_reads_own_prompt?(run, launch, input['tool_input'], input['cwd'] || Dir.pwd)
+
+          if kind == :seat
+            deny("A review seat reads only its prompt file and answers with its hand-back; #{tool} is refused to it " \
+                 '(INV-2). Answer from the prompt.')
+          else
+            deny('The run cannot tell whether this subagent is a review seat (its host meta file names no launch) while ' \
+                 "a seat is out, so it is held to a seat's tools (INV-2).")
+          end
+        rescue StandardError, ScriptError => e
+          deny("agent seat gate error (#{e.class}): #{e.message[0, 200]}")
+        end
+
+        def seat_reads_own_prompt?(run, launch, tool_input, cwd = Dir.pwd)
+          given = tool_input.is_a?(Hash) ? tool_input['file_path'].to_s : ''
+          !given.empty? && File.expand_path(given, cwd) == File.expand_path(Seats.prompt_path(run, launch['full_sha256'].to_s))
+        end
+
+        # A launch of a seat by its marker, from any caller, and messages or
+        # stops aimed at a seat. nil when neither applies.
+        def seat_launch_gate(run, input, tool)
+          if Seats::LAUNCH_TOOLS.include?(tool)
+            prompt = input.dig('tool_input', 'prompt').to_s.strip
+            return nil unless prompt.start_with?(Seats::MARKER_PREFIX)
+
+            return Seats.locked(run) { launch_seat(run, input, prompt) }
+          end
+          return nil unless Seats::TARGET_TOOLS.include?(tool)
+
+          entries = run.journal.entries
+          return nil unless Seats.any_launch?(entries)
+
+          ti = input['tool_input'].is_a?(Hash) ? input['tool_input'] : {}
+          targets = Seats::TARGET_KEYS.map { |k| ti[k] }.select { |v| v.is_a?(String) && !v.empty? }
+          out = Seats.unsettled_launches(entries).any?
+          targets.each do |t|
+            kind, launch = Seats.identify(entries, input, t)
+            if kind == :seat
+              # A settled seat's reply is frozen, so stopping it changes no
+              # record; a message still could reach a reply, so it stays refused.
+              next if tool == 'TaskStop' && Seats.settlement_for(entries, launch)
+
+              return deny("#{tool} to a review seat is refused: a seat is neither messaged nor stopped by the run (INV-3).")
+            end
+            if kind == :unknown && out
+              return deny("#{tool} to #{t} is refused while a review seat is out: the run cannot tell whether it is a seat (INV-3).")
+            end
+          end
+          nil
+        end
+
+        # Admits one launch of a seat (under the run's seat lock) and replaces
+        # the marker with the seat's short prompt; every other key the caller
+        # gave is dropped.
+        def launch_seat(run, input, prompt)
+          if input['tool_use_id'].to_s.empty?
+            return deny('A review seat cannot be launched from a call the host gave no tool_use_id: the seat could not be bound to its launch.')
+          end
+
+          entries = run.journal.entries
+          live = Seats.live_markers(run.id, entries)
+          seat = live[prompt]
+          listing = live.empty? ? 'There is no seat to launch now.' : "Live markers:\n#{live.keys.join("\n")}"
+          unless seat
+            spent = Seats.spent_reason(run.id, entries, prompt)
+            return deny("This seat is no longer launched: #{spent}. #{listing}") if spent
+
+            return deny("Not a live review-seat marker. #{listing}")
+          end
+
+          why = Seats.launch_refusal(entries, seat)
+          return deny("Refused: #{why}. #{listing}") if why
+
+          path = Seats.prompt_path(run, seat['sha256'])
+          unless File.file?(path) && Digest::SHA256.file(path).hexdigest == seat['sha256']
+            return deny("The stored prompt of seat #{seat['persona']} no longer matches its dispatch; the seat cannot be launched.")
+          end
+
+          short = Seats.short_prompt(run, seat, Seats.dispatch_for(entries, seat['token']))
+          run.append(:seat_launched, token: seat['token'], persona: seat['persona'], phase: seat['phase'], round: seat['round'],
+                                     tool_use_id: input['tool_use_id'], full_sha256: seat['sha256'],
+                                     prompt_sha256: Digest::SHA256.hexdigest(short), session_id: input['session_id'],
+                                     subagents_dir: Seats.subagents_dir(input))
+          updated = { 'description' => "review seat #{seat['persona']}", 'prompt' => short, 'subagent_type' => 'general-purpose' }
+          effort = input['effort'].is_a?(Hash) ? input['effort']['level'] : input['effort']
+          updated['effort'] = effort if Seats::EFFORTS.include?(effort)
+          allow(updated_input: updated)
+        end
+
+        # Settles a seat at its first stop, and journals a subagent the run
+        # cannot place while a seat is out. :seat when the stop was a seat's.
+        def seat_stop(run, input)
+          entries = run.journal.entries
+          return nil unless Seats.any_launch?(entries)
+
+          kind, launch = Seats.identify(entries, input)
+          if kind == :seat
+            begin
+              reply = Seats.kept_handback(run, input['agent_id']) || input['last_assistant_message']
+              cause = Seats.first_prompt_sha256(Seats.host_files(input)) == launch['prompt_sha256'] ? nil : 'prompt_mismatch'
+              Seats.settle(run, launch, agent_id: input['agent_id'], reply: reply, cause: cause)
+            rescue StandardError, ScriptError => e
+              run.append(:seat_settle_failed, token: launch['token'], persona: launch['persona'], tool_use_id: launch['tool_use_id'],
+                                              reason: "#{e.class}: #{e.message[0, 200]}")
+            end
+            return :seat
+          end
+          if kind == :unknown && Seats.unsettled_launches(entries).any?
+            run.append(:subagent_unidentified, agent_id: input['agent_id'], agent_type: input['agent_type'],
+                                               cause: 'its host meta file names no launch')
+          end
+          nil
+        end
+
         # A session whose run another session took over: its guard refuses
         # what would act, until the operator speaks here again or the session
         # ends, so its turn does not continue unguarded.

data/templates/skillsets/agent/lib/agent/review.rb

@@ -3,6 +3,7 @@
 require 'json'
 require 'digest'
 require 'fileutils'
+require_relative 'seats'
 
 module KairosMcp
   module SkillSets
@@ -43,7 +44,8 @@ module KairosMcp
         # revision_diff: callable(previous review_round entry, this one) -> the
         # actor's change between the two rounds' artifacts, as text.
         def initialize(run:, policy:, stand_in:, invoke:, project_root:, words: -> { [] }, precedents: ->(_t) { [] },
-                       head: nil, type: nil, revision_diff: ->(_a, _b) { '' })
+                       head: nil, type: nil, revision_diff: ->(_a, _b) { '' }, clock: -> { Time.now },
+                       sleep: ->(s) { Kernel.sleep(s) })
           @run = run
           @policy = policy
           @stand_in = stand_in
@@ -54,6 +56,8 @@ module KairosMcp
           @head = head
           @type = type&.to_s
           @revision_diff = revision_diff
+          @clock = clock
+          @sleep = sleep
         end
 
         def credentials?(text)
@@ -124,58 +128,200 @@ module KairosMcp
           end
           clear_blocking(name)
 
-          payload = @invoke.call('multi_llm_review', {
-                                   'artifact_name' => artifact_name, 'review_type' => review_type,
-                                   'artifact_content' => bundle, 'review_round' => round,
-                                   'orchestrator_strategy' => 'delegate', 'orchestrator_model' => 'claude-opus-5-5',
-                                   'persona_count_declared' => 0, 'escalate' => true, 'complexity' => 'high',
-                                   'prior_findings' => carry.map { |f| { 'id' => f['id'], 'severity' => 'P0', 'issue' => f['text'][0, 400] } }
-                                 })
+          prior = carry.map { |f| { 'id' => f['id'], 'severity' => 'P0', 'issue' => f['text'][0, 400] } }
+          seats = compose_seats(name, round, review_type, artifact_name, bundle, prior)
+          request = {
+            'artifact_name' => artifact_name, 'review_type' => review_type,
+            'artifact_content' => bundle, 'review_round' => round,
+            'orchestrator_strategy' => 'delegate', 'orchestrator_model' => 'claude-opus-5-5',
+            'persona_count_declared' => seats.size, 'escalate' => true, 'complexity' => 'high',
+            'prior_findings' => prior
+          }
+          request['collect_deadline_seconds_override'] = Seats::DEADLINE_SECONDS unless seats.empty?
+          payload = @invoke.call('multi_llm_review', request)
           token = payload['collect_token']
           return { 'status' => 'error', 'reason' => payload['error'] || 'no collect token' } unless token
 
-          @run.append(:review_dispatched, { phase: name, round: round, token: token,
-                                            bundle_sha256: Digest::SHA256.hexdigest(bundle), artifact_digest: artifact_digest,
-                                            bundle_file: store_bundle(name, round, bundle) }.merge(extra))
+          entry = { phase: name, round: round, token: token,
+                    bundle_sha256: Digest::SHA256.hexdigest(bundle), artifact_digest: artifact_digest,
+                    bundle_file: store_bundle(name, round, bundle) }.merge(extra)
+          # Persona seats exist in the delegated protocol only; the seats, the
+          # token and its deadline are journaled in the one dispatch entry.
+          if !seats.empty? && payload['status'] == 'delegation_pending'
+            entry[:seats] = seats
+            entry[:must_collect_by] = payload['must_collect_by']
+          end
+          @run.append(:review_dispatched, entry)
           { 'status' => 'dispatched', 'round' => round,
             'next' => "Round #{round} is running (about 5-10 minutes). Call agent_advance again to collect it." }
         end
 
+        # The persona seats' full prompts, stored under their digests; none
+        # (the round runs as 1.0.1 did) when they cannot be composed.
+        def compose_seats(phase, round, review_type, artifact_name, bundle, prior)
+          composed = Seats.compose(review_type: review_type, artifact_name: artifact_name, bundle: bundle, round: round,
+                                   prior: prior, worktree: @run.worktree, branch: @run.branch)
+          Seats.store_prompts(@run, composed)
+        rescue StandardError, ScriptError => e
+          @run.append(:seats_not_composed, phase: phase, round: round, reason: "#{e.class}: #{e.message[0, 300]}")
+          []
+        end
+
         # Collects whatever the round produced, also after a worker crash: a
         # round with quorum is a round.
         def collect(phase, pending)
           name = phase.name.to_s
-          wait = @invoke.call('multi_llm_review_wait', { 'collect_token' => pending['token'], 'max_wait_seconds' => 540 })
+          budget_end = @clock.call + Seats::WAIT_SECONDS
+          with_seats = pending['seats'].is_a?(Array) && !pending['seats'].empty?
+          if with_seats
+            held = seat_gate(pending, budget_end)
+            return held if held
+          end
+          left = (budget_end - @clock.call).to_i.clamp(30, Seats::WAIT_SECONDS)
+          wait = @invoke.call('multi_llm_review_wait', { 'collect_token' => pending['token'], 'max_wait_seconds' => left })
           st = wait['status'].to_s
           if WAITING.include?(st)
+            # Each call that waited earns the Stop hook's next block (§3.7).
+            @run.append(:seats_waited, phase: name, round: pending['round'], token: pending['token'], running: 0) if with_seats
             return { 'status' => 'pending', 'detail' => st, 'next' => 'The round is still running. Call agent_advance again.' }
           end
 
-          result = @invoke.call('multi_llm_review_collect', { 'collect_token' => pending['token'],
-                                                              'orchestrator_reviews' => [], 'include_raw_text' => true })
+          reviews, persona_rows, outcomes = with_seats ? seat_submission(pending) : [[], [], nil]
+          result = collect_call(pending['token'], reviews)
+          if result['status'] == 'error' && !reviews.empty? && result['error'].to_s.start_with?('invalid orchestrator_reviews')
+            # MLR's refusal of a persona submission leaves the token
+            # collectable: the external seats' replies are kept.
+            @run.append(:seat_submission_refused, phase: name, round: pending['round'], token: pending['token'],
+                                                  detail: result['error'].to_s[0, 600])
+            outcomes.each { |o| o.merge!('submitted' => false, 'cause' => 'refused_by_review_tool') if o['submitted'] }
+            result = collect_call(pending['token'], [])
+          end
           if result['status'] != 'ok'
             detail = "#{st}: #{result['error'] || result['status']}"
-            @run.append(:review_dispatch_failed, phase: name, round: pending['round'], detail: detail)
+            @run.append(:review_dispatch_failed, phase: name, round: pending['round'], token: pending['token'], detail: detail)
             return { 'status' => 'dispatch_failed', 'detail' => detail, 'next' => 'Call agent_advance again to dispatch the round anew.' }
           end
           seats = Array(result['reviews']).map do |r|
             { 'seat' => r['role_label'].to_s, 'verdict' => r['verdict'].to_s, 'reply' => (r['raw_text'] || r['raw_text_excerpt']).to_s }
           end
+          # What the stand-in reads: each persona's own reply in place of the
+          # review tool's assembled persona row (INV-3).
+          team = Array(result['reviews']).find { |r| r['synthetic'] || r.key?('persona_rows') }
+          team_label = team ? team['role_label'].to_s : 'claude_team'
+          read = if with_seats
+                   seats.reject { |s| s['seat'] == team_label } +
+                     persona_rows.map { |r| { 'seat' => "#{team_label}/#{r['persona']}", 'verdict' => r['verdict'], 'reply' => r['reply'] } }
+                 else
+                   seats
+                 end
           p0_lines = Array(result['aggregated_findings']).select { |f| f.is_a?(Hash) && f['severity'].to_s.upcase == 'P0' }
                                                          .map { |f| (f['issue'] || f['text']).to_s[0, 600] }
           counted = result.dig('vote_tally', 'successful_count').to_i
           quorum = result.dig('vote_tally', 'min_quorum').to_i.nonzero? || 2
-          file = store_replies(name, pending['round'], seats, p0_lines)
-          @run.append(:review_round, phase: name, round: pending['round'], counted: counted, quorum: quorum,
-                                     wait_status: st, commit: pending['commit'], replies_file: file,
-                                     bundle_sha256: pending['bundle_sha256'], artifact: pending['artifact'],
-                                     bundle_file: pending['bundle_file'], artifact_digest: pending['artifact_digest'],
-                                     seats: seats.map { |s| { 'seat' => s['seat'], 'verdict' => s['verdict'],
-                                                              'reply_sha256' => Digest::SHA256.hexdigest(s['reply']),
-                                                              'reply' => s['reply'][0, 4000] } })
+          file = store_replies(name, pending['round'], read, p0_lines)
+          @run.append(:review_round, { phase: name, round: pending['round'], token: pending['token'], counted: counted,
+                                       quorum: quorum, wait_status: st, commit: pending['commit'], replies_file: file,
+                                       bundle_sha256: pending['bundle_sha256'], artifact: pending['artifact'],
+                                       bundle_file: pending['bundle_file'], artifact_digest: pending['artifact_digest'],
+                                       seats: seats.map { |s| { 'seat' => s['seat'], 'verdict' => s['verdict'],
+                                                                'reply_sha256' => Digest::SHA256.hexdigest(s['reply']),
+                                                                'reply' => s['reply'][0, 4000] } } }
+                                     .merge(with_seats ? { personas: outcomes, persona_count_declared: pending['seats'].size } : {}))
           label_round(phase, @run.journal.entries.reverse.find { |e| e['kind'] == 'review_round' && e['phase'] == name })
         end
 
+        def collect_call(token, reviews)
+          @invoke.call('multi_llm_review_collect', { 'collect_token' => token, 'orchestrator_reviews' => reviews,
+                                                     'include_raw_text' => true })
+        end
+
+        # Holds the round while persona seats are reviewing, within this
+        # call's budget and never past the cutoff. Seats never launched get
+        # the launch instruction once; after that, and at the cutoff, what is
+        # missing becomes a shortfall. Returns a reply, or nil to collect.
+        def seat_gate(pending, budget_end)
+          token = pending['token']
+          loop do
+            at = @clock.call
+            Seats.settle_orphans(@run, at)
+            entries = @run.journal.entries
+            return nil if Seats.closed?(entries, token)
+
+            d = Seats.dispatch_for(entries, token) || pending
+            cutoff = Seats.cutoff_of(d)
+            return nil if cutoff && at >= cutoff
+
+            states = Seats.seat_states(entries, d)
+            launch = Seats.to_launch(states)
+            running = states.select { |s| s['state'] == 'running' }
+            prompted = entries.any? { |e| e['kind'] == 'seats_prompted' && e['token'] == token }
+            if !launch.empty? && !prompted
+              @run.append(:seats_prompted, phase: d['phase'], round: d['round'], token: token,
+                                           personas: launch.map { |s| s['persona'] })
+              return { 'status' => 'pending', 'detail' => 'persona seats to launch',
+                       'markers' => launch.map { |s| Seats.marker(@run.id, token, s['persona']) } }
+            end
+            return nil if running.empty?
+
+            if at >= budget_end
+              @run.append(:seats_waited, phase: d['phase'], round: d['round'], token: token, running: running.size)
+              return { 'status' => 'pending', 'detail' => 'persona seats reviewing', 'running' => running.map { |s| s['persona'] } }
+            end
+            @sleep.call([Seats::POLL_SECONDS, budget_end - at, cutoff ? cutoff - at : Seats::POLL_SECONDS].min.clamp(0.05, Seats::POLL_SECONDS))
+          end
+        end
+
+        # The seats' replies as settled: submitted to the review tool when a
+        # verdict reads from them, given to the stand-in either way, never
+        # inferred or transcribed.
+        def seat_submission(pending)
+          close_seats(pending)
+          entries = @run.journal.entries
+          d = Seats.dispatch_for(entries, pending['token']) || pending
+          reviews = []
+          rows = []
+          outcomes = Seats.seat_states(entries, d).map do |s|
+            o = { 'persona' => s['persona'], 'launches' => s['launches'], 'late' => s['late'] }
+            a = s['answer']
+            unless a
+              cause = case s['state']
+                      when 'not_launched' then 'not_launched'
+                      when 'running' then 'not_settled'
+                      else s['last_cause'] || 'no_reply'
+                      end
+              next o.merge('submitted' => false, 'cause' => cause)
+            end
+            text = Seats.settled_reply(a)
+            next o.merge('submitted' => false, 'cause' => 'reply_changed') unless text
+
+            v = Seats.verdict(text)
+            rows << { 'persona' => s['persona'], 'verdict' => v.to_s, 'reply' => text }
+            next o.merge('submitted' => false, 'cause' => 'no_verdict', 'agent_id' => a['agent_id']) unless v
+
+            reviews << { 'persona' => s['persona'], 'verdict' => v, 'findings' => Seats.findings(text, v),
+                         'reasoning' => text, 'agent_id' => a['agent_id'] }.compact
+            o.merge('submitted' => true, 'verdict' => v, 'agent_id' => a['agent_id'])
+          end
+          [reviews, rows, outcomes]
+        rescue StandardError, ScriptError => e
+          # The review tool's parsers are its internals: if they cannot be
+          # used, the round is collected without personas, and says why.
+          @run.append(:seat_submission_failed, phase: pending['phase'], round: pending['round'], token: pending['token'],
+                                               reason: "#{e.class}: #{e.message[0, 300]}")
+          [[], [], Array(pending['seats']).map { |x| { 'persona' => x['persona'], 'submitted' => false, 'cause' => 'parse_failed' } }]
+        end
+
+        # Closes the round's seats. A close that fails (the seat lock cannot be
+        # taken) is journaled as itself and the replies already settled are
+        # still submitted; launches left unsettled count as not_settled. A
+        # journal that cannot be written fails the round whatever this does.
+        def close_seats(pending)
+          Seats.settle_remaining(@run, pending['token'])
+        rescue StandardError => e
+          @run.append(:seats_close_failed, phase: pending['phase'], round: pending['round'], token: pending['token'],
+                                           reason: "#{e.class}: #{e.message[0, 300]}")
+        end
+
         # Labels a collected round. A failed labelling keeps the round: the
         # next advance labels it again without paying for another dispatch.
         def label_round(phase, entry)
@@ -234,12 +380,12 @@ module KairosMcp
           if quorate && open.empty?
             @run.append(:phase_ended, phase: name, by: 'closure', provisional: true, round: round)
             item = @run.open_item('closure', "#{name} closed provisionally at round #{round}; the operator confirms it, or sends " \
-                                             'it back (decision send_back)', ref: name)
+                                             "it back (decision send_back)#{seats_note(entry)}", ref: name)
             return { 'status' => 'closed_provisionally', 'round' => round, 'labels' => labels, 'item' => item['id'] }
           end
           if quorate && bound && round >= bound
             return refuse_with_item(name, 'review_open', "#{name} is open (#{open.size} P0) and has had its #{bound} rounds; it " \
-                                                         'waits for the operator (decision more_rounds, or freeze)',
+                                                         "waits for the operator (decision more_rounds, or freeze)#{seats_note(entry)}",
                                     "#{name} is at its round cap; it waits for the operator", status: 'waiting',
                                                                                               extra: { 'labels' => labels },
                                                                                               any_of_kind: true)
@@ -272,6 +418,20 @@ module KairosMcp
           steps.join(' ')
         end
 
+        # Persona seats the round went without because of how they were
+        # launched — never, or only after another seat had answered — named
+        # where the operator rules on the round (design v0.3 §3.8).
+        def seats_note(entry)
+          missed = Array(entry['personas']).select { |o| o['cause'] == 'not_launched' || o['late'] }
+          return '' if missed.empty?
+
+          '. Persona seats launched late or never in this round: ' +
+            missed.map do |o|
+              how = o['cause'] == 'not_launched' ? 'never launched' : 'first launched after another seat had answered'
+              "#{o['persona']} (#{how}#{o['submitted'] ? ', then submitted' : (o['cause'] == 'not_launched' ? '' : ", then #{o['cause']}")})"
+            end.join(', ')
+        end
+
         def tally_of(labels)
           n = ->(label, rev = nil) { labels.count { |l| l['label'] == label && (rev.nil? || (l['from_revision'] == true) == rev) } }
           { 'carried_open' => n.call('carried_over'), 'fixed' => n.call('fixed'), 'refuted' => n.call('refuted'),

data/templates/skillsets/agent/lib/agent/run.rb

@@ -396,7 +396,7 @@ module KairosMcp
         # passed to the operator is not progress: a turn made only of those
         # rests instead of being pushed on.
         PROGRESS = %w[item_resolved created pinned check review_dispatched review_round review_labelled phase_ended
-                      report_built plan_ratified].freeze
+                      report_built plan_ratified seat_launched seat_settled].freeze
 
         FILE_TOOLS = %w[Edit Write MultiEdit NotebookEdit].freeze