@vtxmacro/cli 2026.9.6 → 2026.9.8

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

package/bin/vtx.js

@@ -47,7 +47,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.9.6",
+      package_version: "2026.9.8",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -14442,7 +14442,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_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, agentConnectRequestSchema, agentNextRequestSchema, agentHeartbeatRequestSchema, emptyAgentNextResultSchema, claimedAgentNextResultSchema, agentNextResultSchema, agentCompleteRequestSchema, agentFailRequestSchema, requestedModelSelectionSchema, completedModelProvenanceSchema, attemptModelProvenanceSchema, providerWeeklyQuotaReadSchema, hostHeartbeatRequestSchema, jobClaimRequestSchema, emptyJobClaimSchema, claimedJobSchema, 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, 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";
@@ -14452,6 +14452,7 @@ var init_external_inference_contract = __esm({
     EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION_V2 = "external_inference_controller_v2";
     EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION = "external_inference_advertisement_v1";
     EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION = "external_inference_envelope_v1";
+    EXTERNAL_INFERENCE_COMPRESSED_INPUT_ENVELOPE_SCHEMA_VERSION = "external_inference_input_envelope_v2";
     EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION = "external_inference_job_input_v2";
     LEGACY_EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION = "external_inference_job_input_v1";
     EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION = "external_inference_usage_v1";
@@ -14858,7 +14859,10 @@ var init_external_inference_contract = __esm({
       }
     });
     envelopeAadSchema = external_exports.strictObject({
-      envelope_version: external_exports.literal(EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION),
+      envelope_version: external_exports.union([
+        external_exports.literal(EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION),
+        external_exports.literal(EXTERNAL_INFERENCE_COMPRESSED_INPUT_ENVELOPE_SCHEMA_VERSION)
+      ]),
       suite: external_exports.literal("X25519-HKDF-SHA256-AES256GCM"),
       direction: external_exports.enum(["wrap", "input", "candidate"]),
       job_id: identifierSchema,
@@ -14871,6 +14875,9 @@ var init_external_inference_contract = __esm({
       plaintext_sha256: sha256HexSchema
     });
     validateEnvelopeAad = (value, context, attemptRequired) => {
+      if (value.aad.envelope_version !== value.schema_version) {
+        context.addIssue({ code: "custom", message: "envelope schema version must match AAD envelope version", path: ["aad", "envelope_version"] });
+      }
       if (value.aad.direction !== value.direction) {
         context.addIssue({ code: "custom", message: "envelope direction must match AAD direction", path: ["aad", "direction"] });
       }
@@ -14900,7 +14907,10 @@ var init_external_inference_contract = __esm({
       }
     };
     commonEnvelopeShape = {
-      schema_version: external_exports.literal(EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION),
+      schema_version: external_exports.union([
+        external_exports.literal(EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION),
+        external_exports.literal(EXTERNAL_INFERENCE_COMPRESSED_INPUT_ENVELOPE_SCHEMA_VERSION)
+      ]),
       suite: external_exports.literal("X25519-HKDF-SHA256-AES256GCM"),
       key_generation: generationSchema,
       nonce: base64UrlNonceSchema,
@@ -14911,6 +14921,7 @@ var init_external_inference_contract = __esm({
     };
     sealedKeyWrapEnvelopeSchema = external_exports.strictObject({
       ...commonEnvelopeShape,
+      schema_version: external_exports.literal(EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION),
       direction: external_exports.literal("wrap"),
       ephemeral_public_key: base64Url32BytesSchema
     }).superRefine((value, context) => validateEnvelopeAad(value, context, false));
@@ -14920,6 +14931,7 @@ var init_external_inference_contract = __esm({
     }).superRefine((value, context) => validateEnvelopeAad(value, context, false));
     sealedCandidateEnvelopeSchema = external_exports.strictObject({
       ...commonEnvelopeShape,
+      schema_version: external_exports.literal(EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION),
       direction: external_exports.literal("candidate")
     }).superRefine((value, context) => validateEnvelopeAad(value, context, true));
     sealedEnvelopeSchema = external_exports.discriminatedUnion("direction", [
@@ -15363,8 +15375,7 @@ var init_external_inference_contract = __esm({
       provider_weekly_quota: providerWeeklyQuotaReadSchema.nullable().optional(),
       observed_at: timestampSchema
     });
-    jobClaimRequestSchema = external_exports.strictObject({
-      schema_version: external_exports.literal("external_inference_job_claim_v1"),
+    jobClaimRequestBaseShape = {
       contract_version: external_exports.literal(EXTERNAL_INFERENCE_CONTRACT_VERSION),
       host_id: identifierSchema,
       host_generation: generationSchema,
@@ -15372,7 +15383,23 @@ var init_external_inference_contract = __esm({
       key_generation: generationSchema,
       claim_request_id: operationIdentifierSchema,
       requested_at: timestampSchema
-    });
+    };
+    jobClaimRequestSchema = external_exports.discriminatedUnion("schema_version", [
+      external_exports.strictObject({
+        schema_version: external_exports.literal("external_inference_job_claim_v1"),
+        ...jobClaimRequestBaseShape
+      }),
+      external_exports.strictObject({
+        schema_version: external_exports.literal("external_inference_job_claim_v2"),
+        ...jobClaimRequestBaseShape,
+        maximum_jobs: external_exports.number().int().min(1).max(32)
+      }),
+      external_exports.strictObject({
+        schema_version: external_exports.literal("external_inference_job_claim_v3"),
+        ...jobClaimRequestBaseShape,
+        maximum_jobs: external_exports.number().int().min(1).max(32)
+      })
+    ]);
     emptyJobClaimSchema = external_exports.strictObject({
       schema_version: external_exports.literal("external_inference_job_claim_result_v1"),
       claim_state: external_exports.literal("empty"),
@@ -15415,9 +15442,32 @@ var init_external_inference_contract = __esm({
         context.addIssue({ code: "custom", message: "claim lease cannot exceed the immutable deadline", path: ["lease_expires_at"] });
       }
     });
-    jobClaimResultSchema = external_exports.discriminatedUnion("claim_state", [
+    claimedDispatchIntentSchema = external_exports.strictObject({
+      claim: claimedJobSchema,
+      attempt_id: identifierSchema,
+      started_at: timestampSchema,
+      provider_dispatch_freshness_remaining_ms: nonNegativeSafeIntegerSchema
+    });
+    batchedJobClaimSchema = external_exports.strictObject({
+      schema_version: external_exports.literal("external_inference_job_claim_result_v2"),
+      claim_state: external_exports.literal("batch"),
+      claim_request_id: operationIdentifierSchema,
+      claims: external_exports.array(claimedDispatchIntentSchema).max(32),
+      retry_after_ms: nonNegativeSafeIntegerSchema
+    });
+    timedBatchedJobClaimSchema = external_exports.strictObject({
+      schema_version: external_exports.literal("external_inference_job_claim_result_v3"),
+      claim_state: external_exports.literal("batch"),
+      claim_request_id: operationIdentifierSchema,
+      claims: external_exports.array(claimedDispatchIntentSchema).max(32),
+      retry_after_ms: nonNegativeSafeIntegerSchema,
+      server_processing_ms: nonNegativeSafeIntegerSchema
+    });
+    jobClaimResultSchema = external_exports.union([
       emptyJobClaimSchema,
-      claimedJobSchema
+      claimedJobSchema,
+      batchedJobClaimSchema,
+      timedBatchedJobClaimSchema
     ]);
     attemptStartRequestSchema = external_exports.strictObject({
       schema_version: external_exports.literal("external_inference_attempt_start_v1"),
@@ -18689,6 +18739,19 @@ var init_mcp_client = __esm({
       if (name === "inference.job.claim") {
         if (result2.claim_request_id !== request.claim_request_id) invalidBoundResult(name);
         if (result2.claim_state === "claimed" && (result2.host_id !== request.host_id || result2.host_generation !== request.host_generation || result2.advertisement_generation > request.advertisement_generation || result2.key_generation !== request.key_generation)) invalidBoundResult(name);
+        if (result2.claim_state === "batch") {
+          if (request.schema_version !== "external_inference_job_claim_v2" && request.schema_version !== "external_inference_job_claim_v3" || result2.schema_version !== (request.schema_version === "external_inference_job_claim_v3" ? "external_inference_job_claim_result_v3" : "external_inference_job_claim_result_v2") || result2.claims.length > request.maximum_jobs) {
+            invalidBoundResult(name);
+          }
+          const jobIds = /* @__PURE__ */ new Set();
+          const attemptIds = /* @__PURE__ */ new Set();
+          for (const item of result2.claims) {
+            const claim = item.claim;
+            if (claim.host_id !== request.host_id || claim.host_generation !== request.host_generation || claim.advertisement_generation > request.advertisement_generation || claim.key_generation !== request.key_generation || jobIds.has(claim.job_id) || attemptIds.has(item.attempt_id)) invalidBoundResult(name);
+            jobIds.add(claim.job_id);
+            attemptIds.add(item.attempt_id);
+          }
+        }
         return;
       }
       if (name === "inference.job.start") {
@@ -25929,6 +25992,7 @@ import {
   hkdfSync,
   randomBytes as randomBytes5
 } from "node:crypto";
+import { gunzipSync } from "node:zlib";
 var ENVELOPE_SUITE, JOB_KEY_PAYLOAD_SCHEMA_VERSION, WRAP_HKDF_INFO, PAYLOAD_HKDF_INFO, X25519_PKCS8_PREFIX, X25519_SPKI_PREFIX, ExternalInferenceEnvelopeError, canonicalize, canonicalEnvelopeAadBytes, externalInferenceSha256, decodeCanonicalBase64Url, rawPrivateKey, rawPublicKey, rawPublicBytes, aesGcmDecrypt, aesGcmEncrypt, assertIdentity, validatePlaintext, generateExternalInferenceEnvelopeKeyPair, externalInferenceEnvelopePublicKey, deriveKey, deriveExternalInferencePayloadKey, unwrapExternalInferenceJobKey, decryptExternalInferenceJobInput, decryptExternalInferenceClaim, sealExternalInferenceCandidate;
 var init_crypto = __esm({
   "lib/inference-host/crypto.ts"() {
@@ -26121,12 +26185,27 @@ var init_crypto = __esm({
         );
       }
       const aadBytes = canonicalEnvelopeAadBytes(envelope.aad);
-      const plaintext = aesGcmDecrypt(
+      const encodedPlaintext = aesGcmDecrypt(
         deriveExternalInferencePayloadKey(jobKey, envelope.aad),
         decodeCanonicalBase64Url(envelope.nonce, "External inference envelope nonce", 12),
         decodeCanonicalBase64Url(envelope.ciphertext, "External inference envelope ciphertext"),
         aadBytes
       );
+      let plaintext;
+      if (envelope.schema_version === EXTERNAL_INFERENCE_COMPRESSED_INPUT_ENVELOPE_SCHEMA_VERSION) {
+        try {
+          plaintext = gunzipSync(encodedPlaintext, {
+            maxOutputLength: envelope.plaintext_bytes
+          });
+        } catch {
+          throw new ExternalInferenceEnvelopeError(
+            "invalid_job_input",
+            "External inference compressed immutable input is invalid."
+          );
+        }
+      } else {
+        plaintext = encodedPlaintext;
+      }
       validatePlaintext(plaintext, envelope.plaintext_bytes, envelope.plaintext_sha256);
       let rawJob;
       try {
@@ -32508,7 +32587,7 @@ function createDefaultInferenceHostRunnerDependencies(options) {
     envelopePublicKey: options.envelopePublicKey
   };
 }
-var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, DEFAULT_AGENT_RATE_LIMIT_COOLDOWN_MS, DEFAULT_AGENT_QUOTA_COOLDOWN_MS, DEFAULT_AGENT_TRANSIENT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, settlesWithin, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, serverProviderDispatchNotAfterMs, membershipFailureDisposition, safeFailureCode, publicServerFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, isDefinitiveCompletionEvidenceExpiry, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner, createInferenceAgentControlClient, INFERENCE_AGENT_SYSTEM_PROMPT, INFERENCE_AGENT_WAKE_SCHEMA, parseInferenceAgentWake, InferenceAgentRuntime;
+var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, CLAIM_DISPATCH_BATCH_SIZE, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, DEFAULT_AGENT_RATE_LIMIT_COOLDOWN_MS, DEFAULT_AGENT_QUOTA_COOLDOWN_MS, DEFAULT_AGENT_TRANSIENT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, settlesWithin, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, serverProviderDispatchNotAfterMs, membershipFailureDisposition, safeFailureCode, publicServerFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, isDefinitiveCompletionEvidenceExpiry, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner, createInferenceAgentControlClient, INFERENCE_AGENT_SYSTEM_PROMPT, INFERENCE_AGENT_WAKE_SCHEMA, parseInferenceAgentWake, InferenceAgentRuntime;
 var init_runner = __esm({
   "lib/inference-host/runner.ts"() {
     "use strict";
@@ -32523,6 +32602,7 @@ var init_runner = __esm({
     init_oauth();
     RUNTIME_RECEIPT_SCHEMA_VERSION = "vtx_inference_host_runtime_v1";
     ATTEMPT_RECEIPT_SCHEMA_VERSION = "vtx_inference_attempt_receipt_v1";
+    CLAIM_DISPATCH_BATCH_SIZE = 16;
     DEFAULT_ADVERTISEMENT_TTL_MS = 12e4;
     DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS = 3e4;
     DEFAULT_HOST_HEARTBEAT_MS = 3e3;
@@ -33808,28 +33888,47 @@ var init_runner = __esm({
           let nextClaimAt = Math.max(now(), providerRetryAtMs ?? 0);
           let pendingClaimPromotions = 0;
           let onceClaimed = false;
+          let batchClaimVersion = 3;
           const preparePendingClaim = (current) => {
             if (current.pending_claim_request) return current;
             const claimSequence = current.claim_sequence + 1;
             const requestedAt = now();
+            const claimRequestBase = {
+              contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
+              host_id: localState.host_id,
+              host_generation: localState.host_generation,
+              advertisement_generation: current.advertisement_generation,
+              key_generation: localState.key_generation,
+              claim_request_id: stableOperationId("claim", [
+                localState.host_id,
+                localState.host_generation,
+                current.advertisement_generation,
+                claimSequence
+              ]),
+              requested_at: isoAt(requestedAt)
+            };
+            const pendingClaimRequest = batchClaimVersion === 3 ? {
+              schema_version: "external_inference_job_claim_v3",
+              ...claimRequestBase,
+              maximum_jobs: Math.min(
+                this.options.once ? 1 : CLAIM_DISPATCH_BATCH_SIZE,
+                settings.maxConcurrency === null ? CLAIM_DISPATCH_BATCH_SIZE : Math.max(1, settings.maxConcurrency - active.size)
+              )
+            } : batchClaimVersion === 2 ? {
+              schema_version: "external_inference_job_claim_v2",
+              ...claimRequestBase,
+              maximum_jobs: Math.min(
+                this.options.once ? 1 : CLAIM_DISPATCH_BATCH_SIZE,
+                settings.maxConcurrency === null ? CLAIM_DISPATCH_BATCH_SIZE : Math.max(1, settings.maxConcurrency - active.size)
+              )
+            } : {
+              schema_version: "external_inference_job_claim_v1",
+              ...claimRequestBase
+            };
             return {
               ...current,
               claim_sequence: claimSequence,
-              pending_claim_request: {
-                schema_version: "external_inference_job_claim_v1",
-                contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
-                host_id: localState.host_id,
-                host_generation: localState.host_generation,
-                advertisement_generation: current.advertisement_generation,
-                key_generation: localState.key_generation,
-                claim_request_id: stableOperationId("claim", [
-                  localState.host_id,
-                  localState.host_generation,
-                  current.advertisement_generation,
-                  claimSequence
-                ]),
-                requested_at: isoAt(requestedAt)
-              },
+              pending_claim_request: pendingClaimRequest,
               updated_at: isoAt(requestedAt)
             };
           };
@@ -33948,8 +34047,8 @@ var init_runner = __esm({
           });
           const recoveryQueue = [];
           const attemptStartRetryCounts = /* @__PURE__ */ new Map();
-          const launchClaim = (claim, recovery, claimRequest) => {
-            if (!recovery) {
+          const launchClaim = (claim, recovery, claimRequest, prestarted) => {
+            if (!recovery || prestarted) {
               claimed += 1;
               onceClaimed = true;
             }
@@ -34048,6 +34147,7 @@ var init_runner = __esm({
               },
               resumeReceipt: recovery,
               claimRequest,
+              prestarted,
               onClaimPersisted: settleClaimPromotion,
               rolloverClaimRequest: (current) => {
                 if (drainRequested || this.options.once || settings.maxConcurrency !== null && active.size + 1 >= settings.maxConcurrency) return current;
@@ -34251,6 +34351,7 @@ var init_runner = __esm({
               }
               const request = receipt.pending_claim_request;
               let claim;
+              const claimCallStartedAtMs = now();
               try {
                 claim = await mcp.callTool(
                   "inference.job.claim",
@@ -34259,7 +34360,48 @@ var init_runner = __esm({
                 );
                 assertClaimResult(request, claim);
               } catch (error48) {
-                if (!this.options.signal?.aborted && controlPlaneFatal(error48)) {
+                if (!this.options.signal?.aborted && request.schema_version === "external_inference_job_claim_v3" && error48 instanceof ExternalInferenceMcpError && error48.serverFailureCode === "schema_validation") {
+                  batchClaimVersion = 2;
+                  await mutateReceipt((current) => ({
+                    ...current,
+                    pending_claim_request: current.pending_claim_request?.claim_request_id === request.claim_request_id ? {
+                      schema_version: "external_inference_job_claim_v2",
+                      contract_version: request.contract_version,
+                      host_id: request.host_id,
+                      host_generation: request.host_generation,
+                      advertisement_generation: request.advertisement_generation,
+                      key_generation: request.key_generation,
+                      claim_request_id: stableOperationId("claim-fallback-v2", [
+                        request.claim_request_id
+                      ]),
+                      requested_at: isoAt(now()),
+                      maximum_jobs: request.maximum_jobs
+                    } : current.pending_claim_request,
+                    updated_at: isoAt(now())
+                  }));
+                  nextClaimAt = now();
+                  continue;
+                } else if (!this.options.signal?.aborted && request.schema_version === "external_inference_job_claim_v2" && error48 instanceof ExternalInferenceMcpError && error48.serverFailureCode === "schema_validation") {
+                  batchClaimVersion = 1;
+                  await mutateReceipt((current) => ({
+                    ...current,
+                    pending_claim_request: current.pending_claim_request?.claim_request_id === request.claim_request_id ? {
+                      schema_version: "external_inference_job_claim_v1",
+                      contract_version: request.contract_version,
+                      host_id: request.host_id,
+                      host_generation: request.host_generation,
+                      advertisement_generation: request.advertisement_generation,
+                      key_generation: request.key_generation,
+                      claim_request_id: stableOperationId("claim-fallback-v1", [
+                        request.claim_request_id
+                      ]),
+                      requested_at: isoAt(now())
+                    } : current.pending_claim_request,
+                    updated_at: isoAt(now())
+                  }));
+                  nextClaimAt = now();
+                  continue;
+                } else if (!this.options.signal?.aborted && controlPlaneFatal(error48)) {
                   requestDrain("authority_lost");
                 } else if (!this.options.signal?.aborted && error48 instanceof ExternalInferenceMcpError && error48.code === "claim_replay_obsolete") {
                   await mutateReceipt((current) => ({
@@ -34291,6 +34433,109 @@ var init_runner = __esm({
                 }
                 break;
               }
+              const claimResponseReceivedAtMs = now();
+              const claimCallRoundTripMs = Math.max(
+                0,
+                claimResponseReceivedAtMs - claimCallStartedAtMs
+              );
+              if (claim.claim_state === "batch") {
+                if (request.schema_version === "external_inference_job_claim_v1") {
+                  runnerIdentityMismatch("Batched job claim");
+                }
+                const maximumJobs = "maximum_jobs" in request ? request.maximum_jobs : runnerIdentityMismatch("Batched job claim");
+                const expectedBatchResultVersion = request.schema_version === "external_inference_job_claim_v3" ? "external_inference_job_claim_result_v3" : "external_inference_job_claim_result_v2";
+                if (claim.schema_version !== expectedBatchResultVersion || claim.claims.length > maximumJobs) runnerIdentityMismatch("Batched job claim");
+                const claimTransportResidualMs = Math.max(
+                  0,
+                  claimCallRoundTripMs - (claim.schema_version === "external_inference_job_claim_result_v3" ? claim.server_processing_ms : 0)
+                );
+                if (claim.claims.length === 0) {
+                  await mutateReceipt((current) => ({
+                    ...current,
+                    pending_claim_request: current.pending_claim_request?.claim_request_id === request.claim_request_id ? null : current.pending_claim_request,
+                    updated_at: isoAt(now())
+                  }));
+                  nextClaimAt = now() + Math.max(MIN_SLEEP_MS, claim.retry_after_ms);
+                  if (this.options.once) requestDrain("once_empty");
+                  break;
+                }
+                const decryptClaim = this.dependencies.decryptClaim ?? decryptExternalInferenceClaim;
+                const prepared = claim.claims.map((item) => {
+                  const claimedJob = item.claim;
+                  if (claimedJob.host_id !== localState.host_id || claimedJob.host_generation !== localState.host_generation || claimedJob.advertisement_generation > receipt.advertisement_generation || claimedJob.key_generation !== localState.key_generation) runnerIdentityMismatch("Batched job claim");
+                  const { jobInput } = decryptClaim(
+                    credential.x25519_private_key,
+                    claimedJob
+                  );
+                  const expectedAttemptId = stableOperationId("attempt", [
+                    claimedJob.host_id,
+                    claimedJob.job_id,
+                    claimedJob.claim_generation,
+                    claimedJob.attempt_index,
+                    claimedJob.input_sha256
+                  ]);
+                  if (item.attempt_id !== expectedAttemptId) {
+                    runnerIdentityMismatch("Batched attempt");
+                  }
+                  const startRequest = buildAttemptStartRequest(
+                    claimedJob,
+                    item.attempt_id,
+                    item.started_at
+                  );
+                  return validateAttemptReceipt({
+                    schema_version: ATTEMPT_RECEIPT_SCHEMA_VERSION,
+                    attempt_id: item.attempt_id,
+                    job_id: claimedJob.job_id,
+                    profile_id: jobInput.profile_id,
+                    input_sha256: jobInput.input_sha256,
+                    claim_generation: claimedJob.claim_generation,
+                    attempt_index: claimedJob.attempt_index,
+                    phase: "claimed",
+                    dispatch_outcome: "not_dispatched",
+                    terminal_operation_id: null,
+                    job_heartbeat_sequence: 0,
+                    claim: claimedJob,
+                    start_request: startRequest,
+                    terminal_request: null,
+                    updated_at: isoAt(now())
+                  });
+                });
+                const shouldRollover = !this.options.once && (settings.maxConcurrency === null || active.size + prepared.length < settings.maxConcurrency);
+                await mutateReceipt((current) => {
+                  if (current.pending_claim_request?.claim_request_id !== request.claim_request_id) runnerIdentityMismatch("Batched claim receipt");
+                  const attempts = { ...current.attempts };
+                  for (const attempt of prepared) {
+                    if (attempts[attempt.attempt_id]) {
+                      runnerIdentityMismatch("Batched attempt receipt");
+                    }
+                    attempts[attempt.attempt_id] = attempt;
+                  }
+                  const promoted = {
+                    ...current,
+                    pending_claim_request: null,
+                    attempts,
+                    updated_at: isoAt(now())
+                  };
+                  return shouldRollover ? preparePendingClaim(promoted) : promoted;
+                });
+                for (let index = 0; index < prepared.length; index += 1) {
+                  const item = claim.claims[index];
+                  launchClaim(item.claim, prepared[index], void 0, {
+                    result: {
+                      job_id: item.claim.job_id,
+                      attempt_id: item.attempt_id,
+                      attempt_index: item.claim.attempt_index,
+                      state: "dispatch_intent",
+                      provider_dispatch_freshness_remaining_ms: item.provider_dispatch_freshness_remaining_ms
+                    },
+                    roundTripMs: claimTransportResidualMs,
+                    claimResponseReceivedAtMs
+                  });
+                }
+                if (this.options.once) requestDrain("once_complete");
+                nextClaimAt = claim.claims.length >= (request.schema_version !== "external_inference_job_claim_v1" ? request.maximum_jobs : CLAIM_DISPATCH_BATCH_SIZE) ? now() : now() + Math.max(MIN_SLEEP_MS, claim.retry_after_ms);
+                continue;
+              }
               if (claim.claim_state === "empty") {
                 await mutateReceipt((current) => ({
                   ...current,
@@ -34536,69 +34781,75 @@ var init_runner = __esm({
           let startResult;
           const startCallStartedAtMs = now();
           let startCallCompletedAtMs = startCallStartedAtMs;
-          const claimPromotionPromise = options.resumeReceipt ? Promise.resolve() : persistAttempt({ phase: "claimed" }, true);
-          const startCallPromise = retryExact(() => mcp.callTool(
-            "inference.job.start",
-            startRequest,
-            { signal, deadlineAtMs: attemptDeadlineAtMs }
-          ), { signal, deadlineAtMs: attemptDeadlineAtMs }).then((result2) => {
+          if (options.prestarted) {
+            startResult = options.prestarted.result;
             startCallCompletedAtMs = now();
-            return result2;
-          });
-          const [startOutcome, claimPromotionOutcome] = await Promise.allSettled([
-            startCallPromise,
-            claimPromotionPromise
-          ]);
-          if (claimPromotionOutcome.status === "rejected") {
-            throw claimPromotionOutcome.reason;
-          }
-          if (startOutcome.status === "rejected") {
-            const error48 = startOutcome.reason;
-            if (error48 instanceof ExternalInferenceMcpError && error48.serverFailureCode === "server_account_context_expired_before_provider_dispatch") {
-              await removeAttempt();
-              options.onAttemptOutcome?.({
-                outcome: "freshness_rejected_before_provider_dispatch",
-                failure_category: "freshness",
-                failure_code: error48.serverFailureCode,
-                dispatch_outcome: "not_dispatched"
+            startRoundTripMs = Math.max(0, options.prestarted.roundTripMs);
+          } else {
+            const claimPromotionPromise = options.resumeReceipt ? Promise.resolve() : persistAttempt({ phase: "claimed" }, true);
+            const startCallPromise = retryExact(() => mcp.callTool(
+              "inference.job.start",
+              startRequest,
+              { signal, deadlineAtMs: attemptDeadlineAtMs }
+            ), { signal, deadlineAtMs: attemptDeadlineAtMs }).then((result2) => {
+              startCallCompletedAtMs = now();
+              return result2;
+            });
+            const [startOutcome, claimPromotionOutcome] = await Promise.allSettled([
+              startCallPromise,
+              claimPromotionPromise
+            ]);
+            if (claimPromotionOutcome.status === "rejected") {
+              throw claimPromotionOutcome.reason;
+            }
+            if (startOutcome.status === "rejected") {
+              const error48 = startOutcome.reason;
+              if (error48 instanceof ExternalInferenceMcpError && error48.serverFailureCode === "server_account_context_expired_before_provider_dispatch") {
+                await removeAttempt();
+                options.onAttemptOutcome?.({
+                  outcome: "freshness_rejected_before_provider_dispatch",
+                  failure_category: "freshness",
+                  failure_code: error48.serverFailureCode,
+                  dispatch_outcome: "not_dispatched"
+                });
+                return "failed";
+              }
+              if (attemptDeadlineAtMs <= now() + MIN_CLAIM_START_WINDOW_MS) {
+                await removeAttempt();
+                return "failed";
+              }
+              if (signal.aborted) throw error48;
+              if (controlPlaneFatal(error48)) throw error48;
+              const remainingMs = Math.max(
+                MIN_SLEEP_MS,
+                attemptDeadlineAtMs - now() - MIN_CLAIM_START_WINDOW_MS
+              );
+              const retryCount = Math.min(
+                Math.max(1, options.startRetryCount),
+                Number.MAX_SAFE_INTEGER
+              );
+              const retryDelayMs = Math.min(
+                remoteRetryAfterMs(error48, attemptStartRetryFallbackMs(retryCount)),
+                remainingMs
+              );
+              const rawErrorCode = error48 && typeof error48 === "object" && "code" in error48 ? String(error48.code) : "start_acknowledgement_failed";
+              options.onAttemptStartRetry?.({
+                failure_stage: "job_start_acknowledgement",
+                error_code: safeFailureCode(rawErrorCode, "start_acknowledgement_failed"),
+                http_status_code: error48 instanceof ExternalInferenceMcpError ? error48.httpStatusCode : null,
+                retryable: retryableRemoteError(error48),
+                definitively_not_applied: Boolean(
+                  error48 && typeof error48 === "object" && "definitivelyNotApplied" in error48 && error48.definitivelyNotApplied === true
+                ),
+                retry_after_ms: error48 instanceof ExternalInferenceMcpError ? error48.retryAfterMs : null,
+                retry_count: retryCount,
+                next_delay_ms: retryDelayMs
               });
-              return "failed";
+              await options.sleep(retryDelayMs, signal);
+              return "retry_claimed";
             }
-            if (attemptDeadlineAtMs <= now() + MIN_CLAIM_START_WINDOW_MS) {
-              await removeAttempt();
-              return "failed";
-            }
-            if (signal.aborted) throw error48;
-            if (controlPlaneFatal(error48)) throw error48;
-            const remainingMs = Math.max(
-              MIN_SLEEP_MS,
-              attemptDeadlineAtMs - now() - MIN_CLAIM_START_WINDOW_MS
-            );
-            const retryCount = Math.min(
-              Math.max(1, options.startRetryCount),
-              Number.MAX_SAFE_INTEGER
-            );
-            const retryDelayMs = Math.min(
-              remoteRetryAfterMs(error48, attemptStartRetryFallbackMs(retryCount)),
-              remainingMs
-            );
-            const rawErrorCode = error48 && typeof error48 === "object" && "code" in error48 ? String(error48.code) : "start_acknowledgement_failed";
-            options.onAttemptStartRetry?.({
-              failure_stage: "job_start_acknowledgement",
-              error_code: safeFailureCode(rawErrorCode, "start_acknowledgement_failed"),
-              http_status_code: error48 instanceof ExternalInferenceMcpError ? error48.httpStatusCode : null,
-              retryable: retryableRemoteError(error48),
-              definitively_not_applied: Boolean(
-                error48 && typeof error48 === "object" && "definitivelyNotApplied" in error48 && error48.definitivelyNotApplied === true
-              ),
-              retry_after_ms: error48 instanceof ExternalInferenceMcpError ? error48.retryAfterMs : null,
-              retry_count: retryCount,
-              next_delay_ms: retryDelayMs
-            });
-            await options.sleep(retryDelayMs, signal);
-            return "retry_claimed";
+            startResult = startOutcome.value;
           }
-          startResult = startOutcome.value;
           assertStartResult(startRequest, startResult);
           if (serverProviderDispatchDeadlineMs !== void 0) {
             const serverRemaining = startResult.provider_dispatch_freshness_remaining_ms;
@@ -34608,13 +34859,16 @@ var init_runner = __esm({
                 "The Server provider-dispatch freshness receipt is unavailable."
               );
             }
-            startRoundTripMs = Math.max(0, startCallCompletedAtMs - startCallStartedAtMs);
+            if (!options.prestarted) {
+              startRoundTripMs = Math.max(0, startCallCompletedAtMs - startCallStartedAtMs);
+            }
             serverReportedFreshnessRemainingMs = Number(serverRemaining);
             const conservativeRemainingMs = Math.max(
               0,
               serverReportedFreshnessRemainingMs - startRoundTripMs
             );
-            providerDispatchNotAfterMs = startCallCompletedAtMs + conservativeRemainingMs;
+            const freshnessAnchorAtMs = options.prestarted ? options.prestarted.claimResponseReceivedAtMs : startCallCompletedAtMs;
+            providerDispatchNotAfterMs = freshnessAnchorAtMs + conservativeRemainingMs;
           }
         }
         if (attemptReceipt.phase !== "dispatched") {

package/package.json

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