fix(ai): stabilize backpressure deferral dedup key against volatile counters (#14156) (#14157)

* fix(ai): stabilize backpressure deferral dedup key against volatile counters (#14156)

The backpressure deferral log floods (~8% of orchestrator-log lines): recordDeferral dedups via deferralLogKeys, but the dedup key embeds the full reasonText, and memorySummaryBackfill emits 'pending-memory-minisummary:${backlog}' whose count changes every poll — so the key churns and the dedup never fires while kbSync holds the heavy-maintenance lease for hours.

Strip a trailing ':<digits>' from the dedup key only; the full reasonText (with count) stays in the log message + the recordTaskOutcome payload. Recurring deferrals now collapse to one log per episode (clearDeferralLogState still re-logs a new episode). No change to deferral/lease behavior. Unit: 4 changing-counter polls -> 1 log, post-clear -> re-logs; 28/28 specs pass.

* refactor(ai): key deferral dedup on stable (task, blocker, reasonCode), not regex-stripped reasonText (#14156)

Follow-up to the #14157 depth-floor point (broad trailing-number normalization also collapsed constant interval-style reasons like periodic-sync:1800000). Drop the volatile reasonText from the dedup key entirely and key on the deferred task + blocker + reasonCode — stable, declared identifiers. The deferred task's source-class is already implied by taskName and the count is volatile noise, so the key gains no distinction from reasonText. Full reasonText stays in the log message + the recordTaskOutcome payload. 28/28 specs pass.

---------

Co-authored-by: tobiu <tobiasuhlig78@gmail.com>

Author: neo-opus-ada

ai/daemons/orchestrator/services/MaintenanceBackpressureService.mjs

@@ -237,9 +237,14 @@ export function recordDeferral({
 }) {
     const isLeaseHeld = reasonCode === 'heavy-maintenance-lease-held';
     const holderOwner = holdingLease?.owner || 'unknown';
-    const dedupKey    = isLeaseHeld
-        ? `${taskName}:lease-held-by-${holderOwner}:${reasonText}`
-        : `${taskName}:${blockingTaskName}:${reasonText}`;
+    // Dedup on STABLE identifiers only — the deferred task, its blocker, and the deferral reasonCode —
+    // never the volatile `reasonText`: its `:<count>` / `:<interval>` suffix changes every poll and its
+    // source-class is already implied by `taskName`, so including it churns the key (the dedup never
+    // fires) without adding a real distinction. The full reasonText (with count) stays in the log
+    // message + the recordTaskOutcome payload below.
+    const dedupKey = isLeaseHeld
+        ? `${taskName}:lease-held-by-${holderOwner}`
+        : `${taskName}:${blockingTaskName}:${reasonCode}`;
 
     if (!deferralLogKeys.has(dedupKey)) {
         const taskLabel = taskDefinitions?.[taskName]?.label || taskName;

test/playwright/unit/ai/daemons/orchestrator/services/MaintenanceBackpressureService.spec.mjs

@@ -289,6 +289,46 @@ test.describe('Neo.ai.daemons.orchestrator.services.MaintenanceBackpressureServi
         expect(outcomeCalls[0].payload.deferredAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
     });
 
+    test('recordDeferral dedupes across a CHANGING reasonText counter (the volatile-backlog flood fix)', () => {
+        const deferralLogKeys = new Set();
+        const logCalls        = [];
+        const writeLog        = (level, message) => logCalls.push({level, message});
+        const taskDefinitions = {kbSync: {label: 'KB sync'}, 'memory-summary-backfill': {label: 'memory miniSummary backfill'}};
+
+        // The memorySummaryBackfill backlog counter changes every poll. The dedup key is keyed on
+        // (task, blocker, reasonCode) — NOT the volatile reasonText — so the changing count never
+        // churns it and the deferral logs once per episode (not the live ~8%-of-lines flood).
+        for (const backlog of [47, 48, 49, 50]) {
+            recordDeferral({
+                deferralLogKeys,
+                taskName        : 'memory-summary-backfill',
+                reasonCode      : 'heavy-maintenance-backpressure',
+                reasonText      : `pending-memory-minisummary:${backlog}`,
+                blockingTaskName: 'kbSync',
+                taskDefinitions,
+                writeLog
+            });
+        }
+
+        // Four polls with a changing counter → ONE log line (the dedup now holds on the stable key).
+        expect(logCalls.length).toBe(1);
+        expect(logCalls[0].message).toContain('Deferring memory miniSummary backfill');
+        expect(logCalls[0].message).toContain('pending-memory-minisummary:47'); // first episode's live count stays in the message
+
+        // A new deferral episode after the prior one clears → re-logs exactly once.
+        clearDeferralLogState({deferralLogKeys, taskName: 'memory-summary-backfill'});
+        recordDeferral({
+            deferralLogKeys,
+            taskName        : 'memory-summary-backfill',
+            reasonCode      : 'heavy-maintenance-backpressure',
+            reasonText      : 'pending-memory-minisummary:51',
+            blockingTaskName: 'kbSync',
+            taskDefinitions,
+            writeLog
+        });
+        expect(logCalls.length).toBe(2);
+    });
+
     test('recordDeferral (cross-daemon lease-held) uses holdingLease owner in key + payload', () => {
         const deferralLogKeys = new Set();
         const logCalls        = [];