desic-okx-agent 0.2.1 → 0.3.0

package/dist/cli/index.js

@@ -8,7 +8,7 @@ import { publicError } from "../core/errors.js";
 import { PACKAGE_VERSION } from "../core/version.js";
 import { checkOkxConnectivity, OKX_REST_BASE_URL } from "../network/connectivity.js";
 import { displayProxy, resolveProxy } from "../network/proxy.js";
-import { AccountService } from "../account/service.js";
+import { AccountService, detectAccountEnvironment } from "../account/service.js";
 import { runMcpServer } from "../mcp/server.js";
 import { RuntimeClient } from "../runtime/client.js";
 import { ask, askConfirm, askSecret } from "./prompts.js";
@@ -16,6 +16,20 @@ import { SetupCancelledError, inspectSetupTargets, parseSetupTargets, SETUP_TARG
 import { runSetupWizard } from "../setup/wizard.js";
 import { runDoctor, formatDoctor } from "./doctor.js";
 import { formatRuntimeStatus, formatToolHelp } from "./render.js";
+import { describeEnvironment, formatCoverageDetail, formatInstrumentTable, formatSyncReport, parseBarTime } from "./data-render.js";
+import fs from "node:fs";
+import path from "node:path";
+import { TEMPLATE_NAMES, isTemplateName, template } from "../strategy/templates.js";
+import { formatComparison, formatEquitySparkline, formatOptimizationReport, formatRunDetail, formatRunTable, formatTradeTable, formatValidation } from "./strategy-render.js";
+import { buildComparison, MAX_COMPARED_RUNS, MIN_COMPARED_RUNS } from "../report/compare.js";
+import { formatProfileTable, formatReadiness, formatSignalTable } from "./live-render.js";
+import { DEFAULT_BUDGET } from "../strategy/parameter-space.js";
+import { activeLocale, activeMessages, saveLocale } from "../i18n/locale.js";
+import { LOCALES, isLocale } from "../i18n/messages.js";
+import { SETTINGS_PATH, SETTING_SPECS, coerceSetting, formatSettingValue, loadSettings, withSetting } from "../strategy/settings.js";
+import { displayWidth, padEndDisplay } from "./width.js";
+import { openInBrowser, writeComparison, writeReport } from "../report/open.js";
+import { collectComparison, collectReport } from "../report/fetch.js";
 import { getToolHelp } from "../tools/help.js";
 import { checkForUpdate, installLatestVersion, OFFICIAL_NPM_REGISTRY, runInstalledCommand } from "../update/service.js";
 const program = new Command()
@@ -173,29 +187,670 @@ program.command("config-path")
     .action(() => {
     process.stdout.write(`${CONFIG_PATH}\n`);
 });
+program.command("lang")
+    .description("Show or set the display language (en / zh); the choice is saved")
+    .argument("[locale]", `one of ${LOCALES.join(", ")}`)
+    .option("--json", "Print machine-readable JSON")
+    .action((locale, options) => {
+    if (!locale) {
+        const current = activeLocale();
+        if (options.json || !process.stdout.isTTY)
+            print({ locale: current, available: LOCALES });
+        else
+            process.stdout.write(`${activeMessages().languageCurrent(current)}\n`);
+        return;
+    }
+    const requested = locale.toLowerCase();
+    if (!isLocale(requested))
+        throw new Error(`Unsupported locale '${locale}'. Available: ${LOCALES.join(", ")}`);
+    saveLocale(requested);
+    if (options.json || !process.stdout.isTTY)
+        print({ locale: requested, saved: true });
+    else
+        process.stdout.write(`${activeMessages().languageChanged(requested)}\n`);
+});
+const live = program.command("live").description("Run a validated strategy against a real account");
+live.command("list")
+    .description("List live profiles and their state")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    const result = await client.call("live_list_profiles", {});
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else
+        process.stdout.write(`${formatProfileTable(result.data)}\n`);
+});
+live.command("create")
+    .description("Create a live profile. Creating one never starts it.")
+    .requiredOption("--file <file>", "strategy .py file")
+    .requiredOption("--inst <instId>", "OKX instrument ID")
+    .requiredOption("--account <name>", "configured account alias")
+    .requiredOption("--entry-budget <usdt>", "margin ceiling for one entry")
+    .requiredOption("--side-budget <usdt>", "margin ceiling for one direction")
+    .requiredOption("--daily-loss <usdt>", "realized loss for the UTC day at which entries stop")
+    .option("--name <name>", "profile name; defaults to the file name")
+    .option("--environment <env>", "demo | live", "demo")
+    .option("--leverage <x>", "leverage", "10")
+    .option("--margin-mode <mode>", "cross | isolated", "cross")
+    .option("--cooldown <seconds>", "seconds after an order before another may be sent", "0")
+    .option("--params <file>", "JSON file of strategy parameters")
+    .option("--no-long", "forbid opening long positions")
+    .option("--no-short", "forbid opening short positions")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const file = String(options.file);
+    const client = await RuntimeClient.connect();
+    const result = await client.call("live_create_profile", {
+        name: options.name ? String(options.name) : path.basename(file, ".py"),
+        source: fs.readFileSync(file, "utf8"),
+        instId: String(options.inst),
+        account: String(options.account),
+        environment: String(options.environment),
+        leverage: Number(options.leverage),
+        marginMode: String(options.marginMode),
+        entryBudgetUsdt: Number(options.entryBudget),
+        sideBudgetUsdt: Number(options.sideBudget),
+        dailyLossLimitUsdt: Number(options.dailyLoss),
+        cooldownSeconds: Number(options.cooldown),
+        allowLong: options.long !== false,
+        allowShort: options.short !== false,
+        ...(options.params ? { params: readJsonFile(String(options.params), "--params") } : {})
+    });
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else {
+        process.stdout.write(`${activeMessages().liveProfileCreated(result.data.id)}\n`);
+        process.stdout.write(`  desic-okx live readiness --id ${result.data.id}\n`);
+    }
+});
+live.command("readiness")
+    .description("Show what still blocks this profile from being enabled")
+    .requiredOption("--id <profileId>", "profile id")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    const result = await client.call("live_readiness", { profileId: options.id });
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else
+        process.stdout.write(`${formatReadiness(result.data)}\n`);
+});
+live.command("start")
+    .description("Enable a profile so it trades on every closed minute")
+    .requiredOption("--id <profileId>", "profile id")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    const result = await client.call("live_start", { profileId: options.id });
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else {
+        const text = activeMessages();
+        process.stdout.write(`${text.liveProfileStarted(result.data.profile.name)}\n`);
+        process.stdout.write(`  ${text.liveEvidence(result.data.backtestRunId ?? "-")}\n`);
+        process.stdout.write(`  desic-okx live signals --id ${options.id}\n`);
+    }
+});
+live.command("stop")
+    .description("Disable a profile. Always allowed.")
+    .requiredOption("--id <profileId>", "profile id")
+    .option("--reason <text>", "recorded on the profile")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    const result = await client.call("live_stop", {
+        profileId: options.id,
+        ...(options.reason ? { reason: options.reason } : {})
+    });
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else
+        process.stdout.write(`${activeMessages().liveProfileStopped(result.data.name)}\n`);
+});
+live.command("signals")
+    .description("Show what a profile decided, including every refusal")
+    .requiredOption("--id <profileId>", "profile id")
+    .option("--limit <count>", "rows to show", "30")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    const result = await client.call("live_signals", {
+        profileId: options.id,
+        limit: Number(options.limit)
+    });
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else
+        process.stdout.write(`${formatSignalTable(result.data)}\n`);
+});
+live.command("agent-access")
+    .description("Show or set whether MCP clients may create and enable live profiles")
+    .argument("[state]", "on | off; omit to show the current setting")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (state, options) => {
+    const text = activeMessages();
+    const config = loadConfig();
+    const current = config.live.agentAccess;
+    if (state === undefined) {
+        if (options.json || !process.stdout.isTTY)
+            print({ agentAccess: current });
+        else
+            process.stdout.write(`${text.agentAccessState(current ? "on" : "off")}\n`);
+        return;
+    }
+    const target = state.trim().toLowerCase();
+    if (target !== "on" && target !== "off")
+        throw new Error(text.agentAccessUsage);
+    saveConfig({ ...config, live: { ...config.live, agentAccess: target === "on" } });
+    if (options.json || !process.stdout.isTTY) {
+        print({ agentAccess: target === "on", restartRequired: true });
+        return;
+    }
+    process.stdout.write(`${text.agentAccessSet(target)}\n`);
+    process.stdout.write(`  ${text.agentAccessRestart}\n`);
+    if (target === "on")
+        process.stdout.write(`  ${text.agentAccessWarning}\n`);
+});
+live.command("delete")
+    .description("Delete a stopped profile and its signal history")
+    .requiredOption("--id <profileId>", "profile id")
+    .option("--yes", "confirm deletion")
+    .action(async (options) => {
+    if (!options.yes)
+        throw new Error(activeMessages().liveDeleteConfirm(options.id));
+    const client = await RuntimeClient.connect();
+    print(await client.call("live_delete_profile", { profileId: options.id }));
+});
+const market = program.command("market").description("Inspect and switch the market data environment");
+market.command("env")
+    .description("Show or switch which OKX venue supplies market data")
+    .argument("[environment]", "demo | live; omit to show the current one")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (requested, options) => {
+    const text = activeMessages();
+    const config = loadConfig();
+    const current = config.market.environment;
+    if (requested === undefined) {
+        if (options.json || !process.stdout.isTTY)
+            print({ environment: current });
+        else
+            process.stdout.write(`${text.marketEnvironmentLabel} ${describeEnvironment(current) ?? current}\n`);
+        return;
+    }
+    const target = requested.trim().toLowerCase();
+    if (target !== "demo" && target !== "live") {
+        throw new Error(text.environmentUsage);
+    }
+    if (target === current) {
+        process.stdout.write(`${text.environmentAlready(target)}\n`);
+        return;
+    }
+    saveConfig({ ...config, market: { ...config.market, environment: target } });
+    if (options.json || !process.stdout.isTTY) {
+        print({ environment: target, previous: current, restartRequired: true });
+        return;
+    }
+    process.stdout.write(`${text.environmentSwitched(describeEnvironment(target) ?? target)}\n`);
+    // The runtime reads this once at startup, so saying it changed without saying it
+    // has not taken effect yet would be worse than saying nothing.
+    process.stdout.write(`${text.environmentRestartHint}\n`);
+    if (target === "demo")
+        process.stdout.write(`${text.demoDataWarning}\n`);
+});
+const strategy = program.command("strategy").description("Write, validate, and backtest Python strategies");
+strategy.command("new")
+    .description("Write a starting strategy file")
+    .requiredOption("--out <file>", "destination .py file")
+    .option("--template <name>", `one of ${TEMPLATE_NAMES.join(", ")}`, "ema-trend")
+    .option("--force", "overwrite an existing file")
+    .action((options) => {
+    if (!isTemplateName(options.template)) {
+        throw new Error(`Unknown template '${options.template}'. Available: ${TEMPLATE_NAMES.join(", ")}`);
+    }
+    if (fs.existsSync(options.out) && !options.force) {
+        throw new Error(`${options.out} already exists. Pass --force to overwrite it.`);
+    }
+    fs.writeFileSync(options.out, template(options.template), "utf8");
+    process.stdout.write(`Wrote ${options.template} template to ${options.out}\n`);
+});
+strategy.command("env")
+    .description("Check or prepare the local Python strategy environment")
+    .option("--setup", "Create the environment and install packages")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    if (options.setup) {
+        const result = await client.call("strategy_environment_setup", {});
+        if (options.json || !process.stdout.isTTY)
+            print(result);
+        else {
+            for (const line of result.data.log ?? [])
+                process.stdout.write(`  ${line}\n`);
+            process.stdout.write("Environment ready\n");
+        }
+        return;
+    }
+    const result = await client.call("strategy_environment", {});
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else {
+        const status = result.data;
+        process.stdout.write(`Python       ${status.interpreter ?? "not found"}${status.version ? ` (${status.version})` : ""}\n`);
+        process.stdout.write(`Engine       ${status.engineRoot}\n`);
+        process.stdout.write(`Ready        ${status.ready ? "yes" : "no"}\n`);
+        for (const problem of status.problems ?? [])
+            process.stdout.write(`  ! ${problem}\n`);
+    }
+});
+strategy.command("validate")
+    .description("Statically validate a strategy file")
+    .requiredOption("--file <file>", "strategy .py file")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const source = fs.readFileSync(options.file, "utf8");
+    const client = await RuntimeClient.connect();
+    const result = await client.call("strategy_validate_source", { source });
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else
+        process.stdout.write(`${formatValidation(result.data, options.file)}\n`);
+    if (!result.data.valid)
+        process.exitCode = 1;
+});
+const backtestCommand = strategy.command("backtest")
+    .description("Queue a backtest and print its run id")
+    .requiredOption("--file <file>", "strategy .py file")
+    .requiredOption("--inst <instId>", "OKX instrument ID")
+    .option("--days <days>", "trailing evaluation window in days", "30")
+    .option("--from <date>", "inclusive evaluation start, for example 2026-07-01")
+    .option("--to <date>", "inclusive evaluation end")
+    .option("--params <file>", "JSON file of strategy parameters")
+    .option("--intervals <list>", "extra timeframes to derive, for example 15m,1H")
+    .option("--follow", "wait for completion and print the report")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const request = {
+        instId: String(options.inst),
+        source: fs.readFileSync(String(options.file), "utf8"),
+        strategyName: path.basename(String(options.file), ".py")
+    };
+    // Only flags the user actually passed are forwarded; the rest fall through to
+    // the saved settings, so `strategy settings` genuinely takes effect.
+    for (const spec of SETTING_SPECS) {
+        const provided = options[camelFlag(spec.flag)];
+        if (provided === undefined)
+            continue;
+        request[spec.key] = coerceSetting(spec, provided);
+    }
+    if (options.from)
+        request.fromMs = parseBarTime(String(options.from), "--from");
+    if (options.to)
+        request.toMs = parseBarTime(String(options.to), "--to");
+    if (!options.from)
+        request.days = Number(options.days);
+    if (options.params)
+        request.params = JSON.parse(fs.readFileSync(String(options.params), "utf8"));
+    if (options.intervals) {
+        request.intervals = String(options.intervals).split(",").map((item) => item.trim()).filter(Boolean);
+    }
+    const client = await RuntimeClient.connect();
+    const queued = await client.call("strategy_run_backtest", request);
+    const runId = queued.data.runId;
+    if (!options.follow) {
+        if (options.json || !process.stdout.isTTY)
+            print(queued);
+        else
+            process.stdout.write(`Queued ${runId}\n  desic-okx strategy report --run ${runId}\n`);
+        return;
+    }
+    const final = await followRun(client, runId, Boolean(options.json));
+    if (options.json || !process.stdout.isTTY)
+        print({ data: final });
+    else
+        process.stdout.write(`${formatRunDetail(final)}\n`);
+    if (final.status !== "completed")
+        process.exitCode = 1;
+});
+const optimizeCommand = strategy.command("optimize")
+    .description("Search a parameter space, ranking candidates on a held-back segment")
+    .requiredOption("--file <file>", "strategy .py file")
+    .requiredOption("--inst <instId>", "OKX instrument ID")
+    .requiredOption("--space <file>", "JSON file of { param: { min, max, step } } ranges")
+    .option("--budget <count>", "candidates to evaluate", String(DEFAULT_BUDGET))
+    .option("--days <days>", "trailing evaluation window in days", "90")
+    .option("--from <date>", "inclusive evaluation start, for example 2026-05-01")
+    .option("--to <date>", "inclusive evaluation end")
+    .option("--params <file>", "JSON file of the strategy's base parameters")
+    .option("--intervals <list>", "extra timeframes to derive, for example 15m,1H")
+    .option("--top <count>", "candidates to print when following", "20")
+    .option("--follow", "wait for completion and print the candidate table")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const request = {
+        instId: String(options.inst),
+        source: fs.readFileSync(String(options.file), "utf8"),
+        strategyName: path.basename(String(options.file), ".py"),
+        space: readJsonFile(String(options.space), "--space"),
+        budget: Number(options.budget)
+    };
+    for (const spec of SETTING_SPECS) {
+        const provided = options[camelFlag(spec.flag)];
+        if (provided === undefined)
+            continue;
+        request[spec.key] = coerceSetting(spec, provided);
+    }
+    if (options.from)
+        request.fromMs = parseBarTime(String(options.from), "--from");
+    if (options.to)
+        request.toMs = parseBarTime(String(options.to), "--to");
+    if (!options.from)
+        request.days = Number(options.days);
+    // The space is checked against these, so a strategy whose defaults live in
+    // `ctx.params.get(...)` calls needs them passed here for the check to work.
+    if (options.params)
+        request.params = readJsonFile(String(options.params), "--params");
+    if (options.intervals) {
+        request.intervals = String(options.intervals).split(",").map((item) => item.trim()).filter(Boolean);
+    }
+    const client = await RuntimeClient.connect();
+    const queued = await client.call("strategy_run_optimize", request);
+    const runId = queued.data.runId;
+    if (!options.follow) {
+        if (options.json || !process.stdout.isTTY)
+            print(queued);
+        else
+            process.stdout.write(`Queued ${runId}\n  desic-okx strategy optimize-report --run ${runId}\n`);
+        return;
+    }
+    const final = await followRun(client, runId, Boolean(options.json));
+    const report = await client.call("strategy_get_optimization", {
+        runId,
+        top: Number(options.top)
+    });
+    if (options.json || !process.stdout.isTTY)
+        print(report);
+    else
+        process.stdout.write(`${formatOptimizationReport(report.data)}\n`);
+    if (final.status !== "completed")
+        process.exitCode = 1;
+});
+for (const spec of SETTING_SPECS) {
+    const exists = optimizeCommand.options.some((option) => option.long === `--${spec.flag}`);
+    if (!exists)
+        optimizeCommand.option(`--${spec.flag} <value>`, settingFlagHelp(spec));
+}
+strategy.command("optimize-report")
+    .description("Show an optimize run's candidates, ranked by the held-back segment")
+    .requiredOption("--run <runId>", "optimize run id")
+    .option("--top <count>", "candidates to print", "20")
+    .option("--adopt <file>", "write the best parameters to this JSON file")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    const report = await client.call("strategy_get_optimization", {
+        runId: options.run,
+        top: Number(options.top)
+    });
+    if (options.json || !process.stdout.isTTY)
+        print(report);
+    else
+        process.stdout.write(`${formatOptimizationReport(report.data)}\n`);
+    if (!options.adopt)
+        return;
+    // Written beside the strategy rather than into it: the source is the user's,
+    // and a tool that edits it takes away the ability to see what changed.
+    const best = report.data.candidates.find((candidate) => candidate.status === "completed");
+    if (!best) {
+        process.stderr.write(`${activeMessages().noBestCandidate}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    fs.writeFileSync(options.adopt, `${JSON.stringify(best.params, null, 2)}\n`, "utf8");
+    process.stdout.write(`${activeMessages().adoptedParams(options.adopt)}\n  ${activeMessages().adoptHint(options.run)}\n`);
+});
+strategy.command("runs")
+    .description("List recent strategy runs")
+    .option("--limit <count>", "maximum rows", "20")
+    .option("--status <status>", "queued|running|completed|failed|cancelled")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    const input = { limit: Number(options.limit) };
+    if (options.status)
+        input.status = options.status;
+    const result = await client.call("strategy_list_runs", input);
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else
+        process.stdout.write(`${formatRunTable(result.data)}\n`);
+});
+strategy.command("report")
+    .description("Show one run's metrics, equity curve, and trades")
+    .requiredOption("--run <runId>", "strategy run id")
+    .option("--open", "Build an HTML report and open it in the browser")
+    .option("--equity", "include the equity sparkline")
+    .option("--trades", "include closed trades")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    if (options.open) {
+        const file = writeReport(await collectReport(client, options.run));
+        const opened = openInBrowser(file);
+        if (options.json || !process.stdout.isTTY)
+            print({ file, opened });
+        else
+            process.stdout.write(`${opened ? activeMessages().reportOpened : activeMessages().reportWritten}\n${file}\n`);
+        return;
+    }
+    // Read through the paginating collector rather than guessing a page size:
+    // a limit above the tool's cap is rejected, and one below the row count
+    // silently returns a prefix.
+    const needsDetail = Boolean(options.equity || options.trades);
+    const run = await client.call("strategy_get_run", { runId: options.run });
+    const collected = needsDetail ? await collectReport(client, options.run) : null;
+    if (options.json || !process.stdout.isTTY) {
+        const payload = { run: run.data };
+        if (options.equity)
+            payload.equity = collected?.equity ?? [];
+        if (options.trades)
+            payload.trades = collected?.trades ?? [];
+        print(payload);
+        return;
+    }
+    process.stdout.write(`${formatRunDetail(run.data)}\n`);
+    if (options.equity && collected) {
+        process.stdout.write(`\n${activeMessages().equityHeading}\n${formatEquitySparkline(collected.equity)}\n`);
+    }
+    if (options.trades && collected) {
+        process.stdout.write(`\n${activeMessages().tradesHeading}\n${formatTradeTable(collected.trades)}\n`);
+    }
+});
+strategy.command("compare")
+    .description("Put two or more runs side by side, normalizing their equity curves")
+    .requiredOption("--runs <ids>", "comma-separated run ids, for example bt_a,bt_b")
+    .option("--open", "Build an HTML comparison and open it in the browser")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const runIds = options.runs.split(",").map((item) => item.trim()).filter(Boolean);
+    if (runIds.length < MIN_COMPARED_RUNS)
+        throw new Error(activeMessages().compareNeedsTwo);
+    if (runIds.length > MAX_COMPARED_RUNS)
+        throw new Error(activeMessages().compareTooMany(MAX_COMPARED_RUNS));
+    const client = await RuntimeClient.connect();
+    const report = buildComparison(await collectComparison(client, runIds));
+    if (options.open) {
+        const file = writeComparison(report);
+        const opened = openInBrowser(file);
+        if (options.json || !process.stdout.isTTY)
+            print({ file, opened, warnings: report.warnings });
+        else {
+            // Warnings are printed even when the document opens elsewhere: a reader who
+            // switches to the browser should not be the only one who sees them.
+            for (const warning of report.warnings)
+                process.stderr.write(`! ${warning.message}\n`);
+            process.stdout.write(`${opened ? activeMessages().reportOpened : activeMessages().reportWritten}\n${file}\n`);
+        }
+        return;
+    }
+    if (options.json || !process.stdout.isTTY) {
+        print({
+            runs: report.runs,
+            warnings: report.warnings,
+            differingAssumptions: report.differingAssumptions,
+            sharedAssumptions: report.sharedAssumptions
+        });
+        return;
+    }
+    process.stdout.write(`${formatComparison(report)}\n`);
+});
+strategy.command("delete")
+    .description("Delete a run and its stored equity curve, trades, and decisions")
+    .requiredOption("--run <runId>", "strategy run id")
+    .option("--yes", "skip the confirmation")
+    .action(async (options) => {
+    // Irreversible, so it is confirmed rather than assumed.
+    if (!options.yes) {
+        throw new Error(`This removes ${options.run} and its stored series. Pass --yes to confirm.`);
+    }
+    const client = await RuntimeClient.connect();
+    print(await client.call("strategy_delete_run", { runId: options.run }));
+});
+strategy.command("cancel")
+    .description("Cancel a queued or running backtest")
+    .requiredOption("--run <runId>", "strategy run id")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    print(await client.call("strategy_cancel_run", { runId: options.run }));
+});
+for (const spec of SETTING_SPECS) {
+    // `--days` is already declared above with its own help text; re-registering a
+    // flag makes commander throw at startup.
+    const exists = backtestCommand.options.some((option) => option.long === `--${spec.flag}`);
+    if (!exists)
+        backtestCommand.option(`--${spec.flag} <value>`, settingFlagHelp(spec));
+}
+const settings = strategy.command("settings")
+    .description("Show or change the assumptions every backtest uses")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    const current = (await client.call("strategy_settings", {})).data;
+    if (options.json || !process.stdout.isTTY)
+        print({ settings: current, path: SETTINGS_PATH });
+    else
+        process.stdout.write(`${formatSettingsTable(current)}\n`);
+});
+settings.command("set")
+    .description("Change one or more settings, as key=value pairs")
+    .argument("<pairs...>", "for example leverage=5 budget-pct=0.1")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (pairs, options) => {
+    // Validated locally for a fast, clear error, then applied through the
+    // runtime so both views stay in agreement.
+    let candidate = loadSettings();
+    const values = {};
+    const changed = [];
+    for (const pair of pairs) {
+        const separator = pair.indexOf("=");
+        if (separator <= 0)
+            throw new Error(`Expected key=value, received '${pair}'`);
+        const applied = withSetting(candidate, pair.slice(0, separator), pair.slice(separator + 1));
+        candidate = applied.settings;
+        values[applied.spec.key] = candidate[applied.spec.key];
+        changed.push(applied.spec.key);
+    }
+    const client = await RuntimeClient.connect();
+    const current = (await client.call("strategy_settings_update", { values })).data;
+    if (options.json || !process.stdout.isTTY)
+        print({ settings: current, changed });
+    else
+        process.stdout.write(`${activeMessages().settingsSaved}\n${formatSettingsTable(current)}\n`);
+});
+settings.command("reset")
+    .description("Restore every setting to its default")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    const restored = (await client.call("strategy_settings_update", { values: {}, reset: true })).data;
+    if (options.json || !process.stdout.isTTY)
+        print({ settings: restored, reset: true });
+    else
+        process.stdout.write(`${formatSettingsTable(restored)}\n`);
+});
+const data = program.command("data").description("Inspect and download local one-minute history");
+data.command("list")
+    .description("List instruments with locally stored history and their covered range")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    const result = await client.call("data_list_instruments", {});
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else
+        process.stdout.write(`${formatInstrumentTable(result.data, describeEnvironment(result.meta?.environment))}\n`);
+});
+data.command("coverage")
+    .description("Show the stored range, bar count, and gaps for one instrument")
+    .requiredOption("--inst <instId>", "OKX instrument ID, for example BTC-USDT-SWAP")
+    .option("--gap-limit <count>", "Maximum gaps to list", "50")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const client = await RuntimeClient.connect();
+    const result = await client.call("data_coverage", {
+        instId: options.inst,
+        gapLimit: Number(options.gapLimit)
+    });
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else
+        process.stdout.write(`${formatCoverageDetail(result.data, options.inst)}\n`);
+});
+data.command("download")
+    .description("Download or repair local one-minute history. Higher timeframes are derived from it.")
+    .requiredOption("--inst <instId>", "OKX instrument ID, for example BTC-USDT-SWAP")
+    .option("--days <days>", "Trailing window in days", "30")
+    .option("--from <date>", "Inclusive start, for example 2026-01-01")
+    .option("--to <date>", "Inclusive end; defaults to the newest closed minute")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options) => {
+    const request = { instId: options.inst };
+    if (options.from)
+        request.fromMs = parseBarTime(options.from, "--from");
+    if (options.to)
+        request.toMs = parseBarTime(options.to, "--to");
+    if (!options.from)
+        request.days = Number(options.days);
+    const client = await RuntimeClient.connect();
+    const result = await client.call("data_download", request);
+    if (options.json || !process.stdout.isTTY)
+        print(result);
+    else
+        process.stdout.write(`${formatSyncReport(result.data)}\n`);
+});
 const account = program.command("account").description("Manage named OKX accounts");
 account.command("add")
     .description("Add or replace a named account")
     .option("--name <name>", "account alias")
-    .option("--environment <environment>", "demo or live")
     .action(async (options) => {
     const name = options.name?.trim() || await ask("Account name", "default");
-    const environmentValue = options.environment?.trim() || await ask("Environment (demo/live)", "demo");
-    if (environmentValue !== "demo" && environmentValue !== "live")
-        throw new Error("Environment must be demo or live");
     const apiKey = await askSecret("API Key");
     const secretKey = await askSecret("Secret Key");
     const passphrase = await askSecret("Passphrase");
     if (!apiKey || !secretKey || !passphrase)
         throw new Error("All three credential fields are required");
-    const config = loadStoredConfig();
-    const candidate = structuredClone(config);
-    candidate.accounts[name] = { environment: environmentValue, apiKey, secretKey, passphrase };
+    const detected = await detectCredentials({ name, apiKey, secretKey, passphrase });
+    const candidate = loadStoredConfig();
+    candidate.accounts[name] = {
+        environment: detected.account.environment,
+        apiKey,
+        secretKey,
+        passphrase
+    };
     candidate.defaultAccount ??= name;
-    const verified = await verifyAccount(candidate, name);
     saveConfig(candidate);
     await stopForReload();
-    print({ saved: true, name, environment: environmentValue, permissions: verified.data, configPath: CONFIG_PATH });
+    print({ saved: true, name, environment: detected.account.environment, permissions: detected.config, configPath: CONFIG_PATH });
 });
 account.command("list")
     .description("List configured account aliases")
@@ -256,34 +911,34 @@ account.command("rename")
     print({ renamed: true, from: oldName, to: newName, default: config.defaultAccount === newName });
 });
 account.command("edit")
-    .description("Edit an account environment or replace its credentials")
+    .description("Verify an account or replace its credentials")
     .argument("<name>", "account alias")
-    .option("--environment <environment>", "demo or live")
     .option("--replace-credentials", "Prompt for replacement credentials")
     .action(async (name, options) => {
     const config = loadStoredConfig();
     const current = config.accounts[name];
     if (!current)
         throw new Error(`Account '${name}' was not found`);
-    const environment = options.environment?.trim() || await ask("Environment (demo/live)", current.environment);
-    if (environment !== "demo" && environment !== "live")
-        throw new Error("Environment must be demo or live");
-    const normalizedEnvironment = environment;
     const replace = options.replaceCredentials ?? await askConfirm("Replace API credentials", false);
-    const updated = { ...current, environment: normalizedEnvironment };
+    const credentials = { name, apiKey: current.apiKey, secretKey: current.secretKey, passphrase: current.passphrase };
     if (replace) {
-        updated.apiKey = await askSecret("API Key");
-        updated.secretKey = await askSecret("Secret Key");
-        updated.passphrase = await askSecret("Passphrase");
-        if (!updated.apiKey || !updated.secretKey || !updated.passphrase)
+        credentials.apiKey = await askSecret("API Key");
+        credentials.secretKey = await askSecret("Secret Key");
+        credentials.passphrase = await askSecret("Passphrase");
+        if (!credentials.apiKey || !credentials.secretKey || !credentials.passphrase)
             throw new Error("All three credential fields are required");
     }
+    const detected = await detectCredentials(credentials, current.environment);
     const candidate = structuredClone(config);
-    candidate.accounts[name] = updated;
-    const verified = await verifyAccount(candidate, name);
+    candidate.accounts[name] = {
+        environment: detected.account.environment,
+        apiKey: credentials.apiKey,
+        secretKey: credentials.secretKey,
+        passphrase: credentials.passphrase
+    };
     saveConfig(candidate);
     await stopForReload();
-    print({ saved: true, name, environment, permissions: verified.data });
+    print({ saved: true, name, environment: detected.account.environment, permissions: detected.config });
 });
 account.command("remove")
     .description("Remove one account")
@@ -299,6 +954,12 @@ account.command("remove")
     await stopForReload();
     print({ removed: true, name });
 });
+program.command("shell", { isDefault: true })
+    .description("Open the interactive strategy research shell (default)")
+    .action(async () => {
+    const { runShell } = await import("../tui/index.js");
+    await runShell();
+});
 try {
     await program.parseAsync(process.argv);
 }
@@ -315,9 +976,10 @@ async function stopForReload() {
     }
     catch { }
 }
-async function verifyAccount(config, name) {
+async function detectCredentials(credentials, preferred) {
+    const config = loadStoredConfig();
     const client = new OkxClient(OKX_REST_BASE_URL, resolveProxy(config.proxy.url).url);
-    return new AccountService(config, client).verify(name);
+    return detectAccountEnvironment(client, credentials, preferred);
 }
 function parseSkillTargets(value) {
     const targets = value.split(",").map((item) => item.trim()).filter(Boolean);
@@ -336,7 +998,76 @@ function resolveSkillTargets(value) {
         throw new Error("No installed Codex or Claude Code Skills were detected; pass --targets to install them");
     return detected;
 }
+/**
+ * Reads a JSON argument file, naming the flag in any failure.
+ *
+ * `JSON.parse` reports only a character offset, which is unhelpful when two flags
+ * both take a file and either could be the one at fault.
+ */
+function readJsonFile(file, flag) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        throw new Error(`${flag} file '${file}' could not be read`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`${flag} file '${file}' is not valid JSON: ${error instanceof Error ? error.message : error}`);
+    }
+}
+/** `budget-pct` becomes `budgetPct`, which is how commander stores the option. */
+function camelFlag(flag) {
+    return flag.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+}
+function settingFlagHelp(spec) {
+    const messages = activeMessages();
+    const bounds = spec.minimum !== undefined && spec.maximum !== undefined ? ` (${spec.minimum}-${spec.maximum})` : "";
+    return `${messages[spec.label]}${bounds}; defaults to the saved setting`;
+}
+function formatSettingsTable(settings) {
+    const messages = activeMessages();
+    const width = Math.max(...SETTING_SPECS.map((spec) => displayWidth(messages[spec.label])));
+    const lines = [activeMessages().settingsHeading, ""];
+    for (const spec of SETTING_SPECS) {
+        const value = settings[spec.key];
+        // A marker beats printing the default beside every row: only the changed
+        // ones need attention.
+        const marker = value === spec.default ? " " : "*";
+        lines.push(`${marker} ${padEndDisplay(messages[spec.label], width + 2)}${padEndDisplay(formatSettingValue(spec, value), 12)}--${spec.flag}`);
+    }
+    lines.push("", SETTINGS_PATH);
+    return lines.join("\n");
+}
 function print(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
+/** Carriage return plus "erase to end of line", written as an escape so no raw control byte sits in source. */
+const CLEAR_LINE = "\r\u001b[K";
+/**
+ * Polls a run to completion, rewriting one progress line in place.
+ *
+ * A backtest can take minutes, so it is queued rather than held open on a single
+ * request; this is the interactive counterpart to that design.
+ */
+async function followRun(client, runId, quiet) {
+    const interactive = !quiet && process.stdout.isTTY;
+    for (;;) {
+        const response = await client.call("strategy_get_run", { runId });
+        const run = response.data;
+        if (run.status === "completed" || run.status === "failed" || run.status === "cancelled") {
+            if (interactive)
+                process.stdout.write(CLEAR_LINE);
+            return run;
+        }
+        if (interactive) {
+            const eta = run.etaMs === null ? "" : `  eta ${Math.max(1, Math.round(run.etaMs / 1000))}s`;
+            process.stdout.write(`${CLEAR_LINE}  ${runId}  ${run.status}  ${run.progressPct.toFixed(1)}%${eta}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+}
 //# sourceMappingURL=index.js.map