enigma-memory 0.1.16 → 0.1.18

package/packages/proof-network/src/index.js

@@ -5,12 +5,16 @@ export const PROOF_NETWORK_CAPABILITY_GRANT_SCHEMA = 'enigma.proof_network.capab
 export const PROOF_NETWORK_CAPABILITY_REVOCATION_SCHEMA = 'enigma.proof_network.capability_revocation.v1';
 export const PROOF_NETWORK_BENCHMARK_ATTESTATION_SCHEMA = 'enigma.proof_network.benchmark_attestation.v1';
 export const PROOF_NETWORK_PACKET_SCHEMA = 'enigma.proof_network.packet.v1';
+export const PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA = 'enigma.proof_network.registry_entry.v1';
+export const PROOF_NETWORK_REGISTRY_BATCH_SCHEMA = 'enigma.proof_network.registry_batch.v1';
 
 export const ANCHOR_BATCH_SCHEMA = PROOF_NETWORK_ANCHOR_BATCH_SCHEMA;
 export const CAPABILITY_GRANT_SCHEMA = PROOF_NETWORK_CAPABILITY_GRANT_SCHEMA;
 export const CAPABILITY_REVOCATION_SCHEMA = PROOF_NETWORK_CAPABILITY_REVOCATION_SCHEMA;
 export const BENCHMARK_ATTESTATION_SCHEMA = PROOF_NETWORK_BENCHMARK_ATTESTATION_SCHEMA;
 export const PACKET_SCHEMA = PROOF_NETWORK_PACKET_SCHEMA;
+export const REGISTRY_ENTRY_SCHEMA = PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA;
+export const REGISTRY_BATCH_SCHEMA = PROOF_NETWORK_REGISTRY_BATCH_SCHEMA;
 
 export const PROOF_NETWORK_SCHEMAS = Object.freeze({
   anchor_batch: PROOF_NETWORK_ANCHOR_BATCH_SCHEMA,
@@ -18,6 +22,8 @@ export const PROOF_NETWORK_SCHEMAS = Object.freeze({
   capability_revocation: PROOF_NETWORK_CAPABILITY_REVOCATION_SCHEMA,
   benchmark_attestation: PROOF_NETWORK_BENCHMARK_ATTESTATION_SCHEMA,
   packet: PROOF_NETWORK_PACKET_SCHEMA,
+  registry_entry: PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA,
+  registry_batch: PROOF_NETWORK_REGISTRY_BATCH_SCHEMA,
 });
 
 const SHA256_PREFIX = 'sha256:';
@@ -36,6 +42,14 @@ const SAFE_FIELD_NAMES = new Set(Object.keys(SAFE_BOOLEAN_BOUNDARIES));
 const FORBIDDEN_KEY_RE = /(?:^|_)(?:raw|plaintext|plain_text|prompt|prompts|message|messages|text|content|document|documents|transcript|transcripts|completion|completions|embedding|embeddings|acl|acl_body|access_control_list|provider_response|provider_responses|response_body|credential|credentials|api_key|secret|password|private_key|seed|seed_phrase|mnemonic|tenant_name|customer_name|organization_name|org_name)(?:$|_)/iu;
 const SECRET_VALUE_RE = /(?:Bearer\s+[A-Za-z0-9._~+/=-]{12,}|Basic\s+[A-Za-z0-9+/=-]{12,}|-----BEGIN [A-Z ]*PRIVATE KEY-----|https?:\/\/[^\s/@]+:[^\s/@]+@|sk-[A-Za-z0-9_-]{16,}|AKIA[0-9A-Z]{16}|(?:seed phrase|mnemonic phrase|raw memory|private prompt|full transcript|provider response|embedding vector))/iu;
 const SUPPORTED_ARTIFACT_SCHEMAS = new Set(Object.values(PROOF_NETWORK_SCHEMAS));
+const REGISTRY_ENTRY_TYPES = Object.freeze(new Set([
+  'anchor_batch',
+  'benchmark_attestation',
+  'connector_conformance',
+  'health_report',
+  'operator_receipt',
+  'settlement_job',
+]));
 
 function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -296,6 +310,10 @@ function artifactHash(artifact, index) {
       return requiredString(artifact.benchmark_attestation_hash, `artifacts[${index}].benchmark_attestation_hash`);
     case PROOF_NETWORK_PACKET_SCHEMA:
       return requiredString(artifact.proof_network_packet_hash, `artifacts[${index}].proof_network_packet_hash`);
+    case PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA:
+      return requiredString(artifact.registry_entry_hash, `artifacts[${index}].registry_entry_hash`);
+    case PROOF_NETWORK_REGISTRY_BATCH_SCHEMA:
+      return requiredString(artifact.registry_batch_hash, `artifacts[${index}].registry_batch_hash`);
     default:
       throw new TypeError(`artifacts[${index}] has unsupported schema`);
   }
@@ -313,6 +331,10 @@ function validateSupportedArtifact(artifact) {
       return validateBenchmarkAttestation(artifact);
     case PROOF_NETWORK_PACKET_SCHEMA:
       return validateProofNetworkPacket(artifact);
+    case PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA:
+      return validateRegistryEntry(artifact);
+    case PROOF_NETWORK_REGISTRY_BATCH_SCHEMA:
+      return validateRegistryBatch(artifact);
     default:
       return Object.freeze({ ok: false, valid: false, errors: Object.freeze(['unsupported artifact schema']) });
   }
@@ -568,3 +590,120 @@ export function validateProofNetworkPacket(packet) {
     validateIdentity(packet, errors, 'proof_network_packet_id', 'proof_network_packet_hash', 'pnp');
   });
 }
+
+function registryEntryType(value, field = 'entry_type') {
+  const type = optionalString(value, undefined, field);
+  if (type === undefined || !REGISTRY_ENTRY_TYPES.has(type)) {
+    throw new TypeError(`${field} must be one of ${[...REGISTRY_ENTRY_TYPES].join(', ')}`);
+  }
+  return type;
+}
+
+export function createRegistryEntry(input = {}) {
+  requiredObject(input, 'input');
+  assertNoPrivateProofPayload(input, 'input');
+  const entryType = registryEntryType(input.entry_type ?? input.entryType ?? input.type, 'entry_type');
+  const artifactHash = digestRef(input.artifact_hash ?? input.artifactHash ?? input.digest_ref ?? input.digestRef, 'artifact_hash');
+  const artifactSchemaRef = publicRef(input.artifact_schema_ref ?? input.artifactSchemaRef ?? input.schema_ref ?? input.schemaRef, 'artifact_schema_ref');
+  const digestRefs = digestArray(input.digest_refs ?? input.digestRefs ?? input.digest_roots ?? input.digestRoots ?? input.roots ?? artifactHash, 'digest_refs', { min: 1, max: 64 });
+  const signerRefs = publicRefArray(input.signer_refs ?? input.signerRefs ?? input.signer_ref ?? input.signerRef, 'signer_refs', { min: 0, max: 64 });
+  const entryRef = optionalPublicRef(input.entry_ref ?? input.entryRef, refFromDigest('registry-entry', artifactHash), 'entry_ref');
+  const body = {
+    schema: PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA,
+    registered_at: isoTimestamp(input.registered_at ?? input.registeredAt ?? input.created_at ?? input.createdAt ?? input.generated_at ?? input.generatedAt, 'registered_at'),
+    entry_type: entryType,
+    entry_ref: entryRef,
+    registry_ref: optionalPublicRef(input.registry_ref ?? input.registryRef ?? input.marketplace_ref ?? input.marketplaceRef, 'registry:memory-drive-marketplace', 'registry_ref'),
+    artifact_schema_ref: artifactSchemaRef,
+    artifact_hash: artifactHash,
+    digest_root: sha256Json(digestRefs),
+    digest_refs: digestRefs,
+    signer_refs: signerRefs,
+    entry_count: nonNegativeInteger(input.entry_count ?? input.entryCount ?? input.count, 'entry_count', 1),
+    ...((input.signature_ref ?? input.signatureRef) ? { signature_ref: signatureRef(input.signature_ref ?? input.signatureRef, 'signature_ref') } : {}),
+    ...SAFE_BOOLEAN_BOUNDARIES,
+  };
+  return freezeArtifact(body, 'registry_entry_id', 'registry_entry_hash', 'pnrg');
+}
+
+export function validateRegistryEntry(entry) {
+  return collectValidation((errors) => {
+    requiredObject(entry, 'entry');
+    assertNoPrivateProofPayload(entry, 'entry');
+    if (entry.schema !== PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA) errors.push(`schema must be ${PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA}`);
+    requireSafeBoundaries(entry, errors, 'entry');
+    isoTimestamp(entry.registered_at, 'registered_at');
+    if (!REGISTRY_ENTRY_TYPES.has(entry.entry_type)) errors.push(`entry_type must be one of ${[...REGISTRY_ENTRY_TYPES].join(', ')}`);
+    publicRef(entry.entry_ref, 'entry_ref');
+    publicRef(entry.registry_ref, 'registry_ref');
+    publicRef(entry.artifact_schema_ref, 'artifact_schema_ref');
+    digestRef(entry.artifact_hash, 'artifact_hash');
+    const digestRefs = digestArray(entry.digest_refs, 'digest_refs', { min: 1, max: 64 });
+    if (entry.digest_root !== sha256Json(digestRefs)) errors.push('digest_root mismatch');
+    publicRefArray(entry.signer_refs, 'signer_refs', { min: 0, max: 64 });
+    nonNegativeInteger(entry.entry_count, 'entry_count');
+    if (entry.signature_ref !== undefined) signatureRef(entry.signature_ref, 'signature_ref');
+    validateIdentity(entry, errors, 'registry_entry_id', 'registry_entry_hash', 'pnrg');
+  });
+}
+
+export function createRegistryBatch(input = {}) {
+  requiredObject(input, 'input');
+  assertNoPrivateProofPayload(input, 'input');
+  const entries = Object.freeze(arrayInput(input.entries ?? input.registry_entries ?? input.registryEntries).map((entry, index) => {
+    requiredObject(entry, `entries[${index}]`);
+    if (entry.schema !== PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA) throw new TypeError(`entries[${index}] must be a ${PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA}`);
+    const validation = validateRegistryEntry(entry);
+    if (!validation.ok) throw new TypeError(`entries[${index}] is invalid: ${validation.errors.join('; ')}`);
+    return Object.freeze(entry);
+  }));
+  if (entries.length === 0) throw new TypeError('entries must be non-empty');
+  if (entries.length > 128) throw new TypeError('entries must contain at most 128 entries');
+  const entryHashes = Object.freeze(entries.map((entry) => requiredString(entry.registry_entry_hash, 'entries.registry_entry_hash')).sort());
+  const registryRoot = sha256Json(entryHashes);
+  const body = {
+    schema: PROOF_NETWORK_REGISTRY_BATCH_SCHEMA,
+    created_at: isoTimestamp(input.created_at ?? input.createdAt ?? input.generated_at ?? input.generatedAt, 'created_at'),
+    registry_ref: optionalPublicRef(input.registry_ref ?? input.registryRef ?? input.marketplace_ref ?? input.marketplaceRef, refFromDigest('registry-batch', registryRoot), 'registry_ref'),
+    entry_count: entries.length,
+    registry_root: registryRoot,
+    entry_hashes: entryHashes,
+    entries,
+    ...SAFE_BOOLEAN_BOUNDARIES,
+  };
+  return freezeArtifact(body, 'registry_batch_id', 'registry_batch_hash', 'pnrb');
+}
+
+export function validateRegistryBatch(batch) {
+  return collectValidation((errors) => {
+    requiredObject(batch, 'batch');
+    assertNoPrivateProofPayload(batch, 'batch');
+    if (batch.schema !== PROOF_NETWORK_REGISTRY_BATCH_SCHEMA) errors.push(`schema must be ${PROOF_NETWORK_REGISTRY_BATCH_SCHEMA}`);
+    requireSafeBoundaries(batch, errors, 'batch');
+    isoTimestamp(batch.created_at, 'created_at');
+    publicRef(batch.registry_ref, 'registry_ref');
+    const entries = Array.isArray(batch.entries) ? batch.entries : [];
+    if (entries.length === 0 || entries.length > 128) errors.push('entries must contain 1-128 entries');
+    const entryHashes = [];
+    for (const [index, entry] of entries.entries()) {
+      requiredObject(entry, `entries[${index}]`);
+      if (entry.schema !== PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA) {
+        errors.push(`entries[${index}] must be a ${PROOF_NETWORK_REGISTRY_ENTRY_SCHEMA}`);
+        continue;
+      }
+      const validation = validateRegistryEntry(entry);
+      if (!validation.ok) errors.push(`entries[${index}] is invalid: ${validation.errors.join('; ')}`);
+      entryHashes.push(requiredString(entry.registry_entry_hash, `entries[${index}].registry_entry_hash`));
+    }
+    entryHashes.sort();
+    if (batch.entry_count !== entries.length) errors.push('entry_count mismatch');
+    if (batch.registry_root !== sha256Json(entryHashes)) errors.push('registry_root mismatch');
+    if (JSON.stringify(batch.entry_hashes) !== JSON.stringify(entryHashes)) errors.push('entry_hashes mismatch');
+    validateIdentity(batch, errors, 'registry_batch_id', 'registry_batch_hash', 'pnrb');
+  });
+}
+
+export const createProofRegistryEntry = createRegistryEntry;
+export const validateProofRegistryEntry = validateRegistryEntry;
+export const createProofRegistryBatch = createRegistryBatch;
+export const validateProofRegistryBatch = validateRegistryBatch;

package/packages/vault/src/index.js

@@ -3,9 +3,13 @@ import {
   createDecipheriv,
   createHash,
   createHmac,
+  createPrivateKey,
+  createPublicKey,
   generateKeyPairSync,
+  pbkdf2Sync,
   randomBytes,
   randomUUID,
+  scryptSync,
 } from 'node:crypto';
 import {
   canonicalize,
@@ -46,6 +50,14 @@ const PUBLIC_PLAINTEXT_KEYS = new Set([
 const SAFE_METADATA_DIGEST_RE = /^(?:sha256:)?[a-f0-9]{64}$|^hmac-sha256:[a-f0-9]{64}$/;
 const SOURCE_REF_ROOT_RE = /^sha256:[a-f0-9]{64}$/;
 
+export const KEYRING_ENCRYPTED_TYPE = 'local_secret_encrypted';
+export const KEYRING_PLAINTEXT_TYPE = 'local_secret';
+const DERIVED_KEY_LENGTH = 128; // 32 bytes each: KEK, vaultKey, addressKey, signingSeed
+const SALT_LENGTH = 16;
+const IV_LENGTH = 12;
+const PLAINTEXT_KEYRING_WARNING = 'WARNING: This bundle stores vault keys in plaintext. Anyone with file access can decrypt memory contents. Use --passphrase to encrypt the keyring.';
+const ENCRYPTED_KEYRING_WARNING = 'Keyring is encrypted with AES-256-GCM; passphrase required on import.';
+const DEPRECATION_PLAINTEXT_KEYRING = 'Plaintext keyrings are deprecated; use --passphrase to encrypt new bundles.';
 function normalizedPublicKey(key) {
   return String(key).toLowerCase().replace(/[^a-z0-9]/g, '');
 }
@@ -313,7 +325,84 @@ function keyBytes(key, label) {
   throw new Error(`${label} must be a Buffer or base64 string`);
 }
 
-function signingPair() {
+function buildEd25519Pkcs8(seed) {
+  if (!Buffer.isBuffer(seed) || seed.length !== 32) throw new Error('Ed25519 seed must be 32 bytes');
+  // PKCS#8 PrivateKeyInfo for Ed25519 (OID 1.3.101.112): SEQUENCE { INTEGER 0, AlgorithmIdentifier, OCTET STRING { OCTET STRING seed } }
+  return Buffer.from([
+    0x30, 0x2e,
+      0x02, 0x01, 0x00,
+      0x30, 0x05,
+        0x06, 0x03, 0x2b, 0x65, 0x70,
+      0x04, 0x22,
+        0x04, 0x20,
+          ...seed,
+  ]);
+}
+
+function deriveMasterKeyFromPassphrase(passphrase, salt) {
+  const normalized = Buffer.from(String(passphrase), 'utf8');
+  const saltBuf = typeof salt === 'string' ? Buffer.from(salt, 'base64') : Buffer.from(salt);
+  if (saltBuf.length < 8) throw new Error('Salt must be at least 8 bytes');
+  try {
+    return scryptSync(normalized, saltBuf, DERIVED_KEY_LENGTH);
+  } catch {
+    return pbkdf2Sync(normalized, saltBuf, 600000, DERIVED_KEY_LENGTH, 'sha256');
+  }
+}
+
+function deriveKeysFromPassphrase(passphrase, salt) {
+  const master = deriveMasterKeyFromPassphrase(passphrase, salt);
+  return {
+    kek: master.subarray(0, 32),
+    vaultKey: master.subarray(32, 64),
+    addressKey: master.subarray(64, 96),
+    signingSeed: master.subarray(96, 128),
+  };
+}
+
+function encryptKeyring(plaintextKeyring, kek) {
+  const iv = randomBytes(IV_LENGTH);
+  const cipher = createCipheriv('aes-256-gcm', kek, iv);
+  const plaintext = Buffer.from(JSON.stringify(plaintextKeyring), 'utf8');
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    iv: iv.toString('base64'),
+    tag: tag.toString('base64'),
+    ciphertext: ciphertext.toString('base64'),
+  };
+}
+
+export function decryptKeyring(keyring, passphrase) {
+  if (keyring?.type !== KEYRING_ENCRYPTED_TYPE) throw new Error('Keyring is not encrypted');
+  if (passphrase === undefined || passphrase === null || String(passphrase).length === 0) {
+    throw new Error('Encrypted keyring requires passphrase');
+  }
+  const { kek } = deriveKeysFromPassphrase(passphrase, keyring.salt);
+  const decipher = createDecipheriv('aes-256-gcm', kek, Buffer.from(keyring.iv, 'base64'));
+  decipher.setAuthTag(Buffer.from(keyring.tag, 'base64'));
+  const plaintext = Buffer.concat([
+    decipher.update(Buffer.from(keyring.ciphertext, 'base64')),
+    decipher.final(),
+  ]).toString('utf8');
+  return JSON.parse(plaintext);
+}
+
+function signingPair(seed) {
+  if (seed !== undefined && seed !== null) {
+    try {
+      const privateKey = createPrivateKey({ key: buildEd25519Pkcs8(seed), format: 'der', type: 'pkcs8' });
+      const publicKey = createPublicKey(privateKey);
+      const publicKeyPem = publicKey.export({ type: 'spki', format: 'pem' });
+      return {
+        key_id: `ed25519:${sha256Hex(publicKeyPem).slice(0, 32)}`,
+        publicKey,
+        privateKey,
+      };
+    } catch {
+      // Fall through to random signing pair if deterministic construction is unsupported.
+    }
+  }
   try {
     const pair = generateSigningKeyPair();
     if (pair && typeof pair.then !== 'function') return pair;
@@ -389,7 +478,7 @@ function metadata(input) {
 
 function pruneUndefined(value) {
   if (Array.isArray(value)) return value.map((item) => pruneUndefined(item));
-  if (value && typeof value === 'object') {
+  if (value && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
     const out = {};
     for (const [key, item] of Object.entries(value)) {
       if (item !== undefined) out[key] = pruneUndefined(item);
@@ -581,7 +670,23 @@ function attachInternals(vault) {
 
 export function createVault(args = {}) {
   const createdAt = nowIso(args.now);
-  const signingKeyPair = args.signingKeyPair ?? signingPair();
+  const passphrase = args.passphrase;
+  const salt = args.salt ?? randomBytes(SALT_LENGTH).toString('base64');
+  let vaultKey;
+  let addressKey;
+  let signingSeed;
+  let keyringType = KEYRING_PLAINTEXT_TYPE;
+  if (passphrase !== undefined && passphrase !== null && String(passphrase).length > 0) {
+    const derived = deriveKeysFromPassphrase(passphrase, salt);
+    vaultKey = derived.vaultKey;
+    addressKey = derived.addressKey;
+    signingSeed = derived.signingSeed;
+    keyringType = KEYRING_ENCRYPTED_TYPE;
+  } else {
+    vaultKey = keyBytes(args.vault_key ?? args.vaultKey, 'vault key');
+    addressKey = keyBytes(args.address_key ?? args.addressKey, 'address key');
+  }
+  const signingKeyPair = args.signingKeyPair ?? signingPair(signingSeed);
   const vault = {
     schema: VAULT_SCHEMA,
     vault_id: args.vault_id ?? args.vaultId ?? `vault_${randomUUID()}`,
@@ -593,8 +698,8 @@ export function createVault(args = {}) {
     updated_at: createdAt,
     encryption: 'local_aead',
     key_id: args.key_id ?? args.keyId ?? `vault-key-${randomUUID()}`,
-    vaultKey: keyBytes(args.vault_key ?? args.vaultKey, 'vault key'),
-    addressKey: keyBytes(args.address_key ?? args.addressKey, 'address key'),
+    vaultKey,
+    addressKey,
     signingKeyPair,
     signer: args.signer ?? signerFor(signingKeyPair),
     memories: new Map(),
@@ -605,10 +710,18 @@ export function createVault(args = {}) {
     sequence: 0,
     active_set_root: ZERO_ROOT,
     receipt_log_root: ZERO_ROOT,
+    keyringType,
   };
   return attachInternals(vault);
 }
 
+function normalizeImportance(value) {
+  if (value === undefined || value === null) return undefined;
+  const num = Number(value);
+  if (!Number.isFinite(num)) return undefined;
+  return Math.max(0, Math.min(1, num));
+}
+
 export function remember(args = {}) {
   const vault = args.vault;
   if (!vault) throw new Error('remember requires a vault');
@@ -636,6 +749,7 @@ export function remember(args = {}) {
     sensitivity: args.sensitivity ?? 'normal',
     purpose_tags: Array.isArray(args.purpose_tags ?? args.purposeTags) ? (args.purpose_tags ?? args.purposeTags) : [],
     retention: args.retention ?? 'durable',
+    importance: normalizeImportance(args.importance),
     state: 'active',
     metadata: metadata(args.metadata),
     created_at: createdAt,
@@ -651,12 +765,13 @@ export function remember(args = {}) {
     actor_id: args.actor_id ?? args.actorId,
     policy_id: args.policy_id ?? args.policyId,
     now: args.now,
-    metadata: {
+    metadata: pruneUndefined({
       memory_id: memoryId,
       kind: record.kind,
       sensitivity: record.sensitivity,
+      importance: record.importance,
       content_commitment: record.content_commitment,
-    },
+    }),
   });
 
   return { memory: publicRecord(record), memory_addr: memoryAddr, event, receipt };
@@ -788,6 +903,39 @@ export function deleteMemory(args = {}) {
   return { memory_addr: memoryAddr, tombstone, event, receipt };
 }
 
+function buildKeyring(vault, passphrase) {
+  if (passphrase !== undefined && passphrase !== null && String(passphrase).length > 0) {
+    const salt = randomBytes(SALT_LENGTH).toString('base64');
+    const { kek } = deriveKeysFromPassphrase(passphrase, salt);
+    const plaintextKeyring = {
+      vault_key_b64: vault.vaultKey.toString('base64'),
+      address_key_b64: vault.addressKey.toString('base64'),
+      privateKey: exportPrivateKey(vault.signingKeyPair),
+    };
+    const encrypted = encryptKeyring(plaintextKeyring, kek);
+    return {
+      type: KEYRING_ENCRYPTED_TYPE,
+      warning: ENCRYPTED_KEYRING_WARNING,
+      salt,
+      iv: encrypted.iv,
+      tag: encrypted.tag,
+      ciphertext: encrypted.ciphertext,
+      signer: vault.signer,
+      publicKey: exportPublicKey(vault.signingKeyPair),
+    };
+  }
+  return {
+    type: KEYRING_PLAINTEXT_TYPE,
+    unencrypted: true,
+    warning: PLAINTEXT_KEYRING_WARNING,
+    vault_key_b64: vault.vaultKey.toString('base64'),
+    address_key_b64: vault.addressKey.toString('base64'),
+    signer: vault.signer,
+    publicKey: exportPublicKey(vault.signingKeyPair),
+    privateKey: exportPrivateKey(vault.signingKeyPair),
+  };
+}
+
 export function exportBundle(args = {}) {
   const vault = args.vault;
   if (!vault) throw new Error('exportBundle requires a vault');
@@ -822,15 +970,7 @@ export function exportBundle(args = {}) {
       receipt_log_root: roots.receipt_log_root,
       sequence: vault.sequence,
     },
-    keyring: {
-      type: 'local_secret',
-      warning: 'Contains local vault keys for offline import; memory payloads remain AES-256-GCM encrypted.',
-      vault_key_b64: vault.vaultKey.toString('base64'),
-      address_key_b64: vault.addressKey.toString('base64'),
-      signer: vault.signer,
-      publicKey: exportPublicKey(vault.signingKeyPair),
-      privateKey: exportPrivateKey(vault.signingKeyPair),
-    },
+    keyring: buildKeyring(vault, args.passphrase),
     memory_objects: [...vault.memories.values()].map(publicRecord),
     active_memory_addresses: [...vault.activeAddresses].sort(),
     tombstones: [...vault.tombstones.values()].sort((a, b) => a.memory_addr.localeCompare(b.memory_addr)),
@@ -850,12 +990,33 @@ export function importBundle(args = {}) {
   const source = args.schema === 'enigma.vault_bundle.v1' ? args : (args.bundle?.bundle ?? args.bundle ?? args);
   const bundle = typeof source === 'string' ? JSON.parse(source) : source;
   if (!bundle || bundle.schema !== 'enigma.vault_bundle.v1') throw new Error('importBundle requires an enigma.vault_bundle.v1 bundle');
-  const restoredSigningKeyPair = bundle.keyring?.privateKey
+  const warnings = [];
+  let vaultKey;
+  let addressKey;
+  let privateKey;
+  const keyring = bundle.keyring;
+  if (keyring?.type === KEYRING_ENCRYPTED_TYPE) {
+    if (args.passphrase === undefined || args.passphrase === null || String(args.passphrase).length === 0) {
+      throw new Error('Encrypted keyring requires passphrase');
+    }
+    const decrypted = decryptKeyring(keyring, args.passphrase);
+    vaultKey = decrypted.vault_key_b64;
+    addressKey = decrypted.address_key_b64;
+    privateKey = decrypted.privateKey;
+  } else {
+    if (keyring?.type === KEYRING_PLAINTEXT_TYPE) {
+      warnings.push(DEPRECATION_PLAINTEXT_KEYRING);
+    }
+    vaultKey = keyring?.vault_key_b64;
+    addressKey = keyring?.address_key_b64;
+    privateKey = keyring?.privateKey;
+  }
+  const restoredSigningKeyPair = privateKey
     ? {
-        key_id: bundle.keyring?.signer?.key_id,
-        signer: bundle.keyring?.signer,
-        publicKey: bundle.keyring?.publicKey,
-        privateKey: bundle.keyring?.privateKey,
+        key_id: keyring?.signer?.key_id,
+        signer: keyring?.signer,
+        publicKey: keyring?.publicKey,
+        privateKey,
       }
     : undefined;
   const vault = createVault({
@@ -864,10 +1025,10 @@ export function importBundle(args = {}) {
     subject_id: bundle.vault?.subject_id,
     actor_id: args.actor_id ?? args.actorId ?? bundle.vault?.actor_id,
     policy_id: bundle.vault?.policy_id,
-    vault_key: bundle.keyring?.vault_key_b64,
-    address_key: bundle.keyring?.address_key_b64,
+    vault_key: vaultKey,
+    address_key: addressKey,
     signingKeyPair: restoredSigningKeyPair,
-    signer: bundle.keyring?.signer,
+    signer: keyring?.signer,
     now: bundle.vault?.created_at,
   });
   vault.created_at = bundle.vault?.created_at ?? vault.created_at;
@@ -900,5 +1061,6 @@ export function importBundle(args = {}) {
       imported_tombstone_count: vault.tombstones.size,
     },
   });
-  return { vault, active_memory_addresses: [...vault.activeAddresses].sort(), tombstones: [...vault.tombstones.values()] };
+  return { vault, active_memory_addresses: [...vault.activeAddresses].sort(), tombstones: [...vault.tombstones.values()], warnings };
+
 }

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

@@ -23,6 +23,7 @@ const SHA256_PREFIX = 'sha256:';
 const PUBLIC_REF_RE = /^[a-z0-9][a-z0-9._:/@+-]{2,191}$/u;
 const SCORE_KEY_RE = /^[a-z][a-z0-9_.:-]{1,63}$/u;
 const PRIVATE_REPORT_KEY_RE = /(?:^|_)(?:raw_memory|memory_plaintext|plaintext|plain_text|prompt|prompts|conversation|conversations|message|messages|content|body|payload|payloads|document|documents|transcript|transcripts|completion|completions|embedding|embeddings|provider_response|provider_responses|response_body|credential|credentials|api_key|secret|password|private_key|seed|seed_phrase|mnemonic|tenant_name|customer_name|organization_name|org_name|account_id)(?:$|_)/iu;
+const RAW_ANSWER_REPORT_KEY_RE = /(?:^|_)(?:raw_answer|raw_answers|answer_text|answer_texts|answer_body|answer_content|generated_answer|generated_answers|final_answer|final_answers|model_answer|model_answers|llm_answer|llm_answers|provider_answer|provider_answers)(?:$|_)/iu;
 const ALLOWED_FALSE_REPORT_KEYS = new Set([
   'raw_private_memory_plaintext_included',
   'raw_question_text_included',
@@ -55,6 +56,9 @@ const ALLOWED_PUBLIC_REPORT_KEYS = new Set([
   'estimated_prompt_tokens',
   'baseline_prompt_tokens',
   'optimized_prompt_tokens',
+  'prompt_refs',
+  'same_prompts_for_all_rows',
+  'prompts_fixed',
 ]);
 const SECRET_VALUE_RE = /(?:Bearer\s+[A-Za-z0-9._~+/=-]{12,}|Basic\s+[A-Za-z0-9+/=-]{12,}|-----BEGIN [A-Z ]*PRIVATE KEY-----|https?:\/\/[^\s/@]+:[^\s/@]+@|sk-[A-Za-z0-9_-]{16,}|AKIA[0-9A-Z]{16}|(?:seed phrase|mnemonic phrase|raw memory|private prompt|full transcript|provider response|embedding vector))/iu;
 const ABSOLUTE_LOCAL_PATH_RE = /^(?:[A-Za-z]:[\\/]|\\\\|\/(?:Users|home|tmp|var|etc|mnt|Volumes)\b)/u;
@@ -62,6 +66,7 @@ const CLAIM_SCORE_KEY_RE = /(?:provider|competitor|roi|profit|savings|solana|tra
 const PROOF_COMPATIBLE_REPORT_SCHEMAS = new Set([
   'enigma.memory_benchmark_suite.v1',
   'enigma.standard_memory_benchmark_suite.v1',
+  'enigma.standard_memory_benchmark_protocol_plan.v1',
 ]);
 const REQUIRED_FALSE_BOUNDARY_KEYS = Object.freeze([
   'external_provider_calls',
@@ -172,7 +177,7 @@ export function parseArgs(argv = process.argv.slice(2)) {
 export function usage() {
   return `Usage: node scripts/build-benchmark-proof-release.mjs --report <path> --dataset-ref <ref> --runner-ref <ref> --package-ref <ref> [--score key=value ...] [--out-dir <dir>]
 
-Builds a dependency-free, local benchmark proof release from an existing public-safe benchmark report. The report must use a compatible benchmark schema and explicit offline benchmark boundaries. The report file is parsed for public-safety checks and hashed, but its body and local path are never copied into the attestation or proof packet. The generated artifacts are local benchmark attestation/proof only: no API calls, provider answer-accuracy claims, Mem0 or competitor performance claims, Solana submissions, hosted SaaS claims, ROI/profit/savings claims, raw memory, prompts, transcripts, embeddings, credentials, account ids, private keys, or provider responses are written.
+Builds a dependency-free, local benchmark proof release from an existing public-safe benchmark report. The report must use a compatible benchmark schema (a scored retrieval proxy report such as enigma.standard_memory_benchmark_suite.v1, or a full-answer protocol plan such as enigma.standard_memory_benchmark_protocol_plan.v1) and explicit offline benchmark boundaries. The report file is parsed for public-safety checks and hashed, but its body and local path are never copied into the attestation or proof packet. The generated artifacts are local benchmark attestation/proof only: no API calls, provider answer-accuracy claims, Mem0 or competitor performance claims, Solana submissions, hosted SaaS claims, ROI/profit/savings claims, raw memory, prompts, transcripts, embeddings, credentials, account ids, private keys, or provider responses are written. A protocol-plan report is accepted as protocol-readiness evidence only and is rejected if it contains raw answers, prompts, provider responses, or competitor scores.
 `;
 }
 
@@ -205,7 +210,7 @@ function assertPublicReportPayload(value, path = 'report') {
   }
   if (!isPlainObject(value)) return;
   for (const [key, child] of Object.entries(value)) {
-    if (PRIVATE_REPORT_KEY_RE.test(key) && !ALLOWED_PUBLIC_REPORT_KEYS.has(key)) {
+    if ((PRIVATE_REPORT_KEY_RE.test(key) || RAW_ANSWER_REPORT_KEY_RE.test(key)) && !ALLOWED_PUBLIC_REPORT_KEYS.has(key)) {
       if (!ALLOWED_FALSE_REPORT_KEYS.has(key) || child !== false) throw new UsageError(`${path}.${key} is not allowed in public benchmark proof artifacts`);
     }
     assertPublicReportPayload(child, `${path}.${key}`);
@@ -275,6 +280,13 @@ function assertProofCompatibleBenchmarkBoundaries(report) {
   if (report.schema === 'enigma.memory_benchmark_suite.v1') {
     if (boundaries.local_only !== true) throw new UsageError('local memory benchmark report must set benchmark_boundaries.local_only true');
   }
+  if (report.schema === 'enigma.standard_memory_benchmark_protocol_plan.v1') {
+    const protocolBoundaries = report.protocol_boundaries;
+    if (!isPlainObject(protocolBoundaries)) throw new UsageError('protocol plan report must include protocol_boundaries');
+    for (const key of ['network_required', 'provider_calls_made', 'answers_generated', 'judged']) {
+      requireFalseField(protocolBoundaries, key, 'report.protocol_boundaries');
+    }
+  }
   assertCommandBoundaries(report);
   assertExternalAdaptersUnscored(report);
 }
@@ -404,7 +416,7 @@ export async function buildBenchmarkProofRelease(args, options = {}) {
   const schema = reportSchema(report);
   const sampleCount = sampleCountFromReport(report);
   const datasetCount = Array.isArray(report.datasets) ? report.datasets.length : 0;
-  const commitments = scoreCommitments(args.scores, reportHash);
+  const commitments = scoreCommitments(Array.isArray(args.scores) ? args.scores : [], reportHash);
   const metricRoots = commitments.map((score) => score.score_hash);
 
   const attestation = createBenchmarkAttestation({