enigma-memory 0.1.18 → 0.1.22

package/scripts/run-backend-readiness-smoke.mjs

@@ -1,8 +1,17 @@
 #!/usr/bin/env node
 import { once } from 'node:events';
 import { pathToFileURL } from 'node:url';
-import { createRelayServer } from '../apps/relay/src/server.mjs';
-import { createGatewayServer } from '../apps/gateway/src/server.mjs';
+import {
+  FEDERATION_STORAGE_ADAPTER_SCHEMA,
+  RELAY_STATE_ADAPTER_SCHEMA,
+  createRelayServer,
+} from '../apps/relay/src/server.mjs';
+import {
+  GATEWAY_KMS_SIGNER_ADAPTER_SCHEMA,
+  GATEWAY_SIEM_SINK_ADAPTER_SCHEMA,
+  GATEWAY_STATE_ADAPTER_SCHEMA,
+  createGatewayServer,
+} from '../apps/gateway/src/server.mjs';
 
 export const BACKEND_READINESS_SMOKE_SCHEMA = 'enigma.backend_readiness_smoke.v1';
 
@@ -21,6 +30,76 @@ const SHARED_READINESS_REFS = Object.freeze({
   incident_drill_ref: 'incident-drill-smoke-ref',
   backup_restore_drill_ref: 'backup-restore-drill-smoke-ref',
 });
+function transactionalStateAdapter(schema, service, ready) {
+  let snapshot = null;
+  return {
+    schema,
+    ref: `fixture://${service}/durable-state`,
+    durable: true,
+    encryptedAtRest: true,
+    supportsMultiReplica: true,
+    async isReady() { return ready; },
+    async transaction(operation, options) {
+      const result = await operation(snapshot ?? options.initialSnapshot);
+      snapshot = structuredClone(result.snapshot);
+      return result.value;
+    },
+  };
+}
+
+function federationFixture(service, ready) {
+  const bridge = {
+    started: false,
+    async start() { this.started = true; },
+    async stop() { this.started = false; },
+  };
+  return {
+    storage: {
+      schema: FEDERATION_STORAGE_ADAPTER_SCHEMA,
+      ref: `fixture://${service}/opaque-federation-storage`,
+      durable: true,
+      async isReady() { return ready; },
+      async appendOpaqueFrame() {},
+    },
+    authenticator: {
+      ref: `fixture://${service}/federation-auth`,
+      async isReady() { return ready; },
+      async authenticate() { return { ok: false }; },
+    },
+    bridge,
+    kmsRef: `fixture://${service}/kms-custody`,
+  };
+}
+
+function relayRuntimeFixture(ready) {
+  return {
+    relayStateAdapter: transactionalStateAdapter(RELAY_STATE_ADAPTER_SCHEMA, 'relay', ready),
+    federation: federationFixture('relay', ready),
+  };
+}
+
+function gatewayRuntimeFixture(ready) {
+  return {
+    gatewayStateAdapter: transactionalStateAdapter(GATEWAY_STATE_ADAPTER_SCHEMA, 'gateway', ready),
+    kmsSignerAdapter: {
+      schema: GATEWAY_KMS_SIGNER_ADAPTER_SCHEMA,
+      ref: 'fixture://gateway/kms-signer',
+      publicKey: 'fixture-public-key-not-used-by-readiness-smoke',
+      async isReady() { return ready; },
+      async createDecision() { throw new Error('readiness smoke does not request a gateway decision'); },
+    },
+    siemSinkAdapter: {
+      schema: GATEWAY_SIEM_SINK_ADAPTER_SCHEMA,
+      ref: 'fixture://gateway/siem-sink',
+      durable: true,
+      idempotent: true,
+      async isReady() { return ready; },
+      async appendBatch() {},
+    },
+    federation: federationFixture('gateway', ready),
+  };
+}
+
 
 function parseArgs(argv = process.argv.slice(2)) {
   const flags = new Map();
@@ -38,7 +117,7 @@ function parseArgs(argv = process.argv.slice(2)) {
 }
 
 function usage() {
-  return `Usage: node scripts/run-backend-readiness-smoke.mjs [--host 127.0.0.1]\n\nStarts in-process relay/gateway HTTP servers on loopback ephemeral ports, probes /livez and /readyz,\nand verifies fail-closed production readiness plus a fully referenced production-ready local fixture.\nIt does not expose admin/data routes, provision cloud resources, or prove hosted live infrastructure.\n`;
+  return `Usage: node scripts/run-backend-readiness-smoke.mjs [--host 127.0.0.1]\n\nStarts in-process relay/gateway HTTP servers on loopback ephemeral ports, probes /livez and /readyz,\nand verifies fail-closed production readiness plus an explicit operational-runtime fixture with durable state, KMS signer, SIEM sink, federation storage/authentication, and all evidence refs.\nIt does not expose credentials, provision cloud resources, or prove hosted live infrastructure.\n`;
 }
 
 function listen(server, host) {
@@ -53,13 +132,19 @@ function listen(server, host) {
 }
 
 async function close(server) {
+  await server.federationRuntime?.stop();
   if (!server.listening) return;
   server.close();
+  server.closeAllConnections?.();
   await once(server, 'close');
 }
 
 async function getJson(baseUrl, path) {
-  const response = await fetch(`${baseUrl}${path}`, { method: 'GET', headers: { accept: 'application/json' } });
+  const response = await fetch(`${baseUrl}${path}`, {
+    method: 'GET',
+    headers: { accept: 'application/json' },
+    signal: AbortSignal.timeout(5_000),
+  });
   const text = await response.text();
   if (SECRET_OUTPUT_RE.test(text)) throw new Error(`${baseUrl}${path} emitted secret-looking output`);
   let body;
@@ -97,6 +182,7 @@ function relayReadyOptions() {
     monitoring_ref: 'relay-monitoring-smoke-ref',
     ...SHARED_READINESS_REFS,
     operator_acceptance: { decision: 'go', status: 'go', ref: 'relay-operator-acceptance-smoke-ref' },
+    ...relayRuntimeFixture(true),
   };
 }
 
@@ -115,6 +201,9 @@ function gatewayReadyOptions() {
     data_plane_auth_ref: 'gateway-data-plane-auth-smoke-ref',
     ...SHARED_READINESS_REFS,
     operator_acceptance: { decision: 'go', status: 'go', ref: 'gateway-operator-acceptance-smoke-ref' },
+    admin_auth_bearer_sha256: `sha256:${'a'.repeat(64)}`,
+    data_plane_auth_bearer_sha256: `sha256:${'b'.repeat(64)}`,
+    ...gatewayRuntimeFixture(true),
   };
 }
 
@@ -122,9 +211,18 @@ async function probeServer({ service, mode, serverFactory, host, expectedReadySt
   const server = serverFactory();
   try {
     const address = await listen(server, host);
+    await server.federationRuntime?.start();
     const baseUrl = `http://${address.address}:${address.port}`;
     const livez = await getJson(baseUrl, '/livez');
     const readyz = await getJson(baseUrl, '/readyz');
+    const failedChecks = Array.isArray(readyz.body?.checks)
+      ? readyz.body.checks
+        .filter((check) => check?.ok !== true && typeof (check?.check ?? check?.name) === 'string')
+        .map((check) => check.check ?? check.name)
+      : [];
+    const missingChecks = Array.isArray(readyz.body?.missing_checks) && readyz.body.missing_checks.length > 0
+      ? [...readyz.body.missing_checks]
+      : failedChecks;
     return {
       service,
       mode,
@@ -134,6 +232,10 @@ async function probeServer({ service, mode, serverFactory, host, expectedReadySt
       livez_ok: livez.body?.ok === true,
       readyz_status: readyz.status,
       readyz_ok: readyz.body?.ok === true,
+      readyz_missing_checks: missingChecks,
+      readyz_blocker_paths: missingChecks.length > 0
+        ? missingChecks.map((check) => `checks.${check}`)
+        : (readyz.body?.error !== undefined ? ['error'] : []),
       readyz_missing_evidence_ref_count: missingCount(readyz.body),
       readyz_all_checks_ok: allChecksOk(readyz.body),
       ok: livez.status === 200
@@ -157,7 +259,7 @@ export async function runBackendReadinessSmoke(options = {}) {
     host,
     expectedReadyStatus: 503,
     expectedReadyOk: false,
-    serverFactory: () => createRelayServer({ mode: 'production', now: '1970-01-01T00:00:00.000Z' }),
+    serverFactory: () => createRelayServer({ mode: 'production', now: '1970-01-01T00:00:00.000Z', ...relayRuntimeFixture(false) }),
   }));
   checks.push(await probeServer({
     service: 'gateway',
@@ -165,11 +267,11 @@ export async function runBackendReadinessSmoke(options = {}) {
     host,
     expectedReadyStatus: 503,
     expectedReadyOk: false,
-    serverFactory: () => createGatewayServer({ mode: 'production' }),
+    serverFactory: () => createGatewayServer({ mode: 'production', ...gatewayRuntimeFixture(false) }),
   }));
   checks.push(await probeServer({
     service: 'relay',
-    mode: 'production-referenced-fixture',
+    mode: 'production-operational-fixture',
     host,
     expectedReadyStatus: 200,
     expectedReadyOk: true,
@@ -177,7 +279,7 @@ export async function runBackendReadinessSmoke(options = {}) {
   }));
   checks.push(await probeServer({
     service: 'gateway',
-    mode: 'production-referenced-fixture',
+    mode: 'production-operational-fixture',
     host,
     expectedReadyStatus: 200,
     expectedReadyOk: true,
@@ -192,8 +294,8 @@ export async function runBackendReadinessSmoke(options = {}) {
     checks,
     claim_boundary: [
       'This smoke starts local in-process HTTP servers on loopback ephemeral ports only.',
-      'It verifies /livez and /readyz behavior, fail-closed production defaults, and fully referenced production fixture readiness.',
-      'It does not prove hosted DNS, TLS, Cloudflare, durable cloud storage, KMS, SIEM, backup, operator acceptance, or customer BYOC infrastructure is live.',
+      'It verifies fail-closed production defaults and an explicit operational fixture with durable transactional state, gateway KMS/SIEM adapters, authenticated federation dependencies, and all readiness refs.',
+      'Fixture adapters are test-scoped and do not prove hosted DNS, TLS, durable cloud storage, KMS, SIEM, backup, operator acceptance, or customer BYOC infrastructure is live.',
     ],
   };
   if (SECRET_OUTPUT_RE.test(JSON.stringify(result))) throw new Error('backend readiness smoke output appears to contain a secret');

package/scripts/scan-secrets.mjs

@@ -30,6 +30,7 @@ const SKIP_DIRS = new Set([
   'tmp',
   '.vscode',
   '.idea',
+  '.next',
 ])
 
 const SKIP_EXTENSIONS = new Set([

package/scripts/simulate-production-env.mjs

@@ -13,6 +13,7 @@ import { fileURLToPath } from 'node:url'
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
 const DEFAULT_SECRETS_DIR = path.join(os.homedir(), '.enigma', 'simulation-secrets')
+const DOCKER_READABLE_SECRET_MODE = 0o644
 
 const REQUIRED_SECRET_FILES = [
   'relay-signing-key',
@@ -109,7 +110,8 @@ const SECRET_GENERATORS = {
 }
 
 function ensureDir(dir) {
-  fs.mkdirSync(dir, { recursive: true })
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
+  if (process.platform !== 'win32') fs.chmodSync(dir, 0o700)
 }
 
 function isMissingOrEmpty(filePath) {
@@ -200,8 +202,11 @@ function generateSecrets(secretsDir) {
     if (name === 'tls.crt' || name === 'tls.key') continue
     const filePath = path.join(secretsDir, name)
     if (isMissingOrEmpty(filePath)) {
-      fs.writeFileSync(filePath, SECRET_GENERATORS[name](), { mode: 0o600 })
+      fs.writeFileSync(filePath, SECRET_GENERATORS[name](), { mode: DOCKER_READABLE_SECRET_MODE })
     }
+    // Compose file-backed secrets preserve host file bits. The parent directory
+    // remains owner-only while non-root simulation containers receive read access.
+    if (process.platform !== 'win32') fs.chmodSync(filePath, DOCKER_READABLE_SECRET_MODE)
   }
   const keyPath = path.join(secretsDir, 'tls.key')
   const certPath = path.join(secretsDir, 'tls.crt')

package/scripts/validate-hosted-backend-live.mjs

@@ -5,6 +5,9 @@ import { fileURLToPath } from 'node:url';
 
 export const HOSTED_BACKEND_LIVE_EVIDENCE_SCHEMA = 'enigma.hosted_backend_live_evidence.v1';
 export const HOSTED_BACKEND_LIVE_RESULT_SCHEMA = 'enigma.hosted_backend_live_result.v1';
+export const HOSTED_BACKEND_RUNTIME_CAPABILITY_SCHEMA = 'enigma.hosted_backend_runtime_capability.v1';
+export const HOSTED_BACKEND_AUTHENTICATED_DATA_PLANE_SCHEMA = 'enigma.hosted_backend_authenticated_data_plane.v1';
+export const PRIVATE_DATA_PLANE_RUNTIME_MARKER = 'enigma.private_data_plane.runtime.v1';
 
 export const REQUIRED_REF_KEYS = Object.freeze([
   'backend_host',
@@ -35,6 +38,11 @@ export const REQUIRED_REF_KEYS = Object.freeze([
 ]);
 
 const REQUIRED_PROBES = Object.freeze(['relay_livez', 'relay_readyz', 'gateway_livez', 'gateway_readyz']);
+const RUNTIME_SERVICES = Object.freeze(['relay', 'gateway']);
+const DATA_PLANE_ROUTES = Object.freeze({
+  relay: Object.freeze(['/relay/records', '/pairing/challenge', '/pairing/complete']),
+  gateway: Object.freeze(['/policy', '/gateway/evaluate', '/gateway/decision', '/siem/export']),
+});
 const ACCEPTED_STATUSES = new Set(['observed', 'verified', 'go', 'accepted']);
 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/@]+@|raw memory|private prompt|full transcript|decrypted capsule|sk-[A-Za-z0-9_-]{16,}|AKIA[0-9A-Z]{16})/iu;
 const FORBIDDEN_KEY_RE = /(?:password|passwd|pwd|token|api[_-]?key|private[_-]?key|secret|raw[_-]?memory|plaintext|plain[_-]?text|prompt|completion|transcript|embedding|provider[_-]?response|cookie|session)/iu;
@@ -151,6 +159,12 @@ function validateEnvironment(environment, blockers) {
   for (const field of ['environment_id', 'cloud_provider', 'region', 'owner', 'status']) {
     if (!nonEmptyString(environment[field])) blockers.push(blocker(`environment.${field} is required`, `environment.${field}`));
   }
+  if (environment.local_simulation !== false) {
+    blockers.push(blocker('environment.local_simulation must be false for hosted production evidence', 'environment.local_simulation'));
+  }
+  if (nonEmptyString(environment.cloud_provider) && environment.cloud_provider.trim().toLowerCase() === 'local') {
+    blockers.push(blocker('environment.cloud_provider must identify a non-simulation production provider', 'environment.cloud_provider'));
+  }
   if (!statusAccepted(environment.status)) blockers.push(blocker('environment.status must be observed/verified/go/accepted', 'environment.status'));
   return { domain };
 }
@@ -179,6 +193,9 @@ function validateProbe(probe, expectedName, domain, blockers) {
     if (probe.body.hosted_probe_only === true || probe.body.pages_edge_probe_only === true) {
       blockers.push(blocker(`${path}.body must not be an edge-probe-only payload`, `${path}.body`));
     }
+    if (probe.body.hosted_backend_live === false || probe.body.private_data_plane_operational === false || probe.body.runtime_capability?.bootstrap_worker === true) {
+      blockers.push(blocker(`${path}.body declares the private data plane closed or bootstrap-only`, `${path}.body.runtime_capability`));
+    }
     if (probe.body.service !== expectedService) blockers.push(blocker(`${path}.body.service must be ${expectedService}`, `${path}.body.service`));
     if (probe.body.ok !== true) blockers.push(blocker(`${path}.body.ok must be true`, `${path}.body.ok`));
     if (expectedName.endsWith('readyz')) {
@@ -203,6 +220,94 @@ function validateProbes(probes, domain, blockers) {
   return { covered };
 }
 
+function validateRuntimeCapability(capability, blockers) {
+  if (!isPlainObject(capability)) {
+    blockers.push(blocker('runtime_capability object is required', 'runtime_capability'));
+    return { covered: 0 };
+  }
+  if (capability.schema !== HOSTED_BACKEND_RUNTIME_CAPABILITY_SCHEMA) blockers.push(blocker(`runtime_capability.schema must be ${HOSTED_BACKEND_RUNTIME_CAPABILITY_SCHEMA}`, 'runtime_capability.schema'));
+  if (capability.marker !== PRIVATE_DATA_PLANE_RUNTIME_MARKER) blockers.push(blocker(`runtime_capability.marker must be ${PRIVATE_DATA_PLANE_RUNTIME_MARKER}`, 'runtime_capability.marker'));
+  if (!isoLike(capability.observed_at)) blockers.push(blocker('runtime_capability.observed_at must be ISO time', 'runtime_capability.observed_at'));
+  if (!isPlainObject(capability.services)) {
+    blockers.push(blocker('runtime_capability.services object is required', 'runtime_capability.services'));
+    return { covered: 0 };
+  }
+  let covered = 0;
+  for (const serviceKey of RUNTIME_SERVICES) {
+    const path = `runtime_capability.services.${serviceKey}`;
+    const service = capability.services[serviceKey];
+    if (!isPlainObject(service)) {
+      blockers.push(blocker(`${path} object is required`, path));
+      continue;
+    }
+    const expectedService = serviceKey === 'relay' ? 'enigma-relay' : 'enigma-gateway';
+    if (service.service !== expectedService) blockers.push(blocker(`${path}.service must be ${expectedService}`, `${path}.service`));
+    if (service.private_data_plane_operational !== true) blockers.push(blocker(`${path}.private_data_plane_operational must be true`, `${path}.private_data_plane_operational`));
+    if (service.authentication_enforced !== true) blockers.push(blocker(`${path}.authentication_enforced must be true`, `${path}.authentication_enforced`));
+    if (service.bootstrap_worker !== false) blockers.push(blocker(`${path}.bootstrap_worker must be false`, `${path}.bootstrap_worker`));
+    if (!nonEmptyString(service.evidence_ref)) blockers.push(blocker(`${path}.evidence_ref is required`, `${path}.evidence_ref`));
+    covered += 1;
+  }
+  return { covered };
+}
+
+function authenticatedDataPlaneUrl(value, serviceKey, domain, path, blockers) {
+  if (!nonEmptyString(value)) {
+    blockers.push(blocker(`${path} is required`, path));
+    return null;
+  }
+  try {
+    const url = new URL(value);
+    if (url.protocol !== 'https:') blockers.push(blocker(`${path} must use https`, path));
+    if (url.username || url.password) blockers.push(blocker(`${path} must not include credentials`, path));
+    if (url.search || url.hash) blockers.push(blocker(`${path} must not include query strings or fragments`, path));
+    if (isPrivateHost(url.hostname)) blockers.push(blocker(`${path} must not target localhost or private network host`, path));
+    const hostname = url.hostname.toLowerCase();
+    if (domain && hostname !== domain && !hostname.endsWith(`.${domain}`)) blockers.push(blocker(`${path} host must be the domain or a subdomain`, path));
+    if (!DATA_PLANE_ROUTES[serviceKey].includes(url.pathname)) blockers.push(blocker(`${path} must target a ${serviceKey} private data-plane route`, path));
+    return url;
+  } catch {
+    blockers.push(blocker(`${path} must be a valid URL`, path));
+    return null;
+  }
+}
+
+function validateAuthenticatedDataPlane(evidence, domain, blockers) {
+  if (!isPlainObject(evidence)) {
+    blockers.push(blocker('authenticated_data_plane object is required', 'authenticated_data_plane'));
+    return { covered: 0 };
+  }
+  if (evidence.schema !== HOSTED_BACKEND_AUTHENTICATED_DATA_PLANE_SCHEMA) blockers.push(blocker(`authenticated_data_plane.schema must be ${HOSTED_BACKEND_AUTHENTICATED_DATA_PLANE_SCHEMA}`, 'authenticated_data_plane.schema'));
+  if (!isoLike(evidence.observed_at)) blockers.push(blocker('authenticated_data_plane.observed_at must be ISO time', 'authenticated_data_plane.observed_at'));
+  if (!isPlainObject(evidence.proofs)) {
+    blockers.push(blocker('authenticated_data_plane.proofs object is required', 'authenticated_data_plane.proofs'));
+    return { covered: 0 };
+  }
+  let covered = 0;
+  for (const serviceKey of RUNTIME_SERVICES) {
+    const path = `authenticated_data_plane.proofs.${serviceKey}`;
+    const proof = evidence.proofs[serviceKey];
+    if (!isPlainObject(proof)) {
+      blockers.push(blocker(`${path} object is required`, path));
+      continue;
+    }
+    const expectedService = serviceKey === 'relay' ? 'enigma-relay' : 'enigma-gateway';
+    if (proof.service !== expectedService) blockers.push(blocker(`${path}.service must be ${expectedService}`, `${path}.service`));
+    authenticatedDataPlaneUrl(proof.url, serviceKey, domain, `${path}.url`, blockers);
+    if (!['GET', 'POST', 'PUT', 'DELETE'].includes(proof.method)) blockers.push(blocker(`${path}.method must be GET/POST/PUT/DELETE`, `${path}.method`));
+    if (!Number.isSafeInteger(proof.status_code) || proof.status_code < 200 || proof.status_code >= 300) blockers.push(blocker(`${path}.status_code must be a successful 2xx response`, `${path}.status_code`));
+    if (proof.authenticated !== true) blockers.push(blocker(`${path}.authenticated must be true`, `${path}.authenticated`));
+    if (proof.authorization_result !== 'allowed') blockers.push(blocker(`${path}.authorization_result must be allowed`, `${path}.authorization_result`));
+    if (!isoLike(proof.observed_at)) blockers.push(blocker(`${path}.observed_at must be ISO time`, `${path}.observed_at`));
+    for (const field of ['request_hash', 'response_hash']) {
+      if (!nonEmptyString(proof[field]) || !/^sha256:[a-f0-9]{64}$/i.test(proof[field])) blockers.push(blocker(`${path}.${field} must be sha256:<64 hex>`, `${path}.${field}`));
+    }
+    if (!nonEmptyString(proof.evidence_ref)) blockers.push(blocker(`${path}.evidence_ref is required`, `${path}.evidence_ref`));
+    covered += 1;
+  }
+  return { covered };
+}
+
 function validateOperator(operatorAcceptance, blockers) {
   if (!isPlainObject(operatorAcceptance)) {
     blockers.push(blocker('operator_acceptance object is required', 'operator_acceptance'));
@@ -238,6 +343,8 @@ export function validateHostedBackendLiveEvidence(evidence, options = {}) {
   const env = validateEnvironment(evidence.environment, blockers);
   const refs = validateRefs(evidence.refs, blockers);
   const probes = validateProbes(evidence.probes, env.domain, blockers);
+  const runtimeCapability = validateRuntimeCapability(evidence.runtime_capability, blockers);
+  const authenticatedDataPlane = validateAuthenticatedDataPlane(evidence.authenticated_data_plane, env.domain, blockers);
   validateOperator(evidence.operator_acceptance, blockers);
   validateClaimBoundary(evidence.claim_boundary, blockers);
   const result = {
@@ -253,11 +360,15 @@ export function validateHostedBackendLiveEvidence(evidence, options = {}) {
       refs_missing: refs.missing,
       required_probes: REQUIRED_PROBES.length,
       probes_covered: probes.covered,
+      runtime_services_required: RUNTIME_SERVICES.length,
+      runtime_services_covered: runtimeCapability.covered,
+      authenticated_data_plane_proofs_required: RUNTIME_SERVICES.length,
+      authenticated_data_plane_proofs_covered: authenticatedDataPlane.covered,
       operator_decision: evidence.operator_acceptance?.decision ?? null,
     },
     claim_boundary: [
       'Hosted backend live validation checks supplied evidence only; it does not deploy infrastructure, mutate Cloudflare, create DNS records, or generate credentials.',
-      'A pass result requires public HTTPS /livez and /readyz probe evidence for relay and gateway plus all required production refs and operator acceptance go.',
+      'A pass result requires public HTTPS /livez and /readyz probes, an explicit operational private-runtime capability marker, successful authenticated relay and gateway data-plane proofs, all required production refs, and operator acceptance go.',
       'Credentials, bearer tokens, API tokens, private memory payloads, prompts, transcripts, provider responses, and personal contact data must remain outside hosted backend live evidence.',
     ],
   };

package/specs/antibody-pack-v1.schema.json

@@ -0,0 +1,95 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://schemas.enigma.ai/antibody-pack-v1.schema.json",
+  "title": "Enigma Antibody Pack v1",
+  "type": "object",
+  "required": [
+    "schema",
+    "antibody_pack_id",
+    "created_at",
+    "version",
+    "policy_fingerprints",
+    "pack_root",
+    "signatures",
+    "public_payload_only",
+    "private_inputs_included"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "schema": { "const": "enigma.antibody_pack.v1" },
+    "antibody_pack_id": { "$ref": "#/$defs/publicId" },
+    "created_at": { "type": "string", "format": "date-time" },
+    "version": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+(?:[-+][A-Za-z0-9.-]+)?$" },
+    "policy_fingerprints": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/$defs/policyFingerprint" }
+    },
+    "pack_root": { "$ref": "#/$defs/sha256Digest" },
+    "signatures": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/$defs/signatureRef" }
+    },
+    "public_payload_only": { "const": true },
+    "private_inputs_included": { "const": false }
+  },
+  "$defs": {
+    "sha256Digest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
+    "publicId": { "type": "string", "pattern": "^[a-z0-9][a-z0-9._:-]{7,127}$" },
+    "publicRef": { "type": "string", "pattern": "^ref:[A-Za-z0-9][A-Za-z0-9._~:@#?=&%+-]{0,255}$" },
+    "detectorId": { "type": "string", "pattern": "^detector:[A-Za-z0-9][A-Za-z0-9._~:@#?=&%+-]{0,191}$" },
+    "policyId": { "type": "string", "pattern": "^policy:[A-Za-z0-9][A-Za-z0-9._~:@#?=&%+-]{0,191}$" },
+    "signerRef": { "type": "string", "pattern": "^signer:[A-Za-z0-9][A-Za-z0-9._~:@#?=&%+-]{0,191}$" },
+    "signaturePublicRef": { "type": "string", "pattern": "^sigref:[A-Za-z0-9][A-Za-z0-9._~:@#?=&%+-]{0,191}$" },
+    "policyFingerprint": {
+      "type": "object",
+      "required": [
+        "policy_id",
+        "detector_id",
+        "detector_ref",
+        "policy_hash",
+        "risk_labels",
+        "threshold_commitment",
+        "private_inputs_included"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "policy_id": { "$ref": "#/$defs/policyId" },
+        "detector_id": { "$ref": "#/$defs/detectorId" },
+        "detector_ref": { "$ref": "#/$defs/publicRef" },
+        "policy_hash": { "$ref": "#/$defs/sha256Digest" },
+        "risk_labels": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/riskLabel" },
+          "uniqueItems": true
+        },
+        "threshold_commitment": { "$ref": "#/$defs/sha256Digest" },
+        "private_inputs_included": { "const": false }
+      }
+    },
+    "signatureRef": {
+      "type": "object",
+      "required": ["signer_ref", "signature_ref", "signature_hash", "alg"],
+      "additionalProperties": false,
+      "properties": {
+        "signer_ref": { "$ref": "#/$defs/signerRef" },
+        "signature_ref": { "$ref": "#/$defs/signaturePublicRef" },
+        "signature_hash": { "$ref": "#/$defs/sha256Digest" },
+        "alg": { "type": "string", "enum": ["Ed25519", "ECDSA-P256-SHA256"] }
+      }
+    },
+    "riskLabel": {
+      "type": "string",
+      "enum": [
+        "untrusted_origin",
+        "prompt_injection",
+        "data_exfiltration",
+        "secret_material",
+        "memory_poisoning",
+        "policy_violation",
+        "unknown"
+      ]
+    }
+  }
+}

package/specs/antigen-envelope-v1.schema.json

@@ -0,0 +1,81 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://schemas.enigma.ai/antigen-envelope-v1.schema.json",
+  "title": "Enigma Antigen Envelope v1",
+  "type": "object",
+  "required": [
+    "schema",
+    "envelope_id",
+    "created_at",
+    "content_commitment",
+    "source_refs",
+    "detector_refs",
+    "risk_labels",
+    "commitment_roots",
+    "public_payload_only",
+    "payload_included"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "schema": { "const": "enigma.antigen_envelope.v1" },
+    "envelope_id": { "$ref": "#/$defs/publicId" },
+    "created_at": { "type": "string", "format": "date-time" },
+    "content_commitment": {
+      "type": "object",
+      "required": ["hash", "byte_count", "canonicalization"],
+      "additionalProperties": false,
+      "properties": {
+        "hash": { "$ref": "#/$defs/sha256Digest" },
+        "byte_count": { "type": "integer", "minimum": 0 },
+        "canonicalization": { "type": "string", "enum": ["json-c14n-sha256", "bytes-sha256", "utf8-nfc-sha256"] }
+      }
+    },
+    "source_refs": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/$defs/publicRef" },
+      "uniqueItems": true
+    },
+    "detector_refs": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/$defs/publicRef" },
+      "uniqueItems": true
+    },
+    "risk_labels": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/riskLabel" },
+      "uniqueItems": true
+    },
+    "commitment_roots": {
+      "type": "object",
+      "required": ["antigen_root", "source_root", "detector_root"],
+      "additionalProperties": false,
+      "properties": {
+        "antigen_root": { "$ref": "#/$defs/sha256Digest" },
+        "source_root": { "$ref": "#/$defs/sha256Digest" },
+        "detector_root": { "$ref": "#/$defs/sha256Digest" }
+      }
+    },
+    "public_payload_only": { "const": true },
+    "payload_included": { "const": false }
+  },
+  "$defs": {
+    "sha256Digest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
+    "publicId": { "type": "string", "pattern": "^[a-z0-9][a-z0-9._:-]{7,127}$" },
+    "publicRef": { "type": "string", "pattern": "^ref:[A-Za-z0-9][A-Za-z0-9._~:@#?=&%+-]{0,255}$" },
+    "riskLabel": {
+      "type": "string",
+      "enum": [
+        "benign",
+        "untrusted_origin",
+        "prompt_injection",
+        "data_exfiltration",
+        "secret_material",
+        "memory_poisoning",
+        "policy_violation",
+        "unknown"
+      ]
+    }
+  }
+}