@receiz/ai-skills 110.0.0 → 112.0.0

package/README.md

@@ -1,13 +1,25 @@
 # Receiz AI Skills
 
+The `112.0.0` package is a registry-bound operating-contract distribution beneath Receiz proof authority. AI instructions, MCP confirmations, JSON objects, database rows, staging references, and receipts never become proof or runtime authority.
+
+## V112 artifact authority chain
+
+The exact current sequence is: verify exact bytes → profile admission → verified actor/history → transition → plan/domain/effects/idempotency → plan-bound capability → seal → durable stage → independent byte resolution → atomic named-domain acceptance → report-only receipt.
+
+Exact bytes cross a process only as bytes and require `reverify-exact-bytes`. Verified artifacts, admissions, histories, actors, plans, verified capabilities, candidates, and stores require `same-runtime-custody`. Identity Seal signing uses local key custody, supports Ed25519 and P-256, and produces a signed claim—not verified capability authority. Private keys and passphrases are never serialized.
+
+The exact current artifact MCP tools are `receiz_artifact_verify`, `receiz_artifact_admit`, `receiz_artifact_append_plan`, `receiz_artifact_transition_seal_and_stage`, and `receiz_artifact_transition_commit`. A sealed candidate is a proof object but not the accepted head. Stage writes no head and its reference is non-authoritative. Commit resolves and reverifies staged bytes before atomic named-domain acceptance. `COMMIT_DOMAIN_MISMATCH` is distinct from same-domain `IDEMPOTENCY_CONFLICT`; registry-derived effects stay outside the portable transition digest; unknown namespaces remain byte-preserved.
+
+`client.admission.browserStore` is durable admission coordination only: it stores no proof object or sealed artifact bytes and never blocks known-artifact first paint. `client.admission.remoteStore` and `client.admission.reconcileOffline` are explicitly unavailable in v112. Receiz-generated files retain declared ownership, while `receiz.extensions.ts` is developer-owned and must never be overwritten.
+
 `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 skill names remain packaged for compatibility. Seven operation skill names first introduced in obsolete-versioned now
-describe current v110 outcomes for identity profiles, portable continuity, bearer ownership, offline transport,
+describe current v112 outcomes for identity profiles, portable continuity, bearer ownership, offline transport,
 proof media, cross-app state, and admission evidence. Their retired obsolete-versioned mechanisms are not active defaults.
-Every current manifest uses schema and version `v110` / `110.0.0`, requires SDK/MCP `>=110.0.0 <111.0.0`, and binds ruleset `110.0.0` to registry digest `824aa4af849c4840ba94535798eab36e45d514703b6ae0cd30d4aa53f3c896e4`.
+Every current manifest uses version `112.0.0`, requires SDK/MCP `>=112.0.0 <113.0.0`, and binds ruleset `112.0.0` to the exported current v112 registry digest.
 
 This package teaches AI agents how to understand, verify, build with, and operate Receiz from the existing repository surfaces.
 
@@ -27,9 +39,9 @@ Agents may acquire scoped delegated access through the official Receiz Connect/O
 
 ## 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 operation skill for SDK/MCP implementation and a constitutional skill for broader system law. Stable obsolete-versioned wire schemas remain available only through the explicit historical `@receiz/sdk/obsolete-versioned` package entry; current skills never teach their key, head, receipt, reconcile, or signed-command mechanics as a v110 outcome.
+Start with `receiz-build-production-system` when work spans multiple constitutional domains. Its machine-readable manifest requires the exact active canonical v112 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 obsolete-versioned wire schemas remain available only through the explicit historical `@receiz/sdk/obsolete-versioned` package entry; current skills never teach their key, head, receipt, reconcile, or signed-command mechanics as a v112 outcome.
 
-The v110 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.
+The v112 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 obsolete-versioned schema names and their head/receipt mechanics remain explicitly historical compatibility, not the active/default profile, bearer, or proof-media contract.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@receiz/ai-skills",
-  "version": "110.0.0",
-  "description": "Authoritative Receiz AI operating skills for proof-native SDK and MCP agents.",
+  "version": "112.0.0",
+  "description": "Registry-bound Receiz AI operating contracts beneath proof authority for SDK and MCP agents.",
   "type": "module",
   "files": [
     "README.md",

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

@@ -8,7 +8,7 @@ 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 v110 artifact law
+## Binding v112 artifact law
 
 A Receiz artifact is the exact byte sequence returned by native Record -> Seal. The inner payload is never an acceptable substitute.
 
@@ -21,6 +21,8 @@ Label every byte sequence generated or consumed by the application:
 
 ## Required SDK artifact workflow
 
+The exact v112 application-operation inventory is `receiz.artifact.verify`, `receiz.artifact.admit`, `receiz.artifact.append.plan`, `receiz.identity.capability.sign`, `receiz.artifact.transition.seal`, `receiz.artifact.transition.stage`, `receiz.artifact.transition.commit`, `receiz.admission.command.execute`, and `receiz.public-proof.projection.locate`. These identifiers describe the application authority matrix; they do not create authority.
+
 ```ts
 const payload = { bytes: applicationPayload, mimeType: applicationMimeType };
 const sealedArtifact = await receiz.assets.createProofObject(
@@ -39,7 +41,7 @@ Independently hash the saved bytes and require equality with `sealedArtifact.art
 ## Twelve-step artifact workflow
 
 1. Label the input bytes as `payload`; never call them an artifact.
-2. Load the active signed v110 registry and `ARTIFACT-001` through `ARTIFACT-010`.
+2. Load the active canonical v112 registry and `ARTIFACT-001` through `ARTIFACT-030`.
 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.
@@ -53,12 +55,11 @@ Independently hash the saved bytes and require equality with `sealedArtifact.art
 
 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`
+- `receiz_artifact_admit`
+- `receiz_artifact_append_plan`
+- `receiz_artifact_transition_seal_and_stage`
+- `receiz_artifact_transition_commit`
 
 ## Artifact prohibitions
 
@@ -202,20 +203,20 @@ Resources:
 - [Generated-file repair](resources/generated-file-repair.md)
 - [Upgrade rules](resources/upgrade-rules.md)
 
-## v110 unified admission and recovery
+## v112 unified admission and recovery
 
-Use `receiz.artifacts.admit(file)` to verify the complete artifact before classification. Verdicts are exactly `canonical-identity`, `bearer-recovery`, `verified-legacy-read`, `foreign-owner`, or `invalid`. Every verified result must report `canRestore`, `canSign`, `canClaimOwnership`, `canPublish`, and `canSettle` without inferring stronger authority from possession.
+First call `verifyReceizArtifact(file)`. Then call `receiz.artifacts.admit(verification, profileOptions)` in the same runtime. Admission reports profile membership and primitive-specific assessments; it does not authorize an operation. Verified actor evidence exists only after identity-profile admission, never from a caller constraint or structural object.
 
-Use `receiz.artifacts.planRecovery(admission)` for an explicit read-only plan, or `receiz.artifacts.admitAndRecover(file)` for zero-network, read-only verification and recovery planning. Both perform zero writes. The standard proof history, parent links, ownership transitions, terminal events, unknown namespaces, plan digest, and explicit permitted actions must remain intact. Explanation is not authority; the underlying sealed proof object remains authority.
+Call `verifyReceizArtifact(file)`, then `receiz.artifacts.admit(verification, profileOptions)`, and pass the runtime-custodied admission, verified history, actor evidence, registry law, named commit domain, event, expected head, and idempotency identity to `planArtifactAppend`. Planning performs zero writes and preserves unknown namespaces byte-for-byte.
 
-Commit only through `receiz.artifacts.commitRecovery(plan, capability, idempotencyKey, store)`. Raw capability authority is forbidden. MCP JSON must never carry a capability or store object; use runtime-resolved verified capability and a caller-provided local atomic store. The SDK/MCP/AI operation identity must match.
+Seal and durably stage the plan-bound candidate before commit. Commit independently resolves and reverifies the staged bytes inside the named domain, then advances the head atomically. A receipt reports acceptance and cannot re-enter any authority-bearing API.
 
 - Never admit a card-only payload as a Receiz artifact.
 - Never treat an explanation as proof authority.
 - Never accept raw capability JSON as recovery authority.
-- Never hide mutation inside `admitAndRecover` or a recovery plan.
+- Never hide mutation inside admission or append planning.
 
-Current MCP parity: `receiz_artifact_admit`, `receiz_artifact_recovery_plan`, `receiz_artifact_admit_and_recover`, and `receiz_artifact_recovery_commit`.
+Current MCP parity is exactly `receiz_artifact_verify`, `receiz_artifact_admit`, `receiz_artifact_append_plan`, `receiz_artifact_transition_seal_and_stage`, and `receiz_artifact_transition_commit`.
 
 Required completion evidence:
 
@@ -227,3 +228,13 @@ Recovery plan digest:
 Operation identity:
 Atomic commit result:
 ```
+
+## v112 artifact-derived authority
+
+Engineers remain free to build whatever they choose, but conforming Receiz receivers recognize authority only when every authority-bearing value is provably derived from independently verified artifact truth. Custom JavaScript objects, callbacks, normalized histories, local receipts, server rows, sessions, MCP memory, and AI explanations remain application data or inspection material; their shape never creates Receiz authority.
+
+Admission begins from runtime-custodied verification of the exact enclosing artifact bytes under the complete frozen verifier context. Verified history and actor evidence remain same-runtime objects and fail closed on divergence or structural reconstruction. Identity Seal signing uses a locally held Ed25519 or P-256 key and emits a signed capability claim; only current verification of that claim against the exact plan produces capability authority.
+
+Deterministic plan identity and unique execution-attempt identity are separate. MCP may reuse a confirmation digest only while the identical attempt is actively pending; committed and failed attempts are terminal and require a fresh confirmation. Expected authority failures are structured, immutable, machine-readable, and report zero writes.
+
+Historical sealed proof objects remain exact-byte verifiable evidence. Historical runtime admissions, histories, actors, capabilities, plans, candidates, stores, or confirmations cannot authorize a current v112 receiver; exact bytes crossing a process require `reverify-exact-bytes`, followed by current profile admission and `same-runtime-custody` through plan, capability, seal, stage, independent byte resolution, atomic named-domain acceptance, and report-only receipt.

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

@@ -1,14 +1,14 @@
 {
-  "schema": "receiz.ai-skill-contract.v110",
+  "schema": "receiz.ai-skill-contract.v112",
   "name": "receiz-app-builder-skill",
-  "version": "110.0.0",
+  "version": "112.0.0",
   "requires": {
-    "sdk": ">=110.0.0 <111.0.0",
-    "mcp": ">=110.0.0 <111.0.0",
-    "ruleset": "110.0.0",
-    "registryDigest": "824aa4af849c4840ba94535798eab36e45d514703b6ae0cd30d4aa53f3c896e4"
+    "sdk": ">=112.0.0 <113.0.0",
+    "mcp": ">=112.0.0 <113.0.0",
+    "ruleset": "112.0.0",
+    "registryDigest": "1356f8122d0b5fcbe891d7e6ed1e75faca827f15d63d1ed5d950664e11c146ee"
   },
-  "artifactLawVersion": "110.0.0",
+  "artifactLawVersion": "112.0.0",
   "artifactLaws": [
     "ARTIFACT-001",
     "ARTIFACT-002",
@@ -24,7 +24,22 @@
     "ARTIFACT-012",
     "ARTIFACT-013",
     "ARTIFACT-014",
-    "ARTIFACT-015"
+    "ARTIFACT-015",
+    "ARTIFACT-016",
+    "ARTIFACT-017",
+    "ARTIFACT-018",
+    "ARTIFACT-019",
+    "ARTIFACT-020",
+    "ARTIFACT-021",
+    "ARTIFACT-022",
+    "ARTIFACT-023",
+    "ARTIFACT-024",
+    "ARTIFACT-025",
+    "ARTIFACT-026",
+    "ARTIFACT-027",
+    "ARTIFACT-028",
+    "ARTIFACT-029",
+    "ARTIFACT-030"
   ],
   "laws": [
     "receiz.artifact.sealed-truth",
@@ -37,9 +52,15 @@
     "artifacts.download",
     "artifacts.verifyAndOpen",
     "artifacts.admit",
-    "artifacts.planRecovery",
-    "artifacts.admitAndRecover",
-    "artifacts.commitRecovery"
+    "artifact.verify",
+    "artifact.admit",
+    "artifact.append.plan",
+    "identity.capability.sign",
+    "artifact.transition.seal",
+    "artifact.transition.stage",
+    "artifact.transition.commit",
+    "admission.command.execute",
+    "public-proof.projection.locate"
   ],
   "allowedTools": [
     "receiz_project_inspect",
@@ -48,9 +69,10 @@
     "receiz_app_check",
     "receiz_release_qualify",
     "receiz_artifact_admit",
-    "receiz_artifact_recovery_plan",
-    "receiz_artifact_admit_and_recover",
-    "receiz_artifact_recovery_commit"
+    "receiz_artifact_verify",
+    "receiz_artifact_append_plan",
+    "receiz_artifact_transition_seal_and_stage",
+    "receiz_artifact_transition_commit"
   ],
   "forbiddenOperations": [
     "direct-state-write",
@@ -63,7 +85,27 @@
     "hidden-recovery-mutation",
     "explanation-as-authority",
     "raw-capability-authority",
-    "card-payload-admission"
+    "card-payload-admission",
+    "structural-object-as-authority",
+    "caller-verifier-as-history-authority",
+    "parseable-key-as-signing-authority",
+    "terminal-mcp-confirmation-reuse",
+    "historical-runtime-object-as-current-authority",
+    "projection-as-artifact-authority",
+    "runtime-shape-as-v112-authority",
+    "subpayload-hash-as-enclosing-authority",
+    "unaccepted-candidate-as-committed",
+    "staging-reference-without-byte-resolution",
+    "receipt-as-proof-authority",
+    "cross-domain-idempotency-conflict",
+    "external-effects-in-transition-digest",
+    "serialized-sdk-authority",
+    "mcp-property-bag-authority",
+    "generic-constitutional-artifact-mutation",
+    "confirmation-as-proof-authority",
+    "receipt-actor-as-runtime-identity",
+    "browser-proof-object-storage",
+    "known-artifact-first-paint-blocking"
   ],
   "requiredInputs": [
     "repository-root",
@@ -93,7 +135,25 @@
     "zero-network-read-only-coordinator",
     "atomic-recovery-commit",
     "operation-identity-parity",
-    "multi-application-convergence"
+    "multi-application-convergence",
+    "canonical-exact-byte-readmission",
+    "complete-verifier-context-digest",
+    "independent-proof-history-evidence-roots",
+    "domain-separated-signing-challenge",
+    "distinct-plan-and-attempt-identities",
+    "structured-zero-write-failures",
+    "exact-nine-row-operation-matrix-parity",
+    "exact-five-tool-mcp-parity",
+    "process-boundary-parity",
+    "exact-byte-reverification",
+    "identity-seal-ed25519-p256-signing",
+    "neutral-staging-zero-head-writes",
+    "independent-staged-byte-resolution",
+    "named-domain-atomic-acceptance",
+    "report-only-receipt",
+    "browser-ledger-no-proof-bytes",
+    "generated-file-ownership-preservation",
+    "current-registry-payload-digest-equality"
   ],
   "requiredCompletionFields": [
     "sdk-version",
@@ -122,9 +182,168 @@
     "release-lock-pass",
     "zero-network-verification",
     "local-verifier-result",
-    "v110-admission-recovery-conformance",
+    "v112-artifact-authority-conformance",
     "no-hidden-mutation",
     "explanation-remains-non-authoritative"
   ],
-  "maximumAutonomousAuthority": "inspect-plan-scaffold-test"
+  "maximumAutonomousAuthority": "inspect-plan-scaffold-test",
+  "operationAuthorityMatrix": [
+    {
+      "operation": "artifact.verify",
+      "authorityProfiles": [],
+      "inputAuthority": "exact-artifact-bytes",
+      "requiredEvidence": [
+        "exact-artifact-bytes",
+        "pinned-verifier-roots"
+      ],
+      "outputAuthority": "verified-artifact-runtime",
+      "processBoundary": "reverify-exact-bytes",
+      "namespacePolicy": "not-applicable",
+      "compatibleSdkRange": ">=112.0.0 <113.0.0"
+    },
+    {
+      "operation": "artifact.admit",
+      "authorityProfiles": [],
+      "inputAuthority": "verified-artifact-runtime",
+      "requiredEvidence": [
+        "verified-artifact-runtime",
+        "admission-profile",
+        "current-registry"
+      ],
+      "outputAuthority": "verified-admission-runtime",
+      "processBoundary": "same-runtime-custody",
+      "namespacePolicy": "not-applicable",
+      "compatibleSdkRange": ">=112.0.0 <113.0.0"
+    },
+    {
+      "operation": "artifact.append.plan",
+      "authorityProfiles": [
+        "artifact-local",
+        "global-shared"
+      ],
+      "inputAuthority": "verified-admission-runtime",
+      "requiredEvidence": [
+        "verified-admission-runtime",
+        "verified-history-runtime",
+        "verified-actor-runtime",
+        "discovered-registry-law-runtime",
+        "commit-domain",
+        "canonical-event",
+        "expected-head",
+        "idempotency-identity"
+      ],
+      "outputAuthority": "sdk-plan-runtime",
+      "processBoundary": "same-runtime-custody",
+      "namespacePolicy": "preserve-all-non-target",
+      "compatibleSdkRange": ">=112.0.0 <113.0.0"
+    },
+    {
+      "operation": "identity.capability.sign",
+      "authorityProfiles": [],
+      "inputAuthority": "identity-key-file",
+      "requiredEvidence": [
+        "identity-key-file",
+        "capability-payload"
+      ],
+      "outputAuthority": "signed-capability-claim-not-yet-verified",
+      "processBoundary": "local-identity-key-custody",
+      "namespacePolicy": "not-applicable",
+      "compatibleSdkRange": ">=112.0.0 <113.0.0"
+    },
+    {
+      "operation": "artifact.transition.seal",
+      "authorityProfiles": [
+        "artifact-local",
+        "global-shared"
+      ],
+      "inputAuthority": "sdk-plan-runtime",
+      "requiredEvidence": [
+        "sdk-plan-runtime",
+        "verified-capability-runtime",
+        "transition-sealer-runtime"
+      ],
+      "outputAuthority": "sealed-candidate-proof-object-not-accepted-head",
+      "processBoundary": "same-runtime-custody",
+      "namespacePolicy": "preserve-all-non-target",
+      "compatibleSdkRange": ">=112.0.0 <113.0.0"
+    },
+    {
+      "operation": "artifact.transition.stage",
+      "authorityProfiles": [
+        "artifact-local",
+        "global-shared"
+      ],
+      "inputAuthority": "sealed-candidate-runtime",
+      "requiredEvidence": [
+        "sealed-candidate-runtime",
+        "conforming-transition-store-runtime",
+        "commit-domain"
+      ],
+      "outputAuthority": "staged-candidate-locator-non-authoritative",
+      "processBoundary": "same-runtime-custody",
+      "namespacePolicy": "preserve-all-non-target",
+      "compatibleSdkRange": ">=112.0.0 <113.0.0"
+    },
+    {
+      "operation": "artifact.transition.commit",
+      "authorityProfiles": [
+        "artifact-local",
+        "global-shared"
+      ],
+      "inputAuthority": "staged-candidate-reference",
+      "requiredEvidence": [
+        "sdk-plan-runtime",
+        "verified-capability-runtime",
+        "staged-candidate-reference",
+        "conforming-transition-store-runtime",
+        "commit-domain"
+      ],
+      "outputAuthority": "accepted-artifact-history-with-report-only-receipt",
+      "processBoundary": "same-runtime-custody",
+      "namespacePolicy": "preserve-all-non-target",
+      "compatibleSdkRange": ">=112.0.0 <113.0.0"
+    },
+    {
+      "operation": "admission.command.execute",
+      "authorityProfiles": [
+        "artifact-local",
+        "global-shared",
+        "projection-only",
+        "simulation-only"
+      ],
+      "inputAuthority": "claimed-command",
+      "requiredEvidence": [
+        "claimed-command",
+        "current-registry",
+        "capability-verifier-runtime",
+        "consequence-projector-runtime",
+        "admission-store"
+      ],
+      "outputAuthority": "admission-receipt-non-authoritative",
+      "processBoundary": "same-runtime-custody",
+      "namespacePolicy": "not-applicable",
+      "compatibleSdkRange": ">=112.0.0 <113.0.0"
+    },
+    {
+      "operation": "public-proof.projection.locate",
+      "authorityProfiles": [
+        "projection-only"
+      ],
+      "inputAuthority": "projection-only",
+      "requiredEvidence": [
+        "projection-locator"
+      ],
+      "outputAuthority": "exact-artifact-bytes-not-yet-verified",
+      "processBoundary": "projection-only",
+      "namespacePolicy": "not-applicable",
+      "compatibleSdkRange": ">=112.0.0 <113.0.0"
+    }
+  ],
+  "currentMcpArtifactTools": [
+    "receiz_artifact_verify",
+    "receiz_artifact_admit",
+    "receiz_artifact_append_plan",
+    "receiz_artifact_transition_seal_and_stage",
+    "receiz_artifact_transition_commit"
+  ]
 }

package/receiz-app-builder-skill/resources/generated-file-repair.md

@@ -6,5 +6,7 @@ and request confirmation before writing.
 
 Automatic edits are limited to generated files, approved `package.json` fields,
 and explicit generated blocks. Unmarked source becomes a manual action. Preserve
-all unrelated code. Reject traversal, symlink escape, stale previews, and content
+the declared owner of every Receiz-generated file. `receiz.extensions.ts` is always
+developer-owned and must never be overwritten, regenerated, or adopted by Receiz.
+Preserve all unrelated code. Reject traversal, symlink escape, stale previews, and content
 whose digest changed after review.

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

@@ -13,5 +13,7 @@ After every mutation, run the returned verification commands and reinspect.
 The same repository must produce zero changes on the second run.
 Preserve the developer-owned `receiz.extensions.ts` sibling on every run. Finish with `receiz conformance` or `receiz_release_qualify`.
 
+For v112 artifact mutation, use the exact five-tool MCP sequence: `receiz_artifact_verify`, `receiz_artifact_admit`, `receiz_artifact_append_plan`, `receiz_artifact_transition_seal_and_stage`, then `receiz_artifact_transition_commit`. Planning and staging perform zero head writes; commit independently resolves and reverifies staged bytes before atomic named-domain acceptance.
+
 Do not substitute inspection for verification, publication for settlement, or a
 successful write for proof admission.

package/receiz-architecture/SKILL.md

@@ -10,7 +10,7 @@ Map domains, sources of truth, state machines, dependency direction, and cross-d
 ## Constitutional workflow
 
 1. Inspect the repository and installed SDK version.
-2. Load the active signed registry and applicable constitutional laws.
+2. Load the active canonical v112 registry and applicable constitutional laws.
 3. Identify every authority boundary affected by the change.
 4. Write the implementation contract before implementation.
 5. Implement canonical changes only through SDK commands.
@@ -51,3 +51,12 @@ Request: Map domains, sources of truth, state machines, dependency direction, an
 
 Return a written implementation contract and read-only plan first. Execute only allowed commands after exact confirmation, then report registry digest, laws, authority, tests, independent evidence, release-lock status, and the exact remaining boundary.
 
+## v112 artifact-derived authority
+
+Engineers remain free to build whatever they choose, but conforming Receiz receivers recognize authority only when every authority-bearing value is provably derived from independently verified artifact truth. Custom JavaScript objects, callbacks, normalized histories, local receipts, server rows, sessions, MCP memory, and AI explanations remain application data or inspection material; their shape never creates Receiz authority.
+
+Admission begins from runtime-custodied verification of the exact enclosing artifact bytes under the complete frozen verifier context. Verified history and actor evidence remain same-runtime objects and fail closed on divergence or structural reconstruction. Identity Seal signing uses a locally held Ed25519 or P-256 key and emits a signed capability claim; only current verification of that claim against the exact plan produces capability authority.
+
+Deterministic plan identity and unique execution-attempt identity are separate. MCP may reuse a confirmation digest only while the identical attempt is actively pending; committed and failed attempts are terminal and require a fresh confirmation. Expected authority failures are structured, immutable, machine-readable, and report zero writes.
+
+Historical sealed proof objects remain exact-byte verifiable evidence. Historical runtime admissions, histories, actors, capabilities, plans, candidates, stores, or confirmations cannot authorize a current v112 receiver; exact bytes crossing a process require `reverify-exact-bytes`, followed by current profile admission and `same-runtime-custody` through plan, capability, seal, stage, independent byte resolution, atomic named-domain acceptance, and report-only receipt.