@vtxmacro/cli 2026.8.16 → 2026.8.18

package/README.md

@@ -127,7 +127,7 @@ object to `vtx inference-host agent-fail --json`.
 Keep `agent-run` open in a separate terminal and keep calling `agent-next`
 while the host should remain available. The independent keeper preserves
 truthful liveness while the harness reasons. This same loop
-supports Main, Review, and Screener; Provider response and Decision candidate;
+supports Main, Review, and Screener; Provider and Decision;
 and normally running VTX Client Mode or Server Mode bots. Server Mode keeps the
 normal VTX call fee. Client Mode has no VTX platform fee. Neither mode falls back
 to another model when the agent host is unavailable.

package/bin/vtx.js

@@ -38,7 +38,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.8.16",
+      package_version: "2026.8.18",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       platforms: {
@@ -17303,7 +17303,7 @@ 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 === "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);
         return;
       }
       if (name === "inference.job.start") {
@@ -17403,11 +17403,24 @@ var init_mcp_client = __esm({
         }).passthrough().parse(rawResult);
         if (callResult.isError === true) {
           const errorText = (callResult.content ?? []).filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n");
-          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."));
+          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"));
+          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"));
+          const retryableHeartbeatClockSkew = name === "inference.host.heartbeat" && definitivelyNotApplied;
+          const retryableAdvertisementClockSkew = (name === "inference.host.register" || name === "inference.host.advertise") && definitivelyNotApplied;
           throw new ExternalInferenceMcpError(
             "tool_rejected",
             `Insights MCP rejected ${name}.`,
-            { definitivelyNotApplied }
+            {
+              definitivelyNotApplied,
+              // Claim polling is an idempotent control-plane operation. During an
+              // API rotation the MCP server can return a tool error after the
+              // request reached the application boundary, so retain and replay
+              // the exact request unless the server proves it was not applied.
+              retryable: retryableInfrastructureRejection || retryableClaimRejection || retryableHeartbeatClockSkew || retryableAdvertisementClockSkew
+            }
           );
         }
         const structured = inlineStructuredContentSchema.parse(callResult.structuredContent);
@@ -17515,11 +17528,13 @@ var init_mcp_client = __esm({
           const remoteError = external_exports.object({ code: external_exports.number().int() }).passthrough().safeParse(
             document2.error
           );
+          const remoteCode = remoteError.success ? remoteError.data.code : null;
           throw new ExternalInferenceMcpError(
             "remote_error",
             "Insights MCP rejected the JSON-RPC request.",
             {
-              definitivelyNotApplied: remoteError.success && [-32700, -32600, -32601, -32602].includes(remoteError.data.code)
+              definitivelyNotApplied: remoteCode !== null && [-32700, -32600, -32601, -32602].includes(remoteCode),
+              retryable: remoteCode === -32603 || remoteCode !== null && remoteCode >= -32099 && remoteCode <= -32e3
             }
           );
         }
@@ -27700,7 +27715,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_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, DEFAULT_MAX_CONCURRENCY, MIN_SLEEP_MS, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, CODEX_INFERENCE_ADVERTISED_MODEL, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, safeFailureCode, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner;
+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_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, DEFAULT_MAX_CONCURRENCY, MIN_SLEEP_MS, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, CODEX_INFERENCE_ADVERTISED_MODEL, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, safeFailureCode, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner;
 var init_runner = __esm({
   "lib/inference-host/runner.ts"() {
     "use strict";
@@ -27724,6 +27739,7 @@ var init_runner = __esm({
     DEFAULT_MAX_CONCURRENCY = 1;
     MIN_SLEEP_MS = 10;
     DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS = 5 * 60 * 1e3;
+    MIN_CLAIM_START_WINDOW_MS = 5e3;
     CODEX_INFERENCE_ADVERTISED_MODEL = Object.freeze({
       model_id: INITIAL_CODEX_INFERENCE_MODEL,
       label: "Codex GPT-5.6 Sol",
@@ -27877,7 +27893,7 @@ var init_runner = __esm({
         throw new Error("Inference host runtime receipt is invalid.");
       }
       const record2 = value;
-      if (!exactObjectKeys(record2, [
+      const legacyKeys = [
         "schema_version",
         "host_id",
         "host_generation",
@@ -27890,10 +27906,16 @@ var init_runner = __esm({
         "claim_sequence",
         "attempts",
         "updated_at"
-      ]) || record2.schema_version !== RUNTIME_RECEIPT_SCHEMA_VERSION || typeof record2.host_id !== "string" || !record2.host_id || !safeInteger(record2.host_generation, 1) || !safeInteger(record2.key_generation, 1) || !safeInteger(record2.advertisement_generation, 1) || record2.advertisement_expires_at !== null && !validIso(record2.advertisement_expires_at) || typeof record2.registered !== "boolean" || !safeInteger(record2.host_heartbeat_sequence, 0) || !safeInteger(record2.claim_sequence, 0) || !record2.attempts || typeof record2.attempts !== "object" || Array.isArray(record2.attempts) || !validIso(record2.updated_at)) {
+      ];
+      const currentKeys = [...legacyKeys, "pending_claim_request"];
+      if (!(exactObjectKeys(record2, legacyKeys) || exactObjectKeys(record2, currentKeys)) || record2.schema_version !== RUNTIME_RECEIPT_SCHEMA_VERSION || typeof record2.host_id !== "string" || !record2.host_id || !safeInteger(record2.host_generation, 1) || !safeInteger(record2.key_generation, 1) || !safeInteger(record2.advertisement_generation, 1) || record2.advertisement_expires_at !== null && !validIso(record2.advertisement_expires_at) || typeof record2.registered !== "boolean" || !safeInteger(record2.host_heartbeat_sequence, 0) || !safeInteger(record2.claim_sequence, 0) || !record2.attempts || typeof record2.attempts !== "object" || Array.isArray(record2.attempts) || !validIso(record2.updated_at)) {
         throw new Error("Inference host runtime receipt is invalid.");
       }
       const pendingAdvertisement = record2.pending_advertisement === null ? null : hostAdvertisementSchema.parse(record2.pending_advertisement);
+      const pendingClaimRequest = record2.pending_claim_request == null ? null : jobClaimRequestSchema.parse(record2.pending_claim_request);
+      if (pendingClaimRequest && (pendingClaimRequest.host_id !== record2.host_id || pendingClaimRequest.host_generation !== record2.host_generation || pendingClaimRequest.key_generation !== record2.key_generation || pendingClaimRequest.advertisement_generation > Number(record2.advertisement_generation))) {
+        throw new Error("Inference host pending claim receipt is invalid.");
+      }
       const attempts = Object.fromEntries(
         Object.entries(record2.attempts).map(([key, attempt]) => {
           const validated = validateAttemptReceipt(attempt);
@@ -27906,6 +27928,7 @@ var init_runner = __esm({
       return {
         ...record2,
         pending_advertisement: pendingAdvertisement,
+        pending_claim_request: pendingClaimRequest,
         attempts
       };
     };
@@ -28154,7 +28177,7 @@ var init_runner = __esm({
       if (result2.claim_request_id !== request.claim_request_id) {
         runnerIdentityMismatch("Job claim");
       }
-      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)) runnerIdentityMismatch("Job claim");
+      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)) runnerIdentityMismatch("Job claim");
     };
     assertStartResult = (request, result2) => {
       if (result2.job_id !== request.job_id || result2.attempt_id !== request.attempt_id || result2.attempt_index !== request.attempt_index || result2.state !== "dispatch_intent") runnerIdentityMismatch("Job start");
@@ -28350,7 +28373,7 @@ var init_runner = __esm({
           await mcp.initialize({ signal: this.options.signal });
           const existingReceipt = await this.dependencies.receiptStore.read();
           const identityMatches = existingReceipt && existingReceipt.host_id === localState.host_id && existingReceipt.host_generation === localState.host_generation && existingReceipt.key_generation === localState.key_generation;
-          if (existingReceipt && !identityMatches && Object.keys(existingReceipt.attempts).length > 0) {
+          if (existingReceipt && !identityMatches && (Object.keys(existingReceipt.attempts).length > 0 || existingReceipt.pending_claim_request !== null)) {
             throw new InferenceHostRecoveryRequiredError(
               "A prior attempt belongs to another host generation and must be reconciled before takeover."
             );
@@ -28371,6 +28394,7 @@ var init_runner = __esm({
             advertisement_expires_at: null,
             registered: false,
             pending_advertisement: null,
+            pending_claim_request: null,
             host_heartbeat_sequence: 0,
             claim_sequence: 0,
             attempts: {},
@@ -28398,7 +28422,7 @@ var init_runner = __esm({
                 return await operation();
               } catch (error48) {
                 lastError = error48;
-                if (!retryableRemoteError(error48) || attempt === settings.remoteRetryLimit) throw error48;
+                if (!retryableRemoteError(error48) || error48 instanceof ExternalInferenceMcpError && error48.definitivelyNotApplied || attempt === settings.remoteRetryLimit) throw error48;
                 const requestedRetryDelay = remoteRetryAfterMs(
                   error48,
                   Math.min(250 * attempt, 1e3)
@@ -28499,7 +28523,7 @@ var init_runner = __esm({
           }
           const hostHeartbeat = async (status, requestOptions = {
             signal: this.options.signal
-          }, retryRemote = true, allowOfflineProjection = false) => {
+          }, retryRemote = true, allowOfflineProjection = false, definitiveReseedAttempt = 0) => {
             const sequence = receipt.host_heartbeat_sequence + 1;
             const request = {
               schema_version: "external_inference_host_heartbeat_v1",
@@ -28525,7 +28549,22 @@ var init_runner = __esm({
               request,
               requestOptions
             );
-            const result2 = status === "draining" || !retryRemote ? await heartbeatOperation() : await retryExact(heartbeatOperation, requestOptions);
+            let result2;
+            try {
+              result2 = status === "draining" || !retryRemote ? await heartbeatOperation() : await retryExact(heartbeatOperation, requestOptions);
+            } catch (error48) {
+              if (status !== "draining" && retryRemote && error48 instanceof ExternalInferenceMcpError && error48.definitivelyNotApplied && error48.retryable && definitiveReseedAttempt < settings.remoteRetryLimit - 1) {
+                await sleep4(remoteRetryAfterMs(error48, MIN_SLEEP_MS), requestOptions.signal);
+                return await hostHeartbeat(
+                  status,
+                  requestOptions,
+                  retryRemote,
+                  allowOfflineProjection,
+                  definitiveReseedAttempt + 1
+                );
+              }
+              throw error48;
+            }
             assertHostHeartbeatResult(request, result2, allowOfflineProjection);
             if (result2.host.status === "revoked" || result2.host.status === "offline" && !allowOfflineProjection) {
               const error48 = new InferenceHostRunnerError(
@@ -28540,8 +28579,9 @@ var init_runner = __esm({
           let nextAdvertisementAttemptAt = 0;
           let providerRetryAtMs = this.options.codexRateLimits && codexAccountRateLimitReached(this.options.codexRateLimits) ? codexRateLimitRetryAtMs(this.options.codexRateLimits) ?? now() + DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS : null;
           let nextClaimAt = Math.max(now(), providerRetryAtMs ?? 0);
+          let pendingClaimPromotions = 0;
           let onceClaimed = false;
-          const launchClaim = (claim, recovery) => {
+          const launchClaim = (claim, recovery, claimRequest) => {
             if (!recovery) {
               claimed += 1;
               onceClaimed = true;
@@ -28555,6 +28595,13 @@ var init_runner = __esm({
             ]);
             const controller = new AbortController();
             attemptControllers.set(attemptId, controller);
+            let claimPromotionSettled = claimRequest === void 0;
+            const settleClaimPromotion = () => {
+              if (claimPromotionSettled) return;
+              claimPromotionSettled = true;
+              pendingClaimPromotions = Math.max(0, pendingClaimPromotions - 1);
+            };
+            if (claimRequest) pendingClaimPromotions += 1;
             const promise2 = this.executeClaim({
               claim,
               attemptId,
@@ -28582,7 +28629,9 @@ var init_runner = __esm({
                 providerRetryAtMs = Math.max(providerRetryAtMs ?? 0, retryAtMs);
                 nextClaimAt = Math.max(nextClaimAt, providerRetryAtMs);
               },
-              resumeReceipt: recovery
+              resumeReceipt: recovery,
+              claimRequest,
+              onClaimPersisted: settleClaimPromotion
             }).then((outcome) => {
               if (outcome === "completed") completed += 1;
               else failed += 1;
@@ -28590,6 +28639,7 @@ var init_runner = __esm({
               failed += 1;
               requestDrain(controlPlaneFatal(error48) ? "authority_lost" : "attempt_terminal_unconfirmed");
             }).finally(() => {
+              settleClaimPromotion();
               active.delete(attemptId);
               attemptControllers.delete(attemptId);
             });
@@ -28686,29 +28736,33 @@ var init_runner = __esm({
               const recovery = recoveryQueue.shift();
               launchClaim(recovery.claim, recovery);
             }
-            while (!drainRequested && recoveryQueue.length === 0 && (!this.options.once || !onceClaimed) && active.size < settings.maxConcurrency && now() >= nextClaimAt) {
-              const claimSequence = receipt.claim_sequence + 1;
-              const 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: receipt.advertisement_generation,
-                key_generation: localState.key_generation,
-                claim_request_id: stableOperationId("claim", [
-                  localState.host_id,
-                  localState.host_generation,
-                  receipt.advertisement_generation,
-                  claimSequence
-                ]),
-                requested_at: isoAt(now())
-              };
-              receipt = {
-                ...receipt,
-                claim_sequence: claimSequence,
-                updated_at: isoAt(now())
-              };
-              await this.persistReceipt(receipt, now);
+            while (!drainRequested && recoveryQueue.length === 0 && (!this.options.once || !onceClaimed) && active.size < settings.maxConcurrency && pendingClaimPromotions === 0 && now() >= nextClaimAt) {
+              if (!receipt.pending_claim_request) {
+                const claimSequence = receipt.claim_sequence + 1;
+                const pendingClaimRequest = {
+                  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: receipt.advertisement_generation,
+                  key_generation: localState.key_generation,
+                  claim_request_id: stableOperationId("claim", [
+                    localState.host_id,
+                    localState.host_generation,
+                    receipt.advertisement_generation,
+                    claimSequence
+                  ]),
+                  requested_at: isoAt(now())
+                };
+                receipt = {
+                  ...receipt,
+                  claim_sequence: claimSequence,
+                  pending_claim_request: pendingClaimRequest,
+                  updated_at: isoAt(now())
+                };
+                await this.persistReceipt(receipt, now);
+              }
+              const request = receipt.pending_claim_request;
               let claim;
               try {
                 claim = await mcp.callTool(
@@ -28720,6 +28774,18 @@ var init_runner = __esm({
               } catch (error48) {
                 if (!this.options.signal?.aborted && controlPlaneFatal(error48)) {
                   requestDrain("authority_lost");
+                } else if (!this.options.signal?.aborted && error48 instanceof ExternalInferenceMcpError && error48.definitivelyNotApplied) {
+                  if (request.advertisement_generation < receipt.advertisement_generation) {
+                    receipt = {
+                      ...receipt,
+                      pending_claim_request: null,
+                      updated_at: isoAt(now())
+                    };
+                    await this.persistReceipt(receipt, now);
+                    nextClaimAt = now();
+                  } else {
+                    requestDrain("claim_failed");
+                  }
                 } else if (!this.options.signal?.aborted && retryableRemoteError(error48)) {
                   nextClaimAt = now() + remoteRetryAfterMs(error48, 1e3);
                 } else if (!this.options.signal?.aborted) {
@@ -28728,11 +28794,27 @@ var init_runner = __esm({
                 break;
               }
               if (claim.claim_state === "empty") {
+                receipt = {
+                  ...receipt,
+                  pending_claim_request: null,
+                  updated_at: isoAt(now())
+                };
+                await this.persistReceipt(receipt, now);
                 nextClaimAt = now() + Math.max(MIN_SLEEP_MS, claim.retry_after_ms);
                 if (this.options.once) requestDrain("once_empty");
                 break;
               }
-              launchClaim(claim);
+              if (Date.parse(claim.lease_expires_at) <= now() + MIN_CLAIM_START_WINDOW_MS || Date.parse(claim.deadline_at) <= now() + MIN_CLAIM_START_WINDOW_MS) {
+                receipt = {
+                  ...receipt,
+                  pending_claim_request: null,
+                  updated_at: isoAt(now())
+                };
+                await this.persistReceipt(receipt, now);
+                nextClaimAt = now();
+                break;
+              }
+              launchClaim(claim, void 0, request);
               if (this.options.once) requestDrain("once_complete");
             }
             if (drainRequested) break;
@@ -28805,7 +28887,7 @@ var init_runner = __esm({
         const sealCandidate = this.dependencies.sealCandidate ?? sealExternalInferenceCandidate;
         const validateOutput = this.dependencies.validateOutput ?? defaultValidateOutput;
         const activeReceipt = options.receipt();
-        if (claim.host_id !== localState.host_id || claim.host_generation !== localState.host_generation || (options.resumeReceipt ? claim.advertisement_generation > activeReceipt.advertisement_generation : claim.advertisement_generation !== activeReceipt.advertisement_generation) || claim.key_generation !== localState.key_generation) {
+        if (claim.host_id !== localState.host_id || claim.host_generation !== localState.host_generation || (options.resumeReceipt || options.claimRequest ? claim.advertisement_generation > activeReceipt.advertisement_generation : claim.advertisement_generation !== activeReceipt.advertisement_generation) || claim.key_generation !== localState.key_generation) {
           throw new InferenceHostRunnerError(
             "claim_generation_mismatch",
             "The claimed job crossed the active host generation fence."
@@ -28839,11 +28921,15 @@ var init_runner = __esm({
           );
         }
         if (!options.resumeReceipt) {
+          const currentReceipt = options.receipt();
+          const pendingClaimRequest = options.claimRequest && currentReceipt.pending_claim_request?.claim_request_id === options.claimRequest.claim_request_id ? null : currentReceipt.pending_claim_request ?? null;
           await options.updateReceipt({
-            ...options.receipt(),
-            attempts: { ...options.receipt().attempts, [attemptId]: attemptReceipt },
+            ...currentReceipt,
+            pending_claim_request: pendingClaimRequest,
+            attempts: { ...currentReceipt.attempts, [attemptId]: attemptReceipt },
             updated_at: isoAt(now())
           });
+          options.onClaimPersisted?.();
         }
         const updateAttempt = async (changes) => {
           attemptReceipt = validateAttemptReceipt({
@@ -28867,12 +28953,28 @@ var init_runner = __esm({
           });
         };
         if (attemptReceipt.phase === "claimed") {
-          const attemptDeadlineAtMs = Date.parse(claim.deadline_at);
-          const startResult = await retryExact(() => mcp.callTool(
-            "inference.job.start",
-            startRequest,
-            { signal, deadlineAtMs: attemptDeadlineAtMs }
-          ), { signal, deadlineAtMs: attemptDeadlineAtMs });
+          const attemptDeadlineAtMs = Math.min(
+            Date.parse(claim.deadline_at),
+            Date.parse(claim.lease_expires_at)
+          );
+          if (attemptDeadlineAtMs <= now() + MIN_CLAIM_START_WINDOW_MS) {
+            await removeAttempt();
+            return "failed";
+          }
+          let startResult;
+          try {
+            startResult = await retryExact(() => mcp.callTool(
+              "inference.job.start",
+              startRequest,
+              { signal, deadlineAtMs: attemptDeadlineAtMs }
+            ), { signal, deadlineAtMs: attemptDeadlineAtMs });
+          } catch (error48) {
+            if (attemptDeadlineAtMs <= now() + MIN_CLAIM_START_WINDOW_MS) {
+              await removeAttempt();
+              return "failed";
+            }
+            throw error48;
+          }
           assertStartResult(startRequest, startResult);
           await updateAttempt({ phase: "started" });
         }
@@ -29582,7 +29684,7 @@ private-file fallback. See https://vtxmacro.com/insights#subscription-inference.
       const receipt = await new FileInferenceHostRuntimeReceiptStore(
         runtimeReceiptPath(config2)
       ).read();
-      const pendingAttempts = receipt ? Object.keys(receipt.attempts).length : 0;
+      const pendingAttempts = receipt ? Object.keys(receipt.attempts).length + (receipt.pending_claim_request ? 1 : 0) : 0;
       const codexRecoveryPresent = await fileExistsPrivately(
         codexRecoveryPath(config2),
         "Codex attempt recovery file"
@@ -29873,7 +29975,7 @@ Waiting for approval...
           runtime: receipt ? {
             registered: receipt.registered,
             advertisement_generation: receipt.advertisement_generation,
-            pending_attempts: Object.keys(receipt.attempts).length,
+            pending_attempts: Object.keys(receipt.attempts).length + (receipt.pending_claim_request ? 1 : 0),
             updated_at: receipt.updated_at
           } : null,
           agent_attempt: agentAttempt ? {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtxmacro/cli",
-  "version": "2026.8.16",
+  "version": "2026.8.18",
   "description": "VTX Macro CLI, MCP server, and foreground subscription inference host.",
   "type": "module",
   "license": "UNLICENSED",