@vtxmacro/cli 2026.8.36 → 2026.8.38

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.38",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       platforms: {
@@ -16245,6 +16245,109 @@ function resolveInferenceHostConfig(env = process.env) {
     supervisorProcessLockPath: join(baseDir, "host.lock")
   };
 }
+async function writeInferenceHostCredentialContext(config2) {
+  const context = credentialContextForConfig(config2);
+  await writeAtomicInferencePrivateFile(
+    inferenceHostCredentialContextPath(config2),
+    `${JSON.stringify(context, null, 2)}
+`
+  );
+}
+async function writeInferenceHostCredentialContextTransition(config2, previous, candidate = credentialContextForConfig(config2), operation = "selection", phase = "prepared") {
+  const transition = {
+    schema_version: "vtx_inference_credential_context_transition_v1",
+    operation,
+    phase,
+    previous,
+    candidate
+  };
+  await writeAtomicInferencePrivateFile(
+    inferenceHostCredentialContextTransitionPath(config2),
+    `${JSON.stringify(transition, null, 2)}
+`
+  );
+}
+async function readInferenceHostCredentialContextTransition(config2) {
+  const raw = await readInferencePrivateFile(
+    inferenceHostCredentialContextTransitionPath(config2),
+    "Inference host credential context transition"
+  );
+  if (raw === null) return null;
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new Error("Inference host credential context transition is not valid JSON.");
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Inference host credential context transition is invalid.");
+  }
+  const record2 = value;
+  const expectedKeys = ["schema_version", "operation", "phase", "previous", "candidate"];
+  if (Object.keys(record2).sort().join("\0") !== expectedKeys.sort().join("\0") || record2.schema_version !== "vtx_inference_credential_context_transition_v1" || record2.operation !== "selection" && record2.operation !== "cleanup" || record2.phase !== "prepared" && record2.phase !== "committed") {
+    throw new Error("Inference host credential context transition is invalid.");
+  }
+  return {
+    schema_version: "vtx_inference_credential_context_transition_v1",
+    operation: record2.operation,
+    phase: record2.phase,
+    previous: record2.previous === null ? null : assertInferenceHostCredentialContext(record2.previous, config2),
+    candidate: record2.candidate === null ? null : assertInferenceHostCredentialContext(record2.candidate, config2)
+  };
+}
+async function clearInferenceHostCredentialContextTransition(config2) {
+  await clearInferencePrivateFile(
+    inferenceHostCredentialContextTransitionPath(config2),
+    "Inference host credential context transition"
+  );
+}
+async function clearInferenceHostCredentialContext(config2) {
+  await clearInferencePrivateFile(
+    inferenceHostCredentialContextPath(config2),
+    "Inference host credential context"
+  );
+}
+async function readInferenceHostCredentialContext(config2) {
+  const raw = await readInferencePrivateFile(
+    inferenceHostCredentialContextPath(config2),
+    "Inference host credential context"
+  );
+  if (raw === null) return null;
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new Error("Inference host credential context is not valid JSON.");
+  }
+  return assertInferenceHostCredentialContext(value, config2);
+}
+function assertInferenceHostCredentialContext(value, config2) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Inference host credential context is invalid.");
+  }
+  const record2 = value;
+  const expectedKeys = [
+    "schema_version",
+    "instance_name",
+    "credential_store_mode",
+    "credential_file_path"
+  ];
+  if (Object.keys(record2).sort().join("\0") !== expectedKeys.sort().join("\0") || record2.schema_version !== "vtx_inference_credential_context_v1" || record2.instance_name !== config2.instanceName || record2.credential_store_mode !== "os" && record2.credential_store_mode !== "file" || (record2.credential_store_mode === "os" ? record2.credential_file_path !== null : typeof record2.credential_file_path !== "string" || !record2.credential_file_path)) {
+    throw new Error("Inference host credential context is invalid.");
+  }
+  const credentialFilePath = record2.credential_store_mode === "file" ? requireNamedInstancePath(
+    config2.instanceName,
+    config2.instanceName === DEFAULT_INFERENCE_HOST_INSTANCE ? config2.baseDir : join(config2.baseDir, "instances", config2.instanceName),
+    record2.credential_file_path,
+    "Stored inference credential path"
+  ) : null;
+  return {
+    schema_version: "vtx_inference_credential_context_v1",
+    instance_name: config2.instanceName,
+    credential_store_mode: record2.credential_store_mode,
+    credential_file_path: credentialFilePath
+  };
+}
 function assertLocalState(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("Inference host local state is invalid.");
@@ -16619,7 +16722,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;
+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 init_config = __esm({
   "lib/inference-host/config.ts"() {
     "use strict";
@@ -17138,6 +17241,17 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
       if (process.platform === "darwin") return "os:macos-keychain";
       return `os:${process.platform}:unsupported`;
     };
+    inferenceHostCredentialContextPath = (config2) => join(
+      config2.instanceName === DEFAULT_INFERENCE_HOST_INSTANCE ? config2.baseDir : join(config2.baseDir, "instances", config2.instanceName),
+      "credential-context.json"
+    );
+    inferenceHostCredentialContextTransitionPath = (config2) => `${inferenceHostCredentialContextPath(config2)}.pending`;
+    credentialContextForConfig = (config2) => ({
+      schema_version: "vtx_inference_credential_context_v1",
+      instance_name: config2.instanceName,
+      credential_store_mode: config2.credentialStoreMode,
+      credential_file_path: config2.credentialStoreMode === "file" ? resolve(config2.credentialFilePath) : null
+    });
   }
 });
 
@@ -29047,7 +29161,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 +29218,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 +29887,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 +30168,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 +30262,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 +30321,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 +30329,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 +31074,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 +31088,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 +31096,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 +31114,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 +31165,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 +31206,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 +31240,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 +31258,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 +31308,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 +31466,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 +31485,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 +31504,9 @@ WantedBy=default.target
       logPath() {
         return inferenceHostServiceLogPath(this.config);
       }
+      runtimePath() {
+        return inferenceHostServiceRuntimePath(this.config);
+      }
       controlLockPath() {
         return `${this.config.supervisorProcessLockPath}.service-control`;
       }
@@ -31344,7 +31592,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, maxAttempts = this.reconcileWaitAttempts) {
+        let consecutiveReadyObservations = 0;
+        for (let attempt = 0; attempt < maxAttempts; 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 +31698,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 +31725,85 @@ ${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,
+                  // A failed generation may still be draining while the manager
+                  // restores the previous manifest. Never give rollback less than
+                  // a bounded 100-observation confirmation window, even when a
+                  // caller intentionally shortens forward-readiness checks.
+                  Math.max(this.reconcileWaitAttempts, 100)
+                );
+              } 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 +31860,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 +31869,8 @@ ${cleanup.stderr}`)) {
         });
         return await this.replaceManifestUnlocked(
           manifest,
-          options.startImmediately !== false
+          options.startImmediately !== false,
+          this.config.instanceName
         );
       }
       async start() {
@@ -31516,41 +31902,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 +31969,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 +32008,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 +32036,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 +32058,8 @@ ${result2.stderr}`)) {
 `, resolvePromise);
       });
     };
-    spawnServiceChild = async (manifest, worker, signal) => {
+    spawnInferenceHostServiceChild = async (manifest, worker, signal, onReady = () => {
+    }) => {
       const args = [
         manifest.script,
         "inference-host",
@@ -31667,6 +32072,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 +32086,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 +32109,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 +32117,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 +32140,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 +32160,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);
           }
         }
       };
-      await Promise.all(manifest.workers.map(superviseWorker));
-      await appendServiceLog(manifest.log_path, "service_supervisor_stopped");
+      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 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 +32393,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";
@@ -31835,7 +32407,7 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
       return { exitCode: 0, stdout: INFERENCE_HOST_HELP, stderr: "" };
     }
     const parsed = parseInferenceHostArgs(argv2, env);
-    const config2 = await resolveInferenceHostCommandConfig(parsed, env);
+    const config2 = await resolveInferenceHostCommandConfig(parsed, env, dependencies);
     if (parsed.command === "login") {
       return await login(config2, parsed, env, dependencies, warnings);
     }
@@ -31902,7 +32474,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, credentialLifecycleLockPath, 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, restoreInferenceHostCredentialContext, recoverInferenceHostCredentialContextTransition, 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, credentialEnvironmentForIdentity, commandRequiresRetainedCredentialStore, commandUsesInstalledServiceCredentials, resolveInferenceHostCommandConfig;
 var init_cli = __esm({
   "lib/inference-host/cli.ts"() {
     "use strict";
@@ -31926,6 +32498,7 @@ var init_cli = __esm({
     codexGuardianReceiptRoot = (config2) => `${config2.statePath}.codex-processes`;
     revocationCheckpointPath = (config2) => `${config2.statePath}.revoke.json`;
     foregroundHostLockPath = (config2) => `${config2.processLockPath}.foreground`;
+    credentialLifecycleLockPath = (config2) => `${inferenceHostCredentialContextPath(config2)}.lock`;
     AGENT_HEARTBEAT_INTERVAL_MS = 3e3;
     AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS = 9e3;
     retryableAgentHeartbeatError = (error48) => {
@@ -32147,14 +32720,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) => {
@@ -32173,6 +32767,36 @@ Durable service:
       };
     };
     configuredCredentialStore = (config2, dependencies, warn) => dependencies.createCredentialStore?.(config2, warn) ?? createConfiguredInferenceCredentialStore(config2, { warn });
+    restoreInferenceHostCredentialContext = async (config2, previous) => {
+      if (!previous) {
+        await clearInferenceHostCredentialContext(config2);
+        return;
+      }
+      await writeInferenceHostCredentialContext({
+        ...config2,
+        credentialStoreMode: previous.credential_store_mode,
+        credentialFilePath: previous.credential_file_path
+      });
+    };
+    recoverInferenceHostCredentialContextTransition = async (config2, selectedEnv, dependencies) => {
+      const transition = await readInferenceHostCredentialContextTransition(config2);
+      if (!transition) return;
+      const localState = await readInferenceHostLocalState(config2.statePath);
+      const candidateRecovery = transition.candidate ? await configuredCredentialStore(
+        resolveInferenceHostConfig({
+          ...selectedEnv,
+          VTX_INFERENCE_HOST_CREDENTIAL_STORE: transition.candidate.credential_store_mode,
+          VTX_INFERENCE_HOST_CREDENTIAL_FILE: transition.candidate.credential_file_path ?? void 0
+        }),
+        dependencies,
+        () => void 0
+      ).readRecovery?.() ?? null : null;
+      await restoreInferenceHostCredentialContext(
+        config2,
+        transition.operation === "selection" ? localState || candidateRecovery ? transition.candidate : transition.previous : transition.phase === "committed" && !localState ? null : transition.previous
+      );
+      await clearInferenceHostCredentialContextTransition(config2);
+    };
     accountKeyForState = (state) => inferenceCredentialAccountKey({
       issuer: state.issuer,
       clientId: state.client_id,
@@ -32306,8 +32930,15 @@ Durable service:
       }).run();
     };
     login = async (config2, parsed, env, dependencies, warnings) => {
-      const lock2 = await acquireInferenceHostProcessLock(config2.processLockPath);
+      const credentialLock = await acquireInferenceHostProcessLock(
+        credentialLifecycleLockPath(config2)
+      );
+      let lock2 = null;
+      let previousCredentialContext;
+      let selectedStore = null;
+      let localStateCommitted = false;
       try {
+        lock2 = await acquireInferenceHostProcessLock(config2.processLockPath);
         if (await readRevocationCheckpoint(config2)) {
           throw new Error("Inference host revocation recovery must finish before login.");
         }
@@ -32317,18 +32948,41 @@ Durable service:
         const store = configuredCredentialStore(config2, dependencies, (message) => {
           warnings.push(message);
         });
+        selectedStore = store;
+        if (!store.writeRecovery || !store.removeRecovery || !store.readRecovery) {
+          throw new Error("Inference host credential store does not support durable login recovery.");
+        }
         if (await store.readRecovery?.()) {
           throw new Error("Inference host credential recovery is required before login.");
         }
+        previousCredentialContext = await readInferenceHostCredentialContext(config2);
+        await writeInferenceHostCredentialContextTransition(config2, previousCredentialContext);
+        await writeInferenceHostCredentialContext(config2);
         const keyPair = generateExternalInferenceEnvelopeKeyPair();
-        const hostId = randomUUID();
+        const hostId = randomUUID2();
         const beginLogin = dependencies.beginLogin ?? beginInferenceOAuthLogin;
+        const loginStore = {
+          kind: store.kind,
+          read: store.read.bind(store),
+          remove: store.remove.bind(store),
+          readRecovery: store.readRecovery.bind(store),
+          writeRecovery: store.writeRecovery.bind(store),
+          removeRecovery: store.removeRecovery.bind(store),
+          write: async (accountKey, credential, options) => {
+            await store.writeRecovery(accountKey, credential);
+            try {
+              await store.write(accountKey, credential, options);
+            } catch (error48) {
+              throw error48;
+            }
+          }
+        };
         const pending = await beginLogin({
           apiUrl: config2.apiUrl,
           hostId,
           x25519PrivateKey: keyPair.private_key,
           keyGeneration: 1,
-          store
+          store: loginStore
         });
         const emitStdout = dependencies.emitStdout ?? ((text) => {
           process.stdout.write(text);
@@ -32372,6 +33026,7 @@ Waiting for approval...
               store
             });
             remoteCleanupConfirmed = true;
+            await store.removeRecovery?.();
           } catch {
             if (!store.writeRecovery) {
               throw new Error(
@@ -32390,6 +33045,9 @@ Waiting for approval...
           }
           throw stateError;
         }
+        localStateCommitted = true;
+        await store.removeRecovery?.();
+        await clearInferenceHostCredentialContextTransition(config2);
         return {
           exitCode: 0,
           stdout: render({
@@ -32402,8 +33060,18 @@ Waiting for approval...
           stderr: warnings.length > 0 ? `${warnings.join("\n")}
 ` : ""
         };
+      } catch (error48) {
+        const recovery = await selectedStore?.readRecovery?.() ?? null;
+        if (!recovery && !localStateCommitted && previousCredentialContext !== void 0) {
+          await restoreInferenceHostCredentialContext(config2, previousCredentialContext);
+          await clearInferenceHostCredentialContextTransition(config2);
+        } else if (recovery) {
+          await clearInferenceHostCredentialContextTransition(config2);
+        }
+        throw error48;
       } finally {
-        await lock2.release();
+        await lock2?.release();
+        await credentialLock.release();
       }
     };
     codexLogin = async (config2, parsed, env, dependencies) => {
@@ -32544,6 +33212,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 ? {
@@ -32636,10 +33305,14 @@ Waiting for approval...
       };
     };
     cleanupLogin = async (config2, parsed, dependencies, warnings, revoke) => {
-      await assertDurableServiceUninstalled(config2);
-      const lock2 = await acquireInferenceHostProcessLock(config2.processLockPath);
+      const credentialLock = await acquireInferenceHostProcessLock(
+        credentialLifecycleLockPath(config2)
+      );
+      let lock2 = null;
       let keeperLock = null;
       try {
+        await assertDurableServiceUninstalled(config2);
+        lock2 = await acquireInferenceHostProcessLock(config2.processLockPath);
         try {
           keeperLock = await acquireInferenceHostProcessLock(foregroundHostLockPath(config2));
         } catch (error48) {
@@ -32666,8 +33339,35 @@ Waiting for approval...
             state,
             oauthRecovery
           );
+        }
+        let cleanupTransitionStaged = false;
+        const stageCleanupTransition = async () => {
+          if (cleanupTransitionStaged) return;
+          const selectedContext = await readInferenceHostCredentialContext(config2);
+          await writeInferenceHostCredentialContextTransition(
+            config2,
+            selectedContext,
+            null,
+            "cleanup",
+            "prepared"
+          );
+          cleanupTransitionStaged = true;
+        };
+        const commitCleanupTransition = async () => {
+          await writeInferenceHostCredentialContextTransition(
+            config2,
+            await readInferenceHostCredentialContext(config2),
+            null,
+            "cleanup",
+            "committed"
+          );
+        };
+        if (revocationCheckpoint) {
+          await stageCleanupTransition();
+          await commitCleanupTransition();
         } else if (oauthRecovery) {
           if (revoke) {
+            await stageCleanupTransition();
             const metadata = await (dependencies.discoverOAuth ?? discoverInferenceOAuth)(config2.apiUrl);
             await (dependencies.revokeCredential ?? revokeInferenceCredential)({
               metadata,
@@ -32682,9 +33382,12 @@ Waiting for approval...
               config2.credentialStoreIdentity
             );
             await writeRevocationCheckpoint(config2, revocationCheckpoint);
+            await commitCleanupTransition();
           } else {
+            await stageCleanupTransition();
             await store.remove(oauthRecovery.accountKey);
             await store.removeRecovery?.();
+            await commitCleanupTransition();
           }
         } else if (state) {
           const accountKey = accountKeyForState(state);
@@ -32694,6 +33397,7 @@ Waiting for approval...
             if (!credential) {
               throw new Error("Inference host credential is unavailable; remote revoke cannot be confirmed.");
             }
+            await stageCleanupTransition();
             const metadata = await (dependencies.discoverOAuth ?? discoverInferenceOAuth)(config2.apiUrl);
             await (dependencies.revokeCredential ?? revokeInferenceCredential)({
               metadata,
@@ -32708,11 +33412,16 @@ Waiting for approval...
               config2.credentialStoreIdentity
             );
             await writeRevocationCheckpoint(config2, revocationCheckpoint);
+            await commitCleanupTransition();
           } else {
+            await stageCleanupTransition();
             await store.remove(accountKey);
+            await commitCleanupTransition();
           }
         } else if (!revoke && store.kind === "file") {
+          await stageCleanupTransition();
           await store.remove("");
+          await commitCleanupTransition();
         } else if (revoke) {
           throw new Error("Inference host is not logged in; there is no exact grant to revoke.");
         }
@@ -32732,14 +33441,18 @@ Waiting for approval...
               { cause: error48 }
             );
           }
-          await clearLocalRuntimeArtifacts(config2);
           await store.remove(revocationCheckpoint.account_key);
           if (revocationCheckpoint.remove_credential_recovery) {
             await store.removeRecovery?.();
           }
+          await (dependencies.clearLocalRuntimeArtifacts ?? clearLocalRuntimeArtifacts)(config2);
+          await clearInferenceHostCredentialContext(config2);
           await clearRevocationCheckpoint(config2);
+          await clearInferenceHostCredentialContextTransition(config2);
         } else {
-          await clearLocalRuntimeArtifacts(config2);
+          await (dependencies.clearLocalRuntimeArtifacts ?? clearLocalRuntimeArtifacts)(config2);
+          await clearInferenceHostCredentialContext(config2);
+          await clearInferenceHostCredentialContextTransition(config2);
         }
         return {
           exitCode: 0,
@@ -32753,7 +33466,8 @@ Waiting for approval...
         };
       } finally {
         await keeperLock?.release();
-        await lock2.release();
+        await lock2?.release();
+        await credentialLock.release();
       }
     };
     runHost = async (config2, parsed, env, dependencies, warnings) => {
@@ -32855,7 +33569,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.");
@@ -33300,44 +34014,52 @@ Waiting for approval...
         dependencies.serviceDependencies
       ) ?? new InferenceHostServiceManager(config2, dependencies.serviceDependencies);
       if (action === "install") {
-        const adapter = parsed.adapter || "codex";
-        if (adapter !== "codex") {
-          throw new Error(
-            `Adapter ${adapter} does not have a supported durable service integration. Use foreground agent-run instead.`
-          );
-        }
-        const state = await readInferenceHostLocalState(config2.statePath);
-        if (!state) throw new Error("Run vtx inference-host login before installing the service.");
-        const store = configuredCredentialStore(config2, dependencies, (message) => warnings.push(message));
-        const credential = await store.read(accountKeyForState(state));
-        if (!credential) throw new Error("Inference-host credential is missing. Run login again.");
-        assertCredentialMatchesState2(state, credential);
-        if (parsed.modelId || parsed.modelLabel || parsed.reasoningEffort) {
-          throw new Error("Automated Codex service does not accept agent model or effort options.");
-        }
-        const auth = await inspectCodexAuthentication(config2);
-        if (!auth.present || !auth.private) {
-          throw new Error("Run vtx inference-host codex-login before installing the automated Codex service.");
-        }
-        const binary = await (dependencies.resolveBinary ?? resolvePinnedCodexBinary)(env);
-        const preflight = await (dependencies.preflightCodex ?? preflightCodexSubscription)({
-          binary,
-          codexHome: config2.codexHomePath,
-          deadlineAtMs: Date.now() + 3e4
-        });
-        const status = await manager.install({
-          adapter: "codex",
-          displayName: parsed.displayName,
-          maxConcurrency: parsed.maxConcurrency,
-          authenticatedAccountEmail: preflight?.authenticated_account_email ?? null,
-          authenticatedAccountPlan: preflight?.authenticated_account_plan ?? null
-        });
-        return {
-          exitCode: 0,
-          stdout: render({ status: "service_installed", ...status }, parsed.json),
-          stderr: warnings.length > 0 ? `${warnings.join("\n")}
+        const credentialLock = await acquireInferenceHostProcessLock(
+          credentialLifecycleLockPath(config2)
+        );
+        try {
+          const adapter = parsed.adapter || "codex";
+          if (adapter !== "codex") {
+            throw new Error(
+              `Adapter ${adapter} does not have a supported durable service integration. Use foreground agent-run instead.`
+            );
+          }
+          const state = await readInferenceHostLocalState(config2.statePath);
+          if (!state) throw new Error("Run vtx inference-host login before installing the service.");
+          const store = configuredCredentialStore(config2, dependencies, (message) => warnings.push(message));
+          const credential = await store.read(accountKeyForState(state));
+          if (!credential) throw new Error("Inference-host credential is missing. Run login again.");
+          assertCredentialMatchesState2(state, credential);
+          if (parsed.modelId || parsed.modelLabel || parsed.reasoningEffort) {
+            throw new Error("Automated Codex service does not accept agent model or effort options.");
+          }
+          const auth = await inspectCodexAuthentication(config2);
+          if (!auth.present || !auth.private) {
+            throw new Error("Run vtx inference-host codex-login before installing the automated Codex service.");
+          }
+          const binary = await (dependencies.resolveBinary ?? resolvePinnedCodexBinary)(env);
+          const preflight = await (dependencies.preflightCodex ?? preflightCodexSubscription)({
+            binary,
+            codexHome: config2.codexHomePath,
+            deadlineAtMs: Date.now() + 3e4
+          });
+          const status = await manager.install({
+            adapter: "codex",
+            displayName: parsed.displayName,
+            maxConcurrency: parsed.maxConcurrency,
+            authenticatedAccountEmail: preflight?.authenticated_account_email ?? null,
+            authenticatedAccountPlan: preflight?.authenticated_account_plan ?? null
+          });
+          await writeInferenceHostCredentialContext(config2);
+          return {
+            exitCode: 0,
+            stdout: render({ status: "service_installed", ...status }, parsed.json),
+            stderr: warnings.length > 0 ? `${warnings.join("\n")}
 ` : ""
-        };
+          };
+        } finally {
+          await credentialLock.release();
+        }
       }
       if (parsed.adapter || parsed.modelId || parsed.modelLabel || parsed.reasoningEffort) {
         throw new Error("Service adapter and model options are accepted only by service install.");
@@ -33364,36 +34086,98 @@ Waiting for approval...
         return { exitCode: lifecycleMatches ? 0 : 1, stdout: render(status, parsed.json), stderr: "" };
       }
       if (action === "uninstall") {
-        const status = parsed.instanceExplicit ? await manager.uninstallInstance(config2.instanceName) : await manager.uninstall();
-        return { exitCode: 0, stdout: render({ status: "service_uninstalled", ...status }, parsed.json), stderr: "" };
+        const credentialLock = await acquireInferenceHostProcessLock(
+          credentialLifecycleLockPath(config2)
+        );
+        try {
+          if (parsed.instanceExplicit) {
+            const retained = await readInferenceHostCredentialContext(config2);
+            const retainedIdentity = retained ? resolveInferenceHostConfig({
+              ...env,
+              VTX_INFERENCE_HOST_INSTANCE: config2.instanceName,
+              VTX_INFERENCE_HOST_CREDENTIAL_STORE: retained.credential_store_mode,
+              VTX_INFERENCE_HOST_CREDENTIAL_FILE: retained.credential_file_path ?? void 0
+            }).credentialStoreIdentity : null;
+            if (retainedIdentity !== config2.credentialStoreIdentity) {
+              await writeInferenceHostCredentialContext(config2);
+            }
+          }
+          const status = parsed.instanceExplicit ? await manager.uninstallInstance(config2.instanceName) : await manager.uninstall();
+          return { exitCode: 0, stdout: render({ status: "service_uninstalled", ...status }, parsed.json), stderr: "" };
+        } finally {
+          await credentialLock.release();
+        }
       }
       throw new Error("Usage: vtx inference-host service <install|start|stop|status|logs|uninstall>.");
     };
     hasExplicitCredentialStoreConfiguration = (env) => Boolean(
       String(env.VTX_INFERENCE_HOST_CREDENTIAL_STORE || "").trim() || String(env.VTX_INFERENCE_HOST_CREDENTIAL_FILE || "").trim()
     );
-    commandUsesInstalledServiceCredentials = (parsed) => parsed.command === "status" || parsed.command === "doctor" || parsed.command === "service" && parsed.serviceAction === "install";
-    resolveInferenceHostCommandConfig = async (parsed, env) => {
+    credentialEnvironmentForIdentity = (identity) => {
+      if (identity.startsWith("file:")) {
+        const path = identity.slice("file:".length);
+        if (!path) throw new Error("Inference host credential store identity is invalid.");
+        return {
+          VTX_INFERENCE_HOST_CREDENTIAL_STORE: "file",
+          VTX_INFERENCE_HOST_CREDENTIAL_FILE: path
+        };
+      }
+      if (identity.startsWith("os:")) {
+        return {
+          VTX_INFERENCE_HOST_CREDENTIAL_STORE: "os",
+          VTX_INFERENCE_HOST_CREDENTIAL_FILE: void 0
+        };
+      }
+      throw new Error("Inference host credential store identity is invalid.");
+    };
+    commandRequiresRetainedCredentialStore = (parsed) => parsed.command === "logout" || parsed.command === "revoke" || parsed.command === "service" && parsed.instanceExplicit && (parsed.serviceAction === "install" || parsed.serviceAction === "uninstall");
+    commandUsesInstalledServiceCredentials = (parsed) => parsed.command === "login" || parsed.command === "logout" || parsed.command === "revoke" || parsed.command === "status" || parsed.command === "doctor" || parsed.command === "service" && parsed.serviceAction === "install" || parsed.command === "service" && parsed.serviceAction === "uninstall" && parsed.instanceExplicit;
+    resolveInferenceHostCommandConfig = async (parsed, env, dependencies) => {
       const selectedEnv = {
         ...env,
         VTX_INFERENCE_HOST_INSTANCE: parsed.instanceName
       };
       const baseConfig = resolveInferenceHostConfig(selectedEnv);
-      if (!commandUsesInstalledServiceCredentials(parsed) || hasExplicitCredentialStoreConfiguration(env)) {
-        return baseConfig;
+      if (!commandUsesInstalledServiceCredentials(parsed)) return baseConfig;
+      if (await readInferenceHostCredentialContextTransition(baseConfig)) {
+        const credentialLock = await acquireInferenceHostProcessLock(
+          credentialLifecycleLockPath(baseConfig)
+        );
+        try {
+          await recoverInferenceHostCredentialContextTransition(baseConfig, selectedEnv, dependencies);
+        } finally {
+          await credentialLock.release();
+        }
       }
       const manifestPath = `${baseConfig.supervisorStatePath}.service.json`;
       const manifest = await readInferenceHostServiceManifest(manifestPath);
-      if (!manifest) return baseConfig;
+      const installedEnvironment = manifest?.workers.find(
+        (worker) => worker.instance_name === baseConfig.instanceName
+      )?.runtime_environment;
+      const persistedContext = installedEnvironment ? null : await readInferenceHostCredentialContext(baseConfig);
+      const revocationCheckpoint = !installedEnvironment && !persistedContext && parsed.command === "revoke" ? await readRevocationCheckpoint(baseConfig) : null;
+      const retainedEnvironment = installedEnvironment ?? (persistedContext ? {
+        VTX_INFERENCE_HOST_CREDENTIAL_STORE: persistedContext.credential_store_mode,
+        VTX_INFERENCE_HOST_CREDENTIAL_FILE: persistedContext.credential_file_path ?? void 0
+      } : revocationCheckpoint ? credentialEnvironmentForIdentity(revocationCheckpoint.credential_store_identity) : null);
+      if (!retainedEnvironment) return baseConfig;
       const installedConfig = resolveInferenceHostConfig({
         ...selectedEnv,
-        ...manifest.workers.find((worker) => worker.instance_name === baseConfig.instanceName)?.runtime_environment
+        ...retainedEnvironment
       });
       if (resolve5(installedConfig.statePath) !== resolve5(baseConfig.statePath)) {
         throw new Error(
           "Installed inference-host service manifest does not match the requested local state path."
         );
       }
+      if (hasExplicitCredentialStoreConfiguration(env)) {
+        if (commandRequiresRetainedCredentialStore(parsed) && baseConfig.credentialStoreIdentity !== installedConfig.credentialStoreIdentity) {
+          throw new Error(
+            "Explicit inference credential store does not match the retained store for this host. Log out or revoke with the retained store before switching."
+          );
+        }
+        return baseConfig;
+      }
       return installedConfig;
     };
   }
@@ -33503,7 +34287,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 +34549,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 +34558,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 +34567,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 +34579,7 @@ var init_client = __esm({
         return this.request("/trading/market-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33803,7 +34587,7 @@ var init_client = __esm({
         return this.request("/trading/limit-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33811,7 +34595,7 @@ var init_client = __esm({
         return this.request("/trading/cancel-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33830,7 +34614,7 @@ var init_client = __esm({
         return this.request("/trading/ai/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33838,7 +34622,7 @@ var init_client = __esm({
         return this.request("/trading/ai/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: {}
         });
       }
@@ -33846,7 +34630,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: {}
         });
       }
@@ -33854,7 +34638,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: {}
         });
       }
@@ -33862,7 +34646,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/session/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33873,7 +34657,7 @@ var init_client = __esm({
           return this.request("/trading/ai/runtime/session/stop", {
             method: "POST",
             profileId,
-            idempotencyKey: randomUUID2(),
+            idempotencyKey: randomUUID3(),
             body: payload
           });
         }
@@ -33890,7 +34674,7 @@ var init_client = __esm({
         }).request("/trading/ai/runtime/session/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID2(),
+          idempotencyKey: randomUUID3(),
           body: payload
         });
       }
@@ -33899,7 +34683,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 +34781,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 +51400,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 +51813,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 +51869,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 +52074,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 +52488,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,