enigma-memory 0.1.15 → 0.1.17

package/deploy/SIMULATION.md

@@ -103,50 +103,46 @@ and are non-empty.
   `sim.enigmamemory.com`, `relay.sim.enigmamemory.com`,
   `gateway.sim.enigmamemory.com`, and `*.sim.enigmamemory.com`.
 
-## Collect hosted backend live evidence
+## Shortest path from local simulation to hosted readiness
 
-The simulation can be probed as if it were a public hosted deployment by
-using the public-looking domain `sim.enigmamemory.com`. Because the domain
-has no real DNS record, the collector resolves it to `127.0.0.1` locally and
-accepts the self-signed certificate.
+The local simulation proves that the relay, gateway, fail-closed readiness
+checks, hosted-live collector, and hosted-live validator can interoperate. It
+does **not** produce production go-live evidence because it uses loopback DNS,
+self-signed TLS, mocked KMS/SIEM services, and fixture operator approval.
 
-1. Build a simulation operator acceptance packet:
+Run the local proof without external credentials:
 
-   ```bash
-   node scripts/build-operator-acceptance-packet.mjs \
-     --complete-fixture --decision go --packet-id sim-operator-acceptance \
-     --tenant enigma-sim --deployment-mode hosted --environment local-simulation \
-     --target-regions local --requested-go-live-date 2026-06-25 \
-     --evidence-repository https://github.com/enigma-memory/evidence/sim \
-     --packet-owner "Simulation Owner" \
-     --last-updated 2026-06-25T00:00:00.000Z \
-     --owners-json .enigma/sim-owner-overrides.json \
-     --evidence-refs .enigma/sim-evidence-overrides.json \
-     --out .enigma/sim-operator-acceptance.json --validate
-   ```
+```bash
+node --test test/enigma-hosted-go-live-simulation.test.mjs
+```
 
-2. Collect and validate live evidence:
+That test starts `deploy/docker-compose.local-production-simulation.yml`,
+builds a simulation-only operator acceptance packet, collects relay/gateway
+`/livez` and `/readyz` evidence, validates it with
+`scripts/validate-hosted-backend-live.mjs`, and tears the stack down. For manual
+simulation probing, `production:hosted-collect -- --local-simulation-loopback`
+is restricted to `https://*.sim.enigmamemory.com` loopback probes with
+self-signed TLS and must not be used as production evidence.
 
-   ```bash
-   node .enigma/collect-sim-evidence.mjs \
-     --relay-url https://sim.enigmamemory.com:8443 \
-     --gateway-url https://sim.enigmamemory.com:9443 \
-     --refs-json .enigma/sim-hosted-refs.json \
-     --domain sim.enigmamemory.com --environment-id local-simulation \
-     --cloud-provider local --region local --owner enigma-sim \
-     --operator-decision go \
-     --operator-packet-ref .enigma/sim-operator-acceptance.json \
-     --operator-approved-at <iso8601> --operator-approved-by enigma-sim \
-     --out .enigma/hosted-backend-live-collection.json \
-     --evidence-out .enigma/hosted-backend-live-simulated.json
-
-   node scripts/validate-hosted-backend-live.mjs \
-     --evidence .enigma/hosted-backend-live-simulated.json
-   ```
+Move from that local proof to real hosted relay/gateway readiness with the same
+script chain, replacing every template with operator-owned production evidence:
+
+```bash
+npm run production:evidence-starter -- --out-dir <evidence-dir> --domain enigmamemory.com --tenant <tenant-id> --environment production
+npm run production:backend-env -- --out-dir <backend-env-kit-dir> --domain enigmamemory.com --tenant <tenant-id> --environment production
+# Operator deploys relay/gateway from deploy/docker-compose.production.example.yml or deploy/kubernetes/enigma-backend.example.yaml using private filled env/secrets.
+npm run production:manifests -- --out <evidence-dir>/production-manifests.json
+npm run production:storage -- --out <evidence-dir>/production-storage-migration.json
+npm run infrastructure:readiness -- --manifest <evidence-dir>/infrastructure-readiness-manifest.json --live --cloudflare-live required > <evidence-dir>/infrastructure-readiness-live.json
+npm run production:hosted-collect -- --relay-url https://relay.enigmamemory.com --gateway-url https://gateway.enigmamemory.com --refs-json <evidence-dir>/hosted-refs.json --domain enigmamemory.com --environment-id production --cloud-provider <provider> --region <region> --owner <owner> --operator-decision go --operator-packet-ref <operator-packet-ref> --operator-approved-at <iso8601> --operator-approved-by <operator> --out <evidence-dir>/hosted-backend-live-collection.json --evidence-out <evidence-dir>/hosted-backend-live.json
+npm run production:hosted-live -- --evidence <evidence-dir>/hosted-backend-live.json
+npm run production:acceptance:packet -- --out <evidence-dir>/operator-acceptance-packet.json --owners-json <evidence-dir>/owner-approval-refs.json --evidence-refs <evidence-dir>/evidence-refs.json --readiness <evidence-dir>/infrastructure-readiness-live.json --manifest <evidence-dir>/infrastructure-readiness-manifest.json --storage <evidence-dir>/production-storage-migration.json --release-audit .enigma/release-audit-current.json --production-manifests <evidence-dir>/production-manifests.json --decision go --tenant <tenant-id> --target-regions <regions> --requested-go-live-date <date> --evidence-repository <evidence-repository> --packet-owner <operator> --validate
+npm run production:acceptance -- --packet <evidence-dir>/operator-acceptance-packet.json
+```
 
-The expected result is `status: accepted` with all four probes observed and no
-blockers. The wrapper does not mutate DNS or deploy infrastructure and never
-sends credentials.
+Hosted readiness remains blocked until the production commands above observe
+public HTTPS relay/gateway probes, all required hosted refs, and operator
+acceptance `go` for the exact target environment.
 
 Never commit `deploy/secrets-simulation/` or `*.pem` files. Both are
 `.gitignore`d.

package/docs/benchmark-attestation-network.md

@@ -169,7 +169,7 @@ Minimum public-safe attestation skeleton:
   "track": "public_practice",
   "program": {
     "name": "enigma_benchmark_attestation_network",
-    "version": "0.1.15",
+    "version": "0.1.17",
     "policy_ref": "sha256:policy-root"
   },
   "run": {
@@ -177,7 +177,7 @@ Minimum public-safe attestation skeleton:
     "nonce": "sha256:run-nonce-commitment",
     "status": "completed",
     "runner_ref": "sha256:runner-root",
-    "package_ref": "npm:enigma-memory@0.1.15",
+    "package_ref": "npm:enigma-memory@0.1.17",
     "adapter_ref": "local:enigma-relevance",
     "environment_ref": "sha256:environment-summary-root"
   },

package/docs/benchmark-reproducibility.md

@@ -4,7 +4,7 @@ This guide explains how to reproduce the current local Enigma memory benchmark,
 
 ## What is reproducible today
 
-The current planned package is `enigma-memory@0.1.15`. Two benchmark paths are reproducible without provider credentials:
+The current planned package is `enigma-memory@0.1.17`. Two benchmark paths are reproducible without provider credentials:
 
 1. The local deterministic memory suite, available through the package script and the script file it wraps:
 
@@ -20,12 +20,15 @@ The current planned package is `enigma-memory@0.1.15`. Two benchmark paths are r
 2. The official-dataset standard runner, which consumes locally downloaded LoCoMo and/or LongMemEval JSON files:
 
    ```sh
+   node scripts/run-standard-memory-benchmarks.mjs --locomo .enigma/benchmarks/datasets/locomo10.json --longmemeval .enigma/benchmarks/datasets/longmemeval_s_cleaned.json --max-locomo-qa 25 --max-longmemeval-items 25 --top-k 5 --dry-run
    node scripts/run-standard-memory-benchmarks.mjs --locomo .enigma/benchmarks/datasets/locomo10.json --longmemeval .enigma/benchmarks/datasets/longmemeval_s_cleaned.json --max-locomo-qa 25 --max-longmemeval-items 25 --top-k 5 --out .enigma/standard-memory-benchmark-sample.json
    ```
 
-   The standard report schema is `enigma.standard_memory_benchmark_suite.v1`. It scores retrieval/evidence coverage over official dataset records with local deterministic methods only. It does not call LLM providers, generate final answers, grade natural-language answer correctness, call competitor SDKs, or create provider/competitor scores.
+   The `--dry-run` command emits `enigma.standard_memory_benchmark_plan.v1`: a public-safe offline plan with file names, sample caps, top-k, local method rows, a requirements-only Mem0 adapter row, and explicit boundaries. It does not read dataset files, hash data, produce scores, call APIs, run Mem0 or competitor adapters, generate answers, or spend provider budget.
 
-   In that standard report, `keyword_filter` is intentionally the simpler lexical baseline. `enigma_relevance` is the deterministic Enigma retrieval approximation: it uses deterministic query expansion, term normalization and stemming, task/category and temporal/date hints, role/session metadata, phrase/proximity scoring, and final reranking for evidence diversity. It does not use raw answer text, evidence labels, or `has_answer` flags to choose records. It must be interpreted only as retrieval/evidence proxy scoring over the local dataset file named in the report, not as LLM answer accuracy, provider performance, competitor performance, or leaderboard standing.
+   The scored standard report schema is `enigma.standard_memory_benchmark_suite.v1`. It scores retrieval/evidence coverage over official dataset records with local deterministic methods only and includes a requirements-only Mem0 row with `scores_included:false`. It does not call LLM providers, generate final answers, grade natural-language answer correctness, call Mem0 or other competitor SDKs, or create provider/competitor scores.
+
+   In that standard report, `keyword_filter` is intentionally the simpler lexical baseline. `enigma_relevance` is the deterministic Enigma retrieval approximation: it uses deterministic query expansion, term normalization and stemming, task/category and temporal/date hints, role/session metadata, phrase/proximity scoring, and final reranking for evidence diversity. It does not use raw answer text, evidence labels, or `has_answer` flags to choose records. It must be interpreted only as retrieval/evidence proxy scoring over the local dataset file named in the report, not as LLM answer accuracy, provider performance, Mem0/competitor performance, or leaderboard standing.
 
    | Standard-runner row | Retrieval boundary |
    | --- | --- |
@@ -64,7 +67,7 @@ Do not commit downloaded files or raw benchmark conversations. The package `.git
 
 ## Reproduce and save local fixture JSON
 
-1. Use a clean checkout containing `enigma-memory@0.1.15`.
+1. Use a clean checkout containing `enigma-memory@0.1.17`.
 2. From a repository root that contains `enigma/package.json`, enter the package directory:
 
    ```sh
@@ -94,7 +97,15 @@ Interpret improvements as local fixture behavior. Enigma reduces context-pack es
 
 ## Run the official-dataset standard benchmark
 
-The standard runner reads local dataset files produced by the downloader and writes a public-safe proxy report to the path supplied with `--out`. A bounded sample is the safest first run:
+The standard runner reads local dataset files produced by the downloader and writes a public-safe proxy report to the path supplied with `--out`. Preview the exact offline boundary first:
+
+```sh
+node scripts/run-standard-memory-benchmarks.mjs --locomo .enigma/benchmarks/datasets/locomo10.json --longmemeval .enigma/benchmarks/datasets/longmemeval_s_cleaned.json --max-locomo-qa 25 --max-longmemeval-items 25 --top-k 5 --dry-run
+```
+
+That command proves only the planned local files, sample bounds, `--top-k`, deterministic local rows, and no-API/no-Mem0/no-competitor/no-score boundary. It does not prove the files exist, hash the datasets, or report accuracy.
+
+A bounded scored sample is the safest first run:
 
 ```sh
 node scripts/run-standard-memory-benchmarks.mjs --locomo .enigma/benchmarks/datasets/locomo10.json --longmemeval .enigma/benchmarks/datasets/longmemeval_s_cleaned.json --max-locomo-qa 25 --max-longmemeval-items 25 --top-k 5 --out .enigma/standard-memory-benchmark-sample.json
@@ -106,6 +117,7 @@ Useful runner options:
 - `--longmemeval <path>` supplies a local LongMemEval JSON file. Use one cleaned split per run when you want split-specific evidence.
 - `--max-locomo-qa <n>` and `--max-longmemeval-items <n>` bound the sample size.
 - `--top-k <n>` controls retrieval depth; the default is `5`.
+- `--dry-run` prints the public-safe offline plan and does not read dataset files or produce scores.
 - `--out <path>` writes public-safe JSON to that path. Without `--out`, the report is printed to stdout.
 
 If only `--locomo` or only `--longmemeval` is supplied, the runner scores only that dataset.
@@ -130,7 +142,7 @@ Public sharing should include the generated benchmark report JSON and generated
 
 ## Proof-network benchmark attestations
 
-For the planned 0.1.15 proof-network layer, benchmark results should be represented as a public-safe local attestation rather than by publishing raw benchmark inputs. The attestation JSON uses `schema: "enigma.proof_network.benchmark_attestation.v1"` and may be bundled in `enigma.proof_network.packet.v1` for review. The benchmark proof-release flow is local planning only: it does not call APIs, submit transactions, or claim hosted SaaS behavior, and generated artifacts must keep `transaction_submitted: false` and `raw_memory_on_chain: false`.
+For the planned 0.1.17 proof-network layer, benchmark results should be represented as a public-safe local attestation rather than by publishing raw benchmark inputs. The attestation JSON uses `schema: "enigma.proof_network.benchmark_attestation.v1"` and may be bundled in `enigma.proof_network.packet.v1` for review. The benchmark proof-release flow is local planning only: it does not call APIs, submit transactions, or claim hosted SaaS behavior, and generated artifacts must keep `transaction_submitted: false` and `raw_memory_on_chain: false`.
 
 Hash the generated benchmark report and companion dataset manifest, then attest only the report hash, schema name, dataset refs, runner refs, package refs, score commitments, record counts, top-k/sample bounds, and timestamps needed for review. The public artifacts must not contain raw dataset rows, raw conversations, prompts, private questions, private answers, provider responses, embeddings, credentials, tenant names, account ids, local absolute paths, unpublished benchmark scores, or the raw benchmark report body.
 
@@ -139,12 +151,12 @@ Use a `sha256:<hex>` commitment for the report and manifest. The proof-release s
 After running one of the benchmark commands above and confirming the report is public-safe, create a local proof release:
 
 ```sh
-npm run benchmark:proof-release -- --report .enigma/standard-memory-benchmark-sample.json --dataset-ref "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" --runner-ref "runner:run-standard-memory-benchmarks.mjs@reviewed-revision" --package-ref "enigma-memory@0.1.15" --score "retrieval_evidence_proxy=<value-copied-from-report>" --out-dir .enigma/benchmark-proof-release
+npm run benchmark:proof-release -- --report .enigma/standard-memory-benchmark-sample.json --dataset-ref "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" --runner-ref "runner:run-standard-memory-benchmarks.mjs@reviewed-revision" --package-ref "enigma-memory@0.1.17" --score "retrieval_evidence_proxy=<value-copied-from-report>" --out-dir .enigma/benchmark-proof-release
 ```
 
-The command writes `benchmark-attestation.json`, `benchmark-proof-packet.json`, and `benchmark-proof-release.json` in the output directory. The release manifest uses `schema: "enigma.benchmark_proof_release.v1"` and records explicit boundaries: local benchmark attestation only, no API calls, no provider answer-accuracy claim, no competitor performance claim, no Solana submission claim, no hosted SaaS claim, and no ROI/profit/provider-savings claim.
+The command writes `benchmark-attestation.json`, `benchmark-proof-packet.json`, and `benchmark-proof-release.json` in the output directory. The release manifest uses `schema: "enigma.benchmark_proof_release.v1"` and records explicit boundaries: local benchmark attestation only, local report file hashing only, no network calls, no provider APIs, no API spend, no provider answer-accuracy claim, no competitor performance claim, no Solana submission claim, no hosted SaaS claim, and no ROI/profit/provider-savings claim.
 
-When a report file is supplied, the generated attestation is a reproducibility receipt for a specific local report hash and explicitly supplied aggregate score commitments. It is not evidence of provider answer accuracy, competitor performance, Solana settlement, ROI, hosted-cloud readiness, provider deletion, model forgetting, or live model behavior.
+When a report file is supplied, the generated attestation is a reproducibility receipt for a specific local report hash and explicitly supplied aggregate score commitments. The proof builder now requires a compatible benchmark schema plus explicit offline `benchmark_boundaries`, and rejects scored external adapter rows. It is not evidence of provider answer accuracy, Mem0 or competitor performance, Solana settlement, ROI, hosted-cloud readiness, provider deletion, model forgetting, or live model behavior.
 
 ## Local baseline rows in the report
 
@@ -168,6 +180,55 @@ Use these standards as dataset sources, citations, and task-category references,
 
 The local report mirrors some task categories from those benchmarks but does not download or score official records. The standard runner consumes official local dataset files and scores retrieval/evidence coverage; it does not run the original papers' full LLM evaluation pipelines or claim leaderboard-equivalent answer accuracy.
 
+## Full-answer benchmark protocol plan (--protocol-plan)
+
+The scored standard runner is retrieval/evidence proxy only. A true apples-to-apples full-answer run (same category set, same top-k, same frozen answerer and judge, same prompts, same competitor adapters) is a separate, credentialed benchmark that this package does not execute. `--protocol-plan` is the readiness layer between the two: it emits a public-safe plan of that future protocol without reading datasets, calling providers, generating answers, judging answers, or running competitor adapters.
+
+```sh
+cd enigma
+node scripts/run-standard-memory-benchmarks.mjs --locomo .enigma/benchmarks/datasets/locomo10.json --longmemeval .enigma/benchmarks/datasets/longmemeval_s_cleaned.json --max-locomo-qa 25 --max-longmemeval-items 25 --top-k 5 --protocol-plan --out .enigma/standard-memory-benchmark-protocol-plan.json
+```
+
+Optionally pin the public-safe model/prompt/protocol refs so the plan records exactly which artifacts a future live run must freeze (defaults mark every ref `not-selected`/`not-pinned`):
+
+```sh
+node scripts/run-standard-memory-benchmarks.mjs --locomo .enigma/benchmarks/datasets/locomo10.json --top-k 5 --protocol-plan \
+  --answerer-ref "model:answerer@frozen-revision" \
+  --judge-ref "model:judge@frozen-revision" \
+  --answer-prompt-ref "prompt:standard-answer@frozen-revision" \
+  --judge-prompt-ref "prompt:standard-judge@frozen-revision" \
+  --protocol-ref "protocol:apples-to-apples-full-answer@frozen-revision" \
+  --out .enigma/standard-memory-benchmark-protocol-plan.json
+```
+
+The emitted schema is `enigma.standard_memory_benchmark_protocol_plan.v1`. It records the planned category set (the same LoCoMo/LongMemEval task categories the scored report uses), `--top-k`, the answerer model ref and judge model ref, the prompt refs and protocol ref, the requirements-only competitor adapter refs, and cost-estimate inputs (sample limits, token caps, temperature, retries, timeout, and a `budget_cap_set:false` flag). It does not contain raw questions, raw answers, prompts, provider responses, embeddings, credentials, dataset bytes, or scores.
+
+The plan carries explicit boundaries that must read `false`:
+
+| Boundary | Meaning |
+| --- | --- |
+| `protocol_boundaries.network_required` | No network is used to produce the plan. |
+| `protocol_boundaries.provider_calls_made` | No provider APIs are called. |
+| `protocol_boundaries.answers_generated` | No model answers are generated. |
+| `protocol_boundaries.judged` | No answers are judged or graded. |
+| `protocol_boundaries.competitor_adapters_run` | No Mem0 or other competitor adapters are run. |
+| `benchmark_boundaries.llm_answer_accuracy_scored` | The plan is not a score. |
+| `benchmark_boundaries.retrieval_evidence_proxy_scored` | The plan does not even score the retrieval proxy. |
+
+The protocol plan can be turned into a local proof release with the same command used for a scored report, because the proof-release builder accepts either a local retrieval proxy report or a protocol-plan report:
+
+```sh
+npm run benchmark:proof-release -- --report .enigma/standard-memory-benchmark-protocol-plan.json --dataset-ref "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" --runner-ref "runner:run-standard-memory-benchmarks.mjs@protocol-plan" --package-ref "enigma-memory@0.1.17" --out-dir .enigma/benchmark-protocol-proof-release
+```
+
+The resulting attestation uses the existing `enigma.proof_network.benchmark_attestation.v1` schema and binds the protocol-plan report hash plus `report_hash_only` metric roots; it does not copy the report body. A protocol-plan proof release is evidence of protocol readiness only. It is not evidence that answers were generated, that answers were judged, that any provider or competitor was called or outperformed, or that benchmark leadership, ROI, provider deletion, model forgetting, or compliance was achieved. Competitor adapter refs are references, not scores; a reference is never a superiority claim.
+
+### What the protocol plan proves and does not prove
+
+**Proves:** the exact category set, top-k, planned answerer/judge model refs, prompt/protocol refs, competitor adapter refs, and cost-estimate inputs that a future full-answer run would freeze, plus the explicit no-network/no-provider/no-answers/no-judgement boundary.
+
+**Does not prove:** that any model answered correctly, that any model was judged, that any provider or competitor ran, that prompts are final, that a budget cap was set, or that the planned run would favor Enigma. Pinned refs mark which artifacts a future run must freeze; they are not a claim that the run happened or succeeded.
+
 ## Future provider answer-accuracy runs
 
 A real answer-accuracy run is a different benchmark from the current standard runner. It would need all of the following before any answer-correctness or model-quality claim is published:

package/docs/blockchain-only-mechanisms.md

@@ -166,6 +166,8 @@ Keep private:
 
 The registry should answer, "Which public key attested to which digest under which schema?" It should not answer, "What private data produced that digest?" Disclosure of the underlying report is a separate permissioned review action.
 
+The local Enigma artifacts that prepare this registry are `enigma.proof_network.registry_entry.v1` and `enigma.proof_network.registry_batch.v1`. A registry entry binds one already-created artifact (anchor batch, benchmark attestation, connector conformance attestation, health report, operator receipt, or settlement job ref) to a public-safe `registry_ref`, the artifact schema ref, digest refs, signer refs, an entry type, and a count — never the artifact body. A registry batch sorts entry hashes into a single registry root. Both are local planning artifacts: they carry `transaction_submitted:false` and `raw_memory_on_chain:false`, and they do not prove that any marketplace, registry program, or live chain has adopted the index. What the chain would uniquely add is shared discovery (any verifier can resolve an indexed digest by package, dataset, runner, or operator key without trusting one private API) and signer accountability (the public key that attested to a digest is recorded alongside it); neither requires revealing the private report behind the digest.
+
 ## Mechanism 5: USDC escrow and settlement
 
 ### Blockchain-native value
@@ -292,6 +294,7 @@ The public rail should be modeled as a small state machine over commitments, not
 | Grant record | program id, `grant`, issuer key, subject key, scope digest, capability | grant id, capability, scope digest, expiry, revocation ref | Was this public subject granted this scoped capability at this time? |
 | Nullifier record | program id, `nullifier`, nullifier digest | nullifier digest, issuer key, effective slot, optional safe reason ref | Should verifiers reject the matching grant, scope, or one-time proof? |
 | Attestation record | program id, `attestation`, attestor key, report or packet digest | digest, attestation type, public-safe refs, slot, signature | Which public key attested to this digest under which schema? |
+| Registry index record | program id, `registry`, registry namespace ref, artifact digest, attestor key | artifact digest, artifact schema ref, entry type, public-safe digest/signer refs, count, slot, signature | Which public key indexed which digest under which schema and registry namespace? |
 | Escrow record | program id, `escrow`, payer key, operator key, job ref | token mint, amount, proof refs, release rule, timeout, state | Are funds locked, releasable, refundable, or disputed against public-safe refs? |
 | Reputation index | program id, `operator`, operator key | counters, correction refs, challenge refs, signer rotation refs | What public-key history can be checked without private customer facts? |
 
@@ -342,6 +345,15 @@ The chain contributes shared permission and revocation state. It does not expose
 
 The chain contributes shared discovery and signer accountability. It does not publish raw benchmark examples or private results.
 
+### Marketplace registry index
+
+1. Enigma creates one or more proof artifacts (anchor, attestation, health report, operator receipt, or settlement job ref) and keeps their bodies private.
+2. Enigma emits a registry entry per artifact that records only the artifact hash, schema ref, digest refs, signer refs, entry type, and a registry namespace ref.
+3. Enigma aggregates entries into a registry batch whose root commits to the whole index.
+4. A reviewer resolves individual artifact hashes through approved private channels; a public observer can see only that a digest was indexed under a schema by named signers.
+
+The chain would contribute shared discovery and signer accountability. The local registry artifacts do not broadcast to a marketplace, register on a live chain, or prove third-party adoption.
+
 ### Escrow for proof-backed operator work
 
 1. A payer would lock USDC against a job ref and release rule.

package/docs/browser-extension-install.md

@@ -27,21 +27,24 @@ node scripts/package-browser-extension.mjs --zip ./dist/enigma-browser-extension
 
 The ZIP command does not publish, sign, upload, or submit the extension.
 
-## Install the native host first
+## Install the native host and MCP connector first
 
-Install the npm package so both `enigma` and `enigma-native-host` are available:
+Install the npm package, create the local bundle, and let Enigma merge the MCP server entry into the selected client config. Pick the command for the client you use:
 
 ```sh
-npm install -g enigma-memory
+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
 ```
 
-Create or select a local bundle:
+If you want Enigma to touch only client config files that already exist, use:
 
 ```sh
-enigma init --bundle <absolute-bundle-path> --subject local-user --display-name "Local user"
+npm install -g enigma-memory && enigma setup --client auto --connect-installed --overwrite
 ```
 
-Set `ENIGMA_BUNDLE` for the browser-launched host process, or point the native-host manifest at a small local wrapper that sets `ENIGMA_BUNDLE=<absolute-bundle-path>` before launching `enigma-native-host`. Native messaging manifests require an absolute executable path; they do not expand shell aliases, `~`, `$HOME`, `%USERPROFILE%`, or command arguments.
+Set `ENIGMA_BUNDLE` for the browser-launched host process to the same bundle path reported by setup, or point the native-host manifest at a small local wrapper that sets `ENIGMA_BUNDLE=<absolute-bundle-path>` before launching `enigma-native-host`. Native messaging manifests require an absolute executable path; they do not expand shell aliases, `~`, `$HOME`, `%USERPROFILE%`, or command arguments.
 
 Resolve the absolute host executable path:
 

package/docs/client-connectors.md

@@ -1,6 +1,6 @@
 # Client connectors
 
-Enigma connects to assistant clients through MCP. The client starts `enigma-mcp` over stdio, and Enigma reads/writes the local vault bundle named by `ENIGMA_BUNDLE`. Start with the public test drive, then create a regular local workspace, then explicitly connect installed/config-present clients when you are ready.
+Enigma connects to assistant clients through MCP. The client starts `enigma-mcp` over stdio, and Enigma reads/writes the local vault bundle named by `ENIGMA_BUNDLE`. Install once, run setup once, then connect the same AI Memory Passport everywhere when you explicitly choose to write a client config.
 
 Supported connector IDs:
 
@@ -12,61 +12,25 @@ Supported connector IDs:
 - `opencode`
 - `generic-mcp`
 
-## Public test drive first
-
-Prove the live npm package path without credentials, hosted SaaS, provider calls, or client-config writes:
-
-```sh
-npm install -g enigma-memory
-enigma test-drive --overwrite
-```
-
-`enigma test-drive --overwrite` writes an isolated demo under `.enigma/test-drive` by default, emits one public-safe JSON summary, and does not print raw private memory plaintext. Use `--dry-run` to preview without writing, or `--out-dir <path>` to choose another isolated demo directory. The local proof/demo is bounded to Enigma-controlled vault state, receipts, checkpoints, committed roots, exported bundle shape, and declared boundary operations; it is not hosted SaaS evidence and does not prove provider deletion or model forgetting.
-
 ## One clear path
 
-After the test drive, create a regular local workspace:
-
 ```sh
 npm install -g enigma-memory
-enigma setup --overwrite
-```
-
-`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, VS Code, Roo, OpenCode, or generic MCP client configs.
-
-To auto-detect installed or already-configured clients and show the setup connector plan without mutating client configs:
-
-```sh
-enigma setup --client auto --overwrite
-```
-
-`--client auto` selects clients found by connector detection and falls back to the default setup client list when none are present. The setup output lists selected clients, skipped clients, and the reason for each skip.
-
-To explicitly write connector entries for installed/config-present clients only:
-
-```sh
-enigma setup --connect-installed --overwrite
-```
-
-`--connect-installed` implies auto client selection and is a client-config write flag. It skips missing client configs instead of creating every default client config. Only explicit write flags mutate client configs. Existing `enigma connect <client>` behavior and existing `enigma setup --write-connectors` behavior for explicit/default clients are unchanged.
-
-After setup, use the same local vault from the CLI or connected clients:
-
-```sh
+enigma init
+enigma setup --client auto --connect-installed --overwrite
+enigma drive health
+enigma status
 enigma remember --text-file ./memory.txt
-enigma search --query "..."
-enigma context --query "..." --optimize
+enigma search --query "project context"
+enigma context --query "project context" --optimize
 enigma verify --export ./.enigma/export.json
-enigma connect claude-desktop --dry-run
 ```
 
-Provider-native memory is non-canonical cache only in this architecture. The Enigma vault remains canonical, and Enigma receipts prove Enigma-controlled lifecycle events; they do not prove that a hosted provider deleted hidden copies or that a model forgot anything.
+One command connects every installed client: `enigma setup --client auto --connect-installed --overwrite` writes the `mcpServers.enigma` entry into every installed/config-present client it detects (Claude Desktop, Cursor, Kimi Code, VS Code/Cline, Roo, OpenCode, generic MCP). It skips clients that are not installed and never creates configs from scratch; preview with `--dry-run` first. `enigma drive health` reports a SMART-style memory-drive health packet (freshness, tombstone backlog, stale derived artifacts, receipt coverage, connector health) from local metadata only — it is part of the Memory Drive surface in this release, and `enigma status` plus `enigma doctor` cover local passport counts, roots, and connector readiness in every build. No setup command prints raw memory plaintext.
 
-One-off public test drive without a global install:
+For a single client, or to preview before writing, use `enigma connect <client> --dry-run` and then drop `--dry-run`.
 
-```sh
-npx --yes --package enigma-memory enigma test-drive --overwrite
-```
+Provider-native memory is non-canonical cache only in this architecture. The Enigma vault remains canonical, and Enigma receipts prove Enigma-controlled lifecycle events; they do not prove that a hosted provider deleted hidden copies or that a model forgot anything.
 
 From a source checkout, use this only for package development or source-only docs:
 
@@ -77,14 +41,6 @@ npm install -g .
 
 ## Preview, then connect
 
-Preview installed/config-present connector targets during setup without changing client configs:
-
-```sh
-enigma setup --client auto --overwrite
-```
-
-The output reports selected clients, skipped clients, and skip reasons. If no installed/config-present client is discovered, auto selection falls back to the default setup client list for planning.
-
 Preview one client without changing it:
 
 ```sh
@@ -97,7 +53,25 @@ enigma connect opencode --dry-run
 enigma connect generic-mcp --dry-run
 ```
 
-When you are ready to write all installed/config-present client configs discovered by setup, use the explicit setup-time write flag:
+When the single-client dry run looks right, remove `--dry-run` for the client you want:
+
+```sh
+enigma connect claude-desktop
+enigma connect cursor
+enigma connect kimi-code
+enigma connect vscode-cline
+enigma connect roo
+enigma connect opencode
+enigma connect generic-mcp
+```
+
+Optional setup-time planning for installed/config-present connector targets remains available:
+
+```sh
+enigma setup --client auto --overwrite
+```
+
+Use the explicit setup-time write flag only when you want setup to write all installed/config-present client configs it discovers:
 
 ```sh
 enigma setup --connect-installed --overwrite

package/docs/demo-proof-network.md

@@ -201,7 +201,7 @@ enigma chain attest \
   --report-hash sha256:5555555555555555555555555555555555555555555555555555555555555555 \
   --dataset-ref enigma-fixture:deterministic-local:v1 \
   --runner-ref enigma-memory:local-benchmark-runner:v1 \
-  --package-ref npm:enigma-memory@0.1.15 \
+  --package-ref npm:enigma-memory@0.1.17 \
   --score recall_at_5=1 \
   --score p95_latency_ms=14 \
   --out .enigma/proof-network/benchmark-attestation.json
@@ -219,7 +219,7 @@ enigma chain attest \
   --report-file .enigma/benchmarks/report.json \
   --dataset-ref enigma-fixture:deterministic-local:v1 \
   --runner-ref enigma-memory:scripts/run-memory-benchmarks.mjs \
-  --package-ref npm:enigma-memory@0.1.15 \
+  --package-ref npm:enigma-memory@0.1.17 \
   --score recall_at_5=1 \
   --score p95_latency_ms=14 \
   --out .enigma/proof-network/benchmark-attestation.json
@@ -236,7 +236,7 @@ Expected public-safe output shape from `chain attest`:
   "report_hash": "sha256:5555555555555555555555555555555555555555555555555555555555555555",
   "dataset_ref": "enigma-fixture:deterministic-local:v1",
   "runner_ref": "enigma-memory:local-benchmark-runner:v1",
-  "package_ref": "npm:enigma-memory@0.1.15",
+  "package_ref": "npm:enigma-memory@0.1.17",
   "scores": {
     "recall_at_5": 1,
     "p95_latency_ms": 14