jcc_hyper_tool 0.1.4 → 0.1.6

package/dist/cli/advisorCli.js

@@ -0,0 +1,706 @@
+import { randomUUID } from "node:crypto";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import * as readline from "node:readline/promises";
+import { DEFAULT_DEEPSEEK_MODEL } from "../advisor/deepseekClient.js";
+import { executeAdvisorAction, runAdvisorModelTurnWithRepair } from "../advisor/adviseEngine.js";
+import { advisorActionToCliArgs, buildGlobalPrefix, formatCliInvocation, } from "../advisor/actionRunner.js";
+import { buildAdvisorMarketSnapshot } from "../advisor/contextBuilder.js";
+import { formatAdvisorExecutedDisplay, formatAdvisorShowHeader, formatAdvisorTurnDisplay, UNLIMITED_REASONING_PREVIEW, } from "../advisor/adviseDisplay.js";
+import { resolveAdvisorExecutionPolicy, resolveAdvisorSzCap, prepareAdvisorActionForExecution } from "../advisor/executionPolicy.js";
+import { buildAdvisorSystemPrompt, formatFirstUserPayload } from "../advisor/promptTemplate.js";
+import { listPendingAmbushIntents } from "../advisor/ambushPolicy.js";
+import { buildActivePositionPlan } from "../advisor/positionPlan.js";
+import { writeAdvisorSessionLog } from "../advisor/sessionLog.js";
+import { loadEffectiveConfig, requireUserContext } from "../core/config.js";
+import { ConfigError } from "../core/errors.js";
+import { HyperliquidInfoClient } from "../core/hyperliquid/client.js";
+import { clearUserProfile, mergeUserProfileDefaults, upsertUserProfileFields, } from "../core/state/profileStore.js";
+import { UserProfileSchema } from "../core/state/schema.js";
+import { defaultAdvisorLogDir } from "../core/state/statePaths.js";
+import { readOrCreateTradeStateFile } from "../core/state/store.js";
+import { requireStdinYes } from "./confirm.js";
+import { printJson, readGlobalOptions, requireStateCliEnabled, resolveTradeStatePath, } from "./util.js";
+function requireApiKey() {
+    const k = process.env.DEEPSEEK_API_KEY?.trim();
+    if (!k) {
+        throw new ConfigError("DEEPSEEK_API_KEY is required for `advise`.");
+    }
+    return k;
+}
+function parseMaxSz(raw) {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new ConfigError("--max-sz must be a positive finite number.");
+    }
+    return n;
+}
+function parseOptionalConfidence(raw, flag) {
+    if (raw === undefined || raw.trim() === "") {
+        return undefined;
+    }
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 0 || n > 1) {
+        throw new ConfigError(`${flag} must be between 0 and 1.`);
+    }
+    return n;
+}
+function parseOptionalNonNegative(raw, flag) {
+    if (raw === undefined || raw.trim() === "") {
+        return undefined;
+    }
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 0) {
+        throw new ConfigError(`${flag} must be a non-negative finite number.`);
+    }
+    return n;
+}
+function parseOptionalUnitInterval(raw, flag) {
+    if (raw === undefined || raw.trim() === "") {
+        return undefined;
+    }
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 0 || n > 1) {
+        throw new ConfigError(`${flag} must be between 0 and 1.`);
+    }
+    return n;
+}
+async function persistAndPrintSession(logPath, session) {
+    await writeAdvisorSessionLog(logPath, session);
+}
+function globalArgs(globals) {
+    return {
+        network: globals.network,
+        apiUrl: globals.apiUrl,
+        stateFile: globals.stateFile,
+        noState: globals.noState,
+    };
+}
+async function readLatestAdvisorMid(logDir, coin) {
+    try {
+        const entries = await readdir(logDir).catch(() => []);
+        const jsonFiles = entries
+            .filter((e) => e.endsWith(".json"))
+            .map((e) => path.join(logDir, e))
+            .sort()
+            .reverse();
+        for (const file of jsonFiles.slice(0, 20)) {
+            const raw = await readFile(file, "utf-8");
+            const session = JSON.parse(raw);
+            if (session.coin !== coin)
+                continue;
+            const snap = session.marketSnapshot;
+            if (!snap)
+                continue;
+            const mid = snap.mid;
+            if (typeof mid === "number" && Number.isFinite(mid) && mid > 0)
+                return mid;
+        }
+    }
+    catch {
+        // ignore — no previous sessions
+    }
+    return null;
+}
+function collectPair(value, prev) {
+    return [...prev, value];
+}
+function requireRecordedAdvisorStatePath(cmd, explicit) {
+    requireStateCliEnabled(cmd, "`advisor profile` / `advise profile`");
+    const p = resolveTradeStatePath(cmd, explicit);
+    if (!p) {
+        throw new ConfigError("Unexpected: advisor profile needs a trade-state path.");
+    }
+    return p;
+}
+/** `profile show|set|clear` — mounted under both `advisor` and `advise`. */
+function attachAdvisorProfileCommands(parent) {
+    const profile = parent
+        .command("profile")
+        .description("Risk profile (merged into `advise` system prompt)");
+    profile
+        .command("show")
+        .description("Print merged userProfile JSON")
+        .option("--state-file <path>", "trade-state path")
+        .action(async (o, cmd) => {
+        readGlobalOptions(cmd);
+        const statePath = requireRecordedAdvisorStatePath(cmd, o.stateFile);
+        const f = await readOrCreateTradeStateFile(statePath, Date.now());
+        printJson({ userProfile: mergeUserProfileDefaults(f.userProfile) });
+    });
+    profile
+        .command("set")
+        .description("Update userProfile (atomic write; does not touch intents)")
+        .option("--state-file <path>", "trade-state path")
+        .option("--risk <level>", "conservative | balanced | aggressive")
+        .option("--max-sz <n>", "defaultMaxSz")
+        .option("--min-sz <n>", "defaultMinSz (minimum bracket sz floor)")
+        .option("--require-tpsl", "Force requireTpsl true on profile when passed", false)
+        .option("--no-require-tpsl", "Force requireTpsl false on profile when passed", false)
+        .option("--price-dev-pct <n>", "priceDeviationPctMax decimal fraction (e.g. 0.03)")
+        .option("--notes <text>", "tradingStyleNotes")
+        .option("--min-confidence <n>", "minConfidenceToExecute (0–1, 0=off)")
+        .option("--limit-jitter-pct <n>", "limitPriceJitterPct (e.g. 0.002)")
+        .option("--sl-entry-shift <n>", "bracketSlEntryShift (0–1, 1=entry at model SL)")
+        .option("--execute-cooldown-sec <n>", "executeCooldownSec between same coin+action (+ side for bracket)")
+        .option("--anti-rush-close-min-sec <n>", "antiRushCloseMinSec (block early close_position)")
+        .option("--protection-grace-sec <n>", "protectionGraceSec (wait for reconcile TP/SL after fill)")
+        .option("--min-close-pnl-pct <n>", "minClosePnlPct (block close on tiny PnL unless tp_unreachable)")
+        .option("--ambush-replace-dev-pct <n>", "ambushReplaceDeviationPct (default: priceDeviationPctMax)")
+        .option("--default-ambush-expires-min <n>", "defaultAmbushExpiresMin reference for model")
+        .option("--no-forbid-cancel-all-ambush", "Allow cancel_all while TTL ambush pending", false)
+        .option("--coin-max <pair>", "COIN=size max override (repeatable)", collectPair, [])
+        .option("--coin-min <pair>", "COIN=size min override (repeatable)", collectPair, [])
+        .action(async (opts, cmd) => {
+        readGlobalOptions(cmd);
+        const statePath = requireRecordedAdvisorStatePath(cmd, opts.stateFile);
+        const now = Date.now();
+        if (opts.noRequireTpsl && opts.requireTpsl) {
+            throw new ConfigError("Use either --require-tpsl or --no-require-tpsl, not both.");
+        }
+        const patch = { updatedAtMs: now };
+        const risk = opts.risk?.trim();
+        if (risk) {
+            if (risk !== "conservative" && risk !== "balanced" && risk !== "aggressive") {
+                throw new ConfigError("--risk must be conservative | balanced | aggressive");
+            }
+            patch.risk = risk;
+        }
+        if (opts.maxSz !== undefined) {
+            const n = Number(opts.maxSz);
+            if (!Number.isFinite(n) || n <= 0) {
+                throw new ConfigError("--max-sz must be positive");
+            }
+            patch.defaultMaxSz = n;
+        }
+        if (opts.minSz !== undefined) {
+            const n = Number(opts.minSz);
+            if (!Number.isFinite(n) || n <= 0) {
+                throw new ConfigError("--min-sz must be positive");
+            }
+            patch.defaultMinSz = n;
+        }
+        if (opts.noRequireTpsl) {
+            patch.requireTpsl = false;
+        }
+        else if (opts.requireTpsl) {
+            patch.requireTpsl = true;
+        }
+        if (opts.priceDevPct !== undefined) {
+            const n = Number(opts.priceDevPct);
+            if (!Number.isFinite(n) || n <= 0) {
+                throw new ConfigError("--price-dev-pct must be positive");
+            }
+            patch.priceDeviationPctMax = n;
+        }
+        if (opts.notes !== undefined) {
+            patch.tradingStyleNotes = opts.notes;
+        }
+        if (opts.minConfidence !== undefined) {
+            patch.minConfidenceToExecute = parseOptionalConfidence(opts.minConfidence, "--min-confidence");
+        }
+        if (opts.limitJitterPct !== undefined) {
+            const n = Number(opts.limitJitterPct);
+            if (!Number.isFinite(n) || n < 0 || n > 0.05) {
+                throw new ConfigError("--limit-jitter-pct must be between 0 and 0.05");
+            }
+            patch.limitPriceJitterPct = n;
+        }
+        if (opts.slEntryShift !== undefined) {
+            patch.bracketSlEntryShift = parseOptionalUnitInterval(opts.slEntryShift, "--sl-entry-shift");
+        }
+        if (opts.executeCooldownSec !== undefined) {
+            patch.executeCooldownSec = parseOptionalNonNegative(opts.executeCooldownSec, "--execute-cooldown-sec");
+        }
+        if (opts.antiRushCloseMinSec !== undefined) {
+            patch.antiRushCloseMinSec = parseOptionalNonNegative(opts.antiRushCloseMinSec, "--anti-rush-close-min-sec");
+        }
+        if (opts.protectionGraceSec !== undefined) {
+            patch.protectionGraceSec = parseOptionalNonNegative(opts.protectionGraceSec, "--protection-grace-sec");
+        }
+        if (opts.minClosePnlPct !== undefined) {
+            const n = Number(opts.minClosePnlPct);
+            if (!Number.isFinite(n) || n < 0) {
+                throw new ConfigError("--min-close-pnl-pct must be a non-negative number");
+            }
+            patch.minClosePnlPct = n;
+        }
+        if (opts.ambushReplaceDevPct !== undefined) {
+            const n = Number(opts.ambushReplaceDevPct);
+            if (!Number.isFinite(n) || n <= 0) {
+                throw new ConfigError("--ambush-replace-dev-pct must be positive");
+            }
+            patch.ambushReplaceDeviationPct = n;
+        }
+        if (opts.defaultAmbushExpiresMin !== undefined) {
+            const n = Number(opts.defaultAmbushExpiresMin);
+            if (!Number.isFinite(n) || n <= 0) {
+                throw new ConfigError("--default-ambush-expires-min must be positive");
+            }
+            patch.defaultAmbushExpiresMin = n;
+        }
+        if (opts.noForbidCancelAllAmbush) {
+            patch.forbidCancelAllWithActiveAmbush = false;
+        }
+        const pairs = opts.coinMax ?? [];
+        if (pairs.length > 0) {
+            const map = {
+                ...(mergeUserProfileDefaults((await readOrCreateTradeStateFile(statePath, now)).userProfile).maxSzByCoin ?? {}),
+            };
+            for (const p of pairs) {
+                const [c, s] = p.split("=");
+                const coin = c?.trim();
+                const sz = Number(s?.trim());
+                if (!coin || !Number.isFinite(sz) || sz <= 0) {
+                    throw new ConfigError(`Invalid --coin-max '${p}' (expect COIN=size)`);
+                }
+                map[coin] = sz;
+            }
+            patch.maxSzByCoin = map;
+        }
+        const minPairs = opts.coinMin ?? [];
+        if (minPairs.length > 0) {
+            const map = {
+                ...(mergeUserProfileDefaults((await readOrCreateTradeStateFile(statePath, now)).userProfile).minSzByCoin ?? {}),
+            };
+            for (const p of minPairs) {
+                const [c, s] = p.split("=");
+                const coin = c?.trim();
+                const sz = Number(s?.trim());
+                if (!coin || !Number.isFinite(sz) || sz <= 0) {
+                    throw new ConfigError(`Invalid --coin-min '${p}' (expect COIN=size)`);
+                }
+                map[coin] = sz;
+            }
+            patch.minSzByCoin = map;
+        }
+        const patchKeys = Object.keys(patch).filter((k) => k !== "updatedAtMs");
+        if (patchKeys.length === 0) {
+            throw new ConfigError("profile set: pass at least one of --risk, --max-sz, --min-sz, --notes, --price-dev-pct, --min-confidence, --limit-jitter-pct, --sl-entry-shift, --execute-cooldown-sec, --anti-rush-close-min-sec, --protection-grace-sec, --min-close-pnl-pct, --ambush-replace-dev-pct, --default-ambush-expires-min, --no-forbid-cancel-all-ambush, --coin-max, --coin-min, --require-tpsl / --no-require-tpsl");
+        }
+        const out = await upsertUserProfileFields(statePath, patch, now);
+        printJson({ ok: true, userProfile: out.userProfile });
+    });
+    profile
+        .command("clear")
+        .description("Remove userProfile from trade-state.json")
+        .option("--state-file <path>", "trade-state path")
+        .action(async (o, cmd) => {
+        readGlobalOptions(cmd);
+        const statePath = requireRecordedAdvisorStatePath(cmd, o.stateFile);
+        const cur = await readOrCreateTradeStateFile(statePath, Date.now());
+        const hadProfile = Boolean(cur.userProfile);
+        await clearUserProfile(statePath, Date.now());
+        printJson({ ok: true, hadProfile });
+    });
+}
+export function attachAdvisorCli(program) {
+    const advise = program
+        .command("advise")
+        .description("DeepSeek advisor and profile preferences");
+    const adviseRun = advise
+        .command("run", { isDefault: true })
+        .description("K-lines + positions → structured action (dry-run default; `--live` for real orders via spawned CLI)")
+        .requiredOption("--coin <sym>", "Perp symbol (e.g. BTC, xyz:CL)")
+        .requiredOption("--max-sz <n>", "Hard cap on size for bracket / close positions")
+        .option("--note <text>", "Note injected into the first user message")
+        .option("--once", "Single model turn then exit", false)
+        .option("--auto", "After the model turn, run the execute step immediately", false)
+        .option("--require-tpsl", "Enforce TP/SL on bracket actions (default on)", true)
+        .option("--no-require-tpsl", "Disable TP/SL enforcement for brackets")
+        .option("--bars5m <n>", "5m bars", "48")
+        .option("--bars1h <n>", "1h bars", "48")
+        .option("--bars1d <n>", "1d bars", "30")
+        .option("--context-version <v>", "Prompt context: raw_kline (v1, default) | precomputed_indicators (v2)", "raw_kline")
+        .option("--live", "Forwarded to spawned order/state commands", false)
+        .option("--assume-yes", "Forwarded: skip YES on spawned --live", false)
+        .option("--dump-kline <path>", "Dump raw K-line snapshot and account data to a JSON file for debugging")
+        .option("--dump-prompt <dir>", "Save system and user prompts to files in <dir> (system.md, user.json) for external model testing")
+        .option("--skip-if-stable <pct>", "Skip LLM call if mid changed < pct since last session (e.g. 0.002 = 0.2%)")
+        .option("--log-dir <path>", "Session log directory", "")
+        .option("--json", "Print raw JSON to stdout (default: human-readable summary)", false)
+        .option("--min-confidence <n>", "Block execute when model confidence is below this (0–1)")
+        .option("--limit-jitter-pct <n>", "Random limit-price offset fraction before execute (e.g. 0.002 = up to ±0.2%)")
+        .option("--execute-cooldown-sec <n>", "Min seconds between same coin+action executions (stored in trade-state)")
+        .option("--sl-entry-shift <n>", "Shift bracket entry toward model SL (0=off, 1=entry at SL; TP/SL move equally)")
+        .option("--anti-rush-close-min-sec <n>", "Block close_position until position age exceeds this (0=off; profile antiRushCloseMinSec)")
+        .option("--ambush-replace-dev-pct <n>", "Replace pending TTL ambush when new limit deviates more than this fraction")
+        .action(async (opts, command) => {
+        const coinRaw = String(opts.coin ?? "");
+        const globals = readGlobalOptions(command);
+        const cfg = loadEffectiveConfig({ network: globals.network, apiUrl: globals.apiUrl });
+        const user = requireUserContext(cfg);
+        const apiKey = requireApiKey();
+        const maxSz = parseMaxSz(opts.maxSz !== undefined ? String(opts.maxSz) : undefined);
+        const noState = Boolean(globals.noState);
+        const statePath = resolveTradeStatePath(command, undefined);
+        const requireTpsl = opts.noRequireTpsl === true ? false : opts.requireTpsl !== false;
+        const jsonOutput = opts.json === true;
+        const auto = opts.auto === true;
+        const minConfidence = parseOptionalConfidence(opts.minConfidence !== undefined ? String(opts.minConfidence) : undefined, "--min-confidence");
+        const limitJitterPct = parseOptionalNonNegative(opts.limitJitterPct !== undefined ? String(opts.limitJitterPct) : undefined, "--limit-jitter-pct");
+        const executeCooldownSec = parseOptionalNonNegative(opts.executeCooldownSec !== undefined ? String(opts.executeCooldownSec) : undefined, "--execute-cooldown-sec");
+        const slEntryShift = parseOptionalUnitInterval(opts.slEntryShift !== undefined ? String(opts.slEntryShift) : undefined, "--sl-entry-shift");
+        const antiRushCloseMinSec = parseOptionalNonNegative(opts.antiRushCloseMinSec !== undefined ? String(opts.antiRushCloseMinSec) : undefined, "--anti-rush-close-min-sec");
+        const ambushReplaceDevPct = parseOptionalConfidence(opts.ambushReplaceDevPct !== undefined ? String(opts.ambushReplaceDevPct) : undefined, "--ambush-replace-dev-pct");
+        const k5 = Number(opts.bars5m ?? "48");
+        const k1h = Number(opts.bars1h ?? "48");
+        const k1d = Number(opts.bars1d ?? "30");
+        for (const [label, v] of [
+            ["--bars5m", k5],
+            ["--bars1h", k1h],
+            ["--bars1d", k1d],
+        ]) {
+            if (!Number.isInteger(v) || v < 1) {
+                throw new ConfigError(`${label} must be a positive integer.`);
+            }
+        }
+        const contextVersion = opts.contextVersion === "precomputed_indicators"
+            ? "precomputed_indicators"
+            : "raw_kline";
+        let profile;
+        if (!noState && statePath) {
+            const f = await readOrCreateTradeStateFile(statePath, Date.now());
+            profile = f.userProfile ? UserProfileSchema.parse(f.userProfile) : undefined;
+        }
+        const profileSnapshot = mergeUserProfileDefaults(profile);
+        const info = new HyperliquidInfoClient({ infoOrigin: user.infoOrigin });
+        const nowMs = Date.now();
+        const snap = await buildAdvisorMarketSnapshot({
+            info,
+            coin: coinRaw,
+            network: cfg.network,
+            userAddress: user.userAddress,
+            userNote: opts.note ? String(opts.note) : undefined,
+            nowMs,
+            kline5mBars: k5,
+            kline1hBars: k1h,
+            kline1dBars: k1d,
+            contextVersion,
+        });
+        if (typeof opts.dumpKline === "string" && opts.dumpKline.trim()) {
+            const dumpPath = opts.dumpKline.trim();
+            const dump = {
+                coin: snap.coin,
+                network: snap.network,
+                now_ms: snap.now_ms,
+                mid: snap.mid,
+                positions: snap.positions,
+                kline_5m: snap.kline_5m,
+                kline_1h: snap.kline_1h,
+                kline_1d: snap.kline_1d,
+            };
+            await writeFile(dumpPath, JSON.stringify(dump, null, 2), "utf-8");
+            console.error(`[advisor] K-line dump written to ${dumpPath}`);
+        }
+        let pendingAmbush = [];
+        let activePositionPlan;
+        if (!noState && statePath) {
+            const f = await readOrCreateTradeStateFile(statePath, nowMs);
+            pendingAmbush = listPendingAmbushIntents(f, snap.coin, nowMs);
+            const posRow = snap.positions[snap.coin];
+            if (posRow?.signed_sz) {
+                activePositionPlan = buildActivePositionPlan({
+                    state: f,
+                    coin: snap.coin,
+                    nowMs,
+                    mid: snap.mid,
+                    positionSignedSz: posRow.signed_sz,
+                    positionEntryPx: posRow.entry_px,
+                });
+            }
+        }
+        const sessionId = randomUUID();
+        const logDir = typeof opts.logDir === "string" && opts.logDir.trim()
+            ? opts.logDir.trim()
+            : defaultAdvisorLogDir();
+        const logPath = path.join(logDir, `${sessionId}.json`);
+        const modelLabel = process.env.DEEPSEEK_MODEL?.trim() || DEFAULT_DEEPSEEK_MODEL;
+        const session = {
+            sessionId,
+            coin: snap.coin,
+            createdAtMs: nowMs,
+            model: modelLabel,
+            userProfileSnapshot: profileSnapshot,
+            marketSnapshot: {
+                coin: snap.coin,
+                network: snap.network,
+                now_ms: snap.now_ms,
+                mid: snap.mid,
+                positions: snap.positions,
+                kline_5m: snap.kline_5m,
+                kline_1h: snap.kline_1h,
+                kline_1d: snap.kline_1d,
+            },
+            turns: [],
+        };
+        const system = buildAdvisorSystemPrompt(profile, contextVersion);
+        const firstUser = formatFirstUserPayload(snap, {
+            pendingAmbushIntents: pendingAmbush,
+            activePositionPlan: activePositionPlan ?? null,
+        });
+        session.turns.push({ role: "system", content: system });
+        session.turns.push({ role: "user", content: firstUser });
+        if (typeof opts.dumpPrompt === "string" && opts.dumpPrompt.trim()) {
+            const dir = opts.dumpPrompt.trim();
+            await import("node:fs/promises").then((fs) => fs.mkdir(dir, { recursive: true }));
+            await writeFile(path.join(dir, "system.md"), system, "utf-8");
+            await writeFile(path.join(dir, "user.json"), firstUser, "utf-8");
+            console.error(`[advisor] prompts saved to ${dir}/system.md and ${dir}/user.json`);
+        }
+        const execBase = {
+            globals: globalArgs(globals),
+            maxSz,
+            requireTpsl,
+            live: Boolean(opts.live),
+            assumeYes: Boolean(opts.assumeYes),
+            statePath,
+            noState,
+            profile,
+            auto,
+            minConfidence,
+            limitJitterPct,
+            executeCooldownSec,
+            slEntryShift,
+            antiRushCloseMinSec,
+            ambushReplaceDeviationPct: ambushReplaceDevPct,
+        };
+        // Skip LLM if mid barely moved since last session
+        const skipPct = opts.skipIfStable !== undefined ? Number(opts.skipIfStable) : NaN;
+        if (Number.isFinite(skipPct) && skipPct > 0 && snap.mid !== null) {
+            const lastMid = await readLatestAdvisorMid(logDir, snap.coin);
+            if (lastMid !== null && lastMid > 0) {
+                const change = Math.abs(snap.mid - lastMid) / lastMid;
+                if (change <= skipPct) {
+                    process.stderr.write(`advise: mid ${snap.mid} vs last ${lastMid} changed ${(change * 100).toFixed(3)}% ≤ ${(skipPct * 100).toFixed(1)}%, skipping.\n`);
+                    return;
+                }
+            }
+        }
+        process.stderr.write("正在请求模型（可能需要 10–60 秒）…\n");
+        const { messages, response, actions, lastAssistant } = await runAdvisorModelTurnWithRepair({
+            apiKey,
+            messages: [
+                { role: "system", content: system },
+                { role: "user", content: firstUser },
+            ],
+        });
+        session.turns.push({
+            role: "assistant",
+            content: lastAssistant.content,
+            reasoning_content: lastAssistant.reasoningContent,
+            action: actions[0]?.action,
+        });
+        await persistAndPrintSession(logPath, session);
+        const printTurn = (act, strategy, reasoning, analysis) => {
+            if (jsonOutput) {
+                printJson({
+                    strategy,
+                    action: act,
+                    analysis,
+                    logPath,
+                    reasoning_content: reasoning ?? null,
+                });
+            }
+            else {
+                process.stdout.write(formatAdvisorTurnDisplay({
+                    action: act,
+                    coin: `${snap.coin} [${strategy}]`,
+                    mid: snap.mid,
+                    logPath,
+                    reasoningContent: reasoning,
+                    reasoningPreviewMax: UNLIMITED_REASONING_PREVIEW,
+                    analysis,
+                }));
+            }
+        };
+        const ana = response.analysis;
+        for (const { strategy, action } of actions) {
+            printTurn(action, strategy, lastAssistant.reasoningContent, ana);
+        }
+        if (actions.length === 0) {
+            // Both strategies wait — show analysis + each strategy's reason
+            const scalpReason = response.scalp?.reason ?? "";
+            const ambushReason = response.ambush?.reason ?? "";
+            printTurn({ action: "wait", reason: `scalp: ${scalpReason || "—"}\n  ambush: ${ambushReason || "—"}`, confidence: 0 }, "—", lastAssistant.reasoningContent, ana);
+        }
+        const runExecute = async (act) => {
+            const r = await executeAdvisorAction({
+                action: act,
+                coin: snap.coin,
+                snapshot: snap,
+                profile,
+                maxSz,
+                requireTpsl,
+                globals: execBase.globals,
+                live: execBase.live,
+                assumeYes: execBase.assumeYes,
+                statePath,
+                noState,
+                executionPolicyCli: {
+                    auto: execBase.auto,
+                    minConfidence: execBase.minConfidence,
+                    limitJitterPct: execBase.limitJitterPct,
+                    executeCooldownSec: execBase.executeCooldownSec,
+                    slEntryShift: execBase.slEntryShift,
+                    antiRushCloseMinSec: execBase.antiRushCloseMinSec,
+                    ambushReplaceDeviationPct: execBase.ambushReplaceDeviationPct,
+                },
+                confirmLive: (p) => requireStdinYes(p + "输入 YES 确认执行：\n"),
+            });
+            process.stdout.write(r.stdout);
+            if (r.stderr) {
+                process.stderr.write(r.stderr);
+            }
+            session.executed = {
+                command: r.command,
+                actionSpec: act,
+                exchangeResponse: r.response,
+                exitCode: r.exitCode,
+            };
+            await persistAndPrintSession(logPath, session);
+            if (jsonOutput) {
+                printJson({ executed: session.executed });
+            }
+            else {
+                process.stdout.write(formatAdvisorExecutedDisplay({
+                    command: r.command,
+                    action: act,
+                    exitCode: r.exitCode,
+                    logPath,
+                }));
+            }
+        };
+        if (opts.auto === true) {
+            for (const { strategy, action } of actions) {
+                process.stderr.write(`\n[${strategy}] 执行中…\n`);
+                try {
+                    await runExecute(action);
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    process.stderr.write(`advise [${strategy}]: 执行未提交（护栏拦截）:\n  ${msg}\n`);
+                    session.executed = {
+                        command: "(blocked before exchange)",
+                        actionSpec: action,
+                        exchangeResponse: { error: msg },
+                        exitCode: 1,
+                    };
+                    await persistAndPrintSession(logPath, session);
+                    if (jsonOutput) {
+                        printJson({ executed: session.executed, guardError: msg });
+                    }
+                    else {
+                        process.stdout.write(formatAdvisorExecutedDisplay({
+                            command: "(blocked before exchange)",
+                            action,
+                            exitCode: 1,
+                            logPath,
+                        }));
+                        process.stdout.write(`\n拦截原因: ${msg}\n\n`);
+                    }
+                    process.exitCode = 1;
+                }
+            }
+            return;
+        }
+        if (opts.once === true) {
+            return;
+        }
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        // In REPL mode, use the first action for backward compat
+        const primary = actions[0]?.action ?? { action: "wait", reason: "", confidence: 0 };
+        let latest = primary;
+        let msgs = messages;
+        try {
+            while (true) {
+                const line = (await rl.question("advise> （自然语言 | show 预览 | execute 执行 | quit 退出）\n")).trim();
+                if (line === "" || line === "quit" || line === "exit") {
+                    break;
+                }
+                if (line === "show") {
+                    if (!jsonOutput) {
+                        process.stderr.write(formatAdvisorShowHeader(latest, snap.coin));
+                    }
+                    const policy = resolveAdvisorExecutionPolicy(profile, {
+                        auto: execBase.auto,
+                        minConfidence: execBase.minConfidence,
+                        limitJitterPct: execBase.limitJitterPct,
+                        executeCooldownSec: execBase.executeCooldownSec,
+                        slEntryShift: execBase.slEntryShift,
+                    });
+                    const szCap = resolveAdvisorSzCap({
+                        coin: snap.coin,
+                        maxSz,
+                        profile,
+                        mid: snap.mid,
+                        positionSignedSz: snap.positions[snap.coin]?.signed_sz,
+                    });
+                    const prepared = prepareAdvisorActionForExecution(latest, {
+                        slEntryShift: policy.bracketSlEntryShift,
+                        limitJitterPct: policy.limitJitterPct,
+                        mid: snap.mid,
+                        maxDevPct: profileSnapshot.priceDeviationPctMax,
+                        szDecimals: snap.sz_decimals,
+                        kline1h: snap.kline_1h,
+                        profile,
+                    });
+                    const cmd = formatCliInvocation(advisorActionToCliArgs(prepared.action, {
+                        coin: snap.coin,
+                        mid: snap.mid,
+                        positionSignedSz: snap.positions[snap.coin]?.signed_sz,
+                        globals: buildGlobalPrefix(execBase.globals),
+                        live: execBase.live,
+                        assumeYes: execBase.assumeYes,
+                        szCap,
+                        limitJitterPct: policy.limitJitterPct,
+                        maxDevPct: profileSnapshot.priceDeviationPctMax,
+                        szDecimals: snap.sz_decimals,
+                    }));
+                    process.stderr.write(`${cmd}\n`);
+                    continue;
+                }
+                if (line === "execute" || line === "e") {
+                    await runExecute(latest);
+                    continue;
+                }
+                if (line === "cancel") {
+                    process.stderr.write("已清除待执行动作，可继续对话。\n");
+                    continue;
+                }
+                msgs = [...msgs, { role: "user", content: line }];
+                session.turns.push({ role: "user", content: line });
+                process.stderr.write("正在请求模型…\n");
+                const turn = await runAdvisorModelTurnWithRepair({ apiKey, messages: msgs });
+                msgs = turn.messages;
+                const replPrimary = turn.actions[0];
+                latest = replPrimary?.action ?? { action: "wait", reason: "", confidence: 0 };
+                session.turns.push({
+                    role: "assistant",
+                    content: turn.lastAssistant.content,
+                    reasoning_content: turn.lastAssistant.reasoningContent,
+                    action: turn.actions[0]?.action,
+                });
+                await persistAndPrintSession(logPath, session);
+                const replAna = turn.response.analysis;
+                for (const { strategy, action } of turn.actions) {
+                    printTurn(action, strategy, turn.lastAssistant.reasoningContent, replAna);
+                }
+                if (turn.actions.length === 0) {
+                    const sr = turn.response.scalp?.reason ?? "";
+                    const ar = turn.response.ambush?.reason ?? "";
+                    printTurn({ action: "wait", reason: `scalp: ${sr || "—"}\n  ambush: ${ar || "—"}`, confidence: 0 }, "—", turn.lastAssistant.reasoningContent, replAna);
+                }
+            }
+        }
+        finally {
+            rl.close();
+        }
+    });
+    attachAdvisorProfileCommands(advise);
+    const advisor = program
+        .command("advisor")
+        .description("Advisor preferences stored as `userProfile` in trade-state.json");
+    attachAdvisorProfileCommands(advisor);
+}
+//# sourceMappingURL=advisorCli.js.map