enigma-memory 0.1.18 → 0.1.22

package/scripts/build-production-backend-env-kit.mjs

@@ -194,6 +194,7 @@ function serviceEnv({ service, domain, tenant, environment }) {
     ['ENIGMA_INCIDENT_DRILL_REF', placeholderFor('ENIGMA_INCIDENT_DRILL_REF')],
     ['ENIGMA_BACKUP_RESTORE_DRILL_REF', placeholderFor('ENIGMA_BACKUP_RESTORE_DRILL_REF')],
     ['ENIGMA_OPERATOR_ACCEPTANCE_DECISION', '<operator-required-go-decision>'],
+    ['ENIGMA_BACKUP_TARGET_REF', placeholderFor('ENIGMA_BACKUP_TARGET_REF')],
     ['ENIGMA_BACKUP_TARGET_URI_FILE', '/run/secrets/backup_target_uri'],
     ['ENIGMA_KMS_KEY_REF_FILE', '/run/secrets/kms_key_ref'],
     ['ENIGMA_OPERATOR_ACCEPTANCE_EVIDENCE_URI_FILE', '/run/secrets/operator_acceptance_evidence_uri'],
@@ -211,6 +212,7 @@ function serviceEnv({ service, domain, tenant, environment }) {
       ['ENIGMA_RELAY_DNS_TLS_REF', placeholderFor('ENIGMA_RELAY_DNS_TLS_REF')],
       ['ENIGMA_RELAY_RUNTIME_AUTH_REF', placeholderFor('ENIGMA_RELAY_RUNTIME_AUTH_REF')],
       ['ENIGMA_RELAY_MONITORING_REF', placeholderFor('ENIGMA_RELAY_MONITORING_REF')],
+      ['ENIGMA_RELAY_STORAGE_REF', placeholderFor('ENIGMA_RELAY_STORAGE_REF')],
       ['ENIGMA_RELAY_SIGNING_KEY_FILE', '/run/secrets/relay_signing_key'],
       ['ENIGMA_EXTERNAL_STORAGE_DSN_FILE', '/run/secrets/external_storage_dsn'],
       ...common,

package/scripts/build-production-unblocker.mjs

@@ -4,6 +4,9 @@ import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 export const PRODUCTION_UNBLOCKER_SCHEMA = 'enigma.production_unblocker.v1';
+// Last VERIFIED live registry version (`npm view enigma-memory version`), distinct
+// from the source release candidate (ENIGMA_VERSION). Bump ONLY after a publish is
+// confirmed live on the registry — never to the candidate version in advance.
 export const CURRENT_PUBLIC_PACKAGE_VERSION = '0.1.18';
 
 const STATUS_VALUES = Object.freeze([

package/scripts/check.mjs

@@ -265,14 +265,28 @@ function validatePackageMetadata(pkg) {
     './gateway',
     './desktop'
   ];
+  function extractExportTargets(target) {
+    if (typeof target === 'string') return [target];
+    if (isPlainObject(target)) return Object.values(target).flatMap(extractExportTargets);
+    if (Array.isArray(target)) return target.flatMap(extractExportTargets);
+    return [];
+  }
+
   if (!isPlainObject(pkg.exports)) throw new Error('package.json missing exports');
   for (const key of requiredExports) {
     const target = pkg.exports[key];
-    if (typeof target !== 'string') throw new Error(`package.json missing export ${key}`);
-    if (!packageFileExists(target)) throw new Error(`package.json export ${key} points to a missing file`);
+    if (typeof target !== 'string' && !isPlainObject(target)) throw new Error(`package.json missing export ${key}`);
+    const targets = extractExportTargets(target);
+    if (targets.length === 0) throw new Error(`package.json missing export ${key}`);
+    for (const t of targets) {
+      if (!packageFileExists(t)) throw new Error(`package.json export ${key} points to a missing file: ${t}`);
+    }
   }
   for (const [key, target] of Object.entries(pkg.exports)) {
-    if (typeof target === 'string' && !packageFileExists(target)) throw new Error(`package.json export ${key} points to a missing file`);
+    const targets = extractExportTargets(target);
+    for (const t of targets) {
+      if (!packageFileExists(t)) throw new Error(`package.json export ${key} points to a missing file: ${t}`);
+    }
   }
 
   const requiredBins = ['enigma', 'enigma-verify', 'enigma-mcp', 'enigma-relay', 'enigma-gateway', 'enigma-native-host'];

package/scripts/collect-hosted-backend-live-evidence.mjs

@@ -15,10 +15,13 @@ export const HOSTED_BACKEND_LIVE_COLLECTION_SCHEMA = 'enigma.hosted_backend_live
 
 const REQUIRED_PROBES = Object.freeze(['relay_livez', 'relay_readyz', 'gateway_livez', 'gateway_readyz']);
 const CLAIM_BOUNDARY = Object.freeze([
-  'This collector performs public HTTPS health probes and assembles evidence; it does not deploy infrastructure, mutate DNS, create credentials, or approve operator acceptance.',
-  'Collected evidence is accepted only if validate-hosted-backend-live also accepts it.',
-  'Probe response bodies must be public-safe readiness JSON and must not contain tokens, prompts, transcripts, provider responses, raw memory, or personal contact data.',
+  'This collector performs public HTTPS health probes and assembles separately supplied runtime-capability and authenticated data-plane proof; it does not deploy infrastructure, mutate DNS, create credentials, or approve operator acceptance.',
+  'Health-only collection remains blocked: validate-hosted-backend-live requires operational runtime markers and successful authenticated relay/gateway data-plane evidence.',
+  'Local-simulation loopback collection is marked local_simulation:true and hosted_backend_live:false, so it cannot satisfy hosted production evidence.',
+  'Probe response bodies and supplied evidence must be public-safe and must not contain tokens, prompts, transcripts, provider responses, raw memory, or personal contact data.',
 ]);
+const DEFAULT_PROBE_TIMEOUT_MS = 10_000;
+
 const SAFE_PROBE_FIELD_NAMES = new Set(['evidence_refs', 'kms_or_secret_custody']);
 
 function sha256(text) {
@@ -36,6 +39,15 @@ function nonEmptyString(value) {
 function readFlag(flags, key, fallback = null) {
   return flags.has(key) ? flags.get(key) : fallback;
 }
+function bounded(promise, timeoutMs, label) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    timer.unref?.();
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
 
 function parsePublicHealthUrl(value, label) {
   if (!nonEmptyString(value)) throw new Error(`${label} is required`);
@@ -88,6 +100,7 @@ export function localSimulationLoopbackFetch(url, init = {}) {
   if (parsed.protocol !== 'https:' || (host !== 'sim.enigmamemory.com' && !host.endsWith('.sim.enigmamemory.com'))) {
     throw new Error('--local-simulation-loopback only supports https://*.sim.enigmamemory.com simulation probes');
   }
+  const timeoutMs = Number.isSafeInteger(init.timeoutMs) && init.timeoutMs > 0 ? init.timeoutMs : DEFAULT_PROBE_TIMEOUT_MS;
   const request = {
     hostname: '127.0.0.1',
     port: parsed.port || 443,
@@ -102,6 +115,7 @@ export function localSimulationLoopbackFetch(url, init = {}) {
       const chunks = [];
       res.on('data', (chunk) => chunks.push(chunk));
       res.on('end', () => {
+        clearTimeout(timer);
         const text = Buffer.concat(chunks).toString('utf8');
         resolve({
           ok: res.statusCode >= 200 && res.statusCode < 300,
@@ -113,24 +127,33 @@ export function localSimulationLoopbackFetch(url, init = {}) {
         });
       });
     });
-    req.on('error', reject);
+    const timer = setTimeout(() => req.destroy(new Error(`simulation probe timed out after ${timeoutMs}ms`)), timeoutMs);
+    timer.unref?.();
+    req.on('error', (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
     req.end();
   });
 }
 
-async function fetchProbe(url, { fetchImpl = globalThis.fetch, observedAt }) {
+async function fetchProbe(url, { fetchImpl = globalThis.fetch, observedAt, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS }) {
   if (typeof fetchImpl !== 'function') throw new Error('global fetch is not available in this Node runtime');
-  const response = await fetchImpl(url, {
+  const response = await bounded(fetchImpl(url, {
     method: 'GET',
     headers: { Accept: 'application/json' },
     redirect: 'manual',
-  });
+    signal: AbortSignal.timeout(timeoutMs),
+    timeoutMs,
+  }), timeoutMs, `hosted backend probe ${url}`);
   const statusCode = Number(response.status ?? 0);
   const responseUrl = typeof response.url === 'string' && response.url.length > 0 ? response.url : url;
   if (response.redirected === true || responseUrl !== url || (statusCode >= 300 && statusCode <= 399)) {
     throw new Error(`hosted backend probe ${url} must not redirect`);
   }
-  const text = typeof response.text === 'function' ? await response.text() : '';
+  const text = typeof response.text === 'function'
+    ? await bounded(response.text(), timeoutMs, `hosted backend probe body ${url}`)
+    : '';
   let body = null;
   try {
     body = text.trim().length === 0 ? {} : JSON.parse(text);
@@ -158,7 +181,12 @@ function buildProbeUrls(options) {
 }
 
 function buildEnvironment(options) {
-  if (isPlainObject(options.environment)) return options.environment;
+  if (isPlainObject(options.environment)) {
+    return {
+      ...options.environment,
+      local_simulation: options.localSimulation === true || options.environment.local_simulation === true,
+    };
+  }
   return {
     environment_id: options.environmentId,
     domain: options.domain,
@@ -166,6 +194,7 @@ function buildEnvironment(options) {
     region: options.region,
     owner: options.owner,
     status: options.environmentStatus ?? 'observed',
+    local_simulation: options.localSimulation === true,
   };
 }
 
@@ -187,16 +216,19 @@ function validateRefsShape(refs) {
 export async function collectHostedBackendLiveEvidence(options = {}) {
   const observedAt = options.observed_at ?? options.observedAt ?? new Date().toISOString();
   const probeUrls = buildProbeUrls(options);
-  const probeEntries = await Promise.all(REQUIRED_PROBES.map(async (key) => [key, await fetchProbe(probeUrls[key], { fetchImpl: options.fetchImpl, observedAt })]));
+  const timeoutMs = options.probeTimeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+  const probeEntries = await Promise.all(REQUIRED_PROBES.map(async (key) => [key, await fetchProbe(probeUrls[key], { fetchImpl: options.fetchImpl, observedAt, timeoutMs })]));
   const evidence = {
     schema: HOSTED_BACKEND_LIVE_EVIDENCE_SCHEMA,
     observed_at: observedAt,
     environment: buildEnvironment(options),
     refs: validateRefsShape(options.refs),
     probes: Object.fromEntries(probeEntries),
+    runtime_capability: isPlainObject(options.runtime_capability ?? options.runtimeCapability) ? (options.runtime_capability ?? options.runtimeCapability) : null,
+    authenticated_data_plane: isPlainObject(options.authenticated_data_plane ?? options.authenticatedDataPlane) ? (options.authenticated_data_plane ?? options.authenticatedDataPlane) : null,
     operator_acceptance: buildOperatorAcceptance(options),
     claim_boundary: {
-      hosted_backend_live: true,
+      hosted_backend_live: options.localSimulation !== true,
       public_site_live: false,
       cloudflare_credentials_claim: false,
       token_roi_claim: false,
@@ -239,7 +271,7 @@ function parseArgs(argv) {
 }
 
 function usage() {
-  return `Usage: node scripts/collect-hosted-backend-live-evidence.mjs --relay-url <https-base> --gateway-url <https-base> --refs-json <refs.json> --domain <domain> --environment-id <id> --cloud-provider <provider> --region <region> --owner <owner> --operator-decision go --operator-packet-ref <ref> --operator-approved-at <iso> --operator-approved-by <name> [--out <collection.json>] [--evidence-out <evidence.json>] [--local-simulation-loopback]\n\nCollects public HTTPS /livez and /readyz evidence for relay and gateway, then validates it with validate-hosted-backend-live. It never sends credentials and does not deploy infrastructure. The --local-simulation-loopback flag is restricted to https://*.sim.enigmamemory.com local simulation probes with self-signed TLS and must not be used as production evidence.\n`;
+  return `Usage: node scripts/collect-hosted-backend-live-evidence.mjs --relay-url <https-base> --gateway-url <https-base> --refs-json <refs.json> --runtime-capability-json <runtime-capability.json> --authenticated-data-plane-json <authenticated-data-plane.json> --domain <domain> --environment-id <id> --cloud-provider <provider> --region <region> --owner <owner> --operator-decision go --operator-packet-ref <ref> --operator-approved-at <iso> --operator-approved-by <name> [--out <collection.json>] [--evidence-out <evidence.json>] [--local-simulation-loopback]\n\nCollects public HTTPS /livez and /readyz evidence and assembles separate public-safe runtime/authenticated data-plane evidence for relay and gateway, then validates it with validate-hosted-backend-live. It never sends credentials and does not deploy infrastructure. Health-only evidence is always blocked. The --local-simulation-loopback flag is restricted to https://*.sim.enigmamemory.com local simulation probes with self-signed TLS.\n`;
 }
 
 async function runCli(argv = process.argv.slice(2), { fetchImpl = globalThis.fetch } = {}) {
@@ -253,6 +285,8 @@ async function runCli(argv = process.argv.slice(2), { fetchImpl = globalThis.fet
   const refs = await readJsonFile(refsPath);
   const environment = await maybeReadJsonFile(readFlag(flags, 'environment-json'));
   const operatorAcceptance = await maybeReadJsonFile(readFlag(flags, 'operator-acceptance-json'));
+  const runtimeCapability = await maybeReadJsonFile(readFlag(flags, 'runtime-capability-json'));
+  const authenticatedDataPlane = await maybeReadJsonFile(readFlag(flags, 'authenticated-data-plane-json'));
   const selectedFetchImpl = flags.get('local-simulation-loopback') === true ? localSimulationLoopbackFetch : fetchImpl;
   const collection = await collectHostedBackendLiveEvidence({
     relayBaseUrl: readFlag(flags, 'relay-url'),
@@ -274,7 +308,10 @@ async function runCli(argv = process.argv.slice(2), { fetchImpl = globalThis.fet
     operatorPacketRef: readFlag(flags, 'operator-packet-ref'),
     operatorApprovedAt: readFlag(flags, 'operator-approved-at'),
     operatorApprovedBy: readFlag(flags, 'operator-approved-by'),
+    runtimeCapability,
+    authenticatedDataPlane,
     observed_at: readFlag(flags, 'observed-at') ?? new Date().toISOString(),
+    localSimulation: flags.get('local-simulation-loopback') === true,
     fetchImpl: selectedFetchImpl,
   });
   const collectionJson = `${JSON.stringify(collection, null, 2)}\n`;

package/scripts/install-enigma-local.mjs

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'node:url';
 export const INSTALLER_SCHEMA = 'enigma.local_installer.v1';
 export const REQUIRED_NODE_MAJOR = 24;
 export const DEFAULT_BUNDLE_PATH = '.enigma/bundle.json';
+export const DEFAULT_PASSPHRASE_FILE = '.enigma/passphrase';
 
 const execFileAsync = promisify(execFile);
 const SCRIPT_PATH = fileURLToPath(import.meta.url);
@@ -21,7 +22,7 @@ function readRequiredValue(argv, index, flag) {
 }
 
 export function usage() {
-  return `Usage: node scripts/install-enigma-local.mjs [--dry-run|--execute] [--init-vault] [--bundle <path>]\n\nDry-run is the default. Execute mode runs npm install -g . from the local checkout.\nNo network download command is generated, and vault initialization runs only when --init-vault is present.\n`;
+  return `Usage: node scripts/install-enigma-local.mjs [--dry-run|--execute] [--init-vault] [--bundle <path>] [--passphrase-file <path>]\n\nDry-run is the default. Execute mode runs npm install -g . from the local checkout.\nVault initialization is encrypted and runs only when --init-vault is present; create the passphrase file through an approved secret manager or secure editor before execute mode.\nNo network download command is generated.\n`;
 }
 
 export function parseInstallerArgs(argv = process.argv.slice(2)) {
@@ -30,6 +31,7 @@ export function parseInstallerArgs(argv = process.argv.slice(2)) {
     execute: false,
     initVault: false,
     bundlePath: DEFAULT_BUNDLE_PATH,
+    passphraseFile: DEFAULT_PASSPHRASE_FILE,
     packageDir: DEFAULT_PACKAGE_DIR,
     subject: 'local-user',
     displayName: 'Local user',
@@ -56,6 +58,9 @@ export function parseInstallerArgs(argv = process.argv.slice(2)) {
     } else if (arg === '--bundle') {
       options.bundlePath = readRequiredValue(argv, index, arg);
       index += 1;
+    } else if (arg === '--passphrase-file') {
+      options.passphraseFile = readRequiredValue(argv, index, arg);
+      index += 1;
     } else if (arg === '--package-dir') {
       options.packageDir = readRequiredValue(argv, index, arg);
       index += 1;
@@ -114,8 +119,10 @@ export function validateCommandSpec(spec) {
 
   if (command === 'enigma' || command === 'enigma.cmd') {
     const bundleIndex = args.indexOf('--bundle');
-    if (args[0] !== 'init' || bundleIndex === -1 || bundleIndex + 1 >= args.length) {
-      throw new Error('Installer Enigma command must initialize a bundle with --bundle.');
+    const passphraseIndex = args.indexOf('--passphrase-file');
+    if (args[0] !== 'init' || bundleIndex === -1 || bundleIndex + 1 >= args.length
+      || passphraseIndex === -1 || passphraseIndex + 1 >= args.length) {
+      throw new Error('Installer Enigma command must initialize a bundle with --bundle and --passphrase-file.');
     }
     return true;
   }
@@ -125,7 +132,7 @@ export function validateCommandSpec(spec) {
 
 function publicCommand(command) {
   if (command.step === 'install_package') return { command: 'npm', args: ['install', '-g', '.'] };
-  return { command: 'enigma', args: ['init', '--bundle', '<bundle-path>', '--subject', '<subject>', '--display-name', '<display-name>'] };
+  return { command: 'enigma', args: ['init', '--bundle', '<bundle-path>', '--passphrase-file', '<passphrase-file>', '--subject', '<subject>', '--display-name', '<display-name>'] };
 }
 
 export function buildInstallerPlan(options = {}, runtime = {}) {
@@ -137,6 +144,9 @@ export function buildInstallerPlan(options = {}, runtime = {}) {
   const requestedBundlePath = String(options.bundlePath ?? DEFAULT_BUNDLE_PATH);
   rejectUnsafeArg(requestedBundlePath, 'Bundle path');
   const bundlePath = isAbsolute(requestedBundlePath) ? resolvePath(requestedBundlePath) : resolvePath(cwd, requestedBundlePath);
+  const requestedPassphraseFile = String(options.passphraseFile ?? DEFAULT_PASSPHRASE_FILE);
+  rejectUnsafeArg(requestedPassphraseFile, 'Passphrase file');
+  const passphraseFile = isAbsolute(requestedPassphraseFile) ? resolvePath(requestedPassphraseFile) : resolvePath(cwd, requestedPassphraseFile);
 
   const commands = [
     {
@@ -152,7 +162,7 @@ export function buildInstallerPlan(options = {}, runtime = {}) {
     commands.push({
       step: 'initialize_vault',
       command: commandForPlatform('enigma', platform),
-      args: ['init', '--bundle', bundlePath, '--subject', String(options.subject ?? 'local-user'), '--display-name', String(options.displayName ?? 'Local user')],
+      args: ['init', '--bundle', bundlePath, '--passphrase-file', passphraseFile, '--subject', String(options.subject ?? 'local-user'), '--display-name', String(options.displayName ?? 'Local user')],
       cwd: packageDir,
       mutates_local_filesystem: true,
     });
@@ -166,6 +176,7 @@ export function buildInstallerPlan(options = {}, runtime = {}) {
     packageDir,
     bundlePath,
     bundlePathKind: requestedBundlePath === DEFAULT_BUNDLE_PATH ? 'default' : (isAbsolute(requestedBundlePath) ? 'absolute' : 'relative'),
+    passphraseFile,
     initVault: options.initVault === true,
     commands,
   };
@@ -205,6 +216,8 @@ function publicOutput(plan, node, commandResults = []) {
       path_kind: plan.bundlePathKind,
       initialize_requested: plan.initVault,
       initialized: plan.execute && plan.initVault && resultByStep.get('initialize_vault')?.ok === true,
+      encrypted: plan.initVault,
+      credential_source: plan.initVault ? 'passphrase_file' : null,
     },
     commands,
     preview: {

package/scripts/release-audit.mjs

@@ -58,6 +58,14 @@ const SHA256_PREFIXED_DIGEST = /^sha256:[0-9a-f]{64}$/;
 const PRIVATE_PUBLIC_SITE_COLLATERAL_PATH = /(?:^|\/)(?:private|internal|launch-code|investor|token(?:omics)?|sales|marketing|funnel|community|social|adoption|objections|faq|whitepaper)[^/]*\.(?:md|html|json)$/i;
 const LOCAL_BUNDLE_LOG_OR_SECRET_PATH = /(?:^|\/)(?:\.env(?:\.|$)|env\.local$|secrets?|credentials?|tokens?|api[-_]?keys?|private[-_]?keys?|\.enigma|enigma[-_]?bundle|vault[-_]?bundle|bundle\.json|logs?|npm-debug\.log|yarn-error\.log|pnpm-debug\.log)(?:\/|$|[._-])/i;
 const PRIVATE_REVIEW_PACKET_COLLATERAL_PATH = /(?:^|\/)(?:\d+[_-])?(?:private|internal|launch-code|executive|investor|partner|sales|marketing|funnel|community|social|adoption|objections|faq|pitch|demo[-_]?scripts?|content[-_]?calendar|brand[-_]?messaging)[^/]*\.(?:html|json|md|txt)$/i;
+const PINNED_MODEL_ARTIFACT_PATHS = new Set([
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/config.json',
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/tokenizer.json',
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/tokenizer_config.json',
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/onnx/model_quantized.onnx',
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/sha256-manifest.json',
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/THIRD_PARTY_LICENSES.txt',
+]);
 const RAW_MEMORY_EXAMPLE_FIELD = /"(?:raw_memory|plaintext|prompt|response|memory)"\s*:\s*"[^"]+"/i;
 const NATIVE_HOST_MANIFEST_SMOKES = Object.freeze([
   {
@@ -123,8 +131,6 @@ const WHITEPAPER_CLAIMS_VALIDATOR_SCRIPT = resolve(PROJECT_ROOT, 'scripts', 'val
 const PRODUCTION_DEPENDENCY_REPORT_SCRIPT = resolve(PROJECT_ROOT, 'scripts', 'build-production-dependency-report.mjs');
 const PRODUCTION_WORKPLAN_SCRIPT = resolve(PROJECT_ROOT, 'scripts', 'build-production-workplan.mjs');
 const PRODUCTION_STATUS_BOARD_SCRIPT = resolve(PROJECT_ROOT, 'scripts', 'build-production-status-board.mjs');
-const AI_ORCHESTRATION_PLAN_SCHEMA = 'enigma.ai_orchestration_plan.v1';
-const AI_ORCHESTRATION_PLAN_SCRIPT = resolve(PROJECT_ROOT, 'scripts', 'build-ai-orchestration-plan.mjs');
 const CLOUDFLARE_WORKER_INSPECT_VALIDATOR_SCRIPT = resolve(PROJECT_ROOT, 'scripts', 'validate-cloudflare-worker-inspect.mjs');
 const CLOUDFLARE_CREDENTIALS_VALIDATOR_SCRIPT = resolve(PROJECT_ROOT, 'scripts', 'validate-cloudflare-credentials.mjs');
 const CLOUDFLARE_WORKER_INSPECT_CURRENT = resolve(PROJECT_ROOT, '.enigma', 'worker-inspect-current.json');
@@ -337,8 +343,9 @@ function isSha256PrefixedDigest(value) {
 function isSafeReleaseProvenancePath(value) {
   return typeof value === 'string'
     && value.length > 0
-    && !PRIVATE_PUBLIC_SITE_COLLATERAL_PATH.test(value)
-    && !LOCAL_BUNDLE_LOG_OR_SECRET_PATH.test(value);
+    && (PINNED_MODEL_ARTIFACT_PATHS.has(value)
+      || (!PRIVATE_PUBLIC_SITE_COLLATERAL_PATH.test(value)
+        && !LOCAL_BUNDLE_LOG_OR_SECRET_PATH.test(value)));
 }
 
 function isSafeReviewPacketPath(value) {
@@ -1724,6 +1731,7 @@ function hostedBackendLiveFixture() {
       region: 'us-central',
       owner: 'operator',
       status: 'verified',
+      local_simulation: false,
     },
     refs,
     probes: {
@@ -1732,6 +1740,57 @@ function hostedBackendLiveFixture() {
       gateway_livez: { url: 'https://gateway.enigmamemory.com/livez', status_code: 200, body: { ok: true, service: 'enigma-gateway' }, observed_at: '2026-06-24T00:00:00.000Z', response_hash: responseHash },
       gateway_readyz: { url: 'https://gateway.enigmamemory.com/readyz', status_code: 200, body: readyBody('enigma-gateway'), observed_at: '2026-06-24T00:00:00.000Z', response_hash: responseHash },
     },
+    runtime_capability: {
+      schema: 'enigma.hosted_backend_runtime_capability.v1',
+      marker: 'enigma.private_data_plane.runtime.v1',
+      observed_at: '2026-06-24T00:00:00.000Z',
+      services: {
+        relay: {
+          service: 'enigma-relay',
+          private_data_plane_operational: true,
+          authentication_enforced: true,
+          bootstrap_worker: false,
+          evidence_ref: 'runtime://enigma-relay/release-audit-fixture',
+        },
+        gateway: {
+          service: 'enigma-gateway',
+          private_data_plane_operational: true,
+          authentication_enforced: true,
+          bootstrap_worker: false,
+          evidence_ref: 'runtime://enigma-gateway/release-audit-fixture',
+        },
+      },
+    },
+    authenticated_data_plane: {
+      schema: 'enigma.hosted_backend_authenticated_data_plane.v1',
+      observed_at: '2026-06-24T00:00:00.000Z',
+      proofs: {
+        relay: {
+          service: 'enigma-relay',
+          url: 'https://relay.enigmamemory.com/pairing/complete',
+          method: 'POST',
+          status_code: 200,
+          authenticated: true,
+          authorization_result: 'allowed',
+          observed_at: '2026-06-24T00:00:00.000Z',
+          request_hash: responseHash,
+          response_hash: responseHash,
+          evidence_ref: 'data-plane://enigma-relay/release-audit-fixture',
+        },
+        gateway: {
+          service: 'enigma-gateway',
+          url: 'https://gateway.enigmamemory.com/gateway/decision',
+          method: 'POST',
+          status_code: 200,
+          authenticated: true,
+          authorization_result: 'allowed',
+          observed_at: '2026-06-24T00:00:00.000Z',
+          request_hash: responseHash,
+          response_hash: responseHash,
+          evidence_ref: 'data-plane://enigma-gateway/release-audit-fixture',
+        },
+      },
+    },
     operator_acceptance: {
       decision: 'go',
       packet_ref: 'operator-acceptance-release-audit#fixture',
@@ -1797,6 +1856,8 @@ export async function runHostedBackendLiveValidatorGate() {
       refs_missing: parsed.checked?.refs_missing ?? null,
       probes_covered: parsed.checked?.probes_covered ?? null,
       operator_decision: parsed.checked?.operator_decision ?? null,
+      runtime_services_covered: parsed.checked?.runtime_services_covered ?? null,
+      authenticated_data_plane_proofs_covered: parsed.checked?.authenticated_data_plane_proofs_covered ?? null,
     };
   } catch (error) {
     gate.ok = false;
@@ -2827,110 +2888,6 @@ export async function runProductionStatusBoardGate() {
   return gate;
 }
 
-export async function runAiOrchestrationPlanGate() {
-  const started = Date.now();
-  const tempDir = await mkdtemp(join(tmpdir(), 'enigma-ai-orchestration-audit-'));
-  const gate = {
-    name: 'ai-orchestration-plan',
-    required: false,
-    command: commandLabel(process.execPath, ['scripts/build-ai-orchestration-plan.mjs', '--status-board', '<production-status-board.json>']),
-    ok: true,
-    status: null,
-    signal: null,
-    duration_ms: 0,
-    evidence: {},
-  };
-  try {
-    if (!(await pathExists(PRODUCTION_WORKPLAN_SCRIPT)) || !(await pathExists(PRODUCTION_STATUS_BOARD_SCRIPT)) || !(await pathExists(AI_ORCHESTRATION_PLAN_SCRIPT))) {
-      gate.evidence = {
-        skipped: true,
-        reason: 'AI orchestration plan builder or its production fixture builders are absent in this local checkout.',
-      };
-      return gate;
-    }
-    const files = await writeProductionStatusBoardFixtureFiles(tempDir);
-    const statusBoard = parseJson(await readFile(files.statusBoard, 'utf8'));
-    if (statusBoard.schema !== 'enigma.production_status_board.v1') throw new Error('AI orchestration fixture status board emitted wrong schema.');
-    if (statusBoard.fresh_input_evidence !== true || statusBoard.input_freshness?.stale !== false) throw new Error('AI orchestration fixture status board must provide fresh input evidence.');
-    if (statusBoard.launch_ready === true) throw new Error('AI orchestration fixture status board must remain blocked.');
-    const { stdout, stderr, status } = await execFile(process.execPath, [
-      'scripts/build-ai-orchestration-plan.mjs',
-      '--status-board',
-      files.statusBoard,
-    ], {
-      cwd: PROJECT_ROOT,
-      env: localOnlyEnv(),
-      timeout: COMMAND_TIMEOUT_MS,
-      maxBuffer: MAX_OUTPUT_BYTES,
-      windowsHide: true,
-    }).then((result) => ({ ...result, status: 0 })).catch((error) => {
-      if (Number.isInteger(error.code) && error.code === 1 && typeof error.stdout === 'string') return { stdout: error.stdout, stderr: error.stderr ?? '', status: 1 };
-      throw error;
-    });
-    gate.status = status;
-    gate.stderr_bytes = Buffer.byteLength(stderr);
-    gate.stdout_bytes = Buffer.byteLength(stdout);
-    if (status !== 1) throw new Error('AI orchestration plan blocked fixture must exit with status 1.');
-    const output = `${stdout}\n${stderr}`;
-    const tempPathNeedles = [tempDir, tempDir.replaceAll('\\', '\\\\'), tempDir.replaceAll('\\', '/')];
-    if (tempPathNeedles.some((needle) => output.toLowerCase().includes(needle.toLowerCase()))) throw new Error('AI orchestration plan output leaked a temporary fixture path.');
-    if (SECRET_LOOKING_OUTPUT.test(output)) throw new Error('AI orchestration plan output appears to contain a secret.');
-    if (output.includes(RAW_MEMORY_SENTINEL)) throw new Error('AI orchestration plan output leaked raw memory sentinel text.');
-    const parsed = parseJson(stdout);
-    if (parsed.schema !== AI_ORCHESTRATION_PLAN_SCHEMA) throw new Error('AI orchestration plan emitted wrong schema.');
-    if (parsed.status !== 'blocked' || parsed.launch_ready !== false) throw new Error('AI orchestration plan must remain blocked while status board launch_ready is false.');
-    if (parsed.source_status_fresh_input_evidence !== true) throw new Error('AI orchestration plan must preserve fresh source status evidence.');
-    if (parsed.source_status_board_generated_at !== statusBoard.generated_at) throw new Error('AI orchestration plan source timestamp must match the fixture status board.');
-    if (!Array.isArray(parsed.lanes) || parsed.lanes.length !== parsed.role_lane_count || parsed.role_lane_count < 5) throw new Error('AI orchestration plan role_lane_count does not match lanes.');
-    if (!Array.isArray(parsed.waves) || parsed.waves.length !== parsed.wave_count || parsed.wave_count !== 4) throw new Error('AI orchestration plan wave_count does not match waves.');
-    const laneIds = new Set(parsed.lanes.map((lane) => lane?.id));
-    if (!laneIds.has('kimi_coding') || !laneIds.has('gpt55_architecture') || !laneIds.has('gpt55_review')) throw new Error('AI orchestration plan must include Kimi and GPT lane names.');
-    const controlText = Array.isArray(parsed.non_delegable_controls) ? parsed.non_delegable_controls.join('\n') : '';
-    if (!/Cloudflare token values/i.test(controlText) || !/human-controlled/i.test(controlText) || !/No AI lane may mark the goal complete/i.test(controlText)) throw new Error('AI orchestration plan must preserve non-delegable human control boundaries.');
-    const claimBoundary = requireJsonField(
-      parsed,
-      ['claim_boundary'],
-      (value) => Array.isArray(value) && value.length >= 3 && value.every((item) => typeof item === 'string'),
-      'AI orchestration plan must emit claim_boundary strings.',
-    );
-    const claimText = claimBoundary.join('\n');
-    if (!/does not invoke external AI systems/i.test(claimText) || !/not proof that an external model/i.test(claimText) || !/Launch readiness remains false/i.test(claimText)) throw new Error('AI orchestration plan claim boundary must prevent overclaiming launch readiness or model execution.');
-    gate.evidence = {
-      schema: parsed.schema,
-      status: parsed.status,
-      launch_ready: parsed.launch_ready === true,
-      source_status_fresh_input_evidence: parsed.source_status_fresh_input_evidence === true,
-      source_status_board_generated_at: parsed.source_status_board_generated_at,
-      role_lane_count: parsed.role_lane_count,
-      wave_count: parsed.wave_count,
-      kimi_lane_present: laneIds.has('kimi_coding'),
-      gpt_architecture_lane_present: laneIds.has('gpt55_architecture'),
-      gpt_review_lane_present: laneIds.has('gpt55_review'),
-      non_delegable_control_count: Array.isArray(parsed.non_delegable_controls) ? parsed.non_delegable_controls.length : null,
-      claim_boundary_count: claimBoundary.length,
-      temp_path_leaked: false,
-    };
-  } catch (error) {
-    gate.ok = false;
-    gate.status = Number.isInteger(error.code) ? error.code : (gate.status ?? 1);
-    gate.signal = error.signal ?? null;
-    gate.stderr_bytes = Buffer.byteLength(error.stderr ?? '');
-    gate.stdout_bytes = Buffer.byteLength(error.stdout ?? '');
-    const tempPathNeedles = [tempDir, tempDir.replaceAll('\\', '\\\\'), tempDir.replaceAll('\\', '/')];
-    let message = scrubLocalPathText(error instanceof Error ? error.message : String(error));
-    for (const needle of tempPathNeedles) message = replaceInsensitive(message, needle, '<temp-fixture>');
-    if (SECRET_LOOKING_OUTPUT.test(message)) message = 'AI orchestration plan failed with secret-looking output redacted.';
-    if (message.includes(RAW_MEMORY_SENTINEL)) message = 'AI orchestration plan failed with raw-memory sentinel output redacted.';
-    gate.error = {
-      code: error.killed ? 'COMMAND_TIMEOUT' : (error.code ?? 'AI_ORCHESTRATION_PLAN_FAILED'),
-      message,
-    };
-  } finally {
-    await rm(tempDir, { recursive: true, force: true });
-    gate.duration_ms = Date.now() - started;
-  }
-  return gate;
-}
 
 function validateCloudflareOpsHelp(stdout) {
   const text = String(stdout);
@@ -5586,7 +5543,6 @@ export async function runReleaseAudit() {
   gates.push(await runProductionDependencyReportGate());
   gates.push(await runProductionWorkplanGate());
   gates.push(await runProductionStatusBoardGate());
-  gates.push(await runAiOrchestrationPlanGate());
   gates.push(await runProductionManifestValidatorGate());
   gates.push(await runProductionManifestSafetyGate());
   gates.push(await runInfrastructureReadinessGate());

package/scripts/release-provenance.mjs

@@ -21,6 +21,12 @@ const PUBLIC_SITE_MANIFEST_CANDIDATES = Object.freeze([
 ]);
 const KNOWN_SAFE_PATHS = new Set([
   'scripts/scan-secrets.mjs',
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/config.json',
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/tokenizer.json',
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/tokenizer_config.json',
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/onnx/model_quantized.onnx',
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/sha256-manifest.json',
+  'packages/rag/models/Xenova/all-MiniLM-L6-v2/THIRD_PARTY_LICENSES.txt',
 ]);