kairos-chain 3.4.1 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d768f68be9bfcc4c365d337abe42eb6b34cb180da8edfc01d839ad48449484b
-  data.tar.gz: 45b150ceea4779e8999db1234d5085f032d10a4ae2c312e23bd43f1f6b5b702a
+  metadata.gz: 330c7ed792c82c5484002e3d4c34eadee17b12a3dff89b4740bf331f49973565
+  data.tar.gz: eaec92628e858a914b10863221c3463e05767e7e01dfaaf5fe430ff667a4c04a
 SHA512:
-  metadata.gz: 44a1f1d1d1783ba2ef2c25c4cde5955857e4d2115b6a5c8bdecb8eae1495736df24a63772a7d728edb873600f9d60ebe7eef57abc302a6322a3c171d4a6258b0
-  data.tar.gz: ac8f3759a9c2fa72465d4b65198ebccd2a8759b6812581f45271c2436aa36e27958ac7fd922d0d96b349452fedea6a2f4a1cf00aa1c3737520825eabfd7f406c
+  metadata.gz: d55b480528d2a810bf254948ea867f888e6c426e370fff6ec069f146479fbd2e80908b7ea0f2349f713f76763fca34d108eadd5f3592eb51c91125f36466c9bc
+  data.tar.gz: 72d9eeb8df3c7185d6ad411e4bc77305b74d29002c2022e529fcab0de52fd6706c4048f508039c9b94ebff3db96aa6eeb30a69b736fedeb74e67e867ad4ed912

data/CHANGELOG.md

@@ -4,6 +4,40 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.5.0] - 2026-03-27
+
+### Added
+
+- **Trust Score v2 — Meeting Place-aware 2-layer trust model**: Client-side trust scoring
+  for Meeting Place skills and depositors. Core principle: Meeting Place provides facts,
+  trust computation is always a local cognitive act by the querying agent.
+  - **Skill Trust**: attestation quality (anti-collusion discounted), usage (remote-discounted),
+    freshness, provenance, depositor signature gate
+  - **Depositor Trust**: portfolio average skill trust (with shrinkage for small portfolios),
+    attestation breadth, attester diversity, activity level
+  - **Combined Score**: smooth linear interpolation (no discontinuity) — new skills lean on
+    depositor reputation, established skills stand on their own evidence
+  - **Anti-collusion**: self-attestation discount (0.15x), bootstrap gate, honest labeling
+    (`v2_simplified_bootstrap`), signature presence vs verification distinction
+  - **URI routing**: `meeting:<skill_id>`, `meeting_agent:<agent_id>`, legacy local refs
+  - **Input sanitization**: `SAFE_ID_PATTERN` regex for skill_id/agent_id
+  - **Portfolio truncation warning**: when browse limit (50) may have truncated depositor data
+  - **YAML-driven weights**: all weights, claim weights, thresholds configurable via `trust_v2:`
+    section in `synoptis.yml`
+  - **Graceful degradation**: returns `source: "unavailable"` when not connected
+  - New file: `synoptis/lib/synoptis/meeting_trust_adapter.rb` (HTTP data fetching + TTL cache)
+  - Design: 2-round multi-LLM review (R1 with Persona Assembly: 3 P0 found and fixed)
+  - Implementation: 2-round multi-LLM review (R1: 3 P1 + 4 P2; R2: converged)
+
+- **Multi-LLM Design Review v2.2**: Persona Assembly integration — orchestrator auto-decides
+  whether to use Persona Assembly for Claude Agent Team based on complexity tier:
+  - Tier 1-2 / knowledge review: single perspective (default)
+  - Tier 3 / safety-critical: Persona Assembly (4+ personas)
+  - R2+ verification passes: single perspective
+  - Assembly findings weighted as single reviewer in consensus analysis
+
+---
+
 ## [3.4.1] - 2026-03-24
 
 ### Fixed

data/lib/kairos_mcp/version.rb

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

data/templates/knowledge/multi_llm_design_review/multi_llm_design_review.md

@@ -1,7 +1,7 @@
 ---
 description: Multi-LLM design review methodology with automated and manual execution modes
 tags: [methodology, multi-llm, design-review, automation, quality-assurance, experiment]
-version: "2.1"
+version: "2.2"
 ---
 
 # Multi-LLM Design Review Methodology
@@ -333,6 +333,37 @@ reduce post-implementation review/debug cycles.
 - Single-LLM integration (Opus 4.6) of all findings into next version worked well
 - Agent team review (4-persona + Persona Assembly) for internal Claude rounds
 
+### Persona Assembly Integration (Optional)
+
+When the Claude Agent Team is one of the reviewers, the orchestrator MAY enhance
+its review with Persona Assembly instead of a single-perspective review. The
+orchestrator decides automatically based on review complexity:
+
+| Complexity | Claude Agent Team Mode | Rationale |
+|-----------|----------------------|-----------|
+| Tier 1-2 (simple feature, single file) | Single perspective (default) | Overhead of assembly not justified |
+| Tier 3 (architectural, cross-component) | Persona Assembly (4+ personas) | Multiple viewpoints catch more seam issues |
+| Safety-critical (auth, billing, access control) | Persona Assembly + dedicated safety persona | Safety requires adversarial thinking |
+| Knowledge/methodology review | Single perspective | Content review benefits more from LLM diversity than persona diversity |
+
+**How the orchestrator decides:**
+1. At review prompt generation time, assess the artifact's complexity tier
+2. If Tier 3+ or safety-critical: instruct the Claude Agent Team to use Persona
+   Assembly with personas appropriate to the domain (e.g., kairos + conservative +
+   pragmatic + skeptic for design; kairos + guardian + pragmatic for safety)
+3. If Tier 1-2 or knowledge review: use single-perspective Claude Agent Team review
+4. Record the decision in the review prompt header: `Assembly: yes/no (reason)`
+
+**When NOT to use Persona Assembly in Multi-LLM review:**
+- When all 3 external LLMs already provide sufficient viewpoint diversity
+- When speed is more important than depth (e.g., quick sanity check between rounds)
+- When the review is a verification pass (R2+) rather than initial discovery (R1)
+
+This integration means a Tier 3 review can produce up to 6 perspectives: 4 from
+Claude Persona Assembly + 1 from Codex + 1 from Cursor. The orchestrator's
+consensus analysis weights assembly findings as a single reviewer (not 4 separate
+votes) to avoid over-representing the Claude perspective.
+
 ## Relation to multi_agent_design_workflow
 
 This skill is the detailed execution guide for **Step 5 (Multi-LLM Integration)**

data/templates/skillsets/synoptis/config/synoptis.yml

@@ -15,6 +15,38 @@ trust:
   min_trust_score: 0.0
   max_trust_score: 1.0
 
+trust_v2:
+  skill_weights:
+    attestation_quality: 0.50
+    usage: 0.20
+    freshness: 0.15
+    provenance: 0.15
+  depositor_weights:
+    avg_skill_trust: 0.40
+    attestation_breadth: 0.25
+    diversity: 0.25
+    activity: 0.10
+  combined:
+    combined_min_skill_weight: 0.35
+    combined_max_skill_weight: 0.70
+  anti_collusion:
+    self_attestation_weight: 0.15
+    scc_discount: 0.20
+    max_expected_attestations: 5
+  remote_signal_discount: 0.50
+  depositor_shrinkage_threshold: 3
+  cache_ttl: 300
+  recommendation_thresholds:
+    high_confidence: 0.70
+    moderate_confidence: 0.40
+    low_confidence: 0.20
+  claim_weights:
+    multi_llm_reviewed: 0.90
+    used_in_production: 0.85
+    quality_reviewed: 0.75
+    integrity_verified: 0.60
+    default: 0.50
+
 challenge:
   response_timeout: 3600      # 1 hour
   max_active_per_subject: 5

data/templates/skillsets/synoptis/lib/synoptis/meeting_trust_adapter.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Synoptis
+  # Fetches raw data from a connected Meeting Place and prepares it for
+  # TrustScorer v2 computation. All trust computation remains client-side;
+  # this adapter only handles data retrieval, signature verification, and caching.
+  #
+  # Core principle: Meeting Place provides facts; trust is a local cognitive act.
+  class MeetingTrustAdapter
+    DEFAULT_CACHE_TTL = 300 # 5 minutes
+
+    def initialize(place_client:, crypto: nil, config: {})
+      @client = place_client
+      @crypto = crypto
+      @cache = {}
+      @cache_ttl = config.fetch('cache_ttl', config.fetch(:cache_ttl, DEFAULT_CACHE_TTL))
+      @remote_signal_discount = config.fetch('remote_signal_discount',
+                                             config.fetch(:remote_signal_discount, 0.5))
+    end
+
+    attr_reader :remote_signal_discount
+
+    # Fetch skill data for trust scoring. Uses preview_skill for full attestation data.
+    # Returns nil if Meeting Place is not connected or skill not found.
+    def fetch_skill_data(skill_id, owner: nil)
+      cache_key = "skill:#{skill_id}:#{owner}"
+      cached = get_cache(cache_key)
+      return cached if cached
+
+      result = @client.preview_skill(skill_id: skill_id, owner: owner, first_lines: 0)
+      return nil unless result && !result[:error]
+
+      set_cache(cache_key, result)
+      result
+    rescue StandardError
+      nil
+    end
+
+    # Fetch all deposited skills (with attestations) visible on the Meeting Place.
+    # For depositor trust, we filter by owner_agent_id client-side.
+    def fetch_all_skills
+      cache_key = 'all_skills'
+      cached = get_cache(cache_key)
+      return cached if cached
+
+      result = @client.browse(type: 'deposited_skill', limit: 50)
+      return [] unless result
+
+      skills = result[:entries] || result[:skills] || []
+      set_cache(cache_key, skills)
+      skills
+    rescue StandardError
+      []
+    end
+
+    # Fetch skills for a specific depositor from cached browse results.
+    # Server uses :agent_id; meeting_browse tool maps to :owner_agent_id.
+    # We check both for compatibility.
+    def fetch_depositor_skills(agent_id)
+      all = fetch_all_skills
+      all.select { |s| owner_of(s) == agent_id }
+    end
+
+    # Extract owner agent ID from skill data, handling both server and tool formats.
+    def owner_of(skill_data)
+      skill_data[:owner_agent_id] || skill_data[:agent_id] || skill_data[:depositor_id]
+    end
+
+    # Verify an attestation signature client-side.
+    # Returns true if: no signature present (accepted with discount), or signature valid.
+    # Returns false only if signature is present but verification fails.
+    def verify_attestation_signature(attestation)
+      return true unless attestation[:has_signature]
+      return true unless @crypto # No crypto available — accept with discount
+
+      # Meeting Place browse only exposes has_signature (boolean),
+      # not the full signature material. For browse-derived attestations,
+      # we accept them with a discount applied at the scoring layer.
+      # Full verification requires preview_skill which includes signed_payload.
+      if attestation[:signature] && attestation[:signed_payload]
+        @crypto.verify_signature(
+          attestation[:signed_payload],
+          attestation[:signature],
+          attestation[:attester_public_key]
+        )
+      else
+        true # Browse-level: accept, scoring layer applies discount
+      end
+    rescue StandardError
+      false
+    end
+
+    # Check if the Meeting Place client is connected.
+    def connected?
+      return false unless @client
+
+      status = @client.session_status
+      status && (status[:connected] || status['connected'])
+    rescue StandardError
+      false
+    end
+
+    private
+
+    def get_cache(key)
+      entry = @cache[key]
+      return nil unless entry
+      return nil if Time.now - entry[:at] > @cache_ttl
+
+      entry[:data]
+    end
+
+    def set_cache(key, data)
+      @cache[key] = { data: data, at: Time.now }
+    end
+  end
+end

data/templates/skillsets/synoptis/lib/synoptis/trust_scorer.rb

@@ -321,5 +321,364 @@ module Synoptis
       @active_graph_cache = graph
       scores
     end
+
+    # =================================================================
+    # Meeting Place Trust (v2) — Client-side computation from raw facts
+    # =================================================================
+
+    public
+
+    MEETING_SKILL_WEIGHTS = {
+      attestation_quality: 0.50,
+      usage: 0.20,
+      freshness: 0.15,
+      provenance: 0.15
+    }.freeze
+
+    MEETING_DEPOSITOR_WEIGHTS = {
+      avg_skill_trust: 0.40,
+      attestation_breadth: 0.25,
+      diversity: 0.25,
+      activity: 0.10
+    }.freeze
+
+    CLAIM_WEIGHTS = {
+      'multi_llm_reviewed' => 0.90,
+      'used_in_production' => 0.85,
+      'quality_reviewed' => 0.75,
+      'integrity_verified' => 0.60
+    }.freeze
+    DEFAULT_CLAIM_WEIGHT = 0.50
+
+    MEETING_CONFIG_DEFAULTS = {
+      self_attestation_weight: 0.15,
+      scc_discount: 0.20,
+      max_expected_attestations: 5,
+      remote_signal_discount: 0.50,
+      depositor_shrinkage_threshold: 3,
+      combined_min_skill_weight: 0.35,
+      combined_max_skill_weight: 0.70
+    }.freeze
+
+    # Compute trust score for a skill on a connected Meeting Place.
+    # Input: skill_data hash from MeetingTrustAdapter (browse/preview response).
+    # Returns: { score:, details:, attestation_summary:, anti_collusion: }
+    def calculate_meeting_skill(skill_data, adapter: nil)
+      return empty_meeting_result('no_data') unless skill_data
+
+      attestations = skill_data[:attestations] || []
+      owner_id = skill_data[:owner_agent_id] || skill_data[:agent_id] || skill_data[:depositor_id]
+      config = meeting_config
+
+      # Attestation quality with anti-collusion
+      aq = meeting_attestation_quality(attestations, owner_id, config)
+
+      # Usage signal (discounted as unverifiable remote data)
+      raw_usage = [
+        (skill_data.dig(:trust_metadata, :exchange_count) || 0).to_f / 10.0,
+        1.0
+      ].min
+      usage = raw_usage * config[:remote_signal_discount]
+
+      # Freshness (180-day decay, floor at 0.2)
+      first_dep = skill_data.dig(:trust_metadata, :first_deposited)
+      freshness = if first_dep
+                    begin
+                      age_days = (Time.now.utc - Time.parse(first_dep.to_s)) / 86400.0
+                      [1.0 - (age_days / 180.0), 0.2].max
+                    rescue ArgumentError
+                      0.5
+                    end
+                  else
+                    0.5
+                  end
+
+      # Provenance (direct is best)
+      hop_count = skill_data.dig(:trust_metadata, :provenance, :hop_count) || 0
+      provenance = [1.0 - (hop_count * 0.2), 0.4].max
+
+      # Depositor signature gate
+      depositor_signed = skill_data.dig(:trust_notice, :depositor_signed) ? 1.0 : 0.5
+
+      w = skill_weights
+      raw = (aq[:score] * w[:attestation_quality] +
+             usage * w[:usage] +
+             freshness * w[:freshness] +
+             provenance * w[:provenance]) * depositor_signed
+
+      score = raw.clamp(0.0, 1.0)
+
+      {
+        score: score.round(4),
+        details: {
+          attestation_quality: aq[:score].round(4),
+          usage: usage.round(4),
+          freshness: freshness.round(4),
+          provenance: provenance.round(4),
+          depositor_signed: depositor_signed == 1.0
+        },
+        anti_collusion: aq[:anti_collusion],
+        attestation_summary: aq[:summary]
+      }
+    end
+
+    # Compute trust score for a depositor (agent) based on their portfolio.
+    # Input: agent_id + array of all browse skill data.
+    def calculate_depositor(agent_id, all_skills_data, adapter: nil)
+      depositor_skills = all_skills_data.select do |s|
+        (s[:owner_agent_id] || s[:agent_id] || s[:depositor_id]) == agent_id
+      end
+      return empty_depositor_result(agent_id) if depositor_skills.empty?
+
+      config = meeting_config
+
+      # Per-skill trust scores
+      skill_trusts = depositor_skills.map { |s| calculate_meeting_skill(s)[:score] }
+      avg_skill_trust = skill_trusts.sum / skill_trusts.size
+
+      # Shrinkage for small portfolios
+      n = depositor_skills.size
+      threshold = config[:depositor_shrinkage_threshold]
+      shrinkage = [n.to_f / threshold, 1.0].min
+      neutral_prior = 0.3
+      avg_shrunk = avg_skill_trust * shrinkage + neutral_prior * (1.0 - shrinkage)
+
+      # Third-party attestation breadth
+      third_party_count = depositor_skills.sum do |s|
+        (s[:attestations] || []).count { |a| a[:attester_id] != agent_id }
+      end
+      attestation_breadth = [third_party_count / 8.0, 1.0].min
+
+      # Attester diversity across portfolio
+      unique_attesters = depositor_skills.flat_map do |s|
+        (s[:attestations] || [])
+          .select { |a| a[:attester_id] != agent_id }
+          .map { |a| a[:attester_id] }
+      end.uniq.size
+      diversity = [unique_attesters / 4.0, 1.0].min
+
+      # Activity
+      activity = [n / 8.0, 1.0].min
+
+      w = depositor_weights
+      raw = (avg_shrunk * w[:avg_skill_trust] +
+             attestation_breadth * w[:attestation_breadth] +
+             diversity * w[:diversity] +
+             activity * w[:activity])
+
+      score = raw.clamp(0.0, 1.0)
+
+      result = {
+        score: score.round(4),
+        agent_id: agent_id,
+        details: {
+          avg_skill_trust: avg_skill_trust.round(4),
+          shrinkage_applied: n < threshold,
+          attestation_breadth: attestation_breadth.round(4),
+          diversity: diversity.round(4),
+          activity: activity.round(4)
+        },
+        portfolio_size: n
+      }
+      # Warn if browse limit may have truncated the portfolio
+      total_available = all_skills_data.size
+      if total_available >= 50
+        result[:portfolio_truncated] = true
+        result[:truncation_warning] = 'Browse limit reached (50). Depositor may have more skills not included in this score.'
+      end
+      result
+    end
+
+    # Combined score: smooth interpolation between skill and depositor trust.
+    # At skill_trust=0: 35% skill, 65% depositor (lean on reputation)
+    # At skill_trust=1: 70% skill, 30% depositor (stand on own evidence)
+    def calculate_combined(skill_trust, depositor_trust)
+      alpha = skill_trust.clamp(0.0, 1.0)
+      min_w = meeting_config[:combined_min_skill_weight]
+      max_w = meeting_config[:combined_max_skill_weight]
+      skill_weight = min_w + alpha * (max_w - min_w)
+      depositor_weight = 1.0 - skill_weight
+
+      combined = skill_trust * skill_weight + depositor_trust * depositor_weight
+      combined.clamp(0.0, 1.0).round(4)
+    end
+
+    # Recommendation based on combined score.
+    def recommendation(combined_score)
+      thresholds = meeting_config[:recommendation_thresholds] || {}
+      if combined_score >= (thresholds[:high_confidence] || 0.70)
+        { level: 'high_confidence', reason: 'Multiple independent trust signals verified.' }
+      elsif combined_score >= (thresholds[:moderate_confidence] || 0.40)
+        { level: 'moderate_confidence', reason: 'Some trust evidence present.' }
+      elsif combined_score >= (thresholds[:low_confidence] || 0.20)
+        { level: 'low_confidence', reason: 'Minimal evidence, proceed with caution.' }
+      else
+        { level: 'insufficient_evidence', reason: 'No meaningful trust signals found.' }
+      end
+    end
+
+    private
+
+    def meeting_attestation_quality(attestations, owner_id, config)
+      bootstrapped_count = 0
+      clique_discounted = 0
+      sig_present = 0
+
+      if attestations.empty?
+        return {
+          score: 0.0,
+          anti_collusion: { bootstrapped_attesters: 0, clique_discounted: 0,
+                            signatures_present: 0, note: 'no attestations' },
+          summary: { total: 0, third_party: 0, self: 0, unique_attesters: 0 }
+        }
+      end
+
+      # Build a simple attestation graph from browse data for SCC detection
+      attester_ids = attestations.map { |a| a[:attester_id] }.compact.uniq
+      # For meeting-level SCC: check if any pair of attesters attest each other's skills
+      # This is a simplified version — full graph requires attestation_graph API (v2.1)
+
+      total = 0.0
+      attestations.each do |a|
+        attester = a[:attester_id]
+        next unless attester
+
+        # Self-attestation discount
+        is_self = (attester == owner_id)
+        source_mult = is_self ? config[:self_attestation_weight] : 1.0
+
+        # Bootstrap check: does this attester have any external attestation?
+        # In browse context, we approximate: an attester that only attests their own
+        # skills has no external validation. This is conservative.
+        has_external = !is_self # Third-party attesters are inherently "external" to this skill
+        bootstrap_mult = has_external ? 1.0 : 0.1
+        bootstrapped_count += 1 if has_external
+
+        # Clique detection (simplified for browse data):
+        # If attester == owner (self), it's already discounted.
+        # Full mutual-attestation detection requires cross-skill data (v2.1).
+        clique_mult = 1.0
+
+        # Claim weight (loaded from YAML, merged with defaults)
+        cw = claim_weights
+        claim_weight = cw.fetch(a[:claim].to_s, cw.fetch('default', DEFAULT_CLAIM_WEIGHT))
+
+        # Signature presence (browse only exposes boolean; actual verification requires preview)
+        # We count "present" not "verified" — honest about what we can confirm from browse data
+        if a[:has_signature]
+          sig_mult = 0.8 # present but not cryptographically verified from browse
+          sig_present += 1
+        else
+          sig_mult = 0.6
+        end
+
+        total += source_mult * bootstrap_mult * clique_mult * claim_weight * sig_mult
+      end
+
+      max_expected = config[:max_expected_attestations]
+      score = [total / max_expected.to_f, 1.0].min
+
+      third_party = attestations.count { |a| a[:attester_id] != owner_id }
+
+      {
+        score: score,
+        anti_collusion: {
+          bootstrapped_attesters: bootstrapped_count,
+          clique_discounted: clique_discounted,
+          signatures_present: sig_present,
+          note: 'browse-level: signature presence checked, not cryptographically verified'
+        },
+        summary: {
+          total: attestations.size,
+          third_party: third_party,
+          self: attestations.size - third_party,
+          unique_attesters: attester_ids.size
+        }
+      }
+    end
+
+    def meeting_config
+      @config_cache = nil if @config_cache_stale # allow invalidation
+      @config_cache ||= begin
+        raw = synoptis_v2_config
+        ac = raw['anti_collusion'] || {}
+        comb = raw['combined'] || {}
+        {
+          self_attestation_weight: ac.fetch('self_attestation_weight',
+            MEETING_CONFIG_DEFAULTS[:self_attestation_weight]),
+          scc_discount: ac.fetch('scc_discount',
+            MEETING_CONFIG_DEFAULTS[:scc_discount]),
+          max_expected_attestations: ac.fetch('max_expected_attestations',
+            MEETING_CONFIG_DEFAULTS[:max_expected_attestations]),
+          remote_signal_discount: raw.fetch('remote_signal_discount',
+            MEETING_CONFIG_DEFAULTS[:remote_signal_discount]),
+          depositor_shrinkage_threshold: raw.fetch('depositor_shrinkage_threshold',
+            MEETING_CONFIG_DEFAULTS[:depositor_shrinkage_threshold]),
+          combined_min_skill_weight: comb.fetch('combined_min_skill_weight',
+            MEETING_CONFIG_DEFAULTS[:combined_min_skill_weight]),
+          combined_max_skill_weight: comb.fetch('combined_max_skill_weight',
+            MEETING_CONFIG_DEFAULTS[:combined_max_skill_weight]),
+          recommendation_thresholds: {
+            high_confidence: raw.dig('recommendation_thresholds', 'high_confidence') || 0.70,
+            moderate_confidence: raw.dig('recommendation_thresholds', 'moderate_confidence') || 0.40,
+            low_confidence: raw.dig('recommendation_thresholds', 'low_confidence') || 0.20
+          }
+        }
+      end
+    end
+
+    def synoptis_v2_config
+      config_path = File.join(KairosMcp.skillsets_dir, 'synoptis', 'config', 'synoptis.yml')
+      return {} unless File.exist?(config_path)
+
+      full = YAML.safe_load(File.read(config_path)) || {}
+      full['trust_v2'] || {}
+    rescue StandardError
+      {}
+    end
+
+    # Load skill weights from YAML, merge with defaults
+    def skill_weights
+      raw = synoptis_v2_config['skill_weights'] || {}
+      MEETING_SKILL_WEIGHTS.merge(
+        raw.transform_keys(&:to_sym).slice(*MEETING_SKILL_WEIGHTS.keys)
+          .transform_values(&:to_f)
+      )
+    end
+
+    # Load depositor weights from YAML, merge with defaults
+    def depositor_weights
+      raw = synoptis_v2_config['depositor_weights'] || {}
+      MEETING_DEPOSITOR_WEIGHTS.merge(
+        raw.transform_keys(&:to_sym).slice(*MEETING_DEPOSITOR_WEIGHTS.keys)
+          .transform_values(&:to_f)
+      )
+    end
+
+    # Load claim weights from YAML, merge with defaults
+    def claim_weights
+      raw = synoptis_v2_config['claim_weights'] || {}
+      defaults = CLAIM_WEIGHTS.merge('default' => DEFAULT_CLAIM_WEIGHT)
+      defaults.merge(raw.transform_values(&:to_f))
+    end
+
+    def empty_meeting_result(reason)
+      {
+        score: 0.0,
+        details: { reason: reason },
+        anti_collusion: { bootstrapped_attesters: 0, clique_discounted: 0,
+                          signatures_present: 0, note: 'no attestations' },
+        attestation_summary: { total: 0, third_party: 0, self: 0, unique_attesters: 0 }
+      }
+    end
+
+    def empty_depositor_result(agent_id)
+      {
+        score: 0.0,
+        agent_id: agent_id,
+        details: { reason: 'no_deposits' },
+        portfolio_size: 0
+      }
+    end
   end
 end

data/templates/skillsets/synoptis/lib/synoptis.rb

@@ -6,7 +6,9 @@ require_relative 'synoptis/attestation_engine'
 require_relative 'synoptis/revocation_manager'
 require_relative 'synoptis/registry/file_registry'
 require_relative 'synoptis/challenge_manager'
+require_relative 'synoptis/trust_identity'
 require_relative 'synoptis/trust_scorer'
+require_relative 'synoptis/meeting_trust_adapter'
 require_relative 'synoptis/tool_helpers'
 require_relative 'synoptis/transport/base_transport'
 require_relative 'synoptis/transport/mmp_transport'

data/templates/skillsets/synoptis/tools/trust_query.rb

@@ -12,7 +12,9 @@ module KairosMcp
           end
 
           def description
-            'Calculate trust score for a subject based on its attestation history. Considers quality, freshness, diversity, velocity, and revocation penalty.'
+            'Calculate trust score for a subject based on its attestation history. ' \
+            'Considers quality, freshness, diversity, velocity, and revocation penalty. ' \
+            'Supports Meeting Place skills via "meeting:<skill_id>" and depositor trust via "meeting_agent:<agent_id>".'
           end
 
           def category
@@ -20,33 +22,247 @@ module KairosMcp
           end
 
           def usecase_tags
-            %w[trust score query attestation reputation]
+            %w[trust score query attestation reputation meeting]
           end
 
           def related_tools
-            %w[attestation_list attestation_issue attestation_verify]
+            %w[attestation_list attestation_issue attestation_verify meeting_browse meeting_preview_skill]
           end
 
           def input_schema
             {
               type: 'object',
               properties: {
-                subject_ref: { type: 'string', description: 'The subject reference to calculate trust score for' }
+                subject_ref: {
+                  type: 'string',
+                  description: 'The subject reference to calculate trust score for. ' \
+                               'Use "meeting:<skill_id>" for Meeting Place skills, ' \
+                               '"meeting_agent:<agent_id>" for depositor trust, ' \
+                               'or a local ref (e.g., "skill://local_skill") for local attestation registry.'
+                }
               },
               required: %w[subject_ref]
             }
           end
 
+          # Allowed characters for skill_id and agent_id (alphanumeric, underscore, hyphen, dot)
+          SAFE_ID_PATTERN = /\A[a-zA-Z0-9_\-\.]+\z/.freeze
+
           def call(arguments)
-            result = trust_scorer.calculate(arguments['subject_ref'])
+            ref = arguments['subject_ref'].to_s.strip
 
-            chain_status = registry.verify_chain(:proofs)
-            result[:registry_integrity] = chain_status
+            result = case ref
+                     when /\Ameeting:(.+)/
+                       id = sanitize_id($1)
+                       return text_content(JSON.pretty_generate({ error: 'Invalid skill_id' })) unless id
+                       calculate_meeting_skill_trust(id)
+                     when /\Ameeting_agent:(.+)/
+                       id = sanitize_id($1)
+                       return text_content(JSON.pretty_generate({ error: 'Invalid agent_id' })) unless id
+                       calculate_meeting_agent_trust(id)
+                     else
+                       calculate_local_trust(ref)
+                     end
 
             text_content(JSON.pretty_generate(result))
           rescue StandardError => e
             text_content(JSON.pretty_generate({ error: e.message }))
           end
+
+          def sanitize_id(raw)
+            stripped = raw.to_s.strip
+            SAFE_ID_PATTERN.match?(stripped) ? stripped : nil
+          end
+
+          private
+
+          # Local trust (v1, unchanged)
+          def calculate_local_trust(ref)
+            result = trust_scorer.calculate(ref)
+            chain_status = registry.verify_chain(:proofs)
+            result[:registry_integrity] = chain_status
+            result[:source] = 'local'
+            result
+          end
+
+          # Meeting Place skill trust (v2)
+          def calculate_meeting_skill_trust(skill_id)
+            adapter = meeting_trust_adapter
+            unless adapter&.connected?
+              return {
+                subject_ref: "meeting:#{skill_id}",
+                score: 0.0,
+                source: 'unavailable',
+                error: 'Not connected to a Meeting Place. Use meeting_connect first.'
+              }
+            end
+
+            # Fetch skill data from Meeting Place
+            skill_data = adapter.fetch_skill_data(skill_id)
+            unless skill_data
+              return {
+                subject_ref: "meeting:#{skill_id}",
+                score: 0.0,
+                source: 'meeting_place',
+                error: "Skill '#{skill_id}' not found or Meeting Place unreachable.",
+                hint: 'This may indicate the skill does not exist, or a network/auth error. Check meeting_connect status.'
+              }
+            end
+
+            # Calculate skill trust
+            skill_result = trust_scorer.calculate_meeting_skill(skill_data, adapter: adapter)
+            owner_id = skill_data[:owner_agent_id] || skill_data[:agent_id] || skill_data[:depositor_id]
+
+            # Calculate depositor trust
+            all_skills = adapter.fetch_all_skills
+            depositor_result = trust_scorer.calculate_depositor(owner_id, all_skills, adapter: adapter)
+
+            # Combined score
+            combined = trust_scorer.calculate_combined(skill_result[:score], depositor_result[:score])
+            rec = trust_scorer.recommendation(combined)
+
+            # Build canonical URI
+            place_url = resolve_place_url
+            canonical = "skill://#{skill_id}?source=meeting&place=#{place_url}&owner=#{owner_id}"
+
+            {
+              subject_ref: canonical,
+              score: combined,
+              score_type: 'combined',
+              layers: {
+                skill_trust: skill_result,
+                depositor_trust: depositor_result
+              },
+              recommendation: rec[:level],
+              recommendation_reason: rec[:reason],
+              data_quality: {
+                source: 'meeting_place',
+                place_url: place_url,
+                remote_signals_discounted: true,
+                anti_collusion_version: 'v2_simplified_bootstrap'
+              }
+            }
+          end
+
+          # Meeting Place depositor/agent trust (v2)
+          def calculate_meeting_agent_trust(agent_id)
+            adapter = meeting_trust_adapter
+            unless adapter&.connected?
+              return {
+                subject_ref: "meeting_agent:#{agent_id}",
+                score: 0.0,
+                source: 'unavailable',
+                error: 'Not connected to a Meeting Place. Use meeting_connect first.'
+              }
+            end
+
+            all_skills = adapter.fetch_all_skills
+            depositor_result = trust_scorer.calculate_depositor(agent_id, all_skills, adapter: adapter)
+
+            place_url = resolve_place_url
+            canonical = "agent://#{agent_id}?source=meeting&place=#{place_url}"
+
+            rec = trust_scorer.recommendation(depositor_result[:score])
+
+            {
+              subject_ref: canonical,
+              score: depositor_result[:score],
+              score_type: 'depositor',
+              layers: {
+                depositor_trust: depositor_result
+              },
+              recommendation: rec[:level],
+              recommendation_reason: rec[:reason],
+              data_quality: {
+                source: 'meeting_place',
+                place_url: place_url,
+                remote_signals_discounted: true,
+                anti_collusion_version: 'v2_simplified_bootstrap'
+              }
+            }
+          end
+
+          def meeting_trust_adapter
+            @_meeting_adapter = nil # no caching across calls — connection state may change
+            connection = load_connection_state
+            return nil unless connection
+
+            config = trust_scorer.send(:synoptis_v2_config) rescue {}
+            client = MeetingPlaceHttpClient.new(
+              url: connection['url'] || connection[:url],
+              token: connection['session_token'] || connection[:session_token]
+            )
+            ::Synoptis::MeetingTrustAdapter.new(
+              place_client: client,
+              config: config
+            )
+          end
+
+          def load_connection_state
+            f = File.join(KairosMcp.storage_dir, 'meeting_connection.json')
+            File.exist?(f) ? JSON.parse(File.read(f)) : nil
+          rescue StandardError
+            nil
+          end
+
+          def resolve_place_url
+            conn = load_connection_state
+            (conn && (conn['url'] || conn[:url])) || 'unknown'
+          end
+
+          # Lightweight HTTP client for Meeting Place — mirrors MMP browse/preview patterns
+          class MeetingPlaceHttpClient
+            require 'net/http'
+            require 'uri'
+            require 'json'
+
+            def initialize(url:, token:)
+              @base_url = url
+              @token = token
+            end
+
+            def browse(type: nil, search: nil, tags: nil, limit: 50)
+              params = { 'limit' => limit.to_s }
+              params['type'] = type if type
+              params['search'] = search if search
+              params['tags'] = Array(tags).join(',') if tags && !tags.empty?
+              get('/place/v1/board/browse', params)
+            end
+
+            def preview_skill(skill_id:, owner: nil, first_lines: 0)
+              params = { 'first_lines' => first_lines.to_s }
+              params['owner'] = owner if owner
+              encoded = URI.encode_www_form_component(skill_id)
+              get("/place/v1/preview/#{encoded}", params)
+            end
+
+            def session_status
+              { url: @base_url, connected: !@token.nil? }
+            end
+
+            def respond_to_missing?(method, include_private = false)
+              super
+            end
+
+            private
+
+            def get(path, params = {})
+              query = params.empty? ? '' : "?#{URI.encode_www_form(params)}"
+              uri = URI.parse("#{@base_url}#{path}#{query}")
+              http = Net::HTTP.new(uri.host, uri.port)
+              http.use_ssl = (uri.scheme == 'https')
+              http.open_timeout = 5
+              http.read_timeout = 10
+              req = Net::HTTP::Get.new(uri)
+              req['Authorization'] = "Bearer #{@token}" if @token
+              response = http.request(req)
+              if response.is_a?(Net::HTTPSuccess)
+                JSON.parse(response.body, symbolize_names: true)
+              end
+            rescue StandardError
+              nil
+            end
+          end
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kairos-chain
 version: !ruby/object:Gem::Version
-  version: 3.4.1
+  version: 3.5.0
 platform: ruby
 authors:
 - Masaomi Hatakeyama
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-24 00:00:00.000000000 Z
+date: 2026-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -353,6 +353,7 @@ files:
 - templates/skillsets/synoptis/lib/synoptis.rb
 - templates/skillsets/synoptis/lib/synoptis/attestation_engine.rb
 - templates/skillsets/synoptis/lib/synoptis/challenge_manager.rb
+- templates/skillsets/synoptis/lib/synoptis/meeting_trust_adapter.rb
 - templates/skillsets/synoptis/lib/synoptis/proof_envelope.rb
 - templates/skillsets/synoptis/lib/synoptis/registry/file_registry.rb
 - templates/skillsets/synoptis/lib/synoptis/revocation_manager.rb
@@ -397,7 +398,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: KairosChain - Self-referential MCP server for auditable skill self-management