enigma-memory 0.1.18 → 0.1.22

package/scripts/build-goal-completion-audit.mjs

@@ -5,7 +5,12 @@ import { pathToFileURL } from 'node:url';
 import { buildProductionHandoffPacket } from './build-production-handoff-packet.mjs';
 import { buildCloudflareTokenPolicy } from './build-cloudflare-token-policy.mjs';
 import { runBackendReadinessSmoke } from './run-backend-readiness-smoke.mjs';
-import { HOSTED_BACKEND_LIVE_EVIDENCE_SCHEMA, HOSTED_BACKEND_LIVE_RESULT_SCHEMA, REQUIRED_REF_KEYS } from './validate-hosted-backend-live.mjs';
+import {
+  HOSTED_BACKEND_LIVE_EVIDENCE_SCHEMA,
+  HOSTED_BACKEND_LIVE_RESULT_SCHEMA,
+  REQUIRED_REF_KEYS,
+  validateHostedBackendLiveEvidence,
+} from './validate-hosted-backend-live.mjs';
 import { validateProductionManifestFiles } from './validate-production-manifests.mjs';
 import { applyCloudflareSecretEnvFile } from './cloudflare-secret-env.mjs';
 
@@ -29,7 +34,7 @@ function assertNoUnsafeOutput(name, value, path = name) {
   }
 }
 
-const DEFAULT_OBJECTIVE = 'Build Enigma Memory into a production-grade project with backend infrastructure, tests, professional math/diagram whitepaper, secure public site, deployment/handoff plan, GPT-5.5 architecture/review ownership, and Kimi Code implementation support without unsupported claims.';
+const DEFAULT_OBJECTIVE = 'Build Enigma Memory into a production-grade project with backend infrastructure, tests, professional math/diagram whitepaper, secure public site, and a deployment/handoff plan, without unsupported claims.';
 
 class UsageError extends Error {
   constructor(message) {
@@ -67,6 +72,45 @@ function expandHostedBackendBlockers(infra) {
   }
   return blockers;
 }
+async function hostedBackendLiveSummary(input, generatedAt) {
+  const supplied = input && typeof input === 'object'
+    ? input
+    : await readJsonPath(input, 'hosted backend live evidence');
+  if (supplied === null) {
+    return {
+      ok: false,
+      status: 'missing',
+      blocker_paths: ['hosted_backend_live_evidence'],
+      checked: null,
+    };
+  }
+  const result = supplied.schema === HOSTED_BACKEND_LIVE_EVIDENCE_SCHEMA
+    ? validateHostedBackendLiveEvidence(supplied, { generated_at: generatedAt })
+    : supplied;
+  if (result.schema !== HOSTED_BACKEND_LIVE_RESULT_SCHEMA) {
+    throw new UsageError(`hosted backend live input must use schema ${HOSTED_BACKEND_LIVE_EVIDENCE_SCHEMA} or ${HOSTED_BACKEND_LIVE_RESULT_SCHEMA}`);
+  }
+  const blockerPaths = Array.isArray(result.blockers)
+    ? result.blockers.map((entry) => entry?.path).filter((path) => typeof path === 'string')
+    : ['blockers'];
+  if (result.checked?.refs_missing !== 0) blockerPaths.push('checked.refs_missing');
+  if (result.checked?.probes_covered !== 4) blockerPaths.push('checked.probes_covered');
+  if (result.checked?.runtime_services_covered !== 2) blockerPaths.push('checked.runtime_services_covered');
+  if (result.checked?.authenticated_data_plane_proofs_covered !== 2) blockerPaths.push('checked.authenticated_data_plane_proofs_covered');
+  if (result.ok !== true || result.status !== 'accepted') blockerPaths.push('status');
+  return {
+    ok: blockerPaths.length === 0,
+    status: result.status,
+    blocker_paths: [...new Set(blockerPaths)],
+    checked: {
+      refs_missing: result.checked?.refs_missing ?? null,
+      probes_covered: result.checked?.probes_covered ?? null,
+      runtime_services_covered: result.checked?.runtime_services_covered ?? null,
+      authenticated_data_plane_proofs_covered: result.checked?.authenticated_data_plane_proofs_covered ?? null,
+    },
+  };
+}
+
 
 function parseArgs(argv) {
   const out = {
@@ -82,6 +126,7 @@ function parseArgs(argv) {
     operatorAcceptancePacket: null,
     infrastructureReadiness: null,
     releaseAudit: null,
+    hostedBackendLive: null,
     workerInspect: null,
   };
   for (let index = 0; index < argv.length;) {
@@ -103,6 +148,7 @@ function parseArgs(argv) {
     else if (token === '--cloudflare-env-file') out.envFile = readValue(token);
     else if (token === '--operator-acceptance-packet' || token === '--operatorAcceptancePacket') out.operatorAcceptancePacket = readValue(token);
     else if (token === '--infrastructure-readiness' || token === '--infrastructureReadiness') out.infrastructureReadiness = readValue(token);
+    else if (token === '--hosted-backend-live' || token === '--hostedBackendLive') out.hostedBackendLive = readValue(token);
     else if (token === '--release-audit' || token === '--releaseAudit') out.releaseAudit = readValue(token);
     else if (token === '--worker-inspect' || token === '--workerInspect') out.workerInspect = readValue(token);
     else if (token === '--out') out.out = readValue(token);
@@ -112,7 +158,7 @@ function parseArgs(argv) {
 }
 
 function usage() {
-  return `Usage: node scripts/build-goal-completion-audit.mjs --site <dir> [options]\n\nOptions:\n  --project-name <name>             Cloudflare Pages project. Default: enigma-memory.\n  --domain <host>                   Public domain. Default: enigmamemory.com.\n  --live-url <url>                  Current public URL to observe. Default: https://enigmamemory.com/.\n  --expect-title <text>             Expected live title fragment. Default: Enigma.\n  --account-id <id>                 Cloudflare account id or placeholder for token-policy evidence.\n  --infrastructure-readiness <file> Completed infrastructure readiness JSON to summarize.\n  --operator-acceptance-packet <file> Completed operator packet JSON to validate and summarize.\n  --release-audit <file>            Current release audit JSON to summarize.\n  --worker-inspect <file>           Optional Worker inspection result; ready evidence suppresses the standalone probe action.\n  --cloudflare-env-file <file>      Load local Cloudflare env values without printing the path or values.\n  --objective <text>                Override objective text.\n  --out <file>                      Write audit JSON.\n  --help                            Show this help.\n`;
+  return `Usage: node scripts/build-goal-completion-audit.mjs --site <dir> [options]\n\nOptions:\n  --project-name <name>             Cloudflare Pages project. Default: enigma-memory.\n  --domain <host>                   Public domain. Default: enigmamemory.com.\n  --live-url <url>                  Current public URL to observe. Default: https://enigmamemory.com/.\n  --expect-title <text>             Expected live title fragment. Default: Enigma.\n  --account-id <id>                 Cloudflare account id or placeholder for token-policy evidence.\n  --infrastructure-readiness <file> Completed infrastructure readiness JSON to summarize.\n  --hosted-backend-live <file>      Strict hosted evidence/result with runtime and authenticated data-plane proofs.\n  --operator-acceptance-packet <file> Completed operator packet JSON to validate and summarize.\n  --release-audit <file>            Current release audit JSON to summarize.\n  --worker-inspect <file>           Optional Worker inspection result; ready evidence suppresses the standalone probe action.\n  --cloudflare-env-file <file>      Load local Cloudflare env values without printing the path or values.\n  --objective <text>                Override objective text.\n  --out <file>                      Write audit JSON.\n  --help                            Show this help.\n`;
 }
 
 async function readText(path) {
@@ -148,31 +194,23 @@ function blockerBreakdownLines(prefix, breakdown) {
 }
 
 async function inspectDocs() {
-  const masterPlan = await readText(resolve('docs/overnight-build-master-plan.md'));
   const whitepaper = await readText(resolve('docs/enigma-memory-technical-whitepaper.md'));
   const evidence = await readText(resolve('docs/release-evidence-2026-06-23.md'));
+  const claimBoundaries = await readText(resolve('docs/proof-network-claim-boundaries.md'));
   return {
-    masterPlan,
     whitepaper,
     evidence,
+    claimBoundaries,
   };
 }
 
-function deliverablesFromEvidence({ docs, handoff, tokenPolicy, backendSmoke, productionManifests }) {
+function deliverablesFromEvidence({ docs, handoff, tokenPolicy, backendSmoke, productionManifests, hostedBackendLive }) {
   const pages = handoff.pages ?? {};
   const infra = handoff.infrastructure ?? {};
   const operator = handoff.operator_acceptance ?? {};
   const releaseAudit = handoff.release_audit ?? {};
   const releaseGateNames = new Set(Array.isArray(releaseAudit.gate_names) ? releaseAudit.gate_names : []);
   const deliverables = [];
-  deliverables.push({
-    id: 'orchestration-master-plan',
-    requirement: 'Architecture/review owner and implementation-owner plan exists with claim boundaries and handoff cadence.',
-    ...boolEvidence(
-      /GPT-5\.5 owns architecture, design, and review/.test(docs.masterPlan) && /Kimi Code owns implementation/.test(docs.masterPlan),
-      ['docs/overnight-build-master-plan.md'],
-    ),
-  });
   deliverables.push({
     id: 'whitepaper-math-diagrams',
     requirement: 'Professional whitepaper contains math and diagrams for the memory layer and its evidence-bounded comparison framework.',
@@ -211,9 +249,9 @@ function deliverablesFromEvidence({ docs, handoff, tokenPolicy, backendSmoke, pr
       backendSmoke.ok === true
         && backendSmoke.check_count === 4
         && backendSmoke.checks?.filter((check) => check.mode === 'production-fail-closed' && check.readyz_status === 503).length === 2
-        && backendSmoke.checks?.filter((check) => check.mode === 'production-referenced-fixture' && check.readyz_status === 200 && check.readyz_missing_evidence_ref_count === 0).length === 2,
+        && backendSmoke.checks?.filter((check) => check.mode === 'production-operational-fixture' && check.readyz_status === 200 && check.readyz_missing_evidence_ref_count === 0 && check.readyz_all_checks_ok === true).length === 2,
       ['npm run production:backend-smoke', `${backendSmoke.check_count} checks`],
-      ['backend readiness smoke did not prove fail-closed and fully referenced local runtime fixtures'],
+      ['backend readiness smoke did not prove fail-closed and explicit operational local runtime fixtures'],
     ),
   });
   deliverables.push({
@@ -231,7 +269,7 @@ function deliverablesFromEvidence({ docs, handoff, tokenPolicy, backendSmoke, pr
   });
   deliverables.push({
     id: 'hosted-live-evidence-contract',
-    requirement: 'Hosted backend live evidence has a formal validator/schema requiring public HTTPS relay/gateway probes, all hosted refs, and operator acceptance go.',
+    requirement: 'Hosted backend live evidence has a formal validator/schema requiring public HTTPS health probes, explicit operational runtime capability, authenticated relay/gateway private data-plane proofs, all hosted refs, and operator acceptance go.',
     ...boolEvidence(
       HOSTED_BACKEND_LIVE_EVIDENCE_SCHEMA === 'enigma.hosted_backend_live_evidence.v1'
         && HOSTED_BACKEND_LIVE_RESULT_SCHEMA === 'enigma.hosted_backend_live_result.v1'
@@ -280,11 +318,17 @@ function deliverablesFromEvidence({ docs, handoff, tokenPolicy, backendSmoke, pr
   });
   deliverables.push({
     id: 'hosted-backend-live',
-    requirement: 'Hosted relay/gateway/storage/KMS/SIEM/backup/operator infrastructure is live and directly verified.',
+    requirement: 'Hosted relay/gateway/storage/KMS/SIEM/backup/operator infrastructure is live with explicit operational runtime capability and authenticated private data-plane proofs.',
     ...boolEvidence(
-      infra.hosted_live_ready === true,
-      ['npm run infrastructure:readiness -- --manifest <completed> --live --cloudflare-live required'],
-      expandHostedBackendBlockers(infra),
+      infra.hosted_live_ready === true && hostedBackendLive.ok === true,
+      [
+        'npm run infrastructure:readiness -- --manifest <completed> --live --cloudflare-live required',
+        'npm run production:hosted-live -- --evidence <completed-hosted-evidence.json>',
+      ],
+      [
+        ...expandHostedBackendBlockers(infra),
+        ...hostedBackendLive.blocker_paths.map((path) => `hosted evidence blocker path: ${path}`),
+      ],
     ),
   });
   deliverables.push({
@@ -300,8 +344,9 @@ function deliverablesFromEvidence({ docs, handoff, tokenPolicy, backendSmoke, pr
     id: 'unsupported-claims-blocked',
     requirement: '$100B/best-in-world ambition is treated as ambition; collateral does not convert it into unsupported proof, ROI, compliance, or hosted-live claims.',
     ...boolEvidence(
-      /unsupported_market_superlative/.test(docs.evidence) || /unsupported superlatives/.test(docs.evidence) || /unsupported launch claim/i.test(docs.masterPlan),
-      ['docs/overnight-build-master-plan.md', 'docs/release-evidence-2026-06-23.md'],
+      /unsupported_market_superlative/.test(docs.evidence) || /unsupported superlatives/.test(docs.evidence)
+        || /market leadership/i.test(docs.claimBoundaries ?? '') || /unsupported superlatives/i.test(docs.claimBoundaries ?? ''),
+      ['docs/release-evidence-2026-06-23.md', 'docs/proof-network-claim-boundaries.md'],
       ['claim-boundary evidence missing unsupported-superlative controls'],
     ),
   });
@@ -318,6 +363,7 @@ export async function buildGoalCompletionAudit(input = {}, options = {}) {
   const expectTitle = optionalText(input.expectTitle, 'Enigma');
   const accountId = optionalText(input.accountId, '<cloudflare-account-id>');
   const workerInspect = await readJsonPath(input.workerInspect, 'worker inspection');
+  const hostedBackendLive = await hostedBackendLiveSummary(input.hostedBackendLive, generatedAt);
   const docs = await inspectDocs();
   const handoff = await buildProductionHandoffPacket({ site, projectName, domain, liveUrl, expectTitle, infrastructureReadiness: input.infrastructureReadiness, operatorAcceptancePacket: input.operatorAcceptancePacket, releaseAudit: input.releaseAudit }, {
     env,
@@ -335,7 +381,7 @@ export async function buildGoalCompletionAudit(input = {}, options = {}) {
     generated_at: generatedAt,
   });
   const productionManifests = await validateProductionManifestFiles({ generated_at: generatedAt });
-  const deliverables = deliverablesFromEvidence({ docs, handoff, tokenPolicy, backendSmoke, productionManifests });
+  const deliverables = deliverablesFromEvidence({ docs, handoff, tokenPolicy, backendSmoke, productionManifests, hostedBackendLive });
   const blockers = deliverables.flatMap((item) => item.ok ? [] : item.blockers.map((blocker) => `${item.id}: ${blocker}`));
   const deliverableById = new Map(deliverables.map((item) => [item.id, item]));
   const staticSiteLive = deliverableById.get('secure-static-site-artifact')?.ok === true
@@ -357,6 +403,7 @@ export async function buildGoalCompletionAudit(input = {}, options = {}) {
       check_count: backendSmoke.check_count,
       loopback_only: backendSmoke.loopback_only,
     },
+    hosted_backend_live_evidence: hostedBackendLive,
     production_manifest_validation: {
       ok: productionManifests.ok,
       status: productionManifests.status,
@@ -367,7 +414,7 @@ export async function buildGoalCompletionAudit(input = {}, options = {}) {
     next_actions: nextActionsForGoalAudit(handoff.next_actions, workerInspect),
     claim_boundary: [
       'This audit preserves the original objective and maps it to current direct evidence.',
-      'complete:false remains expected until hosted backend, operator acceptance, and provider evidence exist; static Cloudflare Pages deploy alone is not enough.',
+      'complete:false remains expected until hosted backend runtime capability, authenticated relay/gateway private data-plane proofs, operator acceptance, and provider evidence exist; health probes or static Cloudflare Pages deploy alone are not enough.',
       'Ambition language is not treated as proof of market value, ROI, compliance status, benchmark leadership, hosted-live readiness, provider deletion, or model forgetting.',
     ],
   };

package/scripts/build-hosted-api-key-lifecycle.mjs

@@ -13,7 +13,7 @@ import {
 } from '../packages/hosted-cloud/src/index.js';
 
 export const HOSTED_API_KEY_LIFECYCLE_PACKET_SCHEMA = HOSTED_CLOUD_API_KEY_LIFECYCLE_PACKET_SCHEMA;
-export const HOSTED_API_KEY_LIFECYCLE_RELEASE_TARGET = '0.1.18';
+export const HOSTED_API_KEY_LIFECYCLE_RELEASE_TARGET = '0.1.20';
 
 const PROVIDED = 'provided';
 const BLOCKED = 'blocked_external_dependency';
@@ -148,6 +148,22 @@ function keyInputsFor({ operation, tenantId, subjectRef, scopes, generatedAt, ev
   return inputs;
 }
 
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+  }
+  return value;
+}
+
+function withCanonicalContractHash(value) {
+  const { contract_hash: _staleHash, ...canonicalFields } = value;
+  return {
+    ...canonicalFields,
+    contract_hash: `sha256:${createHash('sha256').update(JSON.stringify(canonicalize(canonicalFields))).digest('hex')}`,
+  };
+}
+
 function scriptBoundary() {
   return {
     public_safe_packet_only: true,
@@ -182,13 +198,15 @@ export function buildHostedApiKeyLifecyclePacket(options = {}) {
   });
   validateApiKeyLifecyclePacket(packet);
   return {
-    ...packet,
-    schema: HOSTED_CLOUD_API_KEY_LIFECYCLE_PACKET_SCHEMA,
-    release_target: HOSTED_API_KEY_LIFECYCLE_RELEASE_TARGET,
-    tenant_id: tenantId,
-    subject_ref: subjectRef,
-    operation,
-    scopes,
+    ...withCanonicalContractHash({
+      ...packet,
+      schema: HOSTED_CLOUD_API_KEY_LIFECYCLE_PACKET_SCHEMA,
+      release_target: HOSTED_API_KEY_LIFECYCLE_RELEASE_TARGET,
+      tenant_id: tenantId,
+      subject_ref: subjectRef,
+      operation,
+      scopes,
+    }),
     boundary: scriptBoundary(),
   };
 }

package/scripts/build-hosted-customer-lifecycle.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { resolve } from 'node:path';
 
@@ -30,7 +31,7 @@ import {
 } from 'enigma-memory/hosted-cloud';
 
 export const HOSTED_CUSTOMER_LIFECYCLE_PACKET_SCHEMA = HOSTED_CLOUD_CUSTOMER_LIFECYCLE_PACKET_SCHEMA;
-export const HOSTED_CUSTOMER_LIFECYCLE_RELEASE_TARGET = '0.1.18';
+export const HOSTED_CUSTOMER_LIFECYCLE_RELEASE_TARGET = '0.1.20';
 export const HOSTED_CLOUD_READINESS_RELEASE_SCHEMA = HOSTED_CLOUD_READINESS_PACKET_SCHEMA;
 
 const PROVIDED = 'provided';
@@ -342,6 +343,22 @@ function coreRequiredEvidenceRefs(evidenceRefs) {
     .map((phase) => [phase, refs[phase]]));
 }
 
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+  }
+  return value;
+}
+
+function withCanonicalContractHash(value) {
+  const { contract_hash: _staleHash, ...canonicalFields } = value;
+  return {
+    ...canonicalFields,
+    contract_hash: `sha256:${createHash('sha256').update(JSON.stringify(canonicalize(canonicalFields))).digest('hex')}`,
+  };
+}
+
 function scriptBoundary() {
   return {
     public_safe_packet_only: true,
@@ -370,7 +387,7 @@ export function buildHostedCustomerLifecyclePacket(options = {}) {
     operator_go_live_ref: operatorGoLiveRef,
   });
   validateCustomerLifecyclePacket(packet);
-  return {
+  return withCanonicalContractHash({
     ...packet,
     release_target: HOSTED_CUSTOMER_LIFECYCLE_RELEASE_TARGET,
     tenant_id: tenantId,
@@ -379,7 +396,7 @@ export function buildHostedCustomerLifecyclePacket(options = {}) {
     evidence_refs: Object.fromEntries(Object.entries(evidenceRefs).map(([key, value]) => [key, { ...value }])),
     operator_external_evidence_refs: operatorEvidenceRefsFrom(evidenceRefs),
     boundary: scriptBoundary(),
-  };
+  });
 }
 
 export function buildHostedCloudReadinessPacketFromArgs(options = {}) {

package/scripts/build-hosted-probe-worker.mjs

@@ -27,9 +27,9 @@ export const REQUIRED_WORKER_ENV_REFS = Object.freeze([
 ]);
 
 const WORKER_CLAIM_BOUNDARY = Object.freeze([
-  'This Worker is a hosted public HTTPS probe harness, not the relay/gateway data plane.',
-  'It proves only that the edge route can fail closed and expose /livez and /readyz shape without secrets.',
-  'It must not be used as hosted backend live evidence unless real relay/gateway/storage/KMS/SIEM/backup/operator refs and probes are supplied separately.',
+  'This Worker is a hosted public HTTPS probe harness, not the relay/gateway data plane; hosted_backend_live is always false.',
+  'Its private data plane is closed and non-operational even when /readyz returns 200 after reference checks.',
+  'It must not be used as hosted backend live evidence; operational runtime markers and successful authenticated relay/gateway data-plane proofs must come from the real runtime.',
 ]);
 
 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}|raw memory|private prompt|full transcript|decrypted capsule)/iu;
@@ -45,6 +45,12 @@ export function hostedProbeWorkerSource(options = {}) {
   return `const SERVICE_NAME = ${JSON.stringify(serviceName)};
 const REQUIRED_REFS = ${requiredRefs};
 const CLAIM_BOUNDARY = ${boundary};
+const RUNTIME_CAPABILITY = Object.freeze({
+  marker: 'enigma.private_data_plane.runtime.v1',
+  bootstrap_worker: true,
+  private_data_plane_operational: false,
+  authenticated_data_plane_supported: false
+});
 
 function json(body, status = 200) {
   return new Response(JSON.stringify(body, null, 2), {
@@ -70,6 +76,9 @@ function readiness(env) {
     ok: missing.length === 0 && decisionOk,
     service: SERVICE_NAME,
     hosted_probe_only: true,
+    hosted_backend_live: false,
+    private_data_plane_operational: false,
+    runtime_capability: RUNTIME_CAPABILITY,
     missing_evidence_refs: missing,
     checks: [
       { id: 'required_refs', ok: missing.length === 0, missing_count: missing.length, required_count: REQUIRED_REFS.length },
@@ -84,7 +93,7 @@ export default {
     const url = new URL(request.url);
     if (request.method !== 'GET' && request.method !== 'HEAD') return json({ ok: false, error: 'method_not_allowed' }, 405);
     if (url.pathname === '/livez') {
-      return json({ ok: true, service: SERVICE_NAME, hosted_probe_only: true, claim_boundary: CLAIM_BOUNDARY });
+      return json({ ok: true, service: SERVICE_NAME, hosted_probe_only: true, hosted_backend_live: false, private_data_plane_operational: false, runtime_capability: RUNTIME_CAPABILITY, claim_boundary: CLAIM_BOUNDARY });
     }
     if (url.pathname === '/readyz') {
       const body = readiness(env);
@@ -103,6 +112,10 @@ export function validateHostedProbeWorkerSource(source) {
   if (!text.includes("url.pathname === '/readyz'")) blockers.push({ path: 'source', message: 'worker must route /readyz' });
   if (!text.includes('missing_evidence_refs')) blockers.push({ path: 'source', message: 'worker must expose missing evidence refs on /readyz' });
   if (!text.includes('hosted_probe_only: true')) blockers.push({ path: 'source', message: 'worker must mark hosted_probe_only true' });
+  if (!text.includes('hosted_backend_live: false')) blockers.push({ path: 'source', message: 'worker must explicitly declare hosted_backend_live false' });
+  if (!text.includes('private_data_plane_operational: false')) blockers.push({ path: 'source', message: 'worker must explicitly declare the private data plane non-operational' });
+  if (!text.includes('authenticated_data_plane_supported: false')) blockers.push({ path: 'source', message: 'worker must explicitly declare authenticated data-plane support unavailable' });
+  if (/hosted_backend_live\s*:\s*true/u.test(text)) blockers.push({ path: 'source', message: 'probe worker must never declare hosted_backend_live true' });
   if (!text.includes('status,') || !text.includes('body.ok ? 200 : 503')) blockers.push({ path: 'source', message: 'worker readyz must fail closed with 503 until complete' });
   if (SECRET_VALUE_RE.test(text)) blockers.push({ path: 'source', message: 'worker source contains secret-looking literal' });
   for (const ref of REQUIRED_WORKER_ENV_REFS) if (!text.includes(ref)) blockers.push({ path: `source.${ref}`, message: `worker missing required ref ${ref}` });
@@ -129,6 +142,8 @@ export function buildHostedProbeWorkerBundle(options = {}) {
       runtime: 'cloudflare-workers',
       entrypoint: 'worker.mjs',
       default_routes: ['/livez', '/readyz'],
+      hosted_backend_live: false,
+      private_data_plane_operational: false,
       mutates_cloudflare: false,
       command_hint: 'wrangler deploy worker.mjs --name enigma-hosted-probe',
     },

package/scripts/build-installer-assets.mjs

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'node:url';
 
 export const INSTALLER_ASSET_SCHEMA = 'enigma.installer_assets.v1';
 export const INSTALLER_ASSET_PACKAGE = 'enigma-memory';
-export const INSTALLER_ASSET_VERSION = '0.1.18';
+export const INSTALLER_ASSET_VERSION = '0.1.20';
 export const INSTALLER_ASSET_GENERATED_AT = '1970-01-01T00:00:00.000Z';
 
 const SCRIPT_PATH = fileURLToPath(import.meta.url);
@@ -98,7 +98,8 @@ function windowsInstallerScript() {
 # Dry-run is the default; pass -Execute to mutate global npm state and create local setup files.
 param(
   [switch]$Execute,
-  [string]$Bundle = '.\\.enigma\\bundle.json'
+  [string]$Bundle = '.\\.enigma\\bundle.json',
+  [string]$PassphraseFile = '.\\.enigma\\passphrase'
 )
 $ErrorActionPreference = 'Stop'
 $PackageName = '${INSTALLER_ASSET_PACKAGE}'
@@ -108,11 +109,12 @@ Write-Output 'Enigma Memory Windows installer source asset'
 Write-Output 'Default mode: dry-run. No native .exe, code-signing, tokens, or hosted credentials are included.'
 Write-Output "Package: $PackageName"
 Write-Output "Bundle: $Bundle"
+Write-Output "Passphrase file: $PassphraseFile"
 
 $steps = @(
   'npm install -g enigma-memory',
-  'enigma test-drive --dry-run',
-  'enigma setup --bundle <bundle> --overwrite',
+  'enigma test-drive --dry-run --insecure-dev # INSECURE, EVALUATION ONLY',
+  'enigma setup --bundle <bundle> --passphrase-file <passphrase-file> --overwrite',
   'enigma doctor',
   "Next client-connect preview: $NextClientConnect"
 )
@@ -122,10 +124,17 @@ if (-not $Execute) {
   $steps | ForEach-Object { Write-Output "DRY-RUN: $_" }
   exit 0
 }
+if (-not (Test-Path -LiteralPath $PassphraseFile -PathType Leaf)) {
+  throw 'Encrypted setup requires -PassphraseFile pointing to a non-empty file created through an approved secret manager or secure editor.'
+}
+if ((Get-Item -LiteralPath $PassphraseFile).Length -eq 0) {
+  throw 'Encrypted setup passphrase file must not be empty.'
+}
+
 
 npm install -g $PackageName
-enigma test-drive --dry-run
-enigma setup --bundle $Bundle --overwrite
+enigma test-drive --dry-run --insecure-dev # INSECURE, EVALUATION ONLY
+enigma setup --bundle $Bundle --passphrase-file $PassphraseFile --overwrite
 enigma doctor
 Write-Output "Next client-connect preview: $NextClientConnect"
 `;
@@ -140,13 +149,15 @@ function linuxInstallerScript() {
     '',
     'execute=0',
     "bundle='./.enigma/bundle.json'",
+    "passphrase_file='./.enigma/passphrase'",
     'while [ "$#" -gt 0 ]; do',
     '  case "$1" in',
     '    --execute) execute=1 ;;',
     '    --dry-run) execute=0 ;;',
     '    --bundle) shift; bundle="${1:-}" ;;',
+    '    --passphrase-file) shift; passphrase_file="${1:-}" ;;',
     '    --help|-h)',
-    "      printf '%s\\n' 'Usage: ./install-linux.sh [--execute|--dry-run] [--bundle ./.enigma/bundle.json]'",
+    "      printf '%s\\n' 'Usage: ./install-linux.sh [--execute|--dry-run] [--bundle ./.enigma/bundle.json] [--passphrase-file ./.enigma/passphrase]'",
     '      exit 0',
     '      ;;',
     '    *)',
@@ -163,20 +174,26 @@ function linuxInstallerScript() {
     "printf '%s\\n' 'Default mode: dry-run. No native package, signing key, tokens, or hosted credentials are included.'",
     'printf \'%s\\n\' "Package: $package"',
     'printf \'%s\\n\' "Bundle: $bundle"',
+    'printf \'%s\\n\' "Passphrase file: $passphrase_file"',
     '',
     'if [ "$execute" -ne 1 ]; then',
     "  printf '%s\\n' 'Preview only. Re-run with --execute after reviewing these steps.'",
     "  printf '%s\\n' 'DRY-RUN: npm install -g enigma-memory'",
-    "  printf '%s\\n' 'DRY-RUN: enigma test-drive --dry-run'",
-    "  printf '%s\\n' 'DRY-RUN: enigma setup --bundle <bundle> --overwrite'",
+    "  printf '%s\\n' 'DRY-RUN: enigma test-drive --dry-run --insecure-dev # INSECURE, EVALUATION ONLY'",
+    "  printf '%s\\n' 'DRY-RUN: enigma setup --bundle <bundle> --passphrase-file <passphrase-file> --overwrite'",
     "  printf '%s\\n' 'DRY-RUN: enigma doctor'",
     '  printf \'%s\\n\' "DRY-RUN: Next client-connect preview: $next_client_connect"',
     '  exit 0',
     'fi',
+    'if [ ! -s "$passphrase_file" ]; then',
+    "  printf '%s\\n' 'Encrypted setup requires --passphrase-file pointing to a non-empty file created through an approved secret manager or secure editor.' >&2",
+    '  exit 2',
+    'fi',
+    '',
     '',
     'npm install -g "$package"',
-    'enigma test-drive --dry-run',
-    'enigma setup --bundle "$bundle" --overwrite',
+    'enigma test-drive --dry-run --insecure-dev # INSECURE, EVALUATION ONLY',
+    'enigma setup --bundle "$bundle" --passphrase-file "$passphrase_file" --overwrite',
     'enigma doctor',
     'printf \'%s\\n\' "Next client-connect preview: $next_client_connect"',
     '',
@@ -187,8 +204,8 @@ function homebrewFormulaDraft() {
   return `# Draft only. This formula is not submitted to a Homebrew tap by this generator.
 # Release engineering must replace the tarball URL and sha256 after a real source archive exists.
 # Post-install smoke path:
-#   enigma test-drive --dry-run
-#   enigma setup --overwrite
+#   enigma test-drive --dry-run --insecure-dev # INSECURE, EVALUATION ONLY
+#   enigma setup --passphrase-file "$HOME/.enigma/passphrase" --overwrite
 #   enigma doctor
 #   enigma connect <client> --dry-run
 class EnigmaMemory < Formula
@@ -212,8 +229,8 @@ class EnigmaMemory < Formula
 
   test do
     assert_match "enigma", shell_output("#{bin}/enigma --help")
-    assert_match "enigma.test_drive.v1", shell_output("#{bin}/enigma test-drive --dry-run")
-    assert_match "enigma.setup.v1", shell_output("#{bin}/enigma setup --dry-run")
+    assert_match "enigma.test_drive.v1", shell_output("#{bin}/enigma test-drive --dry-run --insecure-dev") # INSECURE, EVALUATION ONLY
+    assert_match "enigma.setup.v1", shell_output("#{bin}/enigma setup --dry-run --insecure-dev") # INSECURE, EVALUATION ONLY
     shell_output("#{bin}/enigma doctor")
     puts "Next client-connect preview: enigma connect <client> --dry-run"
   end
@@ -230,8 +247,9 @@ Current supported path:
 
 \`\`\`sh
 npm install -g ${INSTALLER_ASSET_PACKAGE}
-enigma test-drive --dry-run
-enigma setup --overwrite
+enigma test-drive --dry-run --insecure-dev # INSECURE, EVALUATION ONLY
+test -s "$HOME/.enigma/passphrase" || { printf '%s\n' 'Create $HOME/.enigma/passphrase with an approved secret manager or secure editor, then restrict it to the current user.' >&2; exit 1; }
+enigma setup --passphrase-file "$HOME/.enigma/passphrase" --overwrite
 enigma doctor
 enigma connect <client> --dry-run
 \`\`\`
@@ -260,8 +278,8 @@ function macosPkgManifest() {
     install_prefix: '<homebrew-or-npm-managed-prefix>',
     commands: [
       ['npm', 'install', '-g', INSTALLER_ASSET_PACKAGE],
-      ['enigma', 'test-drive', '--dry-run'],
-      ['enigma', 'setup', '--overwrite'],
+      ['enigma', 'test-drive', '--dry-run', '--insecure-dev'],
+      ['enigma', 'setup', '--passphrase-file', '<passphrase-file>', '--overwrite'],
       ['enigma', 'doctor'],
     ],
     next_client_connect: ['enigma', 'connect', '<client>', '--dry-run'],
@@ -321,8 +339,8 @@ export function buildInstallerAssets(options = {}, runtime = {}) {
     installer_smoke: {
       default_preview_commands: [
         'npm install -g enigma-memory',
-        'enigma test-drive --dry-run',
-        'enigma setup --overwrite',
+        'enigma test-drive --dry-run --insecure-dev # INSECURE, EVALUATION ONLY',
+        'enigma setup --passphrase-file <passphrase-file> --overwrite',
         'enigma doctor',
       ],
       next_client_connect: 'enigma connect <client> --dry-run',
@@ -336,6 +354,8 @@ export function buildInstallerAssets(options = {}, runtime = {}) {
       embeds_provider_responses: false,
       embeds_private_keys: false,
       default_dry_run: true,
+      setup_encrypted_by_default: true,
+      insecure_mode_evaluation_only: true,
       requires_write_flag_for_filesystem_mutation: true,
     },
   };

package/scripts/build-operator-evidence-starter.mjs

@@ -4,7 +4,13 @@ import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { buildOperatorAcceptancePacket } from './build-operator-acceptance-packet.mjs';
 import { buildProductionReadinessManifest } from './build-production-readiness-manifest.mjs';
-import { HOSTED_BACKEND_LIVE_EVIDENCE_SCHEMA, REQUIRED_REF_KEYS } from './validate-hosted-backend-live.mjs';
+import {
+  HOSTED_BACKEND_AUTHENTICATED_DATA_PLANE_SCHEMA,
+  HOSTED_BACKEND_LIVE_EVIDENCE_SCHEMA,
+  HOSTED_BACKEND_RUNTIME_CAPABILITY_SCHEMA,
+  PRIVATE_DATA_PLANE_RUNTIME_MARKER,
+  REQUIRED_REF_KEYS,
+} from './validate-hosted-backend-live.mjs';
 import { REQUIRED_EVIDENCE_ITEMS, REQUIRED_OWNER_ROLES, REQUIRED_PACKET_METADATA } from './validate-operator-acceptance.mjs';
 import { groupHostedRefsByWorkstream } from './hosted-ref-workstreams.mjs';
 
@@ -97,6 +103,7 @@ function buildHostedBackendLiveEvidenceTemplate({ domain }) {
       region: '<public-region-code>',
       owner: '<operator-team-or-role>',
       status: 'observed',
+      local_simulation: false,
     },
     refs: Object.fromEntries(HOSTED_REF_KEYS.map((key) => [key, `<operator-provided-${key}-evidence-ref>`])),
     probes: {
@@ -105,6 +112,57 @@ function buildHostedBackendLiveEvidenceTemplate({ domain }) {
       gateway_livez: hostedProbeTemplate('gateway', 'livez', domain),
       gateway_readyz: hostedProbeTemplate('gateway', 'readyz', domain),
     },
+    runtime_capability: {
+      schema: HOSTED_BACKEND_RUNTIME_CAPABILITY_SCHEMA,
+      marker: PRIVATE_DATA_PLANE_RUNTIME_MARKER,
+      observed_at: '<runtime-capability-observed-at-iso8601>',
+      services: {
+        relay: {
+          service: 'enigma-relay',
+          private_data_plane_operational: true,
+          authentication_enforced: true,
+          bootstrap_worker: false,
+          evidence_ref: '<operator-provided-relay-runtime-capability-ref>',
+        },
+        gateway: {
+          service: 'enigma-gateway',
+          private_data_plane_operational: true,
+          authentication_enforced: true,
+          bootstrap_worker: false,
+          evidence_ref: '<operator-provided-gateway-runtime-capability-ref>',
+        },
+      },
+    },
+    authenticated_data_plane: {
+      schema: HOSTED_BACKEND_AUTHENTICATED_DATA_PLANE_SCHEMA,
+      observed_at: '<authenticated-data-plane-observed-at-iso8601>',
+      proofs: {
+        relay: {
+          service: 'enigma-relay',
+          url: `https://relay.${domain}/pairing/complete`,
+          method: 'POST',
+          status_code: 200,
+          authenticated: true,
+          authorization_result: 'allowed',
+          observed_at: '<relay-data-plane-observed-at-iso8601>',
+          request_hash: 'sha256:<operator-provided-relay-request-sha256-hex>',
+          response_hash: 'sha256:<operator-provided-relay-response-sha256-hex>',
+          evidence_ref: '<operator-provided-relay-authenticated-data-plane-ref>',
+        },
+        gateway: {
+          service: 'enigma-gateway',
+          url: `https://gateway.${domain}/gateway/decision`,
+          method: 'POST',
+          status_code: 200,
+          authenticated: true,
+          authorization_result: 'allowed',
+          observed_at: '<gateway-data-plane-observed-at-iso8601>',
+          request_hash: 'sha256:<operator-provided-gateway-request-sha256-hex>',
+          response_hash: 'sha256:<operator-provided-gateway-response-sha256-hex>',
+          evidence_ref: '<operator-provided-gateway-authenticated-data-plane-ref>',
+        },
+      },
+    },
     operator_acceptance: {
       decision: 'go',
       packet_ref: '<operator-acceptance-packet-ref>',