@vtxmacro/cli 2026.9.33 → 2026.9.35

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.33",
+  package_version: "2026.9.35",
   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 };
+    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"] } };
   }
 });
 
@@ -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.33",
+      package_version: "2026.9.35",
       codex_package_name: "@openai/codex",
       codex_version: "0.153.3",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -14722,7 +14722,7 @@ var init_zod = __esm({
 });
 
 // lib/external-inference-contract.ts
-var EXTERNAL_INFERENCE_CONTRACT_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION_V2, EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION, EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION, EXTERNAL_INFERENCE_COMPRESSED_INPUT_ENVELOPE_SCHEMA_VERSION, EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, LEGACY_EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION, EXTERNAL_INFERENCE_INPUT_HASH_DOMAIN, MAX_EXTERNAL_INFERENCE_STATUS_HOSTS, MAX_PROFILE_EXTERNAL_INFERENCE_FALLBACKS_PER_LANE, MAX_GENERATION, MAX_SAFE_INTEGER, MAX_PROMPT_BYTES, MAX_IMMUTABLE_JOB_INPUT_BYTES, MAX_CANDIDATE_PLAINTEXT_BYTES, MAX_CIPHERTEXT_CHARS, SHA256_INITIAL_STATE, SHA256_ROUND_CONSTANTS, rotateRight, sha256BytesHex, sha256Utf8Hex, computeImmutableJobInputSha256, identifierSchema, operationIdentifierSchema, sha256HexSchema, generationSchema, zeroBasedGenerationSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, sqlIntegerTokenCountSchema, timestampSchema, safeCodeSchema, processExitCodeSchema, externalInferenceAdapterIdSchema, reasoningEffortSchema, modelNameSchema, displayNameSchema, authenticatedAccountEmailSchema, protocolVersionSchema, base64UrlAlphabet, isCanonicalBase64Url, base64Url32BytesSchema, base64UrlNonceSchema, base64UrlCiphertextSchema, claimHandleSchema, boundedJsonTextSchema, boundedPromptTextSchema, laneSchema, botModeSchema, executionModeSchema, responseModeSchema, controlModeSchema, dispatchOutcomeSchema, responseOutcomeSchema, nativeModelControllerSchema, legacyExternalAgentModelControllerSchema, externalAgentModelControllerSchema, boundExternalAgentModelControllerSchema, externalAgentUnboundControllerSchema, externalAgentUnboundControllerV2Schema, orderedFallbackHostIdsSchema, externalInferenceFallbackHostIdsSchema, liveModelControllerSchema, snapshotModelControllerSchema, modelIdentityMappingSchema, advertisedModelSchema, hostAdvertisementSchema, envelopeAadSchema, validateEnvelopeAad, commonEnvelopeShape, sealedKeyWrapEnvelopeSchema, sealedInputEnvelopeSchema, sealedCandidateEnvelopeSchema, sealedEnvelopeSchema, screenerCandidateRuntimeBindingSchema, screenerClientLeaseBindingSchema, screenerRuntimeBindingSchema, serverRuntimeBindingSchema, clientRuntimeBindingSchema, runtimeBindingSchema, immutableJobInputSchema, canonicalizeJsonValue, serializeImmutableJobInput, reportedTokenUsageSchema, unavailableTokenUsageSchema, tokenUsageSchema, grokToolValidationDiagnosticSchema, agentTurnReceiptSchema, agentConnectRequestSchema, agentNextRequestSchema, agentHeartbeatRequestSchema, emptyAgentNextResultSchema, claimedAgentNextResultSchema, agentNextResultSchema, agentCompleteRequestSchema, agentFailRequestSchema, requestedModelSelectionSchema, completedModelProvenanceSchema, attemptModelProvenanceSchema, providerWeeklyQuotaReadSchema, hostHeartbeatRequestSchema, jobClaimRequestBaseShape, jobClaimRequestSchema, emptyJobClaimSchema, claimedJobSchema, claimedDispatchIntentSchema, batchedJobClaimSchema, timedBatchedJobClaimSchema, jobClaimResultSchema, attemptStartRequestSchema, jobHeartbeatRequestSchema, continueHeartbeatDirectiveSchema, cancelHeartbeatDirectiveSchema, jobHeartbeatResultSchema, adapterOutcomeEvidenceSchema, completionBaseShape, validateCompletion, providerResponseCompletionSchema, decisionCandidateCompletionSchema, jobCompleteRequestSchema, codexProcessExitDiagnosticsSchema, jobFailRequestSchema, jobCancelRequestSchema, jobCancellationReceiptSchema, jobDeliveryRequestSchema, deliveryBaseShape, validateDeliveryCandidate, providerResponseDeliverySchema, decisionCandidateDeliverySchema, jobDeliveryResultSchema, jobConsumptionRequestSchema, jobConsumptionReceiptSchema, jobStateSchema, jobStatusReadSchema, hostStatusReadSchema, controllerBindingStatusReadSchema, queueStatusReadSchema, outcomeStatusReadSchema, externalInferenceVolumeWindowReadSchema, externalInferenceFailureCountReadSchema, externalInferenceHostDiagnosticsReadSchema, externalInferenceProfileActivityReadSchema, externalInferenceStatusReadSchema, nativeResearchEvidenceSourceSchema, externalAgentResearchEvidenceSourceSchema, researchEvidenceSourceSchema, reportedResearchTokenUsageSchema, unavailableResearchTokenUsageSchema, researchTokenUsageSchema, externalInferenceProductLineageBaseShape, traderExternalInferenceProductLineageSchema, decisionChatExternalInferenceProductLineageSchema, screenerExternalInferenceProductLineageSchema, externalInferenceProductLineageSchema, normalProductLinkageSchema, evidenceMaterializationMarkerSchema, deliveredExternalAgentSourceIdentitySchema, deliveredRequestEvidenceSchema, researchEvidenceBaseShape, researchEvidenceBaseSchema, validateExactUtf8, validateResearchEvidence, providerResponseResearchEvidenceSchema, decisionCandidateResearchEvidenceSchema, researchEvidenceSchema;
+var EXTERNAL_INFERENCE_CONTRACT_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION_V2, EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION, EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION, EXTERNAL_INFERENCE_COMPRESSED_INPUT_ENVELOPE_SCHEMA_VERSION, EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, LEGACY_EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION, EXTERNAL_INFERENCE_INPUT_HASH_DOMAIN, MAX_EXTERNAL_INFERENCE_STATUS_HOSTS, MAX_PROFILE_EXTERNAL_INFERENCE_FALLBACKS_PER_LANE, MAX_GENERATION, MAX_SAFE_INTEGER, MAX_PROMPT_BYTES, MAX_IMMUTABLE_JOB_INPUT_BYTES, MAX_CANDIDATE_PLAINTEXT_BYTES, MAX_CIPHERTEXT_CHARS, SHA256_INITIAL_STATE, SHA256_ROUND_CONSTANTS, rotateRight, sha256BytesHex, sha256Utf8Hex, computeImmutableJobInputSha256, identifierSchema, operationIdentifierSchema, sha256HexSchema, generationSchema, zeroBasedGenerationSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, sqlIntegerTokenCountSchema, timestampSchema, safeCodeSchema, processExitCodeSchema, externalInferenceAdapterIdSchema, reasoningEffortSchema, modelNameSchema, displayNameSchema, authenticatedAccountEmailSchema, protocolVersionSchema, base64UrlAlphabet, isCanonicalBase64Url, base64Url32BytesSchema, base64UrlNonceSchema, base64UrlCiphertextSchema, claimHandleSchema, boundedJsonTextSchema, boundedPromptTextSchema, laneSchema, botModeSchema, executionModeSchema, responseModeSchema, controlModeSchema, dispatchOutcomeSchema, responseOutcomeSchema, nativeModelControllerSchema, legacyExternalAgentModelControllerSchema, externalAgentModelControllerSchema, boundExternalAgentModelControllerSchema, externalAgentUnboundControllerSchema, externalAgentUnboundControllerV2Schema, orderedFallbackHostIdsSchema, externalInferenceFallbackHostIdsSchema, liveModelControllerSchema, snapshotModelControllerSchema, modelIdentityMappingSchema, advertisedModelSchema, hostAdvertisementSchema, envelopeAadSchema, validateEnvelopeAad, commonEnvelopeShape, sealedKeyWrapEnvelopeSchema, sealedInputEnvelopeSchema, sealedCandidateEnvelopeSchema, sealedEnvelopeSchema, screenerCandidateRuntimeBindingSchema, screenerClientLeaseBindingSchema, screenerRuntimeBindingSchema, serverRuntimeBindingSchema, clientRuntimeBindingSchema, runtimeBindingSchema, immutableJobInputSchema, canonicalizeJsonValue, serializeImmutableJobInput, reportedTokenUsageSchema, unavailableTokenUsageSchema, tokenUsageSchema, grokToolValidationDiagnosticSchema, grokResponseIdentityDiagnosticSchema, agentTurnReceiptSchema, agentConnectRequestSchema, agentNextRequestSchema, agentHeartbeatRequestSchema, emptyAgentNextResultSchema, claimedAgentNextResultSchema, agentNextResultSchema, agentCompleteRequestSchema, agentFailRequestSchema, requestedModelSelectionSchema, completedModelProvenanceSchema, attemptModelProvenanceSchema, providerWeeklyQuotaReadSchema, hostHeartbeatRequestSchema, jobClaimRequestBaseShape, jobClaimRequestSchema, emptyJobClaimSchema, claimedJobSchema, claimedDispatchIntentSchema, batchedJobClaimSchema, timedBatchedJobClaimSchema, jobClaimResultSchema, attemptStartRequestSchema, jobHeartbeatRequestSchema, continueHeartbeatDirectiveSchema, cancelHeartbeatDirectiveSchema, jobHeartbeatResultSchema, adapterOutcomeEvidenceSchema, completionBaseShape, validateCompletion, providerResponseCompletionSchema, decisionCandidateCompletionSchema, jobCompleteRequestSchema, codexProcessExitDiagnosticsSchema, jobFailRequestSchema, jobCancelRequestSchema, jobCancellationReceiptSchema, jobDeliveryRequestSchema, deliveryBaseShape, validateDeliveryCandidate, providerResponseDeliverySchema, decisionCandidateDeliverySchema, jobDeliveryResultSchema, jobConsumptionRequestSchema, jobConsumptionReceiptSchema, jobStateSchema, jobStatusReadSchema, hostStatusReadSchema, controllerBindingStatusReadSchema, queueStatusReadSchema, outcomeStatusReadSchema, externalInferenceVolumeWindowReadSchema, externalInferenceFailureCountReadSchema, externalInferenceHostDiagnosticsReadSchema, externalInferenceProfileActivityReadSchema, externalInferenceStatusReadSchema, nativeResearchEvidenceSourceSchema, externalAgentResearchEvidenceSourceSchema, researchEvidenceSourceSchema, reportedResearchTokenUsageSchema, unavailableResearchTokenUsageSchema, researchTokenUsageSchema, externalInferenceProductLineageBaseShape, traderExternalInferenceProductLineageSchema, decisionChatExternalInferenceProductLineageSchema, screenerExternalInferenceProductLineageSchema, externalInferenceProductLineageSchema, normalProductLinkageSchema, evidenceMaterializationMarkerSchema, deliveredExternalAgentSourceIdentitySchema, deliveredRequestEvidenceSchema, researchEvidenceBaseShape, researchEvidenceBaseSchema, validateExactUtf8, validateResearchEvidence, providerResponseResearchEvidenceSchema, decisionCandidateResearchEvidenceSchema, researchEvidenceSchema;
 var init_external_inference_contract = __esm({
   "lib/external-inference-contract.ts"() {
     "use strict";
@@ -15516,10 +15516,25 @@ var init_external_inference_contract = __esm({
       (value) => value.prior_dispatch || value.completed_response_count === 0,
       { message: "Completed responses require prior dispatch." }
     );
+    grokResponseIdentityDiagnosticSchema = external_exports.strictObject({
+      schema_version: external_exports.literal("external_inference_grok_response_identity_v1"),
+      reason: external_exports.enum(["invalid_id", "model_mismatch", "changed_id"]),
+      route: external_exports.enum(["/responses", "/chat/completions"]),
+      response_event: external_exports.enum(["response.created", "response.in_progress", "response.completed", "chat.completion.chunk", "other"]),
+      id_present: external_exports.boolean(),
+      id_matches_previous: external_exports.boolean().nullable(),
+      model_present: external_exports.boolean(),
+      model_matches_requested: external_exports.boolean(),
+      model_sha256: sha256HexSchema.nullable()
+    }).refine(
+      (value) => value.model_present === (value.model_sha256 !== null) && (!value.model_matches_requested || value.model_present) && (value.id_matches_previous !== true || value.id_present) && (value.reason === "invalid_id" ? !value.id_present : value.reason === "model_mismatch" ? value.id_present && !value.model_matches_requested : value.id_present && value.model_matches_requested && value.id_matches_previous === false),
+      { message: "Grok response identity observations must match their rejection reason." }
+    );
     agentTurnReceiptSchema = external_exports.strictObject({
       terminal_status: external_exports.enum(["completed", "failed"]),
       failure_code: safeCodeSchema.nullable(),
       grok_tool_validation: grokToolValidationDiagnosticSchema.optional(),
+      grok_response_identity: grokResponseIdentityDiagnosticSchema.optional(),
       dispatch_outcome: external_exports.enum(["not_dispatched", "outcome_unknown"]).optional(),
       turn_id: external_exports.string().uuid(),
       agent_run_id: identifierSchema,
@@ -15537,8 +15552,11 @@ var init_external_inference_contract = __esm({
         { message: "Agent decision operation IDs must be unique." }
       )
     }).refine(
-      (value) => value.grok_tool_validation === void 0 ? value.dispatch_outcome === void 0 : value.terminal_status === "failed" && value.failure_code === `grok_tool_isolation_${value.grok_tool_validation.reason}` && value.dispatch_outcome === (value.grok_tool_validation.prior_dispatch ? "outcome_unknown" : "not_dispatched") && value.effective_model === null && value.effective_reasoning_effort === null && value.adapter_request_id === null && value.adapter_response_id === null && value.usage.availability === "unavailable",
+      (value) => value.grok_tool_validation === void 0 ? value.grok_response_identity !== void 0 || value.dispatch_outcome === void 0 : value.grok_response_identity === void 0 && value.terminal_status === "failed" && value.failure_code === `grok_tool_isolation_${value.grok_tool_validation.reason}` && value.dispatch_outcome === (value.grok_tool_validation.prior_dispatch ? "outcome_unknown" : "not_dispatched") && value.effective_model === null && value.effective_reasoning_effort === null && value.adapter_request_id === null && value.adapter_response_id === null && value.usage.availability === "unavailable",
       { message: "Grok diagnostics must match the failed Agent turn and dispatch outcome." }
+    ).refine(
+      (value) => value.grok_response_identity === void 0 || value.terminal_status === "failed" && value.failure_code === "grok_provider_identity_mismatch" && value.dispatch_outcome === "outcome_unknown" && value.grok_tool_validation === void 0 && value.effective_model === null && value.effective_reasoning_effort === null && value.adapter_request_id === null && value.adapter_response_id === null && value.usage.availability === "unavailable",
+      { message: "Grok response identity diagnostics require an unaccepted dispatched Agent turn." }
     ).refine(
       (value) => value.terminal_status === "failed" ? value.failure_code !== null : value.failure_code === null && value.effective_model !== null && value.effective_reasoning_effort !== null && value.adapter_response_id !== null,
       { message: "Agent terminal evidence is incomplete." }
@@ -16038,6 +16056,7 @@ var init_external_inference_contract = __esm({
       provider_dispatch_freshness_remaining_ms: nonNegativeSafeIntegerSchema.nullable().optional(),
       process_exit: codexProcessExitDiagnosticsSchema.nullable().optional(),
       grok_tool_validation: grokToolValidationDiagnosticSchema.optional(),
+      grok_response_identity: grokResponseIdentityDiagnosticSchema.optional(),
       membership_disposition: external_exports.enum([
         "retry_same_host",
         "cascade_cooldown",
@@ -16047,6 +16066,9 @@ var init_external_inference_contract = __esm({
       ]).optional(),
       failed_at: timestampSchema
     }).superRefine((value, context) => {
+      if (value.grok_response_identity !== void 0 && (value.failure_code !== "grok_provider_identity_mismatch" || value.outcome.dispatch_outcome !== "outcome_unknown" || value.grok_tool_validation !== void 0)) {
+        context.addIssue({ code: "custom", message: "Grok response identity diagnostics require an unaccepted dispatched attempt.", path: ["grok_response_identity"] });
+      }
       if (value.grok_tool_validation !== void 0 && (value.failure_code !== `grok_tool_isolation_${value.grok_tool_validation.reason}` || value.outcome.dispatch_outcome !== (value.grok_tool_validation.prior_dispatch ? "outcome_unknown" : "not_dispatched"))) {
         context.addIssue({ code: "custom", message: "Grok diagnostics must match the failure and dispatch outcome.", path: ["grok_tool_validation"] });
       }
@@ -19976,6 +19998,7 @@ var init_mcp_client = __esm({
       #initialized = false;
       #providerQuotaRecoverySupported = false;
       #grokToolValidationTools = /* @__PURE__ */ new Set();
+      #grokResponseIdentityTools = /* @__PURE__ */ new Set();
       supportsGrokToolValidationDiagnostics(tool) {
         return this.#grokToolValidationTools.has(tool);
       }
@@ -19988,6 +20011,18 @@ var init_mcp_client = __esm({
         }
         return this.supportsGrokToolValidationDiagnostics(tool);
       }
+      supportsGrokResponseIdentityDiagnostics(tool) {
+        return this.#grokResponseIdentityTools.has(tool);
+      }
+      async refreshGrokResponseIdentitySupport(tool, options = {}) {
+        if (this.supportsGrokResponseIdentityDiagnostics(tool)) return true;
+        try {
+          await this.initialize(options);
+        } catch {
+          return false;
+        }
+        return this.supportsGrokResponseIdentityDiagnostics(tool);
+      }
       supportsProviderQuotaRecovery() {
         return this.#providerQuotaRecoverySupported;
       }
@@ -20052,20 +20087,27 @@ var init_mcp_client = __esm({
         const heartbeatSchema = listed.tools.find(
           (tool) => tool.name === "inference.agent.assignment.heartbeat"
         )?.inputSchema;
-        const advertisesDiagnosticReceipt = (value, depth = 0) => {
+        const advertisesDiagnosticReceipt = (value, field, depth = 0) => {
           if (depth > 4 || !value || typeof value !== "object" || Array.isArray(value)) return false;
           const node = value;
           const properties = node.properties;
-          if (properties && typeof properties === "object" && Object.hasOwn(properties, "grok_tool_validation") && Object.hasOwn(properties, "dispatch_outcome")) return true;
+          if (properties && typeof properties === "object" && Object.hasOwn(properties, field) && Object.hasOwn(properties, "dispatch_outcome")) return true;
           if (typeof node.$ref === "string" && /^#\/\$defs\/[^/]+$/u.test(node.$ref)) {
             const definition = node.$ref.slice("#/$defs/".length).replace(/~1/gu, "/").replace(/~0/gu, "~");
-            return advertisesDiagnosticReceipt(heartbeatSchema?.$defs?.[definition], depth + 1);
+            return advertisesDiagnosticReceipt(heartbeatSchema?.$defs?.[definition], field, depth + 1);
           }
-          return Array.isArray(node.anyOf) && node.anyOf.some((branch) => advertisesDiagnosticReceipt(branch, depth + 1));
+          return Array.isArray(node.anyOf) && node.anyOf.some((branch) => advertisesDiagnosticReceipt(branch, field, depth + 1));
         };
-        if (advertisesDiagnosticReceipt(heartbeatSchema?.properties?.turn_receipt)) {
+        if (advertisesDiagnosticReceipt(heartbeatSchema?.properties?.turn_receipt, "grok_tool_validation")) {
           this.#grokToolValidationTools.add("inference.agent.assignment.heartbeat");
         }
+        this.#grokResponseIdentityTools.clear();
+        if (advertisesFields("inference.job.fail", ["grok_response_identity"])) {
+          this.#grokResponseIdentityTools.add("inference.job.fail");
+        }
+        if (advertisesDiagnosticReceipt(heartbeatSchema?.properties?.turn_receipt, "grok_response_identity")) {
+          this.#grokResponseIdentityTools.add("inference.agent.assignment.heartbeat");
+        }
         this.#initialized = true;
       }
       async callTool(name, argumentsValue, options = {}) {
@@ -21666,6 +21708,7 @@ var init_codex_app_server = __esm({
         this.rateLimits = options.rateLimits ?? null;
         this.processExit = options.processExit ?? null;
         this.grokToolValidation = options.grokToolValidation ?? null;
+        this.grokResponseIdentity = options.grokResponseIdentity ?? null;
       }
     };
     objectOrNull = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -34441,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, loadGrokPolicy;
+var validateGrokPolicy, grokAllowedEffectiveModels, loadGrokPolicy;
 var init_grok_policy = __esm({
   "lib/inference-host/grok-policy.ts"() {
     "use strict";
@@ -34459,12 +34502,26 @@ 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)
+        maximum_transport_response_bytes: Number(policy.maximum_transport_response_bytes),
+        effective_model_aliases: effectiveModelAliases
       });
     };
+    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"));
@@ -34517,13 +34574,19 @@ var init_grok_transport_proxy = __esm({
         this.requestFingerprints = /* @__PURE__ */ new Set();
         this.pending = false;
         this.closed = false;
+        this.observedModel = null;
         this.dispatched = false;
         this.responded = false;
         this.failureCode = null;
         this.rejectionStatus = null;
         this.terminalFailure = null;
         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");
       }
       get baseUrl() {
@@ -34697,6 +34760,7 @@ var init_grok_transport_proxy = __esm({
             this.checkDispatch();
             this.options.onProviderDispatch?.();
             this.checkDispatch();
+            this.observedModel = null;
             this.dispatched = true;
           }
           const upstream = await (this.options.fetchImpl ?? fetch)(
@@ -34794,9 +34858,35 @@ 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 || native.model !== this.options.requestedModel || id2 && native.id !== id2) throw new Error("grok_provider_identity_mismatch");
+            if (typeof native.id !== "string" || !native.id || !(this.options.allowedEffectiveModels ?? [this.options.requestedModel]).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)) {
+                throw new Error("grok_provider_response_id_changed");
+              }
+              const eventType = route === "/responses" ? event.type : event.object;
+              this.responseIdentityFailure = grokResponseIdentityDiagnosticSchema.parse({
+                schema_version: "external_inference_grok_response_identity_v1",
+                reason: !idPresent ? "invalid_id" : !modelMatches ? "model_mismatch" : "changed_id",
+                route,
+                response_event: ["response.created", "response.in_progress", "response.completed", "chat.completion.chunk"].includes(String(eventType)) ? eventType : "other",
+                id_present: idPresent,
+                id_matches_previous: id2 ? native.id === id2 : null,
+                model_present: modelPresent,
+                model_matches_requested: modelMatches,
+                model_sha256: modelPresent ? createHash6("sha256").update(native.model).digest("hex") : null
+              });
+              try {
+                this.options.onResponseIdentityFailure?.(this.responseIdentityFailure);
+              } catch {
+              }
+              throw new Error("grok_provider_identity_mismatch");
+            }
+            if (model && native.model !== model) throw new Error("grok_provider_model_changed");
             id2 = native.id;
             model = String(native.model);
+            this.observedModel = model;
           }
           const responseEffort = native.reasoning_effort ?? record3(native.reasoning).effort;
           if (responseEffort != null && effort(responseEffort) !== effort(this.options.requestedReasoningEffort)) {
@@ -35453,11 +35543,11 @@ var init_grok_adapter = __esm({
         isDefault: state.currentModelId === model.modelId
       }];
     });
-    grokPromptUsage = (value, expectedModel) => {
+    grokPromptUsage = (value, expectedModel, allowedEffectiveModels = [expectedModel]) => {
       const usage = grokObject(value);
       if (usage.usageIsIncomplete === true) throw new Error("grok_usage_incomplete");
       const models = Object.keys(grokObject(usage.modelUsage));
-      if (models.length !== 1 || models[0] !== expectedModel) throw new Error("grok_effective_model_mismatch");
+      if (models.length !== 1 || !allowedEffectiveModels.includes(models[0])) throw new Error("grok_effective_model_mismatch");
       const inputTokens = integer2(usage.inputTokens, "input_tokens");
       const outputTokens = integer2(usage.outputTokens, "output_tokens");
       const cachedInputTokens = integer2(usage.cachedReadTokens, "cached_input_tokens");
@@ -35562,7 +35652,11 @@ var init_grok_adapter = __esm({
             throw new Error("grok_subscription_auth_unavailable");
           }
           const state = unwrap(await session.request("_x.ai/models/list", {}, deadline, signal));
-          const capabilities = grokModelCapabilities(state);
+          const policy = this.options.policy ?? await loadGrokPolicy();
+          const capabilities = grokModelCapabilities(state).map((capability) => ({
+            ...capability,
+            allowedEffectiveModels: grokAllowedEffectiveModels(policy, capability.model)
+          }));
           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");
@@ -35607,6 +35701,7 @@ 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;
@@ -35616,6 +35711,7 @@ var init_grok_adapter = __esm({
         let retained = Boolean(agent?.durableThread);
         let thought = "";
         let firstToken = null;
+        let activeThread = null;
         try {
           input.signal.throwIfAborted();
           const evidence = [];
@@ -35642,6 +35738,12 @@ var init_grok_adapter = __esm({
             } }
           ] : [];
           mcp = agent ? await createGrokToolServer({ tools, signal: input.signal, execute: async (name, args) => {
+            const observedModel = proxy?.observedModel;
+            if (!activeThread || !observedModel) throw new Error("grok_tool_provenance_missing");
+            if (activeThread.effectiveModel !== observedModel) {
+              activeThread = { ...activeThread, effectiveModel: observedModel };
+              await agent.onThreadReady?.(activeThread);
+            }
             const callId = randomUUID5();
             const tool = name;
             const result3 = await agent.executeTool({ callId, tool, arguments: args });
@@ -35655,12 +35757,19 @@ 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,
             onProviderDispatch: provider?.onProviderDispatch,
             signal: input.signal,
             fetchImpl: this.options.fetchImpl,
+            onResponseIdentityFailure: (diagnostic) => this.options.emitDiagnosticEvent?.({
+              event: "grok_response_identity_failed",
+              attempt_id: provider?.attemptId ?? null,
+              control_mode: provider ? "provider" : "agent",
+              ...diagnostic
+            }),
             onToolValidationFailure: (diagnostic) => this.options.emitDiagnosticEvent?.({
               event: "grok_tool_validation_failed",
               attempt_id: provider?.attemptId ?? null,
@@ -35719,6 +35828,7 @@ var init_grok_adapter = __esm({
             effectiveModel: input.requestedModel,
             effectiveReasoningEffort: input.requestedReasoningEffort
           };
+          activeThread = thread;
           if (agent) {
             await agent.onThreadReady?.(thread);
             retained = true;
@@ -35743,15 +35853,17 @@ var init_grok_adapter = __esm({
           if (meta3.structuredOutputError || meta3.structuredOutput === void 0) throw new Error("grok_structured_output_missing");
           const text = JSON.stringify(meta3.structuredOutput);
           if (Buffer.byteLength(text) > 3e5) throw new Error("grok_result_too_large");
-          const usage = grokPromptUsage(meta3.usage, input.requestedModel);
+          const usage = grokPromptUsage(meta3.usage, input.requestedModel, allowedEffectiveModels);
           const actualModel = Object.keys(grokObject(grokObject(meta3.usage).modelUsage))[0];
           if (!proxy.dispatched || !proxy.responded || proxy.terminalFailure) throw new Error(proxy.failureCode ?? "grok_transport_receipt_missing");
           const receipts = proxy.receipts;
           if (!receipts.length || proxy.pendingRequest || receipts.some((receipt) => receipt.model !== actualModel || receipt.requestedReasoningEffort !== input.requestedReasoningEffort || receipt.input === null || receipt.output === null || receipt.cachedInput === null) || receipts.reduce((sum, receipt) => sum + receipt.input, 0) !== usage.inputTokens || receipts.reduce((sum, receipt) => sum + receipt.output, 0) !== usage.outputTokens || receipts.reduce((sum, receipt) => sum + receipt.cachedInput, 0) !== usage.cachedInputTokens || integer2(grokObject(meta3.usage).modelCalls, "model_calls") !== receipts.length) {
             throw new Error("grok_transport_usage_mismatch");
           }
+          const effectiveThread = { ...thread, effectiveModel: actualModel };
+          if (agent && activeThread.effectiveModel !== actualModel) await agent.onThreadReady?.(effectiveThread);
           provider?.onTerminalDispatchOutcome?.("confirmed_dispatched");
-          return { thread, turn: {
+          return { thread: effectiveThread, turn: {
             text,
             reasoningContent: thought || null,
             reasoningSummary: null,
@@ -35785,7 +35897,8 @@ var init_grok_adapter = __esm({
             httpStatusCode: proxy?.rejectionStatus,
             retryable: false,
             dispatchOutcome: outcome,
-            grokToolValidation: proxy?.toolValidationFailure ?? null
+            grokToolValidation: proxy?.toolValidationFailure ?? null,
+            grokResponseIdentity: proxy?.responseIdentityFailure ?? null
           });
         } finally {
           try {
@@ -37287,8 +37400,8 @@ var init_runner = __esm({
     init_mcp_client();
     init_config();
     init_oauth();
-    terminalFailureRequiresManualRecovery = (error48) => (error48.terminalEvidence !== null || error48.grokToolValidation != null) && !error48.retryable && error48.category !== "auth" && !["quota_exceeded", "codex_rate_limited", "provider_rate_limited"].includes(error48.code);
-    canReplayFencedAgentTerminal = (state, fence) => state?.schema_version === "vtx_inference_agent_runtime_v3" && state.adapter_id === fence.adapter_id && state.host_id === fence.host_id && state.assignment.assignment_id === fence.assignment_id && state.pending_turn?.terminal_receipt?.terminal_status === "failed" && state.pending_turn.terminal_receipt.failure_code === fence.failure_code && (fence.dispatch_outcome !== "outcome_unknown" || state.pending_turn.terminal_receipt.grok_tool_validation?.prior_dispatch === true && state.pending_turn.terminal_receipt.dispatch_outcome === "outcome_unknown");
+    terminalFailureRequiresManualRecovery = (error48) => (error48.terminalEvidence !== null || error48.grokToolValidation != null || error48.grokResponseIdentity != null) && !error48.retryable && error48.category !== "auth" && !["quota_exceeded", "codex_rate_limited", "provider_rate_limited"].includes(error48.code);
+    canReplayFencedAgentTerminal = (state, fence) => state?.schema_version === "vtx_inference_agent_runtime_v3" && state.adapter_id === fence.adapter_id && state.host_id === fence.host_id && state.assignment.assignment_id === fence.assignment_id && state.pending_turn?.terminal_receipt?.terminal_status === "failed" && state.pending_turn.terminal_receipt.failure_code === fence.failure_code && (fence.dispatch_outcome !== "outcome_unknown" || (state.pending_turn.terminal_receipt.grok_tool_validation?.prior_dispatch === true || state.pending_turn.terminal_receipt.grok_response_identity != null) && state.pending_turn.terminal_receipt.dispatch_outcome === "outcome_unknown");
     RUNTIME_RECEIPT_SCHEMA_VERSION = "vtx_inference_host_runtime_v1";
     ATTEMPT_RECEIPT_SCHEMA_VERSION = "vtx_inference_attempt_receipt_v1";
     CLAIM_DISPATCH_BATCH_SIZE = 16;
@@ -37328,7 +37441,7 @@ var init_runner = __esm({
         supported_control_modes: [...supportedControlModes],
         allowed_model_identities: [{
           requested_model: capability.model,
-          effective_models: [capability.model]
+          effective_models: [...capability.allowedEffectiveModels ?? [capability.model]]
         }],
         structured_output: structuredOutput,
         same_attempt_recovery: sameAttemptRecovery,
@@ -40465,6 +40578,11 @@ var init_runner = __esm({
             signal,
             deadlineAtMs: Date.parse(jobInput.evidence_expires_at)
           }) === true);
+          const identityDiagnostic = heartbeatFailure === void 0 && effectiveError instanceof CodexAppServerError && failure2.code === "grok_provider_identity_mismatch" && dispatchOutcome === "outcome_unknown" ? effectiveError.grokResponseIdentity ?? null : null;
+          const sendIdentityDiagnostic = identityDiagnostic !== null && (mcp.supportsGrokResponseIdentityDiagnostics?.("inference.job.fail") === true || await mcp.refreshGrokResponseIdentitySupport?.("inference.job.fail", {
+            signal,
+            deadlineAtMs: Date.parse(jobInput.evidence_expires_at)
+          }) === true);
           const failureRequest = jobFailRequestSchema.parse({
             schema_version: "external_inference_job_fail_v1",
             contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
@@ -40506,6 +40624,7 @@ var init_runner = __esm({
             provider_dispatch_freshness_remaining_ms: providerDispatchFreshnessRemainingMs,
             ...processExit ? { process_exit: processExit } : {},
             ...sendGrokDiagnostic ? { grok_tool_validation: grokDiagnostic } : {},
+            ...sendIdentityDiagnostic ? { grok_response_identity: identityDiagnostic } : {},
             membership_disposition: membershipFailureDisposition({
               ...failure2,
               dispatchOutcome
@@ -40577,6 +40696,7 @@ var init_runner = __esm({
       }
     };
     createInferenceAgentControlClient = (mcp) => ({
+      supportsGrokResponseIdentityDiagnostics: async (options = {}) => mcp.supportsGrokResponseIdentityDiagnostics?.("inference.agent.assignment.heartbeat") === true || await mcp.refreshGrokResponseIdentitySupport?.("inference.agent.assignment.heartbeat", options) === true,
       supportsGrokToolValidationDiagnostics: async (options = {}) => mcp.supportsGrokToolValidationDiagnostics?.("inference.agent.assignment.heartbeat") === true || await mcp.refreshGrokToolValidationSupport?.("inference.agent.assignment.heartbeat", options) === true,
       nextAssignment: async (request, options) => {
         const result2 = await mcp.callTool("inference.agent.assignment.next", {
@@ -41124,11 +41244,13 @@ var init_runner = __esm({
           return nextWakeAtMs;
         } catch (error48) {
           const diagnostic = error48 instanceof CodexAppServerError && error48.grokToolValidation && error48.code === `grok_tool_isolation_${error48.grokToolValidation.reason}` && error48.dispatchOutcome === (error48.grokToolValidation.prior_dispatch ? "outcome_unknown" : "not_dispatched") && await this.options.controlClient.supportsGrokToolValidationDiagnostics?.({}) === true ? error48.grokToolValidation : null;
-          if (error48 instanceof CodexAppServerError && error48.dispatchOutcome === "not_dispatched" && error48.terminalEvidence === null && !diagnostic) {
+          const identityDiagnostic = error48 instanceof CodexAppServerError && error48.grokResponseIdentity && error48.code === "grok_provider_identity_mismatch" && error48.dispatchOutcome === "outcome_unknown" && await this.options.controlClient.supportsGrokResponseIdentityDiagnostics?.({}) === true ? error48.grokResponseIdentity : null;
+          const hasDiagnostic = diagnostic != null || identityDiagnostic != null;
+          if (error48 instanceof CodexAppServerError && error48.dispatchOutcome === "not_dispatched" && error48.terminalEvidence === null && !hasDiagnostic) {
             state = { ...state, pending_turn: null, updated_at: nowIso() };
             await writeInferenceAgentRuntimeState(this.options.statePath, state);
           }
-          if (state.pending_turn && !state.pending_turn.terminal_receipt && error48 instanceof CodexAppServerError && (diagnostic != null || error48.terminalEvidence !== null || error48.dispatchOutcome === "confirmed_dispatched" && ["provider_rate_limited", "codex_rate_limited", "quota_exceeded"].includes(error48.code))) {
+          if (state.pending_turn && !state.pending_turn.terminal_receipt && error48 instanceof CodexAppServerError && (hasDiagnostic || error48.terminalEvidence !== null || error48.dispatchOutcome === "confirmed_dispatched" && ["provider_rate_limited", "codex_rate_limited", "quota_exceeded"].includes(error48.code))) {
             state = { ...state, pending_turn: {
               ...state.pending_turn,
               terminal_receipt: {
@@ -41137,19 +41259,23 @@ var init_runner = __esm({
                 turn_id: state.pending_turn.turn_id,
                 agent_run_id: state.thread?.threadId ?? state.pending_turn.turn_id,
                 requested_model: assignment.model_id,
-                effective_model: diagnostic ? null : error48.terminalEvidence?.effectiveModel ?? null,
+                effective_model: hasDiagnostic ? null : error48.terminalEvidence?.effectiveModel ?? null,
                 requested_reasoning_effort: assignment.reasoning_effort,
-                effective_reasoning_effort: diagnostic ? null : error48.terminalEvidence?.effectiveReasoningEffort ?? null,
+                effective_reasoning_effort: hasDiagnostic ? null : error48.terminalEvidence?.effectiveReasoningEffort ?? null,
                 started_at: state.pending_turn.started_at,
                 completed_at: nowIso(),
-                adapter_request_id: diagnostic ? null : error48.terminalEvidence?.adapterRequestId ?? null,
-                adapter_response_id: diagnostic ? null : error48.terminalEvidence?.adapterResponseId ?? null,
-                usage: !diagnostic && error48.usage ? reportedTokenUsage(error48.usage, this.options.adapterId) : {
+                adapter_request_id: hasDiagnostic ? null : error48.terminalEvidence?.adapterRequestId ?? null,
+                adapter_response_id: hasDiagnostic ? null : error48.terminalEvidence?.adapterResponseId ?? null,
+                usage: !hasDiagnostic && error48.usage ? reportedTokenUsage(error48.usage, this.options.adapterId) : {
                   schema_version: EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION,
                   availability: "unavailable",
                   reason_code: "terminal_usage_unavailable"
                 },
                 decision_operation_ids: [...state.pending_turn.decision_operation_ids],
+                ...identityDiagnostic ? {
+                  grok_response_identity: identityDiagnostic,
+                  dispatch_outcome: "outcome_unknown"
+                } : {},
                 ...diagnostic ? {
                   grok_tool_validation: diagnostic,
                   dispatch_outcome: error48.dispatchOutcome === "not_dispatched" ? "not_dispatched" : "outcome_unknown"
@@ -44615,7 +44741,7 @@ Waiting for approval...
           process.stdout.write(text);
         }))(`${JSON.stringify(event)}
 `) : adapterId === "codex" || adapterId === "grok-build" ? (event) => {
-          if (!["codex_app_server_closed", "codex_app_server_session_started", "grok_tool_validation_failed"].includes(
+          if (!["codex_app_server_closed", "codex_app_server_session_started", "grok_tool_validation_failed", "grok_response_identity_failed"].includes(
             String(event.event ?? "")
           )) return;
           (dependencies.emitStderr ?? ((text) => {

package/package.json

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