Vest: projected days trade the next stage after each payout, as the bot does

runClaims claims a same-day type's target and trades its next stage the
same day on the room the claim freed, but the projection paid out once a
day, so Vest's payout calendar showed $1,500 a day instead of $1,500 then
$3,000. Each payout now counts toward its own date, and the same date is
projected again on the next stage, once through the stages a day (the
last one repeats). A cycle that stood complete before today counts
toward today, when it is claimed. Other types project as before.

The account page sums a date's cycles, cuts after the second payout day,
and labels a same-day type's past days from that day's own payout.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

app/accounts/[id]/page.tsx

@@ -600,7 +600,7 @@ export default function AccountPage() {
     // books exactly its plan, cycles complete, and the configured withdrawal
     // fires the day a cycle finishes. Same planner the trade path runs, so the
     // numbers (bumps and drain amounts included) are what would actually be
-    // aimed for. Shown up to TWO payouts ahead.
+    // aimed for. Shown up to TWO payout days ahead.
     const rawProjection = (cfg && !isDead) ? projectPerfectPath({
         accountId: account.id,
         cfg,
@@ -610,7 +610,8 @@ export default function AccountPage() {
         realizedPnL: account.realizedPnL,
         // A type whose stages reset each day: its state stage counts today's payouts.
         stageInputs: { stagesSameDay: cfg.stagesSameDay === true, sameDayWithdrawals: account.stage - 1 },
-        maxWithdrawals: 2,
+        // Such a type pays out once per stage on each of those days.
+        maxWithdrawals: cfg.stagesSameDay === true ? 2 * (1 + cfg.withdrawalStages.length) : 2,
         payout: {
             withdrawalPct: cfg.withdrawalPct,
             payoutCap: cfg.payoutCap,
@@ -626,23 +627,21 @@ export default function AccountPage() {
                 : undefined,
         },
     }) : [];
-    // Cut the projection at the second payout — days beyond it are noise here.
-    const secondPayoutIdx = (() => {
-        let seen = 0;
-        for (let i = 0; i < rawProjection.length; i++) {
-            const p = rawProjection[i];
-            if (p.withdrawal !== undefined || p.payoutReady) {
-                seen++;
-                if (seen >= 2 || p.payoutReady) return i;
-            }
-        }
-        return -1;
-    })();
-    const projection = secondPayoutIdx >= 0 ? rawProjection.slice(0, secondPayoutIdx + 1) : rawProjection;
+    // Cut the projection after the second payout day — days beyond it are
+    // noise here. The path's dates never go back, and a payoutReady entry is
+    // always its last.
+    const payoutDays = [...new Set(rawProjection.filter((p) => p.withdrawal !== undefined || p.payoutReady).map((p) => p.date))];
+    const projection = payoutDays.length >= 2 ? rawProjection.filter((p) => p.date <= payoutDays[1]) : rawProjection;
     // A payout day is the cycle's FINAL trading day — it can carry both the
-    // day's booked P&L and the withdrawal.
-    const projPnlMap = new Map(projection.filter((p) => p.pnl !== 0).map((p) => [p.date, p.pnl]));
-    const projFundMap = new Map(projection.filter((p) => p.withdrawal !== undefined).map((p) => [p.date, p.withdrawal!]));
+    // day's booked P&L and the withdrawal. A same-day type's day can hold
+    // several cycles: their P&L and withdrawals add up, and the day shows
+    // the last stage it traded.
+    const projPnlMap = new Map<string, number>();
+    const projFundMap = new Map<string, number>();
+    for (const p of projection) {
+        if (p.pnl !== 0) projPnlMap.set(p.date, Math.round(((projPnlMap.get(p.date) ?? 0) + p.pnl) * 100) / 100);
+        if (p.withdrawal !== undefined) projFundMap.set(p.date, Math.round(((projFundMap.get(p.date) ?? 0) + p.withdrawal) * 100) / 100);
+    }
     const projStageMap = new Map(projection.map((p) => [p.date, p.stage]));
     /** Cumulative probability of the perfect path surviving through each projected day. */
     const projProbMap = new Map(projection.map((p) => [p.date, p.prob]));
@@ -657,14 +656,20 @@ export default function AccountPage() {
     ];
     const calendarMonths = [...new Set(allCalendarDates.map((d) => d.slice(0, 7)))].sort();
 
-    // Build stage map: stage increments after each withdrawal (negative fund txn)
+    // Build stage map: stage increments after each withdrawal (negative fund txn).
+    // A type whose stages reset each day starts every day on stage 1 and
+    // trades its next stage after a payout that day, as the projected days
+    // show — one fund row a day holds all of that day's payouts, so a day
+    // with one reads stage 2.
     const sortedWithdrawalDates = fundTransactions
         .filter((f) => f.amount < 0)
         .map((f) => f.date)
         .sort();
     const stageMap = new Map<string, number>();
     for (const d of displayPnL) {
-        const stage = sortedWithdrawalDates.filter((wd) => wd < d.date).length + 1;
+        const stage = cfg?.stagesSameDay === true
+            ? sortedWithdrawalDates.filter((wd) => wd === d.date).length + 1
+            : sortedWithdrawalDates.filter((wd) => wd < d.date).length + 1;
         stageMap.set(d.date, stage);
     }