Promote main -> release (conflict-resolved)

app/src/components/intelligence/MemoryTreeStatusPanel.test.tsx

@@ -22,14 +22,22 @@ import {
 const mockPipelineStatus = vi.fn();
 const mockSetEnabled = vi.fn();
 const mockSyncStatusList = vi.fn();
+const mockRetryFailed = vi.fn();
 // #5324: the panel now navigates (budget CTA) and dispatches (escalating the
 // blocking cause to the shell-mounted UserErrorCenter). Stub both so the
 // suite keeps rendering the panel bare, without a Router or a Redux store.
 const mockNavigate = vi.fn();
 const mockDispatch = vi.fn();
+// Analytics is a consent-gated side effect that reaches into the core-state
+// snapshot; stub it so the panel renders bare and the retry-success path can be
+// asserted without a real analytics pipeline.
+const mockTrackAnalyticsEvent = vi.fn();
 
 vi.mock('react-router-dom', () => ({ useNavigate: () => mockNavigate }));
 vi.mock('../../store/hooks', () => ({ useAppDispatch: () => mockDispatch }));
+vi.mock('../analytics', () => ({
+  trackAnalyticsEvent: (...args: unknown[]) => mockTrackAnalyticsEvent(...args),
+}));
 
 vi.mock('../../utils/tauriCommands', async importOriginal => {
   // Inherit everything else (types, sibling wrappers) verbatim so the panel
@@ -41,6 +49,7 @@ vi.mock('../../utils/tauriCommands', async importOriginal => {
     memoryTreePipelineStatus: (...args: unknown[]) => mockPipelineStatus(...args),
     memoryTreeSetEnabled: (...args: unknown[]) => mockSetEnabled(...args),
     memorySyncStatusList: (...args: unknown[]) => mockSyncStatusList(...args),
+    memoryTreeRetryFailed: (...args: unknown[]) => mockRetryFailed(...args),
   };
 });
 
@@ -73,6 +82,8 @@ describe('<MemoryTreeStatusPanel />', () => {
     mockPipelineStatus.mockReset();
     mockSetEnabled.mockReset();
     mockSyncStatusList.mockReset();
+    mockRetryFailed.mockReset();
+    mockTrackAnalyticsEvent.mockReset();
     mockSyncStatusList.mockResolvedValue([]); // default: empty, harmless to existing tests
   });
 
@@ -550,6 +561,125 @@ describe('<MemoryTreeStatusPanel />', () => {
       expect(mockDispatch).toHaveBeenCalled();
     });
   });
+
+  // ── Retry-failed affordance ─────────────────────────────────────────────
+
+  it('offers a retry when jobs are parked in failed', async () => {
+    mockPipelineStatus.mockResolvedValue(
+      payload({
+        status: 'error',
+        reason: '29 unrecoverable failure(s) need action',
+        pipeline_jobs: { ready: 0, running: 0, failed: 29 },
+      })
+    );
+    render(<MemoryTreeStatusPanel />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('memory-tree-retry-failed')).toBeInTheDocument();
+    });
+  });
+
+  /**
+   * The affordance keys off the failed-job counter, not off the blocking-cause
+   * banner. A failure the pipeline has already worked past no longer surfaces a
+   * remediation (the core withholds a superseded cause), but its rows still sit
+   * in `failed` and still need clearing — so the button must be reachable with
+   * no banner on screen. Without this the user is left in a permanent `error`
+   * state with no way out, which is the bug.
+   */
+  it('offers the retry even when no blocking cause is surfaced', async () => {
+    mockPipelineStatus.mockResolvedValue(
+      payload({
+        status: 'error',
+        reason: '29 unrecoverable failure(s) need action',
+        pipeline_jobs: { ready: 0, running: 0, failed: 29 },
+        first_blocking_cause: null,
+      })
+    );
+    render(<MemoryTreeStatusPanel />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('memory-tree-retry-failed')).toBeInTheDocument();
+    });
+    expect(screen.queryByTestId('memory-tree-blocking-cause')).not.toBeInTheDocument();
+  });
+
+  it('hides the retry when nothing has failed', async () => {
+    mockPipelineStatus.mockResolvedValue(payload({ status: 'running' }));
+    render(<MemoryTreeStatusPanel />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('memory-tree-status-label')).toHaveTextContent(/running/i);
+    });
+    expect(screen.queryByTestId('memory-tree-retry-failed')).not.toBeInTheDocument();
+  });
+
+  it('requeues the failed jobs, reports the count, and re-fetches', async () => {
+    mockPipelineStatus.mockResolvedValue(
+      payload({
+        status: 'error',
+        reason: '29 unrecoverable failure(s) need action',
+        pipeline_jobs: { ready: 0, running: 0, failed: 29 },
+      })
+    );
+    mockRetryFailed.mockResolvedValue({ requeued: 29 });
+    const onToast = vi.fn();
+    render(<MemoryTreeStatusPanel onToast={onToast} />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('memory-tree-retry-failed')).toBeInTheDocument();
+    });
+    const callsBefore = mockPipelineStatus.mock.calls.length;
+    await act(async () => {
+      fireEvent.click(screen.getByTestId('memory-tree-retry-failed'));
+    });
+
+    expect(mockRetryFailed).toHaveBeenCalledTimes(1);
+    // Successful domain outcome is tracked with the privacy-safe count only.
+    expect(mockTrackAnalyticsEvent).toHaveBeenCalledWith('memory_tree_retry_succeeded', {
+      count: 29,
+    });
+    await waitFor(() => {
+      expect(onToast).toHaveBeenCalledWith(
+        expect.objectContaining({ type: 'success', message: expect.stringContaining('29') })
+      );
+    });
+    // Successful domain outcome is tracked with a privacy-safe count only.
+    expect(mockTrackAnalyticsEvent).toHaveBeenCalledWith('memory_tree_retry_succeeded', {
+      count: 29,
+    });
+    await waitFor(() => {
+      expect(mockPipelineStatus.mock.calls.length).toBeGreaterThan(callsBefore);
+    });
+  });
+
+  it('surfaces an error toast when the requeue fails', async () => {
+    mockPipelineStatus.mockResolvedValue(
+      payload({
+        status: 'error',
+        reason: '29 unrecoverable failure(s) need action',
+        pipeline_jobs: { ready: 0, running: 0, failed: 29 },
+      })
+    );
+    mockRetryFailed.mockRejectedValue(new Error('UNIQUE constraint failed'));
+    const onToast = vi.fn();
+    render(<MemoryTreeStatusPanel onToast={onToast} />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('memory-tree-retry-failed')).toBeInTheDocument();
+    });
+    await act(async () => {
+      fireEvent.click(screen.getByTestId('memory-tree-retry-failed'));
+    });
+
+    await waitFor(() => {
+      expect(onToast).toHaveBeenCalledWith(
+        expect.objectContaining({ type: 'error', message: 'UNIQUE constraint failed' })
+      );
+    });
+    // The button must stay usable so a transient failure is not a dead end.
+    expect(screen.getByTestId('memory-tree-retry-failed')).not.toBeDisabled();
+  });
 });
 
 describe('integration health helpers', () => {

app/src/components/intelligence/MemoryTreeStatusPanel.tsx

@@ -31,8 +31,10 @@ import {
   type MemorySyncStatusRow,
   memoryTreePipelineStatus,
   type MemoryTreePipelineStatus,
+  memoryTreeRetryFailed,
   memoryTreeSetEnabled,
 } from '../../utils/tauriCommands';
+import { trackAnalyticsEvent } from '../analytics';
 import Button from '../ui/Button';
 
 /** Translator function shape exposed by `useT()`. */
@@ -338,6 +340,7 @@ export function MemoryTreeStatusPanel({ onToast }: MemoryTreeStatusPanelProps) {
   const dispatch = useAppDispatch();
   const { status, integrations, loading, error, refresh } = useMemoryTreeStatus();
   const [toggleBusy, setToggleBusy] = useState(false);
+  const [retryBusy, setRetryBusy] = useState(false);
 
   // #002 (FR-004): the single first blocking cause. Prefer the explicit
   // `first_blocking_cause`; fall back to the active degradation cause so older
@@ -376,6 +379,46 @@ export function MemoryTreeStatusPanel({ onToast }: MemoryTreeStatusPanelProps) {
     }
   }, [status, toggleBusy, refresh, onToast, t]);
 
+  /**
+   * Requeue every terminally-failed job.
+   *
+   * An unrecoverable failure (auth, budget, dimension mismatch) is terminal by
+   * design — the worker never retries it — so a batch that failed under a
+   * since-fixed config stays parked forever and pins this panel on `error`.
+   * The `memory_tree_retry_failed` RPC existed for exactly this, but had no
+   * caller anywhere in the app, leaving the user with a permanent error state
+   * and no way to clear it.
+   */
+  const handleRetryFailed = useCallback(async () => {
+    if (retryBusy) {
+      console.debug('[ui-flow][memory-tree-status] retryFailed: skipped busy=true');
+      return;
+    }
+    console.debug('[ui-flow][memory-tree-status] retryFailed: entry');
+    setRetryBusy(true);
+    console.debug('[ui-flow][memory-tree-status] retryFailed: busy=true rpc:start');
+    try {
+      const { requeued } = await memoryTreeRetryFailed();
+      console.debug('[ui-flow][memory-tree-status] retryFailed: rpc:ok requeued=%d', requeued);
+      // Record the successful domain outcome (not just the click). Privacy-safe:
+      // a non-identifying count only, no ids or user text.
+      trackAnalyticsEvent('memory_tree_retry_succeeded', { count: requeued });
+      onToast?.({
+        type: 'success',
+        title: t('memoryTree.status.retryFailedDone'),
+        message: t('memoryTree.status.retryFailedCount').replace('{count}', String(requeued)),
+      });
+      await refresh();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn('[ui-flow][memory-tree-status] retryFailed: error %s', message);
+      onToast?.({ type: 'error', title: t('memoryTree.status.retryFailedError'), message });
+    } finally {
+      console.debug('[ui-flow][memory-tree-status] retryFailed: busy=false exit');
+      setRetryBusy(false);
+    }
+  }, [retryBusy, refresh, onToast, t]);
+
   const statusKind = status?.status ?? 'idle';
   // #5324: "Error — 936 unrecoverable failures need action" told the user
   // nothing they could act on. When the blocking cause is a spent embedding
@@ -413,6 +456,12 @@ export function MemoryTreeStatusPanel({ onToast }: MemoryTreeStatusPanelProps) {
   // with a localized remediation.
   const degraded = status?.degraded;
 
+  // Parked failures are the one panel state the user can act on directly, and
+  // the affordance is keyed off the counter rather than off the blocking-cause
+  // banner: a failure the pipeline has already worked past no longer surfaces a
+  // remediation, but its rows still sit in `failed` and still need clearing.
+  const failedJobs = status?.pipeline_jobs.failed ?? 0;
+
   const checked = !(status?.is_paused ?? false);
 
   const tileClass =
@@ -513,6 +562,23 @@ export function MemoryTreeStatusPanel({ onToast }: MemoryTreeStatusPanelProps) {
               {status.reason ? (
                 <div className="mt-0.5 text-[11px] text-content-muted">{status.reason}</div>
               ) : null}
+              {failedJobs > 0 ? (
+                <div className="mt-2">
+                  <Button
+                    variant="secondary"
+                    size="xs"
+                    disabled={retryBusy}
+                    data-testid="memory-tree-retry-failed"
+                    analyticsId="memory-tree-retry-failed-jobs"
+                    onClick={() => {
+                      void handleRetryFailed();
+                    }}>
+                    {retryBusy
+                      ? t('memoryTree.status.retryFailedBusy')
+                      : t('memoryTree.status.retryFailed')}
+                  </Button>
+                </div>
+              ) : null}
             </>
           )}
         </div>