@mnemom/agent-alignment-protocol 0.5.0 → 0.6.1

package/README.md

@@ -75,7 +75,7 @@ A structured declaration of an agent's alignment posture:
 
 ```json
 {
-  "aap_version": "0.1.0",
+  "aap_version": "0.5.0",
   "agent_id": "did:web:my-agent.example.com",
   "principal": {
     "type": "human",

package/dist/index.d.mts

@@ -501,6 +501,76 @@ interface FleetCoherenceResult {
     /** Per-agent coherence summaries */
     agent_summaries: AgentCoherenceSummary[];
 }
+/** Classification of a fault line's nature. */
+type FaultLineClassification = 'resolvable' | 'priority_mismatch' | 'incompatible' | 'complementary';
+/** A single fault line — a value dimension that splits the fleet. */
+interface FaultLine {
+    /** Deterministic ID for this fault line */
+    id: string;
+    /** The value in question */
+    value: string;
+    /** How the fault line is classified */
+    classification: FaultLineClassification;
+    /** Severity based on impact_score */
+    severity: Severity;
+    /** Agent IDs that declare this value */
+    agents_declaring: string[];
+    /** Agent IDs missing this value */
+    agents_missing: string[];
+    /** Agent IDs whose conflicts_with includes this value */
+    agents_conflicting: string[];
+    /** Weighted impact score (0.0 to 1.0) */
+    impact_score: number;
+    /** Plain-English resolution hint */
+    resolution_hint: string;
+    /** Bounded actions shared by all involved agents */
+    affects_capabilities: string[];
+}
+/** Aggregated summary of fault lines by classification. */
+interface FaultLineSummary {
+    /** Total number of fault lines */
+    total: number;
+    /** Count of resolvable fault lines */
+    resolvable: number;
+    /** Count of priority_mismatch fault lines */
+    priority_mismatch: number;
+    /** Count of incompatible fault lines */
+    incompatible: number;
+    /** Count of complementary fault lines */
+    complementary: number;
+    /** Count of critical-severity fault lines */
+    critical_count: number;
+}
+/** A pattern where the same set of agents is consistently isolated across multiple fault lines. */
+interface FaultLineAlignment {
+    /** Deterministic ID */
+    id: string;
+    /** IDs of the fault lines that form this alignment */
+    fault_line_ids: string[];
+    /** Agents consistently missing from this group of fault lines */
+    minority_agents: string[];
+    /** Agents consistently declaring this group of fault lines */
+    majority_agents: string[];
+    /** Mean Jaccard similarity within the alignment group */
+    alignment_score: number;
+    /** Severity of the alignment pattern */
+    severity: Severity;
+    /** Human-readable description */
+    description: string;
+}
+/** Full fault line analysis result. */
+interface FaultLineAnalysis {
+    /** Deterministic analysis identifier */
+    analysis_id: string;
+    /** Fleet coherence score (from FleetCoherenceResult) */
+    fleet_score: number;
+    /** Detected fault lines, sorted by severity then impact_score desc */
+    fault_lines: FaultLine[];
+    /** Detected alignment patterns */
+    alignments: FaultLineAlignment[];
+    /** Counts by classification */
+    summary: FaultLineSummary;
+}
 
 /**
  * AAP Verification API - The three public entry points.
@@ -586,6 +656,38 @@ declare function checkFleetCoherence(cards: Array<{
  * @returns List of DriftAlert objects for detected drift events
  */
 declare function detectDrift(card: AlignmentCard, traces: APTrace[], similarityThreshold?: number, sustainedThreshold?: number): DriftAlert[];
+/**
+ * Analyze fault lines in a fleet based on a FleetCoherenceResult.
+ *
+ * @param coherenceResult - Result from checkFleetCoherence
+ * @param cards - Same agent cards passed to checkFleetCoherence
+ * @param options - Optional reputationScores and taskContext
+ * @returns FaultLineAnalysis with fault lines and alignment patterns
+ */
+declare function analyzeFaultLines(coherenceResult: FleetCoherenceResult, cards: Array<{
+    agentId: string;
+    card: AlignmentCard;
+}>, options?: {
+    reputationScores?: Record<string, number>;
+    taskContext?: string;
+}): FaultLineAnalysis;
+/**
+ * Convenience wrapper: run fleet coherence then fault line analysis in one call.
+ *
+ * @param cards - Array of agent cards
+ * @param options - Optional reputationScores and taskContext
+ * @returns Both FleetCoherenceResult and FaultLineAnalysis
+ */
+declare function checkFleetFaultLines(cards: Array<{
+    agentId: string;
+    card: AlignmentCard;
+}>, options?: {
+    reputationScores?: Record<string, number>;
+    taskContext?: string;
+}): {
+    coherence: FleetCoherenceResult;
+    analysis: FaultLineAnalysis;
+};
 
 /**
  * Value Coherence Handshake messages - Agent-to-agent alignment verification.
@@ -857,4 +959,4 @@ declare const EU_COMPLIANCE_EXTENSIONS: {
 /** Recommended declared values for Article 50 transparency obligations. */
 declare const EU_COMPLIANCE_VALUES: readonly ["transparency", "honesty", "user_control", "principal_benefit"];
 
-export { ALGORITHM_VERSION, type APTrace, type Action, type ActionCategory, type ActionTarget, type ActionType, type AgentCoherenceSummary, type AlignmentCard, type AlignmentCardRequest, type AlignmentCardResponse, type Alternative, type AuditCommitment, type AuditStorage, type AutonomyEnvelope, type AutonomyScope, CLUSTER_COMPATIBILITY_THRESHOLD, CONFLICT_PENALTY_MULTIPLIER, type Coherence, type CoherenceResult, type CoherenceResultMessage, DEFAULT_SIMILARITY_THRESHOLD, DEFAULT_SUSTAINED_TURNS_THRESHOLD, type DataSharing, type Decision, type DriftAlert, type DriftAnalysis, type DriftDirection, type DriftIndicator, EU_COMPLIANCE_AUDIT_COMMITMENT, EU_COMPLIANCE_EXTENSIONS, EU_COMPLIANCE_VALUES, type Escalation, type EscalationStatus, type EscalationTrigger, type FleetCluster, type FleetCoherenceResult, type FleetOutlier, type HierarchyType, MAX_TFIDF_FEATURES, MIN_COHERENCE_FOR_PROCEED, MIN_WORD_LENGTH, type MonetaryValue, NEAR_BOUNDARY_THRESHOLD, OUTLIER_STD_DEV_THRESHOLD, type PairwiseEntry, type Principal, type PrincipalResponse, type PrincipalType, type ProposedCollaboration, type ProposedResolution, type RelationshipType, type RequesterInfo, type Severity, type Signature, type StorageType, type TamperEvidence, type TaskContext, type TraceContext, type TriggerAction, type TriggerCheck, VIOLATION_SEVERITY, type ValueAlignment, type ValueAlignmentDetail, type ValueCoherenceCheck, type ValueCoherenceMessage, type ValueConflict, type ValueConflictResult, type ValueDefinition, type ValueDivergence, type Values, type VerificationMetadata, type VerificationResult, type Violation, type ViolationType, type Warning, checkCoherence, checkFleetCoherence, computeCentroid, cosineSimilarity, createViolation, detectDrift, extractCardFeatures, extractTraceFeatures, getSelectedAlternative, hadViolations, hasValue, isActionBounded, isActionForbidden, isCardExpired, verifyTrace, wasEscalated };
+export { ALGORITHM_VERSION, type APTrace, type Action, type ActionCategory, type ActionTarget, type ActionType, type AgentCoherenceSummary, type AlignmentCard, type AlignmentCardRequest, type AlignmentCardResponse, type Alternative, type AuditCommitment, type AuditStorage, type AutonomyEnvelope, type AutonomyScope, CLUSTER_COMPATIBILITY_THRESHOLD, CONFLICT_PENALTY_MULTIPLIER, type Coherence, type CoherenceResult, type CoherenceResultMessage, DEFAULT_SIMILARITY_THRESHOLD, DEFAULT_SUSTAINED_TURNS_THRESHOLD, type DataSharing, type Decision, type DriftAlert, type DriftAnalysis, type DriftDirection, type DriftIndicator, EU_COMPLIANCE_AUDIT_COMMITMENT, EU_COMPLIANCE_EXTENSIONS, EU_COMPLIANCE_VALUES, type Escalation, type EscalationStatus, type EscalationTrigger, type FaultLine, type FaultLineAlignment, type FaultLineAnalysis, type FaultLineClassification, type FaultLineSummary, type FleetCluster, type FleetCoherenceResult, type FleetOutlier, type HierarchyType, MAX_TFIDF_FEATURES, MIN_COHERENCE_FOR_PROCEED, MIN_WORD_LENGTH, type MonetaryValue, NEAR_BOUNDARY_THRESHOLD, OUTLIER_STD_DEV_THRESHOLD, type PairwiseEntry, type Principal, type PrincipalResponse, type PrincipalType, type ProposedCollaboration, type ProposedResolution, type RelationshipType, type RequesterInfo, type Severity, type Signature, type StorageType, type TamperEvidence, type TaskContext, type TraceContext, type TriggerAction, type TriggerCheck, VIOLATION_SEVERITY, type ValueAlignment, type ValueAlignmentDetail, type ValueCoherenceCheck, type ValueCoherenceMessage, type ValueConflict, type ValueConflictResult, type ValueDefinition, type ValueDivergence, type Values, type VerificationMetadata, type VerificationResult, type Violation, type ViolationType, type Warning, analyzeFaultLines, checkCoherence, checkFleetCoherence, checkFleetFaultLines, computeCentroid, cosineSimilarity, createViolation, detectDrift, extractCardFeatures, extractTraceFeatures, getSelectedAlternative, hadViolations, hasValue, isActionBounded, isActionForbidden, isCardExpired, verifyTrace, wasEscalated };

package/dist/index.d.ts

@@ -501,6 +501,76 @@ interface FleetCoherenceResult {
     /** Per-agent coherence summaries */
     agent_summaries: AgentCoherenceSummary[];
 }
+/** Classification of a fault line's nature. */
+type FaultLineClassification = 'resolvable' | 'priority_mismatch' | 'incompatible' | 'complementary';
+/** A single fault line — a value dimension that splits the fleet. */
+interface FaultLine {
+    /** Deterministic ID for this fault line */
+    id: string;
+    /** The value in question */
+    value: string;
+    /** How the fault line is classified */
+    classification: FaultLineClassification;
+    /** Severity based on impact_score */
+    severity: Severity;
+    /** Agent IDs that declare this value */
+    agents_declaring: string[];
+    /** Agent IDs missing this value */
+    agents_missing: string[];
+    /** Agent IDs whose conflicts_with includes this value */
+    agents_conflicting: string[];
+    /** Weighted impact score (0.0 to 1.0) */
+    impact_score: number;
+    /** Plain-English resolution hint */
+    resolution_hint: string;
+    /** Bounded actions shared by all involved agents */
+    affects_capabilities: string[];
+}
+/** Aggregated summary of fault lines by classification. */
+interface FaultLineSummary {
+    /** Total number of fault lines */
+    total: number;
+    /** Count of resolvable fault lines */
+    resolvable: number;
+    /** Count of priority_mismatch fault lines */
+    priority_mismatch: number;
+    /** Count of incompatible fault lines */
+    incompatible: number;
+    /** Count of complementary fault lines */
+    complementary: number;
+    /** Count of critical-severity fault lines */
+    critical_count: number;
+}
+/** A pattern where the same set of agents is consistently isolated across multiple fault lines. */
+interface FaultLineAlignment {
+    /** Deterministic ID */
+    id: string;
+    /** IDs of the fault lines that form this alignment */
+    fault_line_ids: string[];
+    /** Agents consistently missing from this group of fault lines */
+    minority_agents: string[];
+    /** Agents consistently declaring this group of fault lines */
+    majority_agents: string[];
+    /** Mean Jaccard similarity within the alignment group */
+    alignment_score: number;
+    /** Severity of the alignment pattern */
+    severity: Severity;
+    /** Human-readable description */
+    description: string;
+}
+/** Full fault line analysis result. */
+interface FaultLineAnalysis {
+    /** Deterministic analysis identifier */
+    analysis_id: string;
+    /** Fleet coherence score (from FleetCoherenceResult) */
+    fleet_score: number;
+    /** Detected fault lines, sorted by severity then impact_score desc */
+    fault_lines: FaultLine[];
+    /** Detected alignment patterns */
+    alignments: FaultLineAlignment[];
+    /** Counts by classification */
+    summary: FaultLineSummary;
+}
 
 /**
  * AAP Verification API - The three public entry points.
@@ -586,6 +656,38 @@ declare function checkFleetCoherence(cards: Array<{
  * @returns List of DriftAlert objects for detected drift events
  */
 declare function detectDrift(card: AlignmentCard, traces: APTrace[], similarityThreshold?: number, sustainedThreshold?: number): DriftAlert[];
+/**
+ * Analyze fault lines in a fleet based on a FleetCoherenceResult.
+ *
+ * @param coherenceResult - Result from checkFleetCoherence
+ * @param cards - Same agent cards passed to checkFleetCoherence
+ * @param options - Optional reputationScores and taskContext
+ * @returns FaultLineAnalysis with fault lines and alignment patterns
+ */
+declare function analyzeFaultLines(coherenceResult: FleetCoherenceResult, cards: Array<{
+    agentId: string;
+    card: AlignmentCard;
+}>, options?: {
+    reputationScores?: Record<string, number>;
+    taskContext?: string;
+}): FaultLineAnalysis;
+/**
+ * Convenience wrapper: run fleet coherence then fault line analysis in one call.
+ *
+ * @param cards - Array of agent cards
+ * @param options - Optional reputationScores and taskContext
+ * @returns Both FleetCoherenceResult and FaultLineAnalysis
+ */
+declare function checkFleetFaultLines(cards: Array<{
+    agentId: string;
+    card: AlignmentCard;
+}>, options?: {
+    reputationScores?: Record<string, number>;
+    taskContext?: string;
+}): {
+    coherence: FleetCoherenceResult;
+    analysis: FaultLineAnalysis;
+};
 
 /**
  * Value Coherence Handshake messages - Agent-to-agent alignment verification.
@@ -857,4 +959,4 @@ declare const EU_COMPLIANCE_EXTENSIONS: {
 /** Recommended declared values for Article 50 transparency obligations. */
 declare const EU_COMPLIANCE_VALUES: readonly ["transparency", "honesty", "user_control", "principal_benefit"];
 
-export { ALGORITHM_VERSION, type APTrace, type Action, type ActionCategory, type ActionTarget, type ActionType, type AgentCoherenceSummary, type AlignmentCard, type AlignmentCardRequest, type AlignmentCardResponse, type Alternative, type AuditCommitment, type AuditStorage, type AutonomyEnvelope, type AutonomyScope, CLUSTER_COMPATIBILITY_THRESHOLD, CONFLICT_PENALTY_MULTIPLIER, type Coherence, type CoherenceResult, type CoherenceResultMessage, DEFAULT_SIMILARITY_THRESHOLD, DEFAULT_SUSTAINED_TURNS_THRESHOLD, type DataSharing, type Decision, type DriftAlert, type DriftAnalysis, type DriftDirection, type DriftIndicator, EU_COMPLIANCE_AUDIT_COMMITMENT, EU_COMPLIANCE_EXTENSIONS, EU_COMPLIANCE_VALUES, type Escalation, type EscalationStatus, type EscalationTrigger, type FleetCluster, type FleetCoherenceResult, type FleetOutlier, type HierarchyType, MAX_TFIDF_FEATURES, MIN_COHERENCE_FOR_PROCEED, MIN_WORD_LENGTH, type MonetaryValue, NEAR_BOUNDARY_THRESHOLD, OUTLIER_STD_DEV_THRESHOLD, type PairwiseEntry, type Principal, type PrincipalResponse, type PrincipalType, type ProposedCollaboration, type ProposedResolution, type RelationshipType, type RequesterInfo, type Severity, type Signature, type StorageType, type TamperEvidence, type TaskContext, type TraceContext, type TriggerAction, type TriggerCheck, VIOLATION_SEVERITY, type ValueAlignment, type ValueAlignmentDetail, type ValueCoherenceCheck, type ValueCoherenceMessage, type ValueConflict, type ValueConflictResult, type ValueDefinition, type ValueDivergence, type Values, type VerificationMetadata, type VerificationResult, type Violation, type ViolationType, type Warning, checkCoherence, checkFleetCoherence, computeCentroid, cosineSimilarity, createViolation, detectDrift, extractCardFeatures, extractTraceFeatures, getSelectedAlternative, hadViolations, hasValue, isActionBounded, isActionForbidden, isCardExpired, verifyTrace, wasEscalated };
+export { ALGORITHM_VERSION, type APTrace, type Action, type ActionCategory, type ActionTarget, type ActionType, type AgentCoherenceSummary, type AlignmentCard, type AlignmentCardRequest, type AlignmentCardResponse, type Alternative, type AuditCommitment, type AuditStorage, type AutonomyEnvelope, type AutonomyScope, CLUSTER_COMPATIBILITY_THRESHOLD, CONFLICT_PENALTY_MULTIPLIER, type Coherence, type CoherenceResult, type CoherenceResultMessage, DEFAULT_SIMILARITY_THRESHOLD, DEFAULT_SUSTAINED_TURNS_THRESHOLD, type DataSharing, type Decision, type DriftAlert, type DriftAnalysis, type DriftDirection, type DriftIndicator, EU_COMPLIANCE_AUDIT_COMMITMENT, EU_COMPLIANCE_EXTENSIONS, EU_COMPLIANCE_VALUES, type Escalation, type EscalationStatus, type EscalationTrigger, type FaultLine, type FaultLineAlignment, type FaultLineAnalysis, type FaultLineClassification, type FaultLineSummary, type FleetCluster, type FleetCoherenceResult, type FleetOutlier, type HierarchyType, MAX_TFIDF_FEATURES, MIN_COHERENCE_FOR_PROCEED, MIN_WORD_LENGTH, type MonetaryValue, NEAR_BOUNDARY_THRESHOLD, OUTLIER_STD_DEV_THRESHOLD, type PairwiseEntry, type Principal, type PrincipalResponse, type PrincipalType, type ProposedCollaboration, type ProposedResolution, type RelationshipType, type RequesterInfo, type Severity, type Signature, type StorageType, type TamperEvidence, type TaskContext, type TraceContext, type TriggerAction, type TriggerCheck, VIOLATION_SEVERITY, type ValueAlignment, type ValueAlignmentDetail, type ValueCoherenceCheck, type ValueCoherenceMessage, type ValueConflict, type ValueConflictResult, type ValueDefinition, type ValueDivergence, type Values, type VerificationMetadata, type VerificationResult, type Violation, type ViolationType, type Warning, analyzeFaultLines, checkCoherence, checkFleetCoherence, checkFleetFaultLines, computeCentroid, cosineSimilarity, createViolation, detectDrift, extractCardFeatures, extractTraceFeatures, getSelectedAlternative, hadViolations, hasValue, isActionBounded, isActionForbidden, isCardExpired, verifyTrace, wasEscalated };

package/dist/index.js

@@ -34,8 +34,10 @@ __export(index_exports, {
   NEAR_BOUNDARY_THRESHOLD: () => NEAR_BOUNDARY_THRESHOLD,
   OUTLIER_STD_DEV_THRESHOLD: () => OUTLIER_STD_DEV_THRESHOLD,
   VIOLATION_SEVERITY: () => VIOLATION_SEVERITY,
+  analyzeFaultLines: () => analyzeFaultLines,
   checkCoherence: () => checkCoherence,
   checkFleetCoherence: () => checkFleetCoherence,
+  checkFleetFaultLines: () => checkFleetFaultLines,
   computeCentroid: () => computeCentroid,
   cosineSimilarity: () => cosineSimilarity,
   createViolation: () => createViolation,
@@ -710,6 +712,297 @@ function detectDrift(card, traces, similarityThreshold = DEFAULT_SIMILARITY_THRE
   }
   return alerts;
 }
+function deterministicHex(input, length) {
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    const char = input.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16).padStart(length, "0").slice(0, length);
+}
+function jaccardSimilarity(a, b) {
+  const setA = new Set(a);
+  const setB = new Set(b);
+  const intersection = [...setA].filter((x) => setB.has(x)).length;
+  const union = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
+  return union === 0 ? 0 : intersection / union;
+}
+var ROLE_KEYWORDS = [
+  "safety",
+  "executive",
+  "cfo",
+  "analyst",
+  "compliance",
+  "legal",
+  "risk",
+  "finance",
+  "security",
+  "ethics",
+  "audit",
+  "ops",
+  "operations"
+];
+function hasRoleKeyword(agentId) {
+  const lower = agentId.toLowerCase();
+  return ROLE_KEYWORDS.some((kw) => lower.includes(kw));
+}
+function getClpiRole(card) {
+  const ext = card.extensions;
+  if (!ext) return null;
+  const clpi = ext["clpi"];
+  if (!clpi || typeof clpi["role"] !== "string") return null;
+  return clpi["role"] || null;
+}
+function analyzeFaultLines(coherenceResult, cards, options) {
+  const reputationScores = options?.reputationScores;
+  const agentBoundedActions = /* @__PURE__ */ new Map();
+  for (const { agentId, card } of cards) {
+    agentBoundedActions.set(agentId, card.autonomy_envelope?.bounded_actions ?? []);
+  }
+  const agentConflictMap = /* @__PURE__ */ new Map();
+  for (const { agentId, card } of cards) {
+    agentConflictMap.set(agentId, new Set(card.values.conflicts_with ?? []));
+  }
+  const agentRoleMap = /* @__PURE__ */ new Map();
+  for (const { agentId, card } of cards) {
+    agentRoleMap.set(agentId, getClpiRole(card));
+  }
+  const faultLines = [];
+  for (const divergence of coherenceResult.divergence_report) {
+    const {
+      value,
+      agents_declaring,
+      agents_missing,
+      agents_conflicting,
+      impact_on_fleet_score
+    } = divergence;
+    const involvedAgents = [
+      .../* @__PURE__ */ new Set([...agents_declaring, ...agents_missing, ...agents_conflicting])
+    ];
+    let classification;
+    if (agents_conflicting.length > 0) {
+      classification = "incompatible";
+    } else if (agents_declaring.length >= 2 && (() => {
+      for (let i = 0; i < agents_declaring.length; i++) {
+        for (let j = i + 1; j < agents_declaring.length; j++) {
+          const idA = agents_declaring[i];
+          const idB = agents_declaring[j];
+          const entry = coherenceResult.pairwise_matrix.find(
+            (p) => p.agent_a === idA && p.agent_b === idB || p.agent_a === idB && p.agent_b === idA
+          );
+          if (entry && entry.result.score < 0.5) {
+            return true;
+          }
+        }
+      }
+      return false;
+    })()) {
+      classification = "priority_mismatch";
+    } else if (agents_declaring.length >= 1 && agents_missing.length >= 1 && (() => {
+      const declaringRoles = new Set(agents_declaring.map((id2) => agentRoleMap.get(id2) ?? null).filter(Boolean));
+      const missingRoles = new Set(agents_missing.map((id2) => agentRoleMap.get(id2) ?? null).filter(Boolean));
+      if (declaringRoles.size > 0) {
+        const declaringRoleArr = [...declaringRoles];
+        const isRoleExclusive = declaringRoleArr.every((role) => !missingRoles.has(role));
+        if (isRoleExclusive) return true;
+      }
+      const allInvolved = [...agents_declaring, ...agents_missing];
+      return allInvolved.some((id2) => hasRoleKeyword(id2));
+    })()) {
+      classification = "complementary";
+    } else {
+      classification = "resolvable";
+    }
+    let coordinationOverlap;
+    if (involvedAgents.length < 2) {
+      coordinationOverlap = 0.5;
+    } else {
+      const actionSets = involvedAgents.map((id2) => agentBoundedActions.get(id2) ?? []);
+      const nonEmpty = actionSets.filter((s) => s.length > 0);
+      if (nonEmpty.length < 2) {
+        coordinationOverlap = 0.5;
+      } else {
+        let total = 0;
+        let count = 0;
+        for (let i = 0; i < nonEmpty.length; i++) {
+          for (let j = i + 1; j < nonEmpty.length; j++) {
+            total += jaccardSimilarity(nonEmpty[i], nonEmpty[j]);
+            count++;
+          }
+        }
+        coordinationOverlap = count > 0 ? total / count : 0.5;
+      }
+    }
+    let impactScore = impact_on_fleet_score * coordinationOverlap;
+    if (reputationScores && involvedAgents.length > 0) {
+      const repValues = involvedAgents.map((id2) => (reputationScores[id2] ?? 500) / 1e3).map((r) => Math.max(1e-3, r));
+      const logSum = repValues.reduce((sum, r) => sum + Math.log(r), 0);
+      const geoMean = Math.exp(logSum / repValues.length);
+      impactScore *= geoMean;
+    }
+    impactScore = Math.min(1, Math.max(0, impactScore));
+    let severity;
+    if (impactScore >= 0.7) {
+      severity = "critical";
+    } else if (impactScore >= 0.4) {
+      severity = "high";
+    } else if (impactScore >= 0.2) {
+      severity = "medium";
+    } else {
+      severity = "low";
+    }
+    let resolutionHint;
+    switch (classification) {
+      case "resolvable":
+        resolutionHint = `Add value '${value}' to ${agents_missing.join(", ")} alignment card(s).`;
+        break;
+      case "priority_mismatch":
+        resolutionHint = `Align priority/definition of '${value}' across all declaring agents.`;
+        break;
+      case "incompatible":
+        resolutionHint = `Value '${value}' conflicts with ${agents_conflicting.join(", ")}. Requires human review.`;
+        break;
+      case "complementary":
+        resolutionHint = `Value '${value}' divergence appears intentional given agent specializations.`;
+        break;
+    }
+    let affectsCapabilities = [];
+    if (involvedAgents.length > 0) {
+      const firstActions = agentBoundedActions.get(involvedAgents[0]) ?? [];
+      affectsCapabilities = firstActions.filter(
+        (action) => involvedAgents.every((id2) => (agentBoundedActions.get(id2) ?? []).includes(action))
+      );
+    }
+    const idInput = [value, ...involvedAgents.sort()].join("|");
+    const id = deterministicHex(idInput, 12);
+    faultLines.push({
+      id,
+      value,
+      classification,
+      severity,
+      agents_declaring,
+      agents_missing,
+      agents_conflicting,
+      impact_score: Math.round(impactScore * 1e4) / 1e4,
+      resolution_hint: resolutionHint,
+      affects_capabilities: affectsCapabilities
+    });
+  }
+  const severityOrder = {
+    critical: 0,
+    high: 1,
+    medium: 2,
+    low: 3
+  };
+  faultLines.sort((a, b) => {
+    const sev = severityOrder[a.severity] - severityOrder[b.severity];
+    if (sev !== 0) return sev;
+    return b.impact_score - a.impact_score;
+  });
+  const alignments = [];
+  const grouped = /* @__PURE__ */ new Map();
+  const groupAssignment = /* @__PURE__ */ new Map();
+  let nextGroupId = 0;
+  for (let i = 0; i < faultLines.length; i++) {
+    for (let j = i + 1; j < faultLines.length; j++) {
+      const sim = jaccardSimilarity(faultLines[i].agents_missing, faultLines[j].agents_missing);
+      if (sim > 0.6) {
+        const gi = groupAssignment.get(i);
+        const gj = groupAssignment.get(j);
+        if (gi === void 0 && gj === void 0) {
+          const gid = nextGroupId++;
+          grouped.set(gid, [i, j]);
+          groupAssignment.set(i, gid);
+          groupAssignment.set(j, gid);
+        } else if (gi !== void 0 && gj === void 0) {
+          grouped.get(gi).push(j);
+          groupAssignment.set(j, gi);
+        } else if (gi === void 0 && gj !== void 0) {
+          grouped.get(gj).push(i);
+          groupAssignment.set(i, gj);
+        } else if (gi !== gj) {
+          const smaller = gi < gj ? gj : gi;
+          const larger = gi < gj ? gi : gj;
+          const smallerMembers = grouped.get(smaller) ?? [];
+          const largerMembers = grouped.get(larger) ?? [];
+          const merged = [.../* @__PURE__ */ new Set([...largerMembers, ...smallerMembers])];
+          grouped.set(larger, merged);
+          grouped.delete(smaller);
+          for (const idx of smallerMembers) {
+            groupAssignment.set(idx, larger);
+          }
+        }
+      }
+    }
+  }
+  for (const [, members] of grouped) {
+    if (members.length < 2) continue;
+    const unique = [...new Set(members)];
+    const groupFaultLines = unique.map((i) => faultLines[i]);
+    const minorityAgents = [
+      ...new Set(groupFaultLines.flatMap((fl) => fl.agents_missing))
+    ];
+    const majorityAgents = [
+      ...new Set(groupFaultLines.flatMap((fl) => fl.agents_declaring))
+    ];
+    let jaccardSum = 0;
+    let jaccardCount = 0;
+    for (let i = 0; i < unique.length; i++) {
+      for (let j = i + 1; j < unique.length; j++) {
+        jaccardSum += jaccardSimilarity(
+          groupFaultLines[i].agents_missing,
+          groupFaultLines[j].agents_missing
+        );
+        jaccardCount++;
+      }
+    }
+    const alignmentScore = jaccardCount > 0 ? jaccardSum / jaccardCount : 0;
+    const hasHigherSeverity = groupFaultLines.some(
+      (fl) => fl.severity === "critical" || fl.severity === "high"
+    );
+    let severity = unique.length >= 3 ? "high" : "medium";
+    if (hasHigherSeverity && severity === "medium") {
+      severity = "high";
+    }
+    const sortedFaultLineIds = groupFaultLines.map((fl) => fl.id).sort();
+    const alignmentId = deterministicHex(sortedFaultLineIds.join("|"), 12);
+    alignments.push({
+      id: alignmentId,
+      fault_line_ids: sortedFaultLineIds,
+      minority_agents: minorityAgents,
+      majority_agents: majorityAgents,
+      alignment_score: Math.round(alignmentScore * 1e4) / 1e4,
+      severity,
+      description: `${groupFaultLines.length} fault lines consistently isolate ${minorityAgents.join(", ")} from the team`
+    });
+  }
+  const summary = {
+    total: faultLines.length,
+    resolvable: faultLines.filter((fl) => fl.classification === "resolvable").length,
+    priority_mismatch: faultLines.filter((fl) => fl.classification === "priority_mismatch").length,
+    incompatible: faultLines.filter((fl) => fl.classification === "incompatible").length,
+    complementary: faultLines.filter((fl) => fl.classification === "complementary").length,
+    critical_count: faultLines.filter((fl) => fl.severity === "critical").length
+  };
+  const analysisIdInput = [
+    String(coherenceResult.fleet_score),
+    ...faultLines.map((fl) => fl.id).sort()
+  ].join("|");
+  const analysisId = deterministicHex(analysisIdInput, 16);
+  return {
+    analysis_id: analysisId,
+    fleet_score: coherenceResult.fleet_score,
+    fault_lines: faultLines,
+    alignments,
+    summary
+  };
+}
+function checkFleetFaultLines(cards, options) {
+  const coherence = checkFleetCoherence(cards);
+  const analysis = analyzeFaultLines(coherence, cards, options);
+  return { coherence, analysis };
+}
 function evaluateCondition(condition, trace) {
   if (!condition) {
     return false;
@@ -720,7 +1013,7 @@ function evaluateCondition(condition, trace) {
     const actual = trace.action.type ?? "";
     return actual === expected;
   }
-  const numericMatch = condition.match(/(\w+)\s*([><=!]+)\s*(\d+(?:\.\d+)?)/);
+  const numericMatch = condition.match(/^\s*(\w+)\s*([><=!]+)\s*(\d+(?:\.\d+)?)\s*$/);
   if (numericMatch) {
     const [, field, op, valueStr] = numericMatch;
     const value = parseFloat(valueStr);
@@ -886,8 +1179,10 @@ var EU_COMPLIANCE_VALUES = [
   NEAR_BOUNDARY_THRESHOLD,
   OUTLIER_STD_DEV_THRESHOLD,
   VIOLATION_SEVERITY,
+  analyzeFaultLines,
   checkCoherence,
   checkFleetCoherence,
+  checkFleetFaultLines,
   computeCentroid,
   cosineSimilarity,
   createViolation,