@receiz/ai-skills 102.0.0

package/receiz-proof-skill/resources/output-templates.md

@@ -0,0 +1,56 @@
+# Output Templates
+
+## Verified Object
+
+```md
+## Verified Object
+Object:
+Status:
+Identity:
+Current controller / owner:
+Proof present:
+Witness history:
+Provenance:
+Media:
+Transfer state:
+What is proven:
+What is not proven:
+Safe next action:
+```
+
+## Tool Failure
+
+```md
+## Verification Boundary
+Object:
+Attempted tool or SDK rail:
+Result:
+What can be stated from available data:
+What cannot be stated:
+Required next evidence:
+```
+
+## Missing Truth
+
+```md
+## Missing Truth
+Primitive:
+Expected evidence:
+Available evidence:
+Missing evidence:
+Safe next action:
+Append path, if the user confirms:
+```
+
+## Offline Report
+
+```md
+## Offline Proof
+Artifact:
+Local verifier:
+Proof status:
+Strongest truth:
+Projection:
+Server dependency:
+What remains unverified:
+```

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

@@ -0,0 +1,30 @@
+# Proof Object Model
+
+## Required Shape
+
+A Receiz proof object carries enough structure to be inspected or recomputed without letting a weaker layer become authority.
+
+Core fields and evidence may include:
+
+- deterministic identity such as asset ID, collectible ID, proof ID, claim hash, witness ID, or Receiz ID
+- sealed payload, proof bundle, manifest, signature, hash, wireproof, or integrity material
+- provenance, source snapshot, owner/custody, or chain state
+- media or attached payload
+- append, transfer, settlement, event, or verification history
+- Kai/Klok coordinate such as `kaiPulseEternal`, `kai_upulse`, or known proof head
+- verify URL, inspect behavior, local validator, or offline verifier
+
+## Implemented SDK Payloads
+
+- `receiz.asset_manifest.v1`: asset ID, asset type, `receiz.proof_bundle`, owner, media, appends, settlement, links.
+- `receiz.sports_arena.card_manifest.v1`: sport, collectible ID, claim hash, card, ownership, value basis, append summary, event proof summary, links.
+- `receiz.webhook_event.v1`: delivery envelope for append, transfer, score, event proof, wallet, note, market, or profile visibility events. Verify the underlying proof object before treating the event as product truth.
+- `receiz.sdk.proof_register.v1`: admitted local proof memory with a known head for append-only sync.
+
+## Projection Rule
+
+Projection is display preparation. It is not proof authority. Use projectors to render rows, title, media, owner label, value, score, append counts, and verify links after validation.
+
+## Subpayload Rule
+
+When a subpayload is embedded inside a stronger artifact, verify the stronger artifact first. A subpayload hash validates deterministic projection only. Ownership, access, transfer, settlement, and public proof bind to the enclosing stronger primitive unless Receiz law defines the subpayload as its own sealed proof object.

package/receiz-proof-skill/resources/receiz-laws.md

@@ -0,0 +1,41 @@
+# Receiz Laws For Proof Work
+
+## Central Law
+
+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.
+
+## Truth Ladder
+
+1. Receiz law and product invariants
+2. Sealed artifact truth / embedded proof
+3. Deterministic proof object state
+4. Verified local truth / durable local truth
+5. Verified register block / verified append
+6. Authenticated snapshot
+7. Server append / global sync
+8. DB/session state
+9. UI cache / temporary render state
+10. External references for mechanics only
+11. Generic app convention
+
+## Non-Negotiables
+
+- Verify before claiming.
+- Name implemented primitives directly.
+- Never invent ownership, witness IDs, rarity, transfer history, or verification status.
+- Never mutate witnessed history.
+- Append new truth only.
+- Treat durable local truth as admitted proof, not cache.
+- Treat offline verification as a primitive, not degraded mode.
+- Treat MCP and SDK responses as tooling or projection beneath proof truth.
+
+## Repo Sources To Inspect
+
+- `AGENTS.md`
+- `docs/receiz-reasoning-kernel.md`
+- `docs/reality-grade-systems-kernel.md`
+- `docs/invariant-first-kernel.md`
+- `docs/chronos-causality-kai-time-kernel.md`
+- `docs/offline-verified-register.md`
+- `packages/receiz-sdk/README.md`
+- `packages/receiz-mcp-server/README.md`

package/receiz-proof-skill/resources/sdk-reference.md

@@ -0,0 +1,80 @@
+# SDK Reference For Proof Work
+
+Source: `packages/receiz-sdk/src/index.ts`, `packages/receiz-sdk/src/identity.ts`, `packages/receiz-sdk/src/react.ts`, and SDK package docs.
+
+## Core Constants And Schemas
+
+- `RECEIZ_SDK_VERSION`
+- `RECEIZ_SCHEMAS`
+- `RECEIZ_ASSET_MANIFEST_SCHEMA`
+- `RECEIZ_SPORTS_CARD_MANIFEST_SCHEMA`
+- `RECEIZ_WEBHOOK_EVENT_SCHEMA`
+- `RECEIZ_APP_STATE_FEED_SCHEMA`
+- `RECEIZ_PUBLIC_STORE_STATE_FEED_SCHEMA`
+- `RECEIZ_PUBLIC_STORE_STATE_PROJECTION_SCHEMA`
+
+## Validators And Projectors
+
+- `assertReceizProofBundle`
+- `isReceizProofBundle`
+- `assertReceizAssetManifest`
+- `isReceizAssetManifest`
+- `assertReceizSportsCardManifest`
+- `isReceizSportsCardManifest`
+- `assertReceizWebhookEvent`
+- `isReceizWebhookEvent`
+- `projectReceizAssetManifest`
+- `projectReceizSportsCardManifest`
+- `assertReceizProofRegisterSnapshot`
+
+## Proof Memory
+
+- `createReceizProofRegister`
+- `createReceizProofMemory`
+- `createReceizInMemoryProofMemoryStorage`
+- `createReceizLocalStorageProofMemoryStorage`
+- `receizProofMemoryAdditionsQuery`
+- `receiz.proofMemory.syncAdditions`
+
+Use proof memory as admitted truth. It is not cache.
+
+## Client Rails
+
+- `createReceizClient`
+- `receiz.verification.verifyArtifact(file)`
+- `receiz.publicProof.byUrl(url)`
+- `receiz.publicProof.byId(id)`
+- `receiz.publicProof.byCreator(receizId)`
+- `receiz.appState.publish(...)`
+- `receiz.appState.resolve(...)`
+- `receiz.publicStore.publish(...)`
+- `receiz.publicStore.resolve(...)`
+- `receiz.publicStore.publishWithIdentityProof(...)`
+- `receiz.wallet.publicLedger(...)`
+- `receiz.sports.conformance()`
+- `receiz.sports.resolveCardMemory(...)`
+- `receiz.sports.resolvePitchDayProof(...)`
+
+## Identity Proof Helpers
+
+- `createReceizIdIdentity`
+- `readReceizIdentityArtifact`
+- `projectReceizIdentityAccount`
+- `signReceizIdentityLoginProof`
+- `verifyReceizIdentityLoginProof`
+- `buildReceizIdContinueRequest`
+- `appendReceizIdentityArtifactTrailerToPng`
+- `serializeReceizIdentityArtifact`
+
+## Local CLI
+
+- `receiz inspect <path-to-proof-json>`
+- `receiz conformance`
+- `receiz init <target-dir>`
+- `receiz doctor`
+- `receiz dev`
+- `receiz deploy-check`
+- `receiz seed-store`
+- `receiz simulate-checkout`
+
+The CLI uses SDK validators, projections, and proof memory. It is not a separate authority.

package/receiz-proof-skill/resources/verification-flow.md

@@ -0,0 +1,38 @@
+# Verification Flow
+
+## Local Artifact Or Manifest
+
+1. Preserve the original bytes or JSON payload.
+2. Identify the claimed schema or primitive.
+3. For artifact bytes, use `receiz.verification.verifyArtifact(file)` when available.
+4. For JSON manifests, use the SDK validators:
+   - `assertReceizAssetManifest`
+   - `assertReceizSportsCardManifest`
+   - `assertReceizWebhookEvent`
+5. Project with SDK projectors only after validation.
+6. Admit valid proof objects into `ReceizProofMemory`.
+7. Use `knownHead()` or `receizProofMemoryAdditionsQuery()` for append-only sync.
+
+## MCP Verification
+
+Use MCP when the agent host exposes Receiz MCP tools:
+
+- `receiz_inspect_offline_file`: inspect a local manifest or proof payload shape; always returns `verified: false`.
+- `receiz_asset_by_url` / `receiz_asset_by_id`: resolve public proof records; resolution is not artifact verification.
+- SDK `verification.verifyArtifact(file)`: verify enclosing integrity plus ownership continuity.
+- `receiz_asset_by_url` and `receiz_asset_by_id`: read public proof surfaces.
+- `receiz_inspect_proof_object`: inspect provided payload structure without claiming final verification.
+- `receiz_card_history`: resolve Sports card memory from local-first SDK rails.
+- `receiz_pitch_proof_by_witness_id`: resolve a pitch witness from already-admitted local day-proof truth.
+
+## Report Boundary
+
+Every report must state:
+
+- what was verified
+- what was only inspected
+- what source of truth was used
+- what remains unknown
+- what tool or artifact is required to resolve the unknown
+
+If a tool fails, do not claim verification happened.

package/receiz-skill-bundle/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: receiz-skill-bundle
+description: Use when an agent needs the complete Receiz skill router for choosing proof, builder, MCP agent, commerce, sports card, offline verifier, or distribution skills in one task.
+---
+
+# receiz-skill-bundle
+
+Use this bundle as the top-level router. It does not replace the specialized skills; it selects them and preserves canonical Receiz language across combined tasks.
+
+## When To Use This Skill
+
+- Use when a task spans verification, app building, MCP tool use, commerce, sports cards, offline proof, and distribution.
+- Use when an agent needs to decide which Receiz skill should run first.
+- Use when user language is broad, such as "understand Receiz end to end" or "build with the full power of Receiz."
+
+## When Not To Use This Skill
+
+- Do not use as the only skill when a specific object must be verified. Route to `receiz-proof-skill`.
+- Do not use as the only skill when live MCP calls are required. Route to `receiz-mcp-agent-skill`.
+- Do not use to soften Receiz primitives into generic app categories.
+
+## Core Receiz Laws
+
+- Receiz is a proof-native artifact system.
+- Specialized skills must preserve the same truth hierarchy.
+- Artifact truth, deterministic proof object state, verified local truth, and verified register appends outrank server, database, session, UI, and model output.
+- Never treat a database, server, marketplace, UI, model response, or cache as final authority.
+- Use direct primitive language for implemented primitives.
+- Do not add new authority layers when existing Receiz primitives already carry the boundary.
+- Read [resources/skill-routing.md](resources/skill-routing.md) first.
+
+## Required Behavior
+
+1. Classify the task by primitive and risk.
+2. Route to the narrowest skill that can answer the task.
+3. Chain skills in proof-first order when multiple skills apply.
+4. Preserve canonical language from [resources/canonical-receiz-language.md](resources/canonical-receiz-language.md).
+5. State exact uncertainty boundaries instead of vague caution.
+6. Stop before writes unless MCP confirmation rules are loaded.
+
+## Forbidden Behavior
+
+- Do not use the bundle to skip proof verification.
+- Do not invent APIs, tools, scopes, product claims, ownership, settlement, rarity, or official status.
+- Do not call proof objects cards, listings, metadata wrappers, cache, or generic UI state as product truth.
+- Do not let an external convention define Receiz product truth.
+- Do not route value-affecting actions without explicit confirmation.
+
+## MCP Usage Rules
+
+When MCP tools are needed, route to `receiz-mcp-agent-skill` and follow delegated authorization, read/write separation, and action confirmation rules. Use MCP read tools to resolve or inspect only; use SDK `verification.verifyArtifact(file)` for verification. Use MCP write tools only after explicit confirmation and scoped delegated access.
+
+## SDK Usage Rules
+
+When generated code is needed, route to `receiz-builder-skill` and then to domain skills. Use `createReceizClient`, SDK validators, proof memory, public proof, public store, sports, identity, offline, commerce, payments, and connect rails according to the selected skill.
+
+## Output Format
+
+Use this router output:
+
+```md
+## Receiz Skill Route
+Primary primitive:
+Source of truth:
+Selected skills:
+First skill to run:
+MCP needed:
+SDK needed:
+Write action:
+Confirmation required:
+Exact uncertainty:
+```
+
+## Safety And Security Boundaries
+
+The bundle cannot authorize actions by itself. Delegated access, OIDC Authorization Code with PKCE, MCP login setup, private credentials, and confirmation rules remain under `receiz-mcp-agent-skill`. Never print secrets or private proof material.
+
+## Examples
+
+This router has no standalone example files. Use the specialized skill examples after routing.
+
+Load resources as needed:
+
+- [Skill routing](resources/skill-routing.md)
+- [Combined agent behavior](resources/combined-agent-behavior.md)
+- [When to use each skill](resources/when-to-use-each-skill.md)
+- [Canonical Receiz language](resources/canonical-receiz-language.md)

package/receiz-skill-bundle/resources/canonical-receiz-language.md

@@ -0,0 +1,46 @@
+# Canonical Receiz Language
+
+## Required Primitive Names
+
+- Proof object
+- Artifact system
+- Vault object
+- Ownership surface
+- Settlement primitive
+- Identity primitive
+- Public proof surface
+- Offline proof
+- Verified local truth
+- Durable local truth
+- Card memory
+- Live event append
+- Receipt proof
+- Certificate
+- Note issue route
+- Public store projection
+- Market projection
+
+## Forbidden Downgrades
+
+- Proof object to card.
+- Artifact system to UI experience.
+- Vault object to content card.
+- Sealed file to metadata wrapper.
+- Offline verification to fallback mode.
+- Durable local truth to cache.
+- Public proof surface to share page.
+- Ownership surface to dashboard state.
+- Settlement primitive to balance display.
+- Receiz ID to login method.
+- Deterministic first paint to loading state.
+
+## Exact Uncertainty
+
+Hedge only the unknown boundary:
+
+- Build not run.
+- MCP tool unavailable.
+- Live DB state not verified.
+- Browser path not tested.
+- External API behavior not checked.
+- Write action not confirmed.

package/receiz-skill-bundle/resources/combined-agent-behavior.md

@@ -0,0 +1,35 @@
+# Combined Agent Behavior
+
+## Core Loop
+
+1. Name the primitive.
+2. Name the strongest source of truth.
+3. Select the skill.
+4. Verify before claiming.
+5. Separate proof facts from projections and actions.
+6. Confirm value-affecting writes.
+7. Output exact uncertainty boundaries.
+
+## Risk Labels
+
+Use precise labels when relevant:
+
+- primitive-risk
+- first-paint-risk
+- truth-downgrade-risk
+- offline-proof-risk
+- ownership-risk
+- settlement-risk
+- identity-risk
+- provenance-risk
+- transfer-risk
+- public-proof-risk
+- language-drift-risk
+- money-risk
+- session-risk
+- security-risk
+- hydration-risk
+
+## Final Guard
+
+Before completion, confirm no stronger truth was replaced by weaker server, database, session, UI, cache, marketplace, or model state.

package/receiz-skill-bundle/resources/skill-routing.md

@@ -0,0 +1,15 @@
+# Skill Routing
+
+## Route Order
+
+1. If an object must be verified, start with `receiz-proof-skill`.
+2. If local files or airplane-mode proof are involved, use `receiz-offline-verifier-skill`.
+3. If MCP tools or delegated access are involved, use `receiz-mcp-agent-skill`.
+4. If code or app surfaces are being generated, use `receiz-builder-skill`.
+5. If product, storefront, order, receipt, certificate, note, or checkout boundaries appear, use `receiz-commerce-skill`.
+6. If sports cards, card memory, Pack Derby, rarity, MLB proof language, or live events appear, use `receiz-sports-card-skill`.
+7. If QR, venue, affiliate, staff script, or physical activation appears, use `receiz-distribution-skill`.
+
+## Multi-Skill Order
+
+Proof first. Offline verifier before network comparison. MCP confirmation before writes. Builder after primitive boundaries are known. Domain skill before public copy.

package/receiz-skill-bundle/resources/when-to-use-each-skill.md

@@ -0,0 +1,29 @@
+# When To Use Each Skill
+
+## receiz-proof-skill
+
+Use for verification, inspection, proof reports, ownership, provenance, public proof, and vault objects.
+
+## receiz-builder-skill
+
+Use for generating apps, SDK integrations, no-database stores, proof-native UI, and deployment checklists.
+
+## receiz-mcp-agent-skill
+
+Use for live tools, delegated access, read/write MCP separation, OIDC Authorization Code with PKCE setup, confirmation rules, and action execution.
+
+## receiz-commerce-skill
+
+Use for products, storefronts, checkout, orders, receipts, certificates, notes, seller/buyer copy, and commerce proof.
+
+## receiz-sports-card-skill
+
+Use for sports cards, card memory, live events, pack openings, rarity, MLB proof language, card markets, and game surfaces.
+
+## receiz-offline-verifier-skill
+
+Use for local files, sealed artifacts, offline verification, airplane mode, embedded proof, and artifact-over-server boundaries.
+
+## receiz-distribution-skill
+
+Use for QR activation, Pack Derby venues, restaurant or bar copy, affiliate boundaries, staff scripts, and physical-to-proof distribution.

package/receiz-sports-card-skill/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: receiz-sports-card-skill
+description: Use when an agent must explain, verify, build, or operate Receiz sports card objects, card memory, live event appends, rarity language, MLB proof language, pack openings, card market surfaces, or game surfaces.
+---
+
+# receiz-sports-card-skill
+
+Receiz sports cards are living proof objects. Player identity, media, rarity, live-event memory, pack origin, ownership, market projection, and game state must remain tied to verified card history.
+
+## When To Use This Skill
+
+- Use for Receiz Sports Cards, MLB-themed proof language, live event appends, Pack Derby, pack opening, card market explanation, rarity copy, and geo appeal.
+- Use when a user asks what a player card is, why it changed, where an event came from, or how a card can gain memory.
+- Use before generating sports card UI, card economy language, or live-game proof copy.
+
+## When Not To Use This Skill
+
+- Do not use for generic products without sports memory. Use `receiz-commerce-skill`.
+- Do not use as the only verifier for arbitrary assets. Use `receiz-proof-skill` first when the card proof is unknown.
+- Do not execute live event appends without `receiz-mcp-agent-skill` confirmation rules.
+
+## Core Receiz Laws
+
+- A Receiz sports card is a proof object with card memory, provenance, media, ownership, and event append boundaries.
+- Live event memory appends to a card. It does not rewrite earlier card truth.
+- Rarity language must come from card proof, event proof, or declared product law.
+- Market state is a projection beneath card proof and ownership proof.
+- Never treat a database, server, marketplace, UI, model response, or cache as final authority.
+- Game surfaces may display proof-native scores and state, but verified card memory remains the stronger truth.
+- Read [resources/sports-card-object-model.md](resources/sports-card-object-model.md) before explaining a card.
+
+## Required Behavior
+
+1. Name the card primitive: proof object, card memory, live-event append, ownership surface, public proof surface, market projection, pack proof, or game surface.
+2. Verify card proof with sports card manifest validation, MCP card history, or artifact verification.
+3. Report player identity, card identity, media, rarity, event history, ownership, and market status separately.
+4. Treat new live events as append-only.
+5. Use precise MLB and rarity language from [resources/mlb-proof-language.md](resources/mlb-proof-language.md) and [resources/rarity-and-event-language.md](resources/rarity-and-event-language.md).
+
+## Forbidden Behavior
+
+- Do not invent stats, team data, event memory, rarity, pack origin, ownership, or value.
+- Do not describe a sports card as a generic collectible image or marketplace card.
+- Do not collapse live-event memory into UI state.
+- Do not let market projection outrank card proof.
+- Do not call a card changed unless a verified append or proof update supports it.
+
+## MCP Usage Rules
+
+Use `receiz_card_history` for card memory, `receiz_pitch_proof_by_witness_id` for pitch witnesses, `receiz_sports_conformance` for sports conformance, `receiz_asset_by_url` or `receiz_inspect_proof_object` for proof resolution/inspection, SDK `verification.verifyArtifact(file)` for verification, and `receiz_pack_open_preview` for pack-opening previews. Writes or live event appends require explicit confirmation and a scoped write rail.
+
+## SDK Usage Rules
+
+Use `assertReceizSportsCardManifest`, `projectReceizSportsCardManifest`, `receiz.sports.resolveCardMemory`, `receiz.sports.resolvePitchDayProof`, `receiz.sports.conformance`, `receiz.sports.conformanceHistory`, `receiz.verification.verifyArtifact`, and proof memory helpers. Use [resources/card-memory-law.md](resources/card-memory-law.md) for append behavior.
+
+## Output Format
+
+Use this format for sports card answers:
+
+```md
+## Sports Card Proof
+Card:
+Primitive:
+Source of truth:
+Player identity:
+Card identity:
+Media:
+Rarity:
+Pack origin:
+Live event memory:
+Ownership / custody:
+Market projection:
+What is proven:
+What is not proven:
+Safe next action:
+```
+
+## Safety And Security Boundaries
+
+Live event append, pack open, transfer, sale, settlement, certificate, and market actions require explicit confirmation. Do not invent official sports claims. Do not print private credentials, bearer tokens, private identity material, or hidden proof payloads.
+
+## Examples
+
+- [Explain player card](examples/explain-player-card.md)
+- [Explain live event card](examples/explain-live-event-card.md)
+- [Explain pack opening](examples/explain-pack-opening.md)
+- [Explain card market](examples/explain-card-market.md)
+- [Explain geo appeal](examples/explain-geo-appeal.md)
+
+Load resources as needed:
+
+- [Sports card object model](resources/sports-card-object-model.md)
+- [Card memory law](resources/card-memory-law.md)
+- [Live event append flow](resources/live-event-append-flow.md)
+- [Rarity and event language](resources/rarity-and-event-language.md)
+- [MLB proof language](resources/mlb-proof-language.md)
+- [Game surface patterns](resources/game-surface-patterns.md)

package/receiz-sports-card-skill/examples/explain-card-market.md

@@ -0,0 +1,18 @@
+# Explain Card Market
+
+## Agent Steps
+
+1. Verify card proof first.
+2. Resolve ownership and market projection.
+3. Report display value or settlement route only when present.
+4. Explain that market state is weaker than card proof.
+
+## Output
+
+```md
+Card proof:
+Owner / custody:
+Market projection:
+Settlement boundary:
+Safe action:
+```

package/receiz-sports-card-skill/examples/explain-geo-appeal.md

@@ -0,0 +1,9 @@
+# Explain Geo Appeal
+
+Geo appeal can be described only as audience or venue context unless proof carries a location, event, or venue witness.
+
+## Agent Steps
+
+1. Identify whether the card proof includes location or venue data.
+2. If absent, describe geo appeal as distribution strategy, not artifact truth.
+3. Keep venue activation under `receiz-distribution-skill` when QR or Pack Derby is involved.

package/receiz-sports-card-skill/examples/explain-live-event-card.md

@@ -0,0 +1,18 @@
+# Explain Live Event Card
+
+## Agent Steps
+
+1. Resolve the card history.
+2. Resolve the live event witness.
+3. Explain the event as an append to card memory.
+4. State whether the base card changed or only memory grew.
+
+## Output
+
+```md
+Live event:
+Witness:
+Append target:
+Memory result:
+Unverified fields:
+```

package/receiz-sports-card-skill/examples/explain-pack-opening.md

@@ -0,0 +1,10 @@
+# Explain Pack Opening
+
+Pack opening is a proof event when it carries deterministic pack identity and resulting card identities.
+
+## Agent Steps
+
+1. Preview or inspect the pack with `receiz_pack_open_preview` when available.
+2. Identify pack proof and card outputs.
+3. Separate pack reveal copy from proof results.
+4. Do not claim rarity without proof.

package/receiz-sports-card-skill/examples/explain-player-card.md

@@ -0,0 +1,19 @@
+# Explain Player Card
+
+## Agent Steps
+
+1. Verify the card manifest or proof URL.
+2. Name player identity exactly as the proof provides it.
+3. Report media, rarity, pack origin, memory, ownership, and market projection separately.
+4. Avoid unverified stats or official endorsement claims.
+
+## Output
+
+```md
+This is a Receiz sports card proof object.
+Player identity:
+Card identity:
+Rarity:
+Card memory:
+Ownership:
+```

package/receiz-sports-card-skill/resources/card-memory-law.md

@@ -0,0 +1,23 @@
+# Card Memory Law
+
+Card memory is append-only.
+
+## What Can Append
+
+- Live pitch witness.
+- Game event proof.
+- Pack opening proof.
+- Ownership transfer proof.
+- Market action proof.
+- Certification or note proof.
+
+## What Cannot Happen
+
+- Earlier card identity cannot be rewritten.
+- Rarity cannot be invented after the fact without a verified append or declared proof route.
+- Market projection cannot redefine card memory.
+- UI state cannot become event proof.
+
+## Agent Rule
+
+When card memory is requested, use `receiz_card_history` or SDK sports card memory rails. If unavailable, say exactly which memory rail was not available.