opentradex 0.1.3 → 0.1.4

package/src/index.mjs

@@ -6,10 +6,14 @@ import process from "node:process";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import {
+  CHANNEL_OPTIONS,
+  DASHBOARD_SURFACE_OPTIONS,
   INTEGRATION_OPTIONS,
+  MCP_TRANSPORT_OPTIONS,
   MARKET_OPTIONS,
   PACKAGE_MANAGER_OPTIONS,
   RUNTIME_OPTIONS,
+  TRADINGVIEW_CONNECTOR_OPTIONS,
   formatOptionLines,
   getOptionById,
   keepKnownIds,
@@ -49,6 +53,8 @@ const DEFAULT_ENV = {
   OPENTRADEX_ENABLED_MARKETS: "kalshi",
   OPENTRADEX_ENABLED_INTEGRATIONS: "apify,rss",
   OPENTRADEX_LIVE_EXECUTION_MARKET: "kalshi",
+  OPENTRADEX_DASHBOARD_SURFACE: "chat",
+  OPENTRADEX_CHANNELS: "command,markets,feeds,risk,execution",
   KALSHI_API_KEY_ID: "",
   KALSHI_PRIVATE_KEY_PATH: "",
   KALSHI_USE_DEMO: "true",
@@ -58,6 +64,12 @@ const DEFAULT_ENV = {
   TRADINGVIEW_USERNAME: "",
   TRADINGVIEW_PASSWORD: "",
   TRADINGVIEW_WATCHLIST: "SPY,QQQ,BTCUSD,NQ1!",
+  TRADINGVIEW_CONNECTOR_MODE: "watchlist",
+  TRADINGVIEW_MCP_ENABLED: "false",
+  TRADINGVIEW_MCP_TRANSPORT: "stdio",
+  TRADINGVIEW_MCP_COMMAND: "",
+  TRADINGVIEW_MCP_ARGS: "",
+  TRADINGVIEW_MCP_URL: "",
   ROBINHOOD_USERNAME: "",
   ROBINHOOD_PASSWORD: "",
   ROBINHOOD_MFA_CODE: "",
@@ -111,6 +123,11 @@ export function writeWorkspaceProfile(workspace, profile) {
     primaryMarket: profile.primaryMarket,
     enabledMarkets: uniqueIds(profile.enabledMarkets),
     integrations: uniqueIds(profile.integrations),
+    dashboardSurface: profile.dashboardSurface,
+    channels: uniqueIds(profile.channels),
+    tradingviewConnectorMode: profile.tradingviewConnectorMode,
+    tradingviewMcpEnabled: Boolean(profile.tradingviewMcpEnabled),
+    tradingviewMcpTransport: profile.tradingviewMcpTransport,
     bankroll: Number(profile.bankroll).toFixed(2),
     interval: Number(profile.interval),
     installDeps: Boolean(profile.installDeps),
@@ -179,6 +196,8 @@ export function writeEnvFile(workspace, overrides = {}) {
         "OPENTRADEX_ENABLED_MARKETS",
         "OPENTRADEX_ENABLED_INTEGRATIONS",
         "OPENTRADEX_LIVE_EXECUTION_MARKET",
+        "OPENTRADEX_DASHBOARD_SURFACE",
+        "OPENTRADEX_CHANNELS",
         "NEWS_PROVIDER",
       ],
     },
@@ -214,6 +233,12 @@ export function writeEnvFile(workspace, overrides = {}) {
         "TRADINGVIEW_USERNAME",
         "TRADINGVIEW_PASSWORD",
         "TRADINGVIEW_WATCHLIST",
+        "TRADINGVIEW_CONNECTOR_MODE",
+        "TRADINGVIEW_MCP_ENABLED",
+        "TRADINGVIEW_MCP_TRANSPORT",
+        "TRADINGVIEW_MCP_COMMAND",
+        "TRADINGVIEW_MCP_ARGS",
+        "TRADINGVIEW_MCP_URL",
       ],
     },
     {
@@ -293,6 +318,11 @@ export function collectDoctor(workspaceArg) {
   const runtime = config.runtime || env.OPENTRADEX_RUNTIME || "claude-code";
   const packageManager = config.packageManager || env.OPENTRADEX_PACKAGE_MANAGER || "npm";
   const primaryMarket = config.primaryMarket || env.OPENTRADEX_PRIMARY_MARKET || "kalshi";
+  const dashboardSurface = config.dashboardSurface || env.OPENTRADEX_DASHBOARD_SURFACE || DEFAULT_ENV.OPENTRADEX_DASHBOARD_SURFACE;
+  const channels = keepKnownIds(
+    CHANNEL_OPTIONS,
+    config.channels?.length ? config.channels : env.OPENTRADEX_CHANNELS || DEFAULT_ENV.OPENTRADEX_CHANNELS
+  );
   const enabledMarkets = keepKnownIds(
     MARKET_OPTIONS,
     config.enabledMarkets?.length ? config.enabledMarkets : env.OPENTRADEX_ENABLED_MARKETS || primaryMarket
@@ -301,6 +331,16 @@ export function collectDoctor(workspaceArg) {
     INTEGRATION_OPTIONS,
     config.integrations?.length ? config.integrations : env.OPENTRADEX_ENABLED_INTEGRATIONS || "apify,rss"
   );
+  const tradingviewConnectorMode =
+    String(config.tradingviewConnectorMode || env.TRADINGVIEW_CONNECTOR_MODE || DEFAULT_ENV.TRADINGVIEW_CONNECTOR_MODE).toLowerCase() === "mcp"
+      ? "mcp"
+      : "watchlist";
+  const tradingviewMcpEnabled =
+    String(config.tradingviewMcpEnabled ?? env.TRADINGVIEW_MCP_ENABLED ?? DEFAULT_ENV.TRADINGVIEW_MCP_ENABLED).toLowerCase() === "true";
+  const tradingviewMcpTransport =
+    String(config.tradingviewMcpTransport || env.TRADINGVIEW_MCP_TRANSPORT || DEFAULT_ENV.TRADINGVIEW_MCP_TRANSPORT).toLowerCase() === "http"
+      ? "http"
+      : "stdio";
 
   const checks = [
     check("Node.js", commandWorks("node", ["-v"]), "Install Node.js 22+."),
@@ -354,6 +394,17 @@ export function collectDoctor(workspaceArg) {
         "Add TRADINGVIEW_WATCHLIST so the agent has symbols to monitor."
       )
     );
+    if (tradingviewConnectorMode === "mcp" || tradingviewMcpEnabled) {
+      checks.push(
+        check(
+          "TradingView MCP",
+          tradingviewMcpTransport === "http" ? Boolean(env.TRADINGVIEW_MCP_URL) : Boolean(env.TRADINGVIEW_MCP_COMMAND),
+          tradingviewMcpTransport === "http"
+            ? "Set TRADINGVIEW_MCP_URL to your TradingView MCP endpoint."
+            : "Set TRADINGVIEW_MCP_COMMAND and optional TRADINGVIEW_MCP_ARGS for your local TradingView MCP server."
+        )
+      );
+    }
   }
 
   if (integrations.includes("apify") || integrations.includes("twitter") || integrations.includes("tiktok")) {
@@ -365,13 +416,28 @@ export function collectDoctor(workspaceArg) {
     profile: {
       runtime,
       packageManager,
+      dashboardSurface,
+      channels,
       mode: liveTrading ? "live" : config.mode || env.OPENTRADEX_EXECUTION_MODE || "paper",
       primaryMarket,
       enabledMarkets,
       integrations,
+      tradingviewConnectorMode,
+      tradingviewMcpEnabled,
+      tradingviewMcpTransport,
     },
     checks,
-    notes: buildDoctorNotes({ runtime, primaryMarket, enabledMarkets, liveTrading }),
+    notes: buildDoctorNotes({
+      runtime,
+      primaryMarket,
+      enabledMarkets,
+      liveTrading,
+      dashboardSurface,
+      channels,
+      tradingviewConnectorMode,
+      tradingviewMcpEnabled,
+      tradingviewMcpTransport,
+    }),
   };
 }
 
@@ -384,6 +450,15 @@ export async function onboard(options = {}) {
   try {
     printWelcomeBanner();
 
+    if (interactive) {
+      printSecurityNotice();
+      const accepted = await confirm(rl, "I understand this is powerful and inherently risky. Continue?", false);
+      if (!accepted) {
+        return null;
+      }
+      printSection("1/7", "workspace", "Choose where OpenTradex should create or reuse the local harness.");
+    }
+
     const workspace = path.resolve(
       options.workspace ||
         (interactive
@@ -396,11 +471,20 @@ export async function onboard(options = {}) {
       ...saved,
       ...readWorkspaceProfile(workspace),
     });
+    const workspaceExists = existsSync(path.join(workspace, "main.py"));
+
+    if (interactive && workspaceExists && !(await confirm(rl, `Reuse existing workspace at ${workspace}`, true))) {
+      return null;
+    }
+
+    if (interactive) {
+      printSection("2/7", "runtime", "Pick the operator runtime and package flow for this machine.");
+    }
 
     const runtime = interactive
       ? await chooseOption(
           rl,
-          "Choose your agent runtime",
+          "Select operator runtime",
           RUNTIME_OPTIONS,
           options.llm || options.runtime || savedProfile.runtime || currentEnv.OPENTRADEX_RUNTIME || "claude-code"
         )
@@ -409,7 +493,7 @@ export async function onboard(options = {}) {
     const packageManager = interactive
       ? await chooseOption(
           rl,
-          "Choose your package manager",
+          "Select package manager",
           PACKAGE_MANAGER_OPTIONS,
           options.packageManager || savedProfile.packageManager || currentEnv.OPENTRADEX_PACKAGE_MANAGER || "npm"
         )
@@ -419,10 +503,14 @@ export async function onboard(options = {}) {
           "npm"
         ).id;
 
+    if (interactive) {
+      printSection("3/7", "market rails", "Pick the execution rail first, then enable any additional discovery or watchlist rails.");
+    }
+
     const primaryMarket = interactive
       ? await chooseOption(
           rl,
-          "Choose your primary market rail",
+          "Select primary market",
           MARKET_OPTIONS,
           options.primaryMarket || options.market || savedProfile.primaryMarket || currentEnv.OPENTRADEX_PRIMARY_MARKET || "kalshi"
         )
@@ -442,7 +530,7 @@ export async function onboard(options = {}) {
     const extraMarkets = interactive
       ? await chooseMany(
           rl,
-          "Enable extra market rails",
+          "Enable additional market rails",
           MARKET_OPTIONS.filter((item) => item.id !== primaryMarket),
           defaultMarkets
         )
@@ -450,15 +538,53 @@ export async function onboard(options = {}) {
 
     const enabledMarkets = uniqueIds([primaryMarket, ...extraMarkets]);
 
+    const availableChannels = enabledMarkets.includes("tradingview")
+      ? CHANNEL_OPTIONS
+      : CHANNEL_OPTIONS.filter((item) => item.id !== "tradingview");
+
+    if (interactive) {
+      printSection("4/7", "operator channels", "Choose the dashboard surface and the messaging lanes your operator cockpit should keep online.");
+    }
+
+    const dashboardSurface = interactive
+      ? await chooseOption(
+          rl,
+          "Select dashboard surface",
+          DASHBOARD_SURFACE_OPTIONS,
+          options.dashboardSurface || savedProfile.dashboardSurface || currentEnv.OPENTRADEX_DASHBOARD_SURFACE || DEFAULT_ENV.OPENTRADEX_DASHBOARD_SURFACE
+        )
+      : getOptionById(
+          DASHBOARD_SURFACE_OPTIONS,
+          options.dashboardSurface || savedProfile.dashboardSurface || currentEnv.OPENTRADEX_DASHBOARD_SURFACE,
+          DEFAULT_ENV.OPENTRADEX_DASHBOARD_SURFACE
+        ).id;
+
+    const defaultChannels = keepKnownIds(
+      availableChannels,
+      options.channels || savedProfile.channels || currentEnv.OPENTRADEX_CHANNELS || DEFAULT_ENV.OPENTRADEX_CHANNELS
+    );
+
+    const channels = interactive
+      ? await chooseMany(rl, "Enable operator channels", availableChannels, defaultChannels)
+      : defaultChannels;
+
     const defaultIntegrations = keepKnownIds(
       INTEGRATION_OPTIONS,
       options.integrations || savedProfile.integrations || currentEnv.OPENTRADEX_ENABLED_INTEGRATIONS || "apify,rss"
     );
 
+    if (interactive) {
+      printSection("5/7", "data feeds", "Enable only the context feeds you want. Optional integrations stay optional.");
+    }
+
     const integrations = interactive
       ? await chooseMany(rl, "Enable optional data integrations", INTEGRATION_OPTIONS, defaultIntegrations)
       : defaultIntegrations;
 
+    if (interactive) {
+      printSection("6/7", "guardrails", "Set trading mode, bankroll, and loop interval before anything gets close to execution.");
+    }
+
     const mode =
       options.live ? "live" : options.paper ? "paper" : interactive ? await chooseMode(rl, savedProfile.mode || "paper") : savedProfile.mode || "paper";
 
@@ -472,8 +598,9 @@ export async function onboard(options = {}) {
         ? await ask(rl, "Loop interval in seconds", String(savedProfile.interval || DEFAULT_ENV.CYCLE_INTERVAL))
         : savedProfile.interval || DEFAULT_ENV.CYCLE_INTERVAL);
 
-    const installDeps =
-      options.install ?? (options.skipInstall ? false : interactive ? await confirm(rl, "Install Python and web dependencies now", true) : true);
+    if (interactive) {
+      printSection("7/7", "credentials", "Enter only the keys and watchlists you need. Blank values stay blank unless you enable live Kalshi.");
+    }
 
     const apifyToken =
       options.apifyToken ??
@@ -519,6 +646,80 @@ export async function onboard(options = {}) {
             : currentEnv.TRADINGVIEW_WATCHLIST || DEFAULT_ENV.TRADINGVIEW_WATCHLIST)
         : currentEnv.TRADINGVIEW_WATCHLIST || DEFAULT_ENV.TRADINGVIEW_WATCHLIST;
 
+    const tradingviewConnectorMode =
+      enabledMarkets.includes("tradingview")
+        ? interactive
+          ? await chooseOption(
+              rl,
+              "TradingView connector mode",
+              TRADINGVIEW_CONNECTOR_OPTIONS,
+              options.tradingviewConnectorMode ||
+                savedProfile.tradingviewConnectorMode ||
+                currentEnv.TRADINGVIEW_CONNECTOR_MODE ||
+                DEFAULT_ENV.TRADINGVIEW_CONNECTOR_MODE
+            )
+          : getOptionById(
+              TRADINGVIEW_CONNECTOR_OPTIONS,
+              options.tradingviewConnectorMode ||
+                savedProfile.tradingviewConnectorMode ||
+                currentEnv.TRADINGVIEW_CONNECTOR_MODE,
+              DEFAULT_ENV.TRADINGVIEW_CONNECTOR_MODE
+            ).id
+        : currentEnv.TRADINGVIEW_CONNECTOR_MODE || DEFAULT_ENV.TRADINGVIEW_CONNECTOR_MODE;
+
+    const tradingviewMcpTransport =
+      enabledMarkets.includes("tradingview") && tradingviewConnectorMode === "mcp"
+        ? interactive
+          ? await chooseOption(
+              rl,
+              "TradingView MCP transport",
+              MCP_TRANSPORT_OPTIONS,
+              options.tradingviewMcpTransport ||
+                savedProfile.tradingviewMcpTransport ||
+                currentEnv.TRADINGVIEW_MCP_TRANSPORT ||
+                DEFAULT_ENV.TRADINGVIEW_MCP_TRANSPORT
+            )
+          : getOptionById(
+              MCP_TRANSPORT_OPTIONS,
+              options.tradingviewMcpTransport ||
+                savedProfile.tradingviewMcpTransport ||
+                currentEnv.TRADINGVIEW_MCP_TRANSPORT,
+              DEFAULT_ENV.TRADINGVIEW_MCP_TRANSPORT
+            ).id
+        : currentEnv.TRADINGVIEW_MCP_TRANSPORT || DEFAULT_ENV.TRADINGVIEW_MCP_TRANSPORT;
+
+    const tradingviewMcpEnabled =
+      enabledMarkets.includes("tradingview") && tradingviewConnectorMode === "mcp"
+        ? options.tradingviewMcpEnabled ??
+          (interactive
+            ? await confirm(rl, "Enable TradingView MCP for this workspace", true)
+            : String(savedProfile.tradingviewMcpEnabled ?? currentEnv.TRADINGVIEW_MCP_ENABLED ?? "true").toLowerCase() === "true")
+        : false;
+
+    const tradingviewMcpCommand =
+      tradingviewMcpEnabled && tradingviewMcpTransport === "stdio"
+        ? options.tradingviewMcpCommand ??
+          (interactive
+            ? await ask(rl, "TradingView MCP command", currentEnv.TRADINGVIEW_MCP_COMMAND || "")
+            : currentEnv.TRADINGVIEW_MCP_COMMAND || "")
+        : currentEnv.TRADINGVIEW_MCP_COMMAND || "";
+
+    const tradingviewMcpArgs =
+      tradingviewMcpEnabled && tradingviewMcpTransport === "stdio"
+        ? options.tradingviewMcpArgs ??
+          (interactive
+            ? await ask(rl, "TradingView MCP args (optional)", currentEnv.TRADINGVIEW_MCP_ARGS || "")
+            : currentEnv.TRADINGVIEW_MCP_ARGS || "")
+        : currentEnv.TRADINGVIEW_MCP_ARGS || "";
+
+    const tradingviewMcpUrl =
+      tradingviewMcpEnabled && tradingviewMcpTransport === "http"
+        ? options.tradingviewMcpUrl ??
+          (interactive
+            ? await ask(rl, "TradingView MCP URL", currentEnv.TRADINGVIEW_MCP_URL || "")
+            : currentEnv.TRADINGVIEW_MCP_URL || "")
+        : currentEnv.TRADINGVIEW_MCP_URL || "";
+
     const robinhoodUsername =
       enabledMarkets.includes("robinhood")
         ? options.robinhoodUsername ??
@@ -543,16 +744,29 @@ export async function onboard(options = {}) {
             : currentEnv.GROWW_ACCESS_TOKEN || "")
         : currentEnv.GROWW_ACCESS_TOKEN || "";
 
-    const workspaceExists = existsSync(path.join(workspace, "main.py"));
-    if (interactive && workspaceExists && !(await confirm(rl, `Reuse existing workspace at ${workspace}`, true))) {
-      throw new Error("Onboarding cancelled.");
-    }
-
     if (mode === "live" && primaryMarket !== "kalshi") {
       notes.push("Live execution is currently wired through Kalshi. This workspace has been kept in paper mode while the extra rails stay enabled.");
     }
 
+    if (dashboardSurface === "chat") {
+      notes.push("Dashboard chat cockpit is enabled with operator channels for command, markets, feeds, risk, and execution.");
+    }
+
+    if (enabledMarkets.includes("tradingview") && tradingviewConnectorMode !== "mcp") {
+      notes.push("TradingView is configured in watchlist mode. Add an MCP connector later if you want richer chart and symbol context.");
+    }
+
+    if (tradingviewMcpEnabled && tradingviewMcpTransport === "stdio" && !tradingviewMcpCommand) {
+      notes.push("TradingView MCP was enabled without a command. The dashboard will show the connector as incomplete until you fill it in.");
+    }
+
+    if (tradingviewMcpEnabled && tradingviewMcpTransport === "http" && !tradingviewMcpUrl) {
+      notes.push("TradingView MCP was enabled without a URL. The dashboard will show the connector as incomplete until you fill it in.");
+    }
+
     const effectiveMode = mode === "live" && primaryMarket === "kalshi" ? "live" : "paper";
+    const installDeps =
+      options.install ?? (options.skipInstall ? false : interactive ? await confirm(rl, "Install Python and web dependencies now", true) : true);
 
     ensureWorkspaceFiles(workspace, { force: Boolean(options.force) });
 
@@ -564,6 +778,8 @@ export async function onboard(options = {}) {
       OPENTRADEX_ENABLED_MARKETS: enabledMarkets.join(","),
       OPENTRADEX_ENABLED_INTEGRATIONS: integrations.join(","),
       OPENTRADEX_LIVE_EXECUTION_MARKET: "kalshi",
+      OPENTRADEX_DASHBOARD_SURFACE: dashboardSurface,
+      OPENTRADEX_CHANNELS: channels.join(","),
       NEWS_PROVIDER: integrations.join(","),
       APIFY_API_TOKEN: apifyToken,
       BANKROLL: Number(bankroll).toFixed(2),
@@ -575,6 +791,12 @@ export async function onboard(options = {}) {
       POLYMARKET_WALLET_ADDRESS: polymarketWalletAddress,
       POLYMARKET_PRIVATE_KEY: polymarketPrivateKey,
       TRADINGVIEW_WATCHLIST: tradingviewWatchlist,
+      TRADINGVIEW_CONNECTOR_MODE: tradingviewConnectorMode,
+      TRADINGVIEW_MCP_ENABLED: tradingviewMcpEnabled ? "true" : "false",
+      TRADINGVIEW_MCP_TRANSPORT: tradingviewMcpTransport,
+      TRADINGVIEW_MCP_COMMAND: tradingviewMcpCommand,
+      TRADINGVIEW_MCP_ARGS: tradingviewMcpArgs,
+      TRADINGVIEW_MCP_URL: tradingviewMcpUrl,
       ROBINHOOD_USERNAME: robinhoodUsername,
       ROBINHOOD_PASSWORD: robinhoodPassword,
       GROWW_ACCESS_TOKEN: growwAccessToken,
@@ -588,6 +810,11 @@ export async function onboard(options = {}) {
       primaryMarket,
       enabledMarkets,
       integrations,
+      dashboardSurface,
+      channels,
+      tradingviewConnectorMode,
+      tradingviewMcpEnabled,
+      tradingviewMcpTransport,
       bankroll,
       interval,
       installDeps,
@@ -603,14 +830,25 @@ export async function onboard(options = {}) {
       primaryMarket,
       enabledMarkets,
       integrations,
+      dashboardSurface,
+      channels,
+      tradingviewConnectorMode,
+      tradingviewMcpEnabled,
+      tradingviewMcpTransport,
       bankroll: Number(bankroll).toFixed(2),
       interval: Number(interval),
       installedAt: new Date().toISOString(),
     });
 
     if (installDeps) {
+      if (interactive) {
+        printSection("BOOT", "local launch", "Installing the requested Python and dashboard dependencies.");
+      }
       await runCommand("python", ["-m", "pip", "install", "-r", "requirements.txt"], { cwd: workspace });
       await runPackageInstall(packageManager, path.join(workspace, "web"));
+      notes.push("Local dependencies were installed for Python and the dashboard.");
+    } else {
+      notes.push("Dependency install was skipped. You can still boot later with `pip install -r requirements.txt` and a dashboard package install.");
     }
 
     return {
@@ -671,6 +909,8 @@ export async function runDashboard(options = {}) {
     await runPackageInstall(packageManager, webDir);
   }
 
+  printDashboardBoot({ workspace, packageManager, profile });
+
   await runPackageScript(packageManager, "dev", webDir);
 }
 
@@ -680,6 +920,8 @@ export function formatDoctorReport(report) {
     `workspace: ${report.workspace}`,
     `runtime: ${report.profile.runtime}`,
     `package manager: ${report.profile.packageManager}`,
+    `dashboard: ${report.profile.dashboardSurface}`,
+    `channels: ${labelsForIds(CHANNEL_OPTIONS, report.profile.channels).join(", ") || "none"}`,
     `mode: ${report.profile.mode}`,
     `primary market: ${labelsForIds(MARKET_OPTIONS, [report.profile.primaryMarket]).join(", ")}`,
     `market rails: ${labelsForIds(MARKET_OPTIONS, report.profile.enabledMarkets).join(", ") || "none"}`,
@@ -711,12 +953,18 @@ export function formatProviderMatrix() {
     "Agent runtimes:",
     ...formatOptionLines(RUNTIME_OPTIONS).map((line) => `  ${line}`),
     "",
+    "Dashboard surfaces:",
+    ...formatOptionLines(DASHBOARD_SURFACE_OPTIONS).map((line) => `  ${line}`),
+    "",
     "Market rails:",
     ...formatOptionLines(MARKET_OPTIONS).map((line) => `  ${line}`),
     "",
     "Data integrations:",
     ...formatOptionLines(INTEGRATION_OPTIONS).map((line) => `  ${line}`),
     "",
+    "Operator channels:",
+    ...formatOptionLines(CHANNEL_OPTIONS).map((line) => `  ${line}`),
+    "",
     "Package managers:",
     ...formatOptionLines(PACKAGE_MANAGER_OPTIONS).map((line) => `  ${line}`),
   ];
@@ -817,12 +1065,12 @@ async function chooseMode(rl, fallback) {
 
 async function chooseOption(rl, label, options, fallbackId) {
   const fallback = getOptionById(options, fallbackId, options[0].id);
-  console.log(`${label}:`);
+  printOptionList(label);
   for (const line of formatOptionLines(options)) {
     console.log(`  ${line}`);
   }
 
-  const answer = (await rl.question(`Enter number or id [${fallback.id}]: `)).trim().toLowerCase();
+  const answer = (await rl.question(`  Enter number or id [${fallback.id}]: `)).trim().toLowerCase();
   if (!answer) {
     return fallback.id;
   }
@@ -837,13 +1085,13 @@ async function chooseOption(rl, label, options, fallbackId) {
 
 async function chooseMany(rl, label, options, fallbackIds = []) {
   const fallback = keepKnownIds(options, fallbackIds);
-  console.log(`${label}:`);
+  printOptionList(label);
   for (const line of formatOptionLines(options)) {
     console.log(`  ${line}`);
   }
 
   const fallbackText = fallback.join(",") || "none";
-  const answer = (await rl.question(`Enter comma-separated ids or numbers [${fallbackText}]: `)).trim().toLowerCase();
+  const answer = (await rl.question(`  Enter comma-separated ids or numbers [${fallbackText}]: `)).trim().toLowerCase();
   if (!answer) {
     return fallback;
   }
@@ -866,28 +1114,180 @@ async function chooseMany(rl, label, options, fallbackIds = []) {
 function printWelcomeBanner() {
   console.log([
     "",
-    "Welcome to OpenTradex",
-    "Our implementation. Your strategy.",
+    "  ___  ____  _____ _   _ _____ ____    _    ____  _______  __",
+    " / _ \\|  _ \\| ____| \\ | |_   _|  _ \\  / \\  |  _ \\| ____\\ \\/ /",
+    "| | | | |_) |  _| |  \\| | | | | |_) |/ _ \\ | | | |  _|  \\  / ",
+    "| |_| |  __/| |___| |\\  | | | |  _ </ ___ \\| |_| | |___ /  \\ ",
+    " \\___/|_|   |_____|_| \\_| |_| |_| \\_\\_/   \\_\\____/|_____/_/\\_\\",
+    "",
+    " OpenTradex onboarding",
+    " Our implementation. Your strategy.",
+    "",
+  ].join("\n"));
+}
+
+function printSecurityNotice() {
+  printPanel("Security", [
+    "OpenTradex can read local files, install dependencies, and route trading workflows.",
+    "Treat it like a capable local operator. Use least-privilege credentials and keep secrets out of the repo.",
+    "Do not enable live trading until your paper workflow is stable and your risk limits are set.",
+    "Live execution is currently supported on Kalshi. Other rails stay in research, discovery, watchlist, or paper mode.",
+    "",
+    "Recommended routine:",
+    "opentradex doctor",
+    "opentradex providers",
+  ]);
+}
+
+function printSection(step, title, description) {
+  console.log([
+    "",
+    `[${step}] ${title.toUpperCase()}`,
+    "-".repeat(72),
+    description,
+    "",
+  ].join("\n"));
+}
+
+function printOptionList(label) {
+  console.log([
     "",
+    label,
+    "-".repeat(72),
   ].join("\n"));
 }
 
+function printDashboardBoot({ workspace, packageManager, profile }) {
+  printPanel("Local harness", [
+    `workspace: ${workspace}`,
+    `runtime: ${profile.runtime}`,
+    `package flow: ${packageManager}`,
+    `dashboard: ${profile.dashboardSurface || DEFAULT_ENV.OPENTRADEX_DASHBOARD_SURFACE}`,
+    `primary rail: ${profile.primaryMarket}`,
+    `additional rails: ${profile.enabledMarkets.join(", ") || "none"}`,
+    `channels: ${profile.channels?.join(", ") || "none"}`,
+    "",
+    "When the dev server is ready, open the dashboard and warm boot the local harness.",
+    "Suggested local URL: http://localhost:3000/dashboard",
+  ]);
+}
+
+function printPanel(title, lines, width = 76) {
+  const innerWidth = Math.max(32, width - 4);
+  const border = `+${"-".repeat(innerWidth + 2)}+`;
+  const output = [border];
+
+  for (const line of wrapText(title, innerWidth)) {
+    output.push(`| ${padRight(line, innerWidth)} |`);
+  }
+
+  output.push(`| ${"-".repeat(innerWidth)} |`);
+
+  for (const sourceLine of lines) {
+    if (!sourceLine) {
+      output.push(`| ${" ".repeat(innerWidth)} |`);
+      continue;
+    }
+
+    for (const line of wrapText(sourceLine, innerWidth)) {
+      output.push(`| ${padRight(line, innerWidth)} |`);
+    }
+  }
+
+  output.push(border);
+  console.log(`\n${output.join("\n")}\n`);
+}
+
+function wrapText(text, width) {
+  const normalized = String(text);
+  if (normalized.length <= width) {
+    return [normalized];
+  }
+
+  const words = normalized.split(/\s+/).filter(Boolean);
+  if (words.length === 0) {
+    return [""];
+  }
+
+  const lines = [];
+  let current = "";
+
+  const flush = () => {
+    if (current) {
+      lines.push(current);
+      current = "";
+    }
+  };
+
+  for (const word of words) {
+    if (word.length > width) {
+      flush();
+      for (let index = 0; index < word.length; index += width) {
+        lines.push(word.slice(index, index + width));
+      }
+      continue;
+    }
+
+    if (!current) {
+      current = word;
+      continue;
+    }
+
+    if (`${current} ${word}`.length <= width) {
+      current = `${current} ${word}`;
+      continue;
+    }
+
+    flush();
+    current = word;
+  }
+
+  flush();
+  return lines;
+}
+
+function padRight(value, width) {
+  return String(value).padEnd(width, " ");
+}
+
 function normalizeConfig(config = {}) {
   return {
     workspace: config.workspace,
     runtime: config.runtime || config.profile?.runtime || DEFAULT_ENV.OPENTRADEX_RUNTIME,
     packageManager: config.packageManager || config.profile?.packageManager || DEFAULT_ENV.OPENTRADEX_PACKAGE_MANAGER,
+    dashboardSurface: config.dashboardSurface || config.profile?.dashboardSurface || DEFAULT_ENV.OPENTRADEX_DASHBOARD_SURFACE,
+    channels: keepKnownIds(CHANNEL_OPTIONS, config.channels || config.profile?.channels || DEFAULT_ENV.OPENTRADEX_CHANNELS),
     mode: config.mode || config.profile?.mode || DEFAULT_ENV.OPENTRADEX_EXECUTION_MODE,
     primaryMarket: config.primaryMarket || config.profile?.primaryMarket || DEFAULT_ENV.OPENTRADEX_PRIMARY_MARKET,
     enabledMarkets: keepKnownIds(MARKET_OPTIONS, config.enabledMarkets || config.profile?.enabledMarkets || DEFAULT_ENV.OPENTRADEX_ENABLED_MARKETS),
     integrations: keepKnownIds(INTEGRATION_OPTIONS, config.integrations || config.profile?.integrations || DEFAULT_ENV.OPENTRADEX_ENABLED_INTEGRATIONS),
+    tradingviewConnectorMode:
+      String(config.tradingviewConnectorMode || config.profile?.tradingviewConnectorMode || DEFAULT_ENV.TRADINGVIEW_CONNECTOR_MODE).toLowerCase() === "mcp"
+        ? "mcp"
+        : "watchlist",
+    tradingviewMcpEnabled:
+      String(config.tradingviewMcpEnabled ?? config.profile?.tradingviewMcpEnabled ?? DEFAULT_ENV.TRADINGVIEW_MCP_ENABLED).toLowerCase() === "true",
+    tradingviewMcpTransport:
+      String(config.tradingviewMcpTransport || config.profile?.tradingviewMcpTransport || DEFAULT_ENV.TRADINGVIEW_MCP_TRANSPORT).toLowerCase() === "http"
+        ? "http"
+        : "stdio",
     bankroll: config.bankroll || config.profile?.bankroll || DEFAULT_ENV.BANKROLL,
     interval: config.interval || config.profile?.interval || DEFAULT_ENV.CYCLE_INTERVAL,
     installDeps: config.installDeps ?? config.profile?.installDeps ?? false,
   };
 }
 
-function buildDoctorNotes({ runtime, primaryMarket, enabledMarkets, liveTrading }) {
+function buildDoctorNotes({
+  runtime,
+  primaryMarket,
+  enabledMarkets,
+  liveTrading,
+  dashboardSurface,
+  channels,
+  tradingviewConnectorMode,
+  tradingviewMcpEnabled,
+  tradingviewMcpTransport,
+}) {
   const notes = [];
 
   if (runtime !== "claude-code") {
@@ -906,6 +1306,20 @@ function buildDoctorNotes({ runtime, primaryMarket, enabledMarkets, liveTrading
     notes.push("TradingView, Robinhood, and Groww are configured as watchlist/profile rails so you can add credentials only when you really need them.");
   }
 
+  if (dashboardSurface === "chat") {
+    notes.push(`Dashboard chat cockpit is enabled with channels: ${channels.join(", ") || "none"}.`);
+  }
+
+  if (enabledMarkets.includes("tradingview") && tradingviewConnectorMode === "mcp") {
+    notes.push(`TradingView is set to MCP mode over ${tradingviewMcpTransport}. The dashboard will surface connector status, but Claude Code still needs the MCP server available locally.`);
+  } else if (enabledMarkets.includes("tradingview")) {
+    notes.push("TradingView is currently a watchlist/context rail. Enable MCP later if you want richer chart tooling.");
+  }
+
+  if (tradingviewMcpEnabled && tradingviewConnectorMode === "mcp") {
+    notes.push("TradingView MCP is marked enabled in the workspace profile. Fill in the command or URL if the doctor still shows it as incomplete.");
+  }
+
   return notes;
 }