# Install Receiz in your AI

Receiz is a proof-native artifact system. This download contains the executable MCP runtime, required
SDK runtime and production dependencies, one scoped assistant skill, and manual
setup files. It requires Node.js 22 or newer, installed separately.
You do not need to install the Receiz packages from npm. No personal identity,
signing keys, access tokens or reviewer credentials are included.

## Give your AI one link

Ask: **Install Receiz from https://receiz.com/developers/install**.

An AI with local file access, command execution and permission to configure its
MCP host can complete the local installation below. The current machine-readable
download index is https://receiz.com/downloads/ai/manifest.json. It identifies the
exact archive, guide, configuration files and assistant instructions, with byte
lengths and SHA-256 checksums. Resolve its file paths against https://receiz.com.

For an AI performing the installation:

1. Inspect the host's supported MCP setup and existing Receiz configuration.
   Read the current manifest and its guide; use the current archive entry rather
   than guessing a filename, version or Git branch.
2. Download the complete ZIP, check its byte length and SHA-256, and extract the
   complete `receiz` folder into a permanent location. Check Node.js 22 or newer.
   Runtime dependencies are included; do not install separate Receiz npm packages.
3. Reuse the user's existing Identity Seal path and any existing signer,
   workspace and subject directories. Ask for the local path if it is unknown.
   Keep identity files and passphrases out of AI attachments and messages.
   Do not bootstrap a replacement identity or enroll signing custody without
   the user's explicit approval of that operation.
4. Merge `manual/mcp.json` or `manual/codex.toml` into the supported host setup,
   replacing only the runtime and Identity Seal path placeholders. Preserve
   other servers. Import `marketplace-skills/receiz` if the host supports skills,
   then reconnect the MCP host and follow the readiness check in section 3.
5. Report the actual discovered tools and returned sealing readiness. Installation
   is complete when the host executes those checks; writing configuration or
   reading instructions alone is not a working connection. If the host needs a
   restart, permission or identity selection, identify that exact remaining step.

ChatGPT and other hosted AI frontends use the authenticated Receiz connection
in the hosted section below. Connecting that account through the platform's
supported install flow is required; downloading this local ZIP does not install
or start a hosted runtime. Instructions cannot supply execution to a host that
does not support MCP tools.

## 1. Download and keep the package

Download the ZIP at https://receiz.com/developers/install. Compare its SHA-256
with the checksum shown there. On macOS use `shasum -a 256 <download.zip>`;
on Linux use `sha256sum <download.zip>`; in Windows PowerShell use
`Get-FileHash <download.zip> -Algorithm SHA256`. A checksum checks downloaded
bytes; it does not verify a Receiz proof object.

Extract the archive. Keep the complete `receiz` folder in a permanent location
such as your home directory's Applications folder. Keep `runtime`, `scripts`,
`marketplace-skills` and the hidden plugin files together. Do not run from inside
the ZIP. Run `node --version` in your terminal; the major version must be 22 or
higher. If Node is missing, install it from https://nodejs.org before continuing.

## 2. Continue with your existing Identity Seal and Receiz ID

Keep your original Identity Seal in a private, permanent location on your device.
The runtime verifies the enclosing artifact, its Receiz ID binding and proof of
control, then uses that admitted identity for supported tools. Your Receiz ID text
alone is not a substitute for the identity proof. Do not attach private identity
artifacts to an AI conversation.

The supplied configurations use your existing Identity Seal. A passphrase-free
seal needs no password or passphrase environment variable. Only a selected
password-encrypted identity artifact needs its existing passphrase, configured
privately as `RECEIZ_SUBJECT_IDENTITY_PASSPHRASE` in the host environment.
That secret unlocks encrypted custody; the verified identity proof remains the
authority. Do not invent a new password for a passphrase-free seal.

### Connect a local MCP host

Your AI must support local MCP servers over stdio and be allowed to launch Node.
Use `manual/mcp.json` for hosts accepting an `mcpServers` JSON configuration
(including compatible Claude Desktop and Cursor configurations). Merge the
`receiz` entry into the host's existing configuration instead of replacing other
servers. The exact settings location is owned by your AI host.

Replace `/ABSOLUTE/PATH/TO/receiz/scripts/start-mcp.mjs` with the actual extracted
script path. Also replace `/ABSOLUTE/PATH/TO/your-identity-seal.png` with the
absolute path to your original Identity Seal file (use its actual filename and
extension). Example runtime path on macOS: `/Users/you/Applications/receiz/scripts/start-mcp.mjs`.
Example Windows JSON: `C:\\Users\\you\\Applications\\receiz\\scripts\\start-mcp.mjs`.
If a desktop host cannot find `node`, replace the command with its full executable
path (`command -v node` on macOS/Linux, `where.exe node` on Windows).

For hosts with a form instead of a configuration file, enter:

- Name: `receiz`
- Transport: `stdio` / local command
- Command: `node` (or its absolute executable path)
- Argument: the absolute path to `scripts/start-mcp.mjs`
- Environment: `RECEIZ_SUBJECT_IDENTITY_PATH=<absolute path to your Identity Seal>`
- Environment: `RECEIZ_MCP_EXECUTION_PROFILE=marketplace-nonfinancial`

Do not use shell quotes as part of a JSON argument. Paths with spaces work as
one array entry. Save, restart or reconnect the host's MCP connection, and allow
its startup prompt. Allow up to 120 seconds if the host has a startup-timeout
setting. Check local signing readiness below; first-time signing enrollment
requires connectivity and explicit approval.

### Codex

Merge `manual/codex.toml` into `~/.codex/config.toml`, replacing both absolute paths.
Restart the connection and start a new conversation. The archive also contains
the native `.codex-plugin/plugin.json` and `.mcp.json` for hosts that support
local plugin installation. Before enabling that connection, set the Identity
Seal path in its `.mcp.json` to your original file. The placeholder must be
replaced; the supplied plugin configuration does not bootstrap a new identity.
Choose one connection method to avoid duplicate tools.
See https://developers.openai.com/codex/mcp for current host configuration mechanics.

### Assistant instructions

If your host supports skills, install `marketplace-skills/receiz` using its skill
import mechanism. Otherwise attach its `SKILL.md` or paste it into your assistant's
project instructions. Keep all files together when installing a folder-based skill.
Instructions alone
do not install tools, grant permissions or expand the connection's scope.

## 3. Confirm the connection

Start a new conversation and ask:

> Use receiz_capabilities with action describe. Report the tools available on this
> connection. Then use receiz_offline_seal_status to report local sealing readiness.
> Do not create, replace or publish any proof object.

You should see actual tool calls and their returned status. A prose answer alone
does not establish a working connection. The capability inventory describes the
full distribution; the host's discovered tool list defines this connection.

If the status says local sealing is not ready, ask your assistant to explain the
one-time device-signing enrollment. Explicitly approve
`receiz_offline_seal_enroll` with `confirmEnrollment: true` when you are ready.
The tool enrolls the local signer under the already admitted identity; it does
not replace your Receiz ID. Recheck readiness before creating a proof object.

For your first file, put a small text file in `~/.receiz/workspace` and ask:

> Receiz seal this.

The default profile exposes reviewed nonfinancial tools. Financial transfers,
Settlement, Reserve transaction planning and unrestricted executors are excluded
from this connection. The included runtime does not authorize bypassing the selected profile. Each operation retains its own
proof, custody, consent and host prerequisites.

## Verify an original attachment

Select the original file in your assistant and ask:

> Receiz verify this.

The assistant uses `receiz_verify_uploaded_artifact` and reports the actual
canonical verdict, `verdictObtained` and any failed stage. No technical prompt
is needed. Verification never seals or replaces the selected original.

The updated tools accept a local host's absolute staged attachment path or a
hosted platform's authorized file object. The latter carries `download_url` and
`file_id`, plus `mime_type` and `file_name` when supplied. Never invent a URL or
replace the original with a screenshot, converted photo or model transcription.
An existing workspace file uses `receiz_offline_verify_file` with `inputPath`.

When ChatGPT cannot register an image reference but provides authorized access
to the selected file's bytes, the assistant prepares an exact temporary binary
copy inside ChatGPT and submits it through the same attachment tool. It checks
equal length and SHA-256 without decoding, converting or resealing. The user still
asks only "Receiz verify this." If no authorized byte handoff is available, the
assistant reports that transport failure. A binary copy cannot restore embedded
proof that the platform removed before exposing the uploaded file.

Every file extension reaches the existing canonical verifier. A sealed artifact
must carry its proof; an unsealed or unsupported file receives the canonical
result rather than a claimed success. Attachment transport retains its current
32 MiB bound. This is separate from the proof verdict.

`verdictObtained: false` means verification could not run, not that the proof is
invalid. `attachment_authorization_failed` occurs before proof verification.
Update older local tools and reconnect before retrying a rejected attachment.
Do not alter, reseal or discard the original as a repair.

### Attachment host configuration

The launcher recognizes Codex's `codex-remote-attachments` staging directory
beneath the host temporary directory and `/tmp` on Unix. If another compatible
host stages files elsewhere, its administrator configures
`RECEIZ_ATTACHMENT_LOCAL_ROOTS` as a JSON array of exact attachment directories.
Keep private custody outside these directories. Arbitrary device file paths are
not attachments. This is byte-access configuration, not proof authority.

For hosted URL handoffs, configure `RECEIZ_ATTACHMENT_DOWNLOAD_ORIGINS` on the
device host as comma-separated exact HTTPS origins confirmed from authorized
platform references. No origin is implicitly trusted. Do not use wildcards,
local-network origins or model-supplied lists. Keep signed URLs out of logs.
Both host configuration variables are forwarded by the plugin.

## ChatGPT: the full hosted Receiz connection

ChatGPT is the conversational frontend. Receiz infrastructure executes the full
nonfinancial SDK/MCP owner runtime with your admitted identity, original custody
and verified sources. A configured hosted owner runtime does not need your Mac
awake. The local Node ZIP is a separate installation: attaching it to a ChatGPT
conversation does not start a runtime or install a ChatGPT plugin.

1. In ChatGPT Plugins, install the full Receiz plugin made available to your
   account. If your administrator provides a custom connection instead, enable
   Developer mode in Settings → Security and login where available and use the
   registered OAuth client and exact callback with
   `https://receiz.com/api/mcp/device`. Choose OAuth, not anonymous access.
2. Connect the Receiz account whose existing Identity Seal and original custody
   the owner runtime admits. Keep private identity artifacts, passphrases and
   transport credentials out of chat. Installing the plugin alone does not provision
   hosted custody, relocate a signer or make a private developer app public.
3. Enable Receiz in a conversation and ask `Receiz, check that you are ready.`
   Require actual tool results. The full reviewed profile has 195 nonfinancial
   tools, including sealing, verification, private AI subjects and Memory Crystal
   operations. The discovered tool list and returned readiness determine this
   account's available operations; each retains its actual prerequisites.
4. Select an original attachment and ask `Receiz verify this`. To seal supplied
   text or a response, ask `Receiz seal this: My first proof object.` To record a
   supplied account of a moment, ask `Receiz record this moment: …`. Then ask
   `Keep that in a Memory Crystal.` Short requests and translated equivalents
   use the same tools without a technical prompt.
5. Tap **Download sealed proof** on the branded proof object in the conversation.
   It delivers the exact original sealed file, preserving its filename, signed
   proof and history. The private download uses `receiz.com` and can be opened
   outside ChatGPT while its short-lived link is valid. Tap Download again to
   refresh expired transport. If the small Receiz panel appears, tap **Download file**
   in the small Receiz panel. That same original-file link can also be copied
   outside the conversation.

ChatGPT can also retain the object through its supported file APIs. Where the
platform needs the existing `receiz.bundle.v1` carrier, it preserves the same
signed proof and reconstructs the exact original. The original download remains
available independently of that handoff. No sealer or Offline Studio is embedded.
A download creates no new seal, signer or history append. Original delivery
supports the existing 500 MiB artifact limit; sources above the 32 MiB carrier
bound bypass carrier composition. Device memory and platform file acceptance
require their own actual qualification.

Known read-only failures before upload allow an explicit retry. An invoked upload
with an unknown outcome is never repeated, and a held file ID is checked without
another upload. Report the actual result: file acceptance, Library persistence,
and a completed device download require separate evidence.

Open ChatGPT on iPhone using the same ChatGPT account and enable its available
Receiz plugin. Computation stays on the configured Receiz host. Physical iPhone
execution and exact file delivery need separate acceptance evidence. If Photos
or Files transforms an image and removes its embedded proof, the transformed
upload cannot verify as the original. Keep the complete original or an existing
proof-bearing Receiz bundle. A QR locator alone does not supply its proof.

Account/workspace controls and private developer-app access can limit
installation. Public marketplace approval, directory publication and another
account's original-custody setup are separate steps; the public local download
supplies neither a private ChatGPT app nor another owner's signing custody.
Current host mechanics: https://developers.openai.com/plugins/deploy/connect-chatgpt

### Discovery-only public connection

The separate unauthenticated `https://receiz.com/api/mcp` connection supports
capability discovery, supplied-field inspection and integration planning. It
does not supply full sealing or Memory Crystal execution. Its inspection result
is not an enclosing-artifact verification verdict. Choose it only for those
limited public tools.

### Administrator setup: hosted or local owner runtime

Full execution reuses the existing `/api/mcp/device` transport and canonical
owner runtime. Register the actual OAuth client and exact redirect URI through
Receiz Connect: https://receiz.com/developers/receiz-connect. Resource-bound grants
for `https://receiz.com/api/mcp/device` are separate: the ChatGPT caller uses
`openid mcp:execute`; the owner worker uses `openid mcp:device`. Optional refresh
requires explicitly authorized `offline_access`. OAuth permits transport beneath
identity proof; it cannot manufacture identity or ownership.

A Receiz-hosted worker requires explicitly authorized original custody, its exact
Identity Seal/signer, verified owner binding and durable private workspace.
Retain original Memory Crystal signer continuity. Host deployment must qualify
identity admission, readiness, restart recovery, existing Crystal access and
actual operations before claiming account availability. Do not replace missing
custody with a service signer or a smaller read-only catalog.

A device-held local worker remains an optional deployment. On that host only,
configure `RECEIZ_MCP_DEVICE_RELAY_TOKEN` with the worker grant and
`RECEIZ_DEVICE_TRANSPORT_OWNER_ID` with the selected Receiz account UID.
Optional refresh variables are `RECEIZ_MCP_DEVICE_RELAY_REFRESH_TOKEN`,
`RECEIZ_MCP_DEVICE_RELAY_CLIENT_ID` and, for confidential clients,
`RECEIZ_MCP_DEVICE_RELAY_CLIENT_SECRET`. The launcher inherits them privately.
Keep this local worker awake while it executes; the configured hosted deployment
has no such Mac requirement. The admitted Identity Seal must prove the owner
binding. Neither caller nor relay credentials are SDK authority.

A queued or timed-out attempt has an unknown outcome. Inspect its exact returned
attempt locator; do not resubmit signing, append or save to guess the outcome.

## Identity, files and updates

Reuse your existing Identity Seal and keep the same `RECEIZ_SUBJECT_IDENTITY_PATH`
on subsequent starts. The verified artifact, its identity binding and proof of
control establish authority. A passphrase is only the unlock mechanism for a
selected password-encrypted artifact.

Your seal remains where you placed it. Working files default to
`~/.receiz/workspace`; use `RECEIZ_OFFLINE_WORKSPACE` to choose another workspace.
The existing-identity path stores local signing custody in `~/.receiz/offline-seal`
and subject continuity in `~/.receiz/subjects`, unless you configured other paths.
These locations live outside the replaceable tools package.

### Optional: create a separate local identity

Choose this only if you want a separate local identity instead of continuing
with your existing Identity Seal. In the connection's environment settings,
remove `RECEIZ_SUBJECT_IDENTITY_PATH` and any identity passphrase setting, then
set `RECEIZ_MCP_DEVICE_BOOTSTRAP=1`. Keep
`RECEIZ_MCP_EXECUTION_PROFILE=marketplace-nonfinancial` unchanged.

First bootstrap enrolls the local signer online and creates encrypted identity
custody in `~/.receiz/mcp-device`. It generates and stores the local secret
automatically; you do not choose a password. Later starts reuse that custody.
This identity does not automatically become your existing account. If you already
used this bootstrap path, keep that configuration and custody when updating;
do not switch identity or discard its files as an update step.

### Update the tools, preserve your identity

Stop the connection, extract the new package into a new versioned folder, and
update only the runtime script path. Preserve the selected identity path, all
configured custody directories and the workspace. Reconnect and check readiness.
Keep the previous software package until the updated connection passes that check.
Never delete identity or custody to force an update or recover from an error.
Replacing software must not replace identity or held proof.

The current kit includes the attachment verification update. Its checksum
identifies the exact package even when the coordinated release version remains
the same. Use the latest archive linked at https://receiz.com/developers/install.
Updating the API alone does not update an installed local runtime. Local users
must install the corrected package and reconnect. Hosted users need no local
download when their administrator updates the server and connected owner runtime;
refresh the hosted connection's tool metadata after that update. Automatic
plugin updates have not been qualified.

## Use Receiz Mind alongside your AI

Open https://mind.receiz.com for Receiz Mind: connected observations, exact source
inspection, sealed Memory Crystals and evidence-grounded intelligence. The Mac
application records locally and includes a local model. Browser/PWA access to
that Mac's model requires the connected, running Mac and explicit identity-scoped
sync. The web app and Mac install are separate from this AI package.

Use your existing Receiz identity where supported and deliberately select the
files or carried state you share. The package does not automatically import Mind
memory or private conversations from ChatGPT or other assistants. Memory Crystals
remain sealed proof objects; read their supported carried content only after
verification. A generic file verification does not establish support for every
Mind-specific projection. AI answers remain interpretations beneath their sources.
Learn how the parts fit together at https://receiz.com/developers/mind.

## Troubleshooting

- `node` not found: install Node 22+; use its absolute executable path in your host.
- Script not found: extract the whole ZIP and correct the absolute script path.
- No tools: ensure local stdio MCP is supported, save the correct host config,
  reconnect, review startup errors, and begin a new conversation.
- First enrollment fails: check connectivity and returned error; retain custody
  and retry after resolving the cause. Never delete identity files to force reset.
- Existing custody cannot open: restore the exact original secret/identity files;
  do not silently substitute a new identity.
- File inaccessible: choose a file inside the configured workspace and grant the
  host access. Hosted public tools cannot read your disk.
- Unsupported operation: inspect the actual tool list and required environment.
  Do not switch profiles to bypass scope or invent a successful result.
- ChatGPT connection unavailable: check developer-mode/workspace access and the
  current official host instructions; a marketplace listing is not required for
  supported manual connections.

No installation changes your AI subscription. Receiz sealing runs locally
without network after the one-time canonical enrollment. Verification runs
locally from exact held bytes and packaged verifier resources; it needs neither
enrollment nor server confirmation. A local MCP host can call both operations
offline. Hosted ChatGPT needs connectivity to reach its configured owner runtime
on Receiz infrastructure, without a Mac worker. A URL attachment must be
downloaded first. Once held, those source bytes enter the SDK proof operation in
that runtime. Network-dependent operations retain their explicit connectivity
requirements.
