enigma-memory 0.1.16 → 0.1.17

package/README.md

@@ -2,7 +2,7 @@
 
 Enigma Memory is a local-first AI Memory Passport. It gives you one canonical local memory vault, receipt-backed proof for Enigma-controlled events, and MCP connections into assistants such as Claude Desktop, Cursor, Kimi Code, and generic MCP clients.
 
-Start with `enigma setup --overwrite` below. You do not need to understand relay, gateway, mesh, browser, desktop, hosted infrastructure, or the proof network before trying Enigma locally.
+Start with the Memory Drive loop below — one install, one connect, then health and status verification. You do not need to understand relay, gateway, mesh, browser, desktop, hosted infrastructure, or the proof network before trying Enigma locally.
 
 The package path needs no database, provider credential, cloud credential, npm publishing token, or external account. Hosted cloud and BYOC operation are separate advanced modes that require real deployment credentials, domains, TLS, durable storage, KMS/secrets, monitoring, backups, and operator acceptance.
 
@@ -16,21 +16,25 @@ Prerequisites:
 - No database, package registry account, provider credential, cloud credential, hosted Enigma account, or external account for the local setup path
 - Git only when you choose the advanced source-checkout path
 
-Use Enigma as a one-time AI Memory Passport setup: install the package, create the local Enigma workspace once, then use the same memory/search/context/verify/connect loop from any supported client.
+Use Enigma as your private Memory Drive for AI: install once, connect the AI clients you already have, then inspect drive health and passport status before remembering, retrieving, packaging, and verifying context.
 
 ```sh
 npm install -g enigma-memory
-enigma setup --overwrite
+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 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`; keep `--dry-run` while reviewing the planned MCP entry.
+`enigma init` is the credential-free first run: it creates the local `.enigma` workspace, bundle, and proof artifacts and emits public-safe JSON without provider or cloud credentials. `enigma setup --client auto --connect-installed --overwrite` then configures the drive and merges 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 if you want to see which clients will be written. The same commands run on Windows PowerShell because the npm global install adds an `enigma.cmd` shim. Neither command prints raw memory plaintext.
+
+`enigma drive health` reports a SMART-style memory-drive health packet — freshness, duplicate rate, tombstone backlog, stale derived artifacts, receipt coverage, and connector health — computed from local metadata only, with no network calls or private payloads. It is part of the Memory Drive surface in this release; in any build where it is unavailable, `enigma status` and `enigma doctor` cover the same local passport counts, roots, and connector readiness.
 
-The local Enigma vault remains canonical. Provider-native memory is non-canonical and should be treated as a convenience cache only. Enigma receipts prove Enigma-controlled vault state, receipts, checkpoints, and declared boundary operations; they do not prove provider deletion, provider model forgetting, provider-native memory removal, hosted availability, ROI/savings, or compliance certification.
+`enigma status` shows passport counts, roots, owner display fields, and connector readiness. The local Enigma vault remains canonical. Provider-native memory is non-canonical and should be treated as a convenience cache only. Enigma receipts prove Enigma-controlled vault state, receipts, checkpoints, and declared boundary operations; they do not prove provider deletion, provider model forgetting, provider-native memory removal, hosted availability, ROI/savings, or compliance certification.
 
 ## Enigma Proof Network
 
@@ -146,7 +150,7 @@ Supported connector profiles are:
 - `opencode`
 - `generic-mcp`
 
-After `enigma setup --overwrite`, preview a client connection before writing anything:
+The one-command path above (`enigma setup --client auto --connect-installed --overwrite`) already connects every installed/config-present client. To connect or preview a single client instead:
 
 ```sh
 enigma connect claude-desktop --dry-run
@@ -155,7 +159,7 @@ enigma connect kimi-code --dry-run
 enigma connect generic-mcp --dry-run
 ```
 
-Remove `--dry-run` from `enigma connect <client>` only after you are ready for Enigma to merge the `mcpServers.enigma` entry into that specific client config. The safe default setup command never writes third-party app configs.
+Remove `--dry-run` from `enigma connect <client>` only after you are ready for Enigma to merge the `mcpServers.enigma` entry into that specific client config. Bare `enigma setup` without `--connect-installed` or `--write-connectors` never writes third-party app configs.
 
 Copy-paste MCP snippets:
 

package/apps/cli/bin/enigma.mjs

@@ -6,7 +6,7 @@ import { access, mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promi
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { createVault, remember, recall, updateMemory, deleteMemory, exportBundle } from '../../../packages/vault/src/index.js';
-import { createPassport, compileContextPack } from '../../../packages/passport/src/index.js';
+import { createPassport, compileContextPack, createMemoryDriveHealthReport } from '../../../packages/passport/src/index.js';
 import { runBoundarySimulation } from '../../../packages/boundary/src/index.js';
 import { startStdioServer } from '../../../packages/mcp-server/src/index.js';
 import { runMeshDemo } from '../../../packages/mesh/src/index.js';
@@ -36,11 +36,15 @@ import {
   createCapabilityGrant,
   createCapabilityRevocation,
   createProofNetworkAnchorBatch,
+  createRegistryEntry,
+  createRegistryBatch,
   sha256Json as proofNetworkSha256Json,
   validateBenchmarkAttestation,
   validateCapabilityGrant,
   validateCapabilityRevocation,
   validateProofNetworkAnchorBatch,
+  validateRegistryEntry,
+  validateRegistryBatch,
   validateProofNetworkPacket,
 } from '../../../packages/proof-network/src/index.js';
 
@@ -1059,13 +1063,16 @@ function oneCommandInstallConnect(bundleDisplay = DEFAULT_BUNDLE, outDirDisplay
 
 function setupNextCommands(bundleInput, exportDisplay, clients, writeConnectors) {
   const primaryClient = clients[0] ?? DEFAULT_SETUP_CLIENTS[0];
+  const bundle = commandPath(bundleInput);
   const commands = [
-    `enigma remember --bundle ${commandPath(bundleInput)} --text-file ./memory.txt`,
-    `enigma search --bundle ${commandPath(bundleInput)} --query "project context"`,
-    `enigma context --bundle ${commandPath(bundleInput)} --query "project context"`,
+    `enigma status --bundle ${bundle}`,
+    `enigma drive health --bundle ${bundle}`,
+    `enigma remember --bundle ${bundle} --text-file ./memory.txt`,
+    `enigma search --bundle ${bundle} --query "project context"`,
+    `enigma context --bundle ${bundle} --query "project context"`,
     `enigma verify --export ${commandPath(exportDisplay)}`,
   ];
-  if (!writeConnectors) commands.push(`enigma connect ${primaryClient} --bundle ${commandPath(bundleInput)} --dry-run`);
+  if (!writeConnectors) commands.push(`enigma connect ${primaryClient} --bundle ${bundle} --dry-run`);
   return commands;
 }
 
@@ -1086,10 +1093,13 @@ function initNextCommands({ dryRun, bundleDisplay, outDirDisplay, exportDisplay,
 
 function doctorNextCommands(bundleDisplay, client) {
   const clientId = client ?? DEFAULT_SETUP_CLIENTS[0];
+  const bundle = commandPath(bundleDisplay);
   return [
-    `enigma setup --bundle ${commandPath(bundleDisplay)}`,
-    `enigma doctor --bundle ${commandPath(bundleDisplay)} --client ${clientId}`,
-    `enigma connect ${clientId} --bundle ${commandPath(bundleDisplay)}`,
+    `enigma status --bundle ${bundle}`,
+    `enigma drive health --bundle ${bundle}`,
+    `enigma setup --bundle ${bundle}`,
+    `enigma doctor --bundle ${bundle} --client ${clientId}`,
+    `enigma connect ${clientId} --bundle ${bundle}`,
   ];
 }
 
@@ -1690,6 +1700,27 @@ async function statusCommand(flags, io) {
   print(passportStatusReport({ bundlePath, stored, vault, passport }), io);
   return 0;
 }
+async function readOptionalJsonInput(flags, names) {
+  const path = getFlag(flags, names);
+  if (!path) return null;
+  if (!(await fileExists(path))) return null;
+  return readJson(path);
+}
+
+async function driveHealthCommand(flags, io) {
+  const bundlePath = resolve(String(getFlag(flags, ['bundle', 'file'], DEFAULT_BUNDLE)));
+  const { vault, passport } = await loadState(bundlePath);
+  const benchmarkSummary = await readOptionalJsonInput(flags, ['benchmark-summary', 'benchmarkSummary']);
+  const connectorSummary = await readOptionalJsonInput(flags, ['connector-summary', 'connectorSummary']);
+  const replicas = await readOptionalJsonInput(flags, ['replicas']);
+  const latestAnchorBatchRef = getFlag(flags, ['latest-anchor-batch-ref', 'latestAnchorBatchRef']);
+  const now = getFlag(flags, ['now'], '2026-06-25T00:00:00.000Z');
+  const report = createMemoryDriveHealthReport({ vault, passport, benchmarkSummary, connectorSummary, replicas, latestAnchorBatchRef, now });
+  const outPath = getFlag(flags, ['out']);
+  if (outPath) await writeJson(outPath, report);
+  print(report, io);
+  return 0;
+}
 
 function testDrivePathDisplay(outDirInput, name) {
   return isAbsolute(outDirInput) ? join(outDirInput, name) : quickstartPathDisplay(outDirInput, name);
@@ -1746,6 +1777,7 @@ function testDriveNextCommands(bundleDisplay, crossModelReportDisplay) {
   const quotedReport = commandPath(crossModelReportDisplay);
   return [
     `enigma status --bundle ${quotedBundle}`,
+    `enigma drive health --bundle ${quotedBundle}`,
     `enigma search --bundle ${quotedBundle} --query "local proof bundle"`,
     `enigma demo cross-model --bundle ${quotedBundle} --out ${quotedReport}`,
     'enigma setup --overwrite',
@@ -1760,6 +1792,7 @@ function testDriveFlowCommands({ bundleDisplay, outDirInput, crossModelReportDis
   return [
     `enigma quickstart --bundle ${quotedBundle} --out-dir ${quotedOutDir}${overwriteSuffix}`,
     `enigma status --bundle ${quotedBundle}`,
+    `enigma drive health --bundle ${quotedBundle}`,
     `enigma search --bundle ${quotedBundle} --query "local proof bundle"`,
     `enigma demo cross-model --bundle ${quotedBundle} --out ${quotedReport}`,
   ];
@@ -1953,7 +1986,7 @@ export async function testDriveCommand(flags, io) {
     out_dir: outDirInput,
     bundle: bundleInput,
     install_command: `npm install -g ${packageJson.name ?? 'enigma-memory'}`,
-    release_target: '0.1.16',
+    release_target: '0.1.17',
     artifacts_written: !dryRun,
     client_configs_written: false,
     client_config_write_required: false,
@@ -2405,6 +2438,8 @@ function chainArtifactValidator(artifact) {
   if (schema === 'enigma.proof_network.capability_revocation.v1') return [schema, validateCapabilityRevocation];
   if (schema === 'enigma.proof_network.benchmark_attestation.v1') return [schema, validateBenchmarkAttestation];
   if (schema === 'enigma.proof_network.packet.v1') return [schema, validateProofNetworkPacket];
+  if (schema === 'enigma.proof_network.registry_entry.v1') return [schema, validateRegistryEntry];
+  if (schema === 'enigma.proof_network.registry_batch.v1') return [schema, validateRegistryBatch];
   throw new Error(schema ? 'Unsupported proof-network artifact schema.' : 'Unsupported proof-network artifact schema: missing.');
 }
 
@@ -2702,6 +2737,60 @@ export async function chainVerifyCommand(flags, io, positionalFile = undefined)
   return result.ok === true ? 0 : 1;
 }
 
+export async function chainRegisterCommand(flags, io) {
+  const entryType = requireFlag(flags, ['entry-type', 'entryType', 'type'], 'entry-type');
+  const artifactHashFlag = getFlag(flags, ['artifact-hash', 'artifactHash', 'digest-ref', 'digestRef', 'artifact-ref', 'artifactRef']);
+  const artifactFile = getFlag(flags, ['artifact-file', 'artifactFile']);
+  const resolvedArtifactHash = artifactHashFlag || (artifactFile ? await sha256PublicFile(resolve(String(artifactFile))) : undefined);
+  if (!resolvedArtifactHash) throw new Error('Missing required --artifact-hash or --artifact-file.');
+  const digestRefs = flagValues(flags, ['digest-ref', 'digest-refs', 'digestRef', 'digestRefs', 'root', 'roots']);
+  const entry = createRegistryEntry({
+    entry_type: entryType,
+    artifact_hash: resolvedArtifactHash,
+    artifact_schema_ref: requireFlag(flags, ['artifact-schema-ref', 'artifactSchemaRef', 'schema-ref', 'schemaRef'], 'artifact-schema-ref'),
+    digest_refs: digestRefs.length ? digestRefs : resolvedArtifactHash,
+    signer_refs: flagValues(flags, ['signer', 'signers', 'signer-ref', 'signerRef', 'signer-refs', 'signerRefs', 'attestor', 'attestor-ref', 'attestorRef']),
+    registry_ref: getFlag(flags, ['registry-ref', 'registryRef', 'marketplace-ref', 'marketplaceRef']),
+    entry_ref: getFlag(flags, ['entry-ref', 'entryRef']),
+    entry_count: getFlag(flags, ['entry-count', 'entryCount', 'count']),
+    created_at: getFlag(flags, ['created-at', 'createdAt', 'registered-at', 'registeredAt']),
+    transaction_submitted: false,
+    raw_memory_on_chain: false,
+  });
+  assertChainArtifact(validateRegistryEntry, entry);
+  return chainWriteOrPrint(flags, io, entry, {
+    artifact_type: entry.schema,
+    registry_entry_id: entry.registry_entry_id,
+    registry_entry_hash: entry.registry_entry_hash ?? proofNetworkSha256Json(entry),
+  });
+}
+
+export async function chainRegistryCommand(flags, io, positionalFile = undefined) {
+  const entryPaths = flagValues(flags, ['entry', 'entries', 'entry-file', 'entryFile']);
+  const positionalEntry = positionalFile && !String(positionalFile).startsWith('--') ? positionalFile : undefined;
+  const paths = entryPaths.length ? entryPaths : (positionalEntry ? [positionalEntry] : []);
+  if (paths.length === 0) throw new Error('Missing required --entry <registry-entry.json>.');
+  const entries = [];
+  for (const entryPath of paths) {
+    const entry = await readJson(resolve(entryPath));
+    assertNoPrivateProofPayload(entry);
+    entries.push(entry);
+  }
+  const batch = createRegistryBatch({
+    entries,
+    registry_ref: getFlag(flags, ['registry-ref', 'registryRef', 'marketplace-ref', 'marketplaceRef']),
+    created_at: getFlag(flags, ['created-at', 'createdAt']),
+    transaction_submitted: false,
+    raw_memory_on_chain: false,
+  });
+  assertChainArtifact(validateRegistryBatch, batch);
+  return chainWriteOrPrint(flags, io, batch, {
+    artifact_type: batch.schema,
+    registry_batch_id: batch.registry_batch_id,
+    registry_batch_hash: batch.registry_batch_hash ?? proofNetworkSha256Json(batch),
+  });
+}
+
 
 export async function meterEventCommand(flags, io) {
   const event = createUsageEvent({
@@ -2927,6 +3016,9 @@ function usage() {
       'chain attest',
       'chain verify',
       'chain submit-solana',
+      'chain register',
+      'chain registry',
+      'drive health',
     ],
     connector_options: {
       '--bundle <path>': 'Absolute local Enigma vault bundle path rendered as ENIGMA_BUNDLE.',
@@ -3047,9 +3139,26 @@ function usage() {
       revoke: 'enigma chain revoke --grant-hash <sha256:...> --reason <public-reason-code> [--revocation-ref <public-ref>] [--out <file>]',
       attest: 'enigma chain attest (--report-hash <sha256:...> | --report-file <report.json>) --dataset-ref <sha256:...> --runner-ref <public-runner-ref> --package-ref <public-package-ref> [--score name=value] [--out <file>]',
       verify: 'enigma chain verify --file <proof-artifact.json>',
+      register: 'enigma chain register --entry-type <anchor_batch|benchmark_attestation|connector_conformance|health_report|operator_receipt|settlement_job> (--artifact-hash <sha256:...> | --artifact-file <artifact.json>) --artifact-schema-ref <schema-id> [--digest-ref <sha256:...>] [--signer <public-ref>] [--registry-ref <public-ref>] [--entry-ref <public-ref>] [--entry-count <n>] [--out <file>]',
+      registry: 'enigma chain registry --entry <registry-entry.json> [--entry <registry-entry.json>] [--registry-ref <public-ref>] [--out <file>]',
       submit_solana: 'enigma chain submit-solana --file <proof-artifact.json> --cluster <devnet|testnet|mainnet-beta|localnet> [--rpc <url>] [--execute --keypair <solana-cli-64-byte-keypair.json>]',
       boundary: 'Proof Network chain commands default to local planning and dry-run validation. submit-solana only submits a Solana Memo transaction when --execute is passed; it carries compact public-safe commitment/ref JSON, never raw memory or artifact bodies.',
     },
+    memory_drive_health: {
+      command: 'enigma drive health --bundle <path> [--now <iso>] [--benchmark-summary <path>] [--connector-summary <path>] [--replicas <path>] [--latest-anchor-batch-ref <ref>] [--out <file>]',
+      schema: 'enigma.memory_drive_health_report.v1',
+      output_shape: 'SMART-style report: overall_status/overall_score, ten metrics (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/recommended_actions, plus roots, privacy_boundaries, claim_boundaries, and a conservative proof_network_ready block.',
+      options: {
+        '--bundle <path>': 'Local Enigma vault bundle to inspect. Defaults to .enigma/bundle.json.',
+        '--now <iso>': 'ISO-8601 timestamp used for age calculations. Defaults to a deterministic timestamp.',
+        '--benchmark-summary <path>': 'Optional JSON file with public-safe retrieval probes (probe_count, top_k, hit_at_k, exact_coverage, abstention_correctness). Omit to default gracefully.',
+        '--connector-summary <path>': 'Optional JSON file with public-safe connector health (connector_count, healthy_connector_count, lagging_connector_count, error_rate_24h, cursor_gap_count). Omit to default gracefully.',
+        '--replicas <path>': 'Optional JSON file of replica root reports for sync fork risk.',
+        '--latest-anchor-batch-ref <ref>': 'Optional public-safe proof-network anchor batch ref for receipt coverage.',
+        '--out <path>': 'Write the JSON report to a file in addition to stdout.',
+      },
+      boundary: 'Computed locally from public-safe counters, roots, receipt metadata, tombstones, and derived/context-pack refs only. No network or chain calls; transaction_submitted and raw_memory_on_chain are always false. It is local operational evidence, not provider-deletion, model-forgetting, compliance, or live-chain-settlement proof.',
+    },
     relay_gateway_options: {
       '--host <host>': 'Bind host. Defaults to 127.0.0.1.',
       '--port <port>': `Bind port. Defaults to ${DEFAULT_RELAY_PORT} for relay and ${DEFAULT_GATEWAY_PORT} for gateway.`,
@@ -3076,10 +3185,10 @@ export async function main(argv = process.argv.slice(2), io = { stdout: process.
     print(usage(), io);
     return 0;
   }
-  const twoPartCommands = ['boundary', 'mcp', 'mesh', 'enterprise', 'capsule', 'relay', 'gateway', 'connect', 'disconnect', 'import', 'native-host', 'meter', 'settlement', 'chain', 'demo', 'passport'];
+  const twoPartCommands = ['boundary', 'mcp', 'mesh', 'enterprise', 'capsule', 'relay', 'gateway', 'connect', 'disconnect', 'import', 'native-host', 'meter', 'settlement', 'chain', 'demo', 'passport', 'drive'];
   const flags = parseArgs(twoPartCommands.includes(command) ? argv.slice(2) : argv.slice(1));
   const positionalFile = optionalPositional(argv[2]);
-  if ((command === 'chain' && (!subcommand || subcommand === '--help' || subcommand === '-h' || flags.has('help'))) || ((flags.has('help') || argv.includes('-h')) && (command === 'init' || command === 'setup' || command === 'test-drive' || command === 'search' || command === 'status' || (command === 'passport' && subcommand === 'status') || ((command === 'relay' || command === 'gateway') && (subcommand === 'serve' || subcommand === 'demo')) || (command === 'native-host' && (subcommand === 'manifest' || subcommand === 'install-plan')) || (command === 'demo' && subcommand === 'cross-model')))) {
+  if ((command === 'chain' && (!subcommand || subcommand === '--help' || subcommand === '-h' || flags.has('help'))) || ((flags.has('help') || argv.includes('-h')) && (command === 'init' || command === 'setup' || command === 'test-drive' || command === 'search' || command === 'status' || (command === 'passport' && subcommand === 'status') || ((command === 'relay' || command === 'gateway') && (subcommand === 'serve' || subcommand === 'demo')) || (command === 'native-host' && (subcommand === 'manifest' || subcommand === 'install-plan')) || (command === 'demo' && subcommand === 'cross-model') || (command === 'drive' && subcommand === 'health')))) {
     print(usage(), io);
     return 0;
   }
@@ -3101,6 +3210,7 @@ export async function main(argv = process.argv.slice(2), io = { stdout: process.
     if (command === 'search') return await searchCommand(flags, io);
     if (command === 'status') return await statusCommand(flags, io);
     if (command === 'passport' && subcommand === 'status') return await statusCommand(flags, io);
+    if (command === 'drive' && subcommand === 'health') return await driveHealthCommand(flags, io);
     if (command === 'export') return await exportCommand(flags, io);
     if (command === 'import') return await importCommand(subcommand, flags, io, positionalFile);
     if (command === 'capsule' && subcommand === 'export') return await capsuleExportCommand(flags, io, positionalFile);
@@ -3127,6 +3237,8 @@ export async function main(argv = process.argv.slice(2), io = { stdout: process.
     if (command === 'chain' && subcommand === 'attest') return await chainAttestCommand(flags, io);
     if (command === 'chain' && subcommand === 'verify') return await chainVerifyCommand(flags, io, positionalFile);
     if (command === 'chain' && subcommand === 'submit-solana') return await chainSubmitSolanaCommand(flags, io, positionalFile);
+    if (command === 'chain' && subcommand === 'register') return await chainRegisterCommand(flags, io);
+    if (command === 'chain' && subcommand === 'registry') return await chainRegistryCommand(flags, io, positionalFile);
     if (command === 'native-host' && subcommand === 'install-plan') return await nativeHostInstallPlanCommand(flags, io);
     if (command === 'mesh' && subcommand === 'demo') return await meshDemoCommand(flags, io);
     if (command === 'enterprise' && subcommand === 'demo') return await enterpriseDemoCommand(flags, io);

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.16",
+    "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.16",
+    "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.16`. 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:
 
@@ -67,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.16`.
+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
@@ -142,7 +142,7 @@ Public sharing should include the generated benchmark report JSON and generated
 
 ## Proof-network benchmark attestations
 
-For the planned 0.1.16 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.
 
@@ -151,7 +151,7 @@ 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.16" --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, 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.
@@ -180,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/client-connectors.md

@@ -16,15 +16,19 @@ Supported connector IDs:
 
 ```sh
 npm install -g enigma-memory
-enigma setup --overwrite
+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 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. Client config writes happen only when you explicitly run `enigma connect <client>` without `--dry-run`.
+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.
+
+For a single client, or to preview before writing, use `enigma connect <client> --dry-run` and then drop `--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.
 

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.16 \
+  --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.16 \
+  --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.16",
+  "package_ref": "npm:enigma-memory@0.1.17",
   "scores": {
     "recall_at_5": 1,
     "p95_latency_ms": 14

package/docs/developer-ecosystem.md

@@ -8,15 +8,17 @@ For most developers, start with the installed CLI before reading the SDK interna
 
 ```sh
 npm install -g enigma-memory
-enigma setup --overwrite
+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 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 third-party app configs unless you explicitly run `enigma connect <client>` without `--dry-run`. Treat provider-native memory as non-canonical cache only; the local Enigma vault is canonical.
+`enigma init` creates the local `.enigma` workspace, bundle, and proof artifacts with no provider or cloud credentials. `enigma setup --client auto --connect-installed --overwrite` configures the drive and writes the `mcpServers.enigma` entry into every installed/config-present client it detects, skipping clients that are not installed; preview with `--dry-run` first. `enigma drive health` reports a SMART-style memory-drive health packet (freshness, duplicate rate, 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. Neither setup command prints raw memory plaintext. Treat provider-native memory as non-canonical cache only; the local Enigma vault is canonical.
 
 Optional public test-drive loop:
 

package/docs/developer-proof-quickstart.md

@@ -141,7 +141,7 @@ npx --yes --package enigma-memory enigma chain attest \
   --report-hash sha256:6666666666666666666666666666666666666666666666666666666666666666 \
   --dataset-ref dataset:quickstart-public-fixture:v1 \
   --runner-ref runner:enigma-local:v1 \
-  --package-ref npm:enigma-memory@0.1.16 \
+  --package-ref npm:enigma-memory@0.1.17 \
   --score recall_at_5=1 \
   --score p95_latency_ms=14 \
   --out .enigma/proof-quickstart/benchmark-attestation.json
@@ -154,7 +154,7 @@ npx --yes --package enigma-memory enigma chain attest \
   --report-file .enigma/proof-quickstart/reviewed-benchmark-report.json \
   --dataset-ref dataset:quickstart-public-fixture:v1 \
   --runner-ref runner:enigma-local:v1 \
-  --package-ref npm:enigma-memory@0.1.16 \
+  --package-ref npm:enigma-memory@0.1.17 \
   --score recall_at_5=1 \
   --score p95_latency_ms=14 \
   --out .enigma/proof-quickstart/benchmark-attestation.json
@@ -282,7 +282,7 @@ const attestation = createBenchmarkAttestation({
   report_hash: 'sha256:6666666666666666666666666666666666666666666666666666666666666666',
   dataset_ref: 'dataset:quickstart-public-fixture:v1',
   runner_ref: 'runner:enigma-local:v1',
-  package_ref: 'npm:enigma-memory@0.1.16',
+  package_ref: 'npm:enigma-memory@0.1.17',
   sample_count: 12,
   run_count: 1,
 });

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.16"
+    "enigma_version": "0.1.17"
   },
   "commands": [
     {