Merge pull request #158 from LennartvdM/codex/implement-global-run-counter-and-fifo-history

Limit balance history to last 50 runs

Author: LennartvdM

web/app.js

@@ -3,7 +3,7 @@ import {
   createRadialUrchin,
   createBalanceHistoryEntry,
   computeScheduleSignature,
-  MAX_HISTORY_ENTRIES as BALANCE_HISTORY_LIMIT,
+  MAX_HISTORY_ROWS as BALANCE_HISTORY_LIMIT,
 } from './ui/visuals/RadialUrchin.js';
 
 console.info('[app] app.js loaded');
@@ -104,6 +104,7 @@ const visualsState = {
   metaSlot: null,
   runLabel: null,
   balanceHistory: [],
+  totalRunCount: 0,
 };
 let lastVisualPayload = null;
 let lastVisualSchedule = null;
@@ -325,21 +326,20 @@ function applyBalanceHistoryToUrchin() {
   if (!visualsState.urchin || typeof visualsState.urchin.setBalanceHistory !== 'function') {
     return;
   }
-  visualsState.urchin.setBalanceHistory(visualsState.balanceHistory);
+  visualsState.urchin.setBalanceHistory(
+    visualsState.balanceHistory,
+    visualsState.totalRunCount
+  );
 }
 
 function appendActivityBalanceSnapshot(schedule) {
   if (!schedule || typeof schedule !== 'object') {
     return;
   }
-  const previous =
-    visualsState.balanceHistory.length > 0
-      ? visualsState.balanceHistory[visualsState.balanceHistory.length - 1]
-      : null;
-  const nextRunNumber =
-    (previous && Number.isFinite(previous.runNumber)
-      ? previous.runNumber
-      : visualsState.balanceHistory.length) + 1;
+  const previousTotal = Number.isFinite(visualsState.totalRunCount)
+    ? visualsState.totalRunCount
+    : 0;
+  const nextRunNumber = previousTotal + 1;
   const signature = computeScheduleSignature(schedule);
   const entry = createBalanceHistoryEntry(schedule, {
     runNumber: nextRunNumber,
@@ -349,17 +349,18 @@ function appendActivityBalanceSnapshot(schedule) {
   if (!entry) {
     return;
   }
-  const next = [...visualsState.balanceHistory, entry];
-  if (next.length > BALANCE_HISTORY_LIMIT) {
-    next.splice(0, next.length - BALANCE_HISTORY_LIMIT);
-  }
-  visualsState.balanceHistory = next;
+  visualsState.totalRunCount = nextRunNumber;
+  const nextHistory =
+    visualsState.balanceHistory.length >= BALANCE_HISTORY_LIMIT
+      ? [...visualsState.balanceHistory.slice(1), entry]
+      : [...visualsState.balanceHistory, entry];
+  visualsState.balanceHistory = nextHistory;
   if (
     visualsState.urchin &&
     typeof visualsState.urchin.appendBalanceHistoryEntry === 'function'
   ) {
     try {
-      visualsState.urchin.appendBalanceHistoryEntry(entry);
+      visualsState.urchin.appendBalanceHistoryEntry(entry, nextRunNumber);
     } catch (error) {
       console.warn('[visuals] failed to append balance history entry:', error);
     }
@@ -737,7 +738,9 @@ function updateActiveRunLabel() {
   }
 
   const entry = runHistory[index];
-  const runNumber = runHistory.length - index;
+  const runNumber = Number.isFinite(entry?.runNumber)
+    ? entry.runNumber
+    : runHistory.length - index;
   const parts = [`Run #${runNumber}`];
   if (entry.timestamp) {
     const formatted = formatHistoryTimestamp(entry.timestamp);
@@ -907,7 +910,12 @@ function renderCalendarHistorySummary() {
   });
 
   if (meta) {
-    const runNumber = activeIndex !== -1 ? runHistory.length - activeIndex : null;
+    const activeEntry = activeIndex !== -1 ? runHistory[activeIndex] : null;
+    const runNumber = activeEntry && Number.isFinite(activeEntry.runNumber)
+      ? activeEntry.runNumber
+      : activeIndex !== -1
+      ? runHistory.length - activeIndex
+      : null;
     const metaParts = [];
     if (Number.isFinite(runNumber)) {
       metaParts.push(`Run #${runNumber}`);
@@ -1049,6 +1057,9 @@ function recordCalendarHistoryEntry(entry) {
   const visualPayload = resolveVisualPayload(entry.calendarJson || entry.rawResult);
   const normalized = {
     id: entry.id || generateCalendarHistoryId(),
+    runNumber: Number.isFinite(visualsState.totalRunCount)
+      ? visualsState.totalRunCount
+      : undefined,
     timestamp: entry.timestamp || new Date().toISOString(),
     archetype: entry.archetype || '',
     seed:

web/style.css

@@ -1346,6 +1346,7 @@ body {
   flex-direction: column;
   gap: 4px;
   min-height: 0;
+  overflow: hidden;
 }
 
 .activity-balance-history--dense .activity-balance-history__stack {

web/ui/visuals/RadialUrchin.js

@@ -25,7 +25,8 @@ const SPEED_OPTIONS = [
 
 const HOVER_DELAY = 180;
 
-export const MAX_HISTORY_ENTRIES = 100;
+export const MAX_HISTORY_ROWS = 50;
+export const MAX_HISTORY_ENTRIES = MAX_HISTORY_ROWS;
 
 export function extractScheduleTimestamp(schedule) {
   if (!schedule || typeof schedule !== 'object') {
@@ -122,8 +123,7 @@ export function createBalanceHistoryEntry(schedule, options = {}) {
     return null;
   }
 
-  const previousRunNumber = Number.isFinite(options.runNumber) ? options.runNumber : 1;
-  const runNumber = previousRunNumber;
+  const runNumber = Number.isFinite(options.runNumber) ? options.runNumber : 1;
   const timestamp = extractScheduleTimestamp(schedule);
   const entry = {
     id: options.id || `${runNumber}-${Date.now()}`,
@@ -267,8 +267,9 @@ export class RadialUrchin {
     this.shareContainer = null;
     this.historyView = null;
     this.balanceHistory = [];
+    this.totalRunCount = 0;
     this.isHistoryOpen = false;
-    this.maxHistoryEntries = MAX_HISTORY_ENTRIES;
+    this.maxHistoryEntries = MAX_HISTORY_ROWS;
 
     this.handleResize = this.handleResize.bind(this);
     this.handlePointerMove = this.handlePointerMove.bind(this);
@@ -569,7 +570,7 @@ export class RadialUrchin {
     this.updateHistoryUi();
   }
 
-  setBalanceHistory(entries) {
+  setBalanceHistory(entries, totalRunCount) {
     const next = Array.isArray(entries) ? entries.slice(-this.maxHistoryEntries) : [];
     this.balanceHistory = next.map((entry) => ({
       ...entry,
@@ -580,10 +581,22 @@ export class RadialUrchin {
         ? entry.activities.map((activity) => ({ ...activity }))
         : [],
     }));
+    if (Number.isFinite(totalRunCount)) {
+      this.totalRunCount = totalRunCount;
+    } else if (this.balanceHistory.length > 0) {
+      const latest = this.balanceHistory[this.balanceHistory.length - 1];
+      if (latest && Number.isFinite(latest.runNumber)) {
+        this.totalRunCount = latest.runNumber;
+      } else {
+        this.totalRunCount = this.balanceHistory.length;
+      }
+    } else {
+      this.totalRunCount = 0;
+    }
     this.updateHistoryUi({ refreshEntries: true });
   }
 
-  appendBalanceHistoryEntry(entry) {
+  appendBalanceHistoryEntry(entry, totalRunCount) {
     if (!entry || typeof entry !== 'object') {
       return;
     }
@@ -596,32 +609,34 @@ export class RadialUrchin {
         ? entry.activities.map((activity) => ({ ...activity }))
         : [],
     };
-    const next = [...this.balanceHistory, normalized];
-    if (next.length > this.maxHistoryEntries) {
-      next.splice(0, next.length - this.maxHistoryEntries);
-    }
+    const next =
+      this.balanceHistory.length >= this.maxHistoryEntries
+        ? [...this.balanceHistory.slice(1), normalized]
+        : [...this.balanceHistory, normalized];
     this.balanceHistory = next;
+    if (Number.isFinite(totalRunCount)) {
+      this.totalRunCount = totalRunCount;
+    } else if (Number.isFinite(normalized.runNumber)) {
+      const previousTotal = Number.isFinite(this.totalRunCount) ? this.totalRunCount : 0;
+      this.totalRunCount = Math.max(previousTotal, normalized.runNumber);
+    } else {
+      const previousTotal = Number.isFinite(this.totalRunCount) ? this.totalRunCount : 0;
+      this.totalRunCount = previousTotal + 1;
+    }
     this.updateHistoryUi({ refreshEntries: true });
   }
 
   captureBalanceSnapshot(schedule, signature) {
-    const previous =
-      this.balanceHistory.length > 0
-        ? this.balanceHistory[this.balanceHistory.length - 1]
-        : null;
-    const runNumber =
-      (previous && Number.isFinite(previous.runNumber)
-        ? previous.runNumber
-        : this.balanceHistory.length) + 1;
+    const nextRunNumber = (Number.isFinite(this.totalRunCount) ? this.totalRunCount : 0) + 1;
     const entry = createBalanceHistoryEntry(schedule, {
-      runNumber,
+      runNumber: nextRunNumber,
       highContrast: this.state.highContrast,
       signature,
     });
     if (!entry) {
       return;
     }
-    this.appendBalanceHistoryEntry(entry);
+    this.appendBalanceHistoryEntry(entry, nextRunNumber);
   }
 
   getRunMetaSlot() {