@vtxmacro/cli 2026.9.24 → 2026.9.25

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

package/bin/vtx.js

@@ -69,7 +69,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.9.24",
+      package_version: "2026.9.25",
       codex_package_name: "@openai/codex",
       codex_version: "0.153.3",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -19221,7 +19221,7 @@ ${body}`;
 });
 
 // lib/inference-host/mcp-client.ts
-var EXTERNAL_INFERENCE_MCP_PROTOCOL_VERSION, EXTERNAL_INFERENCE_AUTOMATED_HOST_TOOLS, EXTERNAL_INFERENCE_OPERATIONAL_TOOLS, ExternalInferenceMcpError, DEFAULT_REQUEST_TIMEOUT_MS, MAX_RETRY_AFTER_MS, PUBLIC_TOOL_ERROR_PREFIX, parseRetryAfterMs, identifierSchema2, safeCodeSchema2, publicFailureCodeSchema, publicToolErrorSchema, structuredPublicToolErrorSchema, parsePublicToolError, hostMutationResultSchema, attemptStartResultSchema, agentConnectResultSchema, agentHeartbeatResultSchema, timestampSchema2, positiveGenerationSchema, jsonObjectSchema, agentAssignmentNextArgumentsSchema, agentDataCapabilityDescriptorSchema, agentAssignmentNextResultSchema, agentAssignmentHeartbeatArgumentsSchema, agentAssignmentHeartbeatResultSchema, agentDataCallArgumentsSchema, agentDataCallResultSchema, agentDecisionSubmitArgumentsSchema, agentDecisionSubmitResultSchema, agentDecisionStatusArgumentsSchema, agentDecisionStatusResultSchema, agentAssignmentReleaseArgumentsSchema, agentAssignmentReleaseResultSchema, jobCompletionResultSchema, jobFailureResultSchema, toolContracts, discoveryResultSchema, toolListResultSchema, inlineStructuredContentSchema, protocolMeta, parseJsonDocument, parseSseDocuments, parseResponseDocuments, exactOperationalInventory, exactJson, invalidBoundResult, verifyToolResult, ExternalInferenceMcpClient;
+var EXTERNAL_INFERENCE_MCP_PROTOCOL_VERSION, EXTERNAL_INFERENCE_AUTOMATED_HOST_TOOLS, EXTERNAL_INFERENCE_OPERATIONAL_TOOLS, ClaimTiming, ExternalInferenceMcpError, DEFAULT_REQUEST_TIMEOUT_MS, MAX_RETRY_AFTER_MS, PUBLIC_TOOL_ERROR_PREFIX, parseRetryAfterMs, identifierSchema2, safeCodeSchema2, publicFailureCodeSchema, publicToolErrorSchema, structuredPublicToolErrorSchema, parsePublicToolError, hostMutationResultSchema, attemptStartResultSchema, agentConnectResultSchema, agentHeartbeatResultSchema, timestampSchema2, positiveGenerationSchema, jsonObjectSchema, agentAssignmentNextArgumentsSchema, agentDataCapabilityDescriptorSchema, agentAssignmentNextResultSchema, agentAssignmentHeartbeatArgumentsSchema, agentAssignmentHeartbeatResultSchema, agentDataCallArgumentsSchema, agentDataCallResultSchema, agentDecisionSubmitArgumentsSchema, agentDecisionSubmitResultSchema, agentDecisionStatusArgumentsSchema, agentDecisionStatusResultSchema, agentAssignmentReleaseArgumentsSchema, agentAssignmentReleaseResultSchema, jobCompletionResultSchema, jobFailureResultSchema, toolContracts, discoveryResultSchema, toolListResultSchema, inlineStructuredContentSchema, protocolMeta, parseJsonDocument, parseSseDocuments, parseResponseDocuments, exactOperationalInventory, exactJson, invalidBoundResult, verifyToolResult, ExternalInferenceMcpClient;
 var init_mcp_client = __esm({
   "lib/inference-host/mcp-client.ts"() {
     "use strict";
@@ -19254,6 +19254,42 @@ var init_mcp_client = __esm({
       "inference.agent.complete",
       "inference.agent.fail"
     ];
+    ClaimTiming = class {
+      constructor() {
+        this.startedAt = performance.now();
+        this.changedAt = this.startedAt;
+        this.phase = "other_ms";
+        this.finished = false;
+        this.elapsed = {
+          token_lookup_ms: 0,
+          fetch_headers_ms: 0,
+          body_reception_ms: 0,
+          response_parse_ms: 0,
+          response_validation_ms: 0,
+          other_ms: 0
+        };
+        this.transportAttempts = 0;
+        this.tokenRefreshes = 0;
+      }
+      enter(phase) {
+        if (this.finished) return;
+        const at = performance.now();
+        this.elapsed[this.phase] += Math.max(0, at - this.changedAt);
+        this.changedAt = at;
+        this.phase = phase;
+      }
+      finish(outcome) {
+        this.enter("other_ms");
+        this.finished = true;
+        return Object.freeze({
+          ...this.elapsed,
+          total_ms: Math.max(0, this.changedAt - this.startedAt),
+          transport_attempts: this.transportAttempts,
+          token_refreshes: this.tokenRefreshes,
+          outcome
+        });
+      }
+    };
     ExternalInferenceMcpError = class extends Error {
       constructor(code, message, options = {}) {
         super(message, { cause: options.cause });
@@ -19662,9 +19698,11 @@ var init_mcp_client = __esm({
       }
       return documents;
     };
-    parseResponseDocuments = async (response) => {
+    parseResponseDocuments = async (response, timing) => {
       const contentType = String(response.headers.get("content-type") || "").split(";", 1)[0].trim().toLowerCase();
+      timing?.enter("body_reception_ms");
       const body = await response.text();
+      timing?.enter("response_parse_ms");
       if (contentType === "application/json") return [parseJsonDocument(body)];
       if (contentType === "text/event-stream") return parseSseDocuments(body);
       throw new ExternalInferenceMcpError(
@@ -19852,75 +19890,90 @@ var init_mcp_client = __esm({
         this.#initialized = true;
       }
       async callTool(name, argumentsValue, options = {}) {
-        if (!this.#initialized) {
-          throw new ExternalInferenceMcpError(
-            "not_initialized",
-            "Insights MCP inventory must be verified before calling an inference operation."
-          );
-        }
-        const contract = toolContracts[name];
-        const argumentsDocument = contract.arguments.parse(argumentsValue);
-        const rawResult = await this.#request(
-          "tools/call",
-          { name, arguments: argumentsDocument },
-          name,
-          options
-        );
-        const callResult = external_exports.object({
-          isError: external_exports.boolean().optional(),
-          content: external_exports.array(external_exports.object({
-            type: external_exports.string(),
-            text: external_exports.string().optional()
-          }).passthrough()).optional(),
-          structuredContent: external_exports.unknown()
-        }).passthrough().parse(rawResult);
-        if (callResult.isError === true) {
-          const errorText = (callResult.content ?? []).filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n");
-          const structuredPublicToolError = structuredPublicToolErrorSchema.safeParse(
-            callResult.structuredContent
-          );
-          const structuredDocument = callResult.structuredContent !== null && typeof callResult.structuredContent === "object" && !Array.isArray(callResult.structuredContent) ? callResult.structuredContent : null;
-          const hasStructuredPublicToolErrorMarker = structuredDocument?.schema_version === "vtx_insights_tool_error_v1";
-          const publicToolError = structuredPublicToolError.success ? structuredPublicToolError.data : hasStructuredPublicToolErrorMarker ? null : parsePublicToolError(errorText);
-          const hasPublicToolErrorMarker = hasStructuredPublicToolErrorMarker || errorText.includes(PUBLIC_TOOL_ERROR_PREFIX);
-          const completionEvidenceExpired = name === "inference.job.complete" && (publicToolError ? publicToolError.failure_code === "completion_evidence_expired" && publicToolError.phase === "validation" && publicToolError.retryable === false && publicToolError.terminal_before_execution === true : !hasPublicToolErrorMarker && errorText.includes("External inference completion evidence window expired"));
-          const hostNotClaimable = name === "inference.job.claim" && publicToolError?.failure_code === "host_not_claimable" && publicToolError.phase === "admission" && publicToolError.retryable === true && publicToolError.terminal_before_execution === true;
-          const definitivelyNotApplied = name === "inference.agent.decision.submit" && publicToolError?.phase === "validation" && publicToolError.retryable === false && publicToolError.terminal_before_execution === true && (publicToolError.failure_code === "agent_decision_schema_invalid" || publicToolError.failure_code === "invalid_arguments" && publicToolError.reason_code === "schema_validation") || (name === "inference.host.register" || name === "inference.host.advertise") && (errorText.includes("Advertisement time is outside the allowed clock skew.") || errorText.includes("Advertisement is already expired.")) || (name === "inference.agent.next" || name === "inference.agent.heartbeat") && (errorText.includes("Advertisement time is outside the allowed clock skew.") || errorText.includes("Advertisement is already expired.") || errorText.includes("Heartbeat time is outside the allowed clock skew.")) || name === "inference.host.heartbeat" && errorText.includes("Heartbeat time is outside the allowed clock skew.") || name === "inference.job.claim" && (errorText.includes(
-            "External inference claim request was not applied before its generation became stale"
-          ) || errorText.includes("External inference host advertisement is expired or superseded")) || name === "inference.job.complete" && completionEvidenceExpired;
-          const retryableInfrastructureRejection = EXTERNAL_INFERENCE_AUTOMATED_HOST_TOOLS.includes(name) && (errorText.includes("External inference polling is at its configured concurrency limit") || errorText.includes("The Insights action reached the response timeout") || errorText.includes("Insights capability failed without exposing private runtime details"));
-          const retryableClaimRejection = name === "inference.job.claim" && !definitivelyNotApplied && (retryableInfrastructureRejection || hostNotClaimable || errorText.includes("External inference host is not live enough to claim work") || errorText.includes("External inference host request generation is stale") || errorText.includes("External inference claim runtime fence is stale"));
-          const retryableHeartbeatClockSkew = name === "inference.host.heartbeat" && definitivelyNotApplied;
-          const retryableAdvertisementClockSkew = (name === "inference.host.register" || name === "inference.host.advertise") && definitivelyNotApplied;
-          const staleHostHeartbeatGeneration = name === "inference.host.heartbeat" && errorText.includes("Heartbeat generations do not match the current host authority.");
-          const obsoleteClaimReplay = name === "inference.job.claim" && errorText.includes(
-            "External inference claim replay is no longer dispatchable"
+        const timing = name === "inference.job.claim" && options.onClaimTiming ? new ClaimTiming() : void 0;
+        let outcome = "failure";
+        try {
+          if (!this.#initialized) {
+            throw new ExternalInferenceMcpError(
+              "not_initialized",
+              "Insights MCP inventory must be verified before calling an inference operation."
+            );
+          }
+          const contract = toolContracts[name];
+          const argumentsDocument = contract.arguments.parse(argumentsValue);
+          const rawResult = await this.#request(
+            "tools/call",
+            { name, arguments: argumentsDocument },
+            name,
+            options,
+            timing
           );
-          throw new ExternalInferenceMcpError(
-            completionEvidenceExpired ? "completion_evidence_expired" : staleHostHeartbeatGeneration ? "generation_stale" : obsoleteClaimReplay ? "claim_replay_obsolete" : "tool_rejected",
-            `Insights MCP rejected ${name}.`,
-            {
-              definitivelyNotApplied: definitivelyNotApplied || staleHostHeartbeatGeneration,
-              // Claim polling is an idempotent control-plane operation. During an
-              // API rotation the MCP server can return a tool error after the
-              // request reached the application boundary, so retain and replay
-              // the exact request unless the server proves it was not applied.
-              retryable: retryableInfrastructureRejection || retryableClaimRejection || retryableHeartbeatClockSkew || retryableAdvertisementClockSkew,
-              serverFailureCode: publicToolError?.failure_code ?? null,
-              retryAfterMs: hostNotClaimable ? publicToolError?.retry_after_ms ?? null : null
+          timing?.enter("response_validation_ms");
+          const callResult = external_exports.object({
+            isError: external_exports.boolean().optional(),
+            content: external_exports.array(external_exports.object({
+              type: external_exports.string(),
+              text: external_exports.string().optional()
+            }).passthrough()).optional(),
+            structuredContent: external_exports.unknown()
+          }).passthrough().parse(rawResult);
+          if (callResult.isError === true) {
+            const errorText = (callResult.content ?? []).filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n");
+            const structuredPublicToolError = structuredPublicToolErrorSchema.safeParse(
+              callResult.structuredContent
+            );
+            const structuredDocument = callResult.structuredContent !== null && typeof callResult.structuredContent === "object" && !Array.isArray(callResult.structuredContent) ? callResult.structuredContent : null;
+            const hasStructuredPublicToolErrorMarker = structuredDocument?.schema_version === "vtx_insights_tool_error_v1";
+            const publicToolError = structuredPublicToolError.success ? structuredPublicToolError.data : hasStructuredPublicToolErrorMarker ? null : parsePublicToolError(errorText);
+            const hasPublicToolErrorMarker = hasStructuredPublicToolErrorMarker || errorText.includes(PUBLIC_TOOL_ERROR_PREFIX);
+            const completionEvidenceExpired = name === "inference.job.complete" && (publicToolError ? publicToolError.failure_code === "completion_evidence_expired" && publicToolError.phase === "validation" && publicToolError.retryable === false && publicToolError.terminal_before_execution === true : !hasPublicToolErrorMarker && errorText.includes("External inference completion evidence window expired"));
+            const hostNotClaimable = name === "inference.job.claim" && publicToolError?.failure_code === "host_not_claimable" && publicToolError.phase === "admission" && publicToolError.retryable === true && publicToolError.terminal_before_execution === true;
+            const definitivelyNotApplied = name === "inference.agent.decision.submit" && publicToolError?.phase === "validation" && publicToolError.retryable === false && publicToolError.terminal_before_execution === true && (publicToolError.failure_code === "agent_decision_schema_invalid" || publicToolError.failure_code === "invalid_arguments" && publicToolError.reason_code === "schema_validation") || (name === "inference.host.register" || name === "inference.host.advertise") && (errorText.includes("Advertisement time is outside the allowed clock skew.") || errorText.includes("Advertisement is already expired.")) || (name === "inference.agent.next" || name === "inference.agent.heartbeat") && (errorText.includes("Advertisement time is outside the allowed clock skew.") || errorText.includes("Advertisement is already expired.") || errorText.includes("Heartbeat time is outside the allowed clock skew.")) || name === "inference.host.heartbeat" && errorText.includes("Heartbeat time is outside the allowed clock skew.") || name === "inference.job.claim" && (errorText.includes(
+              "External inference claim request was not applied before its generation became stale"
+            ) || errorText.includes("External inference host advertisement is expired or superseded")) || name === "inference.job.complete" && completionEvidenceExpired;
+            const retryableInfrastructureRejection = EXTERNAL_INFERENCE_AUTOMATED_HOST_TOOLS.includes(name) && (errorText.includes("External inference polling is at its configured concurrency limit") || errorText.includes("The Insights action reached the response timeout") || errorText.includes("Insights capability failed without exposing private runtime details"));
+            const retryableClaimRejection = name === "inference.job.claim" && !definitivelyNotApplied && (retryableInfrastructureRejection || hostNotClaimable || errorText.includes("External inference host is not live enough to claim work") || errorText.includes("External inference host request generation is stale") || errorText.includes("External inference claim runtime fence is stale"));
+            const retryableHeartbeatClockSkew = name === "inference.host.heartbeat" && definitivelyNotApplied;
+            const retryableAdvertisementClockSkew = (name === "inference.host.register" || name === "inference.host.advertise") && definitivelyNotApplied;
+            const staleHostHeartbeatGeneration = name === "inference.host.heartbeat" && errorText.includes("Heartbeat generations do not match the current host authority.");
+            const obsoleteClaimReplay = name === "inference.job.claim" && errorText.includes(
+              "External inference claim replay is no longer dispatchable"
+            );
+            throw new ExternalInferenceMcpError(
+              completionEvidenceExpired ? "completion_evidence_expired" : staleHostHeartbeatGeneration ? "generation_stale" : obsoleteClaimReplay ? "claim_replay_obsolete" : "tool_rejected",
+              `Insights MCP rejected ${name}.`,
+              {
+                definitivelyNotApplied: definitivelyNotApplied || staleHostHeartbeatGeneration,
+                // Claim polling is an idempotent control-plane operation. During an
+                // API rotation the MCP server can return a tool error after the
+                // request reached the application boundary, so retain and replay
+                // the exact request unless the server proves it was not applied.
+                retryable: retryableInfrastructureRejection || retryableClaimRejection || retryableHeartbeatClockSkew || retryableAdvertisementClockSkew,
+                serverFailureCode: publicToolError?.failure_code ?? null,
+                retryAfterMs: hostNotClaimable ? publicToolError?.retry_after_ms ?? null : null
+              }
+            );
+          }
+          const structured = inlineStructuredContentSchema.parse(callResult.structuredContent);
+          if (structured.capability !== name) {
+            throw new ExternalInferenceMcpError(
+              "invalid_response",
+              "Insights MCP returned a result for a different capability."
+            );
+          }
+          const result2 = contract.result.parse(structured.result);
+          verifyToolResult(name, argumentsDocument, result2);
+          outcome = "success";
+          return result2;
+        } finally {
+          if (timing) {
+            const receipt = timing.finish(outcome);
+            try {
+              void Promise.resolve(options.onClaimTiming?.(receipt)).catch(() => void 0);
+            } catch {
             }
-          );
-        }
-        const structured = inlineStructuredContentSchema.parse(callResult.structuredContent);
-        if (structured.capability !== name) {
-          throw new ExternalInferenceMcpError(
-            "invalid_response",
-            "Insights MCP returned a result for a different capability."
-          );
+          }
         }
-        const result2 = contract.result.parse(structured.result);
-        verifyToolResult(name, argumentsDocument, result2);
-        return result2;
       }
       async #token(refresh, options) {
         try {
@@ -19944,7 +19997,7 @@ var init_mcp_client = __esm({
           );
         }
       }
-      async #request(method, params, name, options = {}) {
+      async #request(method, params, name, options = {}, timing) {
         const timeoutMs = options.timeoutMs ?? this.#requestTimeoutMs;
         if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) {
           throw new ExternalInferenceMcpError(
@@ -19968,22 +20021,32 @@ var init_mcp_client = __esm({
             _meta: protocolMeta(this.#clientName, this.#clientVersion)
           }
         };
+        timing?.enter("token_lookup_ms");
+        const token = await this.#token(false, boundedOptions);
+        timing?.enter("fetch_headers_ms");
+        if (timing) timing.transportAttempts += 1;
         let response = await this.#send(
           method,
           name,
           body,
-          await this.#token(false, boundedOptions),
+          token,
           boundedOptions
         );
         if (response.status === 401 && this.#tokenSource.refreshAccessToken) {
+          timing?.enter("token_lookup_ms");
+          if (timing) timing.tokenRefreshes += 1;
+          const refreshedToken = await this.#token(true, boundedOptions);
+          timing?.enter("fetch_headers_ms");
+          if (timing) timing.transportAttempts += 1;
           response = await this.#send(
             method,
             name,
             body,
-            await this.#token(true, boundedOptions),
+            refreshedToken,
             boundedOptions
           );
         }
+        timing?.enter("other_ms");
         if (!response.ok) {
           const httpStatusCode = response.status;
           const retryAfterMs = parseRetryAfterMs(response);
@@ -19998,7 +20061,7 @@ var init_mcp_client = __esm({
         let documents;
         try {
           documents = await this.#bounded(
-            parseResponseDocuments(response),
+            parseResponseDocuments(response, timing),
             boundedOptions,
             "request_timeout"
           );
@@ -20006,6 +20069,7 @@ var init_mcp_client = __esm({
           await response.body?.cancel().catch(() => void 0);
           throw error48;
         }
+        timing?.enter("response_validation_ms");
         const document2 = documents.find((candidate) => candidate.id === requestId);
         if (!document2 || document2.jsonrpc !== "2.0") {
           throw new ExternalInferenceMcpError(
@@ -37396,6 +37460,7 @@ var init_runner = __esm({
               const request = receipt.pending_claim_request;
               if (request === claimPreparation.unsent && Date.parse(receipt.advertisement_expires_at ?? "") <= now()) break;
               let claim;
+              let claimTiming;
               const claimCallStartedAtMs = now();
               try {
                 claimOpportunities += 1;
@@ -37405,6 +37470,9 @@ var init_runner = __esm({
                   request,
                   {
                     signal: this.options.signal,
+                    onClaimTiming: (timing) => {
+                      claimTiming = timing;
+                    },
                     ...yieldRenewalToClaim ? { deadlineAtMs: expiresAt } : {}
                   }
                 );
@@ -37506,6 +37574,7 @@ var init_runner = __esm({
                   claimCallRoundTripMs - (claim.schema_version === "external_inference_job_claim_result_v3" ? claim.server_processing_ms : 0)
                 );
                 emitDiagnostic("claim_batch_received", {
+                  ...claimTiming ? { client_timing: claimTiming } : {},
                   claim_count: claim.claims.length,
                   round_trip_ms: claimCallRoundTripMs,
                   server_processing_ms: claim.schema_version === "external_inference_job_claim_result_v3" ? claim.server_processing_ms : null,

package/package.json

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