@vtxmacro/cli 2026.9.17 → 2026.9.18

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.17",
+  package_version: "2026.9.18",
   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.17",
+      package_version: "2026.9.18",
       codex_package_name: "@openai/codex",
       codex_version: "0.153.3",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -19254,7 +19254,8 @@ var init_mcp_client = __esm({
       failure_code: publicFailureCodeSchema,
       phase: safeCodeSchema2,
       retryable: external_exports.boolean(),
-      terminal_before_execution: external_exports.boolean()
+      terminal_before_execution: external_exports.boolean(),
+      retry_after_ms: external_exports.number().int().nonnegative().max(MAX_RETRY_AFTER_MS).optional()
     }).passthrough();
     structuredPublicToolErrorSchema = publicToolErrorSchema.extend({
       schema_version: external_exports.literal("vtx_insights_tool_error_v1")
@@ -19845,11 +19846,12 @@ var init_mcp_client = __esm({
           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.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 || 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 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.");
@@ -19866,7 +19868,8 @@ var init_mcp_client = __esm({
               // 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
+              serverFailureCode: publicToolError?.failure_code ?? null,
+              retryAfterMs: hostNotClaimable ? publicToolError?.retry_after_ms ?? null : null
             }
           );
         }
@@ -24692,6 +24695,7 @@ var init_codex_adapter = __esm({
         const promise2 = this.executeAttempt(input);
         this.inFlightAttempts.set(input.attemptId, {
           inputSha256: input.inputSha256,
+          deadlineAtMs: input.deadlineAtMs,
           promise: promise2
         });
         void promise2.then(async () => {
@@ -24715,6 +24719,25 @@ var init_codex_adapter = __esm({
             retryable: false
           });
         }
+        const activeAttempt = this.inFlightAttempts.get(attemptId);
+        if (activeAttempt) {
+          let timer;
+          try {
+            await Promise.race([
+              activeAttempt.promise.catch(() => void 0),
+              new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new CodexAppServerError({
+                  message: "Codex cancelled setup did not settle before its immutable deadline.",
+                  category: "adapter",
+                  code: "attempt_cleanup_unconfirmed",
+                  retryable: false
+                })), Math.max(1, Math.min(2147483647, activeAttempt.deadlineAtMs - Date.now())));
+              })
+            ]);
+          } finally {
+            if (timer !== void 0) clearTimeout(timer);
+          }
+        }
         const activeCleanup = this.attemptCleanups.get(attemptId);
         if (activeCleanup) {
           try {
@@ -24886,6 +24909,12 @@ var init_codex_adapter = __esm({
         let completedResult = null;
         let caughtError = null;
         let sessionInvalidationError = null;
+        let turnEntered = false;
+        const reportSetupCancellation = () => {
+          if (!turnEntered) input.onTerminalDispatchOutcome?.("not_dispatched");
+        };
+        input.signal?.addEventListener("abort", reportSetupCancellation, { once: true });
+        if (input.signal?.aborted) reportSetupCancellation();
         try {
           resources = await (this.dependencies.createAttemptResources ?? ((attemptId) => createIsolatedCodexAttemptResources(
             attemptId,
@@ -24946,6 +24975,8 @@ var init_codex_adapter = __esm({
           };
           latestCheckpoint = baseCheckpoint;
           await recoveryHooks?.save(baseCheckpoint);
+          assertAttemptActive(input.deadlineAtMs, input.signal);
+          turnEntered = true;
           const result2 = await session.executeTurn({
             thread,
             workspacePath: resources.workspacePath,
@@ -25063,6 +25094,7 @@ var init_codex_adapter = __esm({
           }
           throw classified;
         } finally {
+          input.signal?.removeEventListener("abort", reportSetupCancellation);
           sessionLease?.activeAttemptIds.delete(input.attemptId);
           const cleanup = async () => {
             let cleanupError = sessionInvalidationError;
@@ -36370,6 +36402,7 @@ var init_runner = __esm({
           const scheduleReceiptWriter = () => {
             if (receiptWriter || receiptWriterFailed) return;
             receiptWriter = (async () => {
+              await Promise.resolve();
               try {
                 while (persistedReceiptRevision < receiptRevision) {
                   const targetRevision = receiptRevision;
@@ -36595,6 +36628,7 @@ var init_runner = __esm({
               };
             }
           };
+          let claimAvailabilityBackoff = null;
           const hostHeartbeat = async (status, requestOptions = {
             signal: this.options.signal
           }, retryRemote = true, allowOfflineProjection = false, definitiveReseedAttempt = 0, advertisementGeneration = receipt.advertisement_generation) => {
@@ -36659,6 +36693,9 @@ var init_runner = __esm({
               );
               throw error48;
             }
+            if (claimAvailabilityBackoff !== null && result2.host.status === "online" && request.provider_quota_recovery != null && Date.parse(request.provider_quota_recovery.observed_at) >= claimAvailabilityBackoff.rejectedAtMs) {
+              claimAvailabilityBackoff = null;
+            }
           };
           await hostHeartbeat("healthy");
           let lastHostHeartbeatSucceededAt = now();
@@ -36951,13 +36988,15 @@ var init_runner = __esm({
                 });
               },
               onProviderDispatchWatchdog: (observation) => {
-                providerDispatchWatchdogDrainRequested = true;
                 emitDiagnostic("provider_dispatch_watchdog_expired", {
                   ...observation,
                   job_id: claim.job_id,
                   attempt_id: attemptId,
                   active_attempts: active.size
                 });
+              },
+              onProviderDispatchRecoveryRequired: () => {
+                providerDispatchWatchdogDrainRequested = true;
                 requestDrain("provider_dispatch_watchdog_expired");
               },
               startRetryCount: nextStartRetryCount,
@@ -37245,7 +37284,12 @@ var init_runner = __esm({
               const recovery = recoveryQueue.shift();
               launchClaim(recovery.claim, recovery);
             }
-            while (!drainRequested && recoveryQueue.length === 0 && (!this.options.once || !onceClaimed) && (settings.maxConcurrency === null || active.size < settings.maxConcurrency) && pendingClaimPromotions === 0 && now() >= Math.max(nextClaimAt, providerRetryAtMs ?? 0, providerFailureRetryAtMs)) {
+            while (!drainRequested && recoveryQueue.length === 0 && (!this.options.once || !onceClaimed) && (settings.maxConcurrency === null || active.size < settings.maxConcurrency) && pendingClaimPromotions === 0 && now() >= Math.max(
+              nextClaimAt,
+              claimAvailabilityBackoff?.untilMs ?? 0,
+              providerRetryAtMs ?? 0,
+              providerFailureRetryAtMs
+            )) {
               if (!receipt.pending_claim_request) {
                 await mutateReceipt(preparePendingClaim);
               }
@@ -37327,7 +37371,13 @@ var init_runner = __esm({
                     requestDrain("claim_failed");
                   }
                 } else if (!this.options.signal?.aborted && retryableRemoteError(error48)) {
-                  nextClaimAt = now() + remoteRetryAfterMs(error48, 1e3);
+                  const rejectedAtMs = now();
+                  const retryAtMs = rejectedAtMs + remoteRetryAfterMs(error48, 1e3);
+                  if (error48 instanceof ExternalInferenceMcpError && error48.serverFailureCode === "host_not_claimable") {
+                    claimAvailabilityBackoff = { untilMs: retryAtMs, rejectedAtMs };
+                  } else {
+                    nextClaimAt = retryAtMs;
+                  }
                 } else if (!this.options.signal?.aborted) {
                   requestDrain("claim_failed");
                 }
@@ -37465,7 +37515,12 @@ var init_runner = __esm({
             if (drainRequested) break;
             const advertisementDueAt = nextAdvertisementAttemptAt > now() ? nextAdvertisementAttemptAt : receipt.advertisement_expires_at ? Date.parse(receipt.advertisement_expires_at) - settings.advertisementRefreshLeadMs : now() + MIN_SLEEP_MS;
             const wakeAt = Math.min(
-              Math.max(nextClaimAt, providerRetryAtMs ?? 0, providerFailureRetryAtMs),
+              Math.max(
+                nextClaimAt,
+                claimAvailabilityBackoff?.untilMs ?? 0,
+                providerRetryAtMs ?? 0,
+                providerFailureRetryAtMs
+              ),
               nextProviderRateLimitRefreshAt,
               now() + settings.hostHeartbeatMs,
               Math.max(now() + MIN_SLEEP_MS, advertisementDueAt)
@@ -37846,10 +37901,6 @@ var init_runner = __esm({
                 options.prestarted.claimResponseReceivedAtMs,
                 options.prestarted.roundTripMs
               );
-              if (options.prestarted.receiptDurability) {
-                reportPreProviderStage("receipt_persistence");
-                await awaitPreProviderDurability(options.prestarted.receiptDurability);
-              }
             } else {
               reportPreProviderStage("receipt_persistence");
               const claimPromotionPromise = options.resumeReceipt ? Promise.resolve() : awaitPreProviderDurability(
@@ -37933,10 +37984,13 @@ var init_runner = __esm({
             const providerDispatchable = inputValidationError === void 0 && outputContract !== null;
             reportPreProviderStage("receipt_persistence");
             await awaitPreProviderDurability(
-              persistAttempt({
-                phase: providerDispatchable ? "dispatched" : "started",
-                dispatch_outcome: providerDispatchable ? "outcome_unknown" : "not_dispatched"
-              })
+              Promise.all([
+                persistAttempt({
+                  phase: providerDispatchable ? "dispatched" : "started",
+                  dispatch_outcome: providerDispatchable ? "outcome_unknown" : "not_dispatched"
+                }),
+                options.prestarted?.receiptDurability
+              ])
             );
           }
           reportPreProviderStage("thread_setup");
@@ -37944,6 +37998,7 @@ var init_runner = __esm({
           clearProviderDispatchWatchdog();
           signal.removeEventListener("abort", relayAbort);
           if (providerDispatchWatchdogExpired) {
+            options.onProviderDispatchRecoveryRequired?.();
             return terminalizeProviderDispatchWatchdog();
           }
           throw error48;
@@ -38091,6 +38146,7 @@ var init_runner = __esm({
                   dispatchOutcome: "not_dispatched"
                 });
               }
+              options.onProviderDispatchRecoveryRequired?.();
               throw new CodexAppServerError({
                 message: "Provider dispatch could not be excluded after the freshness watchdog expired.",
                 category: "timeout",

package/package.json

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