@vtxmacro/cli 2026.8.42 → 2026.8.44

package/README.md

@@ -60,7 +60,9 @@ Copilot is an additive preview adapter that uses the official SDK and validates
 final text against VTX's immutable schema. An uncertain interrupted Copilot call
 is quarantined as `outcome_unknown` and is never blindly repeated. A different
 adapter cannot replace an installed Codex instance; it needs a distinct instance
-and VTX grant.
+and VTX grant. VTX resolves the package-owned pinned Copilot platform runtime
+explicitly and rejects an `auto`-only catalog because it cannot prove the
+effective model.
 
 Before the first Codex login, enable **Device code authorization for Codex** in
 ChatGPT Security settings. Only enter a device code from a login you initiated,
@@ -200,7 +202,8 @@ Use `not_dispatched` only when no harness inference began,
 `outcome_unknown` when dispatch itself cannot be confirmed. Pipe exactly one
 object to `vtx inference-host agent-fail --json`.
 
-Claude Code, Kiro, Grok Build, Cursor, Amp, Auggie, Junie, and Warp/Oz remain on
+Claude Code, Antigravity, Gemini CLI, Kiro, Grok Build, Cursor, Amp, Auggie,
+Junie, Warp/Oz, Qwen Code, and OpenCode remain on
 the explicit foreground agent loop. Their current subscription routing,
 effective-model identity, schema, usage, or crash-recovery contracts do not yet
 meet every durable VTX acceptance fence. The public Insights matrix records the

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.42",
+      package_version: "2026.8.44",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -16196,7 +16196,7 @@ import { spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { lstat, mkdir, open, readFile, realpath, rename, rm } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, win32 as windowsPath } from "node:path";
 function inferenceBaseDir(env) {
   const configured = String(env.VTX_INFERENCE_HOST_HOME || "").trim();
   return configured || join(homedir(), ".vtx", "inference-host");
@@ -16737,7 +16737,7 @@ async function acquireInferenceHostProcessLock(path, dependencies = {}) {
     }
   };
 }
-var INFERENCE_CREDENTIAL_NAMESPACE, MAX_INFERENCE_PRIVATE_FILE_BYTES, WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, windowsPrivateAclBrokerInvocation, WindowsPrivateAclBroker, defaultWindowsPrivateAclBroker, runWindowsPrivateAcl, windowsAclCache, windowsAclIdentity, aclCacheKey, secureWindowsPrivatePath, invalidateWindowsAclCache, rebindHardenedWindowsAclAfterRename, rebindHardenedWindowsDirectoryAfterOwnedMutation, isDefaultWindowsPrivatePath, secureExistingWindowsPath, linuxProcessIdentity, windowsProcessIdentity, darwinProcessIdentity, runSmallIdentityCommand, cachedSystemBootIdentity, readInferenceSystemBootIdentity, defaultProcessIdentity, defaultCurrentProcessIdentity, processLockObservationCache, inferenceProcessIdentitiesMatch, DEFAULT_INFERENCE_HOST_INSTANCE, SAFE_INFERENCE_HOST_INSTANCE, requireNamedInstancePath, credentialStoreIdentity, inferenceHostCredentialContextPath, inferenceHostCredentialContextTransitionPath, credentialContextForConfig;
+var INFERENCE_CREDENTIAL_NAMESPACE, MAX_INFERENCE_PRIVATE_FILE_BYTES, WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS, WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS, SMALL_IDENTITY_COMMAND_TIMEOUT_MS, windowsPowerShellEnvironment, windowsPrivateAclBrokerInvocation, WindowsPrivateAclBroker, defaultWindowsPrivateAclBroker, runWindowsPrivateAcl, windowsAclCache, windowsAclIdentity, aclCacheKey, secureWindowsPrivatePath, invalidateWindowsAclCache, rebindHardenedWindowsAclAfterRename, rebindHardenedWindowsDirectoryAfterOwnedMutation, isDefaultWindowsPrivatePath, secureExistingWindowsPath, linuxProcessIdentity, windowsProcessIdentityInvocation, windowsBootIdentityInvocation, windowsProcessIdentity, darwinProcessIdentity, runSmallIdentityCommand, cachedSystemBootIdentity, readInferenceSystemBootIdentity, defaultProcessIdentity, defaultCurrentProcessIdentity, processLockObservationCache, inferenceProcessIdentitiesMatch, DEFAULT_INFERENCE_HOST_INSTANCE, SAFE_INFERENCE_HOST_INSTANCE, requireNamedInstancePath, credentialStoreIdentity, inferenceHostCredentialContextPath, inferenceHostCredentialContextTransitionPath, credentialContextForConfig;
 var init_config = __esm({
   "lib/inference-host/config.ts"() {
     "use strict";
@@ -16747,6 +16747,7 @@ var init_config = __esm({
 $ProgressPreference='SilentlyContinue'
 while(($line=[Console]::In.ReadLine()) -ne $null) {
   $requestId=$null
+  $failureStage='request_validation'
   try {
     if($line.Length -lt 2 -or $line.Length -gt 65536) { throw 'invalid request size' }
     $request=$line | ConvertFrom-Json
@@ -16761,18 +16762,25 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
     if($mode -ne 'harden' -and $mode -ne 'verify' -and $mode -ne 'verify-owner') { throw 'invalid ACL mode' }
     $path=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String([string]$request.path_b64))
     if([string]::IsNullOrWhiteSpace($path) -or $path.Length -gt 32767 -or $path.Contains([char]0)) { throw 'invalid path' }
+    $failureStage='path_lookup'
     if(-not (Test-Path -LiteralPath $path)) {
       [Console]::Out.WriteLine((@{id=$requestId;status='missing'} | ConvertTo-Json -Compress))
       continue
     }
-    $current=[Security.Principal.WindowsIdentity]::GetCurrent().User
+    $failureStage='principal_resolution'
+    $currentIdentity=[Security.Principal.WindowsIdentity]::GetCurrent()
+    $current=$currentIdentity.User
     $system=New-Object Security.Principal.SecurityIdentifier('S-1-5-18')
     $admins=New-Object Security.Principal.SecurityIdentifier('S-1-5-32-544')
+    $currentIsAdmin=(New-Object Security.Principal.WindowsPrincipal($currentIdentity)).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
     $allowed=@($current.Value,$system.Value,$admins.Value)
     if($mode -eq 'harden') {
+      $failureStage='acl_read'
       $acl=Get-Acl -LiteralPath $path
+      $failureStage='owner_validation'
       $existingOwner=(New-Object Security.Principal.NTAccount($acl.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value
-      if($existingOwner -ne $current.Value) { throw 'private ACL owner is invalid' }
+      if($existingOwner -ne $current.Value -and ($existingOwner -ne $admins.Value -or -not $currentIsAdmin)) { throw 'private ACL owner is invalid' }
+      $failureStage='acl_mutation'
       $acl.SetAccessRuleProtection($true,$false)
       foreach($existingRule in @($acl.Access)) { [void]$acl.RemoveAccessRuleSpecific($existingRule) }
       $inherit=if($kind -eq 'directory') {
@@ -16788,11 +16796,14 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
         )
         [void]$acl.AddAccessRule($rule)
       }
+      $failureStage='acl_write'
       (Get-Item -LiteralPath $path).SetAccessControl($acl)
     }
+    $failureStage='acl_readback'
     $actual=Get-Acl -LiteralPath $path
+    $failureStage='acl_verification'
     $owner=(New-Object Security.Principal.NTAccount($actual.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value
-    if($owner -ne $current.Value) { throw 'private ACL owner is invalid' }
+    if($owner -ne $current.Value -and ($owner -ne $admins.Value -or -not $currentIsAdmin)) { throw 'private ACL owner is invalid' }
     if($mode -ne 'verify-owner') {
       if(-not $actual.AreAccessRulesProtected) { throw 'private ACL inheritance is invalid' }
       $userFull=$false
@@ -16807,9 +16818,28 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
     }
     [Console]::Out.WriteLine((@{id=$requestId;status='ok'} | ConvertTo-Json -Compress))
   } catch {
-    [Console]::Out.WriteLine((@{id=$requestId;status='error'} | ConvertTo-Json -Compress))
+    [Console]::Out.WriteLine((@{id=$requestId;status='error';error_code=$failureStage} | ConvertTo-Json -Compress))
   }
 }`;
+    WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS = 15e3;
+    WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS = 45e3;
+    SMALL_IDENTITY_COMMAND_TIMEOUT_MS = 5e3;
+    windowsPowerShellEnvironment = (extra = {}) => {
+      const sanitizedExtra = { ...extra };
+      delete sanitizedExtra.PSModulePath;
+      const windowsRoot = process.env.SystemRoot ?? process.env.WINDIR;
+      return {
+        ...sanitizedExtra,
+        NODE_ENV: process.env.NODE_ENV,
+        SystemRoot: process.env.SystemRoot,
+        WINDIR: process.env.WINDIR,
+        ComSpec: process.env.ComSpec,
+        PATHEXT: process.env.PATHEXT,
+        PSModulePath: windowsRoot ? windowsPath.join(windowsRoot, "System32", "WindowsPowerShell", "v1.0", "Modules") : void 0,
+        TEMP: process.env.TEMP,
+        TMP: process.env.TMP
+      };
+    };
     windowsPrivateAclBrokerInvocation = () => ({
       args: [
         "-NoLogo",
@@ -16818,16 +16848,7 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
         "-EncodedCommand",
         Buffer.from(WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, "utf16le").toString("base64")
       ],
-      env: {
-        NODE_ENV: process.env.NODE_ENV,
-        SystemRoot: process.env.SystemRoot,
-        WINDIR: process.env.WINDIR,
-        ComSpec: process.env.ComSpec,
-        PATHEXT: process.env.PATHEXT,
-        PSModulePath: process.env.PSModulePath,
-        TEMP: process.env.TEMP,
-        TMP: process.env.TMP
-      }
+      env: windowsPowerShellEnvironment()
     });
     WindowsPrivateAclBroker = class {
       constructor(dependencies = {}) {
@@ -16846,6 +16867,7 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
           await operation;
         };
         this.requestTimeoutMs = dependencies.requestTimeoutMs ?? 15e3;
+        this.startupRequestTimeoutMs = dependencies.startupRequestTimeoutMs ?? WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS;
         this.idleShutdownMs = dependencies.idleShutdownMs ?? 3e4;
         this.spawnProcess = dependencies.spawnProcess ?? (() => {
           const invocation = windowsPrivateAclBrokerInvocation();
@@ -16896,7 +16918,19 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
         let response;
         try {
           const parsed = JSON.parse(line);
-          if (Object.keys(parsed).sort().join("\0") !== "id\0status" || parsed.id !== pending.id || !["ok", "missing", "error"].includes(String(parsed.status))) throw new Error("invalid response");
+          const status = String(parsed.status);
+          const expectedKeys = status === "error" ? "error_code\0id\0status" : "id\0status";
+          if (Object.keys(parsed).sort().join("\0") !== expectedKeys || parsed.id !== pending.id || !["ok", "missing", "error"].includes(status) || status === "error" && ![
+            "request_validation",
+            "path_lookup",
+            "principal_resolution",
+            "acl_read",
+            "owner_validation",
+            "acl_mutation",
+            "acl_write",
+            "acl_readback",
+            "acl_verification"
+          ].includes(String(parsed.error_code))) throw new Error("invalid response");
           response = parsed;
         } catch {
           this.failChild(child, new Error("Windows private ACL broker returned malformed output."));
@@ -16911,12 +16945,16 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
           error48.code = "ENOENT";
           pending.reject(error48);
         } else {
-          pending.reject(new Error(`Windows private ACL ${pending.mode} failed.`));
+          pending.reject(new Error(
+            `Windows private ACL ${pending.mode} failed (${response.error_code}).`
+          ));
         }
         this.scheduleIdleShutdown();
       }
       ensureChild() {
-        if (this.child && this.child.exitCode === null && !this.child.killed) return this.child;
+        if (this.child && this.child.exitCode === null && !this.child.killed) {
+          return { child: this.child, startedNow: false };
+        }
         const child = this.spawnProcess();
         this.child = child;
         this.outputBuffer = "";
@@ -16947,7 +16985,7 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
         for (const stream of [child.stdin, child.stdout, child.stderr]) {
           stream.unref?.();
         }
-        return child;
+        return { child, startedNow: true };
       }
       async dispatch(path, kind, mode) {
         if (this.idleTimer) {
@@ -16965,11 +17003,12 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
         if (Buffer.byteLength(request, "utf8") > 65536) {
           throw new Error("Windows private ACL broker request exceeds its input limit.");
         }
-        const child = this.ensureChild();
+        const { child, startedNow } = this.ensureChild();
+        const timeoutMs = startedNow ? this.startupRequestTimeoutMs : this.requestTimeoutMs;
         await new Promise((resolvePromise, reject) => {
           const timer = setTimeout(() => {
             this.failChild(child, new Error("Windows private ACL broker request timed out."));
-          }, this.requestTimeoutMs);
+          }, timeoutMs);
           this.pending = { id: id2, mode, resolve: resolvePromise, reject, timer };
           child.stdin.write(request, "utf8", (error48) => {
             if (error48) {
@@ -17072,26 +17111,40 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
         return null;
       }
     };
+    windowsProcessIdentityInvocation = (pid) => {
+      const script = `$ErrorActionPreference='Stop';$p=[Diagnostics.Process]::GetProcessById([int]$env:VTX_PROCESS_PID);[Console]::Out.Write($p.StartTime.ToUniversalTime().ToFileTimeUtc())`;
+      return {
+        args: [
+          "-NoLogo",
+          "-NoProfile",
+          "-NonInteractive",
+          "-EncodedCommand",
+          Buffer.from(script, "utf16le").toString("base64")
+        ],
+        env: windowsPowerShellEnvironment({ VTX_PROCESS_PID: String(pid) }),
+        timeoutMs: WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS
+      };
+    };
+    windowsBootIdentityInvocation = () => {
+      const script = `$ErrorActionPreference='Stop';$s=[System.Management.ManagementObjectSearcher]::new('SELECT LastBootUpTime FROM Win32_OperatingSystem');try{$c=$s.Get();$e=$c.GetEnumerator();if(-not $e.MoveNext()){throw 'boot identity unavailable'};$raw=[string]$e.Current['LastBootUpTime'];$v=[System.Management.ManagementDateTimeConverter]::ToDateTime($raw).ToUniversalTime().ToFileTimeUtc();[Console]::Out.Write($v)}finally{if($c){$c.Dispose()};$s.Dispose()}`;
+      return {
+        args: [
+          "-NoLogo",
+          "-NoProfile",
+          "-NonInteractive",
+          "-EncodedCommand",
+          Buffer.from(script, "utf16le").toString("base64")
+        ],
+        env: windowsPowerShellEnvironment(),
+        timeoutMs: WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS
+      };
+    };
     windowsProcessIdentity = async (pid) => await new Promise((resolvePromise) => {
-      const script = `$ErrorActionPreference='Stop';$p=Get-Process -Id ([int]$env:VTX_PROCESS_PID);[Console]::Out.Write($p.StartTime.ToUniversalTime().ToFileTimeUtc())`;
-      const child = spawn("powershell.exe", [
-        "-NoLogo",
-        "-NoProfile",
-        "-NonInteractive",
-        "-EncodedCommand",
-        Buffer.from(script, "utf16le").toString("base64")
-      ], {
+      const invocation = windowsProcessIdentityInvocation(pid);
+      const child = spawn("powershell.exe", [...invocation.args], {
         windowsHide: true,
         stdio: ["ignore", "pipe", "ignore"],
-        env: {
-          NODE_ENV: process.env.NODE_ENV,
-          SystemRoot: process.env.SystemRoot,
-          WINDIR: process.env.WINDIR,
-          ComSpec: process.env.ComSpec,
-          PATHEXT: process.env.PATHEXT,
-          PSModulePath: process.env.PSModulePath,
-          VTX_PROCESS_PID: String(pid)
-        }
+        env: invocation.env
       });
       const output3 = [];
       let settled = false;
@@ -17104,7 +17157,7 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
       const timer = setTimeout(() => {
         child.kill("SIGKILL");
         settle(null);
-      }, 5e3);
+      }, invocation.timeoutMs);
       child.stdout.on("data", (chunk) => {
         if (output3.reduce((total, item) => total + item.byteLength, 0) + Buffer.byteLength(chunk) > 1024) {
           child.kill("SIGKILL");
@@ -17142,7 +17195,7 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
         settle(code === 0 && Number.isFinite(started) ? `darwin:${Math.floor(started / 1e3)}` : null);
       });
     });
-    runSmallIdentityCommand = async (command, args, env) => await new Promise((resolvePromise) => {
+    runSmallIdentityCommand = async (command, args, env, timeoutMs = SMALL_IDENTITY_COMMAND_TIMEOUT_MS) => await new Promise((resolvePromise) => {
       const child = spawn(command, [...args], {
         windowsHide: true,
         stdio: ["ignore", "pipe", "ignore"],
@@ -17160,7 +17213,7 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
       const timer = setTimeout(() => {
         child.kill("SIGKILL");
         settle(null);
-      }, 5e3);
+      }, timeoutMs);
       child.stdout.on("data", (chunk) => {
         bytes3 += Buffer.byteLength(chunk);
         if (bytes3 > 4096) {
@@ -17189,21 +17242,13 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
             identity = null;
           }
         } else if (platform === "win32") {
-          const script = `$ErrorActionPreference='Stop';$v=(Get-CimInstance Win32_OperatingSystem).LastBootUpTime.ToUniversalTime().ToFileTimeUtc();[Console]::Out.Write($v)`;
-          identity = await runSmallIdentityCommand("powershell.exe", [
-            "-NoLogo",
-            "-NoProfile",
-            "-NonInteractive",
-            "-EncodedCommand",
-            Buffer.from(script, "utf16le").toString("base64")
-          ], {
-            NODE_ENV: process.env.NODE_ENV,
-            SystemRoot: process.env.SystemRoot,
-            WINDIR: process.env.WINDIR,
-            ComSpec: process.env.ComSpec,
-            PATHEXT: process.env.PATHEXT,
-            PSModulePath: process.env.PSModulePath
-          });
+          const invocation = windowsBootIdentityInvocation();
+          identity = await runSmallIdentityCommand(
+            "powershell.exe",
+            invocation.args,
+            invocation.env,
+            invocation.timeoutMs
+          );
         } else if (platform === "darwin") {
           identity = await runSmallIdentityCommand("sysctl", ["-n", "kern.boottime"], void 0);
         }
@@ -22788,16 +22833,44 @@ $items = @(Get-CimInstance Win32_Process | Where-Object { $_.Name -in @('node.ex
 
 // lib/inference-host/copilot-adapter.ts
 import { mkdtemp as mkdtemp2, rm as rm4 } from "node:fs/promises";
+import { createRequire as createRequire2 } from "node:module";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join5 } from "node:path";
-import { CopilotClient } from "@github/copilot-sdk";
-var COPILOT_SDK_VERSION, MAX_RESULT_BYTES, createPrivateWorkspace, cleanCopilotEnvironment, defaultClient, modelCapabilities, requiredUsageInteger, optionalUsageInteger, CopilotSubscriptionAdapter;
+import {
+  CopilotClient,
+  RuntimeConnection
+} from "@github/copilot-sdk";
+var COPILOT_SDK_VERSION, MAX_RESULT_BYTES, resolveRuntimePackage, copilotRuntimePackageCandidates, resolvePinnedCopilotCliPath, createPrivateWorkspace, cleanCopilotEnvironment, defaultClient, modelCapabilities, requiredUsageInteger, optionalUsageInteger, CopilotSubscriptionAdapter;
 var init_copilot_adapter = __esm({
   "lib/inference-host/copilot-adapter.ts"() {
     "use strict";
     init_codex_app_server();
     COPILOT_SDK_VERSION = "1.0.0-beta.8";
     MAX_RESULT_BYTES = 3e5;
+    resolveRuntimePackage = createRequire2(import.meta.url).resolve;
+    copilotRuntimePackageCandidates = () => {
+      if (process.arch !== "x64") {
+        throw new Error(`copilot_runtime_platform_unsupported:${process.platform}-${process.arch}`);
+      }
+      if (process.platform === "win32") return ["@github/copilot-win32-x64"];
+      if (process.platform === "linux") {
+        const report = process.report?.getReport();
+        const glibcVersion = report?.header?.glibcVersionRuntime;
+        return glibcVersion ? ["@github/copilot-linux-x64", "@github/copilot-linuxmusl-x64"] : ["@github/copilot-linuxmusl-x64", "@github/copilot-linux-x64"];
+      }
+      throw new Error(`copilot_runtime_platform_unsupported:${process.platform}-${process.arch}`);
+    };
+    resolvePinnedCopilotCliPath = () => {
+      const failures = [];
+      for (const packageName of copilotRuntimePackageCandidates()) {
+        try {
+          return resolveRuntimePackage(packageName);
+        } catch (error48) {
+          failures.push(error48 instanceof Error ? error48.message : String(error48));
+        }
+      }
+      throw new Error(`copilot_runtime_package_missing:${failures.join(";")}`);
+    };
     createPrivateWorkspace = async () => {
       const path = await mkdtemp2(join5(tmpdir3(), "vtx-copilot-"));
       return {
@@ -22824,13 +22897,14 @@ var init_copilot_adapter = __esm({
       return environment;
     };
     defaultClient = (workingDirectory) => new CopilotClient({
+      connection: RuntimeConnection.forStdio({ path: resolvePinnedCopilotCliPath() }),
       workingDirectory,
       env: cleanCopilotEnvironment(),
       useLoggedInUser: true,
       logLevel: "error"
     });
     modelCapabilities = (models) => {
-      const capabilities = models.filter((model) => model.policy?.state !== "disabled" && model.policy?.state !== "unconfigured").flatMap((model) => {
+      const capabilities = models.filter((model) => model.id !== "auto" && model.id.trim() !== "" && model.policy?.state !== "disabled" && model.policy?.state !== "unconfigured").flatMap((model) => {
         const efforts = model.capabilities.supports.reasoningEffort ? [...model.supportedReasoningEfforts ?? []] : ["none"];
         if (efforts.length === 0) return [];
         const defaultEffort = model.defaultReasoningEffort && efforts.includes(model.defaultReasoningEffort) ? model.defaultReasoningEffort : efforts[0];
@@ -29688,7 +29762,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_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, 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_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, safeFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner;
 var init_runner = __esm({
   "lib/inference-host/runner.ts"() {
     "use strict";
@@ -29712,6 +29786,7 @@ var init_runner = __esm({
     MIN_SLEEP_MS = 10;
     DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS = 5 * 60 * 1e3;
     MIN_CLAIM_START_WINDOW_MS = 5e3;
+    MAX_ATTEMPT_START_RETRY_DELAY_MS = 15e3;
     UNBOUNDED_AVAILABLE_SLOTS = Number.MAX_SAFE_INTEGER;
     buildInferenceAdvertisedModels = (capabilities, adapterRuntimeVersion, adapter = "codex", structuredOutput = true, sameAttemptRecovery = adapter === "codex") => {
       const visible = capabilities.filter((capability) => !capability.hidden);
@@ -30247,6 +30322,10 @@ var init_runner = __esm({
       const normalized = value.trim().toLowerCase().replace(/[^a-z0-9._-]+/gu, "_").slice(0, 96);
       return /^[a-z0-9]/u.test(normalized) ? normalized : fallback;
     };
+    attemptStartRetryFallbackMs = (retryCount) => Math.min(
+      1e3 * 2 ** Math.min(Math.max(0, retryCount - 1), 4),
+      MAX_ATTEMPT_START_RETRY_DELAY_MS
+    );
     exactJson2 = (left, right) => JSON.stringify(left) === JSON.stringify(right);
     runnerIdentityMismatch = (operation) => {
       throw new InferenceHostRunnerError(
@@ -30707,6 +30786,7 @@ var init_runner = __esm({
           let pendingClaimPromotions = 0;
           let onceClaimed = false;
           const recoveryQueue = [];
+          const attemptStartRetryCounts = /* @__PURE__ */ new Map();
           const launchClaim = (claim, recovery, claimRequest) => {
             if (!recovery) {
               claimed += 1;
@@ -30719,6 +30799,10 @@ var init_runner = __esm({
               claim.attempt_index,
               claim.input_sha256
             ]);
+            const nextStartRetryCount = Math.min(
+              (attemptStartRetryCounts.get(attemptId) ?? 0) + 1,
+              Number.MAX_SAFE_INTEGER
+            );
             const controller = new AbortController();
             attemptControllers.set(attemptId, controller);
             let claimPromotionSettled = claimRequest === void 0;
@@ -30783,13 +30867,27 @@ var init_runner = __esm({
                   active_attempts: active.size
                 });
               },
+              startRetryCount: nextStartRetryCount,
+              onAttemptStartRetry: (observation) => {
+                attemptStartRetryCounts.set(attemptId, observation.retry_count);
+                emitDiagnostic("attempt_start_retry_scheduled", {
+                  ...observation,
+                  job_id: claim.job_id,
+                  attempt_id: attemptId,
+                  active_attempts: active.size
+                });
+              },
               resumeReceipt: recovery,
               claimRequest,
               onClaimPersisted: settleClaimPromotion
             }).then((outcome) => {
-              if (outcome === "completed") completed += 1;
-              else if (outcome === "failed") failed += 1;
-              else {
+              if (outcome === "completed") {
+                attemptStartRetryCounts.delete(attemptId);
+                completed += 1;
+              } else if (outcome === "failed") {
+                attemptStartRetryCounts.delete(attemptId);
+                failed += 1;
+              } else {
                 const recovery2 = receipt.attempts[attemptId];
                 if (recovery2?.phase !== "claimed") {
                   throw new InferenceHostRecoveryRequiredError(
@@ -30799,6 +30897,7 @@ var init_runner = __esm({
                 retryRecovery = recovery2;
               }
             }).catch((error48) => {
+              attemptStartRetryCounts.delete(attemptId);
               failed += 1;
               const recovery2 = receipt.attempts[attemptId];
               if (recovery2?.phase === "terminal_pending") {
@@ -30811,22 +30910,19 @@ var init_runner = __esm({
               attemptControllers.delete(attemptId);
               if (retryRecovery) {
                 recoveryQueue.push(retryRecovery);
-                emitDiagnostic("attempt_start_retry_scheduled", {
-                  job_id: claim.job_id,
-                  attempt_id: attemptId,
-                  active_attempts: active.size
-                });
               }
             });
             active.set(attemptId, promise2);
-            emitDiagnostic("attempt_started", {
-              job_id: claim.job_id,
-              attempt_id: attemptId,
-              attempt_index: claim.attempt_index,
-              requested_model: claim.requested_model,
-              requested_reasoning_effort: claim.requested_reasoning_effort,
-              active_attempts: active.size
-            });
+            if (!recovery) {
+              emitDiagnostic("attempt_started", {
+                job_id: claim.job_id,
+                attempt_id: attemptId,
+                attempt_index: claim.attempt_index,
+                requested_model: claim.requested_model,
+                requested_reasoning_effort: claim.requested_reasoning_effort,
+                active_attempts: active.size
+              });
+            }
             return attemptId;
           };
           const removeRecoveredAttempt = async (attemptId) => {
@@ -31233,10 +31329,28 @@ var init_runner = __esm({
               MIN_SLEEP_MS,
               attemptDeadlineAtMs - now() - MIN_CLAIM_START_WINDOW_MS
             );
-            await options.sleep(
-              Math.min(remoteRetryAfterMs(error48, 1e3), remainingMs),
-              signal
+            const retryCount = Math.min(
+              Math.max(1, options.startRetryCount),
+              Number.MAX_SAFE_INTEGER
+            );
+            const retryDelayMs = Math.min(
+              remoteRetryAfterMs(error48, attemptStartRetryFallbackMs(retryCount)),
+              remainingMs
             );
+            const rawErrorCode = error48 && typeof error48 === "object" && "code" in error48 ? String(error48.code) : "start_acknowledgement_failed";
+            options.onAttemptStartRetry?.({
+              failure_stage: "job_start_acknowledgement",
+              error_code: safeFailureCode(rawErrorCode, "start_acknowledgement_failed"),
+              http_status_code: error48 instanceof ExternalInferenceMcpError ? error48.httpStatusCode : null,
+              retryable: retryableRemoteError(error48),
+              definitively_not_applied: Boolean(
+                error48 && typeof error48 === "object" && "definitivelyNotApplied" in error48 && error48.definitivelyNotApplied === true
+              ),
+              retry_after_ms: error48 instanceof ExternalInferenceMcpError ? error48.retryAfterMs : null,
+              retry_count: retryCount,
+              next_delay_ms: retryDelayMs
+            });
+            await options.sleep(retryDelayMs, signal);
             return "retry_claimed";
           }
           assertStartResult(startRequest, startResult);
@@ -32954,8 +33068,8 @@ ${result2.stderr}`)) {
           return !nextWorker || !sameWorker(record2.worker, nextWorker);
         });
         for (const record2 of retiring) {
-          await updateRecord(record2, "draining");
           record2.controller.abort();
+          await updateRecord(record2, "draining");
         }
         const settled = await Promise.allSettled(retiring.map((record2) => record2.promise));
         const failedDrain = settled.find(
@@ -32989,8 +33103,8 @@ ${result2.stderr}`)) {
       const drainWorkers = async () => {
         const draining = [...workers.values()];
         for (const record2 of draining) {
-          await updateRecord(record2, "draining");
           record2.controller.abort();
+          await updateRecord(record2, "draining");
         }
         const settled = await Promise.allSettled(draining.map((record2) => record2.promise));
         const failedDrain = settled.find(

package/package.json

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