@vtxmacro/cli 2026.9.21 → 2026.9.23

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.21",
+  package_version: "2026.9.23",
   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.21",
+      package_version: "2026.9.23",
       codex_package_name: "@openai/codex",
       codex_version: "0.153.3",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -36139,6 +36139,8 @@ var init_runner = __esm({
         let providerDispatchWatchdogDrainRequested = false;
         const agentAbort = new AbortController();
         let agentLoop = Promise.resolve();
+        let modelCatalogRefresh = null;
+        let providerRateLimitRefresh = null;
         let wakeDrain;
         const drainSignal = new Promise((resolve10) => {
           wakeDrain = resolve10;
@@ -36561,6 +36563,7 @@ var init_runner = __esm({
             }
           };
           let advertisementHandoff = null;
+          const claimPreparation = { unsent: null };
           const publishAdvertisement = async (health, forceAdvance, retryRemote = true, allowDefinitiveReseed = true) => {
             let advertisement = receipt.pending_advertisement;
             if (!advertisement) {
@@ -36778,6 +36781,45 @@ var init_runner = __esm({
             return gapMs;
           };
           let nextAdvertisementAttemptAt = 0;
+          let renewalYieldedToClaim = false;
+          let catalogRefreshGeneration = null;
+          const refreshModelCatalog = () => {
+            if (modelCatalogRefresh || !this.dependencies.codexAdapter.readModelCapabilities || receipt.pending_advertisement || catalogRefreshGeneration === receipt.advertisement_generation) return;
+            catalogRefreshGeneration = receipt.advertisement_generation;
+            modelCatalogRefresh = (async () => {
+              try {
+                const capabilities = await this.dependencies.codexAdapter.readModelCapabilities(
+                  Date.now() + Math.max(1, Math.floor(settings.advertisementRefreshLeadMs / 2)),
+                  agentAbort.signal
+                );
+                if (agentAbort.signal.aborted) return;
+                const refreshedModels = buildInferenceAdvertisedModels(
+                  capabilities,
+                  this.options.adapterRuntimeVersion,
+                  settings.adapterId,
+                  this.options.structuredOutput ?? settings.adapterId === "codex",
+                  settings.sameAttemptRecovery,
+                  settings.agentRuntime ? ["provider", "agent"] : ["provider"]
+                );
+                const changed = !exactJson2(settings.advertisedModels, refreshedModels);
+                settings.advertisedModels = refreshedModels;
+                emitDiagnostic("model_catalog_refreshed", {
+                  model_count: refreshedModels.length,
+                  changed,
+                  active_attempts: active.size
+                });
+              } catch (error48) {
+                if (agentAbort.signal.aborted) return;
+                emitDiagnostic("model_catalog_refresh_failed", {
+                  failure_category: error48 instanceof CodexAppServerError ? error48.category : "adapter",
+                  failure_code: error48 instanceof CodexAppServerError ? error48.code : "model_catalog_refresh_failed",
+                  retained_model_count: settings.advertisedModels.length
+                });
+              } finally {
+                modelCatalogRefresh = null;
+              }
+            })();
+          };
           let nextProviderRateLimitRefreshAt = now() + settings.providerRateLimitRefreshMs;
           let nextClaimAt = now();
           let pendingClaimPromotions = 0;
@@ -36819,6 +36861,7 @@ var init_runner = __esm({
               schema_version: "external_inference_job_claim_v1",
               ...claimRequestBase
             };
+            claimPreparation.unsent = pendingClaimRequest;
             return {
               ...current,
               claim_sequence: claimSequence,
@@ -37230,103 +37273,88 @@ var init_runner = __esm({
               providerCooldownReason = null;
               providerQuotaSnapshot = null;
             }
-            if (this.dependencies.codexAdapter.readAccountRateLimits && currentTime >= nextProviderRateLimitRefreshAt) {
-              try {
-                const refreshVersion = providerCooldownVersion;
-                const refreshStartedAt = now();
-                const refreshedRateLimits = await this.dependencies.codexAdapter.readAccountRateLimits(
-                  Date.now() + Math.min(2e3, settings.hostHeartbeatMs),
-                  this.options.signal
-                );
-                if (refreshVersion !== providerCooldownVersion) continue;
-                providerRateLimits = refreshedRateLimits;
-                providerRateLimitsObservedAtMs = now();
-                const refreshedAt = now();
-                const usableSnapshot = usableProviderQuotaSnapshot(
-                  providerRateLimits,
-                  knownProviderQuotaSnapshot,
-                  refreshedAt
-                );
-                providerQuotaRecoveryObservedAtMs = usableSnapshot ? refreshStartedAt : null;
-                retainKnownQuotaWindows(providerRateLimits.rateLimits);
-                const refreshedRetryAt = codexAccountRateLimitReached(providerRateLimits) ? codexRateLimitRetryAtMs(providerRateLimits) ?? refreshedAt + DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS : null;
-                if (refreshedRetryAt !== null && refreshedRetryAt > refreshedAt) {
-                  providerRetryAtMs = Math.max(providerRetryAtMs ?? 0, refreshedRetryAt);
-                  providerCooldownReason = "provider_limit_snapshot";
-                  retainQuotaSnapshot(providerRateLimits);
-                } else if (providerRetryAtMs !== null && !codexAccountRateLimitReached(providerRateLimits) && providerRateLimits.rateLimits.limitId === providerQuotaSnapshot?.limitId && [providerRateLimits.rateLimits.primary, providerRateLimits.rateLimits.secondary].some((window2) => window2 !== null) && ["primary", "secondary"].every((key) => {
-                  const window2 = refreshedRateLimits.rateLimits[key];
-                  const previous = providerQuotaSnapshot?.[key];
-                  if (previous && (!window2 || window2.windowDurationMins !== previous.windowDurationMins)) {
-                    return false;
+            if (this.dependencies.codexAdapter.readAccountRateLimits && currentTime >= nextProviderRateLimitRefreshAt && !providerRateLimitRefresh) {
+              nextProviderRateLimitRefreshAt = Infinity;
+              providerRateLimitRefresh = Promise.resolve().then(async () => {
+                try {
+                  const refreshVersion = providerCooldownVersion;
+                  const refreshStartedAt = now();
+                  const refreshedRateLimits = await this.dependencies.codexAdapter.readAccountRateLimits(
+                    Date.now() + Math.min(2e3, settings.hostHeartbeatMs),
+                    agentAbort.signal
+                  );
+                  if (agentAbort.signal.aborted || refreshVersion !== providerCooldownVersion) return;
+                  providerRateLimits = refreshedRateLimits;
+                  providerRateLimitsObservedAtMs = now();
+                  const refreshedAt = now();
+                  const usableSnapshot = usableProviderQuotaSnapshot(
+                    providerRateLimits,
+                    knownProviderQuotaSnapshot,
+                    refreshedAt
+                  );
+                  providerQuotaRecoveryObservedAtMs = usableSnapshot ? refreshStartedAt : null;
+                  retainKnownQuotaWindows(providerRateLimits.rateLimits);
+                  const refreshedRetryAt = codexAccountRateLimitReached(providerRateLimits) ? codexRateLimitRetryAtMs(providerRateLimits) ?? refreshedAt + DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS : null;
+                  if (refreshedRetryAt !== null && refreshedRetryAt > refreshedAt) {
+                    providerRetryAtMs = Math.max(providerRetryAtMs ?? 0, refreshedRetryAt);
+                    providerCooldownReason = "provider_limit_snapshot";
+                    retainQuotaSnapshot(providerRateLimits);
+                  } else if (providerRetryAtMs !== null && !codexAccountRateLimitReached(providerRateLimits) && providerRateLimits.rateLimits.limitId === providerQuotaSnapshot?.limitId && [providerRateLimits.rateLimits.primary, providerRateLimits.rateLimits.secondary].some((window2) => window2 !== null) && ["primary", "secondary"].every((key) => {
+                    const window2 = refreshedRateLimits.rateLimits[key];
+                    const previous = providerQuotaSnapshot?.[key];
+                    if (previous && (!window2 || window2.windowDurationMins !== previous.windowDurationMins)) {
+                      return false;
+                    }
+                    return window2 === null || window2.resetsAt !== null && window2.resetsAt * 1e3 > refreshedAt && window2.usedPercent < 100;
+                  })) {
+                    emitDiagnostic("provider_cooldown_cleared", {
+                      reason: providerCooldownReason,
+                      recovery: "provider_quota_restored",
+                      active_attempts: active.size,
+                      provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
+                        providerRateLimits,
+                        providerRateLimitsObservedAtMs,
+                        refreshedAt
+                      )
+                    });
+                    providerRetryAtMs = null;
+                    providerCooldownReason = null;
+                    providerQuotaSnapshot = null;
                   }
-                  return window2 === null || window2.resetsAt !== null && window2.resetsAt * 1e3 > refreshedAt && window2.usedPercent < 100;
-                })) {
-                  emitDiagnostic("provider_cooldown_cleared", {
-                    reason: providerCooldownReason,
-                    recovery: "provider_quota_restored",
-                    active_attempts: active.size,
+                  emitDiagnostic("provider_rate_limits_refreshed", {
                     provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
                       providerRateLimits,
                       providerRateLimitsObservedAtMs,
-                      refreshedAt
-                    )
+                      now()
+                    ),
+                    active_attempts: active.size
                   });
-                  providerRetryAtMs = null;
-                  providerCooldownReason = null;
-                  providerQuotaSnapshot = null;
+                } catch (error48) {
+                  emitDiagnostic("provider_rate_limits_refresh_failed", {
+                    failure_category: error48 instanceof CodexAppServerError ? error48.category : "adapter",
+                    failure_code: error48 instanceof CodexAppServerError ? error48.code : "provider_rate_limits_refresh_failed"
+                  });
+                } finally {
+                  nextProviderRateLimitRefreshAt = now() + settings.providerRateLimitRefreshMs;
+                  providerRateLimitRefresh = null;
                 }
-                emitDiagnostic("provider_rate_limits_refreshed", {
-                  provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
-                    providerRateLimits,
-                    providerRateLimitsObservedAtMs,
-                    now()
-                  ),
-                  active_attempts: active.size
-                });
-              } catch (error48) {
-                emitDiagnostic("provider_rate_limits_refresh_failed", {
-                  failure_category: error48 instanceof CodexAppServerError ? error48.category : "adapter",
-                  failure_code: error48 instanceof CodexAppServerError ? error48.code : "provider_rate_limits_refresh_failed"
-                });
-              } finally {
-                nextProviderRateLimitRefreshAt = now() + settings.providerRateLimitRefreshMs;
-              }
+              });
             }
             const expiresAt = receipt.advertisement_expires_at ? Date.parse(receipt.advertisement_expires_at) : 0;
-            if (currentTime >= nextAdvertisementAttemptAt && expiresAt - currentTime <= settings.advertisementRefreshLeadMs) {
+            const renewalDue = currentTime >= nextAdvertisementAttemptAt && expiresAt - currentTime <= settings.advertisementRefreshLeadMs;
+            if (renewalDue) refreshModelCatalog();
+            const yieldRenewalToClaim = renewalDue && !renewalYieldedToClaim && !receipt.pending_advertisement && expiresAt > now() && 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 (yieldRenewalToClaim) renewalYieldedToClaim = true;
+            if (renewalDue && !yieldRenewalToClaim) {
               try {
-                if (!receipt.pending_advertisement && this.dependencies.codexAdapter.readModelCapabilities) {
-                  try {
-                    const capabilities = await this.dependencies.codexAdapter.readModelCapabilities(
-                      Date.now() + Math.max(1, Math.floor(settings.advertisementRefreshLeadMs / 2)),
-                      this.options.signal
-                    );
-                    const refreshedModels = buildInferenceAdvertisedModels(
-                      capabilities,
-                      this.options.adapterRuntimeVersion,
-                      settings.adapterId,
-                      this.options.structuredOutput ?? settings.adapterId === "codex",
-                      settings.sameAttemptRecovery,
-                      settings.agentRuntime ? ["provider", "agent"] : ["provider"]
-                    );
-                    const changed = !exactJson2(settings.advertisedModels, refreshedModels);
-                    settings.advertisedModels = refreshedModels;
-                    emitDiagnostic("model_catalog_refreshed", {
-                      model_count: refreshedModels.length,
-                      changed,
-                      active_attempts: active.size
-                    });
-                  } catch (error48) {
-                    emitDiagnostic("model_catalog_refresh_failed", {
-                      failure_category: error48 instanceof CodexAppServerError ? error48.category : "adapter",
-                      failure_code: error48 instanceof CodexAppServerError ? error48.code : "model_catalog_refresh_failed",
-                      retained_model_count: settings.advertisedModels.length
-                    });
-                  }
-                }
                 await publishAdvertisement("healthy", true, false);
                 nextAdvertisementAttemptAt = 0;
+                renewalYieldedToClaim = false;
               } catch (error48) {
                 if (controlPlaneFatal(error48)) {
                   requestDrain("authority_lost");
@@ -37344,23 +37372,38 @@ 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(
+            let claimOpportunities = 0;
+            while (!drainRequested && (!yieldRenewalToClaim || claimOpportunities === 0) && 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 === claimPreparation.unsent && claimPreparation.unsent !== null && claimPreparation.unsent.advertisement_generation !== receipt.advertisement_generation) {
+                await mutateReceipt((current) => preparePendingClaim({
+                  ...current,
+                  pending_claim_request: null
+                }));
+              }
+              const knownUnsent = receipt.pending_claim_request === null || receipt.pending_claim_request === claimPreparation.unsent;
+              if (knownUnsent && Date.parse(receipt.advertisement_expires_at ?? "") <= now()) break;
               if (!receipt.pending_claim_request) {
                 await mutateReceipt(preparePendingClaim);
               }
               const request = receipt.pending_claim_request;
+              if (request === claimPreparation.unsent && Date.parse(receipt.advertisement_expires_at ?? "") <= now()) break;
               let claim;
               const claimCallStartedAtMs = now();
               try {
+                claimOpportunities += 1;
+                if (claimPreparation.unsent === request) claimPreparation.unsent = null;
                 claim = await mcp.callTool(
                   "inference.job.claim",
                   request,
-                  { signal: this.options.signal }
+                  {
+                    signal: this.options.signal,
+                    ...yieldRenewalToClaim ? { deadlineAtMs: expiresAt } : {}
+                  }
                 );
                 assertClaimResult(request, claim);
               } catch (error48) {
@@ -37459,6 +37502,14 @@ var init_runner = __esm({
                   0,
                   claimCallRoundTripMs - (claim.schema_version === "external_inference_job_claim_result_v3" ? claim.server_processing_ms : 0)
                 );
+                emitDiagnostic("claim_batch_received", {
+                  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,
+                  transport_residual_ms: claimTransportResidualMs,
+                  minimum_freshness_remaining_ms: claim.claims.length ? Math.min(...claim.claims.map((item) => item.provider_dispatch_freshness_remaining_ms)) : null,
+                  active_attempts: active.size
+                });
                 if (claim.claims.length === 0) {
                   await mutateReceipt((current) => ({
                     ...current,
@@ -37585,6 +37636,7 @@ var init_runner = __esm({
               now() + settings.hostHeartbeatMs,
               Math.max(now() + MIN_SLEEP_MS, advertisementDueAt)
             );
+            if (yieldRenewalToClaim) continue;
             await Promise.race([
               sleep4(Math.max(MIN_SLEEP_MS, wakeAt - now())),
               drainSignal,
@@ -37634,6 +37686,8 @@ var init_runner = __esm({
           agentAbort.abort();
           const agentCleanup = Promise.allSettled([
             agentLoop,
+            modelCatalogRefresh,
+            providerRateLimitRefresh,
             Promise.resolve().then(async () => {
               await settings.agentRuntime?.adapter.close();
             })
@@ -48099,6 +48153,7 @@ async function postClientRuntime(path, profileId, body, options) {
   let lastNetworkError = null;
   let missingRuntimeLeaseRecoveryAttempted = false;
   let replacementLeaseRetryUsed = false;
+  let lastRequestId = null;
   const deadlineError = (attempt, cause) => annotateRuntimeRequestError(
     Object.assign(
       new Error("Client runtime decision persistence deadline exceeded after the AI run completed."),
@@ -48113,7 +48168,8 @@ async function postClientRuntime(path, profileId, body, options) {
       keepalive,
       hadRuntimeLeaseToken: Boolean(resolvedRuntimeLeaseToken),
       deadlineAtMs,
-      deadlineExceeded: true
+      deadlineExceeded: true,
+      requestId: lastRequestId
     }
   );
   const waitBeforeRetry = async (delayMs, attempt, cause) => {
@@ -48152,12 +48208,13 @@ async function postClientRuntime(path, profileId, body, options) {
       }, Math.max(1, attemptTimeoutMs));
       requestSignal = timeoutController.signal;
     }
+    lastRequestId = path === "/runtime/decision" ? createIdempotencyKey("runtime-request") : null;
     const trace = startRuntimeNetworkDebugTrace({
       kind: "runtime",
       label: "client_runtime_api",
       method: "POST",
       url: requestUrl,
-      note: `path=${path} attempt=${attempt}/${maxAttempts}`
+      note: `path=${path} attempt=${attempt}/${maxAttempts}${lastRequestId ? ` reconcile_only=${options?.reconcileOnly === true} request_id=${lastRequestId}` : ""}`
     });
     try {
       response = await fetch(requestUrl, {
@@ -48165,7 +48222,10 @@ async function postClientRuntime(path, profileId, body, options) {
         credentials: "include",
         keepalive,
         signal: requestSignal,
-        headers: { ...requestHeaders },
+        headers: {
+          ...requestHeaders,
+          ...lastRequestId ? { "X-Request-ID": lastRequestId } : {}
+        },
         body
       });
       if (!response.ok) {
@@ -48246,7 +48306,8 @@ async function postClientRuntime(path, profileId, body, options) {
           status: response?.status ?? null,
           keepalive,
           hadRuntimeLeaseToken: Boolean(resolvedRuntimeLeaseToken),
-          deadlineAtMs
+          deadlineAtMs,
+          requestId: lastRequestId
         });
       }
       await waitBeforeRetry(
@@ -48687,6 +48748,7 @@ var init_api2 = __esm({
       target.runtimeRequestTransientNetwork = isTransientNetworkFetchError(error48);
       target.runtimeRequestKeepalive = metadata.keepalive;
       target.runtimeRequestHadLeaseToken = metadata.hadRuntimeLeaseToken;
+      if (metadata.requestId !== void 0) target.runtimeRequestId = metadata.requestId;
       if (metadata.deadlineAtMs !== void 0) {
         target.runtimeRequestDeadlineAtMs = metadata.deadlineAtMs;
       }

package/package.json

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