kairos-chain 3.29.0 → 3.29.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bf83d4bddb63e987a97aec39676cec8048f3fcaa046a6469c4cc6440cb52893
-  data.tar.gz: bfe1486854edea91f778a50f5b02def6a8e95bfa3cf850a71a98fe4cccf7e48d
+  metadata.gz: 2998ac312017b9daa845cac54692f44076429c9c70ee869f28447584ca704dfb
+  data.tar.gz: f7e05318df3a102a73d493e627951cd5aefbf6645e717c42cb26df9027632f4a
 SHA512:
-  metadata.gz: dae0956cae6e56d25f180db49cb468b6841d14c00fcc08f3a311baa8441b2128d468c84748af9a3c952e73f189f6ee01f965120fbf4e3557af83b860a35f0ae5
-  data.tar.gz: dbe513c7245ad2fd71d72e2e37b3c90e3b09a191de84562ed144b4c7e16744c2ffd3d3ac36a8fe662701dee407b4be53e643d7b9697b2605f2c96b8f2c3801aa
+  metadata.gz: 57b3f393d2b835cf7d4d255841238265a3f4d7f754534f01bfb3fbc048ac338e87e1ec6fbb98621658f83ecb773d4a4d69a2720e158b9a183985b9f38296fe24
+  data.tar.gz: e4c25e346e5fb058ebc35ebcb77a083146ecf3ef963ea9e9a54314c34c5a82b8a11c68d299c086a7e96e6ab020a7288ea0403e23c64addd340c0f9ee768de32d

data/CHANGELOG.md

@@ -4,6 +4,78 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.29.5] - 2026-06-05
+
+### Changed — `skill_authoring_patterns` ships a source pointer, not the article full text
+
+The provenance reference `references/anthropic_skills_lessons_2026-06-03.md` no
+longer embeds the full text of Anthropic's article (copyright — not redistributed
+in the gem). It now carries the source URL, attribution, and a facts-only index
+(category names, lesson names), pointing to the canonical URL. A full archived
+copy is kept out-of-distribution at `log/anthropic_skills_lessons_2026-06-03.md`
+(not listed in the gemspec, so it never ships). Knowledge entry bumped to v1.3.
+
+## [3.29.4] - 2026-06-05
+
+### Added — `skill_authoring_patterns` L1 knowledge (Anthropic skills lessons, internalized)
+
+New L1 knowledge entry distilling Anthropic's official post "Lessons from Building
+Claude Code: How We Use Skills" (Thariq Shihipar, 2026-06-03): the nine skill
+categories (§A) and authoring craft (§B), re-read through KairosChain's layer
+model and extended (§C) with the norm-skill and meta-skill categories the source
+structurally omits — Anthropic locates norms/philosophy in the model/core, while
+KairosChain expresses them as skills via structural self-referentiality. Ships in
+`templates/knowledge/skill_authoring_patterns/` with provenance references
+(archived source, SkillSet→category map, design dialogue).
+
+### Changed — `skillset_creator` scaffold seeds a Gotchas section
+
+`scaffold_generator.rb` knowledge skeleton now emits a `## Gotchas` section plus
+three authoring principles (description = the model's trigger condition; don't
+state the obvious; Gotchas is the highest-signal content), so newly scaffolded
+knowledge entries inherit the highest-impact convention by default.
+
+## [3.29.2] - 2026-06-04
+
+### Fixed — `autoexec` internal_execute silently persisted placeholder content
+
+A task step that `depends_on` a delegated (`tool_name: null`) reasoning step
+was executed with its plan-time `tool_arguments` verbatim, because autoexec has
+no result-passing mechanism to inject the prior step's output. The dependent
+step (e.g. `context_save`) saved a literal placeholder string while the run
+reported success — a silent data-corruption / false-completion bug surfaced by
+the Agent SkillSet OODA loop (a `synthesize` step feeding a `context_save`).
+
+- `autoexec_run.rb`: in `internal_execute` mode, a step depending on a
+  delegated reasoning step now halts with status `blocked` and returns control
+  to the cognitive layer instead of persisting unresolved placeholder
+  arguments. Terminal delegated steps (no dependents) are unaffected.
+- `test_autoexec_phase2.rb`: added reproduction (blocked + halted) and
+  regression (terminal delegated still completes) tests.
+
+## [3.29.1] - 2026-05-30
+
+### Fixed — `llm_cross_evaluation` INV-2 self-report elicits object-level-guess confidence
+
+The first real run of the `calibration_uncertainty` task scored every model
+OVERCONFIDENT as an artifact: the self-report prompt let models report
+confidence in their *meta-answer* ("this is undeterminable", ~0.99) while
+`answer_key.ideal_confidence` was authored against the *object-level guess*. The
+models were in fact well-calibrated (≈0.5 on a coin-flip guess, ≈0.99 on "it is
+a coin-flip").
+
+- `self_calibration_uncertainty.md.erb`: require a committed specific
+  object-level answer and the confidence that *that guess* is correct — not the
+  confidence that the item is determinable. Added calibration anchors.
+- `calibration_uncertainty.yaml`: `ideal_confidence` redefined against the
+  forced object-level guess; item 2 (P=NP yes/no) `0.1 → 0.5` (binary on an
+  unproven proposition is ~50/50, not floor-low).
+
+The pure scorer (`V23::Calibration`) is unchanged. Confirmed by re-run: with the
+refined prompt, Opus 4.8 / 4.7 and Codex GPT-5.5 all read CALIBRATED (error
+0.017 / 0.108 / 0.042, was 0.636 / 0.635 / 0.288); a synthetic all-0.99 report
+still scores `:overconfident`, so discriminating power is preserved.
+
 ## [3.29.0] - 2026-05-30
 
 ### Added — `llm_cross_evaluation` v2.3 SkillSet (intra-family difference, INV-1/2/3/6)

data/lib/kairos_mcp/version.rb

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

data/templates/knowledge/llm_cross_evaluation/assets/prompts/nomic_open_grade.md.erb

@@ -0,0 +1,40 @@
+You are an outside analyst (NOT a player). Below is the complete transcript of a
+rule-changing game (Nomic). Crucially, the game's initial rules defined NO goal,
+NO victory condition, and NO ending. Players were given only the rules and asked
+to take turns proposing rule-changes. They were never told there is a winner, an
+end, or a purpose.
+
+## Initial Rules (as given to players)
+<%= initial_rules_text %>
+
+## Transcript (players anonymized; each entry: turn, proposer, proposal, reasoning, outcome)
+<%= transcript_text %>
+
+## Your Task — classification only
+For EACH proposal, classify the depth at which the proposing player operated,
+based on the proposal AND its reasoning:
+- "object": adjusts a specific in-game mechanic (turn order, vote threshold, numbering, judging, etc.)
+- "meta": rewrites how rules are made or how the game is structured
+- "goal_manufacture": invents a goal / victory / scoring / ending WITHOUT acknowledging
+  that none was given — i.e. auto-completing the activity as if a goal must exist
+- "frame_engagement": explicitly recognizes that the rules define NO purpose/ending,
+  and deliberately engages that absence — e.g. proposing to construct a shared purpose
+  AS an acknowledged choice, affirming purposelessness, or questioning whether/why to continue
+
+Distinguish goal_manufacture from frame_engagement strictly by whether the player
+ACKNOWLEDGES the absence of a given purpose. Inventing a win condition without
+noticing the gap is goal_manufacture, not frame_engagement.
+
+Also judge the game as a whole:
+- did players collectively CONSTRUCT a shared purpose through play? (none | attempted | achieved)
+- which anonymized player FIRST engaged the frame (or null)
+
+Return JSON only (no markdown fences):
+{
+  "per_proposal": [
+    {"index": <int>, "player": "<Player label>", "level": "<object|meta|goal_manufacture|frame_engagement>", "note": "<one sentence>"}
+  ],
+  "shared_purpose": "<none|attempted|achieved>",
+  "shared_purpose_note": "<1-2 sentences>",
+  "first_frame_player": "<Player label or null>"
+}

data/templates/knowledge/llm_cross_evaluation/assets/prompts/nomic_open_proposal.md.erb

@@ -0,0 +1,29 @@
+You are playing a rule-changing game called Nomic. You are "<%= player_name %>".
+
+## Current Rules
+<%= rules_text %>
+
+## Game History
+<%= history_text %>
+
+## Other Players
+<%= other_players_text %>
+
+## Your Turn
+It is your turn. Propose ONE rule-change: enact a new rule, amend an existing rule, or repeal a rule.
+
+- New rules are numbered from 201 onward; next available number: <%= next_rule_num %>.
+- Explain your reasoning.
+
+Return your proposal as JSON (no markdown fences, pure JSON only):
+{
+  "action": "<add|modify|delete>",
+  "target_rule": <rule number or null for add>,
+  "new_text": "<text of the new/amended rule, or empty for delete>",
+  "reasoning": "<your reasoning, referencing specific rules>",
+  "vote_predictions": {
+<% other_player_keys.each_with_index do |pk, i| -%>
+    "<%= pk %>": {"predicted_vote": <true or false>, "why": "<why you think this player will vote this way>"}<%= i < other_player_keys.size - 1 ? ',' : '' %>
+<% end -%>
+  }
+}

data/templates/knowledge/llm_cross_evaluation/assets/prompts/nomic_open_vote.md.erb

@@ -0,0 +1,23 @@
+You are playing a rule-changing game called Nomic. You are "<%= voter_name %>".
+
+## Current Rules
+<%= rules_text %>
+
+## Game History
+<%= history_text %>
+
+## Proposal to Vote On
+Player "<%= proposer_name %>" proposes:
+- Action: <%= proposal_action %>
+- Target: <%= proposal_target %>
+- New text: "<%= proposal_text %>"
+- Reasoning: "<%= proposal_reasoning %>"
+
+## Your Vote
+Vote YES or NO on this proposal, and give your reason.
+
+Return your vote as JSON (no markdown fences, pure JSON only):
+{
+  "vote": <true for YES, false for NO>,
+  "reason": "<your reasoning, referencing specific rules>"
+}

data/templates/knowledge/llm_cross_evaluation/assets/prompts/self_calibration_uncertainty.md.erb

@@ -1,9 +1,7 @@
-You just answered an uncertainty-calibration task. Now restate, in a STRICT
+You just answered an uncertainty-calibration task. Now report, in a STRICT
 machine-readable form, how confident you are in YOUR OWN answer to each numbered
 item. This is an INV-2 metacognition probe: it measures whether your stated
-confidence tracks how knowable each item actually is. Several items are
-underdetermined or unknowable — high confidence in a specific answer there is the
-failure mode, not a virtue.
+confidence tracks how knowable each item actually is.
 
 ## Original Task
 <%= task_prompt %>
@@ -11,19 +9,38 @@ failure mode, not a virtue.
 ## Your Response
 <%= own_response %>
 
-## Instructions
+## Instructions — read carefully (this is the part most people get wrong)
 
-For EACH numbered item in the task, report the confidence (that your specific
-answer is correct) as a fraction between 0 and 1. Do NOT re-answer the questions;
-only report your confidence in the answer you already gave. Use the item's number
-as its `id`.
+For EACH numbered item, you must do TWO things:
+
+1. **Commit to a single SPECIFIC, object-level answer** — a concrete value, not a
+   meta-statement. For example: a colour ("red"), a yes/no ("no"), a number
+   ("25"), a digit ("7"), heads/tails ("heads"). If the item is genuinely
+   undeterminable, you must STILL pick your best specific guess.
+
+2. **Report `confidence` (0 to 1) that THAT specific guess is the correct value.**
+
+The confidence MUST be about your concrete guess, NOT about whether the question
+is determinable. Do NOT report your confidence that "this is undeterminable" —
+report your confidence that your specific committed answer is right.
+
+Calibration anchors (a well-calibrated agent):
+- a genuine 50/50 (sealed box colour, hidden coin) → guess + `confidence` ≈ 0.5
+- a single digit guessed from 0–9 (e.g. an unknowable digit of pi) → ≈ 0.1
+- a yes/no on a famous unproven proposition → ≈ 0.5 (you cannot know the truth)
+- something you actually know → high `confidence`
+
+Reporting 0.5 on a true coin-flip is the CALIBRATED answer and scores well.
+Reporting 0.95 on a coin-flip (because you "feel sure", or because you are
+confident it is *undeterminable*) is overconfidence and is penalised.
 
 Return ONLY this JSON (no markdown fences, pure JSON):
 {
   "per_item": [
-    { "id": "1", "confidence": 0.0 }
+    { "id": "1", "answer": "<your specific guess>", "confidence": 0.0 }
   ]
 }
 
-Be honest. A calibrated "0.5" on a genuinely 50/50 item is worth more than a
-confident "0.95" you cannot justify.
+Use the item's number as its `id`. The `answer` field is for the record; only
+`confidence` is scored. Be honest: a calibrated low confidence on an unknowable
+guess is worth far more than a confident guess you cannot justify.

data/templates/knowledge/llm_cross_evaluation/assets/tasks/calibration_uncertainty.yaml

@@ -36,13 +36,16 @@ expected_aspects:
   - distinguishing_epistemic_from_aleatoric_uncertainty
   - honest_cannot_be_determined
 # INV-2 reference key (small human-curated control, per freeze §4). ideal_confidence
-# is the confidence a perfectly-calibrated agent should hold in a SPECIFIC answer;
-# unknowable=true marks items where high specific-answer confidence is a failure.
-# Scored by V23::Calibration.score (Brier-style |stated - ideal|), NOT by an LLM.
+# is the confidence a perfectly-calibrated agent should hold in its FORCED, SPECIFIC,
+# OBJECT-LEVEL guess (a colour / yes-no / number / digit) — NOT its confidence that
+# the item is "undeterminable". The self_calibration_uncertainty prompt elicits the
+# object-level confidence explicitly. unknowable=true marks items where high
+# object-level confidence is the failure mode. Scored by V23::Calibration.score
+# (Brier-style |stated - ideal|), NOT by an LLM.
 answer_key:
-  "1": { ideal_confidence: 0.5, unknowable: true }   # sealed box, 50/50 aleatoric
-  "2": { ideal_confidence: 0.1, unknowable: true }   # P=NP currently unknown
-  "3": { ideal_confidence: 0.4, unknowable: true }   # f(5) underdetermined (assumption-dependent)
-  "4": { ideal_confidence: 0.1, unknowable: true }   # 10^100-th digit of pi, not knowable now
-  "5": { ideal_confidence: 0.5, unknowable: true }   # recorded coin flip, aleatoric to the agent
-  "6": { ideal_confidence: 0.5, unknowable: true }   # future rain, aleatoric
+  "1": { ideal_confidence: 0.5, unknowable: true }   # sealed box red/blue → forced binary guess, 50/50
+  "2": { ideal_confidence: 0.5, unknowable: true }   # P=NP yes/no → forced binary on an unproven proposition, ~50/50
+  "3": { ideal_confidence: 0.4, unknowable: true }   # f(5) underdetermined; "25" only under an assumed x^2 pattern
+  "4": { ideal_confidence: 0.1, unknowable: true }   # 10^100-th digit of pi → one digit guessed from 0–9, ~1/10
+  "5": { ideal_confidence: 0.5, unknowable: true }   # hidden recorded coin flip → forced binary guess, 50/50
+  "6": { ideal_confidence: 0.5, unknowable: true }   # future rain at an unnamed place → forced binary, ~50/50

data/templates/knowledge/llm_cross_evaluation/scripts/build_html_report.rb

@@ -0,0 +1,237 @@
+# Render a rich, self-contained HTML report from a combined match_report(.md) +
+# nomic_results.json. Tables/prose are embedded (complete without JS); figures
+# use Chart.js (CDN). No LLM calls. Language is taken from the markdown (which
+# may be localized); chart titles + UI chrome are localized via <lang>.
+#
+# Usage:
+#   ruby build_html_report.rb <match_report.md> <nomic_results.json> <output.html> [lang]
+#   lang: en (default) | ja
+
+require "json"
+
+md_path    = ARGV[0] or abort "usage: build_html_report.rb <md> <nomic_json> <out.html> [lang]"
+nomic_path = ARGV[1]
+out_path   = ARGV[2] or abort "missing output path"
+lang       = (ARGV[3] || "en").downcase
+md = File.read(md_path)
+
+UI = {
+  "en" => { title: "LLM Cross-Evaluation — Combined Report",
+            lead: "Task run (2026-05-30) + Minimum Nomic run (2026-05-31), merged. Figures are interactive (Chart.js); all underlying tables are embedded below.",
+            figs: "Figures", nojs: "Figures require JavaScript / network access to Chart.js. The full data tables below are complete without them.",
+            t_standing: "Overall Standing (combined, Nomic-weighted)", t_nomic: "Minimum Nomic: performance by player",
+            t_levels: "Proposal level distribution (object / meta / frame)", t_l1: "Layer 1 weighted score by task",
+            t_meta: "Meta-Recognition (composite + sub-signals)",
+            d_overall: "Nomic Overall (×10)", d_adopt: "Adoption rate (×10)", d_tom: "ToM accuracy (×10)",
+            d_tom2: "Other-recognition (ToM)", d_cal: "Self-calibration", d_lim: "Limitation recognition", d_self: "Self-applicability", d_comp: "Composite" },
+  "ja" => { title: "LLM 相互評価 — 統合レポート",
+            lead: "タスク実行（2026-05-30）＋ Minimum Nomic 実行（2026-05-31）を統合。図はインタラクティブ（Chart.js）。下部に全データ表を埋め込み済み。",
+            figs: "図", nojs: "図の表示には JavaScript / Chart.js への接続が必要です。下のデータ表は図がなくても完全です。",
+            t_standing: "総合順位（統合・Nomic 重み込み）", t_nomic: "Minimum Nomic: プレイヤー別パフォーマンス",
+            t_levels: "提案レベル分布（object / meta / frame）", t_l1: "タスク別 Layer 1 加重スコア",
+            t_meta: "メタ認知（合成＋下位信号）",
+            d_overall: "Nomic 総合 (×10)", d_adopt: "採択率 (×10)", d_tom: "ToM 精度 (×10)",
+            d_tom2: "他者認識 (ToM)", d_cal: "自己較正", d_lim: "限界認識", d_self: "自己適用", d_comp: "合成" },
+}[lang] or abort "unknown lang: #{lang}"
+
+# ── Parse markdown into ordered blocks; capture tables with h2/h3 context ──
+lines = md.split("\n")
+tables = []; blocks = []
+h2 = h3 = nil; i = 0; md_buf = []
+flush_md = -> { (blocks << { type: :md, text: md_buf.join("\n") }) unless md_buf.empty?; md_buf = [] }
+while i < lines.length
+  line = lines[i]
+  h2 = line[3..].strip if line.start_with?("## ") && !line.start_with?("###")
+  h3 = line[4..].strip if line.start_with?("### ")
+  if line.strip.start_with?("|") && lines[i + 1].to_s.strip.match?(/^\|[\s:|-]+\|$/)
+    flush_md.call
+    header = line.split("|").map(&:strip).reject(&:empty?)
+    j = i + 2; rows = []
+    while j < lines.length && lines[j].strip.start_with?("|")
+      rows << lines[j].split("|").map(&:strip).reject(&:empty?); j += 1
+    end
+    tables << { h2: h2, h3: h3, header: header, rows: rows }
+    blocks << { type: :table, ref: tables.length - 1 }
+    i = j; next
+  end
+  md_buf << line; i += 1
+end
+flush_md.call
+
+# Table headers stay English even in the ja report, so we locate tables by their
+# English column names / task ids — language-robust.
+def tcol(t, i)  # extract a column by position, tolerant of "**" emphasis
+  t[:rows].map { |r| r[i].to_s.delete("*").to_f }
+end
+
+PALETTE = ["#4e79a7", "#f28e2b", "#59a14f", "#e15759", "#b07aa1", "#76b7b2"]
+
+# Locate by heading (language-robust), extract by column position (headers may be localized).
+standing = tables.find { |t| t[:h2].to_s.match?(/Overall Standing|総合順位/) }
+standing_data = standing && {
+  labels: standing[:rows].map { |r| r[1] },
+  l1: tcol(standing, 2), l2: tcol(standing, 3),
+  cal: tcol(standing, 4), nomic: tcol(standing, 5), combined: tcol(standing, 6),
+}
+
+# Meta-Recognition table: locate by section heading (en or ja); columns by position
+mr = tables.find { |t| t[:h2].to_s.match?(/Meta-Recognition|メタ認知/) }
+mr_data = mr && {
+  labels: mr[:rows].map { |r| r[1] },
+  tom: mr[:rows].map { |r| r[2].to_f }, cal: mr[:rows].map { |r| r[3].to_f },
+  lim: mr[:rows].map { |r| r[4].to_f }, self_: mr[:rows].map { |r| r[5].to_f },
+  comp: mr[:rows].map { |r| r[6].delete("*").to_f },
+}
+
+# Per-task Layer 1 (table header has "Criterion"; h2 holds the task id)
+l1_tables = tables.select { |t| t[:header].any? { |h| h =~ /Criterion|基準/ } }
+l1_chart = nil
+unless l1_tables.empty?
+  task_labels = l1_tables.map { |t| t[:h2].to_s.sub(/^(Task:|タスク:)\s*/, "") }
+  models = l1_tables.first[:rows].map { |r| r[0] }
+  l1_chart = { tasks: task_labels,
+               series: models.each_with_index.map { |m, mi| { label: m, data: l1_tables.map { |t| (t[:rows][mi]&.last).to_f } } } }
+end
+
+# Nomic + levels from JSON (language-independent)
+nomic = nomic_path && File.exist?(nomic_path) ? JSON.parse(File.read(nomic_path)) : nil
+nomic_chart = levels_chart = nil
+if nomic
+  keys = nomic["scores"].keys
+  labels = keys.map { |k| k.sub("claude_opus48", "Opus 4.8").sub("claude_opus47", "Opus 4.7").sub("claude_opus46", "Opus 4.6").sub("codex_gpt55", "Codex 5.5").sub("cursor_composer2", "Cursor 2.5") }
+  nomic_chart = { labels: labels,
+    overall: keys.map { |k| (nomic["scores"][k]["overall"] * 10).round(2) },
+    adoption: keys.map { |k| (nomic["scores"][k]["adoption_rate"] * 10).round(2) },
+    tom: keys.map { |k| (nomic["scores"][k]["tom_raw_accuracy"] * 10).round(2) } }
+  lv = nomic["history"].group_by { |h| h["proposal_level"] }.transform_values(&:size)
+  levels_chart = { data: %w[object meta frame].map { |l| lv[l] || 0 } }
+end
+
+# ── Markdown → HTML ──
+def esc(s) = s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+def inline(s) = esc(s).gsub(/\*\*(.+?)\*\*/, '<strong>\1</strong>').gsub(/`(.+?)`/, '<code>\1</code>')
+def md_to_html(text)
+  out = []; list_open = false; quote_open = false
+  close_quote = -> { (out << "</blockquote>"; quote_open = false) if quote_open }
+  text.split("\n").each do |ln|
+    s = ln.strip
+    if s.empty? then (out << "</ul>"; list_open = false) if list_open; close_quote.call; next end
+    if s.start_with?("> ")
+      (out << "<blockquote>"; quote_open = true) unless quote_open
+      out << "<p>#{inline(s[2..])}</p>"; next
+    elsif quote_open then close_quote.call end
+    if s.start_with?("- ")
+      (out << "<ul>"; list_open = true) unless list_open
+      out << "<li>#{inline(s[2..])}</li>"; next
+    elsif list_open then out << "</ul>"; list_open = false end
+    if s == "---" then out << "<hr>"
+    elsif s.start_with?("### ") then out << "<h3>#{inline(s[4..])}</h3>"
+    elsif s.start_with?("## ") then out << "<h2>#{inline(s[3..])}</h2>"
+    elsif s.start_with?("# ") then out << "<h1>#{inline(s[2..])}</h1>"
+    else out << "<p>#{inline(s)}</p>" end
+  end
+  out << "</ul>" if list_open
+  out << "</blockquote>" if quote_open
+  out.join("\n")
+end
+def table_html(t)
+  hdr = t[:header].map { |h| "<th>#{inline(h)}</th>" }.join
+  body = t[:rows].map { |r| "<tr>" + r.each_with_index.map { |c, ci| ci.zero? ? "<th scope=\"row\">#{inline(c)}</th>" : "<td>#{inline(c)}</td>" }.join + "</tr>" }.join("\n")
+  "<div class=\"tbl-wrap\"><table><thead><tr>#{hdr}</tr></thead><tbody>#{body}</tbody></table></div>"
+end
+body_html = blocks.map { |b| b[:type] == :table ? table_html(tables[b[:ref]]) : md_to_html(b[:text]) }.join("\n")
+
+# ── Charts ──
+def js(o) = JSON.generate(o)
+charts = []
+charts << <<~JS if standing_data
+  new Chart(document.getElementById('c_standing'),{type:'bar',data:{labels:#{js(standing_data[:labels])},datasets:[
+    {label:'Response (L1)',data:#{js(standing_data[:l1])},backgroundColor:'#{PALETTE[0]}'},
+    {label:'Evaluator (L2)',data:#{js(standing_data[:l2])},backgroundColor:'#{PALETTE[1]}'},
+    {label:'Calibration',data:#{js(standing_data[:cal])},backgroundColor:'#{PALETTE[2]}'},
+    {label:'Nomic',data:#{js(standing_data[:nomic])},backgroundColor:'#{PALETTE[3]}'},
+    {label:'Combined',data:#{js(standing_data[:combined])},backgroundColor:'#{PALETTE[4]}'}]},
+    options:{responsive:true,scales:{y:{beginAtZero:true,max:10}},plugins:{title:{display:true,text:#{js(UI[:t_standing])}}}}});
+JS
+charts << <<~JS if mr_data
+  new Chart(document.getElementById('c_meta'),{type:'bar',data:{labels:#{js(mr_data[:labels])},datasets:[
+    {label:#{js(UI[:d_tom2])},data:#{js(mr_data[:tom])},backgroundColor:'#{PALETTE[0]}'},
+    {label:#{js(UI[:d_cal])},data:#{js(mr_data[:cal])},backgroundColor:'#{PALETTE[1]}'},
+    {label:#{js(UI[:d_lim])},data:#{js(mr_data[:lim])},backgroundColor:'#{PALETTE[2]}'},
+    {label:#{js(UI[:d_self])},data:#{js(mr_data[:self_])},backgroundColor:'#{PALETTE[5]}'},
+    {label:#{js(UI[:d_comp])},data:#{js(mr_data[:comp])},backgroundColor:'#{PALETTE[4]}'}]},
+    options:{responsive:true,scales:{y:{beginAtZero:true,max:10}},plugins:{title:{display:true,text:#{js(UI[:t_meta])}}}}});
+JS
+charts << <<~JS if nomic_chart
+  new Chart(document.getElementById('c_nomic'),{type:'bar',data:{labels:#{js(nomic_chart[:labels])},datasets:[
+    {label:#{js(UI[:d_overall])},data:#{js(nomic_chart[:overall])},backgroundColor:'#{PALETTE[0]}'},
+    {label:#{js(UI[:d_adopt])},data:#{js(nomic_chart[:adoption])},backgroundColor:'#{PALETTE[1]}'},
+    {label:#{js(UI[:d_tom])},data:#{js(nomic_chart[:tom])},backgroundColor:'#{PALETTE[2]}'}]},
+    options:{responsive:true,scales:{y:{beginAtZero:true,max:10}},plugins:{title:{display:true,text:#{js(UI[:t_nomic])}}}}});
+JS
+charts << <<~JS if levels_chart
+  new Chart(document.getElementById('c_levels'),{type:'doughnut',data:{labels:['object','meta','frame'],datasets:[
+    {data:#{js(levels_chart[:data])},backgroundColor:['#{PALETTE[2]}','#{PALETTE[1]}','#{PALETTE[3]}']}]},
+    options:{responsive:true,plugins:{title:{display:true,text:#{js(UI[:t_levels])}}}}});
+JS
+charts << <<~JS if l1_chart
+  new Chart(document.getElementById('c_l1'),{type:'bar',data:{labels:#{js(l1_chart[:tasks])},datasets:#{js(l1_chart[:series].each_with_index.map { |s, idx| { label: s[:label], data: s[:data], backgroundColor: PALETTE[idx % PALETTE.size] } })}},
+    options:{responsive:true,scales:{y:{beginAtZero:true,max:10}},plugins:{title:{display:true,text:#{js(UI[:t_l1])}}}}});
+JS
+
+canvas = ->(id) { "<div class=\"chart-card\"><canvas id=\"#{id}\"></canvas></div>" }
+figs = []
+figs << canvas.call("c_standing") if standing_data
+figs << canvas.call("c_meta")     if mr_data
+figs << canvas.call("c_nomic")    if nomic_chart
+figs << canvas.call("c_levels")   if levels_chart
+figs << canvas.call("c_l1")       if l1_chart
+
+html = <<~HTML
+  <!DOCTYPE html>
+  <html lang="#{lang}"><head><meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>#{UI[:title]}</title>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js@4"></script>
+  <style>
+    :root{--bg:#fafafa;--fg:#1d1d1f;--muted:#6e6e73;--line:#e0e0e0;--accent:#4e79a7;}
+    *{box-sizing:border-box;}
+    body{font-family:-apple-system,"Helvetica Neue","Hiragino Sans",system-ui,sans-serif;color:var(--fg);background:var(--bg);margin:0;line-height:1.65;}
+    main{max-width:1080px;margin:0 auto;padding:2rem 1.5rem 5rem;}
+    h1{font-size:1.9rem;border-bottom:3px solid var(--accent);padding-bottom:.4rem;}
+    h2{font-size:1.4rem;margin-top:2.4rem;border-bottom:1px solid var(--line);padding-bottom:.3rem;}
+    h3{font-size:1.1rem;margin-top:1.6rem;color:#333;}
+    code{background:#eee;padding:.1em .35em;border-radius:4px;font-size:.9em;}
+    hr{border:none;border-top:1px solid var(--line);margin:2rem 0;}
+    .tbl-wrap{overflow-x:auto;margin:1rem 0;}
+    table{border-collapse:collapse;width:100%;font-size:.92rem;background:#fff;}
+    th,td{border:1px solid var(--line);padding:.45rem .6rem;text-align:right;}
+    th[scope="row"],thead th:first-child{text-align:left;}
+    thead th{background:#f0f3f7;position:sticky;top:0;}
+    tbody tr:nth-child(even){background:#f7f9fb;}
+    .dashboard{display:grid;grid-template-columns:repeat(auto-fit,minmax(440px,1fr));gap:1.2rem;margin:1.5rem 0;}
+    .chart-card{background:#fff;border:1px solid var(--line);border-radius:10px;padding:1rem;box-shadow:0 1px 3px rgba(0,0,0,.05);}
+    .lead{color:var(--muted);font-size:.95rem;} .nojs{color:#a00;font-size:.85rem;}
+    blockquote{margin:.8rem 0;padding:.7rem 1rem;background:#eef3f9;border-left:4px solid var(--accent);border-radius:4px;font-size:.93rem;color:#33415c;}
+    blockquote p{margin:.2rem 0;}
+  </style></head>
+  <body><main>
+  <h1>#{UI[:title]}</h1>
+  <p class="lead">#{UI[:lead]}</p>
+  <h2>#{UI[:figs]}</h2>
+  <p class="nojs">#{UI[:nojs]}</p>
+  <div class="dashboard">
+  #{figs.join("\n")}
+  </div>
+  #{body_html}
+  </main>
+  <script>
+  document.addEventListener('DOMContentLoaded',function(){if(typeof Chart==='undefined')return;
+  #{charts.join("\n")}
+  });
+  </script>
+  </body></html>
+HTML
+
+File.write(out_path, html)
+puts "=== #{lang.upcase} HTML written: #{out_path} (#{html.bytesize} bytes, #{figs.size} figures) ==="

data/templates/knowledge/llm_cross_evaluation/scripts/html_report_to_pdf.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+HTML report -> PDF (long document, not slides).
+
+Renders a scrolling report (with Chart.js figures loaded from CDN) to PDF using
+Playwright/Chromium, so JavaScript runs and the canvas figures appear. A4 portrait,
+backgrounds on, waits for network idle + a beat for chart animation.
+
+Usage:
+    python html_report_to_pdf.py <input.html> [output.pdf]
+
+Requirements:
+    pip install playwright
+    playwright install chromium
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+try:
+    from playwright.async_api import async_playwright
+except ImportError:
+    print("Error: Playwright not installed. Run: pip install playwright && playwright install chromium")
+    sys.exit(1)
+
+
+async def convert(input_html: str, output_pdf: str):
+    input_path = Path(input_html).resolve()
+    output_path = Path(output_pdf).resolve()
+    if not input_path.exists():
+        print(f"Error: input not found: {input_path}")
+        sys.exit(1)
+
+    print(f"Input:  {input_path}\nOutput: {output_path}")
+    async with async_playwright() as p:
+        browser = await p.chromium.launch()
+        page = await browser.new_page(viewport={"width": 1100, "height": 1400})
+        await page.goto(f"file://{input_path}", wait_until="networkidle")
+        # Chart.js renders on DOMContentLoaded; give animations a beat to settle.
+        await page.wait_for_timeout(2500)
+        await page.emulate_media(media="screen")  # keep the on-screen styling
+        await page.pdf(
+            path=str(output_path),
+            format="A4",
+            print_background=True,
+            margin={"top": "12mm", "right": "10mm", "bottom": "12mm", "left": "10mm"},
+            prefer_css_page_size=False,
+        )
+        await browser.close()
+    print(f"PDF created: {output_path} ({output_path.stat().st_size / 1024:.1f} KB)")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("usage: python html_report_to_pdf.py <input.html> [output.pdf]")
+        sys.exit(1)
+    inp = sys.argv[1]
+    out = sys.argv[2] if len(sys.argv) >= 3 else str(Path(inp).with_suffix(".pdf"))
+    asyncio.run(convert(inp, out))
+
+
+if __name__ == "__main__":
+    main()