@aikdna/kdna-core 0.18.0 → 0.19.0

package/src/{execution-contract-v1.js → runtime-contract.js}

@@ -2,24 +2,29 @@
 
 const crypto = require('node:crypto');
 
-const Ajv2020 = require('ajv/dist/2020');
+const JsonSchema2020 = require('ajv/dist/2020');
 const addFormats = require('ajv-formats');
 
-const { canonicalizeJcs, computeCapsuleDeliveryDigest } = require('./capsule-v2');
+const { canonicalizeJcs, computeCapsuleDeliveryDigest } = require('./runtime-capsule');
 const digestEvidenceSchema = require('../schema/digest-evidence.schema.json');
-const capsule2Schema = require('../schema/runtime-capsule-2.schema.json');
-const planSchema = require('../schema/consumption-plan-1.schema.json');
-const capabilitiesSchema = require('../schema/agent-host-capabilities-1.schema.json');
-const requestSchema = require('../schema/agent-host-2-request.schema.json');
-const receiptSchema = require('../schema/agent-host-2-receipt.schema.json');
-const traceSchema = require('../schema/judgment-trace-1.schema.json');
-
-const PLAN_DIGEST_PROFILE = 'kdna-consumption-plan-jcs-v1';
-const CAPSULE_DELIVERY_PROFILE = 'kdna-capsule-jcs-v1';
-const CAPSULE_DIGEST_PROFILE = 'kdna-capsule-digests-v1';
-const HOST_PROTOCOL = 'kdna.agent-host/2';
-const CAPSULE_VERSION = '2.0';
-const DEFAULT_CORE_CAPSULE_VERSIONS = Object.freeze(['2.0', '1.0']);
+const runtimeCapsuleSchema = require('../schema/runtime-capsule.schema.json');
+const planSchema = require('../schema/consumption-plan.schema.json');
+const capabilitiesSchema = require('../schema/agent-host-capabilities.schema.json');
+const requestSchema = require('../schema/agent-host-request.schema.json');
+const receiptSchema = require('../schema/agent-host-receipt.schema.json');
+const traceSchema = require('../schema/judgment-trace.schema.json');
+
+const PLAN_DIGEST_PROFILE = 'kdna.canonicalization.consumption-plan-jcs';
+const PLAN_DIGEST_PROFILE_VERSION = '0.1.0';
+const CAPSULE_DELIVERY_PROFILE = 'kdna.canonicalization.runtime-capsule-jcs';
+const CAPSULE_DELIVERY_PROFILE_VERSION = '0.1.0';
+const CAPSULE_DIGEST_PROFILE = 'kdna.digest-evidence';
+const HOST_PROTOCOL = 'kdna.agent-host';
+const HOST_PROTOCOL_VERSION = '0.1.0';
+const CAPSULE_CONTRACT_VERSION = '0.1.0';
+const DEFAULT_CORE_CAPSULE_CONTRACT_VERSIONS = Object.freeze([
+  CAPSULE_CONTRACT_VERSION,
+]);
 const JSON_MAX_BYTES = 2 * 1024 * 1024;
 const JSON_MAX_DEPTH = 64;
 const PRE_HOST_INTERNAL_REQUEST_ID = 'host_000000000000000000000000';
@@ -31,10 +36,10 @@ const PRE_HOST_BUDGET_ERROR = Object.freeze({
 
 let validators;
 
-class KDNAExecutionContractError extends Error {
+class KDNARuntimeContractError extends Error {
   constructor(code, message, details) {
     super(message);
-    this.name = 'KDNAExecutionContractError';
+    this.name = 'KDNARuntimeContractError';
     this.code = code;
     if (details !== undefined) this.details = details;
   }
@@ -42,11 +47,11 @@ class KDNAExecutionContractError extends Error {
 
 function schemaValidators() {
   if (validators) return validators;
-  const ajv = new Ajv2020({ allErrors: true, strict: false });
+  const ajv = new JsonSchema2020({ allErrors: true, strict: false });
   addFormats(ajv);
   for (const schema of [
     digestEvidenceSchema,
-    capsule2Schema,
+    runtimeCapsuleSchema,
     planSchema,
     capabilitiesSchema,
     requestSchema,
@@ -80,7 +85,7 @@ function invalid(code, message, details) {
 function throwInvalid(result) {
   if (result.valid) return;
   const first = result.errors[0] || {};
-  throw new KDNAExecutionContractError(
+  throw new KDNARuntimeContractError(
     result.code || 'KDNA_EXECUTION_CONTRACT_INVALID',
     first.message || 'KDNA execution contract is invalid.',
     first.details,
@@ -111,7 +116,7 @@ function jcsCharacterCount(value) {
 }
 
 function snapshotJsonValue(value) {
-  return parseExecutionContractJsonV1(canonicalizeJcs(value));
+  return parseRuntimeContractJson(canonicalizeJcs(value));
 }
 
 function validateSchema(kind, value) {
@@ -130,7 +135,7 @@ function validateSchema(kind, value) {
     ) {
       return invalid(
         'KDNA_ASSET_FILE_REQUIRED',
-        'ConsumptionPlan 1 requires a packaged .kdna Runtime asset.',
+        'ConsumptionPlan requires a packaged .kdna Runtime asset.',
         details,
       );
     }
@@ -252,14 +257,14 @@ function snapshotPublicInput(input, requiredKeys, optionalKeys = []) {
  * Duplicate member names are rejected after JSON escape decoding, so
  * {"a": 1, "\\u0061": 2} is also rejected.
  */
-function parseExecutionContractJsonV1(input, options = {}) {
+function parseRuntimeContractJson(input, options = {}) {
   if (
     options === null ||
     typeof options !== 'object' ||
     Array.isArray(options) ||
     Object.getPrototypeOf(options) !== Object.prototype
   ) {
-    throw new KDNAExecutionContractError(
+    throw new KDNARuntimeContractError(
       'KDNA_JSON_OPTIONS_INVALID',
       'Execution-contract JSON parser options must be a plain object.',
     );
@@ -274,7 +279,7 @@ function parseExecutionContractJsonV1(input, options = {}) {
         !Object.prototype.hasOwnProperty.call(descriptors[key], 'value'),
     )
   ) {
-    throw new KDNAExecutionContractError(
+    throw new KDNARuntimeContractError(
       'KDNA_JSON_OPTIONS_INVALID',
       'Execution-contract JSON parser options contain an unknown or accessor property.',
     );
@@ -289,7 +294,7 @@ function parseExecutionContractJsonV1(input, options = {}) {
     maxDepth < 1 ||
     maxDepth > JSON_MAX_DEPTH
   ) {
-    throw new KDNAExecutionContractError(
+    throw new KDNARuntimeContractError(
       'KDNA_JSON_OPTIONS_INVALID',
       `maxBytes and maxDepth must be positive safe integers no greater than ${JSON_MAX_BYTES} and ${JSON_MAX_DEPTH}.`,
     );
@@ -299,13 +304,13 @@ function parseExecutionContractJsonV1(input, options = {}) {
     text = input;
   } else if (Buffer.isBuffer(input) || input instanceof Uint8Array) {
     if (input.byteLength > maxBytes) {
-      throw new KDNAExecutionContractError(
+      throw new KDNARuntimeContractError(
         'KDNA_JSON_LIMIT_EXCEEDED',
         'Execution-contract JSON exceeds the configured byte limit.',
       );
     }
     if (input.byteLength >= 3 && input[0] === 0xef && input[1] === 0xbb && input[2] === 0xbf) {
-      throw new KDNAExecutionContractError(
+      throw new KDNARuntimeContractError(
         'KDNA_JSON_BOM_FORBIDDEN',
         'Execution-contract JSON must not begin with a UTF-8 BOM.',
       );
@@ -313,27 +318,27 @@ function parseExecutionContractJsonV1(input, options = {}) {
     try {
       text = new TextDecoder('utf-8', { fatal: true }).decode(input);
     } catch {
-      throw new KDNAExecutionContractError(
+      throw new KDNARuntimeContractError(
         'KDNA_JSON_INVALID_UNICODE',
         'Execution-contract JSON is not valid UTF-8.',
       );
     }
   } else {
-    throw new KDNAExecutionContractError(
+    throw new KDNARuntimeContractError(
       'KDNA_JSON_INPUT_INVALID',
       'Execution-contract JSON input must be a string, Buffer, or Uint8Array.',
     );
   }
 
   if (text.charCodeAt(0) === 0xfeff) {
-    throw new KDNAExecutionContractError(
+    throw new KDNARuntimeContractError(
       'KDNA_JSON_BOM_FORBIDDEN',
       'Execution-contract JSON must not begin with a BOM.',
     );
   }
 
   if (Buffer.byteLength(text, 'utf8') > maxBytes) {
-    throw new KDNAExecutionContractError(
+    throw new KDNARuntimeContractError(
       'KDNA_JSON_LIMIT_EXCEEDED',
       'Execution-contract JSON exceeds the configured byte limit.',
     );
@@ -359,7 +364,7 @@ class StrictJsonParser {
   }
 
   syntax(message) {
-    throw new KDNAExecutionContractError('KDNA_JSON_SYNTAX_INVALID', message, {
+    throw new KDNARuntimeContractError('KDNA_JSON_SYNTAX_INVALID', message, {
       code_unit_offset: this.index,
     });
   }
@@ -381,7 +386,7 @@ class StrictJsonParser {
     const char = this.text[this.index];
     if (char === '{' || char === '[') {
       if (depth >= this.maxDepth) {
-        throw new KDNAExecutionContractError(
+        throw new KDNARuntimeContractError(
           'KDNA_JSON_LIMIT_EXCEEDED',
           'Execution-contract JSON exceeds the configured nesting limit.',
         );
@@ -418,7 +423,7 @@ class StrictJsonParser {
       if (this.text[this.index] !== '"') this.syntax('Expected a quoted JSON member name.');
       const key = this.parseString();
       if (keys.has(key)) {
-        throw new KDNAExecutionContractError(
+        throw new KDNARuntimeContractError(
           'KDNA_JSON_DUPLICATE_KEY',
           `Execution-contract JSON contains duplicate member name ${JSON.stringify(key)}.`,
           { key, code_unit_offset: this.index },
@@ -529,7 +534,7 @@ class StrictJsonParser {
   }
 
   invalidUnicode() {
-    throw new KDNAExecutionContractError(
+    throw new KDNARuntimeContractError(
       'KDNA_JSON_INVALID_UNICODE',
       'Execution-contract JSON contains an unpaired UTF-16 surrogate.',
       { code_unit_offset: this.index },
@@ -544,7 +549,7 @@ class StrictJsonParser {
     this.index += token.length;
     const number = Number(token);
     if (!Number.isFinite(number)) {
-      throw new KDNAExecutionContractError(
+      throw new KDNARuntimeContractError(
         'KDNA_JSON_NUMBER_INVALID',
         'Execution-contract JSON number is outside the finite IEEE-754 range.',
       );
@@ -553,7 +558,7 @@ class StrictJsonParser {
   }
 }
 
-function computeConsumptionPlanDigestV1(plan) {
+function computeConsumptionPlanDigest(plan) {
   try {
     if (plan === null || typeof plan !== 'object' || Array.isArray(plan)) {
       throw new TypeError('plan must be an object');
@@ -562,8 +567,8 @@ function computeConsumptionPlanDigestV1(plan) {
     delete projection.integrity;
     return digestJcs(projection);
   } catch (error) {
-    if (error instanceof KDNAExecutionContractError) throw error;
-    throw new KDNAExecutionContractError(
+    if (error instanceof KDNARuntimeContractError) throw error;
+    throw new KDNARuntimeContractError(
       'KDNA_PLAN_INPUT_INVALID',
       'ConsumptionPlan digest input must be a finite, acyclic JSON object.',
       { cause: error && typeof error.message === 'string' ? error.message : String(error) },
@@ -574,7 +579,7 @@ function computeConsumptionPlanDigestV1(plan) {
 function validatePlanSemantics(plan, trustedPlanDigest) {
   let computed;
   try {
-    computed = computeConsumptionPlanDigestV1(plan);
+    computed = computeConsumptionPlanDigest(plan);
   } catch {
     return 'KDNA_PLAN_INPUT_INVALID';
   }
@@ -585,7 +590,7 @@ function validatePlanSemantics(plan, trustedPlanDigest) {
   return null;
 }
 
-function validateConsumptionPlanV1(plan, context) {
+function validateConsumptionPlan(plan, context) {
   const contextResult = snapshotContext(context, ['trustedPlanDigest']);
   if (!contextResult.valid) return contextResult;
   const safeContext = contextResult.value;
@@ -605,12 +610,12 @@ function validateConsumptionPlanV1(plan, context) {
   return code ? invalid(code, 'ConsumptionPlan integrity correlation failed.') : ok(safePlan);
 }
 
-function buildConsumptionPlanV1(input) {
+function buildConsumptionPlan(input) {
   let plan;
   try {
     plan = {
-      type: 'kdna.consumption.plan',
-      plan_version: '1.0.0',
+      type: 'kdna.consumption-plan',
+      contract_version: '0.1.0',
       plan_id: input.plan_id,
       created_at: input.created_at,
       mode: 'single',
@@ -618,26 +623,31 @@ function buildConsumptionPlanV1(input) {
       asset_ref: clone(input.asset_ref),
       projection_request: {
         profile: input.projection_profile,
-        accepted_capsule_versions: [CAPSULE_VERSION],
+        accepted_capsule_versions: [CAPSULE_CONTRACT_VERSION],
         required_digest_profile: CAPSULE_DIGEST_PROFILE,
+        required_digest_profile_version: '0.1.0',
         require_packaged_asset: true,
       },
       host_request: { accepted_protocols: [HOST_PROTOCOL] },
       result_request: { shape: 'structured_judgment' },
       budget: clone(input.budget),
       trace_policy: clone(input.trace_policy),
-      integrity: { profile: PLAN_DIGEST_PROFILE, plan_digest: '' },
+      integrity: {
+        profile: PLAN_DIGEST_PROFILE,
+        profile_version: PLAN_DIGEST_PROFILE_VERSION,
+        plan_digest: '',
+      },
       constraints: clone(input.constraints),
     };
-    plan.integrity.plan_digest = computeConsumptionPlanDigestV1(plan);
+    plan.integrity.plan_digest = computeConsumptionPlanDigest(plan);
   } catch (error) {
-    if (error instanceof KDNAExecutionContractError) throw error;
-    throw new KDNAExecutionContractError(
+    if (error instanceof KDNARuntimeContractError) throw error;
+    throw new KDNARuntimeContractError(
       'KDNA_PLAN_INPUT_INVALID',
-      'Cannot build ConsumptionPlan 1 from the supplied input.',
+      'Cannot build ConsumptionPlan from the supplied input.',
     );
   }
-  const result = validateConsumptionPlanV1(plan, {
+  const result = validateConsumptionPlan(plan, {
     trustedPlanDigest: plan.integrity.plan_digest,
   });
   throwInvalid(result);
@@ -653,7 +663,7 @@ function blocked(issueCode) {
   };
 }
 
-function negotiateExecutionPairV1(plan, context) {
+function negotiateRuntimePair(plan, context) {
   const contextResult = snapshotContext(context, [
     'trustedPlanDigest',
     'capabilities',
@@ -661,7 +671,7 @@ function negotiateExecutionPairV1(plan, context) {
   ]);
   if (!contextResult.valid) return blocked(contextResult.code);
   const safeContext = contextResult.value;
-  const planResult = validateConsumptionPlanV1(plan, {
+  const planResult = validateConsumptionPlan(plan, {
     trustedPlanDigest: safeContext.trustedPlanDigest,
   });
   if (!planResult.valid) return blocked(planResult.code);
@@ -677,10 +687,10 @@ function negotiateExecutionPairV1(plan, context) {
   }
 
   const hasCapsule =
-    safePlan.projection_request.accepted_capsule_versions.includes(CAPSULE_VERSION) &&
-    safeContext.coreCapsuleVersions.includes(CAPSULE_VERSION) &&
-    safeCapabilities.capsule_versions.includes(CAPSULE_VERSION);
-  if (!hasCapsule) return blocked('KDNA_CAPSULE_VERSION_UNSUPPORTED');
+    safePlan.projection_request.accepted_capsule_versions.includes(CAPSULE_CONTRACT_VERSION) &&
+    safeContext.coreCapsuleVersions.includes(CAPSULE_CONTRACT_VERSION) &&
+    safeCapabilities.capsule_versions.includes(CAPSULE_CONTRACT_VERSION);
+  if (!hasCapsule) return blocked('KDNA_CAPSULE_CONTRACT_VERSION_UNSUPPORTED');
 
   const hasProtocol =
     safePlan.host_request.accepted_protocols.includes(HOST_PROTOCOL) &&
@@ -694,7 +704,7 @@ function negotiateExecutionPairV1(plan, context) {
 
   return {
     state: 'selected',
-    capsule_version: CAPSULE_VERSION,
+    capsule_version: CAPSULE_CONTRACT_VERSION,
     host_protocol: HOST_PROTOCOL,
     issue_code: null,
   };
@@ -702,7 +712,7 @@ function negotiateExecutionPairV1(plan, context) {
 
 function expectedAgainst(source) {
   if (source === 'kdna.json.content_digest') return 'manifest_declaration';
-  if (source === 'checksums.json.entry_set_digest' || source === 'checksums.json.asset_digest') {
+  if (source === 'checksums.json.entry_set_digest') {
     return 'checksum_declaration';
   }
   return 'external_expected';
@@ -742,8 +752,9 @@ function validateRequestSemantics(request, plan, enforceBudget = true) {
   if (
     request.plan_ref.plan_id !== plan.plan_id ||
     request.plan_ref.plan_digest_profile !== plan.integrity.profile ||
+    request.plan_ref.plan_digest_profile_version !== plan.integrity.profile_version ||
     request.plan_ref.plan_digest !== plan.integrity.plan_digest ||
-    computeConsumptionPlanDigestV1(plan) !== plan.integrity.plan_digest
+    computeConsumptionPlanDigest(plan) !== plan.integrity.plan_digest
   ) {
     return 'KDNA_HOST_PLAN_REF_MISMATCH';
   }
@@ -762,14 +773,18 @@ function validateRequestSemantics(request, plan, enforceBudget = true) {
   if (request.capsule.access !== plan.asset_ref.access) return 'KDNA_HOST_ASSET_REF_MISMATCH';
 
   if (
-    request.runtime_contract.capsule_version !== request.capsule.version ||
-    request.capsule.version !== CAPSULE_VERSION
+    request.runtime_contract.capsule_version !== request.capsule.contract_version ||
+    request.capsule.contract_version !== CAPSULE_CONTRACT_VERSION
   ) {
-    return 'KDNA_HOST_CAPSULE_VERSION_MISMATCH';
+    return 'KDNA_HOST_CAPSULE_CONTRACT_VERSION_MISMATCH';
   }
   if (
     request.runtime_contract.capsule_digest_profile !== CAPSULE_DELIVERY_PROFILE ||
-    request.capsule.digests.profile !== plan.projection_request.required_digest_profile
+    request.runtime_contract.capsule_digest_profile_version !==
+      CAPSULE_DELIVERY_PROFILE_VERSION ||
+    request.capsule.digests.profile !== plan.projection_request.required_digest_profile ||
+    request.capsule.digests.profile_version !==
+      plan.projection_request.required_digest_profile_version
   ) {
     return 'KDNA_HOST_PROJECTION_CONTRACT_MISMATCH';
   }
@@ -777,6 +792,8 @@ function validateRequestSemantics(request, plan, enforceBudget = true) {
   const expectedProjectionContract = {
     profile: plan.projection_request.profile,
     required_digest_profile: plan.projection_request.required_digest_profile,
+    required_digest_profile_version:
+      plan.projection_request.required_digest_profile_version,
     require_packaged_asset: plan.projection_request.require_packaged_asset,
   };
   if (
@@ -813,7 +830,7 @@ function validateRequestSemantics(request, plan, enforceBudget = true) {
   return null;
 }
 
-function validateAgentHost2RequestV1(request, context) {
+function validateAgentHostRequest(request, context) {
   const contextResult = snapshotContext(context, [
     'plan',
     'trustedPlanDigest',
@@ -825,42 +842,47 @@ function validateAgentHost2RequestV1(request, context) {
   const schemaResult = validateSchema('request', request);
   if (!schemaResult.valid) return schemaResult;
   const safeRequest = schemaResult.value;
-  const planResult = validateConsumptionPlanV1(safeContext.plan, {
+  const planResult = validateConsumptionPlan(safeContext.plan, {
     trustedPlanDigest: safeContext.trustedPlanDigest,
   });
   if (!planResult.valid) return planResult;
   const safePlan = planResult.value;
-  const negotiation = negotiateExecutionPairV1(safePlan, safeContext);
+  const negotiation = negotiateRuntimePair(safePlan, safeContext);
   if (negotiation.state !== 'selected') {
-    return invalid(negotiation.issue_code, 'No strict ConsumptionPlan 1 / Host 2 pair was selected.');
+    return invalid(negotiation.issue_code, 'No strict ConsumptionPlan / Agent Host pair was selected.');
   }
   try {
     const code = validateRequestSemantics(safeRequest, safePlan, true);
-    return code ? invalid(code, 'Agent Host 2 request correlation failed.') : ok(safeRequest);
+    return code ? invalid(code, 'Agent Host request correlation failed.') : ok(safeRequest);
   } catch (error) {
-    return invalid('KDNA_INPUT_INVALID', 'Agent Host 2 request is not a safe JSON value.', {
+    return invalid('KDNA_INPUT_INVALID', 'Agent Host request is not a safe JSON value.', {
       cause: error && typeof error.message === 'string' ? error.message : String(error),
     });
   }
 }
 
-function assembleAgentHost2RequestV1(input, plan) {
+function assembleAgentHostRequest(input, plan) {
   return {
     protocol: HOST_PROTOCOL,
+    protocol_version: HOST_PROTOCOL_VERSION,
     request_id: input.request_id,
     plan_ref: {
       plan_id: plan.plan_id,
       plan_digest_profile: plan.integrity.profile,
+      plan_digest_profile_version: plan.integrity.profile_version,
       plan_digest: plan.integrity.plan_digest,
     },
     runtime_contract: {
-      capsule_version: CAPSULE_VERSION,
+      capsule_version: CAPSULE_CONTRACT_VERSION,
       capsule_digest_profile: CAPSULE_DELIVERY_PROFILE,
+      capsule_digest_profile_version: CAPSULE_DELIVERY_PROFILE_VERSION,
       capsule_delivery_digest: computeCapsuleDeliveryDigest(input.capsule),
     },
     projection_contract: {
       profile: plan.projection_request.profile,
       required_digest_profile: plan.projection_request.required_digest_profile,
+      required_digest_profile_version:
+        plan.projection_request.required_digest_profile_version,
       require_packaged_asset: plan.projection_request.require_packaged_asset,
     },
     result_contract: clone(plan.result_request),
@@ -874,7 +896,7 @@ function assembleAgentHost2RequestV1(input, plan) {
   };
 }
 
-function buildAgentHost2RequestV1(input, context) {
+function buildAgentHostRequest(input, context) {
   const contextResult = snapshotContext(context, [
     'plan',
     'trustedPlanDigest',
@@ -885,34 +907,38 @@ function buildAgentHost2RequestV1(input, context) {
   const inputResult = snapshotPublicInput(input, ['request_id', 'capsule']);
   throwInvalid(inputResult);
   const safeContext = contextResult.value;
-  const planResult = validateConsumptionPlanV1(safeContext.plan, {
+  const planResult = validateConsumptionPlan(safeContext.plan, {
     trustedPlanDigest: safeContext.trustedPlanDigest,
   });
   throwInvalid(planResult);
   const plan = planResult.value;
-  const negotiation = negotiateExecutionPairV1(plan, safeContext);
+  const negotiation = negotiateRuntimePair(plan, safeContext);
   if (negotiation.state !== 'selected') {
-    throw new KDNAExecutionContractError(
+    throw new KDNARuntimeContractError(
       negotiation.issue_code,
-      'Cannot build Host 2 request without a selected strict execution pair.',
+      'Cannot build Agent Host request without a selected strict execution pair.',
     );
   }
   let request;
   try {
-    request = assembleAgentHost2RequestV1(inputResult.value, plan);
+    request = assembleAgentHostRequest(inputResult.value, plan);
   } catch {
-    throw new KDNAExecutionContractError(
+    throw new KDNARuntimeContractError(
       'KDNA_HOST_REQUEST_INPUT_INVALID',
-      'Cannot build Agent Host 2 request from the supplied input.',
+      'Cannot build Agent Host request from the supplied input.',
     );
   }
-  const result = validateAgentHost2RequestV1(request, { ...safeContext, plan });
+  const result = validateAgentHostRequest(request, { ...safeContext, plan });
   throwInvalid(result);
   return request;
 }
 
 function validateReceiptSemantics(receipt, request) {
-  if (receipt.protocol !== request.protocol || receipt.request_id !== request.request_id) {
+  if (
+    receipt.protocol !== request.protocol ||
+    receipt.protocol_version !== request.protocol_version ||
+    receipt.request_id !== request.request_id
+  ) {
     return 'KDNA_HOST_REQUEST_ID_MISMATCH';
   }
   const runtimeReceipt = receipt.runtime_receipt;
@@ -947,7 +973,7 @@ function validateReceiptSemantics(receipt, request) {
     runtimeReceipt.capsule_version !== request.runtime_contract.capsule_version ||
     runtimeReceipt.capsule_digest_profile !== request.runtime_contract.capsule_digest_profile
   ) {
-    return 'KDNA_HOST_CAPSULE_VERSION_MISMATCH';
+    return 'KDNA_HOST_CAPSULE_CONTRACT_VERSION_MISMATCH';
   }
 
   const outcomeUsage = receipt.outcome?.usage ?? null;
@@ -971,7 +997,7 @@ function validateReceiptSemantics(receipt, request) {
   return null;
 }
 
-function validateAgentHost2ReceiptV1(receipt, context) {
+function validateAgentHostReceipt(receipt, context) {
   const contextResult = snapshotContext(context, ['request']);
   if (!contextResult.valid) return contextResult;
   const safeContext = contextResult.value;
@@ -982,16 +1008,16 @@ function validateAgentHost2ReceiptV1(receipt, context) {
   if (!requestSchemaResult.valid) {
     return invalid(
       'KDNA_VALIDATION_CONTEXT_INVALID',
-      'Receipt validation requires a schema-valid independent Host 2 request.',
+      'Receipt validation requires a schema-valid independent Agent Host request.',
       requestSchemaResult.errors,
     );
   }
   const safeRequest = requestSchemaResult.value;
   try {
     const code = validateReceiptSemantics(safeReceipt, safeRequest);
-    return code ? invalid(code, 'Agent Host 2 receipt correlation failed.') : ok(safeReceipt);
+    return code ? invalid(code, 'Agent Host receipt correlation failed.') : ok(safeReceipt);
   } catch (error) {
-    return invalid('KDNA_INPUT_INVALID', 'Agent Host 2 receipt is not a safe JSON value.', {
+    return invalid('KDNA_INPUT_INVALID', 'Agent Host receipt is not a safe JSON value.', {
       cause: error && typeof error.message === 'string' ? error.message : String(error),
     });
   }
@@ -1038,11 +1064,11 @@ function expectedBudgetEvidence(plan, request, receipt) {
   return { limits: clone(plan.budget), actual, comparison };
 }
 
-function deriveBudgetEvidenceV1(plan, context) {
+function deriveBudgetEvidence(plan, context) {
   const contextResult = snapshotContext(context, ['trustedPlanDigest', 'request', 'receipt']);
   throwInvalid(contextResult);
   const safeContext = contextResult.value;
-  const planResult = validateConsumptionPlanV1(plan, {
+  const planResult = validateConsumptionPlan(plan, {
     trustedPlanDigest: safeContext.trustedPlanDigest,
   });
   throwInvalid(planResult);
@@ -1050,29 +1076,29 @@ function deriveBudgetEvidenceV1(plan, context) {
   if (safeContext.request !== null) {
     const requestResult = validateSchema('request', safeContext.request);
     if (!requestResult.valid) {
-      throw new KDNAExecutionContractError(
+      throw new KDNARuntimeContractError(
         'KDNA_VALIDATION_CONTEXT_INVALID',
-        'Budget derivation requires a schema-valid independent Host 2 request.',
+        'Budget derivation requires a schema-valid independent Agent Host request.',
         requestResult.errors,
       );
     }
     safeContext.request = requestResult.value;
     const requestCode = validateRequestSemantics(safeContext.request, safePlan, false);
     if (requestCode !== null) {
-      throw new KDNAExecutionContractError(
+      throw new KDNARuntimeContractError(
         requestCode,
-        'Budget derivation requires an independently correlated Host 2 request.',
+        'Budget derivation requires an independently correlated Agent Host request.',
       );
     }
   }
   if (safeContext.receipt !== null) {
     if (safeContext.request === null) {
-      throw new KDNAExecutionContractError(
+      throw new KDNARuntimeContractError(
         'KDNA_VALIDATION_CONTEXT_INVALID',
         'Budget derivation cannot use a receipt without its independent request.',
       );
     }
-    const receiptResult = validateAgentHost2ReceiptV1(safeContext.receipt, {
+    const receiptResult = validateAgentHostReceipt(safeContext.receipt, {
       request: safeContext.request,
     });
     throwInvalid(receiptResult);
@@ -1081,13 +1107,13 @@ function deriveBudgetEvidenceV1(plan, context) {
   return expectedBudgetEvidence(safePlan, safeContext.request, safeContext.receipt);
 }
 
-function preparePreHostBudgetBlockedV1(capsule, safeContext) {
-  const planResult = validateConsumptionPlanV1(safeContext.plan, {
+function preparePreHostBudgetBlocked(capsule, safeContext) {
+  const planResult = validateConsumptionPlan(safeContext.plan, {
     trustedPlanDigest: safeContext.trustedPlanDigest,
   });
   if (!planResult.valid) return planResult;
   const plan = planResult.value;
-  const negotiation = negotiateExecutionPairV1(plan, safeContext);
+  const negotiation = negotiateRuntimePair(plan, safeContext);
   if (negotiation.state !== 'selected') {
     return invalid(
       negotiation.issue_code,
@@ -1097,7 +1123,7 @@ function preparePreHostBudgetBlockedV1(capsule, safeContext) {
 
   let projectedCandidate;
   try {
-    projectedCandidate = assembleAgentHost2RequestV1(
+    projectedCandidate = assembleAgentHostRequest(
       { request_id: PRE_HOST_INTERNAL_REQUEST_ID, capsule },
       plan,
     );
@@ -1130,12 +1156,12 @@ function preparePreHostBudgetBlockedV1(capsule, safeContext) {
 }
 
 /**
- * Build the only supported Trace 1 path for a successfully projected Capsule
+ * Build the sole supported pre-Host blocked Trace path for a successfully projected Capsule
  * that exceeds an enforce-before-Host projection or task limit. This function
  * never exposes the internal request-shaped correlation candidate and cannot
- * produce a deliverable Agent Host 2 request.
+ * produce a deliverable Agent Host request.
  */
-function buildPreHostBudgetBlockedTraceV1(input, context) {
+function buildPreHostBudgetBlockedTrace(input, context) {
   const inputResult = snapshotPublicInput(
     input,
     ['trace_id', 'timestamp', 'capsule'],
@@ -1151,10 +1177,10 @@ function buildPreHostBudgetBlockedTraceV1(input, context) {
   throwInvalid(contextResult);
   const safeInput = inputResult.value;
   const safeContext = contextResult.value;
-  const prepared = preparePreHostBudgetBlockedV1(safeInput.capsule, safeContext);
+  const prepared = preparePreHostBudgetBlocked(safeInput.capsule, safeContext);
   throwInvalid(prepared);
 
-  return buildJudgmentTraceV1(
+  return buildJudgmentTrace(
     {
       trace_id: safeInput.trace_id,
       timestamp: safeInput.timestamp,
@@ -1178,7 +1204,7 @@ function buildPreHostBudgetBlockedTraceV1(input, context) {
  * independent Plan/Host capability facts without requiring callers to
  * construct or retain an over-budget request object.
  */
-function validatePreHostBudgetBlockedTraceV1(trace, context) {
+function validatePreHostBudgetBlockedTrace(trace, context) {
   const contextResult = snapshotContext(context, [
     'plan',
     'trustedPlanDigest',
@@ -1188,9 +1214,9 @@ function validatePreHostBudgetBlockedTraceV1(trace, context) {
   ]);
   if (!contextResult.valid) return contextResult;
   const safeContext = contextResult.value;
-  const prepared = preparePreHostBudgetBlockedV1(safeContext.capsule, safeContext);
+  const prepared = preparePreHostBudgetBlocked(safeContext.capsule, safeContext);
   if (!prepared.valid) return prepared;
-  const traceResult = validateJudgmentTraceV1(trace, {
+  const traceResult = validateJudgmentTrace(trace, {
     ...safeContext,
     plan: prepared.value.plan,
     request: prepared.value.projectedCandidate,
@@ -1240,9 +1266,10 @@ function unavailableDigestEvidence() {
   });
   return {
     profile: CAPSULE_DIGEST_PROFILE,
-    asset: item('kdna-container-bytes-v1'),
-    content: item('kdna-content-tree-v1'),
-    runtime_entry_set: item('kdna-runtime-entry-set-v1'),
+    profile_version: '0.1.0',
+    asset: item('kdna.digest-basis.container-bytes'),
+    content: item('kdna.digest-basis.content-tree'),
+    runtime_entry_set: item('kdna.digest-basis.runtime-entry-set'),
   };
 }
 
@@ -1324,8 +1351,9 @@ function validateTraceSemantics(
   if (
     trace.plan_ref.plan_id !== plan.plan_id ||
     trace.plan_ref.plan_digest_profile !== plan.integrity.profile ||
+    trace.plan_ref.plan_digest_profile_version !== plan.integrity.profile_version ||
     trace.plan_ref.plan_digest !== plan.integrity.plan_digest ||
-    trace.plan_ref.plan_digest !== computeConsumptionPlanDigestV1(plan)
+    trace.plan_ref.plan_digest !== computeConsumptionPlanDigest(plan)
   ) {
     return 'KDNA_TRACE_PLAN_REF_MISMATCH';
   }
@@ -1350,7 +1378,7 @@ function validateTraceSemantics(
       if (validateRequestSemantics(request, plan, false) !== null) {
         return 'KDNA_TRACE_REQUEST_MISMATCH';
       }
-      const negotiation = negotiateExecutionPairV1(plan, {
+      const negotiation = negotiateRuntimePair(plan, {
         trustedPlanDigest: plan.integrity.plan_digest,
         capabilities,
         coreCapsuleVersions,
@@ -1390,7 +1418,7 @@ function validateTraceSemantics(
             receipt.runtime_receipt.host_recomputed_capsule_delivery_digest ||
           delivery.host_echoed !== receipt.runtime_receipt.echoed_capsule_delivery_digest ||
           delivery.host_recomputed === p ||
-          delivery.delivered_capsule_version !== CAPSULE_VERSION ||
+          delivery.delivered_capsule_version !== CAPSULE_CONTRACT_VERSION ||
           delivery.request_id !== request.request_id ||
           trace.execution.delivery_status !== 'rejected_before_execution'
         ) {
@@ -1402,7 +1430,7 @@ function validateTraceSemantics(
           receipt !== null ||
           delivery.host_recomputed !== null ||
           delivery.host_echoed !== null ||
-          delivery.delivered_capsule_version !== CAPSULE_VERSION ||
+          delivery.delivered_capsule_version !== CAPSULE_CONTRACT_VERSION ||
           delivery.request_id !== request.request_id ||
           trace.execution.delivery_status !== 'rejected_before_execution'
         ) {
@@ -1456,7 +1484,7 @@ function validateTraceSemantics(
       return 'KDNA_TRACE_NEGOTIATION_EVIDENCE_MISMATCH';
     }
     if (runtime.negotiation_state === 'blocked') {
-      const negotiation = negotiateExecutionPairV1(plan, {
+      const negotiation = negotiateRuntimePair(plan, {
         trustedPlanDigest: plan.integrity.plan_digest,
         capabilities,
         coreCapsuleVersions,
@@ -1490,7 +1518,7 @@ function validateTraceSemantics(
     return 'KDNA_TRACE_HOST_RECEIPT_MISMATCH';
   }
 
-  const negotiation = negotiateExecutionPairV1(plan, {
+  const negotiation = negotiateRuntimePair(plan, {
     trustedPlanDigest: plan.integrity.plan_digest,
     capabilities,
     coreCapsuleVersions,
@@ -1563,7 +1591,7 @@ function validateTraceSemantics(
   return validateTerminalState(trace, receipt);
 }
 
-function validateJudgmentTraceV1(trace, context) {
+function validateJudgmentTrace(trace, context) {
   const contextResult = snapshotContext(context, [
     'plan',
     'trustedPlanDigest',
@@ -1580,7 +1608,7 @@ function validateJudgmentTraceV1(trace, context) {
   const schemaResult = validateSchema('trace', trace);
   if (!schemaResult.valid) return schemaResult;
   const safeTrace = schemaResult.value;
-  const planResult = validateConsumptionPlanV1(safeContext.plan, {
+  const planResult = validateConsumptionPlan(safeContext.plan, {
     trustedPlanDigest: safeContext.trustedPlanDigest,
   });
   if (!planResult.valid) return planResult;
@@ -1612,7 +1640,7 @@ function validateJudgmentTraceV1(trace, context) {
         'Trace validation cannot correlate a receipt without its independent request.',
       );
     }
-    const receiptResult = validateAgentHost2ReceiptV1(safeContext.receipt, {
+    const receiptResult = validateAgentHostReceipt(safeContext.receipt, {
       request: safeContext.request,
     });
     if (!receiptResult.valid) {
@@ -1649,7 +1677,7 @@ function validateJudgmentTraceV1(trace, context) {
   }
 }
 
-function buildJudgmentTraceV1(input, context) {
+function buildJudgmentTrace(input, context) {
   const contextResult = snapshotContext(context, [
     'plan',
     'trustedPlanDigest',
@@ -1662,7 +1690,7 @@ function buildJudgmentTraceV1(input, context) {
   throwInvalid(contextResult);
   const safeContext = contextResult.value;
   throwInvalid(validateTrustedDeliveryObservation(safeContext));
-  const planResult = validateConsumptionPlanV1(safeContext.plan, {
+  const planResult = validateConsumptionPlan(safeContext.plan, {
     trustedPlanDigest: safeContext.trustedPlanDigest,
   });
   throwInvalid(planResult);
@@ -1670,7 +1698,7 @@ function buildJudgmentTraceV1(input, context) {
 
   const capabilitiesResult = validateSchema('capabilities', safeContext.capabilities);
   if (!capabilitiesResult.valid) {
-    throw new KDNAExecutionContractError(
+    throw new KDNARuntimeContractError(
       'KDNA_VALIDATION_CONTEXT_INVALID',
       'Trace construction requires schema-valid independent Host capabilities.',
       capabilitiesResult.errors,
@@ -1680,7 +1708,7 @@ function buildJudgmentTraceV1(input, context) {
   if (safeContext.request !== null) {
     const requestResult = validateSchema('request', safeContext.request);
     if (!requestResult.valid) {
-      throw new KDNAExecutionContractError(
+      throw new KDNARuntimeContractError(
         'KDNA_VALIDATION_CONTEXT_INVALID',
         'Trace construction requires a schema-valid independent Host request.',
         requestResult.errors,
@@ -1693,14 +1721,14 @@ function buildJudgmentTraceV1(input, context) {
       false,
     );
     if (requestCode !== null) {
-      throw new KDNAExecutionContractError(
+      throw new KDNARuntimeContractError(
         requestCode,
         'Trace construction requires an independently correlated Host request.',
       );
     }
-    const negotiation = negotiateExecutionPairV1(safeContext.plan, safeContext);
+    const negotiation = negotiateRuntimePair(safeContext.plan, safeContext);
     if (negotiation.state !== 'selected') {
-      throw new KDNAExecutionContractError(
+      throw new KDNARuntimeContractError(
         negotiation.issue_code,
         'Trace construction requires a selected strict execution pair.',
       );
@@ -1708,12 +1736,12 @@ function buildJudgmentTraceV1(input, context) {
   }
   if (safeContext.receipt !== null) {
     if (safeContext.request === null) {
-      throw new KDNAExecutionContractError(
+      throw new KDNARuntimeContractError(
         'KDNA_VALIDATION_CONTEXT_INVALID',
         'Trace construction cannot use a receipt without its independent request.',
       );
     }
-    const receiptResult = validateAgentHost2ReceiptV1(safeContext.receipt, {
+    const receiptResult = validateAgentHostReceipt(safeContext.receipt, {
       request: safeContext.request,
     });
     throwInvalid(receiptResult);
@@ -1724,7 +1752,7 @@ function buildJudgmentTraceV1(input, context) {
   const request = safeContext.request;
   const receipt = safeContext.receipt;
   const observation = safeContext.trustedDeliveryObservation;
-  const negotiation = negotiateExecutionPairV1(plan, safeContext);
+  const negotiation = negotiateRuntimePair(plan, safeContext);
   const hasRequest = request !== null;
   const hasReceipt = receipt !== null;
   const comparison = hasReceipt
@@ -1738,12 +1766,13 @@ function buildJudgmentTraceV1(input, context) {
   let trace;
   try {
     trace = {
-      type: 'kdna.judgment.trace',
-      trace_version: '1.0.0',
+      type: 'kdna.judgment-trace',
+      contract_version: '0.1.0',
       trace_id: input.trace_id,
       plan_ref: {
         plan_id: plan.plan_id,
         plan_digest_profile: plan.integrity.profile,
+        plan_digest_profile_version: plan.integrity.profile_version,
         plan_digest: plan.integrity.plan_digest,
         comparison: 'matched',
       },
@@ -1768,6 +1797,7 @@ function buildJudgmentTraceV1(input, context) {
       digest_evidence: hasRequest ? clone(request.capsule.digests) : unavailableDigestEvidence(),
       capsule_delivery_evidence: {
         basis: CAPSULE_DELIVERY_PROFILE,
+        basis_version: CAPSULE_DELIVERY_PROFILE_VERSION,
         observed: p,
         sender_computed: hasRequest,
         host_recomputed: hasReceipt
@@ -1777,7 +1807,7 @@ function buildJudgmentTraceV1(input, context) {
           ? receipt.runtime_receipt.echoed_capsule_delivery_digest
           : null,
         delivered_capsule_version:
-          hasReceipt || observation === 'not_observed' ? CAPSULE_VERSION : null,
+          hasReceipt || observation === 'not_observed' ? CAPSULE_CONTRACT_VERSION : null,
         host_boundary_comparison: comparison,
         request_id: hasReceipt || observation === 'not_observed' ? request.request_id : null,
       },
@@ -1810,7 +1840,7 @@ function buildJudgmentTraceV1(input, context) {
           ? {
               shape: request.result_contract.shape,
               result_digest: digestJcs(receipt.outcome),
-              basis: 'kdna-result-jcs-v1',
+              basis: 'kdna.canonicalization.result-jcs',
               stored: input.result_stored ?? true,
             }
           : null,
@@ -1818,33 +1848,35 @@ function buildJudgmentTraceV1(input, context) {
       warnings: clone(input.warnings || []),
     };
   } catch {
-    throw new KDNAExecutionContractError(
+    throw new KDNARuntimeContractError(
       'KDNA_TRACE_INPUT_INVALID',
-      'Cannot build JudgmentTrace 1 from the supplied input and independent context.',
+      'Cannot build JudgmentTrace from the supplied input and independent context.',
     );
   }
 
-  const result = validateJudgmentTraceV1(trace, safeContext);
+  const result = validateJudgmentTrace(trace, safeContext);
   throwInvalid(result);
   return trace;
 }
 
 module.exports = {
-  KDNAExecutionContractError,
+  KDNARuntimeContractError,
   PLAN_DIGEST_PROFILE,
+  PLAN_DIGEST_PROFILE_VERSION,
   HOST_PROTOCOL,
-  DEFAULT_CORE_CAPSULE_VERSIONS,
-  parseExecutionContractJsonV1,
-  computeConsumptionPlanDigestV1,
-  buildConsumptionPlanV1,
-  validateConsumptionPlanV1,
-  negotiateExecutionPairV1,
-  buildAgentHost2RequestV1,
-  validateAgentHost2RequestV1,
-  validateAgentHost2ReceiptV1,
-  deriveBudgetEvidenceV1,
-  buildPreHostBudgetBlockedTraceV1,
-  validatePreHostBudgetBlockedTraceV1,
-  buildJudgmentTraceV1,
-  validateJudgmentTraceV1,
+  HOST_PROTOCOL_VERSION,
+  DEFAULT_CORE_CAPSULE_CONTRACT_VERSIONS,
+  parseRuntimeContractJson,
+  computeConsumptionPlanDigest,
+  buildConsumptionPlan,
+  validateConsumptionPlan,
+  negotiateRuntimePair,
+  buildAgentHostRequest,
+  validateAgentHostRequest,
+  validateAgentHostReceipt,
+  deriveBudgetEvidence,
+  buildPreHostBudgetBlockedTrace,
+  validatePreHostBudgetBlockedTrace,
+  buildJudgmentTrace,
+  validateJudgmentTrace,
 };