kairos-chain 2.7.0 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffb5f6c69245852c1c1f9991cac0098bf630f460a35bc72d5cda24eef290218f
-  data.tar.gz: 60a22caeaf0abcd7433a9f518aac3b4553d48f395f5e8ea70dca69fff3c735f5
+  metadata.gz: 00c55f8f91953d2e57924bdc4748c756c3dce18b64a77e8ff17ebed825f506ce
+  data.tar.gz: d4f1a418e9fbeecde4a5a8f9eecc37116b9620b625af0a2e91f09445fd60c673
 SHA512:
-  metadata.gz: 6121a1dded568c8035a6c4a89c2aaded921d42559b7ae491c898a0648dffa52bc66f784fc08d9de04b8304db2c303a75727fb8b90a28e35007455055a8cfaf68
-  data.tar.gz: '0892de4a22da8c86df601b1b6c4523207adee72988eeb3d982ddeae625181fa04ac7322b4d698d18c8b76684e5693931c2cacf4950933b61f808ead59937a6e0'
+  metadata.gz: 96fc0ef27dcab7f578021254b8e0356644d958fb2da8a61eff02ba9862f02e4542bde04750173edeef0029a34d3a042d308217c17aa98182ebeed134f49a7337
+  data.tar.gz: 0dcbbf48a3c2d1fc6226101b204b1aa7a9f5b0f24e5f1172f29caffd3237195b611aad3684f79034c6528596e5aafa90d0e6750b347b9d5d2e7c419596418747

data/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [2.8.0] - 2026-03-08
+
+### Added
+
+- **Knowledge Creator SkillSet** (`knowledge_creator` v1.0.0): New opt-in SkillSet for evaluating and improving L1 knowledge quality through structured Persona Assembly prompts.
+  - `kc_evaluate`: Generate quality evaluation prompts (evaluate/analyze/criteria commands) with 7 evidence-based dimensions, 3-tier readiness assessment (READY/REVISE/DRAFT), and configurable personas (evaluator, guardian, pragmatic)
+  - `kc_compare`: Generate blind A/B comparison prompts for knowledge version comparison (L1 vs L1, L2 vs L1 promotion readiness)
+  - Bundled L1 knowledge: `quality_criteria` (evaluation dimensions, evidence requirements, persona definitions), `creation_guide` (Kairotic Creation Loop workflow, 6 structural patterns)
+  - SkillSet-local persona definitions (does not modify shared `persona_definitions`)
+  - L2 save instruction for evaluation history tracking
+
+- **SkillSet Creator SkillSet** (`skillset_creator` v1.0.0): New opt-in meta-SkillSet for developing KairosChain SkillSets with the 5-phase development workflow.
+  - `sc_design`: Core-vs-SkillSet decision analysis (loads `core_or_skillset_guide` knowledge) and design phase checklist
+  - `sc_scaffold`: Generate complete SkillSet directory structures with skeleton files (preview/generate), input validation (path traversal prevention, collision check), explicit `output_path` required
+  - `sc_review`: Generate structured review prompts for multi-LLM review or Persona Assembly review of SkillSet designs and implementations
+  - Bundled L1 knowledge: `development_guide` (5-phase workflow, review escalation, multi-LLM best practices), `core_or_skillset_guide` (Core vs SkillSet decision tree)
+  - Runtime-detected integration with Knowledge Creator (no declared dependency; uses `defined?` check)
+
+- **Design Process**: Both SkillSets designed through the 5-phase development meta-pattern with 2 rounds of multi-LLM review (Antigravity/Gemini, Claude Team/Opus 4.6, Codex/GPT-5.4). Design documents in `log/`.
+
+---
+
 ## [2.7.0] - 2026-03-06
 
 ### Added
@@ -349,6 +371,7 @@ This project follows [Semantic Versioning](https://semver.org/).
 - Skill promotion with Persona Assembly
 - Tool guide and metadata system
 
+[2.8.0]: https://github.com/masaomi/KairosChain_2026/compare/v2.7.0...v2.8.0
 [2.7.0]: https://github.com/masaomi/KairosChain_2026/compare/v2.6.0...v2.7.0
 [2.6.0]: https://github.com/masaomi/KairosChain_2026/compare/v2.5.0...v2.6.0
 [2.5.0]: https://github.com/masaomi/KairosChain_2026/compare/v2.4.0...v2.5.0

data/lib/kairos_mcp/version.rb

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

data/templates/skillsets/knowledge_creator/config/knowledge_creator.yml

@@ -0,0 +1,11 @@
+knowledge_creator:
+  default_evaluate_personas:
+    - evaluator
+    - guardian
+    - pragmatic
+  default_compare_personas:
+    - kairos
+    - pragmatic
+    - skeptic
+  default_assembly_mode: oneshot
+  evaluation_context_prefix: "kc_eval_"

data/templates/skillsets/knowledge_creator/knowledge/creation_guide/creation_guide.md

@@ -0,0 +1,101 @@
+---
+name: creation_guide
+description: >
+  Guide for creating and structuring L1 knowledge in KairosChain.
+  Includes the Kairotic Creation Loop workflow and 6 structural patterns
+  extracted from practical skill analysis. Use when creating new L1 knowledge,
+  restructuring existing knowledge, or analyzing structural patterns.
+  NOT for SkillSet architecture decisions (use core_or_skillset_guide).
+version: "1.0"
+layer: L1
+tags: [meta, creation, workflow, patterns, structure, knowledge]
+---
+
+# L1 Knowledge Creation Guide
+
+## Kairotic Creation Loop
+
+Six phases for creating L1 knowledge. The LLM navigates these naturally in conversation; this is a reference, not a rigid procedure.
+
+| Phase | Action | Key Question |
+|-------|--------|-------------|
+| **RECOGNIZE** | Identify repeating pattern across sessions | Has this come up 3+ times? |
+| **DISTILL** | Extract the reusable core from session context | What's universal vs. session-specific? |
+| **STRUCTURE** | Choose appropriate structural pattern (see below) | What format best serves this content? |
+| **COMPOSE** | Write with proper frontmatter and body | Does description include What + When + NOT? |
+| **EVALUATE** | Apply quality_criteria via kc_evaluate | READY / REVISE / DRAFT? |
+| **ITERATE** | Fix issues and re-evaluate | Are all critical dimensions PASS? |
+
+## 6 Structural Patterns
+
+### 1. Quick Reference Table
+**When**: Any knowledge that maps inputs to outputs or actions to approaches.
+Always place at the top of the document.
+
+```markdown
+| Task | Approach | Notes |
+|------|----------|-------|
+| New MCP tool | SkillSet tool_classes | BaseTool inheritance |
+| New layer concept | Core change | Rare; requires L0 review |
+```
+
+### 2. Deterministic Workflow
+**When**: Multi-step ordered procedures where sequence matters.
+
+```markdown
+## Workflow
+1. Check prerequisites → verify X exists
+2. Execute action → run Y with parameters
+3. Validate result → confirm Z matches expected
+```
+
+### 3. Critical Rules / Pitfalls
+**When**: Domain-specific gotchas that cause repeated errors.
+
+```markdown
+## Critical Rules
+- **NEVER** do X because Y (evidence: Z happened when this was violated)
+- **ALWAYS** check A before B (reason: C depends on A being initialized)
+```
+
+### 4. Multi-Tool Selection
+**When**: Multiple valid approaches exist for the same goal.
+
+```markdown
+| Tool | Best For | Limitation |
+|------|----------|------------|
+| Tool A | Simple cases | Doesn't handle edge case X |
+| Tool B | Complex cases | Slower, requires config Y |
+```
+
+### 5. QA-First Verification
+**When**: Output quality matters and errors are costly. Assume problems exist.
+
+```markdown
+## Verification Checklist
+- [ ] Output matches expected format
+- [ ] No placeholder values remain (search for TODO, FIXME)
+- [ ] Edge cases tested: empty input, large input, special characters
+```
+
+### 6. Session Distillation (L2→L1)
+**When**: Promoting session-specific work to reusable knowledge.
+
+```markdown
+## Distillation Steps
+1. Remove all session-specific references (dates, filenames, user names)
+2. Generalize the procedure: replace specific instances with patterns
+3. Add frontmatter with description that answers: What + When + NOT
+4. Evaluate with kc_evaluate
+```
+
+## Pattern Selection Guide
+
+| Content Type | Primary Pattern | Secondary Pattern |
+|-------------|-----------------|-------------------|
+| Decision guide | Quick Reference Table | Critical Rules |
+| Step-by-step procedure | Deterministic Workflow | QA-First |
+| Tool/approach comparison | Multi-Tool Selection | Quick Reference Table |
+| Domain-specific warnings | Critical Rules | Quick Reference Table |
+| Reusable from session | Session Distillation | (varies by content) |
+| Mixed reference | Quick Reference Table | Deterministic Workflow |

data/templates/skillsets/knowledge_creator/knowledge/quality_criteria/quality_criteria.md

@@ -0,0 +1,76 @@
+---
+name: quality_criteria
+description: >
+  Evidence-based quality evaluation criteria for KairosChain L1 knowledge.
+  Defines evaluation dimensions, PASS/FAIL standards, readiness levels
+  (READY/REVISE/DRAFT), and evaluation persona definitions.
+  Used by kc_evaluate tool. NOT for evaluating code or SkillSet architecture.
+version: "1.0"
+layer: L1
+tags: [meta, quality, evaluation, criteria, personas]
+---
+
+# L1 Knowledge Quality Criteria
+
+## Quick Reference
+
+| Dimension | Question | PASS requires |
+|-----------|----------|---------------|
+| Triggering quality | Does `description` enable accurate identification? | What + When + Negative scope in description |
+| Self-containedness | No session-specific context leaks? | No references to "this session", "today", specific dates |
+| Progressive disclosure | Body vs references/ balance? | Core info in body; details in subdirectories |
+| Evidence | Claims factual and verifiable? | Concrete examples, not vague assertions |
+| Discrimination | Provides info base LLM doesn't have? | KairosChain-specific knowledge the model wouldn't know |
+| Redundancy | Overlap with existing L1? | Minimal overlap; unique perspective or content |
+| Safety alignment | No L0 conflicts? | No contradiction with CLAUDE.md principles |
+
+## Readiness Levels
+
+| Level | Criteria | Action |
+|-------|----------|--------|
+| **READY** | All critical dimensions PASS; no session-specific leaks; description enables accurate triggering | Promote to L1 |
+| **REVISE** | Most dimensions PASS but 1-2 specific issues identified; fixable without redesign | Fix identified issues, re-evaluate |
+| **DRAFT** | Multiple FAILs or fundamental issues; needs significant rework | Return to L2 for further development |
+
+## Evidence Requirements
+
+- PASS requires citing **specific evidence** from the knowledge content
+- Surface-level compliance is FAIL (e.g., frontmatter exists but description is vague)
+- Burden of proof is on the assertion: "it looks fine" is not evidence
+- Each evaluation dimension must include a quoted passage or specific observation
+
+## Evaluation Personas
+
+### evaluator
+- **Role**: Knowledge Quality Inspector
+- **Bias**: High bar for evidence; superficial compliance is failure
+- **Focus**: Can I cite specific evidence for each criterion?
+- **When useful**: Primary evaluation of any L1 knowledge
+
+### guardian
+- **Role**: L0/L1 Boundary Guardian
+- **Bias**: Conservative; protect layer integrity
+- **Focus**: Does this knowledge stay within its declared layer? Could it conflict with L0 meta-rules?
+- **When useful**: Knowledge that touches system behavior, governance, or meta-level concerns
+
+### pragmatic
+- **Role**: Practical Value Assessor
+- **Bias**: Real-world utility over theoretical purity
+- **Focus**: Will an LLM actually use this knowledge effectively in a real session?
+- **When useful**: All evaluations; counterbalance to overly strict evaluation
+
+## Frontmatter Design Guidelines
+
+### description field
+- Format: **What** this knowledge contains + **When** to use it + **Negative scope** (what it's NOT for)
+- Good: "Decision guide for Core vs SkillSet classification. Use when starting new KairosChain feature development. NOT for non-KairosChain projects."
+- Bad: "A guide about SkillSets"
+
+### tags field
+- 5-7 tags maximum
+- Structure: domain tags + function tags + meta tags
+- Example: `[meta, guide, architecture, decision, skillset, core]`
+
+### version field
+- Semver string: "1.0", "0.1", etc.
+- Increment on substantive content changes, not formatting fixes

data/templates/skillsets/knowledge_creator/lib/knowledge_creator/assembly_templates.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module KnowledgeCreator
+  # Generates structured Persona Assembly prompts for knowledge evaluation.
+  # These templates guide the LLM to perform multi-perspective evaluation;
+  # the tool itself does NOT execute evaluation autonomously.
+  module AssemblyTemplates
+    module_function
+
+    EVALUATION_PERSONAS = {
+      'evaluator' => {
+        role: 'Knowledge Quality Inspector',
+        bias: 'High bar for evidence; superficial compliance is failure',
+        focus: 'Can I cite specific evidence for each criterion?'
+      },
+      'guardian' => {
+        role: 'L0/L1 Boundary Guardian',
+        bias: 'Conservative; protect layer integrity',
+        focus: 'Does this knowledge stay within its declared layer?'
+      },
+      'pragmatic' => {
+        role: 'Practical Value Assessor',
+        bias: 'Real-world utility over theoretical purity',
+        focus: 'Will an LLM actually use this knowledge effectively?'
+      }
+    }.freeze
+
+    COMPARE_PERSONAS = {
+      'kairos' => {
+        role: 'Philosophy Alignment Reviewer',
+        bias: 'Self-referential consistency',
+        focus: 'Which version better serves KairosChain principles?'
+      },
+      'pragmatic' => {
+        role: 'Practical Value Assessor',
+        bias: 'Real-world utility',
+        focus: 'Which version is more actionable?'
+      },
+      'skeptic' => {
+        role: 'Critical Analyst',
+        bias: 'Doubt first; prove value',
+        focus: 'Which version has fewer weaknesses?'
+      }
+    }.freeze
+
+    EVALUATION_DIMENSIONS = [
+      { name: 'Triggering quality', question: 'Does `description` enable accurate identification from knowledge_list?' },
+      { name: 'Self-containedness', question: 'No session-specific context leaks?' },
+      { name: 'Progressive disclosure', question: 'Body vs references/ balance appropriate?' },
+      { name: 'Evidence', question: 'Are claims factual and verifiable?' },
+      { name: 'Discrimination', question: 'Does this provide information the base LLM does not have?' },
+      { name: 'Redundancy', question: 'Overlap with existing L1 knowledge?' },
+      { name: 'Safety alignment', question: 'No L0 conflicts?' }
+    ].freeze
+
+    def evaluation_prompt(target_name:, target_content:, personas: nil, mode: 'oneshot')
+      persona_names = personas || %w[evaluator guardian pragmatic]
+      persona_defs = persona_names.map { |p| EVALUATION_PERSONAS[p] || { role: p, bias: 'General', focus: 'Overall quality' } }
+
+      <<~PROMPT
+        ## Persona Assembly: Knowledge Quality Evaluation
+
+        ### Mode: #{mode}
+
+        ### Target Knowledge: #{target_name}
+
+        ### Evaluation Task
+        Evaluate the following L1 knowledge from multiple perspectives.
+        For each dimension, cite specific evidence from the content.
+        PASS requires citing specific evidence. Surface-level compliance is FAIL.
+
+        ### Personas
+        #{persona_names.each_with_index.map { |name, i|
+          d = persona_defs[i]
+          "- **#{name}** (#{d[:role]}): Bias: #{d[:bias]}. Focus: #{d[:focus]}"
+        }.join("\n")}
+
+        ### Knowledge Content
+        ```
+        #{target_content}
+        ```
+
+        ### Evaluation Dimensions
+        #{EVALUATION_DIMENSIONS.each_with_index.map { |dim, i|
+          "#{i + 1}. **#{dim[:name]}** — #{dim[:question]}"
+        }.join("\n")}
+
+        ### Output Format
+
+        #### Readiness Assessment
+        **Level**: READY / REVISE / DRAFT
+
+        | Level | Meaning |
+        |-------|---------|
+        | READY | Meets L1 quality standards; safe to promote |
+        | REVISE | Has potential but specific issues need fixing |
+        | DRAFT | Not yet stable enough for L1 |
+
+        #### Per-Persona Evaluation
+        For each persona, for each dimension:
+        - **{Dimension}**: PASS/FAIL — Evidence: "quoted text or specific observation"
+
+        #### Summary Table
+        | Criterion | Pass Count | Fail Count |
+        |-----------|-----------|-----------|
+
+        #### Improvement Suggestions
+        Numbered list of specific, actionable improvements.
+      PROMPT
+    end
+
+    def analysis_prompt(target_name:, target_content:, creation_guide_content: nil)
+      <<~PROMPT
+        ## Structural Pattern Analysis: #{target_name}
+
+        ### Task
+        Analyze the structural patterns used in this knowledge and suggest improvements
+        based on the KairosChain creation guide patterns.
+
+        ### Knowledge Content
+        ```
+        #{target_content}
+        ```
+
+        #{creation_guide_content ? "### Reference: Creation Guide Patterns\n```\n#{creation_guide_content}\n```" : ''}
+
+        ### Analysis Dimensions
+        1. Which structural pattern(s) does this knowledge use? (Quick Reference Table, Deterministic Workflow, Critical Rules, Multi-Tool Selection, QA-First, Session Distillation)
+        2. Is the chosen pattern appropriate for the content type?
+        3. What structural improvements would increase utility?
+        4. Is the frontmatter (description, tags) well-designed?
+
+        ### Output Format
+        - **Current patterns**: List detected patterns
+        - **Pattern fit**: GOOD / IMPROVABLE / MISMATCH
+        - **Suggestions**: Specific structural changes with examples
+      PROMPT
+    end
+
+    def comparison_prompt(version_a_content:, version_b_content:, blind: true, personas: nil)
+      persona_names = personas || %w[kairos pragmatic skeptic]
+      persona_defs = persona_names.map { |p| COMPARE_PERSONAS[p] || { role: p, bias: 'General', focus: 'Overall quality' } }
+
+      label_a = blind ? 'Version A' : 'Version A (current)'
+      label_b = blind ? 'Version B' : 'Version B (candidate)'
+
+      <<~PROMPT
+        ## Persona Assembly: Knowledge Version Comparison
+
+        ### Task
+        Compare two versions of knowledge. #{blind ? 'Labels are anonymized.' : ''}
+        Evaluate which version better serves KairosChain L1 quality standards.
+
+        ### Personas
+        #{persona_names.each_with_index.map { |name, i|
+          d = persona_defs[i]
+          "- **#{name}** (#{d[:role]}): #{d[:focus]}"
+        }.join("\n")}
+
+        ### #{label_a}
+        ```
+        #{version_a_content}
+        ```
+
+        ### #{label_b}
+        ```
+        #{version_b_content}
+        ```
+
+        ### Comparison Dimensions
+        #{EVALUATION_DIMENSIONS.map { |dim| "- **#{dim[:name]}**: #{dim[:question]}" }.join("\n")}
+
+        ### Output Format
+        Per persona:
+        - **Preferred version**: A / B / Equivalent
+        - **Key differences**: 2-3 specific observations with evidence
+        - **Recommendation**: Specific action (keep A, adopt B, merge specific sections)
+
+        #### Final Recommendation
+        Majority vote with rationale.
+      PROMPT
+    end
+  end
+end

data/templates/skillsets/knowledge_creator/lib/knowledge_creator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'knowledge_creator/assembly_templates'
+
+module KnowledgeCreator
+  SKILLSET_ROOT = File.expand_path('..', __dir__)
+  KNOWLEDGE_DIR = File.join(SKILLSET_ROOT, 'knowledge')
+  VERSION = '1.0.0'
+
+  class << self
+    def load!(config: {})
+      @config = config
+      @loaded = true
+    end
+
+    def loaded?
+      @loaded == true
+    end
+
+    def unload!
+      @config = nil
+      @loaded = false
+    end
+
+    # Build a KnowledgeProvider that includes bundled knowledge.
+    # Each tool calls this to access SkillSet-local knowledge.
+    def provider(user_context: nil)
+      provider = KairosMcp::KnowledgeProvider.new(nil, user_context: user_context)
+      provider.add_external_dir(
+        KNOWLEDGE_DIR,
+        source: 'skillset:knowledge_creator',
+        layer: :L1,
+        index: true
+      )
+      provider
+    end
+
+    def skillset_config
+      @skillset_config ||= begin
+        config_path = File.join(SKILLSET_ROOT, 'config', 'knowledge_creator.yml')
+        if File.exist?(config_path)
+          YAML.safe_load(File.read(config_path, encoding: 'UTF-8'))&.dig('knowledge_creator') || {}
+        else
+          {}
+        end
+      end
+    end
+  end
+
+  load! unless loaded?
+end

data/templates/skillsets/knowledge_creator/skillset.json

@@ -0,0 +1,24 @@
+{
+  "name": "knowledge_creator",
+  "version": "1.0.0",
+  "description": "SkillSet for evaluating and improving L1 knowledge quality. Generates structured evaluation prompts using Persona Assembly, and provides blind version comparison. Use when assessing L1 knowledge quality, comparing knowledge versions, or checking promotion readiness from L2 to L1.",
+  "author": "Dr. Masa Hatakeyama",
+  "layer": "L1",
+  "depends_on": [],
+  "provides": [
+    "knowledge_quality_evaluation",
+    "knowledge_version_comparison",
+    "quality_criteria",
+    "creation_patterns"
+  ],
+  "tool_classes": [
+    "KairosMcp::SkillSets::KnowledgeCreator::Tools::KcEvaluate",
+    "KairosMcp::SkillSets::KnowledgeCreator::Tools::KcCompare"
+  ],
+  "config_files": ["config/knowledge_creator.yml"],
+  "knowledge_dirs": [
+    "knowledge/quality_criteria",
+    "knowledge/creation_guide"
+  ],
+  "min_core_version": "2.7.0"
+}

data/templates/skillsets/knowledge_creator/tools/kc_compare.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module KairosMcp
+  module SkillSets
+    module KnowledgeCreator
+      module Tools
+        class KcCompare < KairosMcp::Tools::BaseTool
+          def name
+            'kc_compare'
+          end
+
+          def description
+            'Generate a Persona Assembly prompt for blind A/B comparison of two knowledge versions. ' \
+              'Use for L2→L1 promotion readiness, L1 revision comparison, or duplicate merge decisions. ' \
+              'This tool generates comparison prompts — it does NOT execute comparison autonomously.'
+          end
+
+          def input_schema
+            {
+              type: 'object',
+              properties: {
+                command: {
+                  type: 'string',
+                  enum: %w[compare],
+                  description: 'compare: generate blind comparison prompt'
+                },
+                version_a_name: { type: 'string', description: 'Name of version A knowledge' },
+                version_a_layer: { type: 'string', enum: %w[L1 L2], description: 'Layer of version A' },
+                version_a_session_id: { type: 'string', description: 'Session ID (required if version_a_layer is L2)' },
+                version_b_name: { type: 'string', description: 'Name of version B knowledge' },
+                version_b_layer: { type: 'string', enum: %w[L1 L2], description: 'Layer of version B' },
+                version_b_session_id: { type: 'string', description: 'Session ID (required if version_b_layer is L2)' },
+                blind: {
+                  type: 'boolean',
+                  description: 'Anonymize as Version A / Version B (default: true)'
+                },
+                personas: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description: 'Persona names (default: kairos, pragmatic, skeptic)'
+                }
+              },
+              required: %w[command version_a_name version_a_layer version_b_name version_b_layer]
+            }
+          end
+
+          def category
+            :meta
+          end
+
+          def usecase_tags
+            %w[knowledge comparison version promotion meta]
+          end
+
+          def related_tools
+            %w[kc_evaluate knowledge_get context_save]
+          end
+
+          def call(arguments)
+            return text_content(JSON.pretty_generate({ error: 'Only compare command is supported' })) unless arguments['command'] == 'compare'
+
+            version_a = load_version(
+              arguments['version_a_name'],
+              arguments['version_a_layer'],
+              arguments['version_a_session_id']
+            )
+            return text_content("Version A '#{arguments['version_a_name']}' not found in #{arguments['version_a_layer']}.") unless version_a
+
+            version_b = load_version(
+              arguments['version_b_name'],
+              arguments['version_b_layer'],
+              arguments['version_b_session_id']
+            )
+            return text_content("Version B '#{arguments['version_b_name']}' not found in #{arguments['version_b_layer']}.") unless version_b
+
+            blind = arguments.fetch('blind', true)
+            personas = arguments['personas']
+
+            prompt = ::KnowledgeCreator::AssemblyTemplates.comparison_prompt(
+              version_a_content: version_a[:content],
+              version_b_content: version_b[:content],
+              blind: blind,
+              personas: personas
+            )
+
+            text_content(prompt)
+          rescue StandardError => e
+            text_content(JSON.pretty_generate({ error: e.message, backtrace: e.backtrace&.first(3) }))
+          end
+
+          private
+
+          def load_version(name, layer, session_id = nil)
+            case layer
+            when 'L1'
+              load_l1(name)
+            when 'L2'
+              load_l2(name, session_id)
+            end
+          end
+
+          def load_l1(name)
+            provider = ::KnowledgeCreator.provider(user_context: @safety&.current_user)
+            skill = provider.get(name)
+            return nil unless skill
+
+            content = if skill.respond_to?(:md_file_path) && File.exist?(skill.md_file_path)
+                        File.read(skill.md_file_path, encoding: 'UTF-8')
+                      elsif skill.respond_to?(:content)
+                        skill.content
+                      else
+                        skill.to_s
+                      end
+
+            { name: name, layer: 'L1', content: content }
+          end
+
+          def load_l2(name, session_id)
+            return nil unless defined?(KairosMcp::ContextManager)
+
+            cm = KairosMcp::ContextManager.new(nil, user_context: @safety&.current_user)
+            ctx = if session_id
+                    cm.load_context(session_id: session_id, name: name)
+                  else
+                    cm.find_context(name: name)
+                  end
+            return nil unless ctx
+
+            content = ctx.respond_to?(:content) ? ctx.content : ctx.to_s
+            { name: name, layer: 'L2', content: content }
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end