64. SellPhi — Turnkey Magento + WordPress Storefront, One Command, One VPS (LIVE)

What This Handoff Is

This is SellPhi — a complete Magento 2 CE storefront, WordPress blog, site-wide RSS feed generator, and admin console, packaged for one-command installation on any Linux VPS. Project 64 is the productized form of the exact stack running cri-one.com/store. It ships empty — no products, no customers, no orders, no third-party credentials, and none of the inventor's content or IP — and personalizes itself to the buyer's brand at install time. Underneath: nginx + PHP-FPM + MariaDB under Docker Compose, a CMS template set (featured-items fan-out, footnote with terms, share-to-a-friend), a category skeleton (Store / Blog / Music / Art / Video / Section), backup and restore tooling, and an interactive guided installer. Claude AI is baked into the admin: supply an Anthropic API key and six authoring buttons activate across the storefront and blog. Version 0.1.0. Live in the bid catalog at row 53 as Base, No IP — single-site perpetual use license.

What It Means as a Store-Infrastructure Handoff

Most commerce platforms are rented. Shopify, BigCommerce, and their peers hand the merchant an account, not a system — the merchant's catalog, customers, and copy live on infrastructure they will never control, at a subscription that never terminates. The self-hosted alternative is Magento, and Magento's reputation for punishing initial deployment is entirely earned: a first-time install routinely consumes a week of specialist time and is the single line item that kills self-hosted commerce projects. SellPhi's proposition is that the deployment problem is solved and the solution is transferable. The buyer runs ./install.sh, answers questions, and has a working storefront with a blog and a feed. Layered on top is an authoring surface that did not exist in this category: Claude reachable from inside the admin at the six places a merchant actually writes — the product edit page, the WordPress editor, customer communications, any CMS block, any content editor with a language selector, and the category page. The model tiers are configurable (CLAUDE_MODEL_FAST for descriptions and rewrites, CLAUDE_MODEL_DEEP for blog drafts and long-form) and the buyer's own Anthropic account is billed directly, at cost, with no resale markup. Every AI output is a draft the buyer reviews. Nothing is published or sent automatically.

What Has Been Completed

Version 0.1.0 — Complete Package, Live in Bid Catalog Row 53:

• Magento 2 CE storefront, WordPress blog mounted at /blog/, and a site-wide RSS feed generator with a styled reader view
• Full plumbing stack: nginx + PHP-FPM + MariaDB, orchestrated by docker-compose.yml
• Interactive guided installer (install.sh) — explains every step as it goes, asks before acting, never runs anything without an explicit "yes," and can be stopped and resumed at any point with a printed resume command
• Six Claude AI admin buttons, each documented with its location, model tier, and typical per-call cost in docs/CLAUDE-FEATURES.md:
  • Write description (fast tier) — Catalog → Products → any product edit page; 3–5 sentences in the configured brand voice
  • Draft blog post (deep tier) — WordPress editor; full post from a title and a 1–2 sentence outline
  • Reply with Claude (fast tier) — Sales → Communications; drafts a reply into the compose window, sends nothing
  • Rewrite in [tone] (fast tier) — any editor; formal / casual / punchy / warm / technical, up to 3 variants side by side
  • Translate (fast tier) — preserves markup and links
  • Category writer (deep tier) — category intro paragraph derived from the category name and its first 5 products
• Complete configuration reference (docs/CONFIG.md): site identity, admin login, three database passwords, Claude key and model tiers, Stripe and PayPal, SMTP relay, TLS mode, and backup directory and hour — all in one .env the installer never overwrites
• Graceful degradation at every optional layer — blank payment keys drop to invoice / manual checkout; skipped SMTP falls back to PHP mail(); TLS_MODE=off hands TLS upstream to Cloudflare or Caddy
• CMS template set (featured-items fan-out, footnote with terms, share-to-a-friend) and category skeleton (Store / Blog / Music / Art / Video / Section)
• Backup and restore tooling with configurable nightly schedule
• Documentation set: START-HERE.txt, docs/QUICKSTART.md, docs/CONFIG.md, docs/CLAUDE-FEATURES.md, docs/TROUBLESHOOTING.md, docs/UPGRADING.md, and LICENSE.txt
• Live in the bid catalog as row 53: "SellPhi (Project 64) — Magento + WordPress storefront package for one VPS; single-site perpetual use license. Base, No IP."

What the Customer Needs to Do

To License and Deploy:

1. Request a Quote: SellPhi is priced per site. Tell us whether this is a single storefront or an agency deployment across multiple client sites — the license structure differs.
2. Sign NDA: required at the licensed-software tier for the complete package including install.sh, docker-compose.yml, and the Claude proxy configuration.
3. Rent a Linux VPS: Ubuntu, Debian, CentOS, Rocky — anything modern. 2 GB RAM minimum, 4 GB recommended. A $4/month instance is enough to validate the whole stack before committing to production hosting.
4. Point a Domain at It: the installer needs a domain resolving to the VPS's IP before TLS provisioning will succeed.
5. Read START-HERE.txt First: three steps — rent the VPS, copy the folder onto it, run ./install.sh. That is the whole deployment.
6. Configure .env: domain, brand name, and admin credentials are the only required values. Everything else — payments, SMTP, TLS mode, backups — is optional and degrades gracefully if left blank.
7. Add an Anthropic API Key (Optional): obtain one at console.anthropic.com and set CLAUDE_API_KEY. The AI buttons activate immediately with no restart. Without a key every button still appears and prompts for one. Claude can be suspended at any time with docker compose stop claude-proxy.
8. Build Your Own Catalog: SellPhi deliberately ships with no products, categories, customers, or orders. The storefront is a working, empty system — the commercial content is the buyer's to create.

Timeline Estimate: Guided install on a prepared VPS: under an hour for an operator following START-HERE.txt. Domain and TLS propagation: add up to 24 hours depending on DNS. First catalog and brand configuration: 1–2 days for a merchant who knows their own product line. Agency multi-site rollout: the second and subsequent deployments are substantially faster than the first, since .env is the only file that differs between sites.

Acquisition price: Quote on request (SellPhi v0.1.0 — complete package: Magento 2 CE + WordPress + RSS generator + admin console + Claude AI hooks + CMS templates + category skeleton + backup/restore tooling + guided installer, under a single-site perpetual use license)

Included at no extra charge inside All In One (20T) — the complete cri-one.com portfolio acquisition, where SellPhi is the storefront architecture that delivers the rest of the catalog. Agency and multi-site license structures are quoted separately. See the valuation page for the full rationale.

65. WonderPhi Library — Ready-Made Recipes for WonderPhi Compute (LIVE)

What This Handoff Is

This is WonderPhi Library v1.0.0 — the recipe collection that writes WonderPhi Compute plans for you. Project 65 exists because of a gap in Project 66: WonderPhi Compute runs a plan across every CPU core, honestly and fast, but someone still has to write the plan. This library writes it. You have 500 videos to transcode; you don't sit down and author a plan file, you run python wpc-recipe.py ffmpeg-h264 .\videos and out comes videos.plan.wpc.txt — one tuned command per file, ready to feed straight to the runtime. Library writes the plan. WonderPhi Compute runs the plan. Recipes cover ffmpeg, ImageMagick, PDF tools, 7-Zip, hashing, curl, git, and the obvious NVIDIA GPU jobs. Zero dependencies, Python standard library only, no network, no telemetry, and it never modifies wpc.exe — the 10 Commandments stay intact. Live on the storefront at $2.25 personal (WONDERPHI-LIBRARY-100) and $24.75 industrial (WONDERPHI-LIBRARY-INDUSTRIAL-100), both perpetual, as Base, No IP.

What It Means as a Recipe-Layer Handoff

The barrier to using a parallel runner is never the runner. It is the blank page. An operator who buys WonderPhi Compute and then faces an empty plan.wpc.txt has to decide not only how to structure the job but which flags produce a good result — and the second question is the expensive one. Anyone can write a loop over a folder of videos; knowing that a particular ffmpeg invocation produces a correctly-encoded H.264 file at a sensible quality target is an hour on Stack Overflow, repeated for every tool. This library ships that knowledge as executable defaults. Point a recipe at a folder and the good flags are already filled in. Three input models cover every shape of batch job: files scans a folder for matching types and is used by most recipes; dirs treats each immediate subfolder as one job and drives pytest-dirs, git-gc, and git-pull; lines reads one URL or argument per line for curl-check and curl-get. GPU recipes are marked [GPU] and emit NVIDIA-accelerated command lines, with --gpu auto probing nvidia-smi and pointing at the CPU equivalent when no card is present rather than emitting a plan that will fail. Nothing here executes anything: the library reads a folder and writes a text file, which makes it entirely safe to run speculatively.

What Has Been Completed

v1.0.0 — Complete and Live:

• wpc-recipe.py — the plan generator; Python 3.8+, standard library only, zero external dependencies
• Curated recipes across the tools people actually batch:
  • Video: ffmpeg-h264 (CPU transcode), ffmpeg-nvenc (GPU H.264), ffmpeg-nvenc-hevc (GPU H.265/HEVC, smaller files)
  • Image: img-webp (WebP conversion), realesrgan (4× GPU upscaling)
  • Documents: pdf-text (text extraction across a folder of PDFs)
  • Integrity: sha256 (per-file hashing with a combined manifest step at the end)
  • Network: curl-check (URL health checks), curl-get
  • Development: pytest-dirs (every test suite under a tree in parallel), git-gc, git-pull
  • Audio: whisper (GPU speech-to-text transcription via CUDA)
  • Archive: 7-Zip recipes
• Three input models — files, dirs, lines — each shown in --list so the operator knows what to point a recipe at
• Full option set: --list, --out FILE, --outdir DIR, --gpu auto|on|off, --inbox, --stdout, --check
• --inbox handoff — drops the generated plan directly into %USERPROFILE%\bin\wpc-inbox\ where WonderPhi Compute's always-on watcher runs it within fifteen seconds
• GPU detection with honest fallback — --gpu auto probes nvidia-smi; with no GPU present the tool warns and names the CPU equivalent (e.g. ffmpeg-nvenc → ffmpeg-h264) rather than emitting a plan that cannot run
• GPU environment integration — when WonderPhi Compute's watcher runs a GPU plan it exposes WPC_GPGPU, WPC_GPU_VRAM_FREE_MB, and WPC_GPU_UTIL_PCT to every task
• Per-recipe Needs on PATH: headers naming the external program each recipe drives
• INDEX.md with the full recipe table, README.md, LICENSE, and a samples/ folder containing example-urls.txt and curl-check.example.plan.wpc.txt

What the Customer Needs to Do

To License and Deploy:

1. Choose a Tier: WONDERPHI-LIBRARY-100 at $2.25 personal, or WONDERPHI-LIBRARY-INDUSTRIAL-100 at $24.75 for commercial deployment. The Complete Bundle at $14.75 / $224.75 includes this and all eight other WonderPhi products.
2. Purchase WonderPhi Compute Too: this library generates plans; Project 66 runs them. The output is not useful without it.
3. Install Python 3.8+: required to generate a plan. No pip install, no packages — standard library only.
4. Install the Tools You Intend to Drive: ffmpeg, ImageMagick, 7-Zip, curl, git, Whisper, Real-ESRGAN — whichever recipes you plan to use must be on your PATH. Each recipe's Needs on PATH: header names its dependency. The library installs nothing.
5. List the Recipes: python wpc-recipe.py --list shows every recipe, its input model, and its GPU marking.
6. Generate a Plan: python wpc-recipe.py <recipe> <folder>. Add --outdir to control where the recipe's output files land, or --check first to see how many inputs matched without writing anything.
7. Run It: wpc.exe <that-plan>.plan.wpc.txt. Or add --inbox when generating and let the always-on watcher pick it up automatically.
8. Inspect Before Committing: --stdout prints the plan instead of writing it, so you can read exactly what will execute before anything does.

Timeline Estimate: First plan generated: immediate — one command against a folder you already have. First useful parallel batch: same session, assuming the underlying tool is installed. Installing ffmpeg or ImageMagick if absent: minutes. There is no configuration step, no state, and nothing to set up.

Acquisition price: $2.25 personal (WONDERPHI-LIBRARY-100 — recipe generator, full recipe set, index, samples, under a perpetual personal license)

Commercial tier: WONDERPHI-LIBRARY-INDUSTRIAL-100 at $24.75. Complete Bundle across all nine WonderPhi products: $14.75 personal / $224.75 industrial. Requires WonderPhi Compute (Project 66) at $10 / $99.75 to run the generated plans. Included at no extra charge inside All In One (20T).

66. WonderPhi Compute — The Constitutional Parallel Runner (LIVE)

What This Handoff Is

This is WonderPhi Compute v1.0.0 — a permanent, self-contained parallel runner that reads a plain-text plan of shell commands and executes them across every CPU core, honestly reporting what it is doing. Project 66 is the root of the nine-product WonderPhi family: Projects 65, 68, 69, 70, 71, 72, and 73 are all recipe libraries that write plans, and this is the runtime that runs them. Feed it a plan.wpc.txt — one shell command per line, blank lines as stage barriers — and it executes each stage across every core simultaneously, waits at the barrier, and moves on. A serial script that would run for two hours finishes in ten minutes. It ships with 10 immutable constitutional rules hardcoded into every binary and verified at startup. Born once. Never updated. No subscription. No telemetry. No dependencies. Live on the storefront at $10.00 personal (WONDERPHI-COMPUTE-100) and $99.75 industrial (WONDERPHI-COMPUTE-INDUSTRIAL-100), both perpetual, as Base, No IP.

What It Means as a Constitutional-Runtime Handoff

Modern operating systems hide compute from the people who paid for it — background processes, throttled schedulers, GPU cores that sit dark unless you know the incantation. WonderPhi Compute is the antidote, but the interesting part is not the parallelism. Every other parallel runner is a Unix tool grown organically over decades, with a hundred configuration options and no philosophy. WonderPhi Compute is designed the opposite way. Ten commandments, carved in, verified at startup, and checkable by the buyer with wpc --about against a checksum on their own copy: I. Sole master — no competing orchestrator overrides WPC mid-run. II. No other gods — exactly one WPC per working directory, lock enforced. III. Not in vain — malformed plans are rejected, not silently mangled. IV. Sabbath — idle workers sleep; WPC never busy-waits. V. Honour thy parents — the plan format is frozen forever. VI. Not kill — the log appends only; a crash never destroys prior history. VII. Not adultery — commands dispatch verbatim, no silent retry, no mutation. VIII. Not steal — hardcoded caps of 64 concurrent, 4 GB per task, 24 h maximum. IX. Not false witness — exit codes and elapsed times reported truthfully. X. Not covet — zero dependencies, no network, no telemetry. Every version of WPC that will ever exist is v1.0.0. The buyer is not purchasing features; they are purchasing a guarantee that the tool cannot change out from under them.

What Has Been Completed

v1.0.0 — Complete, Live, and Constitutionally Frozen:

• wpc.exe — the runtime, standalone on Windows with no Python required on the target machine; also runs on macOS and Linux
• wpc.py, wpc-watcher.py, commandments.py — full runner and watcher source, Python 3.8+ standard library only; the constitution ships in auditable source form
• The plan.wpc.txt v1 format, frozen permanently: # comments, blank lines as stage barriers, one shell command per non-blank line, 8 KB maximum task length, 65,536 maximum tasks per plan
• Live progress display showing stage, percentage, task counts, and per-core current command with elapsed time
• Three cooperating always-on watchers, none of which modify wpc.exe:
  • wpc-watcher.exe — drop a plan into wpc-inbox\, it runs within 15 seconds into a timestamped folder under wpc-outbox\, writing both watcher-run.log and wpc.log for audit; injects live GPU environment variables into every task
  • wpc-autoplan.exe — watches wpc-auto\ for bulk drops of 5+ same-type files, auto-generates the appropriate plan (PDF hash, image identify, log grep, text count, or universal SHA-256) and dispatches it
  • wpc-observer.exe — samples the process list once a minute; when the same tool launches 5+ times in a 10-minute window, writes a hypothesis .md suggesting a parallel plan. Observes and suggests, never executes.
• GPU awareness: detects NVIDIA hardware via nvidia-smi and exposes $WPC_GPU, WPC_GPGPU, WPC_GPU_VRAM_FREE_MB, and WPC_GPU_UTIL_PCT to every task's environment, with zero CUDA dependency in WPC itself
• install.ps1 — one-line Windows install requiring no administrator rights: copies four executables to %USERPROFILE%\bin, creates all five working folders, registers three scheduled tasks at user logon, and starts the watchers immediately with no logout required. uninstall.ps1 reverses it.
• wpc --about (display and verify the constitution) and wpc --check (validate a plan without running it)
• Makefile build target producing the frozen executable, so the buyer can rebuild from the source they received
• example.plan.wpc.txt, README.md, LICENSE (proprietary, permanent), and CONTACT_INFO.txt
• Live storefront page at cri-one.com/store/wonderphi-compute-constitutional-parallel-runner.html, with the Complete Bundle (all nine WonderPhi products) at $14.75 personal / $224.75 industrial

What the Customer Needs to Do

To License and Deploy:

1. Choose a Tier: WONDERPHI-COMPUTE-100 at $10.00 for personal use, or WONDERPHI-COMPUTE-INDUSTRIAL-100 at $99.75 for commercial deployment. The artifact is identical; the license differs. The Complete Bundle at $14.75 / $224.75 adds all eight companion products.
2. Purchase Directly: no NDA and no term sheet at these tiers. Full source ships with every copy.
3. Run It or Install It: either invoke wpc.exe myplan.wpc.txt directly, or run install.ps1 for always-on mode with the three watchers. Installation needs no administrator rights.
4. Verify the Constitution: run wpc --about to display the ten commandments and confirm the checksum on your copy. This is the artifact you were sold; check it.
5. Write a Plan — or Don't: a plan is a text file, one command per line, blank lines separating stages. If you would rather not write one, the seven companion recipe libraries (Projects 65, 68–73) generate plans for ffmpeg, Office, servers, hosting, security, finance, and telephony workloads.
6. Validate Before Running: wpc --check my.plan.wpc.txt parses and validates without executing anything.
7. Understand the Caps: 64 concurrent tasks, 4 GB per task, 24 h maximum runtime, 8 KB per task line, 65,536 tasks per plan. These are Commandment VIII and are not configurable by design.
8. Understand What Runs: WPC dispatches your commands verbatim to the platform shell with your own privileges. It does not sandbox, validate, or sanitize them. What the plan contains is what executes.

Timeline Estimate: First run: immediate — download, unzip, point at a plan. Always-on install with all three watchers: under five minutes, no reboot, no admin. First useful parallel workload for an operator who already has a folder of files to process: same session. Building from source with the included Makefile: minutes on any machine with Python 3.8+.

Acquisition price: $10.00 personal (WONDERPHI-COMPUTE-100 — runtime, three watchers, full source, installer, constitution, and example plan, under a perpetual personal license)

Commercial tier: WONDERPHI-COMPUTE-INDUSTRIAL-100 at $99.75. Complete Bundle across all nine WonderPhi products: $14.75 personal / $224.75 industrial. Included at no extra charge inside All In One (20T). See the valuation page for the family structure and the full ladder.

67. GDSII Generator — Standalone Foundry-Handoff Tool for Any Delivery Package

What This Handoff Is

This is the GDSII Generator Standalone CD — a self-contained, failsafe tool that converts foundry delivery package specifications into valid binary GDSII version 6 files ready for foundry handoff. Project 67 works independently with any package: point it at a folder named FOUNDRY_DELIVERY_PACKAGE_* containing a SPECIFICATIONS subfolder of .txt files, and it generates, verifies, and logs. Output carries die outline, power ring, and proper structure, and is compatible with Cadence, Synopsys, and every standard foundry toolchain. It runs on Python 3.6+ with zero third-party dependencies across Windows, Linux, and macOS, and ships as a burnable CD image with Windows autorun for operators who will not touch a command line. Version 2.0.0-STANDALONE, marked Ready for Distribution. Acquisition price $9,500 as Base, No IP — a perpetual tool license.

What It Means as a Foundry-Handoff Handoff

An IC design package is documentation until something turns it into layout. That conversion step is where a great many foundry engagements stall: the specifications are complete, the buyer has the package, and there is no reliable path from one to the other that does not involve a $50,000-per-seat EDA environment or an engineer writing batch tooling from scratch around an open-source format library. This tool is that path, and its engineering is in the failsafe layer rather than the format writer. Writing GDSII records is well-understood; surviving a 1,000-design batch is not. So generation progress is checkpointed to generation_progress.json and an interrupted run resumes where it stopped rather than starting over. Logging is append-only to gdsii_generation.log, so a crash never destroys the audit trail of what succeeded. Verification lives in a separate program (VERIFY_GDSII.py) that shares no code path with the generator, and can be pointed at any output directory including files produced by other tools. An environment checker (CHECK_SETUP.py) diagnoses a broken Python install before a batch begins rather than three hours into it. The package auto-detects delivery folders across the working directory, Desktop, Documents, D:\, and C:\, but accepts an explicit --package path for scripted use — convenience for the operator, determinism for the pipeline. One copy serves every package the buyer owns, now and in future.

What Has Been Completed

v2.0.0-STANDALONE — Complete Package, Ready for Distribution:

• FAILSAFE_GDSII_GENERATOR.py — the main generator; emits binary GDSII version 6 with die outline, power ring, and proper structure
• VERIFY_GDSII.py — independent verification pass; validates any output directory separately from the generator that produced it
• CHECK_SETUP.py — environment checker; confirms Python availability, version, and write permissions before a run
• RUN_GDSII_GENERATION.bat — Windows launcher with interactive prompts for operators who do not use a command line
• AUTORUN.inf — launches automatically on CD insert under Windows
• Full command-line interface: --package (explicit path), --all (every design), --design (single design), --output (custom directory), --resume (continue after interruption), --verify-only (validate without generating)
• Auto-detection across working directory, Desktop, Documents, D:\, and C:\, matching any folder containing FOUNDRY_DELIVERY_PACKAGE in its name and a SPECIFICATIONS subfolder
• Progress tracking to generation_progress.json enabling resume-from-interruption on large batches
• Append-only logging to gdsii_generation.log for a complete audit trail
• Documentation set: README.txt (root quick start), STANDALONE_GUIDE.md (comprehensive guide with a full troubleshooting section), QUICK_REFERENCE.txt (reference card), STANDALONE_CD_SUMMARY.md (distribution summary), and DEPLOYMENT_CHECKLIST.txt
• Pre-distribution testing checklist covering autorun validation, auto-detection, manual path specification, generated-file validity, and clean-system operation with Python absent from PATH
• Verified against the documented delivery packages: FOUNDRY_DELIVERY_PACKAGE_1-37, FOUNDRY_DELIVERY_PACKAGE_1-22500, and FOUNDRY_DELIVERY_PACKAGE_38-39

What the Customer Needs to Do

To License and Deploy:

1. Acquire the Tool: GDSII-GENERATOR-67 at $9,500, perpetual license, Base, No IP.
2. Sign NDA: required at the licensed-software tier for full source access.
3. Install Python 3.6 or Higher: from python.org, with "Add Python to PATH" checked during installation. Verify with python --version. This is the only prerequisite — there are no third-party packages to install.
4. Obtain a Foundry Delivery Package: this tool consumes packages, it does not include one. Any folder named FOUNDRY_DELIVERY_PACKAGE_* with a SPECIFICATIONS subfolder of .txt files will work, whether acquired from this catalog or produced elsewhere.
5. Read STANDALONE_GUIDE.md First: the requirements, the two launch methods, the full command-line reference, and the troubleshooting section covering Python installation, package path errors, missing specification files, permission failures, and partial generation.
6. Run the Generator: either insert the CD and follow autorun, double-click RUN_GDSII_GENERATION.bat and answer the prompts, or invoke directly — python FAILSAFE_GDSII_GENERATOR.py --package "C:\FOUNDRY_DELIVERY_PACKAGE_1-37" --all. Generated files land in GDSII_GENERATOR\GDSII_OUTPUT\ unless --output says otherwise.
7. Verify the Output: run python VERIFY_GDSII.py ./GDSII_OUTPUT. Confirm all expected files were generated, file sizes are reasonable, the verification script reports all valid, files open in a GDSII viewer, and the log is clean.
8. Hand Off to the Foundry: generated files are standard binary GDSII v6 and require no conversion step. They must still pass the receiving foundry's own verification — this tool prepares the handoff, it does not replace foundry sign-off.

Timeline Estimate: Environment setup: under thirty minutes including a fresh Python install. First generation run against a known package: immediate. Large-batch generation across a 1,000-design catalog: hours rather than days, and resumable if interrupted. Physical media preparation for an air-gapped or defense customer: the CD image, autorun, and deployment checklist are already prepared — burn and test per the included checklist.

Acquisition price: $9,500 (GDSII-GENERATOR-67 — complete standalone package: generator, independent verifier, environment checker, Windows launcher, autorun CD image, full documentation set, and deployment checklist, under a perpetual tool license)

Included at no extra charge inside All In One (20T) — the complete cri-one.com portfolio acquisition, where this tool is the execution layer for the entire IC design catalog. Natural companion to the AutoPhi BGA Library ($95,000), the editable V19 source packages ($250,000–$380,000), and the On Demand IC design catalog. See the valuation page for the attach-rate rationale.

68. WonderPhi Office — Batch Recipes for Microsoft Office (LIVE)

What This Handoff Is

This is WonderPhi Office v1.0.0 — ten batch recipes for Word, Excel, and PowerPoint that emit WonderPhi Compute plans, so you never write Office automation by hand. Project 68 is a companion library to WonderPhi Compute (Project 66): you have 500 Word documents to convert to PDF, you run python wpo-recipe.py word-to-pdf .\docs, and out comes docs.plan.wpc.txt — one PowerShell + COM invocation per document, ready to run across every CPU core. Library writes the plan. WonderPhi Compute runs the plan. Ten recipes span three applications plus two audit functions, all using a single uniform input model: point at a folder, get a plan. Zero external Python dependencies, standard library only, no network, no telemetry, and it never modifies wpc.exe. Windows only — the recipes drive real Office applications through COM. Live on the storefront at $2.25 personal (WONDERPHI-OFFICE-100) and $24.75 industrial (WONDERPHI-OFFICE-INDUSTRIAL-100), both perpetual, as Base, No IP.

What It Means as an Office-Automation Handoff

Office COM automation is a specialism nobody wants. Object lifetimes have to be managed by hand, a mishandled exception leaves an orphaned WINWORD.EXE holding a file lock, and the failure modes are quiet rather than loud. Every organisation eventually needs the same handful of bulk operations — convert a folder to PDF, normalise legacy formats, strip metadata before documents leave the building, export workbooks to CSV, pull slides out as images — and every organisation either pays a contractor to write brittle automation or does it by hand one file at a time. This library replaces both with one command per job type. Two of the ten recipes are governance rather than conversion, and they are the ones that matter most in a commercial setting: word-strip-metadata removes authorship, comments, and tracked revisions across a shared folder, and office-sha256 writes tamper-evident checksum sidecars for records retention. Two more need no Office installation at all — office-inventory builds a JSON inventory of an entire document tree using only PowerShell, and office-sha256 uses built-in certutil — so the audit half of the library runs on any Windows machine.

What Has Been Completed

v1.0.0 — Complete and Live, 10 Recipes:

• wpo-recipe.py — the plan generator; Python 3.8+, standard library only, zero external dependencies
• Word (3): word-to-pdf (each document to PDF), word-to-docx (normalise .doc / .rtf / .odt to modern .docx), word-strip-metadata (remove authorship, comments, revisions)
• Excel (3): excel-to-csv (active sheet to CSV), excel-to-pdf (whole workbook to PDF), excel-to-xlsx (normalise .xls / .csv / .ods to .xlsx)
• PowerPoint (2): ppt-to-pdf (each deck to PDF), ppt-to-images (every slide to PNG in its own subfolder)
• Audit (2): office-inventory (JSON inventory line per file — path, size, modified — needs only PowerShell), office-sha256 (tamper-evident SHA-256 sidecar — needs only built-in certutil)
• Uniform files input model across all ten recipes — point at a folder, get a plan; no per-recipe input format to learn
• Full option set: --list, --out FILE, --outdir DIR (default wpo-out), --stdout, --check
• INDEX.md with the complete recipe table, README.md, and LICENSE
• Live storefront listing as WONDERPHI-OFFICE-100 / WONDERPHI-OFFICE-INDUSTRIAL-100, and included in the Complete Bundle

What the Customer Needs to Do

To License and Deploy:

1. Choose a Tier: WONDERPHI-OFFICE-100 at $2.25 personal, or WONDERPHI-OFFICE-INDUSTRIAL-100 at $24.75 for commercial deployment. The Complete Bundle at $14.75 / $224.75 includes this and all eight other WonderPhi products.
2. Purchase WonderPhi Compute Too: this library generates plans; Project 66 runs them.
3. Confirm You Are On Windows With Office Installed: eight of the ten recipes drive Word, Excel, or PowerPoint through COM automation and require the corresponding application on the machine that executes the plan. The two audit recipes do not.
4. Install Python 3.8+: required to generate a plan. Standard library only — nothing to pip install.
5. List the Recipes: python wpo-recipe.py --list shows all ten with their category and requirements.
6. Generate a Plan: python wpo-recipe.py <recipe> <folder>, optionally with --outdir to control where output lands. Run --check first to confirm how many files matched without writing anything.
7. Run It: wpc.exe <that-plan>.plan.wpc.txt.
8. Verify Metadata Removal Against Your Own Standard: word-strip-metadata works through Office's own interfaces and is a batch convenience, not a certified sanitisation tool. If you operate under a formal declassification or redaction policy, validate the output against that policy before relying on it.

Timeline Estimate: First plan generated: immediate. First bulk conversion of a real document folder: same session. There is no configuration step and no state. A large PDF conversion run across a shared drive is bounded by Office's own throughput per core rather than by anything in this library.

Acquisition price: $2.25 personal (WONDERPHI-OFFICE-100 — plan generator, 10 recipes, index, under a perpetual personal license)

Commercial tier: WONDERPHI-OFFICE-INDUSTRIAL-100 at $24.75. Complete Bundle across all nine WonderPhi products: $14.75 personal / $224.75 industrial. Requires WonderPhi Compute (Project 66) at $10 / $99.75. Included at no extra charge inside All In One (20T).

69. WonderPhi Server — Batch Recipes for VM & Server Administration (LIVE)

What This Handoff Is

This is WonderPhi Server v1.0.0 — nineteen batch recipes for VM and server administration that emit WonderPhi Compute plans. Project 69 is a companion library to WonderPhi Compute (Project 66): you have 40 Hyper-V VMs to snapshot before a maintenance window, you run python wps-recipe.py hyperv-snapshot .\vms.txt, and out comes vms.plan.wpc.txt — one checkpoint command per VM, dispatched across every CPU core. Library writes the plan. WonderPhi Compute runs the plan. Coverage spans Hyper-V, WSL, SSH, WinRM, SFTP, host discovery, and ISO integrity. Every recipe uses the lines input model — one target per line, comments and blanks ignored — so a single maintained host list drives all nineteen operations. Zero external Python dependencies, no network, no telemetry, never modifies wpc.exe. Runs on Windows; targets are anything reachable by SSH, WinRM, or the Hyper-V API. Live at $2.25 personal (WONDERPHI-SERVER-100) and $24.75 industrial (WONDERPHI-SERVER-INDUSTRIAL-100), both perpetual, as Base, No IP.

What It Means as a Fleet-Operations Handoff

The maintenance window is a serial-time problem. Forty VMs checkpointed one at a time at two minutes each is eighty minutes of an operator watching a progress bar, and the window is usually shorter than that. Run them in parallel and the whole operation takes as long as the slowest single VM. That is the obvious value, and it is not the interesting one. The interesting value is that this library writes a plan and never executes it. Several of these recipes are genuinely destructive — ssh-reboot and winrm-reboot restart every host in the list, ssh-upgrade runs an unattended package upgrade, hyperv-stop forces a shutdown. On operations of that consequence, the ability to run --stdout and read the exact command that will be issued against each named host before anything happens is worth more than the parallelism. The generated plan is a plain text file the operator can inspect, edit, save as a change record, or discard. Recipes that mutate state accept --tag, so checkpoints and exports carry a meaningful label (pre-2026-Q3) instead of an anonymous timestamp — which is the difference between a rollback you can find and one you have to guess at. The audit set (host-ping, host-http, host-ssh-alive, port-check) needs nothing beyond built-in Windows tooling, so fleet health checking works before anything else is installed.

What Has Been Completed

v1.0.0 — Complete and Live, 19 Recipes:

• wps-recipe.py — the plan generator; Python 3.8+, standard library only, zero external dependencies
• Hyper-V (5): hyperv-snapshot (tagged checkpoint per VM), hyperv-export (bare-metal-restore-ready archive to a timestamped folder), hyperv-start, hyperv-stop (graceful, force), hyperv-status (state / CPU / RAM / uptime as JSON per VM)
• WSL (2): wsl-update (apt update && upgrade inside each named distro), wsl-snapshot (export each distro to a tar file)
• SSH (4): ssh-uptime, ssh-disk (df -h per host), ssh-upgrade (requires sudo NOPASSWD), ssh-reboot (requires sudo NOPASSWD)
• WinRM (2): winrm-cmd (run a command on each host), winrm-reboot (requires admin rights on targets)
• SFTP (1): sftp-put (push a fixed local file to each host)
• Audit (4): host-ping (2s deadline), host-http (HEAD over HTTPS), host-ssh-alive (handshake-only check), port-check (Test-NetConnection on host:port) — all using built-in tooling
• Integrity (1): iso-verify (SHA-256 verification of each listed ISO via built-in certutil)
• Uniform lines input model across all nineteen recipes — one target per line; what "target" means (VM name, hostname, distro name) is documented per recipe
• --tag VALUE for labelling checkpoints, exports, and any recipe taking a parameter
• INDEX.md — the complete nineteen-recipe table generated from the registry in wps-recipe.py, documenting each recipe's category, input model, PATH requirements, and behaviour

What the Customer Needs to Do

To License and Deploy:

1. Choose a Tier: WONDERPHI-SERVER-100 at $2.25 personal, or WONDERPHI-SERVER-INDUSTRIAL-100 at $24.75 for commercial deployment. Fleet administration is almost always a commercial context — check which applies to you. The Complete Bundle at $14.75 / $224.75 includes all nine WonderPhi products.
2. Purchase WonderPhi Compute Too: this library generates plans; Project 66 runs them.
3. Install Python 3.8+: required to generate a plan. Standard library only.
4. Provision the Prerequisites Per Recipe: Hyper-V PowerShell module for Hyper-V recipes, WSL 2 for WSL recipes, OpenSSH client for SSH and SFTP, WinRM enabled on targets for WinRM recipes. INDEX.md names the requirement for every recipe; the audit set needs nothing beyond built-in Windows tooling.
5. Build Your Target List: one VM name, hostname, or distro per line. Comments (#) and blank lines are ignored, so one annotated file can serve as living documentation of the estate.
6. Generate the Plan: python wps-recipe.py <recipe> <hosts.txt> [--tag VALUE].
7. Read the Plan Before You Run It: use --stdout to print it or --check to count matched targets without writing anything. For ssh-reboot, winrm-reboot, ssh-upgrade, and hyperv-stop, treat this step as mandatory — those act on production systems.
8. Run It: wpc.exe <that-plan>.plan.wpc.txt. Keep the plan file as your change record.

Timeline Estimate: First plan generated: immediate, given a host list. First parallel maintenance window: same session, assuming SSH keys or WinRM are already configured — that configuration, not this library, is the long pole in a new estate. A forty-VM checkpoint that ran serially in eighty minutes completes in roughly the time of the slowest single VM.

Acquisition price: $2.25 personal (WONDERPHI-SERVER-100 — plan generator, 19 recipes, index, under a perpetual personal license)

Commercial tier: WONDERPHI-SERVER-INDUSTRIAL-100 at $24.75. Complete Bundle across all nine WonderPhi products: $14.75 personal / $224.75 industrial. Requires WonderPhi Compute (Project 66) at $10 / $99.75. Pairs naturally with WonderPhi Host (Project 70) and WonderPhi Vault (Project 71). Included at no extra charge inside All In One (20T).

70. WonderPhi Host — Batch Recipes for Website Hosting Operations (LIVE)

What This Handoff Is

This is WonderPhi Host v1.0.0 — batch recipes for website hosting operations that emit WonderPhi Compute plans. Project 70 is a companion library to WonderPhi Compute (Project 66): you have 12 nginx-hosted sites to back up before a migration, you run python wph-recipe.py backup-site .\sites.txt, and out comes sites.plan.wpc.txt — one tar+gzip per docroot, dispatched across every CPU core. Library writes the plan. WonderPhi Compute runs the plan. Recipes cover nginx, Apache, TLS certificate lifecycle, site backup, log operations, deployment, HTTP audit, DNS, and SEO. Every recipe uses the lines input model — one target per line, comments and blanks ignored — where a target is a hostname for SSH-based recipes, a domain for TLS/DNS/SEO recipes, or a URL for HTTP audit recipes. Zero external Python dependencies, no network, no telemetry, never modifies wpc.exe. Runs on Windows; targets are anything reachable by SSH, curl, or DNS. Live at $2.25 personal (WONDERPHI-HOST-100) and $24.75 industrial (WONDERPHI-HOST-INDUSTRIAL-100), both perpetual, as Base, No IP.

What It Means as a Hosting-Operations Handoff

The person who administers more websites than they can comfortably touch by hand faces a specific failure pattern: the safe procedure and the fast procedure diverge, and under time pressure the fast one wins. The canonical example is a configuration change across a fleet. The correct sequence is to test the configuration on every host, confirm every test passed, and only then reload any host — because a reload against a broken config takes a site down, and discovering that on host eleven of twelve is discovering it too late. Done by hand across a dozen servers, that discipline doubles the work, so it gets skipped. Here it costs one extra command: nginx-testconf across the list, then nginx-reload across the list. The same shape applies throughout. Certificate renewal across a domain portfolio, backup before migration, identical deployment to every node — each is a task where hand-execution invites both drift and omission, and where generating the full command set in advance makes the operation auditable before it is irreversible. The library connects to nothing. It reads a list and writes a text file. The operator reads that file, and only then does anything touch a live site.

What Has Been Completed

v1.0.0 — Complete and Live:

• wph-recipe.py — the plan generator; Python 3.8+, standard library only, zero external dependencies
• Web server operations: nginx-testconf (validate configuration on every host before any reload), nginx-reload (fleet-wide reload after tests pass), plus Apache equivalents for mixed estates
• TLS certificate lifecycle: letsencrypt-renew across every host in the list, plus certificate inspection recipes for expiry and chain
• Site backup: backup-site — one tar+gzip archive per docroot, generated across a site list for pre-migration or scheduled capture
• Log operations: batch log collection, rotation, and analysis recipes across a host fleet
• Deployment: recipes that apply an identical deployment command to every node in a list, eliminating hand-typed variation between hosts by construction
• HTTP audit: URL-targeted checks that require no SSH access to the host, so an estate can be audited before it is administered
• DNS and SEO: domain-targeted recipes for record checking and SEO auditing across a domain portfolio
• Uniform lines input model with mixed target types — hostname, domain, or URL depending on the recipe, all in the same one-per-line format with # comments and blank lines ignored
• Full option set: --list, --out FILE, --outdir DIR, --stdout, --check
• INDEX.md with the complete recipe table, README.md, and LICENSE

What the Customer Needs to Do

To License and Deploy:

1. Choose a Tier: WONDERPHI-HOST-100 at $2.25 personal, or WONDERPHI-HOST-INDUSTRIAL-100 at $24.75 for commercial deployment. Hosting operations performed for clients or for a business are commercial use. The Complete Bundle at $14.75 / $224.75 includes all nine WonderPhi products.
2. Purchase WonderPhi Compute Too: this library generates plans; Project 66 runs them.
3. Install Python 3.8+: required to generate a plan. Standard library only.
4. Provision Access and Tooling: SSH access to the hosts you intend to administer, certbot or your ACME client for TLS recipes, and curl and DNS tooling for audit recipes. The library installs nothing and holds no credentials.
5. Build Your Target Lists: keep separate files where target types differ — a hostname list for SSH-based recipes, a domain list for TLS/DNS/SEO, a URL list for HTTP audit. Comments and blank lines are ignored, so these double as estate documentation.
6. Generate the Plan: python wph-recipe.py <recipe> <targets.txt>. Use --check first to confirm how many targets matched.
7. Test Before You Reload: run nginx-testconf across the whole fleet and confirm every host passes before generating and running nginx-reload. This is the single most valuable habit the library enables.
8. Inspect, Then Run: --stdout prints the plan so you can read the exact command per host before anything executes. Then wpc.exe <that-plan>.plan.wpc.txt. Keep the plan file as your change record.

Timeline Estimate: First plan generated: immediate, given a target list. First fleet-wide operation: same session, assuming SSH keys are already distributed — that distribution, not this library, is the long pole in a new estate. A twelve-site backup that ran serially completes in roughly the time of the largest single docroot.

Acquisition price: $2.25 personal (WONDERPHI-HOST-100 — plan generator, full recipe set, index, under a perpetual personal license)

Commercial tier: WONDERPHI-HOST-INDUSTRIAL-100 at $24.75. Complete Bundle across all nine WonderPhi products: $14.75 personal / $224.75 industrial. Requires WonderPhi Compute (Project 66) at $10 / $99.75. Pairs naturally with WonderPhi Server (Project 69), WonderPhi Vault (Project 71), and SellPhi (Project 64) for operators running self-hosted storefronts. Included at no extra charge inside All In One (20T).

71. WonderPhi Vault — Encryption & Security Batch Recipes (LIVE)

What This Handoff Is

This is WonderPhi Vault v1.0.0 — thirty batch recipes for encryption, signing, hashing, certificate lifecycle, secrets scanning, and redaction, emitting WonderPhi Compute plans. Project 71 is a companion library to WonderPhi Compute (Project 66): you have 10,000 evidence files to archive with tamper-evident hashes, you run python wpv-recipe.py sha256-manifest .\evidence, and out comes evidence.plan.wpc.txt — one certutil hash command per file plus a combined manifest step, dispatched across every core. Library writes the plan. WonderPhi Compute runs the plan. Recipes drive certutil, openssl, gpg (Gpg4Win), 7z, signtool.exe, ssh-keygen, exiftool, curl, and findstr — the library implements no cryptography of its own. Zero external Python dependencies, no network, no telemetry, never modifies wpc.exe. Live at $4.75 personal (WONDERPHI-VAULT-100) and $49.75 industrial (WONDERPHI-VAULT-INDUSTRIAL-100), both perpetual, as Base, No IP.

What It Means as a Security-Operations Handoff

Security batch work has a property that makes it different from every other domain in this family: the input is exactly the material you cannot send anywhere. An evidence archive, a codebase being swept for leaked credentials, a document dump being checked for SSN and card numbers — each is data whose whole problem is that it is sensitive, which disqualifies the cloud service that would otherwise be the obvious answer. Every recipe here drives a tool that runs locally on the operator's own machine, and the library itself has no network path, no telemetry, and no dependency that could introduce one. That constraint is the product. Beyond it, the thirty recipes cluster into the operations that are individually simple and collectively unmanageable by hand. Hashing ten thousand files with a combined manifest, and later verifying that manifest, is the entire chain-of-custody workflow in two commands. Sweeping a codebase for AWS keys, GitHub tokens, and embedded private keys addresses the single most common cause of credential compromise. Auditing certificate expiry across a domain list prevents the most avoidable outage in production hosting. Signing every DLL and EXE in a build output with an RFC 3161 timestamp keeps those signatures valid after the certificate expires — the detail hand-rolled signing scripts routinely omit. The library implements none of the cryptography and that is deliberate: novel crypto in a $4.75 utility would be a liability, not a feature.

What Has Been Completed

v1.0.0 — Complete and Live, 30 Recipes Across 9 Domains:

• wpv-recipe.py — the plan generator; Python 3.8+, standard library only, zero external dependencies
• Hash & Integrity (5): sha256-each, sha256-manifest (per-file plus combined manifest), sha512-each, md5-each, verify-manifest
• GPG / PGP (5): gpg-encrypt-each, gpg-decrypt-each, gpg-sign-each, gpg-verify-each, gpg-symmetric-each
• AES / OpenSSL (2): aes-encrypt-each, aes-decrypt-each
• Archive with Password (2): 7z-encrypt-each (AES-256 with hidden filenames for compliance archival), 7z-decrypt-each
• Code Signing (2): signtool-sign-each (accepts full flag strings including RFC 3161 timestamp URL), signtool-verify-each
• Certificates & TLS (6): cert-fingerprint-each, cert-expiry-each, cert-extract-chain, tls-cipher-audit, hsts-check, csp-check
• Secrets Scanning (3): secret-scan-aws, secret-scan-github, secret-scan-private-key
• PII / Redaction (3): pii-scan-ssn, pii-scan-cc, exif-strip-each
• SSH Keys (2): sshkey-generate-batch, authorized-keys-audit
• Full option set: --list, --out FILE, --outdir DIR (default wpv-out), --tag VALUE (recipient key, archive password, signing flags), --stdout, --check
• INDEX.md with the complete thirty-recipe table, README.md, and LICENSE

What the Customer Needs to Do

To License and Deploy:

1. Choose a Tier: WONDERPHI-VAULT-100 at $4.75 personal, or WONDERPHI-VAULT-INDUSTRIAL-100 at $49.75 for commercial deployment. Secrets scanning, code signing, and compliance archival are commercial activities — the Industrial tier will apply to most real users. The Complete Bundle at $14.75 / $224.75 includes all nine WonderPhi products.
2. Purchase WonderPhi Compute Too: this library generates plans; Project 66 runs them.
3. Install Python 3.8+ and the Tools You Need: whichever recipes you intend to use require their underlying tool on the operator's machine — openssl, gpg (Gpg4Win), 7z, signtool.exe, ssh-keygen, exiftool. certutil, curl, and findstr are built into Windows.
4. Generate the Plan: python wpv-recipe.py <recipe> <folder> [--tag VALUE]. Use --check first to confirm how many files matched.
5. Handle --tag Secrets Carefully: recipient keys, archive passwords, and signing-certificate flags passed via --tag are written into the generated plan file in plain text. Treat any plan containing a secret as sensitive material, keep it out of version control, and delete it after the run.
6. Run It: wpc.exe <that-plan>.plan.wpc.txt.
7. Verify Rather Than Assume, On Scanning Recipes: secrets and PII recipes are regular-expression sweeps. They will produce false positives and will miss things. Treat a clean result as "nothing matched these patterns," not as "this data is clean."
8. Validate Against Your Own Controls: if you operate under a formal regulatory obligation — PCI, HIPAA, GDPR, a records-retention policy, or a court-facing chain-of-custody standard — validate these recipes' output against that standard before relying on it. This is a batch tool, not a compliance attestation.

Timeline Estimate: First plan generated: immediate. First tamper-evident archive of a real evidence folder: same session. Installing Gpg4Win, OpenSSL, or the Windows SDK for signtool if absent: under an hour. Hashing a ten-thousand-file archive across every core completes in a fraction of the serial time and produces a verifiable manifest at the end.

Acquisition price: $4.75 personal (WONDERPHI-VAULT-100 — plan generator, 30 recipes across 9 security domains, index, under a perpetual personal license)

Commercial tier: WONDERPHI-VAULT-INDUSTRIAL-100 at $49.75. Complete Bundle across all nine WonderPhi products: $14.75 personal / $224.75 industrial. Requires WonderPhi Compute (Project 66) at $10 / $99.75. Pairs naturally with WonderPhi Server (Project 69) and WonderPhi Host (Project 70). Included at no extra charge inside All In One (20T).

72. WonderPhi Ledger — Banking & Finance Batch Recipes (LIVE)

What This Handoff Is

This is WonderPhi Ledger v1.0.0 — twenty-five batch recipes for banking, finance, and accounting operations, emitting WonderPhi Compute plans. Project 72 is a companion library to WonderPhi Compute (Project 66): you have 500 contractors to send 1099-NEC forms to, you run python wpl-recipe.py pdf-1099-nec .\contractors --tag 2026, and out comes contractors.plan.wpc.txt — one wkhtmltopdf render per contractor, dispatched across every core. Library writes the plan. WonderPhi Compute runs the plan. Coverage spans CSV normalisation and reconciliation, OFAC sanctions screening, PDF document generation, tax forms, OCR, ACH/NACHA validation, currency conversion, rules-based categorisation, regulatory archival, and financial schedules. Recipes drive Python stdlib, wkhtmltopdf, tesseract, LibreOffice soffice, certutil, and 7z. Nothing here connects to a bank. Zero external Python dependencies, no network, no telemetry, never modifies wpc.exe. Live at $7.25 personal (WONDERPHI-LEDGER-100) and $74.75 industrial (WONDERPHI-LEDGER-INDUSTRIAL-100), both perpetual, as Base, No IP.

What It Means as a Finance-Operations Handoff

Finance operations are full of tasks that are individually trivial and collectively brutal. Rendering one 1099-NEC is a form-fill; rendering five hundred is a mail-merge project nobody wants to own. Reconciling one CSV against a reference is a lookup; reconciling a month of them is a day. Screening one counterparty against a sanctions list is a search; screening a whole customer file is a compliance obligation with a deadline attached. The design decision that defines this library is what it refuses to do: it does not connect to anything. No bank credentials, no API keys, no network socket, no payment rail. Every recipe reads a folder or a CSV and writes a text file. In a domain where connectivity is the primary risk surface and where a buyer's security review is the longest part of any procurement, an entirely offline batch layer is a fundamentally different proposition from a fintech SaaS — and it collapses that review to almost nothing. The same principle shapes ofac-scan-csv, which matches against a locally-held SDN name list rather than calling a screening API, so the counterparty file never leaves the operator's machine. The trade is explicit and honest: the operator maintains the list, and the library does the matching. That trade is correct for a $74.75 tool and would be dishonest to obscure.

What Has Been Completed

v1.0.0 — Complete and Live, 25 Recipes:

• wpl-recipe.py — the plan generator; Python 3.8+, standard library only, zero external dependencies
• CSV Normalisation (6): csv-dedupe, csv-sort-date, csv-total, csv-row-hash, csv-to-xlsx, csv-to-json
• Compliance / OFAC (1): ofac-scan-csv — match every row against a local SDN name list
• PDF Generation (6): pdf-invoice-from-json, pdf-statement, pdf-receipt, pdf-payment-reminder, pdf-collection-letter, pdf-wire-instructions
• Tax Forms (2): pdf-1099-nec, pdf-w2
• OCR (2): ocr-receipt-each, ocr-invoice-each — via tesseract, locally
• ACH / NACHA (2): ach-nacha-validate, ach-nacha-summary
• Reconciliation (1): csv-reconcile-2way — find unmatched entries against a reference file
• Currency / FX (1): csv-fx-convert — apply a rate table to an Amount column
• Rules / Categorisation (1): csv-categorize-rules — regex-based transaction categorisation
• Regulatory Archival (1): regulatory-hash — SHA-256 with a timestamped audit trail
• Financial Schedules (2): depreciation-schedule, amortization-schedule
• Full option set including --tag for tax year and document parameters, plus --list, --out, --outdir, --stdout, --check
• INDEX.md with the complete twenty-five-recipe table, README.md, and LICENSE

What the Customer Needs to Do

To License and Deploy:

1. Choose a Tier: WONDERPHI-LEDGER-100 at $7.25 personal, or WONDERPHI-LEDGER-INDUSTRIAL-100 at $74.75 for commercial deployment. Bookkeeping, invoicing, tax-form production, and sanctions screening performed for a business or for clients are commercial use. The Complete Bundle at $14.75 / $224.75 includes all nine WonderPhi products.
2. Purchase WonderPhi Compute Too: this library generates plans; Project 66 runs them.
3. Install Python 3.8+ and the Required Tools: wkhtmltopdf for PDF generation, tesseract for OCR, LibreOffice soffice for XLSX conversion. certutil and 7z handle hashing and archival.
4. Obtain and Maintain Your Own SDN List: ofac-scan-csv matches against a local sanctions list you supply and keep current. The library does not fetch or update it. Currency of that list is your compliance responsibility.
5. Prepare Your Data: recipes read CSV and JSON. Normalisation recipes exist precisely because source data rarely arrives clean — run csv-dedupe and csv-sort-date before reconciliation or document generation.
6. Generate the Plan: python wpl-recipe.py <recipe> <input> [--tag VALUE]. Use --check to confirm row or file counts before generating.
7. Run It: wpc.exe <that-plan>.plan.wpc.txt.
8. Have a Qualified Professional Review the Output: this is a document-production and data-processing tool, not a filing service and not professional advice. Tax forms must be reviewed and filed by you or your accountant; depreciation and amortisation schedules must be checked against the applicable method and jurisdiction; ACH files must be authorised before submission.

Timeline Estimate: First plan generated: immediate, given a clean CSV. First batch of 1099-NEC documents: same session once wkhtmltopdf is installed and the contractor data is normalised — data preparation, not rendering, is the long pole. Five hundred forms render across every core in a fraction of the serial time.

Acquisition price: $7.25 personal (WONDERPHI-LEDGER-100 — plan generator, 25 recipes across finance, tax, compliance, and archival, index, under a perpetual personal license)

Commercial tier: WONDERPHI-LEDGER-INDUSTRIAL-100 at $74.75 — the highest single-product commercial tier in the WonderPhi family. Complete Bundle across all nine products: $14.75 personal / $224.75 industrial. Requires WonderPhi Compute (Project 66) at $10 / $99.75. Pairs naturally with WonderPhi Vault (Project 71) for archival and integrity workflows. Included at no extra charge inside All In One (20T).

73. WonderPhi Phone — Telephony & Voice Batch Recipes (LIVE)

What This Handoff Is

This is WonderPhi Phone v1.0.0 — twenty-eight batch recipes for telephony operations that never call a third-party API, emitting WonderPhi Compute plans. Project 73 is a companion library to WonderPhi Compute (Project 66): you have 5,000 voicemails to transcribe for compliance, you run python wpp-recipe.py whisper-vm .\voicemails, and out comes voicemails.plan.wpc.txt — one Whisper invocation per WAV file, dispatched across every core, GPU if present and CPU otherwise. Library writes the plan. WonderPhi Compute runs the plan. Coverage spans transcription, audio processing, fax conversion and OCR, CDR parsing, phone-number normalisation, and the sudo-SMS pattern — queue-to-file messaging where the operator delivers. Recipes drive Whisper, ffmpeg, tesseract, ImageMagick, certutil, 7z, and Python stdlib. Nothing here connects to a phone network. Zero external Python dependencies, no network, no telemetry, never modifies wpc.exe. Live at $4.75 personal (WONDERPHI-PHONE-100) and $49.75 industrial (WONDERPHI-PHONE-INDUSTRIAL-100), both perpetual, as Base, No IP.

What It Means as a Telephony-Operations Handoff

The library's organising idea sits in six of its twenty-eight recipes. SMS and voicemail-drop recipes do not send anything — they write JSON queue records into a local folder, and an operator delivers them. That is the sudo-SMS pattern, and the reasoning behind it is stated plainly in the product: the phone number is identity, and that identity stays with you, not a paid gateway. A business that routes messaging through a CPaaS provider has rented the number its customers recognise, pays per message forever, and has handed a third party the record of who it talks to. The queue-to-file pattern trades automated delivery for ownership, and it is an honest trade rather than a hidden limitation. The same logic runs through the rest of the library. Transcription happens on the operator's own GPU because a regulated caller cannot upload recorded audio to a cloud service — and for healthcare, financial services, and legal practices, that is a hard requirement, not a preference. CDR parsing and toll-fraud scanning happen locally against the operator's own call detail. DNC scrubbing matches against a list the operator holds. In a domain where the data is recorded conversations with identifiable people, the fact that this library opens no network socket at all is not a minor implementation detail — it is the reason a compliance officer can approve it.

What Has Been Completed

v1.0.0 — Complete and Live, 28 Recipes:

• wpp-recipe.py — the plan generator; Python 3.8+, standard library only, zero external dependencies
• Transcription (4): whisper-vm (GPU), whisper-vm-cpu, whisper-vm-tiny, whisper-vm-srt (subtitle output)
• Audio Processing (7): loudness-normalize, silence-trim, audio-to-mp3, audio-to-opus, audio-mono-8k, audio-spectrogram, audio-waveform
• Fax (2): fax-tif-to-pdf, fax-ocr-searchable
• CDR Parsing (2): cdr-generic-parse, cdr-toll-fraud-scan
• Phone Numbers (4): e164-normalize, dnc-scrub, cnam-lookup-file, dial-plan-validate
• SMS Queue — sudo-SMS pattern (4): sms-queue-write, sms-appointment-reminder-queue, sms-otp-queue, sms-broadcast-queue
• Voice Queue (2): voicemail-drop-queue, reminder-call-queue
• GPU-aware transcription with honest CPU fallback, matching the family-wide degradation pattern
• Full option set: --list, --out FILE, --outdir DIR, --tag VALUE, --stdout, --check
• INDEX.md with the complete twenty-eight-recipe table, README.md, and LICENSE

What the Customer Needs to Do

To License and Deploy:

1. Choose a Tier: WONDERPHI-PHONE-100 at $4.75 personal, or WONDERPHI-PHONE-INDUSTRIAL-100 at $49.75 for commercial deployment. Call centres, medical practices, legal firms, and any business processing recorded calls are commercial users. The Complete Bundle at $14.75 / $224.75 includes all nine WonderPhi products.
2. Purchase WonderPhi Compute Too: this library generates plans; Project 66 runs them.
3. Install Python 3.8+ and the Required Tools: Whisper (with CUDA for GPU transcription), ffmpeg for audio processing, tesseract and ImageMagick for fax OCR. GPU recipes need NVIDIA hardware; without it they fall back to CPU.
4. Confirm Your Legal Position Before Processing Recordings: call-recording consent law is two-party in many states, and retention, access, and disposal obligations vary by industry. Establish that you may lawfully hold and process the audio before you batch it.
5. Obtain and Maintain Your Own DNC List: dnc-scrub matches against a list you supply and keep current. The library does not fetch, update, or certify it, and currency is your compliance responsibility.
6. Generate the Plan: python wpp-recipe.py <recipe> <input> [--tag VALUE]. Use --check to confirm how many files or rows matched.
7. Run It: wpc.exe <that-plan>.plan.wpc.txt.
8. Deliver Queue Records Yourself: SMS and voice recipes write JSON queue files. Nothing is transmitted by this software. You decide how, whether, and to whom those records are delivered — and TCPA, DNC, and carrier obligations attach to that decision, not to this tool.
9. Review Transcripts Before Relying On Them: Whisper output is machine transcription. It is unverified and not suitable as a legal record without human review.

Timeline Estimate: First plan generated: immediate. First bulk transcription run: same session once Whisper and CUDA are installed — that installation, not this library, is the long pole. Five thousand voicemails transcribed across every core with GPU acceleration completes in a fraction of the serial time, entirely on the operator's own hardware.

Acquisition price: $4.75 personal (WONDERPHI-PHONE-100 — plan generator, 28 recipes across transcription, audio, fax, CDR, numbering, and queue-to-file messaging, index, under a perpetual personal license)

Commercial tier: WONDERPHI-PHONE-INDUSTRIAL-100 at $49.75. Complete Bundle across all nine WonderPhi products: $14.75 personal / $224.75 industrial. Requires WonderPhi Compute (Project 66) at $10 / $99.75. Pairs naturally with WonderPhi Vault (Project 71) for recording archival and integrity. Included at no extra charge inside All In One (20T).

74. BGA Library Validate — The Intermediate Package Ladder and Its Validation Harness

What This Handoff Is

This is BGA Library Validate — the validation harness for the AutoPhi BGA package family, and the home of the intermediate ball-count ladder added on 2026-07-25. Project 74 exists because the family stepped straight from 256 balls to 1536 with nothing between: eleven body variants, but only two ball counts, so any design needing roughly 600–1,100 I/O had to take a package with far more balls and area than it used. This project adds three rungs — BGA-576, BGA-900, and BGA-1156 — all inside the documented AutoPhi V19 Pinnacle canonical range of 384–1536 pins at 32 mm package width. Source of truth remains Project 40 (40-autophi-bga256) per docs/LIBRARY_GOVERNANCE.md; nothing here forks or duplicates the library — this project only regenerates and checks it. Live SKU APV19-BGA-1536-V1 at $95,000, with the editable BGA-900 source package (APV19-SRC-0900-V1) at $250,000. Base, No IP. Status: geometry cross-validated, signal assignment incomplete — see the disclosure below.

What It Means as a Package-Family Handoff

A package family with a 6× gap in the middle is a family that cannot serve the designs in the middle. The numbers make the problem concrete. BGA-256 spans 15 mm of balls — too small for the canonical 32 mm AutoPhi die. BGA-1536 spans 95 mm — roughly three times too large. A design landing anywhere between those two had no correct choice, only a wasteful one. BGA-900 closes it exactly: a 30×30 grid at 1.00 mm pitch produces a 29 mm ball span inside a 32 mm body, matching the canonical die. BGA-576 (24×24 at 1.27 mm, 29.2 mm span, 32×32 mm body) and BGA-1156 (34×34 at 1.00 mm, 33.0 mm span, 38×38 mm body) bracket it. Every pad diameter holds the 0.45×-pitch ratio the existing v19_default profile already uses — a 0.9 mm pad at 2.0 mm pitch — landing clearances at 0.55–0.70 mm, which is comfortable for standard fabrication rather than aggressive. The second thing this project is, and arguably the more durable one, is a harness. It regenerates the library from its canonical source and checks the result, which means governance is enforced mechanically rather than by memory. That discipline — one source of truth, regenerate and check, never fork — is what keeps a package library trustworthy across years of additions.

What Has Been Completed

Three New Rungs, Mechanically Cross-Validated:

• BGA-576 — 24×24 grid, 1.27 mm pitch, 29.2 mm ball span, 0.57 mm pad / 0.70 mm clearance, 32×32 mm body, profile bga576_ref
• BGA-900 — 30×30 grid, 1.00 mm pitch, 29.0 mm ball span, 0.45 mm pad / 0.55 mm clearance, 32×32 mm body, profile bga900_ref — matches the canonical 32 mm die exactly
• BGA-1156 — 34×34 grid, 1.00 mm pitch, 33.0 mm ball span, 0.45 mm pad / 0.55 mm clearance, 38×38 mm body, profile bga1156_ref
• Geometry, footprint, symbol, and pinmap generated and cross-validated for all three packages
• All three verified as sitting inside the canonical range documented in docs/CANONICAL_DIMENSIONS_MATRIX.md (32 mm package width, 384–1536 pins across SKUs) — no new package class invented
• Pad ratios held consistent with the existing v19_default profile so the new rungs match the family's established fabrication assumptions
• Validation harness that regenerates the library from Project 40 as source of truth and checks the output, enforcing docs/LIBRARY_GOVERNANCE.md mechanically
• Full context documented alongside the existing family: BGA-256 (16×16, 1.00 mm pitch, 15.0 mm span, 20–36 mm body variants) and BGA-1536 (32×48, 2.00 mm pitch, 62×94 mm span, 40–95 mm body variants, profile v19_default)
• Seeding pipeline run against all three new pinmaps, with results reported honestly — see below

What is explicitly NOT complete — signal assignment:

• BGA-576: 36 pins assigned, 540 TBD
• BGA-900: 36 pins assigned, 864 TBD
• BGA-1156: 48 pins assigned, 1108 TBD

What the Customer Needs to Do

To License and Deploy:

1. Understand What You Are Buying: validated mechanical package definitions plus a regeneration and validation harness. Signal assignment is not finished. Read the pin-assignment table above before proceeding — it is the material fact about this project.
2. Acquire the Library: APV19-BGA-1536-V1 at $95,000, Base, No IP.
3. Sign NDA: required for full library and harness source.
4. Acquire Project 40 If You Need The Canonical Library: source of truth lives in 40-autophi-bga256. This project regenerates and checks that library rather than replacing it.
5. Read LIBRARY_GOVERNANCE.md and CANONICAL_DIMENSIONS_MATRIX.md First: the governance rule (never fork, always regenerate) and the canonical dimensional envelope are what keep the family coherent. Both are the harness's operating assumptions.
6. Complete the Signal Assignment: 540, 864, and 1108 pins remain TBD across the three packages. This is the buyer's first substantive task, or a scoped engagement that can be quoted separately.
7. Consider the Editable Source Package: APV19-SRC-0900-V1 at $250,000 is the editable BGA-900 design package that the library rung makes possible. If your intent is a real board rather than a library, that is likely the product you actually want.
8. Fabricate and Measure: no package in this ladder has been built. First-article dimensional measurement and assembly yield characterisation are the buyer's to perform before committing to volume.

Timeline Estimate: Library integration into an existing EDA flow: days, given the footprints and symbols are already cross-validated. Signal assignment completion: the dominant line item — scope it against 540 / 864 / 1108 pins depending on which package you need, and expect a meaningful engineering engagement rather than an afternoon. Fabrication and first-article measurement: standard CM lead times thereafter.

Acquisition price: $95,000 (APV19-BGA-1536-V1 — AutoPhi BGA Library including the BGA-576 / BGA-900 / BGA-1156 intermediate ladder, cross-validated geometry, footprints, symbols, pinmaps, and the regeneration and validation harness)

Related tier: APV19-SRC-0900-V1 at $250,000 (editable BGA-900 design package) and APV19-SRC-1536-V1 at $380,000 (editable BGA-1536). Requires Project 75 for interposer escape routing at 1536. Included at no extra charge inside All In One (20T).

75. AutoPhi 1536 Escape Interposer — Getting 1,536 Balls Out of the Package (LIVE)

What This Handoff Is

This is the AutoPhi 1536 Escape Interposer — the interposer design that routes 1,536 signals out from under a BGA-1536 footprint, delivered as an editable KiCad design package with the escape theory behind it documented in full. Project 75 exists because BGA-1536 is a 32×48 grid on 2.00 mm pitch spanning 62×94 mm, and escaping every signal from a footprint that size is a layer-count problem with a hard theoretical floor rather than a routing exercise. Three live tiers: APV19-INTP-1536-ACCESS at $100,000 (12-layer), APV19-INTP-1536-V1 at $190,000 (editable KiCad design), and APV19-INTP-1536-PREMIUM at $300,000 (24-layer). Ships with ESCAPE-THEORY.md, BGA_IO_STANDARD.md, KICAD_PLUGIN.md, HANDOFF.md, and INTEGRATION_parts_today_tomorrow.md. Base, No IP.

What It Means as an Escape-Routing Handoff

A very-high-pin-count BGA creates a problem that is easy to state and hard to solve: every ball under the package needs a path out, and the balls in the interior are surrounded on all sides by other balls. The number of signals you can escape per layer is fixed by geometry — ball pitch, via diameter, annular ring, minimum trace and space — so for any given grid there is a minimum layer count below which the escape is simply impossible, regardless of how skilled the router is. Above that floor, additional layers buy margin for impedance control and crosstalk budget. That relationship is what ESCAPE-THEORY.md sets out, and it is the reason this project is priced as engineering rather than as a board file. The three tiers map directly onto it: 12-layer Access is the economical escape, 24-layer Premium is the one with signal-integrity headroom, and the editable V1 tier is for the buyer who intends to modify rather than manufacture as-drawn. Because the theory generalises, a buyer who understands it can apply it to package variants beyond the one shipped — which is what makes this an asset rather than a one-time deliverable. The KiCad plugin puts the escape strategy inside the buyer's own tool, and BGA_IO_STANDARD.md tells them which balls carry which signal class before they begin assigning.

What Has Been Completed

Live — Three Tiers, Editable Design, Theory Documented:

• ESCAPE-THEORY.md — the geometric relationship between ball grid, pitch, via technology, trace/space rules, and minimum layer count; the analytical core of the project and reusable across package variants
• Complete interposer design for the BGA-1536 footprint (32×48 grid, 2.00 mm pitch, 62×94 mm ball span) in three layer configurations
• Access tier — 12-layer escape, APV19-INTP-1536-ACCESS at $100,000
• Editable tier — APV19-INTP-1536-V1 at $190,000, full editable KiCad design the buyer modifies directly
• Premium tier — 24-layer escape with signal-integrity headroom, APV19-INTP-1536-PREMIUM at $300,000
• BGA_IO_STANDARD.md — signal-class conventions the escape pattern assumes, so signal assignment can proceed without guessing which balls carry which class
• KICAD_PLUGIN.md — the escape strategy as tooling inside KiCad rather than a document to re-implement by hand
• HANDOFF.md and INTEGRATION_parts_today_tomorrow.md — the rebuild procedure and the interposer's position relative to current and planned parts in the AutoPhi family
• Live on the storefront across all three tiers, with the Premium tier reachable at autophi-1536-escape-interposer-premium-24-layer

What the Customer Needs to Do

To License and Deploy:

1. Choose a Tier By Layer Count: Access ($100,000, 12-layer) if your fabrication budget is the constraint; Premium ($300,000, 24-layer) if signal-integrity margin is; editable V1 ($190,000) if you intend to modify the design rather than build it as drawn. Layer count is the dominant cost driver in your own fab quote, so decide there first.
2. Sign NDA: required for full design files.
3. Read ESCAPE-THEORY.md First: it tells you why the layer counts are what they are. If you intend to modify the package or the pitch, this document, not the board file, is what you are actually buying.
4. Read BGA_IO_STANDARD.md Before Assigning Signals: the escape pattern assumes a signal-class convention. Assigning against a different convention will produce a routable board with the wrong signals in the wrong places.
5. Install KiCad and the Plugin: the editable tiers are KiCad designs and the plugin implements the escape strategy inside the tool.
6. Pair With the Package Definition: this project routes the BGA-1536 footprint defined in Project 74 and canonically in Project 40. If you are working at a different ball count, apply the escape theory yourself rather than using the shipped pattern.
7. Fabricate and Validate: no interposer in this package has been built. PCB fabrication, assembly, impedance coupon measurement, and signal-integrity validation are your scope and your cost.
8. Position It in Your Stack: this is the layer between an AutoPhi 1536-class package and a finished board. Buyers of the PCIe5-1536 accelerator or the BGA-1536 editable source package need an escape path, and this is it.

Timeline Estimate: Design review and tier selection: days. Signal assignment against your own pinout: the dominant engineering line item, scoped against 1,536 signals. Fabrication at a 12- or 24-layer capable house: standard HDI lead times. First-article impedance measurement and signal-integrity validation: add a full characterisation cycle before committing to volume.

Acquisition price: $190,000 (APV19-INTP-1536-V1 — editable KiCad escape interposer design, escape theory, BGA I/O standard, KiCad plugin, handoff and integration documentation)

Tiers: APV19-INTP-1536-ACCESS at $100,000 (12-layer) and APV19-INTP-1536-PREMIUM at $300,000 (24-layer). Pairs directly with Project 74 (BGA package definitions, $95,000) and the editable V19 source packages ($250,000–$380,000). Included at no extra charge inside All In One (20T).

76. Quantum PHY — QBeam Transfer Card, the Classical-Byte Fabric for AutoPhi (LIVE)

What This Handoff Is

This is Quantum PHY — the patented QBeam physical layer, the same silicon inside every ExitPhi and AeroPhi node, packaged as a plain PCIe 5.0 x16 half-height half-length HBA. One APM01-D-QPHY on board. Four QBeam ports on the bracket. It talks to AutoPhi PCIe5-256, BGA256, and PCIe5-1536 accelerators directly over the QBeam physical layer at a design target of 400 GB/s bidirectional per card and 400 ns cut-through latency. The host sees a character device (/dev/qphy0 on Linux, \\.\qphy0 on Windows) plus an optional Verbs / NDIS shim, so the same card doubles as an RDMA-capable NIC. AES-256-GCM at the link layer, SR-IOV for up to 64 virtual functions, and boot from on-card SPI flash — the host driver is optional for basic passthrough. Bytes only. No qubits on the wire. No teleportation. Filed IP dependency: USPTO Application No. 19/722,805. Designated Foundry-ready (L4). Umbrella SKU QPHY at $250,000,000,000 over a twelve-rung silicon ladder from $2,500,000 to $500,000,000. Base, No IP.

What It Means as an Interconnect Handoff

Every rack of AutoPhi accelerators — and every rack of anyone else's — still talks over the same three tired options: PCIe over copper, optical breakouts, or Ethernet-over-fabric. Each costs power, adds latency, needs cables, and hands the fabric silicon to Broadcom, Marvell, or Mellanox. Quantum PHY takes a physical layer the portfolio already owns and applies it to the classical-carrier job it happens to be excellent at. The restraint in that framing is the commercial point. ExitPhi carries quantum plus classical at datacenter scale, quantum-to-quantum. AeroPhi carries quantum plus classical across a six-tier planetary mesh. This carries classical only, board-to-board, rack-local, on a single standard card — and that restriction is exactly what turns a sovereign-scale IP wrap into something an accelerator owner buys by the tray to build a real fabric out of hardware they already have. What the buyer receives is a complete engineering surface rather than a concept: the wire protocol specification, host driver ABI for both operating systems, a five-topology fabric catalog, the ASIC RTL scaffolding, twelve silicon configurations mapped to the AutoPhi Modern generational fade, the HBA board reference with BOM and stackup, firmware in C, a host daemon in Rust, and an SDK spanning C, Python, and Rust. The project states its own maturity plainly — Foundry-ready means the paperwork is ready, not that silicon has been fabricated.

What Has Been Completed

Foundry-ready (L4) — 13 Live SKUs:

• Wire protocol specification (docs/QPHY_PROTOCOL.md)
• Host driver ABI for Linux and Windows (docs/HOST_DRIVER_CONTRACT.md)
• Fabric topology catalog — point-to-point, star, ring, 2D torus, dragonfly (docs/FABRIC_TOPOLOGIES.md)
• APM01-D-QPHY ASIC RTL scaffolding (hardware/APM01-D-QPHY/rtl/*.v), synthesis constraints (SDC), floorplan, and DV testbench; physical-design flow output present
• Twelve silicon configurations, 7 nm to 2 nm, mapped to the AutoPhi Modern APM01–APM12 generational fade, each with its own FOUNDRY_HANDOFF and foundry/PDK/flow selection — live as SKUs from APM01-D-QPHY at $2,500,000 through APM12-D-QPHY at $500,000,000
• QPHY_HBA_BOARD reference: SPEC + BOM + 12-layer STACKUP (hardware/QPHY_HBA_BOARD/)
• Link-layer firmware in C and host daemon in Rust (firmware/)
• SDK — C header, Python bindings, Rust crate (sdk/)
• Deployment playbook for chassis, rack, row, and facility scales (PLAYBOOK.md), with an explicit facility ceiling handing over to AeroPhi (Project 55) above that scale
• Security and virtualization: AES-256-GCM link-layer encryption, SR-IOV for up to 64 virtual functions
• Filed QBeam IP dependency documented: USPTO Application No. 19/722,805 (a filed non-provisional utility patent, via ExitPhi / Project 54)

What is explicitly NOT in hand: physical tape-out submission to any foundry (paperwork ready), KiCad schematic capture (CM scope), PCB layout (CM scope), prototype fabrication, loopback and BER measurements on real silicon, PCIe 5.0 compliance passes, and FIPS 140-3 certification for the crypto module.

What the Customer Needs to Do

To License and Deploy:

1. Choose Your Node: the twelve-rung ladder runs APM01-D-QPHY ($2.5M, 7 nm) through APM12-D-QPHY ($500M, 2 nm). Enter at the process node your fabrication partner actually supports rather than acquiring the whole family.
2. Sign NDA: required for the full engineering package, RTL, firmware, and SDK sources.
3. Read PLAYBOOK.md and FABRIC_TOPOLOGIES.md First: decide your topology — point-to-point, star, ring, 2D torus, or dragonfly — before committing to a card count. The playbook covers chassis through facility scale and tells you when you have outgrown this product.
4. Take the Card Through a CM: KiCad schematic capture and PCB layout are contract-manufacturer scope and are not included. The SPEC, BOM, and STACKUP are drafted so a CM can quote and capture in one pass.
5. Tape Out: foundry paperwork is ready per generation but no submission has been made. Tape-out, mask, and prototype fabrication are yours.
6. Measure What Has Not Been Measured: loopback, BER, and PCIe 5.0 compliance testing on real silicon are outstanding. Treat 400 GB/s and 400 ns as design targets to be validated, not specifications to be relied upon.
7. Certify the Crypto If You Need It: AES-256-GCM is implemented at the link layer but FIPS 140-3 certification has not been obtained. Regulated deployments must budget for it.
8. Plan the Handover Above Facility Scale: deployments larger than one facility hand over to AeroPhi (Project 55). If your roadmap crosses that line, scope both.

Timeline Estimate: Engineering review and node selection: weeks. CM schematic capture and PCB layout from the supplied SPEC/BOM/STACKUP: standard board bring-up schedule. Tape-out through first silicon at the chosen node: foundry-dependent and the dominant line item. Loopback, BER, and PCIe 5.0 compliance: a full characterisation cycle after first silicon. FIPS 140-3 certification, if required, runs in parallel and independently.

Acquisition price: $250,000,000,000 (QPHY umbrella, project 76 — the complete Quantum PHY engineering package across all twelve silicon configurations)

Silicon ladder: APM01-D-QPHY $2,500,000 · APM02 $3,750,000 · APM03 $6,250,000 · APM04 $10,000,000 · APM05 $16,250,000 · APM06 $25,000,000 · APM07 $62,500,000 · APM08 $100,000,000 · APM09 $162,500,000 · APM10 $250,000,000 · APM11 $375,000,000 · APM12-D-QPHY $500,000,000. Sibling products: QPHY PCIe Card (Project 77) at $750,000,000 is the patent-canonical cable-free form. Included at no extra charge inside All In One (20T).

77. QPHY PCIe Card — Cable-Free PCIe, the Patent-Canonical QBeam Form (LIVE)

What This Handoff Is

This is the QPHY PCIe Card — a PCIe 5.0 x16 half-height half-length add-in card hosting a QBeam-enabled chip, where chip-to-chip data goes wirelessly through the package-top antenna and the bracket carries no data cables at all. Project 77 is faithful to the ExitPhi patent (USPTO Application No. 19/722,805): the chip's FCBGA package-top metallic structure is simultaneously the RF phased-array antenna for chip-to-chip data and the cold-side terminal array of a vertical thermoelectric cooling pump, exactly as patent §G describes. Package is FCBGA-196. The bracket has a status LED and a service-only USB-C port — nothing else. PCIe fingers carry only host↔chip traffic at 63 GB/s per direction. Power is slot-only at 75 W with no external connector. Reference silicon is APM07-D-QPHY-W, and any APM04–APM12 W-variant drops in. Designated Foundry-ready (L4). Live at $750,000,000 per card under Quantum PHY (id 3414) and Space & Defense (id 145). Base, No IP.

What It Means as a Patent-Canonical Handoff

Every rack of accelerators still bristles with QSFP-DD, InfiniBand, PCIe-over-copper, and optical cages. The one thing the ExitPhi patent already invented — a chip where the package-top metal is simultaneously an RF phased-array antenna and a thermoelectric cooling cold-side — has never shipped as a mainstream PCIe form factor. That dual use is the non-obvious element, and it is more than an elegance: the package top is contested physical space, normally claimed by a heatsink. Making the same structure serve as the antenna removes the cable without surrendering the thermal path. The consequence at the bracket is total. No cages, no optical modules, no copper. A status LED and a service port. For a dense rack that changes airflow, serviceability, failure surface, and per-port cost simultaneously. The commercial significance, though, is narrower and sharper than throughput. At 63 GB/s per direction this card does not out-perform its cabled sibling — Project 76 moves 400 GB/s across four QBeam ports. What this card does instead is read directly onto the patent claim. Both product families are supported deliberately: some buyers want a wired topology, some want the patent-faithful wireless form, and the rack architecture decides. For an acquirer whose interest is the patent estate rather than a bill of materials, the canonical embodiment is the asset.

What Has Been Completed

Foundry-ready (L4):

• Card-level SPEC, BOM, and 12-layer STACKUP — drafted specifically for one-pass KiCad capture by a contract manufacturer rather than requiring iteration
• Reference silicon specification: APM07-D-QPHY-W = the APM07-D-QPHY die in an FCBGA-196 antenna package per patent §G
• Generational compatibility: any APM04 through APM12 W-variant drops into the same board design — nine silicon generations, one card
• Electrical envelope defined: PCIe 5.0 x16 host interface at 63 GB/s per direction, 75 W slot-only power with no auxiliary connector
• Bracket definition: zero data connectors; status LED and service-only USB-C port only
• By reference from Project 76: host driver ABI (Linux + Windows), C/Python/Rust SDK, wire-protocol framing, and the five-topology fabric catalog
• By reference from Project 54: the full ExitPhi patent text
• Deployment playbook covering chip-to-chip line-of-sight requirements and rack layout
• Live on the storefront as QPHY-PCIE-CARD under two categories — Quantum PHY (3414) and Space & Defense (145)

What is explicitly NOT in hand: tape-out submission, prototype fabrication, any measurement on real silicon, PCIe 5.0 compliance passes, wireless link characterisation (range, throughput, interference, behaviour in a populated rack), and regulatory emissions authorisation for the phased-array antenna. Schematic capture and PCB layout remain CM scope.

What the Customer Needs to Do

To License and Deploy:

1. Decide Wired or Wireless First: if your rack wants a cabled topology, Project 76 at 400 GB/s across four ports is the product. If you want the patent-canonical wireless form, this is. Both are supported; the choice is architectural, not a matter of which is better.
2. Acquire the Card Package: QPHY-PCIE-CARD at $750,000,000, Base, No IP.
3. Sign NDA: required for the full engineering package and the referenced Project 76 software surface.
4. Take It Through a CM: KiCad schematic capture and PCB layout are contract-manufacturer scope. The SPEC, BOM, and 12-layer STACKUP are drafted so this completes in one pass.
5. Select Your Silicon Generation: APM07-D-QPHY-W is the reference, but any APM04–APM12 W-variant fits. Choose against the process node your foundry partner supports.
6. Secure Regulatory Authorisation: this card carries an RF phased-array antenna. FCC authorisation (and equivalent in any other market) has not been obtained and is the buyer's responsibility before deployment or sale. Budget for it early — it gates shipping, not just testing.
7. Validate the Wireless Link in a Real Rack: chip-to-chip operation requires line of sight per the playbook and has not been characterised in a populated chassis. Range, throughput under interference, and behaviour with neighbouring cards are all outstanding measurements.
8. Tape Out and Characterise: no silicon exists. Tape-out, prototype fabrication, PCIe 5.0 compliance, and thermal validation of the dual-function package top are all yours.

Timeline Estimate: Engineering review: weeks. CM schematic capture and PCB layout from the supplied package: standard board schedule, drafted for one pass. Tape-out through first silicon: foundry-dependent and the dominant line item. Regulatory emissions authorisation: runs in parallel and is frequently the longest pole for an RF product — start it before first silicon, not after. Wireless link characterisation in a populated rack: a full validation cycle once prototypes exist.

Acquisition price: $750,000,000 (QPHY-PCIE-CARD — card SPEC + BOM + 12-layer STACKUP, reference silicon spec, referenced driver ABI and SDK, referenced ExitPhi patent text, deployment playbook, and worldwide commercialization rights)

Sibling: Quantum PHY (Project 76) at a $250,000,000,000 umbrella with a twelve-rung silicon ladder — the cabled, four-port, 400 GB/s form. Both families are supported; choose by rack architecture. Included at no extra charge inside All In One (20T).

78. FocusPhi — The Reflective-Cavity Platform Under Six Portfolio Products (LIVE)

What This Handoff Is

This is FocusPhi — the concentrator / resonator / reflector primitive that sits underneath six named portfolio products across three energy regimes. Project 78 is priced as a horizontal enabling platform, not a point product, because it is not one device: it is the shared reflective-cavity substrate that Projects 5, 8, 17, 31, 48, and 49 each independently require. Three variants — optical (dielectric-mirror lining), microwave (Cu / superconducting-Nb lining), and nuclear (Be / graphite / D₂O reflector) — span 28 catalogued configurations and five hybrid stacks (H1–H5). Every kit ships the complete engineering document set, the OpenSCAD parametric segment library, and a numerical verification suite proving every documented number reproduces from first-principles physics. Live on the storefront at $25,000,000 (Complete Platform), $12,500,000 per variant kit, and $18,750,000 for the Hybrid H1 stack; bid catalog row 58. Rev 0.1, 2026-08-03. Base, No IP — patents 3561, 2486, 2485, 2495, 2496, and 3457 are retained by the inventor.

What It Means as a Platform Handoff

The clearest way to understand what FocusPhi is worth is to look at what six other projects look like without it. The Microwave Nuclear Waste Recycling Center (Project 8) has a cavity in its block diagram that is, honestly, hand-waved — a box labelled "cavity" between the emitter and the target. With FocusPhi that box becomes a named, dimensioned emitter-target and neutron-reflector stage, worked all the way through as reference example H1. The Small Microwave Nuclear Recycler (Project 17) has the same gap and gets the compact H1 variant. The Quantum Battery (Project 5) has no optical concentrator source at all and gets one. The AutoPhi Electromagnetic IC (Project 31) has no chip-scale staircase-mirror stage and gets the folded optical variant covered by patent 3561. Private Energy Farms (Project 48) gets a Winston-cone solar-loop concentrator. Solo Negative Microwave (Project 49) gets its containment cavity. Six block-diagram gaps close at once. That is what "horizontal layer" means in practice and why the platform sits in the same tier as the board-family and facility-class products. The technical insight underneath is that the same geometric theory holds across optical, microwave, and nuclear regimes — only the lining material changes. That is what makes this one platform with three variants rather than three unrelated products, and it is what the included verification suite demonstrates numerically.

What Has Been Completed

Rev 0.1 (2026-08-03) — Live, Five Kit Tiers:

• Three variants across three energy regimes — optical (dielectric-mirror lining), microwave (Cu / superconducting-Nb lining), nuclear (Be / graphite / D₂O reflector)
• 28 catalogued configurations — C1–C7, C14 and R1–R9 optical; C8, C9, C12, C13 microwave; C10, C11 nuclear
• Five hybrid stacks H1–H5, with H1 (the microwave-nuclear recycler) fully worked as the reference example
• Complete engineering document set per kit scope: SPEC, THEORY, CONFIGURATIONS, PROOF_OF_FUNCTION, hardware SPECs, IP_REFERENCES
• OpenSCAD parametric segment library — renders to STL and STEP, so the buyer generates geometry at their own dimensions rather than being limited to the catalogued configurations
• Numerical verification suite (verify/verify_theory.py) — proof that every documented number reproduces from first-principles physics, so a buyer can check the claims rather than accept them
• Worked dependency mapping to all six downstream products (Projects 5, 8, 17, 31, 48, 49), each showing the specific gap FocusPhi closes
• Regulatory workmap included with the Nuclear kit
• TESTED_AND_LIMITS.md documenting the L3 → L4 progression the buyer completes
• Live at cri-one.com/store/reflective-tunnel.html, bid catalog row 58

What no kit includes: rendered STL / STEP meshes (the buyer runs OpenSCAD), FDTD / HFSS / MCNP simulation results, prototype hardware, first-article measurements, and NRC / FCC regulatory filings.

What the Customer Needs to Do

To License and Deploy:

1. Choose a Kit By Regime: Complete Platform ($25M, all three variants, all 28 configurations, full CAD library, all worked examples, verification suite); a single variant kit ($12.5M each for Optical, Microwave, or Nuclear); or Hybrid H1 ($18.75M, one fully-worked hybrid stack including its two constituent variants). Note that two variant kits already exceed the platform price — if you need more than one regime, buy the platform.
2. Sign NDA: required for the full engineering package.
3. Read THEORY and PROOF_OF_FUNCTION First: the geometric theory is what generalises across regimes. Understanding it is what lets you apply the platform beyond the 28 catalogued configurations.
4. Run the Verification Suite: verify/verify_theory.py reproduces every documented number from first principles. Run it during diligence, not after — it is the fastest way to establish that the engineering is sound.
5. Render Your Own Geometry: the OpenSCAD library is parametric and meshes are deliberately not shipped. Install OpenSCAD and render to STL or STEP at your dimensions.
6. Simulate: FDTD, HFSS, and MCNP results are not included. Electromagnetic and neutronic simulation against your specific configuration is your first substantive engineering task and the beginning of the L3 → L4 progression.
7. Prototype and Measure: no cavity in this platform has been built. Prototype fabrication and first-article measurement are yours, and are what convert calculated performance into demonstrated performance.
8. Handle Nuclear Regulation Yourself: if you acquire the Nuclear kit or the H1 hybrid, Be, graphite, and D₂O reflector work carries NRC licensing and materials-handling obligations. The included regulatory workmap orients you; it does not discharge the obligation and no filings have been made.

Timeline Estimate: Document review and verification-suite run: days — the suite is designed to be run during diligence. OpenSCAD geometry generation at your dimensions: days once the theory is understood. FDTD / HFSS / MCNP simulation: weeks to months depending on regime and configuration complexity. Prototype fabrication and first-article measurement: the dominant line item, and for nuclear variants gated by regulatory approval that can run considerably longer than the engineering itself.

Acquisition price: $25,000,000 (FOCUSPHI-PLATFORM — all three variants, all 28 configurations, full CAD library, all worked examples, verification suite, worldwide commercialization rights)

Kit tiers: FOCUSPHI-OPTICAL / FOCUSPHI-MICROWAVE / FOCUSPHI-NUCLEAR at $12,500,000 each; FOCUSPHI-HYBRID-H1 at $18,750,000 (microwave-nuclear recycler stack, includes both constituent variants); bespoke configuration quoted from a $12,500,000 floor. De-risks Projects 5, 8, 17, 31, 48, and 49. Included at no extra charge inside All In One (20T).

79. WritePhi-2 — Photonic Quantum Compute in a Memory Slot (LIVE)

What This Handoff Is

This is WritePhi-2 — the photonic quantum compute platform delivered as a CXL 3.0 memory-semantic DIMM. Project 79 puts a photonic quantum compute engine into a standard DDR5 socket. Developers write designs in WritePhi-Q, a three-tier language that lowers cleanly from application-level compute-in-memory calls all the way down to waveguide-level photonic layouts. The compiled design is inscribed onto a WritePhi Q-Blank — a Blu-ray-envelope photonic substrate — by the WritePhi Writer, packaged into a WPQ-DIMM, and plugged into any CXL 3.0-capable board. No cryostat. No optical bench. No custom carrier. Just a DIMM. Live across fifteen SKUs led by WP2-BUNDLE at $2,500,000, with a ninety-day evaluation at $62,500 credited toward acquisition. Priority date 2026-08-04. No IP transfer — the buyer receives a design + product license with worldwide commercialization rights for manufactured DIMMs. Maturity: concept + designed. Read the status section below before evaluating.

What It Means as a Photonic-Quantum Handoff

Every prior photonic quantum system has required a cryogenic dilution refrigerator, an optical bench the size of a car, or both. That is not a detail — it is the reason quantum compute lives in specialist facilities rather than in datacenters. WritePhi-2 breaks that pattern by inheriting the WritePhi platform (Project 57), which fabricates chips at kitchen-table scale using an optically-written Blu-ray-envelope substrate as the physical chip, and extends it in three specific ways. First, a photonic quantum recording chemistry (Q-Blank) — same disc envelope, new chemistry that produces waveguide, resonator, phase-shifter, and single-photon-source elements as it is written. Second, a DIMM package with CXL 3.0 semantics — written discs are diced, edge-polished, coupled to a small bridge PCB carrying a CXL controller, photonic transceiver, and classical control CPU, and assembled into a JEDEC DDR5 DIMM that any Sapphire Rapids-class or later board sees as a CXL 3.0 Type-2 memory-semantic device. Third, WritePhi-Q, whose three tiers are the real accessibility argument: Tier 1 for photonic engineers who want to draw the waveguides, Tier 2 for quantum algorithm developers thinking in gates, Tier 3 for application developers who just want quantum-accelerated compute-in-memory. All three lower to the same intermediate representation and produce a single .wpprog write program. Most quantum platforms are usable only by people with physics degrees; this one is architected so an application team can adopt it without hiring one. That is the design. It is not yet a machine, and the project says so plainly.

What Has Been Completed

Concept + designed, priority date 2026-08-04 — and what that does and does not mean:

• CONCEPT.md — the full architectural concept, on file at the priority date
• WRITEPHI_Q_LANGUAGE.md — complete three-tier language specification with the shared intermediate representation and .wpprog output format
• SPEC.md — system specification covering the Q-Blank substrate, the dicing and edge-polish process, the bridge PCB, and the DIMM assembly
• STATUS.md — subsystem-by-subsystem maturity report; the honest accounting of what exists and what does not
• PLAYBOOK.md and HANDOFF.md — deployment and transfer documentation
• Inventor-record entries 79-A through 79-H in filing-ready form, available as WP2-PDEPO at $625,000
• Fifteen live storefront SKUs across package tiers, reference DIMMs, scale-up chassis, software, consumables, and adapters
• Buyer segmentation documented across four channels: cloud/hyperscaler infrastructure, AI training and inference platforms, defense and signal-processing programs (air-gap compatible — designs are written at the buyer's site), and research universities

What is explicitly NOT in hand — this is the material disclosure on this project:

• The Q-Blank recording chemistry. Candidate materials are identified. None has been selected or characterised. This is the critical path item — without it there is no substrate.
• A working WritePhi-Q compiler. The language is specified; the compiler is not written.
• A working WPQ-DIMM prototype. None has been built.
• Any measured performance data. Every figure in the SKU catalog and this page is a design target derived from the engineering record.

What the Customer Needs to Do

To License and Deploy:

1. Start With the Evaluation, Not the Bundle: WP2-EVAL-90DAY at $62,500 is a ninety-day NDA-gated evaluation of the documentation package, credited toward WP2-BUNDLE if you proceed within the window. Given the maturity, spending $62,500 to decide is the rational path rather than $2,500,000 to find out.
2. Read STATUS.md Before Anything Else: it is the subsystem-by-subsystem account of what exists. If your requirement is a working accelerator this quarter, this project is not that, and STATUS.md will tell you so faster than anyone else can.
3. Scope the Chemistry Work Honestly: selecting and characterising the Q-Blank recording chemistry is the critical path and the largest single unknown. Candidate materials are identified; the materials-science program to select among them is yours and is not a small engagement.
4. Budget for the Compiler: WritePhi-Q is fully specified and entirely unimplemented. Building wpqc, wpqsim, the language server, and the inspection tools from the specification is a real software program.
5. Acquire Project 57 Separately: the WritePhi Writer, Dicer, and Server Bed are Project 57 SKUs and are not included here. The Writer is required to author Q-Blanks at all — without it, WritePhi-2 has no fabrication path.
6. Choose Your Tier: WP2-BUNDLE ($2,500,000) for the full design + product license; WP2-DIMM-PROD ($5,000,000) for the fleet-deployment tier at which a DIMM is qualified, warranted, and licensed for shipping into a paying customer's production infrastructure; WP2-SDK ($125,000) for the toolchain license alone; WP2-PDEPO ($625,000) if your interest is the priority-date record rather than the product.
7. Plan the Scale-Up Path: WPQ-Bed chassis at $37,500 (8-DIMM), $62,500 (16-DIMM), and $125,000 (32-DIMM) with integrated CXL 3.0 switching. The CXL-Shim adapter at $6,250 bridges to PCIe 5.0 x8 for boards that do not route CXL 3.0 over the DDR5 socket.
8. Treat Every Number as a Target: tile counts, throughput, and numerics reproducibility are design values. Validate them against your own workload once silicon exists.

Timeline Estimate: Ninety-day evaluation: as named. Q-Blank chemistry selection and characterisation: the dominant line item and a genuine materials-science program — scope it in quarters, not weeks. WritePhi-Q compiler implementation from specification: a substantial software effort runnable in parallel with the chemistry work. First WPQ-DIMM prototype: gated by the chemistry. Production qualification (the WP2-DIMM-PROD operating point): a full reliability and yield-validation cycle after prototypes exist.

Acquisition price: $2,500,000 (WP2-BUNDLE — full Design + Product License Package: WritePhi-Q SDK, WPQ-DIMM-1 starter set, Q-Blank M-pack, WPQ-Library base subscription, and the full engineering documentation set)

Ladder: WP2-DIMM-PROD $5,000,000 (production tier) · WP2-PDEPO $625,000 (priority-date record) · WP2-SDK $125,000 · WP2-EVAL-90DAY $62,500 (credited toward bundle) · reference DIMMs $37,500 / $75,000 / $125,000 (1, 2, 4-disc) · WPQ-Bed chassis $37,500 / $62,500 / $125,000 (8, 16, 32-DIMM) · Q-Blank M-Pack $25,000 · WPQ-Library $12,500 base / $125,000 advanced per 12 months · CXL-Shim $6,250. Requires the WritePhi Writer from Project 57, sold separately. Included at no extra charge inside All In One (20T).

80. Global Landscaping — The Corrective-Controller Frame for Planetary Chemistry (LIVE)

What This Handoff Is

This is Global Landscaping — a database cataloguing documented, engineered environmental fixes and the elements each one moves, plus the corrective-controller frame built on top of it. Project 80 is aimed at a specific buyer: the environmental agencies of every industrialized country — EPA, USDA, DOE, NOAA, USACE in the U.S., and the EEA, DEFRA, MoEJ, NEA, UNEP and their peers abroad — who deploy hundreds of billions annually responding to damage that already has fixes on the shelf. Live SKUs: four actuator blueprints at $1,250,000 each (AUTOPHI-ENV-AQUAPHI, ATMOPHI, OZONEPHI, HOMEPHI) and the CRI-ONE HYDROPHI DATABASE at $1,000,000 (CRIONE-DB-01). The database runs 11 tables across 308 rows including an accrument totals calculator, and is read directly by the Alchemy Data Processing Calculator (Project 81). Base, No IP. Actuators are at concept proof-state — see below, because that fact governs everything.

What It Means as a Corrective-Controller Handoff

The uncomfortable observation this project is built on is that agencies do not buy ideas. They buy exactly three things: validated proof — reproducible data that survives peer review or a Federal court; defensible IP — patents an agency can license and cite in a Congressional appropriation without a lawyer objecting; and cost-avoided arithmetic — a number they can put in a Regulatory Impact Analysis that survives Office of Management and Budget review. The database is deliberately structured to deliver all three, one table group per requirement. Proof lives in studies.csv (35+ anchor citations, IP filings, case studies, peer-reviewed sources). Defensible mechanism lives in hypotheses.csv, reactions.csv, and cascades.csv, each proposed intervention traced to its chemistry, its actuator, and its scientific source. Arithmetic lives in elements.csv, planet.csv, and accruments.csv — global reservoir masses, the thin-shell habitable envelope, measured or projected outcomes. The result is that a contract officer's two questions answer out of one join: is the fix real? and what is the cheapest experiment that lets me defend acting on it? And the project is candid about why the fixes do not sell for their theoretical worth today. It is not the fix. It is the proof. The invention was worth what it was worth on day one; what agencies pay for is the removal of their own liability in citing it. Each rung of the proof ladder is not "improving the product" — it is manufacturing the artifact the buyer needs to defend their own procurement decision.

What Has Been Completed

Database complete and live; actuators at concept proof-state:

• The database — 11 tables, 308 rows, including an accrument totals calculator, organised into the three groups agencies buy against:
  • Proof: studies.csv — 35+ anchor citations, IP filings, case studies, peer-reviewed sources
  • Defensible mechanism: hypotheses.csv, reactions.csv, cascades.csv — every intervention traced to chemistry, actuator, and source
  • Arithmetic: elements.csv, planet.csv, accruments.csv — global reservoir masses, thin-shell habitable envelope, projected outcomes
• Four live actuator blueprints at $1,250,000 each — AquaPhi (river and water restoration), AtmoPhi (air smog remediation), OzonePhi (reverse Calvin cycle Cu-Al ozone), HomePhi (complete home infrastructure)
• The corrective-controller frame — interventions ranked on the fly by (novelty × delta × confidence) / (proof-cost × regulatory-friction); the project identifies this, not any individual actuator, as its most valuable single invention
• Six damage classes costed with sources — Gulf hypoxic dead zone, U.S. PM2.5 mortality, U.S. wastewater N/P treatment upgrade, stratospheric ozone monitoring and mitigation, global fertilizer-N substitution, and coastal wetland loss, each with an annual damage figure, an NPV, and a 1–5% value-of-information band
• The proof-burden ladder documented and quantified — bench validation (third-party observed) moves a product to roughly $10M; pilot deployment with third-party instrumentation moves it to $100M+; regulatory acceptance (EPA ETV, DOE national-lab benchmark, ASTM / NSF / ISO) moves it to the billions band
• valuation-and-proof-burden.md — the companion analysis explaining why the fix does not sell for its theoretical worth and what the cheapest path across each threshold costs
• A specified valuations.csv schema — one row per product per damage class, with proof-state, next-proof-step, next-proof-cost, and valuation-lift columns; this is the artifact to hand a federal contract officer
• Live storefront SKUs and a database consumed directly by Project 81's calculator

What the Customer Needs to Do

To License and Deploy:

1. Decide Whether You Want the Frame or an Actuator: CRIONE-DB-01 at $1,000,000 licenses the database and the ranking frame — the asset that serves every future intervention you evaluate. An individual actuator blueprint at $1,250,000 addresses one damage class. Agencies evaluating a programme want the frame; a prime pursuing a specific contract wants the actuator.
2. Sign NDA: required for the full database and blueprint packages.
3. Read valuation-and-proof-burden.md First: it tells you honestly why these assets are priced at $1–1.25M rather than at the VOI bands, and what it would cost to change that. No other document in the portfolio is as direct about its own limitations.
4. Fund the Bench Validation: a $50K–$500K bench run per product, third-party observed, is the single highest-return expenditure available — it converts an unrealised $1B into a realised $10M–$100M offer. If you acquire anything here, do this next.
5. Then Pilot: one field installation measuring the promised delta with third-party instrumentation, ideally in a published or filed monitoring report, moves the product from $10M to the $100M+ band.
6. Then Certify: EPA Environmental Technology Verification, a DOE national-lab benchmark, or ASTM / NSF / ISO certification is the rung that reaches the billions band. Budget it as a programme, not a task.
7. Build the valuations.csv Table: the schema is specified — product, damage class, annual damage and NPV (source-cited), VOI band, current proof-state, next proof step and cost, valuation lift, source study. That single table is what you hand a contract officer or a strategic acquirer.
8. Handle Your Own Regulatory Path: no filings have been made and no approvals exist. ETV, benchmarking, certification, and any state or federal permitting are entirely yours.

Timeline Estimate: Database integration and review: days — it is CSV and joins cleanly. Bench validation per product: weeks to a few months at $50K–$500K, and the step with by far the best return per dollar. Pilot deployment with third-party instrumentation: a full field season or more, plus reporting. Regulatory acceptance: years, and the dominant schedule item — but also the rung that changes the asset's order of magnitude.

Acquisition price: $1,250,000 per actuator (AUTOPHI-ENV-AQUAPHI-34, AUTOPHI-ENV-ATMOPHI-34, AUTOPHI-ENV-OZONEPHI-34, AUTOPHI-ENV-HOMEPHI-34 — blueprint engineering packages with worldwide commercialization rights)

Database tier: CRIONE-DB-01 (CRI-ONE HYDROPHI DATABASE) at $1,000,000 — the 11-table corrective-controller database and ranking frame. Read directly by Project 81's calculator. Shares the actuator SKU line with Project 34 (Environment Restoration). The structural analogue in compound discovery is Alchemy Probability Data (Project 07, $5B USPTO-filed). Included at no extra charge inside All In One (20T).

81. Alchemy Data Processing Calculator — The Reader for Every CRI-ONE Database (LIVE)

What This Handoff Is

This is the Alchemy Data Processing Calculator — clean companion software for the CRI-ONE database products, shipped as a single portable HTML file with no data baked in. Buyers of the store's database packages (HYDROPHI DATABASE, MetalloDrugDB, the lite-alchemy JSON exports) load their purchased files into it; the app recognises each dataset automatically and unlocks its module. Fully offline, phone-ready — copy it to a phone, open it in the browser, tap "browse files." Loaded data is remembered on the device in browser storage and never uploaded anywhere. The calculation engine is ported from the Project 63 ALCHEMY_INTEGRATION_FRAMEWORK.py pipeline and verifies itself against stored results on every load — currently 19 of 19 prospects matching. SafetyGatekeeper keyword screening from the Project 63 framework is applied at build time. Live at $10,000 (ALCHEMY-CALCULATOR-81), perpetual, as Base, No IP.

What It Means as a Companion-Software Handoff

A buyer who acquires a million-dollar chemical database and no tooling owns a directory of CSV files. That is the problem this solves, and the way it solves it is by deliberately shipping empty. No data is baked in — which means the calculator conveys none of the database content, carries no leakage risk, and can be sold to buyers who have already paid for the data without discounting the data itself. What the buyer loads determines what the app becomes. Formula Lab is always on because its engine is built in: molar mass, CRI reactivity, formation probability at 10^-n, productivity score. Everything else unlocks on recognition. Load probabilities_lite.json and methods_lite.json and Method Matcher appears. Load the eleven ledger CSVs and the HYDROPHI Ledger with its accrument totals calculator appears. Load the 300-compound files and the MetalloDrugDB explorer appears. Load ranking exports and compound rankings with custom blend re-ranking appear. Load any quantity and unit-cost table and a BOM calculator appears. A universal Data Browser shows every loaded dataset, sortable and searchable, with run-engine, match-methods, and export-CSV available on any of them. The second thing worth understanding is that the engine is a port, not a reimplementation. The Prospects tab recomputes every stored Productivity_Score on load and shows a check per row where the browser result matches the Python pipeline's. That is a claim the buyer can watch being verified rather than one they have to trust.

What Has Been Completed

Live — single-file application, engine parity verified:

• Alchemy-Data-Processing-Calculator.html — the product: a single portable file with no data baked in, which loads and recognises the buyer's own purchased datasets
• Formula Lab — always active, engine built in: molar mass, CRI reactivity, formation probability (10^-n), productivity score
• Method Matcher — unlocks with probabilities_lite.json (plus methods_lite.json)
• HYDROPHI Ledger — unlocks with the 11 ledger CSVs; includes the accrument totals calculator
• MetalloDrugDB explorer — unlocks with the 300-compound files
• Compound rankings — unlocks with ranking exports; supports custom blend re-ranking
• BOM calculator — unlocks with any quantity and unit-cost table
• Data Browser — every loaded dataset, sortable and searchable, with run-engine / match-methods / export-CSV on any of them
• Engine parity verification — the engine is ported from 63-prospecting-data/ALCHEMY_INTEGRATION_FRAMEWORK.py and recomputes every stored Productivity_Score on load, displaying a check per matching row; currently 19/19
• SafetyGatekeeper keyword screening from the Project 63 framework applied at build time
• Fully offline operation with no network path; loaded data persists in browser storage on the device and leaves only by explicit export
• Phone-ready — the same single file works from a phone browser with no installation
• sample-data/ folder holding real files for demonstration and testing
• build_calc.py and template.html — the application is rebuildable from source; build_calc.py re-reads the source folders and regenerates the app, so the buyer refreshes as datasets change
• Cross-project data reach spanning Projects 07 (compound rankings and blueprint depositions), 27 (mathematical depositions), 34 (BOM data), 63 (prospects and engine), and 80 (landscaping database)

What the Customer Needs to Do

To License and Deploy:

1. Acquire the Calculator: ALCHEMY-CALCULATOR-81 at $10,000, perpetual, Base, No IP.
2. Understand That It Ships Empty: this is companion software. Only Formula Lab works without loaded data. If you do not already own — or do not intend to buy — one of the CRI-ONE database products, you are acquiring a calculator with nothing to calculate on.
3. Acquire the Data Separately: HYDROPHI DATABASE (CRIONE-DB-01, $1,000,000), MetalloDrugDB, or the lite-alchemy JSON exports. Your own quantity and unit-cost tables also unlock the BOM calculator with no purchase at all.
4. Try It Against sample-data First: the bundled folder holds real files for demonstration. Load them, watch the modules unlock, and confirm the tool does what you need before committing to a database purchase.
5. Open It — There Is Nothing to Install: a modern browser is the only requirement. No server, no installation, no network. Copy the file wherever you want it, including a phone or a USB stick.
6. Load Your Files: use "browse files" and load what you own. Recognition is automatic; the corresponding modules appear.
7. Watch the Parity Check: on the Prospects tab, confirm the engine reproduces the stored Productivity_Score values. A green result per row means the browser engine matches the Python pipeline. Treat a mismatch as a data problem worth investigating, not a rounding artifact.
8. Rebuild When Your Data Changes: run py build_calc.py to regenerate from source. Edit template.html to change the application itself; edit the source CSV and JSON files to change the data.

Timeline Estimate: First use: immediate — open the file, load a dataset, done. There is no installation, no configuration, and no state to establish. Loading and exploring a full purchased database: same session. Rebuilding from source after a data revision: minutes.

Acquisition price: $10,000 (ALCHEMY-CALCULATOR-81 — the Alchemy Data Processing Calculator single-file application, sample data, build tooling, and template, under a perpetual license)

Companion to the CRI-ONE database products: HYDROPHI DATABASE (CRIONE-DB-01) at $1,000,000, MetalloDrugDB, and the lite-alchemy JSON exports — all sold separately. Reads data originating in Projects 07, 27, 34, 63, and 80. The second of Part 5's two operator tools alongside the GDSII Generator (Project 67, $9,500). Included at no extra charge inside All In One (20T).