@vtxmacro/cli 2026.8.31 → 2026.8.32

package/README.md

@@ -58,6 +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.
 
 ```bash
 vtx inference-host login
@@ -82,10 +86,13 @@ 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`.
 
-Automated hosts use three concurrent slots per subscription by default. Set a
-bounded value from 1 through 8 with `--max-concurrency`. Slots share the live
-subscription rate-limit gate and cooldown; this does not guarantee capacity
-beyond the authenticated account's current entitlement.
+Automated hosts do not impose a subscription-specific profile-count or
+concurrency limit by default. Set an explicit positive integer with
+`--max-concurrency` when you want a local limit. Every active turn shares the live subscription
+rate-limit gate and cooldown; unlimited local admission does not guarantee
+capacity beyond the authenticated account's current entitlement. Updating from
+an older bounded host removes its previous numeric limit; run
+`service install --max-concurrency <positive-integer>` only to add one back.
 
 This durable host uses a separate least-privilege `insights:inference`
 OAuth grant. It also keeps its ChatGPT subscription login in a dedicated private
@@ -94,6 +101,9 @@ session. The per-user OS service starts immediately, starts again at login, and
 reconnects after sleep, network loss, or a worker exit. Stopping a VTX bot leaves
 the provider online and idle. Use `vtx inference-host run` only for foreground
 diagnostics. VTX logout/revoke and Codex logout are intentionally separate operations.
+JSON foreground and service logs include safe concurrency, latency, token,
+failure-code, and cooldown events without prompts, responses, or credentials.
+Use `service logs --instance <name>` to isolate one subscription.
 
 Use `vtx inference-host --help` for command discovery. The VTX login verifies
 that the selected credential store can read back the exact saved grant. If an

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.31",
+      package_version: "2026.8.32",
       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, 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, 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, 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, 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 init_external_inference_contract = __esm({
   "lib/external-inference-contract.ts"() {
     "use strict";
@@ -15181,6 +15181,22 @@ var init_external_inference_contract = __esm({
         });
       }
     });
+    providerWeeklyQuotaReadSchema = external_exports.strictObject({
+      source: external_exports.literal("codex_app_server"),
+      used_percent: external_exports.number().finite().min(0).max(1e6),
+      resets_at: timestampSchema,
+      observed_at: timestampSchema
+    }).superRefine((value, context) => {
+      const observedAt = Date.parse(value.observed_at);
+      const resetsAt = Date.parse(value.resets_at);
+      if (resetsAt <= observedAt || resetsAt > observedAt + 8 * 24 * 60 * 60 * 1e3) {
+        context.addIssue({
+          code: "custom",
+          message: "weekly quota reset must follow observation within eight days",
+          path: ["resets_at"]
+        });
+      }
+    });
     hostHeartbeatRequestSchema = external_exports.strictObject({
       schema_version: external_exports.literal("external_inference_host_heartbeat_v1"),
       contract_version: external_exports.literal(EXTERNAL_INFERENCE_CONTRACT_VERSION),
@@ -15192,6 +15208,7 @@ var init_external_inference_contract = __esm({
       status: external_exports.enum(["healthy", "degraded", "draining"]),
       active_attempts: nonNegativeSafeIntegerSchema,
       available_slots: nonNegativeSafeIntegerSchema,
+      provider_weekly_quota: providerWeeklyQuotaReadSchema.nullable().optional(),
       observed_at: timestampSchema
     });
     jobClaimRequestSchema = external_exports.strictObject({
@@ -15611,6 +15628,44 @@ var init_external_inference_contract = __esm({
       cancelled: nonNegativeSafeIntegerSchema,
       expired: nonNegativeSafeIntegerSchema
     });
+    externalInferenceVolumeWindowReadSchema = external_exports.strictObject({
+      window_seconds: positiveSafeIntegerSchema,
+      requests_started: nonNegativeSafeIntegerSchema,
+      profiles_with_requests: nonNegativeSafeIntegerSchema,
+      attempts_succeeded: nonNegativeSafeIntegerSchema,
+      attempts_failed: nonNegativeSafeIntegerSchema,
+      rate_limited: nonNegativeSafeIntegerSchema,
+      quota_exhausted: nonNegativeSafeIntegerSchema,
+      usage_reported: nonNegativeSafeIntegerSchema,
+      usage_unavailable: nonNegativeSafeIntegerSchema,
+      input_tokens: nonNegativeSafeIntegerSchema,
+      output_tokens: nonNegativeSafeIntegerSchema,
+      total_tokens: nonNegativeSafeIntegerSchema,
+      reasoning_tokens: nonNegativeSafeIntegerSchema,
+      cached_input_tokens: nonNegativeSafeIntegerSchema
+    });
+    externalInferenceFailureCountReadSchema = external_exports.strictObject({
+      failure_category: safeCodeSchema.nullable(),
+      failure_code: safeCodeSchema,
+      count: positiveSafeIntegerSchema,
+      last_observed_at: timestampSchema
+    });
+    externalInferenceHostDiagnosticsReadSchema = external_exports.strictObject({
+      host_id: identifierSchema,
+      active_attempts: nonNegativeSafeIntegerSchema,
+      queue: queueStatusReadSchema,
+      last_second: externalInferenceVolumeWindowReadSchema,
+      last_minute: externalInferenceVolumeWindowReadSchema,
+      last_hour: externalInferenceVolumeWindowReadSchema,
+      last_day: externalInferenceVolumeWindowReadSchema,
+      last_week: externalInferenceVolumeWindowReadSchema,
+      recent_failures: external_exports.array(externalInferenceFailureCountReadSchema).max(32)
+    });
+    externalInferenceProfileActivityReadSchema = external_exports.strictObject({
+      last_hour: externalInferenceVolumeWindowReadSchema,
+      last_day: externalInferenceVolumeWindowReadSchema,
+      last_week: externalInferenceVolumeWindowReadSchema
+    });
     externalInferenceStatusReadSchema = external_exports.strictObject({
       schema_version: external_exports.literal("external_inference_status_v1"),
       contract_version: external_exports.literal(EXTERNAL_INFERENCE_CONTRACT_VERSION),
@@ -15618,8 +15673,11 @@ var init_external_inference_contract = __esm({
       catalog_generation: generationSchema,
       hosts: external_exports.array(hostStatusReadSchema).max(MAX_EXTERNAL_INFERENCE_STATUS_HOSTS),
       bindings: external_exports.array(controllerBindingStatusReadSchema).max(512),
+      binding_count: nonNegativeSafeIntegerSchema.optional().default(0),
+      bindings_truncated: external_exports.boolean().optional().default(false),
       queue: queueStatusReadSchema,
-      outcomes: outcomeStatusReadSchema
+      outcomes: outcomeStatusReadSchema,
+      host_diagnostics: external_exports.array(externalInferenceHostDiagnosticsReadSchema).max(MAX_EXTERNAL_INFERENCE_STATUS_HOSTS).optional().default([])
     });
     nativeResearchEvidenceSourceSchema = external_exports.strictObject({
       source: external_exports.literal("native"),
@@ -16522,14 +16580,12 @@ async function acquireInferenceHostProcessLock(path, dependencies = {}) {
     }
   };
 }
-var INFERENCE_CREDENTIAL_NAMESPACE, MAX_INFERENCE_PRIVATE_FILE_BYTES, DEFAULT_CODEX_HOST_CONCURRENCY, MAX_CODEX_HOST_CONCURRENCY, WINDOWS_PRIVATE_ACL_SCRIPT, windowsPrivateAclInvocation, 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_SCRIPT, windowsPrivateAclInvocation, 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 init_config = __esm({
   "lib/inference-host/config.ts"() {
     "use strict";
     INFERENCE_CREDENTIAL_NAMESPACE = "vtxmacro-insights-inference";
     MAX_INFERENCE_PRIVATE_FILE_BYTES = 16 * 1024 * 1024;
-    DEFAULT_CODEX_HOST_CONCURRENCY = 3;
-    MAX_CODEX_HOST_CONCURRENCY = 8;
     WINDOWS_PRIVATE_ACL_SCRIPT = `$ErrorActionPreference='Stop'
 $path=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($env:VTX_PRIVATE_PATH_B64))
 $kind=$env:VTX_PRIVATE_PATH_KIND
@@ -19183,6 +19239,7 @@ var init_codex_app_server = __esm({
         this.httpStatusCode = options.httpStatusCode ?? null;
         this.retryAtMs = options.retryAtMs ?? null;
         this.usage = options.usage ?? null;
+        this.rateLimits = options.rateLimits ?? null;
       }
     };
     objectOrNull = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -20694,6 +20751,7 @@ child.once('close', async () => {
             );
             const observedUsage = threadUsage ?? rawResponseUsage;
             let retryAtMs = null;
+            let observedRateLimits = null;
             if (failure.code === "quota_exceeded" || failure.httpStatusCode === 429) {
               const observedAtMs = Date.now();
               let accountLimitReached = failure.code === "quota_exceeded";
@@ -20703,9 +20761,12 @@ child.once('close', async () => {
                   observedAtMs + 5e3
                 );
                 if (metadataDeadlineAtMs <= observedAtMs) throw new Error("rate-limit deadline elapsed");
-                const rateLimits = await this.readAccountRateLimits(metadataDeadlineAtMs, request.signal);
-                accountLimitReached = accountLimitReached || codexAccountRateLimitReached(rateLimits);
-                retryAtMs = codexRateLimitRetryAtMs(rateLimits);
+                observedRateLimits = await this.readAccountRateLimits(
+                  metadataDeadlineAtMs,
+                  request.signal
+                );
+                accountLimitReached = accountLimitReached || codexAccountRateLimitReached(observedRateLimits);
+                retryAtMs = codexRateLimitRetryAtMs(observedRateLimits);
               } catch {
               }
               if (accountLimitReached) {
@@ -20735,7 +20796,8 @@ child.once('close', async () => {
               dispatchOutcome: "confirmed_dispatched",
               httpStatusCode: failure.httpStatusCode,
               retryAtMs,
-              usage: observedUsage
+              usage: observedUsage,
+              rateLimits: observedRateLimits
             });
           }
           const items = Array.isArray(terminal.items) ? terminal.items.map(objectOrNull) : [];
@@ -21567,6 +21629,23 @@ var init_codex_adapter = __esm({
         this.adapterClosePromise = null;
         this.dependencies = dependencies;
       }
+      async readAccountRateLimits(deadlineAtMs, signal) {
+        const codexHome = this.dependencies.codexHome;
+        if (!codexHome) {
+          throw new CodexAppServerError({
+            message: "Codex home is required to read account rate limits.",
+            category: "adapter",
+            code: "codex_home_required",
+            retryable: false
+          });
+        }
+        const durableSession = await this.acquireDurableSession(
+          codexHome,
+          deadlineAtMs,
+          signal
+        );
+        return await durableSession.session.readAccountRateLimits(deadlineAtMs, signal);
+      }
       async startDurableSession(codexHome, deadlineAtMs) {
         const binary = await (this.dependencies.resolveBinary ?? resolvePinnedCodexBinary)();
         const guardianManaged = Boolean(
@@ -28742,7 +28821,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, 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 import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, UNBOUNDED_AVAILABLE_SLOTS, buildCodexInferenceAdvertisedModels, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, 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";
@@ -28759,13 +28838,14 @@ var init_runner = __esm({
     DEFAULT_ADVERTISEMENT_TTL_MS = 12e4;
     DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS = 3e4;
     DEFAULT_HOST_HEARTBEAT_MS = 3e3;
+    DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS = 6e4;
     DEFAULT_ATTEMPT_HEARTBEAT_MS = 3e3;
     DEFAULT_DRAIN_TIMEOUT_MS = 3e4;
     DEFAULT_REMOTE_RETRY_LIMIT = 3;
-    DEFAULT_MAX_CONCURRENCY = 1;
     MIN_SLEEP_MS = 10;
     DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS = 5 * 60 * 1e3;
     MIN_CLAIM_START_WINDOW_MS = 5e3;
+    UNBOUNDED_AVAILABLE_SLOTS = Number.MAX_SAFE_INTEGER;
     buildCodexInferenceAdvertisedModels = (capabilities, adapterRuntimeVersion) => {
       const visible = capabilities.filter((capability) => !capability.hidden);
       if (visible.length === 0 || visible.length > 64) {
@@ -29019,6 +29099,19 @@ var init_runner = __esm({
       started_at: startedAt
     });
     isoAt = (milliseconds) => new Date(milliseconds).toISOString();
+    providerWeeklyQuotaFromRateLimits = (rateLimits, observedAtMs, currentTimeMs = observedAtMs) => {
+      if (!rateLimits) return null;
+      for (const window2 of [rateLimits.rateLimits.primary, rateLimits.rateLimits.secondary]) {
+        if (window2?.windowDurationMins !== 7 * 24 * 60 || window2.resetsAt === null || window2.resetsAt * 1e3 <= currentTimeMs) continue;
+        return {
+          source: "codex_app_server",
+          used_percent: window2.usedPercent,
+          resets_at: isoAt(window2.resetsAt * 1e3),
+          observed_at: isoAt(observedAtMs)
+        };
+      }
+      return null;
+    };
     finitePositiveOption = (value, fallback, label) => {
       const result2 = value ?? fallback;
       if (!Number.isSafeInteger(result2) || result2 < 1) {
@@ -29054,20 +29147,7 @@ var init_runner = __esm({
           options.codexModelCapabilities,
           options.adapterRuntimeVersion
         ),
-        maxConcurrency: (() => {
-          const value = finitePositiveOption(
-            options.maxConcurrency,
-            DEFAULT_MAX_CONCURRENCY,
-            "Maximum concurrency"
-          );
-          if (value > MAX_CODEX_HOST_CONCURRENCY) {
-            throw new InferenceHostRunnerError(
-              "invalid_configuration",
-              `Maximum concurrency must not exceed ${MAX_CODEX_HOST_CONCURRENCY}.`
-            );
-          }
-          return value;
-        })(),
+        maxConcurrency: options.maxConcurrency === null || options.maxConcurrency === void 0 ? null : finitePositiveOption(options.maxConcurrency, 1, "Maximum concurrency"),
         advertisementTtlMs,
         advertisementRefreshLeadMs,
         hostHeartbeatMs: finitePositiveOption(
@@ -29075,6 +29155,11 @@ var init_runner = __esm({
           DEFAULT_HOST_HEARTBEAT_MS,
           "Host heartbeat interval"
         ),
+        providerRateLimitRefreshMs: finitePositiveOption(
+          options.providerRateLimitRefreshMs,
+          DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS,
+          "Provider rate-limit refresh interval"
+        ),
         attemptHeartbeatMs: finitePositiveOption(
           options.attemptHeartbeatMs,
           DEFAULT_ATTEMPT_HEARTBEAT_MS,
@@ -29405,6 +29490,20 @@ var init_runner = __esm({
               "Inference host login is required before the runner can start."
             );
           }
+          const emitDiagnostic = (event, fields = {}) => {
+            try {
+              this.options.emitDiagnosticEvent?.({
+                schema_version: "vtx_inference_host_diagnostic_v1",
+                at: isoAt(now()),
+                event,
+                instance_name: this.options.instanceName ?? "default",
+                host_id: localState.host_id,
+                display_name: this.options.displayName,
+                ...fields
+              });
+            } catch {
+            }
+          };
           const accountKey = inferenceCredentialAccountKey({
             issuer: localState.issuer,
             clientId: localState.client_id,
@@ -29601,6 +29700,10 @@ var init_runner = __esm({
           if (!wasRegistered && receipt.registered && (!receipt.advertisement_expires_at || Date.parse(receipt.advertisement_expires_at) - now() <= settings.advertisementRefreshLeadMs)) {
             await publishAdvertisement("healthy", true);
           }
+          let providerRetryAtMs = this.options.codexRateLimits && codexAccountRateLimitReached(this.options.codexRateLimits) ? codexRateLimitRetryAtMs(this.options.codexRateLimits) ?? now() + DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS : null;
+          let providerCooldownReason = providerRetryAtMs === null ? null : "provider_limit_snapshot";
+          let providerRateLimits = this.options.codexRateLimits ?? null;
+          let providerRateLimitsObservedAtMs = now();
           const hostHeartbeat = async (status, requestOptions = {
             signal: this.options.signal
           }, retryRemote = true, allowOfflineProjection = false, definitiveReseedAttempt = 0) => {
@@ -29615,7 +29718,12 @@ var init_runner = __esm({
               sequence,
               status,
               active_attempts: active.size,
-              available_slots: Math.max(0, settings.maxConcurrency - active.size),
+              available_slots: settings.maxConcurrency === null ? UNBOUNDED_AVAILABLE_SLOTS - active.size : Math.max(0, settings.maxConcurrency - active.size),
+              provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
+                providerRateLimits,
+                providerRateLimitsObservedAtMs,
+                now()
+              ),
               observed_at: isoAt(now())
             };
             receipt = {
@@ -29657,10 +29765,21 @@ var init_runner = __esm({
           await hostHeartbeat("healthy");
           let nextHostHeartbeatAt = now() + settings.hostHeartbeatMs;
           let nextAdvertisementAttemptAt = 0;
-          let providerRetryAtMs = this.options.codexRateLimits && codexAccountRateLimitReached(this.options.codexRateLimits) ? codexRateLimitRetryAtMs(this.options.codexRateLimits) ?? now() + DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS : null;
+          let nextProviderRateLimitRefreshAt = now() + settings.providerRateLimitRefreshMs;
           let nextClaimAt = Math.max(now(), providerRetryAtMs ?? 0);
           let pendingClaimPromotions = 0;
           let onceClaimed = false;
+          emitDiagnostic("runtime_started", {
+            max_concurrency: settings.maxConcurrency,
+            active_attempts: active.size,
+            provider_cooldown_reason: providerCooldownReason,
+            provider_cooldown_until: providerRetryAtMs === null ? null : isoAt(providerRetryAtMs),
+            provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
+              providerRateLimits,
+              providerRateLimitsObservedAtMs,
+              now()
+            )
+          });
           const launchClaim = (claim, recovery, claimRequest) => {
             if (!recovery) {
               claimed += 1;
@@ -29704,10 +29823,37 @@ var init_runner = __esm({
               attemptHeartbeatMs: settings.attemptHeartbeatMs,
               sleep: sleep4,
               now,
-              onProviderCooldown: (retryAtMs) => {
+              onProviderCooldown: ({ retryAtMs, reason, rateLimits }) => {
                 if (!Number.isSafeInteger(retryAtMs) || retryAtMs <= now()) return;
+                const priorRetryAtMs = providerRetryAtMs;
                 providerRetryAtMs = Math.max(providerRetryAtMs ?? 0, retryAtMs);
                 nextClaimAt = Math.max(nextClaimAt, providerRetryAtMs);
+                providerCooldownReason = reason;
+                if (rateLimits) {
+                  providerRateLimits = rateLimits;
+                  providerRateLimitsObservedAtMs = now();
+                }
+                emitDiagnostic(
+                  priorRetryAtMs === null ? "provider_cooldown_started" : "provider_cooldown_extended",
+                  {
+                    reason,
+                    cooldown_until: isoAt(providerRetryAtMs),
+                    active_attempts: active.size,
+                    provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
+                      providerRateLimits,
+                      providerRateLimitsObservedAtMs,
+                      now()
+                    )
+                  }
+                );
+              },
+              onAttemptOutcome: (outcome) => {
+                emitDiagnostic("attempt_finished", {
+                  ...outcome,
+                  job_id: claim.job_id,
+                  attempt_id: attemptId,
+                  active_attempts: active.size
+                });
               },
               resumeReceipt: recovery,
               claimRequest,
@@ -29724,6 +29870,14 @@ var init_runner = __esm({
               attemptControllers.delete(attemptId);
             });
             active.set(attemptId, promise2);
+            emitDiagnostic("attempt_started", {
+              job_id: claim.job_id,
+              attempt_id: attemptId,
+              attempt_index: claim.attempt_index,
+              requested_model: claim.requested_model,
+              requested_reasoning_effort: claim.requested_reasoning_effort,
+              active_attempts: active.size
+            });
             return attemptId;
           };
           const removeRecoveredAttempt = async (attemptId) => {
@@ -29764,12 +29918,56 @@ var init_runner = __esm({
             }
             recoveryQueue.push(recovery);
           }
-          while (!drainRequested && recoveryQueue.length > 0 && active.size < settings.maxConcurrency) {
+          while (!drainRequested && recoveryQueue.length > 0 && (settings.maxConcurrency === null || active.size < settings.maxConcurrency)) {
             const recovery = recoveryQueue.shift();
             launchClaim(recovery.claim, recovery);
           }
           while (!drainRequested) {
             const currentTime = now();
+            if (providerRetryAtMs !== null && currentTime >= providerRetryAtMs && providerCooldownReason !== null) {
+              emitDiagnostic("provider_cooldown_cleared", {
+                reason: providerCooldownReason,
+                active_attempts: active.size,
+                provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
+                  providerRateLimits,
+                  providerRateLimitsObservedAtMs,
+                  currentTime
+                )
+              });
+              providerRetryAtMs = null;
+              providerCooldownReason = null;
+              nextClaimAt = Math.min(nextClaimAt, currentTime);
+            }
+            if (this.dependencies.codexAdapter.readAccountRateLimits && currentTime >= nextProviderRateLimitRefreshAt) {
+              try {
+                providerRateLimits = await this.dependencies.codexAdapter.readAccountRateLimits(
+                  Date.now() + Math.min(2e3, settings.hostHeartbeatMs),
+                  this.options.signal
+                );
+                providerRateLimitsObservedAtMs = now();
+                const refreshedRetryAt = codexAccountRateLimitReached(providerRateLimits) ? codexRateLimitRetryAtMs(providerRateLimits) ?? currentTime + DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS : null;
+                if (refreshedRetryAt !== null && refreshedRetryAt > currentTime) {
+                  providerRetryAtMs = Math.max(providerRetryAtMs ?? 0, refreshedRetryAt);
+                  providerCooldownReason = "provider_limit_snapshot";
+                  nextClaimAt = Math.max(nextClaimAt, providerRetryAtMs);
+                }
+                emitDiagnostic("provider_rate_limits_refreshed", {
+                  provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
+                    providerRateLimits,
+                    providerRateLimitsObservedAtMs,
+                    now()
+                  ),
+                  active_attempts: active.size
+                });
+              } catch (error48) {
+                emitDiagnostic("provider_rate_limits_refresh_failed", {
+                  failure_category: error48 instanceof CodexAppServerError ? error48.category : "adapter",
+                  failure_code: error48 instanceof CodexAppServerError ? error48.code : "provider_rate_limits_refresh_failed"
+                });
+              } finally {
+                nextProviderRateLimitRefreshAt = now() + settings.providerRateLimitRefreshMs;
+              }
+            }
             const expiresAt = receipt.advertisement_expires_at ? Date.parse(receipt.advertisement_expires_at) : 0;
             if (currentTime >= nextAdvertisementAttemptAt && expiresAt - currentTime <= settings.advertisementRefreshLeadMs) {
               try {
@@ -29812,11 +30010,11 @@ var init_runner = __esm({
                 nextHostHeartbeatAt = now() + settings.hostHeartbeatMs;
               }
             }
-            while (recoveryQueue.length > 0 && active.size < settings.maxConcurrency) {
+            while (recoveryQueue.length > 0 && (settings.maxConcurrency === null || active.size < settings.maxConcurrency)) {
               const recovery = recoveryQueue.shift();
               launchClaim(recovery.claim, recovery);
             }
-            while (!drainRequested && recoveryQueue.length === 0 && (!this.options.once || !onceClaimed) && active.size < settings.maxConcurrency && pendingClaimPromotions === 0 && now() >= nextClaimAt) {
+            while (!drainRequested && recoveryQueue.length === 0 && (!this.options.once || !onceClaimed) && (settings.maxConcurrency === null || active.size < settings.maxConcurrency) && pendingClaimPromotions === 0 && now() >= nextClaimAt) {
               if (!receipt.pending_claim_request) {
                 const claimSequence = receipt.claim_sequence + 1;
                 const pendingClaimRequest = {
@@ -29935,6 +30133,13 @@ var init_runner = __esm({
               requestDrain("drain_timeout");
             }
           }
+          emitDiagnostic("runtime_stopped", {
+            claimed,
+            completed,
+            failed,
+            drain_reason: drainReason,
+            active_attempts: active.size
+          });
           return { claimed, completed, failed, drain_reason: drainReason };
         } finally {
           removeAbortListener();
@@ -30280,13 +30485,27 @@ var init_runner = __esm({
             );
           }
           await removeAttempt();
+          options.onAttemptOutcome?.({
+            outcome: "completed",
+            failure_category: null,
+            failure_code: null,
+            retryable: null,
+            dispatch_outcome: completion.outcome.dispatch_outcome,
+            response_outcome: completion.outcome.response_outcome,
+            latency_ms: completion.latency_ms,
+            usage: completion.usage
+          });
           return "completed";
         } catch (error48) {
           if (error48 instanceof InferenceHostRunnerError && error48.code === "terminal_outcome_unconfirmed") {
             throw error48;
           }
           if (error48 instanceof CodexAppServerError && error48.retryAtMs !== null && ["quota_exceeded", "codex_rate_limited"].includes(error48.code)) {
-            options.onProviderCooldown?.(error48.retryAtMs);
+            options.onProviderCooldown?.({
+              retryAtMs: error48.retryAtMs,
+              reason: error48.code === "quota_exceeded" ? "quota_exceeded" : "codex_rate_limited",
+              rateLimits: error48.rateLimits
+            });
           }
           const classified = classifyFailure(heartbeatFailure ?? error48, adapterResult);
           const heartbeatAmbiguous = ambiguousHeartbeatTransport(heartbeatFailure);
@@ -30366,6 +30585,16 @@ var init_runner = __esm({
             );
           }
           await removeAttempt();
+          options.onAttemptOutcome?.({
+            outcome: "failed",
+            failure_category: failureRequest.failure_category,
+            failure_code: failureRequest.failure_code,
+            retryable: failureRequest.retryable,
+            dispatch_outcome: failureRequest.outcome.dispatch_outcome,
+            response_outcome: failureRequest.outcome.response_outcome,
+            latency_ms: adapterResult?.latencyMs ?? null,
+            usage: failureRequest.usage
+          });
           return "failed";
         } finally {
           heartbeatStopped = true;
@@ -30406,7 +30635,7 @@ import { createWriteStream, readFileSync } from "node:fs";
 import { access as access3, chmod as chmod3, mkdir as mkdir3, readFile as readFile5, rm as rm4, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname4, join as join5, resolve as resolve4 } from "node:path";
-var SERVICE_NAME, SYSTEMD_UNIT, LAUNCHD_LABEL, SERVICE_COOPERATIVE_STOP_SECONDS, isWindowsSubsystemForLinux, inferenceHostServiceManifestPath, inferenceHostServiceDesiredPath, inferenceHostServiceLogPath, xmlEscape, plistEscape, systemdQuote, defaultRunCommand, managerName, assertRuntimeEnvironment, assertServicePath, assertWorker, assertManifest, assertDesiredState, readInferenceHostServiceManifest, readInferenceHostServiceDesired, readDesiredAcrossAtomicReplacement, writeDesired, runtimeEnvironment, serviceArguments, windowsOwnedCommandLine, vbScriptString, windowsServiceLauncher, windowsTaskXml, systemdUnit, launchAgentPlist, InferenceHostServiceManager, appendServiceLog, spawnServiceChild, runInferenceHostServiceSupervisor;
+var SERVICE_NAME, SYSTEMD_UNIT, LAUNCHD_LABEL, SERVICE_COOPERATIVE_STOP_SECONDS, inferenceHostServiceChildEnvironment, isWindowsSubsystemForLinux, inferenceHostServiceManifestPath, inferenceHostServiceDesiredPath, inferenceHostServiceLogPath, xmlEscape, plistEscape, systemdQuote, defaultRunCommand, managerName, assertRuntimeEnvironment, withoutConcurrencyLimit, assertServicePath, assertWorker, assertManifest, assertDesiredState, readInferenceHostServiceManifest, readInferenceHostServiceDesired, readDesiredAcrossAtomicReplacement, writeDesired, runtimeEnvironment, serviceArguments, windowsOwnedCommandLine, vbScriptString, windowsServiceLauncher, windowsTaskXml, systemdUnit, launchAgentPlist, InferenceHostServiceManager, appendServiceLog, spawnServiceChild, runInferenceHostServiceSupervisor;
 var init_service = __esm({
   "lib/inference-host/service.ts"() {
     "use strict";
@@ -30415,6 +30644,15 @@ var init_service = __esm({
     SYSTEMD_UNIT = "vtx-inference-host.service";
     LAUNCHD_LABEL = "com.vtxmacro.inference-host";
     SERVICE_COOPERATIVE_STOP_SECONDS = 75;
+    inferenceHostServiceChildEnvironment = (runtimeEnvironment2, inheritedEnvironment = process.env) => {
+      const environment = { ...inheritedEnvironment };
+      for (const key of Object.keys(environment)) {
+        if (key === "VTX_API_URL" || key.startsWith("VTX_INFERENCE_HOST_")) {
+          delete environment[key];
+        }
+      }
+      return { ...environment, ...runtimeEnvironment2 };
+    };
     isWindowsSubsystemForLinux = (env = process.env, kernelRelease) => Boolean(
       String(env.WSL_INTEROP || "").trim() || String(env.WSL_DISTRO_NAME || "").trim() || /microsoft/iu.test(kernelRelease ?? (() => {
         try {
@@ -30467,6 +30705,10 @@ var init_service = __esm({
       }
       return value;
     };
+    withoutConcurrencyLimit = (environment) => {
+      const { VTX_INFERENCE_HOST_MAX_CONCURRENCY: _removed, ...rest } = environment;
+      return rest;
+    };
     assertServicePath = (value) => {
       if (typeof value !== "string" || !value || /[\r\n\0]/u.test(value)) {
         throw new Error("Inference-host service manifest paths contain control characters.");
@@ -30478,14 +30720,14 @@ var init_service = __esm({
         throw new Error("Inference-host service worker is invalid.");
       }
       const record2 = value;
-      if (typeof record2.instance_name !== "string" || !/^[a-z0-9](?:[a-z0-9-]{0,46}[a-z0-9])?$/u.test(record2.instance_name) || record2.adapter !== "codex" || typeof record2.display_name !== "string" || !record2.display_name || !Number.isSafeInteger(record2.max_concurrency) || Number(record2.max_concurrency) < 1 || Number(record2.max_concurrency) > MAX_CODEX_HOST_CONCURRENCY || record2.authenticated_account_email !== null && typeof record2.authenticated_account_email !== "string" || record2.authenticated_account_plan !== null && typeof record2.authenticated_account_plan !== "string") {
+      if (typeof record2.instance_name !== "string" || !/^[a-z0-9](?:[a-z0-9-]{0,46}[a-z0-9])?$/u.test(record2.instance_name) || record2.adapter !== "codex" || typeof record2.display_name !== "string" || !record2.display_name || record2.max_concurrency !== null && (!Number.isSafeInteger(record2.max_concurrency) || Number(record2.max_concurrency) < 1) || record2.authenticated_account_email !== null && typeof record2.authenticated_account_email !== "string" || record2.authenticated_account_plan !== null && typeof record2.authenticated_account_plan !== "string") {
         throw new Error("Inference-host service worker is invalid.");
       }
       return {
         instance_name: record2.instance_name,
         adapter: "codex",
         display_name: record2.display_name,
-        max_concurrency: Number(record2.max_concurrency),
+        max_concurrency: record2.max_concurrency === null ? null : Number(record2.max_concurrency),
         authenticated_account_email: record2.authenticated_account_email,
         authenticated_account_plan: record2.authenticated_account_plan,
         runtime_environment: assertRuntimeEnvironment(record2.runtime_environment)
@@ -30499,18 +30741,20 @@ var init_service = __esm({
       if (record2.schema_version === "vtx_inference_service_v1") {
         const legacy = record2;
         if (legacy.adapter !== "codex" || typeof legacy.installed_at !== "string" || !Number.isFinite(Date.parse(legacy.installed_at)) || typeof legacy.executable !== "string" || !legacy.executable || typeof legacy.script !== "string" || !legacy.script || typeof legacy.display_name !== "string" || !legacy.display_name || typeof legacy.log_path !== "string" || !legacy.log_path) throw new Error("Inference-host service manifest is invalid.");
-        const runtime_environment = assertRuntimeEnvironment(legacy.runtime_environment);
+        const runtime_environment = withoutConcurrencyLimit(
+          assertRuntimeEnvironment(legacy.runtime_environment)
+        );
         const worker = assertWorker({
           instance_name: "default",
           adapter: "codex",
           display_name: legacy.display_name,
-          max_concurrency: Number(runtime_environment.VTX_INFERENCE_HOST_MAX_CONCURRENCY || 1),
+          max_concurrency: null,
           authenticated_account_email: null,
           authenticated_account_plan: null,
           runtime_environment
         });
         return {
-          schema_version: "vtx_inference_service_v2",
+          schema_version: "vtx_inference_service_v3",
           installed_at: legacy.installed_at,
           executable: assertServicePath(legacy.executable),
           script: assertServicePath(legacy.script),
@@ -30518,7 +30762,40 @@ var init_service = __esm({
           workers: [worker]
         };
       }
-      if (record2.schema_version !== "vtx_inference_service_v2" || typeof record2.installed_at !== "string" || !Number.isFinite(Date.parse(record2.installed_at)) || typeof record2.executable !== "string" || !record2.executable || typeof record2.script !== "string" || !record2.script || typeof record2.log_path !== "string" || !record2.log_path || !Array.isArray(record2.workers) || record2.workers.length < 1) {
+      if (record2.schema_version === "vtx_inference_service_v2") {
+        const legacy = record2;
+        if (typeof legacy.installed_at !== "string" || !Number.isFinite(Date.parse(legacy.installed_at)) || typeof legacy.executable !== "string" || !legacy.executable || typeof legacy.script !== "string" || !legacy.script || typeof legacy.log_path !== "string" || !legacy.log_path || !Array.isArray(legacy.workers) || legacy.workers.length < 1) {
+          throw new Error("Inference-host service manifest is invalid.");
+        }
+        const workers2 = legacy.workers.map((worker) => {
+          if (!worker || typeof worker !== "object" || Array.isArray(worker)) {
+            throw new Error("Inference-host service worker is invalid.");
+          }
+          const legacyWorker = worker;
+          if (!Number.isSafeInteger(legacyWorker.max_concurrency) || Number(legacyWorker.max_concurrency) < 1) {
+            throw new Error("Inference-host service worker is invalid.");
+          }
+          return assertWorker({
+            ...legacyWorker,
+            max_concurrency: null,
+            runtime_environment: withoutConcurrencyLimit(
+              assertRuntimeEnvironment(legacyWorker.runtime_environment)
+            )
+          });
+        });
+        if (new Set(workers2.map((worker) => worker.instance_name)).size !== workers2.length) {
+          throw new Error("Inference-host service worker names must be unique.");
+        }
+        return {
+          schema_version: "vtx_inference_service_v3",
+          installed_at: legacy.installed_at,
+          executable: assertServicePath(legacy.executable),
+          script: assertServicePath(legacy.script),
+          log_path: assertServicePath(legacy.log_path),
+          workers: workers2
+        };
+      }
+      if (record2.schema_version !== "vtx_inference_service_v3" || typeof record2.installed_at !== "string" || !Number.isFinite(Date.parse(record2.installed_at)) || typeof record2.executable !== "string" || !record2.executable || typeof record2.script !== "string" || !record2.script || typeof record2.log_path !== "string" || !record2.log_path || !Array.isArray(record2.workers) || record2.workers.length < 1) {
         throw new Error("Inference-host service manifest is invalid.");
       }
       assertServicePath(record2.executable);
@@ -30587,9 +30864,11 @@ var init_service = __esm({
         VTX_INFERENCE_HOST_INSTANCE: config2.instanceName,
         VTX_INFERENCE_HOST_CREDENTIAL_STORE: config2.credentialStoreMode,
         VTX_INFERENCE_HOST_STATE_PATH: config2.statePath,
-        VTX_INFERENCE_HOST_LOCK_PATH: config2.processLockPath,
-        VTX_INFERENCE_HOST_MAX_CONCURRENCY: String(maxConcurrency)
+        VTX_INFERENCE_HOST_LOCK_PATH: config2.processLockPath
       };
+      if (maxConcurrency !== null) {
+        result2.VTX_INFERENCE_HOST_MAX_CONCURRENCY = String(maxConcurrency);
+      }
       if (config2.credentialFilePath) {
         result2.VTX_INFERENCE_HOST_CREDENTIAL_FILE = config2.credentialFilePath;
       }
@@ -30905,7 +31184,7 @@ ${cleanup.stderr}`)) {
         }
         await access3(this.executable);
         await access3(this.script);
-        const maxConcurrency = options.maxConcurrency ?? 1;
+        const maxConcurrency = options.maxConcurrency ?? null;
         const workers = [
           ...existing?.workers.filter((worker) => worker.instance_name !== this.config.instanceName) ?? [],
           {
@@ -30919,7 +31198,7 @@ ${cleanup.stderr}`)) {
           }
         ].sort((left, right) => left.instance_name.localeCompare(right.instance_name));
         const manifest = assertManifest({
-          schema_version: "vtx_inference_service_v2",
+          schema_version: "vtx_inference_service_v3",
           installed_at: this.now().toISOString(),
           executable: this.executable,
           script: this.script,
@@ -31016,13 +31295,22 @@ ${result2.stderr}`)) {
           })) ?? []
         };
       }
-      async logs(lines = 100) {
+      async logs(lines = 100, instanceName) {
         const manifest = await readInferenceHostServiceManifest(this.manifestPath());
         const path = manifest?.log_path ?? this.logPath();
         try {
           const contents = await readFile5(path, "utf8");
-          return `${contents.trimEnd().split(/\r?\n/u).slice(-lines).join("\n")}
-`;
+          const logLines = contents.trimEnd().split(/\r?\n/u);
+          const filtered = instanceName ? logLines.filter((line) => {
+            try {
+              const parsed = JSON.parse(line);
+              return parsed.instance_name === instanceName || Array.isArray(parsed.instances) && parsed.instances.includes(instanceName);
+            } catch {
+              return false;
+            }
+          }) : logLines;
+          return filtered.length > 0 ? `${filtered.slice(-lines).join("\n")}
+` : "";
         } catch (error48) {
           if (error48.code === "ENOENT") return "";
           throw error48;
@@ -31102,26 +31390,61 @@ ${result2.stderr}`)) {
       const log = createWriteStream(manifest.log_path, { flags: "a", mode: 384 });
       return await new Promise((resolvePromise, reject) => {
         let stdout = "";
+        const pending = { stdout: "", stderr: "" };
+        const writeTaggedOutput = (stream, text, flush = false) => {
+          const lines = `${pending[stream]}${text}`.split(/\r?\n/u);
+          const remainder = lines.pop() ?? "";
+          pending[stream] = flush ? "" : remainder;
+          if (flush && remainder) lines.push(remainder);
+          if (flush && lines.at(-1) === "") lines.pop();
+          for (const line of lines) {
+            if (!line) continue;
+            try {
+              const parsed = JSON.parse(line);
+              if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                log.write(`${JSON.stringify({
+                  ...parsed,
+                  instance_name: worker.instance_name
+                })}
+`);
+                continue;
+              }
+            } catch {
+            }
+            log.write(`${JSON.stringify({
+              at: (/* @__PURE__ */ new Date()).toISOString(),
+              event: "worker_output",
+              instance_name: worker.instance_name,
+              stream,
+              message: line.slice(0, 4096)
+            })}
+`);
+          }
+        };
         const child = spawn5(manifest.executable, args, {
-          env: { ...process.env, ...worker.runtime_environment },
+          env: inferenceHostServiceChildEnvironment(worker.runtime_environment),
           windowsHide: true,
           stdio: ["ignore", "pipe", "pipe"]
         });
         child.stdout.on("data", (chunk) => {
           const text = chunk.toString("utf8");
-          log.write(text);
+          writeTaggedOutput("stdout", text);
           stdout = `${stdout}${text}`.slice(-65536);
         });
-        child.stderr.on("data", (chunk) => log.write(chunk));
+        child.stderr.on("data", (chunk) => writeTaggedOutput("stderr", chunk.toString("utf8")));
         const onAbort = () => child.kill("SIGTERM");
         signal.addEventListener("abort", onAbort, { once: true });
         child.once("error", (error48) => {
           signal.removeEventListener("abort", onAbort);
+          writeTaggedOutput("stdout", "", true);
+          writeTaggedOutput("stderr", "", true);
           log.end();
           reject(error48);
         });
         child.once("exit", (code) => {
           signal.removeEventListener("abort", onAbort);
+          writeTaggedOutput("stdout", "", true);
+          writeTaggedOutput("stderr", "", true);
           log.end();
           let drainReason = null;
           for (const line of stdout.trim().split("\n").reverse()) {
@@ -31407,7 +31730,7 @@ Commands:
 Common options:
   --json           Emit machine-readable JSON
   --instance NAME  Target an isolated local subscription instance (default: default)
-  --max-concurrency N  Automated Codex slots for this subscription (1-8; default: 3)
+  --max-concurrency N  Optional positive-integer Codex slot limit (default: unlimited)
   --help, -h       Show this help
 
 If the OS credential store cannot retain the VTX grant, set
@@ -31426,18 +31749,16 @@ Durable service:
 `;
     parseHostConcurrency = (raw, label) => {
       const value = Number(raw);
-      if (!Number.isSafeInteger(value) || value < 1 || value > MAX_CODEX_HOST_CONCURRENCY) {
-        throw new Error(`${label} must be an integer from 1 through ${MAX_CODEX_HOST_CONCURRENCY}.`);
+      if (!Number.isSafeInteger(value) || value < 1) {
+        throw new Error(`${label} must be a positive safe integer.`);
       }
       return value;
     };
     parseInferenceHostArgs = (argv2, env) => {
       let json2 = String(env.VTX_OUTPUT_JSON || "").trim().toLowerCase() === "true";
       let once = false;
-      let maxConcurrency = parseHostConcurrency(
-        String(env.VTX_INFERENCE_HOST_MAX_CONCURRENCY || DEFAULT_CODEX_HOST_CONCURRENCY),
-        "VTX_INFERENCE_HOST_MAX_CONCURRENCY"
-      );
+      const configuredConcurrency = String(env.VTX_INFERENCE_HOST_MAX_CONCURRENCY || "").trim();
+      let maxConcurrency = configuredConcurrency ? parseHostConcurrency(configuredConcurrency, "VTX_INFERENCE_HOST_MAX_CONCURRENCY") : null;
       let instanceName = String(env.VTX_INFERENCE_HOST_INSTANCE || "default").trim();
       let instanceExplicit = Boolean(String(env.VTX_INFERENCE_HOST_INSTANCE || "").trim());
       let displayName = String(env.VTX_INFERENCE_HOST_DISPLAY_NAME || "").trim() || "Codex subscription host";
@@ -31693,6 +32014,7 @@ Durable service:
         ...dependencies,
         acquireProcessLock: async () => borrowedProcessLock
       }, {
+        instanceName: options.config.instanceName,
         displayName: options.displayName,
         authenticatedAccountEmail: options.authenticatedAccountEmail,
         authenticatedAccountPlan: options.authenticatedAccountPlan,
@@ -31702,6 +32024,7 @@ Durable service:
         adapterRuntimeVersion: INFERENCE_HOST_CLI_VERSION,
         maxConcurrency: options.maxConcurrency,
         once: options.once,
+        emitDiagnosticEvent: options.emitDiagnosticEvent,
         signal: options.signal
       }).run();
     };
@@ -32203,6 +32526,10 @@ Waiting for approval...
             once: parsed.once,
             env,
             processLock,
+            emitDiagnosticEvent: parsed.json ? (event) => (dependencies.emitStdout ?? ((text) => {
+              process.stdout.write(text);
+            }))(`${JSON.stringify(event)}
+`) : void 0,
             signal: cancellation.signal
           });
           return {
@@ -32739,7 +33066,14 @@ Waiting for approval...
         throw new Error("Service adapter and model options are accepted only by service install.");
       }
       if (action === "logs") {
-        return { exitCode: 0, stdout: await manager.logs(parsed.lines), stderr: "" };
+        return {
+          exitCode: 0,
+          stdout: await manager.logs(
+            parsed.lines,
+            parsed.instanceExplicit ? config2.instanceName : void 0
+          ),
+          stderr: ""
+        };
       }
       if (action === "start") {
         return { exitCode: 0, stdout: render({ status: "service_started", ...await manager.start() }, parsed.json), stderr: "" };

package/package.json

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