@vtxmacro/cli 2026.8.36 → 2026.8.37

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.36",
+      package_version: "2026.8.37",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       platforms: {
@@ -29047,7 +29047,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, buildCodexInferenceAdvertisedModels, 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, UNBOUNDED_AVAILABLE_SLOTS, buildCodexInferenceAdvertisedModels, 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 init_runner = __esm({
   "lib/inference-host/runner.ts"() {
     "use strict";
@@ -29104,6 +29104,35 @@ var init_runner = __esm({
       }
       return models;
     };
+    summarizeInferenceHostRuntimeRecovery = (receipt) => {
+      const phaseCounts = {
+        claimed: 0,
+        started: 0,
+        dispatched: 0,
+        terminal_pending: 0
+      };
+      const terminalOperations = [];
+      for (const attempt of Object.values(receipt.attempts)) {
+        phaseCounts[attempt.phase] += 1;
+        const terminal = attempt.terminal_request;
+        if (!terminal) continue;
+        const failed = terminal.schema_version === "external_inference_job_fail_v1";
+        terminalOperations.push({
+          job_id: attempt.job_id,
+          attempt_id: attempt.attempt_id,
+          operation_kind: failed ? "fail" : "complete",
+          dispatch_outcome: terminal.outcome.dispatch_outcome,
+          failure_category: failed ? terminal.failure_category : null,
+          failure_code: failed ? terminal.failure_code : null,
+          retryable: failed ? terminal.retryable : null
+        });
+      }
+      terminalOperations.sort((left, right) => left.job_id.localeCompare(right.job_id) || left.attempt_id.localeCompare(right.attempt_id));
+      return {
+        phase_counts: phaseCounts,
+        terminal_operations: terminalOperations
+      };
+    };
     FileInferenceHostRuntimeReceiptStore = class {
       constructor(path, readPrivateFile = readInferencePrivateFile) {
         this.path = path;
@@ -29744,6 +29773,22 @@ var init_runner = __esm({
             } catch {
             }
           };
+          const emitTerminalRecoveryFailure = (recovery, error48) => {
+            const cause = error48 instanceof InferenceHostRunnerError && error48.code === "terminal_outcome_unconfirmed" && error48.cause ? error48.cause : error48;
+            const rawCode = cause instanceof ExternalInferenceMcpError || cause instanceof InferenceHostRunnerError || cause instanceof CodexAppServerError ? cause.code : "terminal_recovery_failed";
+            const terminal = recovery.terminal_request;
+            emitDiagnostic("terminal_recovery_failed", {
+              job_id: recovery.job_id,
+              attempt_id: recovery.attempt_id,
+              attempt_phase: recovery.phase,
+              terminal_operation: terminal?.schema_version === "external_inference_job_fail_v1" ? "fail" : "complete",
+              error_code: safeFailureCode(rawCode, "terminal_recovery_failed"),
+              retryable: retryableRemoteError(cause),
+              definitively_not_applied: Boolean(
+                cause && typeof cause === "object" && "definitivelyNotApplied" in cause && cause.definitivelyNotApplied === true
+              )
+            });
+          };
           const accountKey = inferenceCredentialAccountKey({
             issuer: localState.issuer,
             clientId: localState.client_id,
@@ -30009,17 +30054,6 @@ var init_runner = __esm({
           let nextClaimAt = Math.max(now(), providerRetryAtMs ?? 0);
           let pendingClaimPromotions = 0;
           let onceClaimed = false;
-          emitDiagnostic("runtime_started", {
-            max_concurrency: settings.maxConcurrency,
-            active_attempts: active.size,
-            provider_cooldown_reason: providerCooldownReason,
-            provider_cooldown_until: providerRetryAtMs === null ? null : isoAt(providerRetryAtMs),
-            provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
-              providerRateLimits,
-              providerRateLimitsObservedAtMs,
-              now()
-            )
-          });
           const recoveryQueue = [];
           const launchClaim = (claim, recovery, claimRequest) => {
             if (!recovery) {
@@ -30114,6 +30148,10 @@ var init_runner = __esm({
               }
             }).catch((error48) => {
               failed += 1;
+              const recovery2 = receipt.attempts[attemptId];
+              if (recovery2?.phase === "terminal_pending") {
+                emitTerminalRecoveryFailure(recovery2, error48);
+              }
               requestDrain(controlPlaneFatal(error48) ? "authority_lost" : "attempt_terminal_unconfirmed");
             }).finally(() => {
               settleClaimPromotion();
@@ -30169,6 +30207,7 @@ var init_runner = __esm({
                 await this.dependencies.codexAdapter.acknowledgeAttempt?.(recovery.attempt_id);
                 await removeRecoveredAttempt(recovery.attempt_id);
               } catch (error48) {
+                emitTerminalRecoveryFailure(recovery, error48);
                 requestDrain(controlPlaneFatal(error48) ? "authority_lost" : "attempt_terminal_unconfirmed");
                 break;
               }
@@ -30176,6 +30215,19 @@ var init_runner = __esm({
             }
             recoveryQueue.push(recovery);
           }
+          if (!drainRequested) {
+            emitDiagnostic("runtime_started", {
+              max_concurrency: settings.maxConcurrency,
+              active_attempts: active.size,
+              provider_cooldown_reason: providerCooldownReason,
+              provider_cooldown_until: providerRetryAtMs === null ? null : isoAt(providerRetryAtMs),
+              provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
+                providerRateLimits,
+                providerRateLimitsObservedAtMs,
+                now()
+              )
+            });
+          }
           while (!drainRequested && recoveryQueue.length > 0 && (settings.maxConcurrency === null || active.size < settings.maxConcurrency)) {
             const recovery = recoveryQueue.shift();
             launchClaim(recovery.claim, recovery);
@@ -30908,11 +30960,12 @@ var init_runner = __esm({
 
 // lib/inference-host/service.ts
 import { spawn as spawn5 } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { createWriteStream, readFileSync } from "node:fs";
 import { access as access3, chmod as chmod3, mkdir as mkdir3, readFile as readFile5, rm as rm4, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname4, join as join5, resolve as resolve4 } from "node:path";
-var SERVICE_NAME, SYSTEMD_UNIT, LAUNCHD_LABEL, SERVICE_COOPERATIVE_STOP_SECONDS, inferenceHostServiceChildEnvironment, isWindowsSubsystemForLinux, inferenceHostServiceManifestPath, inferenceHostServiceDesiredPath, inferenceHostServiceLogPath, xmlEscape, plistEscape, systemdQuote, defaultRunCommand, managerName, assertRuntimeEnvironment, withoutConcurrencyLimit, assertServicePath, assertWorker, assertManifest, assertDesiredState, readInferenceHostServiceManifest, readInferenceHostServiceDesired, readDesiredAcrossAtomicReplacement, writeDesired, runtimeEnvironment, serviceArguments, windowsOwnedCommandLine, vbScriptString, windowsServiceLauncher, windowsTaskXml, systemdUnit, launchAgentPlist, InferenceHostServiceManager, appendServiceLog, spawnServiceChild, runInferenceHostServiceSupervisor;
+var SERVICE_NAME, SYSTEMD_UNIT, LAUNCHD_LABEL, SERVICE_COOPERATIVE_STOP_SECONDS, INFERENCE_HOST_SERVICE_DRAIN_COMMAND, inferenceHostServiceChildEnvironment, isWindowsSubsystemForLinux, inferenceHostServiceManifestPath, inferenceHostServiceDesiredPath, inferenceHostServiceLogPath, inferenceHostServiceRuntimePath, xmlEscape, plistEscape, systemdQuote, defaultRunCommand, managerName, assertRuntimeEnvironment, withoutConcurrencyLimit, assertServicePath, manifestGeneration, assertWorker, assertManifest, assertServiceRuntimeState, assertDesiredState, readInferenceHostServiceManifest, readManifestAcrossAtomicReplacement, readInferenceHostServiceRuntime, readRuntimeAcrossAtomicReplacement, readInferenceHostServiceDesired, readDesiredAcrossAtomicReplacement, writeDesired, runtimeEnvironment, serviceArguments, windowsOwnedCommandLine, vbScriptString, windowsServiceLauncher, windowsTaskXml, systemdUnit, launchAgentPlist, sameWorker, sameServiceDefinition, sameWorkerSet, InferenceHostServiceManager, appendServiceLog, spawnInferenceHostServiceChild, runInferenceHostServiceSupervisor;
 var init_service = __esm({
   "lib/inference-host/service.ts"() {
     "use strict";
@@ -30921,6 +30974,7 @@ var init_service = __esm({
     SYSTEMD_UNIT = "vtx-inference-host.service";
     LAUNCHD_LABEL = "com.vtxmacro.inference-host";
     SERVICE_COOPERATIVE_STOP_SECONDS = 75;
+    INFERENCE_HOST_SERVICE_DRAIN_COMMAND = "vtx-inference-host-service-drain-v1";
     inferenceHostServiceChildEnvironment = (runtimeEnvironment2, inheritedEnvironment = process.env) => {
       const environment = { ...inheritedEnvironment };
       for (const key of Object.keys(environment)) {
@@ -30928,7 +30982,11 @@ var init_service = __esm({
           delete environment[key];
         }
       }
-      return { ...environment, ...runtimeEnvironment2 };
+      return {
+        ...environment,
+        ...runtimeEnvironment2,
+        VTX_INFERENCE_HOST_SERVICE_CHILD: "1"
+      };
     };
     isWindowsSubsystemForLinux = (env = process.env, kernelRelease) => Boolean(
       String(env.WSL_INTEROP || "").trim() || String(env.WSL_DISTRO_NAME || "").trim() || /microsoft/iu.test(kernelRelease ?? (() => {
@@ -30942,6 +31000,7 @@ var init_service = __esm({
     inferenceHostServiceManifestPath = (config2) => `${config2.supervisorStatePath}.service.json`;
     inferenceHostServiceDesiredPath = (config2) => `${config2.supervisorStatePath}.service-desired.json`;
     inferenceHostServiceLogPath = (config2) => `${config2.supervisorStatePath}.service.log`;
+    inferenceHostServiceRuntimePath = (config2) => `${config2.supervisorStatePath}.service-runtime.json`;
     xmlEscape = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
     plistEscape = xmlEscape;
     systemdQuote = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%")}"`;
@@ -30992,6 +31051,7 @@ var init_service = __esm({
       }
       return value;
     };
+    manifestGeneration = (value, installedAt) => typeof value === "string" && /^[A-Za-z0-9._:-]{1,160}$/u.test(value) ? value : `legacy:${installedAt}`;
     assertWorker = (value) => {
       if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error("Inference-host service worker is invalid.");
@@ -31032,6 +31092,7 @@ var init_service = __esm({
         });
         return {
           schema_version: "vtx_inference_service_v3",
+          generation: manifestGeneration(void 0, legacy.installed_at),
           installed_at: legacy.installed_at,
           executable: assertServicePath(legacy.executable),
           script: assertServicePath(legacy.script),
@@ -31065,6 +31126,7 @@ var init_service = __esm({
         }
         return {
           schema_version: "vtx_inference_service_v3",
+          generation: manifestGeneration(void 0, legacy.installed_at),
           installed_at: legacy.installed_at,
           executable: assertServicePath(legacy.executable),
           script: assertServicePath(legacy.script),
@@ -31082,6 +31144,34 @@ var init_service = __esm({
       if (new Set(workers.map((worker) => worker.instance_name)).size !== workers.length) {
         throw new Error("Inference-host service worker names must be unique.");
       }
+      return {
+        ...record2,
+        generation: manifestGeneration(record2.generation, String(record2.installed_at)),
+        workers
+      };
+    };
+    assertServiceRuntimeState = (value) => {
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Inference-host service runtime state is invalid.");
+      }
+      const record2 = value;
+      if (record2.schema_version !== "vtx_inference_service_runtime_v1" || typeof record2.manifest_generation !== "string" || record2.rejected_manifest_generation !== void 0 && record2.rejected_manifest_generation !== null && typeof record2.rejected_manifest_generation !== "string" || typeof record2.updated_at !== "string" || !Number.isFinite(Date.parse(record2.updated_at)) || !Array.isArray(record2.workers)) {
+        throw new Error("Inference-host service runtime state is invalid.");
+      }
+      const workers = record2.workers.map((worker) => {
+        if (!worker || typeof worker !== "object" || Array.isArray(worker)) {
+          throw new Error("Inference-host service worker runtime state is invalid.");
+        }
+        const item = worker;
+        if (typeof item.instance_name !== "string" || !["starting", "running", "failed", "draining"].includes(String(item.state)) || item.error !== null && typeof item.error !== "string") {
+          throw new Error("Inference-host service worker runtime state is invalid.");
+        }
+        return {
+          instance_name: item.instance_name,
+          state: item.state,
+          error: item.error
+        };
+      });
       return { ...record2, workers };
     };
     assertDesiredState = (value) => {
@@ -31104,6 +31194,42 @@ var init_service = __esm({
         throw error48;
       }
     };
+    readManifestAcrossAtomicReplacement = async (path) => {
+      for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+          return await readInferenceHostServiceManifest(path);
+        } catch (error48) {
+          if (!(error48 instanceof Error) || !error48.message.includes("changed while it was opened")) {
+            throw error48;
+          }
+        }
+      }
+      return await readInferenceHostServiceManifest(path);
+    };
+    readInferenceHostServiceRuntime = async (path) => {
+      const raw = await readInferencePrivateFile(path, "Inference-host service runtime state");
+      if (raw === null) return null;
+      try {
+        return assertServiceRuntimeState(JSON.parse(raw));
+      } catch (error48) {
+        if (error48 instanceof SyntaxError) {
+          throw new Error("Inference-host service runtime state is not valid JSON.");
+        }
+        throw error48;
+      }
+    };
+    readRuntimeAcrossAtomicReplacement = async (path) => {
+      for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+          return await readInferenceHostServiceRuntime(path);
+        } catch (error48) {
+          if (!(error48 instanceof Error) || !error48.message.includes("changed while it was opened")) {
+            throw error48;
+          }
+        }
+      }
+      return await readInferenceHostServiceRuntime(path);
+    };
     readInferenceHostServiceDesired = async (path) => {
       const raw = await readInferencePrivateFile(path, "Inference-host service desired state");
       if (raw === null) return false;
@@ -31226,6 +31352,9 @@ WantedBy=default.target
   <key>StandardErrorPath</key><string>${plistEscape(logPath)}</string>
 </dict></plist>
 `;
+    sameWorker = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+    sameServiceDefinition = (left, right) => left.executable === right.executable && left.script === right.script && left.log_path === right.log_path;
+    sameWorkerSet = (left, right) => left.workers.length === right.workers.length && left.workers.every((worker, index) => sameWorker(worker, right.workers[index]));
     InferenceHostServiceManager = class {
       constructor(config2, dependencies = {}) {
         this.config = config2;
@@ -31242,6 +31371,8 @@ WantedBy=default.target
         });
         this.stopWaitAttempts = dependencies.stopWaitAttempts ?? SERVICE_COOPERATIVE_STOP_SECONDS * 4;
         this.startWaitAttempts = dependencies.startWaitAttempts ?? 40;
+        this.reconcileWaitAttempts = dependencies.reconcileWaitAttempts ?? SERVICE_COOPERATIVE_STOP_SECONDS * 4;
+        this.confirmInitialReadiness = dependencies.confirmInitialReadiness ?? true;
         this.acquireProcessLock = dependencies.acquireProcessLock ?? acquireInferenceHostProcessLock;
         managerName(this.platform);
         if (dependencies.platform === void 0 && this.platform === "linux" && isWindowsSubsystemForLinux()) {
@@ -31259,6 +31390,9 @@ WantedBy=default.target
       logPath() {
         return inferenceHostServiceLogPath(this.config);
       }
+      runtimePath() {
+        return inferenceHostServiceRuntimePath(this.config);
+      }
       controlLockPath() {
         return `${this.config.supervisorProcessLockPath}.service-control`;
       }
@@ -31344,7 +31478,77 @@ WantedBy=default.target
         }
         throw new Error("Background service did not reach an active state within 10 seconds.");
       }
-      async registerManifestUnlocked(manifest, desiredRunning) {
+      async restoreRunningSupervisor(manifest) {
+        const restoredManifest = assertManifest({
+          ...manifest,
+          generation: randomUUID(),
+          installed_at: this.now().toISOString()
+        });
+        await writeAtomicInferencePrivateFile(
+          this.manifestPath(),
+          `${JSON.stringify(restoredManifest, null, 2)}
+`
+        );
+        await writeDesired(this.desiredPath(), true, this.now());
+        const result2 = await this.managerCommand("start");
+        if (result2.exitCode !== 0 && !/already running|in progress|already loaded|service is already loaded/iu.test(`${result2.stdout}
+${result2.stderr}`)) {
+          throw new Error(`Background service restoration failed: ${result2.stderr.trim()}`);
+        }
+        if (this.platform === "darwin") {
+          const domain2 = `gui/${typeof process.getuid === "function" ? process.getuid() : 0}`;
+          const kicked = await this.runCommand("launchctl", [
+            "kickstart",
+            `${domain2}/${LAUNCHD_LABEL}`
+          ]);
+          if (kicked.exitCode !== 0) {
+            throw new Error(`Background service restoration kickstart failed: ${kicked.stderr.trim()}`);
+          }
+        }
+        await this.waitForManagerActive();
+        if (!this.confirmInitialReadiness) return await this.status();
+        const runtime = await this.waitForManifestApplied(restoredManifest);
+        return await this.status(runtime);
+      }
+      async waitForManifestApplied(manifest, targetInstanceName) {
+        let consecutiveReadyObservations = 0;
+        for (let attempt = 0; attempt < this.reconcileWaitAttempts; attempt += 1) {
+          let runtime = null;
+          try {
+            runtime = await readRuntimeAcrossAtomicReplacement(this.runtimePath());
+          } catch (error48) {
+            if (!(error48 instanceof Error) || !error48.message.includes("changed while it was opened")) {
+              throw error48;
+            }
+          }
+          if (runtime?.manifest_generation === manifest.generation) {
+            const configuredNames = manifest.workers.map((worker) => worker.instance_name).sort();
+            const runtimeNames = runtime.workers.map((worker) => worker.instance_name).sort();
+            const exactWorkerSet = JSON.stringify(configuredNames) === JSON.stringify(runtimeNames);
+            const target = targetInstanceName ? runtime.workers.find((worker) => worker.instance_name === targetInstanceName) : null;
+            const allReady = runtime.workers.every((worker) => worker.state === "running");
+            if (exactWorkerSet && (targetInstanceName ? target?.state === "running" : allReady)) {
+              consecutiveReadyObservations += 1;
+              if (consecutiveReadyObservations >= 2) return runtime;
+            } else {
+              consecutiveReadyObservations = 0;
+            }
+            if (exactWorkerSet && target?.state === "failed") {
+              throw new Error(`Inference-host worker ${targetInstanceName} failed before readiness.`);
+            }
+          } else {
+            consecutiveReadyObservations = 0;
+          }
+          if (runtime?.rejected_manifest_generation === manifest.generation) {
+            throw new Error("Inference-host supervisor rejected the updated worker set.");
+          }
+          await this.sleep(250);
+        }
+        throw new Error(
+          targetInstanceName ? `Inference-host supervisor did not confirm worker ${targetInstanceName} ready before timeout.` : "Inference-host supervisor did not confirm the updated worker set before timeout."
+        );
+      }
+      async registerManifestUnlocked(manifest, desiredRunning, targetInstanceName) {
         const args = serviceArguments(manifest.script, this.manifestPath());
         const definition = this.platform === "win32" ? windowsTaskXml(this.windowsLauncherPath(), this.windowsDirectory, this.username) : this.platform === "darwin" ? launchAgentPlist(manifest.executable, args, manifest.log_path) : systemdUnit(manifest.executable, args);
         let managerInstallAttempted = false;
@@ -31380,6 +31584,9 @@ ${started.stderr}`)) {
               throw new Error(`Background service start failed: ${started.stderr.trim()}`);
             }
             await this.waitForManagerActive();
+            if (this.confirmInitialReadiness) {
+              await this.waitForManifestApplied(manifest, targetInstanceName);
+            }
           }
           return await this.status();
         } catch (error48) {
@@ -31404,22 +31611,80 @@ ${cleanup.stderr}`)) {
           }
           await rm4(this.manifestPath(), { force: true }).catch(() => void 0);
           await rm4(this.desiredPath(), { force: true }).catch(() => void 0);
+          await rm4(this.runtimePath(), { force: true }).catch(() => void 0);
           if (this.platform === "linux") {
             await this.runCommand("systemctl", ["--user", "daemon-reload"]).catch(() => void 0);
           }
           throw error48;
         }
       }
-      async replaceManifestUnlocked(next, desiredRunning) {
+      async replaceManifestUnlocked(next, desiredRunning, targetInstanceName) {
         const previous = await readInferenceHostServiceManifest(this.manifestPath());
         const previousDesired = previous ? await readInferenceHostServiceDesired(this.desiredPath()) : false;
-        if (previous) await this.uninstallUnlocked();
+        if (previous && sameServiceDefinition(previous, next) && sameWorkerSet(previous, next) && previousDesired === desiredRunning) {
+          return await this.status();
+        }
+        if (previous && previousDesired && desiredRunning && sameServiceDefinition(previous, next)) {
+          const current = await this.status();
+          const runtime = await readRuntimeAcrossAtomicReplacement(this.runtimePath()).catch(() => null);
+          if (current.manager_active && runtime?.manifest_generation === previous.generation) {
+            await writeAtomicInferencePrivateFile(
+              this.manifestPath(),
+              `${JSON.stringify(next, null, 2)}
+`
+            );
+            if (!this.confirmInitialReadiness) return await this.status();
+            try {
+              const confirmedRuntime = await this.waitForManifestApplied(next, targetInstanceName);
+              return await this.status(confirmedRuntime);
+            } catch (error48) {
+              await writeAtomicInferencePrivateFile(
+                this.manifestPath(),
+                `${JSON.stringify(previous, null, 2)}
+`
+              );
+              try {
+                await this.waitForManifestApplied(
+                  previous,
+                  targetInstanceName && previous.workers.some(
+                    (worker) => worker.instance_name === targetInstanceName
+                  ) ? targetInstanceName : void 0
+                );
+              } catch (rollbackError) {
+                throw new Error(
+                  "Inference-host live reconfiguration failed and rollback was not confirmed.",
+                  { cause: new AggregateError([error48, rollbackError]) }
+                );
+              }
+              throw new Error(
+                "Inference-host live reconfiguration failed; the previous worker set was restored.",
+                { cause: error48 }
+              );
+            }
+          }
+        }
+        if (previous) {
+          try {
+            await this.uninstallUnlocked();
+          } catch (error48) {
+            throw new Error(
+              "Inference-host service reconfiguration could not stop the previous supervisor; its desired state was restored.",
+              { cause: error48 }
+            );
+          }
+        }
         try {
-          return await this.registerManifestUnlocked(next, desiredRunning);
+          return await this.registerManifestUnlocked(next, desiredRunning, targetInstanceName);
         } catch (error48) {
           if (!previous) throw error48;
           try {
-            await this.registerManifestUnlocked(previous, previousDesired);
+            await this.registerManifestUnlocked(
+              previous,
+              previousDesired,
+              targetInstanceName && previous.workers.some(
+                (worker) => worker.instance_name === targetInstanceName
+              ) ? targetInstanceName : void 0
+            );
           } catch (rollbackError) {
             throw new Error(
               "Inference-host service reconfiguration failed and the previous supervisor could not be restored.",
@@ -31476,6 +31741,7 @@ ${cleanup.stderr}`)) {
         ].sort((left, right) => left.instance_name.localeCompare(right.instance_name));
         const manifest = assertManifest({
           schema_version: "vtx_inference_service_v3",
+          generation: randomUUID(),
           installed_at: this.now().toISOString(),
           executable: this.executable,
           script: this.script,
@@ -31484,7 +31750,8 @@ ${cleanup.stderr}`)) {
         });
         return await this.replaceManifestUnlocked(
           manifest,
-          options.startImmediately !== false
+          options.startImmediately !== false,
+          this.config.instanceName
         );
       }
       async start() {
@@ -31516,41 +31783,56 @@ ${result2.stderr}`)) {
         if (!manifest) {
           throw new Error("Inference-host service is not installed.");
         }
+        const restoreOnFailure = await readInferenceHostServiceDesired(this.desiredPath());
         await writeDesired(this.desiredPath(), false, this.now());
-        const serviceLockPath = `${this.config.supervisorProcessLockPath}.service`;
-        let serviceReleased = false;
-        for (let attempt = 0; attempt < this.stopWaitAttempts; attempt += 1) {
-          try {
-            const probe = await this.acquireProcessLock(serviceLockPath);
-            await probe.release();
-            serviceReleased = true;
-            break;
-          } catch (error48) {
-            if (error48 instanceof Error && error48.message.includes("Another inference host process already owns")) {
-              await this.sleep(250);
-              continue;
+        try {
+          const serviceLockPath = `${this.config.supervisorProcessLockPath}.service`;
+          let serviceReleased = false;
+          for (let attempt = 0; attempt < this.stopWaitAttempts; attempt += 1) {
+            try {
+              const probe = await this.acquireProcessLock(serviceLockPath);
+              await probe.release();
+              serviceReleased = true;
+              break;
+            } catch (error48) {
+              if (error48 instanceof Error && error48.message.includes("Another inference host process already owns")) {
+                await this.sleep(250);
+                continue;
+              }
+              throw error48;
             }
-            throw error48;
           }
-        }
-        if (!serviceReleased) {
-          throw new Error(
-            `Inference-host workers did not stop cooperatively within ${SERVICE_COOPERATIVE_STOP_SECONDS} seconds; refusing forced termination while cleanup may be pending.`
-          );
-        }
-        const result2 = await this.managerCommand("stop");
-        if (result2.exitCode !== 0 && !/not running|not found|does not exist|not loaded|cannot find|no such process/iu.test(`${result2.stdout}
+          if (!serviceReleased) {
+            throw new Error(
+              `Inference-host workers did not stop cooperatively within ${SERVICE_COOPERATIVE_STOP_SECONDS} seconds; refusing forced termination while cleanup may be pending.`
+            );
+          }
+          const result2 = await this.managerCommand("stop");
+          if (result2.exitCode !== 0 && !/not running|not found|does not exist|not loaded|cannot find|no such process/iu.test(`${result2.stdout}
 ${result2.stderr}`)) {
-          throw new Error(`Background service stop failed: ${result2.stderr.trim()}`);
-        }
-        const status = await this.status();
-        if (status.manager_active) {
-          throw new Error("Background service manager still reports the service active after stop.");
+            throw new Error(`Background service stop failed: ${result2.stderr.trim()}`);
+          }
+          const status = await this.status();
+          if (status.manager_active) {
+            throw new Error("Background service manager still reports the service active after stop.");
+          }
+          return status;
+        } catch (error48) {
+          if (!restoreOnFailure) throw error48;
+          try {
+            await this.restoreRunningSupervisor(manifest);
+          } catch (restoreError) {
+            throw new Error(
+              "Inference-host stop failed and the previous supervisor could not be restored.",
+              { cause: new AggregateError([error48, restoreError]) }
+            );
+          }
+          throw error48;
         }
-        return status;
       }
-      async status() {
+      async status(confirmedRuntime) {
         const manifest = await readInferenceHostServiceManifest(this.manifestPath());
+        const runtime = confirmedRuntime?.manifest_generation === manifest?.generation ? confirmedRuntime : await readRuntimeAcrossAtomicReplacement(this.runtimePath()).catch(() => null);
         const desired = await readInferenceHostServiceDesired(this.desiredPath());
         const result2 = await this.managerCommand("status");
         const output3 = result2.stdout.trim();
@@ -31568,7 +31850,8 @@ ${result2.stderr}`)) {
             display_name: worker.display_name,
             max_concurrency: worker.max_concurrency,
             authenticated_account_email: worker.authenticated_account_email,
-            authenticated_account_plan: worker.authenticated_account_plan
+            authenticated_account_plan: worker.authenticated_account_plan,
+            runtime_state: runtime?.manifest_generation === manifest.generation && managerActive ? runtime.workers.find((item) => item.instance_name === worker.instance_name)?.state ?? "unknown" : "unknown"
           })) ?? []
         };
       }
@@ -31606,6 +31889,7 @@ ${result2.stderr}`)) {
           if (remaining.length === 0) return await this.uninstallUnlocked();
           return await this.replaceManifestUnlocked({
             ...manifest,
+            generation: randomUUID(),
             installed_at: this.now().toISOString(),
             workers: remaining
           }, await readInferenceHostServiceDesired(this.desiredPath()));
@@ -31633,6 +31917,7 @@ ${result2.stderr}`)) {
         if (this.platform === "linux") await this.runCommand("systemctl", ["--user", "daemon-reload"]);
         await rm4(this.manifestPath(), { force: true });
         await rm4(this.desiredPath(), { force: true });
+        await rm4(this.runtimePath(), { force: true });
         return {
           installed: false,
           desired_running: false,
@@ -31654,7 +31939,8 @@ ${result2.stderr}`)) {
 `, resolvePromise);
       });
     };
-    spawnServiceChild = async (manifest, worker, signal) => {
+    spawnInferenceHostServiceChild = async (manifest, worker, signal, onReady = () => {
+    }) => {
       const args = [
         manifest.script,
         "inference-host",
@@ -31667,6 +31953,8 @@ ${result2.stderr}`)) {
       const log = createWriteStream(manifest.log_path, { flags: "a", mode: 384 });
       return await new Promise((resolvePromise, reject) => {
         let stdout = "";
+        let cooperativeStopTimedOut = false;
+        let cooperativeStopTimer = null;
         const pending = { stdout: "", stderr: "" };
         const writeTaggedOutput = (stream, text, flush = false) => {
           const lines = `${pending[stream]}${text}`.split(/\r?\n/u);
@@ -31679,6 +31967,7 @@ ${result2.stderr}`)) {
             try {
               const parsed = JSON.parse(line);
               if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                if (parsed.event === "runtime_started") onReady();
                 log.write(`${JSON.stringify({
                   ...parsed,
                   instance_name: worker.instance_name
@@ -31701,7 +31990,7 @@ ${result2.stderr}`)) {
         const child = spawn5(manifest.executable, args, {
           env: inferenceHostServiceChildEnvironment(worker.runtime_environment),
           windowsHide: true,
-          stdio: ["ignore", "pipe", "pipe"]
+          stdio: ["pipe", "pipe", "pipe"]
         });
         child.stdout.on("data", (chunk) => {
           const text = chunk.toString("utf8");
@@ -31709,10 +31998,22 @@ ${result2.stderr}`)) {
           stdout = `${stdout}${text}`.slice(-65536);
         });
         child.stderr.on("data", (chunk) => writeTaggedOutput("stderr", chunk.toString("utf8")));
-        const onAbort = () => child.kill("SIGTERM");
-        signal.addEventListener("abort", onAbort, { once: true });
+        child.stdin.on("error", () => {
+        });
+        const onAbort = () => {
+          child.stdin.end(`${INFERENCE_HOST_SERVICE_DRAIN_COMMAND}
+`);
+          cooperativeStopTimer = setTimeout(() => {
+            cooperativeStopTimedOut = true;
+            child.kill("SIGKILL");
+          }, SERVICE_COOPERATIVE_STOP_SECONDS * 1e3);
+          cooperativeStopTimer.unref();
+        };
+        if (signal.aborted) onAbort();
+        else signal.addEventListener("abort", onAbort, { once: true });
         child.once("error", (error48) => {
           signal.removeEventListener("abort", onAbort);
+          if (cooperativeStopTimer) clearTimeout(cooperativeStopTimer);
           writeTaggedOutput("stdout", "", true);
           writeTaggedOutput("stderr", "", true);
           log.end();
@@ -31720,6 +32021,7 @@ ${result2.stderr}`)) {
         });
         child.once("exit", (code) => {
           signal.removeEventListener("abort", onAbort);
+          if (cooperativeStopTimer) clearTimeout(cooperativeStopTimer);
           writeTaggedOutput("stdout", "", true);
           writeTaggedOutput("stderr", "", true);
           log.end();
@@ -31739,81 +32041,231 @@ ${result2.stderr}`)) {
           resolvePromise({
             exitCode: code ?? 1,
             uptimeMs: Date.now() - startedAt,
-            drainReason
+            drainReason,
+            cooperativeStopTimedOut
           });
         });
       });
     };
     runInferenceHostServiceSupervisor = async (manifestPath, options = {}) => {
-      const manifest = await readInferenceHostServiceManifest(manifestPath);
-      if (!manifest) throw new Error("Inference-host service manifest is missing.");
+      const initialManifest = await readInferenceHostServiceManifest(manifestPath);
+      if (!initialManifest) throw new Error("Inference-host service manifest is missing.");
       const desiredPath = manifestPath.replace(/\.service\.json$/u, ".service-desired.json");
+      const runtimePath = manifestPath.replace(/\.service\.json$/u, ".service-runtime.json");
       const signal = options.signal ?? new AbortController().signal;
       const sleep4 = options.sleep ?? (async (milliseconds) => {
         await new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
       });
-      const launch = options.runWorker ?? options.spawnChild ?? spawnServiceChild;
-      await appendServiceLog(manifest.log_path, "service_supervisor_started", {
+      const launch = options.runWorker ?? options.spawnChild ?? spawnInferenceHostServiceChild;
+      await appendServiceLog(initialManifest.log_path, "service_supervisor_started", {
         adapter: "codex",
-        instances: manifest.workers.map((worker) => worker.instance_name)
+        instances: initialManifest.workers.map((worker) => worker.instance_name)
       });
-      const superviseWorker = async (worker) => {
+      const workers = /* @__PURE__ */ new Map();
+      let appliedManifest = initialManifest;
+      let rejectedManifestGeneration = null;
+      let runtimeWriteChain = Promise.resolve();
+      const persistRuntime = async () => {
+        const state = {
+          schema_version: "vtx_inference_service_runtime_v1",
+          manifest_generation: appliedManifest.generation,
+          rejected_manifest_generation: rejectedManifestGeneration,
+          updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          workers: [...workers.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([instanceName, record2]) => ({
+            instance_name: instanceName,
+            state: record2.state,
+            error: record2.error
+          }))
+        };
+        runtimeWriteChain = runtimeWriteChain.then(async () => {
+          await writeAtomicInferencePrivateFile(runtimePath, `${JSON.stringify(state, null, 2)}
+`);
+        });
+        await runtimeWriteChain;
+      };
+      const updateRecord = async (record2, state, error48 = null) => {
+        if (workers.get(record2.worker.instance_name) !== record2) return;
+        record2.state = state;
+        record2.error = error48;
+        await persistRuntime();
+      };
+      const waitRetry = async (milliseconds, controller) => {
+        if (controller.signal.aborted || signal.aborted) return;
+        let finishAbort;
+        const aborted2 = new Promise((resolvePromise) => {
+          finishAbort = resolvePromise;
+        });
+        controller.signal.addEventListener("abort", finishAbort, { once: true });
+        signal.addEventListener("abort", finishAbort, { once: true });
+        try {
+          await Promise.race([sleep4(milliseconds), aborted2]);
+        } finally {
+          controller.signal.removeEventListener("abort", finishAbort);
+          signal.removeEventListener("abort", finishAbort);
+        }
+      };
+      const superviseWorker = async (serviceManifest, record2) => {
         let failures = 0;
-        while (!signal.aborted && await readDesiredAcrossAtomicReplacement(desiredPath)) {
+        while (!signal.aborted && !record2.controller.signal.aborted && await readDesiredAcrossAtomicReplacement(desiredPath)) {
           try {
-            const workerController = new AbortController();
-            const forwardAbort = () => workerController.abort();
+            await updateRecord(record2, "starting");
+            const attemptController = new AbortController();
+            const forwardAbort = () => attemptController.abort();
             signal.addEventListener("abort", forwardAbort, { once: true });
-            let workerComplete = false;
-            let monitorError = null;
-            const desiredMonitor = (async () => {
-              while (!workerComplete && !workerController.signal.aborted) {
-                await sleep4(500);
-                if (!await readDesiredAcrossAtomicReplacement(desiredPath)) {
-                  workerController.abort();
-                  break;
-                }
-              }
-            })().catch((error48) => {
-              monitorError = error48;
-              workerController.abort();
-            });
+            record2.controller.signal.addEventListener("abort", forwardAbort, { once: true });
             let result2;
+            let launchSettled = false;
+            let readinessTask = Promise.resolve();
+            let readinessSignalled = false;
             try {
-              result2 = await launch(manifest, worker, workerController.signal);
+              result2 = await launch(
+                serviceManifest,
+                record2.worker,
+                attemptController.signal,
+                () => {
+                  if (readinessSignalled) return;
+                  readinessSignalled = true;
+                  readinessTask = (async () => {
+                    await sleep4(500);
+                    if (!launchSettled && !attemptController.signal.aborted && !record2.controller.signal.aborted && !signal.aborted) {
+                      await updateRecord(record2, "running");
+                    }
+                  })();
+                }
+              );
             } finally {
-              workerComplete = true;
-              workerController.abort();
+              launchSettled = true;
+              attemptController.abort();
               signal.removeEventListener("abort", forwardAbort);
-              await desiredMonitor;
+              record2.controller.signal.removeEventListener("abort", forwardAbort);
+              await readinessTask;
             }
-            if (monitorError) throw monitorError;
-            if (signal.aborted || !await readDesiredAcrossAtomicReplacement(desiredPath)) break;
+            if (result2.cooperativeStopTimedOut) {
+              await updateRecord(record2, "failed", "worker_cooperative_stop_timeout");
+              await appendServiceLog(serviceManifest.log_path, "worker_cooperative_stop_timeout", {
+                instance_name: record2.worker.instance_name
+              });
+              throw new Error("worker_cooperative_stop_timeout");
+            }
+            if (signal.aborted || record2.controller.signal.aborted || !await readDesiredAcrossAtomicReplacement(desiredPath)) break;
             failures = result2.uptimeMs >= 6e4 ? 0 : failures + 1;
             const retryAfterMs = Math.min(1e3 * 2 ** Math.min(failures, 5), 3e4);
-            await appendServiceLog(manifest.log_path, "worker_exited", {
-              instance_name: worker.instance_name,
+            await updateRecord(record2, "failed", "worker_exited");
+            await appendServiceLog(serviceManifest.log_path, "worker_exited", {
+              instance_name: record2.worker.instance_name,
               exit_code: result2.exitCode,
               uptime_ms: result2.uptimeMs,
               drain_reason: result2.drainReason ?? null,
               retry_after_ms: retryAfterMs
             });
-            await sleep4(retryAfterMs);
+            await waitRetry(retryAfterMs, record2.controller);
           } catch (error48) {
-            if (signal.aborted) break;
+            if (error48 instanceof Error && error48.message === "worker_cooperative_stop_timeout") throw error48;
+            if (signal.aborted || record2.controller.signal.aborted) break;
             failures += 1;
             const retryAfterMs = Math.min(1e3 * 2 ** Math.min(failures, 5), 3e4);
-            await appendServiceLog(manifest.log_path, "worker_launch_failed", {
-              instance_name: worker.instance_name,
+            await updateRecord(record2, "failed", "worker_launch_failed");
+            await appendServiceLog(serviceManifest.log_path, "worker_launch_failed", {
+              instance_name: record2.worker.instance_name,
               error: error48 instanceof Error ? error48.message : "unknown",
               retry_after_ms: retryAfterMs
             });
-            await sleep4(retryAfterMs);
+            await waitRetry(retryAfterMs, record2.controller);
+          }
+        }
+      };
+      const startWorker = (serviceManifest, worker) => {
+        const record2 = {
+          worker,
+          controller: new AbortController(),
+          promise: Promise.resolve(),
+          state: "starting",
+          error: null
+        };
+        workers.set(worker.instance_name, record2);
+        record2.promise = superviseWorker(serviceManifest, record2);
+      };
+      const reconcile = async (next) => {
+        const nextByName = new Map(next.workers.map((worker) => [worker.instance_name, worker]));
+        const retiring = [...workers.values()].filter((record2) => {
+          const nextWorker = nextByName.get(record2.worker.instance_name);
+          return !nextWorker || !sameWorker(record2.worker, nextWorker);
+        });
+        for (const record2 of retiring) {
+          await updateRecord(record2, "draining");
+          record2.controller.abort();
+        }
+        const settled = await Promise.allSettled(retiring.map((record2) => record2.promise));
+        const failedDrain = settled.find(
+          (result2) => result2.status === "rejected"
+        );
+        if (failedDrain) {
+          for (const record2 of retiring) workers.delete(record2.worker.instance_name);
+          for (const worker of appliedManifest.workers) {
+            if (!workers.has(worker.instance_name)) startWorker(appliedManifest, worker);
+          }
+          rejectedManifestGeneration = next.generation;
+          await persistRuntime();
+          await appendServiceLog(appliedManifest.log_path, "service_manifest_rejected", {
+            manifest_generation: next.generation,
+            reason: failedDrain.reason instanceof Error ? failedDrain.reason.message : "worker_cooperative_stop_failed"
+          });
+          return;
+        }
+        for (const record2 of retiring) workers.delete(record2.worker.instance_name);
+        for (const worker of next.workers) {
+          if (!workers.has(worker.instance_name)) startWorker(next, worker);
+        }
+        appliedManifest = next;
+        rejectedManifestGeneration = null;
+        await persistRuntime();
+        await appendServiceLog(next.log_path, "service_manifest_applied", {
+          manifest_generation: next.generation,
+          instances: next.workers.map((worker) => worker.instance_name)
+        });
+      };
+      const drainWorkers = async () => {
+        const draining = [...workers.values()];
+        for (const record2 of draining) {
+          await updateRecord(record2, "draining");
+          record2.controller.abort();
+        }
+        const settled = await Promise.allSettled(draining.map((record2) => record2.promise));
+        const failedDrain = settled.find(
+          (result2) => result2.status === "rejected"
+        );
+        if (failedDrain) throw failedDrain.reason;
+        for (const record2 of draining) {
+          if (workers.get(record2.worker.instance_name) === record2) {
+            workers.delete(record2.worker.instance_name);
           }
         }
+        await persistRuntime();
       };
-      await Promise.all(manifest.workers.map(superviseWorker));
-      await appendServiceLog(manifest.log_path, "service_supervisor_stopped");
+      await reconcile(initialManifest);
+      try {
+        while (!signal.aborted) {
+          while (!signal.aborted && await readDesiredAcrossAtomicReplacement(desiredPath)) {
+            const next = await readManifestAcrossAtomicReplacement(manifestPath);
+            if (!next) throw new Error("Inference-host service manifest is missing.");
+            if (next.generation !== appliedManifest.generation && next.generation !== rejectedManifestGeneration) await reconcile(next);
+            await sleep4(250);
+          }
+          await drainWorkers();
+          if (signal.aborted || !await readDesiredAcrossAtomicReplacement(desiredPath)) break;
+          const restored = await readManifestAcrossAtomicReplacement(manifestPath);
+          if (!restored) throw new Error("Inference-host service manifest is missing.");
+          await reconcile(restored);
+          await appendServiceLog(restored.log_path, "service_desired_state_restored", {
+            manifest_generation: restored.generation,
+            instances: restored.workers.map((worker) => worker.instance_name)
+          });
+        }
+      } finally {
+        await drainWorkers();
+        await runtimeWriteChain;
+        await appendServiceLog(appliedManifest.log_path, "service_supervisor_stopped");
+      }
     };
   }
 });
@@ -31822,9 +32274,10 @@ ${result2.stderr}`)) {
 var cli_exports = {};
 __export(cli_exports, {
   INFERENCE_HOST_CLI_VERSION: () => INFERENCE_HOST_CLI_VERSION,
+  registerInferenceHostServiceControlInput: () => registerInferenceHostServiceControlInput,
   runInferenceHostCli: () => runInferenceHostCli
 });
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { spawn as spawn6 } from "node:child_process";
 import { lstat as lstat4, realpath as realpath4, rm as rm5 } from "node:fs/promises";
 import { join as join6, resolve as resolve5 } from "node:path";
@@ -31902,7 +32355,7 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
     };
   }
 }
-var INFERENCE_HOST_CLI_VERSION, runtimeReceiptPath, codexRecoveryPath, codexGuardianReceiptRoot, revocationCheckpointPath, foregroundHostLockPath, AGENT_HEARTBEAT_INTERVAL_MS, AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS, retryableAgentHeartbeatError, assertRevocationCheckpoint, readRevocationCheckpoint, writeRevocationCheckpoint, clearRevocationCheckpoint, render, INFERENCE_HOST_HELP, parseHostConcurrency, parseInferenceHostArgs, defaultOpenBrowser, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, login, codexLogin, codexLogout, localStatus, doctor, cleanupLogin, runHost, defaultReadStdin, parseAgentStdin, agentOperationId, agentSession, agentConnect, agentRun, agentNext, agentComplete, agentFail, withAgentCommandLock, serviceCommand, hasExplicitCredentialStoreConfiguration, commandUsesInstalledServiceCredentials, resolveInferenceHostCommandConfig;
+var INFERENCE_HOST_CLI_VERSION, runtimeReceiptPath, codexRecoveryPath, codexGuardianReceiptRoot, revocationCheckpointPath, foregroundHostLockPath, AGENT_HEARTBEAT_INTERVAL_MS, AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS, retryableAgentHeartbeatError, assertRevocationCheckpoint, readRevocationCheckpoint, writeRevocationCheckpoint, clearRevocationCheckpoint, render, INFERENCE_HOST_HELP, parseHostConcurrency, parseInferenceHostArgs, defaultOpenBrowser, registerInferenceHostServiceControlInput, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, login, codexLogin, codexLogout, localStatus, doctor, cleanupLogin, runHost, defaultReadStdin, parseAgentStdin, agentOperationId, agentSession, agentConnect, agentRun, agentNext, agentComplete, agentFail, withAgentCommandLock, serviceCommand, hasExplicitCredentialStoreConfiguration, commandUsesInstalledServiceCredentials, resolveInferenceHostCommandConfig;
 var init_cli = __esm({
   "lib/inference-host/cli.ts"() {
     "use strict";
@@ -32147,14 +32600,35 @@ Durable service:
       });
       child.unref();
     };
+    registerInferenceHostServiceControlInput = (input, abort) => {
+      let pendingControlInput = "";
+      const onControlInput = (chunk) => {
+        pendingControlInput = `${pendingControlInput}${chunk.toString()}`.slice(-4096);
+        const lines = pendingControlInput.split(/\r?\n/u);
+        pendingControlInput = lines.pop() ?? "";
+        if (lines.some((line) => line === INFERENCE_HOST_SERVICE_DRAIN_COMMAND)) {
+          abort();
+        }
+      };
+      input.on("data", onControlInput);
+      input.resume();
+      return () => {
+        input.off("data", onControlInput);
+        input.pause();
+      };
+    };
     defaultRegisterLifecycleSignalHandlers = (abort) => {
       const onSigint = () => abort("SIGINT");
       const onSigterm = () => abort("SIGTERM");
       process.on("SIGINT", onSigint);
       process.on("SIGTERM", onSigterm);
+      const serviceChild = process.env.VTX_INFERENCE_HOST_SERVICE_CHILD === "1";
+      const unregisterControlInput = serviceChild ? registerInferenceHostServiceControlInput(process.stdin, onSigterm) : () => {
+      };
       return () => {
         process.off("SIGINT", onSigint);
         process.off("SIGTERM", onSigterm);
+        unregisterControlInput();
       };
     };
     lifecycleCancellation = (dependencies) => {
@@ -32321,7 +32795,7 @@ Durable service:
           throw new Error("Inference host credential recovery is required before login.");
         }
         const keyPair = generateExternalInferenceEnvelopeKeyPair();
-        const hostId = randomUUID();
+        const hostId = randomUUID2();
         const beginLogin = dependencies.beginLogin ?? beginInferenceOAuthLogin;
         const pending = await beginLogin({
           apiUrl: config2.apiUrl,
@@ -32544,6 +33018,7 @@ Waiting for approval...
             registered: receipt.registered,
             advertisement_generation: receipt.advertisement_generation,
             pending_attempts: Object.keys(receipt.attempts).length + (receipt.pending_claim_request ? 1 : 0),
+            recovery: summarizeInferenceHostRuntimeRecovery(receipt),
             updated_at: receipt.updated_at
           } : null,
           agent_attempt: agentAttempt ? {
@@ -32855,7 +33330,7 @@ Waiting for approval...
       }
       return record2;
     };
-    agentOperationId = (kind) => `${kind}-${randomUUID()}`;
+    agentOperationId = (kind) => `${kind}-${randomUUID2()}`;
     agentSession = async (config2, dependencies, warnings, signal) => {
       if (await readRevocationCheckpoint(config2)) {
         throw new Error("Inference host revocation recovery must finish first.");
@@ -33503,7 +33978,7 @@ var init_types = __esm({
 });
 
 // lib/agent-core/client.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 function normalizeApiUrl(value) {
   const parsed = String(value || "").trim();
   if (!parsed) {
@@ -33765,7 +34240,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/decision", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -33774,7 +34249,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/trade-sync", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -33783,7 +34258,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/error", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -33795,7 +34270,7 @@ var init_client = __esm({
         return this.request("/trading/market-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33803,7 +34278,7 @@ var init_client = __esm({
         return this.request("/trading/limit-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33811,7 +34286,7 @@ var init_client = __esm({
         return this.request("/trading/cancel-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33830,7 +34305,7 @@ var init_client = __esm({
         return this.request("/trading/ai/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33838,7 +34313,7 @@ var init_client = __esm({
         return this.request("/trading/ai/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: {}
         });
       }
@@ -33846,7 +34321,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: {}
         });
       }
@@ -33854,7 +34329,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: {}
         });
       }
@@ -33862,7 +34337,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/session/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33873,7 +34348,7 @@ var init_client = __esm({
           return this.request("/trading/ai/runtime/session/stop", {
             method: "POST",
             profileId,
-            idempotencyKey: randomUUID2(),
+            idempotencyKey: randomUUID3(),
             body: payload
           });
         }
@@ -33890,7 +34365,7 @@ var init_client = __esm({
         }).request("/trading/ai/runtime/session/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33899,7 +34374,7 @@ var init_client = __esm({
 });
 
 // lib/agent-core/headless-runtime.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 function objectOrNull2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -33997,8 +34472,8 @@ async function runAndReportLocalWorkCycle(options, state, leaseToken, context) {
   return Boolean(result2.decision || tradeSync || result2.afterDecision);
 }
 async function startHeadlessRuntime(options) {
-  const runtimeSessionId = randomUUID3();
-  const deviceId = String(options.deviceId || "").trim() || randomUUID3();
+  const runtimeSessionId = randomUUID4();
+  const deviceId = String(options.deviceId || "").trim() || randomUUID4();
   const startResponse = await options.client.startRuntime(options.profileId, {
     session_id: runtimeSessionId,
     device_id: deviceId,
@@ -50616,7 +51091,7 @@ var headless_local_worker_exports = {};
 __export(headless_local_worker_exports, {
   createHeadlessLocalWorker: () => createHeadlessLocalWorker
 });
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 function objectOrNull3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -51029,7 +51504,7 @@ function createHeadlessLocalWorker(options) {
       const statusMatch = errorText.match(/\b([45]\d{2})\b/);
       const statusCode = statusMatch ? Number(statusMatch[1]) : null;
       const failedInvocation = normalizeAiInvocationTelemetry({
-        client_invocation_id: randomUUID4(),
+        client_invocation_id: randomUUID5(),
         use_case: "trader",
         role: "primary",
         attempt_index: 0,
@@ -51085,7 +51560,7 @@ function createHeadlessLocalWorker(options) {
       billable_cached_input_tokens: normalizedUsage.cached_input_tokens
     };
     const invocation = normalizeAiInvocationTelemetry({
-      client_invocation_id: randomUUID4(),
+      client_invocation_id: randomUUID5(),
       use_case: "trader",
       role: "primary",
       attempt_index: 0,
@@ -51290,7 +51765,7 @@ var vtx_exports = {};
 __export(vtx_exports, {
   runVtxCli: () => runVtxCli
 });
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { spawn as spawn7 } from "node:child_process";
 function render2(value, json2) {
   if (json2) {
@@ -51704,8 +52179,8 @@ async function runVtxCli(argv2, env = process.env) {
         });
         return { exitCode: 0, stdout: render2(redactCliOutput(response2), json2), stderr: "" };
       }
-      const runtimeSessionId = randomUUID5();
-      const deviceId = config2.runtimeDeviceId ?? randomUUID5();
+      const runtimeSessionId = randomUUID6();
+      const deviceId = config2.runtimeDeviceId ?? randomUUID6();
       const response = await client.startRuntime(profileId, {
         session_id: runtimeSessionId,
         device_id: deviceId,

package/package.json

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