@vtxmacro/cli 2026.8.45 → 2026.8.47

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.45",
+      package_version: "2026.8.47",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -18431,11 +18431,12 @@ var init_mcp_client = __esm({
           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;
+          const staleHostHeartbeatGeneration = name === "inference.host.heartbeat" && errorText.includes("Heartbeat generations do not match the current host authority.");
           throw new ExternalInferenceMcpError(
-            "tool_rejected",
+            staleHostHeartbeatGeneration ? "generation_stale" : "tool_rejected",
             `Insights MCP rejected ${name}.`,
             {
-              definitivelyNotApplied,
+              definitivelyNotApplied: definitivelyNotApplied || staleHostHeartbeatGeneration,
               // 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
@@ -30744,6 +30745,9 @@ var init_runner = __esm({
         let completed = 0;
         let failed = 0;
         let acceptAttemptUpdates = true;
+        let stopHostHeartbeatLoop = () => {
+        };
+        let hostHeartbeatLoop = Promise.resolve();
         let wakeDrain;
         const drainSignal = new Promise((resolve6) => {
           wakeDrain = resolve6;
@@ -30759,6 +30763,7 @@ var init_runner = __esm({
           if (drainRequested && priority(reason) <= priority(drainReason)) return;
           drainRequested = true;
           drainReason = reason;
+          stopHostHeartbeatLoop();
           wakeDrain();
         };
         try {
@@ -30890,6 +30895,18 @@ var init_runner = __esm({
             updated_at: isoAt(now())
           };
           await this.persistReceipt(receipt, now);
+          let receiptMutationChain = Promise.resolve();
+          const mutateReceipt = async (mutation) => {
+            let result2;
+            const operation = receiptMutationChain.then(async () => {
+              result2 = mutation(receipt);
+              receipt = result2;
+              await this.persistReceipt(receipt, now);
+            });
+            receiptMutationChain = operation;
+            await operation;
+            return result2;
+          };
           const envelopePublicKey = await this.dependencies.envelopePublicKey(credential);
           const retryExact = async (operation, boundary = {}) => {
             let lastError;
@@ -30932,40 +30949,48 @@ var init_runner = __esm({
           const publishAdvertisement = async (health, forceAdvance, retryRemote = true, allowDefinitiveReseed = true) => {
             let advertisement = receipt.pending_advertisement;
             if (!advertisement) {
-              const generation = receipt.registered && forceAdvance ? receipt.advertisement_generation + 1 : receipt.advertisement_generation;
-              const advertisedAt = now();
-              advertisement = hostAdvertisementSchema.parse({
-                schema_version: EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION,
-                contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
-                operation_id: stableOperationId("advertise", [
-                  localState.host_id,
-                  localState.host_generation,
-                  generation,
-                  localState.key_generation,
-                  advertisedAt
-                ]),
-                host_id: localState.host_id,
-                host_generation: localState.host_generation,
-                advertisement_generation: generation,
-                key_generation: localState.key_generation,
-                adapter: settings.adapterId,
-                display_name: this.options.displayName.trim(),
-                ...this.options.authenticatedAccountIdentity ? { authenticated_account_identity: this.options.authenticatedAccountIdentity } : {},
-                authenticated_account_email: this.options.authenticatedAccountEmail ?? null,
-                authenticated_account_plan: this.options.authenticatedAccountPlan ?? null,
-                protocol_version: this.options.protocolVersion,
-                envelope_public_key: envelopePublicKey,
-                health,
-                advertised_at: isoAt(advertisedAt),
-                expires_at: isoAt(advertisedAt + settings.advertisementTtlMs),
-                models: settings.advertisedModels
+              const updated = await mutateReceipt((current) => {
+                if (current.pending_advertisement) return current;
+                const generation = current.registered && forceAdvance ? current.advertisement_generation + 1 : current.advertisement_generation;
+                const advertisedAt = now();
+                const pendingAdvertisement = hostAdvertisementSchema.parse({
+                  schema_version: EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION,
+                  contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
+                  operation_id: stableOperationId("advertise", [
+                    localState.host_id,
+                    localState.host_generation,
+                    generation,
+                    localState.key_generation,
+                    advertisedAt
+                  ]),
+                  host_id: localState.host_id,
+                  host_generation: localState.host_generation,
+                  advertisement_generation: generation,
+                  key_generation: localState.key_generation,
+                  adapter: settings.adapterId,
+                  display_name: this.options.displayName.trim(),
+                  ...this.options.authenticatedAccountIdentity ? { authenticated_account_identity: this.options.authenticatedAccountIdentity } : {},
+                  authenticated_account_email: this.options.authenticatedAccountEmail ?? null,
+                  authenticated_account_plan: this.options.authenticatedAccountPlan ?? null,
+                  protocol_version: this.options.protocolVersion,
+                  envelope_public_key: envelopePublicKey,
+                  health,
+                  advertised_at: isoAt(advertisedAt),
+                  expires_at: isoAt(advertisedAt + settings.advertisementTtlMs),
+                  models: settings.advertisedModels
+                });
+                return {
+                  ...current,
+                  pending_advertisement: pendingAdvertisement,
+                  updated_at: isoAt(now())
+                };
               });
-              receipt = {
-                ...receipt,
-                pending_advertisement: advertisement,
-                updated_at: isoAt(now())
-              };
-              await this.persistReceipt(receipt, now);
+              advertisement = updated.pending_advertisement;
+            }
+            if (!advertisement) {
+              throw new InferenceHostRecoveryRequiredError(
+                "The durable host advertisement receipt is unavailable."
+              );
             }
             const tool = receipt.registered ? "inference.host.advertise" : "inference.host.register";
             let result2;
@@ -30980,26 +31005,24 @@ var init_runner = __esm({
               const definitivelyNotApplied = error48 instanceof ExternalInferenceMcpError ? error48.definitivelyNotApplied : Boolean(error48 && typeof error48 === "object" && error48.definitivelyNotApplied === true);
               const expectedGeneration = receipt.registered ? receipt.advertisement_generation + 1 : receipt.advertisement_generation;
               if (definitivelyNotApplied && advertisement.advertisement_generation === expectedGeneration && allowDefinitiveReseed) {
-                receipt = {
-                  ...receipt,
-                  pending_advertisement: null,
+                await mutateReceipt((current) => ({
+                  ...current,
+                  pending_advertisement: current.pending_advertisement?.operation_id === advertisement.operation_id ? null : current.pending_advertisement,
                   updated_at: isoAt(now())
-                };
-                await this.persistReceipt(receipt, now);
+                }));
                 return await publishAdvertisement(health, forceAdvance, retryRemote, false);
               }
               throw error48;
             }
             assertAdvertisementResult(advertisement, result2);
-            receipt = {
-              ...receipt,
+            await mutateReceipt((current) => ({
+              ...current,
               registered: true,
               advertisement_generation: result2.host.advertisement_generation,
               advertisement_expires_at: advertisement.expires_at,
-              pending_advertisement: null,
+              pending_advertisement: current.pending_advertisement?.operation_id === advertisement.operation_id ? null : current.pending_advertisement,
               updated_at: isoAt(now())
-            };
-            await this.persistReceipt(receipt, now);
+            }));
           };
           const wasRegistered = receipt.registered;
           await publishAdvertisement("healthy", wasRegistered);
@@ -31012,32 +31035,34 @@ var init_runner = __esm({
           let providerRateLimitsObservedAtMs = now();
           const hostHeartbeat = async (status, requestOptions = {
             signal: this.options.signal
-          }, retryRemote = true, allowOfflineProjection = false, definitiveReseedAttempt = 0) => {
-            const sequence = receipt.host_heartbeat_sequence + 1;
-            const request = {
-              schema_version: "external_inference_host_heartbeat_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,
-              sequence,
-              status,
-              active_attempts: active.size,
-              available_slots: settings.maxConcurrency === null ? UNBOUNDED_AVAILABLE_SLOTS - active.size : Math.max(0, settings.maxConcurrency - active.size),
-              provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
-                providerRateLimits,
-                providerRateLimitsObservedAtMs,
-                now()
-              ),
-              observed_at: isoAt(now())
-            };
-            receipt = {
-              ...receipt,
-              host_heartbeat_sequence: sequence,
-              updated_at: isoAt(now())
-            };
-            await this.persistReceipt(receipt, now);
+          }, retryRemote = true, allowOfflineProjection = false, definitiveReseedAttempt = 0, advertisementGeneration = receipt.advertisement_generation) => {
+            let request;
+            await mutateReceipt((current) => {
+              const sequence = current.host_heartbeat_sequence + 1;
+              request = {
+                schema_version: "external_inference_host_heartbeat_v1",
+                contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
+                host_id: localState.host_id,
+                host_generation: localState.host_generation,
+                advertisement_generation: advertisementGeneration,
+                key_generation: localState.key_generation,
+                sequence,
+                status,
+                active_attempts: active.size,
+                available_slots: settings.maxConcurrency === null ? UNBOUNDED_AVAILABLE_SLOTS - active.size : Math.max(0, settings.maxConcurrency - active.size),
+                provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
+                  providerRateLimits,
+                  providerRateLimitsObservedAtMs,
+                  now()
+                ),
+                observed_at: isoAt(now())
+              };
+              return {
+                ...current,
+                host_heartbeat_sequence: sequence,
+                updated_at: isoAt(now())
+              };
+            });
             const heartbeatOperation = () => mcp.callTool(
               "inference.host.heartbeat",
               request,
@@ -31054,7 +31079,8 @@ var init_runner = __esm({
                   requestOptions,
                   retryRemote,
                   allowOfflineProjection,
-                  definitiveReseedAttempt + 1
+                  definitiveReseedAttempt + 1,
+                  advertisementGeneration
                 );
               }
               throw error48;
@@ -31089,12 +31115,109 @@ var init_runner = __esm({
             }
             return gapMs;
           };
-          let nextHostHeartbeatAt = now() + settings.hostHeartbeatMs;
           let nextAdvertisementAttemptAt = 0;
           let nextProviderRateLimitRefreshAt = now() + settings.providerRateLimitRefreshMs;
           let nextClaimAt = Math.max(now(), providerRetryAtMs ?? 0);
           let pendingClaimPromotions = 0;
           let onceClaimed = false;
+          const hostHeartbeatAbort = new AbortController();
+          stopHostHeartbeatLoop = () => hostHeartbeatAbort.abort();
+          let nextHostHeartbeatAt = now() + settings.hostHeartbeatMs;
+          hostHeartbeatLoop = (async () => {
+            while (!drainRequested && !hostHeartbeatAbort.signal.aborted) {
+              try {
+                await sleep4(
+                  Math.max(MIN_SLEEP_MS, nextHostHeartbeatAt - now()),
+                  hostHeartbeatAbort.signal
+                );
+              } catch (error48) {
+                if (hostHeartbeatAbort.signal.aborted || drainRequested) return;
+                throw error48;
+              }
+              if (drainRequested || hostHeartbeatAbort.signal.aborted) return;
+              const heartbeatStartedAt = now();
+              observeHostHeartbeatGap(heartbeatStartedAt);
+              const attemptedAdvertisementGeneration = receipt.advertisement_generation;
+              try {
+                const expiresAt = receipt.advertisement_expires_at ? Date.parse(receipt.advertisement_expires_at) : 0;
+                const refreshPendingAcrossExpiry = receipt.pending_advertisement !== null && expiresAt <= heartbeatStartedAt;
+                await hostHeartbeat(
+                  "healthy",
+                  { signal: hostHeartbeatAbort.signal },
+                  false,
+                  refreshPendingAcrossExpiry,
+                  0,
+                  attemptedAdvertisementGeneration
+                );
+              } catch (error48) {
+                if (hostHeartbeatAbort.signal.aborted || drainRequested) return;
+                const errorCode = error48 && typeof error48 === "object" && "code" in error48 ? String(error48.code) : "";
+                const pendingAdvertisement = receipt.pending_advertisement;
+                const recoveryAdvertisementGeneration = receipt.advertisement_generation > attemptedAdvertisementGeneration ? receipt.advertisement_generation : errorCode === "generation_stale" && pendingAdvertisement && pendingAdvertisement.advertisement_generation === attemptedAdvertisementGeneration + 1 ? pendingAdvertisement.advertisement_generation : null;
+                if (errorCode === "generation_stale" && recoveryAdvertisementGeneration !== null) {
+                  try {
+                    await hostHeartbeat(
+                      "healthy",
+                      { signal: hostHeartbeatAbort.signal },
+                      false,
+                      false,
+                      0,
+                      recoveryAdvertisementGeneration
+                    );
+                    if (receipt.advertisement_generation < recoveryAdvertisementGeneration) {
+                      await mutateReceipt((current) => current.advertisement_generation >= recoveryAdvertisementGeneration ? current : {
+                        ...current,
+                        advertisement_generation: recoveryAdvertisementGeneration,
+                        advertisement_expires_at: pendingAdvertisement?.expires_at ?? current.advertisement_expires_at,
+                        updated_at: isoAt(now())
+                      });
+                    }
+                  } catch (recoveryError) {
+                    if (hostHeartbeatAbort.signal.aborted || drainRequested) return;
+                    if (controlPlaneFatal(recoveryError)) {
+                      requestDrain("authority_lost");
+                      return;
+                    }
+                    if (!retryableRemoteError(recoveryError)) {
+                      requestDrain("host_heartbeat_failed");
+                      return;
+                    }
+                    nextHostHeartbeatAt = now() + remoteRetryAfterMs(recoveryError, settings.hostHeartbeatMs);
+                    continue;
+                  }
+                } else if (controlPlaneFatal(error48)) {
+                  requestDrain("authority_lost");
+                  return;
+                } else if (!retryableRemoteError(error48)) {
+                  requestDrain("host_heartbeat_failed");
+                  return;
+                } else {
+                  nextHostHeartbeatAt = now() + remoteRetryAfterMs(error48, settings.hostHeartbeatMs);
+                  continue;
+                }
+              }
+              const heartbeatSucceededAt = now();
+              const gapMs = observeHostHeartbeatGap(heartbeatSucceededAt);
+              if (hostHeartbeatGapOpen) {
+                emitDiagnostic("host_heartbeat_gap_recovered", {
+                  gap_ms: gapMs,
+                  configured_interval_ms: settings.hostHeartbeatMs,
+                  diagnostic_threshold_ms: hostHeartbeatGapThresholdMs,
+                  active_attempts: active.size,
+                  host_heartbeat_sequence: receipt.host_heartbeat_sequence
+                });
+                hostHeartbeatGapOpen = false;
+              }
+              lastHostHeartbeatSucceededAt = heartbeatSucceededAt;
+              nextHostHeartbeatAt = Math.max(
+                nextHostHeartbeatAt + settings.hostHeartbeatMs,
+                heartbeatSucceededAt + MIN_SLEEP_MS
+              );
+            }
+          })().catch((error48) => {
+            if (hostHeartbeatAbort.signal.aborted || drainRequested) return;
+            requestDrain(controlPlaneFatal(error48) ? "authority_lost" : "host_heartbeat_failed");
+          });
           const recoveryQueue = [];
           const attemptStartRetryCounts = /* @__PURE__ */ new Map();
           const launchClaim = (claim, recovery, claimRequest) => {
@@ -31130,15 +31253,14 @@ var init_runner = __esm({
               credential,
               mcp,
               receipt: () => receipt,
-              updateReceipt: async (next) => {
+              updateReceipt: async (mutation) => {
                 if (!acceptAttemptUpdates) {
                   throw new InferenceHostRunnerError(
                     "runtime_closed",
                     "The drained inference runtime no longer accepts attempt updates."
                   );
                 }
-                receipt = next;
-                await this.persistReceipt(receipt, now);
+                await mutateReceipt(mutation);
               },
               retryExact,
               signal: controller.signal,
@@ -31236,10 +31358,11 @@ var init_runner = __esm({
             return attemptId;
           };
           const removeRecoveredAttempt = async (attemptId) => {
-            const attempts = { ...receipt.attempts };
-            delete attempts[attemptId];
-            receipt = { ...receipt, attempts, updated_at: isoAt(now()) };
-            await this.persistReceipt(receipt, now);
+            await mutateReceipt((current) => {
+              const attempts = { ...current.attempts };
+              delete attempts[attemptId];
+              return { ...current, attempts, updated_at: isoAt(now()) };
+            });
           };
           for (const recovery of Object.values({ ...receipt.attempts })) {
             if (recovery.phase === "terminal_pending") {
@@ -31354,73 +31477,37 @@ var init_runner = __esm({
                 nextClaimAt = Math.max(nextClaimAt, nextAdvertisementAttemptAt);
               }
             }
-            if (currentTime >= nextHostHeartbeatAt) {
-              observeHostHeartbeatGap(currentTime);
-              try {
-                const refreshPendingAcrossExpiry = receipt.pending_advertisement !== null && expiresAt <= currentTime && nextAdvertisementAttemptAt > currentTime;
-                await hostHeartbeat(
-                  "healthy",
-                  { signal: this.options.signal },
-                  false,
-                  refreshPendingAcrossExpiry
-                );
-                const heartbeatSucceededAt = now();
-                const gapMs = observeHostHeartbeatGap(heartbeatSucceededAt);
-                if (hostHeartbeatGapOpen) {
-                  emitDiagnostic("host_heartbeat_gap_recovered", {
-                    gap_ms: gapMs,
-                    configured_interval_ms: settings.hostHeartbeatMs,
-                    diagnostic_threshold_ms: hostHeartbeatGapThresholdMs,
-                    active_attempts: active.size,
-                    host_heartbeat_sequence: receipt.host_heartbeat_sequence
-                  });
-                  hostHeartbeatGapOpen = false;
-                }
-                lastHostHeartbeatSucceededAt = heartbeatSucceededAt;
-              } catch (error48) {
-                if (controlPlaneFatal(error48)) {
-                  requestDrain("authority_lost");
-                  break;
-                }
-                if (!retryableRemoteError(error48)) {
-                  requestDrain("host_heartbeat_failed");
-                  break;
-                }
-                nextHostHeartbeatAt = now() + remoteRetryAfterMs(error48, settings.hostHeartbeatMs);
-              }
-              if (!drainRequested && currentTime >= nextHostHeartbeatAt) {
-                nextHostHeartbeatAt = now() + settings.hostHeartbeatMs;
-              }
-            }
             while (recoveryQueue.length > 0 && (settings.maxConcurrency === null || active.size < settings.maxConcurrency)) {
               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() >= 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);
+                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())
+                  };
+                });
               }
               const request = receipt.pending_claim_request;
               let claim;
@@ -31436,12 +31523,11 @@ var init_runner = __esm({
                   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,
+                    await mutateReceipt((current) => ({
+                      ...current,
+                      pending_claim_request: current.pending_claim_request?.claim_request_id === request.claim_request_id ? null : current.pending_claim_request,
                       updated_at: isoAt(now())
-                    };
-                    await this.persistReceipt(receipt, now);
+                    }));
                     nextClaimAt = now();
                   } else {
                     requestDrain("claim_failed");
@@ -31454,23 +31540,21 @@ var init_runner = __esm({
                 break;
               }
               if (claim.claim_state === "empty") {
-                receipt = {
-                  ...receipt,
-                  pending_claim_request: null,
+                await mutateReceipt((current) => ({
+                  ...current,
+                  pending_claim_request: current.pending_claim_request?.claim_request_id === request.claim_request_id ? null : current.pending_claim_request,
                   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;
               }
               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,
+                await mutateReceipt((current) => ({
+                  ...current,
+                  pending_claim_request: current.pending_claim_request?.claim_request_id === request.claim_request_id ? null : current.pending_claim_request,
                   updated_at: isoAt(now())
-                };
-                await this.persistReceipt(receipt, now);
+                }));
                 nextClaimAt = now();
                 break;
               }
@@ -31481,7 +31565,8 @@ var init_runner = __esm({
             const advertisementDueAt = nextAdvertisementAttemptAt > now() ? nextAdvertisementAttemptAt : receipt.advertisement_expires_at ? Date.parse(receipt.advertisement_expires_at) - settings.advertisementRefreshLeadMs : now() + MIN_SLEEP_MS;
             const wakeAt = Math.min(
               nextClaimAt,
-              nextHostHeartbeatAt,
+              nextProviderRateLimitRefreshAt,
+              now() + settings.hostHeartbeatMs,
               Math.max(now() + MIN_SLEEP_MS, advertisementDueAt)
             );
             await Promise.race([
@@ -31490,6 +31575,8 @@ var init_runner = __esm({
               ...active.values()
             ]);
           }
+          stopHostHeartbeatLoop();
+          await hostHeartbeatLoop;
           try {
             await hostHeartbeat("draining", {
               deadlineAtMs: now() + settings.drainTimeoutMs,
@@ -31524,6 +31611,8 @@ var init_runner = __esm({
           });
           return { claimed, completed, failed, drain_reason: drainReason };
         } finally {
+          stopHostHeartbeatLoop();
+          await hostHeartbeatLoop;
           removeAbortListener();
           unregisterSignals();
           try {
@@ -31595,35 +31684,39 @@ 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({
-            ...currentReceipt,
-            pending_claim_request: pendingClaimRequest,
-            attempts: { ...currentReceipt.attempts, [attemptId]: attemptReceipt },
-            updated_at: isoAt(now())
+          await options.updateReceipt((current) => {
+            const pendingClaimRequest = options.claimRequest && current.pending_claim_request?.claim_request_id === options.claimRequest.claim_request_id ? null : current.pending_claim_request ?? null;
+            return {
+              ...current,
+              pending_claim_request: pendingClaimRequest,
+              attempts: { ...current.attempts, [attemptId]: attemptReceipt },
+              updated_at: isoAt(now())
+            };
           });
           options.onClaimPersisted?.();
         }
         const updateAttempt = async (changes) => {
-          attemptReceipt = validateAttemptReceipt({
+          const nextAttemptReceipt = validateAttemptReceipt({
             ...attemptReceipt,
             ...changes,
             updated_at: isoAt(now())
           });
-          await options.updateReceipt({
-            ...options.receipt(),
-            attempts: { ...options.receipt().attempts, [attemptId]: attemptReceipt },
+          attemptReceipt = nextAttemptReceipt;
+          await options.updateReceipt((current) => ({
+            ...current,
+            attempts: { ...current.attempts, [attemptId]: nextAttemptReceipt },
             updated_at: isoAt(now())
-          });
+          }));
         };
         const removeAttempt = async () => {
-          const attempts = { ...options.receipt().attempts };
-          delete attempts[attemptId];
-          await options.updateReceipt({
-            ...options.receipt(),
-            attempts,
-            updated_at: isoAt(now())
+          await options.updateReceipt((current) => {
+            const attempts = { ...current.attempts };
+            delete attempts[attemptId];
+            return {
+              ...current,
+              attempts,
+              updated_at: isoAt(now())
+            };
           });
         };
         if (attemptReceipt.phase === "claimed") {

package/package.json

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