diff --git a/src/app/api/sources/[sourceId]/route.test.ts b/src/app/api/sources/[sourceId]/route.test.ts
index b82d620..6f82574 100644
--- a/src/app/api/sources/[sourceId]/route.test.ts
+++ b/src/app/api/sources/[sourceId]/route.test.ts
@@ -14,7 +14,9 @@ const mocks = vi.hoisted(() => {
     hideDemoSource: vi.fn(),
     makeKnowhereClient: vi.fn(),
     requireUser: vi.fn(),
+    retrySourceToKnowhere: vi.fn(),
     softDeleteSource: vi.fn(),
+    startBackgroundReconciliation: vi.fn(),
   };
 });
 
@@ -46,10 +48,15 @@ vi.mock("@/integrations/knowhere", () => ({
   makeKnowhereClient: mocks.makeKnowhereClient,
 }));
 
+vi.mock("@/domains/sources/background-reconcile", () => ({
+  startBackgroundReconciliation: mocks.startBackgroundReconciliation,
+}));
+
 vi.mock("@/domains/sources/service", () => ({
   sourceService: {
     findInWorkspace: mocks.findSourceInWorkspace,
     hideDemoSource: mocks.hideDemoSource,
+    retrySourceToKnowhere: mocks.retrySourceToKnowhere,
     softDelete: mocks.softDeleteSource,
   },
 }));
@@ -255,4 +262,124 @@ describe("PATCH /api/sources/[sourceId]", () => {
     expect(mocks.ensureApiKeyForWorkspace).not.toHaveBeenCalled();
     expect(mocks.archive).not.toHaveBeenCalled();
   });
+
+  it("retries a failed source and starts background reconciliation", async () => {
+    mocks.requireUser.mockResolvedValue({ id: "user_1" });
+    mocks.ensureWorkspace.mockResolvedValue({ id: "workspace_1" });
+    mocks.findSourceInWorkspace.mockResolvedValue({
+      id: "source_1",
+      workspaceId: "workspace_1",
+      title: "lecture.pdf",
+      mimeType: "application/pdf",
+      sizeBytes: 5,
+      status: "failed",
+      failureReason: "Knowhere upload failed.",
+      knowhereJobId: null,
+      knowhereDocumentId: null,
+      stagedBlobPathname: null,
+      stagedBlobUrl: null,
+      originalBlobPathname: "source-uploads/upload_1/document.pdf",
+      originalBlobUrl:
+        "https://store.public.blob.vercel-storage.com/source-uploads/upload_1/document.pdf",
+      demoKey: null,
+      createdAt: new Date("2026-05-10T00:00:00Z"),
+      updatedAt: new Date("2026-05-10T00:00:00Z"),
+      deletedAt: null,
+    });
+    mocks.ensureApiKeyForWorkspace.mockResolvedValue("jwt_123");
+    const knowhereClient = {
+      jobs: {
+        create: vi.fn(),
+        get: vi.fn(),
+        upload: vi.fn(),
+      },
+      documents: {
+        archive: mocks.archive,
+      },
+    };
+    mocks.makeKnowhereClient.mockReturnValue(knowhereClient);
+    mocks.retrySourceToKnowhere.mockResolvedValue({
+      id: "source_1",
+      workspaceId: "workspace_1",
+      title: "lecture.pdf",
+      mimeType: "application/pdf",
+      sizeBytes: 5,
+      status: "parsing",
+      failureReason: null,
+      knowhereJobId: "job_retry",
+      knowhereDocumentId: null,
+      stagedBlobPathname: null,
+      stagedBlobUrl: null,
+      originalBlobPathname: "source-uploads/upload_1/document.pdf",
+      originalBlobUrl:
+        "https://store.public.blob.vercel-storage.com/source-uploads/upload_1/document.pdf",
+      demoKey: null,
+      createdAt: new Date("2026-05-10T00:00:00Z"),
+      updatedAt: new Date("2026-05-10T00:00:00Z"),
+      deletedAt: null,
+    });
+    mocks.startBackgroundReconciliation.mockResolvedValue(undefined);
+
+    const response = await PATCH(
+      new NextRequest("http://localhost:3001/api/sources/source_1", {
+        method: "PATCH",
+        body: JSON.stringify({ retry: true }),
+      }),
+      { params: Promise.resolve({ sourceId: "source_1" }) },
+    );
+
+    await expect(response.json()).resolves.toEqual({
+      source: {
+        id: "source_1",
+        kind: "workspace",
+        title: "lecture.pdf",
+        mimeType: "application/pdf",
+        status: "parsing",
+        documentId: undefined,
+        originalFile: {
+          url: "https://store.public.blob.vercel-storage.com/source-uploads/upload_1/document.pdf",
+          mimeType: "application/pdf",
+          sizeBytes: 5,
+        },
+      },
+    });
+    expect(response.status).toBe(200);
+    expect(mocks.retrySourceToKnowhere).toHaveBeenCalledWith(
+      { id: "workspace_1" },
+      expect.objectContaining({ id: "source_1", status: "failed" }),
+      knowhereClient,
+    );
+    expect(mocks.startBackgroundReconciliation).toHaveBeenCalledWith(
+      "workspace_1",
+      "source_1",
+      "jwt_123",
+    );
+  });
+
+  it("rejects retry requests for failed rows without a saved original Blob", async () => {
+    mocks.requireUser.mockResolvedValue({ id: "user_1" });
+    mocks.ensureWorkspace.mockResolvedValue({ id: "workspace_1" });
+    mocks.findSourceInWorkspace.mockResolvedValue({
+      id: "source_1",
+      status: "failed",
+      originalBlobPathname: null,
+      originalBlobUrl: null,
+    });
+
+    const response = await PATCH(
+      new NextRequest("http://localhost:3001/api/sources/source_1", {
+        method: "PATCH",
+        body: JSON.stringify({ retry: true }),
+      }),
+      { params: Promise.resolve({ sourceId: "source_1" }) },
+    );
+
+    await expect(response.json()).resolves.toEqual({
+      message:
+        "This source cannot be retried because its original file is unavailable.",
+    });
+    expect(response.status).toBe(409);
+    expect(mocks.ensureApiKeyForWorkspace).not.toHaveBeenCalled();
+    expect(mocks.retrySourceToKnowhere).not.toHaveBeenCalled();
+  });
 });
diff --git a/src/app/api/sources/[sourceId]/route.ts b/src/app/api/sources/[sourceId]/route.ts
index 9d30567..9d05d81 100644
--- a/src/app/api/sources/[sourceId]/route.ts
+++ b/src/app/api/sources/[sourceId]/route.ts
@@ -19,18 +19,19 @@ export async function PATCH(
 ): Promise<NextResponse> {
   const { sourceId } = await context.params
   const routeContext = await nextRouteContext.read()
-  const archiveRequest = await sourceRouteRequest.readArchiveSource({
+  const mutationRequest = await sourceRouteRequest.readSourceMutation({
     cookieHeader: routeContext.cookieHeader,
     request,
     sourceId,
   })
-  if (!archiveRequest.ok) {
-    return nextRouteResponse.toNextResponse(archiveRequest.result)
+  if (!mutationRequest.ok) {
+    return nextRouteResponse.toNextResponse(mutationRequest.result)
   }
 
-  const result = await sourceRouteService.archiveSource({
-    ...archiveRequest.input,
-  })
+  const result =
+    mutationRequest.mutation.kind === "archive"
+      ? await sourceRouteService.archiveSource(mutationRequest.mutation.input)
+      : await sourceRouteService.retrySource(mutationRequest.mutation.input)
 
   return nextRouteResponse.toNextResponse(result)
 }
diff --git a/src/components/source-row.test.ts b/src/components/source-row.test.ts
index 9faa567..26e413f 100644
--- a/src/components/source-row.test.ts
+++ b/src/components/source-row.test.ts
@@ -75,6 +75,99 @@ describe("SourceRow", () => {
       .toBeTruthy();
   });
 
+  it("shows failed source retry with a brief error message", () => {
+    const onRetryClick = vi.fn();
+    const onSelect = vi.fn();
+
+    render(
+      React.createElement(SourceRow, {
+        isArchiving: false,
+        isSelected: false,
+        onRetryClick,
+        onSelect,
+        source: {
+          id: "source_1",
+          mimeType: "application/pdf",
+          title: "lecture.pdf",
+          status: "failed",
+          failureMessage:
+            "Too many concurrent requests (2/2 active). Please retry after 30 seconds.",
+          originalFile: {
+            url: "https://store.public.blob.vercel-storage.com/source-uploads/upload_1/document.pdf",
+            mimeType: "application/pdf",
+          },
+        },
+      }),
+    );
+
+    fireEvent.click(
+      screen.getByRole("button", {
+        name: "Retry lecture.pdf processing",
+      }),
+    );
+
+    expect(
+      screen.getByText(
+        "Too many concurrent requests (2/2 active). Please retry after 30 seconds.",
+      ),
+    ).toBeTruthy();
+    expect(onRetryClick).toHaveBeenCalledWith("source_1");
+    expect(onSelect).not.toHaveBeenCalled();
+  });
+
+  it("shows failed source retry loading locally", () => {
+    render(
+      React.createElement(SourceRow, {
+        isArchiving: false,
+        isRetrying: true,
+        isSelected: false,
+        onRetryClick: vi.fn(),
+        onSelect: vi.fn(),
+        source: {
+          id: "source_1",
+          mimeType: "application/pdf",
+          title: "lecture.pdf",
+          status: "failed",
+          originalFile: {
+            url: "https://store.public.blob.vercel-storage.com/source-uploads/upload_1/document.pdf",
+            mimeType: "application/pdf",
+          },
+        },
+      }),
+    );
+
+    const retryButton = screen.getByRole("button", {
+      name: "Retry lecture.pdf processing",
+    });
+
+    expect((retryButton as HTMLButtonElement).disabled).toBe(true);
+    expect(within(retryButton).getByRole("status", { name: "Loading" }))
+      .toBeTruthy();
+  });
+
+  it("hides retry when a failed source has no saved original file", () => {
+    render(
+      React.createElement(SourceRow, {
+        isArchiving: false,
+        isSelected: false,
+        onRetryClick: vi.fn(),
+        onSelect: vi.fn(),
+        source: {
+          id: "source_1",
+          mimeType: "application/pdf",
+          title: "legacy.pdf",
+          status: "failed",
+        },
+      }),
+    );
+
+    expect(
+      screen.queryByRole("button", {
+        name: "Retry legacy.pdf processing",
+      }),
+    ).toBeNull();
+  });
+
   it("links ready sources to the document chunk tree route", () => {
     const onSelect = vi.fn();
 
diff --git a/src/components/source-row.tsx b/src/components/source-row.tsx
index 77cf9d7..abfe8cb 100644
--- a/src/components/source-row.tsx
+++ b/src/components/source-row.tsx
@@ -2,7 +2,7 @@
 
 import type { ReactElement } from "react";
 import Link from "next/link";
-import { FileText, ListTree, Plus, Trash2 } from "lucide-react";
+import { FileText, ListTree, Plus, RotateCcw, Trash2 } from "lucide-react";
 
 import { Checkbox } from "@/components/ui/checkbox";
 import { Spinner } from "@/components/ui/spinner";
@@ -13,9 +13,11 @@ export type SourceRowProps = {
   readonly isArchiving: boolean;
   readonly isAdding?: boolean;
   readonly isNarrow?: boolean;
+  readonly isRetrying?: boolean;
   readonly isSelected: boolean;
   readonly onAddClick?: (sourceId: string) => void;
   readonly onArchiveClick?: (sourceId: string) => void;
+  readonly onRetryClick?: (sourceId: string) => void;
   readonly onSelect: () => void;
   readonly onToggleIncluded?: (sourceId: string, included: boolean) => void;
   readonly source: SourceView;
@@ -30,12 +32,15 @@ export function SourceRow({
   onSelect,
   onToggleIncluded,
   onArchiveClick,
+  onRetryClick,
   chunkTreeHref,
   isArchiving,
+  isRetrying = false,
 }: SourceRowProps): ReactElement {
   const isReady = source.status === "ready";
   const isBusy = source.status === "uploading" || source.status === "parsing";
   const isFailed = source.status === "failed";
+  const canRetry = isFailed && source.originalFile !== undefined;
   const isLibrarySource = source.officialLibrary !== undefined;
   const isRemoteSource = source.kind === "remote";
 
@@ -104,6 +109,11 @@ export function SourceRow({
                   ? "Uploading"
                   : "Failed"}
           </p>
+          {isFailed && source.failureMessage ? (
+            <p className="mt-0.5 truncate text-[11px] font-medium normal-case tracking-normal text-destructive/80">
+              {source.failureMessage}
+            </p>
+          ) : null}
         </div>
       </button>
       <div className="flex shrink-0 items-center justify-self-end">
@@ -137,6 +147,26 @@ export function SourceRow({
             {isNarrow ? null : "Add"}
           </button>
         )}
+        {canRetry && onRetryClick ? (
+          <button
+            type="button"
+            disabled={isRetrying || isArchiving}
+            onClick={(event) => {
+              event.stopPropagation();
+              if (isRetrying || isArchiving) return;
+              onRetryClick(source.id);
+            }}
+            className="shrink-0 rounded-lg p-1 text-muted-foreground hover:bg-primary/10 hover:text-primary disabled:cursor-wait disabled:opacity-70"
+            aria-label={`Retry ${source.title} processing`}
+            title="Retry processing"
+          >
+            {isRetrying ? (
+              <Spinner className="size-3.5" />
+            ) : (
+              <RotateCcw className="size-3.5" />
+            )}
+          </button>
+        ) : null}
         {onArchiveClick && (
           <button
             type="button"
diff --git a/src/components/sources-panel.test.ts b/src/components/sources-panel.test.ts
index 362df06..fc2005c 100644
--- a/src/components/sources-panel.test.ts
+++ b/src/components/sources-panel.test.ts
@@ -373,6 +373,40 @@ describe("SourcesPanel", () => {
       .toBeTruthy();
   });
 
+  it("shows retry actions for failed source rows", () => {
+    const onRetrySource = vi.fn();
+
+    render(
+      React.createElement(C, {
+        sources: [
+          {
+            id: "source_1",
+            title: "lecture.pdf",
+            status: "failed",
+            failureMessage:
+              "Too many concurrent requests (2/2 active). Please retry after 30 seconds.",
+            originalFile: {
+              url: "https://store.public.blob.vercel-storage.com/source-uploads/upload_1/document.pdf",
+              mimeType: "application/pdf",
+            },
+          },
+        ],
+        onRetrySource,
+        retryingSourceIds: ["source_1"],
+      }),
+    );
+
+    const retryButton = screen.getByRole("button", {
+      name: "Retry lecture.pdf processing",
+    });
+    expect((retryButton as HTMLButtonElement).disabled).toBe(true);
+    expect(
+      screen.getByText(
+        "Too many concurrent requests (2/2 active). Please retry after 30 seconds.",
+      ),
+    ).toBeTruthy();
+  });
+
   it("uploads selected files through the sources API", async () => {
     const user = userEvent.setup();
     const uploadedSource = {
diff --git a/src/components/sources-panel.tsx b/src/components/sources-panel.tsx
index ef27ed8..70a0285 100644
--- a/src/components/sources-panel.tsx
+++ b/src/components/sources-panel.tsx
@@ -39,9 +39,11 @@ export type SourcesPanelProps = {
   onSelectSource?: (sourceId: string | null) => void;
   onToggleIncluded?: (sourceId: string, included: boolean) => void;
   onArchiveSource?: (sourceId: string) => void;
+  onRetrySource?: (sourceId: string) => void;
   onLibraryOpen?: () => void;
   onOfficialLibrarySourceAdd?: (demoSourceId: string) => void;
   archivingSourceIds?: readonly string[];
+  retryingSourceIds?: readonly string[];
   analyticsContext?: AnalyticsContext;
   sourceCountSnapshot?: number;
   /** When provided, the Upload button redirects to login instead of opening the dialog. */
@@ -65,8 +67,10 @@ export function SourcesPanel({
   onSelectSource,
   onToggleIncluded,
   onArchiveSource,
+  onRetrySource,
   onLibraryOpen,
   archivingSourceIds = [],
+  retryingSourceIds = [],
   analyticsContext,
   sourceCountSnapshot = sources.length,
   onLoginClick,
@@ -85,6 +89,7 @@ export function SourcesPanel({
     confirmSourceId,
     sources,
   });
+  const retryingSourceIdSet = new Set(retryingSourceIds);
   const workspaceSources = sources.filter(
     (source) => source.officialLibrary === undefined,
   );
@@ -241,7 +246,9 @@ export function SourcesPanel({
                   onArchiveClick={
                     onArchiveSource ? setConfirmSourceId : undefined
                   }
+                  onRetryClick={onRetrySource}
                   isArchiving={archivingSourceIdSet.has(source.id)}
+                  isRetrying={retryingSourceIdSet.has(source.id)}
                   isNarrow={isNarrow}
                 />
               ))}
diff --git a/src/components/workspace-shell-layout.tsx b/src/components/workspace-shell-layout.tsx
index 8c98141..235eb07 100644
--- a/src/components/workspace-shell-layout.tsx
+++ b/src/components/workspace-shell-layout.tsx
@@ -58,6 +58,7 @@ type WorkspaceChatState = {
 export type WorkspaceShellLayoutProps = {
   readonly addingLibrarySourceIds: readonly string[]
   readonly archivingSourceIds: readonly string[]
+  readonly retryingSourceIds?: readonly string[]
   readonly archivingThreadIds: readonly string[]
   readonly chat: WorkspaceChatState
   readonly chatThreads: readonly ChatThreadView[]
@@ -89,6 +90,7 @@ export type WorkspaceShellLayoutProps = {
   readonly analyticsContext?: AnalyticsContext
   readonly onArchiveChatThread: (threadId: string) => void | Promise<void>
   readonly onArchiveSource: (sourceId: string) => void | Promise<void>
+  readonly onRetrySource?: (sourceId: string) => void | Promise<void>
   readonly onChatSend: (text: string) => void | Promise<void>
   readonly onCitationClick: (
     citation: ChatCitationView,
@@ -131,6 +133,7 @@ export function WorkspaceShellLayout(
 ): ReactElement {
   const { onDesktopLayoutElementChange } = props
   const addingLibrarySourceIds = props.addingLibrarySourceIds ?? []
+  const retryingSourceIds = props.retryingSourceIds ?? []
   const officialLibrarySources = props.officialLibrarySources ?? []
   const selectedSourcesCount = props.sources.filter(
     (source) => !source.excludedFromQuery && source.status === "ready",
@@ -212,11 +215,15 @@ export function WorkspaceShellLayout(
                 onArchiveSource={
                   props.isGuest ? undefined : props.onArchiveSource
                 }
+                onRetrySource={
+                  props.isGuest ? undefined : props.onRetrySource
+                }
                 onOfficialLibrarySourceAdd={
                   props.isGuest ? undefined : props.onOfficialLibrarySourceAdd
                 }
                 onLibraryOpen={props.onLibraryOpen}
                 archivingSourceIds={[...props.archivingSourceIds]}
+                retryingSourceIds={[...retryingSourceIds]}
                 addingLibrarySourceIds={[...addingLibrarySourceIds]}
                 onLoginClick={props.isGuest ? props.onLoginClick : undefined}
               />
@@ -362,6 +369,7 @@ export function WorkspaceShellLayout(
           }}
           onToggleIncluded={props.isGuest ? undefined : props.onToggleIncluded}
           onArchiveSource={props.isGuest ? undefined : props.onArchiveSource}
+          onRetrySource={props.isGuest ? undefined : props.onRetrySource}
           onOfficialLibrarySourceAdd={
             props.isGuest ? undefined : props.onOfficialLibrarySourceAdd
           }
@@ -370,6 +378,7 @@ export function WorkspaceShellLayout(
             props.onMobilePanelChange("content")
           }}
           archivingSourceIds={[...props.archivingSourceIds]}
+          retryingSourceIds={[...retryingSourceIds]}
           addingLibrarySourceIds={[...addingLibrarySourceIds]}
           onLoginClick={props.isGuest ? props.onLoginClick : undefined}
         />
diff --git a/src/components/workspace-shell.tsx b/src/components/workspace-shell.tsx
index 98e34f4..254c91e 100644
--- a/src/components/workspace-shell.tsx
+++ b/src/components/workspace-shell.tsx
@@ -213,6 +213,7 @@ function WorkspaceShellContent({
   return (
     <WorkspaceShellLayout
       archivingSourceIds={sourceWorkflow.archivingSourceIds}
+      retryingSourceIds={sourceWorkflow.retryingSourceIds}
       addingLibrarySourceIds={sourceWorkflow.addingLibrarySourceIds}
       archivingThreadIds={chatWorkflow.archivingThreadIds}
       chat={chatWorkflow.chat}
@@ -245,6 +246,7 @@ function WorkspaceShellContent({
       analyticsContext={analyticsContext}
       onArchiveChatThread={chatWorkflow.handleArchiveChatThread}
       onArchiveSource={sourceWorkflow.handleArchiveSource}
+      onRetrySource={sourceWorkflow.handleRetrySource}
       onChatSend={chatWorkflow.handleChatSend}
       onCitationClick={citationFocus.handleCitationClick}
       onCreateChatThread={chatWorkflow.handleCreateChatThread}
diff --git a/src/components/workspace-source-workflow.test.ts b/src/components/workspace-source-workflow.test.ts
index c98b24c..c0414f5 100644
--- a/src/components/workspace-source-workflow.test.ts
+++ b/src/components/workspace-source-workflow.test.ts
@@ -10,6 +10,7 @@ const mocks = vi.hoisted(() => ({
   archiveSource: vi.fn(),
   fetchSources: vi.fn(),
   materializeDemoSources: vi.fn(),
+  retrySource: vi.fn(),
 }))
 
 vi.mock("@/domains/workspace/client", () => ({
@@ -17,11 +18,13 @@ vi.mock("@/domains/workspace/client", () => ({
     keys: {
       archiveSource: "archive-source",
       materializeDemoSources: "/api/demo-sources/materialize",
+      retrySource: "retry-source",
       sources: "/api/sources",
     },
     archiveSource: mocks.archiveSource,
     fetchSources: mocks.fetchSources,
     materializeDemoSources: mocks.materializeDemoSources,
+    retrySource: mocks.retrySource,
   },
 }))
 
@@ -92,6 +95,54 @@ describe("useWorkspaceSourceWorkflow", () => {
     expect(mocks.fetchSources).toHaveBeenCalled()
   })
 
+  it("retries a failed Source and upserts the returned parsing row", async () => {
+    const failedSource = makeSource({
+      id: "source_1",
+      status: "failed",
+      failureMessage:
+        "Too many concurrent requests (2/2 active). Please retry after 30 seconds.",
+    })
+    const parsingSource = makeSource({
+      id: "source_1",
+      status: "parsing",
+      failureMessage: undefined,
+    })
+    let resolveRetry:
+      | ((source: SourceView) => void)
+      | undefined
+    const retryPromise = new Promise<SourceView>((resolve) => {
+      resolveRetry = resolve
+    })
+    mocks.fetchSources.mockResolvedValue([parsingSource])
+    mocks.retrySource.mockReturnValue(retryPromise)
+
+    const { result } = renderWorkspaceSourceWorkflow({
+      initialSources: [failedSource],
+      isGuest: false,
+    })
+
+    let retryAction: Promise<void> | undefined
+    act(() => {
+      retryAction = result.current.handleRetrySource("source_1")
+    })
+    await waitFor(() => {
+      expect(result.current.retryingSourceIds).toEqual(["source_1"])
+    })
+    await act(async () => {
+      resolveRetry?.(parsingSource)
+      await retryAction
+    })
+
+    expect(mocks.retrySource).toHaveBeenCalledWith("source_1")
+    await waitFor(() => {
+      expect(result.current.sources[0]).toMatchObject({
+        id: "source_1",
+        status: "parsing",
+      })
+    })
+    expect(result.current.retryingSourceIds).toEqual([])
+  })
+
   it("refreshes immediately on mount when initial Sources are pending", async () => {
     const parsingSource = makeSource({
       id: "source_parsing",
diff --git a/src/components/workspace-source-workflow.ts b/src/components/workspace-source-workflow.ts
index a646323..9b9f1f8 100644
--- a/src/components/workspace-source-workflow.ts
+++ b/src/components/workspace-source-workflow.ts
@@ -19,6 +19,7 @@ type WorkspaceSourceWorkflow = {
   readonly addingLibrarySourceIds: string[]
   readonly archivingSourceIds: string[]
   readonly handleArchiveSource: (sourceId: string) => Promise<void>
+  readonly handleRetrySource: (sourceId: string) => Promise<void>
   readonly handleOfficialLibrarySourceAdd: (demoSourceId: string) => Promise<boolean>
   readonly handleSelectedSourceChange: (sourceId: string | null) => void
   readonly handleSourcesMaterialized: (
@@ -28,6 +29,7 @@ type WorkspaceSourceWorkflow = {
   readonly handleSourceUploaded: (source: SourceView) => void
   readonly handleToggleIncluded: (sourceId: string, included: boolean) => void
   readonly readySourceCount: number
+  readonly retryingSourceIds: string[]
   readonly selectedSourceId: string | null
   readonly setSelectedSourceId: (sourceId: string | null) => void
   readonly sourceTitlesByDocumentId: Readonly<Record<string, string>>
@@ -36,6 +38,7 @@ type WorkspaceSourceWorkflow = {
 
 const sourcesSWRKey = workspaceClient.keys.sources
 const archiveSourceSWRKey = workspaceClient.keys.archiveSource
+const retrySourceSWRKey = workspaceClient.keys.retrySource
 const materializeDemoSourceSWRKey = workspaceClient.keys.materializeDemoSources
 
 export function useWorkspaceSourceWorkflow({
@@ -55,6 +58,7 @@ export function useWorkspaceSourceWorkflow({
     Record<string, boolean>
   >({})
   const [archivingSourceIds, setArchivingSourceIds] = useState<string[]>([])
+  const [retryingSourceIds, setRetryingSourceIds] = useState<string[]>([])
   const [addingLibrarySourceIds, setAddingLibrarySourceIds] = useState<string[]>(
     [],
   )
@@ -95,6 +99,10 @@ export function useWorkspaceSourceWorkflow({
     archiveSourceSWRKey,
     archiveSourceMutation,
   )
+  const { trigger: retrySource } = useSWRMutation(
+    retrySourceSWRKey,
+    retrySourceMutation,
+  )
   const { trigger: materializeDemoSources } = useSWRMutation(
     materializeDemoSourceSWRKey,
     materializeDemoSourcesMutation,
@@ -181,6 +189,27 @@ export function useWorkspaceSourceWorkflow({
     }
   }
 
+  async function handleRetrySource(sourceId: string): Promise<void> {
+    setRetryingSourceIds((current) =>
+      workspaceSourceState.addPendingId(current, sourceId),
+    )
+    try {
+      const source = await retrySource(sourceId)
+      void mutateSources(
+        (current) =>
+          workspaceSourceState.upsertSource(current ?? sourceRows, source),
+        { revalidate: false },
+      )
+      void mutateSources()
+    } catch {
+      void mutateSources()
+    } finally {
+      setRetryingSourceIds((current) =>
+        workspaceSourceState.removePendingId(current, sourceId),
+      )
+    }
+  }
+
   async function handleOfficialLibrarySourceAdd(
     demoSourceId: string,
   ): Promise<boolean> {
@@ -205,12 +234,14 @@ export function useWorkspaceSourceWorkflow({
     addingLibrarySourceIds,
     archivingSourceIds,
     handleArchiveSource,
+    handleRetrySource,
     handleOfficialLibrarySourceAdd,
     handleSelectedSourceChange,
     handleSourcesMaterialized,
     handleSourceUploaded,
     handleToggleIncluded,
     readySourceCount,
+    retryingSourceIds,
     selectedSourceId: resolvedSelectedSourceId,
     setSelectedSourceId,
     sourceTitlesByDocumentId,
@@ -239,6 +270,13 @@ function archiveSourceMutation(
   return workspaceClient.archiveSource(sourceId)
 }
 
+function retrySourceMutation(
+  _key: string,
+  { arg: sourceId }: { readonly arg: string },
+): ReturnType<typeof workspaceClient.retrySource> {
+  return workspaceClient.retrySource(sourceId)
+}
+
 function materializeDemoSourcesMutation(
   _key: string,
   { arg: demoSourceIds }: { readonly arg: readonly string[] },
diff --git a/src/domains/sources/failure-message.test.ts b/src/domains/sources/failure-message.test.ts
new file mode 100644
index 0000000..ff1beb7
--- /dev/null
+++ b/src/domains/sources/failure-message.test.ts
@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest"
+
+import { sourceFailureMessage } from "./failure-message"
+
+describe("sourceFailureMessage", () => {
+  it("extracts the SDK rate-limit message from retry log text", () => {
+    const message = sourceFailureMessage.fromStoredReason(`
+Retry attempt 1 for POST /v1/jobs: Error [RateLimitError]: Too many concurrent requests (2/2 active). Please retry after 30 seconds.
+    at iM.handleError (.next/server/chunks/_11555_5._.js:3:44260)
+statusCode: 429,
+code: 'RESOURCE_EXHAUSTED',
+`)
+
+    expect(message).toBe(
+      "Too many concurrent requests (2/2 active). Please retry after 30 seconds.",
+    )
+  })
+
+  it("caps long stored failure messages", () => {
+    const message = sourceFailureMessage.fromStoredReason("x".repeat(220))
+
+    expect(message).toHaveLength(180)
+    expect(message?.endsWith("...")).toBe(true)
+  })
+
+  it("prefers nested API error messages when available", () => {
+    const message = sourceFailureMessage.fromUnknown(
+      {
+        body: {
+          error: {
+            message: "Too many concurrent requests.",
+          },
+        },
+      },
+      "Knowhere upload failed.",
+    )
+
+    expect(message).toBe("Too many concurrent requests.")
+  })
+})
diff --git a/src/domains/sources/failure-message.ts b/src/domains/sources/failure-message.ts
new file mode 100644
index 0000000..c3223e3
--- /dev/null
+++ b/src/domains/sources/failure-message.ts
@@ -0,0 +1,125 @@
+const maxFailureMessageLength = 180
+
+type SourceFailureMessage = {
+  readonly fromStoredReason: (
+    reason: string | null | undefined,
+  ) => string | undefined
+  readonly fromUnknown: (error: unknown, fallback: string) => string
+}
+
+function fromStoredReason(
+  reason: string | null | undefined,
+): string | undefined {
+  if (!reason) return undefined
+
+  const message = extractBriefMessage(reason)
+  if (!message) return undefined
+
+  return truncateMessage(message)
+}
+
+function fromUnknown(error: unknown, fallback: string): string {
+  return (
+    fromStoredReason(readErrorMessage(error)) ??
+    fromStoredReason(fallback) ??
+    fallback
+  )
+}
+
+function readErrorMessage(error: unknown): string | undefined {
+  if (error instanceof Error) {
+    const bodyMessage = readNestedBodyMessage(error)
+    const wrappedMessage = readWrappedErrorMessage(error)
+    return bodyMessage ?? wrappedMessage ?? error.message
+  }
+  if (typeof error === "string") return error
+  if (isRecord(error)) {
+    const bodyMessage = readNestedBodyMessage(error)
+    if (bodyMessage) return bodyMessage
+    const wrappedMessage = readWrappedErrorMessage(error)
+    if (wrappedMessage) return wrappedMessage
+    const message = error.message
+    if (typeof message === "string") return message
+  }
+
+  return undefined
+}
+
+function readWrappedErrorMessage(error: unknown): string | undefined {
+  if (!isRecord(error)) return undefined
+
+  const wrapped = error.error ?? error.cause
+  if (wrapped === undefined || wrapped === error) return undefined
+
+  return readErrorMessage(wrapped)
+}
+
+function readNestedBodyMessage(error: unknown): string | undefined {
+  if (!isRecord(error)) return undefined
+
+  const body = error.body
+  if (!isRecord(body)) return undefined
+
+  const nestedError = body.error
+  if (!isRecord(nestedError)) return undefined
+
+  return typeof nestedError.message === "string"
+    ? nestedError.message
+    : undefined
+}
+
+function extractBriefMessage(value: string): string {
+  const normalized = value.replace(/\r/g, "\n")
+  const messageProperty = normalized.match(
+    /['"]?message['"]?\s*:\s*['"]([^'"]+)['"]/u,
+  )
+  if (messageProperty?.[1]) {
+    return collapseWhitespace(messageProperty[1])
+  }
+
+  const firstMeaningfulLine = normalized
+    .split("\n")
+    .map((line) => line.trim())
+    .find(isMeaningfulFailureLine)
+  if (!firstMeaningfulLine) return ""
+
+  const errorMatch = firstMeaningfulLine.match(
+    /Error(?:\s+\[[^\]]+\])?:\s*(.+)$/u,
+  )
+  if (errorMatch?.[1]) {
+    return collapseWhitespace(errorMatch[1])
+  }
+
+  return collapseWhitespace(
+    firstMeaningfulLine.replace(/^Error:\s*/u, ""),
+  )
+}
+
+function isMeaningfulFailureLine(line: string): boolean {
+  if (!line) return false
+  if (line.startsWith("at ")) return false
+  if (line.startsWith("<unknown>")) return false
+  if (/^(statusCode|code|requestId|details|body|retryAfter):/u.test(line)) {
+    return false
+  }
+
+  return true
+}
+
+function collapseWhitespace(value: string): string {
+  return value.replace(/\s+/g, " ").trim()
+}
+
+function truncateMessage(message: string): string {
+  if (message.length <= maxFailureMessageLength) return message
+  return `${message.slice(0, maxFailureMessageLength - 3).trimEnd()}...`
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null
+}
+
+export const sourceFailureMessage: SourceFailureMessage = {
+  fromStoredReason,
+  fromUnknown,
+}
diff --git a/src/domains/sources/knowhere-upload.ts b/src/domains/sources/knowhere-upload.ts
index 63e00ca..cdfdca5 100644
--- a/src/domains/sources/knowhere-upload.ts
+++ b/src/domains/sources/knowhere-upload.ts
@@ -14,6 +14,7 @@ import type {
 import { validateUploadFile } from "./validation"
 import { TempFile, tempFileLayer } from "@/lib/temp-files"
 import { getUploadNamespace } from "./namespace"
+import { sourceFailureMessage } from "./failure-message"
 
 /**
  * Upload a browser file to Knowhere for parsing.
@@ -74,7 +75,10 @@ export const uploadSourceToKnowhereEffect = (
       Effect.provide(tempFileLayer),
       Effect.catchAll((err) =>
         Effect.gen(function* () {
-          const message = "Knowhere upload failed."
+          const message = sourceFailureMessage.fromUnknown(
+            err,
+            "Knowhere upload failed.",
+          )
           yield* Effect.promise(() =>
             deps.repository.markSourceFailed(
               workspace.id,
@@ -133,9 +137,12 @@ export const uploadSourceBlobToKnowhereEffect = (
         deps,
       })
     }).pipe(
-      Effect.catchAll(() =>
+      Effect.catchAll((err) =>
         Effect.gen(function* () {
-          const message = "Knowhere upload failed."
+          const message = sourceFailureMessage.fromUnknown(
+            err,
+            "Knowhere upload failed.",
+          )
           const failedSource = yield* Effect.promise(() =>
             deps.repository.markSourceFailed(
               workspace.id,
diff --git a/src/domains/sources/retry.test.ts b/src/domains/sources/retry.test.ts
new file mode 100644
index 0000000..86c03a1
--- /dev/null
+++ b/src/domains/sources/retry.test.ts
@@ -0,0 +1,139 @@
+import { Effect } from "effect"
+import { describe, expect, it, vi } from "vitest"
+
+import type { Source, Workspace } from "@/infrastructure/db/schema"
+import type { UploadJobResult } from "./source-upload-contracts"
+import { retrySourceToKnowhereEffect } from "./retry"
+
+const workspace: Workspace = {
+  id: "workspace_1",
+  userId: "user_1",
+  namespace: "notebook-workspace_1",
+  createdAt: new Date("2026-05-10T00:00:00Z"),
+}
+
+describe("retrySourceToKnowhereEffect", () => {
+  it("creates a new URL parse job from the saved original Blob", async () => {
+    const failedSource = makeSource()
+    const parsingSource = makeSource({
+      status: "parsing",
+      failureReason: null,
+      knowhereJobId: "job_retry",
+      knowhereDocumentId: "doc_retry",
+    })
+    const retryJob: UploadJobResult = {
+      jobId: "job_retry",
+      status: "pending",
+      sourceType: "url",
+      documentId: "doc_retry",
+      createdAt: new Date("2026-05-10T00:00:00Z"),
+    }
+    const deps = {
+      repository: {
+        markSourceFailed: vi.fn(),
+        markSourceParsing: vi.fn(async () => parsingSource),
+      },
+      knowhere: {
+        jobs: {
+          create: vi.fn(async () => retryJob),
+          get: vi.fn(),
+          upload: vi.fn(),
+        },
+      },
+    }
+
+    const result = await Effect.runPromise(
+      retrySourceToKnowhereEffect(workspace, failedSource, deps),
+    )
+
+    expect(deps.knowhere.jobs.create).toHaveBeenCalledWith({
+      sourceType: "url",
+      sourceUrl:
+        "https://store.public.blob.vercel-storage.com/source-uploads/upload_1/document.pdf",
+      fileName: "notes.pdf",
+      namespace: "default",
+      documentMetadata: {
+        createdByClient: "notebook",
+        sourceFileName: "notes.pdf",
+        title: "notes.pdf",
+        mimeType: "application/pdf",
+        sizeBytes: 5,
+      },
+    })
+    expect(deps.repository.markSourceParsing).toHaveBeenCalledWith(
+      workspace.id,
+      failedSource.id,
+      "job_retry",
+      "doc_retry",
+      "failed",
+    )
+    expect(result).toBe(parsingSource)
+  })
+
+  it("keeps the source failed with a brief retry error when Knowhere rejects the job", async () => {
+    const failedSource = makeSource()
+    const updatedFailedSource = makeSource({
+      failureReason:
+        "Too many concurrent requests (2/2 active). Please retry after 30 seconds.",
+    })
+    const deps = {
+      repository: {
+        markSourceFailed: vi.fn(async () => updatedFailedSource),
+        markSourceParsing: vi.fn(),
+      },
+      knowhere: {
+        jobs: {
+          create: vi.fn(async () => {
+            throw Object.assign(new Error("Rate limited."), {
+              body: {
+                error: {
+                  message:
+                    "Too many concurrent requests (2/2 active). Please retry after 30 seconds.",
+                },
+              },
+            })
+          }),
+          get: vi.fn(),
+          upload: vi.fn(),
+        },
+      },
+    }
+
+    const result = await Effect.runPromise(
+      retrySourceToKnowhereEffect(workspace, failedSource, deps),
+    )
+
+    expect(result).toBe(updatedFailedSource)
+    expect(deps.repository.markSourceParsing).not.toHaveBeenCalled()
+    expect(deps.repository.markSourceFailed).toHaveBeenCalledWith(
+      workspace.id,
+      failedSource.id,
+      "Too many concurrent requests (2/2 active). Please retry after 30 seconds.",
+      "failed",
+    )
+  })
+})
+
+function makeSource(overrides: Partial<Source> = {}): Source {
+  return {
+    id: "source_1",
+    workspaceId: workspace.id,
+    title: "notes.pdf",
+    mimeType: "application/pdf",
+    sizeBytes: 5,
+    status: "failed",
+    failureReason: "Knowhere upload failed.",
+    knowhereJobId: null,
+    knowhereDocumentId: null,
+    stagedBlobPathname: null,
+    stagedBlobUrl: null,
+    originalBlobPathname: "source-uploads/upload_1/document.pdf",
+    originalBlobUrl:
+      "https://store.public.blob.vercel-storage.com/source-uploads/upload_1/document.pdf",
+    demoKey: null,
+    createdAt: new Date("2026-05-10T00:00:00Z"),
+    updatedAt: new Date("2026-05-10T00:00:00Z"),
+    deletedAt: null,
+    ...overrides,
+  }
+}
diff --git a/src/domains/sources/retry.ts b/src/domains/sources/retry.ts
new file mode 100644
index 0000000..15ada9a
--- /dev/null
+++ b/src/domains/sources/retry.ts
@@ -0,0 +1,144 @@
+import "server-only"
+
+import { Effect } from "effect"
+
+import type { Source, Workspace } from "@/infrastructure/db/schema"
+import { getUploadNamespace } from "./namespace"
+import type {
+  UploadJobResult,
+  UploadKnowhereClient,
+} from "./source-upload-contracts"
+import { sourceFailureMessage } from "./failure-message"
+
+type RetrySourceRepository = {
+  readonly markSourceParsing: (
+    workspaceId: string,
+    sourceId: string,
+    jobId: string,
+    documentId?: string,
+    requiredStatus?: string,
+  ) => Promise<Source | null>
+  readonly markSourceFailed: (
+    workspaceId: string,
+    sourceId: string,
+    reason: string,
+    requiredStatus?: string,
+  ) => Promise<Source | null>
+}
+
+type RetrySourceDependencies = {
+  readonly knowhere: UploadKnowhereClient
+  readonly repository: RetrySourceRepository
+}
+
+export const retrySourceToKnowhereEffect = (
+  workspace: Workspace,
+  source: Source,
+  deps: RetrySourceDependencies,
+) =>
+  Effect.gen(function* () {
+    if (source.status !== "failed") {
+      return yield* Effect.die(
+        new Error("Only failed sources can be retried."),
+      )
+    }
+
+    const originalBlobUrl = source.originalBlobUrl
+    const originalBlobPathname = source.originalBlobPathname
+    if (!originalBlobUrl || !originalBlobPathname) {
+      return yield* Effect.die(
+        new Error(
+          "This source cannot be retried because its original file is unavailable.",
+        ),
+      )
+    }
+
+    return yield* Effect.gen(function* () {
+      const job = yield* Effect.tryPromise(() =>
+        deps.knowhere.jobs.create({
+          sourceType: "url",
+          sourceUrl: originalBlobUrl,
+          fileName: source.title,
+          namespace: getUploadNamespace(),
+          documentMetadata: createNotebookDocumentMetadata({
+            title: source.title,
+            mimeType: source.mimeType,
+            sizeBytes: source.sizeBytes,
+          }),
+        }),
+      )
+      const documentId = yield* tryGetPlannedDocumentIdEffect(job, deps)
+      const parsingSource = yield* Effect.promise(() =>
+        deps.repository.markSourceParsing(
+          workspace.id,
+          source.id,
+          job.jobId,
+          documentId ?? undefined,
+          "failed",
+        ),
+      )
+
+      if (!parsingSource) {
+        return yield* Effect.die(
+          new Error("Source is no longer failed."),
+        )
+      }
+
+      return parsingSource
+    }).pipe(
+      Effect.catchAll((err) =>
+        Effect.gen(function* () {
+          const message = sourceFailureMessage.fromUnknown(
+            err,
+            "Knowhere upload failed.",
+          )
+          const failedSource = yield* Effect.promise(() =>
+            deps.repository.markSourceFailed(
+              workspace.id,
+              source.id,
+              message,
+              "failed",
+            ),
+          )
+          return failedSource ?? source
+        }),
+      ),
+    )
+  })
+
+const tryGetPlannedDocumentIdEffect = (
+  job: UploadJobResult,
+  deps: RetrySourceDependencies,
+) => {
+  const plannedDocumentId = getDocumentId(job)
+  if (plannedDocumentId !== null) {
+    return Effect.succeed(plannedDocumentId)
+  }
+
+  return Effect.gen(function* () {
+    const currentJob = yield* Effect.tryPromise(() =>
+      deps.knowhere.jobs.get(job.jobId),
+    )
+    return getDocumentId(currentJob)
+  }).pipe(Effect.catchAll(() => Effect.succeed(null)))
+}
+
+function createNotebookDocumentMetadata(input: {
+  readonly title: string
+  readonly mimeType: string
+  readonly sizeBytes: number
+}): Readonly<Record<string, unknown>> {
+  return {
+    createdByClient: "notebook",
+    sourceFileName: input.title,
+    title: input.title,
+    mimeType: input.mimeType,
+    sizeBytes: input.sizeBytes,
+  }
+}
+
+function getDocumentId(job: UploadJobResult): string | null {
+  return typeof job.documentId === "string" && job.documentId.length > 0
+    ? job.documentId
+    : null
+}
diff --git a/src/domains/sources/route-dependencies.ts b/src/domains/sources/route-dependencies.ts
index d056e1c..25313ce 100644
--- a/src/domains/sources/route-dependencies.ts
+++ b/src/domains/sources/route-dependencies.ts
@@ -53,6 +53,7 @@ const defaultDependencies: SourceRouteServiceDependencies = {
     softDelete: defaultSourceService.softDelete,
     upsertMaterializedDemoSource:
       defaultSourceService.upsertMaterializedDemoSource,
+    retrySourceToKnowhere: defaultSourceService.retrySourceToKnowhere,
     uploadSourceBlobToKnowhere: defaultSourceService.uploadSourceBlobToKnowhere,
     uploadSourceToKnowhere: defaultSourceService.uploadSourceToKnowhere,
   },
diff --git a/src/domains/sources/route-request.test.ts b/src/domains/sources/route-request.test.ts
index d0fc9d9..9fa3a44 100644
--- a/src/domains/sources/route-request.test.ts
+++ b/src/domains/sources/route-request.test.ts
@@ -22,8 +22,30 @@ describe("sourceRouteRequest", () => {
     });
   });
 
+  it("reads a valid retry request into route service input", async () => {
+    const result = await sourceRouteRequest.readSourceMutation({
+      cookieHeader: "session=abc",
+      request: new Request("http://localhost/api/sources/source_1", {
+        method: "PATCH",
+        body: JSON.stringify({ retry: true }),
+      }),
+      sourceId: "source_1",
+    });
+
+    expect(result).toEqual({
+      ok: true,
+      mutation: {
+        kind: "retry",
+        input: {
+          cookieHeader: "session=abc",
+          sourceId: "source_1",
+        },
+      },
+    });
+  });
+
   it("returns route-ready errors for invalid archive requests", async () => {
-    const result = await sourceRouteRequest.readArchiveSource({
+    const result = await sourceRouteRequest.readSourceMutation({
       cookieHeader: "",
       request: new Request("http://localhost/api/sources/source_1", {
         method: "PATCH",
@@ -36,7 +58,9 @@ describe("sourceRouteRequest", () => {
       ok: false,
       result: {
         status: 400,
-        body: { message: "Request body must include `archived: true`." },
+        body: {
+          message: "Request body must include `archived: true` or `retry: true`.",
+        },
       },
     });
   });
diff --git a/src/domains/sources/route-request.ts b/src/domains/sources/route-request.ts
index 7a73573..46fb057 100644
--- a/src/domains/sources/route-request.ts
+++ b/src/domains/sources/route-request.ts
@@ -1,9 +1,13 @@
 import { Schema } from "effect"
 
-import type { ArchiveSourceInput, JsonRouteResult } from "./route-types"
+import type {
+  ArchiveSourceInput,
+  JsonRouteResult,
+  RetrySourceInput,
+} from "./route-types"
 import { routeResult } from "@/lib/route-result"
 
-type ArchiveSourceRequestInput = {
+type SourceMutationRequestInput = {
   readonly cookieHeader: string
   readonly request: Request
   readonly sourceId: string
@@ -19,21 +23,68 @@ type ArchiveSourceReadResult =
       readonly result: JsonRouteResult<{ readonly message: string }>
     }
 
+type SourceMutationReadResult =
+  | {
+      readonly ok: true
+      readonly mutation:
+        | {
+            readonly kind: "archive"
+            readonly input: ArchiveSourceInput
+          }
+        | {
+            readonly kind: "retry"
+            readonly input: RetrySourceInput
+          }
+    }
+  | {
+      readonly ok: false
+      readonly result: JsonRouteResult<{ readonly message: string }>
+    }
+
 type SourceRouteRequest = {
   readonly readArchiveSource: (
-    input: ArchiveSourceRequestInput,
+    input: SourceMutationRequestInput,
   ) => Promise<ArchiveSourceReadResult>
+  readonly readSourceMutation: (
+    input: SourceMutationRequestInput,
+  ) => Promise<SourceMutationReadResult>
 }
 
 const ArchiveRequest = Schema.Struct({
   archived: Schema.Literal(true),
 })
 
+const RetryRequest = Schema.Struct({
+  retry: Schema.Literal(true),
+})
+
 async function readArchiveSource({
   cookieHeader,
   request,
   sourceId,
-}: ArchiveSourceRequestInput): Promise<ArchiveSourceReadResult> {
+}: SourceMutationRequestInput): Promise<ArchiveSourceReadResult> {
+  const result = await readSourceMutation({ cookieHeader, request, sourceId })
+  if (!result.ok) return result
+  if (result.mutation.kind !== "archive") {
+    return {
+      ok: false,
+      result: routeResult.badRequest(
+        "Request body must include `archived: true`.",
+      ),
+    }
+  }
+
+  return {
+    ok: true,
+    input: result.mutation.input,
+  }
+}
+
+async function readSourceMutation({
+  cookieHeader,
+  request,
+  sourceId,
+}: SourceMutationRequestInput): Promise<SourceMutationReadResult> {
   const body = await routeResult.readJson(request)
   if (!body.ok) {
     return {
@@ -42,24 +93,41 @@ async function readArchiveSource({
     }
   }
 
-  if (Schema.decodeUnknownEither(ArchiveRequest)(body.value)._tag === "Left") {
+  if (Schema.decodeUnknownEither(ArchiveRequest)(body.value)._tag === "Right") {
     return {
-      ok: false,
-      result: routeResult.badRequest(
-        "Request body must include `archived: true`.",
-      ),
+      ok: true,
+      mutation: {
+        kind: "archive",
+        input: {
+          cookieHeader,
+          sourceId,
+        },
+      },
+    }
+  }
+
+  if (Schema.decodeUnknownEither(RetryRequest)(body.value)._tag === "Right") {
+    return {
+      ok: true,
+      mutation: {
+        kind: "retry",
+        input: {
+          cookieHeader,
+          sourceId,
+        },
+      },
     }
   }
 
   return {
-    ok: true,
-    input: {
-      cookieHeader,
-      sourceId,
-    },
+    ok: false,
+    result: routeResult.badRequest(
+      "Request body must include `archived: true` or `retry: true`.",
+    ),
   }
 }
 
 export const sourceRouteRequest: SourceRouteRequest = {
   readArchiveSource,
+  readSourceMutation,
 }
diff --git a/src/domains/sources/route-retry.ts b/src/domains/sources/route-retry.ts
new file mode 100644
index 0000000..68464bb
--- /dev/null
+++ b/src/domains/sources/route-retry.ts
@@ -0,0 +1,78 @@
+import { Effect } from "effect"
+
+import { routeResult } from "@/lib/route-result"
+import { startBackgroundReconciliation } from "./background-reconcile"
+import { toSourceView } from "./view"
+import type {
+  JsonRouteResult,
+  RetrySourceBody,
+  RetrySourceInput,
+  SourceRouteServiceDependencies,
+} from "./route-types"
+
+type RouteRetryDependencies = Pick<
+  SourceRouteServiceDependencies,
+  | "ensureApiKeyForWorkspace"
+  | "ensureWorkspace"
+  | "makeKnowhereClient"
+  | "requireUser"
+  | "sourceService"
+>
+
+type RouteRetry = {
+  readonly retrySource: (
+    input: RetrySourceInput,
+  ) => Promise<JsonRouteResult<RetrySourceBody>>
+}
+
+function createRouteRetry(deps: RouteRetryDependencies): RouteRetry {
+  return {
+    retrySource: (input: RetrySourceInput) =>
+      Effect.runPromise(retrySourceEffect(input, deps)),
+  }
+}
+
+const retrySourceEffect = (
+  input: RetrySourceInput,
+  deps: RouteRetryDependencies,
+) =>
+  Effect.gen(function* () {
+    const user = yield* Effect.tryPromise(() => deps.requireUser())
+    const workspace = yield* Effect.tryPromise(() =>
+      deps.ensureWorkspace(user.id),
+    )
+
+    const source = yield* Effect.tryPromise(() =>
+      deps.sourceService.findInWorkspace(workspace.id, input.sourceId),
+    )
+    if (!source) {
+      return routeResult.error(404, "Source not found.")
+    }
+    if (source.status !== "failed") {
+      return routeResult.error(409, "Only failed sources can be retried.")
+    }
+    if (!source.originalBlobUrl || !source.originalBlobPathname) {
+      return routeResult.error(
+        409,
+        "This source cannot be retried because its original file is unavailable.",
+      )
+    }
+
+    const apiKey = yield* Effect.tryPromise(() =>
+      deps.ensureApiKeyForWorkspace(workspace.id, input.cookieHeader),
+    )
+    const client = deps.makeKnowhereClient(apiKey)
+    const retriedSource = yield* Effect.tryPromise(() =>
+      deps.sourceService.retrySourceToKnowhere(workspace, source, client),
+    )
+
+    if (retriedSource.status === "parsing") {
+      yield* Effect.tryPromise(() =>
+        startBackgroundReconciliation(workspace.id, retriedSource.id, apiKey),
+      )
+    }
+
+    return routeResult.ok({ source: toSourceView(retriedSource) })
+  })
+
+export { createRouteRetry }
diff --git a/src/domains/sources/route-service.test.ts b/src/domains/sources/route-service.test.ts
index 34b8855..3d11b96 100644
--- a/src/domains/sources/route-service.test.ts
+++ b/src/domains/sources/route-service.test.ts
@@ -787,6 +787,131 @@ describe("source route service", () => {
     );
     expect(onUploadFinished).toHaveBeenCalledOnce();
   });
+
+  it("retries a failed source from its saved original Blob", async () => {
+    const failedSource: Source = {
+      ...source,
+      status: "failed",
+      failureReason: "Knowhere upload failed.",
+      originalBlobPathname: "source-uploads/upload_1/document.pdf",
+      originalBlobUrl:
+        "https://store.public.blob.vercel-storage.com/source-uploads/upload_1/document.pdf",
+    };
+    const parsingSource: Source = {
+      ...failedSource,
+      status: "parsing",
+      failureReason: null,
+      knowhereJobId: "job_retry",
+    };
+    const knowhereClient = {
+      jobs: {
+        create: vi.fn(),
+        get: vi.fn(),
+        upload: vi.fn(),
+      },
+      documents: {
+        archive: vi.fn(async () => undefined),
+        listChunks: vi.fn(async () => ({
+          chunks: [],
+          pagination: {
+            page: 1,
+            pageSize: 1,
+            total: 0,
+            totalPages: 0,
+          },
+        })),
+      },
+    };
+    const ensureApiKeyForWorkspace = vi.fn(async () => "jwt_123");
+    const retrySourceToKnowhere = vi.fn(async () => parsingSource);
+    const service = createSourceRouteService({
+      ensureApiKeyForWorkspace,
+      ensureWorkspace: vi.fn(async () => workspace),
+      makeKnowhereClient: vi.fn(() => knowhereClient),
+      requireUser: vi.fn(async () => ({
+        id: "user_1",
+        email: null,
+        name: null,
+      })),
+      sourceService: {
+        findInWorkspace: vi.fn(async () => failedSource),
+        retrySourceToKnowhere,
+      },
+    });
+
+    const result = await service.retrySource({
+      cookieHeader: "session=abc",
+      sourceId: "source_1",
+    });
+
+    expect(result).toEqual({
+      status: 200,
+      body: {
+        source: {
+          id: "source_1",
+          kind: "workspace",
+          title: "notes.pdf",
+          status: "parsing",
+          mimeType: "application/pdf",
+          documentId: undefined,
+          originalFile: {
+            url: "https://store.public.blob.vercel-storage.com/source-uploads/upload_1/document.pdf",
+            mimeType: "application/pdf",
+            sizeBytes: 5,
+          },
+        },
+      },
+    });
+    expect(ensureApiKeyForWorkspace).toHaveBeenCalledWith(
+      workspace.id,
+      "session=abc",
+    );
+    expect(retrySourceToKnowhere).toHaveBeenCalledWith(
+      workspace,
+      failedSource,
+      knowhereClient,
+    );
+  });
+
+  it("rejects retry when the failed source has no saved original Blob", async () => {
+    const failedSource: Source = {
+      ...source,
+      status: "failed",
+      failureReason: "Knowhere upload failed.",
+      originalBlobPathname: null,
+      originalBlobUrl: null,
+    };
+    const ensureApiKeyForWorkspace = vi.fn(async () => "jwt_123");
+    const retrySourceToKnowhere = vi.fn();
+    const service = createSourceRouteService({
+      ensureApiKeyForWorkspace,
+      ensureWorkspace: vi.fn(async () => workspace),
+      requireUser: vi.fn(async () => ({
+        id: "user_1",
+        email: null,
+        name: null,
+      })),
+      sourceService: {
+        findInWorkspace: vi.fn(async () => failedSource),
+        retrySourceToKnowhere,
+      },
+    });
+
+    const result = await service.retrySource({
+      cookieHeader: "session=abc",
+      sourceId: "source_1",
+    });
+
+    expect(result).toEqual({
+      status: 409,
+      body: {
+        message:
+          "This source cannot be retried because its original file is unavailable.",
+      },
+    });
+    expect(ensureApiKeyForWorkspace).not.toHaveBeenCalled();
+    expect(retrySourceToKnowhere).not.toHaveBeenCalled();
+  });
 });
 
 const emptyDemoCatalog: DemoCatalog = {
diff --git a/src/domains/sources/route-service.ts b/src/domains/sources/route-service.ts
index 7b869f7..9a19bef 100644
--- a/src/domains/sources/route-service.ts
+++ b/src/domains/sources/route-service.ts
@@ -4,11 +4,13 @@ import { createRouteArchive } from "./route-archive"
 import { createRouteChunks } from "./route-chunks"
 import { createSourceRouteDependencies } from "./route-dependencies"
 import { createRouteListing } from "./route-listing"
+import { createRouteRetry } from "./route-retry"
 import { createRouteUpload } from "./route-upload"
 import type {
   ArchiveSourceInput,
   ListSourcesInput,
   LoadSourceChunksInput,
+  RetrySourceInput,
   SourceRouteService,
   SourceRouteServiceOverrides,
   UploadSourceInput,
@@ -21,12 +23,14 @@ export function createSourceRouteService(
   const listing = createRouteListing(deps)
   const upload = createRouteUpload(deps)
   const archive = createRouteArchive(deps)
+  const retry = createRouteRetry(deps)
   const chunks = createRouteChunks(deps)
 
   return {
     listSources: (input: ListSourcesInput) => listing.listSources(input),
     uploadSource: (input: UploadSourceInput) => upload.uploadSource(input),
     archiveSource: (input: ArchiveSourceInput) => archive.archiveSource(input),
+    retrySource: (input: RetrySourceInput) => retry.retrySource(input),
     loadSourceChunks: (input: LoadSourceChunksInput) =>
       chunks.loadSourceChunks(input),
   }
diff --git a/src/domains/sources/route-types.ts b/src/domains/sources/route-types.ts
index 998e792..7303ec3 100644
--- a/src/domains/sources/route-types.ts
+++ b/src/domains/sources/route-types.ts
@@ -93,6 +93,14 @@ type ArchiveSourceBody =
       readonly message: string
     }
 
+type RetrySourceBody =
+  | {
+      readonly source: SourceView
+    }
+  | {
+      readonly message: string
+    }
+
 type SourceChunksBody =
   | {
       readonly chunks: readonly ParsedChunkView[]
@@ -117,6 +125,11 @@ type ArchiveSourceInput = {
   readonly sourceId: string
 }
 
+type RetrySourceInput = {
+  readonly cookieHeader: string
+  readonly sourceId: string
+}
+
 type LoadSourceChunksInput = {
   readonly cookieHeader: string
   readonly sourceId: string
@@ -134,6 +147,9 @@ type SourceRouteService = {
   readonly archiveSource: (
     input: ArchiveSourceInput,
   ) => Promise<JsonRouteResult<ArchiveSourceBody>>
+  readonly retrySource: (
+    input: RetrySourceInput,
+  ) => Promise<JsonRouteResult<RetrySourceBody>>
   readonly loadSourceChunks: (
     input: LoadSourceChunksInput,
   ) => Promise<JsonRouteResult<SourceChunksBody>>
@@ -150,6 +166,11 @@ type SourceWorkflowService = {
     input: SourceBlobUploadInput,
     knowhere: UploadKnowhereClient,
   ) => Promise<Source>
+  readonly retrySourceToKnowhere: (
+    workspace: Workspace,
+    source: Source,
+    knowhere: UploadKnowhereClient,
+  ) => Promise<Source>
   readonly findInWorkspace: (
     workspaceId: string,
     sourceId: string,
@@ -245,6 +266,8 @@ export type {
   ListSourcesBody,
   ListSourcesInput,
   LoadSourceChunksInput,
+  RetrySourceBody,
+  RetrySourceInput,
   SourceChunksBody,
   SourceRouteDemoApi,
   SourceRouteKnowhereClient,
diff --git a/src/domains/sources/route-upload.ts b/src/domains/sources/route-upload.ts
index 4c3fc7d..c1f03dc 100644
--- a/src/domains/sources/route-upload.ts
+++ b/src/domains/sources/route-upload.ts
@@ -84,9 +84,11 @@ const uploadSourceEffect = (
       ),
     )
 
-    yield* Effect.tryPromise(() =>
-      startBackgroundReconciliation(workspace.id, source.id, apiKey),
-    )
+    if (source.status === "parsing") {
+      yield* Effect.tryPromise(() =>
+        startBackgroundReconciliation(workspace.id, source.id, apiKey),
+      )
+    }
 
     return routeResult.ok({ source: toSourceView(source) }, 201)
   })
diff --git a/src/domains/sources/service.ts b/src/domains/sources/service.ts
index b5d39b3..0d7c7f6 100644
--- a/src/domains/sources/service.ts
+++ b/src/domains/sources/service.ts
@@ -9,6 +9,7 @@ import {
   uploadSourceBlobToKnowhereEffect,
   uploadSourceToKnowhereEffect,
 } from "./upload"
+import { retrySourceToKnowhereEffect } from "./retry"
 import { sourceWorkflowRuntime } from "./workflow-runtime"
 
 type SourceService = {
@@ -55,6 +56,11 @@ type SourceService = {
     input: SourceBlobUploadInput,
     knowhere: UploadKnowhereClient,
   ) => Promise<Source>
+  readonly retrySourceToKnowhere: (
+    workspace: Workspace,
+    source: Source,
+    knowhere: UploadKnowhereClient,
+  ) => Promise<Source>
 }
 
 const uploadSourceToKnowhere: SourceService["uploadSourceToKnowhere"] = (
@@ -82,6 +88,21 @@ const uploadSourceBlobToKnowhere: SourceService["uploadSourceBlobToKnowhere"] =
       }),
     )
 
+const retrySourceToKnowhere: SourceService["retrySourceToKnowhere"] = (
+  workspace: Workspace,
+  source: Source,
+  knowhere: UploadKnowhereClient,
+) =>
+  Effect.runPromise(
+    retrySourceToKnowhereEffect(workspace, source, {
+      repository: {
+        markSourceFailed: sourceWorkflowRuntime.markFailed,
+        markSourceParsing: sourceWorkflowRuntime.markParsing,
+      },
+      knowhere,
+    }),
+  )
+
 export const sourceService: SourceService = {
   findInWorkspace: sourceWorkflowRuntime.findInWorkspace,
   getParseAssetUrls: sourceWorkflowRuntime.getParseAssetUrls,
@@ -95,4 +116,5 @@ export const sourceService: SourceService = {
     sourceWorkflowRuntime.upsertMaterializedDemoSource,
   uploadSourceToKnowhere,
   uploadSourceBlobToKnowhere,
+  retrySourceToKnowhere,
 }
diff --git a/src/domains/sources/types.ts b/src/domains/sources/types.ts
index e6246be..e1abe9e 100644
--- a/src/domains/sources/types.ts
+++ b/src/domains/sources/types.ts
@@ -40,6 +40,8 @@ export type SourceView = {
   /** Browser-provided content type for preview routing. */
   readonly mimeType: string
   readonly status: SourceStatus
+  /** Brief user-visible parse failure reason. Present only for failed rows. */
+  readonly failureMessage?: string
   /** Knowhere document ID once parsing publishes. */
   readonly documentId?: string
   /** Public Blob URL for original-file preview and download. */
diff --git a/src/domains/sources/upload.test.ts b/src/domains/sources/upload.test.ts
index 9632731..912ab9d 100644
--- a/src/domains/sources/upload.test.ts
+++ b/src/domains/sources/upload.test.ts
@@ -137,7 +137,7 @@ describe("uploadSourceToKnowhere", () => {
     const uploadingSource = makeSource();
     const failedSource = makeSource({
       status: "failed",
-      failureReason: "Knowhere upload failed.",
+      failureReason: "network",
     });
     const deps = {
       repository: {
@@ -165,12 +165,12 @@ describe("uploadSourceToKnowhere", () => {
         new File(["hello"], "notes.pdf", { type: "application/pdf" }),
         deps,
       ),
-    ).rejects.toThrow(/Knowhere upload failed/);
+    ).rejects.toThrow(/network/);
 
     expect(deps.repository.markSourceFailed).toHaveBeenCalledWith(
       workspace.id,
       uploadingSource.id,
-      "Knowhere upload failed.",
+      "network",
     );
     expect(deps.knowhere.jobs.get).not.toHaveBeenCalled();
   });
@@ -405,7 +405,7 @@ describe("uploadSourceToKnowhere", () => {
     const failedSource = makeSource({
       title: "large.pdf",
       status: "failed",
-      failureReason: "Knowhere upload failed.",
+      failureReason: "network",
       sizeBytes: 5,
       originalBlobPathname: "source-uploads/upload_1/document.pdf",
       originalBlobUrl: "https://store.public.blob.vercel-storage.com/source-uploads/upload_1/document.pdf",
@@ -444,7 +444,7 @@ describe("uploadSourceToKnowhere", () => {
     expect(deps.repository.markSourceFailed).toHaveBeenCalledWith(
       workspace.id,
       uploadingSource.id,
-      "Knowhere upload failed.",
+      "network",
     );
   });
 });
diff --git a/src/domains/sources/view.test.ts b/src/domains/sources/view.test.ts
index e9875a9..e854c29 100644
--- a/src/domains/sources/view.test.ts
+++ b/src/domains/sources/view.test.ts
@@ -53,7 +53,7 @@ describe("toSourceView", () => {
     });
   });
 
-  it("does not expose internal job ids or failure internals", () => {
+  it("does not expose internal job ids or non-failed failure internals", () => {
     expect(
       toSourceView(
         makeSource({
@@ -72,6 +72,28 @@ describe("toSourceView", () => {
     });
   });
 
+  it("exposes a brief failed message for failed source rows", () => {
+    expect(
+      toSourceView(
+        makeSource({
+          status: "failed",
+          knowhereDocumentId: null,
+          failureReason:
+            "Retry attempt 1 for POST /v1/jobs: Error [RateLimitError]: Too many concurrent requests (2/2 active). Please retry after 30 seconds.\n    at iM.handleError",
+        }),
+      ),
+    ).toEqual({
+      id: "source_1",
+      kind: "workspace",
+      title: "notes.pdf",
+      mimeType: "application/pdf",
+      status: "failed",
+      failureMessage:
+        "Too many concurrent requests (2/2 active). Please retry after 30 seconds.",
+      documentId: undefined,
+    });
+  });
+
   it("hides the download action for persisted demo originals", () => {
     expect(
       toSourceView(
diff --git a/src/domains/sources/view.ts b/src/domains/sources/view.ts
index 82d7438..4096a81 100644
--- a/src/domains/sources/view.ts
+++ b/src/domains/sources/view.ts
@@ -2,6 +2,7 @@ import { Schema } from "effect";
 
 import type { Source } from "@/infrastructure/db/schema";
 import type { SourceView } from "@/domains/sources/types";
+import { sourceFailureMessage } from "./failure-message";
 
 const SourceStatus = Schema.Literal(
   "uploading",
@@ -15,15 +16,21 @@ export function toSourceView(
   options: { chunkCount?: number } = {},
 ): SourceView {
   const originalFile = getSourceOriginalFile(source)
+  const status = toSourceStatus(source.status)
+  const failureMessage =
+    status === "failed"
+      ? sourceFailureMessage.fromStoredReason(source.failureReason)
+      : undefined
 
   return {
     id: source.id,
     kind: "workspace",
     title: source.title,
     mimeType: source.mimeType,
-    status: toSourceStatus(source.status),
+    status,
     ...(source.demoKey ? { demoSourceId: source.demoKey } : {}),
     documentId: source.knowhereDocumentId ?? undefined,
+    ...(failureMessage ? { failureMessage } : {}),
     ...(originalFile ? { originalFile } : {}),
     ...(options.chunkCount !== undefined
       ? { chunkCount: options.chunkCount }
diff --git a/src/domains/workspace/client.test.ts b/src/domains/workspace/client.test.ts
index 6b83cb9..42e8c65 100644
--- a/src/domains/workspace/client.test.ts
+++ b/src/domains/workspace/client.test.ts
@@ -6,6 +6,7 @@ const { mockRouteClient } = vi.hoisted(() => ({
     postJsonWithStatus: vi.fn(),
     postJson: vi.fn(),
     patchJson: vi.fn(),
+    patchJsonWithStatus: vi.fn(),
     deleteJson: vi.fn(),
   },
 }))
@@ -74,4 +75,43 @@ describe("workspaceClient", () => {
       }),
     ).rejects.toThrow("Demo sources could not be prepared right now.")
   })
+
+  it("retries a source with an encoded source id", async () => {
+    mockRouteClient.patchJsonWithStatus.mockResolvedValue({
+      status: 200,
+      body: {
+        source: {
+          id: "source one",
+          title: "notes.pdf",
+          mimeType: "application/pdf",
+          status: "parsing",
+        },
+      },
+    })
+
+    const source = await workspaceClient.retrySource("source one")
+
+    expect(mockRouteClient.patchJsonWithStatus).toHaveBeenCalledWith(
+      "/api/sources/source%20one",
+      { retry: true },
+    )
+    expect(source).toMatchObject({
+      id: "source one",
+      status: "parsing",
+    })
+  })
+
+  it("throws retry route errors", async () => {
+    mockRouteClient.patchJsonWithStatus.mockResolvedValue({
+      status: 409,
+      body: {
+        message:
+          "This source cannot be retried because its original file is unavailable.",
+      },
+    })
+
+    await expect(workspaceClient.retrySource("source_1")).rejects.toThrow(
+      "This source cannot be retried because its original file is unavailable.",
+    )
+  })
 })
diff --git a/src/domains/workspace/client.ts b/src/domains/workspace/client.ts
index 487240d..9a7b3cd 100644
--- a/src/domains/workspace/client.ts
+++ b/src/domains/workspace/client.ts
@@ -14,6 +14,7 @@ const workspaceClientKeys = {
   chat: "/api/chat",
   materializeDemoSources: "/api/demo-sources/materialize",
   archiveSource: "archive-source",
+  retrySource: "retry-source",
   archiveChatThread: "archive-chat-thread",
 } as const
 
@@ -79,6 +80,11 @@ type ArchiveResponse = {
   archived?: boolean
 }
 
+type RetrySourceResponse = {
+  source?: SourceView
+  message?: string
+}
+
 export const workspaceClient = {
   keys: workspaceClientKeys,
   fetchChunks,
@@ -91,6 +97,7 @@ export const workspaceClient = {
   sendChatMessage,
   materializeDemoSources,
   archiveSource,
+  retrySource,
   archiveChatThread,
 } as const
 
@@ -200,6 +207,22 @@ function archiveSource(sourceId: string): Promise<ArchiveResponse> {
   )
 }
 
+async function retrySource(sourceId: string): Promise<SourceView> {
+  const response = await workspaceRouteClient.patchJsonWithStatus<
+    RetrySourceResponse
+  >(`/api/sources/${encodeURIComponent(sourceId)}`, {
+    retry: true,
+  })
+  if (response.status < 200 || response.status >= 300) {
+    throw new Error(response.body.message ?? "Source could not be retried.")
+  }
+  if (!response.body.source) {
+    throw new Error("Source could not be retried.")
+  }
+
+  return response.body.source
+}
+
 function archiveChatThread(threadId: string): Promise<ArchiveResponse> {
   return workspaceRouteClient.patchJson(
     `/api/chat/threads/${encodeURIComponent(threadId)}`,
diff --git a/src/domains/workspace/route-client.ts b/src/domains/workspace/route-client.ts
index 281119d..11588da 100644
--- a/src/domains/workspace/route-client.ts
+++ b/src/domains/workspace/route-client.ts
@@ -14,6 +14,10 @@ type WorkspaceRouteClientModule = {
     body: unknown,
   ) => Promise<JsonRouteResponse<T>>
   readonly patchJson: <T>(url: string, body: unknown) => Promise<T>
+  readonly patchJsonWithStatus: <T>(
+    url: string,
+    body: unknown,
+  ) => Promise<JsonRouteResponse<T>>
 }
 
 type JsonRouteResponse<T> = {
@@ -47,7 +51,14 @@ function postJsonWithStatus<T>(
 }
 
 async function patchJson<T>(url: string, body: unknown): Promise<T> {
-  return (await requestJson<T>({ method: "PATCH", url, body })).body
+  return (await patchJsonWithStatus<T>(url, body)).body
+}
+
+function patchJsonWithStatus<T>(
+  url: string,
+  body: unknown,
+): Promise<JsonRouteResponse<T>> {
+  return requestJson<T>({ method: "PATCH", url, body })
 }
 
 function requestJson<T>(
@@ -100,4 +111,5 @@ export const workspaceRouteClient: WorkspaceRouteClientModule = {
   postJson,
   postJsonWithStatus,
   patchJson,
+  patchJsonWithStatus,
 }