chainlesschain 0.166.47 → 0.166.56

package/src/lib/evolution/evolution-deployment-profile.js

@@ -1,11 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import {
-  readFileSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
+import { readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join } from "node:path";
 import { resolveConfigDataRoot } from "../paths.js";
 import {
@@ -16,7 +11,7 @@ import {
 import { withFileLock } from "../with-file-lock.js";
 
 export const EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA =
-  "chainlesschain.evolution-deployment-profile/v4";
+  "chainlesschain.evolution-deployment-profile/v5";
 
 const LEGACY_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA =
   "chainlesschain.evolution-deployment-profile/v1";
@@ -24,6 +19,8 @@ const PREVIOUS_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA =
   "chainlesschain.evolution-deployment-profile/v2";
 const PRIOR_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA =
   "chainlesschain.evolution-deployment-profile/v3";
+const LAST_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA =
+  "chainlesschain.evolution-deployment-profile/v4";
 const DIGEST = /^sha256:[a-f0-9]{64}$/u;
 const MAX_TRUST_ROOT_REVISION_FLOORS = 64;
 
@@ -47,6 +44,8 @@ function normalizeProfile(value) {
     PREVIOUS_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA,
     PRIOR_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA,
   ].includes(value.schema);
+  const beforeDeploymentMode =
+    legacy || value.schema === LAST_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA;
   const expected =
     value.schema === LEGACY_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA
       ? ["descriptorPath", "enabled", "schema", "trustRootPath"]
@@ -58,31 +57,44 @@ function normalizeProfile(value) {
             "schema",
             "trustRootPath",
           ]
-      : value.schema === PRIOR_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA
-        ? [
-            "activeTrustRootDigest",
-            "descriptorPath",
-            "enabled",
-            "revisionFloors",
-            "schema",
-            "trustRootPath",
-          ]
-        : [
-            "activeTrustRootDigest",
-            "descriptorPath",
-            "enabled",
-            "revisionFloors",
-            "revokedDescriptorRevisions",
-            "schema",
-            "trustRootPath",
-          ];
+        : value.schema === PRIOR_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA
+          ? [
+              "activeTrustRootDigest",
+              "descriptorPath",
+              "enabled",
+              "revisionFloors",
+              "schema",
+              "trustRootPath",
+            ]
+          : value.schema === LAST_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA
+            ? [
+                "activeTrustRootDigest",
+                "descriptorPath",
+                "enabled",
+                "revisionFloors",
+                "revokedDescriptorRevisions",
+                "schema",
+                "trustRootPath",
+              ]
+            : [
+                "activeTrustRootDigest",
+                "deploymentMode",
+                "descriptorPath",
+                "enabled",
+                "revisionFloors",
+                "revokedDescriptorRevisions",
+                "schema",
+                "testPrivateKeyPath",
+                "trustRootPath",
+              ];
   if (JSON.stringify(keys) !== JSON.stringify(expected.sort()))
     throw new TypeError("evolution deployment profile has unexpected fields");
   if (
     value.schema !== EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA &&
     value.schema !== LEGACY_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA &&
     value.schema !== PREVIOUS_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA &&
-    value.schema !== PRIOR_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA
+    value.schema !== PRIOR_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA &&
+    value.schema !== LAST_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA
   )
     throw new TypeError("evolution deployment profile schema is invalid");
   if (typeof value.enabled !== "boolean")
@@ -103,10 +115,30 @@ function normalizeProfile(value) {
   const activeTrustRootDigest = legacy
     ? null
     : normalizeTrustRootDigest(value.activeTrustRootDigest);
-  const revokedDescriptorRevisions =
-    value.schema === EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA
-      ? normalizeRevokedDescriptorRevisions(value.revokedDescriptorRevisions)
-      : {};
+  const revokedDescriptorRevisions = [
+    EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA,
+    LAST_EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA,
+  ].includes(value.schema)
+    ? normalizeRevokedDescriptorRevisions(value.revokedDescriptorRevisions)
+    : {};
+  const deploymentMode = beforeDeploymentMode
+    ? "managed"
+    : value.deploymentMode;
+  if (!["managed", "test"].includes(deploymentMode))
+    throw new TypeError("evolution deployment profile mode is invalid");
+  const testPrivateKeyPath = beforeDeploymentMode
+    ? null
+    : value.testPrivateKeyPath;
+  if (
+    (deploymentMode === "test" &&
+      (typeof testPrivateKeyPath !== "string" ||
+        !isAbsolute(testPrivateKeyPath))) ||
+    (deploymentMode === "managed" && testPrivateKeyPath !== null)
+  ) {
+    throw new TypeError(
+      "evolution deployment profile test private key path is invalid",
+    );
+  }
   return Object.freeze({
     schema: EVOLUTION_DEPLOYMENT_PROFILE_SCHEMA,
     enabled: value.enabled,
@@ -115,6 +147,8 @@ function normalizeProfile(value) {
     revisionFloors,
     activeTrustRootDigest,
     revokedDescriptorRevisions,
+    deploymentMode,
+    testPrivateKeyPath,
   });
 }
 
@@ -156,12 +190,16 @@ function normalizeTrustRootDigest(value) {
 
 function normalizeRevisionFloors(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
-    throw new TypeError("evolution deployment profile revisionFloors is invalid");
+    throw new TypeError(
+      "evolution deployment profile revisionFloors is invalid",
+    );
   const entries = Object.entries(value).sort(([left], [right]) =>
     left.localeCompare(right),
   );
   if (entries.length > MAX_TRUST_ROOT_REVISION_FLOORS)
-    throw new TypeError("evolution deployment profile revisionFloors is too large");
+    throw new TypeError(
+      "evolution deployment profile revisionFloors is too large",
+    );
   for (const [trustRootDigest, revision] of entries) {
     if (!DIGEST.test(trustRootDigest))
       throw new TypeError(
@@ -228,6 +266,8 @@ function profileFromInput(input) {
     revisionFloors: input?.revisionFloors || {},
     activeTrustRootDigest: input?.activeTrustRootDigest,
     revokedDescriptorRevisions: input?.revokedDescriptorRevisions || {},
+    deploymentMode: input?.deploymentMode || "managed",
+    testPrivateKeyPath: input?.testPrivateKeyPath || null,
   });
 }
 
@@ -251,29 +291,34 @@ export async function readEvolutionDeploymentProfile(options = {}) {
 
 export async function writeEvolutionDeploymentProfile(input, options = {}) {
   const proposed = profileFromInput(input);
-  return updateEvolutionDeploymentProfile((current) => ({
-    ...proposed,
-    // This lower-level writer cannot authenticate a descriptor, so it never
-    // lowers or erases a floor established by configureEvolutionDeployment().
-    revisionFloors: Object.fromEntries(
-      Object.keys({
-        ...(current?.revisionFloors || {}),
-        ...proposed.revisionFloors,
-      }).map((trustRootDigest) => [
-        trustRootDigest,
-        Math.max(
-          current?.revisionFloors?.[trustRootDigest] || 0,
-          proposed.revisionFloors[trustRootDigest] || 0,
-        ),
-      ]),
-    ),
-    activeTrustRootDigest:
-      proposed.activeTrustRootDigest || current?.activeTrustRootDigest,
-    revokedDescriptorRevisions: {
-      ...(current?.revokedDescriptorRevisions || {}),
-      ...(proposed.revokedDescriptorRevisions || {}),
-    },
-  }), options);
+  return updateEvolutionDeploymentProfile(
+    (current) => ({
+      ...proposed,
+      // This lower-level writer cannot authenticate a descriptor, so it never
+      // lowers or erases a floor established by configureEvolutionDeployment().
+      revisionFloors: Object.fromEntries(
+        Object.keys({
+          ...(current?.revisionFloors || {}),
+          ...proposed.revisionFloors,
+        }).map((trustRootDigest) => [
+          trustRootDigest,
+          Math.max(
+            current?.revisionFloors?.[trustRootDigest] || 0,
+            proposed.revisionFloors[trustRootDigest] || 0,
+          ),
+        ]),
+      ),
+      activeTrustRootDigest:
+        proposed.activeTrustRootDigest || current?.activeTrustRootDigest,
+      revokedDescriptorRevisions: {
+        ...(current?.revokedDescriptorRevisions || {}),
+        ...(proposed.revokedDescriptorRevisions || {}),
+      },
+      deploymentMode: proposed.deploymentMode,
+      testPrivateKeyPath: proposed.testPrivateKeyPath,
+    }),
+    options,
+  );
 }
 
 /**
@@ -335,9 +380,8 @@ export function assertEvolutionDeploymentDescriptorNotRevoked(
   profile,
   descriptor,
 ) {
-  const revoked = profile?.revokedDescriptorRevisions?.[
-    descriptor?.trustRootDigest
-  ];
+  const revoked =
+    profile?.revokedDescriptorRevisions?.[descriptor?.trustRootDigest];
   if (!revoked?.includes(descriptor?.revision)) return;
   const error = new Error(
     `evolution deployment descriptor revision ${descriptor.revision} is revoked`,

package/src/lib/evolution/evolution-test-deployment.js

@@ -0,0 +1,386 @@
+import {
+  createPrivateKey,
+  createPublicKey,
+  generateKeyPairSync,
+  randomUUID,
+  sign as signBytes,
+} from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { configureEvolutionDeployment } from "./evolution-deployment-config.js";
+import {
+  EVOLUTION_DEPLOYMENT_DESCRIPTOR_SCHEMA,
+  computeEvolutionDeploymentDigest,
+  serializeEvolutionDeploymentDescriptorPayload,
+  verifyEvolutionDeployment,
+} from "./evolution-deployment-loader.js";
+import {
+  getEvolutionDeploymentProfilePath,
+  readEvolutionDeploymentProfile,
+} from "./evolution-deployment-profile.js";
+import {
+  EVOLUTION_DEPLOYMENT_ROOT_ROTATION_SCHEMA,
+  serializeEvolutionDeploymentRootRotationPayload,
+} from "./evolution-deployment-root-rotation.js";
+import {
+  PRIVATE_FILE_MODE,
+  ensurePrivateDirectory,
+  ensurePrivateFile,
+} from "../secure-fs.js";
+
+export const EVOLUTION_TEST_DEPLOYMENT_COMMANDS = Object.freeze([
+  "agent",
+  "ask",
+  "chat",
+  "compact",
+  "complete",
+  "cowork",
+  "desktop",
+  "evolution",
+  "hub",
+  "learning",
+  "marketplace",
+  "orchestrate",
+  "serve",
+  "skill",
+  "stream",
+  "ui",
+]);
+
+const TEST_PRIVATE_KEY_FILE = "test-signing-private.pem";
+const TEST_TRUST_ROOT_FILE = "test-signing-public.pem";
+const TEST_DESCRIPTOR_FILE = "test-deployment.json";
+const TEST_README_FILE = "README-TEST-ONLY.txt";
+const MAX_MODULE_BYTES = 4 * 1024 * 1024;
+
+function writePrivateAtomic(filePath, value) {
+  ensurePrivateDirectory(dirname(filePath));
+  const temporaryPath = join(
+    dirname(filePath),
+    `.${filePath.split(/[\\/]/u).at(-1)}.${randomUUID()}.tmp`,
+  );
+  try {
+    writeFileSync(temporaryPath, value, {
+      flag: "wx",
+      mode: PRIVATE_FILE_MODE,
+    });
+    ensurePrivateFile(temporaryPath);
+    renameSync(temporaryPath, filePath);
+    ensurePrivateFile(filePath);
+  } catch (error) {
+    try {
+      unlinkSync(temporaryPath);
+    } catch {
+      // The temporary file was not created or has already been renamed.
+    }
+    throw error;
+  }
+}
+
+function assertNoEnvironmentOverride(env) {
+  if (
+    env.CHAINLESSCHAIN_EVOLUTION_DEPLOYMENT_DESCRIPTOR ||
+    env.CHAINLESSCHAIN_EVOLUTION_DEPLOYMENT_TRUST_ROOT
+  ) {
+    throw new Error(
+      "test deployment setup requires the Evolution deployment environment overrides to be unset",
+    );
+  }
+}
+
+function normalizeCommands(commands) {
+  const value =
+    commands === undefined
+      ? [...EVOLUTION_TEST_DEPLOYMENT_COMMANDS]
+      : typeof commands === "string"
+        ? commands
+            .split(",")
+            .map((command) => command.trim())
+            .filter(Boolean)
+        : Array.isArray(commands)
+          ? [...commands]
+          : null;
+  if (!value || value.length === 0 || new Set(value).size !== value.length)
+    throw new TypeError(
+      "test deployment commands must be a non-empty unique list",
+    );
+  return value.sort();
+}
+
+function readRevision(descriptorPath) {
+  if (!existsSync(descriptorPath)) return 0;
+  try {
+    const descriptor = JSON.parse(readFileSync(descriptorPath, "utf8"));
+    if (!Number.isSafeInteger(descriptor.revision) || descriptor.revision < 1)
+      throw new Error("revision is invalid");
+    return descriptor.revision;
+  } catch (error) {
+    throw new Error(
+      "existing test deployment descriptor cannot be refreshed",
+      error instanceof Error ? { cause: error } : undefined,
+    );
+  }
+}
+
+function assertSigningPair(privateKeyBytes, trustRootBytes) {
+  let privateKey;
+  let actualPublic;
+  let expectedPublic;
+  try {
+    privateKey = createPrivateKey(privateKeyBytes);
+    actualPublic = createPublicKey(privateKey).export({
+      type: "spki",
+      format: "der",
+    });
+    expectedPublic = createPublicKey(trustRootBytes).export({
+      type: "spki",
+      format: "der",
+    });
+  } catch {
+    throw new Error("test deployment signing key pair is invalid");
+  }
+  if (!Buffer.from(actualPublic).equals(Buffer.from(expectedPublic)))
+    throw new Error(
+      "test deployment signing key does not match its trust root",
+    );
+  return privateKey;
+}
+
+function claimFreshTestRoot(profilePath) {
+  const parent = dirname(profilePath);
+  const preferred = join(parent, "test-deployment");
+  ensurePrivateDirectory(parent);
+  for (const candidate of [
+    preferred,
+    join(parent, `test-deployment-${randomUUID()}`),
+  ]) {
+    try {
+      mkdirSync(candidate, { mode: 0o700 });
+      ensurePrivateDirectory(candidate);
+      return candidate;
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+    }
+  }
+  throw new Error("could not allocate a private test deployment directory");
+}
+
+function testReadme({ modulePath, descriptorPath, trustRootPath }) {
+  return `ChainlessChain Skill evolution development environment / 仅限测试开发
+
+This directory contains an automatically generated Ed25519 TEST key. It is not
+a production certificate, HSM/KMS identity, reviewer identity, or production
+approval. Automatic active promotion remains HOLD.
+
+本目录包含自动生成的 Ed25519 测试密钥，只用于正式部署前联调。它不属于生产证书、
+HSM/KMS 身份或审核身份，也不会解除人工审核和 automatic active promotion HOLD。
+
+Deployment host: ${modulePath}
+Signed descriptor: ${descriptorPath}
+Test trust root: ${trustRootPath}
+
+Re-run "cc evolution deployment init-test --module <absolute-path>" after the
+host module changes. When the managed descriptor and trust root are available,
+run "cc evolution deployment replace-test --descriptor <path> --trust-root <path>".
+
+部署宿主模块变更后请重新执行 init-test 刷新摘要和签名。正式 descriptor 与 trust
+root 到位后执行 replace-test；CLI 会用测试根签发一次根轮换证明并切换到正式配置。
+`;
+}
+
+/**
+ * Generate or refresh a local-only Ed25519 deployment wrapper for an existing
+ * development host. The ordinary descriptor verifier and profile writer remain
+ * the only activation path; this helper never bypasses deployment admission.
+ */
+export async function initializeEvolutionTestDeployment(
+  { modulePath, commands, enabled = true },
+  options = {},
+) {
+  const env = options.env || process.env;
+  const resolveRealPath =
+    options.resolveRealPath ||
+    (async (value) => {
+      const { realpath } = await import("node:fs/promises");
+      return realpath(value);
+    });
+  assertNoEnvironmentOverride(env);
+  if (typeof modulePath !== "string" || !modulePath.trim())
+    throw new TypeError(
+      "an absolute test deployment host module path is required",
+    );
+  const requestedModulePath = modulePath.trim();
+  if (!isAbsolute(requestedModulePath))
+    throw new TypeError("test deployment host module path must be absolute");
+  const realModulePath = await resolveRealPath(requestedModulePath);
+  const moduleBytes = readFileSync(realModulePath);
+  if (moduleBytes.byteLength === 0 || moduleBytes.byteLength > MAX_MODULE_BYTES)
+    throw new Error("test deployment host module size is invalid");
+
+  const saved = await readEvolutionDeploymentProfile(options);
+  if (saved.error) throw new Error(saved.error);
+  if (saved.profile && saved.profile.deploymentMode !== "test") {
+    const error = new Error(
+      "a managed Evolution deployment profile already exists; test setup will not replace it",
+    );
+    error.code = "EVOLUTION_TEST_DEPLOYMENT_MANAGED_PROFILE_EXISTS";
+    throw error;
+  }
+
+  const requestedTestRoot = saved.profile
+    ? dirname(saved.profile.descriptorPath)
+    : claimFreshTestRoot(
+        options.filePath || getEvolutionDeploymentProfilePath(options),
+      );
+  ensurePrivateDirectory(requestedTestRoot);
+  // macOS exposes /var through the /private/var real path. Persist and compare
+  // the physical path so a refresh does not mistake those aliases for two
+  // different credential directories.
+  const testRoot = await resolveRealPath(requestedTestRoot);
+  const privateKeyPath = join(testRoot, TEST_PRIVATE_KEY_FILE);
+  const trustRootPath = join(testRoot, TEST_TRUST_ROOT_FILE);
+  const descriptorPath = join(testRoot, TEST_DESCRIPTOR_FILE);
+  let privateKeyBytes;
+  let trustRootBytes;
+  let generated = false;
+  if (saved.profile) {
+    const [savedDescriptorPath, savedTrustRootPath, savedPrivateKeyPath] =
+      await Promise.all([
+        resolveRealPath(saved.profile.descriptorPath),
+        resolveRealPath(saved.profile.trustRootPath),
+        resolveRealPath(saved.profile.testPrivateKeyPath),
+      ]);
+    if (
+      resolve(savedDescriptorPath) !== resolve(descriptorPath) ||
+      resolve(savedTrustRootPath) !== resolve(trustRootPath) ||
+      resolve(savedPrivateKeyPath) !== resolve(privateKeyPath)
+    ) {
+      throw new Error("saved test deployment paths are inconsistent");
+    }
+    ensurePrivateFile(privateKeyPath);
+    ensurePrivateFile(trustRootPath);
+    privateKeyBytes = readFileSync(privateKeyPath);
+    trustRootBytes = readFileSync(trustRootPath);
+  } else {
+    const { privateKey, publicKey } = generateKeyPairSync("ed25519");
+    privateKeyBytes = privateKey.export({ type: "pkcs8", format: "pem" });
+    trustRootBytes = publicKey.export({ type: "spki", format: "pem" });
+    writePrivateAtomic(privateKeyPath, privateKeyBytes);
+    writePrivateAtomic(trustRootPath, trustRootBytes);
+    generated = true;
+  }
+  const privateKey = assertSigningPair(privateKeyBytes, trustRootBytes);
+  const descriptor = {
+    schema: EVOLUTION_DEPLOYMENT_DESCRIPTOR_SCHEMA,
+    revision: readRevision(descriptorPath) + 1,
+    modulePath: realModulePath,
+    moduleDigest: computeEvolutionDeploymentDigest(moduleBytes),
+    trustRootDigest: computeEvolutionDeploymentDigest(trustRootBytes),
+    commands: normalizeCommands(commands),
+  };
+  descriptor.signature = signBytes(
+    null,
+    Buffer.from(serializeEvolutionDeploymentDescriptorPayload(descriptor)),
+    privateKey,
+  ).toString("base64");
+  writePrivateAtomic(
+    descriptorPath,
+    `${JSON.stringify(descriptor, null, 2)}\n`,
+  );
+  writePrivateAtomic(
+    join(testRoot, TEST_README_FILE),
+    testReadme({ modulePath: realModulePath, descriptorPath, trustRootPath }),
+  );
+
+  const status = await configureEvolutionDeployment(
+    {
+      descriptorPath,
+      trustRootPath,
+      enabled,
+      deploymentMode: "test",
+      testPrivateKeyPath: privateKeyPath,
+    },
+    options,
+  );
+  return Object.freeze({
+    ...status,
+    generated,
+    testRootPath: testRoot,
+    warning:
+      "TEST ONLY: local development credentials; automatic active promotion remains HOLD",
+  });
+}
+
+/** Replace an active generated test root with an operator-signed deployment. */
+export async function replaceEvolutionTestDeployment(
+  { descriptorPath, trustRootPath },
+  options = {},
+) {
+  const env = options.env || process.env;
+  assertNoEnvironmentOverride(env);
+  const saved = await readEvolutionDeploymentProfile(options);
+  if (saved.error) throw new Error(saved.error);
+  if (saved.profile?.deploymentMode !== "test") {
+    const error = new Error(
+      "the saved Evolution deployment is not a generated test deployment",
+    );
+    error.code = "EVOLUTION_TEST_DEPLOYMENT_NOT_ACTIVE";
+    throw error;
+  }
+  const destination = await verifyEvolutionDeployment(
+    { descriptorPath, trustRootPath },
+    options,
+  );
+  ensurePrivateFile(saved.profile.testPrivateKeyPath);
+  ensurePrivateFile(saved.profile.trustRootPath);
+  const privateKeyBytes = readFileSync(saved.profile.testPrivateKeyPath);
+  const fromTrustRootBytes = readFileSync(saved.profile.trustRootPath);
+  const privateKey = assertSigningPair(privateKeyBytes, fromTrustRootBytes);
+  if (
+    computeEvolutionDeploymentDigest(fromTrustRootBytes) !==
+    saved.profile.activeTrustRootDigest
+  ) {
+    throw new Error(
+      "generated test trust root does not match the active profile",
+    );
+  }
+  const rotation = {
+    schema: EVOLUTION_DEPLOYMENT_ROOT_ROTATION_SCHEMA,
+    fromTrustRootDigest: saved.profile.activeTrustRootDigest,
+    toTrustRootDigest: destination.descriptor.trustRootDigest,
+    minimumDescriptorRevision: destination.descriptor.revision,
+  };
+  rotation.signature = signBytes(
+    null,
+    Buffer.from(serializeEvolutionDeploymentRootRotationPayload(rotation)),
+    privateKey,
+  ).toString("base64");
+  const rotationPath = join(
+    dirname(saved.profile.descriptorPath),
+    "managed-root-rotation.json",
+  );
+  writePrivateAtomic(rotationPath, `${JSON.stringify(rotation, null, 2)}\n`);
+  const status = await configureEvolutionDeployment(
+    {
+      descriptorPath,
+      trustRootPath,
+      rootRotationPath: rotationPath,
+      enabled: true,
+      deploymentMode: "managed",
+      testPrivateKeyPath: null,
+    },
+    options,
+  );
+  return Object.freeze({
+    ...status,
+    replacedTestDeployment: true,
+    rootRotationPath: rotationPath,
+  });
+}

package/src/lib/model-context-window.js

@@ -2,6 +2,7 @@ import { resolveModelCapabilityProfile } from "./model-capabilities.js";
 
 export { CONTEXT_WINDOWS } from "./model-context-catalog.js";
 
-export function getContextWindow(model, provider) {
-  return resolveModelCapabilityProfile({ model, provider }).contextWindowTokens;
+export function getContextWindow(model, provider, options = {}) {
+  return resolveModelCapabilityProfile({ ...options, model, provider })
+    .contextWindowTokens;
 }

package/src/lib/runtime-usage-ledger.js

@@ -162,6 +162,11 @@ export function projectRuntimeTokenUsage(event = {}) {
     ...(projectedOperationId ? { operationId: projectedOperationId } : {}),
     ...(event.source ? { source: source(event.source) } : {}),
     ...(attribution ? { attribution } : {}),
+    ...(Number.isSafeInteger(event.contextWindow) &&
+    event.contextWindow >= 1024 &&
+    event.contextWindow <= 16777216
+      ? { contextWindow: event.contextWindow }
+      : {}),
   };
 }