src/s-z/VolatilityStop/VolatilityStop.StreamHub.cs (1)

198-202: ⚠️ Potential issue | 🟡 Minor

Update XML documentation to reflect parameter change.

The summary references "timestamp" but the parameter is now int restoreIndex. This should be updated for consistency.

📝 Proposed fix

 /// <summary>
-/// Restores the Volatility Stop state up to the specified timestamp.
+/// Restores the Volatility Stop state up to the specified index.
 /// </summary>
 /// <inheritdoc/>
 protected override void RollbackState(int restoreIndex)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/s-z/VolatilityStop/VolatilityStop.StreamHub.cs` around lines 198 - 202,
The XML doc comment for VolatilityStop.StreamHub.cs's protected override method
RollbackState(int restoreIndex) incorrectly mentions "timestamp"; update the
<summary> and any related XML tags to describe restoring state up to the
provided restoreIndex parameter (or simply "Restores the Volatility Stop state
to the specified restoreIndex") and update the <param> tag name/details to match
the parameter restoreIndex so the documentation is consistent with the method
signature.

src/m-r/MaEnvelopes/MaEnvelopes.StreamHub.cs (1)

367-385: ⚠️ Potential issue | 🟠 Major

Rollback state reset is incomplete for DEMA/TEMA continuity.

On Line 369, RollbackState(int restoreIndex) clears EMA layer fields but does not reconstruct them to restoreIndex - 1. After late edits, recalculation can resume with Cache[index - 1].Centerline present while lastEma* is still NaN, which can produce incorrect DEMA/TEMA values. Please replay EMA layers up to restoreIndex - 1 (exclusive rollback point) during rollback before recomputation starts.

Suggested direction

protected override void RollbackState(int restoreIndex)
{
-    if (restoreIndex >= lookbackPeriods)
-    {
-        if (movingAverageType == MaType.DEMA)
-        {
-            lastEma1 = lastEma2 = double.NaN;
-        }
-        else if (movingAverageType == MaType.TEMA)
-        {
-            lastEma3 = lastEma4 = lastEma5 = double.NaN;
-        }
-    }
-    else
-    {
-        lastEma1 = lastEma2 = lastEma3 = lastEma4 = lastEma5 = double.NaN;
-    }
+    lastEma1 = lastEma2 = lastEma3 = lastEma4 = lastEma5 = double.NaN;
+    if (restoreIndex <= 0) return;
+    if (movingAverageType is not MaType.DEMA and not MaType.TEMA) return;
+
+    // replay state to restoreIndex - 1 so incremental updates restart from valid EMA layers
+    ReplayEmaLayerState(restoreIndex - 1);
}

Based on learnings: Applies to src/**/*.StreamHub.cs : Override RollbackState(...) when maintaining stateful fields in StreamHub indicators, replaying up to targetIndex - 1 (exclusive).

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/m-r/MaEnvelopes/MaEnvelopes.StreamHub.cs` around lines 367 - 385,
RollbackState currently clears EMA layer fields (lastEma1..lastEma5) which
leaves them NaN when Cache[restoreIndex - 1].Centerline exists; fix by replaying
EMA layers up to the index before the rollback point: inside RollbackState, when
restoreIndex < lookbackPeriods (or generally when cached centerlines exist),
iterate from the earliest cached index needed up to restoreIndex - 1 and update
the EMA chain using the same per-tick EMA update logic so lastEma1/2/3/4/5
reflect the state at restoreIndex - 1; keep the existing branch for
movingAverageType == MaType.DEMA and MaType.TEMA to replay only the required EMA
layers, and only set fields to double.NaN when there is no cached history to
reconstruct.

src/s-z/Trix/Trix.StreamHub.cs (1)

92-98: ⚠️ Potential issue | 🟠 Major

Rollback boundary is off for seeded TRIX state and can produce incorrect post-rollback values.

At Line 92, restoreIndex >= LookbackPeriods skips restoration when the preserved point is exactly the seed index (LookbackPeriods - 1). The next processed item then reinitializes instead of continuing incrementally.

Proposed fix

-        if (restoreIndex >= LookbackPeriods)
+        if (restoreIndex >= LookbackPeriods - 1)
         {
             TrixResult prior = Cache[restoreIndex];
             lastEma1 = prior.Ema1;
             lastEma2 = prior.Ema2;
-            lastEma3 = prior.Ema3 ?? double.NaN;
+            // At seed boundary, Ema3 output can be null while internal EMA state exists.
+            lastEma3 = prior.Ema3 ?? prior.Ema2;
         }

Based on learnings: "In StreamHub RollbackState implementations, boundary condition checks vary by algorithm requirements: patterns that need prior period values ... use stricter boundary checks."

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/s-z/Trix/Trix.StreamHub.cs` around lines 92 - 98, The rollback boundary
skips restoring the seeded TRIX state when restoreIndex equals the seed index
(LookbackPeriods - 1); change the guard in the rollback block from "restoreIndex
>= LookbackPeriods" to "restoreIndex >= LookbackPeriods - 1" so the code
restores the cached TrixResult for that seed index (use Cache[restoreIndex] to
set lastEma1/lastEma2/lastEma3 as before) and preserve incremental continuation
instead of reinitializing; update the condition around restoreIndex,
LookbackPeriods, Cache, and TrixResult accordingly.

src/a-d/ConnorsRsi/ConnorsRsi.StreamHub.cs (1)

271-276: ⚠️ Potential issue | 🟠 Major

Rollback replay misses the index-0 gain seed used in live processing.

ToIndicator() seeds gainBuffer at index 0, but RollbackState() does not. That can shift the percent-rank window after early rollbacks and produce mismatched results.

🔧 Suggested fix

         if (i == 0)
         {
             prevValue = value;
             streak = 0;
             streakBuffer.Add(0);
+
+            // Keep rollback state consistent with ToIndicator() at index 0
+            double gain = double.IsNaN(value) || value <= 0
+                ? double.NaN
+                : 0d;
+            gainBuffer.Enqueue(gain);
         }
         else
         {
             // Calculate streak
             if (double.IsNaN(value) || double.IsNaN(prevValue))
@@
             gainBuffer.Enqueue(gain);
             if (gainBuffer.Count > RankPeriods + 1)
             {
                 gainBuffer.Dequeue();
             }

Based on learnings: streaming hubs should rebuild from mutation points and realign with full-history Series results after inserts/removals/revisions.

Also applies to: 360-369

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/a-d/ConnorsRsi/ConnorsRsi.StreamHub.cs` around lines 271 - 276,
RollbackState() currently fails to seed the index-0 gain used by ToIndicator(),
causing window alignment drift after early rollbacks; update RollbackState() to
initialize the gainBuffer (and any related streakBuffer/gain seed logic) at
index 0 exactly as ToIndicator() does so the percent-rank window matches live
processing, and apply the same fix to the related block around the 360-369
region to ensure rebuilds from mutation points realign full-history Series
results after inserts/removals/revisions.

src/s-z/Slope/Slope.StreamHub.cs (1)

142-153: ⚠️ Potential issue | 🟠 Major

Restore partial buffer even before warmup threshold.

Line [142] exits when restoreIndex < LookbackPeriods - 1, which leaves buffer empty. After rollback on early history edits, replay resumes at restoreIndex + 1, so the first calculable window is built from too few points and yields incorrect slope/intercept (downstream EPMA is affected too).

💡 Suggested fix

-        if (restoreIndex < LookbackPeriods - 1)
+        if (restoreIndex < 0)
         {
             return;
         }

         // Rebuild buffer from cache up to restoreIndex
         int startIdx = Math.Max(0, restoreIndex - LookbackPeriods + 1);

         for (int p = startIdx; p <= restoreIndex; p++)
         {
-            buffer.Enqueue(ProviderCache[p].Value);
+            buffer.Update(LookbackPeriods, ProviderCache[p].Value);
         }

Based on learnings: when late inserts/removals occur, StreamHub state must rebuild from provider cache so results realign with full-series output.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/s-z/Slope/Slope.StreamHub.cs` around lines 142 - 153, The early return
when restoreIndex < LookbackPeriods - 1 leaves buffer empty after a rollback;
change the logic in Slope.StreamHub so you always rebuild the buffer from
ProviderCache up to restoreIndex (compute startIdx = Math.Max(0, restoreIndex -
LookbackPeriods + 1) and enqueue ProviderCache[p].Value for p in
startIdx..restoreIndex) instead of returning early—this ensures the partial
window is reconstructed before replay resumes so slope/intercept calculations
align with full-series output.

src/s-z/WilliamsR/WilliamsR.StreamHub.cs (1)

95-100: ⚠️ Potential issue | 🟡 Minor

Update XML summary to match index-based rollback contract.

Line 96 still says “specified timestamp”, but this override now restores by restoreIndex. Please align wording to avoid IntelliSense confusion.

✏️ Proposed doc fix

 /// <summary>
-/// Restores the rolling window state up to the specified timestamp.
+/// Restores the rolling window state up to the specified index.
 /// Clears and rebuilds rolling windows from ProviderCache for Add/Remove operations.
 /// </summary>

As per coding guidelines: "Update XML documentation for changed public APIs."

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/s-z/WilliamsR/WilliamsR.StreamHub.cs` around lines 95 - 100, The XML
summary for the RollbackState override still references a "specified timestamp"
but the method signature is RollbackState(int restoreIndex); update the XML
documentation on WilliamsR.StreamHub.RollbackState(int restoreIndex) to describe
an index-based rollback (e.g., "Restores the rolling window state up to the
specified restore index") and ensure any <param> or remarks mention restoreIndex
rather than timestamp so IntelliSense reflects the index-based contract.

src/m-r/RollingPivots/RollingPivots.StreamHub.cs (1)

117-120: ⚠️ Potential issue | 🟡 Minor

Update rollback XML docs to index-based terminology.

The summary still says “timestamp”, but the override now restores by index (restoreIndex), which is misleading.

✏️ Suggested doc fix

 /// <summary>
-/// Restores the rolling window and offset buffer state up to the specified timestamp.
+/// Restores the rolling window and offset buffer state up to the specified index.
 /// Clears and rebuilds state from ProviderCache for Add/Remove operations.
 /// </summary>

As per coding guidelines, "Update XML documentation for changed public APIs".

Also applies to: 122-122

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/m-r/RollingPivots/RollingPivots.StreamHub.cs` around lines 117 - 120,
Update the XML documentation for the override that restores state to use
index-based terminology instead of "timestamp": change the <summary> to say it
"Restores the rolling window and offset buffer state up to the specified restore
index" and update any parameter/docs that reference "timestamp" to reference the
parameter name restoreIndex (also update the other occurrence around line 122)
so the docs match the method signature and behavior in
RollingPivots.StreamHub.cs.

src/s-z/Stoch/Stoch.StreamHub.cs (1)

298-302: ⚠️ Potential issue | 🟡 Minor

Stale rollback summary wording (timestamp vs restoreIndex).

Please align the XML summary with the new int restoreIndex signature.

✏️ Proposed doc fix

-    /// Restores the rolling window state up to the specified timestamp.
+    /// Restores the rolling window state up to the specified restore index.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/s-z/Stoch/Stoch.StreamHub.cs` around lines 298 - 302, The XML doc summary
for the overridden method protected override void RollbackState(int
restoreIndex) is stale (references "timestamp"); update the <summary> (and any
<param> tag) to reference restoreIndex and its meaning (e.g., "Restores the
rolling window state up to the specified restore index" and explain that
restoreIndex is the index in the rolling window to which state will be restored)
so the documentation matches the new int restoreIndex signature and behavior.

src/e-k/Ichimoku/Ichimoku.StreamHub.cs (1)

220-224: ⚠️ Potential issue | 🟡 Minor

Update XML summary to match index-based rollback semantics.

The summary still says “specified timestamp” while the method now accepts restoreIndex.

✏️ Proposed doc fix

-    /// Restores the rolling window states up to the specified timestamp.
+    /// Restores the rolling window states up to the specified restore index.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/e-k/Ichimoku/Ichimoku.StreamHub.cs` around lines 220 - 224, Update the
XML summary for the overridden RollbackState method to reflect that it restores
rolling window state up to a given index (restoreIndex) rather than a timestamp;
locate the protected override void RollbackState(int restoreIndex) declaration
and change the <summary> and any text referencing "timestamp" to describe
index-based rollback semantics (e.g., "Restores the rolling window states up to
the specified index (restoreIndex)"), keeping the <inheritdoc/> tag as
appropriate.

src/s-z/Smi/Smi.StreamHub.cs (1)

152-156: ⚠️ Potential issue | 🟡 Minor

Rollback summary text should be updated to index semantics.

The XML comment still refers to “timestamp” while this override now takes restoreIndex.

✏️ Proposed doc fix

-    /// Restores the SMI calculation state up to the specified timestamp.
+    /// Restores the SMI calculation state up to the specified restore index.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/s-z/Smi/Smi.StreamHub.cs` around lines 152 - 156, Update the XML
documentation for the override RollbackState(int restoreIndex) to refer to
"restore index" (or index-based semantics) instead of "timestamp" — change the
<summary> text to something like "Restores the SMI calculation state up to the
specified restore index" and ensure any parameter/inheritdoc remarks reflect the
rename from timestamp to restoreIndex so the doc matches the method signature.

src/a-d/Cci/Cci.StreamHub.cs (1)

44-49: ⚠️ Potential issue | 🟡 Minor

Rollback XML summary still references timestamp semantics.

The summary should reflect restoreIndex-based behavior now.

✏️ Proposed doc fix

-    /// Restores the CciList state up to the specified timestamp.
+    /// Restores the CciList state up to the specified restore index.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/a-d/Cci/Cci.StreamHub.cs` around lines 44 - 49, Update the XML summary on
the protected override RollbackState(int restoreIndex) method to remove
"timestamp" wording and describe restoreIndex-based behavior: state is restored
up to the specified restoreIndex, clearing and rebuilding _cciList from
ProviderCache to replay Add/Remove operations; ensure the param name
restoreIndex is reflected in the summary or add a <param> tag mentioning
restoreIndex if appropriate and remove any references to timestamps.

src/s-z/Slope/Slope.StreamHub.cs (1)

142-153: ⚠️ Potential issue | 🔴 Critical

Pre-warmup rollback drops required buffer history.

At Line 142, returning when restoreIndex < LookbackPeriods - 1 skips rebuilding preserved prefix values. Because ToIndicator updates buffer before warmup gating, replay after an early historical mutation can reach calculable indices with an underfilled buffer and produce wrong regression statistics.

💡 Proposed fix

-        if (restoreIndex < LookbackPeriods - 1)
+        if (restoreIndex < 0)
         {
             return;
         }

         // Rebuild buffer from cache up to restoreIndex
         int startIdx = Math.Max(0, restoreIndex - LookbackPeriods + 1);

         for (int p = startIdx; p <= restoreIndex; p++)
         {
             buffer.Enqueue(ProviderCache[p].Value);
         }

Based on learnings: “When streaming hubs receive late inserts or revisions (Insert/RemoveAt/Add with same timestamp), they should rebuild from that point in time using the provider cache as the source and realign to match what the series implementation would produce on the full history.”

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/s-z/Slope/Slope.StreamHub.cs` around lines 142 - 153, The early return
when restoreIndex < LookbackPeriods - 1 drops preserved prefix values and causes
underfilled buffer; remove that return and always rebuild the buffer from the
provider cache starting at startIdx = Math.Max(0, restoreIndex - LookbackPeriods
+ 1) by enqueuing ProviderCache[p].Value for p in that range (the existing
loop), ensuring buffer contains the same prefix the series implementation would
have; after rebuilding the buffer, realign/replay from restoreIndex so
ToIndicator sees the same history (i.e., perform the replay/update step that
follows this rebuild) so warmup gating behaves correctly.

src/s-z/Vortex/Vortex.StreamHub.cs (1)

110-114: ⚠️ Potential issue | 🟡 Minor

Rollback XML doc still references timestamp.

Please update the summary to match RollbackState(int restoreIndex).

✏️ Suggested doc fix

-    /// Restores the buffer state up to the specified timestamp.
+    /// Restores the buffer state up to the specified index.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/s-z/Vortex/Vortex.StreamHub.cs` around lines 110 - 114, The XML summary
for the method protected override void RollbackState(int restoreIndex)
incorrectly mentions a timestamp; update the <summary> to describe restoring the
buffer state up to or using the provided restore index (e.g., "Restores the
buffer state up to the specified restore index.") so the doc matches the
RollbackState(int restoreIndex) signature and semantics; update any
<inheritdoc/> usage if needed to ensure the summary reflects the restoreIndex
parameter for RollbackState.

src/a-d/Cmo/Cmo.StreamHub.cs (1)

66-71: ⚠️ Potential issue | 🟡 Minor

Update XML summary wording to index-based terminology.

The summary still says “specified timestamp” while the method now accepts restoreIndex.

✏️ Suggested doc fix

-    /// Restores the tick buffer state up to the specified timestamp.
+    /// Restores the tick buffer state up to the specified index.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/a-d/Cmo/Cmo.StreamHub.cs` around lines 66 - 71, Update the XML
documentation for the RollbackState method to use index-based terminology
(mentioning restoreIndex) instead of "specified timestamp"; update the summary
to say it restores the tick buffer state up to the specified restore index and
that it clears and rebuilds _tickBuffer from ProviderCache for Add/Remove
operations, and if present adjust any <param> or <inheritdoc/> comments to
reference the restoreIndex parameter and index-based semantics.

src/s-z/Stc/Stc.StreamHub.cs (1)

159-181: ⚠️ Potential issue | 🟡 Minor

Raw %K rollback prefill can diverge from ToIndicator with NaN gaps.

This prefill path can produce a numeric rawAtP even when fewer than CyclePeriods valid MACD values exist, while ToIndicator would keep it NaN. That can skew restored _rawKBuffer state.

🛠️ Suggested parity fix

                 int rStart = Math.Max(0, p + 1 - CyclePeriods);
                 double hh = double.NegativeInfinity;
                 double ll = double.PositiveInfinity;
+                int validCount = 0;

                 for (int r = rStart; r <= p; r++)
                 {
                     MacdResult macdAtR = ProviderCache[r];
                     double macdValue = macdAtR.Macd ?? double.NaN;
+                    if (double.IsNaN(macdValue))
+                    {
+                        continue;
+                    }
+
+                    validCount++;

                     if (macdValue > hh)
                     {
                         hh = macdValue;
                     }

                     if (macdValue < ll)
                     {
                         ll = macdValue;
                     }
                 }

                 MacdResult macdAtP = ProviderCache[p];
                 double macdAtPValue = macdAtP.Macd ?? double.NaN;
-                double rawAtP = (hh - ll) != 0 ? 100 * (macdAtPValue - ll) / (hh - ll) : 0;
+                double rawAtP = (!double.IsNaN(macdAtPValue) && validCount >= CyclePeriods)
+                    ? ((hh - ll) != 0 ? 100d * (macdAtPValue - ll) / (hh - ll) : 0d)
+                    : double.NaN;
                 _rawKBuffer.Enqueue(rawAtP);

As per coding guidelines: "Allow natural propagation of NaN values through calculations; never reject NaN inputs."

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/s-z/Stc/Stc.StreamHub.cs` around lines 159 - 181, The rollback prefill
computes rawAtP even when the sliding window contains NaN MACD entries, causing
divergence from ToIndicator; modify the logic in the block using CyclePeriods,
ProviderCache and MacdResult so that you count finite (non-NaN) MACD values
across rStart..p and if that count is less than CyclePeriods set rawAtP =
double.NaN (instead of computing 100*(macdAtPValue-ll)/(hh-ll)), then enqueue
that NaN into _rawKBuffer so the restored state matches ToIndicator behavior.