@vtxmacro/cli 2026.8.34 → 2026.8.36

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.34",
+      package_version: "2026.8.36",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       platforms: {
@@ -16619,66 +16619,86 @@ async function acquireInferenceHostProcessLock(path, dependencies = {}) {
     }
   };
 }
-var INFERENCE_CREDENTIAL_NAMESPACE, MAX_INFERENCE_PRIVATE_FILE_BYTES, WINDOWS_PRIVATE_ACL_SCRIPT, windowsPrivateAclInvocation, 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;
+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;
 var init_config = __esm({
   "lib/inference-host/config.ts"() {
     "use strict";
     INFERENCE_CREDENTIAL_NAMESPACE = "vtxmacro-insights-inference";
     MAX_INFERENCE_PRIVATE_FILE_BYTES = 16 * 1024 * 1024;
-    WINDOWS_PRIVATE_ACL_SCRIPT = `$ErrorActionPreference='Stop'
-$path=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($env:VTX_PRIVATE_PATH_B64))
-$kind=$env:VTX_PRIVATE_PATH_KIND
-$mode=$env:VTX_PRIVATE_ACL_MODE
-if(-not (Test-Path -LiteralPath $path)) { [Console]::Out.Write('missing'); exit 3 }
-$current=[Security.Principal.WindowsIdentity]::GetCurrent().User
-$system=New-Object Security.Principal.SecurityIdentifier('S-1-5-18')
-$admins=New-Object Security.Principal.SecurityIdentifier('S-1-5-32-544')
-$allowed=@($current.Value,$system.Value,$admins.Value)
-if($mode -eq 'harden') {
-  $acl=Get-Acl -LiteralPath $path
-  $existingOwner=(New-Object Security.Principal.NTAccount($acl.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value
-  if($existingOwner -ne $current.Value) { throw 'private ACL owner is invalid' }
-  $acl.SetAccessRuleProtection($true,$false)
-  foreach($existingRule in @($acl.Access)) {
-    [void]$acl.RemoveAccessRuleSpecific($existingRule)
-  }
-  $inherit=if($kind -eq 'directory') {
-    [Security.AccessControl.InheritanceFlags]'ContainerInherit,ObjectInherit'
-  } else { [Security.AccessControl.InheritanceFlags]::None }
-  foreach($sid in @($current,$system,$admins)) {
-    $rule=New-Object Security.AccessControl.FileSystemAccessRule(
-      $sid,
-      [Security.AccessControl.FileSystemRights]::FullControl,
-      $inherit,
-      [Security.AccessControl.PropagationFlags]::None,
-      [Security.AccessControl.AccessControlType]::Allow
-    )
-    [void]$acl.AddAccessRule($rule)
-  }
-  (Get-Item -LiteralPath $path).SetAccessControl($acl)
-}
-$actual=Get-Acl -LiteralPath $path
-$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($mode -eq 'verify-owner') { [Console]::Out.Write('ok'); exit 0 }
-if(-not $actual.AreAccessRulesProtected) { throw 'private ACL inheritance is invalid' }
-$userFull=$false
-foreach($rule in $actual.Access) {
-  $sid=$rule.IdentityReference.Translate([Security.Principal.SecurityIdentifier]).Value
-  if($rule.IsInherited -or $allowed -notcontains $sid -or $rule.AccessControlType -ne [Security.AccessControl.AccessControlType]::Allow) {
-    throw 'private ACL contains an unauthorized access rule'
-  }
-  if($sid -eq $current.Value -and (($rule.FileSystemRights -band [Security.AccessControl.FileSystemRights]::FullControl) -eq [Security.AccessControl.FileSystemRights]::FullControl)) { $userFull=$true }
-}
-if(-not $userFull) { throw 'private ACL does not grant the current user full control' }
-[Console]::Out.Write('ok')`;
-    windowsPrivateAclInvocation = (path, kind, mode) => ({
+    WINDOWS_PRIVATE_ACL_BROKER_SCRIPT = `$ErrorActionPreference='Stop'
+$ProgressPreference='SilentlyContinue'
+while(($line=[Console]::In.ReadLine()) -ne $null) {
+  $requestId=$null
+  try {
+    if($line.Length -lt 2 -or $line.Length -gt 65536) { throw 'invalid request size' }
+    $request=$line | ConvertFrom-Json
+    $names=@($request.PSObject.Properties.Name | Sort-Object)
+    if(($names -join ',') -ne 'id,kind,mode,path_b64') { throw 'invalid request shape' }
+    if($request.id -isnot [long] -and $request.id -isnot [int]) { throw 'invalid request id' }
+    $requestId=[long]$request.id
+    if($requestId -lt 1) { throw 'invalid request id' }
+    $kind=[string]$request.kind
+    $mode=[string]$request.mode
+    if($kind -ne 'directory' -and $kind -ne 'file') { throw 'invalid path kind' }
+    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' }
+    if(-not (Test-Path -LiteralPath $path)) {
+      [Console]::Out.WriteLine((@{id=$requestId;status='missing'} | ConvertTo-Json -Compress))
+      continue
+    }
+    $current=[Security.Principal.WindowsIdentity]::GetCurrent().User
+    $system=New-Object Security.Principal.SecurityIdentifier('S-1-5-18')
+    $admins=New-Object Security.Principal.SecurityIdentifier('S-1-5-32-544')
+    $allowed=@($current.Value,$system.Value,$admins.Value)
+    if($mode -eq 'harden') {
+      $acl=Get-Acl -LiteralPath $path
+      $existingOwner=(New-Object Security.Principal.NTAccount($acl.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value
+      if($existingOwner -ne $current.Value) { throw 'private ACL owner is invalid' }
+      $acl.SetAccessRuleProtection($true,$false)
+      foreach($existingRule in @($acl.Access)) { [void]$acl.RemoveAccessRuleSpecific($existingRule) }
+      $inherit=if($kind -eq 'directory') {
+        [Security.AccessControl.InheritanceFlags]'ContainerInherit,ObjectInherit'
+      } else { [Security.AccessControl.InheritanceFlags]::None }
+      foreach($sid in @($current,$system,$admins)) {
+        $rule=New-Object Security.AccessControl.FileSystemAccessRule(
+          $sid,
+          [Security.AccessControl.FileSystemRights]::FullControl,
+          $inherit,
+          [Security.AccessControl.PropagationFlags]::None,
+          [Security.AccessControl.AccessControlType]::Allow
+        )
+        [void]$acl.AddAccessRule($rule)
+      }
+      (Get-Item -LiteralPath $path).SetAccessControl($acl)
+    }
+    $actual=Get-Acl -LiteralPath $path
+    $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($mode -ne 'verify-owner') {
+      if(-not $actual.AreAccessRulesProtected) { throw 'private ACL inheritance is invalid' }
+      $userFull=$false
+      foreach($rule in $actual.Access) {
+        $sid=$rule.IdentityReference.Translate([Security.Principal.SecurityIdentifier]).Value
+        if($rule.IsInherited -or $allowed -notcontains $sid -or $rule.AccessControlType -ne [Security.AccessControl.AccessControlType]::Allow) {
+          throw 'private ACL contains an unauthorized access rule'
+        }
+        if($sid -eq $current.Value -and (($rule.FileSystemRights -band [Security.AccessControl.FileSystemRights]::FullControl) -eq [Security.AccessControl.FileSystemRights]::FullControl)) { $userFull=$true }
+      }
+      if(-not $userFull) { throw 'private ACL does not grant the current user full control' }
+    }
+    [Console]::Out.WriteLine((@{id=$requestId;status='ok'} | ConvertTo-Json -Compress))
+  } catch {
+    [Console]::Out.WriteLine((@{id=$requestId;status='error'} | ConvertTo-Json -Compress))
+  }
+}`;
+    windowsPrivateAclBrokerInvocation = () => ({
       args: [
         "-NoLogo",
         "-NoProfile",
         "-NonInteractive",
         "-EncodedCommand",
-        Buffer.from(WINDOWS_PRIVATE_ACL_SCRIPT, "utf16le").toString("base64")
+        Buffer.from(WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, "utf16le").toString("base64")
       ],
       env: {
         NODE_ENV: process.env.NODE_ENV,
@@ -16688,49 +16708,169 @@ if(-not $userFull) { throw 'private ACL does not grant the current user full con
         PATHEXT: process.env.PATHEXT,
         PSModulePath: process.env.PSModulePath,
         TEMP: process.env.TEMP,
-        TMP: process.env.TMP,
-        VTX_PRIVATE_PATH_B64: Buffer.from(path, "utf8").toString("base64"),
-        VTX_PRIVATE_PATH_KIND: kind,
-        VTX_PRIVATE_ACL_MODE: mode
+        TMP: process.env.TMP
       }
     });
-    runWindowsPrivateAcl = async (path, kind, mode) => await new Promise((resolvePromise, reject) => {
-      const invocation = windowsPrivateAclInvocation(path, kind, mode);
-      const child = spawn("powershell.exe", [...invocation.args], {
-        env: invocation.env,
-        windowsHide: true,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-      const stdout = [];
-      const stderr = [];
-      let settled = false;
-      const timer = setTimeout(() => child.kill("SIGKILL"), 15e3);
-      child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
-      child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
-      const settle = (error48) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        if (error48) reject(error48);
-        else resolvePromise();
-      };
-      child.once("error", (error48) => settle(error48));
-      child.once("exit", (code) => {
-        const output3 = Buffer.concat(stdout).toString("utf8").trim();
-        if (code === 0 && output3 === "ok") {
-          settle();
+    WindowsPrivateAclBroker = class {
+      constructor(dependencies = {}) {
+        this.child = null;
+        this.requestSequence = 0;
+        this.queue = Promise.resolve();
+        this.pending = null;
+        this.outputBuffer = "";
+        this.idleTimer = null;
+        this.run = async (path, kind, mode) => {
+          const operation = this.queue.then(
+            () => this.dispatch(path, kind, mode),
+            () => this.dispatch(path, kind, mode)
+          );
+          this.queue = operation.then(() => void 0, () => void 0);
+          await operation;
+        };
+        this.requestTimeoutMs = dependencies.requestTimeoutMs ?? 15e3;
+        this.idleShutdownMs = dependencies.idleShutdownMs ?? 3e4;
+        this.spawnProcess = dependencies.spawnProcess ?? (() => {
+          const invocation = windowsPrivateAclBrokerInvocation();
+          return spawn("powershell.exe", [...invocation.args], {
+            env: invocation.env,
+            windowsHide: true,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+        });
+      }
+      scheduleIdleShutdown() {
+        if (this.idleTimer) clearTimeout(this.idleTimer);
+        this.idleTimer = setTimeout(() => {
+          this.idleTimer = null;
+          const child = this.child;
+          if (!child || this.pending) return;
+          this.child = null;
+          this.outputBuffer = "";
+          child.stdin.end();
+          const force = setTimeout(() => child.kill("SIGKILL"), 1e3);
+          force.unref();
+          child.once("exit", () => clearTimeout(force));
+        }, this.idleShutdownMs);
+        this.idleTimer.unref();
+      }
+      failChild(child, error48) {
+        if (this.child !== child) return;
+        this.child = null;
+        this.outputBuffer = "";
+        if (this.idleTimer) {
+          clearTimeout(this.idleTimer);
+          this.idleTimer = null;
+        }
+        const pending = this.pending;
+        this.pending = null;
+        if (pending) {
+          clearTimeout(pending.timer);
+          pending.reject(error48);
+        }
+        child.kill("SIGKILL");
+      }
+      acceptLine(child, line) {
+        const pending = this.pending;
+        if (!pending || !line || line.length > 4096) {
+          this.failChild(child, new Error("Windows private ACL broker returned malformed output."));
+          return;
+        }
+        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");
+          response = parsed;
+        } catch {
+          this.failChild(child, new Error("Windows private ACL broker returned malformed output."));
           return;
         }
-        const detail = Buffer.concat(stderr).toString("utf8").trim();
-        if (code === 3 && output3 === "missing" || /GetAcl_PathNotFound|Cannot find path .* because it does not exist/iu.test(detail)) {
+        this.pending = null;
+        clearTimeout(pending.timer);
+        if (response.status === "ok") {
+          pending.resolve();
+        } else if (response.status === "missing") {
           const error48 = new Error("Windows private path no longer exists.");
           error48.code = "ENOENT";
-          settle(error48);
-          return;
+          pending.reject(error48);
+        } else {
+          pending.reject(new Error(`Windows private ACL ${pending.mode} failed.`));
         }
-        settle(new Error(`Windows private ACL ${mode} failed${detail ? `: ${detail}` : "."}`));
-      });
-    });
+        this.scheduleIdleShutdown();
+      }
+      ensureChild() {
+        if (this.child && this.child.exitCode === null && !this.child.killed) return this.child;
+        const child = this.spawnProcess();
+        this.child = child;
+        this.outputBuffer = "";
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+          if (this.child !== child) return;
+          this.outputBuffer += chunk;
+          if (this.outputBuffer.length > 65536) {
+            this.failChild(child, new Error("Windows private ACL broker exceeded its output limit."));
+            return;
+          }
+          while (this.child === child) {
+            const newline = this.outputBuffer.indexOf("\n");
+            if (newline < 0) break;
+            const line = this.outputBuffer.slice(0, newline).trim();
+            this.outputBuffer = this.outputBuffer.slice(newline + 1);
+            this.acceptLine(child, line);
+          }
+        });
+        child.stderr.on("data", () => void 0);
+        child.once("error", () => {
+          this.failChild(child, new Error("Windows private ACL broker failed to start."));
+        });
+        child.once("exit", () => {
+          this.failChild(child, new Error("Windows private ACL broker exited before confirmation."));
+        });
+        child.unref();
+        for (const stream of [child.stdin, child.stdout, child.stderr]) {
+          stream.unref?.();
+        }
+        return child;
+      }
+      async dispatch(path, kind, mode) {
+        if (this.idleTimer) {
+          clearTimeout(this.idleTimer);
+          this.idleTimer = null;
+        }
+        const id2 = ++this.requestSequence;
+        const request = `${JSON.stringify({
+          id: id2,
+          kind,
+          mode,
+          path_b64: Buffer.from(path, "utf8").toString("base64")
+        })}
+`;
+        if (Buffer.byteLength(request, "utf8") > 65536) {
+          throw new Error("Windows private ACL broker request exceeds its input limit.");
+        }
+        const child = this.ensureChild();
+        await new Promise((resolvePromise, reject) => {
+          const timer = setTimeout(() => {
+            this.failChild(child, new Error("Windows private ACL broker request timed out."));
+          }, this.requestTimeoutMs);
+          this.pending = { id: id2, mode, resolve: resolvePromise, reject, timer };
+          child.stdin.write(request, "utf8", (error48) => {
+            if (error48) {
+              this.failChild(child, new Error("Windows private ACL broker request failed."));
+            }
+          });
+        });
+      }
+      close() {
+        if (this.idleTimer) clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+        const child = this.child;
+        this.child = null;
+        this.outputBuffer = "";
+        if (child) child.stdin.end();
+      }
+    };
+    defaultWindowsPrivateAclBroker = new WindowsPrivateAclBroker();
+    runWindowsPrivateAcl = async (path, kind, mode) => await defaultWindowsPrivateAclBroker.run(path, kind, mode);
     windowsAclCache = /* @__PURE__ */ new Map();
     windowsAclIdentity = async (path) => {
       const metadata = await lstat(path, { bigint: true });
@@ -29880,6 +30020,7 @@ var init_runner = __esm({
               now()
             )
           });
+          const recoveryQueue = [];
           const launchClaim = (claim, recovery, claimRequest) => {
             if (!recovery) {
               claimed += 1;
@@ -29901,6 +30042,7 @@ var init_runner = __esm({
               pendingClaimPromotions = Math.max(0, pendingClaimPromotions - 1);
             };
             if (claimRequest) pendingClaimPromotions += 1;
+            let retryRecovery = null;
             const promise2 = this.executeClaim({
               claim,
               attemptId,
@@ -29960,7 +30102,16 @@ var init_runner = __esm({
               onClaimPersisted: settleClaimPromotion
             }).then((outcome) => {
               if (outcome === "completed") completed += 1;
-              else failed += 1;
+              else if (outcome === "failed") failed += 1;
+              else {
+                const recovery2 = receipt.attempts[attemptId];
+                if (recovery2?.phase !== "claimed") {
+                  throw new InferenceHostRecoveryRequiredError(
+                    "The retryable pre-dispatch attempt receipt is unavailable."
+                  );
+                }
+                retryRecovery = recovery2;
+              }
             }).catch((error48) => {
               failed += 1;
               requestDrain(controlPlaneFatal(error48) ? "authority_lost" : "attempt_terminal_unconfirmed");
@@ -29968,6 +30119,14 @@ var init_runner = __esm({
               settleClaimPromotion();
               active.delete(attemptId);
               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", {
@@ -29986,7 +30145,6 @@ var init_runner = __esm({
             receipt = { ...receipt, attempts, updated_at: isoAt(now()) };
             await this.persistReceipt(receipt, now);
           };
-          const recoveryQueue = [];
           for (const recovery of Object.values({ ...receipt.attempts })) {
             if (recovery.phase === "terminal_pending") {
               try {
@@ -30362,7 +30520,17 @@ var init_runner = __esm({
               await removeAttempt();
               return "failed";
             }
-            throw error48;
+            if (signal.aborted) throw error48;
+            if (controlPlaneFatal(error48)) throw error48;
+            const remainingMs = Math.max(
+              MIN_SLEEP_MS,
+              attemptDeadlineAtMs - now() - MIN_CLAIM_START_WINDOW_MS
+            );
+            await options.sleep(
+              Math.min(remoteRetryAfterMs(error48, 1e3), remainingMs),
+              signal
+            );
+            return "retry_claimed";
           }
           assertStartResult(startRequest, startResult);
           await updateAttempt({ phase: "started" });
@@ -30426,6 +30594,11 @@ var init_runner = __esm({
           heartbeatFailure = error48;
           attemptAbort.abort();
         });
+        const stopHeartbeat = async () => {
+          heartbeatStopped = true;
+          attemptAbort.abort();
+          await heartbeatLoop;
+        };
         try {
           this.validateImmutableSelection(jobInput);
           const outputContract = parseOutputContract(jobInput);
@@ -30584,6 +30757,7 @@ var init_runner = __esm({
               { cause: error48 }
             );
           }
+          await stopHeartbeat();
           await removeAttempt();
           options.onAttemptOutcome?.({
             outcome: "completed",
@@ -30688,6 +30862,7 @@ var init_runner = __esm({
               { cause: terminalError }
             );
           }
+          await stopHeartbeat();
           await removeAttempt();
           options.onAttemptOutcome?.({
             outcome: "failed",
@@ -30701,10 +30876,8 @@ var init_runner = __esm({
           });
           return "failed";
         } finally {
-          heartbeatStopped = true;
-          attemptAbort.abort();
           signal.removeEventListener("abort", relayAbort);
-          await heartbeatLoop;
+          await stopHeartbeat();
         }
       }
       validateImmutableSelection(jobInput) {

package/package.json

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