jcc_hyper_tool 0.1.5 → 0.1.7

package/dist/cli/advisorCli.js

@@ -1,11 +1,16 @@
 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";
@@ -30,6 +35,36 @@ function parseMaxSz(raw) {
     }
     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);
 }
@@ -41,10 +76,231 @@ function globalArgs(globals) {
         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) {
-    program
+    const advise = program
         .command("advise")
-        .description("DeepSeek advisor: K-lines + positions → structured action (dry-run default; `--live` for real orders via spawned CLI)")
+        .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")
@@ -55,9 +311,20 @@ export function attachAdvisorCli(program) {
         .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);
@@ -68,6 +335,14 @@ export function attachAdvisorCli(program) {
         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");
@@ -80,6 +355,9 @@ export function attachAdvisorCli(program) {
                 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());
@@ -98,7 +376,40 @@ export function attachAdvisorCli(program) {
             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()
@@ -123,10 +434,20 @@ export function attachAdvisorCli(program) {
             },
             turns: [],
         };
-        const system = buildAdvisorSystemPrompt(profile);
-        const firstUser = formatFirstUserPayload(snap);
+        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,
@@ -136,9 +457,28 @@ export function attachAdvisorCli(program) {
             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, action, lastAssistant } = await runAdvisorModelTurnWithRepair({
+        const { messages, response, actions, lastAssistant } = await runAdvisorModelTurnWithRepair({
             apiKey,
             messages: [
                 { role: "system", content: system },
@@ -149,10 +489,41 @@ export function attachAdvisorCli(program) {
             role: "assistant",
             content: lastAssistant.content,
             reasoning_content: lastAssistant.reasoningContent,
-            action,
+            action: actions[0]?.action,
         });
         await persistAndPrintSession(logPath, session);
-        printJson({ action, logPath, reasoning_content: lastAssistant.reasoningContent ?? null });
+        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,
@@ -166,6 +537,15 @@ export function attachAdvisorCli(program) {
                 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);
@@ -179,17 +559,58 @@ export function attachAdvisorCli(program) {
                 exitCode: r.exitCode,
             };
             await persistAndPrintSession(logPath, session);
-            printJson({ executed: session.executed });
+            if (jsonOutput) {
+                printJson({ executed: session.executed });
+            }
+            else {
+                process.stdout.write(formatAdvisorExecutedDisplay({
+                    command: r.command,
+                    action: act,
+                    exitCode: r.exitCode,
+                    logPath,
+                }));
+            }
         };
         if (opts.auto === true) {
-            await runExecute(action);
+            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 });
-        let latest = action;
+        // 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) {
@@ -198,14 +619,45 @@ export function attachAdvisorCli(program) {
                     break;
                 }
                 if (line === "show") {
-                    process.stderr.write(`${formatCliInvocation(advisorActionToCliArgs(latest, {
+                    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,
-                    }))}\n`);
+                        szCap,
+                        limitJitterPct: policy.limitJitterPct,
+                        maxDevPct: profileSnapshot.priceDeviationPctMax,
+                        szDecimals: snap.sz_decimals,
+                    }));
+                    process.stderr.write(`${cmd}\n`);
                     continue;
                 }
                 if (line === "execute" || line === "e") {
@@ -221,134 +673,34 @@ export function attachAdvisorCli(program) {
                 process.stderr.write("正在请求模型…\n");
                 const turn = await runAdvisorModelTurnWithRepair({ apiKey, messages: msgs });
                 msgs = turn.messages;
-                latest = turn.action;
+                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.action,
+                    action: turn.actions[0]?.action,
                 });
                 await persistAndPrintSession(logPath, session);
-                printJson({
-                    action: turn.action,
-                    reasoning_content: turn.lastAssistant.reasoningContent ?? null,
-                });
+                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");
-    const profile = advisor
-        .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("--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("--coin-max <pair>", "COIN=size max 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.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;
-        }
-        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 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, --notes, --price-dev-pct, --coin-max, --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 });
-    });
-}
-function collectPair(value, prev) {
-    return [...prev, value];
-}
-function requireRecordedAdvisorStatePath(cmd, explicit) {
-    requireStateCliEnabled(cmd, "`advisor profile`");
-    const p = resolveTradeStatePath(cmd, explicit);
-    if (!p) {
-        throw new ConfigError("Unexpected: advisor profile needs a trade-state path.");
-    }
-    return p;
+    attachAdvisorProfileCommands(advisor);
 }
 //# sourceMappingURL=advisorCli.js.map