@vtxmacro/cli 2026.9.3 → 2026.9.5

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

package/bin/vtx.js

@@ -47,7 +47,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.9.3",
+      package_version: "2026.9.5",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -33526,16 +33526,53 @@ var init_runner = __esm({
             updated_at: isoAt(now())
           };
           await this.persistReceipt(receipt, now);
-          let receiptMutationChain = Promise.resolve();
+          let receiptRevision = 0;
+          let persistedReceiptRevision = 0;
+          let receiptWriter = null;
+          let receiptWriterFailed = false;
+          let receiptWriteFailure;
+          const receiptDurabilityWaiters = [];
+          const scheduleReceiptWriter = () => {
+            if (receiptWriter || receiptWriterFailed) return;
+            receiptWriter = (async () => {
+              try {
+                while (persistedReceiptRevision < receiptRevision) {
+                  const targetRevision = receiptRevision;
+                  const snapshot = receipt;
+                  await this.persistReceipt(snapshot, now);
+                  persistedReceiptRevision = targetRevision;
+                  for (let index = receiptDurabilityWaiters.length - 1; index >= 0; index -= 1) {
+                    const waiter = receiptDurabilityWaiters[index];
+                    if (waiter.revision > persistedReceiptRevision) continue;
+                    receiptDurabilityWaiters.splice(index, 1);
+                    waiter.resolve();
+                  }
+                }
+              } catch (error48) {
+                receiptWriterFailed = true;
+                receiptWriteFailure = error48;
+                for (const waiter of receiptDurabilityWaiters.splice(0)) {
+                  waiter.reject(error48);
+                }
+              } finally {
+                receiptWriter = null;
+                if (!receiptWriterFailed && persistedReceiptRevision < receiptRevision) {
+                  scheduleReceiptWriter();
+                }
+              }
+            })();
+          };
           const mutateReceipt = async (mutation) => {
-            let result2;
-            const operation = receiptMutationChain.then(async () => {
-              result2 = mutation(receipt);
-              receipt = result2;
-              await this.persistReceipt(receipt, now);
+            if (receiptWriterFailed) throw receiptWriteFailure;
+            const result2 = mutation(receipt);
+            receipt = result2;
+            const revision = receiptRevision + 1;
+            receiptRevision = revision;
+            const durable = new Promise((resolve6, reject) => {
+              receiptDurabilityWaiters.push({ revision, resolve: resolve6, reject });
             });
-            receiptMutationChain = operation;
-            await operation;
+            scheduleReceiptWriter();
+            await durable;
             return result2;
           };
           const envelopePublicKey = await this.dependencies.envelopePublicKey(credential);
@@ -33763,6 +33800,31 @@ var init_runner = __esm({
           let nextClaimAt = Math.max(now(), providerRetryAtMs ?? 0);
           let pendingClaimPromotions = 0;
           let onceClaimed = false;
+          const preparePendingClaim = (current) => {
+            if (current.pending_claim_request) return current;
+            const claimSequence = current.claim_sequence + 1;
+            const requestedAt = now();
+            return {
+              ...current,
+              claim_sequence: claimSequence,
+              pending_claim_request: {
+                schema_version: "external_inference_job_claim_v1",
+                contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
+                host_id: localState.host_id,
+                host_generation: localState.host_generation,
+                advertisement_generation: current.advertisement_generation,
+                key_generation: localState.key_generation,
+                claim_request_id: stableOperationId("claim", [
+                  localState.host_id,
+                  localState.host_generation,
+                  current.advertisement_generation,
+                  claimSequence
+                ]),
+                requested_at: isoAt(requestedAt)
+              },
+              updated_at: isoAt(requestedAt)
+            };
+          };
           const hostHeartbeatAbort = new AbortController();
           stopHostHeartbeatLoop = () => hostHeartbeatAbort.abort();
           let nextHostHeartbeatAt = now() + settings.hostHeartbeatMs;
@@ -33978,7 +34040,11 @@ var init_runner = __esm({
               },
               resumeReceipt: recovery,
               claimRequest,
-              onClaimPersisted: settleClaimPromotion
+              onClaimPersisted: settleClaimPromotion,
+              rolloverClaimRequest: (current) => {
+                if (drainRequested || this.options.once || settings.maxConcurrency !== null && active.size + 1 >= settings.maxConcurrency) return current;
+                return preparePendingClaim(current);
+              }
             }).then((outcome) => {
               if (outcome === "completed") {
                 attemptStartRetryCounts.delete(attemptId);
@@ -34173,31 +34239,7 @@ var init_runner = __esm({
             }
             while (!drainRequested && recoveryQueue.length === 0 && (!this.options.once || !onceClaimed) && (settings.maxConcurrency === null || active.size < settings.maxConcurrency) && pendingClaimPromotions === 0 && now() >= nextClaimAt) {
               if (!receipt.pending_claim_request) {
-                await mutateReceipt((current) => {
-                  if (current.pending_claim_request) return current;
-                  const claimSequence = current.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: current.advertisement_generation,
-                    key_generation: localState.key_generation,
-                    claim_request_id: stableOperationId("claim", [
-                      localState.host_id,
-                      localState.host_generation,
-                      current.advertisement_generation,
-                      claimSequence
-                    ]),
-                    requested_at: isoAt(now())
-                  };
-                  return {
-                    ...current,
-                    claim_sequence: claimSequence,
-                    pending_claim_request: pendingClaimRequest,
-                    updated_at: isoAt(now())
-                  };
-                });
+                await mutateReceipt(preparePendingClaim);
               }
               const request = receipt.pending_claim_request;
               let claim;
@@ -34405,14 +34447,52 @@ var init_runner = __esm({
             updated_at: isoAt(now())
           });
           attemptReceipt = nextAttemptReceipt;
-          await options.updateReceipt((current) => ({
-            ...current,
-            pending_claim_request: clearPendingClaim && options.claimRequest && current.pending_claim_request?.claim_request_id === options.claimRequest.claim_request_id ? null : current.pending_claim_request ?? null,
-            attempts: { ...current.attempts, [attemptId]: nextAttemptReceipt },
-            updated_at: isoAt(now())
-          }));
+          await options.updateReceipt((current) => {
+            const retiresClaimRequest = Boolean(
+              clearPendingClaim && options.claimRequest && current.pending_claim_request?.claim_request_id === options.claimRequest.claim_request_id
+            );
+            const promoted = {
+              ...current,
+              pending_claim_request: retiresClaimRequest ? null : current.pending_claim_request ?? null,
+              attempts: { ...current.attempts, [attemptId]: nextAttemptReceipt },
+              updated_at: isoAt(now())
+            };
+            return retiresClaimRequest && options.rolloverClaimRequest ? options.rolloverClaimRequest(promoted) : promoted;
+          });
           if (clearPendingClaim) options.onClaimPersisted?.();
         };
+        const persistAttemptHeartbeat = async (sequence) => {
+          attemptReceipt = validateAttemptReceipt({
+            ...attemptReceipt,
+            job_heartbeat_sequence: Math.max(
+              attemptReceipt.job_heartbeat_sequence,
+              sequence
+            ),
+            updated_at: isoAt(now())
+          });
+          let persisted = false;
+          await options.updateReceipt((current) => {
+            const currentAttempt = current.attempts[attemptId];
+            if (!currentAttempt || currentAttempt.job_id !== attemptReceipt.job_id || currentAttempt.claim_generation !== attemptReceipt.claim_generation || currentAttempt.input_sha256 !== attemptReceipt.input_sha256) return current;
+            persisted = true;
+            return {
+              ...current,
+              attempts: {
+                ...current.attempts,
+                [attemptId]: validateAttemptReceipt({
+                  ...currentAttempt,
+                  job_heartbeat_sequence: Math.max(
+                    currentAttempt.job_heartbeat_sequence,
+                    sequence
+                  ),
+                  updated_at: isoAt(now())
+                })
+              },
+              updated_at: isoAt(now())
+            };
+          });
+          return persisted;
+        };
         const removeAttempt = async () => {
           await options.updateReceipt((current) => {
             const attempts = { ...current.attempts };
@@ -34434,9 +34514,6 @@ var init_runner = __esm({
         } catch (error48) {
           inputValidationError = error48;
         }
-        if (!options.resumeReceipt) {
-          await persistAttempt({ phase: "claimed" }, true);
-        }
         if (attemptReceipt.phase === "claimed") {
           const attemptDeadlineAtMs = Math.min(
             Date.parse(claim.deadline_at),
@@ -34448,13 +34525,25 @@ var init_runner = __esm({
           }
           let startResult;
           const startCallStartedAtMs = now();
-          try {
-            startResult = await retryExact(() => mcp.callTool(
-              "inference.job.start",
-              startRequest,
-              { signal, deadlineAtMs: attemptDeadlineAtMs }
-            ), { signal, deadlineAtMs: attemptDeadlineAtMs });
-          } catch (error48) {
+          let startCallCompletedAtMs = startCallStartedAtMs;
+          const claimPromotionPromise = options.resumeReceipt ? Promise.resolve() : persistAttempt({ phase: "claimed" }, true);
+          const startCallPromise = retryExact(() => mcp.callTool(
+            "inference.job.start",
+            startRequest,
+            { signal, deadlineAtMs: attemptDeadlineAtMs }
+          ), { signal, deadlineAtMs: attemptDeadlineAtMs }).then((result2) => {
+            startCallCompletedAtMs = now();
+            return result2;
+          });
+          const [startOutcome, claimPromotionOutcome] = await Promise.allSettled([
+            startCallPromise,
+            claimPromotionPromise
+          ]);
+          if (claimPromotionOutcome.status === "rejected") {
+            throw claimPromotionOutcome.reason;
+          }
+          if (startOutcome.status === "rejected") {
+            const error48 = startOutcome.reason;
             if (error48 instanceof ExternalInferenceMcpError && error48.serverFailureCode === "server_account_context_expired_before_provider_dispatch") {
               await removeAttempt();
               options.onAttemptOutcome?.({
@@ -34499,6 +34588,7 @@ var init_runner = __esm({
             await options.sleep(retryDelayMs, signal);
             return "retry_claimed";
           }
+          startResult = startOutcome.value;
           assertStartResult(startRequest, startResult);
           if (serverProviderDispatchDeadlineMs !== void 0) {
             const serverRemaining = startResult.provider_dispatch_freshness_remaining_ms;
@@ -34508,7 +34598,6 @@ var init_runner = __esm({
                 "The Server provider-dispatch freshness receipt is unavailable."
               );
             }
-            const startCallCompletedAtMs = now();
             startRoundTripMs = Math.max(0, startCallCompletedAtMs - startCallStartedAtMs);
             serverReportedFreshnessRemainingMs = Number(serverRemaining);
             const conservativeRemainingMs = Math.max(
@@ -34556,7 +34645,7 @@ var init_runner = __esm({
               sequence,
               observed_at: isoAt(now())
             };
-            await persistAttempt({ job_heartbeat_sequence: sequence });
+            if (!await persistAttemptHeartbeat(sequence)) return;
             const heartbeatDeadlineAtMs = Date.parse(claim.deadline_at);
             const directive = await retryExact(
               () => mcp.callTool(

package/package.json

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