@vtxmacro/cli 2026.8.37 → 2026.8.39

package/README.md

@@ -58,10 +58,10 @@ exposed. Before starting a Trader, confirm that the VTX AI page shows the
 intended authenticated ChatGPT email and plan. The host reads the live Codex
 account window: a reached limit pauses new dispatch until its reported reset,
 while a transient throttle uses a short bounded cooldown.
-The selected AI model row shows the open VTX profile's rolling 1-hour, 24-hour,
-and 7-day request and reported-token activity for that subscription path.
-Account-wide quota percentages remain in safe host diagnostics instead of the
-profile-scoped selector.
+The selected AI model row estimates the open VTX profile's attributable
+membership burn rate for that subscription, expressed as equivalent percentage
+points per hour, day, and seven days. Account-wide quota percentages remain in
+safe host diagnostics instead of the profile-scoped selector.
 
 ```bash
 vtx inference-host login
@@ -86,12 +86,12 @@ distinct. Use `service uninstall --instance <name>` to remove one worker;
 unqualified `service uninstall` removes the whole supervisor. The legacy
 unqualified host commands continue to target `default`.
 
-For one VTX account and adapter, the selected host is tried first and other
-compatible memberships follow in setup order. Quota/credits exhaustion,
-unusable authentication, and exhausted recoverable provider failures can
-advance the same logical call. VTX never changes provider, model, effort, or
-response mode, and never cascades a bad request, policy rejection, or uncertain
-dispatch outcome.
+For each VTX profile and lane, **Subscription #1** is tried first and later
+compatible subscriptions follow in the saved Account cascade order.
+Quota/credits exhaustion, unusable authentication, and exhausted recoverable
+provider failures can advance the same logical call. VTX never changes
+provider, model, effort, or response mode, and never cascades a bad request,
+policy rejection, or uncertain dispatch outcome.
 
 Automated hosts do not impose a subscription-specific profile-count or
 concurrency limit by default. Set an explicit positive integer with

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.39",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       platforms: {
@@ -14375,7 +14375,7 @@ var init_zod = __esm({
 });
 
 // lib/external-inference-contract.ts
-var EXTERNAL_INFERENCE_CONTRACT_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION, EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION, EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION, EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, LEGACY_EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION, EXTERNAL_INFERENCE_INPUT_HASH_DOMAIN, MAX_EXTERNAL_INFERENCE_STATUS_HOSTS, MAX_GENERATION, MAX_SAFE_INTEGER, MAX_PROMPT_BYTES, MAX_IMMUTABLE_JOB_INPUT_BYTES, MAX_CANDIDATE_PLAINTEXT_BYTES, MAX_CIPHERTEXT_CHARS, SHA256_INITIAL_STATE, SHA256_ROUND_CONSTANTS, rotateRight, sha256BytesHex, sha256Utf8Hex, computeImmutableJobInputSha256, identifierSchema, operationIdentifierSchema, sha256HexSchema, generationSchema, zeroBasedGenerationSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, sqlIntegerTokenCountSchema, timestampSchema, safeCodeSchema, externalInferenceAdapterIdSchema, reasoningEffortSchema, modelNameSchema, displayNameSchema, authenticatedAccountEmailSchema, protocolVersionSchema, base64UrlAlphabet, isCanonicalBase64Url, base64Url32BytesSchema, base64UrlNonceSchema, base64UrlCiphertextSchema, claimHandleSchema, boundedJsonTextSchema, boundedPromptTextSchema, laneSchema, botModeSchema, executionModeSchema, responseModeSchema, dispatchOutcomeSchema, responseOutcomeSchema, nativeModelControllerSchema, externalAgentModelControllerSchema, externalAgentUnboundControllerSchema, liveModelControllerSchema, snapshotModelControllerSchema, modelIdentityMappingSchema, advertisedModelSchema, hostAdvertisementSchema, envelopeAadSchema, validateEnvelopeAad, commonEnvelopeShape, sealedKeyWrapEnvelopeSchema, sealedInputEnvelopeSchema, sealedCandidateEnvelopeSchema, sealedEnvelopeSchema, screenerCandidateRuntimeBindingSchema, screenerClientLeaseBindingSchema, screenerRuntimeBindingSchema, serverRuntimeBindingSchema, clientRuntimeBindingSchema, runtimeBindingSchema, immutableJobInputSchema, canonicalizeJsonValue, serializeImmutableJobInput, reportedTokenUsageSchema, unavailableTokenUsageSchema, tokenUsageSchema, agentConnectRequestSchema, agentNextRequestSchema, agentHeartbeatRequestSchema, emptyAgentNextResultSchema, claimedAgentNextResultSchema, agentNextResultSchema, agentCompleteRequestSchema, agentFailRequestSchema, requestedModelSelectionSchema, completedModelProvenanceSchema, attemptModelProvenanceSchema, providerWeeklyQuotaReadSchema, hostHeartbeatRequestSchema, jobClaimRequestSchema, emptyJobClaimSchema, claimedJobSchema, jobClaimResultSchema, attemptStartRequestSchema, jobHeartbeatRequestSchema, continueHeartbeatDirectiveSchema, cancelHeartbeatDirectiveSchema, jobHeartbeatResultSchema, adapterOutcomeEvidenceSchema, completionBaseShape, validateCompletion, providerResponseCompletionSchema, decisionCandidateCompletionSchema, jobCompleteRequestSchema, jobFailRequestSchema, jobCancelRequestSchema, jobCancellationReceiptSchema, jobDeliveryRequestSchema, deliveryBaseShape, validateDeliveryCandidate, providerResponseDeliverySchema, decisionCandidateDeliverySchema, jobDeliveryResultSchema, jobConsumptionRequestSchema, jobConsumptionReceiptSchema, jobStateSchema, jobStatusReadSchema, hostStatusReadSchema, controllerBindingStatusReadSchema, queueStatusReadSchema, outcomeStatusReadSchema, externalInferenceVolumeWindowReadSchema, externalInferenceFailureCountReadSchema, externalInferenceHostDiagnosticsReadSchema, externalInferenceProfileActivityReadSchema, externalInferenceStatusReadSchema, nativeResearchEvidenceSourceSchema, externalAgentResearchEvidenceSourceSchema, researchEvidenceSourceSchema, reportedResearchTokenUsageSchema, unavailableResearchTokenUsageSchema, researchTokenUsageSchema, externalInferenceProductLineageBaseShape, traderExternalInferenceProductLineageSchema, decisionChatExternalInferenceProductLineageSchema, screenerExternalInferenceProductLineageSchema, externalInferenceProductLineageSchema, normalProductLinkageSchema, evidenceMaterializationMarkerSchema, deliveredExternalAgentSourceIdentitySchema, deliveredRequestEvidenceSchema, researchEvidenceBaseShape, researchEvidenceBaseSchema, validateExactUtf8, validateResearchEvidence, providerResponseResearchEvidenceSchema, decisionCandidateResearchEvidenceSchema, researchEvidenceSchema;
+var EXTERNAL_INFERENCE_CONTRACT_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION, EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION, EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION, EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, LEGACY_EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION, EXTERNAL_INFERENCE_INPUT_HASH_DOMAIN, MAX_EXTERNAL_INFERENCE_STATUS_HOSTS, MAX_GENERATION, MAX_SAFE_INTEGER, MAX_PROMPT_BYTES, MAX_IMMUTABLE_JOB_INPUT_BYTES, MAX_CANDIDATE_PLAINTEXT_BYTES, MAX_CIPHERTEXT_CHARS, SHA256_INITIAL_STATE, SHA256_ROUND_CONSTANTS, rotateRight, sha256BytesHex, sha256Utf8Hex, computeImmutableJobInputSha256, identifierSchema, operationIdentifierSchema, sha256HexSchema, generationSchema, zeroBasedGenerationSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, sqlIntegerTokenCountSchema, timestampSchema, safeCodeSchema, externalInferenceAdapterIdSchema, reasoningEffortSchema, modelNameSchema, displayNameSchema, authenticatedAccountEmailSchema, protocolVersionSchema, base64UrlAlphabet, isCanonicalBase64Url, base64Url32BytesSchema, base64UrlNonceSchema, base64UrlCiphertextSchema, claimHandleSchema, boundedJsonTextSchema, boundedPromptTextSchema, laneSchema, botModeSchema, executionModeSchema, responseModeSchema, dispatchOutcomeSchema, responseOutcomeSchema, nativeModelControllerSchema, externalAgentModelControllerSchema, externalAgentUnboundControllerSchema, orderedFallbackHostIdsSchema, externalInferenceFallbackHostIdsSchema, liveModelControllerSchema, snapshotModelControllerSchema, modelIdentityMappingSchema, advertisedModelSchema, hostAdvertisementSchema, envelopeAadSchema, validateEnvelopeAad, commonEnvelopeShape, sealedKeyWrapEnvelopeSchema, sealedInputEnvelopeSchema, sealedCandidateEnvelopeSchema, sealedEnvelopeSchema, screenerCandidateRuntimeBindingSchema, screenerClientLeaseBindingSchema, screenerRuntimeBindingSchema, serverRuntimeBindingSchema, clientRuntimeBindingSchema, runtimeBindingSchema, immutableJobInputSchema, canonicalizeJsonValue, serializeImmutableJobInput, reportedTokenUsageSchema, unavailableTokenUsageSchema, tokenUsageSchema, agentConnectRequestSchema, agentNextRequestSchema, agentHeartbeatRequestSchema, emptyAgentNextResultSchema, claimedAgentNextResultSchema, agentNextResultSchema, agentCompleteRequestSchema, agentFailRequestSchema, requestedModelSelectionSchema, completedModelProvenanceSchema, attemptModelProvenanceSchema, providerWeeklyQuotaReadSchema, hostHeartbeatRequestSchema, jobClaimRequestSchema, emptyJobClaimSchema, claimedJobSchema, jobClaimResultSchema, attemptStartRequestSchema, jobHeartbeatRequestSchema, continueHeartbeatDirectiveSchema, cancelHeartbeatDirectiveSchema, jobHeartbeatResultSchema, adapterOutcomeEvidenceSchema, completionBaseShape, validateCompletion, providerResponseCompletionSchema, decisionCandidateCompletionSchema, jobCompleteRequestSchema, jobFailRequestSchema, jobCancelRequestSchema, jobCancellationReceiptSchema, jobDeliveryRequestSchema, deliveryBaseShape, validateDeliveryCandidate, providerResponseDeliverySchema, decisionCandidateDeliverySchema, jobDeliveryResultSchema, jobConsumptionRequestSchema, jobConsumptionReceiptSchema, jobStateSchema, jobStatusReadSchema, hostStatusReadSchema, controllerBindingStatusReadSchema, queueStatusReadSchema, outcomeStatusReadSchema, externalInferenceVolumeWindowReadSchema, externalInferenceFailureCountReadSchema, externalInferenceHostDiagnosticsReadSchema, externalInferenceProfileActivityReadSchema, externalInferenceStatusReadSchema, nativeResearchEvidenceSourceSchema, externalAgentResearchEvidenceSourceSchema, researchEvidenceSourceSchema, reportedResearchTokenUsageSchema, unavailableResearchTokenUsageSchema, researchTokenUsageSchema, externalInferenceProductLineageBaseShape, traderExternalInferenceProductLineageSchema, decisionChatExternalInferenceProductLineageSchema, screenerExternalInferenceProductLineageSchema, externalInferenceProductLineageSchema, normalProductLinkageSchema, evidenceMaterializationMarkerSchema, deliveredExternalAgentSourceIdentitySchema, deliveredRequestEvidenceSchema, researchEvidenceBaseShape, researchEvidenceBaseSchema, validateExactUtf8, validateResearchEvidence, providerResponseResearchEvidenceSchema, decisionCandidateResearchEvidenceSchema, researchEvidenceSchema;
 var init_external_inference_contract = __esm({
   "lib/external-inference-contract.ts"() {
     "use strict";
@@ -14646,6 +14646,15 @@ var init_external_inference_contract = __esm({
       response_mode_hint: responseModeSchema,
       binding_state: external_exports.literal("rebind_required")
     });
+    orderedFallbackHostIdsSchema = external_exports.array(identifierSchema).max(127).refine(
+      (values) => new Set(values).size === values.length,
+      { message: "fallback host IDs must be unique" }
+    );
+    externalInferenceFallbackHostIdsSchema = external_exports.strictObject({
+      main: orderedFallbackHostIdsSchema,
+      review: orderedFallbackHostIdsSchema,
+      screener: orderedFallbackHostIdsSchema
+    });
     liveModelControllerSchema = external_exports.discriminatedUnion("kind", [
       nativeModelControllerSchema,
       externalAgentModelControllerSchema
@@ -16245,6 +16254,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 +16731,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 +17250,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
+    });
   }
 });
 
@@ -19382,7 +19505,7 @@ async function logoutCodexSubscription(options) {
     await session.close();
   }
 }
-var CODEX_INFERENCE_PERMISSION_PROFILE, CODEX_REASONING_CONTENT_MAX_UTF8_BYTES, CODEX_REASONING_SUMMARY_MAX_UTF8_BYTES, CODEX_ACCOUNT_PLAN_TYPES, CodexAppServerError, objectOrNull, finiteToken, tokenUsageFromBreakdown, usageFromNotification, validPlanType, nonnegativeSafeIntegerOrNull, nonnegativeFiniteNumberOrNull, parseRateLimitWindow, RATE_LIMIT_REACHED_TYPES, DEFAULT_CODEX_QUOTA_COOLDOWN_MS, MAX_CODEX_QUOTA_COOLDOWN_MS, CODEX_TRANSIENT_RATE_LIMIT_COOLDOWN_MS, parseRateLimitSnapshot, codexRateLimitRetryAtMs, codexAccountRateLimitReached, forbiddenMethod, forbiddenTerminalItem, classifyCodexTurnFailure, scrubbedCodexEnvironment, killWindowsProcessTree, appServerArgs, GUARDIAN_SCRIPT, WINDOWS_RECEIPT_REPLACE_ERROR_CODES, replaceCodexGuardianReceiptFile, writeCodexGuardianSpawnIntent, parseGuardianReceipt, readCodexGuardianReceipt, waitForCodexGuardianState, defaultSpawn, CodexAppServerSession;
+var CODEX_INFERENCE_PERMISSION_PROFILE, CODEX_REASONING_CONTENT_MAX_UTF8_BYTES, CODEX_REASONING_SUMMARY_MAX_UTF8_BYTES, CODEX_ACCOUNT_PLAN_TYPES, CodexAppServerError, objectOrNull, finiteToken, tokenUsageFromBreakdown, usageFromNotification, validPlanType, nonnegativeSafeIntegerOrNull, nonnegativeFiniteNumberOrNull, parseRateLimitWindow, RATE_LIMIT_REACHED_TYPES, DEFAULT_CODEX_QUOTA_COOLDOWN_MS, MAX_CODEX_QUOTA_COOLDOWN_MS, CODEX_TRANSIENT_RATE_LIMIT_COOLDOWN_MS, parseRateLimitSnapshot, codexRateLimitRetryAtMs, codexAccountRateLimitReached, forbiddenMethod, forbiddenTerminalItem, classifyCodexTurnFailure, scrubbedCodexEnvironment, killWindowsProcessTree, appServerArgs, GUARDIAN_SCRIPT, WINDOWS_RECEIPT_REPLACE_ERROR_CODES, MAX_RETIRED_RESPONSE_IDS, LATE_RESPONSE_SAFE_METHODS, replaceCodexGuardianReceiptFile, writeCodexGuardianSpawnIntent, parseGuardianReceipt, readCodexGuardianReceipt, waitForCodexGuardianState, defaultSpawn, CodexAppServerSession;
 var init_codex_app_server = __esm({
   "lib/inference-host/codex-app-server.ts"() {
     "use strict";
@@ -19845,6 +19968,8 @@ child.once('close', async () => {
       "ENOTEMPTY",
       "EPERM"
     ]);
+    MAX_RETIRED_RESPONSE_IDS = 256;
+    LATE_RESPONSE_SAFE_METHODS = /* @__PURE__ */ new Set(["account/rateLimits/read"]);
     replaceCodexGuardianReceiptFile = async (temporaryPath, receiptPath, options = {}) => {
       const platform = options.platform ?? process.platform;
       const renameFile = options.renameFile ?? rename2;
@@ -19967,6 +20092,7 @@ child.once('close', async () => {
     CodexAppServerSession = class _CodexAppServerSession {
       constructor(options) {
         this.pending = /* @__PURE__ */ new Map();
+        this.retiredResponseIds = /* @__PURE__ */ new Map();
         this.notificationListeners = /* @__PURE__ */ new Set();
         this.fatalListeners = /* @__PURE__ */ new Set();
         this.accountLoginCompletions = /* @__PURE__ */ new Map();
@@ -20105,6 +20231,9 @@ child.once('close', async () => {
         if (typeof id2 === "number" && Number.isSafeInteger(id2) && !("method" in message)) {
           const pending = this.pending.get(id2);
           if (!pending) {
+            const retiredMethod = this.retiredResponseIds.get(id2);
+            this.retiredResponseIds.delete(id2);
+            if (retiredMethod && LATE_RESPONSE_SAFE_METHODS.has(retiredMethod)) return;
             this.failTransport("unexpected_response_id");
             return;
           }
@@ -20169,6 +20298,14 @@ child.once('close', async () => {
         this.pending.clear();
         for (const listener of this.fatalListeners) listener(this.fatalError);
       }
+      retireResponseId(id2, method) {
+        this.retiredResponseIds.set(id2, method);
+        while (this.retiredResponseIds.size > MAX_RETIRED_RESPONSE_IDS) {
+          const oldest = this.retiredResponseIds.keys().next().value;
+          if (typeof oldest !== "number") break;
+          this.retiredResponseIds.delete(oldest);
+        }
+      }
       write(message) {
         if (this.closed || this.fatalError || this.process.exitCode !== null) {
           throw this.fatalError ?? new CodexAppServerError({
@@ -20207,6 +20344,7 @@ child.once('close', async () => {
           const pending = { resolve: resolve6, reject, timer: null, abortCleanup: null };
           pending.timer = setTimeout(() => {
             this.pending.delete(id2);
+            this.retireResponseId(id2, method);
             pending.abortCleanup?.();
             reject(new CodexAppServerError({
               message: "Codex app-server request timed out.",
@@ -20218,6 +20356,7 @@ child.once('close', async () => {
           if (options.signal) {
             const onAbort = () => {
               this.pending.delete(id2);
+              this.retireResponseId(id2, method);
               if (pending.timer) clearTimeout(pending.timer);
               pending.abortCleanup?.();
               reject(new CodexAppServerError({
@@ -22110,9 +22249,21 @@ var init_codex_adapter = __esm({
               dispatchOutcome: checkpoint.dispatchOutcome
             });
           }
-          const receipt = await readCodexGuardianReceipt(checkpoint.processReceiptPath);
-          if (checkpoint.processState === "terminated" || receipt === null || receipt.state === "terminated") {
-            await rm3(checkpoint.processReceiptPath, { force: true });
+          let sharedReceiptStillRequired = true;
+          if (recoveryHooks.loadAll) {
+            try {
+              const checkpoints = await recoveryHooks.loadAll();
+              const receiptPath = resolve3(checkpoint.processReceiptPath);
+              sharedReceiptStillRequired = Object.values(checkpoints).some((candidate) => candidate.attemptId !== attemptId && !candidate.cleanupConfirmed && candidate.processReceiptPath !== null && resolve3(candidate.processReceiptPath) === receiptPath);
+            } catch {
+              sharedReceiptStillRequired = true;
+            }
+          }
+          if (!sharedReceiptStillRequired) {
+            const receipt = await readCodexGuardianReceipt(checkpoint.processReceiptPath);
+            if (checkpoint.processState === "terminated" || receipt === null || receipt.state === "terminated") {
+              await rm3(checkpoint.processReceiptPath, { force: true });
+            }
           }
         }
         await recoveryHooks.clear(attemptId);
@@ -31510,9 +31661,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 +31799,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 +32444,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 +32511,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 +32535,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 +32804,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 +32967,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 +32985,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 +33063,7 @@ Waiting for approval...
               store
             });
             remoteCleanupConfirmed = true;
+            await store.removeRecovery?.();
           } catch {
             if (!store.writeRecovery) {
               throw new Error(
@@ -32864,6 +33082,9 @@ Waiting for approval...
           }
           throw stateError;
         }
+        localStateCommitted = true;
+        await store.removeRecovery?.();
+        await clearInferenceHostCredentialContextTransition(config2);
         return {
           exitCode: 0,
           stdout: render({
@@ -32876,8 +33097,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 +33342,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 +33376,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 +33419,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 +33434,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 +33449,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 +33478,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 +33503,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 +34051,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 +34123,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.39",
   "description": "VTX Macro CLI, MCP server, and durable subscription inference host.",
   "type": "module",
   "license": "UNLICENSED",