@vtxmacro/cli 2026.8.37 → 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.37",
+      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
+    });
   }
 });
 
@@ -31510,9 +31624,9 @@ ${result2.stderr}`)) {
         const runtime = await this.waitForManifestApplied(restoredManifest);
         return await this.status(runtime);
       }
-      async waitForManifestApplied(manifest, targetInstanceName) {
+      async waitForManifestApplied(manifest, targetInstanceName, maxAttempts = this.reconcileWaitAttempts) {
         let consecutiveReadyObservations = 0;
-        for (let attempt = 0; attempt < this.reconcileWaitAttempts; attempt += 1) {
+        for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
           let runtime = null;
           try {
             runtime = await readRuntimeAcrossAtomicReplacement(this.runtimePath());
@@ -31648,7 +31762,12 @@ ${cleanup.stderr}`)) {
                   previous,
                   targetInstanceName && previous.workers.some(
                     (worker) => worker.instance_name === targetInstanceName
-                  ) ? targetInstanceName : void 0
+                  ) ? 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(
@@ -32288,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);
     }
@@ -32355,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, registerInferenceHostServiceControlInput, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, login, codexLogin, codexLogout, localStatus, doctor, cleanupLogin, runHost, defaultReadStdin, parseAgentStdin, agentOperationId, agentSession, agentConnect, agentRun, agentNext, agentComplete, agentFail, withAgentCommandLock, serviceCommand, hasExplicitCredentialStoreConfiguration, commandUsesInstalledServiceCredentials, resolveInferenceHostCommandConfig;
+var 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";
@@ -32379,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) => {
@@ -32647,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,
@@ -32780,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.");
         }
@@ -32791,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 = 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);
@@ -32846,6 +33026,7 @@ Waiting for approval...
               store
             });
             remoteCleanupConfirmed = true;
+            await store.removeRecovery?.();
           } catch {
             if (!store.writeRecovery) {
               throw new Error(
@@ -32864,6 +33045,9 @@ Waiting for approval...
           }
           throw stateError;
         }
+        localStateCommitted = true;
+        await store.removeRecovery?.();
+        await clearInferenceHostCredentialContextTransition(config2);
         return {
           exitCode: 0,
           stdout: render({
@@ -32876,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) => {
@@ -33111,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) {
@@ -33141,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,
@@ -33157,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);
@@ -33169,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,
@@ -33183,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.");
         }
@@ -33207,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,
@@ -33228,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) => {
@@ -33775,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.");
@@ -33839,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;
     };
   }

package/package.json

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