@caupulican/pi-adaptative 0.80.72 → 0.80.74

package/dist/modes/interactive/interactive-mode.js

@@ -408,6 +408,17 @@ export class InteractiveMode {
     pendingClipboardImages = [];
     clipboardImageCounter = 0;
     loadingAnimation = undefined;
+    // Native-reflection debounce: prevents back-to-back/overlapping background reflection passes (cost
+    // guard). `_nativeReflectionInFlight` blocks a second pass while one runs; `_lastNativeReflectionAt`
+    // enforces a minimum gap between passes. A debounce-skipped turn's text is BUFFERED in
+    // `_pendingReflectionText` (not dropped) and folded into the next pass, so no corrective feedback is
+    // lost — reflection sees only the current turn's messages, so dropping a skipped turn would lose its
+    // learning entirely (bug #29).
+    _nativeReflectionInFlight = false;
+    _lastNativeReflectionAt = 0;
+    _pendingReflectionText = [];
+    static NATIVE_REFLECTION_MIN_INTERVAL_MS = 45_000;
+    static PENDING_REFLECTION_MAX_CHARS = 12_000;
     workingMessage = undefined;
     workingVisible = true;
     workingIndicatorOptions = undefined;
@@ -4831,6 +4842,26 @@ export class InteractiveMode {
         const thinkingLevel = settings.thinkingLevel ?? "low";
         return { model, thinkingLevel };
     }
+    /** Buffer a debounce-skipped turn's text so its learning is folded into the next pass (bug #29). */
+    _bufferPendingReflection(text) {
+        const t = text.trim();
+        if (!t)
+            return;
+        this._pendingReflectionText.push(t);
+        // Bound the buffer so a long skipped streak can't grow unbounded; drop oldest past the budget
+        // (the most recent corrections matter most).
+        let total = this._pendingReflectionText.reduce((n, s) => n + s.length + 1, 0);
+        while (this._pendingReflectionText.length > 1 && total > InteractiveMode.PENDING_REFLECTION_MAX_CHARS) {
+            total -= (this._pendingReflectionText.shift()?.length ?? 0) + 1;
+        }
+    }
+    _drainPendingReflection() {
+        if (this._pendingReflectionText.length === 0)
+            return "";
+        const joined = this._pendingReflectionText.join("\n");
+        this._pendingReflectionText = [];
+        return joined;
+    }
     maybeRunNativeReflection(messages) {
         if (!this.isNativeReflectionEnabled())
             return;
@@ -4855,6 +4886,20 @@ export class InteractiveMode {
             .map((m) => `${String(m.role ?? "")}: ${this.getAgentMessagePlainText(m)}`.trim())
             .filter(Boolean)
             .join("\n");
+        // Debounce (cost guard): never run two background reflection passes at once, and never start one
+        // within the min interval of the last — a multi-turn correction session would otherwise spawn
+        // overlapping passes that re-reason the same task. A skipped turn is NOT dropped: its text is
+        // buffered and folded into the next pass, so the corrective feedback is still learned (bug #29).
+        const now = Date.now();
+        const debounced = this._nativeReflectionInFlight ||
+            now - this._lastNativeReflectionAt < InteractiveMode.NATIVE_REFLECTION_MIN_INTERVAL_MS;
+        if (debounced) {
+            this._bufferPendingReflection(recentTurnText);
+            return;
+        }
+        // Fold any buffered (previously debounced) turns into this pass so nothing learned is lost.
+        const pending = this._drainPendingReflection();
+        const reflectionText = pending ? `${pending}\n${recentTurnText}` : recentTurnText;
         // Stable per-turn id so a duplicate scheduling/retry can't double-count the reflection cost.
         // Messages carry no `id` on the real path (only timestamps), so derive the key from the last
         // message's timestamp + the turn size — present on every real turn, stable across a retry of the
@@ -4865,16 +4910,21 @@ export class InteractiveMode {
         // User-configurable reflection model + thinking (auto-learn settings), restricted to AVAILABLE
         // (authed) models — falls back to the session model when unset or unavailable.
         const { model, thinkingLevel } = this._resolveReflectionModel(settings);
+        this._nativeReflectionInFlight = true;
+        this._lastNativeReflectionAt = now;
         void this.session
             .runReflectionPass({
             signals: { trigger, toolCallCount, hadCorrection, contextHeadroomPct, usefulLately: 0 },
-            recentTurnText,
+            recentTurnText: reflectionText,
             reportId,
             model,
             thinkingLevel,
         })
             .catch(() => {
             // best-effort background learning; never disrupt the session
+        })
+            .finally(() => {
+            this._nativeReflectionInFlight = false;
         });
     }
     maybeStartAutoLearn() {