@receiz/ai-skills 102.0.0

package/README.md

@@ -0,0 +1,45 @@
+# Receiz AI Skills
+
+This package teaches AI agents how to understand, verify, build with, and operate Receiz from the existing repository surfaces.
+
+It is published as `@receiz/ai-skills` and is an exact-version dependency of both `@receiz/sdk` and `@receiz/mcp-server`. Installing either package places these eight skill directories under `node_modules/@receiz/ai-skills` for explicit loading by an agent host.
+
+Receiz is a proof-native artifact system. A Receiz object is not a database row. It is a proof-carrying artifact. The artifact's witnessed history is the truth boundary. Server state, database state, UI state, marketplace state, and model memory are projections only. Old witnessed truth is not stale. If a projection is wrong, rebuild it from object history. If truth is missing, append new truth. Never mutate witnessed truth.
+
+## SDK, MCP, And Skills
+
+- SDK: `@receiz/sdk` is for building apps. It exposes validators, projections, proof memory, identity artifact helpers, public app-state, public store, commerce, wallet, sports, world, offline queues, webhooks, and sandbox helpers.
+- MCP: `@receiz/mcp-server` is for agent tool access. It exposes SDK-backed tools for diagnostics, public reads, offline shape inspection, app-state/public-store actions, deterministic previews, and delegated writes. Artifact verification remains SDK `verification.verifyArtifact(file)` and requires continuity.
+- Skills: this package is operating doctrine. It tells an AI which Receiz primitive is active, which source of truth wins, which SDK or MCP rail to use, and what must never be assumed.
+
+Agents may acquire scoped delegated access through the official Receiz Connect/OIDC Authorization Code + PKCE flow or through the MCP delegated-agent setup path exposed by `receiz_mcp_login`. That acquired access is permission to call scoped SDK/MCP rails after user consent. It is not proof authority and must never outrank artifact truth.
+
+## How Agents Should Use This Package
+
+Start with `receiz-skill-bundle` when the request spans multiple Receiz domains. Use `receiz-proof-skill` for any verification, proof object, vault, profile, pack, card, post, product, listing, receipt, marketplace, or offline artifact question. Use narrower skills only after the primitive is named.
+
+Do not invent APIs. Use the SDK and MCP maps inside the skills, then inspect the repo when a requested operation is not listed.
+
+## Developer Install Or Reference
+
+Install `@receiz/sdk`, `@receiz/mcp-server`, or `@receiz/ai-skills` directly. Reference `node_modules/@receiz/ai-skills` from an agent host, or copy the individual skill folders into an agent skill directory. Keep the package together when possible because the router skill depends on the domain skills.
+
+When SDK or MCP changes:
+
+1. Inspect `packages/receiz-sdk/src/index.ts`, `packages/receiz-sdk/src/identity.ts`, `packages/receiz-sdk/src/react.ts`, and `packages/receiz-mcp-server/src/index.ts`.
+2. Update `receiz-proof-skill/resources/sdk-reference.md` and both MCP tool maps.
+3. Update domain skills only when the changed rail affects their primitive.
+4. Run `pnpm validate:ai-skills`.
+5. Run package tests when the SDK or MCP behavior changed.
+
+## Safety Boundaries
+
+- Verify before claiming.
+- Never invent ownership, witness IDs, rarity, transfer history, verification status, proof IDs, append IDs, or settlement state.
+- Never treat a database, server, marketplace, UI, model response, or cache as final authority.
+- Never mutate witnessed history.
+- Append new truth only.
+- If a view is wrong, rebuild the projection from witnessed history.
+- If history is missing, append the missing truth.
+- Generated apps must preserve Receiz proof semantics.
+- Generated apps should not require a traditional database unless the user explicitly asks for one.

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@receiz/ai-skills",
+  "version": "102.0.0",
+  "description": "Authoritative Receiz AI operating skills for proof-native SDK and MCP agents.",
+  "type": "module",
+  "files": [
+    "README.md",
+    "receiz-builder-skill",
+    "receiz-commerce-skill",
+    "receiz-distribution-skill",
+    "receiz-mcp-agent-skill",
+    "receiz-offline-verifier-skill",
+    "receiz-proof-skill",
+    "receiz-skill-bundle",
+    "receiz-sports-card-skill"
+  ],
+  "keywords": [
+    "receiz",
+    "ai",
+    "agent",
+    "skills",
+    "proof",
+    "continuity",
+    "mcp",
+    "sdk"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/receiz-builder-skill/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: receiz-builder-skill
+description: Use when an agent must build or modify Receiz-native apps, storefronts, marketplaces, proof pages, pack apps, profile vaults, claim flows, QR entry flows, templates, or custom domain apps with the Receiz SDK.
+---
+
+# receiz-builder-skill
+
+Build Receiz apps from proof objects, durable public projections, proof memory, identity primitives, and append-only sync. Do not downgrade Receiz into a CRUD app.
+
+## When To Use This Skill
+
+- Use for no-db storefronts, product pages, marketplaces, pack opening apps, profile vaults, proof pages, claim flows, QR entry flows, custom domains, subdomains, and template apps.
+- Use when generating app code that imports `@receiz/sdk` or `@receiz/sdk/react`.
+- Use when an AI must choose SDK rails for public store, app state, checkout, media, identity, wallet, sports, or offline queues.
+
+## When Not To Use This Skill
+
+- Do not use as the only verifier for an existing object. Use `receiz-proof-skill` first.
+- Do not use to call MCP tools directly. Use `receiz-mcp-agent-skill`.
+- Do not use to invent app backend tables when Receiz public store, app-state projection, proof memory, or signed publish already satisfies the behavior.
+
+## Core Receiz Laws
+
+- A generated Receiz app must not downgrade Receiz into a normal CRUD app.
+- The app may use projections, caches, and UI state, but the proof object remains the authority.
+- Generated apps should not require a traditional database unless the user explicitly asks for one.
+- Never treat a database, server, marketplace, UI, model response, or cache as final authority.
+- SDK is for building. MCP is for agent tool access. Skills are operating doctrine.
+- If known verified truth exists, first-paint it and ask only for verified additions after the known head.
+
+## Required Behavior
+
+1. Identify the primitive the app carries: proof, identity, ownership, settlement, public proof, store, pack, profile, or offline verification.
+2. Select SDK rails from [resources/sdk-quickstart.md](resources/sdk-quickstart.md).
+3. First-paint public store/app-state/proof memory before background sync.
+4. Use `publicStore.resolve` for cold storefront recovery.
+5. Use `publicStore.publishWithIdentityProof` when merchant proof owns the publish boundary.
+6. Use delegated writes only for agent/server tasks that need delegated permission.
+7. Keep generated code rules from [resources/generated-code-rules.md](resources/generated-code-rules.md).
+
+## Forbidden Behavior
+
+- Do not make DB rows the canonical product, order, proof, receipt, card, profile, or ownership truth.
+- Do not add a new verifier, issuer, token, signature, or registry before reusing implemented Receiz primitives.
+- Do not block deterministic first paint on session lookup, DB refresh, global sync, or marketplace reconstruction when public proof truth is available.
+- Do not call durable proof memory a cache.
+- Do not hide verify links, source links, owner/custody state, or proof rows.
+
+## MCP Usage Rules
+
+MCP is optional for app building. Use it to inspect capabilities, required scopes, runtime blueprints, public store state, and templates when a live MCP host is available. Never hallucinate unavailable MCP tools. See `receiz-mcp-agent-skill` for tool execution and confirmation rules.
+
+## SDK Usage Rules
+
+Use `createReceizClient`, `publicStore.resolve`, `publicStore.publish`, `publicStore.publishWithIdentityProof`, `appState.resolve`, `appState.publish`, `proofMemory`, `identity.ensureTenantSession`, `commerce.oneClickCheckout`, `media.upload`, `wallet.publicLedger`, `sports.resolveCardMemory`, `offline.createQueue`, and React helpers from `@receiz/sdk/react` as needed. See [resources/sdk-quickstart.md](resources/sdk-quickstart.md).
+
+## Output Format
+
+For generated apps, end with:
+
+```md
+Primitive carried:
+Source of truth:
+SDK rails used:
+MCP rails used:
+First-paint plan:
+Append/enrichment plan:
+No-db boundary:
+User confirmation needed:
+Checks to run:
+```
+
+## Safety And Security Boundaries
+
+Do not print tokens, passphrases, private keys, or private identity artifact contents. Do not execute settlement, transfer, publish, or public-state write actions without explicit user confirmation. Keep access tokens as delegated permissions beneath identity proof, not proof authority.
+
+## Examples
+
+- [Create storefront](examples/create-storefront.md)
+- [Create marketplace](examples/create-marketplace.md)
+- [Create proof page](examples/create-proof-page.md)
+- [Create pack app](examples/create-pack-app.md)
+- [Create profile vault](examples/create-profile-vault.md)
+
+Resources:
+
+- [SDK quickstart](resources/sdk-quickstart.md)
+- [App patterns](resources/app-patterns.md)
+- [No-db pattern](resources/no-db-pattern.md)
+- [Proof-native UI patterns](resources/proof-native-ui-patterns.md)
+- [Deployment checklist](resources/deployment-checklist.md)
+- [Generated code rules](resources/generated-code-rules.md)

package/receiz-builder-skill/examples/create-marketplace.md

@@ -0,0 +1,10 @@
+# Create Marketplace
+
+Use marketplace as a public projection over proof objects, ownership state, settlement state, and store/product records.
+
+Minimum flow:
+
+1. Resolve public app-state or public-store listings.
+2. Render item identity, media, owner/custody, value/settlement, verify link.
+3. Use proof query or public proof reads for enrichment.
+4. Require confirmation before transfer, purchase, settlement, or listing writes.

package/receiz-builder-skill/examples/create-pack-app.md

@@ -0,0 +1,12 @@
+# Create Pack App
+
+Pack preview is not pack truth. Build separate states:
+
+- preview
+- issued pack
+- opened pack
+- claimed card outputs
+- verified receipt
+- failed or missing proof
+
+Use deterministic preview for UX. Append or admit proof only after receipt verification or existing Sports pack rails confirm the issued state.

package/receiz-builder-skill/examples/create-profile-vault.md

@@ -0,0 +1,5 @@
+# Create Profile Vault
+
+Render profile vault objects from proof memory, public proof rails, or canonical profile proof state. Each object remains a proof object with identity, ownership/custody, provenance, media, and verification.
+
+Do not flatten the vault into generic cards. Add filters, search, and sorting beneath proof truth.

package/receiz-builder-skill/examples/create-proof-page.md

@@ -0,0 +1,5 @@
+# Create Proof Page
+
+A proof page first-paints a proof object, not a marketing hero. It should include object identity, proof status, verify link, provenance, media, owner/custody if known, witness history, transfer state, and safe actions.
+
+Use `projectReceizAssetManifest` or `projectReceizSportsCardManifest` after validation. Use `publicProof.byUrl` or `publicProof.byId` for public proof enrichment.

package/receiz-builder-skill/examples/create-storefront.md

@@ -0,0 +1,5 @@
+# Create Storefront
+
+Use `publicStore.resolve({ host })` for cold first paint. Render `storeStateRecord` as the public storefront. For edits, publish through `publicStore.publishWithIdentityProof` when a merchant identity artifact is available, otherwise use delegated `publicStore.publish` only after confirmation.
+
+Do not add a database unless requested. If requested, make it an index beneath public store proof truth.

package/receiz-builder-skill/resources/app-patterns.md

@@ -0,0 +1,29 @@
+# App Patterns
+
+## No-Db Storefront
+
+1. Resolve public store by host.
+2. Render the returned `storeStateRecord` immediately.
+3. Show proof, product, media, seller, and claim affordances from the record.
+4. Let admin save publish a new public-store append.
+5. Store the known append head when returned.
+
+## Product Page
+
+Use a product proof object or public-store product record as the first paint. Link to verify/source material. Do not prove ownership or stock from the visual product tile alone.
+
+## Marketplace
+
+A marketplace is a projection over proof objects, ownership state, settlement state, and public store state. Use public reads and proof query for discovery, but keep object verification available per item.
+
+## Pack Opening App
+
+Preview may be deterministic. Issuance requires verified pack receipt, pack ID, reward lane, card claims, and append state. Do not issue cards from preview alone.
+
+## Profile Vault
+
+Render owned proof objects as proof objects. Preserve custody, transfer, certify, inspect, sell, verify, share, and source affordances. Do not call the vault a content grid.
+
+## QR Entry Flow
+
+QR routes should carry claim or proof entry. They can open the app, resolve a proof object or pack route, and ask the user to confirm claim/open actions before appending truth.

package/receiz-builder-skill/resources/deployment-checklist.md

@@ -0,0 +1,13 @@
+# Deployment Checklist
+
+Use this before claiming a Receiz app is ready.
+
+- Run the generated app build and lint checks.
+- Run Receiz SDK local conformance when SDK proof handling changed.
+- Run `receiz doctor` or the SDK `doctor()` rail for tenant wiring when app setup is in scope.
+- Confirm public store/app-state first paint resolves without a private session when the surface is public.
+- Confirm delegated actions require explicit user confirmation where they append, publish, transfer, or settle.
+- Confirm no generated database table is treated as final authority.
+- Confirm verify links, source links, ownership/custody state, and proof rows remain visible.
+- Confirm offline or local proof routes project known truth before sync.
+- Confirm failure states say what is missing and never claim proof that did not verify.

package/receiz-builder-skill/resources/generated-code-rules.md

@@ -0,0 +1,27 @@
+# Generated Code Rules
+
+## Must Do
+
+- Import from public SDK exports only.
+- Keep SDK responses typed as projections unless the underlying proof object or append is verified.
+- Use idempotency keys for retryable writes.
+- Ask for explicit confirmation before writes, transfers, settlement actions, public publishes, or proof appends.
+- Preserve verify/source links and proof object identity in UI.
+- Keep durable proof memory scoped by owner, app, route, or tenant.
+- Use public store/app-state rails for no-db storefronts.
+
+## Must Not Do
+
+- Do not call private SDK helpers or raw internal API routes when a client method exists.
+- Do not invent schemas, tool names, issuers, rarity levels, ownership states, or receipt IDs.
+- Do not create a parallel auth model that downgrades Receiz ID, PBI, Receiz Key, Identity Record, or Identity Seal.
+- Do not make UI cache, React state, database rows, or model memory final authority.
+- Do not hide verification behind a preview or share page.
+
+## Generated Output Must Say
+
+- which primitive is carried
+- which SDK rails are used
+- what remains unverified
+- what requires a live bearer token or user confirmation
+- which checks were run

package/receiz-builder-skill/resources/no-db-pattern.md

@@ -0,0 +1,34 @@
+# No-Db Pattern
+
+Receiz apps can use public proof rails and durable app-state projections without a traditional app database.
+
+## Correct Shape
+
+```txt
+public store/app-state projection -> first paint
+proof object or identity proof -> authority
+SDK publish rail -> append new projection
+known head -> ask only for verified additions
+```
+
+## When A Database Is Allowed
+
+A database may index, search, cache, or decorate proof truth when the user explicitly asks for one or the app needs lower-authority operational data. It must not become final authority over proof, ownership, settlement, profile, product, receipt, card, pack, or verification truth.
+
+## Write Path
+
+If a user edits a storefront or product:
+
+1. Build the new store state.
+2. Sign with merchant identity proof when available, or use delegated publish for agent/server operation.
+3. Publish through Receiz public-store/app-state rails.
+4. Save returned append coordinates or known head.
+5. Re-render from the returned projection or next resolved public state.
+
+## Forbidden Shape
+
+```txt
+form submit -> DB row -> UI says product exists -> proof added later
+```
+
+The Receiz shape appends proof-native truth or public projection first, then weaker indexes mirror it.

package/receiz-builder-skill/resources/proof-native-ui-patterns.md

@@ -0,0 +1,29 @@
+# Proof-Native UI Patterns
+
+## First Paint
+
+Paint the strongest known proof or public projection immediately. Do not show loading theater for truth already carried by local proof memory, artifact bytes, public store state, or deterministic fixtures.
+
+## Object Surface
+
+Every proof object display should expose:
+
+- object identity
+- proof or verify affordance
+- owner/custody when known
+- provenance or source
+- media or payload
+- append or history summary
+- safe actions
+
+## Storefront Surface
+
+Storefronts should show products as proof-carrying objects or product projections with verification path. Checkout may use wallet-first funding, card fallback, and receipt proof, but the proof object remains the authority.
+
+## Profile Vault Surface
+
+Vault items are artifact objects. Use direct labels: proof object, ownership, custody, provenance, settlement, transfer, certificate, verification.
+
+## Background Work
+
+Background sync may append additions, warm routes, upload media, publish records, or refresh projections. It must not replace the settled shell or demote proof truth to UI state.

package/receiz-builder-skill/resources/sdk-quickstart.md

@@ -0,0 +1,68 @@
+# SDK Quickstart
+
+Use the SDK through public exported APIs.
+
+## Build Client
+
+Use `createReceizClient({ baseUrl, accessToken, fetchImpl })` when you need a typed client. Public reads can run without delegated access when the rail is public. Delegated actions require a Receiz-issued bearer token from Connect/OIDC.
+
+## Public Store
+
+- Publish delegated store state: `receiz.publicStore.publish({ tenantHost, merchantReceizId, state, title })`
+- Publish merchant proof-owned state: `receiz.publicStore.publishWithIdentityProof({ keyFile, tenantHost, merchantReceizId, storeStateRecord })`
+- Recover latest public storefront: `receiz.publicStore.resolve({ host })`
+- Check signed publish contract: `receiz.publicStore.assertSignedPublishContract(...)`
+
+## App State
+
+- `receiz.appState.publish(...)`
+- `receiz.appState.publishRecord(...)`
+- `receiz.appState.resolve(...)`
+- `receiz.appState.byUrl(...)`
+- `receiz.appState.byCreator(...)`
+- `receiz.appState.byNamespace(...)`
+- `receiz.appState.byId(...)`
+- `receiz.appState.restoreByHost(...)`
+
+## Proof Memory
+
+- `createReceizProofMemory`
+- `createReceizLocalStorageProofMemoryStorage`
+- `createReceizInMemoryProofMemoryStorage`
+- `receiz.proofMemory.syncAdditions`
+- `receiz.runtime.localFirst`
+
+## Identity
+
+- `createReceizIdIdentity`
+- `readReceizIdentityArtifact`
+- `projectReceizIdentityAccount`
+- `signReceizIdentityLoginProof`
+- `verifyReceizIdentityLoginProof`
+- `identity.ensureTenantSession`
+- `identity.authorizeUrl`
+
+## Commerce And Media
+
+- `commerce.oneClickCheckout`
+- `media.upload`
+- `media.transform`
+- `wallet.publicLedger`
+- `wallet.resolveLedger`
+- `events.subscribe`
+- `proof.query`
+
+## React Subpath
+
+Use `@receiz/sdk/react` for UI convenience:
+
+- `useReceizIdentity`
+- `useReceizCheckout`
+- `useReceizAppState`
+- `useReceizMedia`
+- `ReceizIdentityButton`
+- `ReceizCheckoutButton`
+- `ReceizWalletBalance`
+- `ReceizMediaUploader`
+- `ReceizDomainConnector`
+- `ReceizTwinWriter`

package/receiz-commerce-skill/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: receiz-commerce-skill
+description: Use when an agent must create, explain, inspect, or verify Receiz commerce surfaces, product proof objects, storefronts, no-database stores, checkout boundaries, buyer/seller language, product ownership, or receipt proof.
+---
+
+# receiz-commerce-skill
+
+Receiz commerce is proof-native commerce. A product page, storefront, order view, receipt, certificate, note, or resale route must preserve product proof, ownership state, settlement state, and public proof surfaces.
+
+## When To Use This Skill
+
+- Use for product proof pages, storefronts, marketplace listings, checkout explanations, buyer/seller copy, no-database stores, receipt proof, and ownership verification.
+- Use when an agent is asked to build a commerce app with the Receiz SDK or MCP tools.
+- Use before writing purchase, transfer, certificate, note, receipt, or seller-facing language.
+
+## When Not To Use This Skill
+
+- Do not use this as the only verifier for a raw artifact. Use `receiz-proof-skill` first when the object itself has not been verified.
+- Do not use this for sports card memory rules. Use `receiz-sports-card-skill` for live-event card logic.
+- Do not use this to execute checkout, transfer, or settlement actions without `receiz-mcp-agent-skill` confirmation rules.
+
+## Core Receiz Laws
+
+- Commerce objects are proof objects with product, ownership, provenance, media, and settlement boundaries.
+- A storefront projection is weaker than the product proof object it presents.
+- A buyer receives a proof-bearing object or receipt boundary, not a generic order row.
+- A seller presents ownership, custody, and transfer conditions directly.
+- Never treat a database, server, marketplace, UI, model response, or cache as final authority.
+- Settlement language must distinguish purchase route, funded event, certificate value, note value, reserve state, and display price.
+- Read [resources/commerce-object-model.md](resources/commerce-object-model.md) before generating commerce behavior.
+
+## Required Behavior
+
+1. Name the product primitive: proof object, ownership surface, settlement primitive, public proof surface, certificate, note, receipt, or storefront projection.
+2. Verify the product object or public proof URL before making ownership or provenance claims.
+3. Separate product proof from checkout mechanics and receipt projection.
+4. Use no-database patterns only when artifact truth and SDK/MCP rails remain the source of truth.
+5. Use buyer and seller language from [resources/seller-buyer-language.md](resources/seller-buyer-language.md).
+6. Preserve explicit confirmation before checkout, transfer, certificate, note, or receipt append actions.
+
+## Forbidden Behavior
+
+- Do not call a product proof object merely a listing, card, catalog item, SKU, or content record.
+- Do not treat checkout completion as stronger than sealed artifact truth or verified receipt proof.
+- Do not invent ownership, price, seller authority, buyer custody, or transfer status.
+- Do not build a storefront that requires a database before showing known verified product truth.
+- Do not imply that marketplace visibility proves ownership.
+
+## MCP Usage Rules
+
+Use MCP read tools to resolve and inspect product proof first: `receiz_asset_by_url`, `receiz_asset_by_id`, `receiz_inspect_proof_object`, and `receiz_public_store_resolve`. Resolution and inspection are not verification. Use SDK `verification.verifyArtifact(file)` for the integrity-and-continuity verdict. Use `receiz_public_store_publish`, `receiz_sandbox_seed_store`, or `receiz_sandbox_checkout` only when the user explicitly asks for a write or sandbox action and confirms the exact inputs. See [resources/product-proof-flow.md](resources/product-proof-flow.md).
+
+## SDK Usage Rules
+
+Use `createReceizClient` and the commerce, public store, verification, app state, payments, and connect rails. Prefer `receiz.publicStore.resolve`, `receiz.publicStore.publish`, `receiz.verification.verifyArtifact`, `receiz.connect.checkout`, `receiz.connect.checkoutSession`, `receiz.commerce`, `receiz.payments`, `assertReceizAssetManifest`, and `projectReceizAssetManifest` as documented in [resources/storefront-patterns.md](resources/storefront-patterns.md).
+
+## Output Format
+
+Use this structure for commerce answers:
+
+```md
+## Commerce Proof Surface
+Object:
+Commerce primitive:
+Source of truth:
+Product proof:
+Ownership / custody:
+Seller claim:
+Buyer action:
+Settlement boundary:
+Receipt or certificate boundary:
+What is proven:
+What is not proven:
+Safe next action:
+```
+
+## Safety And Security Boundaries
+
+Checkout, transfer, certificate issue, note issue, receipt append, seller onboarding, payment, and refund actions are value-affecting. They require explicit confirmation, scoped delegated access, and the existing Receiz rail. Never print bearer tokens, payment credentials, private keys, private identity files, or hidden recovery material.
+
+## Examples
+
+- [Create product page](examples/create-product-page.md)
+- [Create no-database store](examples/create-no-db-store.md)
+- [Verify product ownership](examples/verify-product-ownership.md)
+- [Explain Receiz commerce](examples/explain-receiz-commerce.md)
+
+Load resources as needed:
+
+- [Commerce object model](resources/commerce-object-model.md)
+- [Product proof flow](resources/product-proof-flow.md)
+- [Storefront patterns](resources/storefront-patterns.md)
+- [Order and receipt boundaries](resources/order-and-receipt-boundaries.md)
+- [Seller buyer language](resources/seller-buyer-language.md)
+- [Conversion copy patterns](resources/conversion-copy-patterns.md)

package/receiz-commerce-skill/examples/create-no-db-store.md

@@ -0,0 +1,15 @@
+# Create No-Database Store
+
+Use public proof and public store state as the source of rendered products.
+
+## Agent Steps
+
+1. Use `receiz.publicStore.resolve` or `receiz_public_store_resolve`.
+2. Verify product proof objects referenced by the store projection.
+3. Render deterministic product shells from verified truth.
+4. Use background sync only to append verified additions.
+5. Do not introduce a database as product authority.
+
+## Required Statement
+
+State that the store is no-database because product truth lives in Receiz proof objects and public store append rails.

package/receiz-commerce-skill/examples/create-product-page.md

@@ -0,0 +1,25 @@
+# Create Product Page
+
+Use `receiz-commerce-skill` with `receiz-proof-skill`.
+
+## Agent Steps
+
+1. Resolve the product proof object with `receiz_asset_by_url` or SDK verification.
+2. Name the commerce primitive and source of truth.
+3. Build the page around proof identity, product media, provenance, ownership, price display, and purchase action.
+4. Put checkout behind explicit confirmation.
+5. Show receipt proof status after a purchase rail returns proof.
+
+## Output Shape
+
+```md
+## Product Page Plan
+Proof identity:
+Product media:
+Ownership:
+Provenance:
+Settlement boundary:
+Receipt boundary:
+SDK rails:
+MCP rails:
+```

package/receiz-commerce-skill/examples/explain-receiz-commerce.md

@@ -0,0 +1,14 @@
+# Explain Receiz Commerce
+
+Receiz commerce sells proof-bearing objects. The product object, ownership state, provenance, receipt proof, and settlement route remain legible outside a single storefront.
+
+## Explanation Pattern
+
+```md
+Receiz commerce is proof-native commerce:
+- Products are proof objects.
+- Storefronts project verified product truth.
+- Buyers inspect proof before value moves.
+- Receipts, certificates, and notes carry their own proof boundaries.
+- Servers and marketplaces help route actions, but they do not outrank artifact truth.
+```

package/receiz-commerce-skill/examples/verify-product-ownership.md

@@ -0,0 +1,20 @@
+# Verify Product Ownership
+
+## Agent Steps
+
+1. Identify the product proof identity.
+2. Inspect artifact proof and ownership surface.
+3. Compare seller claim to current custody or owner state.
+4. Report proven and unproven ownership separately.
+5. Refuse to confirm sale authority when ownership is absent.
+
+## Output
+
+```md
+Product:
+Proof identity:
+Current owner / custody:
+Seller claim:
+Ownership status:
+Safe buyer action:
+```

package/receiz-commerce-skill/resources/commerce-object-model.md

@@ -0,0 +1,44 @@
+# Commerce Object Model
+
+Receiz commerce objects are proof-native artifacts projected into commerce surfaces.
+
+## Required Fields To Name
+
+- Object identity: deterministic proof identity, public proof URL, artifact ID, or manifest identity.
+- Product identity: product name, media, description, and included proof payload.
+- Ownership or custody: current owner, seller, custody state, or absent proof.
+- Provenance: origin, creator, chain, public witness, register append, or artifact history.
+- Settlement boundary: purchase route, funded state, certificate value, note issue value, reserve state, or display price.
+- Receipt boundary: proof of purchase, certificate, note, or receipt artifact.
+
+## Truth Order
+
+1. Sealed artifact truth or embedded proof.
+2. Deterministic proof object state.
+3. Verified local truth or durable local projection.
+4. Verified register append.
+5. Authenticated snapshot.
+6. Server append and public store state.
+7. Database, session, UI, or market projection.
+
+When conflict appears, report the stronger proof first and mark the weaker projection as inconsistent.
+
+## Language
+
+Use direct language:
+
+- Product proof object
+- Ownership surface
+- Receipt proof
+- Public proof surface
+- Settlement route
+- Certificate value
+- Note issue route
+- Verified product projection
+
+Avoid generic language as product truth:
+
+- Generic listing
+- Plain SKU
+- Cart item as final authority
+- Backend order as final authority