@n8n/frontend-module-inbox 0.2.3 → 0.3.0

package/src/self-healing/selfHealingResult.store.test.ts

@@ -0,0 +1,86 @@
+import type { SelfHealingResultDetail } from '@n8n/api-types';
+import { ResponseError } from '@n8n/rest-api-client';
+import { createDeferredPromise } from '@n8n/utils/promise/deferred-promise';
+
+import { useSelfHealingResultStore } from './selfHealingResult.store';
+import * as api from './selfHealingResults.api';
+import { result, resultSelection } from './selfHealingResults.test.utils';
+
+vi.mock('./selfHealingResults.api');
+
+beforeEach(() => {
+	vi.resetAllMocks();
+	vi.mocked(api.fetchSelfHealingResult).mockImplementation(async (_context, selection) =>
+		result({ resultId: selection.id }),
+	);
+	vi.mocked(api.fetchResultWorkflow).mockResolvedValue({
+		name: 'Daily report',
+		scopes: ['workflow:read', 'workflow:update'],
+	});
+});
+
+it('ignores a detail response after selecting another result', async () => {
+	const request = createDeferredPromise<SelfHealingResultDetail>();
+	vi.mocked(api.fetchSelfHealingResult).mockReturnValueOnce(request.promise);
+	const store = useSelfHealingResultStore();
+	const first = store.select(resultSelection);
+	await store.select({ ...resultSelection, id: 'other' });
+	request.resolve(result());
+	await first;
+	expect(store.detail?.resultId).toBe('other');
+	expect(store.loading).toBe(false);
+});
+
+it('does not let a pending read replace a completed action', async () => {
+	const store = useSelfHealingResultStore();
+	await store.select(resultSelection);
+	const request = createDeferredPromise<SelfHealingResultDetail>();
+	vi.mocked(api.fetchSelfHealingResult).mockReturnValueOnce(request.promise);
+	const loading = store.refreshDetail();
+	store.acceptResult(result({ reviewState: 'applied' }));
+	request.resolve(result());
+	await loading;
+	expect(store.detail?.reviewState).toBe('applied');
+	expect(store.loading).toBe(false);
+});
+
+it.each([403, 404])('clears saved detail when a read returns %s', async (httpStatusCode) => {
+	const store = useSelfHealingResultStore();
+	await store.select(resultSelection);
+	const error = new ResponseError('Unavailable', { httpStatusCode });
+	vi.mocked(api.fetchSelfHealingResult).mockRejectedValueOnce(error);
+	await store.refreshDetail();
+	expect(store.detail).toBeNull();
+	expect(store.error).toBe(error);
+	expect(store.loading).toBe(false);
+});
+
+it('keeps the report available when the workflow metadata request fails', async () => {
+	const error = new Error('Request failed');
+	vi.mocked(api.fetchResultWorkflow).mockRejectedValueOnce(error);
+	const store = useSelfHealingResultStore();
+	await store.select(resultSelection);
+	expect(store.detail?.report).toBe(result().report);
+	expect(store.workflow).toBeNull();
+	expect(store.workflowError).toBe(error);
+	expect(store.error).toBeNull();
+});
+
+it('tracks a pending action for each result', async () => {
+	const store = useSelfHealingResultStore();
+	const second = { ...resultSelection, id: 'other' };
+	await store.select(resultSelection);
+
+	expect(store.beginAction(resultSelection, 'editor')).toBe(true);
+	expect(store.beginAction(resultSelection, 'dismiss')).toBe(false);
+	expect(store.pendingAction).toBe('editor');
+
+	await store.select(second);
+	expect(store.pendingAction).toBeNull();
+	expect(store.beginAction(second, 'dismiss')).toBe(true);
+
+	store.endAction(resultSelection);
+	expect(store.pendingAction).toBe('dismiss');
+	await store.select(resultSelection);
+	expect(store.pendingAction).toBeNull();
+});

package/src/self-healing/selfHealingResult.store.ts

@@ -0,0 +1,153 @@
+import type { SelfHealingResultDetail } from '@n8n/api-types';
+import { useRootStore } from '@n8n/stores/useRootStore';
+import { defineStore } from 'pinia';
+import { computed, ref } from 'vue';
+
+import {
+	fetchResultWorkflow,
+	fetchSelfHealingResult,
+	type SelfHealingResultAction,
+	type SelfHealingResultWorkflowMetadata,
+	type SelfHealingSelection,
+} from './selfHealingResults.api';
+
+function resultKey({ projectId, workflowId, id }: SelfHealingSelection) {
+	return `${projectId}/${workflowId}/${id}`;
+}
+
+export const useSelfHealingResultStore = defineStore('selfHealingResultDetail', () => {
+	const rootStore = useRootStore();
+	const selection = ref<SelfHealingSelection | null>(null);
+	const detail = ref<SelfHealingResultDetail | null>(null);
+	const workflow = ref<SelfHealingResultWorkflowMetadata | null>(null);
+	const loading = ref(false);
+	const error = ref<unknown>(null);
+	const workflowError = ref<unknown>(null);
+	const pendingActions = ref(new Map<string, SelfHealingResultAction>());
+	const pendingAction = computed(() =>
+		selection.value ? (pendingActions.value.get(resultKey(selection.value)) ?? null) : null,
+	);
+	let detailRequestSequence = 0;
+	let workflowRequestSequence = 0;
+
+	function isSelected(target: SelfHealingSelection) {
+		return (
+			selection.value?.id === target.id &&
+			selection.value.projectId === target.projectId &&
+			selection.value.workflowId === target.workflowId
+		);
+	}
+
+	function setError(target: SelfHealingSelection, cause: unknown) {
+		if (!isSelected(target)) return;
+
+		detailRequestSequence++;
+		detail.value = null;
+		error.value = cause;
+		loading.value = false;
+	}
+
+	function acceptResult(result: SelfHealingResultDetail) {
+		if (
+			selection.value?.id !== result.resultId ||
+			selection.value.workflowId !== result.workflowId ||
+			selection.value.projectId !== result.projectId
+		)
+			return;
+
+		// A read started before this action must not restore the pending state.
+		detailRequestSequence++;
+		detail.value = result;
+		error.value = null;
+		loading.value = false;
+	}
+
+	async function refreshDetail() {
+		const target = selection.value;
+		if (!target) return;
+
+		const requestSequence = ++detailRequestSequence;
+		loading.value = true;
+		error.value = null;
+
+		try {
+			const result = await fetchSelfHealingResult(rootStore.restApiContext, target);
+
+			if (requestSequence === detailRequestSequence) {
+				detail.value = result;
+				return result;
+			}
+		} catch (cause) {
+			if (requestSequence === detailRequestSequence) {
+				detail.value = null;
+				error.value = cause;
+			}
+		} finally {
+			if (requestSequence === detailRequestSequence) loading.value = false;
+		}
+
+		return undefined;
+	}
+
+	async function refreshWorkflow() {
+		const target = selection.value;
+		if (!target) return;
+
+		const requestSequence = ++workflowRequestSequence;
+
+		try {
+			const response = await fetchResultWorkflow(rootStore.restApiContext, target.workflowId);
+			if (requestSequence !== workflowRequestSequence) return;
+
+			workflow.value = response;
+			workflowError.value = null;
+		} catch (cause) {
+			if (requestSequence !== workflowRequestSequence) return;
+
+			workflow.value = null;
+			workflowError.value = cause;
+		}
+	}
+
+	function beginAction(target: SelfHealingSelection, action: SelfHealingResultAction) {
+		const key = resultKey(target);
+		if (pendingActions.value.has(key)) return false;
+
+		pendingActions.value.set(key, action);
+		return true;
+	}
+
+	function endAction(target: SelfHealingSelection) {
+		pendingActions.value.delete(resultKey(target));
+	}
+
+	async function select(target: SelfHealingSelection) {
+		detailRequestSequence++;
+		workflowRequestSequence++;
+
+		selection.value = { ...target };
+		detail.value = null;
+		workflow.value = null;
+		error.value = null;
+		workflowError.value = null;
+
+		await Promise.all([refreshDetail(), refreshWorkflow()]);
+	}
+
+	return {
+		detail,
+		workflow,
+		loading,
+		error,
+		workflowError,
+		pendingAction,
+		select,
+		refreshDetail,
+		refreshWorkflow,
+		acceptResult,
+		beginAction,
+		endAction,
+		setError,
+		isSelected,
+	};
+});

package/src/self-healing/selfHealingResults.api.test.ts

@@ -0,0 +1,24 @@
+import { makeRestApiRequest } from '@n8n/rest-api-client';
+
+import { fetchSelfHealingResult, reviewSelfHealingResult } from './selfHealingResults.api';
+import { resultSelection } from './selfHealingResults.test.utils';
+
+vi.mock('@n8n/rest-api-client', () => ({ makeRestApiRequest: vi.fn() }));
+
+it('encodes the full result address and forwards the editor context for each action', async () => {
+	const context = { baseUrl: '/rest', pushRef: 'editor-client' };
+	const selection = {
+		...resultSelection,
+		projectId: 'project/id',
+		workflowId: 'workflow/id',
+		id: 'result/id',
+	};
+	const path = '/projects/project%2Fid/workflows/workflow%2Fid/self-healing-results/result%2Fid';
+	await fetchSelfHealingResult(context, selection);
+	expect(makeRestApiRequest).toHaveBeenLastCalledWith(context, 'GET', path);
+	for (const action of ['apply', 'approve-and-publish', 'dismiss'] as const) {
+		await reviewSelfHealingResult(context, selection, action);
+		expect(makeRestApiRequest).toHaveBeenLastCalledWith(context, 'POST', `${path}/${action}`);
+	}
+	expect(makeRestApiRequest).toHaveBeenCalledTimes(4);
+});

package/src/self-healing/selfHealingResults.api.ts

@@ -0,0 +1,38 @@
+import type { SelfHealingResultActionResponse, SelfHealingResultDetail } from '@n8n/api-types';
+import { makeRestApiRequest, type IRestApiContext } from '@n8n/rest-api-client';
+
+import type { InboxSelection } from '../inbox.constants';
+
+export type SelfHealingSelection = Extract<InboxSelection, { type: 'self_healing_result' }>;
+export type SelfHealingReviewAction = 'apply' | 'approve-and-publish' | 'dismiss';
+export type SelfHealingResultAction = Exclude<SelfHealingReviewAction, 'apply'> | 'editor' | 'chat';
+/** Fields the result view reads from the normal workflow endpoint. */
+export type SelfHealingResultWorkflowMetadata = { name: string; scopes: string[] };
+/** Unknown while workflow permissions load or after they fail to load. */
+export type SelfHealingPublishAccess = 'allowed' | 'denied' | 'unknown';
+
+function resultPath({ projectId, workflowId, id }: SelfHealingSelection) {
+	return `/projects/${encodeURIComponent(projectId)}/workflows/${encodeURIComponent(workflowId)}/self-healing-results/${encodeURIComponent(id)}`;
+}
+
+export async function fetchSelfHealingResult(
+	context: IRestApiContext,
+	selection: SelfHealingSelection,
+): Promise<SelfHealingResultDetail> {
+	return await makeRestApiRequest(context, 'GET', resultPath(selection));
+}
+
+export async function reviewSelfHealingResult(
+	context: IRestApiContext,
+	selection: SelfHealingSelection,
+	action: SelfHealingReviewAction,
+): Promise<SelfHealingResultActionResponse> {
+	return await makeRestApiRequest(context, 'POST', `${resultPath(selection)}/${action}`);
+}
+
+export async function fetchResultWorkflow(
+	context: IRestApiContext,
+	workflowId: string,
+): Promise<SelfHealingResultWorkflowMetadata> {
+	return await makeRestApiRequest(context, 'GET', `/workflows/${encodeURIComponent(workflowId)}`);
+}

package/src/self-healing/selfHealingResults.test.utils.ts

@@ -0,0 +1,106 @@
+import type { SelfHealingResultDetail, WorkflowSuggestionProposalDetail } from '@n8n/api-types';
+
+import type { SelfHealingSelection } from './selfHealingResults.api';
+
+export const resultSelection: SelfHealingSelection = {
+	type: 'self_healing_result',
+	id: 'result-1',
+	workflowId: 'workflow-1',
+	projectId: 'project-1',
+};
+
+export function suggestion(
+	overrides: Partial<WorkflowSuggestionProposalDetail> = {},
+): WorkflowSuggestionProposalDetail {
+	const original = {
+		name: 'Daily report',
+		nodes: [
+			{
+				id: 'node-1',
+				name: 'Start',
+				type: 'n8n-nodes-base.manualTrigger',
+				typeVersion: 1,
+				position: [0, 0] as [number, number],
+				parameters: {},
+			},
+		],
+		connections: {},
+	};
+	const candidate = {
+		nodes: [
+			...original.nodes,
+			{
+				id: 'node-2',
+				name: 'Finish',
+				type: 'n8n-nodes-base.noOp',
+				typeVersion: 1,
+				position: [200, 0] as [number, number],
+				parameters: {},
+			},
+		],
+		connections: {},
+	};
+	return {
+		suggestionId: 'suggestion-1',
+		workflowId: resultSelection.workflowId,
+		projectId: resultSelection.projectId,
+		backgroundUserId: 'background-user',
+		expectedBaseline: {
+			savedVersionId: 'original',
+			publishedVersionId: 'original',
+			checksum: 'checksum',
+			versionCounter: 1,
+			latestPublishHistoryEventId: null,
+		},
+		state: 'pending',
+		closedReason: null,
+		resultKind: 'fix_ready',
+		appliedVersion: null,
+		author: 'assistant',
+		payload: {
+			original,
+			candidate,
+			proposed: { ...original, ...candidate },
+			explanation: 'Add the missing step',
+			errorContext: { summary: 'The last step did not run', evidenceReference: null },
+		},
+		activity: [
+			{
+				id: 'event-1',
+				action: 'submitted',
+				author: 'assistant',
+				actorId: null,
+				createdAt: '2026-10-09T09:00:00.000Z',
+			},
+		],
+		...overrides,
+	};
+}
+
+export function result(overrides: Partial<SelfHealingResultDetail> = {}): SelfHealingResultDetail {
+	return {
+		resultId: resultSelection.id,
+		workflowId: resultSelection.workflowId,
+		projectId: resultSelection.projectId,
+		backgroundUserId: 'background-user',
+		outcome: 'fix_ready',
+		summary: 'Restore the last step',
+		report: 'The workflow stops before the last step. Review the proposed connection.',
+		usage: {
+			turns: 3,
+			durationSeconds: 45,
+			promptTokens: 100,
+			completionTokens: 50,
+			totalTokens: 150,
+		},
+		completedAt: '2026-10-09T09:00:00.000Z',
+		createdAt: '2026-10-09T09:00:00.000Z',
+		updatedAt: '2026-10-09T09:00:00.000Z',
+		dismissedAt: null,
+		dismissedById: null,
+		reviewState: 'open',
+		suggestion: suggestion(),
+		execution: { status: 'available', id: 'execution-1' },
+		...overrides,
+	};
+}

package/src/views/InboxView.test.ts

@@ -1,5 +1,6 @@
 import type {
 	DecideWorkflowReviewRequestResponse,
+	InboxPromotionReviewItem,
 	InboxSelfHealingItem,
 	InboxWorkflowReviewItem,
 	WorkflowReviewRequestDetail,
@@ -11,7 +12,7 @@ import { createTestingPinia } from '@pinia/testing';
 import { defineComponent, type PropType } from 'vue';
 import { createMemoryHistory, createRouter, RouterView } from 'vue-router';
 
-import type { InboxItemChange } from '../inbox.constants';
+import type { InboxItemChange, InboxSelection } from '../inbox.constants';
 import * as inboxApi from '../inbox.api';
 import { InboxModule } from '../inbox.module';
 import { createInboxListSlice, useInboxStore } from '../inbox.store';
@@ -34,6 +35,7 @@ vi.mock('@n8n/composables/useDocumentTitle', () => ({
 }));
 const detailMounted = vi.fn();
 let reportChange: (change: InboxItemChange) => void;
+let reportResultChange: (change: InboxItemChange) => void;
 const router = createRouter({
 	history: createMemoryHistory(),
 	routes: [
@@ -81,9 +83,27 @@ const renderOptions = {
     <slot v-if="!listItem" />
     </div>`,
 			}),
-			SelfHealingResultDetail: {
-				props: ['selection'],
-				template: '<div data-test-id="result-detail" :data-id="selection.id" />',
+			SelfHealingResultDetail: defineComponent({
+				props: {
+					selection: { type: Object as PropType<InboxSelection>, required: true },
+					tab: String,
+					onItemChange: {
+						type: Function as PropType<(change: InboxItemChange) => void>,
+						required: true,
+					},
+				},
+				emits: ['update:tab'],
+				setup(props) {
+					reportResultChange = props.onItemChange;
+				},
+				template: `<div data-test-id="result-detail" :data-id="selection.id" :data-tab="tab">
+    <button data-test-id="select-result-changes-tab" @click="$emit('update:tab', 'changes')" />
+    <button data-test-id="select-result-activity-tab" @click="$emit('update:tab', 'activity')" />
+    </div>`,
+			}),
+			PromotionReviewDetail: {
+				props: ['item'],
+				template: '<div data-test-id="promotion-detail" :data-id="item.id" />',
 			},
 		},
 	},
@@ -166,6 +186,21 @@ it('clears source context and keeps the current state and tab', async () => {
 	expect(router.currentRoute.value.fullPath).toBe('/inbox?state=closed&tab=changes');
 });
 
+it('renders a promotion review from its loaded row until its source becomes disabled', async () => {
+	await router.replace('/inbox/promotion-reviews/rev-1');
+	const { getByTestId, queryByTestId } = renderComponent();
+	expect(queryByTestId('promotion-detail')).not.toBeInTheDocument();
+
+	store.lists.waiting.items = [promotionItem()];
+	await waitAllPromises();
+	expect(getByTestId('promotion-detail')).toHaveAttribute('data-id', 'rev-1');
+
+	store.disabledSources = ['promotion_review'];
+	await waitAllPromises();
+	expect(router.currentRoute.value.fullPath).toBe('/inbox');
+	expect(queryByTestId('promotion-detail')).not.toBeInTheDocument();
+});
+
 it('clears a disabled-source deep link without mounting its detail entry', async () => {
 	await router.replace('/inbox/reviews/req-1');
 	store.disabledSources = ['workflow_review'];
@@ -221,6 +256,71 @@ it('writes detail tabs to the URL and keeps selection and state', async () => {
 	});
 });
 
+it('keeps Assistant selection through detail tabs and reconciles its closure through the Inbox', async () => {
+	const inboxSettings = useSettingsStore().settings.inbox;
+	createTestingPinia({ stubActions: false });
+	useSettingsStore().settings.inbox = inboxSettings;
+	const inbox = useInboxStore();
+	const closedResult: InboxSelfHealingItem = { ...resultItem(), state: 'closed' };
+	const metadata = { partial: false, failedSources: [], disabledSources: [] };
+	vi.mocked(inboxApi.fetchInboxSummary).mockResolvedValue({
+		...metadata,
+		counts: { open: 2, closed: 0 },
+	});
+	vi.mocked(inboxApi.fetchInbox).mockImplementation(async (_ctx, query) => ({
+		...metadata,
+		nextCursor: null,
+		hasMore: false,
+		data:
+			query.category === 'authored'
+				? []
+				: query.state === 'closed'
+					? [closedResult]
+					: [reviewItem(), resultItem()],
+	}));
+	await router.replace('/inbox/assistant-results/req-1?projectId=p1&workflowId=w1');
+	const { getByTestId, queryByTestId } = renderRoutedComponent();
+	await waitAllPromises();
+
+	getByTestId('select-result-changes-tab').click();
+	await waitAllPromises();
+	expect(router.currentRoute.value.query).toEqual({
+		projectId: 'p1',
+		workflowId: 'w1',
+		tab: 'changes',
+	});
+	expect(getByTestId('result-detail')).toHaveAttribute('data-tab', 'changes');
+	getByTestId('select-result-activity-tab').click();
+	await waitAllPromises();
+	expect(router.currentRoute.value.query).toEqual({ projectId: 'p1', workflowId: 'w1' });
+	expect(getByTestId('result-detail')).toHaveAttribute('data-tab', 'activity');
+	expect(inbox.openCount).toBe(2);
+	expect(inbox.closedCount).toBe(0);
+
+	reportResultChange({ type: 'self_healing_result', id: 'req-1', state: 'closed' });
+	await waitAllPromises();
+
+	expect(inbox.reconcileItemChange).toHaveBeenCalledExactlyOnceWith({
+		type: 'self_healing_result',
+		id: 'req-1',
+		state: 'closed',
+	});
+	expect(inbox.openCount).toBe(1);
+	expect(inbox.closedCount).toBe(1);
+	expect(inbox.lists.waiting.items).toEqual([reviewItem()]);
+	expect(inbox.lists.closed.items).toEqual([closedResult]);
+	expect(inbox.activeTab).toBe('closed');
+	expect(router.currentRoute.value.path).toBe('/inbox/assistant-results/req-1');
+	expect(router.currentRoute.value.query).toEqual({
+		projectId: 'p1',
+		workflowId: 'w1',
+		state: 'closed',
+	});
+	expect(getByTestId('result-detail')).toHaveAttribute('data-id', 'req-1');
+	expect(queryByTestId('review-detail')).not.toBeInTheDocument();
+	expect(inboxApi.fetchInboxSummary).toHaveBeenCalledOnce();
+});
+
 it('follows a selected item to Closed after its detail reports the new state', async () => {
 	await router.replace('/inbox/reviews/req-1');
 	renderComponent();
@@ -423,6 +523,28 @@ function reviewItem(): InboxWorkflowReviewItem {
 		updatedAt: '2024-01-01T00:00:00.000Z',
 	};
 }
+function promotionItem(): InboxPromotionReviewItem {
+	return {
+		type: 'promotion_review',
+		id: 'rev-1',
+		state: 'open',
+		reviewState: 'open',
+		reviewType: 'gitlab',
+		title: 'Promote the thing',
+		webUrl: null,
+		branchName: 'n8n-promotion/1',
+		environmentName: null,
+		requester: null,
+		approver: null,
+		remoteError: null,
+		headCommitSha: null,
+		runCommitSha: null,
+		hasConflicts: false,
+		createdAt: '2026-01-01T00:00:00.000Z',
+		updatedAt: '2026-01-01T00:00:00.000Z',
+	};
+}
+
 function resultItem(): InboxSelfHealingItem {
 	return {
 		type: 'self_healing_result',

package/src/views/InboxView.vue

@@ -15,6 +15,7 @@ import { INBOX_VIEW, type InboxItemChange } from '../inbox.constants';
 import { inboxItemLocation, isInboxRoute, selectionFromRoute } from '../inbox.routes';
 import { useInboxStore } from '../inbox.store';
 import WorkflowReviewDetail from '../reviews/WorkflowReviewDetail.vue';
+import PromotionReviewDetail from '../promotions/PromotionReviewDetail.vue';
 import SelfHealingResultDetail from '../self-healing/SelfHealingResultDetail.vue';
 
 const store = useInboxStore();
@@ -53,6 +54,9 @@ const selectedListItem = computed(() =>
 const selectedReviewItem = computed(() =>
 	selectedListItem.value?.type === 'workflow_review' ? selectedListItem.value : undefined,
 );
+const selectedPromotionItem = computed(() =>
+	selectedListItem.value?.type === 'promotion_review' ? selectedListItem.value : undefined,
+);
 const detailTab = computed(() => (route.query.tab === 'changes' ? 'changes' : 'activity'));
 let isMounted = false;
 
@@ -69,6 +73,11 @@ function isSelectedReview(id: string) {
 	return selected?.type === 'workflow_review' && selected.id === id;
 }
 
+function isSelectedResult(id: string) {
+	const selected = selectionFromRoute(router.currentRoute.value);
+	return selected?.type === 'self_healing_result' && selected.id === id;
+}
+
 // Reset on entry. A layout-swap copy can unmount after the next view has mounted.
 store.reset();
 store.activeTab = route.query.state === 'closed' ? 'closed' : 'open';
@@ -185,17 +194,26 @@ onBeforeUnmount(() => {
 				>
 					<InboxEmptyState />
 				</WorkflowReviewDetail>
+				<PromotionReviewDetail
+					v-else-if="selectedPromotionItem && !store.disabledSources.includes('promotion_review')"
+					:item="selectedPromotionItem"
+					:on-item-change="onItemChange"
+				/>
+				<SelfHealingResultDetail
+					v-else-if="
+						selection?.type === 'self_healing_result' &&
+						!store.disabledSources.includes(selection.type)
+					"
+					:selection="selection"
+					:tab="detailTab"
+					:on-item-change="onItemChange"
+					:is-selected="isSelectedResult"
+					@update:tab="onDetailTabChange"
+				/>
 				<template v-else>
 					<div :class="$style.columnTitle" />
 					<div :class="$style.mainBody">
-						<SelfHealingResultDetail
-							v-if="
-								selection?.type === 'self_healing_result' &&
-								!store.disabledSources.includes(selection.type)
-							"
-							:selection="selection"
-						/>
-						<InboxEmptyState v-else />
+						<InboxEmptyState />
 					</div>
 				</template>
 			</div>
@@ -218,10 +236,8 @@ onBeforeUnmount(() => {
 .content {
 	--review-callout--max-width: 34rem;
 	--review-activity--max-width: 45rem;
-	--review-tab-bar--height: var(--height--sm);
 	/* Keep the existing Reviews tab alignment at every root font size. */
 	--review-tab-bar--indicator-overhang: 15px;
-	--review-tab-bar--gap: calc(var(--spacing--sm) + var(--review-tab-bar--indicator-overhang));
 	display: flex;
 	width: 100%;
 	min-height: 0;