PRAHARI प्रहरी

Overview

PRAHARI manages a constellation of 144 quantum-derived seeds harvested from IBM Quantum processors (ibm_marrakesh). These seeds provide the entropy foundation for ML-KEM-768 key generation in ANNEX, eliminating dependence on classical PRNGs alone.

The system includes a Hurwitz quaternion simulator for test environments, an Entropy Sentinel for quality scoring (NPU-accelerated via TIVRA), and a Ternary-144 addressing scheme built on TRIBHUJ mathematics.

SteadywatchSeedStore

The core class that manages the satellite seed constellation:

import { initialize, getHybridSeed, seedStore } from 'yakmesh/security/steadywatch';

// Initialize with real quantum seeds
await initialize({
  seedFile: './data/steadywatch-seeds-p5.json',
  nodeIndex: 42,      // DOKO ceremony assigns this
  prime: 5,           // Hurwitz prime
});

// Or generate test seeds (Hurwitz quaternion simulation)
await initialize({
  generateTest: true,
  prime: 5,
  inferenceEngine: accelInference,  // Optional: wire NPU for Entropy Sentinel
});

Seed File Format

Seeds are stored as JSON with hex-encoded 32-byte values:

{
  "prime": 5,
  "generated": "2026-02-18T...",
  "source": "ibm_marrakesh",
  "seeds": [
    "a3f8e1d4c7b2...  (64 hex chars = 32 bytes)",
    "7b9c0e5a2f1d...  (64 hex chars = 32 bytes)",
    ...  // 144 seeds total
  ]
}

Hurwitz Quaternion Simulation

For development and testing, PRAHARI generates deterministic-but-unpredictable seeds using Hurwitz quaternions parameterized by a prime p:

This ensures each seed is unique (SHA3 collision resistance), deterministic (reproducible from prime + index), and statistically indistinguishable from random bytes.

Hybrid Seed Algorithm

getHybridSeed() is the primary integration point — called by ANNEX before every ML-KEM-768 keygen. It produces a 64-byte seed by combining quantum satellite entropy with local CSPRNG:

import { getHybridSeed } from 'yakmesh/security/steadywatch';

// Returns 64-byte Uint8Array for ML-KEM-768 keygen
const seed = getHybridSeed();

// Even if the satellite seeds are compromised, the CSPRNG XOR
// ensures the hybrid seed remains at least as strong as local
// entropy. If local CSPRNG is compromised, the quantum entropy
// provides an independent source. Both must fail simultaneously.

Ternary-144 Addressing

Each satellite receives a 6-trit balanced ternary address and belongs to one of three SST families:

SST Family Groups

6-Trit Addresses

Satellites are addressed using balanced ternary (digits T=-1, 0, 1). The 144th satellite has address 1TT100 in balanced ternary. Lookups work by trit address:

import { getSeedByTritAddress } from 'yakmesh/security/steadywatch';

// Look up seed by its 6-trit address
const result = getSeedByTritAddress('1TT100');  // satellite #144
// { seed: Uint8Array(32), index: 143 }

Fibonacci-Cycle Selection

The Fibonacci digital root sequence repeats every 24 positions (the Pisano period for mod-9). PRAHARI uses this cycle to determine which SST family to draw seeds from:

import { selectByFibonacciCycle } from 'yakmesh/security/steadywatch';

const pick = selectByFibonacciCycle();
// {
//   index: 87,
//   seed: Uint8Array(32),
//   family: 'B',
//   fibPosition: 5,
//   fibRoot: 8,
//   address: '01T110'
// }

// Fibonacci digital root cycle (24 positions):
// 1,1,2,3,5,8,4,3,7,1,8,9,8,8,7,6,4,1,5,6,2,8,1,9
// Maps: roots 1,4,7 → Family A | 2,5,8 → Family B | 3,6,9 → Family C
// Positions 12 and 24: root = 9 → singularity marker (Family C)

Entropy Sentinel

The EntropySentinel scores the quality of seed material before it enters keygen. When an ONNX model is loaded and an NPU/GPU is available (via TIVRA), it uses hardware-accelerated pattern detection. Otherwise, it runs four software statistical tests:

The combined score maps to a TRIBHUJ ternary verdict:

import { scoreEntropy } from 'yakmesh/security/steadywatch';

const result = await scoreEntropy(seedBytes);
// {
//   score: 0.94,
//   verdict: Trit(POSITIVE),
//   method: 'npu',          // or 'gpu' or 'cpu'
//   details: { bitEntropyPerByte: 7.82, chiSquare: 241.3, ... }
// }

Batch Quality Consensus

After loading all 144 seeds, batchQualityConsensus() aggregates every seed's ternary quality verdict using TritArray.majority():

import { batchQualityConsensus } from 'yakmesh/security/steadywatch';

const consensus = batchQualityConsensus();
// {
//   majority: Trit(POSITIVE),   // overall quality verdict
//   counts: { negative: 2, neutral: 12, positive: 130 },
//   total: 144,
//   balanced: false              // true only if all three are equal
// }

// POSITIVE majority → high-quality quantum entropy
// NEUTRAL majority  → mixed quality (acceptable)
// NEGATIVE majority → WARNING: seeds may be compromised

API Reference

Version History