enigma-memory 0.1.15 → 0.1.17

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, connect your installed AI clients, then inspect Memory Drive health and passport status. 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,78 +12,29 @@ 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 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
 ```
 
+`enigma init` is the credential-free first run that creates the local `.enigma` workspace, bundle, and proof artifacts. `enigma setup --client auto --connect-installed --overwrite` then configures the drive and writes the `mcpServers.enigma` entry into every installed/config-present client it detects; it skips clients that are not installed and never creates configs from scratch. Preview with `--dry-run` first to see which clients will be written. Both commands emit deterministic, public-safe JSON without printing raw memory plaintext, and both run on Windows PowerShell via the `enigma.cmd` shim the npm global install adds.
+
+`enigma drive health` reports a SMART-style memory-drive health packet — freshness, duplicate rate, tombstone backlog, stale derived artifacts, receipt coverage, and connector health — from local metadata only, with no network calls or private payloads. It is part of the Memory Drive surface in this release; `enigma status` and `enigma doctor` cover local passport counts, roots, and connector readiness in every build.
+
 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
@@ -226,19 +177,66 @@ MCP resource and prompt:
 
 Use `docs/client-connectors.md` from a source checkout for Claude Desktop, Cursor, Kimi Code, VS Code/Cline, Roo Code, OpenCode, and generic MCP JSON. Connector entries default to command `enigma-mcp` and env key `ENIGMA_BUNDLE`.
 
-Npm-first connector flow:
+Npm-first connector flow — one command connects every installed/config-present client:
 
 ```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 --client auto --connect-installed --overwrite
+```
+
+`--connect-installed` detects installed/config-present clients (Claude Desktop, Cursor, Kimi Code, VS Code/Cline, Roo, OpenCode, generic MCP) and writes only those existing client configs; missing client configs are reported and skipped. To preview a single client without writing, or to connect just one client later, use `enigma connect <client> --dry-run` and then drop `--dry-run`.
+
+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.
 
@@ -71,6 +74,21 @@ Because `enigma_relevance` can match normalized variants, session/role cues, tem
 
 The standard runner reports retrieval/evidence proxy metrics: LoCoMo evidence-hit@k and exact evidence coverage; LongMemEval turn evidence-hit@k, session evidence-hit@k, exact coverage, and abstention correctness; plus estimated prompt tokens, selected memory counts, and local latency. These are not LLM-generated answer-accuracy scores and must not be described as provider, competitor, or benchmark-leadership results.
 
+## Full-answer benchmark protocol plan
+
+A true apples-to-apples full-answer benchmark (same category set, same `--top-k`, same frozen answerer and judge, same prompts, same competitor adapters) is a separate credentialed run that this package does not execute. `--protocol-plan` is the readiness layer: it emits a public-safe plan of that future protocol with no provider calls, no answer generation, no judging, and no 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 --top-k 5 --protocol-plan --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, `--top-k`, the answerer model ref, the judge model ref, the prompt refs, the protocol ref, requirements-only competitor adapter refs, and cost-estimate inputs. Refs can be pinned with `--answerer-ref`, `--judge-ref`, `--answer-prompt-ref`, `--judge-prompt-ref`, and `--protocol-ref`; unpinned refs read `not-selected`/`not-pinned`.
+
+The plan carries explicit boundaries that must be `false`: `protocol_boundaries.network_required`, `provider_calls_made`, `answers_generated`, `judged`, and `competitor_adapters_run`, plus `benchmark_boundaries.llm_answer_accuracy_scored: false` and `retrieval_evidence_proxy_scored: false`. It contains no raw questions, answers, prompts, provider responses, credentials, or scores.
+
+The protocol plan is accepted by the benchmark proof-release builder alongside a scored retrieval proxy report, producing an `enigma.proof_network.benchmark_attestation.v1` that binds the plan's report hash. A protocol-plan proof release is evidence of protocol readiness only: it is not evidence that answers were generated or judged, that any provider or competitor ran or was 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.
+
 ## Local baseline comparison
 
 `local_baseline_comparisons` (also mirrored at `metrics.local_baseline_comparisons`) compares Enigma against deterministic local baselines only. Every row scores the same private fixture questions and keeps raw memory, question text, and answer text out of the report.

package/docs/memory-drive-health-model.md

@@ -595,6 +595,47 @@ A CLI or UI should show a concise SMART table first, then drill-down evidence:
 
 The product should default to safe blocking language: `proof_network_ready.eligible_for_anchor_batch` is false unless every public-safety and source-root condition passes. This makes health reports usable as local operational evidence now and as future proof-network anchor inputs without changing the privacy model.
 
+## CLI surface
+
+The reference implementation ships the health core in the passport package as `createMemoryDriveHealthReport(args)` and exposes it through a two-part CLI command that emits the report as JSON to stdout:
+
+```sh
+enigma drive health --bundle <path> \
+  [--now <iso>] \
+  [--benchmark-summary <path>] \
+  [--connector-summary <path>] \
+  [--replicas <path>] \
+  [--latest-anchor-batch-ref <ref>] \
+  [--out <file>]
+```
+
+- `--bundle <path>` is the local Enigma vault bundle to inspect (defaults to `.enigma/bundle.json`). A missing or unreadable bundle returns a clean CLI error rather than crashing.
+- `--now <iso>` fixes the timestamp used for age calculations so output is deterministic and reproducible; it defaults to a stable timestamp when omitted.
+- `--benchmark-summary`, `--connector-summary`, and `--replicas` are optional JSON files carrying public-safe retrieval, connector, and replica metadata. When omitted, the corresponding metrics default gracefully to a measured:false healthy state instead of failing the report.
+- `--out <path>` additionally writes the JSON report to a file.
+
+### Output shape
+
+Every emitted object uses schema `enigma.memory_drive_health_report.v1` and contains only public-safe hashes, roots, refs, integer counts, ratios in `0..1`, booleans, statuses, ISO-8601 timestamps, thresholds, and claim text. The top-level fields are:
+
+- `schema`, `report_ref` (`health_report_sha256:<hex>`), `created_at`;
+- `drive_ref`, `namespace_ref`, `source_root` (`memory_root_sha256:<hex>`), `policy_ref`;
+- `overall_status` (`healthy` | `watch` | `degraded` | `critical`) and `overall_score` (0-100, conservative: any critical metric caps the drive at 49, any degraded metric caps it at 70);
+- `transaction_submitted: false` and `raw_memory_on_chain: false` on every report;
+- `privacy_boundaries` (all `*_included` flags false), `roots` (`active_set_root`, `receipt_log_root`);
+- `metrics`: the ten SMART-style attributes (freshness, duplicate_rate, tombstone_risk, stale_derived_artifacts, retrieval_hit_rate, token_reduction, leakage_scan, receipt_coverage, connector_health, sync_fork_risk), each with `status`, `score`, `observed`, `thresholds`, `evidence_refs`, and `recommended_actions`;
+- `recommended_actions` (deduplicated across metrics), `claim_boundaries`;
+- `proof_network_ready`: a conservative block with `eligible_for_anchor_batch`, `blocking_reasons`, `public_payload_only`, and `suggested_anchor_fields` (artifact_type `memory_drive_health_report`, artifact_schema `enigma.memory_drive_health_report.v1`, artifact_root echoing `report_ref`, source_root, and counts). This block maps cleanly onto a proof-network registry `health_report` entry: `report_ref` becomes `artifact_hash`, `artifact_schema` becomes `artifact_schema_ref`.
+
+### Claim boundary
+
+A Memory Drive health report is **local operational evidence**, not a proof of outcome. It:
+
+- is computed locally from public-safe counters, roots, receipt metadata, tombstones, and derived/context-pack refs only, with no network or chain calls;
+- never contains raw memory, prompts, connector bodies, identity labels, or secret material (a leakage scan runs over the report before it is emitted);
+- does **not** prove provider deletion, model forgetting, compliance certification, or live-chain settlement, and never claims a submitted transaction or on-chain memory (`transaction_submitted` and `raw_memory_on_chain` are always false).
+
+
 ## Implementation requirements
 
 The first implementation should treat health reporting as a pure local planner:

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.17 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.17 proof-network layer.
 
 ## Targeted test plan
 

package/docs/proof-network.md

@@ -16,6 +16,8 @@ The initial artifact families are:
 | Capability revocation | `enigma.proof_network.capability_revocation.v1` | Records that a prior grant or scope is no longer accepted by verifiers after the revocation artifact is recognized. |
 | Benchmark attestation | `enigma.proof_network.benchmark_attestation.v1` | Binds a benchmark report hash to dataset, runner, package, and environment refs without publishing raw benchmark contents. |
 | Proof packet | `enigma.proof_network.packet.v1` | Bundles supported proof-network artifacts and verification metadata for review or handoff. |
+| Registry entry | `enigma.proof_network.registry_entry.v1` | Indexes one anchor batch, benchmark attestation, connector conformance attestation, health report, operator receipt, or settlement job ref into a public-safe marketplace registry by digest refs, signer refs, and schema ref only. |
+| Registry batch | `enigma.proof_network.registry_batch.v1` | Aggregates registry entries into one registry root so a marketplace index can be reviewed or handed off as a single commitment. |
 
 The pure package API for these artifacts should stay side-effect free: constructors create public-safe JSON, validators check exact schema shape and privacy flags, `sha256Json` hashes canonical JSON, and `assertNoPrivateProofPayload` rejects private key names or values before an artifact can be emitted. The API must not call a network, touch the filesystem, invoke provider SDKs, or infer missing private context.
 
@@ -92,7 +94,7 @@ Example:
 ```sh
 enigma chain anchor \
   --root sha256:8f0f7d2b7b7f4f2a3e4b9a3d1f0f2c3b4a5d6e7f8091a2b3c4d5e6f708192a3b \
-  --ref release:enigma:0.1.15 \
+  --ref release:enigma:0.1.17 \
   --ref memory-root:public-demo-2026-06-25 \
   --out ./.enigma/proof-network-anchor.json
 ```
@@ -144,8 +146,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 +168,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.17 \
+  --package-ref npm://enigma-memory@0.1.17 \
   --out ./.enigma/proof-network-attestation.json
 ```
 
@@ -177,13 +179,63 @@ 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.17 \
+  --package-ref npm://enigma-memory@0.1.17 \
   --out ./.enigma/proof-network-attestation.json
 ```
 
 The public attestation should include only the report hash and refs. It should not include raw benchmark rows, questions, answers, conversations, private file paths, credentials, or provider outputs.
 
+## Flow: register
+
+Registry entries index one already-created proof artifact into a public-safe marketplace registry. The entry never copies the artifact body; it binds the artifact hash to a schema ref, digest refs, signer refs, an entry type, and a registry namespace ref.
+
+1. The operator creates or selects a supported artifact (anchor batch, benchmark attestation, connector conformance attestation, health report, operator receipt, or settlement job ref) and keeps its body private.
+2. The CLI records only the artifact hash, the artifact schema ref, the public-safe digest refs and signer refs to index, and the entry type.
+3. The CLI validates that no private payload is present and emits a registry entry with `transaction_submitted:false` and `raw_memory_on_chain:false`.
+4. A reviewer can later resolve the artifact hash through approved private channels; the registry entry reveals only that a digest was indexed under a schema by named signers.
+
+Supported entry types are `anchor_batch`, `benchmark_attestation`, `connector_conformance`, `health_report`, `operator_receipt`, and `settlement_job`. An unsupported entry type is rejected before an entry is created.
+
+Example:
+
+```sh
+enigma chain register \
+  --entry-type benchmark_attestation \
+  --artifact-hash sha256:5c3a2e1d0f9b8a7766554433221100ffeeddccbbaa99887766554433221100ff \
+  --artifact-schema-ref enigma.proof_network.benchmark_attestation.v1 \
+  --digest-ref sha256:8f0f7d2b7b7f4f2a3e4b9a3d1f0f2c3b4a5d6e7f8091a2b3c4d5e6f708192a3b \
+  --signer did:key:zpublicattestor \
+  --registry-ref registry:memory-drive-marketplace \
+  --entry-ref registry-entry://enigma/public/benchmark-1 \
+  --out ./.enigma/proof-network-registry-entry.json
+```
+
+A registry entry answers "which digest was indexed under which schema by which signers, in which registry namespace?" It does not publish the artifact body, the report rows, the memory behind a root, customer or tenant identifiers, or any private review content.
+
+## Flow: registry
+
+Registry batches aggregate registry entries into one registry root so a marketplace index can be reviewed or handed off as a single commitment.
+
+1. The operator selects registry entries that have already passed local validation.
+2. The CLI sorts the entry hashes and hashes them into a registry root.
+3. The CLI emits a registry batch with the entry list, entry count, registry root, and the same safety boundaries.
+4. A reviewer verifies the batch locally and resolves individual entries through approved private channels.
+
+The registry root is deterministic and independent of entry input order: the same set of entries always yields the same registry root.
+
+Example:
+
+```sh
+enigma chain registry \
+  --entry ./.enigma/proof-network-registry-entry.json \
+  --entry ./.enigma/proof-network-registry-entry-health.json \
+  --registry-ref registry:memory-drive-marketplace \
+  --out ./.enigma/proof-network-registry-batch.json
+```
+
+A registry batch is a local planning artifact. It does not broadcast to a marketplace, register on a live chain, or prove that any third party adopted the index.
+
 ## Flow: packet
 
 Proof packets bundle several supported artifacts into one reviewable handoff.
@@ -207,10 +259,37 @@ enigma chain verify --file ./.enigma/proof-network-grant.json
 enigma chain verify --file ./.enigma/proof-network-revocation.json
 enigma chain verify --file ./.enigma/proof-network-attestation.json
 enigma chain verify --file ./.enigma/proof-network-packet.json
+enigma chain verify --file ./.enigma/proof-network-registry-entry.json
+enigma chain verify --file ./.enigma/proof-network-registry-batch.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:
@@ -222,6 +301,7 @@ Proof-network artifacts are public-safe only when they follow these boundaries:
 | Benchmark evidence | Report hash, dataset ref, runner ref, package ref, environment ref | Raw questions, answers, conversations, provider responses, private dataset rows |
 | Solana planning | Batch root, schema id, public keys, PDA seed descriptions | Private keys, seed phrases, API keys, local file paths, raw memory |
 | Review packet | Supported proof artifacts, hashes, signatures, verification metadata | Secrets, private operational notes, unredacted logs |
+| Registry index | Artifact hash, schema ref, digest refs, signer refs, registry namespace ref, entry type, count | Artifact bodies, report rows, memory behind roots, customer or tenant identifiers |
 
 The private-payload guard should reject both key names and values that look like private data. Reviewers should treat that guard as a safety net, not as permission to put sensitive fields near public artifacts.
 
@@ -229,11 +309,12 @@ The private-payload guard should reject both key names and values that look like
 
 Allowed public claims are intentionally narrow:
 
-- Enigma can produce local proof-network JSON artifacts for anchors, grants, revocations, benchmark attestations, and packets.
+- Enigma can produce local proof-network JSON artifacts for anchors, grants, revocations, benchmark attestations, packets, registry entries, and registry batches.
 - The artifacts are designed to contain public-safe hashes, roots, refs, counts, timestamps, signatures, and schema identifiers.
 - The local verifier can validate supported proof-network artifact shapes and reject private payload patterns.
 - Anchor batches are Solana-ready planning payloads for compact commitments, with `transaction_submitted:false`.
 - Raw memory is not intended to be placed on a public rail by these artifacts.
+- Registry entries index an already-created artifact by digest refs, signer refs, and schema ref only; registry batches hash entries into one registry root for review or handoff. Neither claims that a marketplace or live chain adopted the index.
 
 Forbidden public claims include:
 
@@ -243,6 +324,7 @@ Forbidden public claims include:
 - saying a revocation changes third-party systems or private stores that do not consume the revocation artifact;
 - saying a benchmark attestation proves answer quality or provider ranking;
 - saying the system replaces separate audits, changes public-market outcomes, or controls systems that do not consume the artifact.
+- saying a registry entry or registry batch was published to a live marketplace, registered on a live chain, or adopted by any third party;
 
 ## Reviewer checklist
 

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.17',
   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.17` 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.17",
   "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) }),
     })),
   };
 }