backtest-kit 11.9.0 → 12.1.0

package/build/index.cjs

@@ -21061,6 +21061,24 @@ class WalkerCommandService {
     }
 }
 
+/**
+ * Derives the number of decimal places to show for a price based on the
+ * magnitude of its integer part. Larger prices need fewer decimals; sub-dollar
+ * prices keep full precision.
+ * @param value - The price to derive the decimal scale for
+ * @returns The number of digits after the decimal point
+ */
+const getPriceScale = (value) => {
+    const abs = Math.abs(value);
+    if (abs >= 1) {
+        // 1..9 -> 4, 10..99 -> 3, 100..999 -> 2, 1000+ -> 2 (floor), capped at 2
+        const digits = Math.floor(Math.log10(abs)) + 1;
+        return Math.max(2, 6 - digits);
+    }
+    // Sub-dollar prices need more precision.
+    return 8;
+};
+
 /**
  * Converts markdown content to plain text with minimal formatting
  * @param content - Markdown string to convert
@@ -21169,43 +21187,43 @@ const backtest_columns = [
     {
         key: "openPrice",
         label: "Open Price",
-        format: (data) => `${data.signal.priceOpen.toFixed(8)} USD`,
+        format: (data) => `${data.signal.priceOpen.toFixed(getPriceScale(data.signal.priceOpen))} USD`,
         isVisible: () => true,
     },
     {
         key: "closePrice",
         label: "Close Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        format: (data) => `${data.currentPrice.toFixed(getPriceScale(data.currentPrice))} USD`,
         isVisible: () => true,
     },
     {
         key: "takeProfit",
         label: "Take Profit",
-        format: (data) => `${data.signal.priceTakeProfit.toFixed(8)} USD`,
+        format: (data) => `${data.signal.priceTakeProfit.toFixed(getPriceScale(data.signal.priceTakeProfit))} USD`,
         isVisible: () => true,
     },
     {
         key: "stopLoss",
         label: "Stop Loss",
-        format: (data) => `${data.signal.priceStopLoss.toFixed(8)} USD`,
+        format: (data) => `${data.signal.priceStopLoss.toFixed(getPriceScale(data.signal.priceStopLoss))} USD`,
         isVisible: () => true,
     },
     {
         key: "originalPriceTakeProfit",
         label: "Original TP",
-        format: (data) => `${data.signal.originalPriceTakeProfit.toFixed(8)} USD`,
+        format: (data) => `${data.signal.originalPriceTakeProfit.toFixed(getPriceScale(data.signal.originalPriceTakeProfit))} USD`,
         isVisible: () => true,
     },
     {
         key: "originalPriceStopLoss",
         label: "Original SL",
-        format: (data) => `${data.signal.originalPriceStopLoss.toFixed(8)} USD`,
+        format: (data) => `${data.signal.originalPriceStopLoss.toFixed(getPriceScale(data.signal.originalPriceStopLoss))} USD`,
         isVisible: () => true,
     },
     {
         key: "originalPriceOpen",
         label: "Original Entry",
-        format: (data) => `${data.signal.originalPriceOpen.toFixed(8)} USD`,
+        format: (data) => `${data.signal.originalPriceOpen.toFixed(getPriceScale(data.signal.originalPriceOpen))} USD`,
         isVisible: () => true,
     },
     {
@@ -21508,6 +21526,71 @@ const heat_columns = [
             : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "trend",
+        label: "Trend",
+        format: (data) => data.trend ?? "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "trendStrength",
+        label: "Trend %/d",
+        format: (data) => data.trendStrength !== null ? functoolsKit.str(data.trendStrength, "%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "trendConfidence",
+        label: "Trend R²",
+        format: (data) => data.trendConfidence !== null ? data.trendConfidence.toFixed(3) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "buyerPressure",
+        label: "Buyer Pres",
+        format: (data) => data.buyerPressure !== null
+            ? (data.buyerPressure * 100).toFixed(1) + "%"
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "sellerPressure",
+        label: "Seller Pres",
+        format: (data) => data.sellerPressure !== null
+            ? (data.sellerPressure * 100).toFixed(1) + "%"
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "buyerStrength",
+        label: "Buyer Str",
+        format: (data) => data.buyerStrength !== null
+            ? (data.buyerStrength * 100).toFixed(1) + "%"
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "sellerStrength",
+        label: "Seller Str",
+        format: (data) => data.sellerStrength !== null
+            ? (data.sellerStrength * 100).toFixed(1) + "%"
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "pressureImbalance",
+        label: "Pres Imb",
+        format: (data) => data.pressureImbalance !== null
+            ? (data.pressureImbalance > 0 ? "+" : "") +
+                data.pressureImbalance.toFixed(3)
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "medianStepSize",
+        label: "Median Step",
+        format: (data) => data.medianStepSize !== null ? functoolsKit.str(data.medianStepSize, "%") : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "sortinoRatio",
         label: "Sortino",
@@ -21604,34 +21687,34 @@ const live_columns = [
     {
         key: "currentPrice",
         label: "Current Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        format: (data) => `${data.currentPrice.toFixed(getPriceScale(data.currentPrice))} USD`,
         isVisible: () => true,
     },
     {
         key: "openPrice",
         label: "Open Price",
-        format: (data) => data.priceOpen !== undefined ? `${data.priceOpen.toFixed(8)} USD` : "N/A",
+        format: (data) => data.priceOpen !== undefined ? `${data.priceOpen.toFixed(getPriceScale(data.priceOpen))} USD` : "N/A",
         isVisible: () => true,
     },
     {
         key: "takeProfit",
         label: "Take Profit",
         format: (data) => data.priceTakeProfit !== undefined
-            ? `${data.priceTakeProfit.toFixed(8)} USD`
+            ? `${data.priceTakeProfit.toFixed(getPriceScale(data.priceTakeProfit))} USD`
             : "N/A",
         isVisible: () => true,
     },
     {
         key: "stopLoss",
         label: "Stop Loss",
-        format: (data) => data.priceStopLoss !== undefined ? `${data.priceStopLoss.toFixed(8)} USD` : "N/A",
+        format: (data) => data.priceStopLoss !== undefined ? `${data.priceStopLoss.toFixed(getPriceScale(data.priceStopLoss))} USD` : "N/A",
         isVisible: () => true,
     },
     {
         key: "originalPriceTakeProfit",
         label: "Original TP",
         format: (data) => data.originalPriceTakeProfit !== undefined
-            ? `${data.originalPriceTakeProfit.toFixed(8)} USD`
+            ? `${data.originalPriceTakeProfit.toFixed(getPriceScale(data.originalPriceTakeProfit))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -21639,7 +21722,7 @@ const live_columns = [
         key: "originalPriceStopLoss",
         label: "Original SL",
         format: (data) => data.originalPriceStopLoss !== undefined
-            ? `${data.originalPriceStopLoss.toFixed(8)} USD`
+            ? `${data.originalPriceStopLoss.toFixed(getPriceScale(data.originalPriceStopLoss))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -21647,7 +21730,7 @@ const live_columns = [
         key: "originalPriceOpen",
         label: "Original Entry",
         format: (data) => data.originalPriceOpen !== undefined
-            ? `${data.originalPriceOpen.toFixed(8)} USD`
+            ? `${data.originalPriceOpen.toFixed(getPriceScale(data.originalPriceOpen))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -21818,43 +21901,43 @@ const partial_columns = [
     {
         key: "currentPrice",
         label: "Current Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        format: (data) => `${data.currentPrice.toFixed(getPriceScale(data.currentPrice))} USD`,
         isVisible: () => true,
     },
     {
         key: "priceOpen",
         label: "Entry Price",
-        format: (data) => (data.priceOpen ? `${data.priceOpen.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.priceOpen ? `${data.priceOpen.toFixed(getPriceScale(data.priceOpen))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
         key: "priceTakeProfit",
         label: "Take Profit",
-        format: (data) => (data.priceTakeProfit ? `${data.priceTakeProfit.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.priceTakeProfit ? `${data.priceTakeProfit.toFixed(getPriceScale(data.priceTakeProfit))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
         key: "priceStopLoss",
         label: "Stop Loss",
-        format: (data) => (data.priceStopLoss ? `${data.priceStopLoss.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.priceStopLoss ? `${data.priceStopLoss.toFixed(getPriceScale(data.priceStopLoss))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
         key: "originalPriceTakeProfit",
         label: "Original TP",
-        format: (data) => (data.originalPriceTakeProfit ? `${data.originalPriceTakeProfit.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.originalPriceTakeProfit ? `${data.originalPriceTakeProfit.toFixed(getPriceScale(data.originalPriceTakeProfit))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
         key: "originalPriceStopLoss",
         label: "Original SL",
-        format: (data) => (data.originalPriceStopLoss ? `${data.originalPriceStopLoss.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.originalPriceStopLoss ? `${data.originalPriceStopLoss.toFixed(getPriceScale(data.originalPriceStopLoss))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
         key: "originalPriceOpen",
         label: "Original Entry",
-        format: (data) => (data.originalPriceOpen ? `${data.originalPriceOpen.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.originalPriceOpen ? `${data.originalPriceOpen.toFixed(getPriceScale(data.originalPriceOpen))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
@@ -21978,43 +22061,43 @@ const breakeven_columns = [
     {
         key: "priceOpen",
         label: "Entry Price",
-        format: (data) => `${data.priceOpen.toFixed(8)} USD`,
+        format: (data) => `${data.priceOpen.toFixed(getPriceScale(data.priceOpen))} USD`,
         isVisible: () => true,
     },
     {
         key: "currentPrice",
         label: "Breakeven Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        format: (data) => `${data.currentPrice.toFixed(getPriceScale(data.currentPrice))} USD`,
         isVisible: () => true,
     },
     {
         key: "priceTakeProfit",
         label: "Take Profit",
-        format: (data) => (data.priceTakeProfit ? `${data.priceTakeProfit.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.priceTakeProfit ? `${data.priceTakeProfit.toFixed(getPriceScale(data.priceTakeProfit))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
         key: "priceStopLoss",
         label: "Stop Loss",
-        format: (data) => (data.priceStopLoss ? `${data.priceStopLoss.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.priceStopLoss ? `${data.priceStopLoss.toFixed(getPriceScale(data.priceStopLoss))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
         key: "originalPriceTakeProfit",
         label: "Original TP",
-        format: (data) => (data.originalPriceTakeProfit ? `${data.originalPriceTakeProfit.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.originalPriceTakeProfit ? `${data.originalPriceTakeProfit.toFixed(getPriceScale(data.originalPriceTakeProfit))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
         key: "originalPriceStopLoss",
         label: "Original SL",
-        format: (data) => (data.originalPriceStopLoss ? `${data.originalPriceStopLoss.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.originalPriceStopLoss ? `${data.originalPriceStopLoss.toFixed(getPriceScale(data.originalPriceStopLoss))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
         key: "originalPriceOpen",
         label: "Original Entry",
-        format: (data) => (data.originalPriceOpen ? `${data.originalPriceOpen.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.originalPriceOpen ? `${data.originalPriceOpen.toFixed(getPriceScale(data.originalPriceOpen))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
@@ -22271,7 +22354,7 @@ const risk_columns = [
         key: "openPrice",
         label: "Open Price",
         format: (data) => data.currentSignal.priceOpen !== undefined
-            ? `${data.currentSignal.priceOpen.toFixed(8)} USD`
+            ? `${data.currentSignal.priceOpen.toFixed(getPriceScale(data.currentSignal.priceOpen))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -22279,7 +22362,7 @@ const risk_columns = [
         key: "takeProfit",
         label: "Take Profit",
         format: (data) => data.currentSignal.priceTakeProfit !== undefined
-            ? `${data.currentSignal.priceTakeProfit.toFixed(8)} USD`
+            ? `${data.currentSignal.priceTakeProfit.toFixed(getPriceScale(data.currentSignal.priceTakeProfit))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -22287,7 +22370,7 @@ const risk_columns = [
         key: "stopLoss",
         label: "Stop Loss",
         format: (data) => data.currentSignal.priceStopLoss !== undefined
-            ? `${data.currentSignal.priceStopLoss.toFixed(8)} USD`
+            ? `${data.currentSignal.priceStopLoss.toFixed(getPriceScale(data.currentSignal.priceStopLoss))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -22295,7 +22378,7 @@ const risk_columns = [
         key: "originalPriceTakeProfit",
         label: "Original TP",
         format: (data) => data.currentSignal.originalPriceTakeProfit !== undefined
-            ? `${data.currentSignal.originalPriceTakeProfit.toFixed(8)} USD`
+            ? `${data.currentSignal.originalPriceTakeProfit.toFixed(getPriceScale(data.currentSignal.originalPriceTakeProfit))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -22303,7 +22386,7 @@ const risk_columns = [
         key: "originalPriceStopLoss",
         label: "Original SL",
         format: (data) => data.currentSignal.originalPriceStopLoss !== undefined
-            ? `${data.currentSignal.originalPriceStopLoss.toFixed(8)} USD`
+            ? `${data.currentSignal.originalPriceStopLoss.toFixed(getPriceScale(data.currentSignal.originalPriceStopLoss))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -22311,7 +22394,7 @@ const risk_columns = [
         key: "originalPriceOpen",
         label: "Original Entry",
         format: (data) => data.currentSignal.originalPriceOpen !== undefined
-            ? `${data.currentSignal.originalPriceOpen.toFixed(8)} USD`
+            ? `${data.currentSignal.originalPriceOpen.toFixed(getPriceScale(data.currentSignal.originalPriceOpen))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -22342,7 +22425,7 @@ const risk_columns = [
     {
         key: "currentPrice",
         label: "Current Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        format: (data) => `${data.currentPrice.toFixed(getPriceScale(data.currentPrice))} USD`,
         isVisible: () => true,
     },
     {
@@ -22468,32 +22551,32 @@ const schedule_columns = [
     {
         key: "currentPrice",
         label: "Current Price",
-        format: (data) => data.currentPrice ? `${data.currentPrice.toFixed(8)} USD` : "N/A",
+        format: (data) => data.currentPrice ? `${data.currentPrice.toFixed(getPriceScale(data.currentPrice))} USD` : "N/A",
         isVisible: () => true,
     },
     {
         key: "priceOpen",
         label: "Entry Price",
-        format: (data) => `${data.priceOpen.toFixed(8)} USD`,
+        format: (data) => `${data.priceOpen.toFixed(getPriceScale(data.priceOpen))} USD`,
         isVisible: () => true,
     },
     {
         key: "takeProfit",
         label: "Take Profit",
-        format: (data) => `${data.priceTakeProfit.toFixed(8)} USD`,
+        format: (data) => `${data.priceTakeProfit.toFixed(getPriceScale(data.priceTakeProfit))} USD`,
         isVisible: () => true,
     },
     {
         key: "stopLoss",
         label: "Stop Loss",
-        format: (data) => `${data.priceStopLoss.toFixed(8)} USD`,
+        format: (data) => `${data.priceStopLoss.toFixed(getPriceScale(data.priceStopLoss))} USD`,
         isVisible: () => true,
     },
     {
         key: "originalPriceTakeProfit",
         label: "Original TP",
         format: (data) => data.originalPriceTakeProfit !== undefined
-            ? `${data.originalPriceTakeProfit.toFixed(8)} USD`
+            ? `${data.originalPriceTakeProfit.toFixed(getPriceScale(data.originalPriceTakeProfit))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -22501,7 +22584,7 @@ const schedule_columns = [
         key: "originalPriceStopLoss",
         label: "Original SL",
         format: (data) => data.originalPriceStopLoss !== undefined
-            ? `${data.originalPriceStopLoss.toFixed(8)} USD`
+            ? `${data.originalPriceStopLoss.toFixed(getPriceScale(data.originalPriceStopLoss))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -22509,7 +22592,7 @@ const schedule_columns = [
         key: "originalPriceOpen",
         label: "Original Entry",
         format: (data) => data.originalPriceOpen !== undefined
-            ? `${data.originalPriceOpen.toFixed(8)} USD`
+            ? `${data.originalPriceOpen.toFixed(getPriceScale(data.originalPriceOpen))} USD`
             : "N/A",
         isVisible: () => true,
     },
@@ -22634,7 +22717,7 @@ const strategy_columns = [
     {
         key: "currentPrice",
         label: "Price",
-        format: (data) => (data.currentPrice !== undefined ? `${data.currentPrice.toFixed(8)} USD` : "N/A"),
+        format: (data) => (data.currentPrice !== undefined ? `${data.currentPrice.toFixed(getPriceScale(data.currentPrice))} USD` : "N/A"),
         isVisible: () => true,
     },
     {
@@ -22754,25 +22837,25 @@ const sync_columns = [
     {
         key: "currentPrice",
         label: "Current Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        format: (data) => `${data.currentPrice.toFixed(getPriceScale(data.currentPrice))} USD`,
         isVisible: () => true,
     },
     {
         key: "priceOpen",
         label: "Entry Price",
-        format: (data) => `${data.priceOpen.toFixed(8)} USD`,
+        format: (data) => `${data.priceOpen.toFixed(getPriceScale(data.priceOpen))} USD`,
         isVisible: () => true,
     },
     {
         key: "priceTakeProfit",
         label: "Take Profit",
-        format: (data) => `${data.priceTakeProfit.toFixed(8)} USD`,
+        format: (data) => `${data.priceTakeProfit.toFixed(getPriceScale(data.priceTakeProfit))} USD`,
         isVisible: () => true,
     },
     {
         key: "priceStopLoss",
         label: "Stop Loss",
-        format: (data) => `${data.priceStopLoss.toFixed(8)} USD`,
+        format: (data) => `${data.priceStopLoss.toFixed(getPriceScale(data.priceStopLoss))} USD`,
         isVisible: () => true,
     },
     {
@@ -22865,25 +22948,25 @@ const highest_profit_columns = [
     {
         key: "currentPrice",
         label: "Peak Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        format: (data) => `${data.currentPrice.toFixed(getPriceScale(data.currentPrice))} USD`,
         isVisible: () => true,
     },
     {
         key: "priceOpen",
         label: "Entry Price",
-        format: (data) => `${data.priceOpen.toFixed(8)} USD`,
+        format: (data) => `${data.priceOpen.toFixed(getPriceScale(data.priceOpen))} USD`,
         isVisible: () => true,
     },
     {
         key: "priceTakeProfit",
         label: "Take Profit",
-        format: (data) => `${data.priceTakeProfit.toFixed(8)} USD`,
+        format: (data) => `${data.priceTakeProfit.toFixed(getPriceScale(data.priceTakeProfit))} USD`,
         isVisible: () => true,
     },
     {
         key: "priceStopLoss",
         label: "Stop Loss",
-        format: (data) => `${data.priceStopLoss.toFixed(8)} USD`,
+        format: (data) => `${data.priceStopLoss.toFixed(getPriceScale(data.priceStopLoss))} USD`,
         isVisible: () => true,
     },
     {
@@ -22952,25 +23035,25 @@ const max_drawdown_columns = [
     {
         key: "currentPrice",
         label: "DD Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        format: (data) => `${data.currentPrice.toFixed(getPriceScale(data.currentPrice))} USD`,
         isVisible: () => true,
     },
     {
         key: "priceOpen",
         label: "Entry Price",
-        format: (data) => `${data.priceOpen.toFixed(8)} USD`,
+        format: (data) => `${data.priceOpen.toFixed(getPriceScale(data.priceOpen))} USD`,
         isVisible: () => true,
     },
     {
         key: "priceTakeProfit",
         label: "Take Profit",
-        format: (data) => `${data.priceTakeProfit.toFixed(8)} USD`,
+        format: (data) => `${data.priceTakeProfit.toFixed(getPriceScale(data.priceTakeProfit))} USD`,
         isVisible: () => true,
     },
     {
         key: "priceStopLoss",
         label: "Stop Loss",
-        format: (data) => `${data.priceStopLoss.toFixed(8)} USD`,
+        format: (data) => `${data.priceStopLoss.toFixed(getPriceScale(data.priceStopLoss))} USD`,
         isVisible: () => true,
     },
     {
@@ -23852,6 +23935,165 @@ MarkdownFileBase = functoolsKit.makeExtendable(MarkdownFileBase);
 ReportBase = functoolsKit.makeExtendable(ReportBase);
 const ReportWriter = new ReportWriterAdapter();
 
+/** Minimum samples to surface any price-profile metric. Below this the
+ *  per-trade step-distribution and the regression are statistically noisy. */
+const MIN_SIGNALS = 10;
+/** R² gate for declaring any trend at all. Below this the regression is
+ *  too weak to claim a direction — treat the series as sideways even if
+ *  the slope is large. 0.30 is the conventional weak-to-moderate-fit
+ *  boundary in econometrics (Cohen's f² ≈ 0.43). */
+const R2_TREND_GATE = 0.30;
+/** Slope-magnitude threshold relative to medianStepSize for declaring the
+ *  trend strong enough to call bullish/bearish. Below this the regression
+ *  fits but the actual drift is weaker than the typical daily step, so we
+ *  downgrade to "neutral" (a real but uninteresting tilt). */
+const SLOPE_VS_STEP_GATE = 0.25;
+const isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+const median = (values) => {
+    const sorted = values.slice().sort((a, b) => a - b);
+    const mid = sorted.length >> 1;
+    return sorted.length % 2 === 0
+        ? (sorted[mid - 1] + sorted[mid]) / 2
+        : sorted[mid];
+};
+const emptyProfile = () => ({
+    medianStepSize: null,
+    buyerPressure: null,
+    sellerPressure: null,
+    buyerStrength: null,
+    sellerStrength: null,
+    pressureImbalance: null,
+    trend: null,
+    trendStrength: null,
+    trendConfidence: null,
+});
+/**
+ * Computes the price-profile bundle for a chronological series of trade
+ * closes. The input is expected to be sorted by `closeAt` ascending; the
+ * function does not sort defensively (the markdown services already sort).
+ *
+ * @param series - One point per closed trade: timestamp (ms) and close price.
+ * @returns A bundle of nine metrics, each `null` when the input is too small
+ *   or numerically unsafe.
+ */
+const getPriceProfile = (series) => {
+    const valid = series.filter((p) => isFiniteNumber(p.closeAt) &&
+        p.closeAt > 0 &&
+        isFiniteNumber(p.close) &&
+        p.close > 0);
+    if (valid.length < MIN_SIGNALS)
+        return emptyProfile();
+    const n = valid.length;
+    const closes = valid.map((p) => p.close);
+    const times = valid.map((p) => p.closeAt);
+    const absSteps = [];
+    let upMoves = 0;
+    let downMoves = 0;
+    let upMagnitude = 0;
+    let downMagnitude = 0;
+    for (let i = 1; i < n; i++) {
+        const prev = closes[i - 1];
+        const cur = closes[i];
+        const ret = (cur - prev) / prev;
+        const abs = Math.abs(ret);
+        absSteps.push(abs);
+        if (ret > 0) {
+            upMoves++;
+            upMagnitude += abs;
+        }
+        else if (ret < 0) {
+            downMoves++;
+            downMagnitude += abs;
+        }
+    }
+    if (absSteps.length === 0)
+        return emptyProfile();
+    const medianStepSize = median(absSteps) * 100; // percent
+    // --- Pressure / strength ---
+    const decisiveMoves = upMoves + downMoves;
+    const totalMagnitude = upMagnitude + downMagnitude;
+    const buyerPressure = decisiveMoves > 0 ? upMoves / decisiveMoves : null;
+    const sellerPressure = decisiveMoves > 0 ? downMoves / decisiveMoves : null;
+    const buyerStrength = totalMagnitude > 0 ? upMagnitude / totalMagnitude : null;
+    const sellerStrength = totalMagnitude > 0 ? downMagnitude / totalMagnitude : null;
+    const pressureImbalance = buyerStrength !== null && sellerStrength !== null
+        ? buyerStrength - sellerStrength
+        : null;
+    // --- Trend: linear regression of log(close) vs days ---
+    // log-price slope is scale-invariant: 1%/day means the same whether the
+    // asset trades at $0.01 or $10000. Use `closeAt[0]` as time origin so x_i
+    // starts at zero — keeps numerical conditioning sane on long horizons.
+    const t0 = times[0];
+    const xs = new Array(n);
+    const ys = new Array(n);
+    for (let i = 0; i < n; i++) {
+        xs[i] = (times[i] - t0) / (1000 * 60 * 60 * 24); // days
+        ys[i] = Math.log(closes[i]);
+    }
+    // Calendar span must be non-degenerate for the slope to mean anything.
+    const xRange = xs[n - 1] - xs[0];
+    let trend = null;
+    let trendStrength = null;
+    let trendConfidence = null;
+    if (xRange > 0) {
+        let sumX = 0;
+        let sumY = 0;
+        for (let i = 0; i < n; i++) {
+            sumX += xs[i];
+            sumY += ys[i];
+        }
+        const meanX = sumX / n;
+        const meanY = sumY / n;
+        let ssXX = 0;
+        let ssXY = 0;
+        let ssYY = 0;
+        for (let i = 0; i < n; i++) {
+            const dx = xs[i] - meanX;
+            const dy = ys[i] - meanY;
+            ssXX += dx * dx;
+            ssXY += dx * dy;
+            ssYY += dy * dy;
+        }
+        if (ssXX > 0) {
+            const slopeLog = ssXY / ssXX; // log-return per day
+            const slopePct = slopeLog * 100; // %/day (small-slope approx)
+            // R² = 1 - SS_res / SS_tot. With a single explanatory variable this
+            // equals (ssXY)² / (ssXX * ssYY) when ssYY > 0.
+            const r2 = ssYY > 0 ? (ssXY * ssXY) / (ssXX * ssYY) : 0;
+            trendStrength = slopePct;
+            trendConfidence = Math.max(0, Math.min(1, r2));
+            if (trendConfidence < R2_TREND_GATE) {
+                trend = "sideways";
+            }
+            else {
+                const slopeMagnitude = Math.abs(slopePct);
+                const stepScale = medianStepSize * SLOPE_VS_STEP_GATE;
+                if (slopeMagnitude < stepScale) {
+                    trend = "neutral";
+                }
+                else if (slopePct > 0) {
+                    trend = "bullish";
+                }
+                else {
+                    trend = "bearish";
+                }
+            }
+        }
+    }
+    const safe = (v) => v === null || !Number.isFinite(v) ? null : v;
+    return {
+        medianStepSize: safe(medianStepSize),
+        buyerPressure: safe(buyerPressure),
+        sellerPressure: safe(sellerPressure),
+        buyerStrength: safe(buyerStrength),
+        sellerStrength: safe(sellerStrength),
+        pressureImbalance: safe(pressureImbalance),
+        trend,
+        trendStrength: safe(trendStrength),
+        trendConfidence: safe(trendConfidence),
+    };
+};
+
 /**
  * Creates a unique key for memoizing ReportStorage instances.
  * Key format: "symbol:strategyName:exchangeName:frameName:backtest" or "symbol:strategyName:exchangeName:live"
@@ -23984,6 +24226,15 @@ let ReportStorage$a = class ReportStorage {
                 avgConsecutiveLossPnl: null,
                 avgWinDuration: null,
                 avgLossDuration: null,
+                medianStepSize: null,
+                buyerPressure: null,
+                sellerPressure: null,
+                buyerStrength: null,
+                sellerStrength: null,
+                pressureImbalance: null,
+                trend: null,
+                trendStrength: null,
+                trendConfidence: null,
             };
         }
         // Valid signal set — those with usable pendingAt AND closeTimestamp. Single source
@@ -24031,16 +24282,18 @@ let ReportStorage$a = class ReportStorage {
         const tradesPerYear = canAnnualize ? rawTradesPerYear : 0;
         // Per-trade Sharpe Ratio (risk-free rate = 0). Sample stddev (N-1) for unbiased estimate.
         // Per-trade ratios are gated by MIN_SIGNALS_FOR_RATIOS — below that, variance estimates
-        // are too noisy to publish (high chance of spurious ±Sharpe).
+        // are too noisy to publish (high chance of spurious ±Sharpe). When the gate fails the
+        // standard deviation itself is reported as null (NOT 0) so the report doesn't suggest
+        // a flat distribution for a small but variable sample.
         const returns = validSignals.map((s) => s.pnl.pnlPercentage);
         const canComputeRatios = totalSignals >= MIN_SIGNALS_FOR_RATIOS$2;
         const stdDev = canComputeRatios
             ? Math.sqrt(returns.reduce((sum, r) => sum + Math.pow(r - avgPnl, 2), 0) / (totalSignals - 1))
-            : 0;
+            : null;
         // Use STDDEV_EPSILON gate (not stdDev > 0) — identical-returns series produce
         // float-artifact stdDev (~1e-17) that's mathematically > 0 but spuriously
         // inflates sharpe to astronomical magnitudes (avgPnl / epsilon).
-        const sharpeRatio = canComputeRatios && stdDev > STDDEV_EPSILON$2
+        const sharpeRatio = canComputeRatios && stdDev !== null && stdDev > STDDEV_EPSILON$2
             ? avgPnl / stdDev
             : null;
         // Annualize only when gate passes; otherwise null.
@@ -24280,6 +24533,13 @@ let ReportStorage$a = class ReportStorage {
         const recoveryFactor = !canComputeRatios || blown || equityMaxDrawdown <= 0
             ? null
             : Math.max(-MAX_CALMAR_RATIO$2, Math.min(MAX_CALMAR_RATIO$2, ((equityFinal - 1) * 100) / equityMaxDrawdown));
+        // Price profile — buyer/seller pressure, trend classification. Walks the
+        // chronological close series (`orderedSignals` is already sorted by
+        // closeTimestamp). N-gated internally by the helper (MIN_SIGNALS = 10).
+        const priceProfile = getPriceProfile(orderedSignals.map((s) => ({
+            closeAt: s.closeTimestamp,
+            close: s.currentPrice,
+        })));
         return {
             signalList: this._signalList,
             totalSignals,
@@ -24305,6 +24565,15 @@ let ReportStorage$a = class ReportStorage {
             avgConsecutiveLossPnl: isUnsafe$4(avgConsecutiveLossPnl) ? null : avgConsecutiveLossPnl,
             avgWinDuration: isUnsafe$4(avgWinDuration) ? null : avgWinDuration,
             avgLossDuration: isUnsafe$4(avgLossDuration) ? null : avgLossDuration,
+            medianStepSize: priceProfile.medianStepSize,
+            buyerPressure: priceProfile.buyerPressure,
+            sellerPressure: priceProfile.sellerPressure,
+            buyerStrength: priceProfile.buyerStrength,
+            sellerStrength: priceProfile.sellerStrength,
+            pressureImbalance: priceProfile.pressureImbalance,
+            trend: priceProfile.trend,
+            trendStrength: priceProfile.trendStrength,
+            trendConfidence: priceProfile.trendConfidence,
         };
     }
     /**
@@ -24361,20 +24630,48 @@ let ReportStorage$a = class ReportStorage {
             `**Avg Loss Duration:** ${stats.avgLossDuration === null ? "N/A" : `${stats.avgLossDuration.toFixed(1)} min`}`,
             `**Avg Consecutive Win PNL:** ${stats.avgConsecutiveWinPnl === null ? "N/A" : `${stats.avgConsecutiveWinPnl > 0 ? "+" : ""}${stats.avgConsecutiveWinPnl.toFixed(3)}% (higher is better)`}`,
             `**Avg Consecutive Loss PNL:** ${stats.avgConsecutiveLossPnl === null ? "N/A" : `${stats.avgConsecutiveLossPnl.toFixed(3)}% (closer to 0 is better)`}`,
+            `**Trend:** ${stats.trend === null ? "N/A" : stats.trend}`,
+            `**Trend Strength:** ${stats.trendStrength === null ? "N/A" : `${stats.trendStrength > 0 ? "+" : ""}${stats.trendStrength.toFixed(3)}%/day`}`,
+            `**Trend Confidence (R²):** ${stats.trendConfidence === null ? "N/A" : stats.trendConfidence.toFixed(3)}`,
+            `**Buyer Pressure:** ${stats.buyerPressure === null ? "N/A" : `${(stats.buyerPressure * 100).toFixed(1)}%`}`,
+            `**Seller Pressure:** ${stats.sellerPressure === null ? "N/A" : `${(stats.sellerPressure * 100).toFixed(1)}%`}`,
+            `**Buyer Strength:** ${stats.buyerStrength === null ? "N/A" : `${(stats.buyerStrength * 100).toFixed(1)}%`}`,
+            `**Seller Strength:** ${stats.sellerStrength === null ? "N/A" : `${(stats.sellerStrength * 100).toFixed(1)}%`}`,
+            `**Pressure Imbalance:** ${stats.pressureImbalance === null ? "N/A" : `${stats.pressureImbalance > 0 ? "+" : ""}${stats.pressureImbalance.toFixed(3)}`}`,
+            `**Median Step Size:** ${stats.medianStepSize === null ? "N/A" : `${stats.medianStepSize.toFixed(3)}%`}`,
             "",
-            `*Win Rate: reliable above 200+ signals; below 30 signals a single streak can shift it by 10-20%.*`,
-            `*Sharpe Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals.*`,
-            `*Annualized Sharpe Ratio: per-trade Sharpe × √tradesPerYear; tradesPerYear = signals × 365 / calendarSpanDays. N/A unless ≥${MIN_SIGNALS_FOR_ANNUALIZATION$2} signals and span ≥${MIN_CALENDAR_SPAN_DAYS$2} days. Assumes returns are iid — autocorrelated strategies are overstated.*`,
-            `*Sortino Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals. N/A when no losing trades — Sortino is mathematically undefined (infinite) and we cannot distinguish "truly flawless" from "lucky streak so far".*`,
-            `*Certainty Ratio: below 1.0 means average loss exceeds average win. Above 1.5 is considered good.*`,
-            `*Expected Yearly Returns: compounded geometric return from the equity curve, annualized by tradesPerYear. Same gating as Annualized Sharpe. Capped at ±${MAX_EXPECTED_YEARLY_RETURNS$2}% — values above the cap return N/A.*`,
-            `*Calmar Ratio: below 0.5 is poor, 0.5-1.0 is acceptable, above 1.0 is strong. Denominator is the mark-to-market max drawdown (see below). Capped at ±${MAX_CALMAR_RATIO$2}.*`,
-            `*Recovery Factor: below 1.0 means total profit does not cover max drawdown. Above 3.0 is considered good. Uses compounded total return as numerator and the mark-to-market max drawdown as denominator.*`,
-            `*Max Drawdown: mark-to-market — the compounded equity curve applies each trade's worst intra-trade excursion (the lowest unrealized point while the position was open) before booking its realized close, so deep round-trip dips count. It is NOT realized-only (close-to-close); a realized-only curve would understate drawdown and inflate Calmar/Recovery.*`,
-            `*Expectancy: per-trade expected value (winProb × avgWin + lossProb × avgLoss). Positive = profitable on average per trade. Break-even trades contribute 0.*`,
-            `*All metrics require 100+ signals to be statistically reliable. Annualized metrics assume the observed trading frequency and market conditions persist year-round.*`,
-            `*IMPORTANT: Equity curve, Expected Yearly Returns, Calmar, Recovery and Max Drawdown all assume **100% capital allocation per position** (no portfolio fraction). These metrics ignore the position-sizing subsystem (PositionSize / Kelly / ATR): pnlPercentage is a return on the position's own invested capital, never scaled by account balance. With DCA (commitAverageBuy) the cost basis is the sum of all entries and the entry price is dollar-cost-weighted, so per-trade % is measured against the averaged position, not a fixed stake. If your strategy risks X% of capital per trade, the realized portfolio return / drawdown will be roughly X/100 of the reported figures — these metrics represent a theoretical upper bound under full allocation.*`,
-            `*Negative values for Sharpe / Sortino / Calmar / Recovery / Expected Yearly Returns indicate a losing strategy (avgPnl < 0 or totalPnl < 0). "Higher is better" still applies — closer to zero is less bad, positive is profitable.*`,
+            `*Win Rate: percent of closed signals that ended with per-trade PNL > 0, computed as winning-trade count / (winning-trade count + losing-trade count) × 100 — break-even trades (per-trade PNL == 0) are excluded from both numerator and denominator. UNITS: percent in [0, 100]. Statistical reliability: noisy below 30 signals (a single streak can shift it 10–20 points); stable above 200 signals.*`,
+            `*Average PNL: arithmetic mean of per-trade PNL across every closed signal, computed as Σ per-trade PNL / closed signal count. UNITS: percent per trade. Sign mirrors strategy edge — positive = profitable on average per trade. Sensitive to one whale trade; cross-check with Median PNL to detect skew.*`,
+            `*Total PNL: arithmetic sum of per-trade PNL across every closed signal. UNITS: percent. This is the additive total, NOT the compounded equity return — for the geometrically-compounded variant see Recovery Factor's numerator and Expected Yearly Returns. Useful as a quick scoreboard but ignores volatility drag.*`,
+            `*Standard Deviation Per Trade: sample standard deviation (Bessel-corrected, N−1 denominator) of per-trade PNL. UNITS: percent. Measures volatility of returns. Denominator for per-trade Sharpe Ratio. Below STDDEV_EPSILON = 1e-9 it is treated as zero (identical-returns guard). Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2} (variance too noisy on small samples).*`,
+            `*Sharpe Ratio: per-trade Sharpe = Average PNL / Standard Deviation Per Trade (risk-free rate = 0). UNITS: dimensionless ratio. Higher = better risk-adjusted return per trade. Rule of thumb: below 1.0 poor, 1.0–2.0 acceptable, above 2.0 strong. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2} OR Standard Deviation ≤ 1e-9 (identical-returns / float-artifact guard).*`,
+            `*Annualized Sharpe Ratio: per-trade Sharpe × √(trades per year), where trades per year = closed signal count × 365 / calendar span in days. UNITS: dimensionless. Null when the closed signal count < ${MIN_SIGNALS_FOR_ANNUALIZATION$2}, OR calendar span < ${MIN_CALENDAR_SPAN_DAYS$2} days, OR raw frequency > ${MAX_TRADES_PER_YEAR$2} (clustered sample, annualisation unreliable). Assumes returns are iid — autocorrelated strategies are overstated.*`,
+            `*Certainty Ratio: mean per-trade PNL over winning trades, divided by the absolute value of the mean per-trade PNL over losing trades. UNITS: dimensionless ratio. Below 1.0 means the typical loss exceeds the typical win; above 1.5 is generally good. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2}, OR there are no losing trades, OR the absolute mean losing PNL < 1e-9 (float-artifact loss guard).*`,
+            `*Expected Yearly Returns: geometric annualisation of the equity curve: (final equity ^ (trades per year / closed signal count) − 1) × 100, where final equity is the compounded product of (1 + per-trade PNL / 100) walked over all closed signals in chronological close order. UNITS: percent per year. Accounts for volatility drag (unlike a simple Σ × 365 / calendar-span projection). Null under the same closed-signal-count / calendar-span / frequency gates as Annualized Sharpe Ratio, AND null when |raw value| > ${MAX_EXPECTED_YEARLY_RETURNS$2}% (capped numbers mislead). −100% when the equity curve hits ≤ 0 (account blown).*`,
+            `*Avg Peak PNL: arithmetic mean of each closed signal's peak-PNL snapshot — the best mark-to-market PNL recorded while the position was open. Signals that never recorded such a snapshot are excluded from both numerator and denominator (no zero dilution). UNITS: percent. Describes the typical best-case unrealised excursion during the position's lifetime, not the realised close. NOT gated by MIN_SIGNALS — computed whenever at least one signal carries the snapshot; null only if no signal carries it.*`,
+            `*Avg Max Drawdown PNL: arithmetic mean of each closed signal's trough-PNL snapshot — the worst mark-to-market PNL recorded while the position was open. Signals that never recorded such a snapshot are excluded (no zero dilution). UNITS: percent (negative for losing excursions). Describes the typical worst-case unrealised PNL during the position's lifetime; closer to 0 is better. NOT gated by MIN_SIGNALS — computed whenever at least one signal carries the snapshot.*`,
+            `*Sortino Ratio: Average PNL / downside deviation, where downside deviation = √( Σ min(0, per-trade PNL)² / closed signal count ) (canonical Sortino 1991: MAR = 0, divide by N_total). UNITS: dimensionless. Penalises only downside volatility. Rule of thumb: below 1.0 poor, 1.0–2.0 acceptable, above 2.0 strong. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2}, OR there are no losing trades (downside is undefined — flawless ≠ infinitely good), OR downside deviation ≤ 1e-9 (float-artifact guard).*`,
+            `*Calmar Ratio: Expected Yearly Returns divided by the equity-curve mark-to-market max drawdown, clamped to ±${MAX_CALMAR_RATIO$2}. The denominator is the max drawdown of the compounded equity curve: each trade's worst intra-trade excursion (the trough-PNL snapshot, ≤ 0) is applied before booking its realised close, so a position that dipped to −18% and recovered to +2% contributes a real drawdown rather than zero. UNITS: dimensionless. Rule of thumb: below 0.5 poor, 0.5–1.0 acceptable, above 1.0 strong. Null when Expected Yearly Returns is null OR the equity max drawdown ≤ 0.*`,
+            `*Recovery Factor: (final equity − 1) × 100 divided by the equity-curve mark-to-market max drawdown, clamped to ±${MAX_CALMAR_RATIO$2}. The numerator is the compounded total return — NOT the arithmetic Total PNL shown above; the denominator is computed on the compounded curve, so mixing those units would inflate the ratio on long winning streaks. The denominator is the same mark-to-market max drawdown used by Calmar. UNITS: dimensionless. Below 1.0 = profit doesn't cover drawdown; above 3.0 = good. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2}, the equity curve blew up (account ≤ 0), or the equity max drawdown ≤ 0.*`,
+            `*Expectancy: per-trade expected value = (winning-trade count / closed signal count) × mean winning PNL + (losing-trade count / closed signal count) × mean losing PNL. Break-even trades contribute 0 (excluded from both probabilities). UNITS: percent per trade. Positive = profitable on average per trade. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2}.*`,
+            `*Median PNL: median of per-trade PNL across all closed signals (middle value after sorting; for even N the mean of the two middles). UNITS: percent. Robust to outliers — comparing it with Average PNL reveals distribution skew. A large gap (e.g. avg +1.5%, median +0.2%) means one or two trades carry the arithmetic mean. NOT gated by MIN_SIGNALS — computed whenever the closed signal count ≥ 1.*`,
+            `*Avg Duration: arithmetic mean of (close-time − pending-time) / 60_000 over all closed signals. UNITS: minutes (synchronised with the strategy's estimated-minutes setting). Describes the typical position hold time. NOT gated by MIN_SIGNALS — computed whenever the closed signal count ≥ 1.*`,
+            `*Avg Win Duration: arithmetic mean of (close-time − pending-time) / 60_000 restricted to winning trades (per-trade PNL > 0). UNITS: minutes. Null only when there are no winning trades (NOT gated by MIN_SIGNALS — computed at any winning-trade count ≥ 1). Pair with Avg Loss Duration to detect the classic asymmetry "let winners run, cut losers short" (Win Duration > Loss Duration is healthy) versus the inverse red flag "cut winners short, let losers run".*`,
+            `*Avg Loss Duration: arithmetic mean of (close-time − pending-time) / 60_000 restricted to losing trades (per-trade PNL < 0). UNITS: minutes. Null only when there are no losing trades (NOT gated by MIN_SIGNALS).*`,
+            `*Avg Consecutive Win PNL: a "win streak" is a run of consecutive trades with per-trade PNL > 0 bounded by either a losing or break-even trade; this metric sums per-trade PNL within each streak and then averages those sums. Trades are walked in chronological close order. UNITS: percent per streak. Higher = winning streaks are typically bigger. Null only when there is not a single complete win streak in the stored history (NOT gated by MIN_SIGNALS).*`,
+            `*Avg Consecutive Loss PNL: a "loss streak" is a run of consecutive trades with per-trade PNL < 0 bounded by either a winning or break-even trade; this metric sums per-trade PNL within each streak and then averages those sums. UNITS: percent per streak (negative). Closer to 0 = losing streaks are typically smaller. Null only when there is not a single complete loss streak (NOT gated by MIN_SIGNALS).*`,
+            `*Trend: classification computed FROM CLOSING PRICES OF CLOSED SIGNALS (one point per closed trade = the price at which it closed, with its close-timestamp — no candles, no order book, no tick stream). Bivariate gate: "sideways" when R² < 0.30 (regression too weak to call any direction). Otherwise "neutral" when |Trend Strength| < 0.25 × Median Step Size (slope detectable but smaller than the typical daily step). Otherwise "bullish" if Trend Strength > 0, "bearish" if Trend Strength < 0. Two-axis gate — never a single-axis if on a magic-constant slope magnitude. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2}, which means Median Step Size, Trend Strength and Trend Confidence all gate as one bundle: if any is null the others are null too, so the classification never sees a partially-computed input. Boundary case: when every closed price is identical (a flat synthetic series at N ≥ ${MIN_SIGNALS_FOR_RATIOS$2}), Median Step Size is 0 and the slope-vs-step gate collapses — the regression then returns slope = R² = 0, R² < 0.30 fires first, and the classification is "sideways" as expected.*`,
+            `*Trend Strength: ordinary-least-squares slope of \`log(close) ~ days\` regressed across CLOSING PRICES OF CLOSED SIGNALS (one point per closed trade in chronological order — no candles). UNITS: percent per day (small-slope approximation: log-return ≈ percent-return). NOT ATR-normalised, NOT ADX, NOT a rolling-window indicator at signal entry — a static fit over the entire stored history at report time. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2} or the calendar span is degenerate.*`,
+            `*Trend Confidence (R²): coefficient of determination of the same log-price regression that produces Trend Strength, computed on log(close) — NOT on absolute close. UNITS: dimensionless in [0, 1]. High R² = log-price moves linearly with time (clean trend); low R² = the series is noisy regardless of slope sign. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2} or the calendar span is degenerate.*`,
+            `*Buyer Pressure: frequency-based, computed FROM CLOSING PRICES OF CLOSED SIGNALS. (count of i where close[i] > close[i−1]) / (count of decisive moves), where "decisive" excludes flats (close[i] == close[i−1]). UNITS: dimensionless fraction in [0, 1]. NOT order-flow aggressor volume — backtest data has no order book; "buyer" labels only the SIGN of the close-to-close return. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2}.*`,
+            `*Seller Pressure: frequency-based, computed FROM CLOSING PRICES OF CLOSED SIGNALS. (count of i where close[i] < close[i−1]) / (count of decisive moves). By construction Seller Pressure = 1 − Buyer Pressure (the two sum to 1). UNITS: dimensionless fraction in [0, 1]. NOT order-flow aggressor volume — labels only the SIGN of the close-to-close return. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2}.*`,
+            `*Buyer Strength: magnitude-based, computed FROM CLOSING PRICES OF CLOSED SIGNALS. Σ |close[i] − close[i−1]| / close[i−1] over up-moves (close[i] > close[i−1]), divided by the same sum over ALL decisive moves. UNITS: dimensionless fraction in [0, 1]. Buyer Pressure (count of up-moves) and Buyer Strength (sum of up-magnitudes) use the SAME close-to-close return series; only count vs magnitude differs. A divergence between them (e.g. Pressure 0.70 with Strength 0.45) means "many small up-moves, fewer but larger down-moves" — a regime asymmetry frequency alone hides. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2}.*`,
+            `*Seller Strength: magnitude-based, computed FROM CLOSING PRICES OF CLOSED SIGNALS. Σ |close[i] − close[i−1]| / close[i−1] over down-moves (close[i] < close[i−1]), divided by the same sum over ALL decisive moves. By construction Seller Strength = 1 − Buyer Strength (the two sum to 1). UNITS: dimensionless fraction in [0, 1]. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2}.*`,
+            `*Pressure Imbalance: DIFFERENCE, not ratio: Buyer Strength − Seller Strength, computed FROM CLOSING PRICES OF CLOSED SIGNALS. Equivalent to (2 × Buyer Strength − 1). UNITS: dimensionless in [−1, +1]. Sign = direction of magnitude bias (positive = bullish bias on magnitude); absolute value = how lopsided. Single signed scalar that compresses the strength pair into one number. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2}.*`,
+            `*Median Step Size: median over i ∈ [1..N−1] of |close[i] − close[i−1]| / close[i−1], computed FROM CLOSING PRICES OF CLOSED SIGNALS — "step" = consecutive closes of CLOSED TRADES (NOT ticks, NOT bars of any timeframe — the report has no candle access). UNITS: percent, normalised by price → directly comparable across symbols at any price level. Median (not mean) → robust to one whale trade. NOT classical candle-based volatility (ATR / σ of returns); it measures the step distribution AT THE RATE TRADES CLOSE. Null when the closed signal count < ${MIN_SIGNALS_FOR_RATIOS$2}.*`,
+            `*General reliability note: per-trade ratios (Sharpe, Sortino, Certainty, Recovery, Expectancy) are gated to N/A below ${MIN_SIGNALS_FOR_RATIOS$2} closed signals because the underlying variance estimates are too noisy. Annualised metrics (Annualized Sharpe, Expected Yearly Returns, Calmar) additionally require a calendar span ≥ ${MIN_CALENDAR_SPAN_DAYS$2} days and a raw trade frequency ≤ ${MAX_TRADES_PER_YEAR$2} per year. 100+ signals are needed for statistical reliability of the ratios; annualised metrics assume the observed frequency and market regime persist year-round.*`,
+            `*IMPORTANT: Total PNL and the equity-curve metrics (Expected Yearly Returns, Calmar, Recovery, and the equity max drawdown that feeds them) all assume **100% capital allocation per position** (no portfolio fraction). They ignore the position-sizing subsystem (PositionSize / Kelly / ATR): per-trade PNL is a return on the position's own invested capital, never scaled by the account balance. With DCA averaging, the cost basis is the sum of all entries and the entry price is dollar-cost-weighted, so per-trade % is measured against the averaged position. If your strategy risks X% of capital per trade, the realised portfolio return / drawdown is roughly X/100 of the reported figures — these are theoretical upper bounds under full allocation.*`,
+            `*Negative values for Sharpe / Annualized Sharpe / Sortino / Calmar / Recovery / Expectancy / Expected Yearly Returns indicate a losing strategy (Average PNL < 0 or Total PNL < 0). "Higher is better" still applies — closer to zero is less bad, positive is profitable.*`,
         ].join("\n");
     }
     /**
@@ -25004,6 +25301,15 @@ let ReportStorage$9 = class ReportStorage {
                 avgConsecutiveLossPnl: null,
                 avgWinDuration: null,
                 avgLossDuration: null,
+                medianStepSize: null,
+                buyerPressure: null,
+                sellerPressure: null,
+                buyerStrength: null,
+                sellerStrength: null,
+                pressureImbalance: null,
+                trend: null,
+                trendStrength: null,
+                trendConfidence: null,
             };
         }
         const closedEvents = this._eventList.filter((e) => e.action === "closed");
@@ -25053,14 +25359,16 @@ let ReportStorage$9 = class ReportStorage {
         const tradesPerYear = canAnnualize ? rawTradesPerYear : 0;
         // Per-trade Sharpe Ratio (risk-free rate = 0). Sample stddev (N-1).
         // Per-trade ratios are gated by MIN_SIGNALS_FOR_RATIOS — below that, variance estimates
-        // are too noisy to publish (high chance of spurious ±Sharpe).
+        // are too noisy to publish (high chance of spurious ±Sharpe). When the gate fails the
+        // standard deviation itself is reported as null (NOT 0) so the report doesn't suggest
+        // a flat distribution for a small but variable sample.
         const canComputeRatios = returns.length >= MIN_SIGNALS_FOR_RATIOS$1;
         const stdDev = canComputeRatios
             ? Math.sqrt(returns.reduce((sum, r) => sum + Math.pow(r - avgPnl, 2), 0) / (returns.length - 1))
-            : 0;
+            : null;
         // STDDEV_EPSILON guard — protects against float-artifact stdDev from identical
         // returns producing spuriously astronomical sharpe.
-        const sharpeRatio = canComputeRatios && stdDev > STDDEV_EPSILON$1
+        const sharpeRatio = canComputeRatios && stdDev !== null && stdDev > STDDEV_EPSILON$1
             ? avgPnl / stdDev
             : null;
         // Annualize only when gate passes; otherwise null.
@@ -25302,6 +25610,14 @@ let ReportStorage$9 = class ReportStorage {
         const recoveryFactor = !canComputeRatios || blown || equityMaxDrawdown <= 0
             ? null
             : Math.max(-MAX_CALMAR_RATIO$1, Math.min(MAX_CALMAR_RATIO$1, ((equityFinal - 1) * 100) / equityMaxDrawdown));
+        // Price profile — buyer/seller pressure, trend classification. Built only
+        // from closed events' (timestamp, currentPrice) pairs in chronological
+        // close order — the same data the equity curve uses. N-gated internally
+        // by the helper (MIN_SIGNALS = 10).
+        const priceProfile = getPriceProfile(validClosed
+            .slice()
+            .sort((a, b) => a.timestamp - b.timestamp)
+            .map((e) => ({ closeAt: e.timestamp, close: e.currentPrice })));
         return {
             eventList: this._eventList,
             totalEvents: this._eventList.length,
@@ -25328,6 +25644,15 @@ let ReportStorage$9 = class ReportStorage {
             avgConsecutiveLossPnl: isUnsafe$3(avgConsecutiveLossPnl) ? null : avgConsecutiveLossPnl,
             avgWinDuration: isUnsafe$3(avgWinDuration) ? null : avgWinDuration,
             avgLossDuration: isUnsafe$3(avgLossDuration) ? null : avgLossDuration,
+            medianStepSize: priceProfile.medianStepSize,
+            buyerPressure: priceProfile.buyerPressure,
+            sellerPressure: priceProfile.sellerPressure,
+            buyerStrength: priceProfile.buyerStrength,
+            sellerStrength: priceProfile.sellerStrength,
+            pressureImbalance: priceProfile.pressureImbalance,
+            trend: priceProfile.trend,
+            trendStrength: priceProfile.trendStrength,
+            trendConfidence: priceProfile.trendConfidence,
         };
     }
     /**
@@ -25384,20 +25709,48 @@ let ReportStorage$9 = class ReportStorage {
             `**Avg Loss Duration:** ${stats.avgLossDuration === null ? "N/A" : `${stats.avgLossDuration.toFixed(1)} min`}`,
             `**Avg Consecutive Win PNL:** ${stats.avgConsecutiveWinPnl === null ? "N/A" : `${stats.avgConsecutiveWinPnl > 0 ? "+" : ""}${stats.avgConsecutiveWinPnl.toFixed(3)}% (higher is better)`}`,
             `**Avg Consecutive Loss PNL:** ${stats.avgConsecutiveLossPnl === null ? "N/A" : `${stats.avgConsecutiveLossPnl.toFixed(3)}% (closer to 0 is better)`}`,
+            `**Trend:** ${stats.trend === null ? "N/A" : stats.trend}`,
+            `**Trend Strength:** ${stats.trendStrength === null ? "N/A" : `${stats.trendStrength > 0 ? "+" : ""}${stats.trendStrength.toFixed(3)}%/day`}`,
+            `**Trend Confidence (R²):** ${stats.trendConfidence === null ? "N/A" : stats.trendConfidence.toFixed(3)}`,
+            `**Buyer Pressure:** ${stats.buyerPressure === null ? "N/A" : `${(stats.buyerPressure * 100).toFixed(1)}%`}`,
+            `**Seller Pressure:** ${stats.sellerPressure === null ? "N/A" : `${(stats.sellerPressure * 100).toFixed(1)}%`}`,
+            `**Buyer Strength:** ${stats.buyerStrength === null ? "N/A" : `${(stats.buyerStrength * 100).toFixed(1)}%`}`,
+            `**Seller Strength:** ${stats.sellerStrength === null ? "N/A" : `${(stats.sellerStrength * 100).toFixed(1)}%`}`,
+            `**Pressure Imbalance:** ${stats.pressureImbalance === null ? "N/A" : `${stats.pressureImbalance > 0 ? "+" : ""}${stats.pressureImbalance.toFixed(3)}`}`,
+            `**Median Step Size:** ${stats.medianStepSize === null ? "N/A" : `${stats.medianStepSize.toFixed(3)}%`}`,
             "",
-            `*Win Rate: reliable above 200+ signals; below 30 signals a single streak can shift it by 10-20%.*`,
-            `*Sharpe Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals.*`,
-            `*Annualized Sharpe Ratio: per-trade Sharpe × √tradesPerYear; tradesPerYear = signals × 365 / calendarSpanDays. N/A unless ≥${MIN_SIGNALS_FOR_ANNUALIZATION$1} signals and span ≥${MIN_CALENDAR_SPAN_DAYS$1} days. Assumes returns are iid — autocorrelated strategies are overstated.*`,
-            `*Sortino Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals. N/A when no losing trades — Sortino is mathematically undefined (infinite) and we cannot distinguish "truly flawless" from "lucky streak so far".*`,
-            `*Certainty Ratio: below 1.0 means average loss exceeds average win. Above 1.5 is considered good.*`,
-            `*Expected Yearly Returns: compounded geometric return from the equity curve, annualized by tradesPerYear. Same gating as Annualized Sharpe. Capped at ±${MAX_EXPECTED_YEARLY_RETURNS$1}% — values above the cap return N/A.*`,
-            `*Calmar Ratio: below 0.5 is poor, 0.5-1.0 is acceptable, above 1.0 is strong. Denominator is the mark-to-market max drawdown (see below). Capped at ±${MAX_CALMAR_RATIO$1}.*`,
-            `*Recovery Factor: below 1.0 means total profit does not cover max drawdown. Above 3.0 is considered good. Uses compounded total return as numerator and the mark-to-market max drawdown as denominator.*`,
-            `*Max Drawdown: mark-to-market — the compounded equity curve applies each trade's worst intra-trade excursion (the lowest unrealized point while the position was open) before booking its realized close, so deep round-trip dips count. It is NOT realized-only (close-to-close); a realized-only curve would understate drawdown and inflate Calmar/Recovery.*`,
-            `*Expectancy: per-trade expected value (winProb × avgWin + lossProb × avgLoss). Positive = profitable on average per trade. Break-even trades contribute 0.*`,
-            `*All metrics require 100+ signals to be statistically reliable. Annualized metrics assume the observed trading frequency and market conditions persist year-round.*`,
-            `*IMPORTANT: Equity curve, Expected Yearly Returns, Calmar, Recovery and Max Drawdown all assume **100% capital allocation per position** (no portfolio fraction). These metrics ignore the position-sizing subsystem (PositionSize / Kelly / ATR): pnlPercentage is a return on the position's own invested capital, never scaled by account balance. With DCA (commitAverageBuy) the cost basis is the sum of all entries and the entry price is dollar-cost-weighted, so per-trade % is measured against the averaged position, not a fixed stake. If your strategy risks X% of capital per trade, the realized portfolio return / drawdown will be roughly X/100 of the reported figures — these metrics represent a theoretical upper bound under full allocation.*`,
-            `*Negative values for Sharpe / Sortino / Calmar / Recovery / Expected Yearly Returns indicate a losing strategy (avgPnl < 0 or totalPnl < 0). "Higher is better" still applies — closer to zero is less bad, positive is profitable.*`,
+            `*Win Rate: percent of closed events that ended with per-trade PNL > 0, computed as winning-event count / (winning-event count + losing-event count) × 100 — break-even closed events (per-trade PNL == 0) are excluded from both numerator and denominator. UNITS: percent in [0, 100]. Statistical reliability: noisy below 30 closed events (a single streak can shift it 10–20 points); stable above 200.*`,
+            `*Average PNL: arithmetic mean of per-trade PNL across every closed event, computed as Σ per-trade PNL / closed event count. UNITS: percent per trade. Sign mirrors strategy edge — positive = profitable on average per trade. Sensitive to one whale trade; cross-check with Median PNL to detect skew.*`,
+            `*Total PNL: arithmetic sum of per-trade PNL across every closed event. UNITS: percent. This is the additive total, NOT the compounded equity return — for the geometrically-compounded variant see Recovery Factor's numerator and Expected Yearly Returns. Useful as a quick scoreboard but ignores volatility drag.*`,
+            `*Standard Deviation Per Trade: sample standard deviation (Bessel-corrected, N−1 denominator) of per-trade PNL across closed events. UNITS: percent. Measures volatility of realised returns. Denominator for per-trade Sharpe Ratio. Below STDDEV_EPSILON = 1e-9 it is treated as zero (identical-returns guard). Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}.*`,
+            `*Sharpe Ratio: per-trade Sharpe = Average PNL / Standard Deviation Per Trade (risk-free rate = 0). UNITS: dimensionless ratio. Higher = better risk-adjusted return per trade. Rule of thumb: below 1.0 poor, 1.0–2.0 acceptable, above 2.0 strong. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1} OR Standard Deviation ≤ 1e-9 (identical-returns / float-artifact guard).*`,
+            `*Annualized Sharpe Ratio: per-trade Sharpe × √(trades per year), where trades per year = closed event count × 365 / calendar span in days. UNITS: dimensionless. Null when the closed event count < ${MIN_SIGNALS_FOR_ANNUALIZATION$1}, OR calendar span < ${MIN_CALENDAR_SPAN_DAYS$1} days, OR raw frequency > ${MAX_TRADES_PER_YEAR$1}. Assumes returns are iid — autocorrelated strategies are overstated.*`,
+            `*Certainty Ratio: mean per-trade PNL over winning closed events, divided by the absolute value of the mean per-trade PNL over losing closed events. UNITS: dimensionless ratio. Below 1.0 means the typical loss exceeds the typical win; above 1.5 is generally good. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}, OR there are no losing events, OR the absolute mean losing PNL < 1e-9 (float-artifact loss guard).*`,
+            `*Expected Yearly Returns: geometric annualisation of the equity curve: (final equity ^ (trades per year / closed event count) − 1) × 100, where final equity is the compounded product of (1 + per-trade PNL / 100) walked over all closed events in chronological close order. UNITS: percent per year. Accounts for volatility drag. Null under the same closed-event-count / calendar-span / frequency gates as Annualized Sharpe Ratio, AND null when |raw value| > ${MAX_EXPECTED_YEARLY_RETURNS$1}%. −100% when the equity curve hits ≤ 0 (account blown).*`,
+            `*Avg Peak PNL: arithmetic mean of each closed event's peak-PNL snapshot — the best mark-to-market PNL recorded while the position was open. Closed events that never recorded such a snapshot are excluded from both numerator and denominator (no zero dilution). UNITS: percent. Describes the typical best-case unrealised PNL during the position's lifetime, not the realised close. NOT gated by MIN_SIGNALS — computed whenever at least one closed event carries the snapshot.*`,
+            `*Avg Max Drawdown PNL: arithmetic mean of each closed event's trough-PNL snapshot — the worst mark-to-market PNL recorded while the position was open. Closed events that never recorded such a snapshot are excluded (no zero dilution). UNITS: percent (negative for losing excursions). Describes the typical worst-case unrealised PNL during the position's lifetime; closer to 0 is better. NOT gated by MIN_SIGNALS — computed whenever at least one closed event carries the snapshot.*`,
+            `*Sortino Ratio: Average PNL / downside deviation, where downside deviation = √( Σ min(0, per-trade PNL)² / closed event count ) (canonical Sortino 1991: MAR = 0, divide by N_total). UNITS: dimensionless. Penalises only downside volatility. Rule of thumb: below 1.0 poor, 1.0–2.0 acceptable, above 2.0 strong. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}, OR there are no losing events, OR downside deviation ≤ 1e-9 (float-artifact guard).*`,
+            `*Calmar Ratio: Expected Yearly Returns divided by the equity-curve mark-to-market max drawdown, clamped to ±${MAX_CALMAR_RATIO$1}. The denominator is the max drawdown of the compounded equity curve: each closed event's worst intra-trade excursion (the trough-PNL snapshot, ≤ 0) is applied before booking its realised close, so a position that dipped to −18% and recovered to +2% contributes a real drawdown rather than zero. UNITS: dimensionless. Rule of thumb: below 0.5 poor, 0.5–1.0 acceptable, above 1.0 strong. Null when Expected Yearly Returns is null OR the equity max drawdown ≤ 0.*`,
+            `*Recovery Factor: (final equity − 1) × 100 divided by the equity-curve mark-to-market max drawdown, clamped to ±${MAX_CALMAR_RATIO$1}. The numerator is the compounded total return — NOT the arithmetic Total PNL shown above; the denominator is computed on the compounded curve, so mixing those units would inflate the ratio on long winning streaks. The denominator is the same mark-to-market max drawdown used by Calmar. UNITS: dimensionless. Below 1.0 = profit doesn't cover drawdown; above 3.0 = good. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}, the equity curve blew up (account ≤ 0), or the equity max drawdown ≤ 0.*`,
+            `*Expectancy: per-trade expected value = (winning-event count / closed event count) × mean winning PNL + (losing-event count / closed event count) × mean losing PNL. Break-even events contribute 0 (excluded from both probabilities). UNITS: percent per trade. Positive = profitable on average per trade. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}.*`,
+            `*Median PNL: median of per-trade PNL across all closed events (middle value after sorting; for even N the mean of the two middles). UNITS: percent. Robust to outliers — comparing it with Average PNL reveals distribution skew. A large gap (e.g. avg +1.5%, median +0.2%) means one or two events carry the arithmetic mean. NOT gated by MIN_SIGNALS — computed whenever the closed event count ≥ 1.*`,
+            `*Avg Duration: arithmetic mean of (close-time − pending-time) / 60_000 over all closed events. UNITS: minutes. Describes the typical position hold time. Closed events that have no pending timestamp fall back to using their own close timestamp (yielding a zero-duration contribution). NOT gated by MIN_SIGNALS — computed whenever the closed event count ≥ 1.*`,
+            `*Avg Win Duration: arithmetic mean of (close-time − pending-time) / 60_000 restricted to winning closed events (per-trade PNL > 0). UNITS: minutes. Null only when there are no winning events (NOT gated by MIN_SIGNALS). Pair with Avg Loss Duration to detect the classic asymmetry "let winners run, cut losers short" versus the inverse "cut winners short, let losers run".*`,
+            `*Avg Loss Duration: arithmetic mean of (close-time − pending-time) / 60_000 restricted to losing closed events (per-trade PNL < 0). UNITS: minutes. Null only when there are no losing events (NOT gated by MIN_SIGNALS).*`,
+            `*Avg Consecutive Win PNL: a "win streak" is a run of consecutive closed events with per-trade PNL > 0 bounded by either a losing or break-even event; this metric sums per-trade PNL within each streak and then averages those sums. Events are walked in chronological close order. UNITS: percent per streak. Higher = winning streaks are typically bigger. Null only when there is not a single complete win streak (NOT gated by MIN_SIGNALS).*`,
+            `*Avg Consecutive Loss PNL: a "loss streak" is a run of consecutive closed events with per-trade PNL < 0 bounded by either a winning or break-even event; this metric sums per-trade PNL within each streak and then averages those sums. UNITS: percent per streak (negative). Closer to 0 = losing streaks are typically smaller. Null only when there is not a single complete loss streak (NOT gated by MIN_SIGNALS).*`,
+            `*Trend: classification computed FROM CLOSING PRICES OF CLOSED EVENTS (one point per closed event = the price at which it closed, with its close-timestamp; the live mode ingests sub-minute events of other kinds but the price profile uses ONLY closed-event prices — no candles, no order book, no tick stream). Bivariate gate: "sideways" when R² < 0.30. Otherwise "neutral" when |Trend Strength| < 0.25 × Median Step Size. Otherwise "bullish" if Trend Strength > 0, "bearish" if Trend Strength < 0. Two-axis gate — never a single-axis if on a magic-constant slope magnitude. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}, which means Median Step Size, Trend Strength and Trend Confidence all gate as one bundle: if any is null the others are null too, so the classification never sees a partially-computed input. Boundary case: when every closed price is identical (a flat synthetic series at N ≥ ${MIN_SIGNALS_FOR_RATIOS$1}), Median Step Size is 0 and the slope-vs-step gate collapses — the regression then returns slope = R² = 0, R² < 0.30 fires first, and the classification is "sideways" as expected.*`,
+            `*Trend Strength: ordinary-least-squares slope of \`log(close) ~ days\` regressed across CLOSING PRICES OF CLOSED EVENTS in chronological order. UNITS: percent per day (small-slope approximation). NOT ATR-normalised, NOT ADX, NOT a rolling-window indicator at signal entry — a static fit over the entire stored history at report time. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1} or the calendar span is degenerate.*`,
+            `*Trend Confidence (R²): coefficient of determination of the same log-price regression that produces Trend Strength, computed on log(close) — NOT on absolute close. UNITS: dimensionless in [0, 1]. High R² = log-price moves linearly with time (clean trend); low R² = the series is noisy regardless of slope sign. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1} or the calendar span is degenerate.*`,
+            `*Buyer Pressure: frequency-based, computed FROM CLOSING PRICES OF CLOSED EVENTS. (count of i where close[i] > close[i−1]) / (count of decisive moves), where "decisive" excludes flats. UNITS: dimensionless fraction in [0, 1]. NOT order-flow aggressor volume — the live ingest does not separate buy/sell side; "buyer" labels only the SIGN of the close-to-close return. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}.*`,
+            `*Seller Pressure: frequency-based, computed FROM CLOSING PRICES OF CLOSED EVENTS. (count of i where close[i] < close[i−1]) / (count of decisive moves). By construction Seller Pressure = 1 − Buyer Pressure (the two sum to 1). UNITS: dimensionless fraction in [0, 1]. NOT order-flow aggressor volume. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}.*`,
+            `*Buyer Strength: magnitude-based, computed FROM CLOSING PRICES OF CLOSED EVENTS. Σ |close[i] − close[i−1]| / close[i−1] over up-moves, divided by the same sum over ALL decisive moves. UNITS: dimensionless fraction in [0, 1]. Buyer Pressure (count of up-moves) and Buyer Strength (sum of up-magnitudes) use the SAME close-to-close return series; only count vs magnitude differs. A divergence between them (e.g. Pressure 0.70 with Strength 0.45) means "many small up-moves, fewer but larger down-moves". Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}.*`,
+            `*Seller Strength: magnitude-based, computed FROM CLOSING PRICES OF CLOSED EVENTS. Σ |close[i] − close[i−1]| / close[i−1] over down-moves, divided by the same sum over ALL decisive moves. By construction Seller Strength = 1 − Buyer Strength (the two sum to 1). UNITS: dimensionless fraction in [0, 1]. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}.*`,
+            `*Pressure Imbalance: DIFFERENCE, not ratio: Buyer Strength − Seller Strength, computed FROM CLOSING PRICES OF CLOSED EVENTS. Equivalent to (2 × Buyer Strength − 1). UNITS: dimensionless in [−1, +1]. Sign = direction of magnitude bias (positive = bullish bias on magnitude); absolute value = how lopsided. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}.*`,
+            `*Median Step Size: median over i ∈ [1..N−1] of |close[i] − close[i−1]| / close[i−1], computed FROM CLOSING PRICES OF CLOSED EVENTS — "step" = consecutive closed-event prices (NOT ticks, NOT bars; the report has no candle access even though the live mode ingests sub-minute events — they are not used here). UNITS: percent, normalised by price → directly comparable across symbols at any price level. Median (not mean) → robust to one whale trade. NOT classical candle-based volatility (ATR / σ of returns); it measures the step distribution AT THE RATE TRADES CLOSE. Null when the closed event count < ${MIN_SIGNALS_FOR_RATIOS$1}.*`,
+            `*General reliability note: per-trade ratios (Sharpe, Sortino, Certainty, Recovery, Expectancy) are gated to N/A below ${MIN_SIGNALS_FOR_RATIOS$1} closed events. Annualised metrics additionally require a calendar span ≥ ${MIN_CALENDAR_SPAN_DAYS$1} days and a raw trade frequency ≤ ${MAX_TRADES_PER_YEAR$1} per year. 100+ closed events are needed for statistical reliability of the ratios.*`,
+            `*IMPORTANT: Total PNL and the equity-curve metrics (Expected Yearly Returns, Calmar, Recovery, and the equity max drawdown that feeds them) all assume **100% capital allocation per position** (no portfolio fraction). They ignore the position-sizing subsystem: per-trade PNL is a return on the position's own invested capital, never scaled by the account balance. With DCA averaging the cost basis is the sum of all entries and the entry price is dollar-cost-weighted. If your strategy risks X% of capital per trade, the realised portfolio return / drawdown is roughly X/100 of the reported figures — these are theoretical upper bounds under full allocation.*`,
+            `*Negative values for Sharpe / Annualized Sharpe / Sortino / Calmar / Recovery / Expectancy / Expected Yearly Returns indicate a losing strategy (Average PNL < 0 or Total PNL < 0). "Higher is better" still applies — closer to zero is less bad, positive is profitable.*`,
         ].join("\n");
     }
     /**
@@ -25952,7 +26305,14 @@ let ReportStorage$8 = class ReportStorage {
             `**Average activation time:** ${stats.avgActivationTime === null ? "N/A" : `${stats.avgActivationTime.toFixed(2)} minutes`}`,
             `**Average wait time (cancelled):** ${stats.avgWaitTime === null ? "N/A" : `${stats.avgWaitTime.toFixed(2)} minutes`}`,
             "",
-            `*Activation / Cancellation rates are computed over scheduled signals whose outcome (opened or cancelled) is also in the buffer — matched by signalId. "Scheduled signals (raw)" above is the unmatched count and may include records whose outcome has not yet arrived or was evicted from the buffer.*`
+            `*Total events: integer count of every scheduled / opened / cancelled event in the ring buffer (capped at CC_MAX_SCHEDULE_MARKDOWN_ROWS, newest-first; oldest entries are dropped past the cap). UNITS: count.*`,
+            `*Scheduled signals (raw): count of events whose action is "scheduled" in the buffer. UNITS: count. NOTE: this is the unmatched raw count — it may include records whose outcome (opened/cancelled) has not yet arrived or was evicted from the buffer. Activation / Cancellation rates do NOT use this denominator (see below).*`,
+            `*Opened signals: count of events whose action is "opened" in the buffer. UNITS: count.*`,
+            `*Cancelled signals: count of events whose action is "cancelled" in the buffer. UNITS: count.*`,
+            `*Activation rate: matched-opened count / matched-resolved count × 100, where matched-opened = number of "opened" events whose signal id also appears among the buffer's "scheduled" events, matched-cancelled = same for "cancelled" events, and matched-resolved = matched-opened + matched-cancelled. The signal-id match guarantees the numerator and denominator come from the SAME population — a sliding window of CC_MAX_SCHEDULE_MARKDOWN_ROWS can otherwise drop a "scheduled" record before its outcome arrives, inflating rates above 100% or firing one rate without the other. UNITS: percent in [0, 100]. Null when matched-resolved = 0 (no matched outcomes in the buffer).*`,
+            `*Cancellation rate: matched-cancelled count / matched-resolved count × 100 — same signal-id-matched denominator as Activation rate. UNITS: percent in [0, 100]. Null when matched-resolved = 0. By construction Activation rate + Cancellation rate = 100% (or both null together).*`,
+            `*Average activation time: arithmetic mean of duration over events whose action is "opened" AND whose duration is a number. Events without a numeric duration are excluded from both numerator and denominator (no zero dilution). UNITS: minutes. Null when no "opened" event carries a numeric duration. The duration on an opened event represents wait time from the moment the signal was scheduled until the moment it activated (became pending).*`,
+            `*Average wait time (cancelled): arithmetic mean of duration over events whose action is "cancelled" AND whose duration is a number. Same exclusion rule as Average activation time. UNITS: minutes. Null when no "cancelled" event carries a numeric duration. The duration on a cancelled event represents wait time from the moment the signal was scheduled until cancellation.*`,
         ].join("\n");
     }
     /**
@@ -26435,8 +26795,6 @@ class PerformanceStorage {
             "",
             summaryTable,
             "",
-            "**Note:** All durations are in milliseconds. P95/P99 represent 95th and 99th percentile response times. Wait times show the interval between consecutive events of the same type.",
-            "",
             `**Total events:** ${stats.totalEvents}`,
             `**Total execution time:** ${stats.totalDuration.toFixed(2)}ms`,
             `**Number of metric types:** ${Object.keys(stats.metricStats).length}`,
@@ -26445,6 +26803,17 @@ class PerformanceStorage {
             "",
             percentages.join("\n"),
             "",
+            `*Total events: integer count of every performance event in the ring buffer (capped at CC_MAX_PERFORMANCE_MARKDOWN_ROWS, newest-first; oldest entries are dropped past the cap). UNITS: count.*`,
+            `*Total execution time: arithmetic sum of every event's duration in the buffer. UNITS: milliseconds.*`,
+            `*Number of metric types: count of distinct metric-type labels present in the buffer. UNITS: count.*`,
+            `*Time Distribution (per metric): the metric's Total Duration divided by overall Total Execution Time × 100; rendered as a percent next to that metric's total duration in milliseconds. Guard: when the overall execution time is 0 (all-instant operations) the percent is forced to 0 instead of NaN. UNITS: percent of total execution time.*`,
+            `*Count (table column): integer number of events of this metric type in the buffer.*`,
+            `*Total Duration (table column): sum of every event's duration for that metric type. UNITS: milliseconds.*`,
+            `*Avg Duration (table column): Total Duration divided by Count for that metric type. UNITS: milliseconds.*`,
+            `*Min / Max Duration (table columns): smallest / largest single-event duration in the metric-type bucket. UNITS: milliseconds.*`,
+            `*Std Dev (table column): sample standard deviation (Bessel-corrected, N−1 denominator) of single-event durations for that metric type. UNITS: milliseconds. Zero when the bucket has only one event (no variance defined).*`,
+            `*Median / P95 / P99 (table columns): percentiles of the sorted single-event durations using linear interpolation between adjacent ranks — equivalent to numpy.percentile with the default linear method. P95 / P99 represent the 95th / 99th percentile response times (tail latency). UNITS: milliseconds. Buckets of size 0 fall back to 0; size 1 returns the single value for every percentile.*`,
+            `*Avg / Min / Max Wait Time (table columns): wait time = (event's timestamp − the previous event's timestamp) for events where a previous-timestamp value is recorded; this captures the interval between consecutive events of the same metric type. Mean / smallest / largest of those gaps. UNITS: milliseconds. All zero when no event in the bucket carries a previous-timestamp value.*`,
         ].join("\n");
     }
     /**
@@ -26904,7 +27273,17 @@ let ReportStorage$7 = class ReportStorage {
             "",
             await this.getPnlTable(pnlColumns),
             "",
-            "**Note:** Higher values are better for all metrics except Standard Deviation (lower is better)."
+            "",
+            `*Optimization Metric: the name of the per-strategy statistic that this walker run ranked strategies by. The "Best ${results.metric}" value below is the largest value of that statistic among all tested strategies (or, if the statistic is one for which "lower is better", the smallest); the strategy that produced it is reported as Best Strategy. Strategies whose ${results.metric} is N/A are skipped from "best" selection — a missing value never wins.*`,
+            `*Strategies Tested: integer count of distinct strategies that were run during this walker comparison. UNITS: count.*`,
+            `*Total Signals (best strategy): integer count of closed signals produced by the best strategy during this walker run.*`,
+            `*Sortino Ratio (best strategy summary): the best strategy's Average PNL divided by downside deviation (risk-free rate = 0). Downside deviation = √( Σ min(0, per-trade PNL)² / closed signal count ) — squared sums computed over the strategy's closed signals and divided by the total signal count (canonical Sortino 1991, MAR = 0). UNITS: dimensionless. N/A when the best strategy has fewer than 10 closed signals, when it has no losing trades, or when downside deviation is below a float-artifact threshold (~1e-9). Rule of thumb: below 1.0 poor, 1.0–2.0 acceptable, above 2.0 strong.*`,
+            `*Calmar Ratio (best strategy summary): the best strategy's Expected Yearly Returns divided by its equity max drawdown, clamped to ±1000. Expected Yearly Returns is the geometric annualisation of the strategy's compounded equity curve; the equity max drawdown is the mark-to-market max drawdown of that same curve (each trade's worst intra-trade excursion is applied as a trough before booking the realised close, so deep round-trip dips count rather than only close-to-close drops). UNITS: dimensionless. N/A when Expected Yearly Returns is N/A (e.g. too few signals, calendar span too short, or trade frequency too clustered to extrapolate) or when the equity max drawdown ≤ 0. Rule of thumb: below 0.5 poor, above 1.0 strong.*`,
+            `*Recovery Factor (best strategy summary): the best strategy's (final equity − 1) × 100 divided by its equity max drawdown, clamped to ±1000. The numerator is the strategy's compounded total return (the equity curve's end value minus its start, in percent) — NOT the arithmetic sum of per-trade PNLs; mixing those units would inflate the ratio on long winning streaks. The denominator is the same mark-to-market max drawdown described under Calmar Ratio. UNITS: dimensionless. N/A when the best strategy has fewer than 10 closed signals, the strategy blew its account (equity ≤ 0), or the equity max drawdown ≤ 0. Rule of thumb: below 1.0 means profit doesn't cover drawdown, above 3.0 is good.*`,
+            `*Top Strategies Comparison (table): up to N strategies (newest-best first) ranked by the optimization metric, where N is the configured top-N limit for this report. Each row shows that strategy's full statistical summary through the configured comparison columns.*`,
+            `*All Signals (PNL Table): every closed signal produced by every tested strategy during the run, in storage order (newest first). Each row shows one closed trade — entry / exit prices, realised PNL percentage and cost, peak / trough excursions, close reason, durations — through the configured PNL columns.*`,
+            "",
+            "**Note:** Higher values are better for all metrics except Standard Deviation (lower is better). The per-strategy ratios shown above (Sortino, Calmar, Recovery) are forwarded verbatim from each strategy's own backtest statistics — Walker only ranks and surfaces those values, it does not recompute them. Their formulas, null-conditions and statistical gates are spelled out in the individual legend entries above."
         ].join("\n");
     }
     /**
@@ -27679,6 +28058,12 @@ class HeatmapStorage {
             calmarRatio = null;
         if (isUnsafe(recoveryFactor))
             recoveryFactor = null;
+        // Price profile — buyer/seller pressure, trend classification. Built from
+        // the chronological close-price series of this symbol's closed signals.
+        // N-gated internally by the helper (MIN_SIGNALS = 10).
+        const priceProfile = getPriceProfile([...signals]
+            .sort((a, b) => a.closeTimestamp - b.closeTimestamp)
+            .map((s) => ({ closeAt: s.closeTimestamp, close: s.currentPrice })));
         return {
             symbol,
             totalPnl,
@@ -27713,6 +28098,15 @@ class HeatmapStorage {
             certaintyRatio,
             expectedYearlyReturns,
             tradesPerYear,
+            medianStepSize: priceProfile.medianStepSize,
+            buyerPressure: priceProfile.buyerPressure,
+            sellerPressure: priceProfile.sellerPressure,
+            buyerStrength: priceProfile.buyerStrength,
+            sellerStrength: priceProfile.sellerStrength,
+            pressureImbalance: priceProfile.pressureImbalance,
+            trend: priceProfile.trend,
+            trendStrength: priceProfile.trendStrength,
+            trendConfidence: priceProfile.trendConfidence,
         };
     }
     /**
@@ -28156,27 +28550,69 @@ class HeatmapStorage {
             "",
             table,
             "",
-            `*Win Rate: reliable above 200+ signals; below 30 signals a single streak can shift it by 10-20%.*`,
-            `*Pooled Sharpe: Sharpe computed over all trades across symbols treated as one sample. NOT a Markowitz portfolio Sharpe — ignores cross-symbol correlations and capital allocation. N/A unless ≥${MIN_SIGNALS_FOR_RATIOS} pooled trades.*`,
-            `*Annualized Sharpe: per-trade Sharpe × √tradesPerYear. N/A unless the underlying Sharpe and tradesPerYear are both available (≥${MIN_SIGNALS_FOR_ANNUALIZATION} signals, span ≥${MIN_CALENDAR_SPAN_DAYS} days, raw frequency ≤${MAX_TRADES_PER_YEAR}). Assumes returns are iid — autocorrelated strategies are overstated.*`,
-            `*Certainty Ratio: avgWin / |avgLoss|. Below 1.0 means average loss exceeds average win. Above 1.5 is considered good. N/A when no losing trades or |avgLoss| is sub-epsilon.*`,
-            `*Expected Yearly Returns: compounded geometric return from the equity curve, annualized by tradesPerYear. Same gating as Annualized Sharpe. Capped at ±${MAX_EXPECTED_YEARLY_RETURNS}% — values above the cap return N/A.*`,
-            `*Trades Per Year: observed trade frequency extrapolated to one year (signals × 365 / calendarSpanDays). N/A when too few signals or too short a calendar span; also null when the raw frequency exceeds ${MAX_TRADES_PER_YEAR} (too clustered for reliable annualization).*`,
-            `*Sharpe Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals per symbol.*`,
-            `*Sortino Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals. N/A when no losing trades — Sortino is mathematically undefined (infinite) and we cannot distinguish "truly flawless" from "lucky streak so far".*`,
-            `*Profit Factor: below 1.0 means strategy is losing overall. Above 1.5 is considered good.*`,
-            `*Calmar Ratio: below 0.5 is poor, 0.5-1.0 is acceptable, above 1.0 is strong. Denominator is the mark-to-market max drawdown (see below). N/A unless ≥${MIN_SIGNALS_FOR_ANNUALIZATION} signals per symbol and span ≥${MIN_CALENDAR_SPAN_DAYS} days. Capped at ±${MAX_CALMAR_RATIO}.*`,
-            `*Recovery Factor: below 1.0 means total profit does not cover max drawdown. Above 3.0 is considered good. Uses compounded total return as numerator and the mark-to-market max drawdown as denominator.*`,
-            `*Expectancy: per-trade expected value (winProb × avgWin + lossProb × avgLoss). Positive = profitable on average per trade. Break-even trades contribute 0.*`,
-            `*Median PNL: middle value of the pnl distribution. Robust to outliers; compare to Average PNL — a large gap signals a skewed distribution (e.g. one whale trade dragging the mean).*`,
-            `*Avg Peak PNL / Avg Max Drawdown PNL: mean of per-trade _peak.pnlPercentage / _fall.pnlPercentage. Higher avg-peak with deeper avg-drawdown means strategy needs to tolerate bigger swings to capture the upside.*`,
-            `*Peak Profit PNL / Max Drawdown PNL: extremes — the best best-case and worst worst-case observed across all trades. Tail behaviour the averages hide.*`,
-            `*Avg Duration / Avg Win Duration / Avg Loss Duration: mean hold time in minutes (closeTimestamp - pendingAt). Winner-shorter-than-loser is a red flag ("cut winners short, let losers run").*`,
-            `*Avg Consecutive Win/Loss PNL: average sum of pnlPercentage across consecutive streaks. Pairs with max streak length to show the typical (not worst-case) streak magnitude. Portfolio uses trade-count-weighted mean of per-symbol streak averages — concatenating streaks across symbols would be meaningless (different markets, different timeframes).*`,
-            `*Max Drawdown: mark-to-market — both the per-symbol and pooled equity curves apply each trade's worst intra-trade excursion (the lowest unrealized point while the position was open) before booking its realized close, so deep round-trip dips count. It is NOT realized-only (close-to-close); a realized-only curve would understate drawdown and inflate Calmar/Recovery. The pooled curve walks trades chronologically by closeTimestamp; simultaneous cross-symbol drawdowns within the same minute are still serialised (one trade applied at a time), so genuine same-instant tail correlation is not modelled.*`,
-            `*All metrics require 100+ signals per symbol to be statistically reliable. Annualized metrics assume the observed trading frequency persists year-round.*`,
-            `*IMPORTANT: Per-symbol equity curve, Expected Yearly Returns, Calmar, Recovery and Max Drawdown all assume **100% capital allocation per position** (no portfolio fraction). These metrics ignore the position-sizing subsystem (PositionSize / Kelly / ATR): pnlPercentage is a return on the position's own invested capital, never scaled by account balance. With DCA (commitAverageBuy) the cost basis is the sum of all entries and the entry price is dollar-cost-weighted, so per-trade % is measured against the averaged position, not a fixed stake. If your strategy risks X% of capital per trade, the realized return / drawdown will be roughly X/100 of the reported figures — these metrics represent a theoretical upper bound under full allocation.*`,
-            `*Negative values for Sharpe / Annualized Sharpe / Sortino / Calmar / Recovery / Expectancy / Expected Yearly Returns indicate a losing symbol (avgPnl < 0 or totalPnl < 0). "Higher is better" still applies — closer to zero is less bad, positive is profitable.*`,
+            `*Total Symbols: count of distinct symbol buckets currently tracked in this storage. Each bucket holds at most CC_MAX_HEATMAP_MARKDOWN_ROWS closed signals (newest-first ring buffer); when capacity is reached the oldest signal is dropped. UNITS: integer count of symbols.*`,
+            `*Portfolio PNL: arithmetic sum of per-trade PNL across every closed signal of every tracked symbol (Σ per-symbol Total PNL over symbols whose Total PNL is non-null). UNITS: percent. Additive total — NOT the compounded equity return. Useful as a quick scoreboard; ignores volatility drag and cross-symbol diversification.*`,
+            `*Pooled Sharpe: pooled mean per-trade PNL divided by the pooled sample standard deviation (Bessel-corrected, N−1 denominator) of per-trade PNL, computed over the POOLED set of every closed signal of every symbol treated as one sample. UNITS: dimensionless ratio. NOT a Markowitz portfolio Sharpe — ignores cross-symbol correlations and capital allocation. Null when pooled trade count < ${MIN_SIGNALS_FOR_RATIOS} OR pooled standard deviation ≤ 1e-9. Rule of thumb: below 1.0 poor, 1.0–2.0 acceptable, above 2.0 strong.*`,
+            `*Annualized Sharpe (portfolio): Pooled Sharpe × √(portfolio Trades Per Year). UNITS: dimensionless. Null when Pooled Sharpe is null OR portfolio Trades Per Year is null OR ≤ 0. Assumes returns are iid — autocorrelated strategies are overstated.*`,
+            `*Certainty Ratio (portfolio): pooledAvgWin / |pooledAvgLoss| where pooledAvgWin = mean over pooled winning closed signals and pooledAvgLoss = mean over pooled losing closed signals. UNITS: dimensionless. Below 1.0 means the typical loss exceeds the typical win; above 1.5 is generally good. Null when pooled N < ${MIN_SIGNALS_FOR_RATIOS}, OR no losing trades in the pool, OR |pooledAvgLoss| < 1e-9.*`,
+            `*Expected Yearly Returns (portfolio): geometric annualisation of the pooled equity curve: (pooled final equity ^ (portfolio Trades Per Year / pooled trade count) − 1) × 100, where the pooled equity curve walks every closed signal of every symbol chronologically by close-time and compounds (1 + per-trade PNL / 100). UNITS: percent per year. Null when the pooled calendar span < ${MIN_CALENDAR_SPAN_DAYS} days, raw portfolio Trades Per Year > ${MAX_TRADES_PER_YEAR}, or |raw value| > ${MAX_EXPECTED_YEARLY_RETURNS}%. −100% if the pooled equity curve hits ≤ 0.*`,
+            `*Trades Per Year (portfolio): pooled trade count × 365 / pooled span in days, where pooled span = (latest close-time − earliest pending-time across the whole pool) / day. UNITS: trades / year. Null when pooled trade count < ${MIN_SIGNALS_FOR_RATIOS}, OR pooled span < ${MIN_CALENDAR_SPAN_DAYS} days, OR raw value > ${MAX_TRADES_PER_YEAR} (sample too clustered to extrapolate reliably). NOTE: portfolio Trades Per Year inherits the ratios-block sample-size gate (MIN_SIGNALS_FOR_RATIOS) on the pooled count, whereas the per-symbol Trades Per Year column uses the annualisation-block gate (MIN_SIGNALS_FOR_ANNUALIZATION) on the per-symbol count. The two constants are equal (${MIN_SIGNALS_FOR_RATIOS}) in this build, so this never produces a discrepancy in practice; should they ever diverge, portfolio Trades Per Year would surface earlier than per-symbol Trades Per Year, which is consistent with the rest of the portfolio block already being scoped under the ratios gate.*`,
+            `*Total Trades (portfolio = portfolioTotalTrades): sum of per-symbol totalTrades over all tracked symbols. UNITS: integer count.*`,
+            `*Avg Peak PNL (portfolio): trade-count-weighted mean of per-symbol Avg Peak PNL over symbols whose value is non-null. Weights are per-symbol Total Trades; symbols without any peak-snapshot signals don't contribute and don't dilute. UNITS: percent. Describes the portfolio's typical best-case unrealised excursion. NOT gated by MIN_SIGNALS at portfolio level — null only if every symbol's Avg Peak PNL is null.*`,
+            `*Avg Max Drawdown PNL (portfolio): trade-count-weighted mean of per-symbol Avg Max Drawdown PNL over symbols whose value is non-null. UNITS: percent (negative for losing excursions). Closer to 0 is better — describes the portfolio's typical worst-case unrealised excursion. NOT gated by MIN_SIGNALS at portfolio level — null only if every symbol's Avg Max Drawdown PNL is null.*`,
+            `*Peak Profit PNL (portfolio): MAX of per-symbol Peak Profit PNL over all symbols whose value is non-null. UNITS: percent. The single best best-case excursion observed anywhere across the portfolio (tail behaviour the average hides). NOT gated by MIN_SIGNALS at portfolio level — null only if every symbol's Peak Profit PNL is null.*`,
+            `*Max Drawdown PNL (portfolio): MIN of per-symbol Max Drawdown PNL over all symbols whose value is non-null. UNITS: percent (negative). The single deepest unrealised dip observed anywhere across the portfolio. NOT gated by MIN_SIGNALS at portfolio level — null only if every symbol's Max Drawdown PNL is null.*`,
+            `*Median PNL (portfolio): median of per-trade PNL over the POOLED set of every closed signal of every symbol (middle value after sorting; for even N the mean of the two middles). UNITS: percent. Robust to outliers; compare with the pooled mean per-trade PNL that underlies Pooled Sharpe to detect distribution skew (a large gap means one or two trades drag the arithmetic mean). NOT gated by MIN_SIGNALS — computed whenever pooled trade count ≥ 1.*`,
+            `*Avg Duration (portfolio): arithmetic mean of (close-time − pending-time) / 60_000 over the pooled set of every closed signal of every symbol that has both timestamps. UNITS: minutes. NOT gated by MIN_SIGNALS — computed whenever at least one closed signal across the pool carries valid timestamps.*`,
+            `*Avg Win Duration (portfolio): mean hold time in minutes restricted to pooled winning closed signals (per-trade PNL > 0). UNITS: minutes. Null only when there are no winning trades across the pool (NOT gated by MIN_SIGNALS).*`,
+            `*Avg Loss Duration (portfolio): mean hold time in minutes restricted to pooled losing closed signals (per-trade PNL < 0). UNITS: minutes. Null only when there are no losing trades across the pool (NOT gated by MIN_SIGNALS). Pair with Avg Win Duration to detect the asymmetry "winner-shorter-than-loser" (a red flag: cut winners short, let losers run).*`,
+            `*Avg Consecutive Win PNL (portfolio): trade-count-weighted mean of per-symbol Avg Consecutive Win PNL over symbols whose value is non-null. A per-symbol "win streak" is a run of consecutive same-symbol closed signals with per-trade PNL > 0 bounded by a losing or break-even trade; the per-symbol metric averages the SUM of per-trade PNL within each streak. The portfolio aggregate weights by per-symbol Total Trades — concatenating streaks ACROSS symbols would be meaningless (different markets, different timeframes). UNITS: percent per streak. NOT gated by MIN_SIGNALS at portfolio level — null only when every per-symbol Avg Consecutive Win PNL is null (i.e. no symbol has a single complete win streak).*`,
+            `*Avg Consecutive Loss PNL (portfolio): trade-count-weighted mean of per-symbol Avg Consecutive Loss PNL over symbols whose value is non-null. Same weighting rationale as the Win-streak counterpart above. UNITS: percent per streak (negative). Closer to 0 = losing streaks are typically smaller. NOT gated by MIN_SIGNALS at portfolio level — null only when every per-symbol Avg Consecutive Loss PNL is null.*`,
+            `*Standard Deviation Per Trade (portfolio): sample standard deviation (Bessel-corrected, N−1 denominator) of per-trade PNL over the pooled set of every closed signal of every symbol. UNITS: percent. Denominator for Pooled Sharpe. Below 1e-9 it is treated as zero (identical-returns guard). Null when pooled trade count < ${MIN_SIGNALS_FOR_RATIOS}.*`,
+            `*Sortino Ratio (portfolio): pooled-mean per-trade PNL divided by pooled downside deviation, where downside deviation = √( Σ min(0, per-trade PNL)² / pooled trade count ) over the pool (canonical Sortino: MAR = 0, divide by N_total). UNITS: dimensionless. Penalises only downside volatility. Rule of thumb: below 1.0 poor, 1.0–2.0 acceptable, above 2.0 strong. Null when pooled trade count < ${MIN_SIGNALS_FOR_RATIOS}, OR no losing trades in the pool, OR pooled downside deviation ≤ 1e-9 (float-artifact guard).*`,
+            `*Calmar Ratio (portfolio): portfolio Expected Yearly Returns divided by the pooled mark-to-market max drawdown, clamped to ±${MAX_CALMAR_RATIO}. The denominator is the max drawdown of the POOLED equity curve walked chronologically by close-timestamp across every symbol — each closed signal's worst intra-trade excursion (its trough-PNL snapshot, ≤ 0) is applied before booking its realised close, so deep round-trip dips count. Cross-symbol simultaneous drawdowns within the same minute are still serialised (one signal applied at a time), so genuine same-instant tail correlation is not modelled. UNITS: dimensionless. Null when the portfolio Expected Yearly Returns is null OR the pooled equity max drawdown ≤ 0.*`,
+            `*Recovery Factor (portfolio): (pooled final equity − 1) × 100 divided by the pooled equity max drawdown, clamped to ±${MAX_CALMAR_RATIO}. The numerator is the compounded total return of the pooled equity curve — NOT the arithmetic Portfolio PNL shown at the top of this report; the denominator is computed on the compounded curve, so mixing those units would inflate the ratio on long winning streaks. The denominator is the same pooled mark-to-market max drawdown used by Calmar. UNITS: dimensionless. Below 1.0 = compounded profit doesn't cover max drawdown; above 3.0 = good. Null when pooled trade count < ${MIN_SIGNALS_FOR_RATIOS}, the pooled equity curve blew up (reached ≤ 0), or the pooled equity max drawdown ≤ 0.*`,
+            `*Expectancy (portfolio): (pooled winning-trade count / pooled trade count) × pooled mean of winning PNLs + (pooled losing-trade count / pooled trade count) × pooled mean of losing PNLs. Break-even closed signals contribute 0 (excluded from both probabilities). UNITS: percent per trade. Positive = profitable on average per trade across the portfolio. Null when pooled trade count < ${MIN_SIGNALS_FOR_RATIOS}, OR when the entire pool is break-even (no wins AND no losses).*`,
+            ``,
+            `*--- Per-symbol table columns ---*`,
+            `*Total PNL (column): arithmetic sum of per-trade PNL across that symbol's stored closed signals. UNITS: percent. Additive total — NOT a compounded equity return. Null only when that symbol has zero stored signals.*`,
+            `*Total Trades (column): integer count of that symbol's stored closed signals. UNITS: count.*`,
+            `*Win Rate (column): per-symbol winning-trade count / (winning-trade count + losing-trade count) × 100; break-even trades (per-trade PNL == 0) are excluded from both numerator and denominator. UNITS: percent in [0, 100]. Statistically noisy below 30 per-symbol signals; stable above 200. NOT gated by MIN_SIGNALS — null only when there are no decisive trades for that symbol.*`,
+            `*Avg PNL (column): arithmetic mean of per-trade PNL across that symbol's signals — Σ per-trade PNL / Total Trades. UNITS: percent per trade. Null only when Total Trades = 0.*`,
+            `*Standard Deviation (column): per-symbol sample standard deviation (Bessel-corrected, N−1 denominator) of per-trade PNL. UNITS: percent. Denominator for per-symbol Sharpe Ratio. Null when that symbol's trade count < ${MIN_SIGNALS_FOR_RATIOS}.*`,
+            `*Avg Win (column): arithmetic mean of per-trade PNL restricted to that symbol's winning trades (per-trade PNL > 0). UNITS: percent. NOT gated by MIN_SIGNALS — null only when that symbol has no winning trades.*`,
+            `*Avg Loss (column): arithmetic mean of per-trade PNL restricted to that symbol's losing trades (per-trade PNL < 0). UNITS: percent (negative). NOT gated by MIN_SIGNALS — null only when that symbol has no losing trades.*`,
+            `*Max Win Streak (column): longest run of consecutive same-symbol closed signals with per-trade PNL > 0, bounded by an opposite-sign or break-even trade. UNITS: integer count of consecutive wins. The streak structure is sign-invariant under reversal, so the count is identical whether signals are walked in chronological or reverse-chronological order. NOT gated by MIN_SIGNALS — 0 when that symbol has no winning trades.*`,
+            `*Max Loss Streak (column): longest run of consecutive same-symbol closed signals with per-trade PNL < 0. UNITS: integer count. Same iteration rules as Max Win Streak. NOT gated by MIN_SIGNALS — 0 when that symbol has no losing trades.*`,
+            `*Median PNL (column): per-symbol median of per-trade PNL (middle value after sorting; for even N the mean of the two middles). UNITS: percent. Robust to outliers; compare with Avg PNL to detect distribution skew. NOT gated by MIN_SIGNALS — null only when Total Trades = 0.*`,
+            `*Sharpe Ratio (column): per-symbol Avg PNL / Standard Deviation (risk-free rate = 0). UNITS: dimensionless. Below 1.0 poor, 1.0–2.0 acceptable, above 2.0 strong. Null when that symbol's trade count < ${MIN_SIGNALS_FOR_RATIOS} OR Standard Deviation ≤ 1e-9 (identical-returns / float-artifact guard).*`,
+            `*Annualized Sharpe (column): per-symbol Sharpe Ratio × √(per-symbol Trades Per Year), where Trades Per Year for that symbol = its trade count × 365 / its calendar span in days. UNITS: dimensionless. Null when per-symbol Sharpe Ratio is null, OR that symbol's Trades Per Year is null (requires trade count ≥ ${MIN_SIGNALS_FOR_ANNUALIZATION}, calendar span ≥ ${MIN_CALENDAR_SPAN_DAYS} days, raw frequency ≤ ${MAX_TRADES_PER_YEAR}). Assumes iid returns.*`,
+            `*Certainty Ratio (column): per-symbol Avg Win / |Avg Loss|. UNITS: dimensionless. Below 1.0 = typical loss exceeds typical win; above 1.5 generally good. Null when that symbol's trade count < ${MIN_SIGNALS_FOR_RATIOS}, OR Avg Win / Avg Loss missing, OR Avg Loss ≥ 0, OR |Avg Loss| < 1e-9 (float-artifact loss guard).*`,
+            `*Expected Yearly Returns (column): per-symbol geometric annualisation of that symbol's equity curve — (final equity ^ (Trades Per Year / trade count) − 1) × 100, where final equity is the compounded product of (1 + per-trade PNL / 100) walked over that symbol's signals in chronological close order. UNITS: percent per year. Null when trade count < ${MIN_SIGNALS_FOR_ANNUALIZATION}, calendar span < ${MIN_CALENDAR_SPAN_DAYS} days, raw frequency > ${MAX_TRADES_PER_YEAR}, or |raw value| > ${MAX_EXPECTED_YEARLY_RETURNS}%. −100% when the symbol's equity curve hits ≤ 0.*`,
+            `*Trades Per Year (column): per-symbol trade count × 365 / calendar span in days, where calendar span = (latest close-time − earliest pending-time for that symbol) / day. UNITS: trades / year. Null when trade count < ${MIN_SIGNALS_FOR_ANNUALIZATION}, calendar span < ${MIN_CALENDAR_SPAN_DAYS} days, or raw value > ${MAX_TRADES_PER_YEAR}.*`,
+            `*Profit Factor (column): per-symbol Σ winning per-trade PNL / |Σ losing per-trade PNL|. UNITS: dimensionless. Below 1.0 means the symbol is net losing; above 1.5 is generally good. Null when there are no winning or no losing trades for that symbol, or when Σ|losing PNL| < 1e-9 (float-artifact guard).*`,
+            `*Sortino Ratio (column): per-symbol Avg PNL / downside deviation, where downside deviation = √( Σ min(0, per-trade PNL)² / total trade count ) (canonical Sortino: MAR = 0, divide by N_total). UNITS: dimensionless. Null when that symbol's trade count < ${MIN_SIGNALS_FOR_RATIOS}, OR no losing trades, OR downside deviation ≤ 1e-9 (float-artifact guard).*`,
+            `*Calmar Ratio (column): per-symbol Expected Yearly Returns / Max Drawdown, clamped to ±${MAX_CALMAR_RATIO}. Denominator is the mark-to-market max drawdown of that symbol's compounded equity curve. Null when Expected Yearly Returns is null (requires ≥ ${MIN_SIGNALS_FOR_ANNUALIZATION} signals and a calendar span ≥ ${MIN_CALENDAR_SPAN_DAYS} days for that symbol) OR Max Drawdown ≤ 0.*`,
+            `*Recovery Factor (column): per-symbol (final equity − 1) × 100 / Max Drawdown, clamped to ±${MAX_CALMAR_RATIO}. The numerator is the compounded total return of that symbol's equity curve. Null when that symbol's trade count < ${MIN_SIGNALS_FOR_RATIOS}, the equity curve blew up (reached ≤ 0), or Max Drawdown ≤ 0.*`,
+            `*Expectancy (column): per-symbol expected value per trade. Three cases depending on what kinds of trades exist for that symbol: (a) BOTH winning and losing trades present → (winning-trade count / Total Trades) × Avg Win + (losing-trade count / Total Trades) × Avg Loss; (b) only winning trades present → (winning-trade count / Total Trades) × Avg Win (zero contribution from non-existent losses); (c) only losing trades present → (losing-trade count / Total Trades) × Avg Loss. Break-even trades contribute 0 (excluded from both probabilities). UNITS: percent per trade. NOT gated by MIN_SIGNALS — computed whenever Total Trades ≥ 1 and at least one decisive trade exists. (Note: the portfolio-level Expectancy further up in this report uses a single combined formula and IS gated by MIN_SIGNALS_FOR_RATIOS over the pooled count; per-symbol Expectancy is intentionally looser to populate the row early.)*`,
+            `*Max Drawdown (column): per-symbol mark-to-market max drawdown — the symbol's compounded equity curve applies each closed signal's worst intra-trade excursion (its trough-PNL snapshot, ≤ 0) before booking the realised close, so deep round-trip dips count rather than only realised close-to-close drops. UNITS: percent. NOT realised-only.*`,
+            `*Avg Peak PNL / Avg Max Drawdown PNL (columns): per-symbol arithmetic means of each closed signal's peak-PNL / trough-PNL snapshot — the best / worst mark-to-market PNL recorded while the position was open. Signals that never recorded the snapshot are excluded — no zero dilution. UNITS: percent. NOT gated by MIN_SIGNALS — each is null only if no signal for that symbol carries the corresponding snapshot.*`,
+            `*Peak Profit PNL / Max Drawdown PNL (columns): per-symbol MAX of the peak-PNL snapshot / MIN of the trough-PNL snapshot across the symbol's stored closed signals. UNITS: percent. The single best best-case and worst worst-case excursions for that symbol — tail behaviour the averages hide. NOT gated by MIN_SIGNALS — each is null only if no signal for that symbol carries the corresponding snapshot.*`,
+            `*Avg Duration / Avg Win Duration / Avg Loss Duration (columns): per-symbol mean hold time in minutes — (close-time − pending-time) / 60_000 — over all signals / winning signals / losing signals respectively. UNITS: minutes. NOT gated by MIN_SIGNALS — each is null only if the corresponding bucket (all / wins / losses) is empty for that symbol. Pair Avg Win vs Avg Loss durations to detect "let winners run, cut losers short" (Avg Win Duration > Avg Loss Duration is healthy).*`,
+            `*Avg Consecutive Win PNL / Avg Consecutive Loss PNL (columns): a per-symbol "streak" is a run of consecutive same-symbol closed signals with same-sign per-trade PNL bounded by an opposite-sign or break-even trade; each metric sums per-trade PNL within each streak and averages those sums. The streak structure is sign-invariant under iteration order, so the resulting average is the same whether signals are walked chronologically or in reverse. UNITS: percent per streak. NOT gated by MIN_SIGNALS — each is null only if not a single complete streak of the corresponding sign exists in that symbol's history. Pair with Max Win Streak / Max Loss Streak to compare typical vs worst-case streak magnitude.*`,
+            `*Trend (column, per-symbol only): bivariate classification computed FROM CLOSING PRICES OF CLOSED SIGNALS of that symbol (one point per closed trade = the price at which it closed, with its close-timestamp — no candles, no order book, no tick stream). "sideways" when R² < 0.30; otherwise "neutral" when |Trend Strength| < 0.25 × Median Step Size; otherwise "bullish" if Trend Strength > 0, "bearish" if Trend Strength < 0. Two-axis gate, never a single magic constant on slope magnitude. Null when that symbol's trade count < ${MIN_SIGNALS_FOR_RATIOS}, which means Median Step Size, Trend Strength and Trend Confidence all gate as one bundle: if any is null the others are null too, so the classification never sees a partially-computed input. Boundary case: when every closed price is identical (a flat synthetic series at N ≥ ${MIN_SIGNALS_FOR_RATIOS}), Median Step Size is 0 and the slope-vs-step gate collapses — the regression then returns slope = R² = 0, R² < 0.30 fires first, and the classification is "sideways" as expected. Not aggregated portfolio-wide because price series across symbols are not comparable.*`,
+            `*Trend %/d (column, per-symbol only): ordinary-least-squares slope of \`log(close) ~ days\` regressed across CLOSING PRICES OF CLOSED SIGNALS of that symbol. UNITS: percent per day (small-slope approximation). NOT ATR-normalised, NOT ADX, NOT a rolling-window indicator — static fit at report time. Null when that symbol's trade count < ${MIN_SIGNALS_FOR_RATIOS} or the calendar span is degenerate.*`,
+            `*Trend R² (column, per-symbol only): coefficient of determination of the same log-price regression that produces Trend %/d, computed on log(close) (NOT on absolute close). UNITS: dimensionless in [0, 1]. High R² = clean trend; low R² = noisy regardless of slope sign. Null when that symbol's trade count < ${MIN_SIGNALS_FOR_RATIOS} or the calendar span is degenerate.*`,
+            `*Buyer Pres (column, per-symbol only): frequency-based, computed FROM CLOSING PRICES OF CLOSED SIGNALS of that symbol. (count of i where close[i] > close[i−1]) / (count of decisive moves); flats (close[i] == close[i−1]) excluded from numerator and denominator. UNITS: dimensionless fraction in [0, 1]. NOT order-flow aggressor volume — the report has no orderbook access; "buyer" labels only the SIGN of the close-to-close return.*`,
+            `*Seller Pres (column, per-symbol only): frequency-based, computed FROM CLOSING PRICES OF CLOSED SIGNALS of that symbol. (count of i where close[i] < close[i−1]) / (count of decisive moves). By construction Buyer Pres + Seller Pres = 1. UNITS: dimensionless fraction in [0, 1].*`,
+            `*Buyer Str (column, per-symbol only): magnitude-based, computed FROM CLOSING PRICES OF CLOSED SIGNALS of that symbol. Σ |close[i] − close[i−1]| / close[i−1] over up-moves, divided by the same sum over ALL decisive moves. UNITS: dimensionless fraction in [0, 1]. Buyer Pres (count) and Buyer Str (Σ|Δ|) use the SAME return series; divergence between them (e.g. Pres 0.70 with Str 0.45) reveals regime asymmetry: many small up-moves vs fewer but larger down-moves.*`,
+            `*Seller Str (column, per-symbol only): magnitude-based, computed FROM CLOSING PRICES OF CLOSED SIGNALS of that symbol. Σ |close[i] − close[i−1]| / close[i−1] over down-moves, divided by the same sum over ALL decisive moves. By construction Buyer Str + Seller Str = 1.*`,
+            `*Pres Imb (column, per-symbol only): DIFFERENCE, not ratio: Buyer Str − Seller Str = (2 × Buyer Str − 1), computed FROM CLOSING PRICES OF CLOSED SIGNALS of that symbol. UNITS: dimensionless in [−1, +1]. Sign = direction of magnitude bias.*`,
+            `*Median Step (column, per-symbol only): median over i ∈ [1..N−1] of |close[i] − close[i−1]| / close[i−1], computed FROM CLOSING PRICES OF CLOSED SIGNALS of that symbol — "step" = consecutive trade closes (NOT ticks, NOT bars of any timeframe; the report has no candle access). UNITS: percent (normalised by price → directly comparable between symbols at any price level). Median (not mean) → robust to one whale trade. NOT classical candle-based volatility (ATR / σ of returns); it measures the step distribution AT THE RATE TRADES CLOSE.*`,
+            ``,
+            `*General reliability note: per-symbol ratios (Sharpe, Sortino, Certainty, Recovery, Expectancy) are gated to N/A below ${MIN_SIGNALS_FOR_RATIOS} per-symbol signals. Annualised metrics (Annualized Sharpe, Expected Yearly Returns, Calmar) additionally require a calendar span ≥ ${MIN_CALENDAR_SPAN_DAYS} days and a raw trade frequency ≤ ${MAX_TRADES_PER_YEAR} per year. The same gates apply to portfolio-level pooled metrics, with the pooled trade count replacing per-symbol trade count. 100+ per-symbol signals are needed for statistical reliability of the ratios; annualised metrics assume the observed frequency and market regime persist year-round.*`,
+            `*IMPORTANT: per-symbol AND pooled equity curve, Expected Yearly Returns, Calmar, Recovery and Max Drawdown all assume **100% capital allocation per position** (no portfolio fraction). They ignore the position-sizing subsystem (PositionSize / Kelly / ATR): per-trade PNL is a return on the position's own invested capital, never scaled by the account balance. With DCA averaging, the cost basis is the sum of all entries and the entry price is dollar-cost-weighted. If your strategy risks X% of capital per trade, the realised return / drawdown is roughly X/100 of the reported figures — these are theoretical upper bounds under full allocation.*`,
+            `*Negative values for Sharpe / Annualized Sharpe / Sortino / Calmar / Recovery / Expectancy / Expected Yearly Returns indicate a losing symbol or portfolio (Average PNL < 0 or Total PNL < 0). "Higher is better" still applies — closer to zero is less bad, positive is profitable.*`,
         ].join("\n");
     }
     /**
@@ -66976,6 +67412,7 @@ exports.getPositionPartials = getPositionPartials;
 exports.getPositionPnlCost = getPositionPnlCost;
 exports.getPositionPnlPercent = getPositionPnlPercent;
 exports.getPositionWaitingMinutes = getPositionWaitingMinutes;
+exports.getPriceScale = getPriceScale;
 exports.getRawCandles = getRawCandles;
 exports.getRiskSchema = getRiskSchema;
 exports.getRuntimeInfo = getRuntimeInfo;