@receiz/ai-skills 106.0.0 → 108.0.0

package/README.md

@@ -1,28 +1,37 @@
 # Receiz AI Skills
 
-`receiz-build-production-system` is the v106 orchestration skill for substantial
+`receiz-build-production-system` remains the constitutional orchestration skill for substantial
 Receiz applications. Fourteen focused constitutional skills supply architecture,
 domain, law, command, authority, replay, offline, causal, artifact, migration,
 performance, observability, testing, and release contracts. The earlier nine
-domain skills remain packaged for compatibility.
+domain skill names remain packaged for compatibility. Seven operation skill names first introduced in v107 now
+describe current v108 outcomes for identity profiles, portable continuity, bearer ownership, offline transport,
+proof media, cross-app state, and admission evidence. Their retired v107 mechanisms are not active defaults.
+Every current manifest uses schema and version `v108` / `108.0.0`, requires SDK/MCP `>=108.0.0 <109.0.0`, and binds ruleset `108.0.0` to registry digest `126ca9283fee4ef4c398dbcb958e861cbea191724fdab8eb08df55ff0c14bb79`.
 
 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 all twenty-four skill directories under `node_modules/@receiz/ai-skills` for explicit loading by an agent host.
+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 all thirty-one 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.
+Receiz is a proof-native artifact system. Sealed proof/object truth is strongest: a Receiz object is not a database row, but a proof-carrying artifact whose witnessed history is the truth boundary. The proof object carries continuity; SDK and MCP may verify, extract, append, or project beneath that carried truth. Receiz.com reference behavior comes before SDK, MCP, AI, and other developer rails. 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.
+
+A verified proof object is not limited to the platform that created it. Any lawful platform may append authenticated ownership and history only while preserving the same immutable object identity, payload, provenance root, prior history, and unknown namespaces, then returning a complete verified proof object. AI skills adapt to that continuity and never invent an origin-platform authority or parallel chain.
 
 ## SDK, MCP, And Skills
 
 - SDK: `@receiz/sdk` is the universal runtime; `@receiz/sdk/react` is React-only; `@receiz/sdk/compiler` is Node-only; `@receiz/sdk/testing` is browser-safe sandbox and conformance support.
-- 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.
+- MCP: `@receiz/mcp-server` is for agent tool access. Its six artifact custody tools plan/execute native Record -> Seal, verify the complete artifact, extract only after verification, check exact byte round trip, and explain evidence through the same SDK artifact verifier. Diagnostics, public reads, app-state/public-store actions, previews, and delegated writes remain beneath proof truth.
 - 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-build-production-system` when work spans multiple constitutional domains. Its machine-readable manifest requires the exact active signed registry digest, command-only mutation, independent verification, MCP conformance, and a passing release lock. Use a focused v106 skill for narrower production work. The compatibility router `receiz-skill-bundle` and proof/domain skills remain available for earlier workflows.
+Start with `receiz-build-production-system` when work spans multiple constitutional domains. Its machine-readable manifest requires the exact active signed registry digest, command-only mutation, independent verification, MCP conformance, and a passing release lock. Use a focused operation skill for SDK/MCP implementation and a constitutional skill for broader system law. Stable v107 wire schemas remain available only through the explicit historical `@receiz/sdk/v107` package entry; current skills never teach their key, head, receipt, reconcile, or signed-command mechanics as a v108 outcome.
+
+The v108 operation skills are executable contracts. Current profile work uses the neutral authenticated same-UID profile operation. Current bearer ownership accepts a complete verified artifact, derives prior ownership from carried proof, and returns a native Record -> Seal artifact. Proof media uses the same native artifact custody and projects only a verified URL beneath it. These outcomes have no active identity-key, caller-head, claim-key, or receipt prerequisite. MCP calls the same SDK outcomes and never creates a parallel authority.
+
+Stable v107 schema names and their head/receipt mechanics remain explicitly historical compatibility, not the active/default profile, bearer, or proof-media contract.
 
 Do not invent APIs. Use the SDK and MCP maps inside the skills, then inspect the repo when a requested operation is not listed.
 

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@receiz/ai-skills",
-  "version": "106.0.0",
+  "version": "108.0.0",
   "description": "Authoritative Receiz AI operating skills for proof-native SDK and MCP agents.",
   "type": "module",
   "files": [
     "README.md",
+    "scripts",
     "receiz-app-builder-skill",
     "receiz-builder-skill",
     "receiz-commerce-skill",
@@ -28,7 +29,14 @@
     "receiz-observability",
     "receiz-testing",
     "receiz-release",
-    "receiz-build-production-system"
+    "receiz-build-production-system",
+    "receiz-identity-profile",
+    "receiz-portable-continuity",
+    "receiz-bearer-ownership",
+    "receiz-offline-command",
+    "receiz-proof-media",
+    "receiz-cross-app-state",
+    "receiz-receipt-admission"
   ],
   "keywords": [
     "receiz",
@@ -43,5 +51,8 @@
   "license": "MIT",
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "test": "node --import tsx scripts/validate-skills.ts"
   }
 }

package/receiz-app-builder-skill/SKILL.md

@@ -8,6 +8,89 @@ description: Use when starting, integrating, upgrading, diagnosing, or repairing
 Build and upgrade Receiz applications from one typed contract. The compiler is
 integration tooling beneath Receiz proof truth; inspection is not verification.
 
+## Binding v108 artifact law
+
+A Receiz artifact is the exact byte sequence returned by native Record -> Seal. The inner payload is never an acceptable substitute.
+
+A verified proof object is not limited to the platform that created it. Any lawful platform may append authenticated ownership and history only while preserving the same immutable object identity, payload, provenance root, prior history, and unknown namespaces, then returning a complete verified proof object.
+
+Label every byte sequence generated or consumed by the application:
+
+- `payload`: application bytes exposed separately only after the enclosing artifact verifies.
+- `sealed artifact`: the indivisible SDK-issued Record -> Seal bytes carrying integrity, Signature V4, owner, claim, verify path, provenance, and payload binding.
+
+## Required SDK artifact workflow
+
+```ts
+const payload = { bytes: applicationPayload, mimeType: applicationMimeType };
+const sealedArtifact = await receiz.assets.createProofObject(
+  { assetType: "proof_object", payload },
+  { filename: applicationFilename, idempotencyKey },
+);
+const downloadEvidence = await receiz.artifacts.download(sealedArtifact);
+const opened = await receiz.artifacts.verifyAndOpen(savedArtifactFile);
+if (downloadEvidence.artifactSha256 !== sealedArtifact.artifactSha256) throw new Error("artifact_digest_mismatch");
+if (opened.sealedArtifact.artifactSha256 !== sealedArtifact.artifactSha256) throw new Error("saved_artifact_mismatch");
+if (opened.verifiedPayload.sha256 !== sealedArtifact.payloadSha256) throw new Error("payload_binding_mismatch");
+```
+
+Independently hash the saved bytes and require equality with `sealedArtifact.artifactSha256`. Require `verification.ok`, `integrity.ok`, carrier `native-record-seal`, Signature V4, owner, claim, and verify-path agreement. Reopen the exact saved file with `verifyAndOpen`, then prove a different Receiz application preserves identity, cards, history, receipts, and unknown namespaces. Current exports use native Record -> Seal; verified legacy artifacts remain read-compatible only.
+
+## Twelve-step artifact workflow
+
+1. Label the input bytes as `payload`; never call them an artifact.
+2. Load the active signed v108 registry and `ARTIFACT-001` through `ARTIFACT-010`.
+3. Call `receiz.assets.createProofObject` so Receiz.com performs native Record -> Seal.
+4. Require an SDK-issued `receiz.native-record-seal`; failure returns no artifact and no payload fallback.
+5. Require complete enclosing-artifact verification, integrity, Signature V4, owner, claim, verify path, and payload binding.
+6. Call `receiz.artifacts.download` with only that SDK-issued sealed artifact.
+7. Independently hash the exact saved artifact bytes without repacking or relabeling them.
+8. Require the saved artifact digest to equal the SDK-issued artifact digest.
+9. Reopen the exact saved file through `receiz.artifacts.verifyAndOpen` before payload extraction.
+10. Pass only `opened.verifiedPayload.bytes` to domain parsers and preserve unknown namespaces.
+11. Exercise a different Receiz application projection and prove identity, ownership history, namespaces, and byte round trip remain intact.
+12. Record every production-ready evidence field below and refuse completion if any field is absent or failing.
+
+When MCP is available, use only these current artifact tools; each remains subordinate to the SDK and enclosing proof:
+
+- `receiz_artifact_record_seal_plan`
+- `receiz_artifact_record_seal_execute`
+- `receiz_artifact_verify`
+- `receiz_artifact_extract_verified`
+- `receiz_artifact_round_trip_check`
+- `receiz_artifact_explain`
+
+## Artifact prohibitions
+
+- Never download an unsealed payload fallback.
+- Never call an inner payload a Receiz artifact.
+- Never relabel payload bytes as a Receiz artifact.
+- Never repack, wrap, recompress, or modify native Record -> Seal bytes.
+- Never treat shape validation as artifact verification.
+- Never delete unknown cross-application namespaces.
+- Never rewrite immutable ownership or provenance history.
+- Never weaken a failing test to accept payload-only continuity.
+- Never claim success from UI rendering alone.
+
+## Production-ready evidence
+
+Refuse to call the artifact production-ready when any field is absent or failing:
+
+```md
+SDK version:
+Registry digest:
+Artifact law version:
+Artifact carrier:
+Signature version:
+Artifact digest:
+Payload digest:
+Owner and claim binding:
+Independent verification result:
+Cross-platform round-trip result:
+Legacy compatibility result:
+Release-lock result:
+```
+
 ## When To Use This Skill
 
 - Use for `defineReceizApp`, `receiz.app.contract.v1`, or `receiz app` commands.
@@ -71,8 +154,8 @@ Import `defineReceizApp`, `validateReceizAppContract`,
 `compileReceizAppContract`, `inspectReceizProject`,
 `planReceizIntegration`, `checkReceizIntegration`, `planReceizUpgrade`, and
 `explainReceizIntegrationFinding` from `@receiz/sdk/compiler`. Artifact verification remains
-`verification.verifyArtifact`; creation remains the SDK's authenticated native
-Record-before-Seal rail.
+`artifacts.verifyAndOpen`; creation and download remain `assets.createProofObject`
+and `artifacts.download` on the SDK's authenticated native Record-before-Seal rail.
 
 ## Output Format
 

package/receiz-app-builder-skill/examples/proof-verifier.md

@@ -1,5 +1,6 @@
 # Proof Verifier Starter Contract
 
-Select `proof` and optionally `proofMemory`. Route byte-bearing files to SDK
-`verification.verifyArtifact`. MCP inspection and repository checks never supply
-the verification verdict.
+Select `proof` and optionally `proofMemory`. Label byte-bearing inputs as payload
+or sealed artifact. Route complete sealed files to SDK `artifacts.verifyAndOpen`
+and domain parsers only to `opened.verifiedPayload.bytes`. MCP inspection and
+repository checks never supply the verification verdict.

package/receiz-app-builder-skill/manifest.json

@@ -0,0 +1,17 @@
+{
+  "schema": "receiz.ai-skill-contract.v108",
+  "name": "receiz-app-builder-skill",
+  "version": "108.0.0",
+  "requires": { "sdk": ">=108.0.0 <109.0.0", "mcp": ">=108.0.0 <109.0.0", "ruleset": "108.0.0", "registryDigest": "126ca9283fee4ef4c398dbcb958e861cbea191724fdab8eb08df55ff0c14bb79" },
+  "artifactLawVersion": "108.0.0",
+  "artifactLaws": ["ARTIFACT-001", "ARTIFACT-002", "ARTIFACT-003", "ARTIFACT-004", "ARTIFACT-005", "ARTIFACT-006", "ARTIFACT-007", "ARTIFACT-008", "ARTIFACT-009", "ARTIFACT-010"],
+  "laws": ["receiz.artifact.sealed-truth", "receiz.compiler.beneath-proof", "receiz.artifact.verify-before-extract", "ownership.cross-platform-proof-object-continuity"],
+  "sdkOperations": ["assets.createProofObject", "artifacts.download", "artifacts.verifyAndOpen"],
+  "allowedTools": ["receiz_project_inspect", "receiz_app_plan", "receiz_app_apply", "receiz_app_check", "receiz_release_qualify"],
+  "forbiddenOperations": ["direct-state-write", "payload-fallback", "payload-relabel-as-artifact", "artifact-repack", "shape-only-verification", "history-rewrite", "authority-bypass"],
+  "requiredInputs": ["repository-root", "installed-sdk-version", "active-registry-digest", "artifact-law-version", "labeled-byte-domains", "cross-app-destination"],
+  "requiredEvidence": ["typecheck", "conformance", "exact-artifact-byte-identity", "artifact-digest-match", "payload-digest-binding", "signature-v4", "owner-claim-binding", "independent-artifact-verification", "cross-platform-round-trip", "legacy-read-compatibility", "release-lock-pass"],
+  "requiredCompletionFields": ["sdk-version", "registry-digest", "artifact-law-version", "artifact-carrier", "signature-version", "artifact-digest", "payload-digest", "owner-and-claim-binding", "independent-verification-result", "cross-platform-round-trip-result", "legacy-compatibility-result", "release-lock-result"],
+  "completionCriteria": ["all-required-evidence-pass", "release-lock-pass"],
+  "maximumAutonomousAuthority": "inspect-plan-scaffold-test"
+}

package/receiz-architecture/manifest.json

@@ -1,11 +1,12 @@
 {
-  "schema": "receiz.ai-skill-contract.v106",
+  "schema": "receiz.ai-skill-contract.v108",
   "name": "receiz-architecture",
+  "version": "108.0.0",
   "requires": {
-    "sdk": ">=106.0.0 <107.0.0",
-    "mcp": ">=106.0.0 <107.0.0",
-    "ruleset": "106.0.0",
-    "registryDigest": "bf851c209e807309672c0f466411baa5607ce6b3195fe4eb16755edfeb7f5a1a"
+    "sdk": ">=108.0.0 <109.0.0",
+    "mcp": ">=108.0.0 <109.0.0",
+    "ruleset": "108.0.0",
+    "registryDigest": "126ca9283fee4ef4c398dbcb958e861cbea191724fdab8eb08df55ff0c14bb79"
   },
   "laws": [
     "receiz.truth.stronger-first",
@@ -54,4 +55,3 @@
   ],
   "maximumAutonomousAuthority": "inspect-plan-scaffold-test"
 }
-

package/receiz-authority-security/manifest.json

@@ -1,11 +1,12 @@
 {
-  "schema": "receiz.ai-skill-contract.v106",
+  "schema": "receiz.ai-skill-contract.v108",
   "name": "receiz-authority-security",
+  "version": "108.0.0",
   "requires": {
-    "sdk": ">=106.0.0 <107.0.0",
-    "mcp": ">=106.0.0 <107.0.0",
-    "ruleset": "106.0.0",
-    "registryDigest": "bf851c209e807309672c0f466411baa5607ce6b3195fe4eb16755edfeb7f5a1a"
+    "sdk": ">=108.0.0 <109.0.0",
+    "mcp": ">=108.0.0 <109.0.0",
+    "ruleset": "108.0.0",
+    "registryDigest": "126ca9283fee4ef4c398dbcb958e861cbea191724fdab8eb08df55ff0c14bb79"
   },
   "laws": [
     "receiz.authority.capability-bound",
@@ -55,4 +56,3 @@
   ],
   "maximumAutonomousAuthority": "inspect-plan-scaffold-test"
 }
-

package/receiz-bearer-ownership/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: receiz-bearer-ownership
+description: Use when claiming a qualifying Receiz bearer proof object from a complete verified artifact and returning its new native sealed artifact.
+---
+
+# Receiz Bearer Ownership
+
+Claim the enclosing proof object, not a detached payload or a card-specific invention. Preserve the verified carried ownership chain through the new native artifact.
+
+## Exact SDK operation
+
+Verify and open the complete sealed artifact first. Pass only the runtime-issued sealed-artifact handle into the ownership operation, then download the exact new artifact.
+
+```ts
+import { createReceizClient } from "@receiz/sdk";
+
+const receiz = createReceizClient({ accessToken });
+const opened = await receiz.artifacts.verifyAndOpen(artifactFile);
+const claimed = await receiz.ownership.claimBearerAsset({
+  artifact: opened.sealedArtifact,
+});
+const downloadEvidence = await receiz.artifacts.download(claimed);
+```
+
+`opened.verifiedPayload` is an inspected projection. Ownership input remains `opened.sealedArtifact`, the complete sealed artifact.
+
+## Required authority
+
+Treat the enclosing sealed proof object and its carried ownership continuity as stronger truth. Bind the new owner to the authenticated Receiz account. Keep the server, SDK, MCP, and AI beneath those primitives.
+
+The proof object is not limited to the platform that created it. Any lawful platform may verify it and append authenticated ownership and history through the same operation, provided the result preserves the same immutable object identity, payload, provenance root, and prior history and returns a newly verified complete proof object.
+
+Require the signed-in session or delegated `receiz:record` and `receiz:seal` scopes. Do not accept a caller-selected owner, identity key, claim key, or proof head.
+
+## Required proof object
+
+Require a complete sealed artifact that passes enclosing integrity, Signature V4, claim/path, owner, and payload-binding verification. Reject payload bytes, a self-hash, an arbitrary Blob, or a caller-constructed artifact handle.
+
+Prior ownership is derived from the verified carried proof payload. Never fetch or accept a caller-provided latest ownership head as the authority boundary.
+
+## Deterministic behavior
+
+Append the authenticated Receiz owner to the verified carried ownership document, then run native Record -> Seal. Return only the newly verified complete artifact. Use `artifacts.download` to preserve its exact bytes and metadata.
+
+## Offline behavior
+
+Retain the original artifact and its verified local truth when network service is unavailable. Do not report an ownership claim as complete until authenticated Record -> Seal returns the new verified artifact.
+
+## Conflict behavior
+
+On failed enclosing verification, non-bearer custody, authenticated-owner failure, Record failure, Seal failure, or custody conflict, return no claimed artifact. Never retry by substituting a server row, caller head, or detached payload.
+
+## Result verification
+
+Require a runtime-issued current native artifact with complete verification, authenticated owner continuity, Record identity, claim/path binding, Signature V4, and native Record -> Seal continuity. A receipt is not emitted or required for this current outcome.
+
+## User confirmation
+
+Show the source artifact identity, verified current custody, authenticated destination account, and the consequence of creating a new ownership artifact. Never ask for a claimant key ID or expected ownership head.
+
+## MCP parity
+
+Call `receiz_bearer_asset_claim_plan` with `{ artifactBase64, filename, mimeType }`, where the bytes are the complete sealed artifact. Require the exact confirmation digest, then call `receiz_bearer_asset_claim_execute` with `{ planDigest, confirmation }`.
+
+The active MCP path calls `client.artifacts.verifyAndOpen(completeFile)`, then `client.ownership.claimBearerAsset({ artifact: opened.sealedArtifact })`. It returns the newly claimed complete sealed artifact bytes and evidence, never the extracted payload.
+
+## Emulator fixture
+
+Run `generic-bearer-transfer` and `previous-owner-projection-invalidation` across qualifying artifact families. Require the prior ownership reference to come from carried verified proof and the output to be a native sealed artifact.

package/receiz-bearer-ownership/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Receiz Bearer Ownership"
+  short_description: "Claim from a complete sealed artifact"
+  default_prompt: "Use $receiz-bearer-ownership to verify the complete sealed artifact and return the authenticated owner's new native Record -> Seal artifact. A verified proof object is not limited to the platform that created it: any lawful platform may append authenticated ownership and history only while preserving the same immutable object identity, payload, provenance root, prior history, and unknown namespaces."

package/receiz-bearer-ownership/manifest.json

@@ -0,0 +1,14 @@
+{
+  "schema": "receiz.ai-skill-contract.v108",
+  "name": "receiz-bearer-ownership",
+  "version": "108.0.0",
+  "requires": { "sdk": ">=108.0.0 <109.0.0", "mcp": ">=108.0.0 <109.0.0", "ruleset": "108.0.0", "registryDigest": "126ca9283fee4ef4c398dbcb958e861cbea191724fdab8eb08df55ff0c14bb79" },
+  "laws": ["receiz.ownership.enclosing-proof", "receiz.ownership.carried-continuity", "receiz.artifact.native-record-seal", "ownership.cross-platform-proof-object-continuity"],
+  "sdkOperations": ["artifacts.verifyAndOpen", "ownership.claimBearerAsset", "artifacts.download"],
+  "allowedTools": ["receiz_bearer_asset_claim_plan", "receiz_bearer_asset_claim_execute"],
+  "requiredScopes": ["receiz:record", "receiz:seal"],
+  "emulatorFixtures": ["generic-bearer-transfer", "previous-owner-projection-invalidation"],
+  "forbiddenOperations": ["direct-state-write", "payload-as-claim-input", "caller-owner-substitution", "caller-proof-head-prerequisite", "claim-key-prerequisite", "receipt-authority", "origin-platform-lock", "authority-bypass"],
+  "requiredEvidence": ["complete-artifact-verification", "native-record-seal", "emulator-conformance", "release-lock-pass"],
+  "maximumAutonomousAuthority": "inspect-plan-simulate"
+}

package/receiz-build-production-system/manifest.json

@@ -1,11 +1,12 @@
 {
-  "schema": "receiz.ai-skill-contract.v106",
+  "schema": "receiz.ai-skill-contract.v108",
   "name": "receiz-build-production-system",
+  "version": "108.0.0",
   "requires": {
-    "sdk": ">=106.0.0 <107.0.0",
-    "mcp": ">=106.0.0 <107.0.0",
-    "ruleset": "106.0.0",
-    "registryDigest": "bf851c209e807309672c0f466411baa5607ce6b3195fe4eb16755edfeb7f5a1a"
+    "sdk": ">=108.0.0 <109.0.0",
+    "mcp": ">=108.0.0 <109.0.0",
+    "ruleset": "108.0.0",
+    "registryDigest": "126ca9283fee4ef4c398dbcb958e861cbea191724fdab8eb08df55ff0c14bb79"
   },
   "laws": [
     "receiz.truth.stronger-first",
@@ -64,4 +65,3 @@
   ],
   "maximumAutonomousAuthority": "inspect-plan-scaffold-test"
 }
-

package/receiz-causal-sync/manifest.json

@@ -1,11 +1,12 @@
 {
-  "schema": "receiz.ai-skill-contract.v106",
+  "schema": "receiz.ai-skill-contract.v108",
   "name": "receiz-causal-sync",
+  "version": "108.0.0",
   "requires": {
-    "sdk": ">=106.0.0 <107.0.0",
-    "mcp": ">=106.0.0 <107.0.0",
-    "ruleset": "106.0.0",
-    "registryDigest": "bf851c209e807309672c0f466411baa5607ce6b3195fe4eb16755edfeb7f5a1a"
+    "sdk": ">=108.0.0 <109.0.0",
+    "mcp": ">=108.0.0 <109.0.0",
+    "ruleset": "108.0.0",
+    "registryDigest": "126ca9283fee4ef4c398dbcb958e861cbea191724fdab8eb08df55ff0c14bb79"
   },
   "laws": [
     "receiz.merge.causal",
@@ -55,4 +56,3 @@
   ],
   "maximumAutonomousAuthority": "inspect-plan-scaffold-test"
 }
-

package/receiz-command-builder/manifest.json

@@ -1,11 +1,12 @@
 {
-  "schema": "receiz.ai-skill-contract.v106",
+  "schema": "receiz.ai-skill-contract.v108",
   "name": "receiz-command-builder",
+  "version": "108.0.0",
   "requires": {
-    "sdk": ">=106.0.0 <107.0.0",
-    "mcp": ">=106.0.0 <107.0.0",
-    "ruleset": "106.0.0",
-    "registryDigest": "bf851c209e807309672c0f466411baa5607ce6b3195fe4eb16755edfeb7f5a1a"
+    "sdk": ">=108.0.0 <109.0.0",
+    "mcp": ">=108.0.0 <109.0.0",
+    "ruleset": "108.0.0",
+    "registryDigest": "126ca9283fee4ef4c398dbcb958e861cbea191724fdab8eb08df55ff0c14bb79"
   },
   "laws": [
     "receiz.command-only-mutation",
@@ -55,4 +56,3 @@
   ],
   "maximumAutonomousAuthority": "inspect-plan-scaffold-test"
 }
-

package/receiz-commerce-skill/SKILL.md

@@ -34,7 +34,7 @@ Receiz commerce is proof-native commerce. A product page, storefront, order view
 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.
+4. Use no-database patterns only when sealed artifact truth and verified local truth remain the source of truth; SDK and MCP rails may transport or project that truth only.
 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.
 

package/receiz-constitutional-laws/manifest.json

@@ -1,11 +1,12 @@
 {
-  "schema": "receiz.ai-skill-contract.v106",
+  "schema": "receiz.ai-skill-contract.v108",
   "name": "receiz-constitutional-laws",
+  "version": "108.0.0",
   "requires": {
-    "sdk": ">=106.0.0 <107.0.0",
-    "mcp": ">=106.0.0 <107.0.0",
-    "ruleset": "106.0.0",
-    "registryDigest": "bf851c209e807309672c0f466411baa5607ce6b3195fe4eb16755edfeb7f5a1a"
+    "sdk": ">=108.0.0 <109.0.0",
+    "mcp": ">=108.0.0 <109.0.0",
+    "ruleset": "108.0.0",
+    "registryDigest": "126ca9283fee4ef4c398dbcb958e861cbea191724fdab8eb08df55ff0c14bb79"
   },
   "laws": [
     "receiz.registry.digest-alignment",
@@ -55,4 +56,3 @@
   ],
   "maximumAutonomousAuthority": "inspect-plan-scaffold-test"
 }
-

package/receiz-cross-app-state/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: receiz-cross-app-state
+description: Use when carrying verified namespaced account state between Receiz applications without a shared app database or identity fork.
+---
+
+# Receiz Cross-App State
+
+Continue the same Receiz identity across applications by restoring portable account truth and appending isolated namespaces. Cross-app continuation is an identity primitive, not session sharing.
+
+## Binding v108 artifact law
+
+A Receiz artifact is the exact byte sequence returned by native Record -> Seal. The inner payload is never an acceptable substitute.
+
+A verified proof object is not limited to the platform that created it. Any lawful platform may append authenticated ownership and history only while preserving the same immutable object identity, payload, provenance root, prior history, and unknown namespaces, then returning a complete verified proof object.
+
+Label every byte sequence before cross-app use:
+
+- `payload`: application bytes exposed separately only after the enclosing artifact verifies.
+- `sealed artifact`: the indivisible SDK-issued Record -> Seal bytes carrying integrity, Signature V4, owner, claim, verify path, provenance, and payload binding.
+
+## Required SDK artifact workflow
+
+```ts
+const payload = { bytes: applicationPayload, mimeType: applicationMimeType };
+const sealedArtifact = await receiz.assets.createProofObject(
+  { assetType: "proof_object", payload },
+  { filename: applicationFilename, idempotencyKey },
+);
+const downloadEvidence = await receiz.artifacts.download(sealedArtifact);
+const opened = await receiz.artifacts.verifyAndOpen(savedArtifactFile);
+if (downloadEvidence.artifactSha256 !== sealedArtifact.artifactSha256) throw new Error("artifact_digest_mismatch");
+if (opened.sealedArtifact.artifactSha256 !== sealedArtifact.artifactSha256) throw new Error("saved_artifact_mismatch");
+if (opened.verifiedPayload.sha256 !== sealedArtifact.payloadSha256) throw new Error("payload_binding_mismatch");
+```
+
+Independently hash the saved bytes and require equality with `sealedArtifact.artifactSha256`. Require `verification.ok`, `integrity.ok`, carrier `native-record-seal`, Signature V4, owner, claim, and verify-path agreement. Reopen the exact saved file with `verifyAndOpen`, then prove a different Receiz application preserves identity, cards, history, receipts, and unknown namespaces. Current exports use native Record -> Seal; verified legacy artifacts remain read-compatible only.
+
+## Twelve-step artifact workflow
+
+1. Label the input bytes as `payload`; never call them an artifact.
+2. Load the active signed v108 registry and `ARTIFACT-001` through `ARTIFACT-010`.
+3. Call `receiz.assets.createProofObject` so Receiz.com performs native Record -> Seal.
+4. Require an SDK-issued `receiz.native-record-seal`; failure returns no artifact and no payload fallback.
+5. Require complete enclosing-artifact verification, integrity, Signature V4, owner, claim, verify path, and payload binding.
+6. Call `receiz.artifacts.download` with only that SDK-issued sealed artifact.
+7. Independently hash the exact saved artifact bytes without repacking or relabeling them.
+8. Require the saved artifact digest to equal the SDK-issued artifact digest.
+9. Reopen the exact saved file through `receiz.artifacts.verifyAndOpen` before payload extraction.
+10. Pass only `opened.verifiedPayload.bytes` to domain parsers and preserve unknown namespaces.
+11. Exercise a different Receiz application projection and prove identity, ownership history, namespaces, and byte round trip remain intact.
+12. Record every production-ready evidence field below and refuse completion if any field is absent or failing.
+
+When MCP is available, use only these current artifact tools; each remains subordinate to the SDK and enclosing proof:
+
+- `receiz_artifact_record_seal_plan`
+- `receiz_artifact_record_seal_execute`
+- `receiz_artifact_verify`
+- `receiz_artifact_extract_verified`
+- `receiz_artifact_round_trip_check`
+- `receiz_artifact_explain`
+
+## Artifact prohibitions
+
+- Never download an unsealed payload fallback.
+- Never call an inner payload a Receiz artifact.
+- Never relabel payload bytes as a Receiz artifact.
+- Never repack, wrap, recompress, or modify native Record -> Seal bytes.
+- Never treat shape validation as artifact verification.
+- Never delete unknown cross-application namespaces.
+- Never rewrite immutable ownership or provenance history.
+- Never weaken a failing test to accept payload-only continuity.
+- Never claim success from UI rendering alone.
+
+## Production-ready evidence
+
+Refuse to call the artifact production-ready when any field is absent or failing:
+
+```md
+SDK version:
+Registry digest:
+Artifact law version:
+Artifact carrier:
+Signature version:
+Artifact digest:
+Payload digest:
+Owner and claim binding:
+Independent verification result:
+Cross-platform round-trip result:
+Legacy compatibility result:
+Release-lock result:
+```
+
+## Exact SDK operation
+
+Use the current root SDK identity verifier and complete-artifact custody methods. Do not import the historical v107 continuity client.
+
+```ts
+import { createReceizClient } from "@receiz/sdk";
+
+const receiz = createReceizClient({ accessToken });
+const identityFile = await receiz.identity.readArtifact(identityArtifactFile);
+const account = await receiz.identity.projectAccount(identityFile);
+const carried = await receiz.artifacts.verifyAndOpen(crossAppStateArtifactFile);
+
+const next = await receiz.assets.createProofObject(
+  {
+    assetType: "proof_object",
+    payload: { bytes: nextNamespacedStateBytes, mimeType: "application/json" },
+  },
+  { filename: "cross-app-state.receiz", idempotencyKey },
+);
+await receiz.artifacts.download(next);
+```
+
+`nextNamespacedStateBytes` must retain the admitted `account.owner.uid`, cite `carried.sealedArtifact.artifactSha256`, preserve every unknown namespace, and append only the authorized application namespace. Native Record -> Seal creates the next proof object.
+
+## Required authority
+
+The verified Record, Seal, Key, or Vault supplies local identity authority. Native reseal requires the admitted session or delegated Record and Seal scopes. An application may append only its explicitly allowed namespace.
+
+## Required proof object
+
+Require the complete identity artifact and complete cross-application state artifact. Verify both enclosing objects before projection. An inner JSON document, database row, receipt, or proof head cannot replace either artifact.
+
+## Deterministic behavior
+
+Bind idempotency to the application namespace, prior artifact digest, next payload digest, and admitted UID. Preserve exact prior bytes and immutable history. Every changed state creates a new artifact.
+
+## Offline behavior
+
+Project verified portable state immediately in the destination application. Persist the exact artifact bytes. Background synchronization may append verified additions later without remounting or downgrading the settled surface.
+
+## Conflict behavior
+
+Reject unauthorized or previously occupied namespaces. Preserve every conflicting verified artifact, stop the affected namespace lane, and require a declared append resolution that cites both histories.
+
+## Result verification
+
+Require the same admitted UID, exact downloaded bytes, native Record -> Seal continuity, Signature V4, owner/claim/path binding, payload binding, and independent verification in the destination application.
+
+## User confirmation
+
+Show the admitted UID, prior artifact digest, destination namespace, data categories, next payload digest, and exact Record -> Seal plan. Require confirmation before creating the next artifact.
+
+## MCP parity
+
+Call `receiz_artifact_verify` and `receiz_artifact_extract_verified` for input, require exact digest confirmation through `receiz_artifact_record_seal_plan`, execute with `receiz_artifact_record_seal_execute`, and finish with `receiz_artifact_round_trip_check`. MCP cannot read or rewrite another application namespace directly.
+
+## Emulator fixture
+
+Run current native artifact round-trip, destination reopen, namespace-preservation, and artifact-substitution rejection contracts. Historical v107 reconcile fixtures are archival evidence only.

package/receiz-cross-app-state/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Receiz Cross-App State"
+  short_description: "Continue verified state across apps"
+  default_prompt: "Use $receiz-cross-app-state to carry verified sealed artifacts across Receiz applications without payload substitution or history rewrite."