@vtxmacro/cli 0.1.0 → 2026.6.22

package/README.md

@@ -22,8 +22,14 @@ vtx auth login --scopes read,bot:control
 vtx --json auth whoami
 vtx --json bots status
 vtx --profile <profile-id> runtime run --follow
+vtx auth login --scopes read,insights:connect
+vtx --profile <profile-id> insights connect
 ```
 
+The Insights connector talks only to a loopback OpenAI-compatible model server.
+It defaults to LM Studio at `http://127.0.0.1:1234/v1` and reads its optional
+API key from `LM_STUDIO_API_KEY`. The key and local URL never leave the device.
+
 ## MCP
 
 Configure your MCP-compatible agent app to start:

package/bin/vtx-mcp.js

@@ -256,6 +256,33 @@ var VtxAgentClient = class _VtxAgentClient {
   getLlmConfig(profileId) {
     return this.request("/llm/config", { profileId });
   }
+  registerInsightConnector(profileId, payload) {
+    return this.request("/insights/connectors/register", {
+      method: "POST",
+      profileId,
+      body: payload
+    });
+  }
+  claimInsightConnectorJob(profileId, connectorId, deviceId) {
+    return this.request(
+      `/insights/connectors/${encodeURIComponent(connectorId)}/jobs:claim`,
+      { method: "POST", profileId, body: { device_id: deviceId } }
+    );
+  }
+  completeInsightConnectorJob(profileId, connectorId, jobId, deviceId, payload) {
+    const params = new URLSearchParams({ device_id: deviceId });
+    return this.request(
+      `/insights/connectors/${encodeURIComponent(connectorId)}/jobs/${encodeURIComponent(jobId)}:complete?${params}`,
+      { method: "POST", profileId, body: payload }
+    );
+  }
+  heartbeatInsightConnectorJob(profileId, connectorId, jobId, deviceId, claimToken) {
+    const params = new URLSearchParams({ device_id: deviceId });
+    return this.request(
+      `/insights/connectors/${encodeURIComponent(connectorId)}/jobs/${encodeURIComponent(jobId)}:heartbeat?${params}`,
+      { method: "POST", profileId, body: { claim_token: claimToken } }
+    );
+  }
   heartbeatRuntime(profileId, payload, leaseToken) {
     return this.request("/trading/ai/runtime/heartbeat", {
       method: "POST",
@@ -968,7 +995,7 @@ async function handleMcpJsonRpcRequest(request, clientFactory = createDefaultMcp
       },
       serverInfo: {
         name: "vtx-macro",
-        version: "0.1.0"
+        version: "2026.6.22"
       }
     });
   }

package/bin/vtx.js

@@ -1632,10 +1632,13 @@ var init_hyperliquid_account_state_adapter = __esm({
 });
 
 // lib/byokProviderRegistry.ts
+function normalizeProviderAlias(value) {
+  return String(value ?? "").trim().toLowerCase().replace(/[._-]+/g, " ").replace(/\s+/g, " ");
+}
 function byokProvidersForClientRuntime() {
   return BYOK_PROVIDERS.filter((provider) => provider.clientRuntimeSupported);
 }
-var BYOK_UI_GROUP, BYOK_PROVIDERS;
+var BYOK_UI_GROUP, BYOK_PROVIDERS, BYOK_PROVIDER_KEY_BY_ALIAS;
 var init_byokProviderRegistry = __esm({
   "lib/byokProviderRegistry.ts"() {
     "use strict";
@@ -1658,6 +1661,15 @@ var init_byokProviderRegistry = __esm({
       { key: "venice", runtimeProvider: "venice", displayName: "Venice AI", apiKeyField: "venice_api_key", envKey: "VENICE_API_KEY", baseUrl: "https://api.venice.ai/api/v1", modelsUrl: "https://api.venice.ai/api/v1/models", requestContractStrategy: "venice", clientRuntimeSupported: true, uiGroup: BYOK_UI_GROUP, providerKind: "hosted", displayOrder: 150, aliases: ["venice.ai"] },
       { key: "xai", runtimeProvider: "grok", displayName: "xAI", apiKeyField: "grok_api_key", envKey: "XAI_API_KEY", baseUrl: "https://api.x.ai/v1", modelsUrl: "https://api.x.ai/v1/models", requestContractStrategy: "native", clientRuntimeSupported: true, uiGroup: BYOK_UI_GROUP, providerKind: "direct", displayOrder: 160, aliases: ["x", "x.ai", "grok"] }
     ];
+    BYOK_PROVIDER_KEY_BY_ALIAS = /* @__PURE__ */ new Map();
+    for (const provider of BYOK_PROVIDERS) {
+      for (const alias of [provider.key, provider.displayName, ...provider.aliases]) {
+        const normalizedAlias = normalizeProviderAlias(alias);
+        if (!BYOK_PROVIDER_KEY_BY_ALIAS.has(normalizedAlias)) {
+          BYOK_PROVIDER_KEY_BY_ALIAS.set(normalizedAlias, provider.key);
+        }
+      }
+    }
   }
 });
 
@@ -1978,22 +1990,22 @@ var init_api = __esm({
         return process.env.API_URL_SERVER || process.env.NEXT_PUBLIC_API_URL || "http://api:8000";
       }
       if (process.env.NODE_ENV === "development") {
-        const hostname = window.location.hostname;
-        const isLocalNetworkIP = hostname.startsWith("192.168.") || hostname.startsWith("10.") || hostname.startsWith("172.") && parseInt(hostname.split(".")[1]) >= 16 && parseInt(hostname.split(".")[1]) <= 31;
+        const hostname2 = window.location.hostname;
+        const isLocalNetworkIP = hostname2.startsWith("192.168.") || hostname2.startsWith("10.") || hostname2.startsWith("172.") && parseInt(hostname2.split(".")[1]) >= 16 && parseInt(hostname2.split(".")[1]) <= 31;
         if (isLocalNetworkIP) {
-          return `http://${hostname}:8000`;
+          return `http://${hostname2}:8000`;
         }
-        if (hostname === "localhost" || hostname === "127.0.0.1") {
-          return `http://${hostname}:8000`;
+        if (hostname2 === "localhost" || hostname2 === "127.0.0.1") {
+          return `http://${hostname2}:8000`;
         }
       }
       if (process.env.NEXT_PUBLIC_API_URL) {
         return process.env.NEXT_PUBLIC_API_URL;
       }
       try {
-        const hostname = window.location.hostname;
+        const hostname2 = window.location.hostname;
         const protocol = window.location.protocol;
-        const baseHost = hostname.startsWith("www.") ? hostname.slice(4) : hostname;
+        const baseHost = hostname2.startsWith("www.") ? hostname2.slice(4) : hostname2;
         const apiHost = baseHost.startsWith("api.") ? baseHost : `api.${baseHost}`;
         return `${protocol}//${apiHost}`;
       } catch {
@@ -11557,7 +11569,7 @@ var init_hyperliquid_signer = __esm({
 });
 
 // lib/runtime/hyperliquid-client.ts
-var HyperliquidExchangeRejectionError, normalizeSymbol, HYPERLIQUID_NONCE_STORAGE_KEY, HYPERLIQUID_NONCE_LOCK_NAME, lastGeneratedNonce, readBrowserStoredHyperliquidNonce, writeBrowserStoredHyperliquidNonce, browserNonceCoordinator, allocateHyperliquidNonce, generateHyperliquidNonce, roundToSigFigs, normalizeDecimalString, toPlainDecimalString, roundDirectionalDecimalString, formatHyperliquidPerpPriceWire, countSignificantDigits, countDecimalPlaces, validateHyperliquidPerpPriceWire, validateHyperliquidSizeWire, formatSizeWire, inferApiUrl, inferIsTestnet, postHyperliquidInfo, toFiniteNumber, firstFiniteNumber2, parseFundingUsdcFromInfoPosition2, isExchangeIsolatedOnly, computeHip3AssetId, getPerpDexIndexMap, buildAssetInfosFromMetaResponse, requireWalletAddress2, assertPositiveNumber, normalizeOrderSide, resolveAssets, findResolvedAsset, normalizeExecutionAssetMetadata, resolveHyperliquidAsset, fetchBrowserAvailableAssets, fetchBrowserAllMids, fetchBrowserSymbolMidPrice, fetchBrowserAccountState2, fetchBrowserPosition, buildHyperliquidOrderWire, signHyperliquidPayload, buildHyperliquidUpdateLeveragePayload, buildHyperliquidMarketOrderPayload, extractHyperliquidExchangeError, buildHyperliquidOrderDiagnostics, submitHyperliquidExchangePayload;
+var HyperliquidExchangeRejectionError, normalizeSymbol, HYPERLIQUID_NONCE_STORAGE_KEY, HYPERLIQUID_NONCE_LOCK_NAME, lastGeneratedNonce, readBrowserStoredHyperliquidNonce, writeBrowserStoredHyperliquidNonce, browserNonceCoordinator, allocateHyperliquidNonce, generateHyperliquidNonce, roundToSigFigs, normalizeDecimalString, toPlainDecimalString, roundDirectionalDecimalString, formatHyperliquidPerpPriceWire, formatHyperliquidTriggerPriceWire, countSignificantDigits, countDecimalPlaces, validateHyperliquidPerpPriceWire, validateHyperliquidSizeWire, formatSizeWire, inferApiUrl, inferIsTestnet, postHyperliquidInfo, toFiniteNumber, firstFiniteNumber2, parseFundingUsdcFromInfoPosition2, isExchangeIsolatedOnly, computeHip3AssetId, getPerpDexIndexMap, buildAssetInfosFromMetaResponse, requireWalletAddress2, assertPositiveNumber, normalizeOrderSide, resolveAssets, findResolvedAsset, normalizeExecutionAssetMetadata, resolveHyperliquidAsset, fetchBrowserAvailableAssets, fetchBrowserAllMids, fetchBrowserSymbolMidPrice, fetchBrowserAccountState2, fetchBrowserPosition, buildHyperliquidOrderWire, signHyperliquidPayload, buildHyperliquidUpdateLeveragePayload, buildHyperliquidMarketOrderPayload, buildHyperliquidTriggerOrderPayload, extractHyperliquidExchangeError, buildHyperliquidOrderDiagnostics, submitHyperliquidExchangePayload;
 var init_hyperliquid_client = __esm({
   "lib/runtime/hyperliquid-client.ts"() {
     "use strict";
@@ -11692,6 +11704,14 @@ var init_hyperliquid_client = __esm({
       assertPositiveNumber(decimalRounded, "Hyperliquid order price");
       return normalizeDecimalString(roundedWire);
     };
+    formatHyperliquidTriggerPriceWire = (value, sizeDecimals) => {
+      const sigFigRounded = roundToSigFigs(value, 5);
+      const priceDecimals = Math.max(0, 6 - sizeDecimals);
+      const scale = 10 ** priceDecimals;
+      const decimalRounded = Math.round(sigFigRounded * scale) / scale;
+      assertPositiveNumber(decimalRounded, "Hyperliquid trigger price");
+      return normalizeDecimalString(decimalRounded.toFixed(priceDecimals));
+    };
     countSignificantDigits = (value) => {
       const normalized = String(value || "").replace("-", "");
       const [integerPartRaw, fractionPartRaw = ""] = normalized.split(".");
@@ -11818,7 +11838,7 @@ var init_hyperliquid_client = __esm({
       }
       return null;
     };
-    isExchangeIsolatedOnly = (asset) => asset.only_isolated === true || String(asset.margin_mode || "").trim().toLowerCase() === "nocross";
+    isExchangeIsolatedOnly = (asset) => asset.only_isolated === true || ["nocross", "strictisolated"].includes(String(asset.margin_mode || "").trim().toLowerCase());
     computeHip3AssetId = (perpDexIndex, indexInMeta) => 1e5 + Math.trunc(perpDexIndex) * 1e4 + Math.trunc(indexInMeta);
     getPerpDexIndexMap = (payload) => {
       if (!Array.isArray(payload)) {
@@ -12183,6 +12203,44 @@ var init_hyperliquid_client = __esm({
         grouping: "na"
       });
     };
+    buildHyperliquidTriggerOrderPayload = async (input) => {
+      assertPositiveNumber(input.size, "Hyperliquid trigger order size");
+      assertPositiveNumber(input.triggerPrice, "Hyperliquid trigger price");
+      const { asset_index: assetIndex, sz_decimals: sizeDecimals } = await resolveHyperliquidAsset(input);
+      const side = normalizeOrderSide(input.side);
+      const roundedSize = Number(input.size.toFixed(sizeDecimals));
+      assertPositiveNumber(roundedSize, "Hyperliquid trigger order size");
+      const priceWire = formatHyperliquidTriggerPriceWire(input.triggerPrice, sizeDecimals);
+      const sizeWire = formatSizeWire(roundedSize, sizeDecimals);
+      const priceValidation = validateHyperliquidPerpPriceWire(priceWire, sizeDecimals);
+      if (!priceValidation.valid) {
+        throw new Error(`Invalid Hyperliquid trigger price wire: ${priceValidation.reason}.`);
+      }
+      const sizeValidation = validateHyperliquidSizeWire(sizeWire, sizeDecimals);
+      if (!sizeValidation.valid) {
+        throw new Error(`Invalid Hyperliquid trigger size wire: ${sizeValidation.reason}.`);
+      }
+      return signHyperliquidPayload(input, {
+        type: "order",
+        orders: [
+          {
+            a: assetIndex,
+            b: side === "buy",
+            p: priceWire,
+            s: sizeWire,
+            r: input.reduceOnly !== false,
+            t: {
+              trigger: {
+                isMarket: true,
+                triggerPx: priceWire,
+                tpsl: input.isTakeProfit === true ? "tp" : "sl"
+              }
+            }
+          }
+        ],
+        grouping: "na"
+      });
+    };
     extractHyperliquidExchangeError = (payload) => {
       if (!payload || typeof payload !== "object") {
         return "Unexpected response format from Hyperliquid.";
@@ -12426,6 +12484,16 @@ function validateDeviceSecrets(value, options) {
   );
   const hasHyperliquidSigningKey = Boolean(hyperliquidSigningKey);
   const providerKeyCount = Object.keys(providerKeysWithFirstSlots).length;
+  const activeProviderKeyAliases = activeProvider ? (() => {
+    const provider = byokProvidersForClientRuntime().find(
+      (candidate) => candidate.runtimeProvider === activeProvider
+    );
+    return /* @__PURE__ */ new Set([
+      activeProvider,
+      ...provider ? [provider.key, provider.runtimeProvider] : []
+    ]);
+  })() : null;
+  const hasActiveProviderKey = activeProviderKeyAliases ? Object.keys(providerKeysWithFirstSlots).some((provider) => activeProviderKeyAliases.has(provider)) : providerKeyCount > 0;
   const missing = [];
   if (!hasHyperliquidSigningKey) {
     missing.push("hyperliquid signing key");
@@ -12434,10 +12502,10 @@ function validateDeviceSecrets(value, options) {
     if (!hasLocalAiConfig) {
       missing.push("local ai config");
     }
-  } else if (providerKeyCount === 0 && !(activeProvider === "openai" && hasOpenAiCompatibleConfig)) {
+  } else if (!hasActiveProviderKey && !(activeProvider === "openai" && hasOpenAiCompatibleConfig)) {
     missing.push("model provider key");
   }
-  const hasProviderRequirement = isLocalProvider ? hasLocalAiConfig : activeProvider === "openai" ? providerKeyCount > 0 || hasOpenAiCompatibleConfig : providerKeyCount > 0;
+  const hasProviderRequirement = isLocalProvider ? hasLocalAiConfig : activeProvider === "openai" ? hasActiveProviderKey || hasOpenAiCompatibleConfig : hasActiveProviderKey;
   return {
     normalized: {
       hyperliquidSigningKey,
@@ -12469,6 +12537,7 @@ var init_vault = __esm({
     init_key_preview_contract();
     init_client_runtime_provider_visibility_contract();
     init_client_runtime_secret_rate_limit_contract();
+    init_byokProviderRegistry();
     VAULT_PREFIX = "vtx_vault_";
     VAULT_DB_NAME = "vtx-client-runtime-vault";
     VAULT_DB_VERSION = 1;
@@ -12977,7 +13046,7 @@ var init_vault = __esm({
 });
 
 // lib/runtime/browser-trading.ts
-var resolveProfileId, requirePositiveNumber, throwIfAborted, loadSigningKey, resolveSigningKey, requireWalletAddress3, resolveEstimatedPrice, executeClientLeverageUpdate, executeClientMarketOrder, executeClientClosePosition;
+var resolveProfileId, requirePositiveNumber, throwIfAborted, loadSigningKey, resolveSigningKey, requireWalletAddress3, resolveEstimatedPrice, executeClientLeverageUpdate, executeClientMarketOrder, executeClientTriggerOrder, executeClientClosePosition;
 var init_browser_trading = __esm({
   "lib/runtime/browser-trading.ts"() {
     "use strict";
@@ -13083,6 +13152,26 @@ var init_browser_trading = __esm({
         signal: input.signal
       });
     };
+    executeClientTriggerOrder = async (input) => {
+      throwIfAborted(input.signal);
+      const signingKey = await resolveSigningKey(input);
+      throwIfAborted(input.signal);
+      const payload = await buildHyperliquidTriggerOrderPayload({
+        config: input.config ?? null,
+        signingKey,
+        symbol: input.symbol,
+        side: input.side,
+        size: input.size,
+        triggerPrice: input.triggerPrice,
+        reduceOnly: input.reduceOnly,
+        isTakeProfit: input.isTakeProfit
+      });
+      return submitHyperliquidExchangePayload({
+        config: input.config ?? null,
+        payload,
+        signal: input.signal
+      });
+    };
     executeClientClosePosition = async (input) => {
       throwIfAborted(input.signal);
       const profileId = resolveProfileId(input.profileId);
@@ -13118,7 +13207,7 @@ var init_browser_trading = __esm({
 });
 
 // lib/runtime/execution-guard-contract.ts
-var unitsFromPosition, signedUnitsFromPosition, classifyExecutionIntent;
+var unitsFromPosition, signedUnitsFromPosition, classifyExecutionIntent, resolveExecutionTarget;
 var init_execution_guard_contract = __esm({
   "lib/runtime/execution-guard-contract.ts"() {
     "use strict";
@@ -13299,11 +13388,52 @@ var init_execution_guard_contract = __esm({
         targetSignedUnits: -(units - Math.abs(snapshotSignedUnits))
       };
     };
+    resolveExecutionTarget = (classified, liveSignedUnits) => {
+      const liveUnits = Number.isFinite(liveSignedUnits) ? Math.trunc(liveSignedUnits) : 0;
+      const deltaSignedUnits = classified.targetSignedUnits - liveUnits;
+      if (classified.side !== "buy" && classified.side !== "sell") {
+        return {
+          allowed: false,
+          reasonCode: classified.requestedAction === "HOLD" ? "hold_no_action" : "invalid_decision",
+          deltaSignedUnits,
+          closeOpposingPosition: false,
+          orderUnits: 0
+        };
+      }
+      if (deltaSignedUnits === 0) {
+        return {
+          allowed: false,
+          reasonCode: "noop_already_at_target",
+          deltaSignedUnits: 0,
+          closeOpposingPosition: false,
+          orderUnits: 0
+        };
+      }
+      const expectedDeltaSign = classified.side === "buy" ? 1 : -1;
+      const actualDeltaSign = deltaSignedUnits > 0 ? 1 : -1;
+      if (actualDeltaSign !== expectedDeltaSign) {
+        return {
+          allowed: false,
+          reasonCode: "stale_target_conflict",
+          deltaSignedUnits,
+          closeOpposingPosition: false,
+          orderUnits: 0
+        };
+      }
+      const closeOpposingPosition = classified.intent === "flip" && (classified.side === "buy" && liveUnits < 0 || classified.side === "sell" && liveUnits > 0);
+      return {
+        allowed: true,
+        reasonCode: "executed",
+        deltaSignedUnits,
+        closeOpposingPosition,
+        orderUnits: closeOpposingPosition ? Math.abs(classified.targetSignedUnits) : Math.abs(deltaSignedUnits)
+      };
+    };
   }
 });
 
 // lib/runtime/runtime-execution.ts
-var createRuntimeId, _extractOrderId, _toExecutionMetadata, throwIfAborted2, sleep2, roundAssetSize, resolvePositionSize, resolveCurrentPositionSize, buildPositionSnapshot, executeClientRuntimeDecision;
+var createRuntimeId, _extractOrderId, _toExecutionMetadata, toPositiveNumber, resolveRiskPct, buildTriggerPrice, throwIfAborted2, sleep2, roundAssetSize, resolvePositionSize, resolveCurrentPositionSize, buildPositionSnapshot, executeClientRuntimeDecision;
 var init_runtime_execution = __esm({
   "lib/runtime/runtime-execution.ts"() {
     "use strict";
@@ -13366,6 +13496,25 @@ var init_runtime_execution = __esm({
       }
       return { raw: value ?? null };
     };
+    toPositiveNumber = (value) => {
+      const parsed = Number(value);
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+    };
+    resolveRiskPct = (mode, percentValue, usdcValue, positionNotional) => {
+      if (mode === "usdc") {
+        const usdc = toPositiveNumber(usdcValue);
+        return positionNotional > 0 ? usdc / positionNotional * 100 : 0;
+      }
+      return toPositiveNumber(percentValue);
+    };
+    buildTriggerPrice = (entryPrice, riskPct, isLong, isTakeProfit) => {
+      if (!Number.isFinite(entryPrice) || entryPrice <= 0 || !Number.isFinite(riskPct) || riskPct <= 0) {
+        return 0;
+      }
+      const multiplier = isTakeProfit ? isLong ? 1 + riskPct / 100 : 1 - riskPct / 100 : isLong ? 1 - riskPct / 100 : 1 + riskPct / 100;
+      const price = entryPrice * multiplier;
+      return Number.isFinite(price) && price > 0 ? price : 0;
+    };
     throwIfAborted2 = (signal) => {
       if (signal?.aborted) {
         throw new DOMException("The operation was aborted.", "AbortError");
@@ -13481,8 +13630,8 @@ var init_runtime_execution = __esm({
         label: "execution_start",
         note: `decision=${input.decision} units=${requestedUnits} symbol=${input.executionContext.symbol}`
       });
+      const decisionSnapshotPositionSize = Number.isFinite(input.executionContext.currentPositionSize) ? Number(input.executionContext.currentPositionSize) : 0;
       if (input.decision === "HOLD" || requestedUnits <= 0) {
-        const snapshotPositionSize = Number.isFinite(input.executionContext.currentPositionSize) ? Number(input.executionContext.currentPositionSize) : 0;
         return {
           status: "skipped",
           intent: "hold",
@@ -13490,7 +13639,7 @@ var init_runtime_execution = __esm({
           reduceOnly: false,
           requestedUnits,
           targetSignedUnits: signedUnitsFromPosition(
-            snapshotPositionSize,
+            decisionSnapshotPositionSize,
             input.executionContext.lastPrice,
             input.executionContext.unitSizeUsdc
           ),
@@ -13509,14 +13658,25 @@ var init_runtime_execution = __esm({
       } = await resolveCurrentPositionSize(input);
       throwIfAborted2(input.signal);
       const currentPosition = buildPositionSnapshot(input.executionContext.symbol, currentPositionSize);
+      const decisionSnapshotSignedUnits = signedUnitsFromPosition(
+        decisionSnapshotPositionSize,
+        input.executionContext.lastPrice,
+        input.executionContext.unitSizeUsdc
+      );
+      const liveSignedUnits = signedUnitsFromPosition(
+        currentPositionSize,
+        executionPrice,
+        input.executionContext.unitSizeUsdc
+      );
       const classified = classifyExecutionIntent(
         input.decision,
         requestedUnits,
-        signedUnitsFromPosition(currentPositionSize, executionPrice, input.executionContext.unitSizeUsdc)
+        decisionSnapshotSignedUnits
       );
+      const targetResolution = resolveExecutionTarget(classified, liveSignedUnits);
       appendRuntimeDebugEvent({
         label: "execution_classified",
-        note: `symbol=${input.executionContext.symbol} intent=${classified.intent} side=${classified.side ?? "none"} snapshot_units=${classified.snapshotSignedUnits} target_units=${classified.targetSignedUnits} requested_units=${classified.requestedUnits} reduceOnly=${String(classified.reduceOnly)} execution_snapshot_id=${executionSnapshotId}`
+        note: `symbol=${input.executionContext.symbol} intent=${classified.intent} side=${classified.side ?? "none"} decision_snapshot_units=${classified.snapshotSignedUnits} live_units=${liveSignedUnits} target_units=${classified.targetSignedUnits} delta_units=${targetResolution.deltaSignedUnits} requested_units=${classified.requestedUnits} reduceOnly=${String(classified.reduceOnly)} resolution=${targetResolution.reasonCode} execution_snapshot_id=${executionSnapshotId}`
       });
       if (!classified.side || classified.intent === "hold") {
         return {
@@ -13533,6 +13693,28 @@ var init_runtime_execution = __esm({
           executionSnapshotCapturedAt
         };
       }
+      if (!targetResolution.allowed) {
+        const staleTargetConflict = targetResolution.reasonCode === "stale_target_conflict";
+        appendRuntimeDebugEvent({
+          label: staleTargetConflict ? "execution_stale_target_skipped" : "execution_target_noop",
+          note: `symbol=${input.executionContext.symbol} intent=${classified.intent} decision_snapshot_units=${classified.snapshotSignedUnits} live_units=${liveSignedUnits} target_units=${classified.targetSignedUnits} delta_units=${targetResolution.deltaSignedUnits}`,
+          outcome: "ok"
+        });
+        return {
+          status: "skipped",
+          intent: classified.intent,
+          side: classified.side,
+          reduceOnly: classified.reduceOnly,
+          requestedUnits: classified.requestedUnits,
+          targetSignedUnits: classified.targetSignedUnits,
+          executedSizeAsset: 0,
+          executionReports: [],
+          message: staleTargetConflict ? "Live state moved beyond the requested target; skipping stale decision" : "No-op: live position already matches target state",
+          reasonCode: staleTargetConflict ? "stale_target_conflict" : "noop_already_at_target",
+          executionSnapshotId,
+          executionSnapshotCapturedAt
+        };
+      }
       if (classified.intent === "open" || classified.intent === "add" || classified.intent === "flip") {
         throwIfAborted2(input.signal);
         await executeClientLeverageUpdate({
@@ -13582,7 +13764,7 @@ var init_runtime_execution = __esm({
         };
       }
       const executionReports = [];
-      if (classified.intent === "flip" && currentPositionSize !== 0) {
+      if (targetResolution.closeOpposingPosition) {
         throwIfAborted2(input.signal);
         const closeResponse = await executeClientClosePosition({
           profileId: input.profileId,
@@ -13606,10 +13788,7 @@ var init_runtime_execution = __esm({
           await sleep2(Math.round(input.executionContext.closePositionDelaySeconds * 1e3), input.signal);
         }
       }
-      let actualUnits = Math.abs(classified.targetSignedUnits - classified.snapshotSignedUnits);
-      if (classified.intent === "flip") {
-        actualUnits = Math.abs(classified.targetSignedUnits);
-      }
+      const actualUnits = targetResolution.orderUnits;
       const sizeAsset = roundAssetSize(
         input.executionContext.unitSizeUsdc * actualUnits / executionPrice,
         input.executionContext.sizeDecimals
@@ -13658,6 +13837,84 @@ var init_runtime_execution = __esm({
         status: "executed",
         execution_metadata: _toExecutionMetadata(marketOrderResponse)
       });
+      const shouldAttachSlTp = input.executionContext.tpSlEnabled === true && classified.reduceOnly !== true && (classified.intent === "open" || classified.intent === "add" || classified.intent === "flip");
+      if (shouldAttachSlTp) {
+        const isLong = classified.side === "buy";
+        const exitSide = isLong ? "sell" : "buy";
+        const positionNotional = Math.abs(executionPrice * sizeAsset);
+        const slPct = input.executionContext.stopLossEnabled === false ? 0 : resolveRiskPct(
+          input.executionContext.stopLossMode,
+          input.executionContext.stopLossPct,
+          input.executionContext.stopLossUsdc,
+          positionNotional
+        );
+        const tpPct = input.executionContext.takeProfitEnabled === false ? 0 : resolveRiskPct(
+          input.executionContext.takeProfitMode,
+          input.executionContext.takeProfitPct,
+          input.executionContext.takeProfitUsdc,
+          positionNotional
+        );
+        const slPrice = buildTriggerPrice(executionPrice, slPct, isLong, false);
+        const tpPrice = buildTriggerPrice(executionPrice, tpPct, isLong, true);
+        const triggerInputs = [
+          { label: "AUTO_SL", triggerPrice: slPrice, isTakeProfit: false },
+          { label: "AUTO_TP", triggerPrice: tpPrice, isTakeProfit: true }
+        ];
+        for (const triggerInput of triggerInputs) {
+          if (triggerInput.triggerPrice <= 0) {
+            continue;
+          }
+          try {
+            throwIfAborted2(input.signal);
+            const triggerResponse = await executeClientTriggerOrder({
+              profileId: input.profileId,
+              walletAddress: input.executionContext.walletAddress,
+              config: input.config ?? null,
+              signal: input.signal,
+              signingKey: input.signingKey,
+              symbol: input.executionContext.symbol,
+              side: exitSide,
+              size: sizeAsset,
+              triggerPrice: triggerInput.triggerPrice,
+              reduceOnly: true,
+              isTakeProfit: triggerInput.isTakeProfit
+            });
+            executionReports.push({
+              order_id: _extractOrderId(triggerResponse),
+              symbol: input.executionContext.symbol,
+              action: triggerInput.label,
+              status: "executed",
+              execution_metadata: {
+                trigger_price: triggerInput.triggerPrice,
+                is_take_profit: triggerInput.isTakeProfit,
+                ..._toExecutionMetadata(triggerResponse)
+              }
+            });
+            appendRuntimeDebugEvent({
+              label: "execution_auto_sl_tp_submitted",
+              note: `symbol=${input.executionContext.symbol} kind=${triggerInput.isTakeProfit ? "tp" : "sl"} side=${exitSide} sizeAsset=${sizeAsset} triggerPrice=${triggerInput.triggerPrice} order_id=${_extractOrderId(triggerResponse) || "none"}`
+            });
+          } catch (triggerError) {
+            const message = triggerError instanceof Error ? triggerError.message : String(triggerError);
+            executionReports.push({
+              order_id: null,
+              symbol: input.executionContext.symbol,
+              action: triggerInput.label,
+              status: "failed",
+              execution_metadata: {
+                trigger_price: triggerInput.triggerPrice,
+                is_take_profit: triggerInput.isTakeProfit,
+                error: message
+              }
+            });
+            appendRuntimeDebugEvent({
+              label: "execution_auto_sl_tp_failed",
+              note: `symbol=${input.executionContext.symbol} kind=${triggerInput.isTakeProfit ? "tp" : "sl"} error=${message}`,
+              outcome: "error"
+            });
+          }
+        }
+      }
       appendRuntimeDebugEvent({
         label: "execution_order_submitted",
         note: `symbol=${input.executionContext.symbol} side=${classified.side} sizeAsset=${sizeAsset} reduceOnly=${String(classified.reduceOnly)} order_id=${_extractOrderId(marketOrderResponse) || "none"}`
@@ -13763,9 +14020,11 @@ function extractDecisionPayload(content, symbol) {
   const decisionSource = scoped ?? parsed;
   const decision = normalizeDecision(decisionSource.decision);
   const units = decision === "HOLD" ? 0 : Math.max(0, Math.trunc(Number(decisionSource.units) || 0));
+  const parsedTradability = Number(decisionSource.tradability);
+  const tradability = Number.isInteger(parsedTradability) && parsedTradability >= 1 && parsedTradability <= 10 ? parsedTradability : null;
   const fallbackReasoning = content.trim() || "Headless runtime produced no reasoning.";
   const reasoning = optionalText(decisionSource.reasoning) ?? optionalText(decisionSource.analysis) ?? fallbackReasoning;
-  return { decision, units, reasoning };
+  return { decision, units, tradability, reasoning };
 }
 function buildClientExchangeSnapshot(input) {
   const accountSummary = input.accountState.accountSummary;
@@ -13774,6 +14033,7 @@ function buildClientExchangeSnapshot(input) {
     captured_at: (/* @__PURE__ */ new Date()).toISOString(),
     wallet_address: input.walletAddress,
     symbol: input.symbol,
+    mark_price: input.accountState.availableToTrade.mark_price ?? null,
     account_summary: {
       account_value: accountSummary.account_value ?? null,
       total_margin_used: accountSummary.total_margin_used ?? null,
@@ -13848,7 +14108,7 @@ async function fetchLocalHyperliquidSnapshot(input) {
   const executionConfig = buildHeadlessExchangeConfig(input.llmConfig);
   const promptKnobs = objectOrNull2(input.metadata.prompt_knobs) ?? {};
   const leverage = requirePositiveNumber2(promptKnobs.leverage ?? input.llmConfig.default_leverage, "leverage");
-  const accountState = await fetchBrowserAccountState({
+  const accountState = await input.fetchAccountState({
     config: executionConfig,
     walletAddress,
     symbol: input.symbol,
@@ -13974,6 +14234,7 @@ function resolveProviderInvocation(input) {
 }
 function createHeadlessLocalWorker(options) {
   const fetchImpl = options.fetchImpl ?? fetch;
+  const fetchAccountState = options.fetchAccountState ?? fetchBrowserAccountState;
   return async function runHeadlessLocalWorker(input) {
     if (!input.runtimeState.leaseToken) {
       throw new Error("Headless runtime worker requires an active runtime lease.");
@@ -14005,7 +14266,31 @@ function createHeadlessLocalWorker(options) {
     const secrets = objectOrNull2(input.secrets) ?? {};
     const decisionSnapshotId = `headless-decision-${Date.now()}`;
     const decisionSnapshotCapturedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const localHyperliquidContext = providerDecision.decision === "HOLD" || providerDecision.units <= 0 ? null : await fetchLocalHyperliquidSnapshot({
+    const promptKnobs = objectOrNull2(metadata.prompt_knobs) ?? {};
+    const tradabilityEnabled = promptKnobs.tradability_enabled === true;
+    const tradabilityOpenEnabled = promptKnobs.tradability_open_enabled === true;
+    const tradabilityIncreaseEnabled = promptKnobs.tradability_increase_enabled === true;
+    const tradabilityMinimumBound = tradabilityEnabled ? requireFiniteNumber(llmConfig.tradability_threshold_min, "Tradability minimum bound") : 0;
+    const tradabilityMaximumBound = tradabilityEnabled ? requireFiniteNumber(llmConfig.tradability_threshold_max, "Tradability maximum bound") : 0;
+    const resolveTradabilityMinimum = (value, label) => {
+      if (!tradabilityEnabled) return 0;
+      const parsed = requireFiniteNumber(value, label);
+      if (!Number.isInteger(parsed) || parsed < tradabilityMinimumBound || parsed > tradabilityMaximumBound) {
+        throw new Error(
+          `Invalid headless runtime ${label}: expected an integer from ${tradabilityMinimumBound} to ${tradabilityMaximumBound}.`
+        );
+      }
+      return parsed;
+    };
+    const tradabilityOpenMinimum = resolveTradabilityMinimum(
+      promptKnobs.tradability_open_minimum,
+      "Open Position Tradability minimum"
+    );
+    const tradabilityIncreaseMinimum = resolveTradabilityMinimum(
+      promptKnobs.tradability_increase_minimum,
+      "Increase Position Tradability minimum"
+    );
+    const candidateHyperliquidContext = providerDecision.decision === "HOLD" || providerDecision.units <= 0 ? null : await fetchLocalHyperliquidSnapshot({
       client: options.client,
       profileId: input.profileId,
       llmConfig,
@@ -14014,8 +14299,36 @@ function createHeadlessLocalWorker(options) {
       symbol,
       timeframe,
       decisionSnapshotId,
-      decisionSnapshotCapturedAt
+      decisionSnapshotCapturedAt,
+      fetchAccountState
     });
+    const classifiedIntent = candidateHyperliquidContext ? classifyExecutionIntent(
+      providerDecision.decision,
+      providerDecision.units,
+      signedUnitsFromPosition(
+        candidateHyperliquidContext.executionContext.currentPositionSize,
+        candidateHyperliquidContext.executionContext.lastPrice,
+        candidateHyperliquidContext.executionContext.unitSizeUsdc
+      )
+    ).intent : "hold";
+    const applicableMinimum = classifiedIntent === "open" && tradabilityOpenEnabled ? tradabilityOpenMinimum : classifiedIntent === "add" && tradabilityIncreaseEnabled ? tradabilityIncreaseMinimum : null;
+    const tradabilityRejected = tradabilityEnabled && applicableMinimum !== null && (providerDecision.tradability == null || providerDecision.tradability < applicableMinimum);
+    const localHyperliquidContext = tradabilityRejected ? null : candidateHyperliquidContext;
+    const tradabilityBlockExecution = tradabilityRejected && applicableMinimum !== null ? {
+      order_id: null,
+      symbol,
+      action: providerDecision.decision,
+      status: "blocked",
+      execution_metadata: {
+        reason_code: "tradability_below_minimum",
+        control: "tradability",
+        intent: classifiedIntent,
+        tradability: providerDecision.tradability,
+        minimum: applicableMinimum,
+        decision_snapshot_id: decisionSnapshotId,
+        message: `Tradability ${providerDecision.tradability ?? "missing"} is below the ${classifiedIntent === "open" ? "Open" : "Add"} minimum of ${applicableMinimum}. No order was placed.`
+      }
+    } : null;
     const envelope = metadata.envelope ?? {};
     const analysisRunId = `headless-${Date.now()}`;
     const baseTradeSync = {
@@ -14038,6 +14351,7 @@ function createHeadlessLocalWorker(options) {
         policy_generation_id: requireText(envelope.policy_generation_id, "policy generation id"),
         decision: providerDecision.decision,
         units: providerDecision.units,
+        final_tradability: providerDecision.tradability,
         reasoning: providerDecision.reasoning,
         model: requireText(prompt.model ?? metadata.model, "model"),
         model_source: normalizeModelSource(metadata.model_source),
@@ -14056,7 +14370,11 @@ function createHeadlessLocalWorker(options) {
         is_analyzing: false,
         is_executing: Boolean(localHyperliquidContext)
       },
-      tradeSync: localHyperliquidContext ? null : { ...baseTradeSync, executions: [] },
+      tradeSync: localHyperliquidContext ? null : {
+        ...baseTradeSync,
+        execution_snapshot_id: tradabilityBlockExecution ? decisionSnapshotId : void 0,
+        executions: tradabilityBlockExecution ? [tradabilityBlockExecution] : []
+      },
       afterDecision: localHyperliquidContext ? async () => {
         const executionResult = await executeClientRuntimeDecision({
           profileId: String(input.profileId),
@@ -14085,6 +14403,7 @@ var init_headless_local_worker = __esm({
     init_hyperliquid_account_state_adapter();
     init_hyperliquid_market_symbol();
     init_runtime_execution();
+    init_execution_guard_contract();
     OPENAI_COMPATIBLE_SOURCE_KEY = {
       openai: "openai",
       groq: "groq",
@@ -14110,6 +14429,7 @@ var init_headless_local_worker = __esm({
 // lib/agent-cli/vtx.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { spawn } from "node:child_process";
+import { hostname } from "node:os";
 
 // lib/agent-core/config.ts
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
@@ -14448,6 +14768,33 @@ var VtxAgentClient = class _VtxAgentClient {
   getLlmConfig(profileId) {
     return this.request("/llm/config", { profileId });
   }
+  registerInsightConnector(profileId, payload) {
+    return this.request("/insights/connectors/register", {
+      method: "POST",
+      profileId,
+      body: payload
+    });
+  }
+  claimInsightConnectorJob(profileId, connectorId, deviceId) {
+    return this.request(
+      `/insights/connectors/${encodeURIComponent(connectorId)}/jobs:claim`,
+      { method: "POST", profileId, body: { device_id: deviceId } }
+    );
+  }
+  completeInsightConnectorJob(profileId, connectorId, jobId, deviceId, payload) {
+    const params = new URLSearchParams({ device_id: deviceId });
+    return this.request(
+      `/insights/connectors/${encodeURIComponent(connectorId)}/jobs/${encodeURIComponent(jobId)}:complete?${params}`,
+      { method: "POST", profileId, body: payload }
+    );
+  }
+  heartbeatInsightConnectorJob(profileId, connectorId, jobId, deviceId, claimToken) {
+    const params = new URLSearchParams({ device_id: deviceId });
+    return this.request(
+      `/insights/connectors/${encodeURIComponent(connectorId)}/jobs/${encodeURIComponent(jobId)}:heartbeat?${params}`,
+      { method: "POST", profileId, body: { claim_token: claimToken } }
+    );
+  }
   heartbeatRuntime(profileId, payload, leaseToken) {
     return this.request("/trading/ai/runtime/heartbeat", {
       method: "POST",
@@ -14710,7 +15057,8 @@ async function startHeadlessRuntime(options) {
     session_id: runtimeSessionId,
     device_id: deviceId,
     mode: "trader",
-    force_takeover: Boolean(options.forceTakeover)
+    force_takeover: Boolean(options.forceTakeover),
+    takeover_initiator: options.forceTakeover ? "agent_forced" : void 0
   });
   if (startResponse.status === "takeover_required") {
     throw new HeadlessRuntimeTakeoverRequiredError(startResponse);
@@ -14805,6 +15153,277 @@ async function startHeadlessRuntime(options) {
   }
 }
 
+// lib/agent-core/insights-local-connector.ts
+var delay = (milliseconds, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(signal?.reason ?? new Error("Local Insights connector stopped"));
+    return;
+  }
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(signal?.reason ?? new Error("Local Insights connector stopped"));
+  };
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, milliseconds);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+function normalizeLocalModelBaseUrl(value) {
+  const raw = String(value || "http://127.0.0.1:1234/v1").trim().replace(/\/+$/, "");
+  const parsed = new URL(raw);
+  const hostname2 = parsed.hostname.toLowerCase();
+  if (!["localhost", "127.0.0.1", "::1", "[::1]"].includes(hostname2)) {
+    throw new Error("The Local Insights connector only accepts a loopback model URL");
+  }
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new Error("The local model URL must use HTTP or HTTPS");
+  }
+  if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+    throw new Error("The local model URL cannot contain credentials, a query, or a fragment");
+  }
+  return raw;
+}
+function authHeaders(apiKey) {
+  const value = String(apiKey || "").trim();
+  return value ? { Authorization: `Bearer ${value}` } : {};
+}
+function isRetryableVtxTransportError(error) {
+  return !(error instanceof AgentClientError) || error.status === 429 || error.status >= 500;
+}
+async function withVtxTransportRetry(operation, retryMilliseconds, signal) {
+  while (true) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isRetryableVtxTransportError(error)) throw error;
+      await delay(retryMilliseconds, signal);
+    }
+  }
+}
+function modelArray(payload) {
+  if (Array.isArray(payload)) return payload.filter((item) => Boolean(item && typeof item === "object"));
+  if (!payload || typeof payload !== "object") return [];
+  const record = payload;
+  for (const key of ["data", "models"]) {
+    if (Array.isArray(record[key])) {
+      return record[key].filter((item) => Boolean(item && typeof item === "object"));
+    }
+  }
+  return [];
+}
+function positiveInteger(value) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function connectorModels(payload) {
+  const models = modelArray(payload).flatMap((item) => {
+    const modelType = String(item.type || "").trim().toLowerCase();
+    if (modelType && !["llm", "vlm"].includes(modelType)) return [];
+    const modelState = String(item.state || "").trim().toLowerCase();
+    if (modelState && modelState !== "loaded") return [];
+    const id2 = String(item.id || item.model || item.key || "").trim();
+    if (!id2) return [];
+    const loadedInstances = Array.isArray(item.loaded_instances) ? item.loaded_instances.filter((instance) => Boolean(instance && typeof instance === "object")) : [];
+    const loadedConfig = loadedInstances[0]?.config;
+    const loadedContextLength = loadedConfig && typeof loadedConfig === "object" ? loadedConfig.context_length : null;
+    return [{
+      id: id2,
+      name: String(item.display_name || item.name || item.id || id2).trim() || id2,
+      context_length: positiveInteger(
+        item.loaded_context_length ?? loadedContextLength ?? item.max_context_length ?? item.context_length ?? item.context_window
+      )
+    }];
+  });
+  return [...new Map(models.map((model) => [model.id, model])).values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+async function fetchJson(fetchImpl, url, init, failureMessage) {
+  const response = await fetchImpl(url, { ...init, redirect: "error" });
+  if (!response.ok) throw new Error(`${failureMessage} (${response.status})`);
+  const payload = await response.json();
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error(`${failureMessage} (invalid JSON response)`);
+  }
+  return payload;
+}
+async function discoverLocalConnectorModels(options = {}) {
+  const baseUrl = normalizeLocalModelBaseUrl(options.baseUrl);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const headers = { Accept: "application/json", ...authHeaders(options.apiKey) };
+  const parsed = new URL(baseUrl);
+  const candidates = [
+    `${parsed.origin}/api/v0/models`,
+    `${baseUrl}/models`
+  ];
+  let lastError = null;
+  for (const url of candidates) {
+    try {
+      const payload = await fetchJson(fetchImpl, url, { headers }, "Unable to list local models");
+      const models = connectorModels(payload);
+      if (models.length > 0) return models;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("The local model server returned no models");
+}
+async function completeFailedJob(options, connector, job, errorClass) {
+  try {
+    await withVtxTransportRetry(
+      () => options.client.completeInsightConnectorJob(
+        options.profileId,
+        connector.id,
+        job.id,
+        options.deviceId,
+        {
+          claim_token: job.claim_token,
+          status: "failed",
+          error_class: errorClass.slice(0, 64)
+        }
+      ),
+      connector.poll_interval_milliseconds,
+      options.signal
+    );
+    return true;
+  } catch (error) {
+    if (error instanceof AgentClientError && error.status === 409) return false;
+    throw error;
+  }
+}
+async function runJob(options, connector, job, baseUrl, fetchImpl) {
+  const requestController = new AbortController();
+  const abortFromParent = () => requestController.abort(
+    options.signal?.reason ?? new Error("Local Insights connector stopped")
+  );
+  options.signal?.addEventListener("abort", abortFromParent, { once: true });
+  let heartbeatError = null;
+  let finished = false;
+  const heartbeatInterval = options.heartbeatIntervalMilliseconds ?? Math.max(1e3, connector.poll_interval_milliseconds * 10);
+  const heartbeatTask = (async () => {
+    try {
+      while (!finished && !requestController.signal.aborted) {
+        await delay(heartbeatInterval, requestController.signal);
+        if (finished) return;
+        try {
+          await options.client.heartbeatInsightConnectorJob(
+            options.profileId,
+            connector.id,
+            job.id,
+            options.deviceId,
+            job.claim_token
+          );
+        } catch (error) {
+          if (isRetryableVtxTransportError(error)) continue;
+          throw error;
+        }
+      }
+    } catch (error) {
+      if (!finished && !options.signal?.aborted) {
+        heartbeatError = error;
+        requestController.abort(error);
+      }
+    }
+  })();
+  let response;
+  try {
+    try {
+      response = await fetchJson(fetchImpl, `${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          ...authHeaders(options.apiKey)
+        },
+        body: JSON.stringify({ ...job.request, model: job.model_id, stream: false }),
+        signal: requestController.signal
+      }, "The local model request failed");
+    } catch (error) {
+      if (options.signal?.aborted) throw error;
+      if (heartbeatError instanceof AgentClientError && heartbeatError.status === 409) {
+        return false;
+      }
+      if (heartbeatError) throw heartbeatError;
+      const completed = await completeFailedJob(
+        options,
+        connector,
+        job,
+        "local_model_request_failed"
+      );
+      return completed;
+    }
+    if (heartbeatError instanceof AgentClientError && heartbeatError.status === 409) {
+      return false;
+    }
+    if (heartbeatError) throw heartbeatError;
+    try {
+      await withVtxTransportRetry(
+        () => options.client.completeInsightConnectorJob(
+          options.profileId,
+          connector.id,
+          job.id,
+          options.deviceId,
+          {
+            claim_token: job.claim_token,
+            status: "succeeded",
+            response
+          }
+        ),
+        connector.poll_interval_milliseconds,
+        options.signal
+      );
+      return true;
+    } catch (error) {
+      if (error instanceof AgentClientError && error.status === 409) return false;
+      throw error;
+    }
+  } finally {
+    finished = true;
+    requestController.abort(new Error("Local model job finished"));
+    options.signal?.removeEventListener("abort", abortFromParent);
+    await heartbeatTask;
+  }
+}
+async function runLocalInsightsConnector(options) {
+  const baseUrl = normalizeLocalModelBaseUrl(options.baseUrl);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const models = await discoverLocalConnectorModels({
+    baseUrl,
+    apiKey: options.apiKey,
+    fetchImpl
+  });
+  const connector = await options.client.registerInsightConnector(options.profileId, {
+    device_id: options.deviceId,
+    display_name: options.displayName,
+    models
+  });
+  options.onRegistered?.(connector);
+  let jobsCompleted = 0;
+  do {
+    let job;
+    try {
+      job = await options.client.claimInsightConnectorJob(
+        options.profileId,
+        connector.id,
+        options.deviceId
+      );
+    } catch (error) {
+      if (!isRetryableVtxTransportError(error)) throw error;
+      await delay(connector.poll_interval_milliseconds, options.signal);
+      continue;
+    }
+    if (job) {
+      if (await runJob(options, connector, job, baseUrl, fetchImpl)) {
+        jobsCompleted += 1;
+      }
+      if (options.once) break;
+      continue;
+    }
+    if (options.once) break;
+    await delay(connector.poll_interval_milliseconds, options.signal);
+  } while (!options.signal?.aborted);
+  return { connector, jobsCompleted };
+}
+
 // lib/agent-cli/vtx.ts
 init_hyperliquid_market_symbol();
 var WRITABLE_SECRET_FIELDS = /* @__PURE__ */ new Set([
@@ -14852,7 +15471,7 @@ function redactCliOutput(value) {
   }
   return result2;
 }
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var delay2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function openBrowser(url) {
   const platform = process.platform;
   const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
@@ -15084,11 +15703,11 @@ Waiting for approval...
     if (polled.status === "denied") {
       throw new Error(polled.error || "CLI login was denied");
     }
-    await delay(Math.max(1, Number(started.interval || 2)) * 1e3);
+    await delay2(Math.max(1, Number(started.interval || 2)) * 1e3);
   }
   throw new Error("Timed out waiting for CLI login approval");
 }
-async function runVtxCli(argv, env = process.env) {
+async function runVtxCli(argv, env = process.env, onProgress = () => void 0) {
   try {
     const parsed = parseFlags(argv);
     const [group, command, ...args] = parsed.rest;
@@ -15243,7 +15862,8 @@ async function runVtxCli(argv, env = process.env) {
         session_id: runtimeSessionId,
         device_id: deviceId,
         mode: "trader",
-        force_takeover: args.includes("--force-takeover")
+        force_takeover: args.includes("--force-takeover"),
+        takeover_initiator: args.includes("--force-takeover") ? "agent_forced" : void 0
       });
       if (objectOrNull3(response)?.status === "takeover_required") {
         await clearRuntimeState(config.statePath);
@@ -15329,6 +15949,52 @@ async function runVtxCli(argv, env = process.env) {
     if (group === "ai" && command === "config") {
       return { exitCode: 0, stdout: render(await client.getLlmConfig(parsed.profileId ?? config.activeProfileId), json), stderr: "" };
     }
+    if (group === "insights" && command === "connect") {
+      const profileId = requireProfileId(parsed.profileId, config.activeProfileId);
+      const hostLabel = hostname().replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 96) || "local-device";
+      const deviceId = optionalValue(args, "--device-id") || config.runtimeDeviceId || `insights-${hostLabel}`;
+      const displayName = optionalValue(args, "--name") || `LM Studio on ${hostLabel}`;
+      const apiKeyEnvironment = optionalValue(args, "--api-key-env") || "LM_STUDIO_API_KEY";
+      const apiKey = String(env[apiKeyEnvironment] || "").trim() || null;
+      const abortController = new AbortController();
+      const stop = () => abortController.abort(new Error("Local Insights connector stopped"));
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+      try {
+        const result2 = await runLocalInsightsConnector({
+          client,
+          profileId,
+          deviceId,
+          displayName,
+          baseUrl: optionalValue(args, "--base-url") || void 0,
+          apiKey,
+          once: args.includes("--once"),
+          signal: abortController.signal,
+          onRegistered: (connector) => onProgress(
+            `Local Insights connector online: ${connector.display_name} (${connector.models.length} models)
+`
+          )
+        });
+        return {
+          exitCode: 0,
+          stdout: render({
+            status: "stopped",
+            connector_id: result2.connector.id,
+            models: result2.connector.models.map((model) => model.id),
+            jobs_completed: result2.jobsCompleted
+          }, json),
+          stderr: ""
+        };
+      } catch (error) {
+        if (abortController.signal.aborted) {
+          return { exitCode: 0, stdout: render({ status: "stopped" }, json), stderr: "" };
+        }
+        throw error;
+      } finally {
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+      }
+    }
     throw new Error(`Unsupported command: ${[group, command].filter(Boolean).join(" ") || "(none)"}`);
   } catch (error) {
     const message = error instanceof AgentClientError ? error.message : error instanceof HeadlessRuntimeTakeoverRequiredError ? error.message : error instanceof Error ? error.message : "Unknown CLI error";
@@ -15338,7 +16004,11 @@ async function runVtxCli(argv, env = process.env) {
 }
 
 // bin/vtx.ts
-var result = await runVtxCli(process.argv.slice(2));
+var result = await runVtxCli(
+  process.argv.slice(2),
+  process.env,
+  (message) => process.stderr.write(message)
+);
 if (result.stdout) {
   process.stdout.write(result.stdout);
 }

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@vtxmacro/cli",
-  "version": "0.1.0",
+  "version": "2026.6.22",
   "description": "VTX Macro CLI and MCP server for agent-token automation.",
   "type": "module",
   "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DataDoesYou/VTX-Macro.git"
+  },
   "private": false,
   "bin": {
     "vtx": "bin/vtx.js",