backtest-kit 11.5.2 → 11.7.0

package/build/index.mjs

@@ -21261,6 +21261,32 @@ const heat_columns = [
         format: (data) => data.sharpeRatio !== null ? str(data.sharpeRatio) : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "annualizedSharpeRatio",
+        label: "Ann Sharpe",
+        format: (data) => data.annualizedSharpeRatio !== null ? str(data.annualizedSharpeRatio) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "certaintyRatio",
+        label: "Certainty",
+        format: (data) => data.certaintyRatio !== null ? str(data.certaintyRatio) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "expectedYearlyReturns",
+        label: "Exp Yearly",
+        format: (data) => data.expectedYearlyReturns !== null
+            ? str(data.expectedYearlyReturns, "%")
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "tradesPerYear",
+        label: "Trades/Yr",
+        format: (data) => data.tradesPerYear !== null ? data.tradesPerYear.toFixed(1) : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "profitFactor",
         label: "PF",
@@ -21327,6 +21353,58 @@ const heat_columns = [
         format: (data) => data.avgFallPnl !== null ? str(data.avgFallPnl, "%") : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "peakProfitPnl",
+        label: "Peak Profit PNL",
+        format: (data) => data.peakProfitPnl !== null ? str(data.peakProfitPnl, "%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "maxDrawdownPnl",
+        label: "Max DD PNL",
+        format: (data) => data.maxDrawdownPnl !== null ? str(data.maxDrawdownPnl, "%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "medianPnl",
+        label: "Median PNL",
+        format: (data) => data.medianPnl !== null ? str(data.medianPnl, "%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgDuration",
+        label: "Avg Dur (min)",
+        format: (data) => data.avgDuration !== null ? data.avgDuration.toFixed(1) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgWinDuration",
+        label: "Avg Win Dur",
+        format: (data) => data.avgWinDuration !== null ? data.avgWinDuration.toFixed(1) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgLossDuration",
+        label: "Avg Loss Dur",
+        format: (data) => data.avgLossDuration !== null ? data.avgLossDuration.toFixed(1) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgConsecutiveWinPnl",
+        label: "Avg Win Streak PNL",
+        format: (data) => data.avgConsecutiveWinPnl !== null
+            ? str(data.avgConsecutiveWinPnl, "%")
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgConsecutiveLossPnl",
+        label: "Avg Loss Streak PNL",
+        format: (data) => data.avgConsecutiveLossPnl !== null
+            ? str(data.avgConsecutiveLossPnl, "%")
+            : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "sortinoRatio",
         label: "Sortino",
@@ -23797,6 +23875,12 @@ let ReportStorage$a = class ReportStorage {
                 calmarRatio: null,
                 recoveryFactor: null,
                 expectancy: null,
+                avgDuration: null,
+                medianPnl: null,
+                avgConsecutiveWinPnl: null,
+                avgConsecutiveLossPnl: null,
+                avgWinDuration: null,
+                avgLossDuration: null,
             };
         }
         // Valid signal set — those with usable pendingAt AND closeTimestamp. Single source
@@ -23874,13 +23958,19 @@ let ReportStorage$a = class ReportStorage {
         // mark-to-market low); equity then moves to the realized close.
         // If equity (at trough or close) goes ≤ 0 (e.g. leveraged loss < -100%) — account
         // blown, fix DD at 100% and stop walking the curve.
+        // Walk the equity curve in chronological close order. Storage is
+        // newest-first (unshift on addSignal); reverse-storage iteration normally
+        // gives chronological order, but explicitly sorting by closeTimestamp
+        // removes the dependency on insertion-order matching close-order (which
+        // can break under crash recovery, signal backfill, or disk replays).
+        const orderedSignals = [...validSignals].sort((a, b) => a.closeTimestamp - b.closeTimestamp);
         let equity = 1;
         let peak = 1;
         let equityMaxDrawdown = 0;
         let blown = false;
-        for (let i = validSignals.length - 1; i >= 0; i--) {
+        for (const s of orderedSignals) {
             // Intra-trade trough — mark-to-market low while the position was open.
-            const fallPct = validSignals[i].signal.maxDrawdown?.pnlPercentage;
+            const fallPct = s.signal.maxDrawdown?.pnlPercentage;
             if (typeof fallPct === "number" && fallPct < 0) {
                 const trough = equity * (1 + fallPct / 100);
                 if (trough <= 0) {
@@ -23893,7 +23983,7 @@ let ReportStorage$a = class ReportStorage {
                     equityMaxDrawdown = troughDd;
             }
             // Realized close — book the final per-trade result.
-            equity *= 1 + validSignals[i].pnl.pnlPercentage / 100;
+            equity *= 1 + s.pnl.pnlPercentage / 100;
             if (equity <= 0) {
                 equityMaxDrawdown = 100;
                 blown = true;
@@ -23946,6 +24036,101 @@ let ReportStorage$a = class ReportStorage {
         const expectancy = canComputeRatios && totalSignals > 0
             ? (wins.length / totalSignals) * avgWin + (losses.length / totalSignals) * avgLoss
             : null;
+        // Median pnlPercentage — robust to outliers; reveals skew when avgPnl is
+        // dragged by a whale trade. Sort a copy (do not mutate validSignals).
+        let medianPnl = null;
+        if (returns.length > 0) {
+            const sortedReturns = returns.slice().sort((a, b) => a - b);
+            const mid = sortedReturns.length >> 1;
+            medianPnl = sortedReturns.length % 2 === 0
+                ? (sortedReturns[mid - 1] + sortedReturns[mid]) / 2
+                : sortedReturns[mid];
+        }
+        // Trade duration metrics in minutes (synchronized with strategy
+        // `minuteEstimatedTime`). validSignals already requires pendingAt > 0 and
+        // closeTimestamp > 0, so every signal here contributes a valid duration.
+        let avgDuration = null;
+        let avgWinDuration = null;
+        let avgLossDuration = null;
+        if (totalSignals > 0) {
+            const durations = [];
+            const winDurations = [];
+            const lossDurations = [];
+            for (const s of validSignals) {
+                const minutes = (s.closeTimestamp - s.signal.pendingAt) / 60000;
+                durations.push(minutes);
+                const pnl = s.pnl.pnlPercentage;
+                if (pnl > 0)
+                    winDurations.push(minutes);
+                else if (pnl < 0)
+                    lossDurations.push(minutes);
+            }
+            avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
+            if (winDurations.length > 0) {
+                avgWinDuration = winDurations.reduce((a, b) => a + b, 0) / winDurations.length;
+            }
+            if (lossDurations.length > 0) {
+                avgLossDuration = lossDurations.reduce((a, b) => a + b, 0) / lossDurations.length;
+            }
+        }
+        // Consecutive streak averages: sum the per-streak pnl, then mean across
+        // streaks. Storage is newest-first, so iterate in reverse for chronological
+        // streaks. Break-even (pnl=0) closes both runs (neither a win nor a loss).
+        let avgConsecutiveWinPnl = null;
+        let avgConsecutiveLossPnl = null;
+        {
+            const winStreakSums = [];
+            const lossStreakSums = [];
+            let curWin = 0;
+            let curLoss = 0;
+            let curWinSum = 0;
+            let curLossSum = 0;
+            for (let i = validSignals.length - 1; i >= 0; i--) {
+                const pnl = validSignals[i].pnl.pnlPercentage;
+                if (pnl > 0) {
+                    if (curLoss > 0) {
+                        lossStreakSums.push(curLossSum);
+                        curLoss = 0;
+                        curLossSum = 0;
+                    }
+                    curWin++;
+                    curWinSum += pnl;
+                }
+                else if (pnl < 0) {
+                    if (curWin > 0) {
+                        winStreakSums.push(curWinSum);
+                        curWin = 0;
+                        curWinSum = 0;
+                    }
+                    curLoss++;
+                    curLossSum += pnl;
+                }
+                else {
+                    if (curWin > 0) {
+                        winStreakSums.push(curWinSum);
+                        curWin = 0;
+                        curWinSum = 0;
+                    }
+                    if (curLoss > 0) {
+                        lossStreakSums.push(curLossSum);
+                        curLoss = 0;
+                        curLossSum = 0;
+                    }
+                }
+            }
+            if (curWin > 0)
+                winStreakSums.push(curWinSum);
+            if (curLoss > 0)
+                lossStreakSums.push(curLossSum);
+            if (winStreakSums.length > 0) {
+                avgConsecutiveWinPnl =
+                    winStreakSums.reduce((a, b) => a + b, 0) / winStreakSums.length;
+            }
+            if (lossStreakSums.length > 0) {
+                avgConsecutiveLossPnl =
+                    lossStreakSums.reduce((a, b) => a + b, 0) / lossStreakSums.length;
+            }
+        }
         // Average peak/fall PNL — over validSignals; only signals that actually have the
         // value contribute (no zero dilution from missing peakProfit/maxDrawdown).
         const peakValues = validSignals
@@ -24011,6 +24196,12 @@ let ReportStorage$a = class ReportStorage {
             calmarRatio: isUnsafe$4(calmarRatio) ? null : calmarRatio,
             recoveryFactor: isUnsafe$4(recoveryFactor) ? null : recoveryFactor,
             expectancy: isUnsafe$4(expectancy) ? null : expectancy,
+            avgDuration: isUnsafe$4(avgDuration) ? null : avgDuration,
+            medianPnl: isUnsafe$4(medianPnl) ? null : medianPnl,
+            avgConsecutiveWinPnl: isUnsafe$4(avgConsecutiveWinPnl) ? null : avgConsecutiveWinPnl,
+            avgConsecutiveLossPnl: isUnsafe$4(avgConsecutiveLossPnl) ? null : avgConsecutiveLossPnl,
+            avgWinDuration: isUnsafe$4(avgWinDuration) ? null : avgWinDuration,
+            avgLossDuration: isUnsafe$4(avgLossDuration) ? null : avgLossDuration,
         };
     }
     /**
@@ -24061,6 +24252,12 @@ let ReportStorage$a = class ReportStorage {
             `**Calmar Ratio:** ${stats.calmarRatio === null ? "N/A" : `${stats.calmarRatio.toFixed(3)} (higher is better)`}`,
             `**Recovery Factor:** ${stats.recoveryFactor === null ? "N/A" : `${stats.recoveryFactor.toFixed(3)} (higher is better)`}`,
             `**Expectancy:** ${stats.expectancy === null ? "N/A" : `${stats.expectancy > 0 ? "+" : ""}${stats.expectancy.toFixed(3)}% (higher is better)`}`,
+            `**Median PNL:** ${stats.medianPnl === null ? "N/A" : `${stats.medianPnl > 0 ? "+" : ""}${stats.medianPnl.toFixed(3)}% (closer to avgPnl = symmetric distribution)`}`,
+            `**Avg Duration:** ${stats.avgDuration === null ? "N/A" : `${stats.avgDuration.toFixed(1)} min`}`,
+            `**Avg Win Duration:** ${stats.avgWinDuration === null ? "N/A" : `${stats.avgWinDuration.toFixed(1)} min`}`,
+            `**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)`}`,
             "",
             `*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.*`,
@@ -24698,6 +24895,12 @@ let ReportStorage$9 = class ReportStorage {
                 calmarRatio: null,
                 recoveryFactor: null,
                 expectancy: null,
+                avgDuration: null,
+                medianPnl: null,
+                avgConsecutiveWinPnl: null,
+                avgConsecutiveLossPnl: null,
+                avgWinDuration: null,
+                avgLossDuration: null,
             };
         }
         const closedEvents = this._eventList.filter((e) => e.action === "closed");
@@ -24787,6 +24990,104 @@ let ReportStorage$9 = class ReportStorage {
             // trades contribute 0 (excluded from both probabilities).
             expectancy = (wins.length / totalClosed) * avgWin + (losses.length / totalClosed) * avgLoss;
         }
+        // Median pnl — robust to outliers; reveals skew when avgPnl is dragged
+        // by a whale trade. Sort a copy (do not mutate returns).
+        let medianPnl = null;
+        if (returns.length > 0) {
+            const sortedReturns = returns.slice().sort((a, b) => a - b);
+            const mid = sortedReturns.length >> 1;
+            medianPnl = sortedReturns.length % 2 === 0
+                ? (sortedReturns[mid - 1] + sortedReturns[mid]) / 2
+                : sortedReturns[mid];
+        }
+        // Trade duration metrics in minutes (synchronized with strategy
+        // `minuteEstimatedTime`). Source: e.timestamp (close) - (e.pendingAt ?? e.timestamp).
+        // validClosed already guarantees e.timestamp > 0; if pendingAt is missing the
+        // event contributes a 0-minute duration, matching the validation fallback.
+        let avgDuration = null;
+        let avgWinDuration = null;
+        let avgLossDuration = null;
+        if (totalClosed > 0) {
+            const durations = [];
+            const winDurations = [];
+            const lossDurations = [];
+            for (const e of validClosed) {
+                const closeTs = e.timestamp;
+                const openTs = e.pendingAt ?? e.timestamp;
+                const minutes = (closeTs - openTs) / 60000;
+                durations.push(minutes);
+                const pnl = e.pnl;
+                if (pnl > 0)
+                    winDurations.push(minutes);
+                else if (pnl < 0)
+                    lossDurations.push(minutes);
+            }
+            avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
+            if (winDurations.length > 0) {
+                avgWinDuration = winDurations.reduce((a, b) => a + b, 0) / winDurations.length;
+            }
+            if (lossDurations.length > 0) {
+                avgLossDuration = lossDurations.reduce((a, b) => a + b, 0) / lossDurations.length;
+            }
+        }
+        // Consecutive streak averages: sum the per-streak pnl, then mean across
+        // streaks. validClosed is newest-first (events unshifted), so iterate in
+        // reverse for chronological streaks. Break-even (pnl=0) closes both runs.
+        let avgConsecutiveWinPnl = null;
+        let avgConsecutiveLossPnl = null;
+        {
+            const winStreakSums = [];
+            const lossStreakSums = [];
+            let curWin = 0;
+            let curLoss = 0;
+            let curWinSum = 0;
+            let curLossSum = 0;
+            for (let i = validClosed.length - 1; i >= 0; i--) {
+                const pnl = validClosed[i].pnl;
+                if (pnl > 0) {
+                    if (curLoss > 0) {
+                        lossStreakSums.push(curLossSum);
+                        curLoss = 0;
+                        curLossSum = 0;
+                    }
+                    curWin++;
+                    curWinSum += pnl;
+                }
+                else if (pnl < 0) {
+                    if (curWin > 0) {
+                        winStreakSums.push(curWinSum);
+                        curWin = 0;
+                        curWinSum = 0;
+                    }
+                    curLoss++;
+                    curLossSum += pnl;
+                }
+                else {
+                    if (curWin > 0) {
+                        winStreakSums.push(curWinSum);
+                        curWin = 0;
+                        curWinSum = 0;
+                    }
+                    if (curLoss > 0) {
+                        lossStreakSums.push(curLossSum);
+                        curLoss = 0;
+                        curLossSum = 0;
+                    }
+                }
+            }
+            if (curWin > 0)
+                winStreakSums.push(curWinSum);
+            if (curLoss > 0)
+                lossStreakSums.push(curLossSum);
+            if (winStreakSums.length > 0) {
+                avgConsecutiveWinPnl =
+                    winStreakSums.reduce((a, b) => a + b, 0) / winStreakSums.length;
+            }
+            if (lossStreakSums.length > 0) {
+                avgConsecutiveLossPnl =
+                    lossStreakSums.reduce((a, b) => a + b, 0) / lossStreakSums.length;
+            }
+        }
         // Average only over signals that have the value — do not dilute the mean with zeros.
         // Use validClosed to keep all metric denominators consistent.
         const peakValues = validClosed
@@ -24827,14 +25128,20 @@ let ReportStorage$9 = class ReportStorage {
         // snapshot, ≤ 0) is applied as a trough BEFORE booking the realized close. Without it
         // the curve only steps at close, so a trade that dipped to -18% and recovered to +2%
         // would register zero drawdown — understating DD and inflating Calmar/Recovery.
-        const chronological = [];
-        for (let i = validClosed.length - 1; i >= 0; i--) {
-            const fall = validClosed[i].fallPnl;
-            chronological.push({
-                r: validClosed[i].pnl,
-                fall: typeof fall === "number" ? fall : null,
-            });
-        }
+        // Walk the equity curve in chronological close order. Reverse-storage
+        // iteration (newest-first storage → reverse) normally yields chronological
+        // order for live ingest, but explicitly sorting by event.timestamp removes
+        // the dependency on insertion-order matching close-order. This matters
+        // under crash recovery (events reloaded from disk in arbitrary order) and
+        // when ingest latency reorders closed events relative to wall-clock time.
+        const chronological = validClosed
+            .map((e) => ({
+            r: e.pnl,
+            fall: typeof e.fallPnl === "number" ? e.fallPnl : null,
+            ts: e.timestamp,
+        }))
+            .sort((a, b) => a.ts - b.ts)
+            .map(({ r, fall }) => ({ r, fall }));
         let equity = 1;
         let peak = 1;
         let equityMaxDrawdown = 0;
@@ -24912,6 +25219,12 @@ let ReportStorage$9 = class ReportStorage {
             calmarRatio: isUnsafe$3(calmarRatio) ? null : calmarRatio,
             recoveryFactor: isUnsafe$3(recoveryFactor) ? null : recoveryFactor,
             expectancy: isUnsafe$3(expectancy) ? null : expectancy,
+            avgDuration: isUnsafe$3(avgDuration) ? null : avgDuration,
+            medianPnl: isUnsafe$3(medianPnl) ? null : medianPnl,
+            avgConsecutiveWinPnl: isUnsafe$3(avgConsecutiveWinPnl) ? null : avgConsecutiveWinPnl,
+            avgConsecutiveLossPnl: isUnsafe$3(avgConsecutiveLossPnl) ? null : avgConsecutiveLossPnl,
+            avgWinDuration: isUnsafe$3(avgWinDuration) ? null : avgWinDuration,
+            avgLossDuration: isUnsafe$3(avgLossDuration) ? null : avgLossDuration,
         };
     }
     /**
@@ -24962,6 +25275,12 @@ let ReportStorage$9 = class ReportStorage {
             `**Calmar Ratio:** ${stats.calmarRatio === null ? "N/A" : `${stats.calmarRatio.toFixed(3)} (higher is better)`}`,
             `**Recovery Factor:** ${stats.recoveryFactor === null ? "N/A" : `${stats.recoveryFactor.toFixed(3)} (higher is better)`}`,
             `**Expectancy:** ${stats.expectancy === null ? "N/A" : `${stats.expectancy > 0 ? "+" : ""}${stats.expectancy.toFixed(3)}% (higher is better)`}`,
+            `**Median PNL:** ${stats.medianPnl === null ? "N/A" : `${stats.medianPnl > 0 ? "+" : ""}${stats.medianPnl.toFixed(3)}% (closer to avgPnl = symmetric distribution)`}`,
+            `**Avg Duration:** ${stats.avgDuration === null ? "N/A" : `${stats.avgDuration.toFixed(1)} min`}`,
+            `**Avg Win Duration:** ${stats.avgWinDuration === null ? "N/A" : `${stats.avgWinDuration.toFixed(1)} min`}`,
+            `**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)`}`,
             "",
             `*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.*`,
@@ -26896,11 +27215,18 @@ class HeatmapStorage {
         let equityFinal = 1;
         let blown = false;
         if (signals.length > 0) {
+            // Walk the per-symbol equity curve in chronological close order.
+            // Storage is newest-first (unshift on addSignal), but if signals were
+            // ingested out-of-order (e.g. Live + crash recovery loading from disk in
+            // arbitrary order, or a backfill replay), reverse-storage iteration
+            // would misplace peak/trough and silently distort maxDrawdown. Sorting
+            // by closeTimestamp explicitly removes that dependency.
+            const ordered = [...signals].sort((a, b) => a.closeTimestamp - b.closeTimestamp);
             let equity = 1;
             let peak = 1;
             let maxDD = 0;
-            for (let i = signals.length - 1; i >= 0; i--) {
-                const fallPct = signals[i].signal.maxDrawdown?.pnlPercentage;
+            for (const s of ordered) {
+                const fallPct = s.signal.maxDrawdown?.pnlPercentage;
                 if (typeof fallPct === "number" && fallPct < 0) {
                     const trough = equity * (1 + fallPct / 100);
                     if (trough <= 0) {
@@ -26912,7 +27238,7 @@ class HeatmapStorage {
                     if (troughDd > maxDD)
                         maxDD = troughDd;
                 }
-                equity *= 1 + signals[i].pnl.pnlPercentage / 100;
+                equity *= 1 + s.pnl.pnlPercentage / 100;
                 if (equity <= 0) {
                     maxDD = 100;
                     blown = true;
@@ -26957,26 +27283,113 @@ class HeatmapStorage {
                     .filter((s) => s.pnl.pnlPercentage < 0)
                     .reduce((acc, s) => acc + s.pnl.pnlPercentage, 0) / lossCount;
         }
-        // Calculate Win/Loss Streaks
+        // Calculate Win/Loss Streaks AND per-streak pnl sums.
+        // A streak is a run of same-signed trades; break-even (pnl=0) ends both runs.
+        // The sign sequence is invariant under reversal, so iterating signals (newest
+        // first) gives the same streak boundaries as chronological order.
         let maxWinStreak = 0;
         let maxLossStreak = 0;
         let currentWinStreak = 0;
         let currentLossStreak = 0;
+        let currentWinStreakSum = 0;
+        let currentLossStreakSum = 0;
+        const winStreakSums = [];
+        const lossStreakSums = [];
         for (const signal of signals) {
-            if (signal.pnl.pnlPercentage > 0) {
+            const pnl = signal.pnl.pnlPercentage;
+            if (pnl > 0) {
+                if (currentLossStreak > 0) {
+                    lossStreakSums.push(currentLossStreakSum);
+                    currentLossStreak = 0;
+                    currentLossStreakSum = 0;
+                }
                 currentWinStreak++;
-                currentLossStreak = 0;
+                currentWinStreakSum += pnl;
                 if (currentWinStreak > maxWinStreak) {
                     maxWinStreak = currentWinStreak;
                 }
             }
-            else if (signal.pnl.pnlPercentage < 0) {
+            else if (pnl < 0) {
+                if (currentWinStreak > 0) {
+                    winStreakSums.push(currentWinStreakSum);
+                    currentWinStreak = 0;
+                    currentWinStreakSum = 0;
+                }
                 currentLossStreak++;
-                currentWinStreak = 0;
+                currentLossStreakSum += pnl;
                 if (currentLossStreak > maxLossStreak) {
                     maxLossStreak = currentLossStreak;
                 }
             }
+            else {
+                // Break-even closes both runs (it's neither a win nor a loss).
+                if (currentWinStreak > 0) {
+                    winStreakSums.push(currentWinStreakSum);
+                    currentWinStreak = 0;
+                    currentWinStreakSum = 0;
+                }
+                if (currentLossStreak > 0) {
+                    lossStreakSums.push(currentLossStreakSum);
+                    currentLossStreak = 0;
+                    currentLossStreakSum = 0;
+                }
+            }
+        }
+        // Flush trailing streak.
+        if (currentWinStreak > 0)
+            winStreakSums.push(currentWinStreakSum);
+        if (currentLossStreak > 0)
+            lossStreakSums.push(currentLossStreakSum);
+        let avgConsecutiveWinPnl = winStreakSums.length > 0
+            ? winStreakSums.reduce((a, b) => a + b, 0) / winStreakSums.length
+            : null;
+        let avgConsecutiveLossPnl = lossStreakSums.length > 0
+            ? lossStreakSums.reduce((a, b) => a + b, 0) / lossStreakSums.length
+            : null;
+        // Trade duration metrics. Source: closeTimestamp - signal.pendingAt, in minutes
+        // (synchronized with strategy `minuteEstimatedTime`). A signal missing either
+        // timestamp is excluded from the corresponding average — silent zeros would
+        // otherwise pull the mean towards zero.
+        let avgDuration = null;
+        let avgWinDuration = null;
+        let avgLossDuration = null;
+        {
+            const durations = [];
+            const winDurations = [];
+            const lossDurations = [];
+            for (const s of signals) {
+                const pendingAt = s.signal.pendingAt;
+                const closeTs = s.closeTimestamp;
+                if (typeof pendingAt !== "number" || pendingAt <= 0)
+                    continue;
+                if (typeof closeTs !== "number" || closeTs <= 0)
+                    continue;
+                const minutes = (closeTs - pendingAt) / 60000;
+                durations.push(minutes);
+                const pnl = s.pnl.pnlPercentage;
+                if (pnl > 0)
+                    winDurations.push(minutes);
+                else if (pnl < 0)
+                    lossDurations.push(minutes);
+            }
+            if (durations.length > 0) {
+                avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
+            }
+            if (winDurations.length > 0) {
+                avgWinDuration = winDurations.reduce((a, b) => a + b, 0) / winDurations.length;
+            }
+            if (lossDurations.length > 0) {
+                avgLossDuration = lossDurations.reduce((a, b) => a + b, 0) / lossDurations.length;
+            }
+        }
+        // Median pnlPercentage — robust to outliers. Sort a copy (do not mutate signals).
+        let medianPnl = null;
+        if (signals.length > 0) {
+            const sorted = signals.map((s) => s.pnl.pnlPercentage).sort((a, b) => a - b);
+            const mid = sorted.length >> 1;
+            medianPnl = sorted.length % 2 === 0
+                ? (sorted[mid - 1] + sorted[mid]) / 2
+                : sorted[mid];
         }
         // Expectancy — probabilities from observed win/loss counts (break-evens contribute 0).
         let expectancy = null;
@@ -26993,8 +27406,12 @@ class HeatmapStorage {
             expectancy = (lossCount / totalTrades) * avgLoss;
         }
         // Average only over signals that have the value — do not dilute the mean with zeros.
+        // Extremes (peakProfitPnl / maxDrawdownPnl) are the best/worst observation
+        // across all trades, surfacing tail behaviour the average hides.
         let avgPeakPnl = null;
         let avgFallPnl = null;
+        let peakProfitPnl = null;
+        let maxDrawdownPnl = null;
         if (signals.length > 0) {
             const peakValues = signals
                 .map((s) => s.signal.peakProfit?.pnlPercentage)
@@ -27002,12 +27419,14 @@ class HeatmapStorage {
             const fallValues = signals
                 .map((s) => s.signal.maxDrawdown?.pnlPercentage)
                 .filter((v) => typeof v === "number");
-            avgPeakPnl = peakValues.length > 0
-                ? peakValues.reduce((sum, v) => sum + v, 0) / peakValues.length
-                : null;
-            avgFallPnl = fallValues.length > 0
-                ? fallValues.reduce((sum, v) => sum + v, 0) / fallValues.length
-                : null;
+            if (peakValues.length > 0) {
+                avgPeakPnl = peakValues.reduce((sum, v) => sum + v, 0) / peakValues.length;
+                peakProfitPnl = Math.max(...peakValues);
+            }
+            if (fallValues.length > 0) {
+                avgFallPnl = fallValues.reduce((sum, v) => sum + v, 0) / fallValues.length;
+                maxDrawdownPnl = Math.min(...fallValues);
+            }
         }
         // Sortino (canonical, Sortino 1991): (avgPnl - MAR) / downside deviation, where
         // downsideDev = √( Σ min(0, r - MAR)² / N_total ). We use MAR = 0 (risk-free target),
@@ -27083,6 +27502,25 @@ class HeatmapStorage {
                 recoveryFactor = Math.max(-MAX_CALMAR_RATIO, Math.min(MAX_CALMAR_RATIO, rawRec));
             }
         }
+        // Annualized Sharpe — sharpeRatio × √tradesPerYear. Both inputs already
+        // carry their own gates (sharpeRatio: N>=MIN_SIGNALS_FOR_RATIOS + STDDEV_EPSILON;
+        // tradesPerYear: N>=MIN_SIGNALS_FOR_ANNUALIZATION + span>=MIN_CALENDAR_SPAN_DAYS
+        // + raw frequency under MAX_TRADES_PER_YEAR), so we just propagate nulls.
+        let annualizedSharpeRatio = null;
+        if (sharpeRatio !== null && tradesPerYear !== null && tradesPerYear > 0) {
+            annualizedSharpeRatio = sharpeRatio * Math.sqrt(tradesPerYear);
+        }
+        // Certainty Ratio = avgWin / |avgLoss|. Same gating shape as Backtest/Live:
+        // N >= MIN_SIGNALS_FOR_RATIOS, AND |avgLoss| above STDDEV_EPSILON (float-artifact
+        // losses near zero would otherwise produce spurious astronomical values).
+        let certaintyRatio = null;
+        if (canComputeRatios &&
+            avgWin !== null &&
+            avgLoss !== null &&
+            avgLoss < 0 &&
+            Math.abs(avgLoss) > STDDEV_EPSILON) {
+            certaintyRatio = avgWin / Math.abs(avgLoss);
+        }
         // Apply safe math checks
         if (isUnsafe(winRate))
             winRate = null;
@@ -27094,6 +27532,14 @@ class HeatmapStorage {
             stdDev = null;
         if (isUnsafe(sharpeRatio))
             sharpeRatio = null;
+        if (isUnsafe(annualizedSharpeRatio))
+            annualizedSharpeRatio = null;
+        if (isUnsafe(certaintyRatio))
+            certaintyRatio = null;
+        if (isUnsafe(expectedYearlyReturns))
+            expectedYearlyReturns = null;
+        if (isUnsafe(tradesPerYear))
+            tradesPerYear = null;
         if (isUnsafe(maxDrawdown))
             maxDrawdown = null;
         if (isUnsafe(profitFactor))
@@ -27108,6 +27554,22 @@ class HeatmapStorage {
             avgPeakPnl = null;
         if (isUnsafe(avgFallPnl))
             avgFallPnl = null;
+        if (isUnsafe(peakProfitPnl))
+            peakProfitPnl = null;
+        if (isUnsafe(maxDrawdownPnl))
+            maxDrawdownPnl = null;
+        if (isUnsafe(avgDuration))
+            avgDuration = null;
+        if (isUnsafe(medianPnl))
+            medianPnl = null;
+        if (isUnsafe(avgConsecutiveWinPnl))
+            avgConsecutiveWinPnl = null;
+        if (isUnsafe(avgConsecutiveLossPnl))
+            avgConsecutiveLossPnl = null;
+        if (isUnsafe(avgWinDuration))
+            avgWinDuration = null;
+        if (isUnsafe(avgLossDuration))
+            avgLossDuration = null;
         if (isUnsafe(sortinoRatio))
             sortinoRatio = null;
         if (isUnsafe(calmarRatio))
@@ -27133,9 +27595,21 @@ class HeatmapStorage {
             expectancy,
             avgPeakPnl,
             avgFallPnl,
+            peakProfitPnl,
+            maxDrawdownPnl,
+            avgDuration,
+            medianPnl,
+            avgConsecutiveWinPnl,
+            avgConsecutiveLossPnl,
+            avgWinDuration,
+            avgLossDuration,
             sortinoRatio,
             calmarRatio,
             recoveryFactor,
+            annualizedSharpeRatio,
+            certaintyRatio,
+            expectedYearlyReturns,
+            tradesPerYear,
         };
     }
     /**
@@ -27197,23 +27671,32 @@ class HeatmapStorage {
         let portfolioExpectancy = null;
         let portfolioCalmarRatio = null;
         let portfolioRecoveryFactor = null;
-        const allReturns = [];
-        // Parallel array of intra-trade troughs (≤ 0), aligned 1:1 with allReturns,
-        // used for mark-to-market DD in the pooled equity curve below.
-        const allFalls = [];
+        let portfolioAnnualizedSharpeRatio = null;
+        let portfolioCertaintyRatio = null;
+        let portfolioExpectedYearlyReturns = null;
+        let portfolioTradesPerYear = null;
+        const pooledTrades = [];
         let poolFirstPendingAt = Infinity;
         let poolLastCloseAt = -Infinity;
         for (const signals of this.symbolData.values()) {
             for (const s of signals) {
-                allReturns.push(s.pnl.pnlPercentage);
                 const fall = s.signal.maxDrawdown?.pnlPercentage;
-                allFalls.push(typeof fall === "number" ? fall : null);
+                pooledTrades.push({
+                    r: s.pnl.pnlPercentage,
+                    fall: typeof fall === "number" ? fall : null,
+                    closeAt: s.closeTimestamp,
+                });
                 if (s.signal.pendingAt < poolFirstPendingAt)
                     poolFirstPendingAt = s.signal.pendingAt;
                 if (s.closeTimestamp > poolLastCloseAt)
                     poolLastCloseAt = s.closeTimestamp;
             }
         }
+        pooledTrades.sort((a, b) => a.closeAt - b.closeAt);
+        const allReturns = pooledTrades.map((t) => t.r);
+        // Parallel array of intra-trade troughs (≤ 0), aligned 1:1 with allReturns,
+        // used for mark-to-market DD in the pooled equity curve below.
+        const allFalls = pooledTrades.map((t) => t.fall);
         if (allReturns.length >= MIN_SIGNALS_FOR_RATIOS) {
             const portfolioAvg = allReturns.reduce((acc, r) => acc + r, 0) / allReturns.length;
             const portfolioVariance = allReturns.reduce((acc, r) => acc + Math.pow(r - portfolioAvg, 2), 0) /
@@ -27243,6 +27726,12 @@ class HeatmapStorage {
             if (wins.length > 0 || losses.length > 0) {
                 portfolioExpectancy = (wins.length / total) * avgWin + (losses.length / total) * avgLoss;
             }
+            // Pooled Certainty Ratio = pooledAvgWin / |pooledAvgLoss|. Same STDDEV_EPSILON
+            // guard as per-symbol — protects against float-artifact losses producing
+            // spuriously astronomical values.
+            if (losses.length > 0 && Math.abs(avgLoss) > STDDEV_EPSILON && avgLoss < 0) {
+                portfolioCertaintyRatio = avgWin / Math.abs(avgLoss);
+            }
             // Pooled equity-curve max drawdown (compounded). MARK-TO-MARKET: each trade's
             // intra-trade trough (allFalls, ≤ 0) is applied before booking the realized close,
             // so deep round-trip dips are captured rather than understating DD.
@@ -27281,30 +27770,38 @@ class HeatmapStorage {
             // calendar span (≥ MIN_CALENDAR_SPAN_DAYS) and a non-clustered trade
             // frequency (≤ MAX_TRADES_PER_YEAR). Above MAX_EXPECTED_YEARLY_RETURNS → null
             // (don't surface the cap as a real figure). This is the numerator for Calmar.
-            let pooledExpectedYearlyReturns = null;
             const poolSpanDays = isFinite(poolFirstPendingAt) && isFinite(poolLastCloseAt)
                 ? (poolLastCloseAt - poolFirstPendingAt) / (1000 * 60 * 60 * 24)
                 : 0;
             if (poolSpanDays >= MIN_CALENDAR_SPAN_DAYS) {
                 const rawTradesPerYear = (allReturns.length / poolSpanDays) * 365;
                 if (rawTradesPerYear <= MAX_TRADES_PER_YEAR) {
+                    portfolioTradesPerYear = rawTradesPerYear;
                     if (blown) {
-                        pooledExpectedYearlyReturns = -100;
+                        portfolioExpectedYearlyReturns = -100;
                     }
                     else {
                         const raw = (Math.pow(equityFinal, rawTradesPerYear / allReturns.length) - 1) * 100;
-                        pooledExpectedYearlyReturns =
+                        portfolioExpectedYearlyReturns =
                             Math.abs(raw) > MAX_EXPECTED_YEARLY_RETURNS ? null : raw;
                     }
                 }
             }
+            // Pooled Annualized Sharpe — pooledSharpe × √pooledTradesPerYear. Both
+            // gates already enforced upstream; just propagate nulls.
+            if (portfolioSharpeRatio !== null &&
+                portfolioTradesPerYear !== null &&
+                portfolioTradesPerYear > 0) {
+                portfolioAnnualizedSharpeRatio =
+                    portfolioSharpeRatio * Math.sqrt(portfolioTradesPerYear);
+            }
             // Pooled Calmar = annualized return / max drawdown — same formula and
             // gating as per-symbol Calmar. NULL when the annualized numerator is
             // unavailable (span/frequency gate, or over the yearly cap). This is what
             // distinguishes it from Recovery, which uses the compounded TOTAL return —
             // previously both used total return, making Calmar == Recovery (a bug).
-            if (maxDD > 0 && pooledExpectedYearlyReturns !== null) {
-                portfolioCalmarRatio = Math.max(-MAX_CALMAR_RATIO, Math.min(MAX_CALMAR_RATIO, pooledExpectedYearlyReturns / maxDD));
+            if (maxDD > 0 && portfolioExpectedYearlyReturns !== null) {
+                portfolioCalmarRatio = Math.max(-MAX_CALMAR_RATIO, Math.min(MAX_CALMAR_RATIO, portfolioExpectedYearlyReturns / maxDD));
             }
             // Pooled Recovery Factor = compounded TOTAL return / max drawdown, clamped.
             // Time-independent (no annualization), so it needs no span gate — only a
@@ -27329,6 +27826,91 @@ class HeatmapStorage {
         if (validFall.length > 0 && fallTradesTotal > 0) {
             portfolioAvgFallPnl = validFall.reduce((acc, s) => acc + s.avgFallPnl * s.totalTrades, 0) / fallTradesTotal;
         }
+        // Portfolio-wide extremes: best best-case and worst worst-case across
+        // every per-symbol extreme. Skips symbols whose extreme is null (no
+        // peakProfit/maxDrawdown snapshots) — they cannot vote in either direction.
+        let portfolioPeakProfitPnl = null;
+        let portfolioMaxDrawdownPnl = null;
+        const peakExtremes = symbols
+            .map((s) => s.peakProfitPnl)
+            .filter((v) => typeof v === "number");
+        const fallExtremes = symbols
+            .map((s) => s.maxDrawdownPnl)
+            .filter((v) => typeof v === "number");
+        if (peakExtremes.length > 0) {
+            portfolioPeakProfitPnl = Math.max(...peakExtremes);
+        }
+        if (fallExtremes.length > 0) {
+            portfolioMaxDrawdownPnl = Math.min(...fallExtremes);
+        }
+        // Portfolio duration metrics — pooled means over every trade with valid
+        // timestamps, regardless of symbol. A signal missing pendingAt/closeTimestamp
+        // is excluded from its average (the same rule as per-symbol).
+        let portfolioAvgDuration = null;
+        let portfolioAvgWinDuration = null;
+        let portfolioAvgLossDuration = null;
+        {
+            const durations = [];
+            const winDurations = [];
+            const lossDurations = [];
+            for (const signals of this.symbolData.values()) {
+                for (const s of signals) {
+                    const pendingAt = s.signal.pendingAt;
+                    const closeTs = s.closeTimestamp;
+                    if (typeof pendingAt !== "number" || pendingAt <= 0)
+                        continue;
+                    if (typeof closeTs !== "number" || closeTs <= 0)
+                        continue;
+                    const minutes = (closeTs - pendingAt) / 60000;
+                    durations.push(minutes);
+                    const pnl = s.pnl.pnlPercentage;
+                    if (pnl > 0)
+                        winDurations.push(minutes);
+                    else if (pnl < 0)
+                        lossDurations.push(minutes);
+                }
+            }
+            if (durations.length > 0) {
+                portfolioAvgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
+            }
+            if (winDurations.length > 0) {
+                portfolioAvgWinDuration = winDurations.reduce((a, b) => a + b, 0) / winDurations.length;
+            }
+            if (lossDurations.length > 0) {
+                portfolioAvgLossDuration = lossDurations.reduce((a, b) => a + b, 0) / lossDurations.length;
+            }
+        }
+        // Portfolio median — pooled over allReturns (already collected for the
+        // Sharpe block). Robust to outliers like the per-symbol counterpart.
+        let portfolioMedianPnl = null;
+        if (allReturns.length > 0) {
+            const sortedAll = allReturns.slice().sort((a, b) => a - b);
+            const mid = sortedAll.length >> 1;
+            portfolioMedianPnl = sortedAll.length % 2 === 0
+                ? (sortedAll[mid - 1] + sortedAll[mid]) / 2
+                : sortedAll[mid];
+        }
+        // Portfolio streak averages — trade-count-weighted mean of per-symbol
+        // averages. Concatenating streaks across symbols would be wrong: trades on
+        // different symbols are not "consecutive" in any meaningful sense (different
+        // markets, different timeframes). Weighting by totalTrades matches the
+        // weighting used for portfolioAvgPeakPnl / portfolioAvgFallPnl.
+        let portfolioAvgConsecutiveWinPnl = null;
+        let portfolioAvgConsecutiveLossPnl = null;
+        const validWinStreak = symbols.filter((s) => s.avgConsecutiveWinPnl !== null);
+        const validLossStreak = symbols.filter((s) => s.avgConsecutiveLossPnl !== null);
+        const winStreakWeight = validWinStreak.reduce((acc, s) => acc + s.totalTrades, 0);
+        const lossStreakWeight = validLossStreak.reduce((acc, s) => acc + s.totalTrades, 0);
+        if (validWinStreak.length > 0 && winStreakWeight > 0) {
+            portfolioAvgConsecutiveWinPnl =
+                validWinStreak.reduce((acc, s) => acc + s.avgConsecutiveWinPnl * s.totalTrades, 0) /
+                    winStreakWeight;
+        }
+        if (validLossStreak.length > 0 && lossStreakWeight > 0) {
+            portfolioAvgConsecutiveLossPnl =
+                validLossStreak.reduce((acc, s) => acc + s.avgConsecutiveLossPnl * s.totalTrades, 0) /
+                    lossStreakWeight;
+        }
         // Apply safe math
         if (isUnsafe(portfolioTotalPnl))
             portfolioTotalPnl = null;
@@ -27338,6 +27920,10 @@ class HeatmapStorage {
             portfolioAvgPeakPnl = null;
         if (isUnsafe(portfolioAvgFallPnl))
             portfolioAvgFallPnl = null;
+        if (isUnsafe(portfolioPeakProfitPnl))
+            portfolioPeakProfitPnl = null;
+        if (isUnsafe(portfolioMaxDrawdownPnl))
+            portfolioMaxDrawdownPnl = null;
         if (isUnsafe(portfolioStdDev))
             portfolioStdDev = null;
         if (isUnsafe(portfolioSortinoRatio))
@@ -27348,6 +27934,26 @@ class HeatmapStorage {
             portfolioRecoveryFactor = null;
         if (isUnsafe(portfolioExpectancy))
             portfolioExpectancy = null;
+        if (isUnsafe(portfolioAvgDuration))
+            portfolioAvgDuration = null;
+        if (isUnsafe(portfolioMedianPnl))
+            portfolioMedianPnl = null;
+        if (isUnsafe(portfolioAvgConsecutiveWinPnl))
+            portfolioAvgConsecutiveWinPnl = null;
+        if (isUnsafe(portfolioAvgConsecutiveLossPnl))
+            portfolioAvgConsecutiveLossPnl = null;
+        if (isUnsafe(portfolioAvgWinDuration))
+            portfolioAvgWinDuration = null;
+        if (isUnsafe(portfolioAvgLossDuration))
+            portfolioAvgLossDuration = null;
+        if (isUnsafe(portfolioAnnualizedSharpeRatio))
+            portfolioAnnualizedSharpeRatio = null;
+        if (isUnsafe(portfolioCertaintyRatio))
+            portfolioCertaintyRatio = null;
+        if (isUnsafe(portfolioExpectedYearlyReturns))
+            portfolioExpectedYearlyReturns = null;
+        if (isUnsafe(portfolioTradesPerYear))
+            portfolioTradesPerYear = null;
         return {
             symbols,
             totalSymbols,
@@ -27356,11 +27962,23 @@ class HeatmapStorage {
             portfolioTotalTrades,
             portfolioAvgPeakPnl,
             portfolioAvgFallPnl,
+            portfolioPeakProfitPnl,
+            portfolioMaxDrawdownPnl,
             portfolioStdDev,
             portfolioSortinoRatio,
             portfolioCalmarRatio,
             portfolioRecoveryFactor,
             portfolioExpectancy,
+            portfolioAvgDuration,
+            portfolioMedianPnl,
+            portfolioAvgConsecutiveWinPnl,
+            portfolioAvgConsecutiveLossPnl,
+            portfolioAvgWinDuration,
+            portfolioAvgLossDuration,
+            portfolioAnnualizedSharpeRatio,
+            portfolioCertaintyRatio,
+            portfolioExpectedYearlyReturns,
+            portfolioTradesPerYear,
         };
     }
     /**
@@ -27409,32 +28027,53 @@ class HeatmapStorage {
         return [
             `# Portfolio Heatmap: ${strategyName}`,
             "",
-            `**Total Symbols:** ${data.totalSymbols}
-      **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%") : "N/A"}
-      **Pooled Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio) : "N/A"}
-      **Total Trades:** ${data.portfolioTotalTrades}
-      **Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? str(data.portfolioAvgPeakPnl, "%") : "N/A"}
-      **Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? str(data.portfolioAvgFallPnl, "%") : "N/A"}`,
-            `**Standard Deviation Per Trade:** ${data.portfolioStdDev !== null ? str(data.portfolioStdDev, "%") : "N/A"}
-      **Sortino Ratio:** ${data.portfolioSortinoRatio !== null ? str(data.portfolioSortinoRatio) : "N/A"}
-      **Calmar Ratio:** ${data.portfolioCalmarRatio !== null ? str(data.portfolioCalmarRatio) : "N/A"}
-      **Recovery Factor:** ${data.portfolioRecoveryFactor !== null ? str(data.portfolioRecoveryFactor) : "N/A"}
-      **Expectancy:** ${data.portfolioExpectancy !== null ? str(data.portfolioExpectancy, "%") : "N/A"}`,
+            `**Total Symbols:** ${data.totalSymbols}`,
+            `**Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%") : "N/A"}`,
+            `**Pooled Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio) : "N/A"}`,
+            `**Annualized Sharpe:** ${data.portfolioAnnualizedSharpeRatio !== null ? str(data.portfolioAnnualizedSharpeRatio) : "N/A"}`,
+            `**Certainty Ratio:** ${data.portfolioCertaintyRatio !== null ? str(data.portfolioCertaintyRatio) : "N/A"}`,
+            `**Expected Yearly Returns:** ${data.portfolioExpectedYearlyReturns !== null ? str(data.portfolioExpectedYearlyReturns, "%") : "N/A"}`,
+            `**Trades Per Year:** ${data.portfolioTradesPerYear !== null ? data.portfolioTradesPerYear.toFixed(1) : "N/A"}`,
+            `**Total Trades:** ${data.portfolioTotalTrades}`,
+            `**Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? str(data.portfolioAvgPeakPnl, "%") : "N/A"}`,
+            `**Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? str(data.portfolioAvgFallPnl, "%") : "N/A"}`,
+            `**Peak Profit PNL:** ${data.portfolioPeakProfitPnl !== null ? str(data.portfolioPeakProfitPnl, "%") : "N/A"}`,
+            `**Max Drawdown PNL:** ${data.portfolioMaxDrawdownPnl !== null ? str(data.portfolioMaxDrawdownPnl, "%") : "N/A"}`,
+            `**Median PNL:** ${data.portfolioMedianPnl !== null ? str(data.portfolioMedianPnl, "%") : "N/A"}`,
+            `**Avg Duration:** ${data.portfolioAvgDuration !== null ? `${data.portfolioAvgDuration.toFixed(1)} min` : "N/A"}`,
+            `**Avg Win Duration:** ${data.portfolioAvgWinDuration !== null ? `${data.portfolioAvgWinDuration.toFixed(1)} min` : "N/A"}`,
+            `**Avg Loss Duration:** ${data.portfolioAvgLossDuration !== null ? `${data.portfolioAvgLossDuration.toFixed(1)} min` : "N/A"}`,
+            `**Avg Consecutive Win PNL:** ${data.portfolioAvgConsecutiveWinPnl !== null ? str(data.portfolioAvgConsecutiveWinPnl, "%") : "N/A"}`,
+            `**Avg Consecutive Loss PNL:** ${data.portfolioAvgConsecutiveLossPnl !== null ? str(data.portfolioAvgConsecutiveLossPnl, "%") : "N/A"}`,
+            `**Standard Deviation Per Trade:** ${data.portfolioStdDev !== null ? str(data.portfolioStdDev, "%") : "N/A"}`,
+            `**Sortino Ratio:** ${data.portfolioSortinoRatio !== null ? str(data.portfolioSortinoRatio) : "N/A"}`,
+            `**Calmar Ratio:** ${data.portfolioCalmarRatio !== null ? str(data.portfolioCalmarRatio) : "N/A"}`,
+            `**Recovery Factor:** ${data.portfolioRecoveryFactor !== null ? str(data.portfolioRecoveryFactor) : "N/A"}`,
+            `**Expectancy:** ${data.portfolioExpectancy !== null ? str(data.portfolioExpectancy, "%") : "N/A"}`,
             "",
             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".*`,
-            `*Certainty Ratio: below 1.0 means average loss exceeds average win. Above 1.5 is considered good.*`,
             `*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.*`,
-            `*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. NOTE: the pooled curve orders trades by storage sequence, not wall-clock time, so simultaneous cross-symbol drawdowns are not modelled.*`,
+            `*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 / Sortino / Calmar / Recovery indicate a losing symbol (avgPnl < 0 or totalPnl < 0). "Higher is better" still applies — closer to zero is less bad, positive is profitable.*`,
+            `*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.*`,
         ].join("\n");
     }
     /**