npm install @claude-flow/plugin-prime-radiant

const result = await mcp.call('pr_coherence_check', {
  vectors: [
    embedding("The project deadline is Friday"),
    embedding("We have two more weeks"),
    embedding("The deadline was moved to next month")
  ],
  threshold: 0.3
});

// Result
{
  coherent: false,
  energy: 0.72,  // High energy = contradiction
  violations: ["Statement 3 contradicts statements 1-2"],
  confidence: 0.28
}

const consensus = await mcp.call('pr_consensus_verify', {
  agentStates: [
    { agentId: 'researcher', embedding: [...], vote: true },
    { agentId: 'analyst', embedding: [...], vote: true },
    { agentId: 'reviewer', embedding: [...], vote: false }
  ],
  consensusThreshold: 0.8
});

// Result
{
  consensusAchieved: true,
  agreementRatio: 0.87,
  coherenceEnergy: 0.12,  // Low = they genuinely agree
  spectralStability: true
}

const stability = await mcp.call('pr_spectral_analyze', {
  adjacencyMatrix: [
    [0, 1, 1, 0, 0],
    [1, 0, 1, 1, 0],
    [1, 1, 0, 1, 1],
    [0, 1, 1, 0, 1],
    [0, 0, 1, 1, 0]
  ],
  analyzeType: 'stability'
});

// Result
{
  stable: true,
  spectralGap: 0.25,      // Higher = more stable
  stabilityIndex: 0.78,
  eigenvalues: [2.73, 0.73, -0.73, -2.73, 0],
  clustering: 0.6         // How well agents cluster
}

const causal = await mcp.call('pr_causal_infer', {
  treatment: 'agent_count',
  outcome: 'task_completion_time',
  graph: {
    nodes: ['agent_count', 'coordination_overhead', 'task_completion_time', 'task_complexity'],
    edges: [
      ['agent_count', 'task_completion_time'],
      ['agent_count', 'coordination_overhead'],
      ['coordination_overhead', 'task_completion_time'],
      ['task_complexity', 'agent_count'],
      ['task_complexity', 'task_completion_time']
    ]
  }
});

// Result
{
  causalEffect: -0.35,  // Adding agents REDUCES completion time
  confounders: ['task_complexity'],  // This affects both
  interventionValid: true,
  backdoorPaths: [['agent_count', 'task_complexity', 'task_completion_time']]
}

const result = await mcp.call('pr_memory_gate', {
  entry: {
    key: 'project-status',
    content: 'Project is on track for Friday deadline',
    embedding: embedding("Project is on track for Friday deadline")
  },
  contextEmbeddings: [
    embedding("Deadline extended to next month"),  // Already stored
    embedding("Team requested more time")          // Already stored
  ],
  thresholds: {
    warn: 0.3,
    reject: 0.7
  }
});

// Result
{
  action: 'reject',  // Blocked from storage
  energy: 0.82,
  reason: 'Contradicts existing information about deadline',
  existingConflicts: ['Deadline extended to next month']
}

// Hook automatically runs before RAG retrieval
// If retrieved docs contradict each other, it filters to the most coherent subset

const context = await rag.retrieve('What is the project deadline?');

// If docs were contradictory:
{
  documents: [...],  // Filtered to consistent subset
  coherenceFiltered: true,
  originalCount: 5,
  filteredCount: 3,
  removedForCoherence: ['doc-4', 'doc-5'],
  originalCoherenceEnergy: 0.68
}

const topology = await mcp.call('pr_quantum_topology', {
  points: embeddings,  // Array of embedding vectors
  maxDimension: 2
});

// Result
{
  bettiNumbers: {
    b0: 3,   // 3 connected components (clusters)
    b1: 1,   // 1 loop (circular relationship)
    b2: 0    // No voids
  },
  persistenceDiagram: [...],  // Birth-death pairs
  significantFeatures: [
    { dimension: 0, persistence: 0.8, interpretation: 'Strong cluster' },
    { dimension: 1, persistence: 0.3, interpretation: 'Weak cyclical pattern' }
  ]
}

// Run periodically to track swarm health
async function monitorSwarmHealth() {
  const adjacency = await getSwarmAdjacencyMatrix();

  const health = await mcp.call('pr_spectral_analyze', {
    adjacencyMatrix: adjacency,
    analyzeType: 'stability'
  });

  if (!health.stable) {
    console.warn('⚠️ Swarm instability detected!');
    console.log('Spectral gap:', health.spectralGap);
    console.log('Stability index:', health.stabilityIndex);

    // Trigger rebalancing
    await swarm.rebalance();
  }

  if (health.spectralGap < 0.1) {
    console.warn('⚠️ Communication breakdown risk');
    // Add redundant connections
    await swarm.addRedundancy();
  }
}

// Monitor every 30 seconds
setInterval(monitorSwarmHealth, 30000);

class CoherentKnowledgeBase {
  async store(fact: string, embedding: number[]) {
    // Check against all existing knowledge
    const existing = await this.getAllEmbeddings();

    const check = await mcp.call('pr_coherence_check', {
      vectors: [...existing, embedding],
      threshold: 0.3
    });

    if (check.energy > 0.7) {
      throw new Error(`Fact contradicts existing knowledge: ${check.violations[0]}`);
    }

    if (check.energy > 0.3) {
      console.warn(`Warning: Minor inconsistency detected (energy: ${check.energy})`);
    }

    // Safe to store
    await this.db.store(fact, embedding, { coherenceEnergy: check.energy });
  }

  async query(question: string) {
    const results = await this.db.search(question);

    // Verify retrieved results are consistent with each other
    const embeddings = results.map(r => r.embedding);
    const coherence = await mcp.call('pr_coherence_check', {
      vectors: embeddings,
      threshold: 0.3
    });

    if (coherence.energy > 0.5) {
      // Filter to most coherent subset
      return this.filterToCoherent(results, coherence);
    }

    return results;
  }
}

# claude-flow.config.yaml
plugins:
  prime-radiant:
    enabled: true
    config:
      coherence:
        warnThreshold: 0.3    # Warn above this energy
        rejectThreshold: 0.7  # Block above this energy
        cacheEnabled: true
      spectral:
        stabilityThreshold: 0.1
        maxMatrixSize: 1000
      causal:
        maxBackdoorPaths: 10