@vtxmacro/cli 2026.9.24 → 2026.9.26

package/bin/vtx-service-bootstrap.js

@@ -16,7 +16,7 @@ import { fileURLToPath } from "node:url";
 // agent-cli-release.json
 var agent_cli_release_default = {
   package_name: "@vtxmacro/cli",
-  package_version: "2026.9.24",
+  package_version: "2026.9.26",
   codex_package_name: "@openai/codex",
   codex_version: "0.153.3",
   copilot_sdk_package_name: "@github/copilot-sdk",

package/bin/vtx.js

@@ -69,7 +69,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.9.24",
+      package_version: "2026.9.26",
       codex_package_name: "@openai/codex",
       codex_version: "0.153.3",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -19221,7 +19221,7 @@ ${body}`;
 });
 
 // lib/inference-host/mcp-client.ts
-var EXTERNAL_INFERENCE_MCP_PROTOCOL_VERSION, EXTERNAL_INFERENCE_AUTOMATED_HOST_TOOLS, EXTERNAL_INFERENCE_OPERATIONAL_TOOLS, ExternalInferenceMcpError, DEFAULT_REQUEST_TIMEOUT_MS, MAX_RETRY_AFTER_MS, PUBLIC_TOOL_ERROR_PREFIX, parseRetryAfterMs, identifierSchema2, safeCodeSchema2, publicFailureCodeSchema, publicToolErrorSchema, structuredPublicToolErrorSchema, parsePublicToolError, hostMutationResultSchema, attemptStartResultSchema, agentConnectResultSchema, agentHeartbeatResultSchema, timestampSchema2, positiveGenerationSchema, jsonObjectSchema, agentAssignmentNextArgumentsSchema, agentDataCapabilityDescriptorSchema, agentAssignmentNextResultSchema, agentAssignmentHeartbeatArgumentsSchema, agentAssignmentHeartbeatResultSchema, agentDataCallArgumentsSchema, agentDataCallResultSchema, agentDecisionSubmitArgumentsSchema, agentDecisionSubmitResultSchema, agentDecisionStatusArgumentsSchema, agentDecisionStatusResultSchema, agentAssignmentReleaseArgumentsSchema, agentAssignmentReleaseResultSchema, jobCompletionResultSchema, jobFailureResultSchema, toolContracts, discoveryResultSchema, toolListResultSchema, inlineStructuredContentSchema, protocolMeta, parseJsonDocument, parseSseDocuments, parseResponseDocuments, exactOperationalInventory, exactJson, invalidBoundResult, verifyToolResult, ExternalInferenceMcpClient;
+var EXTERNAL_INFERENCE_MCP_PROTOCOL_VERSION, EXTERNAL_INFERENCE_AUTOMATED_HOST_TOOLS, EXTERNAL_INFERENCE_OPERATIONAL_TOOLS, ClaimTiming, ExternalInferenceMcpError, DEFAULT_REQUEST_TIMEOUT_MS, MAX_RETRY_AFTER_MS, PUBLIC_TOOL_ERROR_PREFIX, parseRetryAfterMs, identifierSchema2, safeCodeSchema2, publicFailureCodeSchema, publicToolErrorSchema, structuredPublicToolErrorSchema, parsePublicToolError, hostMutationResultSchema, attemptStartResultSchema, agentConnectResultSchema, agentHeartbeatResultSchema, timestampSchema2, positiveGenerationSchema, jsonObjectSchema, agentAssignmentNextArgumentsSchema, agentDataCapabilityDescriptorSchema, agentAssignmentNextResultSchema, agentAssignmentHeartbeatArgumentsSchema, agentAssignmentHeartbeatResultSchema, agentDataCallArgumentsSchema, agentDataCallResultSchema, agentDecisionSubmitArgumentsSchema, agentDecisionSubmitResultSchema, agentDecisionStatusArgumentsSchema, agentDecisionStatusResultSchema, agentAssignmentReleaseArgumentsSchema, agentAssignmentReleaseResultSchema, jobCompletionResultSchema, jobFailureResultSchema, toolContracts, discoveryResultSchema, toolListResultSchema, inlineStructuredContentSchema, protocolMeta, parseJsonDocument, parseSseDocuments, parseResponseDocuments, exactOperationalInventory, exactJson, invalidBoundResult, verifyToolResult, ExternalInferenceMcpClient;
 var init_mcp_client = __esm({
   "lib/inference-host/mcp-client.ts"() {
     "use strict";
@@ -19254,6 +19254,42 @@ var init_mcp_client = __esm({
       "inference.agent.complete",
       "inference.agent.fail"
     ];
+    ClaimTiming = class {
+      constructor() {
+        this.startedAt = performance.now();
+        this.changedAt = this.startedAt;
+        this.phase = "other_ms";
+        this.finished = false;
+        this.elapsed = {
+          token_lookup_ms: 0,
+          fetch_headers_ms: 0,
+          body_reception_ms: 0,
+          response_parse_ms: 0,
+          response_validation_ms: 0,
+          other_ms: 0
+        };
+        this.transportAttempts = 0;
+        this.tokenRefreshes = 0;
+      }
+      enter(phase) {
+        if (this.finished) return;
+        const at = performance.now();
+        this.elapsed[this.phase] += Math.max(0, at - this.changedAt);
+        this.changedAt = at;
+        this.phase = phase;
+      }
+      finish(outcome) {
+        this.enter("other_ms");
+        this.finished = true;
+        return Object.freeze({
+          ...this.elapsed,
+          total_ms: Math.max(0, this.changedAt - this.startedAt),
+          transport_attempts: this.transportAttempts,
+          token_refreshes: this.tokenRefreshes,
+          outcome
+        });
+      }
+    };
     ExternalInferenceMcpError = class extends Error {
       constructor(code, message, options = {}) {
         super(message, { cause: options.cause });
@@ -19662,9 +19698,11 @@ var init_mcp_client = __esm({
       }
       return documents;
     };
-    parseResponseDocuments = async (response) => {
+    parseResponseDocuments = async (response, timing) => {
       const contentType = String(response.headers.get("content-type") || "").split(";", 1)[0].trim().toLowerCase();
+      timing?.enter("body_reception_ms");
       const body = await response.text();
+      timing?.enter("response_parse_ms");
       if (contentType === "application/json") return [parseJsonDocument(body)];
       if (contentType === "text/event-stream") return parseSseDocuments(body);
       throw new ExternalInferenceMcpError(
@@ -19852,75 +19890,90 @@ var init_mcp_client = __esm({
         this.#initialized = true;
       }
       async callTool(name, argumentsValue, options = {}) {
-        if (!this.#initialized) {
-          throw new ExternalInferenceMcpError(
-            "not_initialized",
-            "Insights MCP inventory must be verified before calling an inference operation."
-          );
-        }
-        const contract = toolContracts[name];
-        const argumentsDocument = contract.arguments.parse(argumentsValue);
-        const rawResult = await this.#request(
-          "tools/call",
-          { name, arguments: argumentsDocument },
-          name,
-          options
-        );
-        const callResult = external_exports.object({
-          isError: external_exports.boolean().optional(),
-          content: external_exports.array(external_exports.object({
-            type: external_exports.string(),
-            text: external_exports.string().optional()
-          }).passthrough()).optional(),
-          structuredContent: external_exports.unknown()
-        }).passthrough().parse(rawResult);
-        if (callResult.isError === true) {
-          const errorText = (callResult.content ?? []).filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n");
-          const structuredPublicToolError = structuredPublicToolErrorSchema.safeParse(
-            callResult.structuredContent
-          );
-          const structuredDocument = callResult.structuredContent !== null && typeof callResult.structuredContent === "object" && !Array.isArray(callResult.structuredContent) ? callResult.structuredContent : null;
-          const hasStructuredPublicToolErrorMarker = structuredDocument?.schema_version === "vtx_insights_tool_error_v1";
-          const publicToolError = structuredPublicToolError.success ? structuredPublicToolError.data : hasStructuredPublicToolErrorMarker ? null : parsePublicToolError(errorText);
-          const hasPublicToolErrorMarker = hasStructuredPublicToolErrorMarker || errorText.includes(PUBLIC_TOOL_ERROR_PREFIX);
-          const completionEvidenceExpired = name === "inference.job.complete" && (publicToolError ? publicToolError.failure_code === "completion_evidence_expired" && publicToolError.phase === "validation" && publicToolError.retryable === false && publicToolError.terminal_before_execution === true : !hasPublicToolErrorMarker && errorText.includes("External inference completion evidence window expired"));
-          const hostNotClaimable = name === "inference.job.claim" && publicToolError?.failure_code === "host_not_claimable" && publicToolError.phase === "admission" && publicToolError.retryable === true && publicToolError.terminal_before_execution === true;
-          const definitivelyNotApplied = name === "inference.agent.decision.submit" && publicToolError?.phase === "validation" && publicToolError.retryable === false && publicToolError.terminal_before_execution === true && (publicToolError.failure_code === "agent_decision_schema_invalid" || publicToolError.failure_code === "invalid_arguments" && publicToolError.reason_code === "schema_validation") || (name === "inference.host.register" || name === "inference.host.advertise") && (errorText.includes("Advertisement time is outside the allowed clock skew.") || errorText.includes("Advertisement is already expired.")) || (name === "inference.agent.next" || name === "inference.agent.heartbeat") && (errorText.includes("Advertisement time is outside the allowed clock skew.") || errorText.includes("Advertisement is already expired.") || errorText.includes("Heartbeat time is outside the allowed clock skew.")) || name === "inference.host.heartbeat" && errorText.includes("Heartbeat time is outside the allowed clock skew.") || name === "inference.job.claim" && (errorText.includes(
-            "External inference claim request was not applied before its generation became stale"
-          ) || errorText.includes("External inference host advertisement is expired or superseded")) || name === "inference.job.complete" && completionEvidenceExpired;
-          const retryableInfrastructureRejection = EXTERNAL_INFERENCE_AUTOMATED_HOST_TOOLS.includes(name) && (errorText.includes("External inference polling is at its configured concurrency limit") || errorText.includes("The Insights action reached the response timeout") || errorText.includes("Insights capability failed without exposing private runtime details"));
-          const retryableClaimRejection = name === "inference.job.claim" && !definitivelyNotApplied && (retryableInfrastructureRejection || hostNotClaimable || errorText.includes("External inference host is not live enough to claim work") || errorText.includes("External inference host request generation is stale") || errorText.includes("External inference claim runtime fence is stale"));
-          const retryableHeartbeatClockSkew = name === "inference.host.heartbeat" && definitivelyNotApplied;
-          const retryableAdvertisementClockSkew = (name === "inference.host.register" || name === "inference.host.advertise") && definitivelyNotApplied;
-          const staleHostHeartbeatGeneration = name === "inference.host.heartbeat" && errorText.includes("Heartbeat generations do not match the current host authority.");
-          const obsoleteClaimReplay = name === "inference.job.claim" && errorText.includes(
-            "External inference claim replay is no longer dispatchable"
+        const timing = name === "inference.job.claim" && options.onClaimTiming ? new ClaimTiming() : void 0;
+        let outcome = "failure";
+        try {
+          if (!this.#initialized) {
+            throw new ExternalInferenceMcpError(
+              "not_initialized",
+              "Insights MCP inventory must be verified before calling an inference operation."
+            );
+          }
+          const contract = toolContracts[name];
+          const argumentsDocument = contract.arguments.parse(argumentsValue);
+          const rawResult = await this.#request(
+            "tools/call",
+            { name, arguments: argumentsDocument },
+            name,
+            options,
+            timing
           );
-          throw new ExternalInferenceMcpError(
-            completionEvidenceExpired ? "completion_evidence_expired" : staleHostHeartbeatGeneration ? "generation_stale" : obsoleteClaimReplay ? "claim_replay_obsolete" : "tool_rejected",
-            `Insights MCP rejected ${name}.`,
-            {
-              definitivelyNotApplied: definitivelyNotApplied || staleHostHeartbeatGeneration,
-              // Claim polling is an idempotent control-plane operation. During an
-              // API rotation the MCP server can return a tool error after the
-              // request reached the application boundary, so retain and replay
-              // the exact request unless the server proves it was not applied.
-              retryable: retryableInfrastructureRejection || retryableClaimRejection || retryableHeartbeatClockSkew || retryableAdvertisementClockSkew,
-              serverFailureCode: publicToolError?.failure_code ?? null,
-              retryAfterMs: hostNotClaimable ? publicToolError?.retry_after_ms ?? null : null
+          timing?.enter("response_validation_ms");
+          const callResult = external_exports.object({
+            isError: external_exports.boolean().optional(),
+            content: external_exports.array(external_exports.object({
+              type: external_exports.string(),
+              text: external_exports.string().optional()
+            }).passthrough()).optional(),
+            structuredContent: external_exports.unknown()
+          }).passthrough().parse(rawResult);
+          if (callResult.isError === true) {
+            const errorText = (callResult.content ?? []).filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n");
+            const structuredPublicToolError = structuredPublicToolErrorSchema.safeParse(
+              callResult.structuredContent
+            );
+            const structuredDocument = callResult.structuredContent !== null && typeof callResult.structuredContent === "object" && !Array.isArray(callResult.structuredContent) ? callResult.structuredContent : null;
+            const hasStructuredPublicToolErrorMarker = structuredDocument?.schema_version === "vtx_insights_tool_error_v1";
+            const publicToolError = structuredPublicToolError.success ? structuredPublicToolError.data : hasStructuredPublicToolErrorMarker ? null : parsePublicToolError(errorText);
+            const hasPublicToolErrorMarker = hasStructuredPublicToolErrorMarker || errorText.includes(PUBLIC_TOOL_ERROR_PREFIX);
+            const completionEvidenceExpired = name === "inference.job.complete" && (publicToolError ? publicToolError.failure_code === "completion_evidence_expired" && publicToolError.phase === "validation" && publicToolError.retryable === false && publicToolError.terminal_before_execution === true : !hasPublicToolErrorMarker && errorText.includes("External inference completion evidence window expired"));
+            const hostNotClaimable = name === "inference.job.claim" && publicToolError?.failure_code === "host_not_claimable" && publicToolError.phase === "admission" && publicToolError.retryable === true && publicToolError.terminal_before_execution === true;
+            const definitivelyNotApplied = name === "inference.agent.decision.submit" && publicToolError?.phase === "validation" && publicToolError.retryable === false && publicToolError.terminal_before_execution === true && (publicToolError.failure_code === "agent_decision_schema_invalid" || publicToolError.failure_code === "invalid_arguments" && publicToolError.reason_code === "schema_validation") || (name === "inference.host.register" || name === "inference.host.advertise") && (errorText.includes("Advertisement time is outside the allowed clock skew.") || errorText.includes("Advertisement is already expired.")) || (name === "inference.agent.next" || name === "inference.agent.heartbeat") && (errorText.includes("Advertisement time is outside the allowed clock skew.") || errorText.includes("Advertisement is already expired.") || errorText.includes("Heartbeat time is outside the allowed clock skew.")) || name === "inference.host.heartbeat" && errorText.includes("Heartbeat time is outside the allowed clock skew.") || name === "inference.job.claim" && (errorText.includes(
+              "External inference claim request was not applied before its generation became stale"
+            ) || errorText.includes("External inference host advertisement is expired or superseded")) || name === "inference.job.complete" && completionEvidenceExpired;
+            const retryableInfrastructureRejection = EXTERNAL_INFERENCE_AUTOMATED_HOST_TOOLS.includes(name) && (errorText.includes("External inference polling is at its configured concurrency limit") || errorText.includes("The Insights action reached the response timeout") || errorText.includes("Insights capability failed without exposing private runtime details"));
+            const retryableClaimRejection = name === "inference.job.claim" && !definitivelyNotApplied && (retryableInfrastructureRejection || hostNotClaimable || errorText.includes("External inference host is not live enough to claim work") || errorText.includes("External inference host request generation is stale") || errorText.includes("External inference claim runtime fence is stale"));
+            const retryableHeartbeatClockSkew = name === "inference.host.heartbeat" && definitivelyNotApplied;
+            const retryableAdvertisementClockSkew = (name === "inference.host.register" || name === "inference.host.advertise") && definitivelyNotApplied;
+            const staleHostHeartbeatGeneration = name === "inference.host.heartbeat" && errorText.includes("Heartbeat generations do not match the current host authority.");
+            const obsoleteClaimReplay = name === "inference.job.claim" && errorText.includes(
+              "External inference claim replay is no longer dispatchable"
+            );
+            throw new ExternalInferenceMcpError(
+              completionEvidenceExpired ? "completion_evidence_expired" : staleHostHeartbeatGeneration ? "generation_stale" : obsoleteClaimReplay ? "claim_replay_obsolete" : "tool_rejected",
+              `Insights MCP rejected ${name}.`,
+              {
+                definitivelyNotApplied: definitivelyNotApplied || staleHostHeartbeatGeneration,
+                // Claim polling is an idempotent control-plane operation. During an
+                // API rotation the MCP server can return a tool error after the
+                // request reached the application boundary, so retain and replay
+                // the exact request unless the server proves it was not applied.
+                retryable: retryableInfrastructureRejection || retryableClaimRejection || retryableHeartbeatClockSkew || retryableAdvertisementClockSkew,
+                serverFailureCode: publicToolError?.failure_code ?? null,
+                retryAfterMs: hostNotClaimable ? publicToolError?.retry_after_ms ?? null : null
+              }
+            );
+          }
+          const structured = inlineStructuredContentSchema.parse(callResult.structuredContent);
+          if (structured.capability !== name) {
+            throw new ExternalInferenceMcpError(
+              "invalid_response",
+              "Insights MCP returned a result for a different capability."
+            );
+          }
+          const result2 = contract.result.parse(structured.result);
+          verifyToolResult(name, argumentsDocument, result2);
+          outcome = "success";
+          return result2;
+        } finally {
+          if (timing) {
+            const receipt = timing.finish(outcome);
+            try {
+              void Promise.resolve(options.onClaimTiming?.(receipt)).catch(() => void 0);
+            } catch {
             }
-          );
-        }
-        const structured = inlineStructuredContentSchema.parse(callResult.structuredContent);
-        if (structured.capability !== name) {
-          throw new ExternalInferenceMcpError(
-            "invalid_response",
-            "Insights MCP returned a result for a different capability."
-          );
+          }
         }
-        const result2 = contract.result.parse(structured.result);
-        verifyToolResult(name, argumentsDocument, result2);
-        return result2;
       }
       async #token(refresh, options) {
         try {
@@ -19944,7 +19997,7 @@ var init_mcp_client = __esm({
           );
         }
       }
-      async #request(method, params, name, options = {}) {
+      async #request(method, params, name, options = {}, timing) {
         const timeoutMs = options.timeoutMs ?? this.#requestTimeoutMs;
         if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) {
           throw new ExternalInferenceMcpError(
@@ -19968,22 +20021,32 @@ var init_mcp_client = __esm({
             _meta: protocolMeta(this.#clientName, this.#clientVersion)
           }
         };
+        timing?.enter("token_lookup_ms");
+        const token = await this.#token(false, boundedOptions);
+        timing?.enter("fetch_headers_ms");
+        if (timing) timing.transportAttempts += 1;
         let response = await this.#send(
           method,
           name,
           body,
-          await this.#token(false, boundedOptions),
+          token,
           boundedOptions
         );
         if (response.status === 401 && this.#tokenSource.refreshAccessToken) {
+          timing?.enter("token_lookup_ms");
+          if (timing) timing.tokenRefreshes += 1;
+          const refreshedToken = await this.#token(true, boundedOptions);
+          timing?.enter("fetch_headers_ms");
+          if (timing) timing.transportAttempts += 1;
           response = await this.#send(
             method,
             name,
             body,
-            await this.#token(true, boundedOptions),
+            refreshedToken,
             boundedOptions
           );
         }
+        timing?.enter("other_ms");
         if (!response.ok) {
           const httpStatusCode = response.status;
           const retryAfterMs = parseRetryAfterMs(response);
@@ -19998,7 +20061,7 @@ var init_mcp_client = __esm({
         let documents;
         try {
           documents = await this.#bounded(
-            parseResponseDocuments(response),
+            parseResponseDocuments(response, timing),
             boundedOptions,
             "request_timeout"
           );
@@ -20006,6 +20069,7 @@ var init_mcp_client = __esm({
           await response.body?.cancel().catch(() => void 0);
           throw error48;
         }
+        timing?.enter("response_validation_ms");
         const document2 = documents.find((candidate) => candidate.id === requestId);
         if (!document2 || document2.jsonrpc !== "2.0") {
           throw new ExternalInferenceMcpError(
@@ -37396,6 +37460,7 @@ var init_runner = __esm({
               const request = receipt.pending_claim_request;
               if (request === claimPreparation.unsent && Date.parse(receipt.advertisement_expires_at ?? "") <= now()) break;
               let claim;
+              let claimTiming;
               const claimCallStartedAtMs = now();
               try {
                 claimOpportunities += 1;
@@ -37405,6 +37470,9 @@ var init_runner = __esm({
                   request,
                   {
                     signal: this.options.signal,
+                    onClaimTiming: (timing) => {
+                      claimTiming = timing;
+                    },
                     ...yieldRenewalToClaim ? { deadlineAtMs: expiresAt } : {}
                   }
                 );
@@ -37506,6 +37574,7 @@ var init_runner = __esm({
                   claimCallRoundTripMs - (claim.schema_version === "external_inference_job_claim_result_v3" ? claim.server_processing_ms : 0)
                 );
                 emitDiagnostic("claim_batch_received", {
+                  ...claimTiming ? { client_timing: claimTiming } : {},
                   claim_count: claim.claims.length,
                   round_trip_ms: claimCallRoundTripMs,
                   server_processing_ms: claim.schema_version === "external_inference_job_claim_result_v3" ? claim.server_processing_ms : null,
@@ -39382,6 +39451,124 @@ var init_runner = __esm({
   }
 });
 
+// lib/runtime-policy.generated.json with { type: 'json' }
+var runtime_policy_generated_default;
+var init_runtime_policy_generated = __esm({
+  "lib/runtime-policy.generated.json with { type: 'json' }"() {
+    runtime_policy_generated_default = {
+      ui: {
+        auth_bootstrap_retry: {
+          max_attempts: 3,
+          jitter_milliseconds: 750,
+          base_delay_milliseconds: 500,
+          min_delay_milliseconds: 250,
+          max_delay_milliseconds: 1e4
+        }
+      },
+      ai_dashboard: {
+        market_news_bounds: {
+          max_items_min: 1,
+          max_items_max: 100,
+          lookback_hours_min: 1,
+          lookback_hours_max: 168,
+          max_items_steps: [
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            15,
+            20,
+            25,
+            30,
+            40,
+            50,
+            60,
+            75,
+            90,
+            100
+          ],
+          lookback_hours_steps: [
+            1,
+            2,
+            4,
+            8,
+            12,
+            24,
+            48,
+            72,
+            168
+          ]
+        }
+      },
+      trading: {
+        engine: {
+          client_runtime: {
+            recovery: {
+              resume_retry_base_delay_ms: 1e3,
+              resume_retry_max_delay_ms: 3e4,
+              transient_load_min_delay_ms: 3e4,
+              transient_load_max_delay_ms: 12e4,
+              rate_limit_buffer_ms: 1e3,
+              rate_limit_max_delay_ms: 3e5,
+              engine_stop_settle_retry_delay_ms: 250,
+              recoverable_reset_settle_retry_delay_ms: 1500,
+              local_ai_preflight_timeout_ms: 3e3,
+              surge_stagger_max_ms: 6e4,
+              surge_stagger_min_ms: 2e3,
+              surge_stagger_min_candidates: 4,
+              stagger_deadline_ttl_ms: 3e5,
+              server_active_reprobe_delay_ms: 6e4,
+              transient_load_jitter_ms: 1e4,
+              cross_host_completed_ttl_ms: 15e3,
+              telemetry_dedupe_ttl_ms: 5e3,
+              browser_presence_heartbeat_interval_ms: 3e4,
+              host_liveness_heartbeat_interval_ms: 3e4,
+              host_liveness_recovery_nudge_ttl_ms: 1e4
+            }
+          }
+        }
+      },
+      external_inference: {
+        service: {
+          startup_max_attempts: 40,
+          startup_poll_interval_ms: 250,
+          restart_stable_uptime_ms: 6e4,
+          restart_backoff_base_ms: 1e3,
+          restart_backoff_max_ms: 3e4,
+          restart_exponent_max: 5
+        }
+      },
+      desktop: {
+        runtime_watchdog: {
+          ping_interval_milliseconds: 15e3,
+          telemetry_interval_milliseconds: 3e5
+        }
+      },
+      screener: {
+        resource_scheduler: {
+          client_lock_ttl_milliseconds: 12e4,
+          client_poll_interval_milliseconds: 250
+        }
+      },
+      deployment: {
+        cutover_buffer: {
+          target_timeout_ms: 3e3,
+          retired_timeout_ms: 45e3,
+          max_body_bytes: 33554432,
+          max_inflight: 16,
+          max_queue: 64
+        }
+      }
+    };
+  }
+});
+
 // lib/inference-host/service.ts
 import { spawn as spawn7 } from "node:child_process";
 import { randomUUID as randomUUID6 } from "node:crypto";
@@ -39395,6 +39582,7 @@ var init_service = __esm({
     "use strict";
     init_define_VTX_EXO_POLICY();
     init_define_VTX_PI_MODEL_POLICY();
+    init_runtime_policy_generated();
     init_durable_adapter();
     init_config();
     SERVICE_NAME = "VTX Macro Inference Host";
@@ -39801,7 +39989,7 @@ WantedBy=default.target
           await new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
         });
         this.stopWaitAttempts = dependencies.stopWaitAttempts ?? SERVICE_COOPERATIVE_STOP_SECONDS * 4;
-        this.startWaitAttempts = dependencies.startWaitAttempts ?? 40;
+        this.startWaitAttempts = dependencies.startWaitAttempts ?? runtime_policy_generated_default.external_inference.service.startup_max_attempts;
         this.reconcileWaitAttempts = dependencies.reconcileWaitAttempts ?? SERVICE_COOPERATIVE_STOP_SECONDS * 4;
         this.confirmInitialReadiness = dependencies.confirmInitialReadiness ?? true;
         this.acquireProcessLock = dependencies.acquireProcessLock ?? acquireInferenceHostProcessLock;
@@ -39932,9 +40120,9 @@ WantedBy=default.target
         for (let attempt = 0; attempt < this.startWaitAttempts; attempt += 1) {
           const status = await this.status();
           if (status.manager_active) return status;
-          await this.sleep(250);
+          await this.sleep(runtime_policy_generated_default.external_inference.service.startup_poll_interval_ms);
         }
-        throw new Error("Background service did not reach an active state within 10 seconds.");
+        throw new Error(`Background service did not reach an active state within ${this.startWaitAttempts * runtime_policy_generated_default.external_inference.service.startup_poll_interval_ms / 1e3} seconds.`);
       }
       async restoreRunningSupervisor(manifest, preserveGeneration = false, targetInstanceName) {
         const previousRuntime = await readRuntimeAcrossAtomicReplacement(this.runtimePath()).catch(() => null);
@@ -40735,8 +40923,8 @@ ${result2.stderr}`)) {
               throw new Error("worker_cooperative_stop_timeout");
             }
             if (signal.aborted || record3.controller.signal.aborted || !await readDesiredAcrossAtomicReplacement(desiredPath)) break;
-            failures = result2.uptimeMs >= 6e4 ? 0 : failures + 1;
-            const retryAfterMs = Math.min(1e3 * 2 ** Math.min(failures, 5), 3e4);
+            failures = result2.uptimeMs >= runtime_policy_generated_default.external_inference.service.restart_stable_uptime_ms ? 0 : failures + 1;
+            const retryAfterMs = Math.min(runtime_policy_generated_default.external_inference.service.restart_backoff_base_ms * 2 ** Math.min(failures, runtime_policy_generated_default.external_inference.service.restart_exponent_max), runtime_policy_generated_default.external_inference.service.restart_backoff_max_ms);
             await updateRecord(record3, "failed", "worker_exited");
             await appendServiceLog(serviceManifest.log_path, "worker_exited", {
               instance_name: record3.worker.instance_name,
@@ -40750,7 +40938,7 @@ ${result2.stderr}`)) {
             if (error48 instanceof Error && error48.message === "worker_cooperative_stop_timeout") throw error48;
             if (signal.aborted || record3.controller.signal.aborted) break;
             failures += 1;
-            const retryAfterMs = Math.min(1e3 * 2 ** Math.min(failures, 5), 3e4);
+            const retryAfterMs = Math.min(runtime_policy_generated_default.external_inference.service.restart_backoff_base_ms * 2 ** Math.min(failures, runtime_policy_generated_default.external_inference.service.restart_exponent_max), runtime_policy_generated_default.external_inference.service.restart_backoff_max_ms);
             await updateRecord(record3, "failed", "worker_launch_failed");
             await appendServiceLog(serviceManifest.log_path, "worker_launch_failed", {
               instance_name: record3.worker.instance_name,
@@ -47717,6 +47905,124 @@ var init_local_breadcrumbs = __esm({
   }
 });
 
+// lib/runtime-policy.generated.json
+var runtime_policy_generated_default2;
+var init_runtime_policy_generated2 = __esm({
+  "lib/runtime-policy.generated.json"() {
+    runtime_policy_generated_default2 = {
+      ui: {
+        auth_bootstrap_retry: {
+          max_attempts: 3,
+          jitter_milliseconds: 750,
+          base_delay_milliseconds: 500,
+          min_delay_milliseconds: 250,
+          max_delay_milliseconds: 1e4
+        }
+      },
+      ai_dashboard: {
+        market_news_bounds: {
+          max_items_min: 1,
+          max_items_max: 100,
+          lookback_hours_min: 1,
+          lookback_hours_max: 168,
+          max_items_steps: [
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            15,
+            20,
+            25,
+            30,
+            40,
+            50,
+            60,
+            75,
+            90,
+            100
+          ],
+          lookback_hours_steps: [
+            1,
+            2,
+            4,
+            8,
+            12,
+            24,
+            48,
+            72,
+            168
+          ]
+        }
+      },
+      trading: {
+        engine: {
+          client_runtime: {
+            recovery: {
+              resume_retry_base_delay_ms: 1e3,
+              resume_retry_max_delay_ms: 3e4,
+              transient_load_min_delay_ms: 3e4,
+              transient_load_max_delay_ms: 12e4,
+              rate_limit_buffer_ms: 1e3,
+              rate_limit_max_delay_ms: 3e5,
+              engine_stop_settle_retry_delay_ms: 250,
+              recoverable_reset_settle_retry_delay_ms: 1500,
+              local_ai_preflight_timeout_ms: 3e3,
+              surge_stagger_max_ms: 6e4,
+              surge_stagger_min_ms: 2e3,
+              surge_stagger_min_candidates: 4,
+              stagger_deadline_ttl_ms: 3e5,
+              server_active_reprobe_delay_ms: 6e4,
+              transient_load_jitter_ms: 1e4,
+              cross_host_completed_ttl_ms: 15e3,
+              telemetry_dedupe_ttl_ms: 5e3,
+              browser_presence_heartbeat_interval_ms: 3e4,
+              host_liveness_heartbeat_interval_ms: 3e4,
+              host_liveness_recovery_nudge_ttl_ms: 1e4
+            }
+          }
+        }
+      },
+      external_inference: {
+        service: {
+          startup_max_attempts: 40,
+          startup_poll_interval_ms: 250,
+          restart_stable_uptime_ms: 6e4,
+          restart_backoff_base_ms: 1e3,
+          restart_backoff_max_ms: 3e4,
+          restart_exponent_max: 5
+        }
+      },
+      desktop: {
+        runtime_watchdog: {
+          ping_interval_milliseconds: 15e3,
+          telemetry_interval_milliseconds: 3e5
+        }
+      },
+      screener: {
+        resource_scheduler: {
+          client_lock_ttl_milliseconds: 12e4,
+          client_poll_interval_milliseconds: 250
+        }
+      },
+      deployment: {
+        cutover_buffer: {
+          target_timeout_ms: 3e3,
+          retired_timeout_ms: 45e3,
+          max_body_bytes: 33554432,
+          max_inflight: 16,
+          max_queue: 64
+        }
+      }
+    };
+  }
+});
+
 // lib/api/shared.ts
 function getProfileHeaders(baseHeaders = {}, explicitProfileId) {
   const headers = { ...baseHeaders };
@@ -47724,12 +48030,13 @@ function getProfileHeaders(baseHeaders = {}, explicitProfileId) {
   if (profileId) headers["x-profile-id"] = profileId.toString();
   return headers;
 }
-var getApiUrl, API_URL, sleep2, isTransientNetworkFetchError, createIdempotencyKey, getErrorMessage, getErrorPayloadOrEmpty, getErrorPayloadOrFallbackDetail, getErrorMessageFromResponse, activeProfileId, PROFILE_STORAGE_KEY;
+var getApiUrl, API_URL, sleep2, AUTH_BOOTSTRAP_GET_MAX_ATTEMPTS, AUTH_BOOTSTRAP_RETRY_JITTER_MS, isTransientNetworkFetchError, createIdempotencyKey, getErrorMessage, getErrorPayloadOrEmpty, getErrorPayloadOrFallbackDetail, getErrorMessageFromResponse, activeProfileId, PROFILE_STORAGE_KEY;
 var init_shared = __esm({
   "lib/api/shared.ts"() {
     "use strict";
     init_define_VTX_EXO_POLICY();
     init_define_VTX_PI_MODEL_POLICY();
+    init_runtime_policy_generated2();
     init_abort();
     getApiUrl = () => {
       if (typeof window === "undefined") {
@@ -47760,6 +48067,8 @@ var init_shared = __esm({
     };
     API_URL = getApiUrl();
     sleep2 = (ms) => new Promise((resolve10) => setTimeout(resolve10, ms));
+    AUTH_BOOTSTRAP_GET_MAX_ATTEMPTS = runtime_policy_generated_default2.ui.auth_bootstrap_retry.max_attempts;
+    AUTH_BOOTSTRAP_RETRY_JITTER_MS = runtime_policy_generated_default2.ui.auth_bootstrap_retry.jitter_milliseconds;
     isTransientNetworkFetchError = (error48) => {
       const message = error48 instanceof Error ? error48.message : String(error48 || "");
       const normalized = message.toLowerCase();

package/package.json

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