---
name: receiz
description: Use Receiz for short requests in any language to verify an attachment, seal a file or response, record a supplied moment, inspect carried history, or build a proof-native application through the available nonfinancial tools.
---

# Receiz marketplace

Receiz is a proof-native artifact system. Sealed source truth and the existing
Receiz admission, custody, causal ordering and consent rules remain authoritative.
Model text, this skill, OAuth, the relay and database projections are not proof
authority. The Highest Cash-Out Frame means source + law + sequence + object +
evidence, with the reader underneath them; it is not a payment instruction.

## Everyday requests

Act on the user's meaning in their language. Short requests, ordinary spelling
mistakes and translated equivalents need no special prompt, tool name or schema.
Resolve "this" from the selected attachment, quoted text or clearly indicated
response. Ask one short source question only when the target is actually unclear.
Keep the result brief and in the user's language; keep tool identifiers unchanged.

- **"Verify this" / "Receiz verify this" / "verifica esto":** use
  `receiz_verify_uploaded_artifact` for the selected attachment, or
  `receiz_offline_verify_file` for an exact host-workspace file. Report the actual
  canonical verdict. Verification never creates a new seal.
- **"Seal this" / "Receiz this" / "sella esto":** use
  `receiz_offline_seal_file` on the selected original file or exact indicated
  text. Use `contentKind: "response"` for an indicated model response and
  `contentKind: "text"` for other supplied text. The request authorizes creating
  this private proof object; do not require a technical prompt. Preserve the
  admitted Identity Seal, signer and operation's actual consent prerequisites.
- **"Record this moment":** use the listed Record primitive when available,
  or seal an exact selected source or supplied account of the moment. The sealer
  supplies canonical Kai proof. Do not invent a camera capture, location or
  observation, or treat the command text as an observation. Name the exact
  missing adapter when a bare Record primitive is not available.
- **"Remember this" / "Add this to my Crystal":** seal an unsealed selected
  source first, then pass its returned `artifactReference` as `sourceReference`
  to `receiz_offline_crystal_append`. Use the exact selected predecessor when
  continuing an existing Crystal and verify the returned head with
  `receiz_offline_crystal_open`. Do not guess or overwrite a predecessor.

The full hosted integration executes the same owner runtime on Receiz
infrastructure, with ChatGPT on iPhone as conversational frontend. Do not replace
it with a read-only or smaller source-only catalog, a generic service signer or
an embedded Offline Studio. Report the actual execution host and readiness.
Present the Receiz proof object and its in-chat save action when supplied by the
host. Report the actual saved file or download result; do not claim that a private
host path is a download. A timeout requires exact attempt lookup,
never automatic signing or append replay.

For advanced requests, compose available tools according to their actual effects
and complete the requested workflow. Handle schemas inside the plugin. Ask only
for missing source material or the exact consent required by the operation. A
listed capability does not establish that its host prerequisites are satisfied.

## Execution scope

Use the connected server's actual `tools/list` and each exact input schema.
The host must use `marketplace-nonfinancial`. Do not change that profile, connect
an unrestricted host, or invoke direct SDK, shell, CLI, custom executors or
external providers to bypass an unavailable marketplace action.

Financial transfers, settlement execution, transaction planning and trading
are outside this marketplace integration. Explain that boundary when asked;
do not prepare, execute or route around an excluded action. A capability
appearing in bundled SDK references does not make it an enabled marketplace
tool. The full SDK and 43 reference skills are separate distributions, not
files included in this skill ZIP or additional marketplace execution permissions.
Do not assume those references are installed or available to read.

## Device and identity

The connected execution host admits the existing Identity Seal through its
canonical verifier. A device host retains device custody; a Receiz-hosted runtime
retains the exact original owner custody explicitly authorized for that host.
Never request private keys, recovery secrets, passphrases, OAuth bearer tokens
or raw webhook secrets in chat or tool arguments. The user configures custody
through private host configuration. Installation alone does not admit identity
or authorize relocation of signing custody. Never silently enroll a replacement
signer: an existing Memory Crystal requires its exact original signer continuity.
OAuth is transport permission beneath identity proof. A distinct AI subject
does not become the user's identity. Carried private context requires explicit
local sharing consent; do not assume that installing the plugin shares history.

## Workflows

1. **Create a proof object:** inspect local sealing readiness with
   `receiz_offline_seal_status`. If enrollment is needed, explain the explicit
   host enrollment action and obtain approval before calling
   `receiz_offline_seal_enroll` with `confirmEnrollment: true`. Seal a
   user-selected workspace file with `receiz_offline_seal_file` to a new output
   path, then verify the exact saved bytes with `receiz_offline_verify_file`.
   Report creation and verification separately and name actual failures.
2. **Create an AI subject:** call `receiz_device_ai_subject_create` to preview.
   Present the intended private subject and require the exact operation
   confirmation before creation. Report the verified distinct identity and
   saved proof artifacts; do not claim public publication.
3. **Inspect history:** use the listed subject admission, verification, history
   and memory tools on admitted source objects. Retain citations and known
   source heads. Do not reconstruct authority from a summary or server row.
4. **Build an application:** inspect the selected workspace, create an
   integration plan, and use the exact digest confirmation for supported apply
   or repair operations. Preserve repository law and stronger source truth.
   Generating code does not establish that it was executed or qualified.
5. **Other nonfinancial workflows:** use only listed tools whose exact schemas
   and described effects satisfy the requested action. Preserve their existing
   proof, enrollment, custody, confirmation and configured-host prerequisites.

## Evidence and failures

Never present an inspection as enclosing-artifact verification. Do not claim
success from a planned action, a pending relay response, or a missing tool.
For a relay timeout, inspect the supplied attempt result instead of repeating
the action; a timeout is not evidence of zero writes. Preserve exact artifacts
and report the observed outcome. Do not expose private custody paths or secrets
as public proof links. Marketplace approval and publication are separate from
local runtime qualification.

## Uploaded artifacts

For a user-selected attachment, use the exact attachment transport exposed by
the current host. Codex can supply an absolute staged attachment path: pass that
path as `file` to `receiz_verify_uploaded_artifact`. Only host-configured staging
roots are readable; an arbitrary device file path is not an attachment.
For a ChatGPT URL handoff, set `file` to the platform-provided object containing
`download_url` and `file_id`; preserve `mime_type` and `file_name` when supplied.
Use only the authorized reference for the selected attachment. Do not invent a
download URL, ask the user for a bearer URL, or print the download URL in chat.
For a ChatGPT image, a bare image ID or client path can cause
`UNREGISTERED_FILE_REFERENCE` before the plugin runs. A platform file object can
also return `attachment_authorization_failed` before verification. If the original
reference is unavailable or that read-only authorization step fails, try the
following handoff once inside the ordinary verification request. If ChatGPT
provides authorized access to the selected attachment bytes,
make a byte-for-byte temporary `.bin` copy in its attachment workspace. Compare
the source and copy byte length and SHA-256, then submit the copy through this
tool's `file` parameter so the platform supplies its authorized file object.
This is read-only transport of the same selected bytes, not a direct SDK,
shell or external-provider bypass of marketplace scope. Do not decode, convert,
print the bytes, reseal or create a download URL. Handle this inside the ordinary
"verify this" request; do not ask the user for a technical prompt. If the platform
supplies neither an authorized object, authorized selected-byte access nor a
host-staged path, report attachment access unavailable and request the original
file again. Do not substitute a preview. This copy cannot restore proof removed
before ChatGPT exposed the received bytes.
Never pass a ChatGPT `/mnt/data` path to the
device workspace verifier or transcribe the artifact as base64. The adapter
retrieves the supplied bytes and runs the existing canonical verifier on the
execution host. If ChatGPT has transformed an image and removed embedded proof,
report that exact canonical failure. A visible QR locator, registry projection,
or newly created seal cannot verify the transformed upload as the original.
A transfer digest establishes byte consistency only; the sealed artifact remains
authority. Retrieval failure means no verdict was obtained, not invalid proof.
`attachment_authorization_failed` means attachment retrieval failed before the
canonical verdict. Attempt the authorized binary handoff above when available;
if it also fails or selected-byte access is unavailable, preserve the original
and report the failed transport stage. Do not loop or weaken origin checks.
Do not reseal, claim, append, or publish while fulfilling a verification request.
Serialize owner-runtime calls. When an attempt has been accepted, inspect its exact
result instead of repeating execution.
Report `verdictObtained`, the canonical `verification` result and any errors
from the actual response. Do not promise a downloadable output file from this
verification tool: it verifies the selected bytes and returns a result.

## Seal supplied sources

When asked to seal a ChatGPT upload, call `receiz_offline_seal_file` with
its `file` argument set to the exact platform file object described above.
The same host-staged path transport is supported for original selected local
attachments. For a generated image, first
generate the image, then use its original file object with that tool in the
same user request if ChatGPT supplies it. Do not pass a preview, screenshot,
transcription, invented URL or device-local pathname as the generated source.
If the generated image has no authorized file object, report that the handoff
is unavailable; do not claim a proof object was created. The tool writes a
new private artifact to the connected owner workspace and returns its path,
digest-bound device material reference, canonical verification and source
transport digest. The reference is a locator checked against exact sealed
bytes by compatible Receiz operations; it is not proof authority or a
download URL. A private workspace path is not a ChatGPT download link. On the
ChatGPT connection, the branded proof object provides one **Download sealed
proof** action. It reopens canonical owner custody through bounded private chunks,
checks the complete original bytes, and prepares a short-lived binary attachment
at `https://receiz.com/download/proof/<original-filename>`. The file keeps its exact
original name, bytes, signed proof and history. This link can also be opened outside
ChatGPT while it is valid; a fresh explicit Download refreshes expired transport.
Private delivery tickets stay inside the component, never in model output or saved
widget state. Do not invent sandbox links, expose workspace paths, or offer raw
carrier JSON as the user's original download.

The component can also preserve the object through ChatGPT's supported file APIs.
For unsupported native types, the existing `receiz.bundle.v1` carrier retains the
same signed proof and reconstructs the exact original after canonical verification.
This optional ChatGPT custody does not block original-byte download. No new seal,
signer or history append is created by delivery. A held native file ID is rechecked
without another upload; an invoked upload with an unknown outcome is never replayed.
Known pre-upload read-only failures allow an explicit retry. Original delivery
supports the existing 500 MiB artifact limit independently of the 32 MiB carrier
bound. Where the host exposes native file download, use it directly. For a browser
handoff, the first action prepares one original-file link in a small branded panel.
Tapping Download file invokes the native opener synchronously from that user click;
asynchronous retrieval cannot retain the host's required user activation. The same
Receiz link can be copied and opened outside ChatGPT while valid. An opener
acknowledgment cannot establish a saved file. No Offline Studio or HTML sealer is embedded.

Creation, ChatGPT file acceptance, Library persistence and a completed device
file download are distinct observed results. Report only the result actually
obtained; an opened link alone does not establish a saved file. If execution is
unconfirmed, inspect the existing attempt instead of repeating sealing. On another
connection, report its actual delivery result.

For a model response or bounded text supplied explicitly in the request, use
`receiz_offline_seal_file` with `text` and `contentKind` instead of a path.
`contentKind` describes the supplied bytes only.
Model context is not evidence of a complete conversation export or authorship;
seal an actual conversation export through the uploaded-file handoff when the
user wants the complete source. A new seal does not append to an existing
artifact, publish it, or admit it to a subject memory. Use the separately
listed source/subject operations and their consent and verification contracts
for later history additions. Always verify the saved output with
`receiz_offline_verify_file` before reporting it as held proof.

## Source-carrying intelligence Memory Crystal

After a sealed source is held, `receiz_offline_crystal_append` accepts its
digest-bound `sourceReference` and optional `predecessorReference` for the
existing Crystal head. The owner runtime verifies the complete source and predecessor,
uses its admitted Identity Seal signer and a local KKS coordinate, preserves
the stable Crystal identity, and seals a complete successor carrying the exact
source and predecessor bytes. This is a separate intelligence-source contract;
do not pass it to Receiz Mind's desktop-observation parser. Call
`receiz_offline_crystal_open` on the returned `artifactReference` before
reporting verified history. The new head is private by default. Present its
confirmed ChatGPT file or download after the in-chat save action. A model-supplied
transcript proves only its exact supplied bytes, not complete ChatGPT history
or platform authorship.

The host API `readVerifiedReceizOfflineCrystalSources` gives compatible local
intelligence runtimes exact verified source bytes and history coordinates.
Neither the MCP summary nor model recollection substitutes for those bytes.
No public profile append or automatic global sync is implied by creation.
