42-software-driven-ssd

Description

Software-Driven SSD — Cri-One Storage Hardware Family & Software for Data

Inventor: Christopher Gabriel Brown  · SKU: 2072  · Maturity: L2 (Designed) / L3 (Prototyped for Software for Data)  · Version: 1.0.0  · Status: Three custom storage/accelerator hardware designs in active development; one software product with runnable reference implementation  · Patent posture: Method-claim filing in preparation; may relate to umbrella application US 19/540,453 (“Integrated Technology Portfolio”). Inventor’s broader patent portfolio includes applications 17/687,656, 63/552,008, 29/839,062, 29/892,202, 17/454,808, 18/650,137, 17/454,807, 18/460,559, 18/370,908, 18/219,732, 19/031,884, 19/177,547, 29/788,287, 16/948,862, 17/405,832, 16/658,062, 17/448,179, 16/276,673, 16/258,495, 16/378,597, 15/825,059, 16/004,322, 62/530,996, 62/393,084, 62/892,994, 63/086,494, 62/586,875, 62/375,115, 16/794,048, and 16/276,664, among others. · License: Proprietary & Confidential; commercial source license for the software product  · Source corpus: Buy Invent A1–A1752 (1,752 inventor-authored entries, © 2017–2019 Christopher G. Brown)

Overview

This package holds three custom storage and accelerator hardware designs plus one software product under the Cri-One brand. Each hardware design is self-contained with its own KiCad project, datasheets, mechanical drawings, and architecture notes. The software product — Cri-One Software for Data — is a working pure-Python reference implementation: software for data that does not lose what it stores, that lets people and AI work on the same scenarios at the same time, and that can be packaged, shipped, and resold as a unit.

The whole product is anchored on A649 (2017): “software software please make my software software information and data management creation and business software… an easy and re-sell able application package maker and formatted.” Every architectural decision can be traced back to a 2017–2019 entry in the inventor’s prior-IP corpus.

Total project files: 47  · Total lines of source (excluding binaries): 7,978  · Python source modules: 12 files, 2,358 lines  · Test suite: 5 files, 726 lines  · Demos: 7 scripts, 673 lines  · Required Python version: ≥ 3.10  · External dependencies (core): None (Python stdlib only)

Sub-Project 1: Cri-One 2.5″ Vault (Hardware)

Form Factor 2.5″ external NVMe enclosure

Enclosure Dimensions 100 × 69.85 × 9.5 mm

Internal Drive Standard M.2 2280 NVMe SSD (22.00 × 80.00 × 2.38 mm)

Bridge Chip ASMedia ASM2364 — USB 3.2 Gen 2×2, ~2 GB/s sustained throughput

Physical Power Switch Hardware-level off — true electrical disconnect, not software standby

Design State KiCad schematic + symbols + footprints + BOM; JLCPCB-ready. OpenSCAD parametric model (94 lines) included.

OpenSCAD Model Params Wall: 1.6 mm; Corner radius: 3.0 mm; USB-C opening: 9.0 × 3.2 mm; 7 cooling slots (34.0 × 1.6 mm each); 4 corner fixings (r = 1.6 mm)

Sub-Project 2: Cri-One L3 SSD (Hardware)

Form Factor 2.5″ SATA hot-swap

Target Carrier HPE ProLiant Smart Carrier sleds

Bridge Architecture Hardware SATA-to-managed-NAND bridge — no FPGA, no firmware to write, no Phison/SMI partnership needed

Design State v0 design exploration; bridge chip selection in progress

Sub-Project 3: Cri-One PCIe Accelerator (Hardware)

Form Factor HHHL PCIe — 167.65 × 68.90 mm, single-slot, low-profile, no auxiliary power

Compute Cores 8 RISC-V cores

Memory 1 GB DDR3

On-Board Storage 1 TB eMMC

FPGA Lattice ECP5-85F — open FPGA toolchain (Yosys/nextpnr)

Host Interface PCIe Gen 2 ×4

Design State Architecture + tentative BOM + Python platform files + firmware/host-driver folders. Spiritual successor to Xeon Phi 3120A with on-board SSD.

Sub-Project 4: Cri-One Software for Data (Software — Reference Implementation)

A working reference implementation of Cri-One Software for Data — pure Python, standard library only, no external dependencies for the core runtime. It demonstrates every capability claimed in this listing on real bytes: collaborative RAID over portable Business Cartridges, with human + AI write tagging, format-doubling encryption, kill-switch license envelopes, and recall protocol.

Package Name cri-one-software-for-data

Version 1.0.0

Python Requirement ≥ 3.10 (tested on 3.10, 3.11, 3.12)

Core Dependencies None — Python standard library only

Optional Extras: [agents] anthropic ≥ 0.40.0, pydantic ≥ 2.0

Optional Extras: [embeddings] voyageai ≥ 0.3.0

Console Script sfd — 8 subcommands (build-cartridge, inspect, recall, array-create, array-status, array-add, array-corrupt, array-rebuild)

Build System setuptools ≥ 61.0 via pyproject.toml

Maturity L3 (Prototyped) — runnable reference implementation; 36+ unit tests passing; 7 demos passing

License Commercial source license. Perpetual, irrevocable, worldwide, non-exclusive, royalty-free, sublicensable rights to run, modify, fork, redistribute, and incorporate into commercial products.

Cartridge Binary Format (.sfd)

All multi-byte integers are little-endian. All text is UTF-8. File magic: CRIONESFD (9 bytes).

Offset Size Field

Total fixed header size: 192 bytes (0xC0). Each scenario block begins with a 2-byte magic ( SC ), a 16-byte scenario UUID, then the encrypted payload and embedding with their individual nonces and MACs.

Format-Doubling Encryption Envelope (A376)

Layer 1 (Inner — per-scenario) K scen = SHAKE-256(master_key ‖ cartridge_uuid ‖ scenario_uuid, 32); Keystream = SHAKE-256(K scen ‖ nonce, len); Ciphertext = plaintext XOR keystream; Integrity = HMAC-SHA256(K scen , nonce ‖ ciphertext)

Layer 2 (Outer — per-cartridge) CSV-styled manifest encrypted with K manifest = SHAKE-256(master_key ‖ cartridge_uuid ‖ b"manifest", 32). Footer HMAC keyed by K footer .

Nonce 12 bytes, generated fresh per block via secrets.token_bytes(12)

Salt 32 bytes random per cartridge

Master Key 32 bytes, derived via SHAKE-256 with domain label sfd:v1:master

Domain Separation Labels sfd:v1:scenario-key , sfd:v1:manifest-key , sfd:v1:license-key , sfd:v1:footer-mac , sfd:v1:stream , sfd:v1:leaf: , sfd:v1:node:

Merkle Tree SHA-256 with domain-separated leaf and node hashing; odd levels duplicated to next power of two

Production Recommendation Swap to AES-256-GCM via the cryptography library with separate nonce per scenario

Collaborative RAID Array Protocol

Redundancy Mode A: REPLICATION (default) R-way mirroring (default R = 3). Each scenario stored on R cartridges. Tolerates loss of any R−1 cartridges. Default: 5 cartridges, 3-way replication → tolerates any 2 failures.

Redundancy Mode B: PARITY K data shards + 1 XOR parity shard. Tolerates loss of any 1 shard. P0 = XOR of all data shards. Fixed 4 KiB chunk size.

Hot Add (A246) Append new cartridge to array, update array.json , new scenarios use new geometry. Existing scenarios readable throughout.

Hot Subtract (A246) Mark cartridge “draining”; scenarios migrated off; cartridge released on drain completion.

Rebuild Protocol Failed cartridges rebuilt from surviving replicas/parity. Second failure during rebuild does NOT cascade — scenario-level erasure coding operates on coherent units, not raw stripes.

Scenario Assignment Round-robin: scenario i → cartridges [( i  +  r ) mod M for r in 0..R−1]. No two replicas on the same cartridge.

Array Manifest array.json — array UUID, redundancy mode, replication factor, cartridge members, per-scenario assignment map, conflict log, archive list

Human + AI Conflict Resolution (A1229 — MCIAU)

Incoming Actor Existing Actor Resolution (HumanOverridePolicy)

Critical invariant: No conflicting write is silently dropped. Every conflict results in either an explicit merge, a preserved fork, or an archived proposal. Both outcomes are observable by the runtime. The system also provides a StrictHumanOnlyPolicy where every AI write becomes a proposal until explicit human approval.

Actor types: HUMAN, AI, JOINT  · Write roles: SEED, REVISION, PROPOSAL, FORK, MERGE

License Envelope & Kill Switch (A1239–A1243)

Fields cartridge_uuid , license_id , licensee , valid_from (UNIX epoch), valid_until (UNIX epoch), kill_switch_required (bool), kill_switch_endpoint (URL), royalty_terms (dict), revocation_signature

Kill Switch Enforcement If kill_switch_required is True, the runtime calls the endpoint before each read. A response of {"status": "revoked"} raises LicenseRevoked and the cartridge refuses to decrypt. Network failure defaults to fail-closed.

Storage JSON over UTF-8, encrypted with the same format-doubling scheme as scenarios using a derived license key

Recall Protocol — RAG Primitive (A385–A390, A1437–A1440)

Embedding Dimension 64 (EMBED_DIM) — 64 float32 values × 4 bytes = 256 bytes per vector. Production: 384, 768, or 1024.

Stub Embedder Deterministic character-trigram frequency hashing into EMBED_DIM dimensions. Normalized L2. Not semantic — pedagogical only.

Search Method Cosine similarity, top- k . In-memory vector index over scenarios.

Production Embedder Buyer’s choice (sentence-transformers, OpenAI ada, BGE, Voyage AI). Optional [embeddings] extra includes voyageai ≥ 0.3.0.

AI Agent Integration (Claude + Voyage AI)

Claude Model claude-opus-4-7 via client.messages.parse() (structured outputs)

Thinking Mode Adaptive ( thinking: {"type": "adaptive"} )

Effort Level High ( output_config: {"effort": "high"} )

Prompt Caching 2-block system prompt with cache_control: {"type": "ephemeral"} on both blocks (persona + corpus context)

Output Type ProposedWriteSet (pydantic model): rationale + list of ProposedWrite (target_scenario_id, payload, rationale)

Voyage AI Embedder Real embeddings via src/sfd/agents/voyage_embedder.py (optional [embeddings] extra)

Orchestrator src/sfd/agents/orchestrator.py — issues instruction, recalls top- k context, calls Claude, writes proposals + instruction into array via MCIAUChannel

Source Modules — Full Inventory

Module Lines Corpus Anchor Purpose

envelope.py 154 A376, A41 Format-doubling encryption; key derivation, encrypt/decrypt, Merkle root

cartridge.py 367 A1059, A246, A170, A1515, A1556 Cartridge writer + reader; binary format implementation

erasure.py 141 A1647–A1650 Scenario-level erasure coding; XOR parity + R-way replication

array.py 552 A222, A234, A246, A260, A1229, A1672 Collaborative RAID runtime; append, read, mark_failed, rebuild, hot_add

conflict.py 209 A1229, A1437–A1440 Human/AI write tagging; HumanOverridePolicy + StrictHumanOnlyPolicy

mciau.py 135 A1229 (verbatim) MCIAU instruction channel; Instruction + AIResponse + MCIAUChannel

license.py 132 A1239–A1243, A1311 License envelope + kill switch; LicenseEnvelope + LicenseRevoked

recall.py 130 A385–A390, A1437–A1440, A858–A859 RAG primitive; RecallEngine + stub_embed + cosine similarity

corpus.py 130 A1–A1752 Buy Invent corpus loader; parses line format into CorpusEntry → Scenario

cli.py 205 — Command-line interface; 8 subcommands via argparse

Total 2,358

Test Suite — Full Inventory

Test File Lines Coverage

test_core.py 168 Envelope encrypt/decrypt round-trip, MAC failure, Merkle determinism, master key derivation, manifest CSV round-trip, cartridge write/read round-trip, wrong passphrase rejection, corruption detection, perpetual license validation, revoked license, kill-switch (no callback, revoke response, OK response)

test_array.py 141 XOR parity recovery, replication assignment distinctness, R > M validation, array create/open, append/read, double-failure survival and rebuild (R = 3, 15 scenarios, lose cartridges 1 & 3), triple-failure refusal, hot-add preserves existing

test_conflict.py 150 Human seeds first, AI proposing into human archives, human overrides AI, HUMAN/HUMAN raises ConflictError, AI/AI forks, array archives AI proposals, double-human raises, no silent loss under 5 repeated AI writes, MCIAU instruction/response round-trip

test_recall.py 61 Stub embed shape (256 bytes), deterministic embedding, recall engine top- k relevance, corpus loader (1,000+ entries if corpus present), corpus-to-scenarios conversion

test_agent.py 200 Agent propose returns AI-tagged WriteIntents (mocked Claude), cache_control on system blocks, model/thinking/effort verification (claude-opus-4-7 + adaptive + high), orchestrator archives conflicting AI proposals (end-to-end with mocked client)

Total 726

Demo Scripts — Full Inventory

Demo Lines What It Proves

demo_01_build_cartridge.py 66 Cartridge writer/reader round-trip from 25 corpus entries; format-doubling envelope; license enforcement; wrong-passphrase rejection

demo_02_build_array.py 70 5-cartridge replication array (R = 3); 30 corpus entries; scenario placement across replicas; status reporting

demo_03_silent_corruption.py 71 Single-bit flip at file midpoint causes clean, loud failure — not silent corruption

demo_04_double_failure_rebuild.py 112 Lose cartridges 1 & 3 from a 5-cartridge array (20 scenarios); all scenarios still readable; rebuild restores both; post-rebuild integrity verified

demo_05_human_ai_conflict.py 128 5-step conflict walkthrough: human seed, AI proposal archived, 5 repeated AI proposals all preserved, AI/AI fork preserved, HUMAN/HUMAN raises ConflictError

demo_06_hot_add.py 102 Start with 5 cartridges + 10 scenarios, hot-add 6th cartridge, append 5 more scenarios; existing scenarios remain readable; all 15 scenarios verified

demo_07_real_ai_agent.py 124 End-to-end Claude orchestration: 5 business scenarios seeded, instruction issued, Claude proposes writes via MCIAU, conflicts auto-archived. Dry-run without API key; live with ANTHROPIC_API_KEY set.

Total 673

Buy Invent Corpus Citation Map

A-Number(s) Module Anchor Quote

A1059, A246, A170, A1515, A1556 cartridge.py “ship cloud backups… on recordable media for recovery”

A1647–A1650 erasure.py “quantum raid processing / memory / service / scale”

A222, A234, A246, A260, A1229, A1672 array.py “ethernet fixed raid… raid activate each level for accuracy”

A1229, A1437–A1440 conflict.py “MCIAU… instructional software that tells the AI what to do”

A1229 mciau.py (verbatim — same source as conflict.py)

A1239–A1243, A1311 license.py “data code kill switch agreement” / “data loss and the kill update blanket”

A385–A390, A1437–A1440, A858–A859 recall.py “real life scenarios” / “library of operations for working scenarios… shared by payment”

A1–A1752 corpus.py The corpus boundary itself

A649 Whole product “software software please make my software… an easy and re-sell able application package maker and formatted”

Differentiation vs. Conventional Storage

Dimension Conventional RAID / Replication / Cloud Cri-One Collaborative RAID

Redundancy unit Block / object Scenario (corpus + index + envelope + license)

Silent corruption Returns wrong data; ZFS partial mitigation Quarantined — kill-update blanket (A1311)

Conflict resolution Last-write-wins or app-level CRDT Explicit merge ceremony; no silent drops

Air-gap shippability Online replication; cannot be shipped Native — array is the shippable unit (A1059, A170)

License envelope Trust-the-recipient or DRM bolt-on Travels with each cartridge; kill-switch enforced (A1239–A1243)

Add / subtract live Limited; rebuild stalls workload Hot add and subtract (A246, A260) without scenario downtime

Commercial primitives Storage is a cost center Per-cartridge sale, subscription, royalty-report (A311, A1035, A1291, A230)

Substrate Vendor cloud or fixed controller Substrate-agnostic, hardware-neutral (A1515)

• README.md — Master index and project overview
• PLAYBOOK.md — Internal playbook with identity, hooks, status, and gaps
• MANIFEST.json — Machine-readable project metadata
• CHANGELOG.md — Change log (Keep a Changelog format)
• CITATION.cff — Citation metadata (CFF 1.2.0)
• LICENSE — Proprietary license with patent notice
• CONTACT_INFO.txt / Contact Information.txt — Seller contact details
• 1 light trigger.txt — Buy Invent A1–A1752 corpus (1,752 entries, © 2017–2019)
• Yesterday.txt — AutoPhi portfolio summary and estimated valuations
• google_patents_search_list.txt — 215 USPTO patent application reference entries across 30+ unique application numbers
• cri-one-2-5-vault.scad — OpenSCAD parametric 3D model of the 2.5″ Vault enclosure (94 lines)
• cri-one-software-for-data.zip — Archive of the software distribution

cri-one-software-for-data/ directory:

• README.md — Software product documentation with quickstart
• ARCHITECTURE.md — Binary format, protocol, and corpus citation map (334 lines)
• LICENSE.md — Commercial source license (7 sections, 210 lines)
• pyproject.toml — Python packaging metadata (50 lines)
• sample_corpus.txt — 25 synthetic corpus entries for out-of-box demos
• src/sfd/ — 12 Python source modules (2,358 lines)
• tests/ — 5 test files + __init__.py (726 lines, 36+ unit tests)
• demos/ — 7 demo scripts (673 lines) + output directory

sales-pitches/ directory:

• businesscartridge26_STORE_PRODUCT_DESCRIPTION.html — Full storefront listing HTML (389 lines)
• businesscartridge26_PRODUCT_CARD.md — Magento product card with catalog metadata, SEO fields, and image prompts (203 lines)

How this is delivered

This package ships on a single Blu-ray disc, posted to the delivery address on your order. The archive on the disc is AES-256 encrypted; the passphrase is sent separately, by email, once the disc is despatched — so the disc alone is of no use to anyone who intercepts it.

Discs are despatched by tracked, signed-for post. Allow 5 business days for mastering and verification before despatch.

© 2026 Christopher Gabriel Brown. All rights reserved. “Cri-One Software for Data,” “Cri-One Collaborative RAID,” “Cri-One Business Cartridge,” and “Buy Invent” are product designations of the licensor. Source corpus filed under personal patent reference series. Method-claim patent filing in preparation; may relate to umbrella application US 19/540,453. The array specification and reference implementations are not certified for any specific industrial use absent independent qualification by the licensee.

Photo