@trading-boy/cli 1.10.0 → 1.12.0

package/dist/cli.bundle.js

@@ -35650,6 +35650,13 @@ var init_codex_tokens = __esm({
   }
 });
 
+// ../core/dist/llm/anthropic-tokens.js
+var init_anthropic_tokens = __esm({
+  "../core/dist/llm/anthropic-tokens.js"() {
+    "use strict";
+  }
+});
+
 // ../core/dist/llm/index.js
 var init_llm = __esm({
   "../core/dist/llm/index.js"() {
@@ -35658,6 +35665,42 @@ var init_llm = __esm({
     init_structured_output();
     init_config2();
     init_codex_tokens();
+    init_anthropic_tokens();
+  }
+});
+
+// ../core/dist/strategy-utils.js
+function generateRegimeBehavior(setupTypes = ["BREAKOUT", "MOMENTUM", "MEAN-REVERSION", "CATALYST"]) {
+  return {
+    MARKUP: {
+      enabled: true,
+      maxPositionSize: 0.5,
+      confidenceThreshold: 0,
+      preferredSetups: setupTypes
+    },
+    ACCUMULATION: {
+      enabled: true,
+      maxPositionSize: 0.25,
+      confidenceThreshold: 0,
+      preferredSetups: setupTypes
+    },
+    DISTRIBUTION: {
+      enabled: true,
+      maxPositionSize: 0.15,
+      confidenceThreshold: 0,
+      preferredSetups: setupTypes
+    },
+    MARKDOWN: {
+      enabled: true,
+      maxPositionSize: 0.1,
+      confidenceThreshold: 0,
+      preferredSetups: setupTypes
+    }
+  };
+}
+var init_strategy_utils = __esm({
+  "../core/dist/strategy-utils.js"() {
+    "use strict";
   }
 });
 
@@ -35680,6 +35723,7 @@ var init_dist2 = __esm({
     init_errors3();
     init_crypto();
     init_llm();
+    init_strategy_utils();
   }
 });
 
@@ -56414,6 +56458,49 @@ function registerConfigCommand(program2) {
       process.exitCode = error49 instanceof ApiError ? 2 : 1;
     }
   });
+  configCmd.command("set-models").description("Update per-stage model assignments (no API key needed \u2014 works with Codex OAuth)").option("-m, --model <model>", "Default model for all phases").option("--scan-model <model>", "Model for market scanning").option("--analyze-model <model>", "Model for deep analysis").option("--decide-model <model>", "Model for trade decisions").option("--exit-heartbeat-model <model>", "Model for exit heartbeat checks (cheap, every 4h)").option("--exit-event-model <model>", "Model for exit event-driven analysis (quality)").action(async (opts) => {
+    if (!opts.model && !opts.scanModel && !opts.analyzeModel && !opts.decideModel && !opts.exitHeartbeatModel && !opts.exitEventModel) {
+      console.error(source_default.red("  Error: At least one model flag is required."));
+      console.log(source_default.dim("  Example: trading-boy config set-models --scan-model gpt-5.4-mini --analyze-model gpt-5.4"));
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const result = await apiRequest("/api/v1/llm-config/models", {
+        method: "PATCH",
+        body: {
+          ...opts.model ? { model: opts.model } : {},
+          ...opts.scanModel ? { scanModel: opts.scanModel } : {},
+          ...opts.analyzeModel ? { analyzeModel: opts.analyzeModel } : {},
+          ...opts.decideModel ? { decideModel: opts.decideModel } : {},
+          ...opts.exitHeartbeatModel ? { exitHeartbeatModel: opts.exitHeartbeatModel } : {},
+          ...opts.exitEventModel ? { exitEventModel: opts.exitEventModel } : {}
+        }
+      });
+      console.log("");
+      console.log(source_default.green("  Stage models updated"));
+      console.log(source_default.gray("  " + "\u2500".repeat(40)));
+      console.log(`  ${source_default.gray("Default:")}           ${result.model}`);
+      if (result.scanModel)
+        console.log(`  ${source_default.gray("Scan:")}              ${result.scanModel}`);
+      if (result.analyzeModel)
+        console.log(`  ${source_default.gray("Analyze:")}           ${result.analyzeModel}`);
+      if (result.decideModel)
+        console.log(`  ${source_default.gray("Decide:")}            ${result.decideModel}`);
+      if (result.exitHeartbeatModel)
+        console.log(`  ${source_default.gray("Exit heartbeat:")}    ${result.exitHeartbeatModel}`);
+      if (result.exitEventModel)
+        console.log(`  ${source_default.gray("Exit event:")}        ${result.exitEventModel}`);
+      console.log("");
+      console.log(source_default.dim("  Agents will use these models on their next tick."));
+      console.log("");
+    } catch (error49) {
+      const message = error49 instanceof Error ? error49.message : String(error49);
+      logger17.error({ error: message }, "Failed to set stage models");
+      console.error(source_default.red(`Error: ${message}`));
+      process.exitCode = error49 instanceof ApiError ? 2 : 1;
+    }
+  });
   configCmd.command("get-llm-key").description("Show current LLM configuration (key redacted)").addOption(new Option("--format <format>", "Output format").choices(["text", "json"]).default("text")).action(async (options) => {
     try {
       const result = await apiRequest("/api/v1/llm-config");
@@ -56434,6 +56521,12 @@ function registerConfigCommand(program2) {
         if (result.decideProvider || result.decideModel) {
           console.log(`  ${source_default.gray("Decide:")}        ${result.decideProvider ?? result.provider} / ${result.decideModel ?? result.model}`);
         }
+        if (result.exitHeartbeatModel) {
+          console.log(`  ${source_default.gray("Exit HB:")}       ${result.exitHeartbeatModel}`);
+        }
+        if (result.exitEventModel) {
+          console.log(`  ${source_default.gray("Exit Event:")}    ${result.exitEventModel}`);
+        }
         if (result.baseUrl) {
           console.log(`  ${source_default.gray("Base URL:")}      ${result.baseUrl}`);
         }
@@ -57018,9 +57111,13 @@ init_source();
 init_dist2();
 init_api_client();
 init_utils3();
+import http from "node:http";
+import { URL as URL2 } from "node:url";
 var logger23 = createLogger("cli-connect-chatgpt");
+var CALLBACK_PORT = 1455;
+var CALLBACK_PATH = "/auth/callback";
+var AUTH_TIMEOUT_MS = 3 * 60 * 1e3;
 var POLL_INTERVAL_MS = 2e3;
-var POLL_TIMEOUT_MS = 3 * 60 * 1e3;
 function registerConnectChatgptCommand(program2) {
   program2.command("connect-chatgpt").description("Connect your ChatGPT subscription as your LLM provider (no API key needed)").option("--disconnect", "Disconnect your ChatGPT account").action(async (options) => {
     try {
@@ -57071,38 +57168,125 @@ async function handleConnect() {
   console.log(source_default.dim("  Use your ChatGPT subscription to power your trading agents."));
   console.log(source_default.dim("  No API key needed \u2014 authenticates via your OpenAI account."));
   console.log("");
-  const { authUrl } = await apiRequest("/api/v1/codex/auth-url");
+  const { authUrl, state } = await apiRequest("/api/v1/codex/auth-url");
+  const result = await raceForAuth(authUrl, state);
+  if (result.via === "local") {
+    console.log(source_default.dim("  Exchanging authorization code..."));
+    const exchangeResult = await apiRequest("/api/v1/codex/callback", {
+      method: "POST",
+      body: { code: result.code, state: result.state }
+    });
+    printSuccess(exchangeResult.accountId, null);
+  } else {
+    printSuccess(result.config.codexAccountId, result.config.model);
+  }
+}
+function printSuccess(accountId, model) {
+  console.log("");
+  console.log(source_default.green("  \u2713 ChatGPT connected!"));
+  console.log("");
+  if (accountId)
+    console.log(`  ${source_default.gray("Account:")}  ${accountId}`);
+  console.log(`  ${source_default.gray("Provider:")} codex`);
+  if (model)
+    console.log(`  ${source_default.gray("Model:")}    ${model}`);
+  console.log("");
+  console.log(source_default.dim("  Your agents will now use your ChatGPT subscription for LLM calls."));
+  console.log(source_default.dim("  Change model: trading-boy config set-llm-key --provider codex --model <model>"));
+}
+async function raceForAuth(authUrl, state) {
+  const controller = new AbortController();
+  const localCallback = startLocalCallbackServer(state, controller.signal);
+  const polling = pollForConnection(controller.signal);
   console.log(source_default.white("  Opening OpenAI login in your browser..."));
   await openBrowser(authUrl);
   console.log(source_default.dim("  Complete sign-in in your browser to continue."));
+  console.log(source_default.dim("  Waiting for authentication..."));
   console.log("");
-  const spinner = (await createSpinner("  Waiting for authentication...")).start();
-  const start = Date.now();
-  while (Date.now() - start < POLL_TIMEOUT_MS) {
+  try {
+    const result = await Promise.race([localCallback, polling]);
+    controller.abort();
+    return result;
+  } catch (err) {
+    controller.abort();
+    throw err;
+  }
+}
+function startLocalCallbackServer(state, signal) {
+  return new Promise((resolve4, reject) => {
+    if (signal.aborted) {
+      reject(new Error("Cancelled"));
+      return;
+    }
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Timed out waiting for OpenAI authentication (3 minutes)"));
+    }, AUTH_TIMEOUT_MS);
+    signal.addEventListener("abort", () => {
+      clearTimeout(timeout);
+      server.close();
+    }, { once: true });
+    const server = http.createServer((req, res) => {
+      const url2 = new URL2(req.url ?? "/", `http://localhost:${CALLBACK_PORT}`);
+      if (url2.pathname !== CALLBACK_PATH) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+        return;
+      }
+      const errorParam = url2.searchParams.get("error");
+      const errorDesc = url2.searchParams.get("error_description");
+      const codeParam = url2.searchParams.get("code");
+      if (errorParam) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(callbackHtml(false, errorDesc || errorParam));
+        clearTimeout(timeout);
+        server.close();
+        reject(new Error(`OpenAI returned error: ${errorDesc || errorParam}`));
+        return;
+      }
+      if (!codeParam) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(callbackHtml(false, "Missing authorization code"));
+        clearTimeout(timeout);
+        server.close();
+        reject(new Error("No authorization code in callback"));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(callbackHtml(true));
+      clearTimeout(timeout);
+      server.close();
+      resolve4({ via: "local", code: codeParam, state });
+    });
+    server.on("error", (err) => {
+      clearTimeout(timeout);
+      if (err.code === "EADDRINUSE") {
+        logger23.debug("Port %d in use, falling back to polling only", CALLBACK_PORT);
+        return;
+      }
+      reject(err);
+    });
+    server.listen(CALLBACK_PORT, "127.0.0.1");
+  });
+}
+async function pollForConnection(signal) {
+  const deadline = Date.now() + AUTH_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (signal.aborted)
+      throw new Error("Cancelled");
     await sleep3(POLL_INTERVAL_MS);
-    const elapsed = Math.round((Date.now() - start) / 1e3);
-    spinner.text = `  Waiting for authentication... (${elapsed}s)`;
+    if (signal.aborted)
+      throw new Error("Cancelled");
     try {
       const config2 = await apiRequest("/api/v1/llm-config");
       if (config2.codexConnected) {
-        spinner.succeed(source_default.green("  ChatGPT connected!"));
-        console.log("");
-        console.log(`  ${source_default.gray("Account:")}  ${config2.codexAccountId ?? "connected"}`);
-        console.log(`  ${source_default.gray("Provider:")} codex`);
-        console.log(`  ${source_default.gray("Model:")}    ${config2.model}`);
-        console.log("");
-        console.log(source_default.dim("  Your agents will now use your ChatGPT subscription for LLM calls."));
-        console.log(source_default.dim("  Change model: trading-boy config set-llm-key --provider codex --model <model>"));
-        return;
+        return { via: "poll", config: config2 };
       }
-    } catch (error49) {
-      logger23.debug({ error: error49 }, "Poll attempt failed");
+    } catch {
+      logger23.debug("Poll attempt failed, retrying...");
     }
   }
-  spinner.fail(source_default.yellow("  Timed out waiting for authentication."));
-  console.log("");
-  console.log(source_default.dim("  The browser window may still be open \u2014 complete sign-in there,"));
-  console.log(source_default.dim("  then run this command again to check the connection status."));
+  throw new Error("Timed out waiting for OpenAI authentication (3 minutes)");
 }
 async function handleDisconnect() {
   const { confirm } = await Promise.resolve().then(() => (init_esm15(), esm_exports));
@@ -57121,6 +57305,21 @@ async function handleDisconnect() {
   console.log(source_default.dim("  Your agents will need an API key to continue. Set one:"));
   console.log(source_default.dim("  trading-boy config set-llm-key <your-api-key>"));
 }
+function callbackHtml(success3, errorMsg) {
+  const title = success3 ? "ChatGPT Connected" : "Connection Failed";
+  const icon = success3 ? "&#10003;" : "&#10007;";
+  const color = success3 ? "#22c55e" : "#ef4444";
+  const message = success3 ? "Your ChatGPT subscription is now connected to Trading Boy.<br>You can close this tab." : `Something went wrong: ${escapeHtml(errorMsg ?? "Unknown error")}.<br>Please try again.`;
+  return `<!DOCTYPE html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${title} \u2014 Trading Boy</title>
+<style>*{margin:0;padding:0;box-sizing:border-box}body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;background:#0a0a0a;color:#e5e5e5}
+.card{text-align:center;padding:3rem;max-width:480px}.icon{font-size:4rem;color:${color};margin-bottom:1rem}h1{font-size:1.5rem;margin-bottom:1rem}p{color:#a3a3a3;line-height:1.6}</style>
+</head><body><div class="card"><div class="icon">${icon}</div><h1>${title}</h1><p>${message}</p></div></body></html>`;
+}
+function escapeHtml(str2) {
+  return str2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
 function sleep3(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
@@ -57130,7 +57329,7 @@ var ALLOWED_AUTH_DOMAINS = /* @__PURE__ */ new Set([
   "chat.openai.com"
 ]);
 function validateAuthUrl(url2) {
-  const parsed = new URL(url2);
+  const parsed = new URL2(url2);
   if (parsed.protocol !== "https:") {
     throw new Error(`Refusing to open non-HTTPS URL: ${url2}`);
   }
@@ -57359,11 +57558,15 @@ async function runOnboarding() {
   console.log("");
   console.log(source_default.dim("  Once you create an agent, it runs continuously on our servers:"));
   console.log("");
-  console.log(`  ${source_default.white("Scan")}      ${source_default.dim("Every 5 min (configurable) \u2014 scans your watchlist for setups")}`);
+  console.log(`  ${source_default.white("Scan")}      ${source_default.dim("Every 30 min by default \u2014 scans your watchlist for setups")}`);
   console.log(`  ${source_default.white("Analyze")}   ${source_default.dim("When a setup is found \u2014 deep context analysis via your LLM")}`);
   console.log(`  ${source_default.white("Decide")}    ${source_default.dim("After analysis \u2014 enter/exit/hold based on your strategy")}`);
   console.log(`  ${source_default.white("Learn")}     ${source_default.dim("After trades close \u2014 updates edge profile from outcomes")}`);
   console.log("");
+  console.log(source_default.dim("  Scan interval controls how often your agent checks for setups."));
+  console.log(source_default.dim("  Lower intervals = more LLM calls = higher cost. Recommended: 30m."));
+  console.log(source_default.dim("  Change it: trading-boy agent update <name> --scan-interval 15m"));
+  console.log("");
   console.log(source_default.dim("  Autonomy levels:"));
   console.log(`  ${source_default.cyan("OBSERVE_ONLY")}        ${source_default.dim("Scans and analyzes \u2014 takes no action")}`);
   console.log(`  ${source_default.cyan("SUGGEST")}             ${source_default.dim("Sends trade ideas to your Telegram")}`);
@@ -57398,7 +57601,7 @@ function isUserAbort(error49) {
 // dist/commands/subscribe.js
 var logger24 = createLogger("cli-subscribe");
 var POLL_INTERVAL_MS2 = 3e3;
-var POLL_TIMEOUT_MS2 = 5 * 60 * 1e3;
+var POLL_TIMEOUT_MS = 5 * 60 * 1e3;
 async function createCheckoutSession(email3, plan = "starter") {
   const response = await fetch(`${getApiBase()}/api/v1/billing/checkout`, {
     method: "POST",
@@ -57450,7 +57653,7 @@ async function checkCryptoPayment(reference) {
 async function pollCryptoPayment(reference, provisioningToken, onTick) {
   const start = Date.now();
   const CRYPTO_POLL_INTERVAL = 5e3;
-  while (Date.now() - start < POLL_TIMEOUT_MS2) {
+  while (Date.now() - start < POLL_TIMEOUT_MS) {
     onTick?.(Date.now() - start, "payment");
     try {
       const result = await checkCryptoPayment(reference);
@@ -57464,10 +57667,10 @@ async function pollCryptoPayment(reference, provisioningToken, onTick) {
     }
     await sleep4(CRYPTO_POLL_INTERVAL);
   }
-  if (Date.now() - start >= POLL_TIMEOUT_MS2) {
+  if (Date.now() - start >= POLL_TIMEOUT_MS) {
     return { success: false, error: "Timed out waiting for USDC payment. If you sent the payment, contact support." };
   }
-  while (Date.now() - start < POLL_TIMEOUT_MS2) {
+  while (Date.now() - start < POLL_TIMEOUT_MS) {
     onTick?.(Date.now() - start, "provisioning");
     try {
       const result = await pollProvisioningToken(provisioningToken);
@@ -57487,7 +57690,7 @@ async function pollCryptoPayment(reference, provisioningToken, onTick) {
 async function pollForApiKey(token, onTick) {
   const start = Date.now();
   let elapsed = Date.now() - start;
-  while (elapsed < POLL_TIMEOUT_MS2) {
+  while (elapsed < POLL_TIMEOUT_MS) {
     onTick?.(elapsed);
     try {
       const result = await pollProvisioningToken(token);
@@ -58582,12 +58785,7 @@ function registerStrategyCommand(program2) {
       agentId: options.agentId,
       tokens,
       setupTypes,
-      regimeBehavior: {
-        ACCUMULATION: { enabled: true, maxPositionSize: 0.25, confidenceThreshold: 0.6, preferredSetups: setupTypes },
-        MARKUP: { enabled: true, maxPositionSize: 0.5, confidenceThreshold: 0.5, preferredSetups: setupTypes },
-        DISTRIBUTION: { enabled: true, maxPositionSize: 0.15, confidenceThreshold: 0.7, preferredSetups: setupTypes },
-        MARKDOWN: { enabled: false, maxPositionSize: 0.1, confidenceThreshold: 0.8, preferredSetups: setupTypes }
-      },
+      regimeBehavior: generateRegimeBehavior(setupTypes),
       riskLimits: {
         maxDrawdown: 0.2,
         maxConcurrentPositions: 5,
@@ -58788,9 +58986,9 @@ function formatWinRate2(rate) {
   return source_default.red(str2);
 }
 var POLL_INTERVAL_MS3 = 2e3;
-var POLL_TIMEOUT_MS3 = 6e4;
+var POLL_TIMEOUT_MS2 = 6e4;
 async function pollReplayJob(jobId) {
-  const deadline = Date.now() + POLL_TIMEOUT_MS3;
+  const deadline = Date.now() + POLL_TIMEOUT_MS2;
   while (Date.now() < deadline) {
     const status = await apiRequest(`/api/v1/replay/${encodeURIComponent(jobId)}`);
     if (status.status === "COMPLETE" || status.status === "FAILED") {
@@ -58798,7 +58996,7 @@ async function pollReplayJob(jobId) {
     }
     await new Promise((resolve4) => setTimeout(resolve4, POLL_INTERVAL_MS3));
   }
-  throw new Error(`Replay job ${jobId} did not complete within ${POLL_TIMEOUT_MS3 / 1e3}s timeout.`);
+  throw new Error(`Replay job ${jobId} did not complete within ${POLL_TIMEOUT_MS2 / 1e3}s timeout.`);
 }
 function registerReplayCommand(program2) {
   program2.command("replay").description("Run strategy replay (backtest) over a historical period").requiredOption("--strategy <id>", "Strategy ID").requiredOption("--token <symbol>", "Token symbol").requiredOption("--from <date>", "Start date (ISO-8601, e.g. 2025-01-01)").requiredOption("--to <date>", "End date (ISO-8601, e.g. 2025-03-01)").addOption(new Option("--format <format>", "Output format").choices(["text", "json"]).default("text")).action(async (options) => {
@@ -59413,7 +59611,7 @@ function parseHumanInterval(value) {
 var MIN_SCAN_INTERVAL_MS = 6e4;
 function registerAgentCommand(program2) {
   const agent = program2.command("agent").description("Manage autonomous trading agents");
-  agent.command("create").description("Create a new agent").option("--trader-id <traderId>", "Trader ID").option("--strategy-id <strategyId>", "Strategy ID").option("--name <name>", "Agent name").option("--autonomy <level>", "Autonomy level: OBSERVE_ONLY, SUGGEST, AUTO_WITH_APPROVAL, FULLY_AUTONOMOUS", "OBSERVE_ONLY").option("--scan-interval <ms>", "Scan interval in ms (min 60000)", "300000").option("--scan-interval-human <duration>", "Scan interval in human-readable format (e.g. 1m, 5m, 15m, 30m, 1h)").option("--watchlist <symbols>", "Comma-separated token symbols").option("--max-daily-trades <n>", "Max daily trades", "10").option("--max-daily-loss <usd>", "Max daily loss in USD", "500").option("--max-position-size <pct>", "Max position size as decimal (0.10 = 10%)", "0.10").option("--min-confidence <n>", "Min confidence threshold (0-1)", "0.60").option("--scan-model <model>", "LLM model for market scanning").option("--analyze-model <model>", "LLM model for deep analysis").option("--decide-model <model>", "LLM model for trade decisions").addOption(new Option("--asset-class <class>", "Asset class for this agent").choices(["crypto", "commodities", "mixed"]).default("crypto")).option("--soul-override <text>", "Custom soul/personality for this agent").option("--purpose-override <text>", "Custom purpose/mission for this agent").option("--soul-file <path>", "Load soul from a file").option("--purpose-file <path>", "Load purpose from a file").option("--exit-reasoner", "Enable LLM-powered exit reasoning for this agent").addOption(new Option("--format <format>", "Output format").choices(["text", "json"]).default("text")).action(async (options) => {
+  agent.command("create").description("Create a new agent").option("--trader-id <traderId>", "Trader ID").option("--strategy-id <strategyId>", "Strategy ID (optional \u2014 auto-creates if omitted)").option("--name <name>", "Agent name").option("--autonomy <level>", "Autonomy level: OBSERVE_ONLY, SUGGEST, AUTO_WITH_APPROVAL, FULLY_AUTONOMOUS", "OBSERVE_ONLY").option("--scan-interval <ms>", "Scan interval in ms (min 60000)", "300000").option("--scan-interval-human <duration>", "Scan interval in human-readable format (e.g. 1m, 5m, 15m, 30m, 1h)").option("--watchlist <symbols>", "Comma-separated token symbols").option("--max-daily-trades <n>", "Max daily trades", "10").option("--max-daily-loss <usd>", "Max daily loss in USD", "500").option("--max-position-size <pct>", "Max position size as decimal (0.10 = 10%)", "0.10").option("--min-confidence <n>", "Min confidence threshold (0-1)", "0.60").option("--scan-model <model>", "LLM model for market scanning").option("--analyze-model <model>", "LLM model for deep analysis").option("--decide-model <model>", "LLM model for trade decisions").addOption(new Option("--asset-class <class>", "Asset class for this agent").choices(["crypto", "commodities", "mixed"]).default("crypto")).option("--soul-override <text>", "Custom soul/personality for this agent").option("--purpose-override <text>", "Custom purpose/mission for this agent").option("--soul-file <path>", "Load soul from a file").option("--purpose-file <path>", "Load purpose from a file").option("--exit-reasoner", "Enable LLM-powered exit reasoning for this agent").addOption(new Option("--format <format>", "Output format").choices(["text", "json"]).default("text")).action(async (options) => {
     if (!await ensureRemote())
       return;
     if (!options.traderId) {
@@ -59422,16 +59620,11 @@ function registerAgentCommand(program2) {
       process.exitCode = 1;
       return;
     }
-    if (!options.strategyId) {
-      console.error(source_default.red("Error: --strategy-id is required."));
-      console.log(source_default.dim("  Find yours with: trading-boy strategy list"));
-      process.exitCode = 1;
-      return;
-    }
     const body = {
-      traderId: options.traderId,
-      strategyId: options.strategyId
+      traderId: options.traderId
     };
+    if (options.strategyId)
+      body.strategyId = options.strategyId;
     if (options.name)
       body.name = options.name;
     if (options.autonomy)
@@ -59507,7 +59700,7 @@ function registerAgentCommand(program2) {
         console.log(`  ${source_default.gray("ID:")}        ${result.id}`);
         console.log(`  ${source_default.gray("Name:")}      ${result.name}`);
         console.log(`  ${source_default.gray("Trader:")}    ${result.traderId}`);
-        console.log(`  ${source_default.gray("Strategy:")}  ${result.strategyId}`);
+        console.log(`  ${source_default.gray("Strategy:")}  ${result.strategyId}${result.autoStrategyCreated ? source_default.dim(" (auto-created)") : ""}`);
         console.log(`  ${source_default.gray("Autonomy:")}  ${formatAutonomy(result.autonomyLevel)}`);
         console.log(`  ${source_default.gray("Interval:")}  ${formatInterval(result.scanIntervalMs)}`);
         console.log(`  ${source_default.gray("Next scan:")} ${formatShortDate5(result.nextScanAt)}`);

package/dist/cli.js

@@ -43,6 +43,7 @@ import { registerSuggestionsCommand } from './commands/suggestions-cmd.js';
 import { registerCronCommand } from './commands/cron-cmd.js';
 import { registerAgentCommand } from './commands/agent-cmd.js';
 import { registerConnectChatgptCommand } from './commands/connect-chatgpt.js';
+// import { registerConnectClaudeCommand } from './commands/connect-claude.js'; // Hidden — Anthropic ToS prohibits OAuth for third-party use
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, resolve } from 'node:path';
@@ -86,6 +87,7 @@ export function createCli() {
     registerBillingCommand(program);
     registerSubscribeCommand(program);
     registerConnectChatgptCommand(program);
+    // registerConnectClaudeCommand(program); // Hidden — Anthropic ToS prohibits OAuth for third-party use
     // Learning & coaching
     registerCoachingCommand(program);
     registerThesisCommand(program);

package/dist/commands/agent-cmd.js

@@ -79,7 +79,7 @@ export function registerAgentCommand(program) {
         .command('create')
         .description('Create a new agent')
         .option('--trader-id <traderId>', 'Trader ID')
-        .option('--strategy-id <strategyId>', 'Strategy ID')
+        .option('--strategy-id <strategyId>', 'Strategy ID (optional — auto-creates if omitted)')
         .option('--name <name>', 'Agent name')
         .option('--autonomy <level>', 'Autonomy level: OBSERVE_ONLY, SUGGEST, AUTO_WITH_APPROVAL, FULLY_AUTONOMOUS', 'OBSERVE_ONLY')
         .option('--scan-interval <ms>', 'Scan interval in ms (min 60000)', '300000')
@@ -108,16 +108,11 @@ export function registerAgentCommand(program) {
             process.exitCode = 1;
             return;
         }
-        if (!options.strategyId) {
-            console.error(chalk.red('Error: --strategy-id is required.'));
-            console.log(chalk.dim('  Find yours with: trading-boy strategy list'));
-            process.exitCode = 1;
-            return;
-        }
         const body = {
             traderId: options.traderId,
-            strategyId: options.strategyId,
         };
+        if (options.strategyId)
+            body.strategyId = options.strategyId;
         if (options.name)
             body.name = options.name;
         if (options.autonomy)
@@ -200,7 +195,7 @@ export function registerAgentCommand(program) {
                 console.log(`  ${chalk.gray('ID:')}        ${result.id}`);
                 console.log(`  ${chalk.gray('Name:')}      ${result.name}`);
                 console.log(`  ${chalk.gray('Trader:')}    ${result.traderId}`);
-                console.log(`  ${chalk.gray('Strategy:')}  ${result.strategyId}`);
+                console.log(`  ${chalk.gray('Strategy:')}  ${result.strategyId}${result.autoStrategyCreated ? chalk.dim(' (auto-created)') : ''}`);
                 console.log(`  ${chalk.gray('Autonomy:')}  ${formatAutonomy(result.autonomyLevel)}`);
                 console.log(`  ${chalk.gray('Interval:')}  ${formatInterval(result.scanIntervalMs)}`);
                 console.log(`  ${chalk.gray('Next scan:')} ${formatShortDate(result.nextScanAt)}`);

package/dist/commands/config-cmd.js

@@ -379,6 +379,60 @@ export function registerConfigCommand(program) {
             process.exitCode = error instanceof ApiError ? 2 : 1;
         }
     });
+    // ─── config set-models ───
+    configCmd
+        .command('set-models')
+        .description('Update per-stage model assignments (no API key needed — works with Codex OAuth)')
+        .option('-m, --model <model>', 'Default model for all phases')
+        .option('--scan-model <model>', 'Model for market scanning')
+        .option('--analyze-model <model>', 'Model for deep analysis')
+        .option('--decide-model <model>', 'Model for trade decisions')
+        .option('--exit-heartbeat-model <model>', 'Model for exit heartbeat checks (cheap, every 4h)')
+        .option('--exit-event-model <model>', 'Model for exit event-driven analysis (quality)')
+        .action(async (opts) => {
+        if (!opts.model && !opts.scanModel && !opts.analyzeModel && !opts.decideModel && !opts.exitHeartbeatModel && !opts.exitEventModel) {
+            console.error(chalk.red('  Error: At least one model flag is required.'));
+            console.log(chalk.dim('  Example: trading-boy config set-models --scan-model gpt-5.4-mini --analyze-model gpt-5.4'));
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const result = await apiRequest('/api/v1/llm-config/models', {
+                method: 'PATCH',
+                body: {
+                    ...(opts.model ? { model: opts.model } : {}),
+                    ...(opts.scanModel ? { scanModel: opts.scanModel } : {}),
+                    ...(opts.analyzeModel ? { analyzeModel: opts.analyzeModel } : {}),
+                    ...(opts.decideModel ? { decideModel: opts.decideModel } : {}),
+                    ...(opts.exitHeartbeatModel ? { exitHeartbeatModel: opts.exitHeartbeatModel } : {}),
+                    ...(opts.exitEventModel ? { exitEventModel: opts.exitEventModel } : {}),
+                },
+            });
+            console.log('');
+            console.log(chalk.green('  Stage models updated'));
+            console.log(chalk.gray('  ' + '─'.repeat(40)));
+            console.log(`  ${chalk.gray('Default:')}           ${result.model}`);
+            if (result.scanModel)
+                console.log(`  ${chalk.gray('Scan:')}              ${result.scanModel}`);
+            if (result.analyzeModel)
+                console.log(`  ${chalk.gray('Analyze:')}           ${result.analyzeModel}`);
+            if (result.decideModel)
+                console.log(`  ${chalk.gray('Decide:')}            ${result.decideModel}`);
+            if (result.exitHeartbeatModel)
+                console.log(`  ${chalk.gray('Exit heartbeat:')}    ${result.exitHeartbeatModel}`);
+            if (result.exitEventModel)
+                console.log(`  ${chalk.gray('Exit event:')}        ${result.exitEventModel}`);
+            console.log('');
+            console.log(chalk.dim('  Agents will use these models on their next tick.'));
+            console.log('');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error({ error: message }, 'Failed to set stage models');
+            console.error(chalk.red(`Error: ${message}`));
+            process.exitCode = error instanceof ApiError ? 2 : 1;
+        }
+    });
     // ─── config get-llm-key ───
     configCmd
         .command('get-llm-key')
@@ -405,6 +459,12 @@ export function registerConfigCommand(program) {
                 if (result.decideProvider || result.decideModel) {
                     console.log(`  ${chalk.gray('Decide:')}        ${result.decideProvider ?? result.provider} / ${result.decideModel ?? result.model}`);
                 }
+                if (result.exitHeartbeatModel) {
+                    console.log(`  ${chalk.gray('Exit HB:')}       ${result.exitHeartbeatModel}`);
+                }
+                if (result.exitEventModel) {
+                    console.log(`  ${chalk.gray('Exit Event:')}    ${result.exitEventModel}`);
+                }
                 if (result.baseUrl) {
                     console.log(`  ${chalk.gray('Base URL:')}      ${result.baseUrl}`);
                 }

package/dist/commands/connect-chatgpt.js

@@ -2,22 +2,25 @@
 //
 // Connects a user's ChatGPT subscription via Codex OAuth (PKCE).
 //
-// Flow:
-// 1. GET /api/v1/codex/auth-url → { authUrl, state }
-// 2. Open browser to authUrl (user authenticates with OpenAI)
-// 3. OpenAI redirects back to API server callback
-// 4. CLI polls GET /api/v1/llm-config until codexConnected: true
+// Two completion paths run in parallel (whichever wins first):
+//   A. Local callback: localhost:1455/auth/callback catches code → POST to API
+//   B. Polling: GET /api/v1/llm-config until codexConnected: true
+//      (handles production redirect where API server catches the callback directly)
 //
 // Also supports disconnect via --disconnect flag.
+import http from 'node:http';
+import { URL } from 'node:url';
 import chalk from 'chalk';
 import { createLogger } from '@trading-boy/core';
 import { apiRequest, ApiError, isRemoteMode } from '../api-client.js';
-import { createSpinner, formatConnectionError } from '../utils.js';
+import { formatConnectionError } from '../utils.js';
 // ─── Logger ───
 const logger = createLogger('cli-connect-chatgpt');
 // ─── Constants ───
+const CALLBACK_PORT = 1455;
+const CALLBACK_PATH = '/auth/callback';
+const AUTH_TIMEOUT_MS = 3 * 60 * 1_000; // 3 minutes
 const POLL_INTERVAL_MS = 2_000;
-const POLL_TIMEOUT_MS = 3 * 60 * 1_000; // 3 minutes
 // ─── Command ───
 export function registerConnectChatgptCommand(program) {
     program
@@ -77,43 +80,141 @@ async function handleConnect() {
     console.log(chalk.dim('  Use your ChatGPT subscription to power your trading agents.'));
     console.log(chalk.dim('  No API key needed — authenticates via your OpenAI account.'));
     console.log('');
-    // Step 1: Get auth URL
-    const { authUrl } = await apiRequest('/api/v1/codex/auth-url');
-    // Step 2: Open browser
+    // Step 1: Get auth URL from API (generates PKCE + stores verifier in Redis)
+    const { authUrl, state } = await apiRequest('/api/v1/codex/auth-url');
+    // Step 2: Race local callback server vs polling
+    // - Local callback wins when redirect_uri points to localhost (dev or matching Codex client)
+    // - Polling wins when redirect_uri points to production API server
+    const result = await raceForAuth(authUrl, state);
+    // Step 3: Handle result
+    if (result.via === 'local') {
+        // Local server caught the code — forward to API for token exchange
+        console.log(chalk.dim('  Exchanging authorization code...'));
+        const exchangeResult = await apiRequest('/api/v1/codex/callback', {
+            method: 'POST',
+            body: { code: result.code, state: result.state },
+        });
+        printSuccess(exchangeResult.accountId, null);
+    }
+    else {
+        // Polling detected connection — API server handled the callback directly
+        printSuccess(result.config.codexAccountId, result.config.model);
+    }
+}
+function printSuccess(accountId, model) {
+    console.log('');
+    console.log(chalk.green('  ✓ ChatGPT connected!'));
+    console.log('');
+    if (accountId)
+        console.log(`  ${chalk.gray('Account:')}  ${accountId}`);
+    console.log(`  ${chalk.gray('Provider:')} codex`);
+    if (model)
+        console.log(`  ${chalk.gray('Model:')}    ${model}`);
+    console.log('');
+    console.log(chalk.dim('  Your agents will now use your ChatGPT subscription for LLM calls.'));
+    console.log(chalk.dim('  Change model: trading-boy config set-llm-key --provider codex --model <model>'));
+}
+// ─── Race: Local Callback vs Polling ───
+async function raceForAuth(authUrl, state) {
+    const controller = new AbortController();
+    const localCallback = startLocalCallbackServer(state, controller.signal);
+    const polling = pollForConnection(controller.signal);
+    // Open browser after server is ready (small delay to ensure listen completes)
     console.log(chalk.white('  Opening OpenAI login in your browser...'));
     await openBrowser(authUrl);
     console.log(chalk.dim('  Complete sign-in in your browser to continue.'));
+    console.log(chalk.dim('  Waiting for authentication...'));
     console.log('');
-    // Step 3: Poll for completion
-    const spinner = (await createSpinner('  Waiting for authentication...')).start();
-    const start = Date.now();
-    while (Date.now() - start < POLL_TIMEOUT_MS) {
+    try {
+        const result = await Promise.race([localCallback, polling]);
+        controller.abort(); // cancel the loser
+        return result;
+    }
+    catch (err) {
+        controller.abort();
+        throw err;
+    }
+}
+function startLocalCallbackServer(state, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new Error('Cancelled'));
+            return;
+        }
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error('Timed out waiting for OpenAI authentication (3 minutes)'));
+        }, AUTH_TIMEOUT_MS);
+        signal.addEventListener('abort', () => {
+            clearTimeout(timeout);
+            server.close();
+        }, { once: true });
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url ?? '/', `http://localhost:${CALLBACK_PORT}`);
+            if (url.pathname !== CALLBACK_PATH) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Not found');
+                return;
+            }
+            const errorParam = url.searchParams.get('error');
+            const errorDesc = url.searchParams.get('error_description');
+            const codeParam = url.searchParams.get('code');
+            if (errorParam) {
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(callbackHtml(false, errorDesc || errorParam));
+                clearTimeout(timeout);
+                server.close();
+                reject(new Error(`OpenAI returned error: ${errorDesc || errorParam}`));
+                return;
+            }
+            if (!codeParam) {
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(callbackHtml(false, 'Missing authorization code'));
+                clearTimeout(timeout);
+                server.close();
+                reject(new Error('No authorization code in callback'));
+                return;
+            }
+            // Success — send HTML to browser, resolve
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(callbackHtml(true));
+            clearTimeout(timeout);
+            server.close();
+            resolve({ via: 'local', code: codeParam, state });
+        });
+        server.on('error', (err) => {
+            clearTimeout(timeout);
+            if (err.code === 'EADDRINUSE') {
+                // Port in use — don't fail hard, let polling take over
+                logger.debug('Port %d in use, falling back to polling only', CALLBACK_PORT);
+                // Return a never-resolving promise (polling will win)
+                return;
+            }
+            reject(err);
+        });
+        server.listen(CALLBACK_PORT, '127.0.0.1');
+    });
+}
+async function pollForConnection(signal) {
+    const deadline = Date.now() + AUTH_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (signal.aborted)
+            throw new Error('Cancelled');
         await sleep(POLL_INTERVAL_MS);
-        const elapsed = Math.round((Date.now() - start) / 1000);
-        spinner.text = `  Waiting for authentication... (${elapsed}s)`;
+        if (signal.aborted)
+            throw new Error('Cancelled');
         try {
             const config = await apiRequest('/api/v1/llm-config');
             if (config.codexConnected) {
-                spinner.succeed(chalk.green('  ChatGPT connected!'));
-                console.log('');
-                console.log(`  ${chalk.gray('Account:')}  ${config.codexAccountId ?? 'connected'}`);
-                console.log(`  ${chalk.gray('Provider:')} codex`);
-                console.log(`  ${chalk.gray('Model:')}    ${config.model}`);
-                console.log('');
-                console.log(chalk.dim('  Your agents will now use your ChatGPT subscription for LLM calls.'));
-                console.log(chalk.dim('  Change model: trading-boy config set-llm-key --provider codex --model <model>'));
-                return;
+                return { via: 'poll', config };
             }
         }
-        catch (error) {
+        catch {
             // Poll failures are expected — API might briefly be unavailable
-            logger.debug({ error }, 'Poll attempt failed');
+            logger.debug('Poll attempt failed, retrying...');
         }
     }
-    spinner.fail(chalk.yellow('  Timed out waiting for authentication.'));
-    console.log('');
-    console.log(chalk.dim('  The browser window may still be open — complete sign-in there,'));
-    console.log(chalk.dim('  then run this command again to check the connection status.'));
+    throw new Error('Timed out waiting for OpenAI authentication (3 minutes)');
 }
 // ─── Disconnect Flow ───
 async function handleDisconnect() {
@@ -133,6 +234,24 @@ async function handleDisconnect() {
     console.log(chalk.dim('  Your agents will need an API key to continue. Set one:'));
     console.log(chalk.dim('  trading-boy config set-llm-key <your-api-key>'));
 }
+// ─── HTML for Browser Callback ───
+function callbackHtml(success, errorMsg) {
+    const title = success ? 'ChatGPT Connected' : 'Connection Failed';
+    const icon = success ? '&#10003;' : '&#10007;';
+    const color = success ? '#22c55e' : '#ef4444';
+    const message = success
+        ? 'Your ChatGPT subscription is now connected to Trading Boy.<br>You can close this tab.'
+        : `Something went wrong: ${escapeHtml(errorMsg ?? 'Unknown error')}.<br>Please try again.`;
+    return `<!DOCTYPE html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${title} — Trading Boy</title>
+<style>*{margin:0;padding:0;box-sizing:border-box}body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;background:#0a0a0a;color:#e5e5e5}
+.card{text-align:center;padding:3rem;max-width:480px}.icon{font-size:4rem;color:${color};margin-bottom:1rem}h1{font-size:1.5rem;margin-bottom:1rem}p{color:#a3a3a3;line-height:1.6}</style>
+</head><body><div class="card"><div class="icon">${icon}</div><h1>${title}</h1><p>${message}</p></div></body></html>`;
+}
+function escapeHtml(str) {
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
 // ─── Helpers ───
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));

package/dist/commands/connect-claude.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+export declare function registerConnectClaudeCommand(program: Command): void;
+declare function handleConnect(): Promise<void>;
+export { handleConnect as connectClaude };
+//# sourceMappingURL=connect-claude.d.ts.map

package/dist/commands/connect-claude.js

@@ -0,0 +1,280 @@
+// ─── Connect Claude Command ───
+//
+// Connects a user's Claude subscription via Anthropic OAuth (PKCE).
+//
+// Two completion paths run in parallel (whichever wins first):
+//   A. Local callback: localhost:1456/auth/callback catches code → POST to API
+//   B. Polling: GET /api/v1/llm-config until anthropicOAuthConnected: true
+//      (handles production redirect where API server catches the callback directly)
+//
+// Also supports disconnect via --disconnect flag.
+import http from 'node:http';
+import { URL } from 'node:url';
+import chalk from 'chalk';
+import { createLogger } from '@trading-boy/core';
+import { apiRequest, ApiError, isRemoteMode } from '../api-client.js';
+import { formatConnectionError } from '../utils.js';
+// ─── Logger ───
+const logger = createLogger('cli-connect-claude');
+// ─── Constants ───
+const CALLBACK_PORT = 1456;
+const CALLBACK_PATH = '/callback';
+const AUTH_TIMEOUT_MS = 3 * 60 * 1_000; // 3 minutes
+const POLL_INTERVAL_MS = 2_000;
+// ─── Command ───
+export function registerConnectClaudeCommand(program) {
+    program
+        .command('connect-claude')
+        .description('Connect your Claude subscription as your LLM provider (no API key needed)')
+        .option('--disconnect', 'Disconnect your Claude account')
+        .action(async (options) => {
+        try {
+            if (!(await isRemoteMode())) {
+                console.error(chalk.yellow('  Requires API connection. Run: trading-boy login'));
+                process.exitCode = 1;
+                return;
+            }
+            if (options.disconnect) {
+                await handleDisconnect();
+            }
+            else {
+                await handleConnect();
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger.error({ error: msg }, 'connect-claude failed');
+            const connHelp = formatConnectionError(msg);
+            if (connHelp) {
+                console.error(chalk.red(`\n  Connection failed.\n`));
+                console.error(connHelp);
+            }
+            else {
+                console.error(chalk.red(`\n  Error: ${msg}`));
+            }
+            process.exitCode = error instanceof ApiError ? 2 : 1;
+        }
+    });
+}
+// ─── Connect Flow ───
+async function handleConnect() {
+    // Check if already connected
+    try {
+        const current = await apiRequest('/api/v1/llm-config');
+        if (current.anthropicOAuthConnected) {
+            console.log('');
+            console.log(chalk.green('  ✓ Claude is already connected'));
+            console.log(chalk.dim(`  Provider: anthropic / ${current.model}`));
+            console.log('');
+            console.log(chalk.dim('  To disconnect: trading-boy connect-claude --disconnect'));
+            return;
+        }
+    }
+    catch {
+        // No config yet — that's fine, proceed with connect
+    }
+    console.log('');
+    console.log(chalk.bold.cyan('  Connect Claude'));
+    console.log(chalk.gray('  ' + '\u2500'.repeat(50)));
+    console.log(chalk.dim('  Use your Claude subscription to power your trading agents.'));
+    console.log(chalk.dim('  No API key needed — authenticates via your Anthropic account.'));
+    console.log('');
+    // Step 1: Get auth URL from API (generates PKCE + stores verifier in Redis)
+    const { authUrl, state } = await apiRequest('/api/v1/anthropic-oauth/auth-url');
+    // Step 2: Race local callback server vs polling
+    const result = await raceForAuth(authUrl, state);
+    // Step 3: Handle result
+    if (result.via === 'local') {
+        console.log(chalk.dim('  Exchanging authorization code...'));
+        await apiRequest('/api/v1/anthropic-oauth/callback', {
+            method: 'POST',
+            body: { code: result.code, state: result.state },
+        });
+        printSuccess(null);
+    }
+    else {
+        printSuccess(result.config.model);
+    }
+}
+function printSuccess(model) {
+    console.log('');
+    console.log(chalk.green('  ✓ Claude connected!'));
+    console.log('');
+    console.log(`  ${chalk.gray('Provider:')} anthropic`);
+    if (model)
+        console.log(`  ${chalk.gray('Model:')}    ${model}`);
+    console.log('');
+    console.log(chalk.dim('  Your agents will now use your Claude subscription for LLM calls.'));
+    console.log(chalk.dim('  Change model: trading-boy config set-llm-key --provider anthropic --model <model>'));
+}
+// ─── Race: Local Callback vs Polling ───
+async function raceForAuth(authUrl, state) {
+    const controller = new AbortController();
+    const localCallback = startLocalCallbackServer(state, controller.signal);
+    const polling = pollForConnection(controller.signal);
+    console.log(chalk.white('  Opening Claude login in your browser...'));
+    await openBrowser(authUrl);
+    console.log(chalk.dim('  Complete sign-in in your browser to continue.'));
+    console.log(chalk.dim('  Waiting for authentication...'));
+    console.log('');
+    try {
+        const result = await Promise.race([localCallback, polling]);
+        controller.abort();
+        return result;
+    }
+    catch (err) {
+        controller.abort();
+        throw err;
+    }
+}
+function startLocalCallbackServer(state, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new Error('Cancelled'));
+            return;
+        }
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error('Timed out waiting for Claude authentication (3 minutes)'));
+        }, AUTH_TIMEOUT_MS);
+        signal.addEventListener('abort', () => {
+            clearTimeout(timeout);
+            server.close();
+        }, { once: true });
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url ?? '/', `http://localhost:${CALLBACK_PORT}`);
+            if (url.pathname !== CALLBACK_PATH) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Not found');
+                return;
+            }
+            const errorParam = url.searchParams.get('error');
+            const errorDesc = url.searchParams.get('error_description');
+            const codeParam = url.searchParams.get('code');
+            if (errorParam) {
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(callbackHtml(false, errorDesc || errorParam));
+                clearTimeout(timeout);
+                server.close();
+                reject(new Error(`Anthropic returned error: ${errorDesc || errorParam}`));
+                return;
+            }
+            if (!codeParam) {
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(callbackHtml(false, 'Missing authorization code'));
+                clearTimeout(timeout);
+                server.close();
+                reject(new Error('No authorization code in callback'));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(callbackHtml(true));
+            clearTimeout(timeout);
+            server.close();
+            resolve({ via: 'local', code: codeParam, state });
+        });
+        server.on('error', (err) => {
+            clearTimeout(timeout);
+            if (err.code === 'EADDRINUSE') {
+                logger.debug('Port %d in use, falling back to polling only', CALLBACK_PORT);
+                return;
+            }
+            reject(err);
+        });
+        server.listen(CALLBACK_PORT, '127.0.0.1');
+    });
+}
+async function pollForConnection(signal) {
+    const deadline = Date.now() + AUTH_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (signal.aborted)
+            throw new Error('Cancelled');
+        await sleep(POLL_INTERVAL_MS);
+        if (signal.aborted)
+            throw new Error('Cancelled');
+        try {
+            const config = await apiRequest('/api/v1/llm-config');
+            if (config.anthropicOAuthConnected) {
+                return { via: 'poll', config };
+            }
+        }
+        catch {
+            logger.debug('Poll attempt failed, retrying...');
+        }
+    }
+    throw new Error('Timed out waiting for Claude authentication (3 minutes)');
+}
+// ─── Disconnect Flow ───
+async function handleDisconnect() {
+    const { confirm } = await import('@inquirer/prompts');
+    const yes = await confirm({
+        message: 'Disconnect your Claude account?',
+        default: false,
+    });
+    if (!yes) {
+        console.log(chalk.dim('  Cancelled.'));
+        return;
+    }
+    await apiRequest('/api/v1/anthropic-oauth/disconnect', {
+        method: 'POST',
+    });
+    console.log(chalk.green('  ✓ Claude disconnected.'));
+    console.log(chalk.dim('  Your agents will need an API key to continue. Set one:'));
+    console.log(chalk.dim('  trading-boy config set-llm-key <your-api-key>'));
+}
+// ─── HTML for Browser Callback ───
+function callbackHtml(success, errorMsg) {
+    const title = success ? 'Claude Connected' : 'Connection Failed';
+    const icon = success ? '&#10003;' : '&#10007;';
+    const color = success ? '#22c55e' : '#ef4444';
+    const message = success
+        ? 'Your Claude subscription is now connected to Trading Boy.<br>You can close this tab.'
+        : `Something went wrong: ${escapeHtml(errorMsg ?? 'Unknown error')}.<br>Please try again.`;
+    return `<!DOCTYPE html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${title} — Trading Boy</title>
+<style>*{margin:0;padding:0;box-sizing:border-box}body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;background:#0a0a0a;color:#e5e5e5}
+.card{text-align:center;padding:3rem;max-width:480px}.icon{font-size:4rem;color:${color};margin-bottom:1rem}h1{font-size:1.5rem;margin-bottom:1rem}p{color:#a3a3a3;line-height:1.6}</style>
+</head><body><div class="card"><div class="icon">${icon}</div><h1>${title}</h1><p>${message}</p></div></body></html>`;
+}
+function escapeHtml(str) {
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+// ─── Helpers ───
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const ALLOWED_AUTH_DOMAINS = new Set([
+    'platform.claude.com',
+    'claude.ai',
+    'claude.com',
+]);
+function validateAuthUrl(url) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== 'https:') {
+        throw new Error(`Refusing to open non-HTTPS URL: ${url}`);
+    }
+    if (!ALLOWED_AUTH_DOMAINS.has(parsed.hostname)) {
+        throw new Error(`Refusing to open URL with untrusted domain: ${parsed.hostname}`);
+    }
+}
+async function openBrowser(url) {
+    try {
+        validateAuthUrl(url);
+        const { default: open } = await import('open');
+        await open(url);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.startsWith('Refusing to open')) {
+            console.error(chalk.red(`\n  ${message}`));
+            throw err;
+        }
+        console.log(chalk.yellow(`\n  Could not open browser automatically.`));
+        console.log(chalk.yellow(`  Please open this URL manually:\n`));
+        console.log(`  ${chalk.cyan.underline(url)}\n`);
+    }
+}
+// ─── Exported for onboarding ───
+export { handleConnect as connectClaude };
+//# sourceMappingURL=connect-claude.js.map

package/dist/commands/onboarding.js

@@ -237,11 +237,15 @@ export async function runOnboarding() {
     console.log('');
     console.log(chalk.dim('  Once you create an agent, it runs continuously on our servers:'));
     console.log('');
-    console.log(`  ${chalk.white('Scan')}      ${chalk.dim('Every 5 min (configurable) — scans your watchlist for setups')}`);
+    console.log(`  ${chalk.white('Scan')}      ${chalk.dim('Every 30 min by default — scans your watchlist for setups')}`);
     console.log(`  ${chalk.white('Analyze')}   ${chalk.dim('When a setup is found — deep context analysis via your LLM')}`);
     console.log(`  ${chalk.white('Decide')}    ${chalk.dim('After analysis — enter/exit/hold based on your strategy')}`);
     console.log(`  ${chalk.white('Learn')}     ${chalk.dim('After trades close — updates edge profile from outcomes')}`);
     console.log('');
+    console.log(chalk.dim('  Scan interval controls how often your agent checks for setups.'));
+    console.log(chalk.dim('  Lower intervals = more LLM calls = higher cost. Recommended: 30m.'));
+    console.log(chalk.dim('  Change it: trading-boy agent update <name> --scan-interval 15m'));
+    console.log('');
     console.log(chalk.dim('  Autonomy levels:'));
     console.log(`  ${chalk.cyan('OBSERVE_ONLY')}        ${chalk.dim('Scans and analyzes — takes no action')}`);
     console.log(`  ${chalk.cyan('SUGGEST')}             ${chalk.dim('Sends trade ideas to your Telegram')}`);

package/dist/commands/strategy-cmd.js

@@ -1,6 +1,6 @@
 import { Option } from 'commander';
 import chalk from 'chalk';
-import { createLogger } from '@trading-boy/core';
+import { createLogger, generateRegimeBehavior } from '@trading-boy/core';
 import { apiRequest } from '../api-client.js';
 import { padRight, handleApiError, ensureRemote } from '../utils.js';
 // ─── Logger ───
@@ -155,12 +155,7 @@ export function registerStrategyCommand(program) {
             agentId: options.agentId,
             tokens,
             setupTypes,
-            regimeBehavior: {
-                ACCUMULATION: { enabled: true, maxPositionSize: 0.25, confidenceThreshold: 0.6, preferredSetups: setupTypes },
-                MARKUP: { enabled: true, maxPositionSize: 0.5, confidenceThreshold: 0.5, preferredSetups: setupTypes },
-                DISTRIBUTION: { enabled: true, maxPositionSize: 0.15, confidenceThreshold: 0.7, preferredSetups: setupTypes },
-                MARKDOWN: { enabled: false, maxPositionSize: 0.1, confidenceThreshold: 0.8, preferredSetups: setupTypes },
-            },
+            regimeBehavior: generateRegimeBehavior(setupTypes),
             riskLimits: {
                 maxDrawdown: 0.2,
                 maxConcurrentPositions: 5,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trading-boy/cli",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "Trading Boy CLI — crypto context intelligence for traders and AI agents. Query real-time prices, funding rates, whale activity, and DeFi risk for 100+ Solana tokens and 229 Hyperliquid perpetuals.",
   "homepage": "https://cabal.ventures",
   "repository": {