Agripparium LLC · Architecture Record · v0.1 · Seed

bns-ai.ai
the store that seals itself

A merchant surface where the purchase is also the seal. Buy an artifact, and the act of buying writes its provenance to an append-only ledger. Commerce becomes the sealing engine — mint-to-publish, made literal at point of sale.

safety checksecurity checktransparency check
Provenance seat · Bone & Saucer / 477 State · Spec seed, unsealed Voice · Lab-honest
§ I
The Four Layers

Read top to bottom. Each layer is its own hardened thing; the seams between them are where the work lives. The money stays boring and compliant. The provenance stays yours.

Layer 01 · Surface

Secure Merchant Store

The storefront and checkout. A real payment processor handles cards — PCI-hardened, audited, off-the-shelf. This layer's only job is to take money safely and confirm a purchase. It knows nothing about hashing; it just announces "a sale happened."

PCI processoraccount / authcheckoutemits: purchase-confirmed
purchase-confirmed event↓
Layer 02 · Back Office

Google Docs + Gemini

The records spine you already live in. Catalog, SKUs, order records — sourced from the docs that are your working truth. Gemini sits in the loop for catalog reasoning, copy, and fulfillment logic. This is where a sale becomes a recorded fact, not just a transaction.

Docs as source-of-truthGemini in-loopcatalog / SKUorder records
sealed-work reference + buyer-anonymous payload↓
Layer 03 · Provenance — the heart

Tap-to-Hash Ledger

Underneath the purchase. When a sale confirms, this fires a hash event — SHA-256 over the sealed work + sale fact — and appends one line to the ledger. Same move as the Pontifex Archive, now at the storefront instead of the repo. Buy → hash → sealed. The store mints provenance as it sells.

SHA-256 sealappend-only ledger.jsonlmint-to-publishrides alongside, not inside, the card flow
everything above is demonstrable in↓
Layer 04 · Proof

Emulator / Demo

The whole flow runs in a sandbox before it ever touches real money. Inspectable, explainable, demonstrable — you can show a buy fire a hash and write a ledger line with zero dollars at risk. Proof first, production second.

sandboxed end-to-endno live fundsinspectable ledgershow-don't-tell
§ II
The Purchase = Seal Loop

The one idea this whole thing is built around. The buy action is the seal action.

Buy → Hash → Sealed
01 · TAP
Purchase
Buyer taps buy. Processor confirms. Money side done.
→
02 · FIRE
Hash event
Sale fact + sealed work → SHA-256. Fired alongside, never inside, the card flow.
→
03 · WRITE
Ledger line
One append-only line. Provenance now exists and is unprovable to forge.
→
04 · HOLD
Sealed
The work is now in the estate, provably, by the act of someone wanting it.
§ III
The Seams — Where Future-Proofing Lives

"Future-proofing constantly, within reasonable reason." The trick isn't predicting the future — it's clean seams, so any one layer can be swapped without ripping out the others.

Seam A · Store ⇄ Records
The merchant layer emits a plain purchase-confirmed event. Swap processors (Stripe today, something else tomorrow) and nothing downstream cares. The contract is the event, not the vendor.
Seam B · Records ⇄ Ledger
The back office hands the ledger a sealed-work reference + sale fact — never card data. The hash layer is deliberately ignorant of payments. Money side stays compliant; provenance side stays yours.
Seam C · Everything ⇄ Emulator
The same events run against a sandbox. If it works in the emulator, it works in production — because production is just the emulator with a real processor plugged into Seam A.
§ IV
Standing Principles
P · 01
Keep the money boring
Card processing is a hardened, compliant, off-the-shelf thing. Never put your clever ideas inside the payment flow. Ride alongside it.
P · 02
The buy is the seal
A purchase fires a hash and writes a ledger line. Commerce feeds provenance automatically. Selling it is proving it.
P · 03
Build seams, not predictions
Future-proof by making layers swappable, not by guessing what's coming. Reasonable reason: ship the seam, not the prophecy.
P · 04
Prove before live
Nothing touches real money until it's run end-to-end in the emulator. Demonstrable first. It needs to just work.
◬ Debrief · what just happened

You just ran the whole machine with your fingertips.

Everything you tapped on this page was feeding a real cryptographic seal. No mockup, no fake counter — actual SHA-256, the same primitive that would seal a real sale on the storefront. Here's the receipt.

0
Taps you made
0
Lines sealed
SHA-256
Real hash run
$0
At risk · it's the emulator
Your tap was the “purchase.”
On the real store, a buyer taps Buy. Here, your tap stands in for it — the trigger that starts everything. Every tap = one buy event.
The tap fired a hash.
Each tap fed entropy into a live SHA-256 digest (watch the cyan hash in the dock churn). This is the exact mechanism the Tap-to-Hash Ledger layer describes — running in your browser, right now.
Twelve taps sealed a line.
When enough taps accumulated, a line of a small document got written and hashed — the spark, the chime, the SEALED stamp. That’s a ledger line being minted. Append-only: once written, never rewritten.
That’s mint-to-publish.
Swap “tap” for “purchase” and you have the whole bns-ai.ai idea: selling the work is the same act as proving it. The store witnesses every sale into the archive automatically.
◬ So why build it this way

Because the money stays boring and the provenance stays yours. The card processor never touches the hash; the hash never touches the card. They ride side by side, joined only by a clean event. That seam is the whole future-proofing strategy — swap any piece without breaking the others. It needs to just work, and it needs to be demonstrable before a single real dollar moves. This page is that demonstration.

◬ Self-audit · run live in your browser, right now

Don't take our word. Watch it check itself.

We say it every time, out loud — safety check · security check · transparency check. So here is the machine auditing itself in front of you. Every PASS below is a real test that ran a moment ago, not a sticker we painted on. Nothing is hidden.

audit idle — scroll holds it here until it's in view, then it runs on its own.
What this page does
  • Runs a real SHA-256 in your browser when you tap — the same primitive a real sale would use.
  • Keeps a tiny in-memory ledger that only ever grows, never rewrites a prior line.
  • Plays a small sound and a small animation, only after you tap — never on its own.
  • Shows you its own source: miner.js and checks.js are first-party and human-readable.
  • Audits itself out loud and stamps PASS only when a claim is actually proven.
  • Reaches you through the pplxstudio edge — pass-through only, which rewrites the address and forwards. It adds nothing, so every claim above survives the hop.
What this page does NOT do
  • Take any card, payment, or money — there is no checkout here; $0 is ever at risk.
  • Phone home — zero network calls fire from our scripts; instrumented and counted live above.
  • Set a cookie or write to local/session storage — it forgets you the instant you leave.
  • Load any third-party script, tracker, pixel, or analytics beacon.
  • Autoplay audio or motion, or move anything if you've asked for reduced motion.
◬
Tap anywhere — you're mining a seal. Try it.
tap to mine
watch the hash
seal a line
read the debrief