@vtxmacro/cli 2026.8.25 → 2026.8.27

package/README.md

@@ -51,12 +51,13 @@ credential.
 
 Before the first Codex login, enable **Device code authorization for Codex** in
 ChatGPT Security settings. Only enter a device code from a login you initiated,
-and never share it. The automated host advertises `gpt-5.6-sol` with
-`medium`, `high`, and `xhigh` reasoning effort. 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.
+and never share it. The automated host reads the authenticated Codex model
+picker and advertises every visible model with that model's exact display name,
+default effort, and supported reasoning efforts. Hidden Codex entries are not
+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.
 
 ```bash
 vtx inference-host login

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.25",
+      package_version: "2026.8.27",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       platforms: {
@@ -19074,10 +19074,20 @@ async function preflightCodexSubscription(options) {
       });
     }
     const rateLimits = await session.readAccountRateLimits(options.deadlineAtMs, options.signal);
+    const modelCapabilities = await session.readModelCapabilities(options.deadlineAtMs, options.signal);
+    if (modelCapabilities.length === 0) {
+      throw new CodexAppServerError({
+        message: "Codex did not return any visible models with supported reasoning efforts.",
+        category: "model",
+        code: "model_catalog_empty",
+        retryable: false
+      });
+    }
     return {
       authenticated_account_email: account.authenticatedChatGptAccount.email,
       authenticated_account_plan: account.authenticatedChatGptAccount.planType,
-      rate_limits: rateLimits
+      rate_limits: rateLimits,
+      model_capabilities: modelCapabilities
     };
   } finally {
     await session.close();
@@ -20144,7 +20154,7 @@ child.once('close', async () => {
             });
           }
           const result2 = await this.request("model/list", {
-            includeHidden: true,
+            includeHidden: false,
             ...cursor ? { cursor } : {}
           }, {
             timeoutMs: Math.max(1, deadlineAtMs - Date.now()),
@@ -20154,17 +20164,24 @@ child.once('close', async () => {
           for (const raw of data) {
             const candidate = objectOrNull(raw);
             if (!candidate) continue;
-            const id2 = typeof candidate.id === "string" && candidate.id.trim() ? candidate.id.trim() : null;
-            const model = typeof candidate.model === "string" && candidate.model.trim() ? candidate.model.trim() : null;
-            if (!id2 && !model) continue;
+            const id2 = typeof candidate.id === "string" ? candidate.id.trim() : "";
+            const model = typeof candidate.model === "string" ? candidate.model.trim() : "";
+            const displayName = typeof candidate.displayName === "string" ? candidate.displayName.trim() : "";
+            const hidden = candidate.hidden === true;
             const supportedReasoningEfforts = Array.isArray(candidate.supportedReasoningEfforts) ? candidate.supportedReasoningEfforts.flatMap((item) => {
               const reasoningEffort = objectOrNull(item)?.reasoningEffort;
               return typeof reasoningEffort === "string" && reasoningEffort.trim() ? [reasoningEffort.trim()] : [];
             }) : [];
+            const defaultReasoningEffort = typeof candidate.defaultReasoningEffort === "string" ? candidate.defaultReasoningEffort.trim() : "";
+            if (!id2 || !model || !displayName || hidden || supportedReasoningEfforts.length === 0 || new Set(supportedReasoningEfforts).size !== supportedReasoningEfforts.length || !supportedReasoningEfforts.includes(defaultReasoningEffort)) continue;
             capabilities.push(Object.freeze({
               id: id2,
               model,
-              supportedReasoningEfforts: Object.freeze(supportedReasoningEfforts)
+              displayName,
+              hidden,
+              supportedReasoningEfforts: Object.freeze(supportedReasoningEfforts),
+              defaultReasoningEffort,
+              isDefault: candidate.isDefault === true
             }));
           }
           cursor = typeof result2.nextCursor === "string" && result2.nextCursor ? result2.nextCursor : null;
@@ -20952,7 +20969,7 @@ import {
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { tmpdir as tmpdir2 } from "node:os";
 import { isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
-var INITIAL_CODEX_INFERENCE_MODEL, SUPPORTED_CODEX_REASONING_EFFORTS, MAX_PROMPT_BYTES2, tokenUsageReceiptSchema, turnResultReceiptSchema, terminalReceiptSchema, recoveryCheckpointSchema, recoveryFileSchema, FileCodexAttemptRecoveryStore, utf8Bytes, assertAttemptActive, tomlString, permissionConfig, ensureDedicatedCodexHome, createIsolatedCodexAttemptResources, createIsolatedCodexHostResources, validateAttemptInput, isStrictDescendant, assertRecoveryResourceScope, removeRecoveredThread, confirmGuardianTerminatedForRecovery, reconcileCodexAttemptRecovery, CodexSubscriptionAdapter;
+var MAX_PROMPT_BYTES2, CODEX_MODEL_NAME_PATTERN, CODEX_REASONING_EFFORT_PATTERN, tokenUsageReceiptSchema, turnResultReceiptSchema, terminalReceiptSchema, recoveryCheckpointSchema, recoveryFileSchema, FileCodexAttemptRecoveryStore, utf8Bytes, assertAttemptActive, tomlString, permissionConfig, ensureDedicatedCodexHome, createIsolatedCodexAttemptResources, createIsolatedCodexHostResources, validateAttemptInput, isStrictDescendant, assertRecoveryResourceScope, removeRecoveredThread, confirmGuardianTerminatedForRecovery, reconcileCodexAttemptRecovery, CodexSubscriptionAdapter;
 var init_codex_adapter = __esm({
   "lib/inference-host/codex-adapter.ts"() {
     "use strict";
@@ -20960,16 +20977,9 @@ var init_codex_adapter = __esm({
     init_codex_app_server();
     init_codex_binary();
     init_config();
-    INITIAL_CODEX_INFERENCE_MODEL = "gpt-5.6-sol";
-    SUPPORTED_CODEX_REASONING_EFFORTS = [
-      "low",
-      "medium",
-      "high",
-      "xhigh",
-      "max",
-      "ultra"
-    ];
     MAX_PROMPT_BYTES2 = 3e5;
+    CODEX_MODEL_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/u;
+    CODEX_REASONING_EFFORT_PATTERN = /^[a-z][a-z0-9_-]{0,31}$/u;
     tokenUsageReceiptSchema = external_exports.strictObject({
       inputTokens: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
       cachedInputTokens: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
@@ -20981,10 +20991,10 @@ var init_codex_adapter = __esm({
     });
     turnResultReceiptSchema = external_exports.strictObject({
       text: external_exports.string().min(1).max(MAX_PROMPT_BYTES2),
-      requestedModel: external_exports.literal(INITIAL_CODEX_INFERENCE_MODEL),
-      effectiveModel: external_exports.literal(INITIAL_CODEX_INFERENCE_MODEL),
-      requestedReasoningEffort: external_exports.enum(SUPPORTED_CODEX_REASONING_EFFORTS),
-      effectiveReasoningEffort: external_exports.enum(SUPPORTED_CODEX_REASONING_EFFORTS),
+      requestedModel: external_exports.string().regex(CODEX_MODEL_NAME_PATTERN),
+      effectiveModel: external_exports.string().regex(CODEX_MODEL_NAME_PATTERN),
+      requestedReasoningEffort: external_exports.string().regex(CODEX_REASONING_EFFORT_PATTERN),
+      effectiveReasoningEffort: external_exports.string().regex(CODEX_REASONING_EFFORT_PATTERN),
       adapterRequestId: external_exports.string().min(1).max(512),
       adapterResponseId: external_exports.string().min(1).max(512),
       usage: tokenUsageReceiptSchema,
@@ -20992,7 +21002,7 @@ var init_codex_adapter = __esm({
       timeToFirstTokenMs: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).nullable(),
       terminalStatus: external_exports.literal("completed")
     }).superRefine((value, context) => {
-      if (value.usage.cachedInputTokens > value.usage.inputTokens || value.usage.reasoningOutputTokens > value.usage.outputTokens || value.usage.totalTokens !== value.usage.inputTokens + value.usage.outputTokens || value.effectiveReasoningEffort !== value.requestedReasoningEffort) {
+      if (value.usage.cachedInputTokens > value.usage.inputTokens || value.usage.reasoningOutputTokens > value.usage.outputTokens || value.usage.totalTokens !== value.usage.inputTokens + value.usage.outputTokens || value.effectiveModel !== value.requestedModel || value.effectiveReasoningEffort !== value.requestedReasoningEffort) {
         context.addIssue({ code: "custom", message: "Invalid Codex recovery usage or identity." });
       }
     });
@@ -21215,9 +21225,9 @@ var init_codex_adapter = __esm({
           retryable: false
         });
       }
-      if (input.requestedModel !== INITIAL_CODEX_INFERENCE_MODEL || !SUPPORTED_CODEX_REASONING_EFFORTS.includes(input.requestedReasoningEffort)) {
+      if (!CODEX_MODEL_NAME_PATTERN.test(input.requestedModel) || !CODEX_REASONING_EFFORT_PATTERN.test(input.requestedReasoningEffort)) {
         throw new CodexAppServerError({
-          message: "Codex model selection is not admitted by the pinned adapter.",
+          message: "Codex model selection is not a valid catalog identity.",
           category: "model",
           code: "model_selection_not_admitted",
           retryable: false
@@ -28644,7 +28654,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_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, DEFAULT_MAX_CONCURRENCY, MIN_SLEEP_MS, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, CODEX_INFERENCE_ADVERTISED_MODEL, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, 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_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, DEFAULT_MAX_CONCURRENCY, MIN_SLEEP_MS, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, buildCodexInferenceAdvertisedModels, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, 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";
@@ -28652,7 +28662,6 @@ var init_runner = __esm({
     init_external_inference_contract();
     init_config();
     init_credential_store();
-    init_codex_adapter();
     init_codex_app_server();
     init_crypto();
     init_mcp_client();
@@ -28669,30 +28678,57 @@ var init_runner = __esm({
     MIN_SLEEP_MS = 10;
     DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS = 5 * 60 * 1e3;
     MIN_CLAIM_START_WINDOW_MS = 5e3;
-    CODEX_INFERENCE_ADVERTISED_MODEL = Object.freeze({
-      model_id: INITIAL_CODEX_INFERENCE_MODEL,
-      label: "Codex GPT-5.6 Sol",
-      adapter: "codex",
-      supported_lanes: ["main", "review", "screener"],
-      supported_reasoning_efforts: [...SUPPORTED_CODEX_REASONING_EFFORTS],
-      default_reasoning_effort: "medium",
-      supported_response_modes: ["provider_response", "decision_candidate"],
-      allowed_model_identities: [{
-        requested_model: INITIAL_CODEX_INFERENCE_MODEL,
-        effective_models: [INITIAL_CODEX_INFERENCE_MODEL]
-      }],
-      structured_output: true,
-      same_attempt_recovery: true
-    });
+    buildCodexInferenceAdvertisedModels = (capabilities, adapterRuntimeVersion) => {
+      const visible = capabilities.filter((capability) => !capability.hidden);
+      if (visible.length === 0 || visible.length > 64) {
+        throw new InferenceHostRunnerError(
+          "invalid_configuration",
+          visible.length === 0 ? "Codex did not return any visible models that VTX can advertise." : "Codex returned more models than the VTX advertisement contract can represent."
+        );
+      }
+      const models = visible.map((capability) => ({
+        model_id: capability.model,
+        label: capability.displayName,
+        adapter: "codex",
+        supported_lanes: ["main", "review", "screener"],
+        supported_reasoning_efforts: [...capability.supportedReasoningEfforts],
+        default_reasoning_effort: capability.defaultReasoningEffort,
+        supported_response_modes: ["provider_response", "decision_candidate"],
+        allowed_model_identities: [{
+          requested_model: capability.model,
+          effective_models: [capability.model]
+        }],
+        structured_output: true,
+        same_attempt_recovery: true,
+        adapter_runtime_version: adapterRuntimeVersion
+      }));
+      if (new Set(models.map((model) => model.model_id)).size !== models.length) {
+        throw new InferenceHostRunnerError(
+          "invalid_configuration",
+          "Codex returned duplicate runtime model identities."
+        );
+      }
+      return models;
+    };
     FileInferenceHostRuntimeReceiptStore = class {
-      constructor(path) {
+      constructor(path, readPrivateFile = readInferencePrivateFile) {
         this.path = path;
+        this.readPrivateFile = readPrivateFile;
       }
       async read() {
-        const raw = await readInferencePrivateFile(
-          this.path,
-          "Inference host runtime receipt file"
-        );
+        let raw = null;
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+          try {
+            raw = await this.readPrivateFile(
+              this.path,
+              "Inference host runtime receipt file"
+            );
+            break;
+          } catch (error48) {
+            const changedDuringRead = error48 instanceof Error && error48.message === "Inference host runtime receipt file changed while it was opened.";
+            if (!changedDuringRead || attempt === 2) throw error48;
+          }
+        }
         if (raw === null) return null;
         try {
           return validateRuntimeReceipt(JSON.parse(raw));
@@ -28926,6 +28962,10 @@ var init_runner = __esm({
         );
       }
       return {
+        advertisedModels: buildCodexInferenceAdvertisedModels(
+          options.codexModelCapabilities,
+          options.adapterRuntimeVersion
+        ),
         maxConcurrency: finitePositiveOption(
           options.maxConcurrency,
           DEFAULT_MAX_CONCURRENCY,
@@ -29397,12 +29437,7 @@ var init_runner = __esm({
                 health,
                 advertised_at: isoAt(advertisedAt),
                 expires_at: isoAt(advertisedAt + settings.advertisementTtlMs),
-                models: [{
-                  ...CODEX_INFERENCE_ADVERTISED_MODEL,
-                  supported_lanes: [...CODEX_INFERENCE_ADVERTISED_MODEL.supported_lanes],
-                  supported_response_modes: [...CODEX_INFERENCE_ADVERTISED_MODEL.supported_response_modes],
-                  adapter_runtime_version: this.options.adapterRuntimeVersion
-                }]
+                models: settings.advertisedModels
               });
               receipt = {
                 ...receipt,
@@ -29983,7 +30018,7 @@ var init_runner = __esm({
             systemPrompt: jobInput.system_prompt,
             userPrompt: jobInput.user_prompt,
             outputSchemaJson: outputContract.adapterSchemaJson,
-            requestedModel: INITIAL_CODEX_INFERENCE_MODEL,
+            requestedModel: jobInput.requested_model,
             requestedReasoningEffort: jobInput.requested_reasoning_effort,
             deadlineAtMs: Date.parse(jobInput.deadline_at),
             signal: attemptAbort.signal
@@ -30210,9 +30245,10 @@ var init_runner = __esm({
         }
       }
       validateImmutableSelection(jobInput) {
-        if (jobInput.requested_model !== INITIAL_CODEX_INFERENCE_MODEL || !SUPPORTED_CODEX_REASONING_EFFORTS.includes(
-          jobInput.requested_reasoning_effort
-        ) || jobInput.controller.model_id !== INITIAL_CODEX_INFERENCE_MODEL || jobInput.controller.reasoning_effort !== jobInput.requested_reasoning_effort) {
+        const advertisedModel = this.options.codexModelCapabilities.find(
+          (candidate) => !candidate.hidden && candidate.model === jobInput.requested_model
+        );
+        if (!advertisedModel || !advertisedModel.supportedReasoningEfforts.includes(jobInput.requested_reasoning_effort) || jobInput.controller.model_id !== jobInput.requested_model || jobInput.controller.reasoning_effort !== jobInput.requested_reasoning_effort) {
           throw new InferenceHostRunnerError(
             "unsupported_model_selection",
             "The claimed model or reasoning effort was not advertised by this host."
@@ -30923,7 +30959,7 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
       return { exitCode: 0, stdout: INFERENCE_HOST_HELP, stderr: "" };
     }
     const parsed = parseInferenceHostArgs(argv2, env);
-    const config2 = resolveInferenceHostConfig(env);
+    const config2 = await resolveInferenceHostCommandConfig(parsed, env);
     if (parsed.command === "login") {
       return await login(config2, parsed, env, dependencies, warnings);
     }
@@ -30990,7 +31026,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, parsePositiveInteger, 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;
+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, parsePositiveInteger, 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 init_cli = __esm({
   "lib/inference-host/cli.ts"() {
     "use strict";
@@ -31368,6 +31404,7 @@ Durable service:
         authenticatedAccountEmail: options.authenticatedAccountEmail,
         authenticatedAccountPlan: options.authenticatedAccountPlan,
         codexRateLimits: options.codexRateLimits,
+        codexModelCapabilities: options.codexModelCapabilities,
         protocolVersion: EXTERNAL_INFERENCE_CONTRACT_VERSION,
         adapterRuntimeVersion: INFERENCE_HOST_CLI_VERSION,
         maxConcurrency: options.maxConcurrency,
@@ -31868,6 +31905,7 @@ Waiting for approval...
             authenticatedAccountEmail: preflight?.authenticated_account_email ?? null,
             authenticatedAccountPlan: preflight?.authenticated_account_plan ?? null,
             codexRateLimits: preflight?.rate_limits ?? null,
+            codexModelCapabilities: preflight?.model_capabilities ?? [],
             maxConcurrency: parsed.maxConcurrency,
             once: parsed.once,
             env,
@@ -32456,6 +32494,29 @@ Waiting for approval...
       }
       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) => {
+      const baseConfig = resolveInferenceHostConfig(env);
+      if (!commandUsesInstalledServiceCredentials(parsed) || hasExplicitCredentialStoreConfiguration(env)) {
+        return baseConfig;
+      }
+      const manifestPath = `${baseConfig.statePath}.service.json`;
+      const manifest = await readInferenceHostServiceManifest(manifestPath);
+      if (!manifest) return baseConfig;
+      const installedConfig = resolveInferenceHostConfig({
+        ...env,
+        ...manifest.runtime_environment
+      });
+      if (resolve5(installedConfig.statePath) !== resolve5(baseConfig.statePath)) {
+        throw new Error(
+          "Installed inference-host service manifest does not match the requested local state path."
+        );
+      }
+      return installedConfig;
+    };
   }
 });
 

package/package.json

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