@vtxmacro/cli 2026.9.30 → 2026.9.32

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.30",
+  package_version: "2026.9.32",
   codex_package_name: "@openai/codex",
   codex_version: "0.153.3",
   copilot_sdk_package_name: "@github/copilot-sdk",

package/bin/vtx.js

@@ -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.30",
+      package_version: "2026.9.32",
       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, 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, 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";
@@ -15490,9 +15490,37 @@ var init_external_inference_contract = __esm({
       reportedTokenUsageSchema,
       unavailableTokenUsageSchema
     ]);
+    grokToolValidationDiagnosticSchema = external_exports.strictObject({
+      schema_version: external_exports.literal("external_inference_grok_tool_validation_v1"),
+      reason: external_exports.enum(["invalid_tools", "invalid_type", "missing_name", "unexpected_tools"]),
+      route: external_exports.enum(["/responses", "/chat/completions"]),
+      tools_shape: external_exports.enum(["undefined", "null", "array", "object", "string", "number", "boolean", "bigint", "symbol", "function"]),
+      tool_count: nonNegativeSafeIntegerSchema.nullable(),
+      expected_tool_count: nonNegativeSafeIntegerSchema,
+      tools: external_exports.array(external_exports.strictObject({
+        type: external_exports.enum(["function", "web_search", "web_search_preview", "file_search", "computer_use", "missing", "invalid", "redacted"]),
+        name: external_exports.enum(["search_tool", "use_tool", "bash", "read_file", "write_file", "edit_file", "web_search", "vtx_get_data", "vtx_submit_decision", "vtx_decision_status", "missing", "invalid", "redacted"]),
+        type_sha256: sha256HexSchema.nullable(),
+        name_sha256: sha256HexSchema.nullable()
+      }).refine(
+        (tool) => tool.type === "redacted" === (tool.type_sha256 !== null) && tool.name === "redacted" === (tool.name_sha256 !== null),
+        { message: "Only redacted tool identifiers require hashes." }
+      )).max(8),
+      tools_truncated: external_exports.boolean(),
+      prior_dispatch: external_exports.boolean(),
+      completed_response_count: nonNegativeSafeIntegerSchema
+    }).refine(
+      (value) => value.tools_shape === "array" ? value.tool_count !== null && value.tools.length === Math.min(value.tool_count, 8) && value.tools_truncated === value.tool_count > 8 : value.tool_count === null && value.tools.length === 0 && !value.tools_truncated,
+      { message: "Grok tool diagnostic counts must match the observed shape." }
+    ).refine(
+      (value) => value.prior_dispatch || value.completed_response_count === 0,
+      { message: "Completed responses require prior dispatch." }
+    );
     agentTurnReceiptSchema = external_exports.strictObject({
       terminal_status: external_exports.enum(["completed", "failed"]),
       failure_code: safeCodeSchema.nullable(),
+      grok_tool_validation: grokToolValidationDiagnosticSchema.optional(),
+      dispatch_outcome: external_exports.enum(["not_dispatched", "outcome_unknown"]).optional(),
       turn_id: external_exports.string().uuid(),
       agent_run_id: identifierSchema,
       requested_model: modelNameSchema,
@@ -15509,6 +15537,9 @@ 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",
+      { message: "Grok diagnostics must match the failed Agent turn and dispatch outcome." }
+    ).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." }
     ).refine((value) => Date.parse(value.completed_at) >= Date.parse(value.started_at), {
@@ -16006,6 +16037,7 @@ var init_external_inference_contract = __esm({
       adapter_result_ready_at: timestampSchema.optional(),
       provider_dispatch_freshness_remaining_ms: nonNegativeSafeIntegerSchema.nullable().optional(),
       process_exit: codexProcessExitDiagnosticsSchema.nullable().optional(),
+      grok_tool_validation: grokToolValidationDiagnosticSchema.optional(),
       membership_disposition: external_exports.enum([
         "retry_same_host",
         "cascade_cooldown",
@@ -16015,6 +16047,9 @@ var init_external_inference_contract = __esm({
       ]).optional(),
       failed_at: timestampSchema
     }).superRefine((value, context) => {
+      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"] });
+      }
       if (value.provider_retry_at != null !== (value.provider_retry_source != null)) {
         context.addIssue({ code: "custom", message: "provider retry deadline and source must be provided together", path: ["provider_retry_at"] });
       }
@@ -19940,6 +19975,19 @@ var init_mcp_client = __esm({
       #requestId = 0;
       #initialized = false;
       #providerQuotaRecoverySupported = false;
+      #grokToolValidationTools = /* @__PURE__ */ new Set();
+      supportsGrokToolValidationDiagnostics(tool) {
+        return this.#grokToolValidationTools.has(tool);
+      }
+      async refreshGrokToolValidationSupport(tool, options = {}) {
+        if (this.supportsGrokToolValidationDiagnostics(tool)) return true;
+        try {
+          await this.initialize(options);
+        } catch {
+          return false;
+        }
+        return this.supportsGrokToolValidationDiagnostics(tool);
+      }
       supportsProviderQuotaRecovery() {
         return this.#providerQuotaRecoverySupported;
       }
@@ -19997,6 +20045,27 @@ var init_mcp_client = __esm({
           "inference.host.heartbeat",
           ["provider_quota_recovery"]
         ) && advertisesFields("inference.job.fail", ["provider_retry_at", "provider_retry_source"]);
+        this.#grokToolValidationTools.clear();
+        if (advertisesFields("inference.job.fail", ["grok_tool_validation"])) {
+          this.#grokToolValidationTools.add("inference.job.fail");
+        }
+        const heartbeatSchema = listed.tools.find(
+          (tool) => tool.name === "inference.agent.assignment.heartbeat"
+        )?.inputSchema;
+        const advertisesDiagnosticReceipt = (value, 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 (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 Array.isArray(node.anyOf) && node.anyOf.some((branch) => advertisesDiagnosticReceipt(branch, depth + 1));
+        };
+        if (advertisesDiagnosticReceipt(heartbeatSchema?.properties?.turn_receipt)) {
+          this.#grokToolValidationTools.add("inference.agent.assignment.heartbeat");
+        }
         this.#initialized = true;
       }
       async callTool(name, argumentsValue, options = {}) {
@@ -21596,6 +21665,7 @@ var init_codex_app_server = __esm({
         this.terminalEvidence = options.terminalEvidence ?? null;
         this.rateLimits = options.rateLimits ?? null;
         this.processExit = options.processExit ?? null;
+        this.grokToolValidation = options.grokToolValidation ?? null;
       }
     };
     objectOrNull = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -34407,13 +34477,31 @@ var init_grok_policy = __esm({
 import { createServer as createServer3 } from "node:http";
 import { createHash as createHash6, randomBytes as randomBytes5 } from "node:crypto";
 import { once } from "node:events";
-var record3, count2, effort, safeCode2, GrokTransportProxy, createGrokTransportProxy;
+var diagnosticNames, diagnosticTypes, diagnosticIdentifier, record3, count2, effort, safeCode2, GrokTransportProxy, createGrokTransportProxy;
 var init_grok_transport_proxy = __esm({
   "lib/inference-host/grok-transport-proxy.ts"() {
     "use strict";
     init_define_VTX_EXO_POLICY();
     init_define_VTX_GROK_POLICY();
     init_define_VTX_PI_MODEL_POLICY();
+    init_external_inference_contract();
+    diagnosticNames = /* @__PURE__ */ new Set([
+      "search_tool",
+      "use_tool",
+      "bash",
+      "read_file",
+      "write_file",
+      "edit_file",
+      "web_search",
+      "vtx_get_data",
+      "vtx_submit_decision",
+      "vtx_decision_status"
+    ]);
+    diagnosticTypes = /* @__PURE__ */ new Set(["function", "web_search", "web_search_preview", "file_search", "computer_use"]);
+    diagnosticIdentifier = (value, known) => {
+      if (typeof value !== "string") return { label: value == null ? "missing" : "invalid", sha256: null };
+      return known.has(value) ? { label: value, sha256: null } : { label: "redacted", sha256: createHash6("sha256").update(value).digest("hex") };
+    };
     record3 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
     count2 = (value) => Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : null;
     effort = (value) => value == null ? "none" : String(value).toLowerCase();
@@ -34434,6 +34522,7 @@ var init_grok_transport_proxy = __esm({
         this.failureCode = null;
         this.rejectionStatus = null;
         this.terminalFailure = null;
+        this.toolValidationFailure = null;
         const upstream = new URL(options.upstreamBaseUrl);
         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");
       }
@@ -34471,6 +34560,32 @@ var init_grok_transport_proxy = __esm({
           throw new Error("server_account_context_expired_before_provider_dispatch");
         }
       }
+      rejectTools(reason, payload, route) {
+        const tools = Array.isArray(payload.tools) ? payload.tools : null;
+        const diagnostic = grokToolValidationDiagnosticSchema.parse({
+          schema_version: "external_inference_grok_tool_validation_v1",
+          reason,
+          route,
+          tools_shape: tools ? "array" : payload.tools === null ? "null" : typeof payload.tools,
+          tool_count: tools?.length ?? null,
+          expected_tool_count: this.options.allowedToolNames.length,
+          tools: (tools ?? []).slice(0, 8).map((value) => {
+            const tool = record3(value);
+            const type = diagnosticIdentifier(tool.type, diagnosticTypes);
+            const name = diagnosticIdentifier(route === "/responses" ? tool.name : record3(tool.function).name, diagnosticNames);
+            return { type: type.label, name: name.label, type_sha256: type.sha256, name_sha256: name.sha256 };
+          }),
+          tools_truncated: (tools?.length ?? 0) > 8,
+          prior_dispatch: this.dispatched,
+          completed_response_count: this.receiptValues.length
+        });
+        this.toolValidationFailure ??= diagnostic;
+        try {
+          this.options.onToolValidationFailure?.(diagnostic);
+        } catch {
+        }
+        throw new Error(`grok_tool_isolation_${reason}`);
+      }
       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)) {
@@ -34482,17 +34597,17 @@ var init_grok_transport_proxy = __esm({
         if (instructions.length !== 1 || instructions[0].role !== "system" || instructions[0].content !== this.options.expectedSystemPrompt || route === "/responses" && payload.instructions != null) {
           throw new Error("grok_system_prompt_mismatch");
         }
-        if (payload.tools != null && !Array.isArray(payload.tools)) throw new Error("grok_tool_isolation_failed");
+        if (payload.tools != null && !Array.isArray(payload.tools)) this.rejectTools("invalid_tools", payload, route);
         const tools = payload.tools ?? [];
         const names2 = tools.map((value) => {
           const tool = record3(value);
-          if (tool.type !== "function") throw new Error("grok_tool_isolation_failed");
+          if (tool.type !== "function") this.rejectTools("invalid_type", payload, route);
           const name = route === "/responses" ? tool.name : record3(tool.function).name;
-          if (typeof name !== "string") throw new Error("grok_tool_isolation_failed");
+          if (typeof name !== "string") this.rejectTools("missing_name", payload, route);
           return name;
         });
         if (names2.sort().join("\0") !== [...this.options.allowedToolNames].sort().join("\0")) {
-          throw new Error("grok_tool_isolation_failed");
+          this.rejectTools("unexpected_tools", payload, route);
         }
       }
       async handle(request, response) {
@@ -34622,8 +34737,15 @@ var init_grok_transport_proxy = __esm({
             if (!this.dispatched) this.pending = false;
           }
           controller.abort();
-          if (!response.headersSent) response.writeHead(502, { "x-should-retry": "false", "content-type": "application/json" });
-          response.end();
+          if (!response.headersSent) {
+            const localValidation = inference && this.toolValidationFailure !== null;
+            response.writeHead(localValidation ? 400 : 502, { "x-should-retry": "false", "content-type": "application/json" });
+            response.end(localValidation ? JSON.stringify({ error: {
+              type: "vtx_host_validation_error",
+              code: this.failureCode,
+              message: "VTX blocked this Grok Build request locally because its tools did not match the allowed tool contract."
+            } }) : void 0);
+          } else response.end();
         } finally {
           clearTimeout(timer);
           this.options.signal?.removeEventListener("abort", abort);
@@ -35534,7 +35656,13 @@ var init_grok_adapter = __esm({
             providerDispatchNotAfterMs: provider?.providerDispatchNotAfterMs,
             onProviderDispatch: provider?.onProviderDispatch,
             signal: input.signal,
-            fetchImpl: this.options.fetchImpl
+            fetchImpl: this.options.fetchImpl,
+            onToolValidationFailure: (diagnostic) => this.options.emitDiagnosticEvent?.({
+              event: "grok_tool_validation_failed",
+              attempt_id: provider?.attemptId ?? null,
+              control_mode: provider ? "provider" : "agent",
+              ...diagnostic
+            })
           });
           input.signal.throwIfAborted();
           session = new GrokAcpSession({
@@ -35647,12 +35775,13 @@ var init_grok_adapter = __esm({
           provider?.onTerminalDispatchOutcome?.(outcome);
           if (error48 instanceof CodexAppServerError) throw error48;
           throw new CodexAppServerError({
-            message: "Grok Build could not complete the inference contract.",
+            message: proxy?.toolValidationFailure ? "VTX blocked an outgoing Grok Build request locally because its tools did not match the allowed tool contract." : "Grok Build could not complete the inference contract.",
             category: input.signal?.aborted ? "cancelled" : Date.now() >= input.deadlineAtMs ? "timeout" : proxy?.rejectionStatus === 401 || proxy?.rejectionStatus === 403 ? "auth" : "adapter",
             code: proxy?.failureCode ?? proxy?.terminalFailure?.code ?? (error48 instanceof Error && /^grok_[a-z0-9_]+$/u.test(error48.message) ? error48.message : "grok_adapter_failure"),
             httpStatusCode: proxy?.rejectionStatus,
             retryable: false,
-            dispatchOutcome: outcome
+            dispatchOutcome: outcome,
+            grokToolValidation: proxy?.toolValidationFailure ?? null
           });
         } finally {
           try {
@@ -37154,8 +37283,8 @@ var init_runner = __esm({
     init_mcp_client();
     init_config();
     init_oauth();
-    terminalFailureRequiresManualRecovery = (error48) => error48.terminalEvidence !== 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";
+    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");
     RUNTIME_RECEIPT_SCHEMA_VERSION = "vtx_inference_host_runtime_v1";
     ATTEMPT_RECEIPT_SCHEMA_VERSION = "vtx_inference_attempt_receipt_v1";
     CLAIM_DISPATCH_BATCH_SIZE = 16;
@@ -38165,7 +38294,14 @@ var init_runner = __esm({
                           cooldown_until: retryAtMs === null ? null : isoAt(retryAtMs)
                         }
                       );
-                      if (this.options.once || retryAtMs === null) return;
+                      if (this.options.once) return;
+                      if (retryAtMs === null) {
+                        const retained = await readInferenceAgentRuntimeState(agentRuntimeSettings.statePath);
+                        const fence = await readInferenceAgentFailureFence(agentRuntimeSettings.statePath);
+                        if (!fence || !canReplayFencedAgentTerminal(retained, fence)) return;
+                        await sleep4(1e3, agentIdleSignal).catch(() => void 0);
+                        continue;
+                      }
                       try {
                         await sleep4(Math.max(MIN_SLEEP_MS, retryAtMs - now()), agentIdleSignal);
                       } catch {
@@ -40320,6 +40456,11 @@ var init_runner = __esm({
             failure2.code
           ]);
           const canReportEffective = dispatchOutcome !== "not_dispatched";
+          const grokDiagnostic = heartbeatFailure === void 0 && effectiveError instanceof CodexAppServerError && effectiveError.grokToolValidation !== null && failure2.code === `grok_tool_isolation_${effectiveError.grokToolValidation.reason}` && dispatchOutcome === (effectiveError.grokToolValidation.prior_dispatch ? "outcome_unknown" : "not_dispatched") ? effectiveError.grokToolValidation : null;
+          const sendGrokDiagnostic = grokDiagnostic !== null && (mcp.supportsGrokToolValidationDiagnostics?.("inference.job.fail") === true || await mcp.refreshGrokToolValidationSupport?.("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,
@@ -40360,6 +40501,7 @@ var init_runner = __esm({
             ...adapterResultReadyAt === null ? {} : { adapter_result_ready_at: adapterResultReadyAt },
             provider_dispatch_freshness_remaining_ms: providerDispatchFreshnessRemainingMs,
             ...processExit ? { process_exit: processExit } : {},
+            ...sendGrokDiagnostic ? { grok_tool_validation: grokDiagnostic } : {},
             membership_disposition: membershipFailureDisposition({
               ...failure2,
               dispatchOutcome
@@ -40431,6 +40573,7 @@ var init_runner = __esm({
       }
     };
     createInferenceAgentControlClient = (mcp) => ({
+      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", {
           ...request,
@@ -40674,6 +40817,12 @@ var init_runner = __esm({
           if (terminal.terminal_receipt.terminal_status === "failed") {
             state = { ...state, pending_turn: null, updated_at: nowIso() };
             await writeInferenceAgentRuntimeState(this.options.statePath, state);
+            if (terminal.terminal_receipt.dispatch_outcome === "outcome_unknown") {
+              throw new InferenceHostRunnerError(
+                "agent_terminal_failure_fenced",
+                "The diagnostic receipt was acknowledged; upstream outcome remains unknown and model redispatch is fenced."
+              );
+            }
             await this.releaseForHostStop(terminal.terminal_receipt.failure_code ?? "provider_failure");
             return this.now() + (this.options.idlePollMs ?? 5e3);
           }
@@ -40970,11 +41119,12 @@ var init_runner = __esm({
           await writeInferenceAgentRuntimeState(this.options.statePath, state);
           return nextWakeAtMs;
         } catch (error48) {
-          if (error48 instanceof CodexAppServerError && error48.dispatchOutcome === "not_dispatched" && error48.terminalEvidence === null) {
+          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) {
             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 && (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 && (diagnostic != null || 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: {
@@ -40983,19 +41133,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: error48.terminalEvidence?.effectiveModel ?? null,
+                effective_model: diagnostic ? null : error48.terminalEvidence?.effectiveModel ?? null,
                 requested_reasoning_effort: assignment.reasoning_effort,
-                effective_reasoning_effort: error48.terminalEvidence?.effectiveReasoningEffort ?? null,
+                effective_reasoning_effort: diagnostic ? null : error48.terminalEvidence?.effectiveReasoningEffort ?? null,
                 started_at: state.pending_turn.started_at,
                 completed_at: nowIso(),
-                adapter_request_id: error48.terminalEvidence?.adapterRequestId ?? null,
-                adapter_response_id: error48.terminalEvidence?.adapterResponseId ?? null,
-                usage: error48.usage ? reportedTokenUsage(error48.usage, this.options.adapterId) : {
+                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) : {
                   schema_version: EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION,
                   availability: "unavailable",
                   reason_code: "terminal_usage_unavailable"
                 },
-                decision_operation_ids: [...state.pending_turn.decision_operation_ids]
+                decision_operation_ids: [...state.pending_turn.decision_operation_ids],
+                ...diagnostic ? {
+                  grok_tool_validation: diagnostic,
+                  dispatch_outcome: error48.dispatchOutcome === "not_dispatched" ? "not_dispatched" : "outcome_unknown"
+                } : {}
               }
             }, updated_at: nowIso() };
             if (terminalFailureRequiresManualRecovery(error48)) {
@@ -43609,8 +43763,8 @@ Durable service:
         quiesceSignal: options.quiesceSignal
       }).run();
     };
-    preparePortableDurableAdapter = async (adapterId, config2, signal) => {
-      const adapter = adapterId === "copilot" ? new CopilotSubscriptionAdapter() : adapterId === "grok-build" ? new GrokBuildAdapter({ stateRoot: `${config2.statePath}.grok`, grokHome: `${config2.statePath}.grok-home` }) : adapterId === "pi" ? new PiAdapter({
+    preparePortableDurableAdapter = async (adapterId, config2, signal, emitDiagnosticEvent) => {
+      const adapter = adapterId === "copilot" ? new CopilotSubscriptionAdapter() : adapterId === "grok-build" ? new GrokBuildAdapter({ stateRoot: `${config2.statePath}.grok`, grokHome: `${config2.statePath}.grok-home`, emitDiagnosticEvent }) : adapterId === "pi" ? new PiAdapter({
         credentialStore: createPiCredentialStore(config2),
         stateRoot: `${config2.statePath}.pi`,
         qualifiedModels: await loadPiModelPolicy()
@@ -44456,8 +44610,8 @@ Waiting for approval...
         const emitDiagnosticEvent = parsed.json ? (event) => (dependencies.emitStdout ?? ((text) => {
           process.stdout.write(text);
         }))(`${JSON.stringify(event)}
-`) : adapterId === "codex" ? (event) => {
-          if (!["codex_app_server_closed", "codex_app_server_session_started"].includes(
+`) : adapterId === "codex" || adapterId === "grok-build" ? (event) => {
+          if (!["codex_app_server_closed", "codex_app_server_session_started", "grok_tool_validation_failed"].includes(
             String(event.event ?? "")
           )) return;
           (dependencies.emitStderr ?? ((text) => {
@@ -44466,7 +44620,16 @@ Waiting for approval...
 `);
         } : void 0;
         if (adapterId !== "codex") {
-          const prepared = adapterId === "exo" ? await (dependencies.prepareExoAdapter ?? prepareExoAdapter)(config2, parsed.exoRoot, cancellation.signal) : await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(adapterId, config2, cancellation.signal);
+          const diagnosticState = await readInferenceHostLocalState(config2.statePath);
+          const emitPortableDiagnostic = (event) => emitDiagnosticEvent?.({
+            ...event,
+            schema_version: "vtx_inference_host_diagnostic_v1",
+            at: (/* @__PURE__ */ new Date()).toISOString(),
+            instance_name: config2.instanceName,
+            host_id: diagnosticState?.host_id ?? null,
+            host_runtime_version: INFERENCE_HOST_CLI_VERSION
+          });
+          const prepared = adapterId === "exo" ? await (dependencies.prepareExoAdapter ?? prepareExoAdapter)(config2, parsed.exoRoot, cancellation.signal) : await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(adapterId, config2, cancellation.signal, emitPortableDiagnostic);
           const summary = await (dependencies.runPortableDurableAdapter ?? defaultRunPortableDurableAdapter)({
             config: config2,
             credentialStore: store,

package/package.json

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