clm-kernel 0.0.2__tar.gz

clm_kernel-0.0.2/.gitignore

@@ -0,0 +1,104 @@
+/data/*
+!/data/bootstrap/
+/data/bootstrap/*
+!/data/bootstrap/manifests/
+!/data/bootstrap/manifests/*.yaml
+!/data/execution_data/
+/data/execution_data/*
+!/data/execution_data/logs/
+/data/execution_data/logs/*
+!/data/execution_data/logs/landauer/
+!/data/execution_data/logs/landauer/telemetry.json
+/data/content_memory/
+/data/agent_identity/
+/data/ipc/
+/data/events/
+# The whole runtime directory: the three tapes, the lifecycle sidecars (ORC-29), and
+# `.init_done`. Nothing here is source, and an untracked entry refuses a sandwich for no
+# reason — the loop scopes `dirty` to the target's own tracked content.
+db/
+db/snapshots/
+db/.init_done
+data/*.db
+graphify-out/
+.graphify-out/
+docs/WorkingNotes
+data/keys/*.pem 
+test_core.log
+test_output.log
+.gitnexus
+node_modules/
+.venv
+.venv/
+package-lock.json
+
+# Windows binaries and crash dumps
+kernel/bin/windows-amd64/*.zip
+kernel/bin/windows-amd64/*.exe
+*.stackdump
+scratch/
+.scratch/
+kernel/clm_rust_core/target/
+kernel/scripts/clmEval-rs*
+
+# Runtime artifacts from benchmarks/tests
+*_content_memory.db
+*_cards.txt
+
+# Python caches
+__pycache__/
+*.pyc
+
+# Local Rust db during testing
+kernel/clm_rust_core/db/
+
+# Local context-mode files
+.github/context-mode/
+.github/hooks/
+
+# Tool-generated artifacts
+.opencode/
+.understand-anything/
+.test_handle_clm_XXXXXX.yaml
+
+# Local logs, PIDs, and scratch files at root
+*.log
+logs/
+error.txt
+output.txt
+*_pid.txt
+*.patch
+*.sb
+dummy.yaml
+test.yaml
+py_esc1.yaml
+scratch.sh
+run_manual
+test_rust_exec
+scratch_test/
+dist/
+*.egg-info/
+kernel/clm_rust_core/pkg/*
+!kernel/clm_rust_core/pkg/README.md
+!kernel/clm_rust_core/pkg/node/
+kernel/clm_rust_core/pkg/node/*
+!kernel/clm_rust_core/pkg/node/package.json
+tests/packaging/rust_consumer/target/
+tests/packaging/c_consumer/test_consumer
+tests/packaging/c_consumer/db/
+test-results/
+playwright-report/
+.astro/
+tests/test_data/bootstrap_output/
+meta_functionality.db
+
+# Shared libraries and native extensions
+*.so
+*.dylib
+*.dll
+
+# Ephemeral test and build data
+kernel/clm_rust_core/data/
+kernel/clm_py_core/clm/tests/
+tests/data/
+

clm_kernel-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GovTech Digital Identity & Autonomous Systems / CLM Architecture Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

clm_kernel-0.0.2/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.5
+Name: clm-kernel
+Version: 0.0.2
+Summary: Card Lifecycle Manager (CLM) Kernel — Sovereign Functional Agentic Operating System
+Author: GovTech Digital Identity & Autonomous Systems
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: aiosqlite>=0.17.0
+Requires-Dist: base58>=2.1.1
+Requires-Dist: blake3>=0.4.0
+Requires-Dist: chardet>=5.1.0
+Requires-Dist: cryptography>=44.0.0
+Requires-Dist: duckdb>=1.0.0
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: jsonschema>=4.26.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: pillow>=10.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dateutil>=2.9.0
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: reportlab>=4.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: result>=0.17.0
+Requires-Dist: scipy>=1.14.0
+Requires-Dist: sqlalchemy>=1.4.0
+Requires-Dist: typing-extensions>=4.5.0
+Requires-Dist: uvicorn>=0.20.0
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: build>=1.0.0; extra == 'dev'
+Requires-Dist: hatchling>=1.20.0; extra == 'dev'
+Requires-Dist: hypothesis>=6.100.0; extra == 'dev'
+Requires-Dist: mypy>=1.10.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Requires-Dist: twine>=5.0.0; extra == 'dev'
+Provides-Extra: native
+Description-Content-Type: text/markdown
+
+# clm-kernel
+
+Card Lifecycle Manager (CLM) Kernel — Sovereign Functional Agentic Operating System.
+
+`clm-kernel` is the foundational Python implementation of the Cubical Logic Model (CLM), providing a stratified 5-layer architecture for sovereign, functional, deterministically auditable agentic execution.
+
+## Architectural Layers
+
+- **Layer 0: Cryptographic Substrate & Storage**
+  - Content-addressable storage via BLAKE3 hashing
+  - Merkle DAG tree synthesis and verification
+  - TriDatabase manager and multi-agent Vector Clocks
+- **Layer 1: Type Lattice & Schema Model**
+  - Pydantic-backed invariant validation
+  - Deterministic AST transformations and MCard schemas
+- **Layer 2: Reactive Graph & CPN-VM**
+  - Coloured Petri Net (CPN) virtual machine
+  - Token passing, transition firings, and concurrency invariants
+- **Layer 3: Cordis Spatiotemporal Actor Model**
+  - Effect isolation, savepoints (`SavepointGuard`), and cleanup scopes (`DisposableList`)
+  - Monadic execution with rollback guarantees
+- **Layer 4: Sovereign Execution & Gateway**
+  - Full CLI (`clm`, `clmEval`)
+  - Triad Gateway and Model Context Protocol (MCP) server integration
+
+## Installation
+
+```bash
+pip install clm-kernel
+```
+
+## CLI Usage
+
+```bash
+# Display CLI help
+clm --help
+
+# Evaluate an action or workflow manifest
+clm evaluate --file workflow.yaml
+
+# Initialize TriDatabase storage
+clm init-tridb --path ./data
+```
+
+## Python API Quick Start
+
+```python
+from clm.layer0.merkle import MerkleTree
+from clm.layer4 import SovereignExecutor
+
+# Create and verify Merkle DAG
+tree = MerkleTree()
+tree.insert("card-1", b"payload data")
+root_hash = tree.compute_root()
+print(f"Merkle Root: {root_hash}")
+```
+
+## License
+
+MIT License. See [LICENSE](https://github.com/xlp0/CLM/blob/main/LICENSE) for details.
+
+## Monorepo & Documentation
+
+Source code, formal proofs, and multi-language kernels (Rust, JavaScript/TypeScript, WASM) are maintained in the main [CLM Repository](https://github.com/xlp0/CLM).

clm_kernel-0.0.2/README.md

@@ -0,0 +1,237 @@
+# Cubical Logic Model (CLM)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Tests: 1,677 Passing](https://img.shields.io/badge/Tests-1%2C677%20Passing-brightgreen)](tests/)
+[![Rust: 2024 Edition](https://img.shields.io/badge/Rust-2024%20Edition-orange)](kernel/clm_rust_core/)
+[![Python: 3.10+](https://img.shields.io/badge/Python-3.10%2B-blue)](kernel/clm_py_core/)
+[![Node.js: 20+](https://img.shields.io/badge/Node.js-20%2B-green)](kernel/clm_js_core/)
+[![Polyglot Consensus: 100%](https://img.shields.io/badge/Polyglot%20Consensus-100%25-success)](tests/polyglot/)
+[![Boundary Gates: 24/24 Green](https://img.shields.io/badge/Boundary%20Gates-24%2F24%20Green-brightgreen)](tools/make/boundaries.mk)
+
+> **The Cubical Logic Model (CLM)** is a polyglot computational substrate and conversational operating system implementing the Kenotic Layer 0–5 strata. It unifies content-addressable storage (BLAKE3/SHA-256), Colored Petri Net workflows, and the Satori conversational speech act protocol across three equivalent, character-for-character identical runtimes: **Python**, **Rust**, and **TypeScript**.
+
+---
+
+## 🚀 Key Highlights & Performance
+
+- **Tri-Language Univalence**: Bit-for-bit and byte-for-byte identical evaluation across Python, Rust, and TypeScript with 100% consensus on all 108 polyglot test vectors.
+- **Microsecond Systems Substrate**: Rust native CPN transitions execute in $\le 25\mu\text{s}$, zero-copy rollback in $<0.1\text{ms}$, and WAL database throughput exceeds $>900\text{k}$ QPS.
+- **Architectural Certification**: 100% green across all 24 Layer Boundary Gates and 14 foundational architectural invariants (`INV-01` through `INV-14`).
+- **High-Velocity Parallel Fleet**: 1,677 tests executed in parallel in **14.79s** via `make test-parallel-fast` ($\le 30.0\text{s}$ target budget).
+
+---
+
+## 🛠️ Installation & Setup
+
+Before running the `clm` CLI or switching runtimes, install and activate the environment.
+
+### 1. Quick Install (From Source)
+
+Clone the repository, provision dependencies across all runtimes, and activate your shell:
+
+```bash
+# Clone repository
+git clone https://github.com/xlp0/CLM.git
+cd CLM
+
+# 1. Provision all multi-runtime dependencies, compile Rust core, & init databases
+make install    # or: make setup
+
+# 2. Activate Python virtual environment (adds 'clm' to your PATH)
+source .venv/bin/activate       # On macOS/Linux
+# source .venv/Scripts/activate # On Windows (PowerShell: .venv\Scripts\Activate.ps1)
+
+# 3. Verify installation
+clm version                     # or: clm --version
+```
+
+> **Zero-Activation Shortcut**: You can also use the repository's native root launcher directly without activating `.venv`:
+> ```bash
+> ./clmEval evaluate assets/clm/manifests/example.yaml --json
+> ```
+
+### 2. Prerequisites & Toolchains
+- **Python**: 3.10+ (with `uv` or `pip` / `venv`)
+- **Rust**: 1.80+ (`cargo` with 2024 edition support)
+- **Node.js**: 20+ (`npm` or `pnpm`)
+- **Build Tools**: GNU Make 3.81+, SQLite 3.38+
+
+### 3. Granular Build Targets
+- **Recompile Rust Core**: `make build-rust` (`cargo build --release --features python`)
+- **Compile TypeScript Bundle**: `npm --prefix kernel/clm_js_core run build`
+- **Rebuild All Polyglot Targets**: `make build-all`
+
+### 4. Install Pre-built Packages
+Consume CLM directly via language-specific package managers:
+```bash
+pip install clm-kernel          # Python (PyPI)
+npm install clm-kernel clm-wasm # Node.js / Web (npm)
+cargo install clm-kernel        # Rust (crates.io)
+```
+
+> **Windows Developers**: Windows is fully supported natively (PowerShell / Git Bash) and via WSL. See [`docs/guides/windows-setup-and-practices.md`](docs/guides/windows-setup-and-practices.md) for automated bootstrap scripts, path normalization, and MSVC settings.
+
+---
+
+## 🌐 The Three Language Runtimes
+
+Under the **Kenotic Principle (`INV-01`)**, CLM strictly separates abstract specifications ($A$) from concrete host execution ($C$). It delivers three equivalent, interchangeable execution engines:
+
+```mermaid
+flowchart TD
+    SPEC["Universal Specification (A)<br/>YAML Schemas • CEL Dicts • CPN Graphs"]
+    
+    SPEC --> PY["<b>Python Runtime</b><br/>kernel/clm_py_core/ (clm-kernel)<br/>• Dynamic Duck-Typing & Pydantic v2<br/>• AI Agent Orchestration & REPL<br/>• PyO3 Native Acceleration Bridge"]
+    
+    SPEC --> RS["<b>Rust Microkernel</b><br/>kernel/clm_rust_core/ (clm-kernel)<br/>• Zero-Cost Systems Substrate<br/>• Sub-25µs Petri Net Transition<br/>• Bare-Metal Daemon & CLI Fastpath"]
+
+    SPEC --> TS["<b>TypeScript / JS Runtime</b><br/>kernel/clm_js_core/ (clm-kernel, clm-wasm)<br/>• Isomorphic V8 & WebAssembly<br/>• Cordis Reactive Plugin Micro-Harness<br/>• WebStudio & In-Browser CAS Storage"]
+
+    PY <===>|"Gate 23 (TypeInterpreter) & Gate 24 (TypedValue)"| RS
+    RS <===>|"Byte-Identical BLAKE3 & Marking Parity"| TS
+    TS <===>|"Universal Subcommand Grammar (USG)"| PY
+```
+
+### Runtime Capability & Performance Matrix
+
+| Runtime | Implementation | Primary Role | Latency Profile | Primary Target |
+| :--- | :--- | :--- | :--- | :--- |
+| **Python** | `kernel/clm_py_core/` (`clm-kernel`) | Reference model, AI agents, dynamic prototyping | ~5ms (pure) / <2ms (PyO3) | `clm` / `python -m clm` |
+| **Rust** | `kernel/clm_rust_core/` (`clm-kernel`) | Systems microkernel, zero-copy CAS, high-throughput daemon | $\le 25\mu\text{s}$ transition, $<0.1\text{ms}$ rollback | `clm_rust_core` / native FFI |
+| **TypeScript** | `kernel/clm_js_core/` (`clm-kernel`, `clm-wasm`) | Web & edge runtime, Cordis plugins, in-browser CAS | ~1ms V8 / WASM execution | `npx clmEval` / Browser |
+
+### 🔀 Transparent Runtime Selection (`CLM_RUNNER`)
+
+Once your environment is activated, CLM routes commands through a Universal Subcommand Grammar facade. Switch engines dynamically on the fly using the `CLM_RUNNER` environment variable:
+
+```bash
+# 1. Auto-dispatch (resolves compiled Rust binary if available, falls back to Python)
+clm evaluate assets/clm/manifests/example.yaml --json
+
+# 2. Force native Rust microkernel (<2ms dispatch, sub-25µs transitions)
+CLM_RUNNER=rust clm evaluate assets/clm/manifests/example.yaml --json
+
+# 3. Force Python reference engine
+CLM_RUNNER=python clm evaluate assets/clm/manifests/example.yaml --json
+
+# 4. Force Node.js / TypeScript engine
+CLM_RUNNER=node clm evaluate assets/clm/manifests/example.yaml --json
+```
+
+For the comprehensive comparative analysis of algorithms and benchmarks, see [`docs/architecture/tri-language-runtime-parity-and-performance.md`](docs/architecture/tri-language-runtime-parity-and-performance.md).
+
+---
+
+## ⚡ Common Workflows & Developer Tools
+
+### 1. Headless Streaming Gateway Server
+Launch the universal WebSocket JSON-RPC 2.0 streaming gateway on port 4000:
+```bash
+clm gateway
+```
+
+### 2. Interactive Developer TUI Menu
+Launch the interactive terminal dashboard for running tests, diagnostics, and benchmarks:
+```bash
+make menu
+# or: python3 tools/make/interactive_menu.py
+```
+
+### 3. Programmatic SDK Usage
+
+#### Python
+```python
+from clm.layer0.typed_value import TypedValue
+
+# Create and canonically hash a universe-stratified value
+tv = TypedValue.from_data({"status": "ready", "tokens": 42}, universe="U0")
+print(f"MIME: {tv.mime} | Hash: {tv.content_hash}")
+```
+
+#### TypeScript
+```typescript
+import { TypedValue } from "@clm/core";
+
+const tv = TypedValue.fromData({ status: "ready", tokens: 42 }, "application/json", "U0");
+console.log(`MIME: ${tv.mime} | Hash: ${tv.contentHash}`);
+```
+
+#### Rust
+```rust
+use clm_rust_core::typed_value::TypedValue;
+use serde_json::json;
+
+let tv = TypedValue::from_data(json!({"status": "ready", "tokens": 42}), "application/json".into(), "U0".into());
+println!("Hash: {}", tv.content_hash);
+```
+
+For extended guides, see [`docs/guides/polyglot-quick-start.md`](docs/guides/polyglot-quick-start.md) and [`docs/guides/web-ui-quick-start.md`](docs/guides/web-ui-quick-start.md).
+
+---
+
+## 🏛️ Core Architecture Overview
+
+CLM organizes computation into six stratified, hermetically isolated layers ($L_0$ to $L_5$):
+
+| Layer | Stratum Name | Primary Function | Canonical Spec |
+| :--- | :--- | :--- | :--- |
+| **$L_0$** | **Substrate Primitives** | Codecs, RFC 8785 canonical JSON, `TypedValue` ($U_0$), BLAKE3/SHA-256 CAS | [`docs/spec/20-architecture/`](docs/spec/20-architecture/) |
+| **$L_1$** | **Type Lattice & CPN VM** | Colored Petri Net transition runner, $O(1)$ Noetherian conservation ($x^\top D = 0$) | [`docs/spec/40-behavior/`](docs/spec/40-behavior/) |
+| **$L_2$** | **Storage & Fibers** | Tri-Database isolation (`agent`, `content`, `log`), Cordis spatiotemporal fibers, sub-ms rollback | [`docs/architecture/kernel-pillars.md`](docs/architecture/kernel-pillars.md) |
+| **$L_3$** | **Dialectic Mesh** | Satori Protocol, Austin-Searle speech acts ($U_3$), universe-annotated lambda terms | [`docs/architecture/satori-protocol-and-clm-layers-networking-interfacing.md`](docs/architecture/satori-protocol-and-clm-layers-networking-interfacing.md) |
+| **$L_4$** | **Presentation Membrane** | Pluggable Membrane SPI, `TypedEnvelope` ($U_4$), WebStudio (`mcard-studio`), CLI TUI | [`docs/spec/30-interfaces/presentation-membrane-spi.md`](docs/spec/30-interfaces/presentation-membrane-spi.md) |
+| **$L_5$** | **Epistemic Learning** | Meta-circular continuous learning loop ($\Gamma$), monotonic epistemic fitness ($\Delta E$), quarantine | [`docs/architecture/agentic-conversational-programming.md`](docs/architecture/agentic-conversational-programming.md) |
+
+For deep architectural principles and invariants, see [`docs/architecture/six_layers_architecture.md`](docs/architecture/six_layers_architecture.md), [`docs/architecture/architectural-invariants.md`](docs/architecture/architectural-invariants.md), and [`docs/architecture/zero-trust-made-concrete.md`](docs/architecture/zero-trust-made-concrete.md) (Zero Trust Architecture & PKC Quadriad Audit).
+
+---
+
+## 🧪 Testing & Quality Assurance
+
+CLM features a comprehensive stratified test suite across all six layers. The primary developer targets are:
+
+```bash
+# 1. High-speed parallel test fleet (1,677 tests in ~15s, budget <= 30.0s)
+make test-parallel-fast
+
+# 2. Complete regression test suite
+make test
+
+# 3. Verify all 24 Layer Boundary & Hygiene Guards (zero-regression gate)
+make check-boundaries
+
+# 4. Verify all 14 foundational architectural invariants (INV-01 to INV-14)
+make check-invariants
+
+# 5. Rust 2024 compiler and Clippy zero-warning check
+make clippy-check
+
+# 6. Tri-runtime consensus test battery across Python, Rust, and TypeScript
+make test-polyglot-all
+```
+
+> **Historical Sprint Tests**: For the complete catalog of historical sprint verification targets (Sprints 144–244) and the full 35-row Makefile command reference, see [`docs/guides/sprint-test-target-reference.md`](docs/guides/sprint-test-target-reference.md).
+
+---
+
+## 📚 Documentation & Project Evolution
+
+| Knowledge Domain | Authoritative Documentation | Description |
+| :--- | :--- | :--- |
+| **Formal Specifications** | [`docs/spec/`](docs/spec/) | Complete 8-part normative specification suite ($L_0$–$L_5$) |
+| **Architecture Canons** | [`docs/architecture/`](docs/architecture/) | Six-layer model, Kenotic theory, Zero Trust Quadriad, and tri-runtime execution |
+| **Foundational Theory** | [`docs/theory/why-clm-exists.md`](docs/theory/why-clm-exists.md) | Universal MCard ontology, Kenotic Model, and CHL isomorphism |
+| **Historical Lineage** | [`docs/architecture/lineage-and-inspiration.md`](docs/architecture/lineage-and-inspiration.md) | 50-year chronology: 1969 Logic Frame to Cordis & Koishi.js |
+| **Developer Guides** | [`docs/guides/`](docs/guides/) | 60-second onboarding, Web UI, Headless client, Windows setup |
+| **Active Sprints** | [`docs/sprints/_active/`](docs/sprints/_active/) | Real-time tracking of sprints currently in execution (none in flight — all graduated) |
+| **Thematic Sprint Archive**| [`docs/sprints/`](docs/sprints/) | Catalog of 460+ completed sprints and master log [`sprint_log.md`](docs/sprints/_index/sprint_log.md) — latest: History Provenance Integrity Suite (467–469, [`04_storage-network/`](docs/sprints/04_storage-network/)) & README Modernization Suite (461–466, [`06_kernel-reorganization/`](docs/sprints/06_kernel-reorganization/)) |
+| **Weekly Changelogs** | [`docs/changelog/`](docs/changelog/) | Chronological weekly logs (Current: [`2026-W39.md`](docs/changelog/2026-W39.md)) |
+
+---
+
+## 📄 License & Community
+
+CLM is open-source software licensed under the [MIT License](LICENSE).
+
+- **Issues & Discussions**: [GitHub Issues](https://github.com/xlp0/CLM/issues)
+- **Active Sprint Tracking**: [`docs/sprints/programs/orc/README.md`](docs/sprints/programs/orc/README.md)

clm_kernel-0.0.2/assets/README.md

@@ -0,0 +1,29 @@
+# `assets/` — MCard Data Assets (OKF Bundle-Root Index)
+
+> This directory is the **materialized data-asset layer** of the Sovereign Archive
+> ([Sovereign Archive Architecture §11.3](docs/architecture/sovereign-archive-architecture.md)).
+> Every subdirectory is a reserved MCard asset category; only the categories below may
+> exist at this root (enforced by the Assets Root Canary in
+> `tools/guards/check_root_whitelist.py`).
+
+| Category | Purpose | Sharing Scope | Index |
+|:---|:---|:---|:---|
+| [`clm/`](clm/) | CLM-specific shared data assets (schemas, seeds, manifests, configs) | Full sovereign state — all PKC nodes must agree | [`clm/index.yaml`](clm/index.yaml) |
+| [`personal/`](personal/) | Sovereign per-developer data assets (profiles, credentials, workspaces, configurations) | Per-node; DID ownership bound | [`personal/index.yaml`](personal/index.yaml) |
+| [`media/`](media/) | Multi-media sample assets (images, models, audio, video, documents, fonts) | Full sovereign state (sample corpus) | [`clm/manifests/media_type_registry.yaml`](clm/manifests/media_type_registry.yaml) (MTR-1) |
+| [`webapps/`](webapps/) | External web application references | Full sovereign state (link registry) | — |
+
+## Separation Principle
+
+`assets/clm/` is the **shared kernel**; `assets/personal/` is the **sovereign periphery**.
+The two must not cross-reference each other. The handle namespace prefix
+(`asset:clm:*` vs `asset:personal:*`) makes this machine-checkable via
+`tools/guards/check_assets_invariants.py`.
+
+## Verification
+
+```bash
+make assets-verify     # recompute hashes, diff against manifests/asset_manifest.yaml
+make assets-register   # idempotent registration into the local SQLite CAS
+make check-assets      # full asset conformance guard
+```

clm_kernel-0.0.2/assets/clm/README.md

@@ -0,0 +1,95 @@
+# `assets/clm/` — CLM-Specific Data Assets (Shared Kernel)
+
+> **MCard Type**: `type/schema`, `type/seed`, `type/runtime/executable_manifest`, `type/config`
+>
+> **Sharing Scope**: Full sovereign state — all PKC nodes must agree on these data
+> assets for the system to function. G-Set CRDT merge semantics apply.
+>
+> **Karpathy Layer**: Layer 1 (raw) — immutable once sealed as MCards. The `card`
+> table is insert-only; version evolution tracked via `handle_history`.
+
+## Subdirectories
+
+| Subdirectory | Content | MCard Type | Sharing Scope |
+|:---|:---|:---|:---|
+| [`schemas/`](schemas/) | Serializable MCard schema definitions (the frozen `mcard_schema.sql` equivalent, plus per-type schemas) | `type/schema` | Full sovereign state (all nodes must agree on schema) |
+| [`seeds/`](seeds/) | Seed data for bootstrapping a new PKC node (initial handles, initial agent identities) | `type/seed` | Full sovereign state (node cloning) |
+| [`manifests/`](manifests/) | Executable manifests (DotSlash-style binary resolution declarations) | `type/runtime/executable_manifest` | Full sovereign state (all nodes must resolve the same binaries) |
+| [`configs/`](configs/) | CLM kernel configurations (observability endpoints, backup schedules, federation parameters) | `type/config` | Selective (some configs are node-specific, some are mesh-wide) |
+
+## Feature Tour
+
+The shared kernel assets demonstrate the core CLM features. Each feature is
+linked to its asset file and specification reference.
+
+| Feature | Description | Asset File | Spec Reference |
+|:---|:---|:---|:---|
+| Universal MCard Ontology | Everything is an MCard — scalars, strings, binaries, directories, networks, devices | [`seeds/mcard_exemplars.yaml`](seeds/mcard_exemplars.yaml) | `docs/spec/20-architecture/card-triad-architecture.md` |
+| Kenotic Programming Model | CLM delegates computation to existing language engines (Python, Rust, JS/TS, Shell) | [`seeds/pcard_exemplars.yaml`](seeds/pcard_exemplars.yaml) | `docs/spec/00-product-overview/product-overview.md` |
+| Hoare Triple Verification | {V_pre} PCard {V_post} — VCards return Bool to gate state commits | [`seeds/vcard_exemplars.yaml`](seeds/vcard_exemplars.yaml) | `docs/spec/40-behavior/hoare_triple_composition_protocol.md` |
+| Function-Number Duality | Every MCard is simultaneously a zero-arity constant function 1→X | [`seeds/pcard_exemplars.yaml`](seeds/pcard_exemplars.yaml) (see `duality_of`) | `docs/spec/40-behavior/baldwin_monadic_pcard_algebra.md` |
+| Type Lattice Vocabulary | Six layers of stratified handles (L0–L5) defining the CLM formal syntax | [`seeds/type_lattice_vocabulary.yaml`](seeds/type_lattice_vocabulary.yaml) | `docs/spec/20-architecture/system-architecture.md` |
+| Petri Net Concurrency | Bipartite Place/Transition net with P-invariant conservation laws | [`seeds/petri_net_topology.yaml`](seeds/petri_net_topology.yaml) | `docs/spec/20-architecture/system-architecture.md` |
+| Cordis Fiber Lifecycle | 5-state spatiotemporal execution with LIFO disposer rollback (<1ms) | [`seeds/cordis_fiber_lifecycle.yaml`](seeds/cordis_fiber_lifecycle.yaml) | `docs/spec/40-behavior/pcard_ioc_composition.md` |
+| Baldwin Modularity Operators | Six closed algebraic operations for systematic module composition | [`seeds/baldwin_operators.yaml`](seeds/baldwin_operators.yaml) | `docs/spec/40-behavior/baldwin_monadic_pcard_algebra.md` |
+| Layer-Specific Execution | Executable manifests for each architectural layer (L0–L5) | [`manifests/layer0_manifest.yaml`](manifests/layer0_manifest.yaml) – [`layer5_manifest.yaml`](manifests/layer5_manifest.yaml) | `docs/spec/20-architecture/system-architecture.md` |
+| PCard/VCard Seed Schemas | Structural schemas for non-MCard seed collections | [`schemas/pcard_seed_schema.yaml`](schemas/pcard_seed_schema.yaml), [`schemas/vcard_seed_schema.yaml`](schemas/vcard_seed_schema.yaml) | `docs/spec/30-interfaces/asset-directory-conformance.md` |
+| Cross-Language Parity | N-Version Consensus (BLAKE3 bit-identical across Python, Rust, TS, Shell) | [`Concrete/e2e/cross_language_parity.yaml`](../../computable_knowledge/Concrete/e2e/cross_language_parity.yaml) | `docs/spec/00-product-overview/product-overview.md` |
+| Continuous Learning Loop | Meta-circular learning loop (Gamma) with epistemic fitness (Delta E) and hypothesis revision | [`Abstract/layer5_system/continuous_learning_stratum.yaml`](../../computable_knowledge/Abstract/layer5_system/continuous_learning_stratum.yaml) | `docs/spec/20-architecture/system-architecture.md` |
+
+### Try It In Action
+
+Developers can immediately verify and explore these features using the following commands:
+1. **Verify Asset Conformance & Envelopes**:
+   ```bash
+   make check-assets
+   ```
+2. **Verify Triadic Transclusions & Zero Dangling Pointers**:
+   ```bash
+   python3 tools/guards/check_triadic_transclusion_invariants.py
+   ```
+3. **Verify Layer Vocabulary Sync & Triad Symmetry**:
+   ```bash
+   make check-boundaries
+   ```
+
+## Separation Principle
+
+`assets/clm/` is the **shared kernel** — every PKC node must agree on these data
+assets. `assets/personal/` is the **sovereign periphery** — each developer's
+personal data assets are their own. These two directories must not cross-reference
+each other. The handle namespace prefix (`asset:clm:*` vs `asset:personal:*`) makes
+this distinction machine-checkable.
+
+## Content-Addressing
+
+All files in `assets/clm/` are content-addressed as MCards via the kernel's
+**parameterized multi-algorithm hash registry** (INV-02, Sprint 164). The active
+algorithm is controlled by `CLM_HASH_CONFIG` — currently `sha256:` by default, with
+BLAKE3 (>2 GB/s) available as a parameterized coexisting algorithm. Each file
+declares its own `hash_algorithm` in its frontmatter, and the registered hash
+MUST match that declaration. The `handle_registry` maps human-readable
+handles (`asset:clm:*`) to current content hashes. The `handle_history` table
+tracks version evolution. This makes every change auditable, reversible, and verifiable.
+
+## Machine Inventory & Verification
+
+- **`index.yaml`** in this directory and each concern subdirectory is the machine-readable
+  OKF-style index (handle, type, hash algorithm, owner, sharing scope, per-file inventory).
+- **`manifests/asset_manifest.yaml`** is the deterministic, committed hash inventory of all
+  shared data assets (`assets/clm/`, `assets/media/`, `assets/webapps/`).
+  `assets/personal/` is deliberately excluded (sovereign periphery).
+- **`make assets-verify`** recomputes hashes and diffs against the manifest (offline-safe).
+- **`make assets-register`** idempotently registers the manifest into the local SQLite CAS
+  (`card`, `handle_registry`, `handle_history` in `db/content_memory.db`).
+- **`make check-assets`** runs the conformance guard
+  (`tools/guards/check_assets_invariants.py`) enforcing the asset MUSTs from
+  [`docs/spec/30-interfaces/asset-directory-conformance.md`](../../docs/spec/30-interfaces/asset-directory-conformance.md).
+
+## References
+
+- [`docs/architecture/sovereign-archive-architecture.md`](../../docs/architecture/sovereign-archive-architecture.md) §11 — The Project Directory as a Single Source of Truth
+- [`docs/sprints/08_rust-native/sprint-145-ssot-directory-exemplar.md`](../../docs/sprints/08_rust-native/sprint-145-ssot-directory-exemplar.md) — Sprint 145 design document (archived from `programs/orc/`)
+- [`docs/architecture/assets-clm-implementation-plan.md`](../../docs/architecture/assets-clm-implementation-plan.md) — Implementation plan for this directory's conformance
+- [`docs/spec/30-interfaces/asset-directory-conformance.md`](../../docs/spec/30-interfaces/asset-directory-conformance.md) — Normative asset MUSTs (RFC 2119)
+- [`types/schemas/mcard_schema.sql`](../../types/schemas/mcard_schema.sql) — Core MCard schema definition

clm_kernel-0.0.2/assets/personal/README.md

@@ -0,0 +1,44 @@
+# `assets/personal/` — Personalized / Developer-Specific Data Assets (Sovereign Periphery)
+
+> **MCard Type**: `type/profile`, `type/credential/sbt`, `type/config/personal`, `type/workspace`
+>
+> **Sharing Scope**: DID-bound and private — shared only by explicit consent.
+> Cryptographically bound to the developer's DID; cannot be forged, transferred,
+> or repudiated.
+>
+> **Karpathy Layer**: Layer 1 (raw) — immutable once sealed as MCards. The `card`
+> table is insert-only; version evolution tracked via `handle_history`.
+
+## Subdirectories
+
+| Subdirectory | Content | MCard Type | Sharing Scope |
+|:---|:---|:---|:---|
+| [`profiles/`](profiles/) | Developer profiles — name, bio, skills, DID. Stored as MCards signed by the developer's `did:key`. | `type/profile` | Selective (developer chooses what to share) |
+| [`credentials/`](credentials/) | SBT (Soul Bound Token) credentials — earned roles, certifications, capabilities. Non-transferable, bound to the developer's DID. | `type/credential/sbt` | Selective (developer presents credentials as needed) |
+| [`configurations/`](configurations/) | Personal configurations — editor preferences, tool settings, environment variables. | `type/config/personal` | Private (not shared unless explicitly exported) |
+| [`workspaces/`](workspaces/) | Developer-specific workspace state — active sprint context, in-progress notes, scratch data. | `type/workspace` | Private (ephemeral, not part of the shared archive) |
+
+## Separation Principle
+
+`assets/personal/` is the **sovereign periphery** — each developer's personal data
+assets are their own, bound to their DID, and shared only by explicit consent.
+`assets/clm/` is the **shared kernel** — every PKC node must agree on those data
+assets. These two directories must not cross-reference each other. The handle
+namespace prefix (`asset:personal:*` vs `asset:clm:*`) makes this distinction
+machine-checkable.
+
+## DID Binding
+
+All files in `assets/personal/` must carry a DID signature (`did:key:*` for human
+EOAs). This is verified at ingestion time, not by convention. The DID binding
+ensures:
+
+- **Non-forgeability**: Only the DID key holder can create a valid personal asset
+- **Non-transferability**: SBT credentials are bound to the DID and cannot be transferred
+- **Non-repudiation**: The DID signature proves authorship; the signer cannot deny it
+
+## References
+
+- [`docs/architecture/sovereign-archive-architecture.md`](../../docs/architecture/sovereign-archive-architecture.md) §11 — The Project Directory as a Single Source of Truth
+- [`docs/sprints/programs/orc/sprint-145-ssot-directory-exemplar.md`](../../docs/sprints/programs/orc/sprint-145-ssot-directory-exemplar.md) — Sprint 145 design document
+- [`docs/architecture/verification-led-identity-payment.md`](../../docs/architecture/verification-led-identity-payment.md) §10 — Data Asset Directories for Identity and Payment