enigma-memory 0.1.18 → 0.1.22

package/packages/enigma-weave/src/index.js

@@ -0,0 +1,286 @@
+import { randomUUID } from 'node:crypto';
+
+export const ENIGMA_WEAVE_VERSION = '1.0.0';
+export const WEAVE_POLICIES = Object.freeze({
+  lean: Object.freeze({ maxCalls: 1, maxLatencyMs: 45_000 }),
+  balanced: Object.freeze({ maxCalls: 2, maxLatencyMs: 60_000 }),
+  strict: Object.freeze({ maxCalls: 3, maxLatencyMs: 120_000 }),
+});
+export const WEAVE_PIPELINES = Object.freeze({
+  general: Object.freeze({ name: 'general', direct: 'Answer directly and completely. Keep the result proportionate to the request.' }),
+  research: Object.freeze({ name: 'research', direct: 'Return a complete research synthesis separating evidence, inference, unknowns, and implications.' }),
+  'code-review': Object.freeze({ name: 'code-review', direct: 'Return a senior engineering review with concrete failure modes, fixes, and regression checks.' }),
+});
+
+function positiveInteger(value, fallback, field) {
+  const candidate = value === undefined ? fallback : value;
+  if (!Number.isInteger(candidate) || candidate <= 0) throw new TypeError(`${field} must be a positive integer`);
+  return candidate;
+}
+
+function nonNegativeNumber(value, fallback, field) {
+  const candidate = value === undefined ? fallback : value;
+  if (!Number.isFinite(candidate) || candidate < 0) throw new TypeError(`${field} must be a non-negative number`);
+  return candidate;
+}
+
+function normalizeWorker(worker, index) {
+  if (!worker || typeof worker !== 'object') throw new TypeError(`worker ${index} must be an object`);
+  const id = String(worker.id || '').trim();
+  const model = String(worker.model || '').trim();
+  if (!id || !model) throw new TypeError(`worker ${index} requires id and model`);
+  return Object.freeze({
+    id,
+    model,
+    role: String(worker.role || id),
+    estimatedCredits: nonNegativeNumber(worker.estimatedCredits, 0, `worker ${id} estimatedCredits`),
+    retentionPolicy: String(worker.retentionPolicy || 'unknown'),
+    retentionEvidence: worker.retentionEvidence || null,
+  });
+}
+
+function pickWorker(workers, preferredRoles) {
+  for (const role of preferredRoles) {
+    const match = workers.find((worker) => worker.role === role || worker.id === role);
+    if (match) return match;
+  }
+  if (!workers[0]) throw new Error('Enigma Weave has no workers');
+  return workers[0];
+}
+
+export function assessWeaveTask(input, pipelineName = 'general') {
+  const text = `${pipelineName}\n${input}`.toLowerCase();
+  const signals = [
+    ['security', /\b(security|vulnerab|exploit|attack|ssrf|xss|csrf|injection|secret|credential)\b/],
+    ['identity', /\b(auth|authorization|permission|tenant|access control|token|session)\b/],
+    ['money', /\b(billing|payment|credit|wallet|spend|refund|invoice|double-spend)\b/],
+    ['privacy', /\b(privacy|pii|personal data|retention|redact|data leak)\b/],
+    ['concurrency', /\b(race|concurren|idempot|replay|transaction|atomic)\b/],
+    ['production-code', /\b(api|database|migration|deploy|production|code review|github|repo)\b/],
+  ].filter(([, expression]) => expression.test(text)).map(([signal]) => signal);
+  const research = pipelineName === 'research' || /\b(research|paper|benchmark|evidence|study|compare)\b/.test(text);
+  const codeReview = pipelineName === 'code-review' || signals.length > 0;
+  const simple = input.length < 180 && pipelineName === 'general'
+    && /^(name|list|say|give|what is|what's|define|translate|explain in one|one|short)\b/i.test(input.trim())
+    && !/\b(review|audit|investigate|compare|debug|implement|patch|design)\b/i.test(input);
+  if (codeReview) return { kind: 'code-review', complexity: 'high', risk: 'high', riskSignals: signals };
+  if (research) return { kind: 'research', complexity: 'medium', risk: 'medium', riskSignals: signals };
+  if (simple || input.length < 180) return { kind: 'general', complexity: 'low', risk: 'low', riskSignals: signals };
+  return { kind: 'general', complexity: 'medium', risk: 'medium', riskSignals: signals };
+}
+
+export function resolveWeaveLimits(input = {}) {
+  const policy = String(input.policy || 'balanced').toLowerCase();
+  const defaults = WEAVE_POLICIES[policy];
+  if (!defaults) throw new TypeError('policy must be lean, balanced, or strict');
+  const maxCalls = positiveInteger(input.maxCalls, defaults.maxCalls, 'maxCalls');
+  const maxLatencyMs = positiveInteger(input.maxLatencyMs, defaults.maxLatencyMs, 'maxLatencyMs');
+  const maxCredits = input.maxCredits === undefined ? null : nonNegativeNumber(input.maxCredits, 0, 'maxCredits');
+  return Object.freeze({ policy, maxCalls, maxLatencyMs, maxCredits });
+}
+
+function buildPlan(profile, policy, workers, pipeline) {
+  const directWorker = profile.kind === 'general'
+    ? pickWorker(workers, ['finalizer', 'drafter', 'critic'])
+    : pickWorker(workers, ['drafter', 'finalizer', 'critic']);
+  const steps = [{ id: 'direct', role: 'drafter', worker: directWorker, access: [], instruction: pipeline.direct }];
+  if (policy === 'lean') return steps;
+  const critic = pickWorker(workers, ['critic', 'finalizer', 'drafter']);
+  if (policy === 'balanced') {
+    steps.push({
+      id: 'verify',
+      role: 'editor',
+      worker: critic,
+      access: ['direct'],
+      instruction: 'Audit the direct answer for critical omissions or unsupported claims, then return the complete corrected final answer.',
+    });
+    return steps;
+  }
+  const finalizer = pickWorker(workers, ['finalizer', 'drafter', 'critic']);
+  steps.push(
+    { id: 'verify', role: 'critic', worker: critic, access: ['direct'], instruction: 'Adversarially audit the direct answer. Identify concrete errors, missing risks, and missing checks.' },
+    { id: 'final', role: 'finalizer', worker: finalizer, access: ['direct', 'verify'], instruction: 'Return the complete final answer, incorporating only valid verifier findings and removing weak claims.' },
+  );
+  return steps;
+}
+
+function shouldEscalate(input, profile, answer, policy) {
+  if (policy === 'lean') return false;
+  if (policy === 'strict' || profile.risk === 'high' || profile.kind === 'research') return true;
+  if (profile.risk === 'medium' && /\b(review|audit|investigate|research|compare|verify|debug|design)\b/i.test(input)) return true;
+  const text = String(answer || '').trim();
+  return !text || /^\s*(i can't|i cannot|sorry|unable to)/i.test(text);
+}
+
+function retentionDisclosure(trace) {
+  const routes = trace.map((item) => ({
+    step: item.id,
+    worker: item.workerId,
+    model: item.model,
+    retentionPolicy: item.retentionPolicy,
+    retentionEvidence: item.retentionEvidence,
+    status: item.status,
+  }));
+  const policies = new Set(routes.map((route) => route.retentionPolicy || 'unknown'));
+  return {
+    policy: policies.has('unknown') ? 'unknown' : policies.size === 1 ? [...policies][0] : 'mixed',
+    routes,
+  };
+}
+
+function publicPlan(steps) {
+  return steps.map((step) => ({ id: step.id, role: step.role, workerId: step.worker.id, model: step.worker.model, access: step.access }));
+}
+
+export function createEnigmaWeave(options = {}) {
+  if (typeof options.complete !== 'function') throw new TypeError('createEnigmaWeave requires complete(worker, request)');
+  const workers = (options.workers || []).map(normalizeWorker);
+  if (!workers.length) throw new TypeError('createEnigmaWeave requires workers');
+
+  return Object.freeze({
+    workers,
+    async run(input, runOptions = {}) {
+      if (typeof input !== 'string' || !input.trim()) throw new TypeError('input must be a non-empty string');
+      const pipeline = WEAVE_PIPELINES[runOptions.pipeline || 'general'];
+      if (!pipeline) throw new TypeError(`unknown pipeline: ${runOptions.pipeline}`);
+      const limits = resolveWeaveLimits(runOptions);
+      const profile = assessWeaveTask(input, pipeline.name);
+      const planned = buildPlan(profile, limits.policy, workers, pipeline);
+      const outputs = new Map();
+      const trace = [];
+      const startedAt = Date.now();
+      let estimatedCredits = 0;
+      let stopReason = null;
+      let limited = false;
+      runOptions.onEvent?.({ type: 'plan', pipeline: pipeline.name, policy: limits.policy, steps: publicPlan(planned), profile });
+
+      for (const step of planned) {
+        if (trace.length >= limits.maxCalls) { limited = true; stopReason = 'max-calls-reached'; break; }
+        if (Date.now() - startedAt >= limits.maxLatencyMs) { limited = true; stopReason = 'max-latency-reached'; break; }
+        if (limits.maxCredits !== null && estimatedCredits + step.worker.estimatedCredits > limits.maxCredits) {
+          limited = true;
+          stopReason = 'max-credits-reached';
+          break;
+        }
+        const accessed = Object.fromEntries(step.access.map((id) => [id, outputs.get(id)]));
+        const messages = [
+          { role: 'system', content: step.instruction },
+          { role: 'user', content: input },
+          ...(Object.keys(accessed).length ? [{ role: 'user', content: `Prior step outputs:\n${JSON.stringify(accessed)}` }] : []),
+        ];
+        const stepStartedAt = Date.now();
+        runOptions.onEvent?.({ type: 'step.started', id: step.id, workerId: step.worker.id, model: step.worker.model });
+        let result;
+        try {
+          result = await options.complete(step.worker, { messages, input, step: { id: step.id, role: step.role }, signal: runOptions.signal });
+          if (!result || typeof result.answer !== 'string') throw new Error(`worker ${step.worker.id} returned no answer`);
+          outputs.set(step.id, result.answer);
+          estimatedCredits += step.worker.estimatedCredits;
+          trace.push({
+            id: step.id,
+            workerId: step.worker.id,
+            model: step.worker.model,
+            status: 'succeeded',
+            elapsedMs: Date.now() - stepStartedAt,
+            usage: result.usage || null,
+            spentCredits: Number(result.spentCredits || 0),
+            retentionPolicy: result.retentionPolicy || step.worker.retentionPolicy,
+            retentionEvidence: result.retentionEvidence || step.worker.retentionEvidence,
+          });
+          runOptions.onEvent?.({ type: 'step.done', id: step.id, workerId: step.worker.id });
+        } catch (error) {
+          trace.push({
+            id: step.id,
+            workerId: step.worker.id,
+            model: step.worker.model,
+            status: 'failed',
+            elapsedMs: Date.now() - stepStartedAt,
+            usage: null,
+            spentCredits: 0,
+            retentionPolicy: step.worker.retentionPolicy,
+            retentionEvidence: step.worker.retentionEvidence,
+            error: error.code || 'worker_failed',
+          });
+          runOptions.onEvent?.({ type: 'step.failed', id: step.id, workerId: step.worker.id, code: error.code || 'worker_failed' });
+          if (step.id === 'direct') throw error;
+          break;
+        }
+        if (step.id === 'direct' && !shouldEscalate(input, profile, result.answer, limits.policy)) {
+          stopReason = 'direct-answer-accepted';
+          break;
+        }
+      }
+
+      const answer = outputs.get('final') || outputs.get('verify') || outputs.get('direct') || '';
+      const usage = trace.reduce((sum, item) => {
+        sum.promptTokens += Number(item.usage?.prompt_tokens || item.usage?.input_tokens || 0);
+        sum.completionTokens += Number(item.usage?.completion_tokens || item.usage?.output_tokens || 0);
+        sum.totalTokens += Number(item.usage?.total_tokens || 0);
+        sum.spentCredits += item.spentCredits;
+        return sum;
+      }, { promptTokens: 0, completionTokens: 0, totalTokens: 0, spentCredits: 0 });
+      const retention = retentionDisclosure(trace);
+      return {
+        pipeline: `${pipeline.name}:enigma-weave-${limits.policy}`,
+        answer,
+        trace,
+        metrics: { calls: trace.length, elapsedMs: Date.now() - startedAt, ...usage },
+        workflow: {
+          schema: 'enigma.weave_workflow.v1',
+          mode: 'adaptive',
+          policy: limits.policy,
+          router: 'local-policy',
+          profile,
+          plan: publicPlan(planned).slice(0, trace.length),
+          escalated: trace.length > 1,
+          budget: { limits, used: { calls: trace.length, estimatedCredits, latencyMs: Date.now() - startedAt }, limited, stopReason },
+          retention,
+          receipt: {
+            schema: 'enigma.weave_receipt.v1',
+            receiptId: randomUUID(),
+            stepCount: trace.length,
+            callCount: trace.length,
+            spentCredits: usage.spentCredits,
+            containsPromptOrOutput: false,
+          },
+        },
+      };
+    },
+  });
+}
+
+export function fuseWeaveCandidates(candidates, options = {}) {
+  if (!Array.isArray(candidates) || !candidates.length) throw new TypeError('candidates must be a non-empty array');
+  const valid = candidates.filter((candidate) => candidate && typeof candidate.answer === 'string' && candidate.answer.trim());
+  if (!valid.length) throw new Error('no usable candidate answer');
+  const ranked = valid.map((candidate, index) => ({
+    ...candidate,
+    index,
+    score: Number(candidate.score || 0) + Math.min(candidate.answer.length, 2_000) / 2_000,
+  })).sort((a, b) => b.score - a.score || a.index - b.index);
+  return options.returnAll ? ranked : ranked[0];
+}
+
+export async function evaluateEnigmaWeave(weave, dataset, options = {}) {
+  if (!weave || typeof weave.run !== 'function') throw new TypeError('weave must expose run()');
+  if (!Array.isArray(dataset) || !dataset.length) throw new TypeError('dataset must be a non-empty array');
+  const cases = [];
+  for (const item of dataset) {
+    const id = String(item.id || `case-${cases.length + 1}`);
+    const startedAt = Date.now();
+    try {
+      const result = await weave.run(String(item.input || ''), options);
+      const passed = typeof item.validate === 'function' ? await item.validate(result.answer, result) : Boolean(result.answer);
+      cases.push({ id, passed: Boolean(passed), elapsedMs: Date.now() - startedAt, calls: result.metrics.calls, receiptId: result.workflow.receipt.receiptId });
+    } catch (error) {
+      cases.push({ id, passed: false, elapsedMs: Date.now() - startedAt, calls: 0, error: error.code || 'evaluation_failed' });
+    }
+  }
+  return {
+    schema: 'enigma.weave_evaluation.v1',
+    total: cases.length,
+    passed: cases.filter((item) => item.passed).length,
+    failed: cases.filter((item) => !item.passed).length,
+    cases,
+  };
+}

package/packages/hosted-cloud/src/index.js

@@ -209,6 +209,14 @@ function hashValue(value) {
   return `${SHA256_PREFIX}${createHash('sha256').update(JSON.stringify(canonicalize(value))).digest('hex')}`;
 }
 
+function validateContractHash(contract, name = 'contract') {
+  const actual = requiredString(contract.contract_hash, `${name}.contract_hash`);
+  const { contract_hash: _contractHash, ...canonicalFields } = contract;
+  const expected = hashValue(canonicalFields);
+  if (actual !== expected) throw new TypeError(`${name}.contract_hash must match canonical contract fields`);
+  return true;
+}
+
 function contractId(prefix, body) {
   return `${prefix}_${hashValue(body).slice(SHA256_PREFIX.length, SHA256_PREFIX.length + 24)}`;
 }
@@ -316,7 +324,7 @@ function validateBase(contract, schema) {
       throw new TypeError('readiness.external_blockers must match operator_evidence_refs');
     }
   });
-  requiredString(contract.contract_hash, 'contract_hash');
+  validateContractHash(contract);
   return true;
 }
 
@@ -670,6 +678,19 @@ function lifecycleContractSource(input, aliases) {
 function buildOrValidateLifecycleContract(phase, source) {
   if (source === undefined || source === null) return null;
   if (!isPlainObject(source)) throw new TypeError(`contracts.${phase} must be an object`);
+  if (source.schema !== undefined) {
+    const expectedSchema = {
+      account: HOSTED_CLOUD_USER_ACCOUNT_SCHEMA,
+      tenant: HOSTED_CLOUD_TENANT_SCHEMA,
+      vault: HOSTED_CLOUD_VAULT_SCHEMA,
+      api_key: HOSTED_CLOUD_API_KEY_SCHEMA,
+      billing: HOSTED_CLOUD_USAGE_BILLING_SCHEMA,
+      dashboard: HOSTED_CLOUD_DASHBOARD_SCHEMA,
+      backup: HOSTED_CLOUD_BACKUP_DRILL_SCHEMA,
+      incident_sla: HOSTED_CLOUD_INCIDENT_SLA_SCHEMA,
+    }[phase];
+    if (source.schema !== expectedSchema) throw new TypeError(`contracts.${phase}.schema must be ${expectedSchema}`);
+  }
   switch (phase) {
     case 'account':
       if (source.schema === HOSTED_CLOUD_USER_ACCOUNT_SCHEMA) {
@@ -737,6 +758,29 @@ function lifecycleContractsFrom(input) {
   };
 }
 
+function lifecycleTenantId(input, contracts) {
+  const explicitTenantId = input.tenant_id ?? input.tenantId;
+  const contractTenantIds = CUSTOMER_LIFECYCLE_CONTRACT_PHASES
+    .map((phase) => contracts[phase]?.tenant_id)
+    .filter((tenantId) => tenantId !== undefined && tenantId !== null);
+  const tenantId = requiredString(explicitTenantId ?? contractTenantIds[0], 'tenant_id');
+  for (const contractTenantId of contractTenantIds) {
+    if (requiredString(contractTenantId, 'contracts.tenant_id') !== tenantId) {
+      throw new TypeError('every tenant-bearing lifecycle contract must match packet tenant_id');
+    }
+  }
+  return tenantId;
+}
+
+function validateLifecycleTenantIdentity(contracts, tenantId) {
+  for (const phase of CUSTOMER_LIFECYCLE_CONTRACT_PHASES) {
+    const contract = contracts[phase];
+    if (contract !== null && contract.tenant_id !== tenantId) {
+      throw new TypeError(`contracts.${phase}.tenant_id must match packet tenant_id`);
+    }
+  }
+}
+
 function explicitLifecycleEvidenceRefs(input) {
   const refs = input.required_evidence_refs ?? input.requiredEvidenceRefs ?? input.lifecycle_evidence_refs ?? input.lifecycleEvidenceRefs ?? input.evidence_refs ?? input.evidenceRefs ?? input.operator_evidence_refs ?? input.operatorEvidenceRefs;
   if (refs === undefined || refs === null) return {};
@@ -1057,6 +1101,7 @@ export function buildCustomerLifecyclePacket(input = {}) {
   if (!isPlainObject(input)) throw new TypeError('buildCustomerLifecyclePacket requires an options object');
   assertNoForbiddenPayload(input, 'input');
   const contracts = lifecycleContractsFrom(input);
+  const tenantId = lifecycleTenantId(input, contracts);
   const requiredEvidenceRefs = lifecycleEvidenceRefsFrom(input, contracts);
   const operatorGoLiveRef = operatorGoLiveRefFromInput(input);
   const missingSurfaceRefs = missingLifecycleSurfaceRefs(contracts);
@@ -1065,6 +1110,7 @@ export function buildCustomerLifecyclePacket(input = {}) {
     schema: HOSTED_CLOUD_CUSTOMER_LIFECYCLE_PACKET_SCHEMA,
     packet_id: stringOrDefault(input.packet_id ?? input.packetId, undefined),
     generated_at: isoTimestamp(input.generated_at ?? input.generatedAt, 'generated_at'),
+    tenant_id: tenantId,
     contracts,
     required_evidence_refs: requiredEvidenceRefs,
     lifecycle_phases: lifecyclePhaseRows(requiredEvidenceRefs, contracts, operatorGoLiveRef),
@@ -1089,8 +1135,9 @@ export function validateCustomerLifecyclePacket(packet) {
   if (packet.schema !== HOSTED_CLOUD_CUSTOMER_LIFECYCLE_PACKET_SCHEMA) throw new TypeError(`schema must be ${HOSTED_CLOUD_CUSTOMER_LIFECYCLE_PACKET_SCHEMA}`);
   requiredString(packet.packet_id, 'packet_id');
   isoTimestamp(packet.generated_at, 'generated_at');
-  requiredString(packet.contract_hash, 'contract_hash');
+  const tenantId = requiredString(packet.tenant_id, 'tenant_id');
   validateCustomerLifecycleContracts(packet.contracts);
+  validateLifecycleTenantIdentity(packet.contracts, tenantId);
   if (!isPlainObject(packet.required_evidence_refs)) throw new TypeError('required_evidence_refs must be present');
   const requiredEvidenceRefs = validateCustomerLifecycleEvidenceRefs({ ...packet.required_evidence_refs });
   const operatorGoLiveRef = operatorGoLiveRefFromPacket(packet);
@@ -1104,6 +1151,7 @@ export function validateCustomerLifecyclePacket(packet) {
   if (packet.hosted_cloud_sellable !== expectedReadiness.hosted_cloud_sellable) throw new TypeError('hosted_cloud_sellable must match readiness.hosted_cloud_sellable');
   assertSameLifecycleObject(packet.dashboard, customerLifecycleDashboard(packet.contracts, requiredEvidenceRefs, expectedReadiness, operatorGoLiveRef), 'dashboard');
   validateCustomerLifecycleSafetyGuarantees(packet.guarantees ?? packet.public_safety_guarantees);
+  validateContractHash(packet, 'packet');
   return true;
 }
 
@@ -1179,6 +1227,9 @@ function buildOrValidateApiKeyLifecycleContract(slot, source, tenantId, subjectR
   if (source === undefined || source === null) return null;
   if (!isPlainObject(source)) throw new TypeError(`key_contracts.${slot} must be an object`);
   const name = `key_contracts.${slot}`;
+  if (source.schema !== undefined && source.schema !== HOSTED_CLOUD_API_KEY_SCHEMA) {
+    throw new TypeError(`${name}.schema must be ${HOSTED_CLOUD_API_KEY_SCHEMA}`);
+  }
   if (source.schema === HOSTED_CLOUD_API_KEY_SCHEMA) {
     validateApiKeyContract(source);
     validateApiKeyLifecycleContractTenantSubject(source, tenantId, subjectRef, name);
@@ -1493,6 +1544,7 @@ export function validateApiKeyLifecyclePacket(packet) {
   if (packet.customer_api_keys_live !== expectedReadiness.customer_api_keys_live) throw new TypeError('customer_api_keys_live must match readiness.customer_api_keys_live');
   validateApiKeyLifecycleSafetyGuarantees(packet.guarantees ?? packet.public_safety_guarantees);
   validateApiKeyLifecycleSafetyGuarantees(packet.public_safety_guarantees ?? packet.guarantees);
+  validateContractHash(packet, 'packet');
   return true;
 }
 
@@ -1756,6 +1808,22 @@ function validateReadinessEvidenceRefs(packet) {
   return requiredEvidenceRefs;
 }
 
+function readinessPacketTenantId(input, customerLifecyclePacket, apiKeyLifecyclePacket) {
+  const candidates = [
+    input.tenant_id ?? input.tenantId,
+    customerLifecyclePacket?.tenant_id,
+    apiKeyLifecyclePacket?.tenant_id,
+  ].filter((tenantId) => tenantId !== undefined && tenantId !== null);
+  if (candidates.length === 0) return null;
+  const tenantId = requiredString(candidates[0], 'tenant_id');
+  for (const candidate of candidates.slice(1)) {
+    if (requiredString(candidate, 'embedded packet tenant_id') !== tenantId) {
+      throw new TypeError('customer and API key lifecycle packets must share one tenant_id');
+    }
+  }
+  return tenantId;
+}
+
 export function buildHostedCloudReadinessPacket(input = {}) {
   if (!isPlainObject(input)) throw new TypeError('buildHostedCloudReadinessPacket requires an options object');
   assertNoForbiddenPayload(input, 'input');
@@ -1773,6 +1841,7 @@ export function buildHostedCloudReadinessPacket(input = {}) {
     lifecycleSellable = providedLifecyclePacket.hosted_cloud_sellable;
     lifecycleEvidenceRefs = providedLifecyclePacket.required_evidence_refs;
     lifecycleRef = {
+      tenant_id: providedLifecyclePacket.tenant_id,
       schema: providedLifecyclePacket.schema,
       packet_id: providedLifecyclePacket.packet_id,
       contract_hash: providedLifecyclePacket.contract_hash,
@@ -1785,12 +1854,14 @@ export function buildHostedCloudReadinessPacket(input = {}) {
     validateApiKeyLifecyclePacket(providedApiKeyPacket);
     apiKeyOperatorApprovalRef = providedApiKeyPacket.operator_approval_ref;
     apiKeyLifecycleRef = {
+      tenant_id: providedApiKeyPacket.tenant_id,
       schema: providedApiKeyPacket.schema,
       packet_id: providedApiKeyPacket.packet_id,
       contract_hash: providedApiKeyPacket.contract_hash,
       operator_approval_ref: providedApiKeyPacket.operator_approval_ref,
     };
   }
+  const tenantId = readinessPacketTenantId(input, providedLifecyclePacket, providedApiKeyPacket);
   const lifecycleExternalBlockers = (providedLifecyclePacket && isPlainObject(providedLifecyclePacket)) ? providedLifecyclePacket.external_blockers : [];
   const apiKeyExternalBlockers = (providedApiKeyPacket && isPlainObject(providedApiKeyPacket)) ? providedApiKeyPacket.external_blockers : [];
   const propagatedBlockers = [
@@ -1803,6 +1874,7 @@ export function buildHostedCloudReadinessPacket(input = {}) {
     schema: HOSTED_CLOUD_READINESS_PACKET_SCHEMA,
     readiness_id: stringOrDefault(input.readiness_id ?? input.readinessId, undefined),
     generated_at: generatedAt,
+    tenant_id: tenantId,
     customer_lifecycle_packet: lifecycleRef,
     api_key_lifecycle_packet: apiKeyLifecycleRef,
     required_evidence_refs: requiredEvidenceRefs,
@@ -1828,21 +1900,24 @@ export function validateHostedCloudReadinessPacket(packet) {
   if (packet.schema !== HOSTED_CLOUD_READINESS_PACKET_SCHEMA) throw new TypeError(`schema must be ${HOSTED_CLOUD_READINESS_PACKET_SCHEMA}`);
   requiredString(packet.readiness_id, 'readiness_id');
   isoTimestamp(packet.generated_at, 'generated_at');
-  requiredString(packet.contract_hash, 'contract_hash');
+  validateContractHash(packet, 'packet');
+  const tenantId = packet.tenant_id === null ? null : requiredString(packet.tenant_id, 'tenant_id');
   if (!Object.prototype.hasOwnProperty.call(packet, 'customer_lifecycle_packet')) throw new TypeError('customer_lifecycle_packet must be present');
   if (packet.customer_lifecycle_packet !== null) {
     if (!isPlainObject(packet.customer_lifecycle_packet)) throw new TypeError('customer_lifecycle_packet must be an object or null');
-    requiredString(packet.customer_lifecycle_packet.schema, 'customer_lifecycle_packet.schema');
+    if (packet.customer_lifecycle_packet.schema !== HOSTED_CLOUD_CUSTOMER_LIFECYCLE_PACKET_SCHEMA) throw new TypeError(`customer_lifecycle_packet.schema must be ${HOSTED_CLOUD_CUSTOMER_LIFECYCLE_PACKET_SCHEMA}`);
     requiredString(packet.customer_lifecycle_packet.packet_id, 'customer_lifecycle_packet.packet_id');
     requiredString(packet.customer_lifecycle_packet.contract_hash, 'customer_lifecycle_packet.contract_hash');
     requiredBoolean(packet.customer_lifecycle_packet.hosted_cloud_sellable, 'customer_lifecycle_packet.hosted_cloud_sellable');
+    if (requiredString(packet.customer_lifecycle_packet.tenant_id, 'customer_lifecycle_packet.tenant_id') !== tenantId) throw new TypeError('customer_lifecycle_packet.tenant_id must match readiness packet tenant_id');
   }
   if (!Object.prototype.hasOwnProperty.call(packet, 'api_key_lifecycle_packet')) throw new TypeError('api_key_lifecycle_packet must be present');
   if (packet.api_key_lifecycle_packet !== null) {
     if (!isPlainObject(packet.api_key_lifecycle_packet)) throw new TypeError('api_key_lifecycle_packet must be an object or null');
-    requiredString(packet.api_key_lifecycle_packet.schema, 'api_key_lifecycle_packet.schema');
+    if (packet.api_key_lifecycle_packet.schema !== HOSTED_CLOUD_API_KEY_LIFECYCLE_PACKET_SCHEMA) throw new TypeError(`api_key_lifecycle_packet.schema must be ${HOSTED_CLOUD_API_KEY_LIFECYCLE_PACKET_SCHEMA}`);
     requiredString(packet.api_key_lifecycle_packet.packet_id, 'api_key_lifecycle_packet.packet_id');
     requiredString(packet.api_key_lifecycle_packet.contract_hash, 'api_key_lifecycle_packet.contract_hash');
+    if (requiredString(packet.api_key_lifecycle_packet.tenant_id, 'api_key_lifecycle_packet.tenant_id') !== tenantId) throw new TypeError('api_key_lifecycle_packet.tenant_id must match readiness packet tenant_id');
     if (!Object.prototype.hasOwnProperty.call(packet.api_key_lifecycle_packet, 'operator_approval_ref')) throw new TypeError('api_key_lifecycle_packet.operator_approval_ref must be present');
     if (packet.api_key_lifecycle_packet.operator_approval_ref !== null) {
       requirePublicSafeLifecycleRef(packet.api_key_lifecycle_packet.operator_approval_ref, 'api_key_lifecycle_packet.operator_approval_ref');