@vtxmacro/cli 2026.10.5 → 2026.10.7

package/bin/vtx-mcp.js

@@ -1,44 +1,118 @@
 #!/usr/bin/env node
 import { createRequire as __vtxCreateRequire } from 'node:module'; const require = __vtxCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// lib/agent-core/client.ts
-import { randomUUID } from "node:crypto";
+// <define:__VTX_EXO_POLICY__>
+var init_define_VTX_EXO_POLICY = __esm({
+  "<define:__VTX_EXO_POLICY__>"() {
+  }
+});
+
+// <define:__VTX_GROK_POLICY__>
+var init_define_VTX_GROK_POLICY = __esm({
+  "<define:__VTX_GROK_POLICY__>"() {
+  }
+});
+
+// <define:__VTX_PI_MODEL_POLICY__>
+var init_define_VTX_PI_MODEL_POLICY = __esm({
+  "<define:__VTX_PI_MODEL_POLICY__>"() {
+  }
+});
+
+// agent-cli-release.json
+var agent_cli_release_default;
+var init_agent_cli_release = __esm({
+  "agent-cli-release.json"() {
+    agent_cli_release_default = { package_name: "@vtxmacro/cli", package_version: "2026.10.7", codex_package_name: "@openai/codex", codex_version: "0.155.0", copilot_sdk_package_name: "@github/copilot-sdk", copilot_sdk_version: "1.0.0-beta.8", copilot_cli_package_name: "@github/copilot", copilot_cli_version: "1.0.80", deepseek_harness_version: "0.1.1-rc.2", deepseek_harness_packages: ["@deepseek-ai/dsh-agent", "@deepseek-ai/dsh-agent-instructions", "@deepseek-ai/dsh-agent-loop", "@deepseek-ai/dsh-agent-spine-demo", "@deepseek-ai/dsh-anonymous-user-id", "@deepseek-ai/dsh-atomic-write", "@deepseek-ai/dsh-attachment", "@deepseek-ai/dsh-brand", "@deepseek-ai/dsh-code-runtime", "@deepseek-ai/dsh-credentials", "@deepseek-ai/dsh-fs", "@deepseek-ai/dsh-goal", "@deepseek-ai/dsh-goal-round-driver", "@deepseek-ai/dsh-home-paths", "@deepseek-ai/dsh-invariants", "@deepseek-ai/dsh-jobs", "@deepseek-ai/dsh-jobs-local", "@deepseek-ai/dsh-launch-environment", "@deepseek-ai/dsh-llm", "@deepseek-ai/dsh-llm-deepseek", "@deepseek-ai/dsh-llm-retry", "@deepseek-ai/dsh-output-retention", "@deepseek-ai/dsh-sandbox", "@deepseek-ai/dsh-sandbox-policy", "@deepseek-ai/dsh-scope", "@deepseek-ai/dsh-session", "@deepseek-ai/dsh-session-checkpoint-policy", "@deepseek-ai/dsh-session-persistence", "@deepseek-ai/dsh-session-persistence-jsonl", "@deepseek-ai/dsh-session-projection", "@deepseek-ai/dsh-session-title", "@deepseek-ai/dsh-settings", "@deepseek-ai/dsh-shell", "@deepseek-ai/dsh-shell-env", "@deepseek-ai/dsh-skill", "@deepseek-ai/dsh-skill-filesystem", "@deepseek-ai/dsh-subprocess", "@deepseek-ai/dsh-system-prompt", "@deepseek-ai/dsh-timeout", "@deepseek-ai/dsh-tool-bash", "@deepseek-ai/dsh-tool-goal", "@deepseek-ai/dsh-tool-jobs", "@deepseek-ai/dsh-tool-skill", "@deepseek-ai/dsh-tools", "@deepseek-ai/dsh-typert-protocol", "@deepseek-ai/dsh-user-approval"], deepseek_cordis_package_name: "@deepseek-ai/cordis", deepseek_cordis_version: "4.0.1", deepseek_support_packages: { "@deepseek-ai/cordis-plugin-timer": "1.1.3" }, platforms: { "linux-x64": { package_name: "@openai/codex-linux-x64", target: "x86_64-unknown-linux-musl", binary_name: "codex", sha256: "660e159a49e823ac8e5986cb238f73158ce4b957d40d9292f8de90862644b501" }, "win32-x64": { package_name: "@openai/codex-win32-x64", target: "x86_64-pc-windows-msvc", binary_name: "codex.exe", sha256: "e4c11374bd9de8ad5c3b7617fd4654bb7839901edb0863f9930666863c7a021b" } }, pi_coding_agent_package_name: "@earendil-works/pi-coding-agent", pi_ai_package_name: "@earendil-works/pi-ai", pi_version: "0.85.1", pi_support_packages: ["@earendil-works/pi-agent-core", "@earendil-works/pi-telemetry", "@earendil-works/pi-tui", "@earendil-works/chord"], grok_version: "1.0.30", grok_platforms: { "linux-x64": { package_name: "@xai-official/grok-linux-x64", binary_name: "grok", sha256: "504dd6546ab991b75d36698242875ce461489cd1f8cd84285873cb55bd5c7d54" }, "win32-x64": { package_name: "@xai-official/grok-win32-x64", binary_name: "grok.exe", sha256: "48736d1a4342a801ea26d0ecde4c516b653f791399065adaa55973f83abd8867" } } };
+  }
+});
+
+// lib/agent-core/config.ts
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+function defaultBaseDir() {
+  return join(homedir(), ".vtx");
+}
+function resolveAgentCliConfig(env = process.env) {
+  const baseDir = String(env.VTX_HOME || "").trim() || defaultBaseDir();
+  const rawProfile = String(env.VTX_PROFILE_ID || "").trim();
+  const parsedProfile = rawProfile ? Number(rawProfile) : NaN;
+  const explicitStatePath = String(env.VTX_RUNTIME_STATE_PATH || "").trim();
+  return {
+    apiUrl: String(env.VTX_API_URL || "http://localhost:8000").replace(/\/+$/, ""),
+    tokenPath: String(env.VTX_TOKEN_PATH || "").trim() || join(baseDir, "token.json"),
+    statePath: explicitStatePath || join(baseDir, "runtime-state.json"),
+    runtimeStateDir: explicitStatePath ? null : baseDir,
+    runtimeDeviceId: String(env.VTX_RUNTIME_DEVICE_ID || "").trim() || null,
+    activeProfileId: Number.isFinite(parsedProfile) && parsedProfile > 0 ? parsedProfile : null,
+    outputJson: String(env.VTX_OUTPUT || "").trim().toLowerCase() === "json"
+  };
+}
+async function readStoredAgentAuth(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    if (!raw.trim()) {
+      throw new Error(`VTX token file is empty at ${path}. Run "vtx auth login" or remove the file and retry.`);
+    }
+    const parsed = JSON.parse(raw);
+    const token = String(parsed.token || "").trim();
+    return token ? { token } : null;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    if (error instanceof SyntaxError) {
+      throw new Error(`VTX token file is not valid JSON at ${path}. Run "vtx auth login" or remove the file and retry.`);
+    }
+    throw error;
+  }
+}
+var init_config = __esm({
+  "lib/agent-core/config.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+  }
+});
 
 // lib/agent-core/types.ts
-var AgentClientError = class extends Error {
-  constructor(payload) {
-    super(payload.message);
-    this.name = "AgentClientError";
-    this.status = payload.status;
-    this.code = payload.code;
-    this.detail = payload.detail;
+var AgentClientError;
+var init_types = __esm({
+  "lib/agent-core/types.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    AgentClientError = class extends Error {
+      constructor(payload) {
+        super(payload.message);
+        this.name = "AgentClientError";
+        this.status = payload.status;
+        this.code = payload.code;
+        this.detail = payload.detail;
+      }
+    };
   }
-};
+});
 
 // lib/agent-core/client.ts
-var SECRET_RESPONSE_FIELDS = /* @__PURE__ */ new Set([
-  "provider_key_slots",
-  "hyperliquid_signing_key",
-  "local_ai_api_key",
-  "openai_compatible_api_key",
-  "openai_api_key",
-  "anthropic_api_key",
-  "gemini_api_key",
-  "grok_api_key",
-  "groq_api_key",
-  "openrouter_api_key",
-  "venice_api_key",
-  "deepseek_api_key",
-  "mistral_api_key",
-  "together_api_key",
-  "fireworks_api_key",
-  "byteplus_api_key",
-  "cerebras_api_key",
-  "moonshot_api_key",
-  "alibaba_cloud_model_studio_api_key",
-  "amazon_bedrock_api_key",
-  "lightning_api_key"
-]);
+import { randomUUID as randomUUID2 } from "node:crypto";
 function normalizeApiUrl(value) {
   const parsed = String(value || "").trim();
   if (!parsed) {
@@ -84,706 +158,461 @@ function redactSecretResponse(value) {
   }
   return redacted;
 }
-var VtxAgentClient = class _VtxAgentClient {
-  constructor(config) {
-    this.apiUrl = normalizeApiUrl(config.apiUrl);
-    this.token = String(config.token || "").trim() || null;
-    this.activeProfileId = config.activeProfileId ?? null;
-    this.fetchImpl = config.fetchImpl ?? fetch;
-  }
-  /** How shared web runtime code (lib/api.ts) reaches the API as this client. */
-  apiTransport() {
-    const token = this.token;
-    return {
-      baseUrl: this.apiUrl,
-      authorization: () => token ? `Bearer ${token}` : null
+function agentCliVersionHeaders() {
+  return { "X-VTX-CLI-Version": agent_cli_release_default.package_version };
+}
+function createAgentClient(config) {
+  return new VtxAgentClient(config);
+}
+var SECRET_RESPONSE_FIELDS, VtxAgentClient;
+var init_client = __esm({
+  "lib/agent-core/client.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    init_agent_cli_release();
+    init_types();
+    SECRET_RESPONSE_FIELDS = /* @__PURE__ */ new Set([
+      "provider_key_slots",
+      "hyperliquid_signing_key",
+      "local_ai_api_key",
+      "openai_compatible_api_key",
+      "openai_api_key",
+      "anthropic_api_key",
+      "gemini_api_key",
+      "grok_api_key",
+      "groq_api_key",
+      "openrouter_api_key",
+      "venice_api_key",
+      "deepseek_api_key",
+      "mistral_api_key",
+      "together_api_key",
+      "fireworks_api_key",
+      "byteplus_api_key",
+      "cerebras_api_key",
+      "moonshot_api_key",
+      "alibaba_cloud_model_studio_api_key",
+      "amazon_bedrock_api_key",
+      "lightning_api_key"
+    ]);
+    VtxAgentClient = class _VtxAgentClient {
+      constructor(config) {
+        this.apiUrl = normalizeApiUrl(config.apiUrl);
+        this.token = String(config.token || "").trim() || null;
+        this.activeProfileId = config.activeProfileId ?? null;
+        this.fetchImpl = config.fetchImpl ?? fetch;
+      }
+      /** How shared web runtime code (lib/api.ts) reaches the API as this client. */
+      apiTransport() {
+        const token = this.token;
+        return {
+          baseUrl: this.apiUrl,
+          authorization: () => token ? `Bearer ${token}` : null,
+          // The shared runtime's requests name this CLI's version, as the agent
+          // client's own requests do.
+          headers: agentCliVersionHeaders
+        };
+      }
+      async request(path, options = {}) {
+        const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+        const headers = {
+          Accept: "application/json",
+          ...agentCliVersionHeaders()
+        };
+        if (this.token) {
+          headers.Authorization = `Bearer ${this.token}`;
+        }
+        const profileId = options.profileId ?? this.activeProfileId;
+        if (profileId != null) {
+          headers["x-profile-id"] = String(profileId);
+        }
+        if (options.idempotencyKey) {
+          headers["x-idempotency-key"] = options.idempotencyKey;
+        }
+        if (options.headers) {
+          for (const [key, value] of Object.entries(options.headers)) {
+            if (value) {
+              headers[key] = value;
+            }
+          }
+        }
+        let body;
+        if (options.body !== void 0) {
+          headers["Content-Type"] = "application/json";
+          body = JSON.stringify(options.body);
+        }
+        const response = await this.fetchImpl(`${this.apiUrl}${normalizedPath}`, {
+          method: options.method ?? "GET",
+          headers,
+          body
+        });
+        if (!response.ok) {
+          throw await parseError(response, `VTX API request failed: ${response.status}`);
+        }
+        if (response.status === 204) {
+          return void 0;
+        }
+        return await response.json();
+      }
+      whoami() {
+        return this.request("/auth/agent-tokens/whoami");
+      }
+      listTokens() {
+        return this.request("/auth/agent-tokens");
+      }
+      createToken(payload) {
+        return this.request("/auth/agent-tokens", { method: "POST", body: payload });
+      }
+      startBrowserLogin(payload) {
+        return this.request("/auth/agent-tokens/login/start", {
+          method: "POST",
+          body: payload
+        });
+      }
+      pollBrowserLogin(loginCode, verifier) {
+        return this.request("/auth/agent-tokens/login/poll", {
+          method: "POST",
+          body: { login_code: loginCode, verifier }
+        });
+      }
+      revokeToken(tokenId, reason = "cli_revoked") {
+        return this.request(`/auth/agent-tokens/${tokenId}`, {
+          method: "DELETE",
+          body: { reason }
+        });
+      }
+      listProfiles() {
+        return this.request("/auth/me/profiles");
+      }
+      createProfile(profileId) {
+        return this.request("/auth/me/profiles", {
+          method: "POST",
+          profileId
+        });
+      }
+      updateProfile(profileId, payload) {
+        return this.request("/auth/me", {
+          method: "PATCH",
+          profileId,
+          body: payload
+        });
+      }
+      deleteProfile(profileId) {
+        return this.request(`/auth/me/profiles/${profileId}`, {
+          method: "DELETE"
+        });
+      }
+      setProfileExecutionMode(profileId, executionMode) {
+        return this.request("/preferences", {
+          method: "PUT",
+          profileId,
+          body: { preferences: { execution_mode: executionMode } }
+        });
+      }
+      updatePreferences(profileId, preferences) {
+        return this.request("/preferences", {
+          method: "PUT",
+          profileId,
+          body: { preferences }
+        });
+      }
+      getBillingStatus() {
+        return this.request("/billing/balance");
+      }
+      getBillingPrices(profileId) {
+        return this.request("/billing/prices", { profileId });
+      }
+      getRuntimeStatus(profileId) {
+        return this.request("/trading/ai/status", { profileId });
+      }
+      getRuntimeEvents(profileId, options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit !== void 0) {
+          params.set("limit", String(options.limit));
+        }
+        if (options.eventType) {
+          params.set("event_type", options.eventType);
+        }
+        if (options.clientEventType) {
+          params.set("client_event_type", options.clientEventType);
+        }
+        const query = params.toString();
+        return this.request(`/trading/ai/runtime/events${query ? `?${query}` : ""}`, { profileId });
+      }
+      getRuntimeBootstrap(profileId, leaseToken) {
+        return this.request("/trading/ai/runtime/bootstrap", {
+          profileId,
+          headers: { "x-client-runtime-lease": leaseToken }
+        });
+      }
+      getLlmConfig(profileId) {
+        return this.request("/llm/config", { profileId });
+      }
+      heartbeatRuntime(profileId, payload, leaseToken) {
+        return this.request("/trading/ai/runtime/heartbeat", {
+          method: "POST",
+          profileId,
+          headers: { "x-client-runtime-lease": leaseToken },
+          body: payload
+        });
+      }
+      getTradeHistory(profileId) {
+        return this.request("/trading/ai/history", { profileId });
+      }
+      placeMarketOrder(profileId, payload) {
+        return this.request("/trading/market-order", {
+          method: "POST",
+          profileId,
+          idempotencyKey: randomUUID2(),
+          body: payload
+        });
+      }
+      placeLimitOrder(profileId, payload) {
+        return this.request("/trading/limit-order", {
+          method: "POST",
+          profileId,
+          idempotencyKey: randomUUID2(),
+          body: payload
+        });
+      }
+      cancelOrder(profileId, payload) {
+        return this.request("/trading/cancel-order", {
+          method: "POST",
+          profileId,
+          idempotencyKey: randomUUID2(),
+          body: payload
+        });
+      }
+      getSecretStatus(profileId) {
+        return this.request("/auth/me", { profileId });
+      }
+      async setRuntimeSecret(profileId, fieldName, value) {
+        const response = await this.request("/auth/me/client-runtime-secrets", {
+          method: "PUT",
+          profileId,
+          body: { [fieldName]: value }
+        });
+        return redactSecretResponse(response);
+      }
+      startBot(profileId, payload = {}) {
+        return this.request("/trading/ai/start", {
+          method: "POST",
+          profileId,
+          idempotencyKey: randomUUID2(),
+          body: payload
+        });
+      }
+      stopBot(profileId) {
+        return this.request("/trading/ai/stop", {
+          method: "POST",
+          profileId,
+          idempotencyKey: randomUUID2(),
+          body: {}
+        });
+      }
+      startAssistant(profileId) {
+        return this.request("/trading/ai/assistant/start", {
+          method: "POST",
+          profileId,
+          idempotencyKey: randomUUID2(),
+          body: {}
+        });
+      }
+      stopAssistant(profileId) {
+        return this.request("/trading/ai/assistant/stop", {
+          method: "POST",
+          profileId,
+          idempotencyKey: randomUUID2(),
+          body: {}
+        });
+      }
+      startRuntime(profileId, payload) {
+        return this.request("/trading/ai/runtime/session/start", {
+          method: "POST",
+          profileId,
+          idempotencyKey: randomUUID2(),
+          body: payload
+        });
+      }
+      stopRuntime(profileId, payload, leaseToken) {
+        const headersLease = String(leaseToken || "").trim();
+        const previousFetch = this.fetchImpl;
+        if (!headersLease) {
+          return this.request("/trading/ai/runtime/session/stop", {
+            method: "POST",
+            profileId,
+            idempotencyKey: randomUUID2(),
+            body: payload
+          });
+        }
+        const withLeaseFetch = async (input, init) => {
+          const headers = new Headers(init?.headers);
+          headers.set("x-client-runtime-lease", headersLease);
+          return previousFetch(input, { ...init, headers });
+        };
+        return new _VtxAgentClient({
+          apiUrl: this.apiUrl,
+          token: this.token,
+          activeProfileId: this.activeProfileId,
+          fetchImpl: withLeaseFetch
+        }).request("/trading/ai/runtime/session/stop", {
+          method: "POST",
+          profileId,
+          idempotencyKey: randomUUID2(),
+          body: payload
+        });
+      }
     };
   }
-  async request(path, options = {}) {
-    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-    const headers = {
-      Accept: "application/json"
-    };
-    if (this.token) {
-      headers.Authorization = `Bearer ${this.token}`;
-    }
-    const profileId = options.profileId ?? this.activeProfileId;
-    if (profileId != null) {
-      headers["x-profile-id"] = String(profileId);
-    }
-    if (options.idempotencyKey) {
-      headers["x-idempotency-key"] = options.idempotencyKey;
-    }
-    if (options.headers) {
-      for (const [key, value] of Object.entries(options.headers)) {
-        if (value) {
-          headers[key] = value;
+});
+
+// lib/runtime/hyperliquid-market-symbol.ts
+var configuredCaseSensitiveSymbols, canonicalBaseSymbol, normalizeHyperliquidMarketSymbol;
+var init_hyperliquid_market_symbol = __esm({
+  "lib/runtime/hyperliquid-market-symbol.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    configuredCaseSensitiveSymbols = [];
+    canonicalBaseSymbol = (base) => {
+      const trimmed = base.trim();
+      if (!trimmed) return "";
+      const upper = trimmed.toUpperCase();
+      for (const candidate of configuredCaseSensitiveSymbols) {
+        if (candidate.toUpperCase() === upper) {
+          return candidate;
         }
       }
-    }
-    let body;
-    if (options.body !== void 0) {
-      headers["Content-Type"] = "application/json";
-      body = JSON.stringify(options.body);
-    }
-    const response = await this.fetchImpl(`${this.apiUrl}${normalizedPath}`, {
-      method: options.method ?? "GET",
-      headers,
-      body
-    });
-    if (!response.ok) {
-      throw await parseError(response, `VTX API request failed: ${response.status}`);
-    }
-    if (response.status === 204) {
-      return void 0;
-    }
-    return await response.json();
-  }
-  whoami() {
-    return this.request("/auth/agent-tokens/whoami");
-  }
-  listTokens() {
-    return this.request("/auth/agent-tokens");
-  }
-  createToken(payload) {
-    return this.request("/auth/agent-tokens", { method: "POST", body: payload });
-  }
-  startBrowserLogin(payload) {
-    return this.request("/auth/agent-tokens/login/start", {
-      method: "POST",
-      body: payload
-    });
-  }
-  pollBrowserLogin(loginCode, verifier) {
-    return this.request("/auth/agent-tokens/login/poll", {
-      method: "POST",
-      body: { login_code: loginCode, verifier }
-    });
-  }
-  revokeToken(tokenId, reason = "cli_revoked") {
-    return this.request(`/auth/agent-tokens/${tokenId}`, {
-      method: "DELETE",
-      body: { reason }
-    });
-  }
-  listProfiles() {
-    return this.request("/auth/me/profiles");
-  }
-  createProfile(profileId) {
-    return this.request("/auth/me/profiles", {
-      method: "POST",
-      profileId
-    });
-  }
-  updateProfile(profileId, payload) {
-    return this.request("/auth/me", {
-      method: "PATCH",
-      profileId,
-      body: payload
-    });
-  }
-  deleteProfile(profileId) {
-    return this.request(`/auth/me/profiles/${profileId}`, {
-      method: "DELETE"
-    });
-  }
-  setProfileExecutionMode(profileId, executionMode) {
-    return this.request("/preferences", {
-      method: "PUT",
-      profileId,
-      body: { preferences: { execution_mode: executionMode } }
-    });
+      return upper;
+    };
+    normalizeHyperliquidMarketSymbol = (value) => {
+      const raw = String(value ?? "").trim();
+      if (!raw) return "";
+      if (!raw.includes(":")) return canonicalBaseSymbol(raw);
+      const [dex, ...rest] = raw.split(":");
+      const base = rest.join(":").trim();
+      const normalizedDex = dex.trim().toLowerCase();
+      if (!normalizedDex || !base) return "";
+      return `${normalizedDex}:${canonicalBaseSymbol(base)}`;
+    };
   }
-  updatePreferences(profileId, preferences) {
-    return this.request("/preferences", {
-      method: "PUT",
-      profileId,
-      body: { preferences }
-    });
+});
+
+// lib/agent-mcp/server.ts
+function requirePositiveNumber(input, key) {
+  const value = Number(input[key]);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${key} must be a positive number`);
   }
-  getBillingStatus() {
-    return this.request("/billing/balance");
+  return value;
+}
+function optionalPositiveNumber(input, key) {
+  if (input[key] === void 0 || input[key] === null || input[key] === "") {
+    return void 0;
   }
-  getBillingPrices(profileId) {
-    return this.request("/billing/prices", { profileId });
+  return requirePositiveNumber(input, key);
+}
+function optionalString(input, key) {
+  const value = String(input[key] || "").trim();
+  return value || null;
+}
+function botStartPayload(input) {
+  const payload = {};
+  for (const key of ["symbol", "timeframe", "size"]) {
+    const value = optionalString(input, key);
+    if (value) {
+      payload[key] = value;
+    }
   }
-  getRuntimeStatus(profileId) {
-    return this.request("/trading/ai/status", { profileId });
+  const leverage = optionalPositiveNumber(input, "leverage");
+  if (leverage !== void 0) {
+    payload.leverage = leverage;
   }
-  getRuntimeEvents(profileId, options = {}) {
-    const params = new URLSearchParams();
-    if (options.limit !== void 0) {
-      params.set("limit", String(options.limit));
-    }
-    if (options.eventType) {
-      params.set("event_type", options.eventType);
-    }
-    if (options.clientEventType) {
-      params.set("client_event_type", options.clientEventType);
-    }
-    const query = params.toString();
-    return this.request(`/trading/ai/runtime/events${query ? `?${query}` : ""}`, { profileId });
+  const interval = optionalPositiveNumber(input, "interval");
+  if (interval !== void 0) {
+    payload.interval = interval;
   }
-  getRuntimeBootstrap(profileId, leaseToken) {
-    return this.request("/trading/ai/runtime/bootstrap", {
-      profileId,
-      headers: { "x-client-runtime-lease": leaseToken }
-    });
+  return payload;
+}
+function botConfigurePreferences(input) {
+  const preferences = {};
+  const trade = {};
+  const symbol = optionalString(input, "symbol");
+  if (symbol) {
+    const normalizedSymbol = normalizeHyperliquidMarketSymbol(symbol);
+    preferences.trading_symbols = [normalizedSymbol];
+    trade.tradingSymbol = normalizedSymbol;
   }
-  getLlmConfig(profileId) {
-    return this.request("/llm/config", { profileId });
+  const timeframe = optionalString(input, "timeframe");
+  if (timeframe) {
+    preferences.trading_timeframes = [timeframe.trim()];
+    trade.chartInterval = timeframe.trim();
   }
-  heartbeatRuntime(profileId, payload, leaseToken) {
-    return this.request("/trading/ai/runtime/heartbeat", {
-      method: "POST",
-      profileId,
-      headers: { "x-client-runtime-lease": leaseToken },
-      body: payload
-    });
+  const size = optionalString(input, "size");
+  if (size) {
+    preferences.ai_trade_amount = Number(size);
+    trade.orderSizeUSDC = size;
   }
-  getTradeHistory(profileId) {
-    return this.request("/trading/ai/history", { profileId });
+  const leverage = optionalPositiveNumber(input, "leverage");
+  if (leverage !== void 0) {
+    trade.leverage = leverage;
   }
-  placeMarketOrder(profileId, payload) {
-    return this.request("/trading/market-order", {
-      method: "POST",
-      profileId,
-      idempotencyKey: randomUUID(),
-      body: payload
-    });
+  const interval = optionalPositiveNumber(input, "interval");
+  if (interval !== void 0) {
+    preferences.trading_interval = interval;
   }
-  placeLimitOrder(profileId, payload) {
-    return this.request("/trading/limit-order", {
-      method: "POST",
-      profileId,
-      idempotencyKey: randomUUID(),
-      body: payload
-    });
+  if (Object.keys(trade).length > 0) {
+    preferences.trade = trade;
   }
-  cancelOrder(profileId, payload) {
-    return this.request("/trading/cancel-order", {
-      method: "POST",
-      profileId,
-      idempotencyKey: randomUUID(),
-      body: payload
-    });
+  if (Object.keys(preferences).length === 0) {
+    throw new Error("At least one bot configuration field is required");
   }
-  getSecretStatus(profileId) {
-    return this.request("/auth/me", { profileId });
+  return preferences;
+}
+function requireOrderSide(input) {
+  const side = optionalString(input, "side");
+  if (side !== "buy" && side !== "sell") {
+    throw new Error("side must be buy or sell");
   }
-  async setRuntimeSecret(profileId, fieldName, value) {
-    const response = await this.request("/auth/me/client-runtime-secrets", {
-      method: "PUT",
-      profileId,
-      body: { [fieldName]: value }
-    });
-    return redactSecretResponse(response);
-  }
-  startBot(profileId, payload = {}) {
-    return this.request("/trading/ai/start", {
-      method: "POST",
-      profileId,
-      idempotencyKey: randomUUID(),
-      body: payload
-    });
+  return side;
+}
+function requireSymbol(input) {
+  const symbol = optionalString(input, "symbol");
+  if (!symbol) {
+    throw new Error("symbol is required");
   }
-  stopBot(profileId) {
-    return this.request("/trading/ai/stop", {
-      method: "POST",
-      profileId,
-      idempotencyKey: randomUUID(),
-      body: {}
-    });
+  return normalizeHyperliquidMarketSymbol(symbol);
+}
+function marketOrderPayload(input) {
+  const payload = {
+    symbol: requireSymbol(input),
+    side: requireOrderSide(input),
+    size: requirePositiveNumber(input, "size")
+  };
+  const slippage = optionalPositiveNumber(input, "slippage");
+  if (slippage !== void 0) {
+    payload.slippage = slippage;
   }
-  startAssistant(profileId) {
-    return this.request("/trading/ai/assistant/start", {
-      method: "POST",
-      profileId,
-      idempotencyKey: randomUUID(),
-      body: {}
-    });
+  const estimatedPrice = optionalPositiveNumber(input, "estimatedPrice");
+  if (estimatedPrice !== void 0) {
+    payload.estimated_price = estimatedPrice;
   }
-  stopAssistant(profileId) {
-    return this.request("/trading/ai/assistant/stop", {
-      method: "POST",
-      profileId,
-      idempotencyKey: randomUUID(),
-      body: {}
-    });
+  const estimatedPriceTimestampMs = optionalPositiveNumber(input, "estimatedPriceTimestampMs");
+  if (estimatedPriceTimestampMs !== void 0) {
+    payload.estimated_price_timestamp_ms = estimatedPriceTimestampMs;
   }
-  startRuntime(profileId, payload) {
-    return this.request("/trading/ai/runtime/session/start", {
-      method: "POST",
-      profileId,
-      idempotencyKey: randomUUID(),
-      body: payload
-    });
+  if (input.reduceOnly === true) {
+    payload.reduce_only = true;
   }
-  stopRuntime(profileId, payload, leaseToken) {
-    const headersLease = String(leaseToken || "").trim();
-    const previousFetch = this.fetchImpl;
-    if (!headersLease) {
-      return this.request("/trading/ai/runtime/session/stop", {
-        method: "POST",
-        profileId,
-        idempotencyKey: randomUUID(),
-        body: payload
-      });
+  if (input.protection !== void 0) {
+    if (input.protection === null || typeof input.protection !== "object" || Array.isArray(input.protection)) {
+      throw new Error("protection must be an object with take_profit and/or stop_loss");
     }
-    const withLeaseFetch = async (input, init) => {
-      const headers = new Headers(init?.headers);
-      headers.set("x-client-runtime-lease", headersLease);
-      return previousFetch(input, { ...init, headers });
-    };
-    return new _VtxAgentClient({
-      apiUrl: this.apiUrl,
-      token: this.token,
-      activeProfileId: this.activeProfileId,
-      fetchImpl: withLeaseFetch
-    }).request("/trading/ai/runtime/session/stop", {
-      method: "POST",
-      profileId,
-      idempotencyKey: randomUUID(),
-      body: payload
-    });
+    payload.protection = input.protection;
   }
-};
-function createAgentClient(config) {
-  return new VtxAgentClient(config);
-}
-
-// lib/agent-core/config.ts
-import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { homedir } from "node:os";
-function defaultBaseDir() {
-  return join(homedir(), ".vtx");
-}
-function resolveAgentCliConfig(env = process.env) {
-  const baseDir = String(env.VTX_HOME || "").trim() || defaultBaseDir();
-  const rawProfile = String(env.VTX_PROFILE_ID || "").trim();
-  const parsedProfile = rawProfile ? Number(rawProfile) : NaN;
-  const explicitStatePath = String(env.VTX_RUNTIME_STATE_PATH || "").trim();
-  return {
-    apiUrl: String(env.VTX_API_URL || "http://localhost:8000").replace(/\/+$/, ""),
-    tokenPath: String(env.VTX_TOKEN_PATH || "").trim() || join(baseDir, "token.json"),
-    statePath: explicitStatePath || join(baseDir, "runtime-state.json"),
-    runtimeStateDir: explicitStatePath ? null : baseDir,
-    runtimeDeviceId: String(env.VTX_RUNTIME_DEVICE_ID || "").trim() || null,
-    activeProfileId: Number.isFinite(parsedProfile) && parsedProfile > 0 ? parsedProfile : null,
-    outputJson: String(env.VTX_OUTPUT || "").trim().toLowerCase() === "json"
-  };
-}
-async function readStoredAgentAuth(path) {
-  try {
-    const raw = await readFile(path, "utf8");
-    if (!raw.trim()) {
-      throw new Error(`VTX token file is empty at ${path}. Run "vtx auth login" or remove the file and retry.`);
-    }
-    const parsed = JSON.parse(raw);
-    const token = String(parsed.token || "").trim();
-    return token ? { token } : null;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    if (error instanceof SyntaxError) {
-      throw new Error(`VTX token file is not valid JSON at ${path}. Run "vtx auth login" or remove the file and retry.`);
-    }
-    throw error;
-  }
-}
-
-// lib/runtime/hyperliquid-market-symbol.ts
-var configuredCaseSensitiveSymbols = [];
-var canonicalBaseSymbol = (base) => {
-  const trimmed = base.trim();
-  if (!trimmed) return "";
-  const upper = trimmed.toUpperCase();
-  for (const candidate of configuredCaseSensitiveSymbols) {
-    if (candidate.toUpperCase() === upper) {
-      return candidate;
-    }
-  }
-  return upper;
-};
-var normalizeHyperliquidMarketSymbol = (value) => {
-  const raw = String(value ?? "").trim();
-  if (!raw) return "";
-  if (!raw.includes(":")) return canonicalBaseSymbol(raw);
-  const [dex, ...rest] = raw.split(":");
-  const base = rest.join(":").trim();
-  const normalizedDex = dex.trim().toLowerCase();
-  if (!normalizedDex || !base) return "";
-  return `${normalizedDex}:${canonicalBaseSymbol(base)}`;
-};
-
-// lib/agent-mcp/server.ts
-var VTX_MCP_TOOLS = [
-  {
-    name: "vtx_whoami",
-    description: "Inspect the authenticated VTX user and agent-token scopes.",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "vtx_profiles_list",
-    description: "List profiles owned by the authenticated VTX user.",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "vtx_profiles_create",
-    description: "Create a profile for the authenticated VTX user. Requires profile:write scope.",
-    inputSchema: {
-      type: "object",
-      properties: { sourceProfileId: { type: "number" } }
-    }
-  },
-  {
-    name: "vtx_profiles_update",
-    description: "Update the selected profile handle for the authenticated VTX user. Requires profile:write scope.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId", "name"],
-      properties: { profileId: { type: "number" }, name: { type: "string" } }
-    }
-  },
-  {
-    name: "vtx_profiles_delete",
-    description: "Delete a profile owned by the authenticated VTX user. Requires profile:write scope.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId"],
-      properties: { profileId: { type: "number" } }
-    }
-  },
-  {
-    name: "vtx_profiles_set_mode",
-    description: "Set a profile execution mode. Client Mode runs locally with no VTX platform fee; Server Mode uses normal VTX infrastructure and fees.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId", "mode"],
-      properties: { profileId: { type: "number" }, mode: { type: "string", enum: ["client", "server"] } }
-    }
-  },
-  {
-    name: "vtx_bots_start",
-    description: "Start the Server Mode AI Trader for a profile through the normal backend path. Requires bot:control scope and normal Server Mode billing/caps.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId"],
-      properties: {
-        profileId: { type: "number" },
-        symbol: { type: "string" },
-        timeframe: { type: "string" },
-        size: { type: "string" },
-        leverage: { type: "number" },
-        interval: { type: "number" }
-      }
-    }
-  },
-  {
-    name: "vtx_bots_configure",
-    description: "Configure AI Trader profile preferences through the normal preferences API before starting a bot. Requires profile:write scope.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId"],
-      properties: {
-        profileId: { type: "number" },
-        symbol: { type: "string" },
-        timeframe: { type: "string" },
-        size: { type: "string" },
-        leverage: { type: "number" },
-        interval: { type: "number" }
-      }
-    }
-  },
-  {
-    name: "vtx_bots_stop",
-    description: "Stop the Server Mode AI Trader for a profile through the normal backend path. Requires bot:control scope.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId"],
-      properties: { profileId: { type: "number" } }
-    }
-  },
-  {
-    name: "vtx_bots_status",
-    description: "Read bot/runtime status for a profile.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId"],
-      properties: { profileId: { type: "number" } }
-    }
-  },
-  {
-    name: "vtx_bots_logs",
-    description: "Read AI Trader decision history/logs for a profile without executing trades.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId"],
-      properties: { profileId: { type: "number" } }
-    }
-  },
-  {
-    name: "vtx_runtime_status",
-    description: "Read Client Mode runtime status for a profile. Client Mode has no VTX platform fee; Server Mode bots use normal fees.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId"],
-      properties: { profileId: { type: "number" } }
-    }
-  },
-  {
-    name: "vtx_runtime_events",
-    description: "Read Client Mode runtime events for a profile. This is status/history visibility and does not execute local runtime work.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId"],
-      properties: {
-        profileId: { type: "number" },
-        limit: { type: "number" },
-        eventType: { type: "string" },
-        clientEventType: { type: "string" }
-      }
-    }
-  },
-  {
-    name: "vtx_trade_market_order",
-    description: "Submit a market order for a profile through the normal Trade page backend path. Requires trading:execute scope and uses the same risk checks, rate limits, and idempotency behavior as a user-submitted order.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId", "symbol", "side", "size"],
-      properties: {
-        profileId: { type: "number" },
-        symbol: { type: "string" },
-        side: { type: "string", enum: ["buy", "sell"] },
-        size: { type: "number" },
-        slippage: { type: "number" },
-        estimatedPrice: { type: "number" },
-        estimatedPriceTimestampMs: { type: "number" },
-        reduceOnly: { type: "boolean" },
-        protection: {
-          type: "object",
-          description: 'Optional fixed TP/SL like the AI page Auto SL/TP: take_profit and/or stop_loss, each { mode: "percent" | "usdc", value }. Placed as reduce-only market triggers from the average fill; not allowed with reduceOnly; no trailing stops.',
-          properties: {
-            take_profit: { type: "object", required: ["mode", "value"], properties: { mode: { type: "string", enum: ["percent", "usdc"] }, value: { type: "number" } } },
-            stop_loss: { type: "object", required: ["mode", "value"], properties: { mode: { type: "string", enum: ["percent", "usdc"] }, value: { type: "number" }, stop_type: { type: "string", enum: ["fixed"] } } }
-          }
-        }
-      }
-    }
-  },
-  {
-    name: "vtx_trade_limit_order",
-    description: "Submit a limit order for a profile through the normal Trade page backend path. Requires trading:execute scope and uses the same risk checks, rate limits, and idempotency behavior as a user-submitted order.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId", "symbol", "side", "size", "limitPrice"],
-      properties: {
-        profileId: { type: "number" },
-        symbol: { type: "string" },
-        side: { type: "string", enum: ["buy", "sell"] },
-        size: { type: "number" },
-        limitPrice: { type: "number" },
-        reduceOnly: { type: "boolean" }
-      }
-    }
-  },
-  {
-    name: "vtx_trade_cancel_order",
-    description: "Cancel an open order for a profile through the normal Trade page backend path. Requires trading:execute scope.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId", "symbol", "oid"],
-      properties: {
-        profileId: { type: "number" },
-        symbol: { type: "string" },
-        oid: { type: "number" }
-      }
-    }
-  },
-  {
-    name: "vtx_tokens_list",
-    description: "List agent tokens without returning raw token values.",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "vtx_billing_status",
-    description: "Read VTX billing balance for the authenticated user.",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "vtx_billing_prices",
-    description: "Read VTX pricing visibility, including Server Mode trader call fee and model pricing metadata.",
-    inputSchema: {
-      type: "object",
-      properties: { profileId: { type: "number" } }
-    }
-  },
-  {
-    name: "vtx_ai_config",
-    description: "Read the shared AI/runtime configuration contract used by the web app, CLI, MCP, and Client Mode runtime.",
-    inputSchema: {
-      type: "object",
-      properties: { profileId: { type: "number" } }
-    }
-  },
-  {
-    name: "vtx_secrets_status",
-    description: "Read secret readiness and masked previews for a profile. Raw stored secret values are not returned.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId"],
-      properties: { profileId: { type: "number" } }
-    }
-  },
-  {
-    name: "vtx_secrets_set",
-    description: "Write or rotate one runtime secret for a profile. The response redacts raw secret values.",
-    inputSchema: {
-      type: "object",
-      required: ["profileId", "field", "value"],
-      properties: {
-        profileId: { type: "number" },
-        field: { type: "string" },
-        value: { type: "string" }
-      }
-    }
-  }
-];
-var WRITABLE_SECRET_FIELDS = /* @__PURE__ */ new Set([
-  "hyperliquid_signing_key",
-  "local_ai_api_key",
-  "openai_compatible_api_key",
-  "openai_api_key",
-  "anthropic_api_key",
-  "gemini_api_key",
-  "grok_api_key",
-  "groq_api_key",
-  "openrouter_api_key",
-  "venice_api_key",
-  "deepseek_api_key",
-  "mistral_api_key",
-  "together_api_key",
-  "fireworks_api_key",
-  "byteplus_api_key",
-  "cerebras_api_key",
-  "moonshot_api_key",
-  "alibaba_cloud_model_studio_api_key",
-  "lightning_api_key"
-]);
-function requirePositiveNumber(input, key) {
-  const value = Number(input[key]);
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(`${key} must be a positive number`);
-  }
-  return value;
-}
-function optionalPositiveNumber(input, key) {
-  if (input[key] === void 0 || input[key] === null || input[key] === "") {
-    return void 0;
-  }
-  return requirePositiveNumber(input, key);
-}
-function optionalString(input, key) {
-  const value = String(input[key] || "").trim();
-  return value || null;
-}
-function botStartPayload(input) {
-  const payload = {};
-  for (const key of ["symbol", "timeframe", "size"]) {
-    const value = optionalString(input, key);
-    if (value) {
-      payload[key] = value;
-    }
-  }
-  const leverage = optionalPositiveNumber(input, "leverage");
-  if (leverage !== void 0) {
-    payload.leverage = leverage;
-  }
-  const interval = optionalPositiveNumber(input, "interval");
-  if (interval !== void 0) {
-    payload.interval = interval;
-  }
-  return payload;
-}
-function botConfigurePreferences(input) {
-  const preferences = {};
-  const trade = {};
-  const symbol = optionalString(input, "symbol");
-  if (symbol) {
-    const normalizedSymbol = normalizeHyperliquidMarketSymbol(symbol);
-    preferences.trading_symbols = [normalizedSymbol];
-    trade.tradingSymbol = normalizedSymbol;
-  }
-  const timeframe = optionalString(input, "timeframe");
-  if (timeframe) {
-    preferences.trading_timeframes = [timeframe.trim()];
-    trade.chartInterval = timeframe.trim();
-  }
-  const size = optionalString(input, "size");
-  if (size) {
-    preferences.ai_trade_amount = Number(size);
-    trade.orderSizeUSDC = size;
-  }
-  const leverage = optionalPositiveNumber(input, "leverage");
-  if (leverage !== void 0) {
-    trade.leverage = leverage;
-  }
-  const interval = optionalPositiveNumber(input, "interval");
-  if (interval !== void 0) {
-    preferences.trading_interval = interval;
-  }
-  if (Object.keys(trade).length > 0) {
-    preferences.trade = trade;
-  }
-  if (Object.keys(preferences).length === 0) {
-    throw new Error("At least one bot configuration field is required");
-  }
-  return preferences;
-}
-function requireOrderSide(input) {
-  const side = optionalString(input, "side");
-  if (side !== "buy" && side !== "sell") {
-    throw new Error("side must be buy or sell");
-  }
-  return side;
-}
-function requireSymbol(input) {
-  const symbol = optionalString(input, "symbol");
-  if (!symbol) {
-    throw new Error("symbol is required");
-  }
-  return normalizeHyperliquidMarketSymbol(symbol);
-}
-function marketOrderPayload(input) {
-  const payload = {
-    symbol: requireSymbol(input),
-    side: requireOrderSide(input),
-    size: requirePositiveNumber(input, "size")
-  };
-  const slippage = optionalPositiveNumber(input, "slippage");
-  if (slippage !== void 0) {
-    payload.slippage = slippage;
-  }
-  const estimatedPrice = optionalPositiveNumber(input, "estimatedPrice");
-  if (estimatedPrice !== void 0) {
-    payload.estimated_price = estimatedPrice;
-  }
-  const estimatedPriceTimestampMs = optionalPositiveNumber(input, "estimatedPriceTimestampMs");
-  if (estimatedPriceTimestampMs !== void 0) {
-    payload.estimated_price_timestamp_ms = estimatedPriceTimestampMs;
-  }
-  if (input.reduceOnly === true) {
-    payload.reduce_only = true;
-  }
-  if (input.protection !== void 0) {
-    if (input.protection === null || typeof input.protection !== "object" || Array.isArray(input.protection)) {
-      throw new Error("protection must be an object with take_profit and/or stop_loss");
-    }
-    payload.protection = input.protection;
-  }
-  return payload;
+  return payload;
 }
 function limitOrderPayload(input) {
   return {
@@ -904,57 +733,327 @@ async function callVtxMcpTool(client, name, input = {}) {
   }
   throw new Error(`Unknown VTX MCP tool: ${name}`);
 }
-
-// lib/agent-mcp/stdio.ts
-var MCP_PROTOCOL_VERSION = "2024-11-05";
-function jsonRpcResult(id, result) {
-  return { jsonrpc: "2.0", id, result };
-}
-function jsonRpcError(id, code, message, data) {
-  return { jsonrpc: "2.0", id, error: { code, message, data } };
-}
-function requestId(request) {
-  return request.id === void 0 ? null : request.id;
-}
-function isNotification(request) {
-  return request.id === void 0;
-}
-function stringifyToolResult(result) {
-  if (typeof result === "string") {
-    return result;
-  }
-  return JSON.stringify(result, null, 2);
-}
-async function handleMcpJsonRpcRequest(request, clientFactory = createDefaultMcpClient) {
-  const id = requestId(request);
-  const method = String(request.method || "").trim();
-  if (!method) {
-    return jsonRpcError(id, -32600, "Invalid JSON-RPC request.");
-  }
-  if (method === "initialize") {
-    return jsonRpcResult(id, {
-      protocolVersion: MCP_PROTOCOL_VERSION,
-      capabilities: {
-        tools: {}
+var VTX_MCP_TOOLS, WRITABLE_SECRET_FIELDS;
+var init_server = __esm({
+  "lib/agent-mcp/server.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    init_client();
+    init_config();
+    init_hyperliquid_market_symbol();
+    VTX_MCP_TOOLS = [
+      {
+        name: "vtx_whoami",
+        description: "Inspect the authenticated VTX user and agent-token scopes.",
+        inputSchema: { type: "object", properties: {} }
       },
-      serverInfo: {
-        name: "vtx-macro",
-        version: "2026.6.23"
-      }
-    });
-  }
-  if (method === "notifications/initialized") {
-    return null;
-  }
-  if (method === "ping") {
-    return jsonRpcResult(id, {});
-  }
-  if (method === "tools/list") {
-    return jsonRpcResult(id, { tools: VTX_MCP_TOOLS });
-  }
-  if (method === "tools/call") {
-    const params = request.params || {};
-    const name = String(params.name || "").trim();
+      {
+        name: "vtx_profiles_list",
+        description: "List profiles owned by the authenticated VTX user.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "vtx_profiles_create",
+        description: "Create a profile for the authenticated VTX user. Requires profile:write scope.",
+        inputSchema: {
+          type: "object",
+          properties: { sourceProfileId: { type: "number" } }
+        }
+      },
+      {
+        name: "vtx_profiles_update",
+        description: "Update the selected profile handle for the authenticated VTX user. Requires profile:write scope.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId", "name"],
+          properties: { profileId: { type: "number" }, name: { type: "string" } }
+        }
+      },
+      {
+        name: "vtx_profiles_delete",
+        description: "Delete a profile owned by the authenticated VTX user. Requires profile:write scope.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId"],
+          properties: { profileId: { type: "number" } }
+        }
+      },
+      {
+        name: "vtx_profiles_set_mode",
+        description: "Set a profile execution mode. Client Mode runs locally with no VTX platform fee; Server Mode uses normal VTX infrastructure and fees.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId", "mode"],
+          properties: { profileId: { type: "number" }, mode: { type: "string", enum: ["client", "server"] } }
+        }
+      },
+      {
+        name: "vtx_bots_start",
+        description: "Start the Server Mode AI Trader for a profile through the normal backend path. Requires bot:control scope and normal Server Mode billing/caps.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId"],
+          properties: {
+            profileId: { type: "number" },
+            symbol: { type: "string" },
+            timeframe: { type: "string" },
+            size: { type: "string" },
+            leverage: { type: "number" },
+            interval: { type: "number" }
+          }
+        }
+      },
+      {
+        name: "vtx_bots_configure",
+        description: "Configure AI Trader profile preferences through the normal preferences API before starting a bot. Requires profile:write scope.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId"],
+          properties: {
+            profileId: { type: "number" },
+            symbol: { type: "string" },
+            timeframe: { type: "string" },
+            size: { type: "string" },
+            leverage: { type: "number" },
+            interval: { type: "number" }
+          }
+        }
+      },
+      {
+        name: "vtx_bots_stop",
+        description: "Stop the Server Mode AI Trader for a profile through the normal backend path. Requires bot:control scope.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId"],
+          properties: { profileId: { type: "number" } }
+        }
+      },
+      {
+        name: "vtx_bots_status",
+        description: "Read bot/runtime status for a profile.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId"],
+          properties: { profileId: { type: "number" } }
+        }
+      },
+      {
+        name: "vtx_bots_logs",
+        description: "Read AI Trader decision history/logs for a profile without executing trades.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId"],
+          properties: { profileId: { type: "number" } }
+        }
+      },
+      {
+        name: "vtx_runtime_status",
+        description: "Read Client Mode runtime status for a profile. Client Mode has no VTX platform fee; Server Mode bots use normal fees.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId"],
+          properties: { profileId: { type: "number" } }
+        }
+      },
+      {
+        name: "vtx_runtime_events",
+        description: "Read Client Mode runtime events for a profile. This is status/history visibility and does not execute local runtime work.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId"],
+          properties: {
+            profileId: { type: "number" },
+            limit: { type: "number" },
+            eventType: { type: "string" },
+            clientEventType: { type: "string" }
+          }
+        }
+      },
+      {
+        name: "vtx_trade_market_order",
+        description: "Submit a market order for a profile through the normal Trade page backend path. Requires trading:execute scope and uses the same risk checks, rate limits, and idempotency behavior as a user-submitted order.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId", "symbol", "side", "size"],
+          properties: {
+            profileId: { type: "number" },
+            symbol: { type: "string" },
+            side: { type: "string", enum: ["buy", "sell"] },
+            size: { type: "number" },
+            slippage: { type: "number" },
+            estimatedPrice: { type: "number" },
+            estimatedPriceTimestampMs: { type: "number" },
+            reduceOnly: { type: "boolean" },
+            protection: {
+              type: "object",
+              description: 'Optional fixed TP/SL like the AI page Auto SL/TP: take_profit and/or stop_loss, each { mode: "percent" | "usdc", value }. Placed as reduce-only market triggers from the average fill; not allowed with reduceOnly; no trailing stops.',
+              properties: {
+                take_profit: { type: "object", required: ["mode", "value"], properties: { mode: { type: "string", enum: ["percent", "usdc"] }, value: { type: "number" } } },
+                stop_loss: { type: "object", required: ["mode", "value"], properties: { mode: { type: "string", enum: ["percent", "usdc"] }, value: { type: "number" }, stop_type: { type: "string", enum: ["fixed"] } } }
+              }
+            }
+          }
+        }
+      },
+      {
+        name: "vtx_trade_limit_order",
+        description: "Submit a limit order for a profile through the normal Trade page backend path. Requires trading:execute scope and uses the same risk checks, rate limits, and idempotency behavior as a user-submitted order.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId", "symbol", "side", "size", "limitPrice"],
+          properties: {
+            profileId: { type: "number" },
+            symbol: { type: "string" },
+            side: { type: "string", enum: ["buy", "sell"] },
+            size: { type: "number" },
+            limitPrice: { type: "number" },
+            reduceOnly: { type: "boolean" }
+          }
+        }
+      },
+      {
+        name: "vtx_trade_cancel_order",
+        description: "Cancel an open order for a profile through the normal Trade page backend path. Requires trading:execute scope.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId", "symbol", "oid"],
+          properties: {
+            profileId: { type: "number" },
+            symbol: { type: "string" },
+            oid: { type: "number" }
+          }
+        }
+      },
+      {
+        name: "vtx_tokens_list",
+        description: "List agent tokens without returning raw token values.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "vtx_billing_status",
+        description: "Read VTX billing balance for the authenticated user.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "vtx_billing_prices",
+        description: "Read VTX pricing visibility, including Server Mode trader call fee and model pricing metadata.",
+        inputSchema: {
+          type: "object",
+          properties: { profileId: { type: "number" } }
+        }
+      },
+      {
+        name: "vtx_ai_config",
+        description: "Read the shared AI/runtime configuration contract used by the web app, CLI, MCP, and Client Mode runtime.",
+        inputSchema: {
+          type: "object",
+          properties: { profileId: { type: "number" } }
+        }
+      },
+      {
+        name: "vtx_secrets_status",
+        description: "Read secret readiness and masked previews for a profile. Raw stored secret values are not returned.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId"],
+          properties: { profileId: { type: "number" } }
+        }
+      },
+      {
+        name: "vtx_secrets_set",
+        description: "Write or rotate one runtime secret for a profile. The response redacts raw secret values.",
+        inputSchema: {
+          type: "object",
+          required: ["profileId", "field", "value"],
+          properties: {
+            profileId: { type: "number" },
+            field: { type: "string" },
+            value: { type: "string" }
+          }
+        }
+      }
+    ];
+    WRITABLE_SECRET_FIELDS = /* @__PURE__ */ new Set([
+      "hyperliquid_signing_key",
+      "local_ai_api_key",
+      "openai_compatible_api_key",
+      "openai_api_key",
+      "anthropic_api_key",
+      "gemini_api_key",
+      "grok_api_key",
+      "groq_api_key",
+      "openrouter_api_key",
+      "venice_api_key",
+      "deepseek_api_key",
+      "mistral_api_key",
+      "together_api_key",
+      "fireworks_api_key",
+      "byteplus_api_key",
+      "cerebras_api_key",
+      "moonshot_api_key",
+      "alibaba_cloud_model_studio_api_key",
+      "lightning_api_key"
+    ]);
+  }
+});
+
+// lib/agent-mcp/stdio.ts
+var stdio_exports = {};
+__export(stdio_exports, {
+  encodeMcpFrame: () => encodeMcpFrame,
+  handleMcpJsonRpcRequest: () => handleMcpJsonRpcRequest,
+  runVtxMcpStdioServer: () => runVtxMcpStdioServer
+});
+function jsonRpcResult(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function jsonRpcError(id, code, message, data) {
+  return { jsonrpc: "2.0", id, error: { code, message, data } };
+}
+function requestId(request) {
+  return request.id === void 0 ? null : request.id;
+}
+function isNotification(request) {
+  return request.id === void 0;
+}
+function stringifyToolResult(result) {
+  if (typeof result === "string") {
+    return result;
+  }
+  return JSON.stringify(result, null, 2);
+}
+async function handleMcpJsonRpcRequest(request, clientFactory = createDefaultMcpClient) {
+  const id = requestId(request);
+  const method = String(request.method || "").trim();
+  if (!method) {
+    return jsonRpcError(id, -32600, "Invalid JSON-RPC request.");
+  }
+  if (method === "initialize") {
+    return jsonRpcResult(id, {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: {
+        tools: {}
+      },
+      serverInfo: {
+        name: "vtx-macro",
+        version: agent_cli_release_default.package_version
+      }
+    });
+  }
+  if (method === "notifications/initialized") {
+    return null;
+  }
+  if (method === "ping") {
+    return jsonRpcResult(id, {});
+  }
+  if (method === "tools/list") {
+    return jsonRpcResult(id, { tools: VTX_MCP_TOOLS });
+  }
+  if (method === "tools/call") {
+    const params = request.params || {};
+    const name = String(params.name || "").trim();
     const args = params.arguments && typeof params.arguments === "object" ? params.arguments : {};
     if (!name) {
       return jsonRpcError(id, -32602, "Tool name is required.");
@@ -1075,6 +1174,2416 @@ async function runVtxMcpStdioServer(input = process.stdin, output = process.stdo
     }
   }
 }
+var MCP_PROTOCOL_VERSION;
+var init_stdio = __esm({
+  "lib/agent-mcp/stdio.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    init_agent_cli_release();
+    init_server();
+    MCP_PROTOCOL_VERSION = "2024-11-05";
+  }
+});
 
 // bin/vtx-mcp.ts
-await runVtxMcpStdioServer();
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+
+// lib/cli-release/updater.ts
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+init_agent_cli_release();
+import { spawn as spawn2 } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { access, appendFile, chmod, lstat as lstat2, mkdir as mkdir3, readFile as readFile3, readdir as readdir3, realpath as realpath2, rename as rename2, rm as rm3 } from "node:fs/promises";
+import { constants as osConstants, homedir as homedir3 } from "node:os";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join3, relative as relative2, resolve as resolve2, win32 as windowsPath2 } from "node:path";
+
+// lib/runtime-policy.generated.json
+var runtime_policy_generated_default = {
+  ui: {
+    performance_defaults: {
+      default_timeframe: "30d"
+    },
+    execution_metadata_retry: {
+      max_attempts: 3,
+      base_delay_milliseconds: 2e3,
+      max_delay_milliseconds: 3e4
+    },
+    auth_bootstrap_retry: {
+      max_attempts: 3,
+      jitter_milliseconds: 750,
+      base_delay_milliseconds: 500,
+      min_delay_milliseconds: 250,
+      max_delay_milliseconds: 1e4
+    },
+    trade_refresh_policy: {
+      server_config_stream_timeout_ms: 1e4,
+      config_retry_interval_ms: 5e3,
+      copy_trading_status_poll_ms: 5e3,
+      post_execution_refresh_delay_ms: 3e3,
+      account_read_backoff_min_ms: 2e3,
+      account_read_backoff_max_ms: 6e4
+    },
+    deployment_reload_observability: {
+      bootstrap_max_error_events_per_page: 4,
+      bootstrap_max_profiles: 10
+    }
+  },
+  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: {
+        reconcile: {
+          tick_interval_seconds: 30,
+          wake_jitter_max_ms: 1e3,
+          network_backoff_max_seconds: 300,
+          steal_ack_timeout_ms: 5e3,
+          explicit_claim_max_waits: 3,
+          local_ai_preflight_timeout_ms: 3e3
+        },
+        observability: {
+          deployment_reload_stall_warning_ms: 15e3
+        },
+        protective_actions: {
+          adoption_request_timeout_milliseconds: 2e4,
+          idle_recheck_seconds: 60,
+          attention_refresh_seconds: 60,
+          evidence_max_items: 32,
+          evidence_shared_read_seconds: 10
+        },
+        history_evidence: {
+          device_rounds_per_beat: 6,
+          device_retry_seconds: 60
+        },
+        panel_reads: {
+          device_open_orders_reuse_seconds: 2
+        },
+        account_stream: {
+          fill_forward_interval_ms: 1e3,
+          fill_forward_max_pending: 500
+        },
+        hyperliquid_snapshot: {
+          max_fills_per_execution: 20,
+          max_fill_payload_bytes: 32768
+        }
+      },
+      server_runtime: {
+        prompt_rescue: {
+          request_ttl_seconds: 20,
+          snapshot_max_age_seconds: 5,
+          snapshot_component_max_skew_seconds: 2,
+          client_claim_http_timeout_milliseconds: 5e3,
+          client_claim_retry_delay_milliseconds: 1e3,
+          client_failure_report_timeout_milliseconds: 2e3,
+          client_presence_heartbeat_interval_milliseconds: 3e4,
+          client_presence_http_timeout_milliseconds: 5e3
+        }
+      }
+    },
+    history_reads: {
+      max_requests_per_read: 64,
+      history_start_ms: 16409952e5,
+      device_read_deadline_seconds: 180,
+      device_recent_window_hours: 24
+    }
+  },
+  agent_cli: {
+    update_check_interval_ms: 144e5,
+    update_check_timeout_ms: 5e3,
+    stage_timeout_ms: 6e5,
+    startup_ready_timeout_ms: 12e4
+  },
+  leaderboard: {
+    device_portfolio: {
+      device_retry_seconds: 300
+    }
+  },
+  external_inference: {
+    service: {
+      update_check_interval_ms: 3e5,
+      update_registry_timeout_ms: 15e3,
+      bootstrap_readiness_timeout_ms: 6e5,
+      bootstrap_stop_timeout_ms: 1e4,
+      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
+    },
+    claim_diagnostics: {
+      event_loop_sample_interval_ms: 100
+    }
+  },
+  desktop: {
+    runtime_watchdog: {
+      ping_interval_milliseconds: 15e3,
+      telemetry_interval_milliseconds: 3e5
+    },
+    updates: {
+      auto_check_interval_seconds: 21600
+    }
+  },
+  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
+    }
+  },
+  exchange: {
+    hyperliquid: {
+      client_public_read_budget: {
+        max_weight: 1200,
+        window_seconds: 60,
+        ui_max_weight_percent: 75,
+        background_max_weight_percent: 50,
+        cooldown_seconds: 60,
+        metadata_ttl_seconds: 300,
+        user_fees_ttl_seconds: 300,
+        account_mode_ttl_seconds: 30,
+        default_request_weight: 20,
+        cache_max_entries: 512
+      },
+      read_budget: {
+        weights: {
+          exchange: 1,
+          exchangeStatus: 2,
+          clearinghouseState: 2,
+          spotClearinghouseState: 2,
+          l2Book: 2,
+          allMids: 2,
+          userFills: 120,
+          userFillsByTime: 120,
+          historicalOrders: 120,
+          twapHistory: 120,
+          userTwapSliceFills: 120,
+          userFunding: 45,
+          userNonFundingLedgerUpdates: 45,
+          candleSnapshot: 104,
+          userRole: 60,
+          userAbstraction: 20,
+          userDexAbstraction: 20,
+          activeAssetData: 20,
+          openOrders: 20,
+          orderStatus: 2,
+          portfolio: 20,
+          userFees: 20,
+          metaAndAssetCtxs: 20,
+          meta: 20,
+          perpDexs: 20,
+          spotMeta: 20,
+          approvedAgents: 20,
+          authorizedAgents: 20,
+          agents: 20,
+          apiWallets: 20
+        },
+        exchange_action_batch_size: 40
+      },
+      public_recovery: {
+        fallback_initial_seconds: 2,
+        fallback_max_seconds: 60,
+        permit_lease_seconds: 60,
+        recovery_initial_concurrency: 1,
+        recovery_max_concurrency: 8,
+        recovery_successes_per_step: 4,
+        recovery_min_spacing_ms: 100,
+        queue_poll_ms: 50,
+        recovery_queue_wait_seconds: 10,
+        recovery_quiet_seconds: 30
+      },
+      http: {
+        exchange: {
+          request_timeout_seconds: 10,
+          pool_timeout_seconds: 10
+        },
+        public_critical: {
+          request_timeout_seconds: 10,
+          pool_timeout_seconds: 5
+        }
+      },
+      public_request_priority: {
+        trading_reduce: 1,
+        trading_reconcile: 2,
+        trading_execute: 3,
+        trading_analysis: 4,
+        ui: 5,
+        background: 6
+      },
+      account_stream_backoff: {
+        initial_seconds: 1,
+        max_seconds: 15,
+        multiplier: 2,
+        jitter_seconds: 2,
+        reset_after_seconds: 60
+      },
+      websocket: {
+        ping_interval_seconds: 20,
+        account_open_timeout_seconds: 10
+      }
+    },
+    cache: {
+      order_history_ttl_seconds: 30,
+      twap_history_ttl_seconds: 30,
+      twap_fills_ttl_seconds: 30,
+      funding_history_ttl_seconds: 300
+    }
+  },
+  data_sync: {
+    trade_chain_history: {
+      range_page_limit: 500
+    }
+  }
+};
+
+// lib/cli-release/updater.ts
+init_config();
+
+// lib/inference-host/config.ts
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { lstat, mkdir as mkdir2, open, readdir as readdir2, readFile as readFile2, realpath, rename, rm as rm2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { basename, dirname as dirname2, isAbsolute, join as join2, relative, resolve, win32 as windowsPath } from "node:path";
+
+// node_modules/smol-toml/dist/index.js
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+
+// node_modules/smol-toml/dist/parse.js
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+
+// node_modules/smol-toml/dist/struct.js
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+
+// node_modules/smol-toml/dist/primitive.js
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+
+// node_modules/smol-toml/dist/date.js
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+
+// node_modules/smol-toml/dist/error.js
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+
+// node_modules/smol-toml/dist/util.js
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+
+// node_modules/smol-toml/dist/extract.js
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+
+// node_modules/smol-toml/dist/stringify.js
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+
+// lib/inference-host/mcp-transport-config.ts
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+
+// lib/inference-host/config.ts
+var InferenceHostProcessLockBusyError = class extends Error {
+  constructor() {
+    super("Another inference host process already owns this local host.");
+    this.name = "InferenceHostProcessLockBusyError";
+  }
+};
+var MAX_INFERENCE_PRIVATE_FILE_BYTES = 16 * 1024 * 1024;
+var WINDOWS_PRIVATE_ACL_BROKER_SCRIPT = `$ErrorActionPreference='Stop'
+$ProgressPreference='SilentlyContinue'
+while(($line=[Console]::In.ReadLine()) -ne $null) {
+  $requestId=$null
+  $failureStage='request_validation'
+  try {
+    if($line.Length -lt 2 -or $line.Length -gt 65536) { throw 'invalid request size' }
+    $request=$line | ConvertFrom-Json
+    $names=@($request.PSObject.Properties.Name | Sort-Object)
+    if(($names -join ',') -ne 'id,kind,mode,path_b64') { throw 'invalid request shape' }
+    if($request.id -isnot [long] -and $request.id -isnot [int]) { throw 'invalid request id' }
+    $requestId=[long]$request.id
+    if($requestId -lt 1) { throw 'invalid request id' }
+    $kind=[string]$request.kind
+    $mode=[string]$request.mode
+    if($kind -ne 'directory' -and $kind -ne 'file') { throw 'invalid path kind' }
+    if($mode -ne 'harden' -and $mode -ne 'verify' -and $mode -ne 'verify-owner') { throw 'invalid ACL mode' }
+    $path=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String([string]$request.path_b64))
+    if([string]::IsNullOrWhiteSpace($path) -or $path.Length -gt 32767 -or $path.Contains([char]0)) { throw 'invalid path' }
+    $failureStage='path_lookup'
+    if(-not (Test-Path -LiteralPath $path)) {
+      [Console]::Out.WriteLine((@{id=$requestId;status='missing'} | ConvertTo-Json -Compress))
+      continue
+    }
+    $failureStage='principal_resolution'
+    $currentIdentity=[Security.Principal.WindowsIdentity]::GetCurrent()
+    $current=$currentIdentity.User
+    $system=New-Object Security.Principal.SecurityIdentifier('S-1-5-18')
+    $admins=New-Object Security.Principal.SecurityIdentifier('S-1-5-32-544')
+    $currentIsAdmin=(New-Object Security.Principal.WindowsPrincipal($currentIdentity)).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+    $allowed=@($current.Value,$system.Value,$admins.Value)
+    if($mode -eq 'harden') {
+      $failureStage='acl_read'
+      $acl=Get-Acl -LiteralPath $path
+      $originalAccess=$acl.GetSecurityDescriptorSddlForm([Security.AccessControl.AccessControlSections]::Access)
+      $failureStage='owner_validation'
+      $existingOwner=(New-Object Security.Principal.NTAccount($acl.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value
+      if($existingOwner -ne $current.Value -and ($existingOwner -ne $admins.Value -or -not $currentIsAdmin)) { throw 'private ACL owner is invalid' }
+      $failureStage='acl_mutation'
+      $acl.SetAccessRuleProtection($true,$false)
+      foreach($existingRule in @($acl.Access)) { [void]$acl.RemoveAccessRuleSpecific($existingRule) }
+      $inherit=if($kind -eq 'directory') {
+        [Security.AccessControl.InheritanceFlags]'ContainerInherit,ObjectInherit'
+      } else { [Security.AccessControl.InheritanceFlags]::None }
+      foreach($sid in @($current,$system,$admins)) {
+        $rule=New-Object Security.AccessControl.FileSystemAccessRule(
+          $sid,
+          [Security.AccessControl.FileSystemRights]::FullControl,
+          $inherit,
+          [Security.AccessControl.PropagationFlags]::None,
+          [Security.AccessControl.AccessControlType]::Allow
+        )
+        [void]$acl.AddAccessRule($rule)
+      }
+      $failureStage='acl_write'
+      if($originalAccess -ne $acl.GetSecurityDescriptorSddlForm([Security.AccessControl.AccessControlSections]::Access)) {
+        (Get-Item -LiteralPath $path).SetAccessControl($acl)
+      }
+    }
+    $failureStage='acl_readback'
+    $actual=Get-Acl -LiteralPath $path
+    $failureStage='acl_verification'
+    $owner=(New-Object Security.Principal.NTAccount($actual.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value
+    if($owner -ne $current.Value -and ($owner -ne $admins.Value -or -not $currentIsAdmin)) { throw 'private ACL owner is invalid' }
+    if($mode -ne 'verify-owner') {
+      if(-not $actual.AreAccessRulesProtected) { throw 'private ACL inheritance is invalid' }
+      $userFull=$false
+      foreach($rule in $actual.Access) {
+        $sid=$rule.IdentityReference.Translate([Security.Principal.SecurityIdentifier]).Value
+        if($rule.IsInherited -or $allowed -notcontains $sid -or $rule.AccessControlType -ne [Security.AccessControl.AccessControlType]::Allow) {
+          throw 'private ACL contains an unauthorized access rule'
+        }
+        if($sid -eq $current.Value -and (($rule.FileSystemRights -band [Security.AccessControl.FileSystemRights]::FullControl) -eq [Security.AccessControl.FileSystemRights]::FullControl)) { $userFull=$true }
+      }
+      if(-not $userFull) { throw 'private ACL does not grant the current user full control' }
+    }
+    [Console]::Out.WriteLine((@{id=$requestId;status='ok'} | ConvertTo-Json -Compress))
+  } catch {
+    [Console]::Out.WriteLine((@{id=$requestId;status='error';error_code=$failureStage} | ConvertTo-Json -Compress))
+  }
+}`;
+var WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS = 15e3;
+var WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS = 9e4;
+var SMALL_IDENTITY_COMMAND_TIMEOUT_MS = 5e3;
+var windowsPowerShellEnvironment = (extra = {}) => {
+  const sanitizedExtra = { ...extra };
+  delete sanitizedExtra.PSModulePath;
+  const windowsRoot = process.env.SystemRoot ?? process.env.WINDIR;
+  return {
+    ...sanitizedExtra,
+    NODE_ENV: process.env.NODE_ENV,
+    SystemRoot: process.env.SystemRoot,
+    WINDIR: process.env.WINDIR,
+    ComSpec: process.env.ComSpec,
+    PATHEXT: process.env.PATHEXT,
+    PSModulePath: windowsRoot ? windowsPath.join(windowsRoot, "System32", "WindowsPowerShell", "v1.0", "Modules") : void 0,
+    TEMP: process.env.TEMP,
+    TMP: process.env.TMP
+  };
+};
+var windowsPrivateAclBrokerInvocation = () => ({
+  args: [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-EncodedCommand",
+    Buffer.from(WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, "utf16le").toString("base64")
+  ],
+  env: windowsPowerShellEnvironment()
+});
+var WindowsPrivateAclBroker = class {
+  constructor(dependencies = {}) {
+    this.child = null;
+    this.requestSequence = 0;
+    this.queue = Promise.resolve();
+    this.pending = null;
+    this.outputBuffer = "";
+    this.idleTimer = null;
+    this.run = async (path, kind, mode) => {
+      const operation = this.queue.then(
+        () => this.dispatch(path, kind, mode),
+        () => this.dispatch(path, kind, mode)
+      );
+      this.queue = operation.then(() => void 0, () => void 0);
+      await operation;
+    };
+    this.requestTimeoutMs = dependencies.requestTimeoutMs ?? 15e3;
+    this.startupRequestTimeoutMs = dependencies.startupRequestTimeoutMs ?? WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS;
+    this.idleShutdownMs = dependencies.idleShutdownMs ?? 3e4;
+    this.spawnProcess = dependencies.spawnProcess ?? (() => {
+      const invocation = windowsPrivateAclBrokerInvocation();
+      return spawn("powershell.exe", [...invocation.args], {
+        env: invocation.env,
+        windowsHide: true,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    });
+  }
+  scheduleIdleShutdown() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = setTimeout(() => {
+      this.idleTimer = null;
+      const child = this.child;
+      if (!child || this.pending) return;
+      this.child = null;
+      this.outputBuffer = "";
+      child.stdin.end();
+      const force = setTimeout(() => child.kill("SIGKILL"), 1e3);
+      force.unref();
+      child.once("exit", () => clearTimeout(force));
+    }, this.idleShutdownMs);
+    this.idleTimer.unref();
+  }
+  failChild(child, error) {
+    if (this.child !== child) return;
+    this.child = null;
+    this.outputBuffer = "";
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    const pending = this.pending;
+    this.pending = null;
+    if (pending) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    child.kill("SIGKILL");
+  }
+  acceptLine(child, line) {
+    const pending = this.pending;
+    if (!pending || !line || line.length > 4096) {
+      this.failChild(child, new Error("Windows private ACL broker returned malformed output."));
+      return;
+    }
+    let response;
+    try {
+      const parsed = JSON.parse(line);
+      const status = String(parsed.status);
+      const expectedKeys = status === "error" ? "error_code\0id\0status" : "id\0status";
+      if (Object.keys(parsed).sort().join("\0") !== expectedKeys || parsed.id !== pending.id || !["ok", "missing", "error"].includes(status) || status === "error" && ![
+        "request_validation",
+        "path_lookup",
+        "principal_resolution",
+        "acl_read",
+        "owner_validation",
+        "acl_mutation",
+        "acl_write",
+        "acl_readback",
+        "acl_verification"
+      ].includes(String(parsed.error_code))) throw new Error("invalid response");
+      response = parsed;
+    } catch {
+      this.failChild(child, new Error("Windows private ACL broker returned malformed output."));
+      return;
+    }
+    this.pending = null;
+    clearTimeout(pending.timer);
+    if (response.status === "ok") {
+      pending.resolve();
+    } else if (response.status === "missing") {
+      const error = new Error("Windows private path no longer exists.");
+      error.code = "ENOENT";
+      pending.reject(error);
+    } else {
+      pending.reject(new Error(
+        `Windows private ACL ${pending.mode} failed (${response.error_code}).`
+      ));
+    }
+    this.scheduleIdleShutdown();
+  }
+  ensureChild() {
+    if (this.child && this.child.exitCode === null && !this.child.killed) {
+      return { child: this.child, startedNow: false };
+    }
+    const child = this.spawnProcess();
+    this.child = child;
+    this.outputBuffer = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      if (this.child !== child) return;
+      this.outputBuffer += chunk;
+      if (this.outputBuffer.length > 65536) {
+        this.failChild(child, new Error("Windows private ACL broker exceeded its output limit."));
+        return;
+      }
+      while (this.child === child) {
+        const newline = this.outputBuffer.indexOf("\n");
+        if (newline < 0) break;
+        const line = this.outputBuffer.slice(0, newline).trim();
+        this.outputBuffer = this.outputBuffer.slice(newline + 1);
+        this.acceptLine(child, line);
+      }
+    });
+    child.stderr.on("data", () => void 0);
+    child.once("error", () => {
+      this.failChild(child, new Error("Windows private ACL broker failed to start."));
+    });
+    child.once("exit", () => {
+      this.failChild(child, new Error("Windows private ACL broker exited before confirmation."));
+    });
+    child.unref();
+    for (const stream of [child.stdin, child.stdout, child.stderr]) {
+      stream.unref?.();
+    }
+    return { child, startedNow: true };
+  }
+  async dispatch(path, kind, mode) {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    const id = ++this.requestSequence;
+    const request = `${JSON.stringify({
+      id,
+      kind,
+      mode,
+      path_b64: Buffer.from(path, "utf8").toString("base64")
+    })}
+`;
+    if (Buffer.byteLength(request, "utf8") > 65536) {
+      throw new Error("Windows private ACL broker request exceeds its input limit.");
+    }
+    const { child, startedNow } = this.ensureChild();
+    const timeoutMs = startedNow ? this.startupRequestTimeoutMs : this.requestTimeoutMs;
+    await new Promise((resolvePromise, reject) => {
+      const timer = setTimeout(() => {
+        this.failChild(child, new Error("Windows private ACL broker request timed out."));
+      }, timeoutMs);
+      this.pending = { id, mode, resolve: resolvePromise, reject, timer };
+      child.stdin.write(request, "utf8", (error) => {
+        if (error) {
+          this.failChild(child, new Error("Windows private ACL broker request failed."));
+        }
+      });
+    });
+  }
+  close() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = null;
+    const child = this.child;
+    this.child = null;
+    this.outputBuffer = "";
+    if (child) child.stdin.end();
+  }
+};
+var defaultWindowsPrivateAclBroker = new WindowsPrivateAclBroker();
+var runWindowsPrivateAcl = async (path, kind, mode) => await defaultWindowsPrivateAclBroker.run(path, kind, mode);
+var windowsAclCache = /* @__PURE__ */ new Map();
+var windowsAclIdentity = async (path) => {
+  const metadata = await lstat(path, { bigint: true });
+  return {
+    dev: metadata.dev,
+    ino: metadata.ino,
+    ctimeNs: metadata.ctimeNs,
+    mtimeNs: metadata.mtimeNs,
+    mode: metadata.mode,
+    size: metadata.size
+  };
+};
+var aclCacheKey = (path, kind, mode) => `${kind}:${mode}:${resolve(path)}`;
+var secureWindowsPrivatePath = async (path, kind, mode, platform = process.platform, runner = runWindowsPrivateAcl) => {
+  if (platform !== "win32") return;
+  const key = aclCacheKey(path, kind, mode);
+  const before = await windowsAclIdentity(path);
+  const cached = windowsAclCache.get(key);
+  if (cached && cached.dev === before.dev && cached.ino === before.ino && cached.ctimeNs === before.ctimeNs && cached.mtimeNs === before.mtimeNs && cached.mode === before.mode && cached.size === before.size) return;
+  await runner(path, kind, mode);
+  windowsAclCache.set(key, await windowsAclIdentity(path));
+};
+var invalidateWindowsAclCache = (path) => {
+  for (const kind of ["file", "directory"]) {
+    for (const mode of ["harden", "verify", "verify-owner"]) {
+      windowsAclCache.delete(aclCacheKey(path, kind, mode));
+    }
+  }
+};
+var rebindHardenedWindowsAclAfterRename = async (source, destination, kind, expected) => {
+  const resolvedSource = resolve(source);
+  const resolvedDestination = resolve(destination);
+  if (resolvedSource === resolvedDestination || dirname2(resolvedSource) !== dirname2(resolvedDestination)) {
+    throw new Error("Windows private ACL cache rename boundary is invalid.");
+  }
+  const published = await windowsAclIdentity(destination);
+  if (published.dev !== expected.dev || published.ino !== expected.ino || published.mode !== expected.mode || published.mtimeNs !== expected.mtimeNs || published.size !== expected.size) {
+    invalidateWindowsAclCache(source);
+    invalidateWindowsAclCache(destination);
+    throw new Error("Windows private file identity changed during atomic publication.");
+  }
+  invalidateWindowsAclCache(source);
+  invalidateWindowsAclCache(destination);
+  for (const mode of ["harden", "verify", "verify-owner"]) {
+    windowsAclCache.set(aclCacheKey(destination, kind, mode), published);
+  }
+};
+var rebindHardenedWindowsDirectoryAfterOwnedMutation = async (path, expected) => {
+  const current = await windowsAclIdentity(path);
+  if (current.dev !== expected.dev || current.ino !== expected.ino || current.mode !== expected.mode) {
+    invalidateWindowsAclCache(path);
+    throw new Error("Windows private directory identity changed during atomic publication.");
+  }
+  invalidateWindowsAclCache(path);
+  for (const mode of ["harden", "verify", "verify-owner"]) {
+    windowsAclCache.set(aclCacheKey(path, "directory", mode), current);
+  }
+};
+var isDefaultWindowsPrivatePath = (path, root = resolve(homedir2(), ".vtx", "inference-host")) => {
+  const child = relative(root, resolve(path));
+  return child === "" || !child.startsWith("..") && !child.includes(":");
+};
+var secureExistingWindowsPath = async (path, kind, platform = process.platform, runner = runWindowsPrivateAcl, defaultRoot = resolve(homedir2(), ".vtx", "inference-host")) => {
+  if (platform !== "win32") return;
+  if (!isDefaultWindowsPrivatePath(path, defaultRoot)) {
+    await secureWindowsPrivatePath(path, kind, "verify", platform, runner);
+    return;
+  }
+  await secureWindowsPrivatePath(path, kind, "harden", platform, runner);
+};
+var linuxProcessIdentity = async (pid) => {
+  try {
+    const [bootId, statLine] = await Promise.all([
+      readFile2("/proc/sys/kernel/random/boot_id", "utf8"),
+      readFile2(`/proc/${pid}/stat`, "utf8")
+    ]);
+    const fields = statLine.slice(statLine.lastIndexOf(")") + 2).trim().split(/\s+/u);
+    const startTicks = fields[19];
+    return startTicks ? `linux:${bootId.trim()}:${startTicks}` : null;
+  } catch {
+    return null;
+  }
+};
+var windowsProcessIdentityInvocation = (pid) => {
+  const script = `$ErrorActionPreference='Stop';$p=[Diagnostics.Process]::GetProcessById([int]$env:VTX_PROCESS_PID);[Console]::Out.Write($p.StartTime.ToUniversalTime().ToFileTimeUtc())`;
+  return {
+    args: [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-EncodedCommand",
+      Buffer.from(script, "utf16le").toString("base64")
+    ],
+    env: windowsPowerShellEnvironment({ VTX_PROCESS_PID: String(pid) }),
+    timeoutMs: WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS
+  };
+};
+var windowsBootIdentityInvocation = () => {
+  const script = `$ErrorActionPreference='Stop';$s=[System.Management.ManagementObjectSearcher]::new('SELECT LastBootUpTime FROM Win32_OperatingSystem');try{$c=$s.Get();$e=$c.GetEnumerator();if(-not $e.MoveNext()){throw 'boot identity unavailable'};$raw=[string]$e.Current['LastBootUpTime'];$v=[System.Management.ManagementDateTimeConverter]::ToDateTime($raw).ToUniversalTime().ToFileTimeUtc();[Console]::Out.Write($v)}finally{if($c){$c.Dispose()};$s.Dispose()}`;
+  return {
+    args: [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-EncodedCommand",
+      Buffer.from(script, "utf16le").toString("base64")
+    ],
+    env: windowsPowerShellEnvironment(),
+    timeoutMs: WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS
+  };
+};
+var windowsProcessIdentity = async (pid) => await new Promise((resolvePromise) => {
+  const invocation = windowsProcessIdentityInvocation(pid);
+  const child = spawn("powershell.exe", [...invocation.args], {
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "ignore"],
+    env: invocation.env
+  });
+  const output = [];
+  let settled = false;
+  const settle = (value) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    resolvePromise(value);
+  };
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+    settle(null);
+  }, invocation.timeoutMs);
+  child.stdout.on("data", (chunk) => {
+    if (output.reduce((total, item) => total + item.byteLength, 0) + Buffer.byteLength(chunk) > 1024) {
+      child.kill("SIGKILL");
+      settle(null);
+      return;
+    }
+    output.push(Buffer.from(chunk));
+  });
+  child.once("error", () => settle(null));
+  child.once("exit", (code) => {
+    const started = Buffer.concat(output).toString("utf8").trim();
+    settle(code === 0 && /^\d+$/u.test(started) ? `win32:${started}` : null);
+  });
+});
+var darwinProcessIdentity = async (pid) => await new Promise((resolvePromise) => {
+  const child = spawn("ps", ["-p", String(pid), "-o", "lstart="], {
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  const output = [];
+  let settled = false;
+  const settle = (value) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    resolvePromise(value);
+  };
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+    settle(null);
+  }, 5e3);
+  child.stdout.on("data", (chunk) => output.push(Buffer.from(chunk)));
+  child.once("error", () => settle(null));
+  child.once("exit", (code) => {
+    const started = Date.parse(Buffer.concat(output).toString("utf8").trim());
+    settle(code === 0 && Number.isFinite(started) ? `darwin:${Math.floor(started / 1e3)}` : null);
+  });
+});
+var runSmallIdentityCommand = async (command, args, env, timeoutMs = SMALL_IDENTITY_COMMAND_TIMEOUT_MS) => await new Promise((resolvePromise) => {
+  const child = spawn(command, [...args], {
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "ignore"],
+    env
+  });
+  const output = [];
+  let bytes = 0;
+  let settled = false;
+  const settle = (value) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    resolvePromise(value);
+  };
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+    settle(null);
+  }, timeoutMs);
+  child.stdout.on("data", (chunk) => {
+    bytes += Buffer.byteLength(chunk);
+    if (bytes > 4096) {
+      child.kill("SIGKILL");
+      settle(null);
+      return;
+    }
+    output.push(Buffer.from(chunk));
+  });
+  child.once("error", () => settle(null));
+  child.once("exit", (code) => settle(
+    code === 0 ? Buffer.concat(output).toString("utf8").trim() || null : null
+  ));
+});
+var cachedSystemBootIdentity = null;
+var readInferenceSystemBootIdentity = async (platform = process.platform) => {
+  if (platform === process.platform && cachedSystemBootIdentity) {
+    return await cachedSystemBootIdentity;
+  }
+  const read = async () => {
+    let identity = null;
+    if (platform === "linux") {
+      try {
+        identity = (await readFile2("/proc/sys/kernel/random/boot_id", "utf8")).trim();
+      } catch {
+        identity = null;
+      }
+    } else if (platform === "win32") {
+      const invocation = windowsBootIdentityInvocation();
+      identity = await runSmallIdentityCommand(
+        "powershell.exe",
+        invocation.args,
+        invocation.env,
+        invocation.timeoutMs
+      );
+    } else if (platform === "darwin") {
+      identity = await runSmallIdentityCommand("sysctl", ["-n", "kern.boottime"], void 0);
+    }
+    if (!identity || /[\r\n\0]/u.test(identity)) {
+      throw new Error("Inference host could not establish the current system boot identity.");
+    }
+    return `${platform}:${identity}`;
+  };
+  const pending = read();
+  if (platform === process.platform) cachedSystemBootIdentity = pending;
+  try {
+    return await pending;
+  } catch (error) {
+    if (platform === process.platform) cachedSystemBootIdentity = null;
+    throw error;
+  }
+};
+var defaultProcessIdentity = async (pid) => {
+  if (process.platform === "linux") return await linuxProcessIdentity(pid);
+  if (process.platform === "win32") return await windowsProcessIdentity(pid);
+  if (process.platform === "darwin") return await darwinProcessIdentity(pid);
+  return null;
+};
+var cachedCurrentProcessIdentity = null;
+var defaultCurrentProcessIdentity = async () => {
+  if (!cachedCurrentProcessIdentity) {
+    cachedCurrentProcessIdentity = (async () => {
+      const identity = await defaultProcessIdentity(process.pid);
+      if (!identity) throw new Error("Inference host could not establish its process-start identity.");
+      return identity;
+    })();
+  }
+  const pending = cachedCurrentProcessIdentity;
+  try {
+    return await pending;
+  } catch (error) {
+    if (cachedCurrentProcessIdentity === pending) cachedCurrentProcessIdentity = null;
+    throw error;
+  }
+};
+var processLockObservationCache = /* @__PURE__ */ new Map();
+var inferenceProcessIdentitiesMatch = (stored, observed) => stored === observed;
+function inferenceBaseDir(env) {
+  const configured = String(env.VTX_INFERENCE_HOST_HOME || "").trim();
+  return configured || join2(homedir2(), ".vtx", "inference-host");
+}
+var resolveInferenceHostApiUrl = (env) => String(env.VTX_API_URL || "https://api.vtxmacro.com").replace(/\/+$/, "");
+var inferenceHostSupervisorServiceManifestPath = (env) => `${join2(inferenceBaseDir(env), "state.json")}.service.json`;
+async function ensureInferencePrivateDirectory(path, dependencies = {}) {
+  const platform = dependencies.platform ?? process.platform;
+  const runner = dependencies.runner ?? runWindowsPrivateAcl;
+  const defaultRoot = dependencies.defaultRoot ?? resolve(homedir2(), ".vtx", "inference-host");
+  let created = false;
+  try {
+    const before = await lstat(path);
+    if (before.isSymbolicLink() || !before.isDirectory()) {
+      throw new Error("Inference host state directory is unsafe.");
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    await mkdir2(path, { recursive: true, mode: 448 });
+    created = true;
+  }
+  const after = await lstat(path);
+  if (after.isSymbolicLink() || !after.isDirectory()) {
+    throw new Error("Inference host state directory is unsafe.");
+  }
+  if (platform === "win32") {
+    if (created) {
+      await secureWindowsPrivatePath(path, "directory", "harden", platform, runner);
+    } else {
+      await secureExistingWindowsPath(
+        path,
+        "directory",
+        platform,
+        runner,
+        defaultRoot
+      );
+    }
+    return;
+  }
+  if ((after.mode & 63) !== 0) {
+    throw new Error("Inference host state directory must have mode 0700.");
+  }
+  if (typeof process.getuid === "function" && after.uid !== process.getuid()) {
+    throw new Error("Inference host state directory must be owned by the current user.");
+  }
+  const canonical = await realpath(path);
+  if (canonical !== resolve(path)) {
+    throw new Error("Inference host state directory may not traverse symbolic links.");
+  }
+}
+async function syncInferenceDirectory(path, platform = process.platform) {
+  if (platform === "win32") return;
+  const handle = await open(path, constants.O_RDONLY | constants.O_DIRECTORY);
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+var WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "EACCES",
+  "EBUSY",
+  "EEXIST",
+  "ENOTEMPTY",
+  "EPERM"
+]);
+async function replaceAtomicInferencePrivateFile(temporaryPath, destinationPath, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const renameFile = options.renameFile ?? rename;
+  const sleep = options.sleep ?? ((milliseconds) => new Promise((resolve3) => setTimeout(resolve3, milliseconds)));
+  const maxAttempts = Math.max(1, options.maxAttempts ?? 40);
+  const retryDelayMs = Math.max(0, options.retryDelayMs ?? 25);
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      await renameFile(temporaryPath, destinationPath);
+      return;
+    } catch (error) {
+      const code = String(error.code ?? "");
+      if (platform !== "win32" || !WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES.has(code) || attempt === maxAttempts - 1) {
+        throw error;
+      }
+      await sleep(retryDelayMs);
+    }
+  }
+}
+async function writeAtomicInferencePrivateFile(path, contents, dependencies = {}) {
+  const platform = dependencies.platform ?? process.platform;
+  const runner = dependencies.runner ?? runWindowsPrivateAcl;
+  const defaultRoot = dependencies.defaultRoot ?? resolve(homedir2(), ".vtx", "inference-host");
+  const directory = dirname2(path);
+  await ensureInferencePrivateDirectory(directory, dependencies);
+  const hardenedDirectoryIdentity = platform === "win32" && isDefaultWindowsPrivatePath(directory, defaultRoot) ? windowsAclCache.get(aclCacheKey(directory, "directory", "harden")) : void 0;
+  if (platform === "win32" && isDefaultWindowsPrivatePath(directory, defaultRoot) && !hardenedDirectoryIdentity) {
+    throw new Error("Windows private directory ACL hardening was not durably verified.");
+  }
+  const temporary = join2(
+    directory,
+    `.${process.pid}.${randomBytes(12).toString("hex")}.tmp`
+  );
+  const handle = await open(
+    temporary,
+    constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
+    384
+  );
+  try {
+    await handle.writeFile(contents, "utf8");
+    await handle.sync();
+  } catch (error) {
+    await handle.close().catch(() => void 0);
+    await rm2(temporary, { force: true }).catch(() => void 0);
+    throw error;
+  }
+  await handle.close();
+  await secureWindowsPrivatePath(temporary, "file", "harden", platform, runner);
+  const hardenedIdentity = platform === "win32" ? windowsAclCache.get(aclCacheKey(temporary, "file", "harden")) : void 0;
+  if (platform === "win32" && !hardenedIdentity) {
+    await rm2(temporary, { force: true }).catch(() => void 0);
+    throw new Error("Windows private ACL hardening was not durably verified.");
+  }
+  try {
+    invalidateWindowsAclCache(path);
+    await replaceAtomicInferencePrivateFile(temporary, path, {
+      platform,
+      renameFile: dependencies.renameFile,
+      sleep: dependencies.sleep,
+      maxAttempts: dependencies.replaceMaxAttempts,
+      retryDelayMs: dependencies.replaceRetryDelayMs
+    });
+    if (platform === "win32" && hardenedIdentity) {
+      await rebindHardenedWindowsAclAfterRename(
+        temporary,
+        path,
+        "file",
+        hardenedIdentity
+      );
+    } else {
+      invalidateWindowsAclCache(temporary);
+    }
+    await syncInferenceDirectory(directory, platform);
+    if (platform === "win32" && hardenedDirectoryIdentity) {
+      await rebindHardenedWindowsDirectoryAfterOwnedMutation(
+        directory,
+        hardenedDirectoryIdentity
+      );
+    }
+  } catch (error) {
+    await rm2(temporary, { force: true }).catch(() => void 0);
+    invalidateWindowsAclCache(temporary);
+    throw error;
+  }
+}
+var PROCESS_LOCK_PUBLICATION_GRACE_MS = 1e4;
+var PROCESS_LOCK_MAX_RECORD_BYTES = 64 * 1024;
+var PROCESS_LOCK_GUARD_ELECTION_LEASE_MS = 5e3;
+var PROCESS_LOCK_GUARD_ELECTION_STALE_MS = 3e4;
+var PROCESS_LOCK_GUARD_ELECTION_ATTEMPTS = 8;
+var PROCESS_LOCK_GUARD_ELECTION_BACKOFF_MS = 10;
+var PROCESS_LOCK_LABEL = "Inference host process lock";
+var PROCESS_LOCK_GUARD_LABEL = "Inference host process lock reclamation guard";
+var sameProcessLockFile = (left, right) => left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+var openExclusiveProcessLockFile = async (path) => {
+  try {
+    return await open(
+      path,
+      constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
+      384
+    );
+  } catch (error) {
+    if (error.code === "EEXIST") return null;
+    throw error;
+  }
+};
+var inspectProcessLockFile = async (path, label, probes) => {
+  let before;
+  try {
+    before = await lstat(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return { state: "missing" };
+    throw error;
+  }
+  if (before.isSymbolicLink() || !before.isFile() || process.platform !== "win32" && (before.mode & 63) !== 0 || typeof process.getuid === "function" && before.uid !== process.getuid()) {
+    throw new Error(`${label} is unsafe.`);
+  }
+  let handle;
+  try {
+    await secureExistingWindowsPath(path, "file");
+    handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  } catch (error) {
+    if (error.code === "ENOENT") return { state: "missing" };
+    throw error;
+  }
+  let stale = false;
+  try {
+    const opened = await handle.stat();
+    if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino) {
+      return { state: "busy" };
+    }
+    const raw = opened.size > PROCESS_LOCK_MAX_RECORD_BYTES ? "" : await handle.readFile("utf8");
+    const stat = await handle.stat();
+    if (!sameProcessLockFile(opened, stat)) return { state: "busy" };
+    let record = null;
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") record = parsed;
+    } catch {
+      record = null;
+    }
+    if (!record || record.schema_version !== 2 || !Number.isSafeInteger(record.pid) || Number(record.pid) < 1 || typeof record.owner_token !== "string" || !record.owner_token || typeof record.process_identity !== "string" || !record.process_identity || typeof record.boot_identity !== "string" || !record.boot_identity) {
+      if (Date.now() - stat.mtimeMs < PROCESS_LOCK_PUBLICATION_GRACE_MS) return { state: "busy" };
+      stale = true;
+      return { state: "stale", handle, stat };
+    }
+    const ownerPid = Number(record.pid);
+    const storedIdentity = record.process_identity;
+    const cacheKey = resolve(path);
+    if (await probes.currentBootIdentity() === record.boot_identity && probes.isProcessAlive(ownerPid)) {
+      const cached = processLockObservationCache.get(cacheKey);
+      const observedIdentity = cached && cached.dev === stat.dev && cached.ino === stat.ino && cached.pid === ownerPid && cached.storedIdentity === storedIdentity && Date.now() - cached.observedAtMs < 5e3 ? cached.observedIdentity : await probes.observeIdentity(ownerPid);
+      if (!observedIdentity) {
+        throw new Error("Inference host could not verify the existing lock owner identity.");
+      }
+      processLockObservationCache.set(cacheKey, {
+        dev: stat.dev,
+        ino: stat.ino,
+        pid: ownerPid,
+        storedIdentity,
+        observedIdentity,
+        observedAtMs: Date.now()
+      });
+      if (inferenceProcessIdentitiesMatch(storedIdentity, observedIdentity)) {
+        return { state: "busy" };
+      }
+    }
+    stale = true;
+    return { state: "stale", handle, stat };
+  } finally {
+    if (!stale) await handle.close().catch(() => void 0);
+  }
+};
+var removeVerifiedStaleProcessLockFile = async (path, inspection, assertExclusive) => {
+  try {
+    await assertExclusive();
+    let current;
+    try {
+      current = await lstat(path);
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    const opened = await inspection.handle.stat();
+    if (current.isSymbolicLink() || !sameProcessLockFile(current, opened) || !sameProcessLockFile(opened, inspection.stat)) {
+      throw new InferenceHostProcessLockBusyError();
+    }
+    if (process.platform === "win32") await inspection.handle.close();
+    try {
+      await rm2(path);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  } finally {
+    await inspection.handle.close().catch(() => void 0);
+  }
+  processLockObservationCache.delete(resolve(path));
+  invalidateWindowsAclCache(path);
+  await syncInferenceDirectory(dirname2(path));
+};
+var removeStaleProcessLockReclaimGuard = async (lockPath, guardPath, inspection) => {
+  const directory = dirname2(lockPath);
+  const prefix = `${basename(lockPath)}.reclaim-ballot.`;
+  try {
+    for (let attempt = 0; attempt < PROCESS_LOCK_GUARD_ELECTION_ATTEMPTS; attempt += 1) {
+      if (attempt > 0) {
+        await new Promise((resolvePromise) => setTimeout(
+          resolvePromise,
+          Math.floor(Math.random() * PROCESS_LOCK_GUARD_ELECTION_BACKOFF_MS * 2 ** Math.min(attempt, 4))
+        ));
+        let current;
+        try {
+          current = await lstat(guardPath);
+        } catch (error) {
+          if (error.code === "ENOENT") return;
+          throw error;
+        }
+        if (!sameProcessLockFile(current, inspection.stat)) return;
+      }
+      const ballotName = `${prefix}${randomBytes(16).toString("hex")}`;
+      const ballotPath = join2(directory, ballotName);
+      const ballot = await openExclusiveProcessLockFile(ballotPath);
+      if (!ballot) continue;
+      await ballot.close();
+      const electedAt = performance.now();
+      try {
+        let contested = false;
+        for (const name of await readdir2(directory)) {
+          if (!name.startsWith(prefix) || name === ballotName) continue;
+          const otherPath = join2(directory, name);
+          let other;
+          try {
+            other = await lstat(otherPath);
+          } catch (error) {
+            if (error.code === "ENOENT") continue;
+            throw error;
+          }
+          if (!other.isDirectory() && Date.now() - other.mtimeMs > PROCESS_LOCK_GUARD_ELECTION_STALE_MS) {
+            await rm2(otherPath, { force: true });
+            continue;
+          }
+          contested = true;
+        }
+        if (contested) continue;
+        await removeVerifiedStaleProcessLockFile(guardPath, inspection, async () => {
+          if (performance.now() - electedAt > PROCESS_LOCK_GUARD_ELECTION_LEASE_MS) {
+            throw new InferenceHostProcessLockBusyError();
+          }
+        });
+        return;
+      } finally {
+        await rm2(ballotPath, { force: true }).catch(() => void 0);
+      }
+    }
+    throw new InferenceHostProcessLockBusyError();
+  } finally {
+    await inspection.handle.close().catch(() => void 0);
+  }
+};
+var acquireProcessLockReclaimGuard = async (lockPath, ownerRecord, probes) => {
+  const guardPath = `${lockPath}.reclaim`;
+  const guardToken = randomBytes(24).toString("base64url");
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const handle = await openExclusiveProcessLockFile(guardPath);
+    if (handle) {
+      try {
+        await handle.writeFile(ownerRecord(guardToken), "utf8");
+      } catch (error) {
+        await handle.close().catch(() => void 0);
+        await rm2(guardPath, { force: true }).catch(() => void 0);
+        throw error;
+      }
+      await handle.close();
+      await secureWindowsPrivatePath(guardPath, "file", "harden");
+      const isHeld = async () => {
+        let reader;
+        try {
+          reader = await open(guardPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+        } catch (error) {
+          if (error.code === "ENOENT") return false;
+          throw error;
+        }
+        try {
+          const [opened, current] = await Promise.all([reader.stat(), lstat(guardPath)]);
+          if (current.isSymbolicLink() || current.dev !== opened.dev || current.ino !== opened.ino) {
+            return false;
+          }
+          const parsed = JSON.parse(await reader.readFile("utf8"));
+          return parsed.owner_token === guardToken;
+        } catch {
+          return false;
+        } finally {
+          await reader.close().catch(() => void 0);
+        }
+      };
+      return {
+        assertHeld: async () => {
+          if (!await isHeld()) throw new InferenceHostProcessLockBusyError();
+        },
+        // Best effort: a guard left behind carries this live process identity
+        // and becomes reclaimable once this process exits.
+        release: async () => {
+          try {
+            if (!await isHeld()) return;
+            await rm2(guardPath);
+            processLockObservationCache.delete(resolve(guardPath));
+            invalidateWindowsAclCache(guardPath);
+          } catch {
+          }
+        }
+      };
+    }
+    if (attempt > 0) break;
+    const inspection = await inspectProcessLockFile(guardPath, PROCESS_LOCK_GUARD_LABEL, probes);
+    if (inspection.state === "busy") break;
+    if (inspection.state === "stale") {
+      await removeStaleProcessLockReclaimGuard(lockPath, guardPath, inspection);
+    }
+  }
+  throw new InferenceHostProcessLockBusyError();
+};
+async function acquireInferenceHostProcessLock(path, dependencies = {}) {
+  const directory = dirname2(path);
+  await ensureInferencePrivateDirectory(directory);
+  const ownerToken = randomBytes(24).toString("base64url");
+  const probes = {
+    currentBootIdentity: dependencies.currentBootIdentity ?? (() => readInferenceSystemBootIdentity()),
+    observeIdentity: dependencies.processIdentity ?? defaultProcessIdentity,
+    isProcessAlive: dependencies.processAlive ?? ((pid) => {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (error) {
+        if (error.code === "ESRCH") return false;
+        throw error;
+      }
+    })
+  };
+  const [ownerIdentity, bootIdentity] = await Promise.all([
+    (dependencies.currentProcessIdentity ?? defaultCurrentProcessIdentity)(),
+    probes.currentBootIdentity()
+  ]);
+  const ownerRecord = (token) => `${JSON.stringify({
+    schema_version: 2,
+    pid: process.pid,
+    owner_token: token,
+    process_identity: ownerIdentity,
+    boot_identity: bootIdentity
+  })}
+`;
+  let handle = await openExclusiveProcessLockFile(path);
+  if (!handle) {
+    const inspection = await inspectProcessLockFile(path, PROCESS_LOCK_LABEL, probes);
+    if (inspection.state === "busy") throw new InferenceHostProcessLockBusyError();
+    if (inspection.state === "stale") {
+      await inspection.handle.close();
+      const guard = await acquireProcessLockReclaimGuard(path, ownerRecord, probes);
+      try {
+        const guarded = await inspectProcessLockFile(path, PROCESS_LOCK_LABEL, probes);
+        if (guarded.state === "busy") throw new InferenceHostProcessLockBusyError();
+        if (guarded.state === "stale") {
+          await removeVerifiedStaleProcessLockFile(path, guarded, guard.assertHeld);
+        }
+        handle = await openExclusiveProcessLockFile(path);
+      } finally {
+        await guard.release();
+      }
+    } else {
+      handle = await openExclusiveProcessLockFile(path);
+    }
+    if (!handle) throw new InferenceHostProcessLockBusyError();
+  }
+  try {
+    await handle.writeFile(ownerRecord(ownerToken), "utf8");
+    await handle.sync();
+  } catch (error) {
+    const created = await handle.stat().catch(() => null);
+    await handle.close().catch(() => void 0);
+    const current = await lstat(path).catch(() => null);
+    if (created && current && current.dev === created.dev && current.ino === created.ino) {
+      await rm2(path, { force: true }).catch(() => void 0);
+    }
+    throw error;
+  }
+  await handle.close();
+  await secureWindowsPrivatePath(path, "file", "harden");
+  await syncInferenceDirectory(directory);
+  let released = false;
+  return {
+    path,
+    ownerToken,
+    release: async () => {
+      if (released) return;
+      const metadata = await lstat(path);
+      if (metadata.isSymbolicLink() || !metadata.isFile()) {
+        throw new Error("Inference host process lock is unsafe.");
+      }
+      const parsed = JSON.parse(await readFile2(path, "utf8"));
+      if (parsed.owner_token !== ownerToken) {
+        throw new Error("Inference host process lock ownership changed.");
+      }
+      await rm2(path);
+      processLockObservationCache.delete(resolve(path));
+      await syncInferenceDirectory(directory);
+      released = true;
+    }
+  };
+}
+
+// lib/inference-host/routing.ts
+init_define_VTX_EXO_POLICY();
+init_define_VTX_GROK_POLICY();
+init_define_VTX_PI_MODEL_POLICY();
+var INFERENCE_HOST_VALUE_OPTIONS = /* @__PURE__ */ new Set([
+  "--display-name",
+  "--max-concurrency",
+  "--adapter",
+  "--model",
+  "--model-label",
+  "--effort",
+  "--wait-seconds",
+  "--lines",
+  "--service-manifest",
+  "--instance"
+]);
+var isInferenceHostCliInvocation = (argv) => {
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (INFERENCE_HOST_VALUE_OPTIONS.has(argument)) {
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("--")) {
+      continue;
+    }
+    return argument === "inference-host";
+  }
+  return false;
+};
+
+// lib/cli-release/updater.ts
+var CLI_PACKAGE_NAME = "@vtxmacro/cli";
+var OFFICIAL_NPM_REGISTRY = "https://registry.npmjs.org";
+var CLI_UPDATE_COMMAND = `npm install -g ${CLI_PACKAGE_NAME}@latest`;
+var parseCliReleaseVersion = (value) => {
+  const match = /^(\d{4})\.(\d{1,2})\.(\d{1,3})$/u.exec(value);
+  if (!match) return null;
+  const values = match.slice(1).map(Number);
+  if (values.some((entry) => !Number.isSafeInteger(entry) || entry < 0)) return null;
+  return values;
+};
+var compareCliReleaseVersions = (left, right) => {
+  const leftParts = parseCliReleaseVersion(left);
+  const rightParts = parseCliReleaseVersion(right);
+  if (!leftParts || !rightParts) {
+    throw new Error("CLI release version is invalid.");
+  }
+  for (let index = 0; index < leftParts.length; index += 1) {
+    const difference = leftParts[index] - rightParts[index];
+    if (difference !== 0) return difference;
+  }
+  return 0;
+};
+var isPathWithin = (parent, child) => {
+  const childRelative = relative2(resolve2(parent), resolve2(child));
+  return childRelative !== "" && !childRelative.startsWith("..") && !isAbsolute2(childRelative);
+};
+var defaultRunCliCommand = async (command, args, options = {}) => await new Promise((resolvePromise) => {
+  const child = spawn2(command, [...args], {
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "pipe"],
+    ...options.signal ? { signal: options.signal, killSignal: "SIGKILL" } : {}
+  });
+  const stdout = [];
+  const stderr = [];
+  let settled = false;
+  const settle = (result) => {
+    if (settled) return;
+    settled = true;
+    resolvePromise(result);
+  };
+  child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
+  child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
+  child.once("error", (error) => settle({ exitCode: 1, stdout: "", stderr: error.message }));
+  child.once("exit", (code) => settle({
+    exitCode: code ?? 1,
+    stdout: Buffer.concat(stdout).toString("utf8"),
+    stderr: Buffer.concat(stderr).toString("utf8")
+  }));
+});
+var runCliReleaseNpmCommand = async (executable, args, platform = process.platform, runCommand = defaultRunCliCommand) => {
+  if (platform !== "win32") return await runCommand(join3(dirname3(executable), "npm"), args);
+  const npmScript = windowsPath2.join(
+    windowsPath2.dirname(executable),
+    "node_modules",
+    "npm",
+    "bin",
+    "npm-cli.js"
+  );
+  return await runCommand(executable, [npmScript, ...args]);
+};
+var fetchLatestCliRelease = async (fetchImpl, options) => {
+  const registry = (options.registry ?? OFFICIAL_NPM_REGISTRY).replace(/\/+$/u, "");
+  const response = await fetchImpl(`${registry}/%40vtxmacro%2Fcli/latest`, {
+    signal: AbortSignal.any([
+      AbortSignal.timeout(options.timeoutMs),
+      ...options.signal ? [options.signal] : []
+    ])
+  });
+  if (!response.ok) throw new Error("registry_request_failed");
+  const value = await response.json();
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("registry_metadata_invalid");
+  }
+  const record = value;
+  const distribution = record.dist;
+  if (record.name !== CLI_PACKAGE_NAME || typeof record.version !== "string" || !parseCliReleaseVersion(record.version) || !distribution || typeof distribution !== "object" || Array.isArray(distribution) || typeof distribution.integrity !== "string") throw new Error("registry_metadata_invalid");
+  return {
+    version: record.version,
+    integrity: distribution.integrity
+  };
+};
+var verifyCliReleaseIntegrity = async (tarballPath, integrity) => {
+  const candidates = integrity.split(/\s+/u).map((entry) => {
+    const separator = entry.indexOf("-");
+    return separator > 0 ? { algorithm: entry.slice(0, separator), digest: entry.slice(separator + 1) } : null;
+  }).filter((entry) => entry !== null);
+  const supported = ["sha512", "sha384", "sha256"].map((algorithm) => candidates.find((candidate) => candidate.algorithm === algorithm)).find(Boolean);
+  if (!supported) throw new Error("release_integrity_unsupported");
+  const actual = createHash(supported.algorithm).update(await readFile3(tarballPath)).digest("base64");
+  if (actual !== supported.digest) throw new Error("release_integrity_mismatch");
+};
+var verifyInstalledCliRelease = async (prefix, targetVersion, executable, platform, runCommand) => {
+  const packagePath = platform === "win32" ? windowsPath2.join(prefix, "node_modules", "@vtxmacro", "cli") : join3(prefix, "lib", "node_modules", "@vtxmacro", "cli");
+  if (!isPathWithin(prefix, packagePath)) throw new Error("release_install_invalid");
+  const packageJson = JSON.parse(await readFile3(join3(packagePath, "package.json"), "utf8"));
+  if (!packageJson || typeof packageJson !== "object" || Array.isArray(packageJson)) {
+    throw new Error("release_install_invalid");
+  }
+  const packageRecord = packageJson;
+  const bin = packageRecord.bin;
+  const binPath = bin && typeof bin === "object" && !Array.isArray(bin) ? bin.vtx : null;
+  if (packageRecord.name !== CLI_PACKAGE_NAME || packageRecord.version !== targetVersion || typeof binPath !== "string") throw new Error("release_install_invalid");
+  const script = resolve2(packagePath, binPath);
+  if (!isPathWithin(packagePath, script)) throw new Error("release_install_invalid");
+  await access(script);
+  const verified = await runCommand(executable, [script, "--version"]);
+  if (verified.exitCode !== 0 || verified.stdout.trim() !== targetVersion) {
+    throw new Error("release_version_verification_failed");
+  }
+  return script;
+};
+var cleanupInterruptedReleaseStaging = async (releasesPath) => {
+  const entries = await readdir3(releasesPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory() && /^\.(?:staging|download)-\d{4}\.\d{1,2}\.\d{1,3}-[0-9a-f-]{36}$/u.test(entry.name)) {
+      await rm3(resolve2(releasesPath, entry.name), { recursive: true, force: true });
+    }
+  }
+};
+var ensureUpdaterPrivateDirectory = async (path, root, dependencies = {}) => {
+  const platform = dependencies.platform ?? process.platform;
+  if (platform !== "win32" && (resolve2(path) === resolve2(root) || isPathWithin(root, path))) {
+    const existing = await lstat2(path).catch(() => null);
+    if (existing && existing.isDirectory() && !existing.isSymbolicLink() && (existing.mode & 63) !== 0 && (typeof process.getuid !== "function" || existing.uid === process.getuid())) {
+      await chmod(path, 448);
+    }
+  }
+  await ensureInferencePrivateDirectory(path, { ...dependencies, defaultRoot: root });
+};
+var stageCliRelease = async (input) => {
+  const { releasesPath, target, executable, platform } = input;
+  const registry = input.registry ?? OFFICIAL_NPM_REGISTRY;
+  const deadline = new AbortController();
+  let reason = "release_stage_timeout";
+  const timer = setTimeout(() => deadline.abort(), input.timeoutMs);
+  const onCancel = () => {
+    reason = "release_stage_cancelled";
+    deadline.abort();
+  };
+  if (input.signal?.aborted) onCancel();
+  input.signal?.addEventListener("abort", onCancel, { once: true });
+  const timedOut = () => new Error(reason);
+  const runCommand = async (command, args) => {
+    if (deadline.signal.aborted) throw timedOut();
+    return await new Promise((resolveCommand, rejectCommand) => {
+      const onAbort = () => rejectCommand(timedOut());
+      deadline.signal.addEventListener("abort", onAbort, { once: true });
+      input.runCommand(command, args, { signal: deadline.signal }).then(resolveCommand, rejectCommand).finally(() => deadline.signal.removeEventListener("abort", onAbort));
+    });
+  };
+  try {
+    return await stageCliReleaseWithin({ ...input, registry, runCommand });
+  } finally {
+    clearTimeout(timer);
+    input.signal?.removeEventListener("abort", onCancel);
+  }
+};
+var stageCliReleaseWithin = async (input) => {
+  const { releasesPath, target, executable, platform, runCommand, registry } = input;
+  const finalPath = join3(releasesPath, target.version);
+  const stagingPath = join3(releasesPath, `.staging-${target.version}-${randomUUID()}`);
+  const downloadPath = join3(releasesPath, `.download-${target.version}-${randomUUID()}`);
+  await ensureUpdaterPrivateDirectory(input.privateRoot, input.privateRoot, { platform });
+  await ensureUpdaterPrivateDirectory(releasesPath, input.privateRoot, { platform });
+  await cleanupInterruptedReleaseStaging(releasesPath);
+  try {
+    await access(finalPath);
+    const existingScript = await verifyInstalledCliRelease(
+      finalPath,
+      target.version,
+      executable,
+      platform,
+      runCommand
+    );
+    return { package_version: target.version, integrity: target.integrity, script: existingScript };
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  await mkdir3(stagingPath, { recursive: true, mode: 448 });
+  await mkdir3(downloadPath, { recursive: true, mode: 448 });
+  try {
+    const packed = await runCliReleaseNpmCommand(executable, [
+      "pack",
+      `${CLI_PACKAGE_NAME}@${target.version}`,
+      "--pack-destination",
+      downloadPath,
+      "--registry",
+      registry,
+      "--json"
+    ], platform, runCommand);
+    if (packed.exitCode !== 0) throw new Error("release_download_failed");
+    let filename;
+    try {
+      const parsed = JSON.parse(packed.stdout);
+      filename = String(parsed[0]?.filename ?? "");
+    } catch {
+      throw new Error("release_download_invalid");
+    }
+    const tarballPath = resolve2(downloadPath, filename);
+    if (!filename || !isPathWithin(downloadPath, tarballPath)) {
+      throw new Error("release_download_invalid");
+    }
+    await verifyCliReleaseIntegrity(tarballPath, target.integrity);
+    const installed = await runCliReleaseNpmCommand(executable, [
+      "install",
+      "--global",
+      "--prefix",
+      stagingPath,
+      tarballPath,
+      "--no-audit",
+      "--no-fund",
+      "--registry",
+      registry
+    ], platform, runCommand);
+    if (installed.exitCode !== 0) throw new Error("release_install_failed");
+    const stagedScript = await verifyInstalledCliRelease(
+      stagingPath,
+      target.version,
+      executable,
+      platform,
+      runCommand
+    );
+    try {
+      await rename2(stagingPath, finalPath);
+    } catch (error) {
+      if (!["EEXIST", "ENOTEMPTY"].includes(String(error.code))) throw error;
+      throw new Error("release_path_already_exists");
+    }
+    return {
+      package_version: target.version,
+      integrity: target.integrity,
+      script: resolve2(finalPath, relative2(stagingPath, stagedScript))
+    };
+  } finally {
+    await rm3(stagingPath, { recursive: true, force: true }).catch(() => void 0);
+    await rm3(downloadPath, { recursive: true, force: true }).catch(() => void 0);
+  }
+};
+var readCliReleaseRejection = async (path) => {
+  try {
+    const value = JSON.parse(await readFile3(path, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    const record = value;
+    if (record.schema_version !== "vtx_inference_service_release_rejection_v1" || typeof record.package_version !== "string" || !parseCliReleaseVersion(record.package_version) || typeof record.rejected_at !== "string" || !Number.isFinite(Date.parse(record.rejected_at)) || typeof record.reason !== "string" || !/^[a-z0-9_]{1,96}$/u.test(record.reason)) return null;
+    return record;
+  } catch {
+    return null;
+  }
+};
+var writeCliReleaseRejection = async (path, rejection, privateRoot) => {
+  if (privateRoot) await ensureUpdaterPrivateDirectory(privateRoot, privateRoot);
+  await writeAtomicInferencePrivateFile(
+    path,
+    `${JSON.stringify(rejection, null, 2)}
+`,
+    privateRoot ? { defaultRoot: privateRoot } : {}
+  );
+};
+var CLI_BACKGROUND_STAGE_ARGUMENT = "--vtx-internal-stage-cli-update";
+var READY_MESSAGE_TYPE = "vtx-cli-ready-v1";
+var CHILD_ENV = "VTX_CLI_SELF_UPDATE_CHILD";
+var READY_PROTOCOL_ENV = "VTX_CLI_READY_PROTOCOL";
+var EMPTY_STATE = {
+  schema_version: "vtx_cli_update_state_v1",
+  checked_at: null,
+  latest: null,
+  minimum_supported_version: null,
+  minimum_api_url: null,
+  active: null,
+  previous: null
+};
+var resolveCliUpdatePaths = (env) => {
+  const home = String(env.VTX_HOME || "").trim() || join3(homedir3(), ".vtx");
+  const root = join3(home, "cli-update");
+  return {
+    root,
+    statePath: join3(root, "state.json"),
+    releasesPath: join3(root, "releases"),
+    lockPath: join3(root, "update.lock"),
+    logPath: join3(root, "update.log"),
+    rejectionPath: join3(root, "release-rejection.json")
+  };
+};
+var cliAutoUpdateDisabled = (env) => /^(?:0|false|off|no)$/iu.test(String(env.VTX_CLI_AUTO_UPDATE ?? "").trim());
+var resolveRegistry = (env) => {
+  const configured = String(env.VTX_CLI_UPDATE_REGISTRY || "").trim().replace(/\/+$/u, "");
+  if (!configured) return OFFICIAL_NPM_REGISTRY;
+  let url;
+  try {
+    url = new URL(configured);
+  } catch {
+    throw new Error("VTX_CLI_UPDATE_REGISTRY is not a URL.");
+  }
+  const loopback = ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
+    throw new Error("VTX_CLI_UPDATE_REGISTRY must be https, or http on loopback.");
+  }
+  return configured;
+};
+var validSelection = async (value, releasesPath) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  if (typeof record.package_version !== "string" || !parseCliReleaseVersion(record.package_version) || typeof record.integrity !== "string" || typeof record.script !== "string" || !isPathWithin(join3(releasesPath, record.package_version), record.script) || typeof record.selected_at !== "string" || record.confirmed_at !== null && typeof record.confirmed_at !== "string") return null;
+  try {
+    await access(record.script);
+  } catch {
+    return null;
+  }
+  return record;
+};
+var readState = async (paths) => {
+  let value;
+  try {
+    value = JSON.parse(await readFile3(paths.statePath, "utf8"));
+  } catch {
+    return EMPTY_STATE;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return EMPTY_STATE;
+  const record = value;
+  if (record.schema_version !== "vtx_cli_update_state_v1") return EMPTY_STATE;
+  const latest = record.latest && typeof record.latest === "object" && typeof record.latest.version === "string" && parseCliReleaseVersion(String(record.latest.version)) && typeof record.latest.integrity === "string" ? record.latest : null;
+  const minimum = typeof record.minimum_supported_version === "string" && parseCliReleaseVersion(record.minimum_supported_version) ? record.minimum_supported_version : null;
+  return {
+    schema_version: "vtx_cli_update_state_v1",
+    checked_at: typeof record.checked_at === "string" && Number.isFinite(Date.parse(record.checked_at)) ? record.checked_at : null,
+    latest,
+    minimum_supported_version: minimum,
+    minimum_api_url: typeof record.minimum_api_url === "string" ? record.minimum_api_url : null,
+    active: await validSelection(record.active, paths.releasesPath),
+    previous: await validSelection(record.previous, paths.releasesPath)
+  };
+};
+var writeState = async (paths, state) => {
+  await ensureUpdaterPrivateDirectory(paths.root, paths.root);
+  await writeAtomicInferencePrivateFile(
+    paths.statePath,
+    `${JSON.stringify(state, null, 2)}
+`,
+    { defaultRoot: paths.root }
+  );
+};
+var appendCliUpdateLog = async (paths, event, fields = {}) => {
+  try {
+    await ensureUpdaterPrivateDirectory(paths.root, paths.root);
+    await appendFile(
+      paths.logPath,
+      `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), event, ...fields })}
+`,
+      { encoding: "utf8", mode: 384 }
+    );
+  } catch {
+  }
+};
+var isSkippedInvocation = (argv, env) => (
+  // A re-run on a selected release, or a process the service updater owns.
+  env[CHILD_ENV] === "1" || env.VTX_INFERENCE_HOST_SERVICE_CHILD === "1" || env.VTX_INFERENCE_HOST_LAUNCHER_PROTOCOL === "1" || isInferenceHostCliInvocation(argv) && argv.includes("run-internal")
+);
+var isVersionQuery = (argv) => argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v");
+var policyApiUrl = (entry, argv, env) => entry === "vtx" && isInferenceHostCliInvocation(argv) ? resolveInferenceHostApiUrl(env) : resolveAgentCliConfig(env).apiUrl;
+var fetchMinimumSupportedVersion = async (fetchImpl, apiUrl, timeoutMs, signal) => {
+  const response = await fetchImpl(`${apiUrl}/status/agent-cli`, {
+    headers: { Accept: "application/json" },
+    signal: AbortSignal.any([AbortSignal.timeout(timeoutMs), ...signal ? [signal] : []])
+  });
+  if (!response.ok) throw new Error("policy_request_failed");
+  const value = await response.json();
+  const minimum = value?.minimum_supported_version;
+  if (value?.package_name !== CLI_PACKAGE_NAME || typeof minimum !== "string" || !parseCliReleaseVersion(minimum)) {
+    throw new Error("policy_invalid");
+  }
+  return minimum;
+};
+var classifyCliInstall = async (script, platform = process.platform, env = process.env) => {
+  try {
+    const real = await realpath2(script);
+    const releasesPath = resolveCliUpdatePaths(env).releasesPath;
+    if (isPathWithin(releasesPath, real) || isPathWithin(await realpath2(releasesPath).catch(() => releasesPath), real) || /\.service-releases[\\/]/u.test(real)) return "managed";
+    const pathApi = platform === "win32" ? windowsPath2 : { dirname: dirname3, join: join3, resolve: resolve2 };
+    const packageRoot = pathApi.dirname(pathApi.dirname(real));
+    const modulesRoot = pathApi.dirname(pathApi.dirname(packageRoot));
+    if (!packageRoot.endsWith(pathApi.join("node_modules", "@vtxmacro", "cli")) || /[\\/]_npx[\\/]/u.test(real)) return "managed";
+    if (platform === "win32") {
+      await access(windowsPath2.join(windowsPath2.dirname(modulesRoot), "vtx.cmd"));
+      return "global";
+    }
+    if (!modulesRoot.endsWith(join3("lib", "node_modules"))) return "managed";
+    const binLink = join3(dirname3(dirname3(modulesRoot)), "bin", "vtx");
+    return await realpath2(binLink) === await realpath2(join3(packageRoot, "bin", "vtx.js")) ? "global" : "managed";
+  } catch {
+    return "managed";
+  }
+};
+var refusal = (current, minimum, reason) => `VTX CLI ${current} is below the minimum supported version ${minimum} and ${reason}. Update it with: ${CLI_UPDATE_COMMAND}`;
+var inferenceHostServiceManifestPaths = async (env) => {
+  const rootManifest = inferenceHostSupervisorServiceManifestPath(env);
+  const instancesPath = join3(dirname3(rootManifest), "instances");
+  const instances = await readdir3(instancesPath, { withFileTypes: true }).catch(() => []);
+  return [
+    rootManifest,
+    ...instances.filter((entry) => entry.isDirectory()).map((entry) => join3(instancesPath, entry.name, "state.json.service.json"))
+  ];
+};
+var prune = async (paths, keep, env) => {
+  const retained = new Set(keep.filter((item) => item !== null).map((item) => item.package_version));
+  for (const manifestPath of await inferenceHostServiceManifestPaths(env)) {
+    try {
+      const manifest = JSON.parse(await readFile3(manifestPath, "utf8"));
+      if (typeof manifest.script === "string" && isPathWithin(paths.releasesPath, manifest.script)) {
+        retained.add(relative2(paths.releasesPath, manifest.script).split(/[\\/]/u)[0]);
+      }
+    } catch {
+    }
+  }
+  let entries;
+  try {
+    entries = await readdir3(paths.releasesPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory() && parseCliReleaseVersion(entry.name) && !retained.has(entry.name)) {
+      await rm3(join3(paths.releasesPath, entry.name), { recursive: true, force: true }).catch(() => void 0);
+    }
+  }
+};
+var stageAndSelect = async (paths, target, input) => {
+  let lock;
+  try {
+    await ensureUpdaterPrivateDirectory(paths.root, paths.root, { platform: input.platform });
+  } catch (error) {
+    const reason = `update_directory_unsafe: ${error instanceof Error ? error.message.slice(0, 120) : "unknown"}`;
+    await appendCliUpdateLog(paths, "cli_update_failed", { package_version: target.version, reason });
+    return { kind: "failed", reason };
+  }
+  try {
+    lock = await acquireInferenceHostProcessLock(paths.lockPath);
+  } catch {
+    return { kind: "busy" };
+  }
+  try {
+    const staged = await stageCliRelease({
+      releasesPath: paths.releasesPath,
+      target,
+      executable: input.executable,
+      platform: input.platform,
+      runCommand: input.runCommand,
+      registry: resolveRegistry(input.env),
+      privateRoot: paths.root,
+      timeoutMs: runtime_policy_generated_default.agent_cli.stage_timeout_ms,
+      signal: input.signal
+    });
+    const state = await readState(paths);
+    const selection = {
+      ...staged,
+      selected_at: input.now().toISOString(),
+      confirmed_at: null
+    };
+    const previous = state.active && state.active.package_version !== selection.package_version ? state.active : state.previous;
+    await writeState(paths, { ...state, active: selection, previous });
+    await prune(paths, [selection, previous], input.env);
+    await appendCliUpdateLog(paths, "cli_release_staged", { package_version: selection.package_version });
+    return { kind: "staged", selection };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message.slice(0, 160) : "unknown";
+    await appendCliUpdateLog(paths, "cli_update_failed", { package_version: target.version, reason });
+    return { kind: "failed", reason };
+  } finally {
+    await lock.release().catch(() => void 0);
+  }
+};
+var planCliEntryUpdate = async (entry, argv, env, script, dependencies = {}) => {
+  if (isSkippedInvocation(argv, env) || !script) return { kind: "run" };
+  const paths = resolveCliUpdatePaths(env);
+  const current = dependencies.currentVersion ?? agent_cli_release_default.package_version;
+  const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+  const executable = dependencies.executable ?? process.execPath;
+  const platform = dependencies.platform ?? process.platform;
+  const runCommand = dependencies.runCommand ?? defaultRunCliCommand;
+  const fetchImpl = dependencies.fetch ?? fetch;
+  const policy = runtime_policy_generated_default.agent_cli;
+  const disabled = cliAutoUpdateDisabled(env);
+  const launcher = resolve2(script);
+  try {
+    let state = await readState(paths);
+    const rejection = await readCliReleaseRejection(paths.rejectionPath);
+    let knownKind = null;
+    const installKind = async () => knownKind ??= await classifyCliInstall(launcher, platform, env);
+    const apiUrl = policyApiUrl(entry, argv, env);
+    const selected = !disabled && state.active && compareCliReleaseVersions(state.active.package_version, current) > 0 && rejection?.package_version !== state.active.package_version && await installKind() === "global" ? state.active : null;
+    const effective = selected?.package_version ?? current;
+    if (isVersionQuery(argv)) return selected ? { kind: "reexec", selection: selected } : { kind: "run" };
+    const cachedMinimum = state.minimum_api_url === apiUrl ? state.minimum_supported_version : null;
+    const checkedAt = state.checked_at ? Date.parse(state.checked_at) : Number.NaN;
+    const due = !Number.isFinite(checkedAt) || now().getTime() - checkedAt >= policy.update_check_interval_ms || now().getTime() < checkedAt || cachedMinimum !== null && compareCliReleaseVersions(effective, cachedMinimum) < 0;
+    let refreshed = false;
+    if (due) {
+      refreshed = true;
+      const [minimumResult, latestResult] = await Promise.allSettled([
+        fetchMinimumSupportedVersion(fetchImpl, apiUrl, policy.update_check_timeout_ms, dependencies.signal),
+        disabled ? Promise.reject(new Error("disabled")) : fetchLatestCliRelease(fetchImpl, {
+          registry: resolveRegistry(env),
+          timeoutMs: policy.update_check_timeout_ms,
+          signal: dependencies.signal
+        })
+      ]);
+      state = {
+        ...state,
+        checked_at: now().toISOString(),
+        latest: latestResult.status === "fulfilled" ? latestResult.value : state.latest,
+        minimum_supported_version: minimumResult.status === "fulfilled" ? minimumResult.value : state.minimum_supported_version,
+        minimum_api_url: minimumResult.status === "fulfilled" ? apiUrl : state.minimum_api_url
+      };
+      await writeState(paths, state).catch(() => void 0);
+    }
+    const minimum = state.minimum_api_url === apiUrl ? state.minimum_supported_version : null;
+    const belowMinimum = minimum !== null && compareCliReleaseVersions(effective, minimum) < 0;
+    const runSelected = (warning) => selected ? { kind: "reexec", selection: selected } : { kind: "run", ...warning ? { warning } : {} };
+    if (disabled) {
+      return belowMinimum ? { kind: "refuse", message: refusal(current, minimum, "automatic updates are off (VTX_CLI_AUTO_UPDATE)") } : { kind: "run" };
+    }
+    const latest = state.latest;
+    const updateAvailable = latest !== null && compareCliReleaseVersions(latest.version, effective) > 0 && rejection?.package_version !== latest.version;
+    if ((refreshed || belowMinimum) && updateAvailable) {
+      if (await installKind() !== "global") {
+        return belowMinimum ? { kind: "refuse", message: refusal(effective, minimum, "this install is managed outside the VTX CLI updater") } : { kind: "run" };
+      }
+      if (belowMinimum && compareCliReleaseVersions(latest.version, minimum) < 0) {
+        return { kind: "refuse", message: refusal(effective, minimum, `npm latest (${latest.version}) does not meet it`) };
+      }
+      const stageInput = { env, executable, platform, runCommand, now, signal: dependencies.signal };
+      if (entry === "vtx-mcp" && !belowMinimum) {
+        (dependencies.spawnBackgroundStage ?? spawnBackgroundStage)(executable, launcher, env);
+        return runSelected();
+      }
+      (dependencies.stderr ?? process.stderr).write(
+        `Updating VTX CLI ${effective} to ${latest.version}...
+`
+      );
+      const outcome = await stageAndSelect(paths, latest, stageInput);
+      if (outcome.kind === "staged") return { kind: "reexec", selection: outcome.selection };
+      const reason = outcome.kind === "busy" ? "another update is in progress" : `the update failed (${outcome.reason})`;
+      if (belowMinimum) return { kind: "refuse", message: refusal(effective, minimum, reason) };
+      return runSelected(`VTX CLI update to ${latest.version} did not complete: ${reason}; continuing on ${effective}.`);
+    }
+    if (belowMinimum) {
+      const reason = latest === null ? "the npm registry could not be reached" : rejection?.package_version === latest.version ? `release ${latest.version} failed to start here` : "no newer release is available";
+      return { kind: "refuse", message: refusal(effective, minimum, reason) };
+    }
+    return runSelected();
+  } catch (error) {
+    await appendCliUpdateLog(paths, "cli_update_check_failed", {
+      reason: error instanceof Error ? error.message.slice(0, 160) : "unknown"
+    });
+    return { kind: "run" };
+  }
+};
+var spawnBackgroundStage = (executable, script, env) => {
+  try {
+    const child = spawn2(executable, [script, CLI_BACKGROUND_STAGE_ARGUMENT], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env
+    });
+    child.on("error", () => void 0);
+    child.unref();
+  } catch {
+  }
+};
+var runCliBackgroundStage = async (env = process.env, dependencies = {}) => {
+  const paths = resolveCliUpdatePaths(env);
+  const state = await readState(paths);
+  const current = dependencies.currentVersion ?? agent_cli_release_default.package_version;
+  const rejection = await readCliReleaseRejection(paths.rejectionPath);
+  if (cliAutoUpdateDisabled(env) || !state.latest || compareCliReleaseVersions(state.latest.version, current) <= 0 || rejection?.package_version === state.latest.version || state.active && compareCliReleaseVersions(state.active.package_version, state.latest.version) >= 0) return 0;
+  const outcome = await stageAndSelect(paths, state.latest, {
+    env,
+    executable: dependencies.executable ?? process.execPath,
+    platform: dependencies.platform ?? process.platform,
+    runCommand: dependencies.runCommand ?? defaultRunCliCommand,
+    now: dependencies.now ?? (() => /* @__PURE__ */ new Date())
+  });
+  return outcome.kind === "failed" ? 1 : 0;
+};
+var installStopTracker = () => {
+  const stopped = new AbortController();
+  const tracker = {
+    stops: 0,
+    child: null,
+    stopped: stopped.signal,
+    uninstall: () => void 0
+  };
+  const onInterrupt = () => {
+    tracker.stops += 1;
+    stopped.abort();
+    if (process.platform === "win32") return;
+    try {
+      tracker.child?.kill("SIGTERM");
+    } catch {
+    }
+  };
+  const forward = (signal) => () => {
+    tracker.stops += 1;
+    stopped.abort();
+    try {
+      tracker.child?.kill(signal);
+    } catch {
+    }
+  };
+  const forwarded = ["SIGTERM", "SIGHUP"].map((signal) => [signal, forward(signal)]);
+  process.on("SIGINT", onInterrupt);
+  for (const [signal, handler] of forwarded) process.on(signal, handler);
+  tracker.uninstall = () => {
+    process.removeListener("SIGINT", onInterrupt);
+    for (const [signal, handler] of forwarded) process.removeListener(signal, handler);
+  };
+  return tracker;
+};
+var runReleaseProcess = async (executable, script, argv, env, readyTimeoutMs, onReady, supervisorStops) => await new Promise((resolvePromise) => {
+  const child = spawn2(executable, [script, ...argv], {
+    stdio: ["inherit", "inherit", "inherit", "ipc"],
+    env: { ...env, [CHILD_ENV]: "1", [READY_PROTOCOL_ENV]: "1" }
+  });
+  let ready = false;
+  let timedOut = false;
+  const stops = supervisorStops ?? installStopTracker();
+  const stopsBefore = supervisorStops ? supervisorStops.stops : 0;
+  stops.child = child;
+  const timer = setTimeout(() => {
+    if (ready) return;
+    timedOut = true;
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }, readyTimeoutMs);
+  child.on("message", (message) => {
+    if (message && typeof message === "object" && message.type === READY_MESSAGE_TYPE) {
+      if (ready) return;
+      ready = true;
+      clearTimeout(timer);
+      onReady();
+    }
+  });
+  const finish = (result) => {
+    clearTimeout(timer);
+    stops.child = null;
+    if (!supervisorStops) stops.uninstall();
+    resolvePromise(result);
+  };
+  child.once("error", () => finish({ kind: "not_ready", reason: "startup_exited_before_ready", exitCode: 1 }));
+  child.once("exit", (code, signal) => {
+    if (ready) {
+      finish({ kind: "exited", exitCode: code ?? 1, signal });
+      return;
+    }
+    if (stops.stops > stopsBefore || signal !== null && !timedOut) {
+      finish({ kind: "interrupted", exitCode: code ?? 1, signal });
+      return;
+    }
+    finish({
+      kind: "not_ready",
+      reason: timedOut ? "startup_ready_timeout" : "startup_exited_before_ready",
+      exitCode: code ?? 1
+    });
+  });
+});
+var reportCliEntryReady = async () => {
+  if (process.env[READY_PROTOCOL_ENV] !== "1" || typeof process.send !== "function") return;
+  delete process.env[READY_PROTOCOL_ENV];
+  await new Promise((resolvePromise) => {
+    try {
+      process.send({ type: READY_MESSAGE_TYPE, package_version: agent_cli_release_default.package_version }, void 0, {}, () => {
+        resolvePromise();
+      });
+    } catch {
+      resolvePromise();
+    }
+  });
+  try {
+    process.disconnect?.();
+  } catch {
+  }
+};
+var markConfirmed = async (paths, selection, now) => {
+  try {
+    const state = await readState(paths);
+    if (state.active?.package_version !== selection.package_version || state.active.confirmed_at) return;
+    await writeState(paths, { ...state, active: { ...state.active, confirmed_at: now().toISOString() } });
+    await appendCliUpdateLog(paths, "cli_release_confirmed", { package_version: selection.package_version });
+  } catch {
+  }
+};
+var ROLLBACK_SKIPPED = /* @__PURE__ */ Symbol("rollback-skipped");
+var rollBack = async (paths, selection, reason, now, env) => {
+  await ensureUpdaterPrivateDirectory(paths.root, paths.root).catch(() => void 0);
+  const lock = await acquireInferenceHostProcessLock(paths.lockPath).catch(() => null);
+  try {
+    const current = await readState(paths);
+    if (current.active?.package_version === selection.package_version && current.active.confirmed_at) {
+      await appendCliUpdateLog(paths, "cli_release_rollback_skipped", {
+        package_version: selection.package_version,
+        reason
+      });
+      return ROLLBACK_SKIPPED;
+    }
+    await writeCliReleaseRejection(paths.rejectionPath, {
+      schema_version: "vtx_inference_service_release_rejection_v1",
+      package_version: selection.package_version,
+      rejected_at: now().toISOString(),
+      reason
+    }, paths.root).catch(() => void 0);
+    const state = await readState(paths);
+    const fallback = state.active?.package_version === selection.package_version ? state.previous : state.active;
+    await writeState(paths, { ...state, active: fallback, previous: null }).catch(() => void 0);
+    if (lock) await prune(paths, [fallback], env);
+    return await finishRollBack(paths, selection, reason, fallback);
+  } finally {
+    await lock?.release().catch(() => void 0);
+  }
+};
+var finishRollBack = async (paths, selection, reason, fallback) => {
+  await appendCliUpdateLog(paths, "cli_release_rolled_back", {
+    package_version: selection.package_version,
+    restored_version: fallback?.package_version ?? null,
+    reason
+  });
+  return fallback?.package_version ?? null;
+};
+var INTERRUPTED_EXIT_CODE = 130;
+var superviseRuntime = async (argv, dependencies, env, launcher) => {
+  const stderr = dependencies.stderr ?? process.stderr;
+  const paths = resolveCliUpdatePaths(env);
+  const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+  const current = dependencies.currentVersion ?? agent_cli_release_default.package_version;
+  const supervisorEnv = {
+    ...env,
+    [RUNTIME_RESUME_FILE_ENV]: join3(paths.root, "runtime-resume", `${process.pid}-${randomUUID()}.json`)
+  };
+  const stops = installStopTracker();
+  const endAfterStop = async (exitCode) => {
+    if (!await readRuntimeResume(supervisorEnv) || !dependencies.stopRuntimeBetweenChildren) return exitCode;
+    const stopExitCode = await dependencies.stopRuntimeBetweenChildren(supervisorEnv);
+    return stopExitCode === 0 ? exitCode : stopExitCode;
+  };
+  let resuming = false;
+  let resumeRecord = null;
+  let failedStarts = 0;
+  try {
+    for (; ; ) {
+      if (stops.stops > 0) return resuming ? await endAfterStop(INTERRUPTED_EXIT_CODE) : INTERRUPTED_EXIT_CODE;
+      const plan = await planCliEntryUpdate("vtx", argv, env, launcher, { ...dependencies, signal: stops.stopped });
+      if (stops.stops > 0) return resuming ? await endAfterStop(INTERRUPTED_EXIT_CODE) : INTERRUPTED_EXIT_CODE;
+      if (plan.kind === "refuse") {
+        stderr.write(`${plan.message}
+`);
+        return 1;
+      }
+      if (plan.kind === "run" && plan.warning) stderr.write(`${plan.warning}
+`);
+      const childScript = plan.kind === "reexec" ? await releaseEntryScript(plan.selection, "vtx").catch(() => null) : launcher;
+      const childEnv = {
+        ...supervisorEnv,
+        [RUNTIME_SUPERVISED_ENV]: "1",
+        [RUNTIME_SUPERVISOR_PID_ENV]: String(process.pid)
+      };
+      if (resuming) childEnv[RUNTIME_RESUME_ENV] = "1";
+      else delete childEnv[RUNTIME_RESUME_ENV];
+      const childArgv = resuming && resumeRecord && !argv.includes("--profile") ? [...argv, "--profile", String(resumeRecord.profileId)] : argv;
+      let confirmation = null;
+      if (stops.stops > 0) return resuming ? await endAfterStop(INTERRUPTED_EXIT_CODE) : INTERRUPTED_EXIT_CODE;
+      const result = childScript === null ? { kind: "not_ready", reason: "startup_exited_before_ready", exitCode: 1 } : await (dependencies.runRelease ?? runReleaseProcess)(
+        dependencies.executable ?? process.execPath,
+        childScript,
+        childArgv,
+        childEnv,
+        dependencies.readyTimeoutMs ?? runtime_policy_generated_default.agent_cli.startup_ready_timeout_ms,
+        () => {
+          if (plan.kind === "reexec" && !plan.selection.confirmed_at) {
+            confirmation = markConfirmed(paths, plan.selection, now);
+          }
+        },
+        stops
+      );
+      await confirmation;
+      if (result.kind === "exited" && result.signal === null && result.exitCode === RUNTIME_RESTART_FOR_UPDATE_EXIT_CODE) {
+        resumeRecord = await readRuntimeResume(supervisorEnv);
+        if (!resumeRecord) {
+          stderr.write("VTX CLI: the runtime ended for an update without a resume record; it was not restarted.\n");
+          return 1;
+        }
+        resuming = true;
+        failedStarts = 0;
+        continue;
+      }
+      if (result.kind === "exited" || result.kind === "interrupted") {
+        const childExitCode = result.signal ? 128 + (osConstants.signals[result.signal] ?? 0) : result.exitCode;
+        return stops.stops > 0 ? await endAfterStop(childExitCode) : childExitCode;
+      }
+      if (plan.kind !== "reexec" || plan.selection.confirmed_at || failedStarts >= 2) {
+        return result.exitCode;
+      }
+      failedStarts += 1;
+      const restored = await rollBack(paths, plan.selection, result.reason, now, env);
+      if (restored !== ROLLBACK_SKIPPED) {
+        stderr.write(
+          `VTX CLI ${plan.selection.package_version} failed to start (${result.reason}); rolled back to ${restored ?? current}.
+`
+        );
+      }
+    }
+  } finally {
+    stops.uninstall();
+    await clearRuntimeResume(supervisorEnv).catch(() => void 0);
+  }
+};
+var releaseEntryScript = async (selection, entry) => {
+  if (entry === "vtx") return selection.script;
+  const packageRoot = dirname3(dirname3(selection.script));
+  const packageJson = JSON.parse(await readFile3(join3(packageRoot, "package.json"), "utf8"));
+  const binPath = packageJson.bin?.[entry];
+  if (typeof binPath !== "string") throw new Error("release_entry_missing");
+  const script = resolve2(packageRoot, binPath);
+  if (!isPathWithin(packageRoot, script)) throw new Error("release_entry_missing");
+  await access(script);
+  return script;
+};
+var runCliEntry = async (entry, argv, runHere, dependencies = {}, env = process.env, script = process.argv[1] ?? "") => {
+  const stderr = dependencies.stderr ?? process.stderr;
+  if (argv[0] === CLI_BACKGROUND_STAGE_ARGUMENT) {
+    return await runCliBackgroundStage(env, dependencies).catch(() => 1);
+  }
+  if (entry === "vtx" && isSupervisableRuntimeCommand(argv) && !isSkippedInvocation(argv, env) && !cliAutoUpdateDisabled(env) && script && await classifyCliInstall(resolve2(script), dependencies.platform ?? process.platform, env) === "global") {
+    return await superviseRuntime(argv, dependencies, env, resolve2(script));
+  }
+  const paths = resolveCliUpdatePaths(env);
+  const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+  const current = dependencies.currentVersion ?? agent_cli_release_default.package_version;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const plan = await planCliEntryUpdate(entry, argv, env, script, dependencies);
+    if (plan.kind === "refuse") {
+      stderr.write(`${plan.message}
+`);
+      return 1;
+    }
+    if (plan.kind === "run") {
+      if (plan.warning) stderr.write(`${plan.warning}
+`);
+      return await runHere();
+    }
+    let confirmation = null;
+    const entryScript = await releaseEntryScript(plan.selection, entry).catch(() => null);
+    const result = entryScript === null ? { kind: "not_ready", reason: "startup_exited_before_ready", exitCode: 1 } : await (dependencies.runRelease ?? runReleaseProcess)(
+      dependencies.executable ?? process.execPath,
+      entryScript,
+      argv,
+      env,
+      dependencies.readyTimeoutMs ?? runtime_policy_generated_default.agent_cli.startup_ready_timeout_ms,
+      () => {
+        if (!plan.selection.confirmed_at) confirmation = markConfirmed(paths, plan.selection, now);
+      }
+    );
+    await confirmation;
+    if (result.kind === "exited" || result.kind === "interrupted") {
+      if (result.signal) {
+        process.kill(process.pid, result.signal);
+      }
+      return result.exitCode;
+    }
+    if (plan.selection.confirmed_at) {
+      return result.exitCode;
+    }
+    const restored = await rollBack(paths, plan.selection, result.reason, now, env);
+    if (restored === ROLLBACK_SKIPPED) continue;
+    stderr.write(
+      `VTX CLI ${plan.selection.package_version} failed to start (${result.reason}); rolled back to ${restored ?? current}.
+`
+    );
+  }
+  return await runHere();
+};
+var RUNTIME_RESTART_FOR_UPDATE_EXIT_CODE = 75;
+var RUNTIME_SUPERVISED_ENV = "VTX_CLI_RUNTIME_SUPERVISED";
+var RUNTIME_RESUME_ENV = "VTX_CLI_RUNTIME_RESUME";
+var RUNTIME_SUPERVISOR_PID_ENV = "VTX_CLI_RUNTIME_SUPERVISOR_PID";
+var RUNTIME_RESUME_FILE_ENV = "VTX_CLI_RUNTIME_RESUME_FILE";
+var runtimeResumeFile = (env) => String(env[RUNTIME_RESUME_FILE_ENV] ?? "").trim() || null;
+var parseRuntimeResumeRecord = (value) => {
+  const record = value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  const profileId = Number(record?.profileId);
+  const text = (field) => typeof record?.[field] === "string" ? String(record[field]).trim() : "";
+  if (!Number.isSafeInteger(profileId) || profileId <= 0) return null;
+  if (!text("runtimeSessionId") || !text("deviceId") || !text("handoffKey")) return null;
+  return {
+    profileId,
+    runtimeSessionId: text("runtimeSessionId"),
+    deviceId: text("deviceId"),
+    leaseToken: text("leaseToken") || null,
+    handoffKey: text("handoffKey")
+  };
+};
+var readRuntimeResume = async (env = process.env) => {
+  const path = runtimeResumeFile(env);
+  if (!path) return null;
+  try {
+    return parseRuntimeResumeRecord(JSON.parse(await readFile3(path, "utf8")));
+  } catch {
+    return null;
+  }
+};
+var clearRuntimeResume = async (env = process.env) => {
+  const path = runtimeResumeFile(env);
+  if (path) await rm3(path, { force: true });
+};
+var isSupervisableRuntimeCommand = (argv) => {
+  if (argv.includes("--once") || isInferenceHostCliInvocation(argv)) return false;
+  const words = argv.filter((item) => !item.startsWith("--"));
+  const at = words.indexOf("runtime");
+  if (at < 0) return false;
+  return words[at + 1] === "run" || words[at + 1] === "start" && argv.includes("--follow");
+};
+
+// bin/vtx-mcp.ts
+process.exitCode = await runCliEntry("vtx-mcp", process.argv.slice(2), async () => {
+  const { runVtxMcpStdioServer: runVtxMcpStdioServer2 } = await Promise.resolve().then(() => (init_stdio(), stdio_exports));
+  await reportCliEntryReady();
+  await runVtxMcpStdioServer2();
+  return typeof process.exitCode === "number" ? process.exitCode : 0;
+});
+/*! Bundled license information:
+
+smol-toml/dist/date.js:
+smol-toml/dist/error.js:
+smol-toml/dist/util.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/