@vtxmacro/cli 2026.9.4 → 2026.9.6

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.4",
+  package_version: "2026.9.6",
   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.4",
+      package_version: "2026.9.6",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -15501,6 +15501,8 @@ var init_external_inference_contract = __esm({
       outcome: adapterOutcomeEvidenceSchema,
       latency_ms: nonNegativeSafeIntegerSchema,
       time_to_first_token_ms: nonNegativeSafeIntegerSchema.nullable(),
+      provider_dispatched_at: timestampSchema.optional(),
+      adapter_result_ready_at: timestampSchema.optional(),
       provider_dispatch_freshness_remaining_ms: nonNegativeSafeIntegerSchema.nullable().optional(),
       finish_reason: safeCodeSchema.nullable(),
       refusal_status: external_exports.enum(["none", "refused", "blocked", "unknown"]),
@@ -15616,6 +15618,8 @@ var init_external_inference_contract = __esm({
       failure_category: safeCodeSchema,
       failure_code: safeCodeSchema,
       retryable: external_exports.boolean(),
+      provider_dispatched_at: timestampSchema.optional(),
+      adapter_result_ready_at: timestampSchema.optional(),
       provider_dispatch_freshness_remaining_ms: nonNegativeSafeIntegerSchema.nullable().optional(),
       process_exit: codexProcessExitDiagnosticsSchema.nullable().optional(),
       membership_disposition: external_exports.enum([
@@ -15651,6 +15655,9 @@ var init_external_inference_contract = __esm({
         if (value.usage?.availability === "reported") {
           context.addIssue({ code: "custom", message: "not-dispatched failures cannot report token usage", path: ["usage"] });
         }
+        if (value.provider_dispatched_at !== void 0 || value.adapter_result_ready_at !== void 0) {
+          context.addIssue({ code: "custom", message: "not-dispatched failures cannot report provider stages", path: ["provider_dispatched_at"] });
+        }
       }
     });
     jobCancelRequestSchema = external_exports.strictObject({
@@ -33297,6 +33304,7 @@ var init_runner = __esm({
                 instance_name: this.options.instanceName ?? "default",
                 host_id: localState.host_id,
                 display_name: this.options.displayName,
+                host_runtime_version: settings.hostRuntimeVersion,
                 ...fields
               });
             } catch {
@@ -33526,16 +33534,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 +33808,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 +34048,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 +34247,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;
@@ -34374,6 +34424,8 @@ var init_runner = __esm({
         let providerDispatchNotAfterMs = serverProviderDispatchDeadlineMs === void 0 ? void 0 : now() - 1;
         let serverReportedFreshnessRemainingMs = null;
         let startRoundTripMs = 0;
+        let providerDispatchedAt = null;
+        let adapterResultReadyAt = null;
         let providerDispatchFreshnessRemainingMs = null;
         const startRequest = options.resumeReceipt?.start_request ?? buildAttemptStartRequest(claim, attemptId, isoAt(now()));
         let attemptReceipt = options.resumeReceipt ? validateAttemptReceipt(options.resumeReceipt) : {
@@ -34405,14 +34457,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 };
@@ -34565,7 +34655,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(
@@ -34625,22 +34715,24 @@ var init_runner = __esm({
             requestedReasoningEffort: jobInput.requested_reasoning_effort,
             deadlineAtMs: Date.parse(jobInput.deadline_at),
             ...providerDispatchNotAfterMs === void 0 ? {} : { providerDispatchNotAfterMs },
-            ...providerDispatchNotAfterMs === void 0 ? {} : {
-              onProviderDispatch: () => {
-                providerDispatchFreshnessRemainingMs = Math.max(
-                  0,
-                  providerDispatchNotAfterMs - now()
-                );
-                options.onProviderDispatch?.({
-                  cycle_id: jobInput.runtime_binding?.cycle_id ?? "unavailable",
-                  freshness_remaining_ms: providerDispatchFreshnessRemainingMs,
-                  server_reported_remaining_ms: serverReportedFreshnessRemainingMs ?? 0,
-                  start_round_trip_ms: startRoundTripMs
-                });
-              }
+            onProviderDispatch: () => {
+              const dispatchedAtMs = now();
+              providerDispatchedAt ??= isoAt(dispatchedAtMs);
+              if (providerDispatchNotAfterMs === void 0) return;
+              providerDispatchFreshnessRemainingMs = Math.max(
+                0,
+                providerDispatchNotAfterMs - dispatchedAtMs
+              );
+              options.onProviderDispatch?.({
+                cycle_id: jobInput.runtime_binding?.cycle_id ?? "unavailable",
+                freshness_remaining_ms: providerDispatchFreshnessRemainingMs,
+                server_reported_remaining_ms: serverReportedFreshnessRemainingMs ?? 0,
+                start_round_trip_ms: startRoundTripMs
+              });
             },
             signal: attemptAbort.signal
           });
+          adapterResultReadyAt = isoAt(now());
           await persistAttempt({
             phase: "dispatched",
             dispatch_outcome: "confirmed_dispatched"
@@ -34747,6 +34839,8 @@ var init_runner = __esm({
             },
             latency_ms: adapterResult.latencyMs,
             time_to_first_token_ms: adapterResult.timeToFirstTokenMs,
+            ...providerDispatchedAt === null ? {} : { provider_dispatched_at: providerDispatchedAt },
+            ...adapterResultReadyAt === null ? {} : { adapter_result_ready_at: adapterResultReadyAt },
             provider_dispatch_freshness_remaining_ms: providerDispatchFreshnessRemainingMs,
             finish_reason: finishReason,
             refusal_status: refusalStatus,
@@ -34877,6 +34971,8 @@ var init_runner = __esm({
             failure_category: failure.category,
             failure_code: failure.code,
             retryable: failure.retryable,
+            ...providerDispatchedAt === null ? {} : { provider_dispatched_at: providerDispatchedAt },
+            ...adapterResultReadyAt === null ? {} : { adapter_result_ready_at: adapterResultReadyAt },
             provider_dispatch_freshness_remaining_ms: providerDispatchFreshnessRemainingMs,
             ...processExit ? { process_exit: processExit } : {},
             membership_disposition: membershipFailureDisposition({

package/package.json

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