@vtxmacro/cli 2026.9.20 → 2026.9.22

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.20",
+  package_version: "2026.9.22",
   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.20",
+      package_version: "2026.9.22",
       codex_package_name: "@openai/codex",
       codex_version: "0.153.3",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -17958,13 +17958,27 @@ async function acquireInferenceHostProcessLock(path, dependencies = {}) {
     }
   };
 }
-var loadInferenceAgentDataRequestTimeoutMs, INFERENCE_CREDENTIAL_NAMESPACE, MAX_INFERENCE_PRIVATE_FILE_BYTES, WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS, WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS, SMALL_IDENTITY_COMMAND_TIMEOUT_MS, windowsPowerShellEnvironment, windowsPrivateAclBrokerInvocation, WindowsPrivateAclBroker, defaultWindowsPrivateAclBroker, runWindowsPrivateAcl, windowsAclCache, windowsAclIdentity, aclCacheKey, secureWindowsPrivatePath, invalidateWindowsAclCache, rebindHardenedWindowsAclAfterRename, rebindHardenedWindowsDirectoryAfterOwnedMutation, isDefaultWindowsPrivatePath, secureExistingWindowsPath, linuxProcessIdentity, windowsProcessIdentityInvocation, windowsBootIdentityInvocation, windowsProcessIdentity, darwinProcessIdentity, runSmallIdentityCommand, cachedSystemBootIdentity, readInferenceSystemBootIdentity, defaultProcessIdentity, defaultCurrentProcessIdentity, processLockObservationCache, inferenceProcessIdentitiesMatch, DEFAULT_INFERENCE_HOST_INSTANCE, SAFE_INFERENCE_HOST_INSTANCE, requireNamedInstancePath, credentialStoreIdentity, inferenceHostCredentialContextPath, inferenceHostCredentialContextTransitionPath, credentialContextForConfig, WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES;
+var loadInferenceReceiptDurabilityTimeoutMs, loadInferenceAgentDataRequestTimeoutMs, INFERENCE_CREDENTIAL_NAMESPACE, MAX_INFERENCE_PRIVATE_FILE_BYTES, WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS, WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS, SMALL_IDENTITY_COMMAND_TIMEOUT_MS, windowsPowerShellEnvironment, windowsPrivateAclBrokerInvocation, WindowsPrivateAclBroker, defaultWindowsPrivateAclBroker, runWindowsPrivateAcl, windowsAclCache, windowsAclIdentity, aclCacheKey, secureWindowsPrivatePath, invalidateWindowsAclCache, rebindHardenedWindowsAclAfterRename, rebindHardenedWindowsDirectoryAfterOwnedMutation, isDefaultWindowsPrivatePath, secureExistingWindowsPath, linuxProcessIdentity, windowsProcessIdentityInvocation, windowsBootIdentityInvocation, windowsProcessIdentity, darwinProcessIdentity, runSmallIdentityCommand, cachedSystemBootIdentity, readInferenceSystemBootIdentity, defaultProcessIdentity, defaultCurrentProcessIdentity, processLockObservationCache, inferenceProcessIdentitiesMatch, DEFAULT_INFERENCE_HOST_INSTANCE, SAFE_INFERENCE_HOST_INSTANCE, requireNamedInstancePath, credentialStoreIdentity, inferenceHostCredentialContextPath, inferenceHostCredentialContextTransitionPath, credentialContextForConfig, WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES;
 var init_config = __esm({
   "lib/inference-host/config.ts"() {
     "use strict";
     init_define_VTX_EXO_POLICY();
     init_define_VTX_PI_MODEL_POLICY();
     init_dist();
+    loadInferenceReceiptDurabilityTimeoutMs = async () => {
+      let configured;
+      if (true) {
+        configured = 5e3;
+      } else {
+        const config2 = parse4(await readFile(resolve(dirname(fileURLToPath(import.meta.url)), "../../../config.toml"), "utf8"));
+        const inference = config2.external_inference;
+        configured = Number(inference?.receipt_durability_timeout_seconds) * 1e3;
+      }
+      if (!Number.isSafeInteger(configured) || Number(configured) < 1) {
+        throw new Error("Inference receipt durability timeout is missing or invalid.");
+      }
+      return Number(configured);
+    };
     loadInferenceAgentDataRequestTimeoutMs = async () => {
       let configured;
       if (true) {
@@ -35774,6 +35788,11 @@ var init_runner = __esm({
           DEFAULT_ATTEMPT_HEARTBEAT_MS,
           "Attempt heartbeat interval"
         ),
+        receiptDurabilityTimeoutMs: finitePositiveOption(
+          options.receiptDurabilityTimeoutMs,
+          options.receiptDurabilityTimeoutMs,
+          "Receipt durability timeout"
+        ),
         drainTimeoutMs: finitePositiveOption(
           options.drainTimeoutMs,
           DEFAULT_DRAIN_TIMEOUT_MS,
@@ -36093,7 +36112,10 @@ var init_runner = __esm({
         this.options = options;
       }
       async run() {
-        const settings = validateRunnerOptions(this.options);
+        const settings = validateRunnerOptions({
+          ...this.options,
+          receiptDurabilityTimeoutMs: this.options.receiptDurabilityTimeoutMs ?? await loadInferenceReceiptDurabilityTimeoutMs()
+        });
         const now = this.dependencies.now ?? Date.now;
         const sleep4 = this.dependencies.sleep ?? defaultSleep;
         const lock2 = await this.dependencies.acquireProcessLock();
@@ -36117,6 +36139,7 @@ var init_runner = __esm({
         let providerDispatchWatchdogDrainRequested = false;
         const agentAbort = new AbortController();
         let agentLoop = Promise.resolve();
+        let modelCatalogRefresh = null;
         let wakeDrain;
         const drainSignal = new Promise((resolve10) => {
           wakeDrain = resolve10;
@@ -36539,6 +36562,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) {
@@ -36756,6 +36780,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;
@@ -36797,6 +36860,7 @@ var init_runner = __esm({
               schema_version: "external_inference_job_claim_v1",
               ...claimRequestBase
             };
+            claimPreparation.unsent = pendingClaimRequest;
             return {
               ...current,
               claim_sequence: claimSequence,
@@ -36965,6 +37029,7 @@ var init_runner = __esm({
               retryExact,
               signal: controller.signal,
               attemptHeartbeatMs: settings.attemptHeartbeatMs,
+              receiptDurabilityTimeoutMs: settings.receiptDurabilityTimeoutMs,
               sleep: sleep4,
               now,
               onProviderCooldown: ({ retryAtMs, reason, rateLimits }) => {
@@ -37032,9 +37097,9 @@ var init_runner = __esm({
                   active_attempts: active.size
                 });
               },
-              onProviderDispatchRecoveryRequired: () => {
+              onProviderDispatchRecoveryRequired: (reason = "provider_dispatch_watchdog_expired") => {
                 providerDispatchWatchdogDrainRequested = true;
-                requestDrain("provider_dispatch_watchdog_expired");
+                requestDrain(reason);
               },
               startRetryCount: nextStartRetryCount,
               onAttemptStartRetry: (observation) => {
@@ -37271,39 +37336,20 @@ var init_runner = __esm({
               }
             }
             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");
@@ -37321,23 +37367,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) {
@@ -37562,6 +37623,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,
@@ -37611,6 +37673,7 @@ var init_runner = __esm({
           agentAbort.abort();
           const agentCleanup = Promise.allSettled([
             agentLoop,
+            modelCatalogRefresh,
             Promise.resolve().then(async () => {
               await settings.agentRuntime?.adapter.close();
             })
@@ -37738,14 +37801,35 @@ var init_runner = __esm({
             attemptAbort.abort();
           }, Math.max(MIN_SLEEP_MS, deadlineAtMs - now()));
         };
-        const awaitPreProviderDurability = async (operation) => Promise.race([
-          operation,
-          providerDispatchWatchdogSignal.then(() => {
-            throw new InferenceHostRecoveryRequiredError(
-              "Provider dispatch stopped because its durable receipt missed the freshness deadline."
-            );
-          })
-        ]);
+        let receiptDurabilityUnhealthy = false;
+        const awaitPreProviderDurability = async (operation) => {
+          let timer;
+          try {
+            return await Promise.race([
+              operation,
+              new Promise((_resolve, reject) => {
+                timer = setTimeout(() => {
+                  receiptDurabilityUnhealthy = true;
+                  options.onProviderDispatchRecoveryRequired?.("receipt_durability_timeout");
+                  reject(new InferenceHostRecoveryRequiredError(
+                    "Provider dispatch stopped because durable receipt storage did not settle."
+                  ));
+                }, options.receiptDurabilityTimeoutMs);
+              })
+            ]);
+          } finally {
+            if (timer !== void 0) clearTimeout(timer);
+          }
+        };
+        const requireDispatchFreshness = () => {
+          if (providerDispatchNotAfterMs === void 0 || !providerDispatchWatchdogExpired && now() < providerDispatchNotAfterMs) return;
+          providerDispatchWatchdogExpired = true;
+          attemptAbort.abort();
+          throw new InferenceHostRunnerError(
+            "server_account_context_expired_before_provider_dispatch",
+            "The Server account context expired before provider dispatch."
+          );
+        };
         const persistAttempt = async (changes, clearPendingClaim = false) => {
           const nextAttemptReceipt = validateAttemptReceipt({
             ...attemptReceipt,
@@ -37865,12 +37949,21 @@ var init_runner = __esm({
             membership_disposition: membershipFailureDisposition(failure2),
             failed_at: isoAt(now())
           });
-          void persistAttempt({
+          const terminalDurability = persistAttempt({
             phase: "terminal_pending",
             dispatch_outcome: "not_dispatched",
             terminal_operation_id: failureId,
             terminal_request: failureRequest
-          }).catch(() => void 0);
+          });
+          if (receiptDurabilityUnhealthy) {
+            void terminalDurability.catch(() => void 0);
+          } else {
+            try {
+              await awaitPreProviderDurability(terminalDurability);
+            } catch (error48) {
+              if (!receiptDurabilityUnhealthy) throw error48;
+            }
+          }
           const evidenceDeadlineAtMs = Date.parse(jobInput.evidence_expires_at);
           const failureResult = await retryExact(() => mcp.callTool(
             "inference.job.fail",
@@ -37878,6 +37971,9 @@ var init_runner = __esm({
             { signal, deadlineAtMs: evidenceDeadlineAtMs }
           ), { signal, deadlineAtMs: evidenceDeadlineAtMs });
           assertTerminalResult(failureRequest, failureResult);
+          if (!receiptDurabilityUnhealthy) {
+            await awaitPreProviderDurability(removeAttempt());
+          }
           options.onAttemptOutcome?.({
             outcome: "failed",
             failure_category: failureRequest.failure_category,
@@ -38018,6 +38114,7 @@ var init_runner = __esm({
             }
           }
           if (attemptReceipt.phase !== "dispatched") {
+            requireDispatchFreshness();
             const providerDispatchable = inputValidationError === void 0 && outputContract !== null;
             reportPreProviderStage("receipt_persistence");
             await awaitPreProviderDurability(
@@ -38030,12 +38127,12 @@ var init_runner = __esm({
               ])
             );
           }
+          if (options.resumeReceipt?.phase !== "dispatched") requireDispatchFreshness();
           reportPreProviderStage("thread_setup");
         } catch (error48) {
           clearProviderDispatchWatchdog();
           signal.removeEventListener("abort", relayAbort);
           if (providerDispatchWatchdogExpired) {
-            options.onProviderDispatchRecoveryRequired?.();
             return terminalizeProviderDispatchWatchdog();
           }
           throw error48;
@@ -41458,6 +41555,7 @@ Durable service:
         protocolVersion: EXTERNAL_INFERENCE_CONTRACT_VERSION,
         adapterRuntimeVersion: INFERENCE_HOST_CLI_VERSION,
         hostRuntimeVersion: INFERENCE_HOST_CLI_VERSION,
+        receiptDurabilityTimeoutMs: await loadInferenceReceiptDurabilityTimeoutMs(),
         maxConcurrency: options.maxConcurrency,
         once: options.once,
         emitDiagnosticEvent: options.emitDiagnosticEvent,
@@ -41528,6 +41626,7 @@ Durable service:
         protocolVersion: EXTERNAL_INFERENCE_CONTRACT_VERSION,
         adapterRuntimeVersion: options.preflight.runtimeVersion,
         hostRuntimeVersion: INFERENCE_HOST_CLI_VERSION,
+        receiptDurabilityTimeoutMs: await loadInferenceReceiptDurabilityTimeoutMs(),
         maxConcurrency: options.maxConcurrency,
         once: options.once,
         emitDiagnosticEvent: options.emitDiagnosticEvent,
@@ -48034,9 +48133,13 @@ async function postClientRuntime(path, profileId, body, options) {
   if (idempotencyKey) {
     requestHeaders["X-Idempotency-Key"] = idempotencyKey;
   }
+  if (options?.reconcileOnly === true) {
+    requestHeaders["X-Runtime-Reconcile-Only"] = "true";
+  }
   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."),
@@ -48051,7 +48154,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) => {
@@ -48090,12 +48194,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, {
@@ -48103,7 +48208,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) {
@@ -48184,7 +48292,8 @@ async function postClientRuntime(path, profileId, body, options) {
           status: response?.status ?? null,
           keepalive,
           hadRuntimeLeaseToken: Boolean(resolvedRuntimeLeaseToken),
-          deadlineAtMs
+          deadlineAtMs,
+          requestId: lastRequestId
         });
       }
       await waitBeforeRetry(
@@ -48625,6 +48734,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;
       }
@@ -48799,7 +48909,7 @@ var init_api2 = __esm({
       return true;
     };
     isRuntimeIdempotencyInProgressError = (status, message) => status === 409 && (message.toLowerCase().includes("duplicate request already in progress") || message.toLowerCase().includes("duplicate request in-flight"));
-    isRetryableRuntimeConflictError = (status, error48) => status === 409 && error48.retryable === true && (error48.code === "profile_runtime_contract_busy" || error48.code === "runtime_decision_finalizing" || error48.code === "runtime_trade_sync_finalizing");
+    isRetryableRuntimeConflictError = (status, error48) => status === 409 && error48.retryable === true && (error48.code === "profile_runtime_contract_busy" || error48.code === "runtime_decision_finalizing" || error48.code === "runtime_trade_sync_finalizing" || error48.code === "runtime_decision_unconfirmed");
     resolveClientRuntimeRetryDelayMs = (attempt, retryAfterHeader) => {
       const retryAfterMs = parseRuntimeRetryAfterMs(retryAfterHeader);
       if (retryAfterMs != null) {

package/package.json

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