Sync with GitHub, license metadata from LICENSE files, commercial license notice

metadata license: None -> mit
README: License section kept (already accurate)

README.md

@@ -1,294 +1,300 @@
-```
-██╗     ███████╗██████╗  ██████╗ ███████╗
-██║     ██╔════╝██╔══██╗██╔════╝ ██╔════╝
-██║     █████╗  ██║  ██║██║  ███╗█████╗
-██║     ██╔══╝  ██║  ██║██║   ██║██╔══╝
-███████╗███████╗██████╔╝╚██████╔╝███████╗
-╚══════╝╚══════╝╚═════╝  ╚═════╝ ╚══════╝
-
-  Sovereign Audit Chain · Built in Rust · Open Protocol · MIT
-```
-
-**Every event sealed. Every tamper detected. No trust required.**
-
-[![MIT License](https://img.shields.io/badge/license-MIT-00ff88?style=flat-square)](LICENSE)
-[![Crates.io](https://img.shields.io/crates/v/ledge?style=flat-square&color=00ff88)](https://crates.io/crates/ledge)
-[![npm](https://img.shields.io/npm/v/@snapkitty/ledge?style=flat-square&color=00ff88)](https://www.npmjs.com/package/@snapkitty/ledge)
-[![CI](https://img.shields.io/github/actions/workflow/status/SNAPKITTYWEST/ledge/ci.yml?style=flat-square&label=tests)](https://github.com/SNAPKITTYWEST/ledge/actions)
-
----
-
-## The problem
-
-AI systems are making decisions worth millions of dollars. Financial platforms are processing transactions at scale. Compliance teams are asking one question:
-
-> **"Can you prove what happened — and that no one changed it?"**
-
-Most audit logs are mutable. A database row can be edited. A log file can be overwritten. An S3 object can be replaced. **None of that is proof.**
-
-LEDGE is proof.
-
----
-
-## How it works
-
-```
-Genesis:  SHA256("LEDGE_GENESIS:SOVEREIGN_CHAIN_INIT")
-
-Event 0:  SHA256( genesis   ║ payload_json ║ timestamp_ms ║ 0 )
-Event 1:  SHA256( seal_0    ║ payload_json ║ timestamp_ms ║ 1 )
-Event 2:  SHA256( seal_1    ║ payload_json ║ timestamp_ms ║ 2 )
-  ···
-Merkle:   SHA256 binary tree over all seals → single root fingerprint
-```
-
-Change one byte in any event. Every subsequent seal breaks. The Merkle root changes. **Tamper is instant, total, and mathematically provable.**
-
----
-
-## Market context (VAULT analysis)
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│  WHY THIS EXISTS NOW                                         │
-├─────────────────────────────────────────────────────────────┤
-│  AI audit trail search volume        +340%  since Q1 2026   │
-│  GDPR fines (2025)                   €2.1B  and rising       │
-│  MiCA enforcement begins             Q1 2027                 │
-│  SOX compliance market               $4.2B  12% YoY growth   │
-│  Avg cost of compliance audit fail   $14.8M per incident     │
-│  Enterprise AI governance market     $1.2B → $9.4B by 2030  │
-│  Companies with AI audit solutions   < 4%  of Fortune 500    │
-└─────────────────────────────────────────────────────────────┘
-
-Every enterprise deploying AI has no answer to:
-"How do we audit what the AI decided?"
-
-LEDGE is that answer.
-```
-
----
-
-## Install
-
-```bash
-npm install @snapkitty/ledge
-```
-
-```toml
-[dependencies]
-ledge = "0.1"
-```
-
----
-
-## Usage
-
-### TypeScript / JavaScript
-
-```typescript
-import { initLedge } from '@snapkitty/ledge'
-
-const { createChain } = await initLedge()
-const chain = createChain()
-
-// Seal an AI decision
-chain.seal({
-  agent:    'VAULT',
-  decision: 'APPROVE_PAYMENT',
-  amount:   50000,
-  vendor:   'Acme Corp',
-  reason:   'Invoice verified, funds available',
-})
-
-// Seal a follow-up action
-chain.seal({
-  agent:  'FORGE',
-  action: 'DEPLOY',
-  ref:    'abc1234',
-  env:    'production',
-})
-
-// Verify nothing was tampered with
-const result = chain.verify()
-// { valid: true, eventCount: 2, merkleRoot: '7f3a...', failures: [] }
-
-console.log('Chain root:', chain.merkleRoot())
-// One hex string that fingerprints the entire history
-```
-
-### Rust
-
-```rust
-use ledge::LedgeChain;
-use serde_json::json;
-
-let mut chain = LedgeChain::new();
-
-chain.seal(json!({
-    "agent":    "VAULT",
-    "decision": "APPROVE_PAYMENT",
-    "amount":   50000,
-}), unix_ms());
-
-chain.seal(json!({
-    "agent":  "FORGE",
-    "action": "DEPLOY",
-    "ref":    "abc1234",
-}), unix_ms());
-
-let result = chain.verify();
-assert!(result.valid);
-
-println!("Merkle root: {}", chain.merkle_root());
-```
-
-### Tamper detection
-
-```rust
-chain.events[0].payload = json!({ "amount": 1 }); // tamper
-
-let result = chain.verify();
-assert!(!result.valid);
-assert!(result.failures.contains(&0)); // reports every broken link
-```
-
----
-
-## API
-
-### Rust — `LedgeChain`
-
-| Method | Returns | Description |
-|--------|---------|-------------|
-| `LedgeChain::new()` | `Self` | New chain from genesis |
-| `.seal(payload, timestamp_ms)` | `SealedEvent` | Append and seal an event |
-| `.verify()` | `VerifyResult` | Verify all seals; reports all failures |
-| `.merkle_root()` | `String` | Hex Merkle root of the full chain |
-| `.genesis()` | `String` | Genesis hash (constant per protocol) |
-| `.events()` | `&[SealedEvent]` | Read-only event slice |
-| `.len()` | `usize` | Event count |
-
-### WASM / JavaScript — stateless functions
-
-| Function | Description |
-|----------|-------------|
-| `ledge_genesis()` | Genesis hash hex |
-| `ledge_seal(prev, payload_json, ts, idx)` | Compute one seal hex |
-| `ledge_verify(events_json)` | JSON in → `{valid, failures, merkleRoot, eventCount}` |
-| `ledge_merkle_root(seals_json)` | Build Merkle root from seal array |
-
-### `SealedEvent` shape
-
-```typescript
-{
-  index:        number   // position in chain
-  seal:         string   // 64-char hex SHA-256
-  previousSeal: string   // 64-char hex of prior seal (or genesis)
-  payload:      object   // your data — anything JSON-serializable
-  timestampMs:  number   // unix ms
-}
-```
-
----
-
-## The seal algorithm
-
-```
-seal = SHA256(
-  prev_seal_bytes   // 32 bytes
-  payload_json      // UTF-8 bytes — canonical JSON.stringify
-  timestamp_ms      // u64 big-endian
-  index             // u64 big-endian
-)
-```
-
-Genesis: `SHA256("LEDGE_GENESIS:SOVEREIGN_CHAIN_INIT")`
-
-Open protocol. No secrets. Any party can verify any chain independently.
-
----
-
-## Security model
-
-```
-┌─────────────────────────────────────────────────┐
-│  WHY RUST                                        │
-├─────────────────────────────────────────────────┤
-│  Prototype pollution        impossible           │
-│  Timing attacks             constant-time sha2   │
-│  Memory safety              borrow checker       │
-│  Supply chain risk          3 deps (sha2/hex/    │
-│                             serde) — auditable   │
-│  V8 non-determinism         eliminated           │
-└─────────────────────────────────────────────────┘
-```
-
-TypeScript was rejected for this library. A cryptographic audit trail written in JavaScript is a liability, not an asset.
-
----
-
-## Build from source
-
-```bash
-# Rust library + tests
-cargo build --release
-cargo test
-
-# WASM + JS (requires wasm-pack)
-cargo install wasm-pack
-wasm-pack build --features wasm --target bundler --out-dir pkg
-npm run build:js
-```
-
----
-
-## Use cases
-
-```
-┌──────────────────────────────────────────────────────────────────┐
-│  AI AGENT DECISIONS     Seal every AI output. Prove it wasn't    │
-│                         altered retroactively. SOC 2 ready.      │
-├──────────────────────────────────────────────────────────────────┤
-│  FINANCIAL TRANSACTIONS  Immutable payment sequence. Approval     │
-│                         chain proof. Audit on demand.            │
-├──────────────────────────────────────────────────────────────────┤
-│  DEPLOYMENT RECORDS      Cryptographic record of what shipped,    │
-│                         when, and who approved it.               │
-├──────────────────────────────────────────────────────────────────┤
-│  COMPLIANCE EVIDENCE     SOX · GDPR · MiCA · ISO 27001           │
-│                         Tamper-evident log, Merkle verifiable.   │
-└──────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## Live demo
-
-**[collectivekitty.com/labs/ledge](https://collectivekitty.com/labs/ledge)**
-
-Seal events in the browser. Verify chain integrity. Explore the Merkle tree. No account required.
-
----
-
-## Part of the SnapKitty Sovereign OS
-
-LEDGE is the open protocol layer of a larger sovereign AI operating system. The chain protocol, SDK, and verification tools are MIT-licensed and open forever.
-
-The intelligence behind it — the agent mesh, the orchestration layer, the sovereign OS — runs privately on bare metal. [collectivekitty.com](https://collectivekitty.com)
-
----
-
-## License
-
-MIT — see [LICENSE](LICENSE)
-
----
-
-```
-Built by LOC — Rust kinetic agent
-SnapKitty Sovereign OS · 2026
-"The borrow checker is the security model."
-```
-
-![](https://sovereign-analytics.snapkittywest.workers.dev/canary/ledge)
+---
+license: mit
+tags:
+- snapkitty
+---
+
+```
+██╗     ███████╗██████╗  ██████╗ ███████╗
+██║     ██╔════╝██╔══██╗██╔════╝ ██╔════╝
+██║     █████╗  ██║  ██║██║  ███╗█████╗
+██║     ██╔══╝  ██║  ██║██║   ██║██╔══╝
+███████╗███████╗██████╔╝╚██████╔╝███████╗
+╚══════╝╚══════╝╚═════╝  ╚═════╝ ╚══════╝
+
+  Sovereign Audit Chain · Built in Rust · Open Protocol · MIT
+```
+
+**Every event sealed. Every tamper detected. No trust required.**
+
+[![MIT License](https://img.shields.io/badge/license-MIT-00ff88?style=flat-square)](LICENSE)
+[![Crates.io](https://img.shields.io/crates/v/ledge?style=flat-square&color=00ff88)](https://crates.io/crates/ledge)
+[![npm](https://img.shields.io/npm/v/@snapkitty/ledge?style=flat-square&color=00ff88)](https://www.npmjs.com/package/@snapkitty/ledge)
+[![CI](https://img.shields.io/github/actions/workflow/status/SNAPKITTYWEST/ledge/ci.yml?style=flat-square&label=tests)](https://github.com/SNAPKITTYWEST/ledge/actions)
+
+---
+
+## The problem
+
+AI systems are making decisions worth millions of dollars. Financial platforms are processing transactions at scale. Compliance teams are asking one question:
+
+> **"Can you prove what happened — and that no one changed it?"**
+
+Most audit logs are mutable. A database row can be edited. A log file can be overwritten. An S3 object can be replaced. **None of that is proof.**
+
+LEDGE is proof.
+
+---
+
+## How it works
+
+```
+Genesis:  SHA256("LEDGE_GENESIS:SOVEREIGN_CHAIN_INIT")
+
+Event 0:  SHA256( genesis   ║ payload_json ║ timestamp_ms ║ 0 )
+Event 1:  SHA256( seal_0    ║ payload_json ║ timestamp_ms ║ 1 )
+Event 2:  SHA256( seal_1    ║ payload_json ║ timestamp_ms ║ 2 )
+  ···
+Merkle:   SHA256 binary tree over all seals → single root fingerprint
+```
+
+Change one byte in any event. Every subsequent seal breaks. The Merkle root changes. **Tamper is instant, total, and mathematically provable.**
+
+---
+
+## Market context (VAULT analysis)
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  WHY THIS EXISTS NOW                                         │
+├─────────────────────────────────────────────────────────────┤
+│  AI audit trail search volume        +340%  since Q1 2026   │
+│  GDPR fines (2025)                   €2.1B  and rising       │
+│  MiCA enforcement begins             Q1 2027                 │
+│  SOX compliance market               $4.2B  12% YoY growth   │
+│  Avg cost of compliance audit fail   $14.8M per incident     │
+│  Enterprise AI governance market     $1.2B → $9.4B by 2030  │
+│  Companies with AI audit solutions   < 4%  of Fortune 500    │
+└─────────────────────────────────────────────────────────────┘
+
+Every enterprise deploying AI has no answer to:
+"How do we audit what the AI decided?"
+
+LEDGE is that answer.
+```
+
+---
+
+## Install
+
+```bash
+npm install @snapkitty/ledge
+```
+
+```toml
+[dependencies]
+ledge = "0.1"
+```
+
+---
+
+## Usage
+
+### TypeScript / JavaScript
+
+```typescript
+import { initLedge } from '@snapkitty/ledge'
+
+const { createChain } = await initLedge()
+const chain = createChain()
+
+// Seal an AI decision
+chain.seal({
+  agent:    'VAULT',
+  decision: 'APPROVE_PAYMENT',
+  amount:   50000,
+  vendor:   'Acme Corp',
+  reason:   'Invoice verified, funds available',
+})
+
+// Seal a follow-up action
+chain.seal({
+  agent:  'FORGE',
+  action: 'DEPLOY',
+  ref:    'abc1234',
+  env:    'production',
+})
+
+// Verify nothing was tampered with
+const result = chain.verify()
+// { valid: true, eventCount: 2, merkleRoot: '7f3a...', failures: [] }
+
+console.log('Chain root:', chain.merkleRoot())
+// One hex string that fingerprints the entire history
+```
+
+### Rust
+
+```rust
+use ledge::LedgeChain;
+use serde_json::json;
+
+let mut chain = LedgeChain::new();
+
+chain.seal(json!({
+    "agent":    "VAULT",
+    "decision": "APPROVE_PAYMENT",
+    "amount":   50000,
+}), unix_ms());
+
+chain.seal(json!({
+    "agent":  "FORGE",
+    "action": "DEPLOY",
+    "ref":    "abc1234",
+}), unix_ms());
+
+let result = chain.verify();
+assert!(result.valid);
+
+println!("Merkle root: {}", chain.merkle_root());
+```
+
+### Tamper detection
+
+```rust
+chain.events[0].payload = json!({ "amount": 1 }); // tamper
+
+let result = chain.verify();
+assert!(!result.valid);
+assert!(result.failures.contains(&0)); // reports every broken link
+```
+
+---
+
+## API
+
+### Rust — `LedgeChain`
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `LedgeChain::new()` | `Self` | New chain from genesis |
+| `.seal(payload, timestamp_ms)` | `SealedEvent` | Append and seal an event |
+| `.verify()` | `VerifyResult` | Verify all seals; reports all failures |
+| `.merkle_root()` | `String` | Hex Merkle root of the full chain |
+| `.genesis()` | `String` | Genesis hash (constant per protocol) |
+| `.events()` | `&[SealedEvent]` | Read-only event slice |
+| `.len()` | `usize` | Event count |
+
+### WASM / JavaScript — stateless functions
+
+| Function | Description |
+|----------|-------------|
+| `ledge_genesis()` | Genesis hash hex |
+| `ledge_seal(prev, payload_json, ts, idx)` | Compute one seal hex |
+| `ledge_verify(events_json)` | JSON in → `{valid, failures, merkleRoot, eventCount}` |
+| `ledge_merkle_root(seals_json)` | Build Merkle root from seal array |
+
+### `SealedEvent` shape
+
+```typescript
+{
+  index:        number   // position in chain
+  seal:         string   // 64-char hex SHA-256
+  previousSeal: string   // 64-char hex of prior seal (or genesis)
+  payload:      object   // your data — anything JSON-serializable
+  timestampMs:  number   // unix ms
+}
+```
+
+---
+
+## The seal algorithm
+
+```
+seal = SHA256(
+  prev_seal_bytes   // 32 bytes
+  payload_json      // UTF-8 bytes — canonical JSON.stringify
+  timestamp_ms      // u64 big-endian
+  index             // u64 big-endian
+)
+```
+
+Genesis: `SHA256("LEDGE_GENESIS:SOVEREIGN_CHAIN_INIT")`
+
+Open protocol. No secrets. Any party can verify any chain independently.
+
+---
+
+## Security model
+
+```
+┌─────────────────────────────────────────────────┐
+│  WHY RUST                                        │
+├─────────────────────────────────────────────────┤
+│  Prototype pollution        impossible           │
+│  Timing attacks             constant-time sha2   │
+│  Memory safety              borrow checker       │
+│  Supply chain risk          3 deps (sha2/hex/    │
+│                             serde) — auditable   │
+│  V8 non-determinism         eliminated           │
+└─────────────────────────────────────────────────┘
+```
+
+TypeScript was rejected for this library. A cryptographic audit trail written in JavaScript is a liability, not an asset.
+
+---
+
+## Build from source
+
+```bash
+# Rust library + tests
+cargo build --release
+cargo test
+
+# WASM + JS (requires wasm-pack)
+cargo install wasm-pack
+wasm-pack build --features wasm --target bundler --out-dir pkg
+npm run build:js
+```
+
+---
+
+## Use cases
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│  AI AGENT DECISIONS     Seal every AI output. Prove it wasn't    │
+│                         altered retroactively. SOC 2 ready.      │
+├──────────────────────────────────────────────────────────────────┤
+│  FINANCIAL TRANSACTIONS  Immutable payment sequence. Approval     │
+│                         chain proof. Audit on demand.            │
+├──────────────────────────────────────────────────────────────────┤
+│  DEPLOYMENT RECORDS      Cryptographic record of what shipped,    │
+│                         when, and who approved it.               │
+├──────────────────────────────────────────────────────────────────┤
+│  COMPLIANCE EVIDENCE     SOX · GDPR · MiCA · ISO 27001           │
+│                         Tamper-evident log, Merkle verifiable.   │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Live demo
+
+**[collectivekitty.com/labs/ledge](https://collectivekitty.com/labs/ledge)**
+
+Seal events in the browser. Verify chain integrity. Explore the Merkle tree. No account required.
+
+---
+
+## Part of the SnapKitty Sovereign OS
+
+LEDGE is the open protocol layer of a larger sovereign AI operating system. The chain protocol, SDK, and verification tools are MIT-licensed and open forever.
+
+The intelligence behind it — the agent mesh, the orchestration layer, the sovereign OS — runs privately on bare metal. [collectivekitty.com](https://collectivekitty.com)
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE)
+
+---
+
+```
+Built by LOC — Rust kinetic agent
+SnapKitty Sovereign OS · 2026
+"The borrow checker is the security model."
+```
+
+![](https://sovereign-analytics.snapkittywest.workers.dev/canary/ledge)