enigma-memory 0.1.15 → 0.1.16

package/docs/enigma-memory-ready-conformance.md

@@ -341,7 +341,7 @@ The negative fixture set should include intentionally unsafe keys and values so
   "subject": {
     "name_ref": "public-package-or-client-ref",
     "version": "0.0.0",
-    "enigma_version": "0.1.15"
+    "enigma_version": "0.1.16"
   },
   "commands": [
     {

package/docs/hosted-cloud-product.md

@@ -49,6 +49,8 @@ Hosted cloud remains blocked until an operator wires and records evidence for al
 
 A `provided` operator evidence ref means the contract can point to external evidence. It still does not by itself make hosted cloud sellable; an operator must complete the release checklist and issue go-live approval. A `blocked_external_dependency` ref is an explicit blocker, not fake evidence.
 
+Hosted relay/gateway readiness is a separate backend health boundary, not hosted-cloud sellability. Operators may validate the backend path with `npm run production:hosted-collect` followed by `npm run production:hosted-live`, but those commands only prove public HTTPS relay/gateway probes and required hosted refs for the named environment. They do not wire auth, billing, legal terms, support, security review, customer lifecycle, API key lifecycle, or operator SaaS go-live approval.
+
 ## Consolidated unblocker report
 
 Before treating hosted cloud as sellable, run the consolidated public-safe unblocker report:

package/docs/install-anywhere.md

@@ -1,8 +1,8 @@
 # Install Enigma anywhere
 
-Start with the published npm package path for `enigma-memory`: install once, run `enigma init --dry-run` to inspect the local plan, then execute local setup and connect real local clients only when you explicitly choose to. Use a source checkout only when you need source-only docs, Docker assets, browser-extension scaffolding, package development, or release scripts.
+Start with the published npm package path for `enigma-memory`: install once, run `enigma setup --overwrite` once, then use memory/search/context/verify/connect from the same local AI Memory Passport. Use a source checkout only when you need source-only docs, Docker assets, browser-extension scaffolding, package development, or release scripts.
 
-Hosted cloud and BYOC operation require real deployment credentials, domains, TLS, durable storage, KMS/secrets, monitoring, backups, and operator/customer infrastructure; they are not activated by installing the package, running init, or running the test drive.
+Hosted cloud and BYOC operation require real deployment credentials, domains, TLS, durable storage, KMS/secrets, monitoring, backups, and operator/customer infrastructure; they are not activated by installing the package, running setup, or running the test drive.
 
 ## Requirements
 
@@ -12,68 +12,13 @@ Hosted cloud and BYOC operation require real deployment credentials, domains, TL
 - Git only for the advanced source-checkout path
 - Optional: Docker for source-checkout containerized relay/gateway operation
 
-## First run: inspect the safe local plan
-
-Use the published package as the primary path:
-
-```sh
-npm install -g enigma-memory
-enigma init --dry-run
-```
-
-`enigma init --dry-run` emits a public-safe JSON plan with exact next commands. It writes no local artifacts, writes no third-party client configs, does not call external providers, does not contact hosted Enigma SaaS, and does not require provider credentials, Solana, or browser extension installation. The output states `provider_credentials_required:false`, `hosted_saas_live:false`, and `raw_memory_printed:false`.
-
-When the plan looks right, create the regular local workspace:
-
-```sh
-enigma init --overwrite
-```
-
-`enigma init --overwrite` writes the local bundle, context pack, export, and verify report under `.enigma` by default. It does not write Claude, Cursor, Kimi, or other third-party client configs unless you explicitly add `--connect`.
-
-The isolated proof/demo command is still available for public reviewers:
-
-```sh
-enigma test-drive --overwrite
-```
-
-`enigma test-drive --overwrite` is the one-command local proof/demo. It needs no credentials, does not call external providers, does not contact hosted Enigma SaaS, and does not write third-party client configs. It writes an isolated demo under `.enigma/test-drive` by default; use `--dry-run` to preview the plan without writing, or `--out-dir <path>` to choose a different isolated demo directory.
-
-The command emits one public-safe JSON summary with paths to the local setup artifacts, search/status output, cross-model demo report, and benchmark pointers. The default bundle lives inside the demo directory. The summary includes exact next commands for public testers and does not print raw private memory plaintext.
-
-Keep the claim bounded: the test drive proves local Enigma-controlled vault state, receipts, checkpoints, committed roots, exported bundle shape, and declared boundary operations. It does not prove hosted SaaS availability, provider deletion, model forgetting, provider-native memory removal, legal approval, ROI/savings, or compliance certification.
-
-To connect real local clients that are already installed or already configured:
-
-```sh
-enigma init --connect --overwrite
-```
-
-`--connect` is the init-time write flag for client configs. With default client selection it skips missing client configs instead of creating every default client config.
-
 ## Default path: install once, use everywhere
 
-After reviewing the first-run plan, create a regular local workspace when you want to use Enigma day to day:
+Use the published package as the primary path:
 
 ```sh
 npm install -g enigma-memory
-enigma init --dry-run
-enigma init --overwrite
-```
-
-`enigma init --overwrite` is the safe default for a regular local workspace. It writes local Enigma artifacts under the workspace `.enigma` path and emits deterministic, public-safe JSON without printing raw memory plaintext. It does not write Claude, Cursor, Kimi, or other third-party app configs.
-
-To let init auto-detect installed or already-configured clients and show the connector plan without mutating client configs:
-
-```sh
-enigma init --client auto --dry-run
-```
-
-`--client auto` selects clients found by connector detection and falls back to the default setup client list when none are present. The init output lists which clients were selected, which were skipped, and why. Existing setup commands remain available: `enigma setup --overwrite`, `enigma setup --client auto --overwrite`, and `enigma setup --connect-installed --overwrite`.
-
-After init or setup, use the same local vault from the CLI or connected clients:
-
-```sh
+enigma setup --overwrite
 enigma remember --text-file ./memory.txt
 enigma search --query "..."
 enigma context --query "..." --optimize
@@ -81,9 +26,11 @@ enigma verify --export ./.enigma/export.json
 enigma connect claude-desktop --dry-run
 ```
 
+`enigma setup --overwrite` writes local Enigma artifacts under the workspace `.enigma` path and emits deterministic, public-safe JSON without printing raw memory plaintext. It does not write Claude, Cursor, Kimi, or other third-party app configs. Client config writes happen only when you explicitly run `enigma connect <client>` without `--dry-run`.
+
 The local Enigma vault is the canonical memory passport. Provider-native memory is non-canonical cache only. Enigma proof covers Enigma-controlled vault state, receipts, checkpoints, committed roots, and exported bundle shape; it does not prove provider deletion, model forgetting, provider-native memory removal, hosted/BYOC availability, legal approval, ROI/savings, or compliance certification.
 
-One-off public test drive without a global install:
+Optional public test drive without a global install:
 
 ```sh
 npx --yes --package enigma-memory enigma test-drive --overwrite
@@ -230,15 +177,63 @@ Npm-first connector flow:
 
 ```sh
 npm install -g enigma-memory
-enigma init --dry-run
-enigma init --overwrite
-enigma init --client auto --dry-run
-enigma init --connect --overwrite
+enigma setup --overwrite
+enigma connect claude-desktop --dry-run
+```
+
+Run `enigma setup --overwrite` for a regular local workspace. It writes local Enigma artifacts only. Use `enigma connect <client> --dry-run` when you want to preview one client config without writing it; remove `--dry-run` only when you explicitly want Enigma to merge that MCP entry while preserving unrelated client settings.
+
+Copy-paste MCP snippets:
+
+Claude Desktop:
+
+```json
+{
+  "mcpServers": {
+    "enigma": {
+      "command": "enigma-mcp",
+      "args": [],
+      "env": {
+        "ENIGMA_BUNDLE": "/absolute/path/to/.enigma/bundle.json"
+      }
+    }
+  }
+}
+```
+
+Cursor:
+
+```json
+{
+  "mcpServers": {
+    "enigma": {
+      "command": "enigma-mcp",
+      "args": [],
+      "env": {
+        "ENIGMA_BUNDLE": "/absolute/path/to/.enigma/bundle.json"
+      }
+    }
+  }
+}
 ```
 
-Run `enigma init --dry-run` first to inspect the safe local plan without credentials, hosted SaaS, provider calls, raw memory output, or client-config writes. Run `enigma init --overwrite` for a regular local workspace. Use `--client auto --dry-run` when you want init to report installed/config-present connector targets without writing client configs. Use `--connect` only when you explicitly want init to merge Enigma into installed/config-present client configs by default; missing configs are skipped with reasons instead of created. Existing `enigma setup --overwrite`, `enigma setup --client auto --overwrite`, `enigma setup --connect-installed --overwrite`, and `enigma setup --write-connectors` behavior remains available. For a single client, replace `claude-desktop` with `cursor`, `kimi-code`, `vscode-cline`, `roo`, `opencode`, or `generic-mcp` and run `enigma connect <client> --dry-run` before writing.
+Kimi Code:
+
+```json
+{
+  "mcpServers": {
+    "enigma": {
+      "command": "enigma-mcp",
+      "args": [],
+      "env": {
+        "ENIGMA_BUNDLE": "/absolute/path/to/.enigma/bundle.json"
+      }
+    }
+  }
+}
+```
 
-Copy-paste MCP entry for Claude Desktop, Cursor, Kimi Code, or a generic MCP client:
+Generic MCP:
 
 ```json
 {

package/docs/memory-benchmarks.md

@@ -12,12 +12,13 @@ For official-dataset retrieval/evidence proxy scoring over operator-downloaded f
 
 ```sh
 cd enigma
+node scripts/run-standard-memory-benchmarks.mjs --locomo ./data/locomo10.json --longmemeval ./data/longmemeval_s_cleaned.json --max-locomo-qa 100 --max-longmemeval-items 100 --top-k 5 --dry-run
 node scripts/run-standard-memory-benchmarks.mjs --locomo ./data/locomo10.json --out ./.enigma/locomo-standard-memory-benchmark.json
 node scripts/run-standard-memory-benchmarks.mjs --longmemeval ./data/longmemeval_s_cleaned.json --top-k 5 --out ./.enigma/longmemeval-standard-memory-benchmark.json
 node scripts/run-standard-memory-benchmarks.mjs --locomo ./data/locomo10.json --longmemeval ./data/longmemeval_s_cleaned.json --max-locomo-qa 100 --max-longmemeval-items 100 --out ./.enigma/standard-memory-benchmark.json
 ```
 
-The standard report schema is `enigma.standard_memory_benchmark_suite.v1`. It reads local official dataset JSON files only, scores deterministic retrieval/evidence coverage proxies, and still excludes raw question, answer, and conversation text from reports.
+The standard dry-run schema is `enigma.standard_memory_benchmark_plan.v1`. It prints planned local file names, sample bounds, local deterministic method rows, a requirements-only Mem0 adapter row, apples-to-apples controls, and explicit no-network/no-provider/no-Mem0/no-score boundaries without reading dataset files. The scored standard report schema is `enigma.standard_memory_benchmark_suite.v1`. It reads local official dataset JSON files only, scores deterministic retrieval/evidence coverage proxies, includes Mem0 as requirements-only with `scores_included:false`, and still excludes raw question, answer, and conversation text from reports.
 
 The report schema is `enigma.memory_benchmark_suite.v1`. It is public-safe by design: aggregate metrics, commitments, citations, boundaries, and cross-provider profile labels are emitted, but raw fixture memory, question text, and answer text are not included.
 
@@ -52,9 +53,11 @@ Numeric token and latency values in generated reports are local fixture measurem
 
 ## Official dataset retrieval/proxy runner
 
-`scripts/run-standard-memory-benchmarks.mjs` is the dependency-free runner for official dataset files already present on disk. It supports `--locomo <path>`, `--longmemeval <path>`, `--max-locomo-qa <n>`, `--max-longmemeval-items <n>`, `--top-k <n>` (default `5`), and optional `--out <path>`. Supplying only one dataset path scores only that dataset.
+`scripts/run-standard-memory-benchmarks.mjs` is the dependency-free runner for official dataset files already present on disk. It supports `--locomo <path>`, `--longmemeval <path>`, `--max-locomo-qa <n>`, `--max-longmemeval-items <n>`, `--top-k <n>` (default `5`), `--dry-run`, and optional `--out <path>`. Supplying only one dataset path scores only that dataset.
 
-Reports include only the input file name plus the input SHA-256, not the full local path, so operator usernames or workstation directories are not persisted.
+Use `--dry-run` before a scored run when publishing benchmark evidence. The plan proves only command shape and offline boundaries: it does not read or hash the files, prove they exist, produce scores, call provider APIs, run Mem0, run competitor SDKs, generate answers, grade answer accuracy, or spend API budget.
+
+Reports include only the input file name plus the input SHA-256, not the full local path, so operator usernames or workstation directories are not persisted. Scored reports also include `command_boundaries` and `apples_to_apples_controls` so reviewers can see that all local rows used the same parsed records, same `--top-k`, same scoring labels, and no gold labels for retrieval selection.
 
 The runner parses LoCoMo `conversation` session turns as memory records and maps evidence labels such as `D1:3` or `D8:6; D9:17` to dialog IDs. It parses LongMemEval `haystack_sessions` turns as memory records, uses `has_answer: true` turns plus `answer_session_ids` as gold evidence, and treats `_abs` question IDs as abstention cases.
 

package/docs/proof-network-build-notes.md

@@ -1,6 +1,6 @@
 # Proof Network build notes
 
-These notes are for future engineers extending Enigma's privacy-preserving Proof Network into a Solana program or hosted verifier. The 0.1.15 scope is local-only: create and verify public-safe proof artifacts, prepare opaque root batches for future chain anchoring, and never submit transactions or write private memory material into proof payloads.
+These notes are for future engineers extending Enigma's privacy-preserving Proof Network into a Solana program or hosted verifier. The 0.1.16 scope is local-only: create and verify public-safe proof artifacts, prepare opaque root batches for future chain anchoring, and never submit transactions or write private memory material into proof payloads.
 
 Paths below are relative to `enigma/`.
 
@@ -202,7 +202,7 @@ On-chain accounts should store compact hashes, counters, timestamps, and public
 
 A hosted verifier can add convenience, not authority over private content. It may validate schema ids, JSON Schemas, package validators, canonical hashes, packet nesting, artifact counts, and public registry/chain observations. It must return bounded public-safe error codes and never echo private submitted values.
 
-Verifier non-goals: no raw memory ingestion, provider transcript ingestion, embedding upload endpoint, tenant-name lookup endpoint, Solana transaction submission, or hosted secret custody in the 0.1.15 proof-network layer.
+Verifier non-goals: no raw memory ingestion, provider transcript ingestion, embedding upload endpoint, tenant-name lookup endpoint, Solana transaction submission, or hosted secret custody in the 0.1.16 proof-network layer.
 
 ## Targeted test plan
 

package/docs/proof-network.md

@@ -92,7 +92,7 @@ Example:
 ```sh
 enigma chain anchor \
   --root sha256:8f0f7d2b7b7f4f2a3e4b9a3d1f0f2c3b4a5d6e7f8091a2b3c4d5e6f708192a3b \
-  --ref release:enigma:0.1.15 \
+  --ref release:enigma:0.1.16 \
   --ref memory-root:public-demo-2026-06-25 \
   --out ./.enigma/proof-network-anchor.json
 ```
@@ -144,8 +144,8 @@ Example:
 ```sh
 enigma chain revoke \
   --issuer did:example:enigma-issuer \
-  --grant-ref grant:sha256:2a0f6d8c1e3b5a799887766554433221100ffeeddccbbaa998877665544332211 \
-  --reason-ref operator-request:2026-06-25 \
+  --grant-hash sha256:2a0f6d8c1e3b5a799887766554433221100ffeeddccbbaa998877665544332211 \
+  --reason operator-request-2026-06-25 \
   --out ./.enigma/proof-network-revocation.json
 ```
 
@@ -166,8 +166,8 @@ Example with a report hash:
 enigma chain attest \
   --report-hash sha256:5c3a2e1d0f9b8a7766554433221100ffeeddccbbaa99887766554433221100ff \
   --dataset-ref locomo:file-sha256:6a7b8c9d0e1f2233445566778899aabbccddeeff00112233445566778899aabb \
-  --runner-ref enigma-standard-memory-benchmark:0.1.15 \
-  --package-ref npm:@enigma-ai/enigma:0.1.15 \
+  --runner-ref enigma-standard-memory-benchmark:0.1.16 \
+  --package-ref npm://enigma-memory@0.1.16 \
   --out ./.enigma/proof-network-attestation.json
 ```
 
@@ -177,8 +177,8 @@ Example with a local report file:
 enigma chain attest \
   --report-file ./.enigma/standard-memory-benchmark.json \
   --dataset-ref longmemeval:file-sha256:7b8c9d0e1f2233445566778899aabbccddeeff00112233445566778899aabbcc \
-  --runner-ref enigma-standard-memory-benchmark:0.1.15 \
-  --package-ref npm:@enigma-ai/enigma:0.1.15 \
+  --runner-ref enigma-standard-memory-benchmark:0.1.16 \
+  --package-ref npm://enigma-memory@0.1.16 \
   --out ./.enigma/proof-network-attestation.json
 ```
 
@@ -211,6 +211,31 @@ enigma chain verify --file ./.enigma/proof-network-packet.json
 
 A successful local verification means the artifact matches a supported proof-network shape and safety boundary. It does not mean a live account exists, a transaction was accepted, or a public rail was contacted.
 
+## Flow: optional Solana Memo dry-run
+
+`enigma chain submit-solana` is the safe handoff from a verified local artifact to the optional Solana proof rail. It defaults to dry-run, validates the artifact first, and prints only the compact Memo reference that would be submitted.
+
+Dry-run command:
+
+```sh
+enigma chain submit-solana \
+  --file ./.enigma/proof-network-anchor.json \
+  --cluster devnet
+```
+
+Execute command, only after devnet gate approval and with an explicit operator keypair:
+
+```sh
+enigma chain submit-solana \
+  --file ./.enigma/proof-network-anchor.json \
+  --cluster devnet \
+  --rpc https://api.devnet.solana.com \
+  --keypair ./operator-devnet-keypair.json \
+  --execute
+```
+
+Execute mode submits one Solana Memo instruction containing only `memo_ref` JSON: schema, artifact hash, cluster, and compact proof commitment. It does not submit the artifact body, raw memory, prompts, transcripts, embeddings, provider responses, private keys, local paths, or customer identifiers.
+
 ## Privacy boundaries
 
 Proof-network artifacts are public-safe only when they follow these boundaries:

package/docs/sdk-api.md

@@ -241,7 +241,7 @@ const attestation = createBenchmarkAttestation({
   report_hash: 'sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
   dataset_ref: 'dataset-ref-public',
   runner_ref: 'runner-ref-public',
-  package_ref: 'npm:enigma-memory@0.1.15',
+  package_ref: 'npm:enigma-memory@0.1.16',
   metric_roots: ['sha256:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'],
   sample_count: 120,
   run_count: 1,

package/docs/solana-devnet-acceptance.md

@@ -33,7 +33,7 @@ enigma chain submit-solana \
   --keypair ./operator-devnet-keypair.json
 ```
 
-Network submission is opt-in only. Execute mode requires an explicit Solana cluster and keypair, lazily loads `@solana/web3.js`, and submits one Memo-program transaction containing only the compact `memo_ref` JSON:
+Network submission is opt-in only. Execute mode requires an explicit Solana cluster and Solana CLI-style 64-byte secret-key JSON keypair, lazily loads `@solana/web3.js`, and submits one Memo-program transaction containing only the compact `memo_ref` JSON:
 
 ```sh
 enigma chain submit-solana \

package/docs/solana-proof-rail.md

@@ -437,7 +437,7 @@ Mainnet use is blocked until all gates below are satisfied for the exact program
 - Use domain tags for every hash: `anchor_batch`, `capability_grant`, `capability_revocation`, `benchmark_attestation`, `job_escrow`, `operator_registry`, and `packet`.
 - Prefer fixed-size byte arrays and enums in instruction args. Avoid variable user text and arbitrary JSON on-chain.
 - Keep account sizes bounded. Store hash lists off-chain behind roots when a vector could grow without a hard cap.
-- Every chain-writing CLI command should have a local planning mode first. The default for release `0.1.15` planning artifacts is no transaction submission.
+- Every chain-writing CLI command should have a local planning mode first. The default for release `0.1.16` planning artifacts is no transaction submission.
 - Chain refs should include cluster, program id, signature/account id, and slot. They should not include RPC URLs with credentials.
 
 ## Future implementation checklist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enigma-memory",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "type": "module",
   "description": "Provider-agnostic AI memory passport and offline-verifiable proof layer.",
   "license": "Apache-2.0",
@@ -46,6 +46,7 @@
     "packages/optimizer/src/",
     "packages/mcp-server/bin/",
     "packages/mcp-server/src/",
+    "packages/mcp-server/README.md",
     "packages/mesh/src/",
     "packages/metering/src/",
     "packages/proof-network/src/",
@@ -76,6 +77,7 @@
     "scripts/build-production-backend-env-kit.mjs",
     "scripts/cloudflare-secret-env.mjs",
     "scripts/cloudflare-ops.mjs",
+    "scripts/stage-cloudflare-pages-artifact.mjs",
     "scripts/build-cloudflare-pages-release-packet.mjs",
     "scripts/build-cloudflare-token-policy.mjs",
     "scripts/build-cloudflare-token-request.mjs",
@@ -182,6 +184,10 @@
     "demo:assets": "node scripts/build-demo-assets.mjs",
     "cloudflare:ops": "node scripts/cloudflare-ops.mjs",
     "cloudflare:pages:packet": "node scripts/build-cloudflare-pages-release-packet.mjs",
+    "cloudflare:pages:stage": "node scripts/stage-cloudflare-pages-artifact.mjs --site ../enigma-deploy --out .enigma/cloudflare-pages/enigmamemory.com",
+    "cloudflare:pages:dry-run": "node scripts/stage-cloudflare-pages-artifact.mjs --site ../enigma-deploy --out .enigma/cloudflare-pages/enigmamemory.com && node scripts/cloudflare-ops.mjs pages deploy --site .enigma/cloudflare-pages/enigmamemory.com --project-name enigma-memory",
+    "cloudflare:pages:deploy": "node scripts/stage-cloudflare-pages-artifact.mjs --site ../enigma-deploy --out .enigma/cloudflare-pages/enigmamemory.com && node scripts/cloudflare-ops.mjs pages deploy --site .enigma/cloudflare-pages/enigmamemory.com --project-name enigma-memory --execute",
+    "cloudflare:pages:verify": "node scripts/cloudflare-ops.mjs pages verify --url https://enigmamemory.com/ --project-name enigma-memory --domain enigmamemory.com --cloudflare-live required",
     "cloudflare:token-policy": "node scripts/build-cloudflare-token-policy.mjs",
     "cloudflare:token-request": "node scripts/build-cloudflare-token-request.mjs",
     "infrastructure:readiness": "node scripts/infrastructure-readiness.mjs",

package/packages/connectors/src/index.js

@@ -566,6 +566,15 @@ function connectCommandFor(clientId, platform) {
   return `enigma connect ${clientId} --bundle "${publicBundlePlaceholder(platform)}"`;
 }
 
+function setupConnectCommandFor(clientId, platform) {
+  return `enigma setup --client ${clientId} --write-connectors --bundle "${publicBundlePlaceholder(platform)}" --overwrite`;
+}
+
+function installConnectCommandFor(clientId, platform) {
+  return `npm install -g enigma-memory && ${setupConnectCommandFor(clientId, platform)}`;
+}
+
+
 function wizardStepsForClient(clientId, platform) {
   const steps = [
     {
@@ -635,6 +644,10 @@ export function planConnectWizard(clientIdOrOptions = {}, maybeOptions = {}) {
       display_name: CLIENT_DEFINITIONS[clientId].display_name,
       default_config_path: publicDefaultConfigPath(clientId, platform),
       steps: wizardStepsForClient(clientId, platform),
+      one_command_install_connect: installConnectCommandFor(clientId, platform),
+      setup_connect_command: setupConnectCommandFor(clientId, platform),
+      connect_command: connectCommandFor(clientId, platform),
+      mcp_config_preview: renderMcpConfig(clientId, { platform, bundlePath: publicBundlePlaceholder(platform) }),
     })),
   };
 }

package/packages/mcp-server/README.md

@@ -0,0 +1,22 @@
+# Enigma MCP server
+
+`enigma-mcp` is the stdio MCP server installed by the `enigma-memory` package. Claude Desktop, Cursor, Kimi Code, and VS Code Cline users should prefer the CLI connector commands below instead of hand-editing MCP JSON.
+
+## One-command install and connect
+
+Pick the client you use:
+
+```sh
+npm install -g enigma-memory && enigma setup --client claude-desktop --write-connectors --overwrite
+npm install -g enigma-memory && enigma setup --client cursor --write-connectors --overwrite
+npm install -g enigma-memory && enigma setup --client kimi-code --write-connectors --overwrite
+npm install -g enigma-memory && enigma setup --client vscode-cline --write-connectors --overwrite
+```
+
+To write only MCP configs that already exist on the machine:
+
+```sh
+npm install -g enigma-memory && enigma setup --client auto --connect-installed --overwrite
+```
+
+The generated server entry uses command `enigma-mcp`, no args, and `ENIGMA_BUNDLE` pointing at the local bundle. Existing sibling MCP servers are preserved.

package/packages/mcp-server/src/index.js

@@ -17,7 +17,7 @@ import {
 const DEFAULT_BUNDLE = '.enigma/bundle.json';
 const JSONRPC_VERSION = '2.0';
 const MCP_PROTOCOL_VERSION = '2024-11-05';
-const SERVER_INFO = Object.freeze({ name: 'enigma-mcp-server', version: '0.1.15' });
+const SERVER_INFO = Object.freeze({ name: 'enigma-mcp-server', version: '0.1.16' });
 const JSON_RPC_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
 const JSON_RPC_ERROR = Object.freeze({
   INVALID_REQUEST: -32600,

package/scripts/build-benchmark-proof-release.mjs

@@ -37,6 +37,7 @@ const ALLOWED_FALSE_REPORT_KEYS = new Set([
   'benchmark_leadership_claim',
   'external_provider_calls',
   'llm_answer_accuracy_scored',
+  'credentials_required',
   'raw_benchmark_body_included',
   'report_body_copied',
   'raw_memory_included',
@@ -50,9 +51,41 @@ const ALLOWED_FALSE_REPORT_KEYS = new Set([
   'provider_invoice_savings_claim',
   'hosted_saas_claim',
 ]);
+const ALLOWED_PUBLIC_REPORT_KEYS = new Set([
+  'estimated_prompt_tokens',
+  'baseline_prompt_tokens',
+  'optimized_prompt_tokens',
+]);
 const SECRET_VALUE_RE = /(?:Bearer\s+[A-Za-z0-9._~+/=-]{12,}|Basic\s+[A-Za-z0-9+/=-]{12,}|-----BEGIN [A-Z ]*PRIVATE KEY-----|https?:\/\/[^\s/@]+:[^\s/@]+@|sk-[A-Za-z0-9_-]{16,}|AKIA[0-9A-Z]{16}|(?:seed phrase|mnemonic phrase|raw memory|private prompt|full transcript|provider response|embedding vector))/iu;
 const ABSOLUTE_LOCAL_PATH_RE = /^(?:[A-Za-z]:[\\/]|\\\\|\/(?:Users|home|tmp|var|etc|mnt|Volumes)\b)/u;
 const CLAIM_SCORE_KEY_RE = /(?:provider|competitor|roi|profit|savings|solana|transaction|answer_accuracy|leaderboard)/iu;
+const PROOF_COMPATIBLE_REPORT_SCHEMAS = new Set([
+  'enigma.memory_benchmark_suite.v1',
+  'enigma.standard_memory_benchmark_suite.v1',
+]);
+const REQUIRED_FALSE_BOUNDARY_KEYS = Object.freeze([
+  'external_provider_calls',
+  'llm_answer_accuracy_scored',
+  'provider_deletion_claim',
+  'model_forgetting_claim',
+  'roi_or_provider_invoice_savings_claim',
+  'compliance_certification_claim',
+  'benchmark_leadership_claim',
+]);
+const OPTIONAL_FALSE_BOUNDARY_KEYS = Object.freeze([
+  'provider_answer_accuracy_claim',
+  'competitor_performance_claim',
+  'solana_submission_claim',
+  'transaction_submitted',
+  'roi_or_profit_claim',
+  'provider_invoice_savings_claim',
+  'hosted_saas_claim',
+  'api_calls_made',
+  'provider_api_calls_made',
+  'network_calls_made',
+  'mem0_adapter_run',
+  'external_competitor_adapters_run',
+]);
 
 class UsageError extends Error {
   constructor(message) {
@@ -139,7 +172,7 @@ export function parseArgs(argv = process.argv.slice(2)) {
 export function usage() {
   return `Usage: node scripts/build-benchmark-proof-release.mjs --report <path> --dataset-ref <ref> --runner-ref <ref> --package-ref <ref> [--score key=value ...] [--out-dir <dir>]
 
-Builds a dependency-free, local benchmark proof release from an existing public-safe benchmark report. The report file is parsed for public-safety checks and hashed, but its body and local path are never copied into the attestation or proof packet. The generated artifacts are local benchmark attestation/proof only: no API calls, provider answer-accuracy claims, competitor performance claims, Solana submissions, hosted SaaS claims, ROI/profit/savings claims, raw memory, prompts, transcripts, embeddings, credentials, account ids, private keys, or provider responses are written.
+Builds a dependency-free, local benchmark proof release from an existing public-safe benchmark report. The report must use a compatible benchmark schema and explicit offline benchmark boundaries. The report file is parsed for public-safety checks and hashed, but its body and local path are never copied into the attestation or proof packet. The generated artifacts are local benchmark attestation/proof only: no API calls, provider answer-accuracy claims, Mem0 or competitor performance claims, Solana submissions, hosted SaaS claims, ROI/profit/savings claims, raw memory, prompts, transcripts, embeddings, credentials, account ids, private keys, or provider responses are written.
 `;
 }
 
@@ -172,7 +205,7 @@ function assertPublicReportPayload(value, path = 'report') {
   }
   if (!isPlainObject(value)) return;
   for (const [key, child] of Object.entries(value)) {
-    if (PRIVATE_REPORT_KEY_RE.test(key)) {
+    if (PRIVATE_REPORT_KEY_RE.test(key) && !ALLOWED_PUBLIC_REPORT_KEYS.has(key)) {
       if (!ALLOWED_FALSE_REPORT_KEYS.has(key) || child !== false) throw new UsageError(`${path}.${key} is not allowed in public benchmark proof artifacts`);
     }
     assertPublicReportPayload(child, `${path}.${key}`);
@@ -190,11 +223,62 @@ function parseJsonReport(bytes) {
 function reportSchema(report) {
   if (!isPlainObject(report)) throw new UsageError('report must be a JSON object');
   if (typeof report.schema !== 'string' || report.schema.trim() === '') throw new UsageError('report.schema must be a non-empty string');
+  if (!PROOF_COMPATIBLE_REPORT_SCHEMAS.has(report.schema)) throw new UsageError(`report.schema is not proof-release compatible: ${report.schema}`);
   if (report.public_safe !== true) throw new UsageError('report.public_safe must be true');
   assertPublicReportPayload(report);
+  assertProofCompatibleBenchmarkBoundaries(report);
   return report.schema;
 }
 
+function requireFalseField(row, key, path) {
+  if (row[key] !== false) throw new UsageError(`${path}.${key} must be false for a public benchmark proof release`);
+}
+
+function assertBoundaryObject(report) {
+  if (!isPlainObject(report.benchmark_boundaries)) throw new UsageError('report.benchmark_boundaries must be present for a public benchmark proof release');
+  return report.benchmark_boundaries;
+}
+
+function assertCommandBoundaries(report) {
+  if (report.command_boundaries === undefined) return;
+  if (!isPlainObject(report.command_boundaries)) throw new UsageError('report.command_boundaries must be an object when present');
+  for (const key of OPTIONAL_FALSE_BOUNDARY_KEYS) {
+    if (report.command_boundaries[key] !== undefined && report.command_boundaries[key] !== false) {
+      throw new UsageError(`report.command_boundaries.${key} must be false for a public benchmark proof release`);
+    }
+  }
+  if (report.command_boundaries.api_spend_possible !== undefined && report.command_boundaries.api_spend_possible !== false) {
+    throw new UsageError('report.command_boundaries.api_spend_possible must be false for a public benchmark proof release');
+  }
+}
+
+function assertExternalAdaptersUnscored(report) {
+  if (!Array.isArray(report.external_competitor_adapters)) return;
+  report.external_competitor_adapters.forEach((row, index) => {
+    if (!isPlainObject(row)) throw new UsageError(`report.external_competitor_adapters[${index}] must be an object`);
+    if (row.scores_included !== false) throw new UsageError(`report.external_competitor_adapters[${index}].scores_included must be false`);
+    for (const key of ['recall', 'answer_accuracy', 'latency', 'cost', 'ranking']) {
+      if (row[key] !== undefined) throw new UsageError(`report.external_competitor_adapters[${index}].${key} is not allowed without a reviewed adapter run`);
+    }
+  });
+}
+
+function assertProofCompatibleBenchmarkBoundaries(report) {
+  const boundaries = assertBoundaryObject(report);
+  for (const key of REQUIRED_FALSE_BOUNDARY_KEYS) requireFalseField(boundaries, key, 'report.benchmark_boundaries');
+  for (const key of OPTIONAL_FALSE_BOUNDARY_KEYS) {
+    if (boundaries[key] !== undefined) requireFalseField(boundaries, key, 'report.benchmark_boundaries');
+  }
+  if (report.schema === 'enigma.standard_memory_benchmark_suite.v1') {
+    if (boundaries.retrieval_evidence_proxy_scored !== true) throw new UsageError('standard benchmark report must set benchmark_boundaries.retrieval_evidence_proxy_scored true');
+  }
+  if (report.schema === 'enigma.memory_benchmark_suite.v1') {
+    if (boundaries.local_only !== true) throw new UsageError('local memory benchmark report must set benchmark_boundaries.local_only true');
+  }
+  assertCommandBoundaries(report);
+  assertExternalAdaptersUnscored(report);
+}
+
 function nonNegativeInteger(value) {
   return Number.isInteger(value) && value >= 0 ? value : undefined;
 }
@@ -242,7 +326,7 @@ function assertValidation(validation, label) {
   if (validation?.ok !== true) throw new Error(`${label} validation failed: ${(validation?.errors ?? ['unknown error']).join('; ')}`);
 }
 
-function releaseManifest({ generatedAt, reportHash, schema, args, commitments, attestation, packet }) {
+function releaseManifest({ generatedAt, reportHash, schema, sampleCount, datasetCount, args, commitments, attestation, packet }) {
   const manifest = {
     schema: BENCHMARK_PROOF_RELEASE_SCHEMA,
     generated_at: generatedAt,
@@ -254,6 +338,8 @@ function releaseManifest({ generatedAt, reportHash, schema, args, commitments, a
       report_public_safe: true,
       report_body_copied: false,
       report_path_copied: false,
+      sample_count: sampleCount,
+      dataset_count: datasetCount,
     },
     refs: {
       dataset_ref: args.datasetRef,
@@ -261,6 +347,16 @@ function releaseManifest({ generatedAt, reportHash, schema, args, commitments, a
       package_ref: args.packageRef,
     },
     score_commitments: commitments,
+    command_boundaries: {
+      deterministic_offline_proof_builder: true,
+      report_file_hashed_from_local_disk: true,
+      network_calls_made: false,
+      provider_api_calls_made: false,
+      api_spend_possible: false,
+      solana_transaction_submitted: false,
+      benchmark_scores_generated: false,
+      report_body_copied: false,
+    },
     claim_boundaries: {
       provider_answer_accuracy_claim: false,
       competitor_performance_claim: false,
@@ -306,6 +402,8 @@ export async function buildBenchmarkProofRelease(args, options = {}) {
   const reportHash = sha256Buffer(bytes);
   const report = parseJsonReport(bytes);
   const schema = reportSchema(report);
+  const sampleCount = sampleCountFromReport(report);
+  const datasetCount = Array.isArray(report.datasets) ? report.datasets.length : 0;
   const commitments = scoreCommitments(args.scores, reportHash);
   const metricRoots = commitments.map((score) => score.score_hash);
 
@@ -317,7 +415,7 @@ export async function buildBenchmarkProofRelease(args, options = {}) {
     package_ref: args.packageRef,
     report_hash: reportHash,
     metric_roots: metricRoots,
-    sample_count: sampleCountFromReport(report),
+    sample_count: sampleCount,
     run_count: 1,
   });
   assertValidation(validateBenchmarkAttestation(attestation), 'benchmark attestation');
@@ -329,7 +427,7 @@ export async function buildBenchmarkProofRelease(args, options = {}) {
   });
   assertValidation(validateProofNetworkPacket(packet), 'proof packet');
 
-  const manifest = releaseManifest({ generatedAt, reportHash, schema, args, commitments, attestation, packet });
+  const manifest = releaseManifest({ generatedAt, reportHash, schema, sampleCount, datasetCount, args, commitments, attestation, packet });
   assertPublicReportPayload(manifest, 'manifest');
 
   return Object.freeze({
@@ -377,6 +475,9 @@ export async function main(argv = process.argv.slice(2)) {
     out_dir: outputLabel(args.outDir),
     ...files,
     report_hash: release.report_hash,
+    report_schema: release.report_schema,
+    sample_count: release.manifest.report.sample_count,
+    dataset_count: release.manifest.report.dataset_count,
     report_body_copied: false,
     api_calls_made: false,
   }, null, 2)}\n`);