L1: Identity Layer

Root Key = Argon2id(seed, salt, params)
  │
  ├── SoulKey("identity")  → DID master key
  ├── SoulKey("work")      → Professional context
  ├── SoulKey("personal")  → Personal context
  ├── SoulKey("device-1")  → Per-device keys
  └── ... unlimited derived keys

did:libertaria:z8m9n0p2q4r6s8t0u2v4w6x8y0z2a4b6c8d0e2f4g6h8i0

initial_key = SoulKey(seed, context="identity")
method-specific-id = multibase(base58btc, BLAKE3-256(initial_key.public_key))

{
  "@context": ["https://www.w3.org/ns/did/v1"],
  "id": "did:libertaria:z8m9n0p2q4r...",
  "verificationMethod": [{
    "id": "did:libertaria:z8m9n...#auth-1",
    "type": "Ed25519VerificationKey2020",
    "controller": "did:libertaria:z8m9n...",
    "publicKeyMultibase": "z6Mk..."
  }],
  "authentication": ["did:libertaria:z8m9n...#auth-1"],
  "keyAgreement": ["did:libertaria:z8m9n...#key-1"],
  "service": [{
    "id": "did:libertaria:z8m9n...#capsule",
    "type": "CapsuleNode",
    "serviceEndpoint": "https://capsule.libertaria.app/z8m9n..."
  }],
  "qvl": {
    "trustScore": 0.87,
    "betrayalRisk": "low",
    "chapters": ["chapter://berlin/core"]
  }
}

pub struct TrustEdge {
    pub source: DidId,           // Who trusts
    pub target: DidId,           // Who is trusted
    pub weight: f64,             // -1.0 (distrust) to +1.0 (trust)
    pub timestamp: Timestamp,    // When established
    pub decay_rate: f64,         // Temporal decay half-life
    pub proof: Option<Signature>, // Cryptographic attestation
}

pub struct TrustGraph {
    pub edges: Vec<TrustEdge>,
    pub nodes: HashSet<DidId>,
}

Effective_Weight = Weight * exp(-λ * Δt)

Where:
  λ = decay_rate (configured per edge)
  Δt = time since timestamp

fn compute_trust(graph: &TrustGraph, source: DidId, target: DidId) -> TrustScore {
    // 1. Find all paths (max depth 6)
    let paths = graph.find_all_paths(source, target, max_depth=6);

    // 2. Compute path weights with decay
    let path_scores: Vec<f64> = paths.iter()
        .map(|p| p.edges.iter()
            .map(|e| e.weight * temporal_decay(e.timestamp))
            .product())
        .collect();

    // 3. Aggregate (parallel resistance model)
    TrustScore::aggregate(path_scores)
}

Alice trusts Bob (+0.8)
Bob trusts Carol (+0.8)
Carol trusts Alice (+0.8)

If Carol defects: She gains from Alice's trust without reciprocating

// Standard Bellman-Ford algorithm
// If negative cycle exists: betrayal risk detected

pub fn detect_betrayal_risk(graph: &TrustGraph) -> Vec<BetrayalRisk> {
    let mut risks = Vec::new();

    // Run Bellman-Ford on transformed graph
    // Negative cycle = profitable betrayal loop
    if let Some(cycle) = bellman_ford_negative_cycle(graph) {
        risks.push(BetrayalRisk {
            cycle: cycle.nodes,
            severity: compute_severity(cycle),
            evidence: generate_evidence(cycle),
        });
    }

    risks
}

pub struct EntropyStamp {
    pub hash: [u8; 32],
    pub salt: [u8; 16],
    pub difficulty: u8,
    pub timestamp: Timestamp,
}

// Kenya-compliant parameters
pub const KENYA_CONFIG: Argon2Config = Argon2Config {
    time_cost: 2,        // iterations
    memory_cost: 2048,   // 2 MB
    parallelism: 1,      // single thread
};