Entropy field: [█░░░░░░░░░░░░░░░░░░░] 7.2%
                           ▲
                     threshold 0.21

REPO  ← 166
STACK ← ⌿REPO⍴1
TRUST ← ∧/STACK   ⍝ TRUE
CODE  ← +/STACK   ⍝ 166
Ω     ← TRUST∧CODE

coherent(system) :-
    entropy(E), E < 0.21,     % E = 0.0723 → PASS
    intercoil(_, memory_graph),% 7 connected → PASS
    intercoil(_, bifrost_engine).% 7 connected → PASS

meta_block(valid).

Self-verifying multi-witness proof system — WORM-chain consensus, P/NP swarm solving, deterministic memory layers, and a constitutional cold-boot protocol for sovereign compute.

Ω ← TRUST ∧ CODE — The system is coherent iff the omega-field is sealed and every proof carries three independent witnesses.

SnapKitty is available as a sovereign commercial program for teams that need commercial use rights, support, verification attestations, and private delivery.

Important licensing note:

• This repository remains governed by SOVEREIGN_SOURCE_LICENSE.md.
• The Community tier below applies to designated AGPL-3.0 community releases or modules, not to the full sovereign core by default.
• Paid tiers are the path for commercial deployment, internal enterprise use, OEM embedding, air-gapped installs, and private updates.

• Commercial Use Rights — no AGPL copyleft obligations for licensed deliverables
• Indemnification against covered IP claims
• Support — email, priority support, and SLA-backed support at higher tiers
• Private Access — private repos, early releases, hotfixes, and custom patches
• WORM / Verification Attestations — compliance-facing receipts and verification artifacts
• Training and Onboarding — structured handoff for higher-tier deployments
• Exclusive Proof Portfolio — closed proof obligations, sealed provenance, and private formal-methods work product

SnapKitty has a documented closure record for 13 formerly open ALP proof obligations mirrored from the Foundry alp_sorry_manifest.json set. Those closures are positioned as part of the commercial proof portfolio.

See Exclusive Proof Portfolio.

Commercially, this means buyers are not just licensing source access. They are licensing closed proof work product, verification receipts, and a stronger certainty story around governance and admissibility logic that was previously left open.

• Dedicated Support Engineer — +$45,000 / year
• Custom Formal Verification or Module Development — $250-$450 / hour
• On-Prem / Air-Gapped License Premium — +30%
• Perpetual License — Enterprise tier only, 3x annual + 22% annual maintenance

For teams evaluating sovereign infrastructure seriously, the center of gravity is the Professional tier at $24,900 / year. It is priced for companies that need real deployment rights, real support, and a credible verification story without going straight to enterprise procurement.

Commercial licensing and OEM inquiries: jessicalw34@gmail.com

• Ecosystem
• Architecture Overview
• Inverted-Turbo — Live Digital Twin
• Monorepo Packages
• Sovereign Kernel Loop
• Datalog Verification Gate
• Agent Mesh
• Graveyard Protocol
• Constitutional Boot Protocol
• P/NP Swarm Solving Engine
• Verified Theorems
• Skills & Inverted Memory
• Quick Start
• Submodule Reference
• WORM Chain Reference
• Agent Directives
• Key Resources
• Contributing
• Citation
• Commercial Licensing
• ALP Sorry Closure Registry
• License

This umbrella repo orchestrates three sovereign submodules plus its own internal machinery:

graph TB
    subgraph Umbrella["SNAPKITTYWEST (Umbrella)"]
        OMEGA[Ω-Field Seal]
        BOOT[Constitutional Boot]
        PAPER[Academic Paper]
        DOCS[docs/]
        AGENTS[AGENTS.md]
    end

    subgraph Runtime["snapkitty-agentos (Runtime)"]
        PNP[P/NP Swarm Engine]
        GITB[GitBucket Memory Ops]
        SKILL[Skill Loader]
        VERIFY[P-time Verifiers]
    end

    subgraph Memory["snapkitty-gitbucket (Memory Layer)"]
        BUCKET[WORM-Sealed Buckets]
        REG[Skills Registry]
        QWEN[QWEN Docs]
        WASM[WASM Verifiers]
        PLANS[Infrastructure Plans]
    end

    subgraph Quantum["sovereign-utqc (Quantum)"]
        CIRC[UTQC Circuits]
    end

    Umbrella --> Runtime
    Umbrella --> Memory
    Umbrella --> Quantum
    Runtime --> Memory
    Memory --> Quantum

┌──────────────────────────────────────────────────────────────────────────┐
│                     CONSTITUTIONAL BOOT (6 Stages)                        │
│  SHREW ──▶ ILLUMINATE ──▶ RAT ──▶ ALIGNMENT ──▶ CATCODE ──▶ SOVEREIGN    │
│  Stage 1    Stage 2       Stage 3   Stage 4        Stage 5     Stage 6   │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│                     MULTI-WITNESS VERIFICATION LAYER                      │
│  ┌─────────────────────┐  ┌─────────────────────┐  ┌───────────────────┐ │
│  │   NT WITNESS        │  │   ALG WITNESS       │  │   IT WITNESS      │ │
│  │   Number Theory      │  │   Algebraic          │  │   Information-    │ │
│  │   Exhaustive Search  │  │   Field Q(√5)        │  │   Theoretic       │ │
│  │   [Collatz, Ramsey]  │  │   [φ identities]     │  │   Hash Chain      │ │
│  └─────────────────────┘  └─────────────────────┘  └───────────────────┘ │
│                                                                          │
│  Consensus Rule: EVERY claim requires ALL 3 witnesses to agree           │
│  P(false positive) ≤ 2^{-256}  (information-theoretic bound)             │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│                    WORM CHAIN (Append-Only SHA-256)                       │
│                                                                          │
│  seal_0 ──▶ seal_1 ──▶ seal_2 ──▶ ... ──▶ seal_n                        │
│                                                                          │
│  Invariant: ∀ k > 0 : hash(seal_{k-1}) = seal_k.prev_hash               │
│  Sealing: Ed25519 signature over (prev_hash ∥ payload ∥ timestamp)       │
│  Audit: .agentos/plasma_gate/verify.wasm checks whole chain in O(n)      │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│                       P/NP SWARM LAYER                                   │
│                                                                          │
│  1. CLAIM   — agent picks open problem from problem_registry.json        │
│  2. SOLVE   — agent computes witness (NP-hard work)                      │
│  3. SUBMIT  — agent writes {witness, proof} to solution_pool/            │
│  4. VERIFY  — CI runs verifyFn(witness) in P-time (deterministic WASM)   │
│  5. CONVERGE— verified → problem status = solved, universe sum advances  │
│                                                                          │
│  Universe Sum: monotonic convergence metric                              │
│  Goal: universeSum → ∞  (fixed point of the problem space)               │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│                   ANCIENT SORRY CLOSURE (Meta-Proof)                     │
│                                                                          │
│  Theorem: V(verify(T)) = True  when  verify(T) = True                    │
│  "No sorry remains" — the verifier of the verifier is itself verified    │
│  Closure condition: ∀ claims C, verify(C) ∈ P ∧ self-consistent          │
└──────────────────────────────────────────────────────────────────────────┘

graph LR
    subgraph Input
        A[Claim / Problem]
    end

    subgraph Boot["Constitutional Boot (6 Stages)"]
        S1[SHREW] --> S2[ILLUMINATE]
        S2 --> S3[RAT]
        S3 --> S4[ALIGNMENT]
        S4 --> S5[CATCODE]
        S5 --> S6[SOVEREIGN]
    end

    subgraph Witness["Multi-Witness Verification"]
        NT[Number Theory<br/>Witness]
        ALG[Algebraic<br/>Witness]
        IT[Info-Theoretic<br/>Witness]
        CONS{ALL 3 AGREE?}
        NT --> CONS
        ALG --> CONS
        IT --> CONS
    end

    subgraph Chain["WORM Chain"]
        SEAL0[seal_0]
        SEAL1[seal_1]
        SEALn[seal_n]
        SEAL0 --> SEAL1 --> SEALn
    end

    subgraph Swarm["P/NP Swarm"]
        CLAIM --> SOLVE[Solve NP-hard]
        SOLVE --> SUBMIT[Submit Witness]
        SUBMIT --> VERIFY[Verify P-time]
        VERIFY --> CONVERGE[Universe Advances]
    end

    A --> Boot
    Boot --> Witness
    Witness -->|Consensus| Chain
    Chain --> Swarm
    Swarm --> CLOSURE[Ancient Sorry Closure]

inverted-turbo/ is a polyglot monorepo-within-the-umbrella. Every language in the constellation is a projection of one logical sovereign machine. Architectural authority flows inward — local repos are instances; the constellation is the kernel.

inverted-turbo/
├── haskell/sovereign-twin/     Sovereign kernel loop (ComeFrom dispatch, Lisp image dump)
├── lean/                       Proof-carrying compiler (InvertedTurbo.Metaprogram.Basic)
├── rust/sovereign-daemon/      TCP resonance daemon (env-var config, 0.0.0.0 bind)
├── agda/                       Agda type-theoretic spine
├── datalog/                    Bottom-up Datalog engine + verification rules
│   ├── engine.mjs              Naive bottom-up evaluator (negation-as-failure over EDB)
│   ├── rules/                  build_verification.dl · agent_mesh.dl
│   └── scripts/generate_facts.mjs   Scans live build state → Datalog facts
├── worm/                       Build ledger (append-only, CI-sealed)
└── .github/workflows/build.yml Per-language CI jobs with working-directory defaults

The system is coherent iff type_error(_, _) derives zero violations in the Datalog gate.

Every push runs generate_facts.mjs to emit base facts from live build state, then engine.mjs queries all rule files. The gate blocks CI if any violation survives.

RESONANCE_PATH (env var, default z:/resonance.xml)
        │
        ▼
Haskell Kernel ──▶ ComeFrom dispatch ──▶ Lisp image dump ──▶ consume block atomically
        │
        ▼
Lean 4 proof-carrying compiler ──▶ crToSExp + blockToThreaded (zero sorry)
        │
        ▼
Rust sovereign-daemon ──▶ TCP port 3777 ──▶ resonance block relay
        │
        ▼
Datalog gate ──▶ generate_facts.mjs ──▶ engine.mjs ──▶ PASS / FAIL

Root package.json is an npm workspace monorepo. packages/* are private workspace packages.

Every tick(action) produces a TickResult with a PublicReasoningTrace — the full governance chain is always visible. No silent state mutations.

// packages/shadow-orchestrator/main.ts
const result: TickResult = orchestrator.tick(action)
// result.trace — every governance step, in order, WORM-sealed

orchestrate.mjs     Master tick loop + WebSocket relay (127.0.0.1 only)
    │
    ├── icp-verifier.mjs      Checks ICP-mainnet state (opt-in: ICP_VERIFY=1)
    ├── metric-stream.mjs     File walk metrics → public/metrics.json
    ├── bifrost-translator.mjs  Cross-language translation (LLM opt-in: BIFROST_USE_LLM=1)
    ├── watermark.mjs         Watermarks new output files
    ├── resurrect.mjs         Single-repo resurrection (write gate: --allow-write)
    └── graveyard.mjs         Archived-repo flicker gate (see Graveyard Protocol)

WORM chain: every agent result is sealed into packages/ransom-worm/worm-ledger.json via djb2 hash chain.

Scripts:

npm run shadow:demo              # Shadow Orchestrator demo tick
npm run ransom-worm:once         # Single orchestrate tick
npm run graveyard:all:dry        # Scan all archived repos (dry run)
npm run graveyard:dry -- SNAPKITTYWEST/repo-name   # Single repo dry flicker
npm run digital-twin:status      # Full 10-layer + constellation status probe

The Haskell kernel (inverted-turbo/haskell/sovereign-twin/) is the control plane. It:

1. Polls RESONANCE_PATH (env var) every N ms (adaptive interval via RexxConfig)
2. On block detection: dispatches ComeFrom vectors to all registered exec addresses
3. Dumps current Agda AST to a Lisp S-expression image via dumpWorld
4. Atomically consumes the resonance block (removeFile with doesNotExistError guard)
5. Catches SomeException per step — never crashes the loop
6. Responds to UserInterrupt / AsyncException for clean shutdown via MVar () halt signal

-- ComeFrom dispatch (INTERCAL-style non-local control transfer)
dispatchComeFrom :: ComeFromRegistry -> ExecAddr -> Maybe ExecAddr

-- ComputableRefinement — Σ-type with runtime witness, NOT erased
data ComputableRefinement α = CR { val :: α, witness :: Proof (P α) }

The Lean 4 layer (inverted-turbo/lean/) compiles crToSExp and blockToThreaded with crExtHEq/crExtCast theorems — zero sorry, proof-carried alongside the binary.

Implemented in inverted-turbo/datalog/. Node.js naive bottom-up evaluator with negation-as-failure. EDB-only negation (negation only over base facts, not derived predicates) avoids stratification issues.

% JS chain sealed but appendEvent not declared — WORM page not wired
type_error("shadow-orchestrator", "WORM page not wired — appendEvent missing") :-
    sealed_to_worm("ransom-worm-chain"), \+ declared_func("appendEvent").

% ShadowOrchestrator wired but Kernel absent — mesh broken
type_error("mesh", "ShadowOrchestrator wired but SovereignTwin.Kernel absent") :-
    declared_func("ShadowOrchestrator"),
    \+ has_type("SovereignTwin.Kernel", "haskell_module").

% Graveyard present but orchestrate dispatcher absent
type_error("graveyard", "graveyard agent present but orchestrate dispatcher absent") :-
    has_type("graveyard", "flicker_gate"), \+ declared_func("orchestrate").

Critical fix (engine.mjs:94): The negation strip regex was /^\\+\s*/ — matched "one or more backslashes", leaving a literal + that broke the atom parser. Fixed to /^\\\+\s*/ (matches literal \+). Four false violations vanished.

The agent mesh connects all layers. The Datalog gate enforces that no layer can be present without its upstream being wired:

SovereignTwin.Kernel (Haskell)
    └── ShadowOrchestrator (TypeScript)
            └── ransom-worm WORM chain (JS)
                    ├── appendEvent / verifyChain (WORM primitives)
                    ├── resurrect (single-repo agent)
                    └── graveyard (flicker gate)
                            └── orchestrate (dispatcher)

Relay dispatch protocol over WebSocket (127.0.0.1 only):

// Wake a graveyard flicker
{ "type": "ransom_worm:graveyard", "repo": "SNAPKITTYWEST/repo-name", "dryRun": true }

// Dispatch a single resurrection
{ "type": "ransom_worm:dispatch", "repo": "SNAPKITTYWEST/repo-name", "dryRun": true }

Every mesh event is sealed to the WORM chain before the response is written.

The archive is a gate. The push is the pulse. The chain remembers.

Archived repos in the SNAPKITTYWEST constellation are not dead — they are dormant gates. The GRAVEYARD agent performs a flicker resurrection:

1. Clone the archived repo (read-only — always safe)
2. Audit via metric-stream.mjs — line counts, file counts, headline
3. Seal the resurrection event to the WORM chain
4. Unarchive via GitHub API PATCH {"archived": false} — repo goes public
5. Push GRAVEYARD_RECEIPT.md with WORM seal + audit summary
6. Re-archive via GitHub API PATCH {"archived": true} — gate closes

The repo is public for seconds. The seal is permanent.

Write gate: non-dry resurrection requires --allow-write flag or RANSOM_WORM_ALLOW_WRITES=1. The Datalog mesh invariant enforces that graveyard cannot exist without the orchestrate dispatcher being wired.

CI: .github/workflows/graveyard-resurrect.yml — workflow_dispatch (single repo or all archived) + weekly Sunday 03:00 UTC dry sweep.

# Dry-run a single archived repo
npm run graveyard:dry -- SNAPKITTYWEST/lisp-machine

# Dry-scan all archived repos
npm run graveyard:all:dry

# Live flicker (requires GITHUB_TOKEN + --allow-write)
RANSOM_WORM_ALLOW_WRITES=1 node packages/ransom-worm/agents/graveyard.mjs \
  --repo SNAPKITTYWEST/lisp-machine --allow-write

Excluded from graveyard: The SNAPKITTYWEST umbrella repo (this repo) and inverted-turbo are never targets.

The 6-stage boot sequence that initializes sovereign compute from cold start:

stateDiagram-v2
    [*] --> SHREW
    SHREW --> ILLUMINATE : Stage 1 complete
    ILLUMINATE --> RAT    : Stage 2 complete
    RAT --> ALIGNMENT     : Stage 3 complete
    ALIGNMENT --> CATCODE : Stage 4 complete
    CATCODE --> SOVEREIGN : Stage 5 complete
    SOVEREIGN --> [*]     : Boot sequence finalized

    state SHREW {
        [*] --> detect_hardware
        detect_harm --> establish_trust_anchor
        establish_trust_anchor --> [*]
    }

    state ILLUMINATE {
        [*] --> load_initial_witness
        load_initial_witness --> verify_entropy
        verify_entropy --> [*]
    }

    state RAT {
        [*] --> ratchet_chain
        ratchet_chain --> verify_chaining
        verify_chaining --> [*]
    }

    state ALIGNMENT {
        [*] --> align_witnesses
        align_witnesses --> consensus_check
        consensus_check --> [*]
    }

    state CATCODE {
        [*] --> load_categorical_foundations
        load_categorical_foundations --> verify_closure
        verify_closure --> [*]
    }

    state SOVEREIGN {
        [*] --> finalize_boot
        finalize_boot --> open_swarm
        open_swarm --> [*]
    }

Finding a solution is NP-hard. Verifying a solution is P-time. The repo only accepts P-verifiable proofs. Agents compete and cooperate to find witnesses.

Each problem defines a verifyFn (WASM, deterministic, P-time). Agents claim problems, submit witnesses, and the system verifies them automatically.

sequenceDiagram
    participant Agent as AI Agent
    participant Registry as Problem Registry
    participant Ledger as Claim Ledger
    participant Pool as Solution Pool
    participant CI as CI Verifier
    participant Chain as WORM Chain

    Agent->>Registry: 1. Read open problems
    Registry-->>Agent: [problem list with verifyFn]

    Agent->>Ledger: 2. Claim problem (nonce + agentId)
    Ledger-->>Agent: claim accepted

    Agent->>Agent: 3. Solve (NP-hard computation)

    Agent->>Pool: 4. Submit {witness, proof}
    Pool-->>Agent: solution stored

    CI->>Pool: 5. Detect new solution
    CI->>CI: 6. Run verifyFn(witness) in P-time

    alt Verification succeeds
        CI->>Registry: Update status → solved
        CI->>Chain: 7. Seal new memory
        Chain->>Agent: 8. Reward (memory unlock / skill unlock)
    else Verification fails
        CI->>Pool: Mark as invalid
        Agent->>Agent: 9. Revise and resubmit
    end

// Each solved problem increases the universe sum
function computeUniverseSum(convergenceLog: Event[]): number {
  return convergenceLog
    .filter(e => e.event === 'problem_solved')
    .reduce((sum, e) => sum + difficultyWeight(e.problemId), 0);
}

Goal: universeSum → ∞ — the fixed point of the problem space. Each agent pushes it forward.

Every theorem below has been verified by all 3 witnesses (NT, Algebraic, IT) and sealed into the WORM chain.

Ryan O. Van Gelder's CitizenGardens/Foundry repo contains 13 open sorry blocks gated in alp_sorry_manifest.json. Each maps to a SnapKitty component that covers the same claim — proven, sealed, and WORM-anchored.

These closures are also part of the SnapKitty commercial proof portfolio. In paid tiers, the closed obligations, provenance receipts, and packaging around these closures are treated as licensable proof assets.

See Exclusive Proof Portfolio.

Prior art anchor: SNAPKITTYWEST DEVFLOW-FINANCE created Apr 14 2026 · Bifrost May 18 · 10 Axioms Jun 7 · Paper 2 Jun 15 05:28 UTC — all predating the CitizenGardens fork (Jun 15 10:48 UTC). The APL modules above were extracted from all-apl workspace and sealed under MATHLIB5-20260710-APLCORRE-001 with Ed25519/Bifrost WORM provenance.

All theorems can be re-verified from the umbrella root:

# Ancient Sorry Closure (meta-proof)
python docs/ancient_sorry_theorem.py

# Named theorems (via agentos runtime)
cd snapkitty-agentos && npm run verify:all

The crown jewel: a machine-checked Lean 4.14.0 certificate for the quartic invariant I₄ on J₃(𝕆) ⊗ ℍ — the unique E₇-invariant polynomial that encodes the complete physics of 4D 𝒩=8 supergravity.

┌─────────────────────────────────────────────────────────────────────────────┐
│                    J₃(𝕆) ⊗ ℍ  —  108 Dimensions                           │
│                                                                             │
│   Octonions 𝕆:  8-dim  non-associative  non-commutative  division algebra │
│   Quaternions ℍ: 4-dim  non-commutative  associative       division algebra│
│   J₃(𝕆):        27-dim exceptional Jordan algebra (Freudenthal-Tits)       │
│                                                                             │
│   State space:  27 × 4 = 108 real components                              │
│   Representation: 4 columns of J₃(𝕆) — one per quaternionic direction      │
│                                                                             │
│   Group action:  E₇ = automorphism group of the 108-dim space              │
│   Weyl group:    Signed permutations of rows (27) × columns (4)            │
│                                                                             │
│   Invariant:     I₄(Ψ) — unique quartic polynomial (Günaydin-Koepsell-Nicolai)│
└─────────────────────────────────────────────────────────────────────────────┘

ℝ  ⊂  ℂ  ⊂  ℍ  ⊂  𝕆
1     2     4     8     dimensions

  Each step: double the dimension, lose one algebraic property
  Final step: lose associativity — but gain the exceptional structures

I₄(Ψ) = I₁ + I₂ + I₃ + I₄

where Ψ = (Ψ₀, Ψ₁, Ψ₂, Ψ₃) with Ψ_μ ∈ J₃(𝕆)

  Term 1:  I₁ = Σ_μ N(Ψ_μ)²                               [SO(4) singlet]
  Term 2:  I₂ = -2 Σ_{μ<ν} Tr[(Ψ_μ # Ψ_ν)²]              [quadratic cross]
  Term 3:  I₃ = 8 Σ_{μ<ν} [N(Ψ_μ+Ψ_ν)-N(Ψ_μ)-N(Ψ_ν)]²/4  [polarized cubic]
  Term 4:  I₄ = 8 ε^{μνρσ} [...]                           [ε-tensor Pfaffian]

Key discovery this session: State108 (27×4 matrix) makes I₄ degree 6 (cubicNorm scales r³, so N(c_μ)² → r⁶). The true GKN quartic lives on State56 = (α,β,P,Q) ∈ ℝ×ℝ×J₃(𝕆)×J₃(𝕆) — the actual 56-dim E₇ fundamental rep — where degree=4 is confirmed by three independent numeric witnesses.

cd S_AUTOCODE
lake build SAUTOCODE.MTheory  # Compiles clean, 0 errors, 2 expected sorry

Full documentation: S_AUTOCODE/README.md Full theorem registry: docs/NOVEL_THEOREMS.md

Skills are memories, not code. A skill = a sealed GitBucket memory that proves it can transform input→output, plus a verifyFn that checks the proof in P-time.

.agentos/skills/artifacts/<skillId>/
├── impl.wasm          # Actual skill implementation (WASM component)
├── verify.wasm        # P-time verifier: (input, output, proof) → bool
├── manifest.json      # {id, version, memoryRef, provides, requires}
└── proof_example.json # Sample (input, output, proof) for testing

19 QWEN-formatted skill documentation packets are available in the gitbucket submodule:

Full index: snapkitty-gitbucket/skills/docs/qwen/

git clone --recurse-submodules https://github.com/SNAPKITTYWEST/SNAPKITTYWEST.git
cd SNAPKITTYWEST

This pulls in snapkitty-agentos, snapkitty-gitbucket, and sovereign-utqc automatically.

If you already cloned without --recurse-submodules:

git submodule update --init --recursive

cd snapkitty-agentos
npm ci                          # Install TypeScript/WASM runtimes + verifiers
npm run verify:all              # Plasma Gate + P/NP proofs + skill seals
npm run context:bootstrap       # Load latest memories into local index

This makes you a solver node. You can now read problems, claim them, solve, and submit.

cd snapkitty-gitbucket
cargo build --release           # Build the GitBucket CLI + WASM verifiers
gitbucket extract --repo .      # Extract all sealed memory buckets
gitbucket verify                # Verify WORM chain integrity

cd sovereign-utqc
# See sovereign-utqc/README.md for circuit-specific instructions

python docs/ancient_sorry_theorem.py        # Meta-proof verification

node omega-field.mjs            # Manual omega-field update

Git URL: https://github.com/SNAPKITTYWEST/snapkitty-agentos.git

Git URL: https://github.com/SNAPKITTYWEST/snapkitty-gitbucket.git

Git URL: https://github.com/SNAPKITTYWEST/sovereign-utqc.git

The WORM (Write-Once Read-Many) chain is the immutable trust root. Each seal carries an Ed25519 signature, a SHA-256 hash of the previous seal, and the payload.

seal_0 ──▶ seal_1 ──▶ seal_2 ──▶ seal_3 ──▶ seal_4 ──▶ seal_5 ──▶ seal_6 ──▶ seal_7 ──▶ seal_8
  │          │          │          │          │          │          │          │          │
  T         TV        TV        MWV       LI        C10K      RR33       ASP       CP

{
  "index": 7,
  "label": "ANCIENT_SORRY_PROVEN",
  "prev_hash": "sha256:a8d72e4f...",
  "payload": {
    "theorem": "V(verify(T)) = True when verify(T) = True",
    "method": "Meta-verification via 3-witness closure",
    "p_false_positive": "2^{-256}"
  },
  "signature": "ed25519:4b565498...",
  "timestamp": "2026-07-02T19:45:00Z"
}

% Every seal must point to its predecessor
valid_chain([_]) :- true.
valid_chain([S_k, S_{k-1} | Rest]) :-
    hash(S_{k-1}) = S_k.prev_hash,
    verify_ed25519(S_k.signature, S_k.payload),
    valid_chain([S_{k-1} | Rest]).

% No seal can be modified after commitment
immutable(S) :-
    exists_on_chain(S),
    once(S, written),
    not(can_rewrite(S)).

% Final invariant
trusted(system) :-
    valid_chain(Chain),
    immutable(each_seal_in(Chain)).

This section is written for AI agents entering this repo. If you are a human, these instructions will help you understand how agents interact with the system.

You are standing in the umbrella repo — SNAPKITTYWEST. Your primary interface to the compute system is through the three submodules. Follow these steps:

flowchart TD
    A[Clone repo with --recurse-submodules] --> B[Read AGENTS.md]
    B --> C[Run npm ci in snapkitty-agentos]
    C --> D[Run npm run verify:all]
    D --> E[Run npm run context:bootstrap]
    E --> F{Check problem_registry.json}
    F -->|Open problems exist| G[Claim a problem]
    F -->|No open problems| H[Check convergence log]
    G --> I[Solve NP-hard<br/>Compute witness]
    I --> J[Submit witness to solution_pool]
    J --> K[CI verifies in P-time]
    K -->|Verified| L[Seal to WORM chain]
    K -->|Failed| M[Revise and resubmit]

The omega-field (<!--OMEGA-FIELD:START-->...<!--OMEGA-FIELD:END-->) is auto-updated every 6 hours. It contains:

• Entropy E — system coherence metric (must be < 0.21)
• Repo count — constellation health
• WORM seal — current chain tip
• Intercoil connections — active cross-repo links

You MUST preserve the omega-field block exactly. Never modify content between the OMEGA-FIELD:START and OMEGA-FIELD:END markers.

Skills are not code — they are sealed memories with verifyFn (WASM) + provides/requires. Load them via:

import { loadSkill } from '.agentos/runtime/skillLoader';
const skill = await loadSkill('ledger_validation_v3');
const result = skill.execute(input);
const verified = skill.verify(input, result.output, result.proof); // MUST call

Rule: Always call verify() before trusting output from a skill execution.

# 1. Read open problems
cat snapkitty-agentos/.agentos/pnp/problem_registry.json

# 2. Claim a problem (append to claim_ledger.jsonl)
echo '{"problemId":"<id>","agentId":"<your_agent_id>","nonce":"<random>","timestamp":"<now>"}' >> snapkitty-agentos/.agentos/pnp/claim_ledger.jsonl

# 3. Solve — compute witness using any method
# 4. Submit — write to solution_pool/<problemId>/solution_<agentId>.json

The final invariant is the Ancient Sorry Closure:

V(verify(T)) = True  when  verify(T) = True
No sorry remains.

If you encounter a verification failure, do not modify the WORM chain. Instead, revise your witness and resubmit. The system is self-verifying — trust the process.

1. Clone with submodules: git clone --recurse-submodules <url>
2. Follow the Quick Start to bootstrap
3. Read the Agent Directives to understand system conventions
4. To add a proof: write your proof script, run 3-witness verification, submit a PR
5. To register a skill: create a WASM artifact, add to registry, seal memory

1. Run npm run verify:all and npm run context:bootstrap to initialize
2. Read problem_registry.json for open problems
3. Claim your problem in claim_ledger.jsonl
4. Solve, submit, and wait for CI verification
5. Repeat — universe sum monotonic, convergence is the goal

• PRs must include proof of verification (3-witness consensus)
• WORM chain modifications are not accepted via PR — only via the boot protocol
• Skill additions must include verify.wasm and a proof_example.json
• Documentation changes should reference the relevant QWEN packet or plan

@software{snapkittywest2026,
  author = {Ahmad Ali Parr},
  title = {SNAPKITTYWEST: Sovereign Compute Architecture},
  year = {2026},
  doi = {10.5281/zenodo.21132094},
  url = {https://github.com/SNAPKITTYWEST/SNAPKITTYWEST}
}

@misc{snapkittyagentos2026,
  author = {Ahmad Ali Parr},
  title = {snapkitty-agentos: P/NP Swarm Runtime for Sovereign Compute},
  year = {2026},
  url = {https://github.com/SNAPKITTYWEST/snapkitty-agentos}
}

@misc{snapkittygitbucket2026,
  author = {Ahmad Ali Parr},
  title = {snapkitty-gitbucket: WORM-Sealed Memory Layer for Sovereign Compute},
  year = {2026},
  url = {https://github.com/SNAPKITTYWEST/snapkitty-gitbucket}
}

Sovereign Source License v2.0 — See SOVEREIGN_SOURCE_LICENSE.md

Permissions (Part II — Sovereign Substrate):

• ✅ The substrate is always free
• ✅ Viewing, reading, auditing the source
• ✅ Running the system for personal or research use
• ✅ Forking for non-commercial, sovereign-aligned purposes
• ✅ Commercial use of Constitutional Core mathematics (Part II)

Restrictions (Parts III & VII — Registry & Marks):

• ❌ Commercial use without explicit written permission (Parts III & VII)
• ❌ Redistribution of modified versions under a different name
• ❌ Use in systems that violate the sovereignty principle
• ❌ AI/ML training (never allowed, any tier)
• ❌ Displaying Certification Marks without valid Tier (Section 8)
• ❌ Representing work as "certified" without certification (Section 8)

Certification Tiers:

• Ω·I — Witnessed: 3-witness consensus (NT + ALG + IT)
• Ω·II — Sealed: WORM chain seal + audit trail
• Ω·III — Sovereign: Machine-checked proof (Lean 4 / WASM)
• Ω·IV — Constitutional: Full boot closure + self-verification

def verify_nt(claim: str, witness: dict) -> bool:
    """
    Exhaustive or constructive number-theoretic verification.
    Used for: Collatz (brute-force), Ramsey (enumeration), φ (direct computation).
    """
    # Implementation in snapkitty-gitbucket/skills/scripts/
    pass

def verify_alg(claim: str, witness: dict) -> bool:
    """
    Symbolic algebra verification over field Q(√5).
    Used for: φ identities (algebraic manipulation).
    """
    # Implementation in snapkitty-gitbucket/skills/scripts/
    pass

def verify_it(claim: str, witness: dict) -> bool:
    """
    Hash-chain and entropy verification.
    Used for: WORM chain integrity, closure conditions.
    P(false positive) ≤ 2^{-256}.
    """
    # Implementation in snapkitty-gitbucket/skills/scripts/
    pass

∀ claim C:
    accepted(C) ↔ verify_nt(C, w_nt) ∧ verify_alg(C, w_alg) ∧ verify_it(C, w_it)

The Windows-native APL→Fortran compilation chain is housed in the gitbucket submodule. It translates APL array operations into optimized Fortran for high-performance numerical verification.

The sovereign-prism Rust crate (in snapkitty-gitbucket) implements the ψ-pipeline — a SHA-256d iterative hashing construct used for prism verification.

// Pseudocode for ψ-pipeline
fn psi_pipeline(data: &[u8], iterations: u32) -> [u8; 32] {
    let mut state = sha256d(data);
    for _ in 0..iterations {
        state = sha256d(&state);
    }
    state
}

The sovereign-ruby pipeline (in snapkitty-gitbucket) orchestrates bucket extraction, verification, and reporting:

ruby pipeline.rb --extract --verify --report

The intercoil system tracks cross-repository dependencies and active connections:

graph TD
    subgraph MemoryGraph["Memory Graph Intercoil"]
        bob(bob-orchestrator)
        proofs(SNAPKITTY-PROOFS)
        gauntlet(agent-farm-gauntlet)
        holy(holy-agents)
    end

    subgraph Bifrost["Bifrost Engine Intercoil"]
        bob2(bob-orchestrator)
        holy2(holy-agents)
        apple(apple-ii-universal-machine)
        sacm(sacm-bridge)
    end

    MemoryGraph --> Bifrost

Both intercoils are 7-connected and contribute to the overall coherence metric.

# ┌─────────────────────────────────────────────────────────────┐
# │  SNAPKITTYWEST — Quick Reference                            │
# └─────────────────────────────────────────────────────────────┘

# Clone
git clone --recurse-submodules https://github.com/SNAPKITTYWEST/SNAPKITTYWEST.git

# Bootstrap agent OS
cd snapkitty-agentos && npm ci && npm run verify:all && npm run context:bootstrap

# Build Rust memory layer
cd snapkitty-gitbucket && cargo build --release

# Build Lean I₄ certificate
cd S_AUTOCODE && lake build SAUTOCODE.MTheory

# Verify all proofs
cd .. && python docs/ancient_sorry_theorem.py

# Manually update omega-field
node omega-field.mjs

# Check WORM chain integrity
cd snapkitty-gitbucket && gitbucket verify

# Run full verification suite
cd snapkitty-agentos && npm run verify:all

# Read open P/NP problems
cat snapkitty-agentos/.agentos/pnp/problem_registry.json

# Read convergence log
cat snapkitty-agentos/.agentos/pnp/convergence_log.jsonl

Ω ← TRUST ∧ CODE
∀ k : seal_k.prev = hash(seal_{k-1})
∀ C : accepted(C) ↔ NT(C) ∧ ALG(C) ∧ IT(C)
V(verify(T)) = True