enigma-memory 0.1.11 → 0.1.13

package/docs/demo-proof-network.md

@@ -0,0 +1,275 @@
+# Proof Network demo scripts
+
+Use these scripts to show Enigma's Proof Network with a local package install. They create and verify public-safe JSON proof artifacts only. They do not submit Solana transactions, call hosted Enigma, call model providers, write client configs, or place raw memory on chain.
+
+Requirements:
+
+- Node.js `>=24`
+- `enigma-memory` available through npm or a local package install
+- No provider credentials for the three default demos
+
+Run the commands from a writable demo directory after installing the package, for example `npm install -g enigma-memory`. For a one-off public npm run, prefix each `enigma` command with `npx --yes --package enigma-memory`. From a source checkout, replace `enigma` with `node apps/cli/bin/enigma.mjs`.
+
+Public-safety rule: proof artifacts may contain hashes, roots, refs, counts, timestamps, public authority refs, signatures, and boolean claim boundaries. They must not contain raw memory, prompts, transcripts, completions, embeddings, ACL bodies, tenant names, private keys, API keys, seed phrases, or provider responses.
+
+## Demo 1 — public npm test-drive + proof anchor plan
+
+Goal: run the public local test drive, then produce a Solana-ready anchor batch that commits only opaque roots and refs. The batch is a transaction plan, not a submitted transaction.
+
+```sh
+node -e "require('node:fs').mkdirSync('.enigma/proof-network',{recursive:true})"
+
+enigma test-drive \
+  --out-dir .enigma/proof-network/test-drive \
+  --overwrite
+
+enigma chain anchor \
+  --root sha256:1111111111111111111111111111111111111111111111111111111111111111 \
+  --root sha256:2222222222222222222222222222222222222222222222222222222222222222 \
+  --root sha256:3333333333333333333333333333333333333333333333333333333333333333 \
+  --ref npm-test-drive:bundle-root:v1 \
+  --ref npm-test-drive:receipt-root:v1 \
+  --ref npm-test-drive:context-root:v1 \
+  --authority did:web:enigma.example#local-demo \
+  --batch-ref proof-network-demo-anchor-001 \
+  --out .enigma/proof-network/anchor-batch.json
+
+enigma chain verify \
+  --file .enigma/proof-network/anchor-batch.json
+```
+
+Expected public-safe output shape from `chain anchor`:
+
+```json
+{
+  "ok": true,
+  "artifact_type": "enigma.proof_network.anchor_batch.v1",
+  "transaction_submitted": false,
+  "raw_memory_on_chain": false,
+  "batch_ref": "proof-network-demo-anchor-001",
+  "roots": [
+    "sha256:1111111111111111111111111111111111111111111111111111111111111111",
+    "sha256:2222222222222222222222222222222222222222222222222222222222222222",
+    "sha256:3333333333333333333333333333333333333333333333333333333333333333"
+  ],
+  "refs": [
+    "npm-test-drive:bundle-root:v1",
+    "npm-test-drive:receipt-root:v1",
+    "npm-test-drive:context-root:v1"
+  ],
+  "solana_ready": true,
+  "claim_boundaries": {
+    "provider_calls": false,
+    "hosted_enigma_calls": false,
+    "transaction_submitted": false,
+    "raw_memory_on_chain": false
+  }
+}
+```
+
+Expected public-safe output shape from `chain verify`:
+
+```json
+{
+  "ok": true,
+  "artifact_type": "enigma.proof_network.anchor_batch.v1",
+  "valid": true,
+  "transaction_submitted": false,
+  "raw_memory_on_chain": false,
+  "private_payload_detected": false
+}
+```
+
+Presenter notes:
+
+1. The test drive proves local Enigma-controlled state only.
+2. The anchor batch is Solana-ready because it is an opaque commitment payload, but it is not a transaction and it is not submitted.
+3. Replace the demo roots with roots emitted by your own local Enigma run when presenting a real local artifact. Do not paste memory text, prompts, embeddings, provider responses, or tenant/customer names into `--root`, `--ref`, or `--authority`.
+
+## Demo 2 — cross-model memory receipt demo
+
+Goal: show one local Enigma bundle producing public receipt summaries for multiple model/client profiles, then issue a scoped capability grant and revocation for one public subject ref. No model provider is contacted.
+
+```sh
+node -e "require('node:fs').mkdirSync('.enigma/proof-network',{recursive:true})"
+
+enigma test-drive \
+  --out-dir .enigma/proof-network/cross-model \
+  --overwrite
+
+enigma demo cross-model \
+  --bundle .enigma/proof-network/cross-model/bundle.json \
+  --out .enigma/proof-network/cross-model-report.json
+
+enigma chain grant \
+  --subject agent:claude-desktop:local-demo \
+  --capability memory.context.read \
+  --scope context-pack:cross-model-demo:v1 \
+  --expires-at 2026-12-31T00:00:00.000Z \
+  --grant-ref proof-network-demo-grant-001 \
+  --out .enigma/proof-network/capability-grant.json
+
+enigma chain revoke \
+  --grant-hash sha256:4444444444444444444444444444444444444444444444444444444444444444 \
+  --reason demo-complete \
+  --revocation-ref proof-network-demo-revocation-001 \
+  --out .enigma/proof-network/capability-revocation.json
+
+enigma chain verify \
+  --file .enigma/proof-network/capability-grant.json
+
+enigma chain verify \
+  --file .enigma/proof-network/capability-revocation.json
+```
+
+Expected public-safe output shape from `demo cross-model`:
+
+```json
+{
+  "ok": true,
+  "demo": "cross-model-memory",
+  "provider_calls": false,
+  "raw_memory_included": false,
+  "profiles": [
+    {
+      "client": "claude-desktop",
+      "context_pack_hash": "sha256:...",
+      "receipt_refs": ["receipt:..."]
+    },
+    {
+      "client": "cursor",
+      "context_pack_hash": "sha256:...",
+      "receipt_refs": ["receipt:..."]
+    },
+    {
+      "client": "kimi-code",
+      "context_pack_hash": "sha256:...",
+      "receipt_refs": ["receipt:..."]
+    }
+  ]
+}
+```
+
+Expected public-safe output shape from `chain grant`:
+
+```json
+{
+  "ok": true,
+  "artifact_type": "enigma.proof_network.capability_grant.v1",
+  "transaction_submitted": false,
+  "raw_memory_on_chain": false,
+  "subject": "agent:claude-desktop:local-demo",
+  "capability": "memory.context.read",
+  "scope": "context-pack:cross-model-demo:v1",
+  "expires_at": "2026-12-31T00:00:00.000Z",
+  "grant_ref": "proof-network-demo-grant-001",
+  "private_payload_detected": false
+}
+```
+
+Expected public-safe output shape from `chain revoke`:
+
+```json
+{
+  "ok": true,
+  "artifact_type": "enigma.proof_network.capability_revocation.v1",
+  "transaction_submitted": false,
+  "raw_memory_on_chain": false,
+  "grant_hash": "sha256:4444444444444444444444444444444444444444444444444444444444444444",
+  "reason": "demo-complete",
+  "revocation_ref": "proof-network-demo-revocation-001",
+  "private_payload_detected": false
+}
+```
+
+Presenter notes:
+
+1. The cross-model report is a receipt demo, not proof that a provider remembered or forgot anything.
+2. Capability grants are public authorization receipts. Scopes must be public refs, not ACL JSON, tenant names, or private policy bodies.
+3. Revocations should point to grant hashes or nullifiers. Do not include the original private grant context.
+
+## Demo 3 — benchmark attestation demo
+
+Goal: turn a benchmark report hash or local report file into a public benchmark attestation. This demo uses deterministic refs and scores only; the proof artifact does not include dataset rows, questions, answers, prompts, completions, provider responses, or credentials.
+
+Package-only path with a precomputed public report hash:
+
+```sh
+node -e "require('node:fs').mkdirSync('.enigma/proof-network',{recursive:true})"
+
+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.13 \
+  --score recall_at_5=1 \
+  --score p95_latency_ms=14 \
+  --out .enigma/proof-network/benchmark-attestation.json
+
+enigma chain verify \
+  --file .enigma/proof-network/benchmark-attestation.json
+```
+
+Source-checkout path when you have a local benchmark report file:
+
+```sh
+node scripts/run-memory-benchmarks.mjs
+
+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.13 \
+  --score recall_at_5=1 \
+  --score p95_latency_ms=14 \
+  --out .enigma/proof-network/benchmark-attestation.json
+```
+
+Expected public-safe output shape from `chain attest`:
+
+```json
+{
+  "ok": true,
+  "artifact_type": "enigma.proof_network.benchmark_attestation.v1",
+  "transaction_submitted": false,
+  "raw_memory_on_chain": false,
+  "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.13",
+  "scores": {
+    "recall_at_5": 1,
+    "p95_latency_ms": 14
+  },
+  "private_payload_detected": false
+}
+```
+
+Optional full-answer benchmark note: a separate full-answer benchmark runner may require provider credentials for the model being evaluated. Keep those credentials in local environment variables or a secret manager only. The public proof artifact should still contain only `report_hash`, `dataset_ref`, `runner_ref`, `package_ref`, scores, roots, refs, signatures, and claim boundaries. Never include provider requests, provider responses, prompts, answers, dataset rows, account ids, API keys, tenant names, or raw memory in the attestation.
+
+Presenter notes:
+
+1. A benchmark attestation proves that a named report hash, dataset ref, runner ref, package ref, and score set were committed together.
+2. It is not a leaderboard claim unless the named benchmark protocol, dataset access, runner, scoring rules, and comparison set are independently published and reproducible.
+3. `chain verify` validates the artifact shape and public-safety boundaries; it does not rerun the benchmark.
+
+## Close the demo
+
+Verify every generated artifact before sharing it:
+
+```sh
+enigma chain verify --file .enigma/proof-network/anchor-batch.json
+enigma chain verify --file .enigma/proof-network/capability-grant.json
+enigma chain verify --file .enigma/proof-network/capability-revocation.json
+enigma chain verify --file .enigma/proof-network/benchmark-attestation.json
+```
+
+Safe closing claim: Enigma can create local, public-safe proof-network artifacts that are ready for chain anchoring without exposing memory contents or submitting a transaction.
+
+Unsafe claims to avoid:
+
+- "A Solana transaction was submitted" unless you separately submitted one outside these local planning commands.
+- "Raw memory is on chain"; that should never be true for these demos.
+- "Providers deleted or forgot the memory."
+- "Provider-native memory is canonical."
+- "Benchmark leadership is proven" unless a reproducible comparison protocol and artifacts are published.

package/docs/developer-ecosystem.md

@@ -67,12 +67,12 @@ The example app prints ids, counts, roots, and verification status only. It does
 
 ## CLI and CI loop
 
-The CI example installs Node 24, installs the published `enigma-memory@0.1.11` package, runs:
+The CI example installs Node 24, installs `enigma-memory` into a disposable npm project, exposes the package benchmark script, then runs:
 
 ```sh
-npx --yes --package enigma-memory enigma test-drive --overwrite
-npx --yes --package enigma-memory enigma setup --overwrite
-npx --yes --package enigma-memory enigma doctor
+npx enigma test-drive --overwrite
+npx enigma setup --overwrite
+npx enigma doctor
 npm run benchmark:memory-suite -- --out benchmark-report.json
 ```
 
@@ -90,6 +90,49 @@ Those commands produce a dataset manifest with source URLs, byte sizes, and SHA-
 
 Use the workflow as a template in a consumer repository. It is intentionally limited to install/import/doctor smoke coverage, local proof generation, and deterministic local benchmark evidence by default; it does not publish packages, deploy infrastructure, contact hosted Enigma cloud, call external memory providers, or download official benchmark datasets unless you intentionally enable `run_standard_benchmark` for a manual workflow run.
 
+## Proof Network developer loop
+
+The proof-network path gives integrators a public, privacy-preserving adoption track before any chain transaction or hosted integration exists. The adoption ladder is intentionally simple:
+
+1. Install or invoke the npm package.
+2. Run the local test drive to produce safe roots/receipts/counts.
+3. Generate proof-network chain artifacts from public-safe inputs.
+4. Verify those artifacts locally.
+5. Wire the same artifact contract into a connector, benchmark dashboard, or conformance test.
+
+```sh
+npx --yes --package enigma-memory enigma test-drive --overwrite
+npx --yes --package enigma-memory enigma chain anchor --root sha256:8f8f... --root sha256:9a9a... --ref demo-local-vault --authority demo-public-authority --batch-ref demo-anchor-batch --out .enigma/proof-anchor-batch.json
+npx --yes --package enigma-memory enigma chain grant --subject did:example:agent --capability memory.read --scope demo-scope --resource-ref sha256:8f8f... --policy-hash sha256:7e7e... --expires-at 2026-07-01T00:00:00Z --grant-ref demo-grant --out .enigma/proof-capability-grant.json
+npx --yes --package enigma-memory enigma chain revoke --grant-hash sha256:6d6d... --reason scope-ended --revocation-ref demo-revocation --out .enigma/proof-capability-revocation.json
+npx --yes --package enigma-memory enigma chain attest --report-file benchmark-report.json --dataset-ref sha256:5c5c... --runner-ref enigma-standard-runner --package-ref enigma-memory@0.1.13 --score accuracy=0.92 --out .enigma/proof-benchmark-attestation.json
+npx --yes --package enigma-memory enigma chain verify --file .enigma/proof-anchor-batch.json
+```
+
+`enigma chain anchor`, `grant`, `revoke`, `attest`, and `verify` are local planning commands. They create or validate opaque JSON proof-network artifacts for Solana-ready anchoring, but they do not create accounts, sign with private keys, submit transactions, deploy programs, or call RPC providers. Generated chain artifacts must keep `transaction_submitted:false` and `raw_memory_on_chain:false`; if an example needs a memory reference, use a public-safe commitment or receipt root rather than raw memory, prompts, transcripts, completions, embeddings, ACL bodies, tenant names, provider responses, private keys, seed phrases, or credentials.
+
+Use proof artifacts as the common exchange format for developer integrations:
+
+- **NPM test-drive adopters:** run the test drive, create an anchor batch from local roots/refs, verify the artifact, and attach the JSON to a pull request, demo, or release note without exposing private memory.
+- **Chain artifact builders:** treat `anchor_batch`, `capability_grant`, `capability_revocation`, `benchmark_attestation`, and `packet` as the supported public artifact types. Anchors carry roots/refs/counts for later settlement; grants carry subject, capability, scope, resource refs, policy hashes, and expiry; revocations carry grant hashes and nullifiers; attestations carry report hashes plus dataset, runner, package, and score refs.
+- **Conformance program partners:** build fixtures that accept valid proof-network artifacts and reject artifacts that leak private payload keys or values, omit the false transaction flags, use raw ACL or tenant bodies, or mix raw memory with public chain payloads. A connector should pass conformance before it claims proof-network support.
+- **Benchmark attestation contributors:** hash the benchmark report or pass the report file, then bind it to dataset, runner, and package refs. The attestation makes benchmark evidence portable, but benchmark claims still depend on the benchmark guide's dataset, scoring, and comparison boundaries.
+- **Connector authors:** wallet, agent, MCP, CI, and dashboard connectors can verify packets, display opaque Solana-ready roots, enforce grants before retrieval, publish revocation/nullifier artifacts when access ends, and keep private bundles off-chain while sharing verifiable commitments.
+
+Conformance should stay narrow and testable. A proof-network connector is ready for public examples when it can:
+
+1. accept every supported proof-network artifact shape and return a deterministic validation result;
+2. reject any artifact containing private-looking field names or values before display, upload, signing, or indexing;
+3. preserve `transaction_submitted:false` unless a separate reviewed settlement path actually submits a transaction;
+4. preserve `raw_memory_on_chain:false` for every chain-facing artifact;
+5. enforce capability grant subject, capability, scope, resource-ref, policy-hash, and expiry constraints before retrieval;
+6. accept capability revocations/nullifiers and stop treating revoked grants as usable;
+7. bind benchmark attestations to report hashes/files plus dataset, runner, and package refs without importing the raw benchmark corpus or private model output.
+
+Good first connector projects are deliberately small: a CLI verifier that fails CI on leaked private payloads, a wallet preview that shows only roots/scopes/expiry/nullifiers, an MCP middleware that blocks retrieval without a live grant, a benchmark dashboard that accepts attestation JSON beside a report hash, and a Solana explorer plugin that labels opaque anchor batches without claiming transaction submission.
+
+This path is intentionally copyable: npm install, run a local test drive, generate proof artifacts, verify them, then wire the same public-safe contract into a connector or conformance test. Do not position it as live settlement, provider deletion proof, compliance certification, or benchmark leadership without the separate evidence those claims require.
+
 ## MCP client loop
 
 The same installed package can be used by Claude Desktop, Cursor, Kimi Code, or any generic MCP client. Run `enigma test-drive --overwrite` first if you want a zero-credential local proof before touching real client configs. The smooth setup path is `enigma setup --client auto --overwrite` to plan detected clients, then `enigma setup --connect-installed --overwrite` only when you explicitly want setup to write installed/config-present client configs. Manual snippets remain useful when a client needs a copied entry; replace the bundle path with the local path from your setup output, and restart the client.

package/docs/developer-proof-quickstart.md

@@ -0,0 +1,325 @@
+# Developer proof quickstart
+
+This quickstart shows how to create, inspect, and verify Enigma Proof Network artifacts from a developer workstation. The product boundary is intentionally narrow: Enigma is the private memory controller for AI, and Solana is an optional proof, permission, and settlement rail that should carry hashes, roots, and opaque refs only.
+
+Use the commands as local proof-artifact exercises. They do not submit Solana transactions, call Solana RPC, call model providers, create hosted Enigma resources, or put raw memory on-chain.
+
+## 0. Public-safety rule
+
+Before running any command, decide what is safe to publish.
+
+Allowed in proof artifacts:
+
+- SHA-256 hashes and Merkle roots;
+- opaque refs such as `memory-batch:demo:v1`, `agent:demo-reviewer`, or `dataset:public-fixture:v1`;
+- counts, timestamps, local artifact ids, and public authority refs;
+- booleans such as `transaction_submitted:false` and `raw_memory_on_chain:false`.
+
+Never place these in a proof artifact, command flag, JSON example, issue comment, gist, explorer memo, or packet:
+
+- raw memory, prompts, transcripts, completions, embeddings, dataset rows, or provider responses;
+- tenant names, customer names, private file paths, ACL bodies, policy documents, or internal ticket text;
+- API keys, bearer tokens, private keys, seed phrases, mnemonics, passwords, or signed provider payloads.
+
+## 1. Install and run the local test-drive
+
+Start in an empty working directory or a scratch directory inside your project. For a one-off test-drive, `npx --package` downloads and runs the CLI without editing your project dependencies:
+
+```sh
+mkdir -p .enigma/proof-quickstart
+
+npx --yes --package enigma-memory enigma test-drive \
+  --out-dir .enigma/proof-quickstart/test-drive \
+  --overwrite
+```
+
+For a project-local install, add the package first and then run the same CLI:
+
+```sh
+npm install enigma-memory
+npx enigma test-drive \
+  --out-dir .enigma/proof-quickstart/test-drive \
+  --overwrite
+```
+
+The test drive creates local Enigma demo artifacts. Treat full local bundles as private until reviewed. For a proof-network flow, publish only reviewed hashes, roots, refs, and verifier output.
+
+If you are working from a source checkout instead of npm, run the CLI directly from the package checkout:
+
+```sh
+cd enigma
+node apps/cli/bin/enigma.mjs test-drive \
+  --out-dir ../.enigma/proof-quickstart/test-drive \
+  --overwrite
+```
+
+## 2. Create a Solana-ready anchor batch
+
+An anchor batch commits to memory-related roots without publishing memory. It is a local transaction plan, not a submitted transaction.
+
+```sh
+npx --yes --package enigma-memory enigma chain anchor \
+  --root sha256:1111111111111111111111111111111111111111111111111111111111111111 \
+  --root sha256:2222222222222222222222222222222222222222222222222222222222222222 \
+  --root sha256:3333333333333333333333333333333333333333333333333333333333333333 \
+  --ref memory-batch:quickstart:v1 \
+  --ref receipt-root:quickstart:v1 \
+  --ref policy-root:quickstart:v1 \
+  --batch-ref anchor:quickstart:001 \
+  --out .enigma/proof-quickstart/anchor-batch.json
+```
+
+The chain should eventually see only the opaque root or payload reference an operator chooses to submit. The JSON file remains the local artifact of record for developer verification.
+
+Verify it:
+
+```sh
+npx --yes --package enigma-memory enigma chain verify \
+  --file .enigma/proof-quickstart/anchor-batch.json
+```
+
+## 3. Create a scoped capability grant
+
+A grant records that a public subject ref is allowed to use a specific memory capability for a public-safe scope until an expiry time. It is not a live auth mutation by itself.
+
+```sh
+npx --yes --package enigma-memory enigma chain grant \
+  --subject agent:demo-reviewer \
+  --capability memory.receipt_summary.read \
+  --scope proof.summary \
+  --resource-ref sha256:1111111111111111111111111111111111111111111111111111111111111111 \
+  --policy-hash sha256:4444444444444444444444444444444444444444444444444444444444444444 \
+  --expires-at 2026-12-31T00:00:00.000Z \
+  --grant-ref grant:quickstart:001 \
+  --out .enigma/proof-quickstart/capability-grant.json
+```
+
+Verify it:
+
+```sh
+npx --yes --package enigma-memory enigma chain verify \
+  --file .enigma/proof-quickstart/capability-grant.json
+```
+
+Good grant inputs are intentionally boring:
+
+- `--subject` is an opaque agent, app, wallet, or reviewer ref;
+- `--capability` is a small action name, not a paragraph of policy;
+- `--scope` is a public scope token, not raw ACL JSON;
+- `--resource-ref` and `--policy-hash` are hashes or public refs, not the underlying resource or policy body;
+- `--expires-at` is explicit so grants are not permanent by default.
+
+## 4. Revoke the grant
+
+A revocation records that a prior grant hash is no longer accepted for the relevant scope. It does not prove that a model, provider, cache, export, or third-party system forgot data.
+
+```sh
+npx --yes --package enigma-memory enigma chain revoke \
+  --grant-hash sha256:5555555555555555555555555555555555555555555555555555555555555555 \
+  --reason scope-ended \
+  --revocation-ref revocation:quickstart:001 \
+  --out .enigma/proof-quickstart/capability-revocation.json
+```
+
+Verify it:
+
+```sh
+npx --yes --package enigma-memory enigma chain verify \
+  --file .enigma/proof-quickstart/capability-revocation.json
+```
+
+Use the real `capability_grant_hash` or `grant_hash` from your reviewed grant artifact when leaving demo mode. Do not paste the original private policy, subject name, customer name, or private grant context into the revocation.
+
+## 5. Create a benchmark attestation
+
+A benchmark attestation binds a public report hash to dataset, runner, package, and metric refs. It should not contain raw benchmark rows, questions, answers, prompts, completions, provider responses, or private dataset paths.
+
+With a precomputed report hash:
+
+```sh
+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.13 \
+  --score recall_at_5=1 \
+  --score p95_latency_ms=14 \
+  --out .enigma/proof-quickstart/benchmark-attestation.json
+```
+
+With a reviewed local report file:
+
+```sh
+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.13 \
+  --score recall_at_5=1 \
+  --score p95_latency_ms=14 \
+  --out .enigma/proof-quickstart/benchmark-attestation.json
+```
+
+Verify it:
+
+```sh
+npx --yes --package enigma-memory enigma chain verify \
+  --file .enigma/proof-quickstart/benchmark-attestation.json
+```
+
+The safe claim is that the attestation binds a report hash and public refs to a local proof artifact. It is not evidence of comparative benchmark rank, legal/compliance status, provider behavior, model state, or customer production deployment.
+
+## 6. Inspect the JSON before sharing
+
+First, verify every artifact locally:
+
+```sh
+for file in .enigma/proof-quickstart/*.json; do
+  npx --yes --package enigma-memory enigma chain verify --file "$file"
+done
+```
+
+Then inspect only public-safe fields. With `jq`:
+
+```sh
+jq '{schema, transaction_submitted, raw_memory_on_chain, anchor_batch_hash, capability_grant_hash, capability_revocation_hash, benchmark_attestation_hash}' \
+  .enigma/proof-quickstart/anchor-batch.json
+```
+
+Without `jq`, use Node:
+
+```sh
+node -e "const fs=require('node:fs'); const p=process.argv[1]; const x=JSON.parse(fs.readFileSync(p,'utf8')); const keys=['schema','transaction_submitted','raw_memory_on_chain','anchor_batch_hash','capability_grant_hash','capability_revocation_hash','benchmark_attestation_hash']; console.log(JSON.stringify(Object.fromEntries(keys.filter(k=>k in x).map(k=>[k,x[k]])), null, 2));" \
+  .enigma/proof-quickstart/anchor-batch.json
+```
+
+Checklist before publishing or sending an artifact:
+
+- `schema` starts with `enigma.proof_network.`;
+- `transaction_submitted` is `false` unless a separate operator-controlled submission artifact exists;
+- `raw_memory_on_chain` is `false`;
+- roots and hashes use `sha256:<64 lowercase hex characters>`;
+- refs are opaque and public-safe;
+- no field names include private payload concepts such as `prompt`, `text`, `content`, `transcript`, `embedding`, `acl`, `secret`, `api_key`, `private_key`, `tenant_name`, or `customer_name`;
+- verifier output returns `ok:true` for the artifact type you intend to share.
+
+A quick secret-name scan can catch obvious mistakes before review:
+
+```sh
+node -e "const fs=require('node:fs'); const bad=/(raw|plaintext|prompt|message|text|content|transcript|completion|embedding|acl|provider_response|credential|api_key|secret|password|private_key|seed|mnemonic|tenant_name|customer_name)/i; const allowed=new Set(['raw_memory_on_chain','transaction_submitted']); for (const p of process.argv.slice(1)) { const x=JSON.parse(fs.readFileSync(p,'utf8')); const hits=[]; (function walk(v,path){ if (v && typeof v==='object') for (const [k,c] of Object.entries(v)) { if (!allowed.has(k) && bad.test(k)) hits.push(path?path+'.'+k:k); walk(c,path?path+'.'+k:k); } })(x,''); console.log(JSON.stringify({file:p, suspicious_keys:hits}, null, 2)); }" \
+  .enigma/proof-quickstart/*.json
+```
+
+This scan is only a convenience. Human review still matters because a safe-looking key can hold unsafe content.
+
+## 7. SDK examples
+
+Use the SDK when your app wants to create proof artifacts in process and then decide separately where to write, review, or publish them. Builders and validators are local functions; they do not submit transactions or call providers.
+
+### Anchor batch
+
+```js
+import {
+  createProofNetworkAnchorBatch,
+  validateProofNetworkAnchorBatch,
+} from 'enigma-memory/proof-network';
+
+const anchorBatch = createProofNetworkAnchorBatch({
+  anchor_ref: 'anchor:quickstart:001',
+  roots: [
+    'sha256:1111111111111111111111111111111111111111111111111111111111111111',
+    'sha256:2222222222222222222222222222222222222222222222222222222222222222',
+  ],
+});
+
+const anchorCheck = validateProofNetworkAnchorBatch(anchorBatch);
+if (!anchorCheck.ok) throw new Error(anchorCheck.errors.join('; '));
+```
+
+### Capability grant and revocation
+
+```js
+import {
+  createCapabilityGrant,
+  validateCapabilityGrant,
+  createCapabilityRevocation,
+  validateCapabilityRevocation,
+} from 'enigma-memory/proof-network';
+
+const grant = createCapabilityGrant({
+  grant_ref: 'grant:quickstart:001',
+  issuer_ref: 'issuer:quickstart-controller',
+  subject_ref: 'agent:demo-reviewer',
+  scope: 'proof.summary',
+  resource_roots: [
+    'sha256:1111111111111111111111111111111111111111111111111111111111111111',
+  ],
+  expires_at: '2026-12-31T00:00:00.000Z',
+});
+
+const grantCheck = validateCapabilityGrant(grant);
+if (!grantCheck.ok) throw new Error(grantCheck.errors.join('; '));
+
+const revocation = createCapabilityRevocation({
+  grant_hash: grant.capability_grant_hash,
+  reason_ref: 'reason:scope-ended',
+  revocation_ref: 'revocation:quickstart:001',
+});
+
+const revocationCheck = validateCapabilityRevocation(revocation);
+if (!revocationCheck.ok) throw new Error(revocationCheck.errors.join('; '));
+```
+
+### Benchmark attestation
+
+```js
+import {
+  createBenchmarkAttestation,
+  validateBenchmarkAttestation,
+} from 'enigma-memory/proof-network';
+
+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.13',
+  sample_count: 12,
+  run_count: 1,
+});
+
+const attestationCheck = validateBenchmarkAttestation(attestation);
+if (!attestationCheck.ok) throw new Error(attestationCheck.errors.join('; '));
+```
+
+### Proof packet
+
+```js
+import {
+  createProofNetworkPacket,
+  validateProofNetworkPacket,
+} from 'enigma-memory/proof-network';
+
+const packet = createProofNetworkPacket({
+  packet_ref: 'packet:quickstart:001',
+  artifacts: [anchorBatch, grant, revocation, attestation],
+});
+
+const packetCheck = validateProofNetworkPacket(packet);
+if (!packetCheck.ok) throw new Error(packetCheck.errors.join('; '));
+```
+
+Share the packet only after reviewing every nested artifact with the same public-safety checklist.
+
+## 8. What to say about the artifact
+
+Safe wording:
+
+> This proof artifact locally verifies as an Enigma Proof Network artifact. It contains hashes, roots, refs, counts, and boundary booleans only. It is suitable for review or optional operator-controlled anchoring without exposing raw memory.
+
+Do not say the artifact proves any of the following without separate reviewed evidence:
+
+- a Solana transaction was submitted;
+- raw memory was deleted from every provider or downstream system;
+- a model forgot data;
+- hosted customer operation exists;
+- legal/compliance status, audit certification, comparative benchmark leadership, financial return, or production deployment.