koishi-plugin-monetary-bourse 1.1.2-Alpha.6 → 2.0.0-Alpha.8

package/lib/index.d.ts

@@ -72,6 +72,7 @@ export interface Config {
     minFreezeTime: number;
     maxFreezeTime: number;
     marketStatus: 'open' | 'close' | 'auto';
+    enableDebug: boolean;
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -27,6 +27,8 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_koishi = require("koishi");
+var import_path = require("path");
+var import_fs = require("fs");
 var name = "monetary-bourse";
 var inject = {
   required: ["database", "puppeteer"],
@@ -51,7 +53,10 @@ var Config = import_koishi.Schema.intersect([
     freezeCostPerMinute: import_koishi.Schema.number().min(1).default(100).description("每多少货币计为1分钟冻结时间"),
     minFreezeTime: import_koishi.Schema.number().min(0).default(10).description("最小冻结时间(分钟)"),
     maxFreezeTime: import_koishi.Schema.number().min(0).default(1440).description("最大交易冻结时间(分钟)")
-  }).description("冻结机制")
+  }).description("冻结机制"),
+  import_koishi.Schema.object({
+    enableDebug: import_koishi.Schema.boolean().default(false).description("启用调试模式（开启后可使用调试指令）")
+  }).description("开发者选项")
 ]);
 function apply(ctx, config) {
   ctx.model.extend("bourse_holding", {
@@ -105,6 +110,7 @@ function apply(ctx, config) {
   let macroWaveCount = 7;
   let macroWeeklyAmplitudeRatio = 0.08;
   let nextMacroSwitchTime = null;
+  let __testNow = null;
   ctx.setInterval(async () => {
     const isOpen = await isMarketOpen();
     if (isOpen && !wasMarketOpen) {
@@ -361,7 +367,7 @@ function apply(ctx, config) {
   __name(switchKLinePattern, "switchKLinePattern");
   async function updatePrice() {
     let state = (await ctx.database.get("bourse_state", { key: "macro_state" }))[0];
-    const now = /* @__PURE__ */ new Date();
+    const now = __testNow ?? /* @__PURE__ */ new Date();
     if (state) {
       if (!state.lastCycleStart) state.lastCycleStart = new Date(Date.now() - 7 * 24 * 3600 * 1e3);
       if (!(state.lastCycleStart instanceof Date)) state.lastCycleStart = new Date(state.lastCycleStart);
@@ -373,25 +379,22 @@ function apply(ctx, config) {
       needNewState = true;
     } else {
       const endTime = state.endTime || new Date(state.lastCycleStart.getTime() + 7 * 24 * 3600 * 1e3);
-      if (state.mode !== "manual" && now > endTime) needNewState = true;
+      if (now > endTime) needNewState = true;
     }
     const createAutoState = /* @__PURE__ */ __name(async () => {
       const durationHours = 7 * 24;
-      const fluctuation = 0.3;
+      const fluctuation = 0.25;
       const targetRatio = 1 + (Math.random() * 2 - 1) * fluctuation;
-      let targetPrice = currentPrice * targetRatio;
-      const upperTarget = currentPrice * 1.5;
-      const lowerTarget = currentPrice * 0.5;
-      targetPrice = Math.max(lowerTarget, Math.min(upperTarget, targetPrice));
+      let targetPrice2 = currentPrice * targetRatio;
+      targetPrice2 = Math.max(currentPrice * 0.5, Math.min(currentPrice * 1.5, targetPrice2));
       const endTime = new Date(now.getTime() + durationHours * 3600 * 1e3);
-      const minutes = durationHours * 60;
-      const trendFactor = (targetPrice - currentPrice) / minutes;
       const newState = {
         key: "macro_state",
         lastCycleStart: now,
         startPrice: currentPrice,
-        targetPrice,
-        trendFactor,
+        targetPrice: targetPrice2,
+        trendFactor: 0,
+        // 不再使用线性趋势因子
         mode: "auto",
         endTime
       };
@@ -415,10 +418,10 @@ function apply(ctx, config) {
       switchKLinePattern("随机时间");
     }
     const basePrice = state.startPrice;
+    const targetPrice = state.targetPrice;
     const totalDuration = state.endTime.getTime() - state.lastCycleStart.getTime();
-    const elapsed = Math.min(totalDuration, now.getTime() - state.lastCycleStart.getTime());
+    const elapsed = now.getTime() - state.lastCycleStart.getTime();
     const cycleProgress = Math.max(0, Math.min(1, elapsed / totalDuration));
-    const trendPrice = basePrice + (state.targetPrice - basePrice) * cycleProgress;
     const dayStart = new Date(now);
     dayStart.setHours(config.openHour, 0, 0, 0);
     const dayEnd = new Date(now);
@@ -426,13 +429,33 @@ function apply(ctx, config) {
     const dayDuration = dayEnd.getTime() - dayStart.getTime();
     const dayElapsed = now.getTime() - dayStart.getTime();
     const dayProgress = Math.max(0, Math.min(1, dayElapsed / dayDuration));
+    const expectedBase = basePrice + (targetPrice - basePrice) * cycleProgress;
+    const wavePhaseForMean = 2 * Math.PI * macroWaveCount * cycleProgress;
+    const weeklyAmplitudeRatioForMean = Math.min(Math.max(macroWeeklyAmplitudeRatio, 0.04), 0.12);
+    const waveMeanBias = Math.sin(wavePhaseForMean) * weeklyAmplitudeRatioForMean;
+    const expectedPrice = expectedBase * (1 + waveMeanBias);
+    const deviation = (expectedPrice - currentPrice) / currentPrice;
+    const meanReversionStrength = 0.05;
+    const driftReturn = deviation * meanReversionStrength;
+    const getVolatility = /* @__PURE__ */ __name((progress) => {
+      const morningVol = Math.exp(-8 * progress);
+      const afternoonVol = Math.exp(-8 * (1 - progress));
+      const baseVol = 0.3;
+      return baseVol + morningVol * 0.5 + afternoonVol * 0.4;
+    }, "getVolatility");
+    const volatility = getVolatility(dayProgress);
+    const u1 = Math.random();
+    const u2 = Math.random();
+    const normalRandom = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+    const baseVolatilityPerTick = 25e-4;
+    const randomReturn = normalRandom * baseVolatilityPerTick * volatility;
     const patternFn = kLinePatterns[currentDayPattern];
-    const dailyFactor = patternFn(dayProgress) * 0.03;
-    const waveFrequency = macroWaveCount;
-    const weeklyAmplitudeRatio = macroWeeklyAmplitudeRatio;
-    const waveFactor = Math.sin(2 * Math.PI * waveFrequency * cycleProgress) * weeklyAmplitudeRatio;
-    const noiseFactor = (Math.random() * 2 - 1) * 1e-3;
-    let newPrice = trendPrice * (1 + dailyFactor + waveFactor + noiseFactor);
+    const patternValue = patternFn(dayProgress);
+    const prevPatternValue = patternFn(Math.max(0, dayProgress - 0.01));
+    const patternTrend = (patternValue - prevPatternValue) * 0.8;
+    const patternBias = patternTrend * 8e-3;
+    const totalReturn = driftReturn + randomReturn + patternBias;
+    let newPrice = currentPrice * (1 + totalReturn);
     const dayBase = dailyOpenPrice ?? basePrice;
     const weekUpper = basePrice * 1.5;
     const weekLower = basePrice * 0.5;
@@ -440,6 +463,14 @@ function apply(ctx, config) {
     const dayLower = dayBase * 0.5;
     const upperLimit = Math.min(weekUpper, dayUpper);
     const lowerLimit = Math.max(weekLower, dayLower);
+    if (newPrice > upperLimit * 0.95) {
+      const overshoot = (newPrice - upperLimit * 0.95) / (upperLimit * 0.05);
+      newPrice = upperLimit * 0.95 + upperLimit * 0.05 * Math.tanh(overshoot);
+    }
+    if (newPrice < lowerLimit * 1.05) {
+      const undershoot = (lowerLimit * 1.05 - newPrice) / (lowerLimit * 0.05);
+      newPrice = lowerLimit * 1.05 - lowerLimit * 0.05 * Math.tanh(undershoot);
+    }
     newPrice = Math.max(lowerLimit, Math.min(upperLimit, newPrice));
     if (newPrice < 1) newPrice = 1;
     newPrice = Number(newPrice.toFixed(2));
@@ -531,8 +562,8 @@ function apply(ctx, config) {
     });
     const high = Math.max(...formattedData.map((d) => d.price));
     const low = Math.min(...formattedData.map((d) => d.price));
-    const title = config.stockName + (interval === "week" ? " (周走势)" : interval === "day" ? " (日走势)" : " (实时)");
-    const img = await renderStockImage(ctx, formattedData, title, latest.price, high, low);
+    const viewLabel = interval === "week" ? "周走势" : interval === "day" ? "日走势" : "实时走势";
+    const img = await renderStockImage(ctx, formattedData, config.stockName, viewLabel, latest.price, high, low);
     return img;
   });
   ctx.command("stock.buy <amount:number>", "买入股票").userFields(["id"]).action(async ({ session }, amount) => {
@@ -555,7 +586,15 @@ function apply(ctx, config) {
       if (freezeMinutes < config.minFreezeTime) freezeMinutes = config.minFreezeTime;
     }
     const freezeMs = freezeMinutes * 60 * 1e3;
-    const endTime = new Date(Date.now() + freezeMs);
+    const userPendingOrders = await ctx.database.get("bourse_pending", { userId: visibleUserId }, { sort: { endTime: "desc" }, limit: 1 });
+    let startTime = /* @__PURE__ */ new Date();
+    if (userPendingOrders.length > 0) {
+      const lastOrderEndTime = userPendingOrders[0].endTime;
+      if (lastOrderEndTime > startTime) {
+        startTime = lastOrderEndTime;
+      }
+    }
+    const endTime = new Date(startTime.getTime() + freezeMs);
     await ctx.database.create("bourse_pending", {
       userId: visibleUserId,
       uid,
@@ -564,7 +603,7 @@ function apply(ctx, config) {
       amount,
       price: currentPrice,
       cost,
-      startTime: /* @__PURE__ */ new Date(),
+      startTime,
       endTime
     });
     if (freezeMinutes === 0) {
@@ -617,7 +656,15 @@ function apply(ctx, config) {
       if (freezeMinutes < config.minFreezeTime) freezeMinutes = config.minFreezeTime;
     }
     const freezeMs = freezeMinutes * 60 * 1e3;
-    const endTime = new Date(Date.now() + freezeMs);
+    const userPendingOrders = await ctx.database.get("bourse_pending", { userId: visibleUserId }, { sort: { endTime: "desc" }, limit: 1 });
+    let startTime = /* @__PURE__ */ new Date();
+    if (userPendingOrders.length > 0) {
+      const lastOrderEndTime = userPendingOrders[0].endTime;
+      if (lastOrderEndTime > startTime) {
+        startTime = lastOrderEndTime;
+      }
+    }
+    const endTime = new Date(startTime.getTime() + freezeMs);
     await ctx.database.create("bourse_pending", {
       userId: visibleUserId,
       uid,
@@ -626,7 +673,7 @@ function apply(ctx, config) {
       amount,
       price: currentPrice,
       cost: gain,
-      startTime: /* @__PURE__ */ new Date(),
+      startTime,
       endTime
     });
     if (freezeMinutes === 0) {
@@ -686,26 +733,26 @@ function apply(ctx, config) {
     const duration = hours || 24;
     const now = /* @__PURE__ */ new Date();
     const endTime = new Date(now.getTime() + duration * 3600 * 1e3);
-    const existing = (await ctx.database.get("bourse_state", { key: "macro_state" }))[0];
-    const keepBasePrice = existing?.startPrice ?? currentPrice;
-    const dayBase = dailyOpenPrice ?? keepBasePrice;
-    const upper = Math.min(keepBasePrice * 1.5, dayBase * 1.5);
-    const lower = Math.max(keepBasePrice * 0.5, dayBase * 0.5);
+    const baseStart = currentPrice;
+    const dayBase = dailyOpenPrice ?? baseStart;
+    const upper = Math.min(baseStart * 1.5, dayBase * 1.5);
+    const lower = Math.max(baseStart * 0.5, dayBase * 0.5);
     const targetPriceClamped = Math.max(lower, Math.min(upper, price));
     const minutes = duration * 60;
     const trendFactor = (targetPriceClamped - currentPrice) / minutes;
     const newState = {
       key: "macro_state",
-      lastCycleStart: existing?.lastCycleStart ?? now,
-      // 保持原周期起点
-      startPrice: keepBasePrice,
-      // 保持原基准价，不重置
+      lastCycleStart: now,
+      // 开启新周期
+      startPrice: currentPrice,
+      // 以当前价作为新基准
       targetPrice: targetPriceClamped,
       trendFactor,
       mode: "manual",
       endTime
     };
-    if (!existing) {
+    const existing = await ctx.database.get("bourse_state", { key: "macro_state" });
+    if (existing.length === 0) {
       await ctx.database.create("bourse_state", newState);
     } else {
       const { key, ...updateFields } = newState;
@@ -750,6 +797,78 @@ function apply(ctx, config) {
     switchKLinePattern("管理员手动");
     return "已切换K线模型。";
   });
+  ctx.command("bourse.test.price [ticks:number]", "开发测试：推进价格更新若干次并返回当前价格", { authority: 3 }).action(async ({ session }, ticks) => {
+    if (!config.enableDebug) return "调试模式未开启，请在插件配置中启用 enableDebug。";
+    const n = typeof ticks === "number" && ticks > 0 ? Math.min(ticks, 500) : 1;
+    const stepMs = 2 * 60 * 1e3;
+    const startNow = /* @__PURE__ */ new Date();
+    __testNow = new Date(startNow);
+    let minP = currentPrice, maxP = currentPrice;
+    for (let i = 0; i < n; i++) {
+      await updatePrice();
+      minP = Math.min(minP, currentPrice);
+      maxP = Math.max(maxP, currentPrice);
+      __testNow = new Date(__testNow.getTime() + stepMs);
+    }
+    __testNow = null;
+    return `测试完成：推进${n}步（每步2分钟）
+当前价格：${Number(currentPrice.toFixed(2))}
+区间最高：${Number(maxP.toFixed(2))} 最低：${Number(minP.toFixed(2))}`;
+  });
+  ctx.command("bourse.test.run <ticks:number> [step:number]", "开发测试：按虚拟时间推进并统计价格分布", { authority: 3 }).action(async ({ session }, ticks, step) => {
+    if (!config.enableDebug) return "调试模式未开启，请在插件配置中启用 enableDebug。";
+    const n = Math.max(1, Math.min(Number(ticks) || 1, 2e3));
+    const stepSec = Math.max(10, Math.min(Number(step) || 120, 3600));
+    const stepMs = stepSec * 1e3;
+    const startPrice = currentPrice;
+    let minP = startPrice, maxP = startPrice;
+    let clampHits = 0;
+    const startNow = /* @__PURE__ */ new Date();
+    __testNow = new Date(startNow);
+    for (let i = 0; i < n; i++) {
+      await updatePrice();
+      const after = currentPrice;
+      minP = Math.min(minP, after);
+      maxP = Math.max(maxP, after);
+      const baseStart = (await ctx.database.get("bourse_state", { key: "macro_state" }))[0]?.startPrice ?? after;
+      const dayBase = dailyOpenPrice ?? baseStart;
+      const upper = Math.min(baseStart * 1.5, dayBase * 1.5);
+      const lower = Math.max(baseStart * 0.5, dayBase * 0.5);
+      if (after >= upper * 0.99 || after <= lower * 1.01) clampHits++;
+      __testNow = new Date(__testNow.getTime() + stepMs);
+    }
+    __testNow = null;
+    const drift = Number((currentPrice - startPrice).toFixed(2));
+    return `内部测试
+步数：${n}；步长：${stepSec}s
+起始：${startPrice.toFixed(2)}；结束：${currentPrice.toFixed(2)}（Δ=${drift}）
+最高：${maxP.toFixed(2)}；最低：${minP.toFixed(2)}
+接近限幅次数：${clampHits}`;
+  });
+  ctx.command("bourse.test.manualThenAuto <target:number> [hours:number] [ticks:number]", "开发测试：手动周期后切回自动的连续性", { authority: 3 }).action(async ({ session }, target, hours, ticks) => {
+    if (!config.enableDebug) return "调试模式未开启，请在插件配置中启用 enableDebug。";
+    const dur = Math.max(1, Math.min(Number(hours) || 6, 48));
+    const n = Math.max(10, Math.min(Number(ticks) || 300, 5e3));
+    await session?.execute?.(`stock.control ${target} ${dur}`);
+    const stepMs = 2 * 60 * 1e3;
+    __testNow = /* @__PURE__ */ new Date();
+    for (let i = 0; i < dur * 30; i++) {
+      await updatePrice();
+      __testNow = new Date(__testNow.getTime() + stepMs);
+    }
+    const before = currentPrice;
+    for (let i = 0; i < n; i++) {
+      await updatePrice();
+      __testNow = new Date(__testNow.getTime() + stepMs);
+    }
+    const after = currentPrice;
+    __testNow = null;
+    const moved = Math.abs(after - before) >= 0.01;
+    return `手动→自动 测试
+目标=${target}，期限=${dur}小时
+手动结束价：${before.toFixed(2)}；后续${n}步结束：${after.toFixed(2)}
+是否继续波动：${moved ? "是" : "否（需检查）"}`;
+  });
   async function renderHoldingImage(ctx2, username, holding, pending, currency) {
     const hasCostData = holding && holding.totalCost !== null;
     const isProfit = hasCostData ? holding.profit >= 0 : true;
@@ -1092,252 +1211,52 @@ function apply(ctx, config) {
     return import_koishi.h.image(imgBuf, "image/png");
   }
   __name(renderHoldingImage, "renderHoldingImage");
-  async function renderStockImage(ctx2, data, name2, current, high, low) {
+  async function renderStockImage(ctx2, data, name2, viewLabel, current, high, low) {
     if (data.length < 2) return "数据不足，无法绘制走势图。";
     const startPrice = data[0].price;
     const change = current - startPrice;
     const changePercent = change / startPrice * 100;
     const isUp = change >= 0;
-    const color = isUp ? "#d93025" : "#188038";
-    const points = JSON.stringify(data.map((d) => d.price));
-    const times = JSON.stringify(data.map((d) => d.time));
-    const timestamps = JSON.stringify(data.map((d) => d.timestamp));
-    const html = `
-    <html>
-    <head>
-      <style>
-        body { margin: 0; padding: 20px; font-family: 'Segoe UI', Roboto, Helvetica, Arial, sans-serif; background: #f5f7fa; width: 700px; box-sizing: border-box; }
-        .card { background: white; padding: 25px; border-radius: 16px; box-shadow: 0 10px 25px rgba(0,0,0,0.05); }
-        .header { display: flex; justify-content: space-between; align-items: flex-start; margin-bottom: 20px; }
-        .title-group { display: flex; flex-direction: column; }
-        .title { font-size: 28px; font-weight: 800; color: #1a1a1a; letter-spacing: -0.5px; }
-        .sub-info { font-size: 14px; color: #888; margin-top: 5px; font-weight: 500; }
-        .price-group { text-align: right; }
-        .price { font-size: 42px; font-weight: 800; color: ${color}; letter-spacing: -1px; line-height: 1; }
-        .change { font-size: 18px; font-weight: 600; color: ${color}; margin-top: 5px; display: flex; align-items: center; justify-content: flex-end; gap: 5px; }
-        .badge { background: #f0f2f5; padding: 4px 8px; border-radius: 6px; font-size: 12px; color: #555; font-weight: 600; }
-        canvas { width: 100%; height: 350px; }
-      </style>
-    </head>
-    <body>
-      <div class="card">
-        <div class="header">
-          <div class="title-group">
-            <div class="title">${name2}</div>
-            <div class="sub-info">
-              <span class="badge">High: ${high.toFixed(2)}</span>
-              <span class="badge">Low: ${low.toFixed(2)}</span>
-            </div>
-          </div>
-          <div class="price-group">
-            <div class="price">${current.toFixed(2)}</div>
-            <div class="change">
-              <span>${change >= 0 ? "+" : ""}${change.toFixed(2)}</span>
-              <span>(${changePercent.toFixed(2)}%)</span>
-            </div>
-          </div>
-        </div>
-        <canvas id="chart" width="1300" height="700"></canvas>
-      </div>
-      <script>
-        const canvas = document.getElementById('chart');
-        const ctx = canvas.getContext('2d');
-        const prices = ${points};
-        const times = ${times};
-        const timestamps = ${timestamps};
-        const width = canvas.width;
-        const height = canvas.height;
-        const padding = { top: 20, bottom: 40, left: 40, right: 100 };
-        
-        const max = Math.max(...prices);
-        const min = Math.min(...prices);
-        const range = max - min || 1;
-        const yMin = min - range * 0.1;
-        const yMax = max + range * 0.1;
-        const yRange = yMax - yMin;
-
-        const minTime = timestamps[0];
-        const maxTime = timestamps[timestamps.length - 1];
-        const timeRange = maxTime - minTime || 1;
-
-        function getX(t) { return ((t - minTime) / timeRange) * (width - padding.left - padding.right) + padding.left; }
-        function getY(p) { return height - padding.bottom - ((p - yMin) / yRange) * (height - padding.top - padding.bottom); }
-        
-        // 1. Draw Grid
-        ctx.strokeStyle = '#f0f0f0';
-        ctx.lineWidth = 2;
-        ctx.beginPath();
-        const gridSteps = 5;
-        for (let i = 0; i <= gridSteps; i++) {
-            const y = height - padding.bottom - (i / gridSteps) * (height - padding.top - padding.bottom);
-            ctx.moveTo(padding.left, y);
-            ctx.lineTo(width - padding.right, y);
-        }
-        ctx.stroke();
-
-        // 2. Draw Area (Gradient Fill)
-        const gradient = ctx.createLinearGradient(0, 0, 0, height);
-        gradient.addColorStop(0, '${isUp ? "rgba(217, 48, 37, 0.15)" : "rgba(24, 128, 56, 0.15)"}');
-        gradient.addColorStop(1, 'rgba(255, 255, 255, 0)');
-
-        ctx.beginPath();
-        ctx.moveTo(getX(timestamps[0]), height - padding.bottom);
-        // Use Bezier curves for smoothing
-        for (let i = 0; i < prices.length - 1; i++) {
-            const x = getX(timestamps[i]);
-            const y = getY(prices[i]);
-            const nextX = getX(timestamps[i + 1]);
-            const nextY = getY(prices[i + 1]);
-            const cpX = (x + nextX) / 2;
-            if (i === 0) ctx.moveTo(x, y);
-            ctx.quadraticCurveTo(x, y, cpX, (y + nextY) / 2);
-        }
-        // Connect to last point
-        ctx.lineTo(getX(timestamps[prices.length - 1]), getY(prices[prices.length - 1]));
-        
-        // Close path for fill
-        ctx.lineTo(getX(timestamps[prices.length - 1]), height - padding.bottom);
-        ctx.closePath();
-        ctx.fillStyle = gradient;
-        ctx.fill();
-
-        // 3. Draw Line (Smooth)
-        ctx.lineWidth = 4;
-        ctx.lineJoin = 'round';
-        ctx.lineCap = 'round';
-        ctx.strokeStyle = '${color}';
-        ctx.shadowColor = '${isUp ? "rgba(217, 48, 37, 0.3)" : "rgba(24, 128, 56, 0.3)"}';
-        ctx.shadowBlur = 10;
-        
-        ctx.beginPath();
-        for (let i = 0; i < prices.length - 1; i++) {
-            const x = getX(timestamps[i]);
-            const y = getY(prices[i]);
-            const nextX = getX(timestamps[i + 1]);
-            const nextY = getY(prices[i + 1]);
-            const cpX = (x + nextX) / 2;
-            if (i === 0) ctx.moveTo(x, y);
-            // Use quadratic curve for simple smoothing between points
-            // Actually, to pass through points, we need a different approach or just straight lines for accuracy.
-            // But for "beautify", slight smoothing is okay. 
-            // A simple smoothing is to use midpoints as control points.
-            // Let's stick to straight lines for accuracy but add shadow/glow.
-            // Or use a simple spline.
-            // Let's revert to straight lines for financial accuracy but keep the glow.
-            ctx.lineTo(nextX, nextY);
-        }
-        ctx.stroke();
-        ctx.shadowBlur = 0;
-
-        // 4. Draw Last Point Marker
-        const lastX = getX(timestamps[prices.length - 1]);
-        const lastY = getY(prices[prices.length - 1]);
-        
-        ctx.beginPath();
-        ctx.arc(lastX, lastY, 6, 0, Math.PI * 2);
-        ctx.fillStyle = 'white';
-        ctx.fill();
-        
-        ctx.beginPath();
-        ctx.arc(lastX, lastY, 4, 0, Math.PI * 2);
-        ctx.fillStyle = '${color}';
-        ctx.fill();
-
-        // 5. Draw Dashed Line to Y-Axis
-        ctx.beginPath();
-        ctx.setLineDash([4, 4]);
-        ctx.strokeStyle = '#ccc';
-        ctx.lineWidth = 1;
-        ctx.moveTo(padding.left, lastY);
-        ctx.lineTo(width - padding.right, lastY);
-        ctx.stroke();
-        ctx.setLineDash([]);
-
-        // 6. Draw Axis Labels
-        ctx.fillStyle = '#999';
-        ctx.font = '600 20px "Segoe UI", sans-serif';
-        ctx.textAlign = 'left';
-        ctx.textBaseline = 'middle';
-
-        for (let i = 0; i <= gridSteps; i++) {
-            const val = yMin + (i / gridSteps) * yRange;
-            const y = height - padding.bottom - (i / gridSteps) * (height - padding.top - padding.bottom);
-            ctx.fillText(val.toFixed(2), width - padding.right + 10, y);
-        }
-        
-        ctx.fillStyle = '${color}';
-        ctx.font = 'bold 20px "Segoe UI", sans-serif';
-        ctx.fillText(prices[prices.length-1].toFixed(2), width - padding.right + 10, lastY);
-
-        ctx.textAlign = 'center';
-        ctx.fillStyle = '#999';
-        ctx.font = '500 18px "Segoe UI", sans-serif';
-        
-        // 动态计算标签间隔，防止重叠
-        // 使用最长的时间标签来估算宽度
-        let maxLabelWidth = 0;
-        for (let i = 0; i < times.length; i++) {
-            const w = ctx.measureText(times[i]).width;
-            if (w > maxLabelWidth) maxLabelWidth = w;
-        }
-        const labelWidth = maxLabelWidth + 40; // 加40px间距确保不重叠
-        const availableWidth = width - padding.left - padding.right;
-        const maxLabels = Math.max(2, Math.floor(availableWidth / labelWidth));
-        const labelCount = Math.min(maxLabels, 5); // 最多显示5个标签
-        const timeStep = Math.max(1, Math.ceil(times.length / labelCount));
-        
-        // 选取要绘制的标签索引（均匀分布）
-        const labelIndices = [];
-        for (let i = 0; i < times.length; i += timeStep) {
-           labelIndices.push(i);
-        }
-        // 确保最后一个点在列表中
-        if (labelIndices[labelIndices.length - 1] !== times.length - 1) {
-           labelIndices.push(times.length - 1);
-        }
-        
-        // 绘制标签，跳过重叠的
-        const drawnLabels = [];
-        for (const i of labelIndices) {
-           const x = getX(timestamps[i]);
-           const textWidth = ctx.measureText(times[i]).width;
-           
-           // 根据textAlign计算实际占用的区域
-           let leftEdge, rightEdge;
-           if (i === 0) {
-               leftEdge = x;
-               rightEdge = x + textWidth;
-           } else if (i === times.length - 1) {
-               leftEdge = x - textWidth;
-               rightEdge = x;
-           } else {
-               leftEdge = x - textWidth / 2;
-               rightEdge = x + textWidth / 2;
-           }
-           
-           // 检查是否与已绘制的标签重叠
-           let overlaps = false;
-           for (const drawn of drawnLabels) {
-               // 两个标签之间至少要有15px间隔
-               if (!(rightEdge + 15 < drawn.left || leftEdge - 15 > drawn.right)) {
-                   overlaps = true;
-                   break;
-               }
-           }
-           if (overlaps) continue;
-           
-           if (i === 0) ctx.textAlign = 'left';
-           else if (i === times.length - 1) ctx.textAlign = 'right';
-           else ctx.textAlign = 'center';
-           
-           ctx.fillText(times[i], x, height - 10);
-           drawnLabels.push({ left: leftEdge, right: rightEdge });
-        }
-
-      </script>
-    </body>
-    </html>
-    `;
+    const templatePath = (0, import_path.resolve)(__dirname, "templates", "stock-chart.html");
+    let html = await import_fs.promises.readFile(templatePath, "utf-8");
+    const colorScheme = {
+      mainColor: isUp ? "#f23645" : "#089981",
+      gradientStart: isUp ? "rgba(242, 54, 69, 0.25)" : "rgba(8, 153, 129, 0.25)",
+      gradientEnd: "rgba(255, 255, 255, 0)",
+      glowColor: isUp ? "rgba(242, 54, 69, 0.4)" : "rgba(8, 153, 129, 0.4)",
+      iconGradientStart: isUp ? "#f23645" : "#089981",
+      iconGradientEnd: isUp ? "#ff7e87" : "#40c2aa",
+      iconShadow: isUp ? "rgba(242, 54, 69, 0.3)" : "rgba(8, 153, 129, 0.3)",
+      changeBadgeBg: isUp ? "rgba(242, 54, 69, 0.12)" : "rgba(8, 153, 129, 0.12)"
+    };
+    const replacements = {
+      "{{MAIN_COLOR}}": colorScheme.mainColor,
+      "{{GRADIENT_START}}": colorScheme.gradientStart,
+      "{{GRADIENT_END}}": colorScheme.gradientEnd,
+      "{{GLOW_COLOR}}": colorScheme.glowColor,
+      "{{ICON_GRADIENT_START}}": colorScheme.iconGradientStart,
+      "{{ICON_GRADIENT_END}}": colorScheme.iconGradientEnd,
+      "{{ICON_SHADOW}}": colorScheme.iconShadow,
+      "{{CHANGE_BADGE_BG}}": colorScheme.changeBadgeBg,
+      "{{STOCK_NAME}}": name2,
+      "{{VIEW_LABEL}}": viewLabel,
+      "{{CURRENT_TIME}}": (/* @__PURE__ */ new Date()).toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit" }),
+      "{{CURRENT_PRICE}}": current.toFixed(2),
+      "{{CHANGE_VALUE}}": `${change >= 0 ? "+" : ""}${change.toFixed(2)}`,
+      "{{CHANGE_ICON}}": change >= 0 ? "↑" : "↓",
+      "{{CHANGE_PERCENT}}": Math.abs(changePercent).toFixed(2),
+      "{{HIGH_PRICE}}": high.toFixed(2),
+      "{{LOW_PRICE}}": low.toFixed(2),
+      "{{AMPLITUDE}}": ((high - low) / startPrice * 100).toFixed(2),
+      "{{START_PRICE}}": startPrice.toFixed(2),
+      "{{UPDATE_TIME}}": (/* @__PURE__ */ new Date()).toLocaleString("zh-CN"),
+      "{{PRICES}}": JSON.stringify(data.map((d) => d.price)),
+      "{{TIMES}}": JSON.stringify(data.map((d) => d.time)),
+      "{{TIMESTAMPS}}": JSON.stringify(data.map((d) => d.timestamp))
+    };
+    for (const [key, value] of Object.entries(replacements)) {
+      html = html.replace(new RegExp(key, "g"), value);
+    }
     const page = await ctx2.puppeteer.page();
     await page.setContent(html);
     const element = await page.$(".card");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-monetary-bourse",
-  "version": "1.1.2-Alpha.6",
+  "version": "2.0.0-Alpha.8",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -12,58 +12,11 @@
   - 内置 **12 种日内走势形态**（如：早盘冲高回落、V型反转、尾盘拉升、M顶/W底等）。
   - 走势不再是单纯的随机波动，每天自动或随机切换不同的操盘剧本，大幅提升观察乐趣。
   - 结合 **周级波浪** 与 **宏观趋势**，模拟真实市场的多周期叠加效应。
-- **📊 精美 K 线与持仓渲染**：使用 Puppeteer 渲染实时/日/周线图和个人持仓信息，Alpha 2 版本优化了坐标轴标签算法，防止文字重叠，观感更佳。
+- **📊 精美 K 线与持仓渲染**：使用 Puppeteer 渲染实时/日/周线图和个人持仓信息，
 - **❄️ 资金冻结机制**：交易采用 T+0 但资金/股票非即时到账模式，根据金额计算冻结时间，增加博弈深度。
 - **🏦 银行联动**：支持与[ `koishi-plugin-monetary-bank`](https://github.com/BYWled/koishi-plugin-monetary-bank)[![npm](https://img.shields.io/npm/v/koishi-plugin-monetary-bank?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-monetary-bank) 联动，现金不足时自动扣除银行活期存款。
 - **🕹️ 宏观调控**：管理员可手动干预股价目标，或强制切换当天的 K 线剧本。
 
-## 更新记录
-
-- **Alpha.6**：
-  - **重大重构**：改用百分比波动模式，所有波动（K线、周波浪、噪音）以百分比形式叠加在趋势价格上，彻底解决振幅失控问题。
-  - 修复：手动宏观调控不再重置周期基准价和起点，保持现有波动机制持续生效。
-  - 优化：K线波动幅度调整为±3%，周波浪和噪音也改为百分比计算，波动更符合真实股票特性。
-  - 性能：新的百分比合成模式更稳定，长期运行不会出现价格失控或波动失效。
-
-- **Alpha.5**：
-  - **重写股票走势引擎**：将增量叠加模式改为绝对价格计算模式，彻底解决长期运行后的高频抖动问题。
-    - 修复：走势计算采用绝对值合成（基准价+趋势进度+日内波动+周波浪+噪音），避免累积误差导致的失控。
-    - 修复：增强±50%限幅机制，确保所有场景下（实时/日/周）均严格受限。
-    - 优化：简化宏观调控状态刷新逻辑，移除复杂的delta计算，提升稳定性。
-    - 性能：新引擎更清晰高效，可长期稳定运行，不会出现抖动或限幅失效。
-
-- **1.1.1（Alpha.4）**：
-  - 新增：硬性涨跌幅上限规则（±50%），同时约束日内与周内视角。随机与手动调控的结果均会在应用前进行限幅。
-  - 新增：更随机的自动宏观调控——随机刷新宏观目标（约每 6–24 小时），并随机调整周波浪频率与幅度（波浪段数约 5–10、周幅度约 6%–12%）。
-  - 修复：手动宏观调控命令更新状态时，严格排除主键字段，避免 `TypeError: cannot modify primary key`。
-  - 变更：移除配置项中的手动宏观调控相关字段（`enableManualControl`、`manualTargetPrice`、`manualDuration`），改为仅通过管理员指令进行宏观调控。
-  - 新增：开发测试命令方便快速验证逻辑（`bourse.test.price`、`bourse.test.clamp`），默认注释不启用，若需要请手动修改代码打开调试。
-
-- **1.1.0**：
-  - Alpha.3版本转为正式版。
-
-- **Alpha.3**：
-  - 新增：持仓盈亏计算与持仓成本追踪（`totalCost` 字段），在 `stock.my` 中展示成本价、持仓成本、当前市值、盈亏金额与盈亏百分比。
-  - 新增：持仓信息 HTML 渲染（`renderHoldingImage`），使用 Puppeteer 输出美观的持仓卡片图像，包含进行中的挂单列表和盈亏高亮显示。
-  - 修复：统一所有金额与价格的显示与存储为保留两位小数，避免浮点精度累积导致的计算偏差（涉及 `currentPrice`、历史记录、支付、扣款、银行活期处理等）。
-  - 修复：兼容旧版持仓数据（旧记录没有 `totalCost`）——合并新旧持仓时使用合理估算策略以避免成本被稀释：
-    - 若旧持仓无成本记录，新买入时以交易单价对旧持仓进行估算（保证合并后平均成本合理）；
-    - 卖出时若无成本记录则使用当前市价估算以避免错误盈亏展示。
-  - 修复：当 `maxFreezeTime = 0`（表示无冻结）时，交易将立即完成并触发即时处理（不再长期挂起）。
-  - 修复：支付、现金变更及银行活期扣除流程中均使用两位小数保留，避免因浮点运算导致余额不一致。
-
-- **1.0.0**：
-  - 修复：解决长期运行时触发的 `TypeError: cannot modify primary key`（更新 `bourse_state` 时排除主键字段，仅按条件写入非主键字段），提高数据库兼容性与稳定性。
-
-- **Alpha.2**：
-  - 在 Alpha.1 的基础上，扩展并完善了 K 线引擎，新增 12 种日内走势剧本、周级波浪叠加以及坐标轴标签冲突修复等视觉与体验改进。
-  - 该版本引入了更丰富的日内走势（例如早盘冲高回落、V 型反转、尾盘拉升、M 顶/W 底等），并改进了 Puppeteer 渲染逻辑以减少横轴标签重叠。
-  - 致命问题说明：长期运行时可能触发 `TypeError: cannot modify primary key`（根因：更新持久化 `bourse_state` 时不小心将主键字段包含在更新负载中，某些数据库实现会拒绝修改主键），该问题在后续修复版本中已处理，请在生产环境中尽量升级至稳定版本。
-
-- **Alpha.1**：
-  - 发布基础功能：买卖、资金冻结、挂单、历史行情存储以及 `stock` 家族指令（`stock` / `stock.buy` / `stock.sell` / `stock.my`）。
-  - 支持与 `monetary` 与 `monetary-bank` 的基本联动，提供最小可用的股票交易所模拟能力。
-
 ## 📦 依赖
 
 本插件需要以下服务：
@@ -71,29 +24,6 @@
 - `puppeteer`: 用于渲染股市行情图。
 - `monetary`: (可选) 用于获取用户货币余额（本插件直接操作数据库表，monetary 插件需安装以建立表结构）。
 
-## 🔧 配置项
-
-可以在控制台插件配置页进行设置：
-
-### 基础设置
-- **currency**: 货币单位名称（默认：`信用点`）。
-- **stockName**: 股票名称（默认：`Koishi股份`）。
-- **initialPrice**: 股票初始价格（默认：`1200`）。
-- **maxHoldings**: 单人最大持仓限制（默认：`100000`）。
-
-### 交易时间
-- **openHour**: 每日开市时间（小时，0-23，默认 `8` 点）。
-- **closeHour**: 每日休市时间（小时，0-23，默认 `23` 点）。
-- **marketStatus**: 股市总开关，可选 `open` (强制开启)、`close` (强制关闭)、`auto` (自动按时间)。
-
-### 冻结机制
-- **freezeCostPerMinute**: 每多少货币金额计为1分钟冻结时间（默认 `100`）。
-- **minFreezeTime**: 最小冻结时间（分钟，默认 `10`）。
-- **maxFreezeTime**: 最大冻结时间（分钟，默认 `1440` 即24小时）。
-
-### 宏观调控
-- 已移除配置项中的手动宏观调控字段；请使用管理员指令进行宏观调控。
-
 ## 🎮 指令说明
 
 ### 用户指令
@@ -136,10 +66,16 @@
 - 【默认不开启】**`bourse.test.price [ticks]`**
   - 开发测试：推进价格更新若干次并返回当前价格。
   - 参数 `ticks`: 推进次数，默认 1，最大 500。
+  - 需要在配置中启用 `enableDebug` 才可使用。
+
+- 【默认不开启】**`bourse.test.run <ticks> [step]`**
+  - 开发测试：按虚拟时间推进并统计价格分布。
+  - 参数 `ticks`: 推进步数；`step`: 每步秒数（默认120秒）。
+  - 需要在配置中启用 `enableDebug` 才可使用。
 
-- 【默认不开启】**`bourse.test.clamp <percent>`**
-  - 开发测试：尝试目标涨跌幅并查看限幅结果。
-  - 参数 `percent`: 期望涨跌百分比，例如 `60` 或 `-40`。
+- 【默认不开启】**`bourse.test.manualThenAuto <target> [hours] [ticks]`**
+  - 开发测试：测试手动调控后切回自动的连续性。
+  - 需要在配置中启用 `enableDebug` 才可使用。
 
 ## 💡 常见问题
 
@@ -156,17 +92,117 @@ A: 本插件设计了基于交易金额的动态冻结机制。交易额越大
 ---
 
 **Q: 股价是如何波动的？**
-A: 股价采用**百分比波动模式**（Alpha.6），由以下部分合成：
+A: 股价采用**几何布朗运动 + 均值回归**模型（Alpha.7），更贴近真实股票：
+
+**核心公式：** `新价格 = 当前价格 × (1 + 总收益率)`
+
+**总收益率由以下部分组成：**
 
-1. **宏观趋势**：周期内从起始价线性向目标价移动的基准价格。
-2. **日内K线形态**：12种剧本产生的波动因子，以±3%的百分比形式叠加在趋势上。
-3. **周内波浪**：正弦曲线的波动因子，以周波浪幅度百分比（6%–12%）形式叠加。
-4. **微小噪音**：±0.1%的随机扰动避免价格过于规律。
+1. **均值回归项（Drift）**：价格会自然向"预期价格"回归
+   - 预期价格 = 周期起始价 → 目标价的线性插值
+   - 偏离越大，回归力越强（每次回归5%的偏差，Alpha.8增强）
 
-**最终价格 = 趋势价格 × (1 + K线因子 + 波浪因子 + 噪音因子)**
+2. **随机波动项（Random Walk）**：模拟市场的随机性
+   - 使用正态分布随机数（Box-Muller变换）
+   - 基础波动率约0.25%/tick（Alpha.8增强，原0.12%）
 
-这种百分比合成方式更符合真实股票特性，所有波动相对于当前价格保持合理比例，避免绝对值叠加导致的振幅失控。
+3. **动态波动率**：模拟日内波动率变化
+   - 开盘：波动率高（活跃交易）
+   - 午盘：波动率低（相对平静）
+   - 尾盘：波动率再次升高
 
-在Alpha.5版本以前，股价仍由四部分叠加而成，新旧引擎的效果相同，仅仅是在算法上进行优化与修复。
+4. **K线形态偏置**：12种日内形态提供方向性偏好
+   - Alpha.8增强了形态影响力（约3倍），让日内走势更有"剧本感"
 
-此外，为保证市场稳定性，应用了**涨跌幅硬性限制**：相对于周周期起始价与当日开盘价的双重基准，股价的涨跌幅不得超过 ±50%。当随机或手动设置的目标超出限幅时，将自动截断至限幅边界。
+5. **周期波浪**：中期波动，模拟市场情绪周期
+   - 幅度范围4%-12%（Alpha.8增强，原2%-6%）
+
+**限幅机制：** 相对于周期起始价和日开盘价的±50%，采用软着陆方式避免硬切。
+
+## 🔧 配置项
+
+可以在控制台插件配置页进行设置：
+
+### 基础设置
+- **currency**: 货币单位名称（默认：`信用点`）。
+- **stockName**: 股票名称（默认：`Koishi股份`）。
+- **initialPrice**: 股票初始价格（默认：`1200`）。
+- **maxHoldings**: 单人最大持仓限制（默认：`100000`）。
+
+### 交易时间
+- **openHour**: 每日开市时间（小时，0-23，默认 `8` 点）。
+- **closeHour**: 每日休市时间（小时，0-23，默认 `23` 点）。
+- **marketStatus**: 股市总开关，可选 `open` (强制开启)、`close` (强制关闭)、`auto` (自动按时间)。
+
+### 冻结机制
+- **freezeCostPerMinute**: 每多少货币金额计为1分钟冻结时间（默认 `100`）。
+- **minFreezeTime**: 最小冻结时间（分钟，默认 `10`）。
+- **maxFreezeTime**: 最大冻结时间（分钟，默认 `1440` 即24小时）。
+
+### 开发者选项
+- **enableDebug**: 是否启用调试模式（默认 `false`）。开启后可使用 `bourse.test.*` 系列调试指令。
+
+### 宏观调控
+- 已移除配置项中的手动宏观调控字段；请使用管理员指令进行宏观调控。
+
+## 更新记录
+- **Alpha.8**：
+  - **代码与 UI 综合更新**：将股票走势图 HTML 模板提取到独立文件 `src/templates/stock-chart.html` 并改用模板替换渲染，前端采用深色玻璃拟态设计（渐变背景、发光曲线、脉冲指示点），底部新增振幅/开盘价等统计信息，视觉与结构双向优化。进一步调整页面比例为4:3（1024x768），优化字体栈（Inter、SF Pro Display等现代字体），增大字体大小和间距，提升可读性。移除股票名称后的括号后缀，改为动态视图标签（实时走势/日走势/周走势）。修改坐标轴字体为更现代的样式，并修复“数据更新于”行在截图中的可见性问题。
+  - **T+0 挂单排队（防绕过机制）**：为避免用户通过拆单（多个小额挂单）绕开冻结时长，本次将挂单（`bourse_pending`）改为按用户串行排队处理。新挂单在创建时会检测该用户最后一个未完成挂单的 `endTime`，若存在则将新挂单的 `startTime` 设置为上一个挂单的 `endTime`，`endTime` 在其基础上累加当前挂单应有的冻结时长。这样同一用户的多个挂单会按先后顺序依次读秒，总冻结时间等于各挂单冻结时长之和，从而与合并为一笔的大额交易保持一致性，避免通过拆单缩短冻结时长的行为。
+  - **算法增强**：提升基础波动率（0.12%→0.25%/tick）、增强 K 线形态影响力（约 3 倍）、将周波浪幅度收敛为 4%–12%、并加强均值回归强度（5%/tick）；同时改进坐标轴标签算法以减少重叠，整体让走势更生动且可读性更好。
+  - **调试与可维护性**：新增 `enableDebug` 配置项（默认关闭），调试命令仅在开启时可用；模板化设计使得 UI 调整无需改动 TypeScript 代码，提高可维护性。
+  - 优化：代码更清晰、模板化后便于后续扩展与样式调整。
+
+- **Alpha.7**：
+  - **采用真实股票模型**：使用几何布朗运动 + 均值回归模型，更贴近真实股票走势。
+  - 新增：均值回归机制——价格会自然向"预期价格"回归，而非硬性跳变。
+  - 新增：动态波动率——开盘和收盘波动大，午盘相对平静（U型波动率曲线）。
+  - 新增：正态分布随机项——使用Box-Muller变换生成更真实的随机波动。
+  - 新增：软着陆限幅——接近涨跌幅限制时逐渐减缓，避免硬切导致的不自然走势。
+  - 优化：K线形态改为提供方向性偏置，而非直接决定价格位置。
+  - 优化：周期波浪改为增量式叠加，更平滑自然。
+
+- **Alpha.6**：
+  - **再次重构**：改用百分比波动模式，所有波动（K线、周波浪、噪音）以百分比形式叠加在趋势价格上，彻底解决振幅失控问题。
+  - 修复：手动宏观调控不再重置周期基准价和起点，保持现有波动机制持续生效。
+  - 优化：K线波动幅度调整为±3%，周波浪和噪音也改为百分比计算，波动更符合真实股票特性。
+  - 性能：新的百分比合成模式更稳定，长期运行不会出现价格失控或波动失效。
+
+- **Alpha.5**：
+  - **重写股票走势引擎**：将增量叠加模式改为绝对价格计算模式，彻底解决长期运行后的高频抖动问题。
+    - 修复：走势计算采用绝对值合成（基准价+趋势进度+日内波动+周波浪+噪音），避免累积误差导致的失控。
+    - 修复：增强±50%限幅机制，确保所有场景下（实时/日/周）均严格受限。
+    - 优化：简化宏观调控状态刷新逻辑，移除复杂的delta计算，提升稳定性。
+    - 性能：新引擎更清晰高效，可长期稳定运行，不会出现抖动或限幅失效。
+
+- **1.1.1（Alpha.4）**：
+  - 新增：硬性涨跌幅上限规则（±50%），同时约束日内与周内视角。随机与手动调控的结果均会在应用前进行限幅。
+  - 新增：更随机的自动宏观调控——随机刷新宏观目标（约每 6–24 小时），并随机调整周波浪频率与幅度（波浪段数约 5–10、周幅度约 6%–12%）。
+  - 修复：手动宏观调控命令更新状态时，严格排除主键字段，避免 `TypeError: cannot modify primary key`。
+  - 变更：移除配置项中的手动宏观调控相关字段（`enableManualControl`、`manualTargetPrice`、`manualDuration`），改为仅通过管理员指令进行宏观调控。
+  - 新增：开发测试命令方便快速验证逻辑（`bourse.test.price`、`bourse.test.clamp`），默认注释不启用，若需要请手动修改代码打开调试。
+
+- **1.1.0**：
+  - Alpha.3版本转为正式版。
+
+- **Alpha.3**：
+  - 新增：持仓盈亏计算与持仓成本追踪（`totalCost` 字段），在 `stock.my` 中展示成本价、持仓成本、当前市值、盈亏金额与盈亏百分比。
+  - 新增：持仓信息 HTML 渲染（`renderHoldingImage`），使用 Puppeteer 输出美观的持仓卡片图像，包含进行中的挂单列表和盈亏高亮显示。
+  - 修复：统一所有金额与价格的显示与存储为保留两位小数，避免浮点精度累积导致的计算偏差（涉及 `currentPrice`、历史记录、支付、扣款、银行活期处理等）。
+  - 修复：兼容旧版持仓数据（旧记录没有 `totalCost`）——合并新旧持仓时使用合理估算策略以避免成本被稀释：
+    - 若旧持仓无成本记录，新买入时以交易单价对旧持仓进行估算（保证合并后平均成本合理）；
+    - 卖出时若无成本记录则使用当前市价估算以避免错误盈亏展示。
+  - 修复：当 `maxFreezeTime = 0`（表示无冻结）时，交易将立即完成并触发即时处理（不再长期挂起）。
+  - 修复：支付、现金变更及银行活期扣除流程中均使用两位小数保留，避免因浮点运算导致余额不一致。
+
+- **1.0.0**：
+  - 修复：解决长期运行时触发的 `TypeError: cannot modify primary key`（更新 `bourse_state` 时排除主键字段，仅按条件写入非主键字段），提高数据库兼容性与稳定性。
+
+- **Alpha.2**：
+  - 在 Alpha.1 的基础上，扩展并完善了 K 线引擎，新增 12 种日内走势剧本、周级波浪叠加以及坐标轴标签冲突修复等视觉与体验改进。
+  - 该版本引入了更丰富的日内走势（例如早盘冲高回落、V 型反转、尾盘拉升、M 顶/W 底等），并改进了 Puppeteer 渲染逻辑以减少横轴标签重叠。
+  - 致命问题说明：长期运行时可能触发 `TypeError: cannot modify primary key`（根因：更新持久化 `bourse_state` 时不小心将主键字段包含在更新负载中，某些数据库实现会拒绝修改主键），该问题在后续修复版本中已处理，请在生产环境中尽量升级至稳定版本。
+
+- **Alpha.1**：
+  - 发布基础功能：买卖、资金冻结、挂单、历史行情存储以及 `stock` 家族指令（`stock` / `stock.buy` / `stock.sell` / `stock.my`）。
+  - 支持与 `monetary` 与 `monetary-bank` 的基本联动，提供最小可用的股票交易所模拟能力。