@vertesia/ui 1.5.0-dev.20260804.124748Z → 1.5.0-dev.20260807.073259Z

package/src/features/agent/chat/ModernAgentConversation.tsx

@@ -57,6 +57,7 @@ import type {
     AgentInitialRequestTemplateContext,
 } from './ModernAgentOutput/AllMessagesMixed';
 import AllMessagesMixed from './ModernAgentOutput/AllMessagesMixed';
+import { collectDeliveredArtifactRefs } from './ModernAgentOutput/AttachmentPreview';
 import type { BatchProgressPanelClassNames } from './ModernAgentOutput/BatchProgressPanel';
 import Header from './ModernAgentOutput/Header';
 import MessageInput, {
@@ -236,12 +237,21 @@ function isWorkstreamActivityFailureMessage(message: AgentMessage): boolean {
               tool_event?: unknown;
               tool_run_id?: unknown;
               tool_status?: unknown;
+              workstream_id?: unknown;
               workstream_event?: unknown;
           }
         | undefined;
 
     if (details?.event_class !== 'activity') return false;
     if (details.workstream_event) return false;
+    const workstreamId =
+        typeof message.workstream_id === 'string' && message.workstream_id.trim()
+            ? message.workstream_id.trim()
+            : typeof details.workstream_id === 'string'
+              ? details.workstream_id.trim()
+              : '';
+    const normalizedWorkstreamId = workstreamId.toLowerCase();
+    if (!workstreamId || normalizedWorkstreamId === 'main' || normalizedWorkstreamId === 'all') return false;
 
     return !(
         details.tool ||
@@ -1487,8 +1497,9 @@ function ModernAgentConversationInner({
         updateDocumentTitle,
     } = useDocumentPanel(messages);
 
+    const deliveredArtifactRefs = useMemo(() => collectDeliveredArtifactRefs(messages), [messages]);
     const { processingFiles, hasProcessingFiles, handleFileUpload, removeProcessingFile, clearProcessingFiles } =
-        useFileProcessing(client, agentRunId, serverFileUpdates, toast);
+        useFileProcessing(client, agentRunId, serverFileUpdates, toast, deliveredArtifactRefs);
     const canUploadFiles = interactive && !hideFileUpload;
 
     const handleRemoveProcessingFile = useCallback(
@@ -1600,6 +1611,16 @@ function ModernAgentConversationInner({
         () => effectiveWorkflowStatus?.toUpperCase() === 'FAILED' || agentRunStatus?.toUpperCase() === 'FAILED',
         [effectiveWorkflowStatus, agentRunStatus],
     );
+    const workflowFailureReason = useMemo(() => {
+        for (let index = messages.length - 1; index >= 0; index--) {
+            const message = messages[index];
+            if (message.type !== AgentMessageType.ERROR) continue;
+            if (getWorkstreamId(message) !== 'main') continue;
+            const text = typeof message.message === 'string' ? message.message.trim() : '';
+            if (text) return text;
+        }
+        return undefined;
+    }, [messages]);
 
     // Read inside handleSendMessage (a stable callback) without widening its deps.
     const isWorkflowTerminalRef = useRef(isWorkflowTerminal);
@@ -2774,8 +2795,8 @@ function ModernAgentConversationInner({
                             // never render for a failed run. Use the caller's action when provided,
                             // otherwise fall back to the default failed message box.
                             (failedAction ?? (
-                                <MessageBox status="error" icon={null} className="m-2">
-                                    This Workflow is FAILED
+                                <MessageBox status="error" title={t('agent.failed')} className="m-2">
+                                    {workflowFailureReason ?? t('agent.error')}
                                 </MessageBox>
                             ))
                         ) : effectiveWorkflowStatus &&

package/src/features/agent/chat/ModernAgentOutput/AttachmentPreview.test.ts

@@ -0,0 +1,38 @@
+import { type AgentMessage, AgentMessageType } from '@vertesia/common';
+import { describe, expect, it } from 'vitest';
+import { collectDeliveredArtifactRefs } from './AttachmentPreview';
+
+function question(message: string, details?: AgentMessage['details']): AgentMessage {
+    return {
+        timestamp: 1_000,
+        workflow_run_id: 'run-1',
+        type: AgentMessageType.QUESTION,
+        message,
+        workstream_id: 'main',
+        details,
+    };
+}
+
+describe('collectDeliveredArtifactRefs', () => {
+    it('collects attachment references from persisted user messages', () => {
+        const refs = collectDeliveredArtifactRefs([
+            question('Review this.\n\nUploaded artifacts:\n[report.pdf](artifact:files/report.pdf)'),
+        ]);
+
+        expect(refs).toEqual(new Set(['artifact:files/report.pdf', 'files/report.pdf']));
+    });
+
+    it.each(['sending', 'received', 'consumed', 'failed'] as const)(
+        'ignores optimistic messages with %s delivery status',
+        (_deliveryStatus) => {
+            const refs = collectDeliveredArtifactRefs([
+                question('Review this.\n\nUploaded artifacts:\n[report.pdf](artifact:files/report.pdf)', {
+                    _optimistic: true,
+                    _deliveryStatus,
+                }),
+            ]);
+
+            expect(refs).toEqual(new Set());
+        },
+    );
+});

package/src/features/agent/chat/ModernAgentOutput/AttachmentPreview.tsx

@@ -1,3 +1,4 @@
+import { type AgentMessage, AgentMessageType } from '@vertesia/common';
 import { Button, cn } from '@vertesia/ui/core';
 import { useUITranslation } from '@vertesia/ui/i18n';
 import { UserSessionContext } from '@vertesia/ui/session';
@@ -475,3 +476,28 @@ export function parseUserMessageAttachments(content: string): ParsedUserAttachme
         attachments,
     };
 }
+
+/**
+ * Collect the artifact references (`artifact:...` hrefs and bare artifact paths) embedded in
+ * sent user messages. A file whose reference appears here has already been delivered to the
+ * agent, so the composer must not offer it as a pending attachment again (e.g. after a reload).
+ */
+export function collectDeliveredArtifactRefs(messages: AgentMessage[]): Set<string> {
+    const refs = new Set<string>();
+    for (const message of messages) {
+        // Only persisted server echoes prove delivery. Optimistic messages can still be sending
+        // or can fail, in which case suppressing their files would prevent a retry.
+        if (
+            message.type !== AgentMessageType.QUESTION ||
+            message.details?._optimistic ||
+            typeof message.message !== 'string'
+        ) {
+            continue;
+        }
+        for (const attachment of parseUserMessageAttachments(message.message).attachments) {
+            if (attachment.href) refs.add(attachment.href);
+            if (attachment.artifactPath) refs.add(attachment.artifactPath);
+        }
+    }
+    return refs;
+}

package/src/features/agent/chat/ModernAgentOutput/SummaryConversation.ts

@@ -181,12 +181,21 @@ function isWorkstreamActivityFailureMessage(message: AgentMessage): boolean {
               tool_event?: unknown;
               tool_run_id?: unknown;
               tool_status?: unknown;
+              workstream_id?: unknown;
               workstream_event?: unknown;
           }
         | undefined;
 
     if (details?.event_class !== 'activity') return false;
     if (details.workstream_event) return false;
+    const workstreamId =
+        typeof message.workstream_id === 'string' && message.workstream_id.trim()
+            ? message.workstream_id.trim()
+            : typeof details.workstream_id === 'string'
+              ? details.workstream_id.trim()
+              : '';
+    const normalizedWorkstreamId = workstreamId.toLowerCase();
+    if (!workstreamId || normalizedWorkstreamId === 'main' || normalizedWorkstreamId === 'all') return false;
 
     return !(
         details.tool ||

package/src/features/agent/chat/ModernAgentOutput/utils.test.ts

@@ -576,6 +576,27 @@ describe('ModernAgentOutput summary conversation items', () => {
         ]);
     });
 
+    it('keeps a main-workstream activity error visible as a primary message', () => {
+        const question = makeMessage({
+            timestamp: 1000,
+            type: AgentMessageType.QUESTION,
+            message: 'do the thing',
+        });
+        const terminationError = makeMessage({
+            timestamp: 1100,
+            type: AgentMessageType.ERROR,
+            message: 'Stopped: the agent called create_document with the same input 4 times in a row.',
+            details: { event_class: 'activity' },
+        });
+
+        const items = buildSummaryConversationItems([question, terminationError], true);
+
+        expect(items).toEqual([
+            { type: 'message', message: question },
+            { type: 'message', message: terminationError },
+        ]);
+    });
+
     it('hides transient thinking once the work segment completes', () => {
         const tool = makeMessage({
             timestamp: 1000,

package/src/features/agent/chat/hooks/useAgentStream.test.tsx

@@ -362,7 +362,12 @@ describe('useAgentStream', () => {
         const { result } = renderHook(() => useAgentStream(client, 'agent-run-1', vi.fn()));
 
         await waitFor(() => expect(deliver).toBeDefined());
-        expect(result.current.serverFileUpdates.size).toBe(0);
+        // History hydrates the latest archived inventory once so an unconsumed staged file
+        // survives a reload; the live replay of that same snapshot is ignored, leaving the
+        // hydrated entry untouched. Already-delivered files are dropped downstream by
+        // useFileProcessing (consumed_at + delivered artifact refs), not by refusing to hydrate.
+        expect(result.current.serverFileUpdates.size).toBe(1);
+        expect(result.current.serverFileUpdates.has('old-upload')).toBe(true);
 
         act(() => deliver?.(fileSnapshot(1_100, 'new-upload')));
         expect(result.current.serverFileUpdates.size).toBe(1);
@@ -843,4 +848,114 @@ describe('useAgentStream', () => {
 
         expect(result.current.serverFileUpdates.has('file-1')).toBe(false);
     });
+
+    it('hydrates the latest historical file snapshot once and ignores its live replay', async () => {
+        let deliver: ((message: AgentMessage) => void) | undefined;
+        const fileSnapshot = (timestamp: number, id: string): AgentMessage => ({
+            timestamp,
+            workflow_run_id: 'run-1',
+            type: AgentMessageType.SYSTEM,
+            message: '',
+            workstream_id: 'main',
+            details: {
+                system_type: 'file_processing',
+                batch_id: 'batch-1',
+                files: [
+                    {
+                        id,
+                        name: `${id}.pdf`,
+                        content_type: 'application/pdf',
+                        size: 1,
+                        status: FileProcessingStatus.READY,
+                        artifact_path: `files/${id}.pdf`,
+                        reference: `artifact:files/${id}.pdf`,
+                        started_at: timestamp,
+                    },
+                ],
+                pending_count: 0,
+                ready_count: 1,
+                error_count: 0,
+            },
+        });
+        const olderHistorical = fileSnapshot(1_000, 'older-upload');
+        const latestHistorical = fileSnapshot(1_100, 'staged-upload');
+        const streamMessages = vi.fn<
+            (
+                id: string,
+                onMessage?: (message: AgentMessage, exitFn?: (payload: unknown) => void) => void,
+                since?: number,
+                signal?: AbortSignal,
+                options?: AgentRunStreamMessagesOptions,
+            ) => Promise<unknown>
+        >(async (_id, onMessage, _since, _signal, options) => {
+            deliver = onMessage;
+            options?.onHistoryLoaded?.([olderHistorical, latestHistorical]);
+            // Completed runs replay archived file_processing snapshots through the
+            // live callback. Replaying the older snapshot must not replace the latest
+            // inventory selected from history.
+            onMessage?.(olderHistorical);
+            return null;
+        });
+        const client = createClient(streamMessages);
+        const { result } = renderHook(() => useAgentStream(client, 'agent-run-1'));
+
+        await waitFor(() => expect(deliver).toBeDefined());
+        expect(result.current.serverFileUpdates.size).toBe(1);
+        expect(result.current.serverFileUpdates.has('staged-upload')).toBe(true);
+
+        act(() => deliver?.(fileSnapshot(1_200, 'new-upload')));
+        expect(result.current.serverFileUpdates.size).toBe(1);
+        expect(result.current.serverFileUpdates.has('new-upload')).toBe(true);
+    });
+
+    it('selects the newest historical file snapshot even when history arrives out of order', async () => {
+        let deliver: ((message: AgentMessage) => void) | undefined;
+        const fileSnapshot = (timestamp: number, id: string): AgentMessage => ({
+            timestamp,
+            workflow_run_id: 'run-1',
+            type: AgentMessageType.SYSTEM,
+            message: '',
+            workstream_id: 'main',
+            details: {
+                system_type: 'file_processing',
+                batch_id: 'batch-1',
+                files: [
+                    {
+                        id,
+                        name: `${id}.pdf`,
+                        content_type: 'application/pdf',
+                        size: 1,
+                        status: FileProcessingStatus.READY,
+                        artifact_path: `files/${id}.pdf`,
+                        reference: `artifact:files/${id}.pdf`,
+                        started_at: timestamp,
+                    },
+                ],
+                pending_count: 0,
+                ready_count: 1,
+                error_count: 0,
+            },
+        });
+        const streamMessages = vi.fn<
+            (
+                id: string,
+                onMessage?: (message: AgentMessage, exitFn?: (payload: unknown) => void) => void,
+                since?: number,
+                signal?: AbortSignal,
+                options?: AgentRunStreamMessagesOptions,
+            ) => Promise<unknown>
+        >(async (_id, onMessage, _since, _signal, options) => {
+            deliver = onMessage;
+            // retrieveMessages returns GET /updates unsorted, so the newest snapshot is not
+            // necessarily last. Selection must be by timestamp, not arrival order.
+            options?.onHistoryLoaded?.([fileSnapshot(1_100, 'staged-upload'), fileSnapshot(1_000, 'older-upload')]);
+            return null;
+        });
+        const client = createClient(streamMessages);
+        const { result } = renderHook(() => useAgentStream(client, 'agent-run-1'));
+
+        await waitFor(() => expect(deliver).toBeDefined());
+        expect(result.current.serverFileUpdates.size).toBe(1);
+        expect(result.current.serverFileUpdates.has('staged-upload')).toBe(true);
+    });
 });

package/src/features/agent/chat/hooks/useAgentStream.ts

@@ -476,13 +476,39 @@ export function useAgentStream(
                     onHistoryLoaded: (historical) => {
                         if (abortController.signal.aborted) return;
                         const timelineMessages = historical.filter(shouldStoreTimelineMessage);
+                        let latestFileSnapshot: FileProcessingDetails | undefined;
+                        let latestFileSnapshotTs = Number.NEGATIVE_INFINITY;
                         // Advance the watermark synchronously before React processes the
                         // history state update. Some completed streams replay history via
                         // the live callback immediately after onHistoryLoaded returns.
+                        // Must cover every historical message, not just the timeline subset:
+                        // file_processing snapshots are excluded from timelineMessages, so
+                        // scanning only that subset would leave the cursor behind them and
+                        // the replay guard would never fire for a file-only history.
                         for (const message of historical) {
                             if (message.timestamp && message.timestamp > lastDeliveredTsRef.current) {
                                 lastDeliveredTsRef.current = message.timestamp;
                             }
+                            if (message.type === AgentMessageType.SYSTEM) {
+                                const details = message.details as FileProcessingDetails | undefined;
+                                if (details?.system_type === 'file_processing' && details.files) {
+                                    // GET /updates is returned unsorted (the client only ever
+                                    // takes a Math.max over timestamps), so select the newest
+                                    // snapshot by timestamp instead of trusting arrival order.
+                                    // >= keeps last-wins for ties and for untimestamped messages.
+                                    const timestamp = message.timestamp ?? Number.NEGATIVE_INFINITY;
+                                    if (!latestFileSnapshot || timestamp >= latestFileSnapshotTs) {
+                                        latestFileSnapshot = details;
+                                        latestFileSnapshotTs = timestamp;
+                                    }
+                                }
+                            }
+                        }
+                        // Hydrate the latest archived inventory once so an unconsumed staged file
+                        // remains visible after reload. Subsequent live-callback replay is ignored
+                        // by isReplay above, while useFileProcessing filters consumed/delivered files.
+                        if (latestFileSnapshot) {
+                            setServerFileUpdates(new Map(latestFileSnapshot.files.map((file) => [file.id, file])));
                         }
                         debugAgentChat('history loaded', {
                             agentRunId,

package/src/features/agent/chat/hooks/useFileProcessing.test.tsx

@@ -149,6 +149,11 @@ describe('useFileProcessing', () => {
 
         await act(async () => {
             resolveUpload?.({ url: 'https://example.test/upload', path: 'files/wrong.png' });
+            // biome 2.5.6 regression: the nursery rule mis-types `await` on a `Promise | undefined`
+            // variable assigned inside a callback, and its own fix suggests `await await`. It only
+            // fires on Linux CI, not on macOS, so the suppression may read as unused locally.
+            // Drop it once the rule is fixed upstream.
+            // biome-ignore lint/nursery/noFloatingPromises: false positive — already awaited
             await uploadPromise;
         });
 
@@ -188,4 +193,86 @@ describe('useFileProcessing', () => {
             vi.unstubAllGlobals();
         }
     });
+
+    it('excludes files already delivered via a sent message (survives reload)', () => {
+        const client = createClient();
+        const toast = vi.fn();
+        const delivered: ConversationFile = {
+            ...createReadyFile('file-1'),
+            artifact_path: 'files/wrong.png',
+            reference: 'artifact:files/wrong.png',
+        };
+        const serverFileUpdates = new Map([['file-1', delivered]]);
+
+        // No delivered refs → the file shows as a pending composer attachment.
+        const { result, rerender } = renderHook(
+            ({ refs }: { refs: Set<string> | undefined }) =>
+                useFileProcessing(client, 'agent-run-1', serverFileUpdates, toast, refs),
+            { initialProps: { refs: undefined as Set<string> | undefined } },
+        );
+        expect(result.current.processingFiles.has('file-1')).toBe(true);
+
+        // Once its artifact reference appears in message history, it is excluded — matching by
+        // either the full `artifact:` reference or the bare path.
+        rerender({ refs: new Set(['artifact:files/wrong.png']) });
+        expect(result.current.processingFiles.has('file-1')).toBe(false);
+
+        rerender({ refs: new Set(['files/wrong.png']) });
+        expect(result.current.processingFiles.has('file-1')).toBe(false);
+    });
+
+    it('excludes files marked consumed by the workflow without relying on message history', () => {
+        const client = createClient();
+        const toast = vi.fn();
+        const consumed: ConversationFile = {
+            ...createReadyFile('file-1'),
+            artifact_path: 'files/wrong.png',
+            reference: 'artifact:files/wrong.png',
+            consumed_at: 1_100,
+        };
+
+        const { result } = renderHook(() =>
+            useFileProcessing(client, 'agent-run-1', new Map([['file-1', consumed]]), toast),
+        );
+
+        expect(result.current.processingFiles.has('file-1')).toBe(false);
+    });
+
+    it('drops a staged local entry when the server marks that file consumed', async () => {
+        const client = createClient();
+        const toast = vi.fn();
+        const { result, rerender } = renderHook(
+            ({ updates }) => useFileProcessing(client, 'agent-run-1', updates, toast),
+            { initialProps: { updates: new Map<string, ConversationFile>() } },
+        );
+
+        const file = new File(['pdf'], 'report.pdf', { type: 'application/pdf' });
+        await act(async () => {
+            await result.current.handleFileUpload([file]);
+        });
+        const [fileId] = Array.from(result.current.processingFiles.entries())[0];
+        expect(result.current.processingFiles.has(fileId)).toBe(true);
+
+        // The turn was consumed elsewhere (another tab, or an agent-initiated turn), so
+        // clearProcessingFiles() never ran here and the optimistic entry is still staged.
+        // Merging local first means skipping the server update is not enough to hide it.
+        rerender({
+            updates: new Map<string, ConversationFile>([
+                [
+                    fileId,
+                    {
+                        id: fileId,
+                        name: 'report.pdf',
+                        content_type: 'application/pdf',
+                        size: 0,
+                        status: FileProcessingStatus.READY,
+                        started_at: 1_000,
+                        consumed_at: 1_100,
+                    },
+                ],
+            ]),
+        });
+
+        expect(result.current.processingFiles.has(fileId)).toBe(false);
+    });
 });

package/src/features/agent/chat/hooks/useFileProcessing.ts

@@ -51,6 +51,13 @@ export function useFileProcessing(
     agentRunId: string,
     serverFileUpdates: Map<string, ConversationFile>,
     toast: ToastFn,
+    /**
+     * Artifact references (`artifact:...` and bare paths) that already appear in sent user
+     * messages. Files matching these have been delivered to the agent, so they must not resurface
+     * as pending composer attachments after a reload — the durable, server-agnostic counterpart to
+     * the in-session `removedFileIds` suppression.
+     */
+    deliveredArtifactRefs?: Set<string>,
 ): UseFileProcessingResult {
     const t = i18nInstance.getFixedT(null, NAMESPACE);
     // Local optimistic file state (uploads initiated from the UI)
@@ -103,6 +110,17 @@ export function useFileProcessing(
             }
         });
         serverFileUpdates.forEach((file, id) => {
+            // consumed_at is the workflow's authoritative delivered marker. Filter it here in
+            // addition to message-history refs: older runs may lack the marker, while some
+            // server-originated messages may not preserve the rendered attachment block.
+            if (file.consumed_at) {
+                // Drop any optimistic local entry as well. clearProcessingFiles() normally
+                // retires it when this client sends the message, but a turn consumed
+                // elsewhere (another tab, or an agent-initiated turn) leaves this session's
+                // chip staged. Skipping the server update alone would keep it visible.
+                merged.delete(id);
+                return;
+            }
             if (!removedFileIds.has(id)) {
                 // Server updates are authoritative for status, but may omit fields the local
                 // optimistic entry already knows: preview_url is never sent by the server, and
@@ -117,8 +135,21 @@ export function useFileProcessing(
                 } as LocalConversationFile);
             }
         });
+        // Drop files already delivered via a sent message. Unlike removedFileIds (session-only),
+        // this is reconstructed from message history on every mount. It also covers runs created
+        // before the workflow began stamping consumed_at.
+        if (deliveredArtifactRefs && deliveredArtifactRefs.size > 0) {
+            for (const [id, file] of merged) {
+                if (
+                    (file.reference && deliveredArtifactRefs.has(file.reference)) ||
+                    (file.artifact_path && deliveredArtifactRefs.has(file.artifact_path))
+                ) {
+                    merged.delete(id);
+                }
+            }
+        }
         return merged;
-    }, [localFiles, removedFileIds, serverFileUpdates]);
+    }, [localFiles, removedFileIds, serverFileUpdates, deliveredArtifactRefs]);
 
     const hasProcessingFiles = useMemo(
         () =>

package/src/features/store/collections/CollectionsTable.tsx

@@ -53,7 +53,7 @@ export function CollectionsTable() {
                 status: 'success',
                 duration: 3000,
             });
-            refetch();
+            void refetch();
         } catch (err: unknown) {
             console.error('Failed to delete collection:', err);
             toast({

package/src/i18n/locales/ar.json

@@ -252,6 +252,31 @@
   "auth.providers.bodyConsumer": "اختر أحد المزوّدين أدناه للمتابعة.",
   "auth.providers.eyebrow": "اختر كيفية تسجيل الدخول",
   "auth.providers.title": "خطوة أخرى",
+    "auth.recovery.continue": "المتابعة إلى Vertesia",
+    "auth.recovery.credential.body": "تعذّر التحقق من تسجيل دخولك. سجّل الدخول مرة أخرى للمتابعة.",
+    "auth.recovery.credential.eyebrow": "تسجيل الدخول مطلوب",
+    "auth.recovery.credential.title": "تعذّر التحقق من تسجيل دخولك",
+    "auth.recovery.errorCode": "رمز الخطأ",
+    "auth.recovery.errorMessage": "رسالة الخطأ",
+    "auth.recovery.httpStatus": "حالة HTTP",
+    "auth.recovery.noAccessibleAccount.body": "لقد سجّلت الدخول، ولكن لا يتوفر حساب Vertesia لهذه الهوية.",
+    "auth.recovery.noAccessibleAccount.eyebrow": "الحساب مطلوب",
+    "auth.recovery.noAccessibleAccount.title": "لا يتوفر حساب",
+    "auth.recovery.requestedAccount": "الحساب المطلوب",
+    "auth.recovery.requestedProject": "المشروع المطلوب",
+    "auth.recovery.scopeAccount.body": "لقد سجّلت الدخول، ولكن الحساب الموجود في هذا الرابط غير متاح. قد يكون الرابط قديمًا أو قد لا يكون لديك حق الوصول.",
+    "auth.recovery.scopeAccount.eyebrow": "الرابط غير متاح",
+    "auth.recovery.scopeAccount.title": "الحساب غير متاح",
+    "auth.recovery.scopeProject.body": "لقد سجّلت الدخول، ولكن المشروع الموجود في هذا الرابط غير متاح. قد يكون الرابط قديمًا أو قد لا يكون لديك حق الوصول.",
+    "auth.recovery.scopeProject.eyebrow": "الرابط غير متاح",
+    "auth.recovery.scopeProject.title": "المشروع غير متاح",
+    "auth.recovery.service.body": "خدمة المصادقة غير متاحة مؤقتًا. حاول مرة أخرى أو استخدم حسابًا مختلفًا.",
+    "auth.recovery.service.eyebrow": "الخدمة غير متاحة",
+    "auth.recovery.service.title": "تعذّر إكمال تسجيل الدخول",
+    "auth.recovery.supportPrefix": "إذا كنت بحاجة إلى مساعدة، فتواصل مع",
+    "auth.recovery.technicalDetails": "التفاصيل التقنية",
+    "auth.recovery.tryAgain": "المحاولة مرة أخرى",
+    "auth.recovery.useDifferentAccount": "استخدام حساب مختلف",
   "auth.restricted.autoRedirect": "إعادة التوجيه إلى الموقع الرئيسي خلال {{seconds}} ثانية…",
   "auth.restricted.body": "هذا الموقع مقتصر على المستخدمين الذين لديهم وصول مبكر إلى الميزات والإصلاحات الجديدة. يُرجى المتابعة إلى الموقع الرئيسي، أو التواصل مع Vertesia بشأن الوصول المبكر إلى هذا الموقع.",
   "auth.restricted.calloutMeta": "تواصل مع Vertesia للحصول على وصول مبكر",

package/src/i18n/locales/de.json

@@ -244,6 +244,31 @@
   "auth.providers.bodyConsumer": "Wähle einen der folgenden Anbieter aus, um fortzufahren.",
   "auth.providers.eyebrow": "Anmeldeart wählen",
   "auth.providers.title": "Noch ein Schritt",
+    "auth.recovery.continue": "Weiter zu Vertesia",
+    "auth.recovery.credential.body": "Ihre Anmeldung konnte nicht überprüft werden. Melden Sie sich erneut an, um fortzufahren.",
+    "auth.recovery.credential.eyebrow": "Anmeldung erforderlich",
+    "auth.recovery.credential.title": "Ihre Anmeldung konnte nicht überprüft werden",
+    "auth.recovery.errorCode": "Fehlercode",
+    "auth.recovery.errorMessage": "Fehlermeldung",
+    "auth.recovery.httpStatus": "HTTP-Status",
+    "auth.recovery.noAccessibleAccount.body": "Sie sind angemeldet, aber für diese Identität ist kein Vertesia-Konto verfügbar.",
+    "auth.recovery.noAccessibleAccount.eyebrow": "Konto erforderlich",
+    "auth.recovery.noAccessibleAccount.title": "Kein Konto verfügbar",
+    "auth.recovery.requestedAccount": "Angefordertes Konto",
+    "auth.recovery.requestedProject": "Angefordertes Projekt",
+    "auth.recovery.scopeAccount.body": "Sie sind angemeldet, aber das Konto in diesem Link ist nicht verfügbar. Der Link ist möglicherweise veraltet oder Sie haben keinen Zugriff.",
+    "auth.recovery.scopeAccount.eyebrow": "Link nicht verfügbar",
+    "auth.recovery.scopeAccount.title": "Konto nicht verfügbar",
+    "auth.recovery.scopeProject.body": "Sie sind angemeldet, aber das Projekt in diesem Link ist nicht verfügbar. Der Link ist möglicherweise veraltet oder Sie haben keinen Zugriff.",
+    "auth.recovery.scopeProject.eyebrow": "Link nicht verfügbar",
+    "auth.recovery.scopeProject.title": "Projekt nicht verfügbar",
+    "auth.recovery.service.body": "Der Authentifizierungsdienst ist vorübergehend nicht verfügbar. Versuchen Sie es erneut oder verwenden Sie ein anderes Konto.",
+    "auth.recovery.service.eyebrow": "Dienst nicht verfügbar",
+    "auth.recovery.service.title": "Die Anmeldung konnte nicht abgeschlossen werden",
+    "auth.recovery.supportPrefix": "Wenn Sie Hilfe benötigen, kontaktieren Sie",
+    "auth.recovery.technicalDetails": "Technische Details",
+    "auth.recovery.tryAgain": "Erneut versuchen",
+    "auth.recovery.useDifferentAccount": "Anderes Konto verwenden",
   "auth.restricted.autoRedirect": "Weiterleitung zur Hauptwebsite in {{seconds}} s…",
   "auth.restricted.body": "Diese Website ist auf Nutzer mit Early Access zu neuen Funktionen und Fixes beschränkt. Bitte fahre zur Hauptwebsite fort oder kontaktiere Vertesia bezüglich Early Access zu dieser Website.",
   "auth.restricted.calloutMeta": "Kontaktiere Vertesia für Early Access",

package/src/i18n/locales/en.json

@@ -319,6 +319,31 @@
     "auth.providers.bodyConsumer": "Pick from one of the providers below to continue.",
     "auth.providers.eyebrow": "Choose How to Sign In",
     "auth.providers.title": "One more step",
+    "auth.recovery.continue": "Continue to Vertesia",
+    "auth.recovery.credential.body": "We couldn't verify your sign-in. Sign in again to continue.",
+    "auth.recovery.credential.eyebrow": "Sign-In Required",
+    "auth.recovery.credential.title": "Your sign-in could not be verified",
+    "auth.recovery.errorCode": "Error code",
+    "auth.recovery.errorMessage": "Error message",
+    "auth.recovery.httpStatus": "HTTP status",
+    "auth.recovery.noAccessibleAccount.body": "You're signed in, but no Vertesia account is available for this identity.",
+    "auth.recovery.noAccessibleAccount.eyebrow": "Account Required",
+    "auth.recovery.noAccessibleAccount.title": "No account is available",
+    "auth.recovery.requestedAccount": "Requested account",
+    "auth.recovery.requestedProject": "Requested project",
+    "auth.recovery.scopeAccount.body": "You’re signed in, but the account in this link isn’t available. The link may be outdated, or you may not have access.",
+    "auth.recovery.scopeAccount.eyebrow": "Link Unavailable",
+    "auth.recovery.scopeAccount.title": "Account not available",
+    "auth.recovery.scopeProject.body": "You’re signed in, but the project in this link isn’t available. The link may be outdated, or you may not have access.",
+    "auth.recovery.scopeProject.eyebrow": "Link Unavailable",
+    "auth.recovery.scopeProject.title": "Project not available",
+    "auth.recovery.service.body": "The authentication service is temporarily unavailable. Try again, or use a different account.",
+    "auth.recovery.service.eyebrow": "Service Unavailable",
+    "auth.recovery.service.title": "We couldn't complete sign-in",
+    "auth.recovery.supportPrefix": "If you need help, contact",
+    "auth.recovery.technicalDetails": "Technical details",
+    "auth.recovery.tryAgain": "Try again",
+    "auth.recovery.useDifferentAccount": "Use a different account",
     "auth.restricted.autoRedirect": "Redirecting to the main site in {{seconds}}s…",
     "auth.restricted.body": "This site is restricted to users with early access to new features and fixes. Please continue to the main site, or contact Vertesia about early access to this site.",
     "auth.restricted.calloutMeta": "Contact Vertesia for early access",