kairos-chain 3.62.0 → 3.63.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d07ef9eddf8433aed348e6ff25d910547da041e89abdf94dc6e5008f2148f417
-  data.tar.gz: bddb2825ffb56e57681be7a1c368e683103133dad90888dff052a8fc5c430ae8
+  metadata.gz: 96a6f46091b47614f44d089e6459dde7e8435cf7caa893c9b335b7359ad25394
+  data.tar.gz: 965451d952fb8fa61d3bfcc581241242de0f25eb492dddc56ebe913e4d07683b
 SHA512:
-  metadata.gz: f432b43e89098c0d794b8e96d8241009802a6ca41e71804ab77f0ad73abaac07aa0b413889f5d84f0425e22bfddcc6f9fa9a3cbc968196bd6ddbda843e89d1f1
-  data.tar.gz: ff82bd049b30fd06ba14d529ff3910ca9d540c071f441519c23f0189619b90a1b1bfa072449713ba8b53bd575cd5dde763eed6022d141465849f8b6769e5e862
+  metadata.gz: 1c3812249637a923526a17b29cbbf34549f3f3039f51ae37941fa990ceec99611d68e88de280b39ff673aaf5f64e55be3133b079578b9f2887df8a6a6c81f102
+  data.tar.gz: a3688710826e2de6bd2d05ee24b0f9c6194e32e6d9dd8587c776b5e3bfa1b614549af903eee8a9bac295b5e0efc36c5e50537d5a54b8352acd40e05f2ef291c1

data/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.63.0] - 2026-08-06
+
+### Changed
+
+- **`multi_llm_review` findings gain a weight axis, and a worker death no
+  longer discards completed seats** (SkillSet 0.9.1 → 0.10.0, frozen after one
+  review round; every deployment-grounded finding fixed in-round).
+
+  The severity of a finding said what kind of defect it was, never what it
+  costs: measured on a three-persona panel, 3 of one round's 7 P0s were
+  factually correct findings that cost nobody anything, landing at the same
+  severity as a defect that silently corrupts published output. The reviewer
+  prompt contract now requires a `[consequence: who is harmed, and how]`
+  clause on every P0, and aggregation records an unclaused P0 at P2 with the
+  stated severity and the demotion reason kept beside it. Only presence is
+  checked, mechanically; whether a stated consequence is real or trivial
+  stays the orchestrator's call. The clause is read before the byte bound
+  cuts the tail, the first non-empty clause counts, deduplication compares
+  issues without their clauses, and the demotion mark survives merging in
+  any member order. Reviewer prompts also stop naming the round number, and
+  the L1 workflow knowledge (v3.10.0) adds the matching orchestrator-side
+  rule: never tell a reviewer its finding count, the round number, or prior
+  verdicts — counts a reviewer performs select for finding-production over
+  finding-weight.
+
+  Separately, one stuck seat used to cost a whole round: a stale heartbeat
+  killed the detached worker and every completed seat's reply died with it,
+  because nothing left the worker's memory until all seats were done. The
+  worker now persists each seat's outcome the moment it is decided
+  (`partial_results.json`, atomic, single writer — including the
+  dispatcher's own deadline skips, so recovery cannot relabel a reached
+  seat as lost). The collect tool's crash and timeout branches recover the
+  completed seats, but only after the reaper CONFIRMS the worker's death: a
+  stale heartbeat is not a death certificate, and a record sealed over a
+  live worker would be permanently false once idempotent replay pins it.
+  Unconfirmed death falls back to the previous retryable total-loss report.
+  Seats the worker never reached enter the denominator as skip rows named
+  `worker_crashed_seat_lost`, and the payload carries `worker_failure`
+  naming the death and the recovered and lost seat labels.
+
 ## [3.62.0] - 2026-08-06
 
 ### Changed

data/lib/kairos_mcp/version.rb

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

data/templates/knowledge/multi_llm_review_workflow/multi_llm_review_workflow.md

@@ -1,7 +1,7 @@
 ---
 name: multi_llm_review_workflow
 description: "Multi-LLM review methodology and execution — workflow pattern, CLI tooling, consensus analysis, Persona Assembly. Applicable to design, implementation, documentation, or any artifact."
-version: "3.8.0"
+version: "3.10.0"
 tags:
   - workflow
   - review
@@ -498,9 +498,58 @@ The user always has the final say.
     `open-question` or `defect` in the round's L2 record
     If no (a)/(b) blocking findings → proceed to next phase
     If any (a)/(b) finding          → repeat from [2] with revised artifact
+    (the revision obeys § Revision Discipline below)
     (c) findings are recorded as advisory; non-blocking
 ```
 
+## Revision Discipline (between rounds)
+
+> Evidence base: 35 recorded runs across 8 threads, 2026-08-03 → 08-06
+> (tokens in `.kairos/multi_llm_review/pending/`), two of which ran to
+> convergence. Same validation caveat as Step -1: a strong regularity in one
+> instance's logs, not yet reproduced elsewhere. Analysis record: L2
+> `mlr_p0_inflation_analysis_and_opus46_no_verdict_diagnosis_20260806`.
+
+The strongest predictor of round N+1's raw P0 count in those logs is whether
+the round-N revision **added mechanism** to the artifact — not the artifact's
+size, not reviewer strictness:
+
+- chain_history_erasure v0.5 added two invariants and a recount section
+  (draft 9.3k → 19.1k chars): raw P0 went 13 → 38, and 17 of the 38 targeted
+  the added or rewritten sections. v0.8, similar in size (18.6k) but authored
+  under an explicit "no new mechanism" rule, closed at 13 with one external
+  slot finding zero P0s.
+- mlr_evidence_fix R1's fix added four unrequested defensive mechanisms; R2
+  returned 41 findings, nearly all of them defects inside the additions. All
+  four mechanisms were later removed, each for a measured reason.
+- Deletions never generated findings: chain erasure v0.7 deleted three
+  mechanisms — zero new P0s against the deletions, confirmed in writing by
+  three slots.
+- Each thread converged within 1–2 rounds of switching to subtractive
+  revisions; neither converged while revisions were additive.
+
+Rules:
+
+1. **A revision closes findings by deletion, correction, or naming — never by
+   default-adding.** New mechanisms, invariants, sections, or defensive
+   layers do not enter a revision unprompted. If a finding appears to require
+   new mechanism, put the question to the operator ("finding X seems to need
+   mechanism Y — add, defer to backlog, or drop?") before drafting it in.
+   Explanatory prose is a lighter form of the same risk: a sentence added
+   only to justify a retreat became the sole blocking finding of the round
+   that followed it (mlr_evidence R6 — "adding an explanation creates a new
+   claim").
+2. **Prefer a revision author that is not the model whose additions are under
+   review.** This extends the existing separation principle — the deciding
+   context never authors what judges it — from verification to revision.
+   Opus 5 has a measured additive propensity (scope-broadening; the v0.5
+   explosion above), but the model is the pressure, not the cause: Fable 5
+   also added-and-broke (v0.6's fsync/realpath additions, v0.7's predicate 4
+   — a fatal genesis-rejecting defect) until the subtractive rule was
+   imposed, and Opus 5 converged mlr_evidence once its revisions became
+   subtractive (retreat + removal). Combine both levers: the subtractive
+   rule always, a different-model reviser when available.
+
 ## Review Types
 
 | Type | Focus | Reviewers See | Typical Use |
@@ -548,6 +597,19 @@ and philosophy-aligned finding has been answered is converged whether or not the
 numerator moved. Do not treat a reached ratio as sufficient on its own either:
 check what the approving replies actually said before counting them.
 
+**Count carryover and new (a)/(b) P0s separately; the machine-side signal of
+convergence is "new P0 = 0", not the APPROVE ratio.** Require each persona to
+state a closure verdict on its own prior-round P0s — closed / open /
+half-closed, with grounds. This format is validated live (chain erasure
+R6–R8) and is what makes the carryover/new split computable. A round whose
+(a)+(b) findings are all carryover with closure verdicts, and whose revision
+drew zero new P0s (observed without exception when the revision was
+subtractive — see § Revision Discipline), is a freeze candidate for the
+operator regardless of the numerator. Neither of the two 2026-08 threads
+ever reached its APPROVE ratio; both closed by (a)+(b) exhaustion + operator
+freeze declaration — the intended close described above, now with a
+measurable trigger.
+
 **Escalating raises the bar.** The rule is a ratio over the observers that
 counted, so adding reserve observers with `escalate: true` raises the number of
 agreements required. That is the intended cost of a wider panel, not a defect —
@@ -1027,6 +1089,26 @@ exclude it would be to exclude every honest terse approval with it. When a round
 reaches its ratio, read what the approving replies actually said before treating
 the ratio as convergence. That judgement is the human's and no rule replaces it.
 
+#### A no_verdict streak is a seat-environment signal, not a dead reviewer
+
+Before treating a slot as dead, read its `raw_text_excerpt` / `stated_text`
+in the pending record. Diagnosed live (2026-08-06, `claude_cli_opus4.6`,
+four consecutive no_verdict exclusions across one implementation-review
+thread): the CLI itself was healthy throughout. The subprocess seat runs
+sandboxed — no tools, empty working directory — so on **implementation**
+artifacts that cite file paths, the model attempted to read code before
+judging: two rounds opened with pseudo-tool-call markup, one opened with
+"the repository is not accessible" and stated its verdict header only
+further down, where the positional rule correctly refuses it. The same
+seat, in the same period, complied on **design** artifacts (verdict on
+line 1, counted every round). Remedies, in order: state in the subprocess
+prompt that the seat has no file access and must review the artifact text
+alone, marking unverifiable claims `[INFERRED]` (the grounding_rules block
+already licenses this); keep prompt rule #6 (full artifact inline) honest
+for implementation reviews; only then consider `--add-dir` with read-only
+tools, accepting CLAUDE.md contamination. A streak that survives those
+remedies is a real outage.
+
 #### Async/Parallel Collect Timing — Iron Rule
 
 When `delegation.parallel.default: true` (the v3.x default), Call 1 returns
@@ -1107,13 +1189,35 @@ Every review prompt MUST include these 7 items:
 1. **Output filename table** — so each reviewer knows where to save
 2. **Auto-execution commands** — ready-to-run CLI per reviewer
 3. **Review instructions** — what to focus on, what NOT to re-review
-4. **Review history** (R2+) — table of previous rounds and findings
+4. **Prior findings to verify** (R2+) — the findings the revision addresses,
+   so the reviewer can judge each closed / open / half-closed. Findings only:
+   no per-reviewer verdict history, no finding counts, no round tallies
+   (see § Reviewer incentive rule)
 5. **Context** — architecture summary for reviewers unfamiliar with codebase
 6. **Full artifact content inline** — reviewers may not have file access
 7. **Severity ratings + output format** — structured template for review output
 
 All prompt content MUST be in **English** for consistent parsing across LLM tools.
 
+### Reviewer incentive rule
+
+**Never tell a reviewer — subprocess or persona — that its finding count is
+compared across rounds, which round this is, or what verdicts were given
+before.** A reviewer told its count is watched treats the count as the
+deliverable, and that selects for finding-*production* over finding-*weight*
+(observed 2026-08-06: an orchestrator wrote "your finding count is compared
+across rounds" into persona prompts during the project_orientation_report
+loop; of the round's 7 P0s, 3 were factually correct findings that cost
+nobody anything). Convergence — carryover vs new, (a)+(b) exhaustion, the
+ratio — is measured by the orchestrator from the record, after the replies
+are in. The reviewer receives the artifact, the review criteria, and the
+prior findings it must verify. Nothing else about the loop's state.
+
+What this rule does NOT forbid: passing prior findings for closure
+verification (rule #4 — that is content, not score-keeping), and the
+carryover/new split in § Convergence Rules (that is orchestrator-side
+bookkeeping the reviewer never sees).
+
 ### XML Block Structure for Review Prompts
 
 Review prompts SHOULD use XML blocks to give LLMs explicit structural contracts.
@@ -1432,5 +1536,43 @@ Compression ratio: parallel agent raw → Assembly ≈ 2:1
   fence markers, character classes, digit ranges, word boundaries — and 18 of
   27 survived. Mutate the inside of a pattern, not only the pattern.
 
+- Revision discipline, new-P0 convergence signal, and no_verdict seat
+  diagnosis (v3.9.0, 2026-08-06): cross-thread analysis of 35 recorded runs
+  (8 threads, 2026-08-03 → 08-06) established that raw P0 growth tracks
+  additive revisions, not reviewer severity — every mechanism a revision
+  added became the next round's battleground, deletions drew zero new P0s
+  in every measured case, and both threads that converged did so within
+  1–2 rounds of switching to subtractive revisions (one under a Fable 5
+  reviser, one under the same Opus 5 orchestrator that had produced the
+  additive explosion). New § Revision Discipline encodes the subtractive
+  rule and the reviser-separation preference. § Convergence Rules gains the
+  carryover/new P0 split, with "new (a)+(b) P0 = 0" as the machine-side
+  freeze-candidate signal — neither thread ever reached its APPROVE ratio;
+  both closed by (a)+(b) exhaustion + operator freeze. § Substance and the
+  denominator gains the seat-environment diagnosis: `claude_cli_opus4.6`'s
+  four-round no_verdict streak was the sandboxed seat colliding with
+  implementation artifacts (pseudo-tool-calls, "repository not accessible"
+  preamble), not a dead reviewer — the same seat counted every round on
+  design artifacts in the same period. Analysis record: L2
+  `mlr_p0_inflation_analysis_and_opus46_no_verdict_diagnosis_20260806`
+
+- Reviewer incentive rule and the finding weight axis (v3.10.0, 2026-08-06):
+  § Prompt Generation Rules gains the Reviewer incentive rule — reviewer
+  prompts never mention finding counts, round numbers, or prior verdicts;
+  convergence is measured orchestrator-side from the record, and prior
+  findings are passed for closure verification only (rule #4 reworded
+  accordingly, from "review history table" to "prior findings to verify").
+  Motivating observation: an orchestrator told personas their counts were
+  compared across rounds, and 3 of the round's 7 P0s were factually correct
+  findings that cost nobody anything. In the same change the SkillSet
+  (0.10.0) adds the weight axis mechanically: the prompt contract requires a
+  `[consequence: who is harmed, and how]` clause on every P0, and
+  aggregation records a P0 without one at P2, keeping the stated severity
+  and the demotion reason beside it (`severity_stated` /
+  `severity_demoted: consequence_missing`). Presence is checked
+  mechanically; whether a stated consequence is real or trivial stays the
+  orchestrator's call, per the (a)/(b)/(c) discipline. Handoff record: L2
+  `handoff_mlr_finding_weight_axis_and_reviewer_incentive_20260806`
+
 **Key insight**: Design reviews and implementation reviews find
 **categorically different bugs**. Both phases are necessary.

data/templates/skillsets/multi_llm_review/bin/dispatch_worker.rb

@@ -259,12 +259,29 @@ begin
   # and on between-reviewer progress (counter advances when result arrives).
   # v0.3.0 PR3 pushes MainState ticks via a per-result hook below.
 
+  # Per-seat persistence: each reply is written the moment it arrives, so a
+  # worker death with one seat stuck leaves the finished seats recoverable
+  # (collect's crash/timeout recovery reads partial_results.json). Runs on
+  # the dispatch collecting thread — the worker stays this file's single
+  # writer (§6.3). subprocess_results.json still supersedes it on clean exit.
+  partial_by_index = {}
+  on_result = lambda do |idx, result|
+    partial_by_index[idx.to_s] = MLR::ReviewSerializer.serialize(result)
+    PS.write_partial_results(token, {
+      'schema_version' => 1,
+      'token' => token,
+      'updated_at' => Time.now.iso8601,
+      'results_by_index' => partial_by_index
+    })
+  end
+
   results = dispatcher.dispatch(
     (request['reviewers'] || []).map { |r| r.transform_keys(&:to_sym) },
     request['messages'] || [],
     request['system_prompt'] || '',
     context: nil,
-    review_context: request['review_context'] || 'independent'
+    review_context: request['review_context'] || 'independent',
+    on_result: on_result
   )
 
   # v3.24.3: counter-only signal (no enter_call!/exit_call! pair). bump_counter!
@@ -287,6 +304,15 @@ begin
     }
   }
   PS.write_subprocess_results(token, payload)
+  # The partial file is superseded the moment the full results land; left
+  # behind, it is a stale copy of reviewer replies sitting beside the record
+  # forever (completed token dirs are never reaped). Removed on the clean
+  # path only — on a crash it IS the record collect recovers from.
+  begin
+    File.unlink(PS.partial_results_path(token))
+  rescue Errno::ENOENT
+    nil
+  end
   PS.transition_to_terminal!(token, 'done')
   exit 0
 rescue StandardError => e

data/templates/skillsets/multi_llm_review/lib/multi_llm_review/consensus.rb

@@ -601,6 +601,15 @@ module KairosMcp
           end
         end
 
+        # The consequence clause a finding carries, when it carries one. The
+        # severity axis says what KIND of defect this is; the consequence
+        # clause is the WEIGHT axis — who is harmed, and how, if it is never
+        # fixed. Measured 2026-08-06 (project_orientation_report checker,
+        # R5): of 7 P0s, 3 were factually correct findings that cost nobody
+        # anything, and the two kinds landed at the same severity because the
+        # record had nowhere to say the difference.
+        CONSEQUENCE_RE = /\[\s*consequence:\s*([^\]]*)\]/i
+
         # Collect severity-tagged findings from all successful reviews.
         # Deduplicates by first 80 chars (case-insensitive).
         def self.aggregate_findings(parsed_verdicts)
@@ -611,23 +620,7 @@ module KairosMcp
 
             # Extract "P0: ...", "P1-1: ...", "**P0**:", etc.
             text.scan(/\*{0,2}(P[0-3])\*{0,2}[-\s]*\d*[.:]\s*(.+?)(?=\n\s*\n|\n\s*\*{0,2}P[0-3]|\z)/mi) do |sev, issue|
-              all_findings << {
-                severity: sev.upcase,
-                # This used to be `[0..200]`, an inclusive Range, so every
-                # finding longer than 201 characters lost its tail — the quoted
-                # line, the file:line, the failure condition — before anything
-                # downstream could bound it on purpose.
-                #
-                # It is bounded here rather than nowhere, and here rather than
-                # further upstream, because this is the point where both costs
-                # are decided at once: what gets stored, and what the sanitizer
-                # is about to normalise character by character. A bound placed
-                # on the reply instead was measured not to work, since NFKC runs
-                # between the two and expands by up to 11x. The bound is in
-                # bytes for the same reason — bytes are what is spent.
-                issue: Sanitizer.clamp_finding_bytes(issue.strip),
-                cited_by: [r[:role_label]]
-              }
+              all_findings << build_finding(sev, issue, r[:role_label])
             end
           end
 
@@ -659,7 +652,7 @@ module KairosMcp
           # (`issue_variants_omitted`), because a silently shortened list
           # reads as "this is all there was" — the failure this whole change
           # exists to remove.
-          grouped = all_findings.group_by { |f| f[:issue][0..79].downcase }
+          grouped = all_findings.group_by { |f| dedup_key(f[:issue]) }
           grouped.map do |_key, findings|
             merged_severity = findings.map { |f| f[:severity] }.min # P0 < P1 < P2
             # `.min` over a non-empty group returns one of its own members, so
@@ -672,6 +665,25 @@ module KairosMcp
               issue: representative[:issue],
               cited_by: findings.flat_map { |f| f[:cited_by] }.uniq
             }
+            # The representative's wording and its weight travel together, like
+            # its severity does. When the representative states no consequence,
+            # another member's is carried rather than none: a group where ONE
+            # reviewer said who is harmed is a finding whose harm is known.
+            consequence = representative[:consequence] ||
+                          findings.map { |f| f[:consequence] }.compact.first
+            row[:consequence] = consequence if consequence
+            # The demotion mark is carried from ANY member, not only the
+            # representative — copied from the representative alone it
+            # vanished order-dependently whenever a non-demoted member of the
+            # same severity happened to sort first (R1 finding, three seats
+            # independently). A row that merged to P0 carries no mark: some
+            # member stated the harm, the row holds its full severity, and
+            # nothing was demoted AWAY from what the record shows.
+            if row[:severity] != 'P0' &&
+               (demoted = findings.find { |f| f[:severity_stated] })
+              row[:severity_stated] = demoted[:severity_stated]
+              row[:severity_demoted] = demoted[:severity_demoted]
+            end
             if variants.size > 1
               row[:issue_variants] = variants.first(MAX_ISSUE_VARIANTS)
               omitted = variants.size - MAX_ISSUE_VARIANTS
@@ -680,6 +692,68 @@ module KairosMcp
             row
           end.sort_by { |f| f[:severity] }
         end
+
+        # The dedup key is the issue WITHOUT its consequence clause. The clause
+        # stays in the issue text (display, replay), but two reviewers naming
+        # one defect — one saying who is harmed, one not — are still one
+        # finding, and the merge is what lets the stated consequence carry the
+        # row's severity for both. Keyed on the raw text instead, the clause
+        # lands inside the first 80 characters of any short issue and splits
+        # the group, moving the finding count and the convergence denominator.
+        # Whitespace is normalised for the same reason: removing the clause
+        # must not leave a gap that fails the comparison it was removed for.
+        def self.dedup_key(issue)
+          issue.gsub(CONSEQUENCE_RE, ' ').gsub(/\s+/, ' ').strip[0..79].downcase
+        end
+
+        # One extracted finding, weight axis applied at the point of entry.
+        #
+        # A P0 that does not say who is harmed is recorded at P2, with the
+        # stated severity and the demotion reason kept beside it — the record
+        # says what the reviewer wrote AND what the rule did with it. Only
+        # PRESENCE is checked, mechanically, by construction: whether a stated
+        # consequence is real or trivial is a judgment call, and it belongs to
+        # the orchestrator reading the record, not to a heuristic here — the
+        # same division of labour as the substance rule above, which asks
+        # "said anything?" and never "said anything good?".
+        #
+        # The clause is copied into its own field but NOT stripped from the
+        # issue text: the display shows the issue line, a later round's prompt
+        # replays it, and the consequence should survive in both. (The dedup
+        # key, above, strips the clause before comparing — the one place the
+        # issue is read WITHOUT it.)
+        def self.build_finding(sev, issue, role_label)
+          raw = issue.strip
+          # The clause is read from the UNCLAMPED text, before the byte bound
+          # cuts the tail — a finding long enough to lose its closing bracket
+          # to the clamp would otherwise read as having stated nothing, and
+          # the demotion would bury exactly the P0 whose author complied (R1
+          # finding, three seats). Scan rather than match, first NON-empty
+          # clause: "[consequence: ] ... [consequence: real harm]" states a
+          # harm, and reading only the first bracket pair would demote past it.
+          consequence = raw.scan(CONSEQUENCE_RE)
+                           .map { |c| c[0].strip }
+                           .find { |c| !c.empty? }
+          # Bounded in BYTES at the point of extraction — this is the clamp
+          # that bounds the sanitizer's input, and the reasoning for bytes
+          # (NFKC expands up to 11x downstream) is at clamp_finding_bytes.
+          # This used to be `[0..200]`, an inclusive Range, so every finding
+          # longer than 201 characters lost its tail before anything
+          # downstream could bound it on purpose.
+          finding = {
+            severity: sev.upcase,
+            issue: Sanitizer.clamp_finding_bytes(raw),
+            cited_by: [role_label]
+          }
+          if consequence
+            finding[:consequence] = Sanitizer.clamp_finding_bytes(consequence)
+          elsif finding[:severity] == 'P0'
+            finding[:severity] = 'P2'
+            finding[:severity_stated] = 'P0'
+            finding[:severity_demoted] = 'consequence_missing'
+          end
+          finding
+        end
       end
     end
   end

data/templates/skillsets/multi_llm_review/lib/multi_llm_review/dispatcher.rb

@@ -33,9 +33,17 @@ module KairosMcp
         # @param system_prompt [String] system prompt for llm_call
         # @param context [InvocationContext] for invoke_tool
         # @param review_context [String] 'independent' or 'project_aware'
+        # @param on_result [#call, nil] called with (index, result) for every
+        #   seat outcome this dispatch decides — arrived replies as they
+        #   arrive, and the dispatch_timeout skips synthesized at the
+        #   deadline. The caller uses this to persist each seat's TRUE
+        #   outcome, so a later crash recovery reads "this seat timed out"
+        #   rather than relabelling a reached seat as lost (R1 finding). Runs
+        #   on the collecting thread; a hook failure is logged and never
+        #   fails the dispatch.
         # @return [Array<Hash>] results indexed by reviewer position
         def dispatch(reviewers, messages, system_prompt, context:,
-                     review_context: 'independent')
+                     review_context: 'independent', on_result: nil)
           dispatch_id = SecureRandom.hex(8)
           deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + @timeout
           results = Array.new(reviewers.size)
@@ -94,11 +102,17 @@ module KairosMcp
                 i, result = entry
                 results[i] = result
                 collected += 1
+                notify_result(on_result, i, result)
               end
-              # Mark uncollected as timed out
+              # Mark uncollected as timed out. Notified like an arrived
+              # reply: the skip IS this dispatch's decision about the seat,
+              # and a persisted record that omits it lets a crash recovery
+              # relabel a reached-and-timed-out seat as one the worker never
+              # got to.
               reviewers.each_with_index do |r, i|
                 next if results[i]
                 results[i] = build_skip(r, 'dispatch_timeout')
+                notify_result(on_result, i, results[i])
               end
               break
             end
@@ -111,6 +125,7 @@ module KairosMcp
             i, result = entry
             results[i] = result
             collected += 1
+            notify_result(on_result, i, result)
           end
 
           # Kill in-flight subprocesses from this dispatch
@@ -136,6 +151,15 @@ module KairosMcp
 
         private
 
+        # A hook failure must not fail the dispatch: the hook exists to save
+        # replies from a dying worker, and a hook that could kill the dispatch
+        # would create the loss it guards against.
+        def notify_result(on_result, idx, result)
+          on_result&.call(idx, result)
+        rescue StandardError => e
+          warn "[multi_llm_review::Dispatcher] on_result hook failed: #{e.class}: #{e.message}"
+        end
+
         def bump_main_state_counter
           return unless defined?(KairosMcp::SkillSets::MultiLlmReview::MainState)
           # v3.24.3: counter-only bump. exit_call! is private; bump_counter!

data/templates/skillsets/multi_llm_review/lib/multi_llm_review/pending_state.rb

@@ -72,6 +72,12 @@ module KairosMcp
         def gc_eligible_path(token);        File.join(token_dir(token), 'gc.eligible'); end
         def request_path(token);            File.join(token_dir(token), 'request.json'); end
         def subprocess_results_path(token); File.join(token_dir(token), 'subprocess_results.json'); end
+        # Per-seat results written as each seat completes, so a worker that
+        # dies with one seat stuck does not take the finished seats' replies
+        # with it (R3 2026-08-06 lost three completed external seats to one
+        # stale heartbeat). Superseded by subprocess_results.json on a clean
+        # exit; read by collect's crash/timeout recovery path only.
+        def partial_results_path(token);    File.join(token_dir(token), 'partial_results.json'); end
         def worker_pid_path(token);         File.join(token_dir(token), 'worker.pid'); end
         def worker_heartbeat_path(token);   File.join(token_dir(token), 'worker.heartbeat'); end
         def worker_tick_path(token);        File.join(token_dir(token), 'worker.tick'); end
@@ -105,6 +111,7 @@ module KairosMcp
         def write_collected(token, data);          atomic_write_json(collected_path(token), data); end
         def write_request(token, data);            atomic_write_json(request_path(token), data); end
         def write_subprocess_results(token, data); atomic_write_json(subprocess_results_path(token), data); end
+        def write_partial_results(token, data);    atomic_write_json(partial_results_path(token), data); end
         def write_worker_pid(token, data);         atomic_write_json(worker_pid_path(token), data); end
         def write_marker(token, data);             atomic_write_json(marker_path(token), data); end
         def write_completed(token, data);          atomic_write_json(completed_path(token), data); end
@@ -172,6 +179,7 @@ module KairosMcp
         def load_collected(token);          load_json_transient(collected_path(token)); end
         def load_request(token);            load_json_transient(request_path(token)); end
         def load_subprocess_results(token); load_json_transient(subprocess_results_path(token)); end
+        def load_partial_results(token);    load_json_transient(partial_results_path(token)); end
         def load_worker_pid(token);         load_json_transient(worker_pid_path(token)); end
 
         # Mutate state.json under a read-modify-write block, serialized

data/templates/skillsets/multi_llm_review/lib/multi_llm_review/prompt_builder.rb

@@ -77,7 +77,13 @@ module KairosMcp
           parts << "<task>"
           parts << "Review the provided artifact for #{review_type} correctness."
           parts << "Target: #{artifact_name}"
-          parts << "Round: R#{review_round}"
+          # The round number is deliberately NOT given to the reviewer
+          # (2026-08-06). Telling a reviewer which round it is in — like
+          # telling it its finding count is compared across rounds — turns the
+          # count into something the reviewer performs, and selects for
+          # finding-production over finding-weight. Convergence is measured by
+          # the orchestrator from the record; the reviewer needs the artifact,
+          # the criteria, and the prior findings to verify, nothing else.
           if review_round > 1 && prior_findings && !prior_findings.empty?
             parts << "Scope: Review the revisions addressing prior findings."
             parts << ""
@@ -161,14 +167,22 @@ module KairosMcp
             line one is read.
 
             For each finding, use this single-line format (one finding per line):
-            P0: <issue description> [location: file:line]
-            P1: <issue description> [location: file:line]
+            P0: <issue description> [consequence: <who is harmed, and how, if this is never fixed>] [location: file:line]
+            P1: <issue description> [consequence: ...] [location: file:line]
             P2: <issue description> [location: file:line]
             P3: <issue description> [location: file:line]
 
+            The consequence clause is REQUIRED for P0 and recommended for
+            P1; P1 findings are never demoted for lacking one. A finding can be
+            factually correct and still cost nobody anything; the consequence
+            clause is where you say who hits the defect and what happens to
+            them. A P0 with no consequence clause, or an empty one, is
+            recorded at P2. Do not restate the issue as its own consequence —
+            name the person or process that is harmed.
+
             Example:
-            P0: Missing input validation in dispatcher timeout path [location: dispatcher.rb:120]
-            P1: Thread safety issue with shared counter [location: consensus.rb:45]
+            P0: Missing input validation in dispatcher timeout path [consequence: a caller passing a negative timeout crashes the worker and the whole round's reviews are lost] [location: dispatcher.rb:120]
+            P1: Thread safety issue with shared counter [consequence: concurrent collects double-count usage] [location: consensus.rb:45]
 
             If no issues found, state "No findings" and verdict APPROVE.
             </structured_output_contract>

data/templates/skillsets/multi_llm_review/lib/multi_llm_review/sanitizer.rb

@@ -157,7 +157,8 @@ module KairosMcp
         # reaches the payload by the same path.
         #
         # @param findings [Array<Hash>] finding rows with String keys
-        # @return [Array<Hash>] the same rows, 'issue' and 'issue_variants' bound
+        # @return [Array<Hash>] the same rows, 'issue', 'consequence' and
+        #   'issue_variants' bound
         def self.bound_findings_for_record(findings)
           findings.map do |f|
             row = f.merge(
@@ -165,6 +166,15 @@ module KairosMcp
                 sanitize_finding_text(f['issue'], max_len: FINDING_RECORD_MAX_LEN)
               )
             )
+            if row['consequence']
+              # Reviewer text like the issue it was extracted from; it reaches
+              # the record by the same path.
+              row = row.merge(
+                'consequence' => clamp_finding_bytes(
+                  sanitize_finding_text(f['consequence'], max_len: FINDING_RECORD_MAX_LEN)
+                )
+              )
+            end
             if row['issue_variants']
               row = row.merge(
                 'issue_variants' => Array(row['issue_variants']).map do |v|

data/templates/skillsets/multi_llm_review/skillset.json

@@ -1,7 +1,7 @@
 {
   "name": "multi_llm_review",
-  "version": "0.9.1",
-  "description": "v0.9.1 (seat access, frozen 2026-08-06 after a one-round review): reviewer prompts carry a <seat_access> block beside the inline artifact — a seat that cannot read the repository must not attempt tool calls and must not open by saying it will read files; it reviews the artifact text alone, marks unverifiable claims [INFERRED], and still opens with its verdict line. The wording is conditional because seats differ (codex runs --sandbox read-only and can read the repository), and the block is not emitted for by_reference delivery, whose existing cannot-read instruction it would contradict. Root cause fixed: the claude subprocess seat runs with tools disabled in an empty working directory, and on implementation artifacts citing file paths it opened with pseudo-tool-call markup or a cannot-access preamble instead of its verdict line, leaving four consecutive rounds as no_verdict while counting every round on design artifacts. v0.9.0 (evidence fidelity, frozen 2026-08-06 after six review rounds): a finding reaches the record whole. It used to be cut at 201 bytes by an inclusive Range in aggregation and bounded again by the 500-character display limit, so a downstream instance measured 18 of 21 findings arriving at exactly 201 bytes with reviews[].raw_text empty on every row. Findings are now bounded in BYTES at FINDING_RECORD_MAX_LEN = 8000 for the record, with DEFAULT_MAX_LEN = 500 still applied by every path that takes a finding into a prompt. Deduplication still keys on the first 80 characters — widening it would stop two reviewers describing one defect from merging, moving the finding count and the convergence denominator — but the surviving text is no longer arbitrary: issue comes from a member whose severity equals the merged severity, distinct texts survive in issue_variants (capped at MAX_ISSUE_VARIANTS = 8, with issue_variants_omitted naming what the cap dropped). Every row now carries raw_text_excerpt unconditionally (4096 bytes) and the reviewer's reply in raw_text on request (include_raw_text, 65536 bytes). Both are SANITISED TRANSCRIPTIONS, not verbatim records, and both tool schemas say so: the text is byte-clamped, NFKC-normalised, stripped of invisible characters, tag-escaped, then byte-clamped again. No field states whether they hold the whole reply, because nothing in this SkillSet can know — a completeness flag was implemented, measured wrong in both directions, and removed. On delegated runs the pending-state record keeps each subprocess reply as it arrived; on single-phase runs the returned payload is the only form there is. Findings carried into a later round's prompt are sanitised and folded to one line, a path that previously took reviewer text into a prompt with no sanitisation at all. v0.8.0 (v0.7 record schema, design frozen 2026-08-01): the verdict vocabulary is the three canonical words plus tense forms only (INV-R1); the ratio and threshold are recorded reference values, not the run's conclusion — the top-level verdict field became reference_verdict and the run is closed by the operator's declaration outside the record (INV-R2); the persona team occupies one seat, its derivation rule is recorded, and a submission smaller than convened — including empty — is accepted with the shortfall on the record (INV-R3/R4); every run writes an existence marker at dispatch, completed records are never garbage-collected, and expired runs are reduced to a minimal trace instead of erased (INV-R4); a divergence-excluded tally is carried beside the main one (INV-R5); the record names its pre-declared spec and carries transport diagnostics as state tags (INV-R6); artifact delivery is a per-seat attribute (inline | by_reference) and an unreachable delivery is refused rather than dispatched (INV-R7). Parallel multi-LLM review orchestration. Dispatches review prompts to N LLM backends via llm_client, collects verdicts, and computes consensus. v0.6.0: reserve observers (escalate) and a declarable persona execution model; the observer set is built in one pass with explicit precedence (ObserverSet); every slot must name its model and role_label, and duplicate names — including the persona team's own — are refused. A reply's verdict is no longer inferred from its prose: it is read from a declared field, from the header the reply opens with when that header carries a verdict name and nothing else, or not at all, in which case the reply leaves the denominator with no_verdict recorded beside its name. The record says why every observer did or did not count (denominator_composition, five skip_reason values, observers_reporting), and the per-reviewer row is written by one mapping rather than two. v0.5.2: the cursor reviewer pins model composer-2.5 instead of inheriting the cursor CLI default, which is operator-editable and had silently become an Anthropic model. v0.5.1: Fable 5 retired from the roster (five consecutive silent returns), convergence 3/5; orchestrator_model description now states the bare-ID rule so a caller does not review its own output. v0.5.0: adds multi_llm_review_wait (Phase 1.5) for explicit subprocess completion gating with next_action recovery hints, and Path A/B doc disambiguation. v0.4.0 (Phase 12): feedback_text + schema_version, sanitization contract for prompt-injection defense, and multi_llm_review_bundle tool for human-handoff paths without dispatch.",
+  "version": "0.10.0",
+  "description": "v0.10.0 (finding weight axis + worker-death recovery, 2026-08-06): findings gain a consequence axis beside the severity axis — the prompt contract requires a [consequence: who is harmed, and how, if this is never fixed] clause on every P0, and aggregation records a P0 without one at P2, keeping the stated severity and the demotion reason on the row (severity_stated / severity_demoted: consequence_missing). Only PRESENCE is checked, mechanically; whether a stated consequence is real or trivial stays the orchestrator's call. The dedup key strips the clause so two reviewers naming one defect still merge, and a group where one member states the harm carries it for the row. Motivating measurement (project_orientation_report checker, R5): 3 of 7 P0s were factually correct findings that cost nobody anything. Reviewer prompts also stop naming the round number — telling a reviewer which round it is in (like telling it its counts are compared) selects for finding-production over finding-weight; the L1 workflow v3.10.0 Reviewer incentive rule states the orchestrator-side half. And a worker death no longer discards completed seats: the worker persists each reply as it arrives (partial_results.json), and collect's crash/timeout branches recover the finished seats, entering every unreached seat in the denominator as a skip row (worker_crashed_seat_lost) with the death named in payload.worker_failure — R3 2026-08-06 lost three completed external seats to one stale heartbeat because the only exit was total loss. v0.9.1 (seat access, frozen 2026-08-06 after a one-round review): reviewer prompts carry a <seat_access> block beside the inline artifact — a seat that cannot read the repository must not attempt tool calls and must not open by saying it will read files; it reviews the artifact text alone, marks unverifiable claims [INFERRED], and still opens with its verdict line. The wording is conditional because seats differ (codex runs --sandbox read-only and can read the repository), and the block is not emitted for by_reference delivery, whose existing cannot-read instruction it would contradict. Root cause fixed: the claude subprocess seat runs with tools disabled in an empty working directory, and on implementation artifacts citing file paths it opened with pseudo-tool-call markup or a cannot-access preamble instead of its verdict line, leaving four consecutive rounds as no_verdict while counting every round on design artifacts. v0.9.0 (evidence fidelity, frozen 2026-08-06 after six review rounds): a finding reaches the record whole. It used to be cut at 201 bytes by an inclusive Range in aggregation and bounded again by the 500-character display limit, so a downstream instance measured 18 of 21 findings arriving at exactly 201 bytes with reviews[].raw_text empty on every row. Findings are now bounded in BYTES at FINDING_RECORD_MAX_LEN = 8000 for the record, with DEFAULT_MAX_LEN = 500 still applied by every path that takes a finding into a prompt. Deduplication still keys on the first 80 characters — widening it would stop two reviewers describing one defect from merging, moving the finding count and the convergence denominator — but the surviving text is no longer arbitrary: issue comes from a member whose severity equals the merged severity, distinct texts survive in issue_variants (capped at MAX_ISSUE_VARIANTS = 8, with issue_variants_omitted naming what the cap dropped). Every row now carries raw_text_excerpt unconditionally (4096 bytes) and the reviewer's reply in raw_text on request (include_raw_text, 65536 bytes). Both are SANITISED TRANSCRIPTIONS, not verbatim records, and both tool schemas say so: the text is byte-clamped, NFKC-normalised, stripped of invisible characters, tag-escaped, then byte-clamped again. No field states whether they hold the whole reply, because nothing in this SkillSet can know — a completeness flag was implemented, measured wrong in both directions, and removed. On delegated runs the pending-state record keeps each subprocess reply as it arrived; on single-phase runs the returned payload is the only form there is. Findings carried into a later round's prompt are sanitised and folded to one line, a path that previously took reviewer text into a prompt with no sanitisation at all. v0.8.0 (v0.7 record schema, design frozen 2026-08-01): the verdict vocabulary is the three canonical words plus tense forms only (INV-R1); the ratio and threshold are recorded reference values, not the run's conclusion — the top-level verdict field became reference_verdict and the run is closed by the operator's declaration outside the record (INV-R2); the persona team occupies one seat, its derivation rule is recorded, and a submission smaller than convened — including empty — is accepted with the shortfall on the record (INV-R3/R4); every run writes an existence marker at dispatch, completed records are never garbage-collected, and expired runs are reduced to a minimal trace instead of erased (INV-R4); a divergence-excluded tally is carried beside the main one (INV-R5); the record names its pre-declared spec and carries transport diagnostics as state tags (INV-R6); artifact delivery is a per-seat attribute (inline | by_reference) and an unreachable delivery is refused rather than dispatched (INV-R7). Parallel multi-LLM review orchestration. Dispatches review prompts to N LLM backends via llm_client, collects verdicts, and computes consensus. v0.6.0: reserve observers (escalate) and a declarable persona execution model; the observer set is built in one pass with explicit precedence (ObserverSet); every slot must name its model and role_label, and duplicate names — including the persona team's own — are refused. A reply's verdict is no longer inferred from its prose: it is read from a declared field, from the header the reply opens with when that header carries a verdict name and nothing else, or not at all, in which case the reply leaves the denominator with no_verdict recorded beside its name. The record says why every observer did or did not count (denominator_composition, five skip_reason values, observers_reporting), and the per-reviewer row is written by one mapping rather than two. v0.5.2: the cursor reviewer pins model composer-2.5 instead of inheriting the cursor CLI default, which is operator-editable and had silently become an Anthropic model. v0.5.1: Fable 5 retired from the roster (five consecutive silent returns), convergence 3/5; orchestrator_model description now states the bare-ID rule so a caller does not review its own output. v0.5.0: adds multi_llm_review_wait (Phase 1.5) for explicit subprocess completion gating with next_action recovery hints, and Path A/B doc disambiguation. v0.4.0 (Phase 12): feedback_text + schema_version, sanitization contract for prompt-injection defense, and multi_llm_review_bundle tool for human-handoff paths without dispatch.",
   "author": "Masaomi Hatakeyama",
   "layer": "L1",
   "depends_on": [