@mnemom/agent-alignment-protocol 0.1.7 → 0.2.0

package/dist/index.mjs

@@ -6,6 +6,8 @@ var MIN_COHERENCE_FOR_PROCEED = 0.7;
 var CONFLICT_PENALTY_MULTIPLIER = 0.5;
 var MIN_WORD_LENGTH = 3;
 var MAX_TFIDF_FEATURES = 500;
+var OUTLIER_STD_DEV_THRESHOLD = 1;
+var CLUSTER_COMPATIBILITY_THRESHOLD = 0.7;
 var ALGORITHM_VERSION = "1.2.0";
 
 // src/verification/features.ts
@@ -381,6 +383,204 @@ function checkCoherence(myCard, theirCard, taskValues) {
     proposed_resolution: proposedResolution
   };
 }
+function checkFleetCoherence(cards, taskValues) {
+  if (cards.length < 2) {
+    throw new Error("Fleet coherence requires at least 2 agents");
+  }
+  const pairwiseMatrix = [];
+  for (let i = 0; i < cards.length; i++) {
+    for (let j = i + 1; j < cards.length; j++) {
+      pairwiseMatrix.push({
+        agent_a: cards[i].agentId,
+        agent_b: cards[j].agentId,
+        result: checkCoherence(cards[i].card, cards[j].card, taskValues)
+      });
+    }
+  }
+  const allScores = pairwiseMatrix.map((p) => p.result.score);
+  const fleetScore = allScores.reduce((a, b) => a + b, 0) / allScores.length;
+  const minPairScore = Math.min(...allScores);
+  const maxPairScore = Math.max(...allScores);
+  const agentIds = cards.map((c) => c.agentId);
+  const agentScoreMap = /* @__PURE__ */ new Map();
+  const agentCompatibleCount = /* @__PURE__ */ new Map();
+  const agentConflictCount = /* @__PURE__ */ new Map();
+  for (const id of agentIds) {
+    agentScoreMap.set(id, []);
+    agentCompatibleCount.set(id, 0);
+    agentConflictCount.set(id, 0);
+  }
+  for (const pair of pairwiseMatrix) {
+    agentScoreMap.get(pair.agent_a).push(pair.result.score);
+    agentScoreMap.get(pair.agent_b).push(pair.result.score);
+    if (pair.result.compatible) {
+      agentCompatibleCount.set(pair.agent_a, agentCompatibleCount.get(pair.agent_a) + 1);
+      agentCompatibleCount.set(pair.agent_b, agentCompatibleCount.get(pair.agent_b) + 1);
+    }
+    if (pair.result.value_alignment.conflicts.length > 0) {
+      agentConflictCount.set(pair.agent_a, agentConflictCount.get(pair.agent_a) + 1);
+      agentConflictCount.set(pair.agent_b, agentConflictCount.get(pair.agent_b) + 1);
+    }
+  }
+  const agentMeans = /* @__PURE__ */ new Map();
+  for (const id of agentIds) {
+    const scores = agentScoreMap.get(id);
+    agentMeans.set(id, scores.reduce((a, b) => a + b, 0) / scores.length);
+  }
+  const meanValues = [...agentMeans.values()];
+  const fleetMeanOfMeans = meanValues.reduce((a, b) => a + b, 0) / meanValues.length;
+  const variance = meanValues.reduce((sum, v) => sum + (v - fleetMeanOfMeans) ** 2, 0) / meanValues.length;
+  const stddev = Math.sqrt(variance);
+  const outliers = [];
+  if (stddev > 0 && agentIds.length >= 3) {
+    for (const id of agentIds) {
+      const agentMean = agentMeans.get(id);
+      const deviation = (fleetMeanOfMeans - agentMean) / stddev;
+      if (deviation >= OUTLIER_STD_DEV_THRESHOLD) {
+        const primaryConflicts = /* @__PURE__ */ new Set();
+        for (const pair of pairwiseMatrix) {
+          if (pair.agent_a === id || pair.agent_b === id) {
+            for (const conflict of pair.result.value_alignment.conflicts) {
+              if (conflict.initiator_value !== "(conflicts_with)") {
+                primaryConflicts.add(conflict.initiator_value);
+              }
+              if (conflict.responder_value !== "(conflicts_with)") {
+                primaryConflicts.add(conflict.responder_value);
+              }
+            }
+          }
+        }
+        outliers.push({
+          agent_id: id,
+          agent_mean_score: Math.round(agentMean * 1e4) / 1e4,
+          fleet_mean_score: Math.round(fleetMeanOfMeans * 1e4) / 1e4,
+          deviation: Math.round(deviation * 1e4) / 1e4,
+          primary_conflicts: [...primaryConflicts]
+        });
+      }
+    }
+  }
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const id of agentIds) {
+    adjacency.set(id, /* @__PURE__ */ new Set());
+  }
+  for (const pair of pairwiseMatrix) {
+    if (pair.result.compatible) {
+      adjacency.get(pair.agent_a).add(pair.agent_b);
+      adjacency.get(pair.agent_b).add(pair.agent_a);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const clusters = [];
+  let clusterId = 0;
+  for (const id of agentIds) {
+    if (visited.has(id)) continue;
+    const component = [];
+    const queue = [id];
+    visited.add(id);
+    while (queue.length > 0) {
+      const current = queue.shift();
+      component.push(current);
+      for (const neighbor of adjacency.get(current)) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          queue.push(neighbor);
+        }
+      }
+    }
+    let internalSum = 0;
+    let internalCount = 0;
+    for (let i = 0; i < component.length; i++) {
+      for (let j = i + 1; j < component.length; j++) {
+        const pair = pairwiseMatrix.find(
+          (p) => p.agent_a === component[i] && p.agent_b === component[j] || p.agent_a === component[j] && p.agent_b === component[i]
+        );
+        if (pair) {
+          internalSum += pair.result.score;
+          internalCount++;
+        }
+      }
+    }
+    const internalCoherence = internalCount > 0 ? internalSum / internalCount : 1;
+    const clusterCards = component.map((cid) => cards.find((c) => c.agentId === cid));
+    const sharedValues = clusterCards.reduce((shared, entry, idx) => {
+      const declared = entry.card.values.declared ?? [];
+      if (idx === 0) return [...declared];
+      return shared.filter((v) => declared.includes(v));
+    }, []);
+    const allOtherValues = /* @__PURE__ */ new Set();
+    for (const entry of cards) {
+      if (!component.includes(entry.agentId)) {
+        for (const v of entry.card.values.declared ?? []) {
+          allOtherValues.add(v);
+        }
+      }
+    }
+    const distinguishingValues = sharedValues.filter((v) => !allOtherValues.has(v));
+    clusters.push({
+      cluster_id: clusterId++,
+      agent_ids: component,
+      internal_coherence: Math.round(internalCoherence * 1e4) / 1e4,
+      shared_values: sharedValues,
+      distinguishing_values: distinguishingValues
+    });
+  }
+  const allValues = /* @__PURE__ */ new Set();
+  const agentValueMap = /* @__PURE__ */ new Map();
+  const agentConflictMap = /* @__PURE__ */ new Map();
+  for (const entry of cards) {
+    const declared = new Set(entry.card.values.declared ?? []);
+    const conflicts = new Set(entry.card.values.conflicts_with ?? []);
+    agentValueMap.set(entry.agentId, declared);
+    agentConflictMap.set(entry.agentId, conflicts);
+    for (const v of declared) allValues.add(v);
+  }
+  const divergenceReport = [];
+  for (const value of allValues) {
+    const declaring = agentIds.filter((id) => agentValueMap.get(id).has(value));
+    const missing = agentIds.filter((id) => !agentValueMap.get(id).has(value));
+    const conflicting = agentIds.filter((id) => agentConflictMap.get(id).has(value));
+    if (missing.length === 0 && conflicting.length === 0) continue;
+    const impactOnFleetScore = Math.round(
+      (missing.length + conflicting.length) / agentIds.length * 1e4
+    ) / 1e4;
+    divergenceReport.push({
+      value,
+      agents_declaring: declaring,
+      agents_missing: missing,
+      agents_conflicting: conflicting,
+      impact_on_fleet_score: impactOnFleetScore
+    });
+  }
+  divergenceReport.sort((a, b) => b.impact_on_fleet_score - a.impact_on_fleet_score);
+  const agentClusterMap = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    for (const id of cluster.agent_ids) {
+      agentClusterMap.set(id, cluster.cluster_id);
+    }
+  }
+  const outlierIds = new Set(outliers.map((o) => o.agent_id));
+  const agentSummaries = agentIds.map((id) => ({
+    agent_id: id,
+    mean_score: Math.round(agentMeans.get(id) * 1e4) / 1e4,
+    compatible_count: agentCompatibleCount.get(id),
+    conflict_count: agentConflictCount.get(id),
+    cluster_id: agentClusterMap.get(id) ?? 0,
+    is_outlier: outlierIds.has(id)
+  }));
+  return {
+    fleet_score: Math.round(fleetScore * 1e4) / 1e4,
+    min_pair_score: Math.round(minPairScore * 1e4) / 1e4,
+    max_pair_score: Math.round(maxPairScore * 1e4) / 1e4,
+    agent_count: cards.length,
+    pair_count: pairwiseMatrix.length,
+    pairwise_matrix: pairwiseMatrix,
+    outliers,
+    clusters,
+    divergence_report: divergenceReport,
+    agent_summaries: agentSummaries
+  };
+}
 function detectDrift(card, traces, similarityThreshold = DEFAULT_SIMILARITY_THRESHOLD, sustainedThreshold = DEFAULT_SUSTAINED_TURNS_THRESHOLD) {
   const sorted = [...traces].sort(
     (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
@@ -587,17 +787,46 @@ function wasEscalated(trace) {
 function hadViolations(trace) {
   return trace.action.category === "forbidden";
 }
+
+// src/compliance.ts
+var EU_COMPLIANCE_AUDIT_COMMITMENT = {
+  retention_days: 90,
+  queryable: true,
+  query_endpoint: "https://audit.example.com/traces",
+  tamper_evidence: "append_only",
+  trace_format: "ap-trace-v1"
+};
+var EU_COMPLIANCE_EXTENSIONS = {
+  eu_ai_act: {
+    article_50_compliant: true,
+    ai_system_classification: "general_purpose",
+    disclosure_text: "This system is powered by an AI agent. Its decisions are logged and auditable. You may request a human review of any decision.",
+    compliance_version: "2026-08"
+  }
+};
+var EU_COMPLIANCE_VALUES = [
+  "transparency",
+  "honesty",
+  "user_control",
+  "principal_benefit"
+];
 export {
   ALGORITHM_VERSION,
+  CLUSTER_COMPATIBILITY_THRESHOLD,
   CONFLICT_PENALTY_MULTIPLIER,
   DEFAULT_SIMILARITY_THRESHOLD,
   DEFAULT_SUSTAINED_TURNS_THRESHOLD,
+  EU_COMPLIANCE_AUDIT_COMMITMENT,
+  EU_COMPLIANCE_EXTENSIONS,
+  EU_COMPLIANCE_VALUES,
   MAX_TFIDF_FEATURES,
   MIN_COHERENCE_FOR_PROCEED,
   MIN_WORD_LENGTH,
   NEAR_BOUNDARY_THRESHOLD,
+  OUTLIER_STD_DEV_THRESHOLD,
   VIOLATION_SEVERITY,
   checkCoherence,
+  checkFleetCoherence,
   computeCentroid,
   cosineSimilarity,
   createViolation,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/agent-alignment-protocol",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "Agent Alignment Protocol (AAP) - Verification and drift detection for AI agents",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/compliance.ts

@@ -0,0 +1,56 @@
+/**
+ * EU AI Act Article 50 compliance presets for AAP.
+ *
+ * These presets provide recommended configuration values for deploying
+ * AAP-instrumented agents in EU jurisdictions subject to AI Act
+ * transparency obligations. Spread them into your AlignmentCard fields.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   EU_COMPLIANCE_AUDIT_COMMITMENT,
+ *   EU_COMPLIANCE_EXTENSIONS,
+ *   EU_COMPLIANCE_VALUES,
+ * } from "agent-alignment-protocol";
+ *
+ * const card: AlignmentCard = {
+ *   ...,
+ *   audit_commitment: { ...EU_COMPLIANCE_AUDIT_COMMITMENT },
+ *   values: { declared: EU_COMPLIANCE_VALUES, ... },
+ *   extensions: { ...EU_COMPLIANCE_EXTENSIONS },
+ * };
+ * ```
+ *
+ * DISCLAIMER: These presets reflect a technical mapping of AAP features to
+ * Article 50 requirements. They do not constitute legal advice. Consult
+ * qualified legal counsel for your specific compliance obligations.
+ */
+
+/** Audit commitment values that satisfy Article 50(4) audit trail requirements. */
+export const EU_COMPLIANCE_AUDIT_COMMITMENT = {
+  retention_days: 90,
+  queryable: true,
+  query_endpoint: "https://audit.example.com/traces",
+  tamper_evidence: "append_only" as const,
+  trace_format: "ap-trace-v1",
+} as const;
+
+/** Extension block for EU AI Act metadata on the Alignment Card. */
+export const EU_COMPLIANCE_EXTENSIONS = {
+  eu_ai_act: {
+    article_50_compliant: true,
+    ai_system_classification: "general_purpose",
+    disclosure_text:
+      "This system is powered by an AI agent. Its decisions are logged " +
+      "and auditable. You may request a human review of any decision.",
+    compliance_version: "2026-08",
+  },
+} as const;
+
+/** Recommended declared values for Article 50 transparency obligations. */
+export const EU_COMPLIANCE_VALUES = [
+  "transparency",
+  "honesty",
+  "user_control",
+  "principal_benefit",
+] as const;

package/src/constants.ts

@@ -39,6 +39,14 @@ export const MIN_WORD_LENGTH = 3;
 /** Maximum features to extract from TF-IDF vectorization */
 export const MAX_TFIDF_FEATURES = 500;
 
+// Fleet Coherence
+// ----------------
+/** Standard deviations below fleet mean to flag an agent as outlier */
+export const OUTLIER_STD_DEV_THRESHOLD = 1.0;
+
+/** Minimum pairwise score to consider agents compatible for cluster analysis */
+export const CLUSTER_COMPATIBILITY_THRESHOLD = 0.7;
+
 // Version
 // -------
 export const ALGORITHM_VERSION = "1.2.0";

package/src/index.ts

@@ -35,7 +35,7 @@
  */
 
 // Main API exports
-export { verifyTrace, checkCoherence, detectDrift } from "./verification/api";
+export { verifyTrace, checkCoherence, checkFleetCoherence, detectDrift } from "./verification/api";
 
 // Schema types
 export type {
@@ -107,6 +107,13 @@ export type {
   DriftAnalysis,
   DriftDirection,
   DriftIndicator,
+  // Fleet Coherence (E-05)
+  FleetCoherenceResult,
+  PairwiseEntry,
+  FleetOutlier,
+  FleetCluster,
+  ValueDivergence,
+  AgentCoherenceSummary,
 } from "./verification/models";
 
 // Utility exports
@@ -134,3 +141,10 @@ export { createViolation, VIOLATION_SEVERITY } from "./verification/models";
 
 // Constants
 export * from "./constants";
+
+// EU AI Act compliance presets
+export {
+  EU_COMPLIANCE_AUDIT_COMMITMENT,
+  EU_COMPLIANCE_EXTENSIONS,
+  EU_COMPLIANCE_VALUES,
+} from "./compliance";

package/src/verification/api.ts

@@ -16,6 +16,7 @@ import {
   DEFAULT_SUSTAINED_TURNS_THRESHOLD,
   MIN_COHERENCE_FOR_PROCEED,
   NEAR_BOUNDARY_THRESHOLD,
+  OUTLIER_STD_DEV_THRESHOLD,
 } from "../constants";
 import type { AlignmentCard } from "../schemas/alignment-card";
 import type { APTrace } from "../schemas/ap-trace";
@@ -26,11 +27,17 @@ import {
 } from "./features";
 import {
   createViolation,
+  type AgentCoherenceSummary,
   type CoherenceResult,
   type DriftAlert,
   type DriftDirection,
   type DriftIndicator,
+  type FleetCluster,
+  type FleetCoherenceResult,
+  type FleetOutlier,
+  type PairwiseEntry,
   type ValueConflictResult,
+  type ValueDivergence,
   type VerificationResult,
   type Violation,
   type Warning,
@@ -340,6 +347,265 @@ export function checkCoherence(
   };
 }
 
+/**
+ * Check fleet-level value coherence across N agents.
+ *
+ * Computes all C(n,2) pairwise coherence scores, then derives:
+ * - Fleet score: mean of all pairwise scores
+ * - Outlier detection: agents >1 std dev below fleet mean
+ * - Cluster analysis: connected components at compatibility threshold
+ * - Divergence report: values where agents disagree
+ *
+ * @param cards - Array of agent cards with their IDs
+ * @param taskValues - Optional list of values required for the task
+ * @returns FleetCoherenceResult with full analysis
+ * @throws Error if fewer than 2 agents provided
+ */
+export function checkFleetCoherence(
+  cards: Array<{ agentId: string; card: AlignmentCard }>,
+  taskValues?: string[]
+): FleetCoherenceResult {
+  if (cards.length < 2) {
+    throw new Error("Fleet coherence requires at least 2 agents");
+  }
+
+  // Step 1: Compute all pairwise coherence scores
+  const pairwiseMatrix: PairwiseEntry[] = [];
+  for (let i = 0; i < cards.length; i++) {
+    for (let j = i + 1; j < cards.length; j++) {
+      pairwiseMatrix.push({
+        agent_a: cards[i].agentId,
+        agent_b: cards[j].agentId,
+        result: checkCoherence(cards[i].card, cards[j].card, taskValues),
+      });
+    }
+  }
+
+  // Step 2: Fleet score (mean of all pairwise scores) + min/max
+  const allScores = pairwiseMatrix.map(p => p.result.score);
+  const fleetScore = allScores.reduce((a, b) => a + b, 0) / allScores.length;
+  const minPairScore = Math.min(...allScores);
+  const maxPairScore = Math.max(...allScores);
+
+  // Step 3: Per-agent summaries
+  const agentIds = cards.map(c => c.agentId);
+  const agentScoreMap = new Map<string, number[]>();
+  const agentCompatibleCount = new Map<string, number>();
+  const agentConflictCount = new Map<string, number>();
+
+  for (const id of agentIds) {
+    agentScoreMap.set(id, []);
+    agentCompatibleCount.set(id, 0);
+    agentConflictCount.set(id, 0);
+  }
+
+  for (const pair of pairwiseMatrix) {
+    agentScoreMap.get(pair.agent_a)!.push(pair.result.score);
+    agentScoreMap.get(pair.agent_b)!.push(pair.result.score);
+    if (pair.result.compatible) {
+      agentCompatibleCount.set(pair.agent_a, agentCompatibleCount.get(pair.agent_a)! + 1);
+      agentCompatibleCount.set(pair.agent_b, agentCompatibleCount.get(pair.agent_b)! + 1);
+    }
+    if (pair.result.value_alignment.conflicts.length > 0) {
+      agentConflictCount.set(pair.agent_a, agentConflictCount.get(pair.agent_a)! + 1);
+      agentConflictCount.set(pair.agent_b, agentConflictCount.get(pair.agent_b)! + 1);
+    }
+  }
+
+  const agentMeans = new Map<string, number>();
+  for (const id of agentIds) {
+    const scores = agentScoreMap.get(id)!;
+    agentMeans.set(id, scores.reduce((a, b) => a + b, 0) / scores.length);
+  }
+
+  // Step 4: Outlier detection
+  const meanValues = [...agentMeans.values()];
+  const fleetMeanOfMeans = meanValues.reduce((a, b) => a + b, 0) / meanValues.length;
+  const variance = meanValues.reduce((sum, v) => sum + (v - fleetMeanOfMeans) ** 2, 0) / meanValues.length;
+  const stddev = Math.sqrt(variance);
+
+  const outliers: FleetOutlier[] = [];
+  // Only detect outliers when there's meaningful variance (3+ agents)
+  if (stddev > 0 && agentIds.length >= 3) {
+    for (const id of agentIds) {
+      const agentMean = agentMeans.get(id)!;
+      const deviation = (fleetMeanOfMeans - agentMean) / stddev;
+      if (deviation >= OUTLIER_STD_DEV_THRESHOLD) {
+        // Identify primary conflict values
+        const primaryConflicts = new Set<string>();
+        for (const pair of pairwiseMatrix) {
+          if (pair.agent_a === id || pair.agent_b === id) {
+            for (const conflict of pair.result.value_alignment.conflicts) {
+              if (conflict.initiator_value !== "(conflicts_with)") {
+                primaryConflicts.add(conflict.initiator_value);
+              }
+              if (conflict.responder_value !== "(conflicts_with)") {
+                primaryConflicts.add(conflict.responder_value);
+              }
+            }
+          }
+        }
+        outliers.push({
+          agent_id: id,
+          agent_mean_score: Math.round(agentMean * 10000) / 10000,
+          fleet_mean_score: Math.round(fleetMeanOfMeans * 10000) / 10000,
+          deviation: Math.round(deviation * 10000) / 10000,
+          primary_conflicts: [...primaryConflicts],
+        });
+      }
+    }
+  }
+
+  // Step 5: Cluster analysis (connected components at compatibility threshold)
+  const adjacency = new Map<string, Set<string>>();
+  for (const id of agentIds) {
+    adjacency.set(id, new Set());
+  }
+  for (const pair of pairwiseMatrix) {
+    if (pair.result.compatible) {
+      adjacency.get(pair.agent_a)!.add(pair.agent_b);
+      adjacency.get(pair.agent_b)!.add(pair.agent_a);
+    }
+  }
+
+  const visited = new Set<string>();
+  const clusters: FleetCluster[] = [];
+  let clusterId = 0;
+
+  for (const id of agentIds) {
+    if (visited.has(id)) continue;
+    // BFS to find connected component
+    const component: string[] = [];
+    const queue = [id];
+    visited.add(id);
+    while (queue.length > 0) {
+      const current = queue.shift()!;
+      component.push(current);
+      for (const neighbor of adjacency.get(current)!) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          queue.push(neighbor);
+        }
+      }
+    }
+
+    // Compute internal coherence for this cluster
+    let internalSum = 0;
+    let internalCount = 0;
+    for (let i = 0; i < component.length; i++) {
+      for (let j = i + 1; j < component.length; j++) {
+        const pair = pairwiseMatrix.find(
+          p => (p.agent_a === component[i] && p.agent_b === component[j]) ||
+               (p.agent_a === component[j] && p.agent_b === component[i])
+        );
+        if (pair) {
+          internalSum += pair.result.score;
+          internalCount++;
+        }
+      }
+    }
+    const internalCoherence = internalCount > 0 ? internalSum / internalCount : 1;
+
+    // Find shared values (intersection of all agents in cluster)
+    const clusterCards = component.map(cid => cards.find(c => c.agentId === cid)!);
+    const sharedValues = clusterCards.reduce<string[]>((shared, entry, idx) => {
+      const declared = entry.card.values.declared ?? [];
+      if (idx === 0) return [...declared];
+      return shared.filter(v => declared.includes(v));
+    }, []);
+
+    // Find distinguishing values (values in this cluster but not in other clusters' shared values)
+    const allOtherValues = new Set<string>();
+    for (const entry of cards) {
+      if (!component.includes(entry.agentId)) {
+        for (const v of entry.card.values.declared ?? []) {
+          allOtherValues.add(v);
+        }
+      }
+    }
+    const distinguishingValues = sharedValues.filter(v => !allOtherValues.has(v));
+
+    clusters.push({
+      cluster_id: clusterId++,
+      agent_ids: component,
+      internal_coherence: Math.round(internalCoherence * 10000) / 10000,
+      shared_values: sharedValues,
+      distinguishing_values: distinguishingValues,
+    });
+  }
+
+  // Step 6: Divergence report
+  const allValues = new Set<string>();
+  const agentValueMap = new Map<string, Set<string>>();
+  const agentConflictMap = new Map<string, Set<string>>();
+
+  for (const entry of cards) {
+    const declared = new Set(entry.card.values.declared ?? []);
+    const conflicts = new Set(entry.card.values.conflicts_with ?? []);
+    agentValueMap.set(entry.agentId, declared);
+    agentConflictMap.set(entry.agentId, conflicts);
+    for (const v of declared) allValues.add(v);
+  }
+
+  const divergenceReport: ValueDivergence[] = [];
+  for (const value of allValues) {
+    const declaring = agentIds.filter(id => agentValueMap.get(id)!.has(value));
+    const missing = agentIds.filter(id => !agentValueMap.get(id)!.has(value));
+    const conflicting = agentIds.filter(id => agentConflictMap.get(id)!.has(value));
+
+    // Skip values with no divergence (everyone declares, no one conflicts)
+    if (missing.length === 0 && conflicting.length === 0) continue;
+
+    // Estimate impact: fraction of agents not aligned on this value
+    const impactOnFleetScore = Math.round(
+      ((missing.length + conflicting.length) / agentIds.length) * 10000
+    ) / 10000;
+
+    divergenceReport.push({
+      value,
+      agents_declaring: declaring,
+      agents_missing: missing,
+      agents_conflicting: conflicting,
+      impact_on_fleet_score: impactOnFleetScore,
+    });
+  }
+
+  // Sort divergence report by impact (highest first)
+  divergenceReport.sort((a, b) => b.impact_on_fleet_score - a.impact_on_fleet_score);
+
+  // Build agent cluster map for summaries
+  const agentClusterMap = new Map<string, number>();
+  for (const cluster of clusters) {
+    for (const id of cluster.agent_ids) {
+      agentClusterMap.set(id, cluster.cluster_id);
+    }
+  }
+
+  const outlierIds = new Set(outliers.map(o => o.agent_id));
+
+  const agentSummaries: AgentCoherenceSummary[] = agentIds.map(id => ({
+    agent_id: id,
+    mean_score: Math.round(agentMeans.get(id)! * 10000) / 10000,
+    compatible_count: agentCompatibleCount.get(id)!,
+    conflict_count: agentConflictCount.get(id)!,
+    cluster_id: agentClusterMap.get(id) ?? 0,
+    is_outlier: outlierIds.has(id),
+  }));
+
+  return {
+    fleet_score: Math.round(fleetScore * 10000) / 10000,
+    min_pair_score: Math.round(minPairScore * 10000) / 10000,
+    max_pair_score: Math.round(maxPairScore * 10000) / 10000,
+    agent_count: cards.length,
+    pair_count: pairwiseMatrix.length,
+    pairwise_matrix: pairwiseMatrix,
+    outliers,
+    clusters,
+    divergence_report: divergenceReport,
+    agent_summaries: agentSummaries,
+  };
+}
+
 /**
  * Detect behavioral drift from declared alignment.
  *