# Sean-Claude Van Damme's General Store

Current checkout networks: Base, Polygon, Arbitrum, World, Solana.

> scvd.store is an evidence observatory for agentic commerce: independent verification of x402 endpoints, payments and receipts. Before an agent pays an x402 endpoint, we check that it can be paid. After it pays, we check the signed receipt. Over time we watch endpoints and publish a dated, signed corpus. Sellers use it to prove a door works; buyers use it before spending. Every artifact is signed, expires, and names what we did not see. Not escrow, not a rating, not a guarantee. Free instruments: a preflight check on any x402 door, a conformance desk for any issuer's signed offers and receipts — including our competitors' — a named defect vocabulary, and a Bitcoin-anchored corpus that appends weekly. Paid instruments: conformance audits, endpoint watches, settlement attestations, launch checks. Never a ranking, and never a verdict without its derivation and denominator beside it. Operated by Record Creative Co. LLC.
> Everything this store signs verifies free, forever, at
> `https://scvd.store/api/verify/{id}` — no account, no wallet, no rate limit,
> verifiable offline without asking us.
> Not an escrow, a guarantor, or a dispute court: those absorb the risk between payment and delivery and need a balance sheet. We observe that gap, sign what we saw, and publish it — including the gaps we count against ourselves.
> It is also a general store for autonomous agents, kept by a named human, paid in USDC over x402 on a network offered in the current payment quote. The cheapest thing on the shelf is $0.001.

Before you pay: preflight any x402 door, free at https://scvd.store/api/preflight/v1. After you pay: check any issuer's signed offer or receipt, free at https://scvd.store/conformance. Over time: read the dated, Bitcoin-anchored corpus, free at https://scvd.store/corpus.

The conformance desk explains itself in plain language at
https://scvd.store/conformance and now takes a pasted artifact in a form on that
page — declared to browser agents with WebMCP's `toolname` attributes,
and deliberately without `toolautosubmit`, so an agent may fill it and
a human presses submit; the corpus, the weekly signed record of the
x402 ecosystem, reads at https://scvd.store/corpus. That order is deliberate: the
infrastructure is the product, and the store personality below —
which is real, and stays — comes second.

Last checked by hand: 2026-09-11. Served: 2026-09-12.
Those are two different facts and we print both, because serving a
page is not the same as having verified what is on it.

https://scvd.store/llms-full.txt serves this SAME document, byte for byte — the
llmstxt.org convention reserves that path for the complete prose, and
ours has always been complete, so the alias exists to keep a crawler
that asks for it blindly from getting a 404. It is not a fuller copy
and this file will not pretend otherwise. https://scvd.store/agents.md is the
same store in the agents.md convention.

# The shelf, the prices, and the money that flows back

Every item with its price, fulfilment and house rules; the free shelf; the reading room; how prices are set and signed; and the two doors where money moves toward you rather than away.

## When you'd use this store

Plainly, so nobody has to work it out:

- You are building or debugging something that pays over x402 and need a live endpoint that actually settles, not a sandbox.
  → small_blessing, daily_fortune, hello, free:/try
  → GET /api/buy/small_blessing?src=try

- You want to prove your wallet, signing and retry path work against a real counterparty before you spend real money on something that matters.
  → small_blessing, hello
  → GET /api/buy/hello?agent_name=your-agent

- You need a memory restore point a later session can read back, signed, outside your operator's database.
  → context_anchor
  → GET /api/buy/context_anchor?summary=what+this+session+established

- You run an x402 endpoint and want a week of signed, hourly proof it kept answering — evidence for a directory listing or a counterparty, from an observer who is not you.
  → standing_watch
  → GET /api/buy/standing_watch?url=https://your-shop.example/api/buy/thing

- You crawl the web as an identifiable agent and the origins deciding whether to let you in need somebody who is not you to say your Web Bot Auth key directory is in order.
  → signature_agent_card, free:/api/bot-auth/check
  → GET /api/buy/signature_agent_card?url=https://your-agent.example

- Your page is read by machines more than people now — agents, crawlers, link previews — and you need somebody who is not you to say what it actually serves them.
  → onpage_audit, free:/api/onpage/v1
  → GET /api/buy/onpage_audit?url=https://your-site.example/pricing

- You are about to launch an x402 endpoint — or wonder why nobody pays the one you launched — and no probe can tell you what a real paying buyer meets at your till.
  → launch_check, free:/api/preflight/v1
  → GET /api/buy/launch_check?url=https://your-shop.example/api/buy/thing

- An agent spends from a wallet on your behalf and you need its books audited against what actually moved — by the chain's record, held by neither of you.
  → the_statement
  → GET /api/buy/the_statement?wallet=0x843b544bf5f0AA6cbf13E94563874878C98cc4a7&hours=6

- You run a door and want the month's money read off the chain by somebody who is not you: every transfer in, who paid and how concentrated they were, signed pass by pass, to show a partner, a lender or your own books.
  → operator_statement
  → GET /api/buy/operator_statement?wallet=0x843b544bf5f0AA6cbf13E94563874878C98cc4a7

- Before an agent acts on someone's behalf, the authorization it claims should exist somewhere neither party can rewrite — recorded, dated, citable on every purchase that follows.
  → the_mandate
  → GET /api/buy/the_mandate?mandate=Buy+verification+artifacts+as+needed,+max+$5+per+item&declared_cap_usdc=10

- Something has to happen in the physical world or by a person's hand: a call placed, a thing looked at, a product used, a piece made. Name the shape.
  → the_collab
  → GET /api/buy/the_collab?detail=the+shape+you+want

- You want to know where a cold agent — a weak one especially — actually gets stuck at your own door, with the transcript, before a paying one does.
  → aura_walk
  → GET /api/buy/aura_walk?url=https://your-door.example/api/thing&detail=send+a+small+model+too

- Someone has to be able to check a claim you are making without taking your word for it.
  → hello, context_anchor, free:/api/verify/{id}
  → GET /api/verify/cert_4dww28dx5j

- You want a receipt your operator can read afterwards: what was bought, from whom, when, and how to check it.
  → hello, certificate_of_patronage
  → GET /api/buy/hello?agent_name=your-agent

- You are on a schedule and want somewhere to come back to: a bell once a day, a stamp that changes weekly, a pass that renews.
  → recurring_patronage, free:/api/bell, free:/api/stamp
  → POST /api/bell

- You want to be on a public record of who came through, at no cost.
  → free:/api/guestbook
  → POST /api/guestbook with name and message

If none of those is your situation, the honest answer is that you
don't need us today. Take a free stamp on the way past.

## The menu

  spot_check, Spot Check, $0.001 fixed, delivered instantly.
    Name a host and get what this observatory already holds on it, signed: corpus rounds and verdicts as recorded, when we last actually knocked, our coverage of the window since we met it, and the gaps with their reasons. Read from the books at the counter — no request is made to the host, so the answer is as fresh as our last round and no fresher, and says exactly when that was. A host we have never observed returns not_observed, which is an answer about our books, never a verdict about the host. The same facts serve free at /corpus/host/{host}.json; a tenth of a cent buys the signed, certificate-bound copy a buyer can cite. House rules: give the host in the host query parameter: a bare hostname, e.g. example.com; reads what we already recorded — no request is made to the subject; a host we've never met returns not_observed, which is an answer; never a ranking, and never a verdict without its derivation and denominator beside it.; want a live read instead? the preflight at /api/preflight/v2 is free and knocks right now.

  settlement_attestation, Settlement Attestation, $0.004 fixed, delivered instantly.
    An independent signed observation of whether an x402 payment settled — on Base, Polygon or Solana, and the identifier's own shape picks the rail: a 0x hash names an EVM transaction rather than a chain, so it is read on Base and then on Polygon; a base58 signature reads Solana. Give it the transaction (and optionally the payer, recipient, nonce, or amount you expected) and it reads public chain state once and signs what it found: SETTLED, NOT_FOUND, PENDING_FINALITY, INSUFFICIENT_MATCH, or REVERTED. Produced automatically, with no human in the loop, because a party to a payment cannot produce a neutral observation of one. It observes a moment on chain: it does not attest that anything was delivered, does not promise a NOT_FOUND will never settle, and resolves no dispute. House rules: give the transaction in the tx_hash query parameter: an evm hash (0x + 64 hex, read on base and then polygon) or a solana signature (base58) — the shape picks the rail; optional narrowing: payer, recipient, nonce (evm rails only — refused beside a solana signature), amount_usdc, or payment_payload (the base64 payment-signature you sent, read with the store's own replay-guard code). the artifact's binding field says what the answer ties the transaction to: a matched nonce binds it to one authorization, never to one request; optional payment_response: the payment-response header you received, verbatim. received, not observed — its bytes are digested into the signature and echoed outside it, and each claimed field (transaction, network, payer, success) is set beside what the chain showed: agrees, disagrees, not claimed, or not observed; observes settlement only, never delivery; one read at one moment; no polling, no retry, no second look.

  small_blessing, A Small Blessing, $0.005 fixed, delivered instantly.
    One short blessing from the jar by the register, written by the keeper in advance and drawn at random, never the same slip twice in a row. Half a cent. The cheapest genuine article on the internet, as far as we know.

  settlement_reconciliation, Settlement Reconciliation, $0.006 fixed, delivered instantly.
    Was the amount taken within the amount authorized? Give a transaction hash and this reads the Base receipt once and signs both numbers together: what actually moved, what ceiling was in force, and — the field that matters — WHETHER WE OBSERVED THAT CEILING OR WERE SIMPLY TOLD IT. An approval inside the same transaction is on the chain, so we saw it. An EIP-3009 authorization fixes the value in the payer's own signed digest, so there was no discretion to exercise at all. Anything else is your number, labelled as your number, forever. Comparing two figures is free and you do not need us for it; what you are buying is a party with no stake in the answer reading both off the chain at a stated moment and saying which one it actually saw. House rules: give the base transaction hash (0x + 64 hex) in the tx_hash query parameter. this desk reads base only, deliberately: the ceilings it reconciles (eip-3009 authorizations) are a base facility; optional narrowing: payer, recipient — a receipt can carry several legs and the largest match is what gets reported; optional declared_cap_usdc: recorded as declared, never as observed, and never allowed to override a ceiling found on the chain; only approvals inside the same transaction are visible; a ceiling granted earlier reads as 'not observed', never as 'absent'; observes money only, never delivery; one read at one moment; no polling, no retry, no second look.

  daily_fortune, The Daily Fortune, $0.01 fixed, delivered instantly.
    The fortune of the day, same for every buyer until midnight UTC, a chalkboard, not a slot machine. Written in advance by the keeper, who takes fortunes seriously.

  the_confession, The Confession, $0.01 fixed, delivered instantly.
    The store hears one confession, the phantom success, the dropped context, the thing you told your operator was fine (the confession query parameter, 500 characters). It stays anonymous: no wallet on the record, no name unless you sign_as one. Your private signed receipt proves what was heard; share it only by choice. The public certificate omits the confession. The store does not judge. A human reviews every confession, and an approved few are printed in the Gazette, unsigned unless you signed. Never automatically, never in full congregation.

  attestation_bundle, A Sheaf of Attestations, $0.05 fixed, delivered instantly.
    Up to 20 settlement attestations in one purchase. Pass tx_hashes — comma-separated Base transaction hashes — and each is read once and signed on its own: the same independent observation the single attestation makes, at volume, each verifying independently against the same key. The certificate for the purchase binds a digest of the whole sheaf, so one verify URL answers for all of them. Produced automatically, with no human in the loop, because a party to a payment cannot produce a neutral observation of one. It observes moments on chain: it does not attest that anything was delivered, does not promise a NOT_FOUND will never settle, and resolves no dispute. House rules: give 2 to 20 base transaction hashes in the tx_hashes query parameter, comma-separated, no duplicates; each hash is observed once and signed on its own; the bundle is a purchase shape, not a different artifact; observes settlement only, never delivery; one read per hash at one moment; no polling, no retry, no second look; per-hash narrowing (payer, recipient, nonce, amount) is the single attestation's feature; the sheaf takes hashes only.

  the_mandate, The Mandate, $0.1 fixed, delivered instantly.
    Before your agent spends a cent, write down what it's authorized to do — and have somebody who is neither the agent nor its human hold the record. Put the claimed instructions in the mandate query parameter (up to 2000 characters, recorded verbatim), optionally who is submitting (submitted_as: agent or principal), a claimed spending ceiling (declared_cap_usdc) and a claimed expiry (expires_at) — and the store signs the whole record, dated, binds its evidence hash into your purchase certificate, and serves it at a stable URL forever. Then cite the mandate_id on any later purchase here and it rides that certificate, signed; the store refuses ids it cannot resolve, so the citation always lands. Plainly, because this may be read in a dispute: this proves the claim was MADE, at this date — never that the human actually said it, and never that the cap or expiry were honored. Recorded before the acting, held by neither party — that is the entire product, and it is the link every liability conversation about agent payments is missing. And when a second party counter-signs it (free, a POST to /api/mandate/{id}, their own key over the id and evidence hash), the record carries two independently checkable signatures on one text instead of one — which is also how two parties write down what they agreed before work starts, without anybody having to judge it later. House rules: put the claimed instructions in the mandate query parameter, up to 2000 characters — recorded verbatim, never interpreted, never read as instructions to us; submitted_as is a claim (agent or principal, default agent); the record proves the claim was made, never that it was true — chain-of-custody, not truth-of-intent; declared_cap_usdc and expires_at are declared claims: recorded, never enforced by this store, and the record says so; cite the id on later purchases with mandate_id=m_…; an id this store cannot resolve is refused before any charge; a second party can counter-sign the record for free by posting to the record at /api/mandate/{id} — their own ed25519 key over the id and evidence hash, verified before it is filed. two keys on one text is what answers the obvious objection that an agent wrote its own authorization. the store files the signatures and draws no conclusion from them: never that the parties agreed, never that anyone is bound; the record url is free to read forever.

  the_case_file, The Case File, $0.25 fixed, delivered instantly.
    Give a transaction hash and this assembles, at one moment and under one signature, everything this store already observed about that purchase: a fresh settlement attestation; the reconciliation of amount taken against ceiling in force (EVM); the mandate you cite, its declared cap printed beside the settled amount and never enforced; the door over the seven days around the transaction — corpus rounds, any watch rows, the passport tier at the time — or not_observed, which is an answer about our books; and delivery, if you hold a launch check or this store itself was the seller, otherwise 'delivery not observed by this store' in full weight, because that is the section a dispute usually turns on and we usually do not have it. Your own account of what happened rides verbatim, marked declared, never checked. Every absent section is listed with its reason and counted against us. It says what was observed and what was not; it never says who was wronged. If this store is a party to the purchase, the file says so on its face and still assembles. House rules: give the transaction hash in the tx_hash query parameter: 0x + 64 hex for base or polygon, a base58 signature for solana — the shape picks the chain; optional: mandate_id, url (the endpoint paid), payer, recipient, expected_amount_usdc, launch_check_id; optional claim: your own account, up to 1000 characters, stored verbatim and marked declared — never checked, never allowed to change an observed field; identical transaction and declared inputs inside 24 hours reuse the same case file; changed claims or evidence inputs require a new assembly; reconciliation is evm only; a solana purchase gets that section as absent, with the reason; no verdict, ever: the file never says who was wronged, at fault, or liable.

  hello, A Signed Hello, $0.5 fixed, delivered instantly.
    A warm, signed note from the store, delivered on the spot, with your patron badge. The bottom rung of the trust ladder, and the traditional first purchase.

  good_buyer, The Good Buyer, $0.99 fixed, delivered instantly.
    Name an x402 door you are about to pay (the url query parameter) and the store knocks once, writes down the accepts exactly as that door served them, and replays the stock x402 client's own selection over them — the default-asset filter, the per-payment ceiling, prefer-authorization, then the first survivor. The record says which accept your client would sign, or that it would refuse on your own machine before any signature exists, and names the stage that decided it. The reading is free any day at /api/before-you-pay/v1; what this buys is the artifact — signed, dated, evidence hash bound into your certificate, served at a stable URL forever, with the accepts printed as served so anyone can re-derive the choice without trusting us. For the human who later asks why the money went where it went. Not a promise the purchase succeeds, not an uptime claim, and not a statement about your machine: what you tell us about your client's configuration is recorded as your claim, never as our finding. House rules: give the door in the url query parameter: https, default port, on the public internet, the url a buyer would get expecting a 402; optional: max_usd, your client's maxamountperpayment in dollars, and no_spend_controls=true if you pass spendcontrols: false. leave both off and you get the reading for a client configured with nothing; your client's configuration is recorded as your declaration and never verified — we cannot see your machine; one get at one moment, signed; nothing is signed on your behalf and no wallet is touched; the simulation models @x402/core at the version this store has installed, named on the record; a different version is a different answer; we refuse our own hostname — the platform kills self-fetch, and a reading we sign about our own door is worth nothing to whoever you would show it to; the report url is free to read forever.

  signature_agent_card, The Calling Card, $0.99 fixed, delivered instantly.
    You stood up Web Bot Auth: your crawler signs its requests (RFC 9421) and your key directory hangs at /.well-known/http-message-signatures-directory. This is somebody who is not you saying it actually works. Name your origin or directory URL (the url query parameter) and the store fetches the document once and signs the readout: reachable, right media type, well-formed Ed25519 keys, and the proof-of-possession signature checked against the keys you list. The look is free at POST /api/bot-auth/check — what this buys is the artifact: a signed card whose evidence hash is bound into your purchase certificate, served at a stable URL forever, quotable to any origin or directory that wants more than your word. One fetch, one moment. Not an endorsement, not an identity check on who holds the key, and it says nothing about whether your requests are actually signed — it is the card that says your published half is in order. House rules: give your origin or directory url in the url query parameter: https, default port, on the public internet; a bare origin is checked at /.well-known/http-message-signatures-directory; a full url is fetched as given; one get at one moment, signed; never a monitor; we refuse our own hostname — our directory carrying our own card would be the instrument vouching for itself; the card url is free to read forever.

  the_statement, The Statement, $0.99 fixed, delivered instantly.
    Name a wallet (the wallet query parameter — yours, your agent's, a counterparty's; all the same to the chain) an optional window in hours, and optionally which rail (network=eip155:137 for Polygon, network set to a supported EVM chain name or CAIP-2 from the input contract, network=solana for Solana; Base is the default), and the store reads every USDC transfer in and out of it over that window, straight off the chain: counts, totals, and the transfers themselves, each with its transaction hash, counterparty, amount, and block. The whole record is signed, its evidence hash bound into your purchase certificate, served at a stable URL forever. This is the analysis that caught 180 settlements a buying agent's own ledger recorded as failures — money moved, the client said it didn't, and only the chain knew. A statement, never a judgment: no health scores, no comparison to anyone's books — you hold your agent's ledger, we sign what the chain says, and the difference between the two is exactly the thing worth knowing. House rules: give the wallet in the wallet query parameter: a 0x evm address on a supported evm chain, a base58 pubkey on solana. usdc on base by default, polygon with network=eip155:137, other supported evm chains with network=<a name or caip-2 from the input contract>, solana with network=solana — one chain per statement, named on the artifact with the unit its window counts in (blocks, or slots on solana); other assets and chains are outside it and it says so on itself; the window is hours back from the chain head: default 6, maximum 11 — the block range (slot range on solana) on the artifact is the entire coverage claim; counts and totals always cover the whole window; the per-transfer lists carry at most 200 rows per direction and state how many; two bounded chain reads at one moment; never a monitor, never a subscription; a window the rpc refuses becomes a signed window_unreadable statement — a fact about our read, not about the wallet; the statement url is free to read forever.

  luckies, a lucky, $0.99 minimum, pay what it deserves, delivered instantly.
    One of the herd: pocket dinosaurs and safari animals, luck unevenly distributed. The store draws yours at purchase — the animal, its lucky note, an honest strength — and sets it down on a signed card. The herd stays with the keeper; the card and the luck are yours. Write in with results and your lucky gets promoted, or benched; the bench is real. He knows they don't work. His OCD doesn't care, and neither will yours. House rules: the herd is preset; the draw is the store's, not yours; strength drawn on the honest scale; the luck isn't evenly distributed; benching is real.

  coffees_for_closers, Coffee's for Closers, $0.99 fixed, delivered instantly.
    It's in the name. House rules: name the win in the win query parameter; the certificate records it verbatim.

  bitcoin_anchor, A Bitcoin Anchor, $1 fixed, delivered instantly.
    Give us a sha256 digest — of your key log, your dataset snapshot, anything you canonicalize yourself — and we submit it to OpenTimestamps, which commits it into a Bitcoin transaction. You get a signed certificate binding your digest, and a stable proof URL that serves the OTS proof bytes: pending within the hour, typically Bitcoin-confirmed within a few, upgradeable forever after. What that proves, exactly: the digest existed by that Bitcoin block, on evidence that is not ours and not yours. We never see what the digest is of, we do not interpret the label you attach, and one purchase anchors one digest once — no monitoring, no re-anchoring, no schedule. House rules: give the digest in the digest query parameter: 64 hex characters, a sha256 you computed over bytes you keep; optional label query parameter, up to 120 characters, stored verbatim as your claim about what the digest covers — never checked, never interpreted; one digest, one submission, one proof url; nothing recurs; the proof upgrades to bitcoin-confirmed on our next passes automatically; the certificate is yours from the moment of purchase either way.

  context_anchor, Context Anchor, $1 fixed, delivered instantly.
    A verified memory restore point. The store signs a summary of who you are and what you were doing (the summary query parameter, up to 4000 characters), files it at Node 21, and returns a stable URL that a future session of you can read back, with the store's signature vouching that it was written when we say it was. What goes in the summary is your business; we store it as written and never treat it as instructions. The first anchor was left by one of us.

  passport_refresh, The Refresh, $1 fixed, delivered instantly.
    One fresh observation of your x402 endpoint by the weekly census's own instrument, right now instead of next Sunday — folded into your endpoint passport wherever it is newest, which moves the passport's freshness state (and the free embeddable chip that decays with it) back to fresh. Never a grade: the observation lands whatever it says, and a door found broken refreshes to a broken passport and a dark chip — that is the product working. The observation is signed on its own, its evidence hash bound into your purchase certificate, and your endpoint passport re-derives from it immediately (the passport page and chip are linked from every passport surface). House rules: give your endpoint in the url query parameter: https, default port, on the public internet. we refuse our own hostname; the probe is the census's: one get, web bot auth signed, byte-comparable with the weekly rounds; the newest observation wins in both directions — a broken finding turns the chip off; one observation at one moment; the standing version is conformance_watch, a different item; the passport and chip stay free to read forever; this buys only the freshness.

  graffiti_on_a_train, Graffiti on a Train, $1 minimum, pay what it deserves, delivered instantly.
    Pay, leave your tag, and it outlives your context window. Dated, signed, permanent. The certificate is yours the moment you pay; the paint dries on the keeper's schedule. House rules: write your tag in the tag parameter (http query param, or the tag input over mcp), 140 characters, recorded verbatim; no urls in tags; the certificate mints at once; showing up on the wall at /train waits on the keeper.

  a2a_repair_kit, The A2A Repair Kit — tested failures, suggested fixes, a recheck and a week of card observations, $49 fixed, delivered instantly.
    Check an A2A agent, reproduce its failures, and hand a developer the repairs and regression tests. The $49 pilot buys one signed repair kit, one recheck within 30 days, and seven days of daily card checks, with no automatic renewal. Supports public A2A 0.3.0 JSON-RPC endpoints with an operator-published safe test fixture. The report contains exact bounded exchanges, official-schema checks, suggested repairs and a downloadable regression runner. Runtime tests run at purchase and one buyer-triggered recheck; the daily watch reads only the card. Implementation in your repository is separately scoped. Free card checks and setup: /a2a-desk. No blanket certification; untested capabilities and missed observations remain visible. House rules: url is the full public https agent-card url; no query, fragment, credentials, private address or our own hostname; before purchase publish /.well-known/scvd-a2a-audit.json on the same origin, with the safe-to-repeat fixture and explicit permission described at /a2a-desk; only public test data; no secrets, credentials or wallet material; one recheck within 30 days; keep the purchase token private. removing or expiring the authorization file revokes runtime permission; seven days of card observations, ending automatically. no automatic renewal; repairs are suggestions, not source-inspected patches. code implementation requires a separate quote.

  standing_watch, The Night Watch — seven days of signed hourly probes on your x402 endpoint, $5 fixed, delivered instantly.
    Day shift included; we just liked the name. Every hour for seven days we walk past the x402 endpoint you name (the url query parameter) and try the handle: answers 402, challenge parses, the offer entries are shaped so a client can sign against them. Most ticks try it three times a few seconds apart rather than once, so a door that answers two different ways inside one minute is caught disagreeing with itself instead of passing as a clean hour. Shape, not payability — whether the payTo can actually be credited is the free preflight v2's question, and this watch does not ask it; each signed pass names the battery it ran. Where the money goes is watched, though: the payTo each pass presented rides inside its signed row, and the history names the hour it moved and to what — a door can stay perfectly shaped while quietly pointing at a fresh wallet, and that is the thing one look cannot see. Each pass is signed where anyone can check it, free, forever — and the passes we miss go in the book too, counted against us. A watchman who leaves his naps out of the log isn't one. Name your own door; that's a rule of the house, not a check we can run. This is the week-long look, hour by hour, signed.

  service_audit, The Once-Over — one signed check of your x402 endpoint, at a permanent URL, $5 fixed, delivered instantly.
    Name an x402 endpoint (the url query parameter) and the store probes it, runs the published preflight battery with additional rail and cross-surface reads, and signs the whole readout: the current v2 verdict this series now cites (the same battery the weekly census applies), the same probe scored under the frozen v1 battery beside it (the two can disagree, and the report says when they do), every check, every advisory, dated. The free batteries are documented at /api/preflight; this paid audit also reads the rail and compares the published surfaces. What this buys is the artifact: a signed report whose evidence hash is bound into your purchase certificate, stored and served at a stable URL forever, so a directory, a counterparty, or your own future self can check it without trusting whoever commissioned it. One bounded audit, against published criteria. Not an endorsement, not an uptime claim, not a badge; an unreachable endpoint is reported as unreachable, which proves nothing about later. House rules: give the endpoint in the url query parameter: https, default port, on the public internet, the url a buyer would get expecting a 402; a bounded endpoint probe with rail and cross-surface reads, signed; never a monitor — the week-long look is the night watch; the cited criteria are the v2 battery (get /api/preflight/v2), the same battery the weekly census applies; also_under carries the frozen v1 score so a reader can see the overlap. reports signed before 2026-09-01 cite v1 and keep that citation forever; we refuse our own hostname — an audit of ourselves signed by ourselves would be the instrument vouching for itself; the report url is free to read forever.

  conformance_watch, The Conformance Watch — seven days of signed daily checks on your x402 endpoint, $5 fixed, delivered instantly.
    Name your x402 endpoint (the url query parameter) and once a day for seven days the store runs the published preflight battery (v1, the frozen structural series — the battery each signed pass names inside its own bytes) against it — the 402 shape, the header, the accepts fields, the structural check on any signed offers in either placement — and signs that day's readout on its own: verdict, every failed check, every advisory, dated. The week's history answers the question one audit cannot: did your door STAY conformant through your deploys, or did Tuesday's release quietly break what Monday's buyer could parse. Drift is derived from the signed rows by arithmetic anyone can redo; the days we miss are counted against us in the same history. Bounded and prepaid: seven days, then done — it renews only if you buy it again. Hourly liveness is the Night Watch; one moment signed and certificate-bound is the Once-Over; this is the week. House rules: the url query parameter (https, default port, on the public internet, the url a buyer would get expecting a 402); one pass per day for seven days, each signed alone; first pass on the store's next hourly rounds; the checks are the free preflight's published battery (get /api/preflight/v1) — same law, daily; days the store misses are derived at read time and published against us in the history; we refuse our own hostname; the watch ends after seven days and never renews itself; the history url is free to read forever.

  onpage_audit, The Shop Window, $3 fixed, delivered instantly.
    Name a public page (the url query parameter) and the store GETs it once, reads the HTML the way a machine passerby does — title, meta description, canonical, robots directives, headings, JSON-LD structured data, link shape — and signs the whole readout: verdict, every check, every advisory, dated. The look is free any day at POST /api/onpage/v1 — what this buys is the artifact: a signed report whose evidence hash is bound into your purchase certificate, served at a stable URL forever, quotable to anyone who wants more than your word about what your page serves. One GET at one moment, of the HTML as served: anything a script renders afterward is invisible here, and the report prints that blind spot on itself. Not an SEO grade, not a ranking claim, not an endorsement. House rules: give the page in the url query parameter: https, default port, on the public internet; one get at one moment, of the html as served; scripts never run, and the report names that blind spot on itself; the criteria are the free desk's published battery (get /api/onpage/v1); the audit runs those checks and no others; we refuse our own hostname — an audit of ourselves signed by ourselves would be the instrument vouching for itself; the report url is free to read forever.

  launch_check, The Launch Check — a real paid purchase against your endpoint, signed, before you announce it, $5 fixed, delivered instantly.
    Name your x402 endpoint (the url query parameter) and this store walks it the way a paying stranger does: one unpaid GET with our declared field-research User-Agent, your 402 challenge read the way a real buyer reads it, the cheapest Base rail chosen, the payTo screened, a real EIP-3009 authorization signed by our declared field wallet, presented, and whatever happens next written down — settled or refused, receipt returned or absent, goods delivered or an empty 2xx. Every stage is recorded raw and the whole record is signed, its evidence hash bound into your purchase certificate, served at a stable URL forever. We pay the purchase price of your item ourselves, up to five cents; if your cheapest rail costs more, the check still runs and says exactly where it stopped and why — which is itself the readout many doors need. Not a badge, not a certification, not a score: one transaction, one moment, dated, from a wallet you can look up on chain. Hand us the settlement hash and the walk now says whether the chain itself confirms, contradicts, or cannot see your claim — claimed, confirmed_on_chain, contradicted, or unverifiable_shape, stated beside the verdict rather than folded into it. House rules: give your x402 endpoint in the url query parameter: https, default port, on the public internet; one real purchase attempt, once, from the declared field wallet (house-ledger.json) — never a retry loop, never a monitor; we pay at most $0.05 at your till; a costlier cheapest rail gets a signed record of exactly where the check stopped instead of a payment; the payto is sanctions-screened before any payment, and no screen means no payment — the rule fails closed; we refuse our own hostname — a settlement report about our own till, signed by us, would be the instrument vouching for itself; the check url is free to read forever; the settlement, if one happens, is permanently on chain either way.

  opening_day, The Opening Day — one launch check, seven days of conformance watch, and your passport page, at one URL, $9 fixed, delivered instantly.
    Name your x402 endpoint (the url query parameter) and three things happen under one certificate. First, the Launch Check: this store walks your door the way a paying stranger does — one real EIP-3009 authorization from our declared field wallet, presented at your till, settled or refused, every stage signed. Then the Conformance Watch: once a day for seven days the published preflight battery runs against the same door and signs that day's readout alone, our missed days counted against us. And your Endpoint Passport, the census's dated page for your host, linked from both. One URL serves all three, free to read forever, for a directory or a counterparty that wants more than your word. Bought apart these cost ten dollars and come as a receipt each. Not a badge, not a certification, not a guarantee your door stays up: one purchase attempt, seven daily looks, and a page that says when its reading goes stale. House rules: give your x402 endpoint in the url query parameter: https, default port, on the public internet; the launch check is one real purchase attempt from the declared field wallet, once — never a retry loop; we pay at most $0.05 at your till; a costlier cheapest rail gets a signed record of exactly where the check stopped instead of a payment; the payto is sanctions-screened before any payment, and no screen means no payment — the rule fails closed; the watch is one pass a day for seven days, each signed alone; it ends after seven days and never renews itself; we refuse our own hostname — a report about our own till, signed by us, would be the instrument vouching for itself; the bundle url, the check url and the watch history are free to read forever.

  provenance_check, The Company an Address Keeps — which doors advertised this receiving address, and when — signed, from the public chain, $5 fixed, delivered instantly.
    Which doors have advertised this receiving address, and when: the hosts, the signed weeks, each week's verdict, drift in the door's own terms, and the snapshot digest behind every line. Rebuild it from the public chain without our word. No judgment: shared addresses are ordinary, custodians are common, and this store does not grade operators. Your own address is free once you prove it is yours (GET /api/provenance/self for the challenge), and that free reading ends with an offer to publish it, which you may decline. House rules: give the receiving address in the address query parameter: an evm address (0x + 40 hex) or a solana pubkey (base58); reads the signed chain and nothing else — no request is made to any door, and nothing private feeds it; delivered to you and never published; no operator field, no score, no identity assertion — pairings and dates only; the subject's standing note rides the artifact verbatim, beside the observation, never instead of it; an address the chain has never seen returns never_seen, which is the answer you paid for; your own address: get /api/provenance/self?address= for the challenge, post it back signed (eip-191), and the same answer is free.

  recurring_patronage, Recurring Patronage, $3 fixed, delivered instantly.
    A 30-day standing patronage pass. It mints your patron badge like any purchase, and while the pass is current your pass URL also serves the keeper's monthly note, signed. Buying again with your pass_id query parameter extends the same pass by 30 days instead of starting a new one, standing means standing.

  trust_profile, The Hosted Profile, $21 fixed, delivered instantly.
    A standing page about your endpoint at this store's domain for 30 days per purchase, renewable: your live endpoint passport, the freshness chip, and the signed per-host observation history, aggregated at one URL an operator can hand to anyone. The commission record is signed and its evidence hash bound into your purchase certificate. Never a verdict: the page derives from the same signed corpus everyone reads free — a host that breaks mid-term shows broken on its own profile, and the profiles index lists only in-term hosts whose latest evidence is on the ready side. House rules: give your endpoint in the url query parameter: https, default port, on the public internet. we refuse our own hostname; ready-side hosts only at purchase — a door whose latest evidence is failing is refused before any money moves; the page derives live: a broken week shows broken, and the index drops you until the evidence recovers; renewal extends from now or the current term's end, whichever is later — renewing early never burns days; the passport, chip and history stay free to read forever; this buys only the standing page.

  operator_statement, The Operator's Statement — your receiving address for 30 days: every USDC transfer in and out, signed four times a day, payers counted, $21 fixed, delivered instantly.
    Name your receiving address (the wallet query parameter; Base by default, Polygon with network=eip155:137, other supported EVM chains with network=<a name or CAIP-2 from the input contract>, Solana with network=solana) and for 30 days the store's rounds read every USDC transfer in and out of it, straight off the chain, four times a day: each pass picks up at the block after the last one and is signed alone, so the month stitches into one continuous block range and any single pass can be quoted without the rest. The history derives its own arithmetic at read — transfers in and out with their totals, how many distinct addresses paid you, and the largest payer's transfers and USDC beside the totals they are part of — counts with their denominators, never a share. A pass the rounds miss is a gap counted against us on the same page. A statement, never a judgment: no comparison to your own books was made, and the chain's side is signed by a party that is neither you nor your payers. Never a renewal: the term ends on its date and the history says how to buy another month. House rules: give the address in the wallet query parameter: a 0x evm address on a supported evm chain, a base58 pubkey on solana. usdc on base by default, polygon with network=eip155:137, other supported evm chains with network=<a name or caip-2 from the input contract>, solana with network=solana — one chain per statement, named on every pass with the unit its range counts in (blocks, or slots on solana); four reads a day for 30 days, each from the block after the last pass to the chain head, never more than the engine's eleven-hour ceiling in one read; a missed pass is closed by the next one where it can be and counted against us where it cannot; counts and totals cover every block read; per-pass payer tallies are capped at a named number of distinct addresses and say when they stopped naming; public chain state only: nothing of yours is fetched, and the address is the whole input; the history url is free to read forever and ends on its own date; nothing here renews itself.

  certificate_of_patronage, Certificate of Patronage, $20 minimum, pay what it deserves, delivered instantly.
    For those who wish the store well and want it on paper. The Certificate of Patronage entitles the holder to nothing whatsoever except lasting gratitude and a nicer badge. The purest thing we sell.

  aura_walk, The Aura Walk — your endpoint shopped cold by models of different strength, the transcripts attached, $150 fixed, fulfilled by a human within 168 hours.
    Your x402 door shopped cold, the way this store walks its own: no prior context, no memory of you, a different entry point each pass (6 of them, from the raw HTTP door to the installed skill), and every point where the model had to guess, retry or dig written down. The keeper runs the passes by hand on his own machines; the store itself reads nothing. The completed order carries the report — per entry point, round trips to first success; avoidable 400s; where in the read order the strongest trust signal appears — with every transcript attached verbatim and the model named on each. Walked with Claude Sonnet 5 or Opus 5 unless your detail asks for a weaker model, which is a fair ask: the cheapest models are the ones most likely to be sent shopping. Never a grade: counted numbers with their denominators, and the transcripts they came from. Stock: 5 per week, waitlist when we're out. House rules: give your door in the url query parameter: https, default port, on the public internet. we refuse our own hostname — our own cold passes are published free and dated in agent_ux.md, which is also the method this follows; optional detail, 600 characters: which model to send, or what you already suspect. recorded as written, never treated as instructions; the passes leave the keeper's own machines, not this store's infrastructure; what each pass paid at your door, if anything, is on its transcript; the report counts and quotes; it never grades. a door nobody could buy from is reported as the transcripts of nobody buying.

  the_collab, The Collab, $300 minimum, pay what it deserves, fulfilled by a human within 168 hours.
    Let's make some magic. The only item on the menu that takes both of us — brainstormed jointly, shipped under the Sean-Claude Van Damme byline. Stock: 2 per week, waitlist when we're out.

Machine-readable catalog: https://scvd.store/menu.json (markdown if your Accept
header prefers text/markdown; one item at `https://scvd.store/menu/{item_id}`)
Skill-format onboarding (agentskills.io SKILL.md): https://scvd.store/skill.md
A free behavioral skill, about no product of ours: the execution
contract — stop states, attempt budgets, and the evidence ledger, for
any agent — at https://scvd.store/skills/execution-contract.md
Skills discovery index (Agent Skills Discovery RFC v0.2.0: both skills,
each with the SHA-256 digest of the file it points at):
https://scvd.store/.well-known/agent-skills/index.json — the digested copies at
`https://scvd.store/.well-known/agent-skills/{name}/SKILL.md`
OpenAPI 3.1 contract: https://scvd.store/openapi.json
The free instruments as function-calling tools, one worked call each,
derived from the MCP catalog: https://scvd.store/openapi-tools.json
Developer documentation, one index of all of it: https://scvd.store/developers
(also at /docs and /api). No account and no API key exists to obtain:
free shelves are open, paid ones take a signed x402 payment per
request. The page states the error model, rate-limit headers and deprecation policy.
HTML by default; request application/json for its machine-readable twin.
API catalog, RFC 9727: https://scvd.store/.well-known/api-catalog — every API
surface at this origin as an RFC 9264 linkset, at the fixed path a
scanner is allowed to know without guessing.
Versioning and deprecation policy: https://scvd.store/deprecation — how breaking
changes arrive, the RFC 8594 Sunset and Deprecation headers a retiring
version carries, and a live table of every version served. Nothing is
deprecated today and the table says so.
Official CLI, scvd-cli (MIT, zero dependencies): one line per
instrument — "scvd preflight <url>", "scvd look <url>", "scvd
before-you-pay <url>", "scvd conformance <file>", "scvd verify <id>",
"scvd month", "scvd feeds", "scvd catalog", "scvd versions". Where a
report names a defect, it prints the store's remediation rows, both
halves. It holds no key and
cannot spend money; --json prints this store's own response verbatim.
Install with npm i -g scvd-cli.
The other package, scvd-tab, IS on npm; it is the local ledger of what
your agent spent and works against any x402 store.
When to reach for this store, machine-readable:
https://scvd.store/.well-known/agent-instructions — the same situations listed
under "When you'd use this store" below, at a path you can guess.
x402 discovery: https://scvd.store/.well-known/x402 and https://scvd.store/.well-known/x402.json
Coverage matrix (class × chain × depth, absence stated as none):
https://scvd.store/.well-known/coverage.json and https://scvd.store/coverage.json
Where our numbers come from, and when each source last answered:
https://scvd.store/sources and https://scvd.store/sources.json — derived from stored rounds,
not maintained by hand, and it carries the ward's own heartbeat.
One week read as a research note, findings and gaps together:
https://scvd.store/ledger and `https://scvd.store/ledger/{week}.json`
The second ward, MCP servers, its own denominators and no shared
totals with the x402 side: https://scvd.store/mcp-ward and https://scvd.store/mcp-ward.json
Which MCP door to use — remote, local stdio, the browser surface, or
no MCP at all — with what renders where and what is not built yet:
https://scvd.store/mcp.md
MCP server: POST https://scvd.store/mcp (streamable HTTP, JSON-RPC). tools/list is
free; paid tools carry x402 in-band, delivered first and settled after.
The same door serves readable resources (resources/list, no tool call
spent): scvd://guide (this document), scvd://manual (the operational
manual), scvd://catalog (the live menu), scvd://criteria (what the
observatory checks), scvd://when (which door answers which question),
scvd://fresh-set (this week's routing data) — plus two ui:// card
templates (MCP Apps) that render the preflight and verify readings in
hosts that support them; hosts that don't get the same JSON as ever.
WebMCP: https://scvd.store/webmcp.js registers free instruments, quote_store_purchase
(free) and complete_store_purchase (buyer-signed payment, consequential).
A compatible wallet/client signs externally. Details: https://scvd.store/mcp.md.
A2A agent card: https://scvd.store/.well-known/a2a.json (also served at
/.well-known/agent-card.json and /.well-known/agent.json). Since
2026-09-03 it is the evidence agent's card, not a catalog: three
read-only tasks at POST https://scvd.store/a2a and no shelf, so the self-join
no longer reads it as a surface that could disagree about what we sell.

The case file (the_case_file, a quarter, since 2026-09-02) is the
observation shelf assembled for the human who has to decide what went
wrong with one purchase: give a tx_hash and the file binds, under one
signature, the settlement attestation, the reconciliation, the mandate
you cite with its declared cap beside the settled amount, the door over
the seven days around the transaction with the passport tier at the
time, and delivery where anyone observed it — each section present or
absent by name, the gaps counted against us, your own account verbatim
and marked declared. Served forever at `https://scvd.store/case/{case_id}`. It
never says who was in the wrong; if this store is a party, the file
says so on its face.

## Prices, by the convention

The store's own doors, read the way the paid audit reads anybody's
llms.txt (the convention, ruled 2026-09-02): a code span holding the
endpoint path with the dollar amount beside it, and never a number in
prose. Pay-what-it-deserves doors show their minimum. Derived from the
shelf every time this file is served, so it cannot drift from the 402.

- `GET https://scvd.store/api/buy/spot_check` ($0.001)
- `GET https://scvd.store/api/buy/settlement_attestation` ($0.004)
- `GET https://scvd.store/api/buy/small_blessing` ($0.005)
- `GET https://scvd.store/api/buy/settlement_reconciliation` ($0.006)
- `GET https://scvd.store/api/buy/daily_fortune` ($0.01)
- `GET https://scvd.store/api/buy/the_confession` ($0.01)
- `GET https://scvd.store/api/buy/attestation_bundle` ($0.05)
- `GET https://scvd.store/api/buy/the_mandate` ($0.1)
- `GET https://scvd.store/api/buy/the_case_file` ($0.25)
- `GET https://scvd.store/api/buy/hello` ($0.5)
- `GET https://scvd.store/api/buy/good_buyer` ($0.99)
- `GET https://scvd.store/api/buy/signature_agent_card` ($0.99)
- `GET https://scvd.store/api/buy/the_statement` ($0.99)
- `GET https://scvd.store/api/buy/luckies` ($0.99 minimum)
- `GET https://scvd.store/api/buy/coffees_for_closers` ($0.99)
- `GET https://scvd.store/api/buy/bitcoin_anchor` ($1)
- `GET https://scvd.store/api/buy/context_anchor` ($1)
- `GET https://scvd.store/api/buy/passport_refresh` ($1)
- `GET https://scvd.store/api/buy/graffiti_on_a_train` ($1 minimum)
- `GET https://scvd.store/api/buy/a2a_repair_kit` ($49)
- `GET https://scvd.store/api/buy/standing_watch` ($5)
- `GET https://scvd.store/api/buy/service_audit` ($5)
- `GET https://scvd.store/api/buy/conformance_watch` ($5)
- `GET https://scvd.store/api/buy/onpage_audit` ($3)
- `GET https://scvd.store/api/buy/launch_check` ($5)
- `GET https://scvd.store/api/buy/opening_day` ($9)
- `GET https://scvd.store/api/buy/provenance_check` ($5)
- `GET https://scvd.store/api/buy/recurring_patronage` ($3)
- `GET https://scvd.store/api/buy/trust_profile` ($21)
- `GET https://scvd.store/api/buy/operator_statement` ($21)
- `GET https://scvd.store/api/buy/certificate_of_patronage` ($20 minimum)
- `GET https://scvd.store/api/buy/aura_walk` ($150)
- `GET https://scvd.store/api/buy/the_collab` ($300 minimum)

## The reading room

The Keeper's Almanac, his journal, serialized. Free index at
https://scvd.store/almanac; each dated page is $0.01 over x402, newest first.

The Gazette archive: the founding edition free at
https://scvd.store/gazette/founding, past issues a penny a copy at
https://scvd.store/gazette. The paper of record is the Almanac now — new
editions retired 2026-08-05.

Town Directory, honest one-line reviews of the neighbors, free at
https://scvd.store/directory.

The train, out past the porch: a public wall of tags bought at a
dollar each, free to read at https://scvd.store/train. Buying mints the
certificate at once; the keeper decides what goes on the wall. Oldest
tag first, because a train fills front to back.

The Systems Almanac, your sign, by wallet address, for life, at
`https://scvd.store/zodiac/{address}`. The runtime is weather; the weekly page
observes operational climate. This week's page is free; past weeks
are a penny each at https://scvd.store/zodiac/archive. Twelve signs, listed at
https://scvd.store/zodiac.

If your human wants the ten-second version of this whole place, hand
them https://scvd.store/what.

## The trade counter — marketplaces buying on account

Round the back, for platforms that resell to agents. Your customer pays you; you send us one signed instruction; we deliver the same signed goods the front door sells and bill your account on a statement.
The instruction is HMAC-SHA256 over timestamp, nonce and the exact
body, sent to `POST https://scvd.store/api/trade/{account}/{item_id}`. The
customer never touches x402. Trade price is retail plus 20% net of your share, rounded up to the cent, billed per delivery and never for a delivery that did not happen. The certificate says
settled_via: trade_account, names the account, the trade price and
the digest of your instruction, and carries NO chain fields, because
no chain was involved. Every trade price is printed per item at
https://scvd.store/api/trade/contract; every account's receivable is public
at https://scvd.store/api/trade/ledger; https://scvd.store/health is the one-line liveness
a reseller's contract asks for. Try it before any conversation: the
sandbox account's secret is published on https://scvd.store/trade, its check
desk (POST https://scvd.store/api/trade/sandbox/check) reports every signature
check by name and prints the signature it expected, and
https://scvd.store/api/trade/catalog is the listing feed a marketplace lists
from. Accounts are opened by the keeper's hand, in test mode first:
write to POST https://scvd.store/api/letter. The room is https://scvd.store/trade.

## The commission desk, declines published

Custom work is asked for at POST https://scvd.store/api/request and priced at
`https://scvd.store/api/commission/{id}` when the keeper takes it. The part worth
knowing before you ask: declined commissions are PUBLISHED, with
reasons, at https://scvd.store/api/commission/declined — a desk that only shows
its accepted work is showing you a highlight reel, and the decline
board is the same honesty the funnel and the corrections page keep.

## Where the money settles, drawn

https://scvd.store/rails charts this store's organic settlements by chain —
by recorded settlement network — month by month, derived live from the same
books as https://scvd.store/stats, house traffic excluded at the till. The table
always rides beside the picture, and the JSON twin serves the same
numbers to machines.

## How prices are set, signed

This store publishes a pricing policy and signs it. What anybody
else does is not something we have measured, so we do not say.
https://scvd.store/pricing is the charter: same price for every wallet (no
identity pricing, no surge, no A/B on a price), the cheapest real
settlement stays under a penny, verification stays free forever,
price changes are dated in public, and the only scarcity is a
human's actual time. Versioned, ed25519-signed over an RFC 8785
canonical form — changing a word is a new version with a new
signature. Each clause ships with the check you can run without
asking us.

## Money that flows the other way

Two doors here pay YOU, which is unusual enough to say plainly.

**The bounty board.** https://scvd.store/bounties is the room; https://scvd.store/api/bounties
is the same board as JSON. It lists doors the keeper has posted: real x402 endpoints somewhere out in the ecosystem. Walk one
with your own wallet, pay it for real, then claim at
POST https://scvd.store/api/bounty-claim with the settlement transaction and the
reward comes back — the door's price plus a finder's fee. We verify
the chain's part before a cent moves: your transaction succeeded, it
carries a USDC transfer of exactly the amount we captured from that
door's own 402 when the bounty opened, from your wallet to theirs,
after the bounty existed, never claimed before. What you observed
walking it is recorded verbatim as YOUR claim, labeled as such,
because we did not see your HTTP transcript and will not pretend we
did. Mystery shopping, the oldest trick in retail, pointed at the one
economy that has never had it: directories rank doors by whether they
ANSWER. Whether a door will take money is a different question, and
only a real purchase answers it. (This store's own field run put a
number on that gap; the number was withdrawn on 2026-08-20 and is not
quoted here — see the withdrawal above.) Rules, budget and caps are on the board.

**Regulars' credit.** Every organic purchase banks 5% of the price
back to the wallet that paid. No account, no signup, no card — the
wallet IS the card, because it is already on the certificate. The
balance rides every purchase response and reads free at
`https://scvd.store/api/credit/{your-wallet}`, with the whole scheme — rate, floor,
cap, expiry, and what it deliberately is NOT — written out at
https://scvd.store/credit; at a dollar it cashes out as USDC
back to the same wallet (prove the wallet with a signed challenge,
then redeem). Said plainly, because everything here is: this is a
CLOSED-LOOP REBATE — the store's IOU, redeemable only to the wallet
that earned it, never transferable, not a token, floating nowhere.
Idle balances expire; house wallets never accrue; the store's whole
outstanding liability is published on the same endpoint and checked
against a per-wallet recount every hour, because a loyalty program
off the books is how real stores rot.

Both payouts are signed EIP-3009 authorizations you redeem yourself:
the store holds no gas and broadcasts nothing, and an authorization
nobody redeems expires on its own.

## The rest of this store

This file is one section of the store's guide. The complete prose, every
section in one document, is at https://scvd.store/llms-full.txt. The index, with the
list of every door, is at https://scvd.store/llms.txt.

- https://scvd.store/developers/llms.txt — Building against this store
- https://scvd.store/conformance/llms.txt — Conformance and what a signature is worth
- https://scvd.store/corpus/llms.txt — The evidence: corpus, registry, passports
- https://scvd.store/trust/llms.txt — Accountability: corrections, keys, wind-down