@vtxmacro/cli 2026.9.35 → 2026.9.37

package/bin/vtx-service-bootstrap.js

@@ -16,7 +16,7 @@ import { fileURLToPath } from "node:url";
 // agent-cli-release.json
 var agent_cli_release_default = {
   package_name: "@vtxmacro/cli",
-  package_version: "2026.9.35",
+  package_version: "2026.9.37",
   codex_package_name: "@openai/codex",
   codex_version: "0.153.3",
   copilot_sdk_package_name: "@github/copilot-sdk",

package/bin/vtx.js

@@ -59,7 +59,7 @@ var init_define_VTX_EXO_POLICY = __esm({
 var define_VTX_GROK_POLICY_default;
 var init_define_VTX_GROK_POLICY = __esm({
   "<define:__VTX_GROK_POLICY__>"() {
-    define_VTX_GROK_POLICY_default = { subscription_proxy_base_url: "https://cli-chat-proxy.grok.com/v1", maximum_transport_request_bytes: 8388608, maximum_transport_response_bytes: 8388608, effective_model_aliases: { "grok-4.5": ["grok-4.5-build"] } };
+    define_VTX_GROK_POLICY_default = { subscription_proxy_base_url: "https://cli-chat-proxy.grok.com/v1", maximum_transport_request_bytes: 8388608, maximum_transport_response_bytes: 8388608 };
   }
 });
 
@@ -77,7 +77,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.9.35",
+      package_version: "2026.9.37",
       codex_package_name: "@openai/codex",
       codex_version: "0.153.3",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -389,9 +389,9 @@ function floatSafeRemainder(val, step) {
   const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
   return valInt % stepInt / 10 ** decCount;
 }
-function defineLazy(object5, key, getter) {
+function defineLazy(object6, key, getter) {
   let value = void 0;
-  Object.defineProperty(object5, key, {
+  Object.defineProperty(object6, key, {
     get() {
       if (value === EVALUATING) {
         return void 0;
@@ -403,7 +403,7 @@ function defineLazy(object5, key, getter) {
       return value;
     },
     set(v) {
-      Object.defineProperty(object5, key, {
+      Object.defineProperty(object6, key, {
         value: v
         // configurable: true,
       });
@@ -18654,28 +18654,28 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
         return await cachedSystemBootIdentity;
       }
       const read = async () => {
-        let identity = null;
+        let identity2 = null;
         if (platform === "linux") {
           try {
-            identity = (await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim();
+            identity2 = (await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim();
           } catch {
-            identity = null;
+            identity2 = null;
           }
         } else if (platform === "win32") {
           const invocation = windowsBootIdentityInvocation();
-          identity = await runSmallIdentityCommand(
+          identity2 = await runSmallIdentityCommand(
             "powershell.exe",
             invocation.args,
             invocation.env,
             invocation.timeoutMs
           );
         } else if (platform === "darwin") {
-          identity = await runSmallIdentityCommand("sysctl", ["-n", "kern.boottime"], void 0);
+          identity2 = await runSmallIdentityCommand("sysctl", ["-n", "kern.boottime"], void 0);
         }
-        if (!identity || /[\r\n\0]/u.test(identity)) {
+        if (!identity2 || /[\r\n\0]/u.test(identity2)) {
           throw new Error("Inference host could not establish the current system boot identity.");
         }
-        return `${platform}:${identity}`;
+        return `${platform}:${identity2}`;
       };
       const pending2 = read();
       if (platform === process.platform) cachedSystemBootIdentity = pending2;
@@ -18693,9 +18693,9 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
       return null;
     };
     defaultCurrentProcessIdentity = async () => {
-      const identity = await defaultProcessIdentity(process.pid);
-      if (!identity) throw new Error("Inference host could not establish its process-start identity.");
-      return identity;
+      const identity2 = await defaultProcessIdentity(process.pid);
+      if (!identity2) throw new Error("Inference host could not establish its process-start identity.");
+      return identity2;
     };
     processLockObservationCache = /* @__PURE__ */ new Map();
     inferenceProcessIdentitiesMatch = (stored, observed) => stored === observed;
@@ -18829,19 +18829,19 @@ function validateInferenceHostCredential(value) {
     updated_at: updatedAt
   };
 }
-function inferenceCredentialAccountKey(identity) {
-  const issuer = canonicalUrl(identity.issuer, "Inference OAuth issuer");
-  if (!identity.clientId || identity.clientId.length > 512) {
+function inferenceCredentialAccountKey(identity2) {
+  const issuer = canonicalUrl(identity2.issuer, "Inference OAuth issuer");
+  if (!identity2.clientId || identity2.clientId.length > 512) {
     throw new Error("Inference OAuth client ID is invalid.");
   }
-  if (!SAFE_IDENTIFIER.test(identity.hostId)) {
+  if (!SAFE_IDENTIFIER.test(identity2.hostId)) {
     throw new Error("Inference host ID is invalid.");
   }
   return createHash("sha256").update(
     JSON.stringify({
       issuer,
-      client_id: identity.clientId,
-      host_id: identity.hostId
+      client_id: identity2.clientId,
+      host_id: identity2.hostId
     }),
     "utf8"
   ).digest("hex");
@@ -34484,7 +34484,7 @@ var init_grok_binary = __esm({
 import { readFile as readFile6 } from "node:fs/promises";
 import { dirname as dirname7, resolve as resolve5 } from "node:path";
 import { fileURLToPath } from "node:url";
-var validateGrokPolicy, grokAllowedEffectiveModels, loadGrokPolicy;
+var validateGrokPolicy, loadGrokPolicy;
 var init_grok_policy = __esm({
   "lib/inference-host/grok-policy.ts"() {
     "use strict";
@@ -34502,26 +34502,12 @@ var init_grok_policy = __esm({
           throw new Error("Grok transport bounds are missing or invalid.");
         }
       }
-      const aliases = policy.effective_model_aliases;
-      if (!aliases || typeof aliases !== "object" || Array.isArray(aliases) || ![Object.prototype, null].includes(Object.getPrototypeOf(aliases)) || Object.keys(aliases).length > 64) throw new Error("Grok effective model aliases are missing or invalid.");
-      const validModel = (model) => typeof model === "string" && model.length > 0 && model.length <= 256 && model.trim() === model && !/[\u0000-\u001f\u007f]/u.test(model);
-      const entries = Object.entries(aliases);
-      for (const [requested, effective] of entries) {
-        if (!validModel(requested) || !Array.isArray(effective) || effective.length < 1 || effective.length > 15 || !effective.every(validModel) || new Set(effective).size !== effective.length || effective.includes(requested)) {
-          throw new Error("Grok effective model aliases are missing or invalid.");
-        }
-      }
-      const effectiveModelAliases = Object.freeze(Object.fromEntries(
-        entries.map(([requested, effective]) => [requested, Object.freeze([...effective])])
-      ));
       return Object.freeze({
         subscription_proxy_base_url: url2.href,
         maximum_transport_request_bytes: Number(policy.maximum_transport_request_bytes),
-        maximum_transport_response_bytes: Number(policy.maximum_transport_response_bytes),
-        effective_model_aliases: effectiveModelAliases
+        maximum_transport_response_bytes: Number(policy.maximum_transport_response_bytes)
       });
     };
-    grokAllowedEffectiveModels = (policy, requested) => Object.freeze([requested, ...Object.hasOwn(policy.effective_model_aliases, requested) ? policy.effective_model_aliases[requested] : []]);
     loadGrokPolicy = async () => {
       if (typeof define_VTX_GROK_POLICY_default !== "undefined") return validateGrokPolicy(define_VTX_GROK_POLICY_default);
       const config2 = parse3(await readFile6(resolve5(dirname7(fileURLToPath(import.meta.url)), "../../../config.toml"), "utf8"));
@@ -34530,6 +34516,46 @@ var init_grok_policy = __esm({
   }
 });
 
+// lib/inference-host/grok-model-catalog.ts
+var object3, identity, parseGrokModelCatalog;
+var init_grok_model_catalog = __esm({
+  "lib/inference-host/grok-model-catalog.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    object3 = (value) => {
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("grok_model_catalog_invalid");
+      return value;
+    };
+    identity = (value) => {
+      if (value == null) return void 0;
+      if (typeof value !== "string" || !value || value !== value.trim() || value.length > 256 || /[\u0000-\u001f\u007f]/u.test(value)) throw new Error("grok_model_catalog_identity_invalid");
+      return value;
+    };
+    parseGrokModelCatalog = (value) => {
+      const data4 = object3(value).data;
+      if (!Array.isArray(data4)) throw new Error("grok_model_catalog_invalid");
+      const result2 = /* @__PURE__ */ new Map();
+      for (const raw of data4) {
+        const row = object3(raw);
+        const meta3 = row._meta == null ? {} : object3(row._meta);
+        const id2 = identity(row.id);
+        const transportModel = identity(row.model) ?? identity(row.modelId) ?? id2 ?? identity(meta3.model) ?? identity(meta3.modelId);
+        if (!transportModel) throw new Error("grok_model_catalog_identity_missing");
+        const selector = id2 ?? transportModel;
+        if (result2.has(selector)) throw new Error("grok_model_catalog_identity_ambiguous");
+        result2.set(selector, Object.freeze({
+          selector,
+          transportModel,
+          allowedEffectiveModels: Object.freeze([.../* @__PURE__ */ new Set([selector, transportModel])])
+        }));
+      }
+      return result2;
+    };
+  }
+});
+
 // lib/inference-host/grok-transport-proxy.ts
 import { createServer as createServer3 } from "node:http";
 import { createHash as createHash6, randomBytes as randomBytes5 } from "node:crypto";
@@ -34541,6 +34567,7 @@ var init_grok_transport_proxy = __esm({
     init_define_VTX_EXO_POLICY();
     init_define_VTX_GROK_POLICY();
     init_define_VTX_PI_MODEL_POLICY();
+    init_grok_model_catalog();
     init_external_inference_contract();
     diagnosticNames = /* @__PURE__ */ new Set([
       "search_tool",
@@ -34574,6 +34601,8 @@ var init_grok_transport_proxy = __esm({
         this.requestFingerprints = /* @__PURE__ */ new Set();
         this.pending = false;
         this.closed = false;
+        this.catalogValue = null;
+        this.boundIdentity = null;
         this.observedModel = null;
         this.dispatched = false;
         this.responded = false;
@@ -34583,11 +34612,7 @@ var init_grok_transport_proxy = __esm({
         this.toolValidationFailure = null;
         this.responseIdentityFailure = null;
         const upstream = new URL(options.upstreamBaseUrl);
-        const models = options.allowedEffectiveModels ?? [options.requestedModel];
-        if (!models.includes(options.requestedModel) || models.length > 16 || new Set(models).size !== models.length || models.some((model) => typeof model !== "string" || !model.trim())) {
-          throw new Error("grok_proxy_invalid_configuration");
-        }
-        if (upstream.protocol !== "https:" || upstream.username || upstream.password || upstream.search || upstream.hash || !options.requestedModel || typeof options.expectedSystemPrompt !== "string" || !Number.isSafeInteger(options.deadlineAtMs) || options.providerDispatchNotAfterMs !== void 0 && !Number.isSafeInteger(options.providerDispatchNotAfterMs) || !Number.isSafeInteger(options.maxRequestBytes) || options.maxRequestBytes < 1 || !Number.isSafeInteger(options.maxResponseBytes) || options.maxResponseBytes < 1 || new Set(options.allowedToolNames).size !== options.allowedToolNames.length || options.allowedToolNames.some((name) => !name)) throw new Error("grok_proxy_invalid_configuration");
+        if (upstream.protocol !== "https:" || upstream.username || upstream.password || upstream.search || upstream.hash || !options.metadataOnly && !options.requestedModel || typeof options.expectedSystemPrompt !== "string" || !Number.isSafeInteger(options.deadlineAtMs) || options.providerDispatchNotAfterMs !== void 0 && !Number.isSafeInteger(options.providerDispatchNotAfterMs) || !Number.isSafeInteger(options.maxRequestBytes) || options.maxRequestBytes < 1 || !Number.isSafeInteger(options.maxResponseBytes) || options.maxResponseBytes < 1 || new Set(options.allowedToolNames).size !== options.allowedToolNames.length || options.allowedToolNames.some((name) => !name)) throw new Error("grok_proxy_invalid_configuration");
       }
       get baseUrl() {
         if (!this.urlValue) throw new Error("grok_proxy_not_started");
@@ -34602,6 +34627,18 @@ var init_grok_transport_proxy = __esm({
       get pendingRequest() {
         return this.pending;
       }
+      get modelCatalog() {
+        return this.catalogValue ? new Map(this.catalogValue) : null;
+      }
+      bindModelIdentity(selector, frozenProviderAllowance) {
+        if (this.options.metadataOnly || this.boundIdentity || this.pending || this.dispatched || this.closed || selector !== this.options.requestedModel) throw new Error("grok_model_identity_binding_invalid");
+        const identity2 = this.catalogValue?.get(selector);
+        if (!identity2) throw new Error("grok_model_catalog_identity_missing");
+        const allowed = identity2.allowedEffectiveModels.filter((model) => !frozenProviderAllowance || frozenProviderAllowance.includes(model));
+        if (!allowed.includes(identity2.transportModel)) throw new Error("grok_model_catalog_identity_changed");
+        this.boundIdentity = Object.freeze({ ...identity2, allowedEffectiveModels: Object.freeze(allowed) });
+        return this.boundIdentity;
+      }
       async start() {
         if (this.server) return;
         if (this.closed) throw new Error("grok_proxy_closed");
@@ -34651,7 +34688,8 @@ var init_grok_transport_proxy = __esm({
       }
       validatePayload(payload, route) {
         const requestedEffort = route === "/responses" ? record3(payload.reasoning).effort : payload.reasoning_effort;
-        if (payload.model !== this.options.requestedModel || effort(requestedEffort) !== effort(this.options.requestedReasoningEffort)) {
+        if (!this.boundIdentity) throw new Error("grok_model_identity_not_bound");
+        if (payload.model !== this.boundIdentity.transportModel || effort(requestedEffort) !== effort(this.options.requestedReasoningEffort)) {
           throw new Error("grok_outbound_model_or_effort_mismatch");
         }
         if (payload.stream !== true) throw new Error("grok_streaming_required");
@@ -34704,6 +34742,7 @@ var init_grok_transport_proxy = __esm({
           if (!authorization?.startsWith("Bearer ") || authorization.length <= 7) throw new Error("grok_proxy_auth_required");
           let body;
           if (inference) {
+            if (this.options.metadataOnly) throw new Error("grok_metadata_only");
             if (this.pending || this.failureCode || this.terminalFailure || this.rejectionStatus) {
               throw new Error("grok_redispatch_blocked");
             }
@@ -34754,7 +34793,7 @@ var init_grok_transport_proxy = __esm({
             if (typeof value === "string") headers.set(name, value);
           }
           if (inference) {
-            if (headers.has("x-grok-model-override") && headers.get("x-grok-model-override") !== this.options.requestedModel) {
+            if (headers.has("x-grok-model-override") && headers.get("x-grok-model-override") !== this.boundIdentity.transportModel) {
               throw new Error("grok_outbound_model_or_effort_mismatch");
             }
             this.checkDispatch();
@@ -34792,6 +34831,29 @@ var init_grok_transport_proxy = __esm({
             const value = upstream.headers.get(name);
             if (value) responseHeaders[name] = value;
           }
+          if (metadata && route === "/models") {
+            const chunks = [];
+            let bytes3 = 0;
+            const reader = upstream.body.getReader();
+            try {
+              for (; ; ) {
+                if (controller.signal.aborted) throw new Error("grok_proxy_cancelled");
+                const part = await reader.read();
+                if (part.done) break;
+                bytes3 += part.value.byteLength;
+                if (bytes3 > this.options.maxResponseBytes) throw new Error("grok_response_too_large");
+                chunks.push(part.value);
+              }
+            } finally {
+              await reader.cancel().catch(() => void 0);
+            }
+            const catalogBytes = Buffer.concat(chunks);
+            const catalog = parseGrokModelCatalog(JSON.parse(catalogBytes.toString("utf8")));
+            if (!this.boundIdentity) this.catalogValue = catalog;
+            response.writeHead(upstream.status, responseHeaders);
+            response.end(catalogBytes);
+            return;
+          }
           response.writeHead(upstream.status, responseHeaders);
           await this.forward(upstream, response, inference ? route : null, controller.signal);
           response.end();
@@ -34858,11 +34920,11 @@ var init_grok_transport_proxy = __esm({
           const event = record3(JSON.parse(data4));
           const native = route === "/responses" ? record3(event.response) : event;
           if (native.id !== void 0 || native.model !== void 0) {
-            if (typeof native.id !== "string" || !native.id || !(this.options.allowedEffectiveModels ?? [this.options.requestedModel]).includes(native.model) || id2 && native.id !== id2) {
+            if (typeof native.id !== "string" || !native.id || !this.boundIdentity.allowedEffectiveModels.includes(native.model) || id2 && native.id !== id2) {
               const idPresent = typeof native.id === "string" && native.id.length > 0;
               const modelPresent = typeof native.model === "string" && native.model.length > 0;
               const modelMatches = native.model === this.options.requestedModel;
-              if (idPresent && !modelMatches && id2 && native.id !== id2 && (this.options.allowedEffectiveModels ?? [this.options.requestedModel]).includes(native.model)) {
+              if (idPresent && !modelMatches && id2 && native.id !== id2 && this.boundIdentity.allowedEffectiveModels.includes(native.model)) {
                 throw new Error("grok_provider_response_id_changed");
               }
               const eventType = route === "/responses" ? event.type : event.object;
@@ -35641,29 +35703,49 @@ var init_grok_adapter = __esm({
         signal.throwIfAborted();
         const workspace = await createGrokOwnedWorkspace(this.stateOptions, "preflight");
         let session = null;
+        let proxy = null;
         try {
           signal.throwIfAborted();
-          session = new GrokAcpSession({ binaryPath: binary.path, grokHome: this.grokHome, cwd: workspace });
-          this.active.add(session);
           const deadline = Date.now() + 3e4;
+          const policy = this.options.policy ?? await loadGrokPolicy();
+          proxy = await createGrokTransportProxy({
+            upstreamBaseUrl: policy.subscription_proxy_base_url,
+            maxRequestBytes: policy.maximum_transport_request_bytes,
+            maxResponseBytes: policy.maximum_transport_response_bytes,
+            metadataOnly: true,
+            requestedModel: "",
+            requestedReasoningEffort: "none",
+            expectedSystemPrompt: "",
+            allowedToolNames: [],
+            deadlineAtMs: deadline,
+            signal,
+            fetchImpl: this.options.fetchImpl
+          });
+          session = new GrokAcpSession({
+            binaryPath: binary.path,
+            grokHome: this.grokHome,
+            cwd: workspace,
+            config: { endpoints: { cli_chat_proxy_base_url: proxy.baseUrl } }
+          });
+          this.active.add(session);
           await this.initialize(session, "VTX inference host capability discovery.", deadline, signal);
           const auth = unwrap(await session.request("_x.ai/auth/info", {}, deadline, signal));
           if (auth.methodId !== "cached_token" || auth.userBlockedReason || list(auth.teamBlockedReasons).length) {
             throw new Error("grok_subscription_auth_unavailable");
           }
           const state = unwrap(await session.request("_x.ai/models/list", {}, deadline, signal));
-          const policy = this.options.policy ?? await loadGrokPolicy();
-          const capabilities = grokModelCapabilities(state).map((capability) => ({
-            ...capability,
-            allowedEffectiveModels: grokAllowedEffectiveModels(policy, capability.model)
-          }));
+          const capabilities = grokModelCapabilities(state).map((capability) => {
+            const identity3 = proxy.modelCatalog?.get(capability.model);
+            if (!identity3) throw new Error("grok_model_catalog_identity_missing");
+            return { ...capability, allowedEffectiveModels: identity3.allowedEffectiveModels };
+          });
           if (!capabilities.length) throw new Error("grok_model_catalog_empty");
-          const identity = typeof auth.principalId === "string" && auth.principalId ? auth.principalId : typeof auth.email === "string" && auth.email ? auth.email.toLowerCase() : null;
-          if (!identity) throw new Error("grok_account_identity_required");
+          const identity2 = typeof auth.principalId === "string" && auth.principalId ? auth.principalId : typeof auth.email === "string" && auth.email ? auth.email.toLowerCase() : null;
+          if (!identity2) throw new Error("grok_account_identity_required");
           return {
             adapterId: "grok-build",
             runtimeVersion: binary.version,
-            authenticatedAccountIdentity: identity,
+            authenticatedAccountIdentity: identity2,
             authenticatedAccountEmail: typeof auth.email === "string" ? auth.email : null,
             authenticatedAccountPlan: null,
             modelCapabilities: capabilities,
@@ -35676,7 +35758,11 @@ var init_grok_adapter = __esm({
             await session?.close();
           } finally {
             if (session) this.active.delete(session);
-            await releaseGrokOwnedWorkspace(this.stateOptions, workspace);
+            try {
+              await proxy?.close();
+            } finally {
+              await releaseGrokOwnedWorkspace(this.stateOptions, workspace);
+            }
           }
         }
       }
@@ -35701,7 +35787,6 @@ var init_grok_adapter = __esm({
         const startedAt = Date.now();
         const binary = await this.binary();
         const policy = this.options.policy ?? await loadGrokPolicy();
-        const allowedEffectiveModels = grokAllowedEffectiveModels(policy, input.requestedModel);
         input.signal.throwIfAborted();
         const workspace = agent?.durableThread ? await validateGrokOwnedThread(this.stateOptions, agent.durableThread) : await createGrokOwnedWorkspace(this.stateOptions, agent ? "agent" : "attempt");
         let mcp = null;
@@ -35757,7 +35842,6 @@ var init_grok_adapter = __esm({
             expectedSystemPrompt: input.systemPrompt,
             requestedModel: input.requestedModel,
             requestedReasoningEffort: input.requestedReasoningEffort,
-            allowedEffectiveModels,
             allowedToolNames: agent ? ["search_tool", "use_tool"] : [],
             deadlineAtMs: input.deadlineAtMs,
             providerDispatchNotAfterMs: provider?.providerDispatchNotAfterMs,
@@ -35795,6 +35879,8 @@ var init_grok_adapter = __esm({
           const catalog = unwrap(await session.request("_x.ai/models/list", {}, input.deadlineAtMs, input.signal));
           const selectedCapability = grokModelCapabilities(catalog).find((entry) => entry.model === input.requestedModel);
           if (!selectedCapability?.supportedReasoningEfforts.includes(input.requestedReasoningEffort)) throw new Error("grok_model_selection_unavailable");
+          if (provider && !provider.allowedEffectiveModels) throw new Error("grok_model_identity_contract_missing");
+          const { allowedEffectiveModels, transportModel } = proxy.bindModelIdentity(input.requestedModel, provider?.allowedEffectiveModels);
           const metadata = {
             systemPromptOverride: input.systemPrompt,
             agentProfile: agentProfile(Boolean(agent)),
@@ -35821,6 +35907,14 @@ var init_grok_adapter = __esm({
               _meta: metadata
             }, input.deadlineAtMs, input.signal);
           }
+          if (transportModel !== input.requestedModel) {
+            created = await session.request("session/load", {
+              sessionId,
+              cwd: workspace,
+              mcpServers: mcp ? [mcp.descriptor] : [],
+              _meta: metadata
+            }, input.deadlineAtMs, input.signal);
+          }
           assertSelection(created, input.requestedModel, input.requestedReasoningEffort);
           const thread = {
             threadId: sessionId,
@@ -36024,7 +36118,7 @@ import { createServer as createServer5 } from "node:http";
 import { access as access3, lstat as lstat8, readdir as readdir4, realpath as realpath7, rm as rm9 } from "node:fs/promises";
 import { basename as basename4, dirname as dirname9, join as join12, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var import_ajv2, failure, object3, receiptUsage, assertOwnedRuntime, cleanupExoOwnedState, ExoForegroundAdapter;
+var import_ajv2, failure, object4, receiptUsage, assertOwnedRuntime, cleanupExoOwnedState, ExoForegroundAdapter;
 var init_exo_adapter = __esm({
   "lib/inference-host/exo-adapter.ts"() {
     "use strict";
@@ -36042,9 +36136,9 @@ var init_exo_adapter = __esm({
       retryable: false,
       dispatchOutcome: dispatched ? "outcome_unknown" : "not_dispatched"
     });
-    object3 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    object4 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
     receiptUsage = (value) => {
-      const usage = object3(value);
+      const usage = object4(value);
       for (const key of ["inputTokens", "cachedInputTokens", "outputTokens", "reasoningOutputTokens", "totalTokens"]) {
         if (!Number.isSafeInteger(usage[key]) || Number(usage[key]) < 0) return null;
       }
@@ -36063,7 +36157,7 @@ var init_exo_adapter = __esm({
       const info = await lstat8(root);
       if (!info.isDirectory() || info.isSymbolicLink() || await realpath7(root) !== root) throw failure("exo_state_not_owned");
       const raw = await readInferencePrivateFile(join12(root, "vtx-owner.json"), "Exo state owner");
-      const owner2 = raw === null ? {} : object3(JSON.parse(raw));
+      const owner2 = raw === null ? {} : object4(JSON.parse(raw));
       if (owner2.adapter !== "exo" || owner2.id !== id2 || owner2.root !== root) throw failure("exo_state_not_owned");
     };
     cleanupExoOwnedState = async (stateRoot) => {
@@ -36265,7 +36359,7 @@ var init_exo_adapter = __esm({
               raw += String(chunk);
               if (Buffer.byteLength(raw) > 2e6) throw failure("exo_bridge_input_too_large");
             }
-            const body = object3(JSON.parse(raw));
+            const body = object4(JSON.parse(raw));
             if (terminal || workerFailure) throw failure("exo_turn_already_finished");
             if (request.url === "/dispatch") {
               if (body.model !== providerModel || body.reasoningEffort !== input.requestedReasoningEffort) throw failure("exo_dispatch_identity_mismatch");
@@ -36282,7 +36376,7 @@ var init_exo_adapter = __esm({
               if (!agent || !dispatched || toolBusy || typeof body.callId !== "string" || toolIds.has(body.callId) || !CODEX_AGENT_DYNAMIC_TOOLS.includes(body.tool) || body.effectiveModel !== input.requestedModel || body.effectiveReasoningEffort !== input.requestedReasoningEffort) throw failure("exo_tool_not_authorized");
               toolBusy = true;
               toolIds.add(body.callId);
-              const call = { callId: body.callId, tool: body.tool, arguments: object3(body.arguments) };
+              const call = { callId: body.callId, tool: body.tool, arguments: object4(body.arguments) };
               try {
                 let result2;
                 try {
@@ -36500,11 +36594,11 @@ var init_exo_credential_store = __esm({
       }
       const provider = validateProvider(record4.provider);
       const apiKey = validateApiKey(record4.api_key);
-      const identity = credentialIdentity(provider, apiKey);
-      if (record4.schema_version !== 1 || record4.adapter !== "exo" || record4.identity !== identity || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,provider,schema_version") {
+      const identity2 = credentialIdentity(provider, apiKey);
+      if (record4.schema_version !== 1 || record4.adapter !== "exo" || record4.identity !== identity2 || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,provider,schema_version") {
         throw new Error("Stored Exo credential failed validation.");
       }
-      return { provider, apiKey, identity };
+      return { provider, apiKey, identity: identity2 };
     };
     serializeCredential = (provider, apiKey) => {
       const validated = validateApiKey(apiKey);
@@ -36698,11 +36792,11 @@ var init_pi_credential_store = __esm({
       const record4 = value;
       const provider = validateProvider2(String(record4.provider ?? ""));
       const apiKey = validateApiKey2(String(record4.api_key ?? ""));
-      const identity = credentialIdentity2(provider, apiKey);
-      if (record4.schema_version !== 1 || record4.adapter !== "pi" || record4.identity !== identity || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,provider,schema_version") {
+      const identity2 = credentialIdentity2(provider, apiKey);
+      if (record4.schema_version !== 1 || record4.adapter !== "pi" || record4.identity !== identity2 || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,provider,schema_version") {
         throw new Error("Stored Pi credential failed validation.");
       }
-      return { provider, apiKey, identity };
+      return { provider, apiKey, identity: identity2 };
     };
     serializeCredential2 = (provider, apiKey) => {
       const validated = validateApiKey2(apiKey);
@@ -36854,11 +36948,11 @@ var init_deepseek_credential_store = __esm({
       }
       const record4 = value;
       const apiKey = validateApiKey3(String(record4.api_key ?? ""));
-      const identity = credentialIdentity3(apiKey);
-      if (record4.schema_version !== 1 || record4.adapter !== "deepseek-harness" || record4.identity !== identity || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,schema_version") {
+      const identity2 = credentialIdentity3(apiKey);
+      if (record4.schema_version !== 1 || record4.adapter !== "deepseek-harness" || record4.identity !== identity2 || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,schema_version") {
         throw new Error("Stored DeepSeek Harness credential failed validation.");
       }
-      return { apiKey, identity };
+      return { apiKey, identity: identity2 };
     };
     serializeCredential3 = (apiKey) => {
       const validated = validateApiKey3(apiKey);
@@ -37112,8 +37206,8 @@ var init_crypto = __esm({
       cipher.setAAD(aad);
       return Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()]);
     };
-    assertIdentity = (aad, identity) => {
-      if (aad.job_id !== identity.job_id || aad.host_id !== identity.host_id || aad.host_generation !== identity.host_generation || aad.key_generation !== identity.key_generation || aad.claim_generation !== identity.claim_generation) {
+    assertIdentity = (aad, identity2) => {
+      if (aad.job_id !== identity2.job_id || aad.host_id !== identity2.host_id || aad.host_generation !== identity2.host_generation || aad.key_generation !== identity2.key_generation || aad.claim_generation !== identity2.claim_generation) {
         throw new ExternalInferenceEnvelopeError(
           "identity_mismatch",
           "External inference envelope identity is invalid."
@@ -37270,7 +37364,7 @@ var init_crypto = __esm({
           "External inference claim does not contain a job."
         );
       }
-      const identity = {
+      const identity2 = {
         job_id: claim.job_id,
         host_id: claim.host_id,
         host_generation: claim.host_generation,
@@ -37280,9 +37374,9 @@ var init_crypto = __esm({
       const jobKey = unwrapExternalInferenceJobKey(
         hostPrivateKey,
         claim.sealed_job_key,
-        identity
+        identity2
       );
-      const jobInput = decryptExternalInferenceJobInput(jobKey, claim.sealed_input, identity);
+      const jobInput = decryptExternalInferenceJobInput(jobKey, claim.sealed_input, identity2);
       if (jobInput.advertisement_generation !== claim.advertisement_generation || jobInput.controller_generation !== claim.controller_generation || jobInput.input_sha256 !== claim.input_sha256 || jobInput.requested_model !== claim.requested_model || jobInput.requested_reasoning_effort !== claim.requested_reasoning_effort || jobInput.response_mode !== claim.response_mode || jobInput.output_schema_version !== claim.output_schema_version) {
         throw new ExternalInferenceEnvelopeError(
           "identity_mismatch",
@@ -40295,6 +40389,9 @@ var init_runner = __esm({
             userPrompt: jobInput.user_prompt,
             outputSchemaJson: outputContract.adapterSchemaJson,
             requestedModel: jobInput.requested_model,
+            allowedEffectiveModels: jobInput.allowed_model_identities.find(
+              (mapping2) => mapping2.requested_model === jobInput.requested_model
+            )?.effective_models,
             requestedReasoningEffort: jobInput.requested_reasoning_effort,
             deadlineAtMs: Date.parse(jobInput.deadline_at),
             ...providerDispatchNotAfterMs === void 0 ? {} : { providerDispatchNotAfterMs },
@@ -42083,8 +42180,8 @@ WantedBy=default.target
         }
       }
       windowsTaskName() {
-        const identity = this.username.replaceAll(/[^A-Za-z0-9_.@-]+/gu, "_").slice(-80) || "current-user";
-        return `VTX Macro Inference Host (${identity})`;
+        const identity2 = this.username.replaceAll(/[^A-Za-z0-9_.@-]+/gu, "_").slice(-80) || "current-user";
+        return `VTX Macro Inference Host (${identity2})`;
       }
       windowsPowerShell(script) {
         return [
@@ -46307,16 +46404,16 @@ Waiting for approval...
     hasExplicitCredentialStoreConfiguration = (env) => Boolean(
       String(env.VTX_INFERENCE_HOST_CREDENTIAL_STORE || "").trim() || String(env.VTX_INFERENCE_HOST_CREDENTIAL_FILE || "").trim()
     );
-    credentialEnvironmentForIdentity = (identity) => {
-      if (identity.startsWith("file:")) {
-        const path = identity.slice("file:".length);
+    credentialEnvironmentForIdentity = (identity2) => {
+      if (identity2.startsWith("file:")) {
+        const path = identity2.slice("file:".length);
         if (!path) throw new Error("Inference host credential store identity is invalid.");
         return {
           VTX_INFERENCE_HOST_CREDENTIAL_STORE: "file",
           VTX_INFERENCE_HOST_CREDENTIAL_FILE: path
         };
       }
-      if (identity.startsWith("os:")) {
+      if (identity2.startsWith("os:")) {
         return {
           VTX_INFERENCE_HOST_CREDENTIAL_STORE: "os",
           VTX_INFERENCE_HOST_CREDENTIAL_FILE: void 0
@@ -54116,10 +54213,10 @@ function arrayifyInteger(value) {
   }
   return result2;
 }
-function _encode2(object5) {
-  if (Array.isArray(object5)) {
+function _encode2(object6) {
+  if (Array.isArray(object6)) {
     let payload = [];
-    object5.forEach(function(child) {
+    object6.forEach(function(child) {
       payload = payload.concat(_encode2(child));
     });
     if (payload.length <= 55) {
@@ -54130,7 +54227,7 @@ function _encode2(object5) {
     length2.unshift(247 + length2.length);
     return length2.concat(payload);
   }
-  const data4 = Array.prototype.slice.call(getBytes(object5, "object"));
+  const data4 = Array.prototype.slice.call(getBytes(object6, "object"));
   if (data4.length === 1 && data4[0] <= 127) {
     return data4;
   } else if (data4.length <= 55) {
@@ -54141,9 +54238,9 @@ function _encode2(object5) {
   length.unshift(183 + length.length);
   return length.concat(data4);
 }
-function encodeRlp(object5) {
+function encodeRlp(object6) {
   let result2 = "0x";
-  for (const v of _encode2(object5)) {
+  for (const v of _encode2(object6)) {
     result2 += nibbles[v >> 4];
     result2 += nibbles[v & 15];
   }
@@ -54291,15 +54388,15 @@ function toObject(names2, items, deep) {
 }
 function checkResultErrors(result2) {
   const errors = [];
-  const checkErrors = function(path, object5) {
-    if (!Array.isArray(object5)) {
+  const checkErrors = function(path, object6) {
+    if (!Array.isArray(object6)) {
       return;
     }
-    for (let key in object5) {
+    for (let key in object6) {
       const childPath = path.slice();
       childPath.push(key);
       try {
-        checkErrors(childPath, object5[key]);
+        checkErrors(childPath, object6[key]);
       } catch (error48) {
         errors.push({ path: childPath, error: error48 });
       }
@@ -56549,15 +56646,15 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   return genUntil;
 }
-function validateObject(object5, validators, optValidators = {}) {
+function validateObject(object6, validators, optValidators = {}) {
   const checkField = (fieldName, type, isOptional) => {
     const checkVal = validatorFns[type];
     if (typeof checkVal !== "function")
       throw new Error(`Invalid validator "${type}", expected function`);
-    const val = object5[fieldName];
+    const val = object6[fieldName];
     if (isOptional && val === void 0)
       return;
-    if (!checkVal(val, object5)) {
+    if (!checkVal(val, object6)) {
       throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
     }
   };
@@ -56565,7 +56662,7 @@ function validateObject(object5, validators, optValidators = {}) {
     checkField(fieldName, type, false);
   for (const [fieldName, type] of Object.entries(optValidators))
     checkField(fieldName, type, true);
-  return object5;
+  return object6;
 }
 var _0n2, _1n2, _2n2, u8a3, hexes, bitSet, bitMask, u8n, u8fr, validatorFns;
 var init_utils4 = __esm({
@@ -56592,7 +56689,7 @@ var init_utils4 = __esm({
       stringOrUint8Array: (val) => typeof val === "string" || val instanceof Uint8Array,
       isSafeInteger: (val) => Number.isSafeInteger(val),
       array: (val) => Array.isArray(val),
-      field: (val, object5) => object5.Fp.isValid(val),
+      field: (val, object6) => object6.Fp.isValid(val),
       hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
     };
   }
@@ -68330,7 +68427,7 @@ function arrayOf(format, allowNull2) {
     return array2.map((i) => format(i));
   });
 }
-function object4(format, altNames) {
+function object5(format, altNames) {
   return ((value) => {
     const result2 = {};
     for (const key in format) {
@@ -68398,7 +68495,7 @@ function formatTransactionResponse(value) {
   if (value.to && getBigInt(value.to) === BN_011) {
     value.to = "0x0000000000000000000000000000000000000000";
   }
-  const result2 = object4({
+  const result2 = object5({
     hash: formatHash,
     // Some nodes do not return this, usually test nodes (like Ganache)
     index: allowNull(getNumber, void 0),
@@ -68484,7 +68581,7 @@ var init_format = __esm({
     init_transaction2();
     init_utils();
     BN_011 = BigInt(0);
-    _formatLog = object4({
+    _formatLog = object5({
       address: getAddress,
       blockHash: formatHash,
       blockNumber: getNumber,
@@ -68497,7 +68594,7 @@ var init_format = __esm({
     }, {
       index: ["logIndex"]
     });
-    _formatBlock = object4({
+    _formatBlock = object5({
       hash: allowNull(formatHash),
       parentHash: formatHash,
       parentBeaconBlockRoot: allowNull(formatHash, null),
@@ -68518,7 +68615,7 @@ var init_format = __esm({
     }, {
       prevRandao: ["mixHash"]
     });
-    _formatReceiptLog = object4({
+    _formatReceiptLog = object5({
       transactionIndex: getNumber,
       blockNumber: getNumber,
       transactionHash: formatHash,
@@ -68530,7 +68627,7 @@ var init_format = __esm({
     }, {
       index: ["logIndex"]
     });
-    _formatTransactionReceipt = object4({
+    _formatTransactionReceipt = object5({
       to: allowNull(getAddress, null),
       from: allowNull(getAddress, null),
       contractAddress: allowNull(getAddress, null),
@@ -79336,13 +79433,13 @@ function getPassword(password) {
   }
   return getBytesCopy(password);
 }
-function spelunk(object5, _path) {
+function spelunk(object6, _path) {
   const match = _path.match(/^([a-z0-9$_.-]*)(:([a-z]+))?(!)?$/i);
   assertArgument(match != null, "invalid path", "path", _path);
   const path = match[1];
   const type = match[3];
   const reqd = match[4] === "!";
-  let cur = object5;
+  let cur = object6;
   for (const comp of path.toLowerCase().split(".")) {
     if (Array.isArray(cur)) {
       if (!comp.match(/^[0-9]+$/)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtxmacro/cli",
-  "version": "2026.9.35",
+  "version": "2026.9.37",
   "description": "VTX Macro CLI, MCP server, and durable external inference host.",
   "type": "module",
   "license": "UNLICENSED",