diff --git a/plugin/package-lock.json b/plugin/package-lock.json
index 61b6bd1..726cb82 100644
--- a/plugin/package-lock.json
+++ b/plugin/package-lock.json
@@ -14,6 +14,7 @@
                 "react-dom": "^19.2.7",
                 "react-markdown": "^10.1.0",
                 "remark-gfm": "^4.0.1",
+                "sonner": "^2.0.7",
                 "zod": "^4.4.3"
             },
             "devDependencies": {
@@ -5850,6 +5851,16 @@
                 "url": "https://github.com/sponsors/ljharb"
             }
         },
+        "node_modules/sonner": {
+            "version": "2.0.7",
+            "resolved": "https://registry.npmjs.org/sonner/-/sonner-2.0.7.tgz",
+            "integrity": "sha512-W6ZN4p58k8aDKA4XPcx2hpIQXBRAgyiWVkYhT7CvK6D3iAu7xjvVyhQHg2/iaKJZ1XVJ4r7XuwGL+WGEK37i9w==",
+            "license": "MIT",
+            "peerDependencies": {
+                "react": "^18.0.0 || ^19.0.0 || ^19.0.0-rc",
+                "react-dom": "^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+            }
+        },
         "node_modules/source-map": {
             "version": "0.6.1",
             "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
diff --git a/plugin/package.json b/plugin/package.json
index 1dfe4d9..1a84124 100644
--- a/plugin/package.json
+++ b/plugin/package.json
@@ -56,6 +56,7 @@
         "react-dom": "^19.2.7",
         "react-markdown": "^10.1.0",
         "remark-gfm": "^4.0.1",
+        "sonner": "^2.0.7",
         "zod": "^4.4.3"
     }
 }
diff --git a/plugin/src/client.ts b/plugin/src/client.ts
index 253d845..cfd9c30 100644
--- a/plugin/src/client.ts
+++ b/plugin/src/client.ts
@@ -1,8 +1,8 @@
 import { getApiUrlAndToken } from '@ds-wizard/plugin-sdk/requests'
 
 import type {
-    PipelineRunResponse,
     PipelineStatusResponse,
+    PipelineSummaryItem,
     TemplateDetail,
     TemplateOption,
     TemplateScope,
@@ -103,6 +103,28 @@ export const getPipelineStatus = async (runId: string): Promise<PipelineStatusRe
     return data
 }
 
+export const getPipelineHistory = async (
+    questionnaireUuid: string,
+): Promise<PipelineSummaryItem[]> => {
+    const url = `${getApiBaseUrl()}/pipelines?questionnaireUuid=${encodeURIComponent(questionnaireUuid)}`
+    const response = await apiFetch(url)
+    const data = await readApiResponse<PipelineSummaryItem[] | { detail?: string }>(response, url)
+
+    if (!response.ok) {
+        throw new Error(
+            'detail' in data && data.detail
+                ? data.detail
+                : 'Failed to load the generation history.',
+        )
+    }
+
+    if (!Array.isArray(data)) {
+        throw new Error('Invalid generation history returned.')
+    }
+
+    return data
+}
+
 type RunPipelineParams = {
     questionnaireUuid: string
     templateUuid: string
@@ -119,7 +141,7 @@ export const runPipeline = async ({
     llmApiKey = null,
     llmApiUrl = null,
     llmMaxWorkers = null,
-}: RunPipelineParams): Promise<PipelineRunResponse> => {
+}: RunPipelineParams): Promise<PipelineStatusResponse> => {
     const url = `${getApiBaseUrl()}/pipelines/run`
     const response = await apiFetch(url, {
         method: 'POST',
@@ -136,7 +158,7 @@ export const runPipeline = async ({
         }),
     })
 
-    const data = await readApiResponse<PipelineRunResponse | { detail?: unknown }>(response, url)
+    const data = await readApiResponse<PipelineStatusResponse | { detail?: unknown }>(response, url)
 
     if (!response.ok) {
         if (response.status == 422) {
@@ -150,7 +172,7 @@ export const runPipeline = async ({
         )
     }
 
-    if (!('runId' in data)) {
+    if (!isPipelineStatusResponse(data)) {
         throw new Error('The backend did not return a pipeline run identifier.')
     }
 
diff --git a/plugin/src/components/CustomTemplateSection.tsx b/plugin/src/components/CustomTemplateSection.tsx
index 9d7dc6f..b34842c 100644
--- a/plugin/src/components/CustomTemplateSection.tsx
+++ b/plugin/src/components/CustomTemplateSection.tsx
@@ -1,8 +1,8 @@
 import { ChangeEvent, DragEvent, useEffect, useRef, useState } from 'react'
+import { toast } from 'sonner'
 
 import { createTemplate, updateTemplate } from '@/client'
 import styles from '@/components/CustomTemplateSection.module.css'
-import { FeedbackAlert } from '@/components/FeedbackAlert'
 import { TemplateStructureEditor } from '@/components/TemplateStructureEditor'
 import type { ApiTemplateContent, TemplateOption, TemplateScope } from '@/types'
 
@@ -34,7 +34,6 @@ export function CustomTemplateSection({
         editingTemplate ? JSON.stringify(editingTemplate.content, null, 2) : '',
     )
     const [fileName, setFileName] = useState('')
-    const [error, setError] = useState<string | null>(null)
     const [isSaving, setIsSaving] = useState(false)
     const [inputMode, setInputMode] = useState<'visual' | 'file'>('visual')
     const [isDraggingFile, setIsDraggingFile] = useState(false)
@@ -46,7 +45,6 @@ export function CustomTemplateSection({
         setTitle(editingTemplate?.title ?? '')
         setJson(editingTemplate ? JSON.stringify(editingTemplate.content, null, 2) : '')
         setFileName('')
-        setError(null)
         setInputMode('visual')
     }, [editingTemplate])
 
@@ -58,9 +56,8 @@ export function CustomTemplateSection({
             if (!title.trim()) {
                 setTitle(file.name.replace(/\.json$/i, ''))
             }
-            setError(null)
         } catch {
-            setError('Failed to read the selected JSON file.')
+            toast.error('Failed to read the selected JSON file.')
         }
     }
 
@@ -114,12 +111,12 @@ export function CustomTemplateSection({
         const trimmedJson = json.trim()
 
         if (!trimmedTitle) {
-            setError('Enter a template title.')
+            toast.error('Enter a template title.')
             return
         }
 
         if (!trimmedJson) {
-            setError('Insert or upload template JSON.')
+            toast.error('Insert or upload template JSON.')
             return
         }
 
@@ -147,10 +144,11 @@ export function CustomTemplateSection({
                 setJson('')
                 setFileName('')
             }
-            setError(null)
             onSaved(data)
         } catch (saveError) {
-            setError(saveError instanceof Error ? saveError.message : 'Template JSON is not valid.')
+            toast.error(
+                saveError instanceof Error ? saveError.message : 'Template JSON is not valid.',
+            )
         } finally {
             setIsSaving(false)
         }
@@ -265,8 +263,6 @@ export function CustomTemplateSection({
                     </button>
                 ) : null}
             </div>
-
-            {error ? <FeedbackAlert kind="error">{error}</FeedbackAlert> : null}
         </section>
     )
 }
diff --git a/plugin/src/components/HistorySidebar.module.css b/plugin/src/components/HistorySidebar.module.css
new file mode 100644
index 0000000..9d61c3b
--- /dev/null
+++ b/plugin/src/components/HistorySidebar.module.css
@@ -0,0 +1,245 @@
+.root {
+    /* Content height of a two-line run item (title + timestamp) — every item matches it. */
+    --ai-doc-history-item-body: calc(1.5 * 0.9rem + 0.1rem + 1.5 * 0.75rem);
+    --ai-doc-history-radius: var(--bs-border-radius);
+    --ai-doc-history-line: var(--ai-doc-color-slate-250);
+    /* Doubles as the list's inset, so nothing is faded until it actually scrolls. */
+    --ai-doc-history-fade: 0.75rem;
+
+    display: flex;
+    flex-direction: column;
+    width: 17rem;
+    flex-shrink: 0;
+    position: sticky;
+    top: 0;
+    align-self: flex-start;
+    height: 100%;
+    padding: 1.5rem 0 1.5rem 0.75rem;
+    /* Anchors the negative z-index of the divider below. */
+    isolation: isolate;
+}
+
+/*
+ * Divider towards the main panel. It sits behind everything in the sidebar:
+ * items leave their last pixel transparent so it shows through, and the
+ * selected one paints over it. It cannot ride above the list instead — the
+ * list is a stacking context (mask), so the selected item's z-index could
+ * never escape it.
+ */
+.root::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    width: 1px;
+    background: var(--ai-doc-history-line);
+    z-index: -1;
+}
+
+.item,
+.newButton {
+    display: flex;
+    align-items: center;
+    gap: 0.55rem;
+    position: relative;
+    width: 100%;
+    min-height: calc(var(--ai-doc-history-item-body) + 0.9rem + 2px);
+    padding: 0.45rem 0.7rem;
+    /* Keep focus/scrollIntoView from parking an item flush against the clip edge. */
+    scroll-margin-block: calc(var(--ai-doc-history-radius) + 2px);
+    border: 1px solid var(--ai-doc-color-slate-200);
+    /* Last pixel is left to the divider until the item is selected. */
+    border-right-color: transparent;
+    border-radius: var(--ai-doc-history-radius) 0 0 var(--ai-doc-history-radius);
+    background: var(--ai-doc-color-slate-50);
+    background-clip: padding-box;
+    color: var(--ai-doc-color-slate-800);
+    font-size: 0.9rem;
+    font-weight: 500;
+    text-align: left;
+    transition:
+        background-color 120ms ease,
+        border-color 120ms ease;
+}
+
+.item:hover:not(.itemActive),
+.newButton:hover:not(:disabled) {
+    background: var(--ai-doc-color-slate-100);
+    border-color: var(--ai-doc-color-slate-300);
+    border-right-color: transparent;
+}
+
+/* Selected item reads as the open page: white and merged with the main panel. */
+.itemActive,
+.newButton:disabled {
+    background: var(--ai-doc-color-white);
+    /* Border box, so the white runs under the transparent right border and hides the divider. */
+    background-clip: border-box;
+    border-color: var(--ai-doc-history-line);
+    border-right-color: transparent;
+    color: var(--ai-doc-color-slate-950);
+    font-weight: 600;
+    z-index: 1;
+}
+
+/* Two class selectors, to outrank the host's `button` cursor rule. */
+.item.itemActive,
+.newButton.itemActive,
+.newButton:disabled {
+    cursor: default;
+}
+
+/*
+ * Concave corners that carry the divider into the selected item's top and
+ * bottom edge, so the tab flows into the content instead of butting against it.
+ * Each is a white patch over the divider with the arc drawn by a radial
+ * gradient centred on the corner the curve turns around.
+ */
+.itemActive::before,
+.itemActive::after,
+.newButton:disabled::before,
+.newButton:disabled::after {
+    content: '';
+    position: absolute;
+    right: -1px;
+    width: var(--ai-doc-history-radius);
+    height: calc(var(--ai-doc-history-radius) + 1px);
+}
+
+.itemActive::before,
+.newButton:disabled::before {
+    top: calc(-1px - var(--ai-doc-history-radius));
+    background: radial-gradient(
+        circle at 0 0,
+        var(--ai-doc-color-white) calc(var(--ai-doc-history-radius) - 1px),
+        var(--ai-doc-history-line) calc(var(--ai-doc-history-radius) - 1px),
+        var(--ai-doc-history-line) var(--ai-doc-history-radius),
+        var(--ai-doc-color-white) var(--ai-doc-history-radius)
+    );
+}
+
+.itemActive::after,
+.newButton:disabled::after {
+    bottom: calc(-1px - var(--ai-doc-history-radius));
+    background: radial-gradient(
+        circle at 0 100%,
+        var(--ai-doc-color-white) calc(var(--ai-doc-history-radius) - 1px),
+        var(--ai-doc-history-line) calc(var(--ai-doc-history-radius) - 1px),
+        var(--ai-doc-history-line) var(--ai-doc-history-radius),
+        var(--ai-doc-color-white) var(--ai-doc-history-radius)
+    );
+}
+
+.list {
+    display: flex;
+    flex-direction: column;
+    flex: 1 1 0;
+    /* Room for the selected item's concave corners between neighbours. */
+    gap: calc(var(--ai-doc-history-radius) + 2px);
+    padding: var(--ai-doc-history-fade) 0;
+    min-height: 0;
+    overflow-y: auto;
+    overscroll-behavior: contain;
+    /*
+     * The scrollbar would sit exactly where the items meet the divider, so it is
+     * hidden and overflow is signalled by fading both ends instead. The fade also
+     * softens concave corners clipped at the container edge.
+     */
+    scrollbar-width: none;
+    -webkit-mask-image: linear-gradient(
+        to bottom,
+        transparent 0,
+        #000 var(--ai-doc-history-fade),
+        #000 calc(100% - var(--ai-doc-history-fade)),
+        transparent 100%
+    );
+    mask-image: linear-gradient(
+        to bottom,
+        transparent 0,
+        #000 var(--ai-doc-history-fade),
+        #000 calc(100% - var(--ai-doc-history-fade)),
+        transparent 100%
+    );
+}
+
+.list::-webkit-scrollbar {
+    display: none;
+}
+
+/*
+ * Overlay scrollbar replacing the hidden native one. It sits in the sidebar's
+ * left gutter rather than on the right, where it would land on the divider and
+ * the selected item. Position and size are set from the list's scroll metrics.
+ */
+.scrollThumb {
+    position: absolute;
+    right: 4px;
+    width: 4px;
+    border-radius: 2px;
+    background: var(--ai-doc-color-slate-300);
+    opacity: 0;
+    z-index: 2;
+    touch-action: none;
+    transition:
+        opacity 120ms ease,
+        background-color 120ms ease;
+}
+
+/* Only shown while the pointer is over the list itself (or the thumb). */
+.list:hover ~ .scrollThumb,
+.scrollThumb:hover,
+.scrollThumb:active {
+    opacity: 1;
+}
+
+.scrollThumb:hover,
+.scrollThumb:active {
+    background: var(--ai-doc-color-slate-400);
+}
+
+.itemBody {
+    display: flex;
+    flex-direction: column;
+    gap: 0.1rem;
+    min-width: 0;
+}
+
+.itemTitle {
+    line-height: 1.5;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.itemTime {
+    font-size: 0.75rem;
+    font-weight: 400;
+    line-height: 1.5;
+    color: var(--ai-doc-color-slate-500);
+}
+
+.statusIcon {
+    flex-shrink: 0;
+    font-size: 0.8rem;
+    color: var(--ai-doc-color-slate-500);
+}
+
+.statusIcon.queued,
+.statusIcon.running {
+    color: var(--bs-primary);
+}
+
+.statusIcon.succeeded {
+    color: var(--ai-doc-color-emerald-700);
+}
+
+.statusIcon.failed {
+    color: var(--ai-doc-color-red-700);
+}
+
+.emptyState {
+    padding: 0.5rem 0.7rem;
+    color: var(--ai-doc-color-slate-500);
+    font-size: 0.85rem;
+}
diff --git a/plugin/src/components/HistorySidebar.tsx b/plugin/src/components/HistorySidebar.tsx
new file mode 100644
index 0000000..f263124
--- /dev/null
+++ b/plugin/src/components/HistorySidebar.tsx
@@ -0,0 +1,184 @@
+import {
+    type PointerEvent as ReactPointerEvent,
+    useCallback,
+    useEffect,
+    useRef,
+    useState,
+} from 'react'
+
+import styles from '@/components/HistorySidebar.module.css'
+import type { RunRecord, UseGenerationHistoryResult } from '@/hooks/useGenerationHistory'
+
+type HistorySidebarProps = {
+    history: UseGenerationHistoryResult
+    selectedRunId: string | null
+    onSelectNew: () => void
+    onSelectRun: (runId: string) => void
+}
+
+const STATUS_ICON: Record<RunRecord['status'], string> = {
+    queued: 'fas fa-spinner fa-spin',
+    running: 'fas fa-spinner fa-spin',
+    succeeded: 'fas fa-check-circle',
+    failed: 'fas fa-exclamation-circle',
+}
+
+const RELATIVE_TIME_DIVISIONS: [Intl.RelativeTimeFormatUnit, number][] = [
+    ['year', 60 * 60 * 24 * 365],
+    ['month', 60 * 60 * 24 * 30],
+    ['day', 60 * 60 * 24],
+    ['hour', 60 * 60],
+    ['minute', 60],
+]
+
+const relativeTimeFormatter = new Intl.RelativeTimeFormat('en', { numeric: 'auto' })
+
+const MIN_THUMB_HEIGHT = 24
+
+type ScrollThumb = { top: number; height: number }
+
+const formatRelativeTime = (isoString: string): string => {
+    const date = new Date(isoString)
+    if (Number.isNaN(date.getTime())) {
+        return ''
+    }
+
+    const diffSeconds = Math.round((date.getTime() - Date.now()) / 1000)
+
+    for (const [unit, secondsInUnit] of RELATIVE_TIME_DIVISIONS) {
+        if (Math.abs(diffSeconds) >= secondsInUnit) {
+            return relativeTimeFormatter.format(Math.round(diffSeconds / secondsInUnit), unit)
+        }
+    }
+
+    return 'a few seconds ago'
+}
+
+export function HistorySidebar({
+    history,
+    selectedRunId,
+    onSelectNew,
+    onSelectRun,
+}: HistorySidebarProps) {
+    const { items, isLoading } = history
+    const activeItemRef = useRef<HTMLButtonElement | null>(null)
+    const listRef = useRef<HTMLDivElement | null>(null)
+    const [thumb, setThumb] = useState<ScrollThumb | null>(null)
+
+    // The native scrollbar is hidden (it would sit on the divider), so the
+    // overlay thumb below is measured from the list instead.
+    const updateThumb = useCallback(() => {
+        const list = listRef.current
+        if (!list) {
+            return
+        }
+
+        const { scrollTop, scrollHeight, clientHeight } = list
+        if (scrollHeight - clientHeight < 1) {
+            setThumb(null)
+            return
+        }
+
+        const height = Math.max((clientHeight / scrollHeight) * clientHeight, MIN_THUMB_HEIGHT)
+        const top =
+            (scrollTop / (scrollHeight - clientHeight)) * (clientHeight - height) + list.offsetTop
+        setThumb({ top, height })
+    }, [])
+
+    useEffect(() => {
+        updateThumb()
+    }, [updateThumb, items.length])
+
+    useEffect(() => {
+        const list = listRef.current
+        if (!list) {
+            return
+        }
+
+        const observer = new ResizeObserver(updateThumb)
+        observer.observe(list)
+        return () => observer.disconnect()
+    }, [updateThumb])
+
+    // The selected run can be off-screen after a new run starts or the list loads.
+    useEffect(() => {
+        activeItemRef.current?.scrollIntoView({ block: 'nearest' })
+    }, [selectedRunId, items.length])
+
+    const handleThumbPointerDown = (event: ReactPointerEvent<HTMLDivElement>) => {
+        const list = listRef.current
+        if (!list || !thumb) {
+            return
+        }
+
+        event.preventDefault()
+        const startY = event.clientY
+        const startScrollTop = list.scrollTop
+        const trackRange = list.clientHeight - thumb.height
+        const scrollRange = list.scrollHeight - list.clientHeight
+
+        const handleMove = (moveEvent: PointerEvent) => {
+            const ratio = trackRange > 0 ? (moveEvent.clientY - startY) / trackRange : 0
+            list.scrollTop = startScrollTop + ratio * scrollRange
+        }
+
+        const handleUp = () => {
+            window.removeEventListener('pointermove', handleMove)
+            window.removeEventListener('pointerup', handleUp)
+        }
+
+        window.addEventListener('pointermove', handleMove)
+        window.addEventListener('pointerup', handleUp)
+    }
+
+    return (
+        <nav className={styles.root} aria-label="Generation history">
+            <button
+                type="button"
+                onClick={onSelectNew}
+                disabled={selectedRunId === null}
+                className={`${styles.newButton} ${selectedRunId === null ? styles.itemActive : ''}`}
+            >
+                <i className={`fas fa-plus ${styles.statusIcon}`} aria-hidden="true" />
+                Generate new DMP
+            </button>
+
+            <div className={styles.list} role="list" ref={listRef} onScroll={updateThumb}>
+                {items.map((item) => (
+                    <button
+                        key={item.runId}
+                        ref={selectedRunId === item.runId ? activeItemRef : null}
+                        type="button"
+                        role="listitem"
+                        onClick={() => onSelectRun(item.runId)}
+                        className={`${styles.item} ${selectedRunId === item.runId ? styles.itemActive : ''}`}
+                    >
+                        <i
+                            className={`${STATUS_ICON[item.status]} ${styles.statusIcon} ${styles[item.status]}`}
+                            aria-hidden="true"
+                        />
+                        <span className={styles.itemBody}>
+                            <span className={styles.itemTitle}>{item.templateTitle}</span>
+                            <span className={styles.itemTime}>
+                                {formatRelativeTime(item.createdAt)}
+                            </span>
+                        </span>
+                    </button>
+                ))}
+
+                {items.length === 0 && !isLoading ? (
+                    <div className={styles.emptyState}>No generations yet.</div>
+                ) : null}
+            </div>
+
+            {thumb ? (
+                <div
+                    className={styles.scrollThumb}
+                    style={{ top: thumb.top, height: thumb.height }}
+                    onPointerDown={handleThumbPointerDown}
+                    aria-hidden="true"
+                />
+            ) : null}
+        </nav>
+    )
+}
diff --git a/plugin/src/components/PipelineResultPanel.module.css b/plugin/src/components/PipelineResultPanel.module.css
index cbff82a..0d5cba8 100644
--- a/plugin/src/components/PipelineResultPanel.module.css
+++ b/plugin/src/components/PipelineResultPanel.module.css
@@ -1,9 +1,6 @@
 .root {
     display: grid;
     gap: 1.25rem;
-    margin-top: 0.5rem;
-    padding-top: 1.25rem;
-    border-top: 1px solid var(--ai-doc-color-slate-200);
 }
 
 .header {
@@ -11,16 +8,6 @@
     gap: 1.1rem;
 }
 
-.headerContent {
-    display: grid;
-    gap: 0.5rem;
-}
-
-.subtitle {
-    color: var(--ai-doc-color-slate-500);
-    font-size: 0.95rem;
-}
-
 .toolbar {
     display: flex;
     justify-content: space-between;
diff --git a/plugin/src/components/PipelineResultPanel.tsx b/plugin/src/components/PipelineResultPanel.tsx
index fa3f220..8c75847 100644
--- a/plugin/src/components/PipelineResultPanel.tsx
+++ b/plugin/src/components/PipelineResultPanel.tsx
@@ -1,26 +1,24 @@
 import { useEffect, useState } from 'react'
+import { toast } from 'sonner'
 
 import { saveEditedPipelineResult } from '@/client'
 import styles from '@/components/PipelineResultPanel.module.css'
-import type { FeedbackController } from '@/hooks/useFeedback'
 import { MarkdownRenderer } from '@/markdown-utils'
-import type { ResultRenderMode } from '@/types'
+import type { PipelineStatusResponse, ResultRenderMode } from '@/types'
 
 type PipelineResultPanelProps = {
     resultMarkdown: string | null
     resultRunId: string | null
-    feedback: FeedbackController
     downloadBaseName: string
+    onSaved?: (status: PipelineStatusResponse) => void
 }
 
 export function PipelineResultPanel({
     resultMarkdown,
     resultRunId,
-    feedback,
     downloadBaseName,
+    onSaved,
 }: PipelineResultPanelProps) {
-    const { notifyError, notifySuccess } = feedback
-
     const [editableResultMarkdown, setEditableResultMarkdown] = useState('')
     const [committedMarkdown, setCommittedMarkdown] = useState<string | null>(null)
     const [resultRenderMode, setResultRenderMode] = useState<ResultRenderMode>('formatted')
@@ -42,9 +40,9 @@ export function PipelineResultPanel({
 
         try {
             await navigator.clipboard.writeText(displayedResultMarkdown)
-            notifySuccess('Markdown has been copied to the clipboard.')
+            toast.success('Markdown has been copied to the clipboard.')
         } catch {
-            notifyError('Failed to copy markdown to the clipboard.')
+            toast.error('Failed to copy markdown to the clipboard.')
         }
     }
 
@@ -62,12 +60,12 @@ export function PipelineResultPanel({
         link.click()
         link.remove()
         URL.revokeObjectURL(url)
-        notifySuccess('Markdown download has started.')
+        toast.success('Markdown download has started.')
     }
 
     const onSaveEditedVersion = async () => {
         if (!resultRunId || !resultMarkdown) {
-            notifyError('There is no pipeline result to save yet.')
+            toast.error('There is no pipeline result to save yet.')
             return
         }
 
@@ -78,9 +76,10 @@ export function PipelineResultPanel({
             const savedMarkdown = data.resultMarkdown ?? editableResultMarkdown
             setCommittedMarkdown(savedMarkdown)
             setEditableResultMarkdown(savedMarkdown)
-            notifySuccess('Edited markdown has been saved.')
+            onSaved?.(data)
+            toast.success('Edited markdown has been saved.')
         } catch (error) {
-            notifyError(
+            toast.error(
                 error instanceof Error ? error.message : 'Failed to save the edited version.',
             )
         } finally {
@@ -91,10 +90,6 @@ export function PipelineResultPanel({
     return (
         <section className={styles.root}>
             <div className={styles.header}>
-                <div className={styles.headerContent}>
-                    <h4>Pipeline output</h4>
-                    <div className={styles.subtitle}>Preview of the generated document.</div>
-                </div>
                 <div className={styles.toolbar}>
                     <div className="ai-doc-segmented-control btn-group" role="group">
                         {(
diff --git a/plugin/src/components/ProjectTab.module.css b/plugin/src/components/ProjectTab.module.css
index 9869df6..87f5910 100644
--- a/plugin/src/components/ProjectTab.module.css
+++ b/plugin/src/components/ProjectTab.module.css
@@ -1,15 +1,35 @@
+.layout {
+    display: flex;
+    align-items: stretch;
+    height: 100%;
+}
+
+.main {
+    flex: 1;
+    min-width: 0;
+    overflow-y: auto;
+    scrollbar-width: thin;
+    margin-top: 1rem;
+}
+
+.main::-webkit-scrollbar {
+    width: 6px;
+}
+
+.main::-webkit-scrollbar-thumb {
+    background: var(--ai-doc-color-slate-300);
+    border-radius: 3px;
+}
+
 .root {
+    width: 100%;
+    max-width: 60rem;
+    margin: 0 auto;
     padding: 1.5rem;
     display: grid;
     gap: 1.25rem;
 }
 
-.lead {
-    margin: 0.75rem 0 0;
-    color: var(--ai-doc-color-slate-600);
-    line-height: 1.6;
-}
-
 .runButton {
     justify-self: start;
     width: auto;
diff --git a/plugin/src/components/ProjectTab.tsx b/plugin/src/components/ProjectTab.tsx
index fdf14e9..7472b8b 100644
--- a/plugin/src/components/ProjectTab.tsx
+++ b/plugin/src/components/ProjectTab.tsx
@@ -1,14 +1,15 @@
 import { ProjectTabComponentProps } from '@ds-wizard/plugin-sdk/elements'
 import { useCallback, useState } from 'react'
+import { toast, Toaster } from 'sonner'
 
 import { FeedbackAlert } from '@/components/FeedbackAlert'
-import { PipelineResultPanel } from '@/components/PipelineResultPanel'
+import { HistorySidebar } from '@/components/HistorySidebar'
 import styles from '@/components/ProjectTab.module.css'
 import { ProjectTemplatePanel } from '@/components/ProjectTemplatePanel'
+import { RunDetailPanel } from '@/components/RunDetailPanel'
 import { SettingsData } from '@/data/settings-data'
 import { UserSettingsData } from '@/data/user-settings-data'
-import { useFeedback } from '@/hooks/useFeedback'
-import { usePipeline } from '@/hooks/usePipeline'
+import { useGenerationHistory } from '@/hooks/useGenerationHistory'
 import { useTemplates } from '@/hooks/useTemplates'
 
 export default function ProjectTab({
@@ -16,15 +17,14 @@ export default function ProjectTab({
     userSettings: _userSettings,
     project,
 }: ProjectTabComponentProps<SettingsData, UserSettingsData>) {
-    const feedback = useFeedback()
     const templates = useTemplates({
         reloadKey: settings.serviceUrl,
-        onReload: feedback.clear,
-        onLoadError: feedback.notifyError,
+        onLoadError: toast.error,
     })
-    const pipeline = usePipeline(project, settings, feedback)
+    const history = useGenerationHistory(project, settings)
 
     const [selectedUuid, setSelectedUuid] = useState('')
+    const [selectedRunId, setSelectedRunId] = useState<string | null>(null)
 
     const handleSelectedUuidChange = useCallback((uuid: string) => {
         setSelectedUuid(uuid)
@@ -33,6 +33,7 @@ export default function ProjectTab({
     if (!project) {
         return (
             <div>
+                <Toaster richColors closeButton />
                 <div className={styles.root}>
                     <div>
                         <h2 className="ai-doc-title">AI Document Generation</h2>
@@ -46,49 +47,52 @@ export default function ProjectTab({
         )
     }
 
-    const handleRunPipeline = () => {
-        void pipeline.run(selectedUuid)
+    const handleRunPipeline = async () => {
+        const started = await history.startRun(selectedUuid)
+        if (started) {
+            setSelectedRunId(started.runId)
+        }
     }
 
     return (
         <div className="Projects__Detail__Content Projects__Detail__Content--Metrics">
-            <div className={`questionnaire__summary-report container ${styles.root}`}>
-                <div>
-                    <h2 className="ai-doc-title">AI Document Generation</h2>
-                    <p className={styles.lead}>
-                        Select a DMP template from the database and run the pipeline on the current
-                        project.
-                    </p>
-                </div>
-
-                <ProjectTemplatePanel
-                    templates={templates}
-                    feedback={feedback}
-                    disabled={pipeline.isRunning}
-                    onSelectedUuidChange={handleSelectedUuidChange}
+            <Toaster richColors closeButton />
+            <div className={`questionnaire__summary-report ${styles.layout}`}>
+                <HistorySidebar
+                    history={history}
+                    selectedRunId={selectedRunId}
+                    onSelectNew={() => setSelectedRunId(null)}
+                    onSelectRun={setSelectedRunId}
                 />
 
-                <button
-                    type="button"
-                    onClick={handleRunPipeline}
-                    disabled={templates.isLoading || pipeline.isRunning || !selectedUuid}
-                    className={`btn btn-primary btn-wide ${styles.runButton}`}
-                >
-                    {pipeline.isRunning ? 'Running pipeline...' : 'Run pipeline'}
-                </button>
+                <div className={styles.main}>
+                    {selectedRunId ? (
+                        <RunDetailPanel runId={selectedRunId} history={history} />
+                    ) : (
+                        <div className={styles.root}>
+                            <div>
+                                <h2 className="ai-doc-title">AI Document Generation</h2>
+                            </div>
 
-                {feedback.current ? (
-                    <FeedbackAlert kind={feedback.current.kind}>
-                        {feedback.current.text}
-                    </FeedbackAlert>
-                ) : null}
+                            <ProjectTemplatePanel
+                                templates={templates}
+                                disabled={history.isStarting}
+                                onSelectedUuidChange={handleSelectedUuidChange}
+                            />
 
-                <PipelineResultPanel
-                    resultMarkdown={pipeline.resultMarkdown}
-                    resultRunId={pipeline.resultRunId}
-                    feedback={feedback}
-                    downloadBaseName={selectedUuid}
-                />
+                            <button
+                                type="button"
+                                onClick={() => void handleRunPipeline()}
+                                disabled={
+                                    templates.isLoading || history.isStarting || !selectedUuid
+                                }
+                                className={`btn btn-primary btn-wide ${styles.runButton}`}
+                            >
+                                {history.isStarting ? 'Starting pipeline...' : 'Run pipeline'}
+                            </button>
+                        </div>
+                    )}
+                </div>
             </div>
         </div>
     )
diff --git a/plugin/src/components/ProjectTemplatePanel.tsx b/plugin/src/components/ProjectTemplatePanel.tsx
index 38eb407..40d7750 100644
--- a/plugin/src/components/ProjectTemplatePanel.tsx
+++ b/plugin/src/components/ProjectTemplatePanel.tsx
@@ -3,12 +3,10 @@ import { useCallback, useEffect, useState } from 'react'
 import styles from '@/components/ProjectTemplatePanel.module.css'
 import { TemplateDropdown } from '@/components/TemplateDropdown'
 import { TemplateManager } from '@/components/TemplateManager'
-import type { FeedbackController } from '@/hooks/useFeedback'
 import type { UseTemplatesResult } from '@/hooks/useTemplates'
 
 type ProjectTemplatePanelProps = {
     templates: UseTemplatesResult
-    feedback: FeedbackController
     disabled: boolean
     onSelectedUuidChange: (uuid: string) => void
 }
@@ -19,11 +17,9 @@ type ProjectTemplatePanelProps = {
  */
 export function ProjectTemplatePanel({
     templates,
-    feedback,
     disabled,
     onSelectedUuidChange,
 }: ProjectTemplatePanelProps) {
-    const { notifySuccess, notifyError } = feedback
     const { templates: options, isLoading, isDeleting, upsertSaved, deleteByUuid } = templates
 
     const [selectedUuid, setSelectedUuid] = useState('')
@@ -39,7 +35,7 @@ export function ProjectTemplatePanel({
     return (
         <>
             <div className={styles.selector}>
-                <h4>DMP template</h4>
+                <h4>Generate DMP from your questionnaire</h4>
                 <TemplateDropdown
                     value={selectedUuid}
                     onChange={select}
@@ -57,8 +53,6 @@ export function ProjectTemplatePanel({
                 isDeleting={isDeleting}
                 upsertSaved={upsertSaved}
                 deleteByUuid={deleteByUuid}
-                notifySuccess={notifySuccess}
-                notifyError={notifyError}
                 onSelectedUuidChange={setSelectedUuid}
             />
         </>
diff --git a/plugin/src/components/RunDetailPanel.module.css b/plugin/src/components/RunDetailPanel.module.css
new file mode 100644
index 0000000..5fe4d0e
--- /dev/null
+++ b/plugin/src/components/RunDetailPanel.module.css
@@ -0,0 +1,19 @@
+.root {
+    width: 100%;
+    max-width: 60rem;
+    margin: 0 auto;
+    display: grid;
+    gap: 1rem;
+    padding: 1.5rem;
+}
+
+.progress {
+    display: flex;
+    align-items: center;
+    gap: 0.65rem;
+    padding: 1.25rem;
+    border-radius: var(--bs-border-radius);
+    border: 1px solid var(--ai-doc-color-slate-300);
+    background: var(--ai-doc-color-slate-50);
+    color: var(--ai-doc-color-slate-700);
+}
diff --git a/plugin/src/components/RunDetailPanel.tsx b/plugin/src/components/RunDetailPanel.tsx
new file mode 100644
index 0000000..54c83f1
--- /dev/null
+++ b/plugin/src/components/RunDetailPanel.tsx
@@ -0,0 +1,83 @@
+import { useEffect } from 'react'
+
+import { FeedbackAlert } from '@/components/FeedbackAlert'
+import { PipelineResultPanel } from '@/components/PipelineResultPanel'
+import styles from '@/components/RunDetailPanel.module.css'
+import type { UseGenerationHistoryResult } from '@/hooks/useGenerationHistory'
+
+type RunDetailPanelProps = {
+    runId: string
+    history: UseGenerationHistoryResult
+}
+
+export function RunDetailPanel({ runId, history }: RunDetailPanelProps) {
+    const run = history.getRun(runId)
+    const { ensureDetailLoaded, applyStatus } = history
+
+    useEffect(() => {
+        if (run?.status === 'succeeded' && !run.hasDetail) {
+            ensureDetailLoaded(runId)
+        }
+    }, [runId, run?.status, run?.hasDetail, ensureDetailLoaded])
+
+    if (!run) {
+        return (
+            <div className={styles.root}>
+                <div className={styles.progress}>
+                    <i className="fas fa-spinner fa-spin" aria-hidden="true" />
+                    Loading generation...
+                </div>
+            </div>
+        )
+    }
+
+    if (run.status === 'queued' || run.status === 'running') {
+        return (
+            <div className={styles.root}>
+                <h4>{run.templateTitle}</h4>
+                <div className={styles.progress}>
+                    <i className="fas fa-spinner fa-spin" aria-hidden="true" />
+                    {run.progressMessage ||
+                        (run.status === 'queued'
+                            ? 'Waiting in the queue...'
+                            : 'Generating document...')}
+                </div>
+            </div>
+        )
+    }
+
+    if (run.status === 'failed') {
+        return (
+            <div className={styles.root}>
+                <h4>{run.templateTitle}</h4>
+                <FeedbackAlert kind="error">
+                    {run.error?.message || 'Pipeline generation failed.'}
+                </FeedbackAlert>
+            </div>
+        )
+    }
+
+    if (!run.hasDetail) {
+        return (
+            <div className={styles.root}>
+                <h4>{run.templateTitle}</h4>
+                <div className={styles.progress}>
+                    <i className="fas fa-spinner fa-spin" aria-hidden="true" />
+                    Loading generated document...
+                </div>
+            </div>
+        )
+    }
+
+    return (
+        <div className={styles.root}>
+            <h4>{run.templateTitle}</h4>
+            <PipelineResultPanel
+                resultMarkdown={run.resultMarkdown}
+                resultRunId={run.runId}
+                downloadBaseName={run.templateTitle}
+                onSaved={applyStatus}
+            />
+        </div>
+    )
+}
diff --git a/plugin/src/components/Settings.tsx b/plugin/src/components/Settings.tsx
index e5f35e4..33347e2 100644
--- a/plugin/src/components/Settings.tsx
+++ b/plugin/src/components/Settings.tsx
@@ -1,4 +1,5 @@
 import { SettingsComponentProps } from '@ds-wizard/plugin-sdk/elements'
+import { Toaster } from 'sonner'
 
 import styles from '@/components/Settings.module.css'
 import { TenantTemplateSection } from '@/components/settings/TenantTemplateSettings'
@@ -10,6 +11,7 @@ export default function Settings({
 }: SettingsComponentProps<SettingsData>) {
     return (
         <div className={styles.root}>
+            <Toaster richColors closeButton />
             <div>
                 <p className={styles.lead}>
                     Configure the LLM connection the plugin should use for pipeline execution.
diff --git a/plugin/src/components/TemplateManager.tsx b/plugin/src/components/TemplateManager.tsx
index 5c2575c..8c1c535 100644
--- a/plugin/src/components/TemplateManager.tsx
+++ b/plugin/src/components/TemplateManager.tsx
@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useState } from 'react'
+import { toast } from 'sonner'
 
 import { getTemplate } from '@/client'
 import { CustomTemplateSection } from '@/components/CustomTemplateSection'
@@ -15,8 +16,6 @@ type TemplateManagerProps = {
     isDeleting: boolean
     upsertSaved: UseTemplatesResult['upsertSaved']
     deleteByUuid: UseTemplatesResult['deleteByUuid']
-    notifySuccess: (message: string) => void
-    notifyError: (message: string) => void
     onSelectedUuidChange: (uuid: string) => void
 }
 
@@ -31,8 +30,6 @@ export function TemplateManager({
     isDeleting,
     upsertSaved,
     deleteByUuid,
-    notifySuccess,
-    notifyError,
     onSelectedUuidChange,
 }: TemplateManagerProps) {
     const [isCreating, setIsCreating] = useState(false)
@@ -123,9 +120,9 @@ export function TemplateManager({
             resetDetail()
             setIsEditing(false)
             setIsCreating(false)
-            notifySuccess(`Template "${saved.title}" was saved.`)
+            toast.success(`Template "${saved.title}" was saved.`)
         },
-        [upsertSaved, onSelectedUuidChange, resetDetail, notifySuccess],
+        [upsertSaved, onSelectedUuidChange, resetDetail],
     )
 
     const handleDelete = useCallback(async () => {
@@ -135,16 +132,16 @@ export function TemplateManager({
 
         const deleted = await deleteByUuid(selected, {
             confirmMessage: `Delete the template "${selected.title}"? This cannot be undone.`,
-            onError: notifyError,
+            onError: toast.error,
         })
 
         if (deleted) {
             onSelectedUuidChange('')
             resetDetail()
             setIsEditing(false)
-            notifySuccess(`Template "${selected.title}" was deleted.`)
+            toast.success(`Template "${selected.title}" was deleted.`)
         }
-    }, [selected, deleteByUuid, onSelectedUuidChange, resetDetail, notifySuccess, notifyError])
+    }, [selected, deleteByUuid, onSelectedUuidChange, resetDetail])
 
     return (
         <>
diff --git a/plugin/src/components/settings/TenantTemplateSettings.tsx b/plugin/src/components/settings/TenantTemplateSettings.tsx
index 8819b07..c573db0 100644
--- a/plugin/src/components/settings/TenantTemplateSettings.tsx
+++ b/plugin/src/components/settings/TenantTemplateSettings.tsx
@@ -1,43 +1,30 @@
-import { useCallback, useState } from 'react'
+import { useState } from 'react'
+import { toast } from 'sonner'
 
 import { CustomTemplateSection, type EditingTemplate } from '@/components/CustomTemplateSection'
-import { FeedbackAlert } from '@/components/FeedbackAlert'
 import styles from '@/components/settings/TenantTemplateSettings.module.css'
 import { useTemplates } from '@/hooks/useTemplates'
 import type { TemplateOption } from '@/types'
 
 export function TenantTemplateSection() {
-    const [error, setError] = useState<string | null>(null)
-    const [success, setSuccess] = useState<string | null>(null)
     const [isCreating, setIsCreating] = useState(false)
     const [editingTemplate, setEditingTemplate] = useState<EditingTemplate | null>(null)
     const [busyUuid, setBusyUuid] = useState<string | null>(null)
 
-    const handleReload = useCallback(() => {
-        setError(null)
-    }, [])
-
-    const handleLoadError = useCallback((message: string) => {
-        setError(message)
-    }, [])
-
     const { templates, isLoading, upsertSaved, deleteByUuid, loadDetail } = useTemplates({
         scope: 'tenant',
-        onReload: handleReload,
-        onLoadError: handleLoadError,
+        onLoadError: toast.error,
     })
 
     const handleSaved = (savedTemplate: TemplateOption) => {
         upsertSaved(savedTemplate)
         setIsCreating(false)
         setEditingTemplate(null)
-        setError(null)
-        setSuccess(`Common template "${savedTemplate.title}" was saved.`)
+        toast.success(`Common template "${savedTemplate.title}" was saved.`)
     }
 
     const handleEdit = async (template: TemplateOption) => {
         setBusyUuid(template.uuid)
-        setError(null)
         try {
             const detail = await loadDetail(template.uuid)
             setIsCreating(false)
@@ -47,7 +34,7 @@ export function TenantTemplateSection() {
                 content: detail.content,
             })
         } catch (editError) {
-            setError(
+            toast.error(
                 editError instanceof Error ? editError.message : 'Failed to load the template.',
             )
         } finally {
@@ -57,18 +44,17 @@ export function TenantTemplateSection() {
 
     const handleDelete = async (template: TemplateOption) => {
         setBusyUuid(template.uuid)
-        setError(null)
 
         const deleted = await deleteByUuid(template, {
             confirmMessage: `Delete the tenant-wide template "${template.title}"? This cannot be undone.`,
-            onError: (message) => setError(message),
+            onError: toast.error,
         })
 
         if (deleted) {
             if (editingTemplate?.uuid === template.uuid) {
                 setEditingTemplate(null)
             }
-            setSuccess(`Tenant-wide template "${template.title}" was deleted.`)
+            toast.success(`Tenant-wide template "${template.title}" was deleted.`)
         }
 
         setBusyUuid(null)
@@ -92,9 +78,6 @@ export function TenantTemplateSection() {
                 </p>
             </div>
 
-            {error ? <FeedbackAlert kind="error">{error}</FeedbackAlert> : null}
-            {success ? <FeedbackAlert kind="success">{success}</FeedbackAlert> : null}
-
             {templates.length === 0 ? (
                 <p className={styles.muted}>No common templates yet.</p>
             ) : (
@@ -154,7 +137,6 @@ export function TenantTemplateSection() {
                     onClick={() => {
                         setIsCreating(true)
                         setEditingTemplate(null)
-                        setSuccess(null)
                     }}
                 >
                     <i className="fas fa-plus" aria-hidden="true" />
diff --git a/plugin/src/hooks/useFeedback.ts b/plugin/src/hooks/useFeedback.ts
deleted file mode 100644
index 92c01b2..0000000
--- a/plugin/src/hooks/useFeedback.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { useCallback, useMemo, useState } from 'react'
-
-export type FeedbackKind = 'error' | 'info' | 'success'
-
-export type Feedback = {
-    kind: FeedbackKind
-    text: string
-}
-
-export type FeedbackController = {
-    /** The single feedback message currently shown, or `null` when there is none. */
-    current: Feedback | null
-    notifyError: (text: string) => void
-    notifyInfo: (text: string) => void
-    notifySuccess: (text: string) => void
-    clear: () => void
-}
-
-/**
- * Holds a single user-facing message. Error, info, and success are mutually
- * exclusive: showing one replaces whatever was there before, which removes the
- * manual `setErrorMessage(null)` dance that surrounded every notification.
- */
-export function useFeedback(): FeedbackController {
-    const [current, setCurrent] = useState<Feedback | null>(null)
-
-    const notifyError = useCallback((text: string) => setCurrent({ kind: 'error', text }), [])
-    const notifyInfo = useCallback((text: string) => setCurrent({ kind: 'info', text }), [])
-    const notifySuccess = useCallback((text: string) => setCurrent({ kind: 'success', text }), [])
-    const clear = useCallback(() => setCurrent(null), [])
-
-    return useMemo(
-        () => ({ current, notifyError, notifyInfo, notifySuccess, clear }),
-        [current, notifyError, notifyInfo, notifySuccess, clear],
-    )
-}
diff --git a/plugin/src/hooks/useGenerationHistory.ts b/plugin/src/hooks/useGenerationHistory.ts
new file mode 100644
index 0000000..bfb1b4a
--- /dev/null
+++ b/plugin/src/hooks/useGenerationHistory.ts
@@ -0,0 +1,255 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { toast } from 'sonner'
+
+import { getPipelineHistory, getPipelineStatus, runPipeline } from '@/client'
+import { SettingsData } from '@/data/settings-data'
+import { pollRunStatus } from '@/runPoller'
+import type { PipelineErrorResponse, PipelineStatusResponse, PipelineSummaryItem } from '@/types'
+
+type PipelineProject =
+    | {
+          uuid: string
+      }
+    | null
+    | undefined
+
+export type RunStatusValue = PipelineStatusResponse['status']
+
+export type RunRecord = {
+    runId: string
+    status: RunStatusValue
+    templateTitle: string
+    error: PipelineErrorResponse | null
+    progressMessage: string | null
+    createdAt: string
+    updatedAt: string
+    resultMarkdown: string | null
+    /** false = came only from the summary list, never polled/backfilled with full detail. */
+    hasDetail: boolean
+}
+
+export type UseGenerationHistoryResult = {
+    items: RunRecord[]
+    isLoading: boolean
+    isStarting: boolean
+    // returns a reference to a generation run.
+    // This helps with handling live updates from the pollers without need to do subscribe logic
+    getRun: (runId: string) => RunRecord | undefined
+    startRun: (templateUuid: string) => Promise<RunRecord | null>
+    ensureDetailLoaded: (runId: string) => void
+    applyStatus: (status: PipelineStatusResponse) => RunRecord
+}
+
+const summaryToRunRecord = (item: PipelineSummaryItem): RunRecord => ({
+    runId: item.runId,
+    status: item.status,
+    templateTitle: item.templateTitle,
+    error: item.error,
+    progressMessage: item.progressMessage,
+    createdAt: item.createdAt,
+    updatedAt: item.updatedAt,
+    resultMarkdown: null,
+    hasDetail: false,
+})
+
+const isSettled = (status: RunStatusValue): boolean => status === 'succeeded' || status === 'failed'
+
+/**
+ * Owns every run belonging to the project: the initial history load, starting new
+ * runs, and polling in-progress ones. Exactly one poller exists per in-progress run,
+ * started once (at load or right after `startRun`) and stopped once it settles.
+ * The sidebar and the detail view both read the same `RunRecord`s from here, so they
+ * can never disagree with each other.
+ */
+export function useGenerationHistory(
+    project: PipelineProject,
+    settings: SettingsData,
+): UseGenerationHistoryResult {
+    const [runs, setRuns] = useState<Record<string, RunRecord>>({})
+    const [isLoading, setIsLoading] = useState(false)
+    const [isStarting, setIsStarting] = useState(false)
+
+    // Mirrors `runs` synchronously so callbacks (applyStatus, getRun, startRun) can
+    // read/merge the latest state without waiting on React's async setState.
+    const runsRef = useRef<Record<string, RunRecord>>({})
+    const pollersRef = useRef<Map<string, () => void>>(new Map())
+
+    const setRunRecord = useCallback((record: RunRecord) => {
+        runsRef.current = { ...runsRef.current, [record.runId]: record }
+        setRuns(runsRef.current)
+    }, [])
+
+    const applyStatus = useCallback(
+        (status: PipelineStatusResponse): RunRecord => {
+            const existing = runsRef.current[status.runId]
+            const record: RunRecord = {
+                runId: status.runId,
+                status: status.status,
+                templateTitle: status.templateTitle,
+                error: status.error,
+                // `PipelineStatusResponse` has no `createdAt`; keep whatever we already knew.
+                createdAt: existing?.createdAt ?? status.updatedAt,
+                updatedAt: status.updatedAt,
+                progressMessage: status.progressMessage,
+                resultMarkdown: status.resultMarkdown,
+                hasDetail: true,
+            }
+            setRunRecord(record)
+            return record
+        },
+        [setRunRecord],
+    )
+
+    const beginPolling = useCallback(
+        (runId: string) => {
+            if (pollersRef.current.has(runId)) {
+                return
+            }
+
+            const stop = pollRunStatus(runId, {
+                onUpdate: applyStatus,
+                onSettle: () => {
+                    pollersRef.current.delete(runId)
+                },
+                onError: () => {
+                    // Leave the run at its last known status; this run's poller simply
+                    // stops rather than retrying forever.
+                    pollersRef.current.delete(runId)
+                },
+            })
+            pollersRef.current.set(runId, stop)
+        },
+        [applyStatus],
+    )
+
+    useEffect(() => {
+        if (!project) {
+            runsRef.current = {}
+            setRuns({})
+            return
+        }
+
+        let cancelled = false
+        const pollers = pollersRef.current
+
+        const load = async () => {
+            setIsLoading(true)
+            try {
+                const items = await getPipelineHistory(project.uuid)
+                if (cancelled) {
+                    return
+                }
+
+                const nextRuns: Record<string, RunRecord> = {}
+                for (const item of items) {
+                    nextRuns[item.runId] = summaryToRunRecord(item)
+                }
+                runsRef.current = nextRuns
+                setRuns(nextRuns)
+
+                for (const record of Object.values(nextRuns)) {
+                    if (!isSettled(record.status)) {
+                        beginPolling(record.runId)
+                    }
+                }
+            } catch {
+                // The sidebar keeps showing an empty/last-known list; it isn't the
+                // place to surface a fetch error, the main panel reports run failures.
+            } finally {
+                if (!cancelled) {
+                    setIsLoading(false)
+                }
+            }
+        }
+
+        void load()
+
+        return () => {
+            cancelled = true
+            for (const stop of pollers.values()) {
+                stop()
+            }
+            pollers.clear()
+        }
+    }, [project?.uuid, beginPolling, project])
+
+    const getRun = useCallback((runId: string) => runsRef.current[runId], [])
+
+    const startRun = useCallback(
+        async (templateUuid: string): Promise<RunRecord | null> => {
+            if (!project) {
+                toast.error('Project is not available.')
+                return null
+            }
+
+            if (!templateUuid) {
+                toast.error('Select a DMP template.')
+                return null
+            }
+
+            setIsStarting(true)
+
+            try {
+                const status = await runPipeline({
+                    questionnaireUuid: project.uuid,
+                    templateUuid,
+                    llmModel: settings.model || null,
+                    llmApiKey: settings.apiKey || null,
+                    llmApiUrl: settings.apiUrl || null,
+                    llmMaxWorkers: settings.maxWorkers ?? null,
+                })
+                const record = applyStatus(status)
+                if (!isSettled(record.status)) {
+                    beginPolling(record.runId)
+                }
+                return record
+            } catch (error) {
+                toast.error(error instanceof Error ? error.message : 'Pipeline execution failed.')
+                return null
+            } finally {
+                setIsStarting(false)
+            }
+        },
+        [
+            project,
+            settings.model,
+            settings.apiKey,
+            settings.apiUrl,
+            settings.maxWorkers,
+            applyStatus,
+            beginPolling,
+        ],
+    )
+
+    const ensureDetailLoaded = useCallback(
+        (runId: string) => {
+            if (runsRef.current[runId]?.hasDetail) {
+                return
+            }
+
+            void (async () => {
+                try {
+                    const status = await getPipelineStatus(runId)
+                    applyStatus(status)
+                } catch (error) {
+                    toast.error(
+                        error instanceof Error
+                            ? error.message
+                            : 'Failed to load the generation result.',
+                    )
+                }
+            })()
+        },
+        [applyStatus],
+    )
+
+    return {
+        items: Object.values(runs).sort((a, b) => b.createdAt.localeCompare(a.createdAt)),
+        isLoading,
+        isStarting,
+        getRun,
+        startRun,
+        ensureDetailLoaded,
+        applyStatus,
+    }
+}
diff --git a/plugin/src/hooks/usePipeline.ts b/plugin/src/hooks/usePipeline.ts
deleted file mode 100644
index 5a601db..0000000
--- a/plugin/src/hooks/usePipeline.ts
+++ /dev/null
@@ -1,173 +0,0 @@
-import { useCallback, useEffect, useState } from 'react'
-
-import { getPipelineStatus, runPipeline } from '@/client'
-import { SettingsData } from '@/data/settings-data'
-import type { FeedbackController } from '@/hooks/useFeedback'
-
-const POLL_INTERVAL_MS = 10_000
-
-type PipelineProject =
-    | {
-          uuid: string
-      }
-    | null
-    | undefined
-
-export type UsePipelineResult = {
-    isRunning: boolean
-    /** Run id of the last completed pipeline, used when saving an edited result. */
-    resultRunId: string | null
-    /** Markdown produced by the last completed pipeline, or `null` before/while running. */
-    resultMarkdown: string | null
-    run: (templateUuid: string) => Promise<void>
-}
-
-/**
- * Owns the full pipeline lifecycle: kicking off a run, polling its status until
- * it settles, and exposing the resulting markdown. The status polling used to
- * live in a separate `PipelineStatusPoller` component wired up through nine
- * setter props; it is now an internal effect keyed on the active run id.
- */
-export function usePipeline(
-    project: PipelineProject,
-    settings: SettingsData,
-    feedback: FeedbackController,
-): UsePipelineResult {
-    const [activeRunId, setActiveRunId] = useState<string | null>(null)
-    const [isRunning, setIsRunning] = useState(false)
-    const [resultRunId, setResultRunId] = useState<string | null>(null)
-    const [resultMarkdown, setResultMarkdown] = useState<string | null>(null)
-
-    // The feedback methods are stable; depend on them individually so a changing
-    // `feedback.current` never restarts the polling effect below.
-    const {
-        notifyError: notifyError,
-        notifyInfo: notifyInfo,
-        notifySuccess: notifySuccess,
-        clear: clearFeedback,
-    } = feedback
-
-    const run = useCallback(
-        async (templateUuid: string) => {
-            if (!project) {
-                notifyError('Project is not available.')
-                return
-            }
-
-            if (!templateUuid) {
-                notifyError('Select a DMP template.')
-                return
-            }
-
-            setIsRunning(true)
-            clearFeedback()
-            setResultRunId(null)
-            setResultMarkdown(null)
-
-            try {
-                const data = await runPipeline({
-                    questionnaireUuid: project.uuid,
-                    templateUuid,
-                    llmModel: settings.model || null,
-                    llmApiKey: settings.apiKey || null,
-                    llmApiUrl: settings.apiUrl || null,
-                    llmMaxWorkers: settings.maxWorkers ?? null,
-                })
-
-                setActiveRunId(data.runId)
-                notifyInfo(`Pipeline has been accepted for the template "${data.templateTitle}".`)
-            } catch (error) {
-                notifyError(error instanceof Error ? error.message : 'Pipeline execution failed.')
-                setIsRunning(false)
-            }
-        },
-        [
-            project,
-            settings.model,
-            settings.apiKey,
-            settings.apiUrl,
-            settings.maxWorkers,
-            notifyError,
-            notifyInfo,
-            clearFeedback,
-        ],
-    )
-
-    useEffect(() => {
-        if (!activeRunId) {
-            return
-        }
-
-        let cancelled = false
-        let timeoutId: ReturnType<typeof window.setTimeout> | undefined
-
-        const sleep = (ms: number) =>
-            new Promise<void>((resolve) => {
-                timeoutId = window.setTimeout(() => {
-                    timeoutId = undefined
-                    resolve()
-                }, ms)
-            })
-
-        const pollStatus = async (): Promise<boolean> => {
-            try {
-                const data = await getPipelineStatus(activeRunId)
-
-                if (data.status === 'queued' || data.status === 'running') {
-                    notifyInfo(
-                        data.progressMessage ||
-                            `Pipeline is running for the template "${data.templateTitle}".`,
-                    )
-                    return true
-                }
-
-                setActiveRunId(null)
-                setIsRunning(false)
-
-                if (data.status === 'succeeded') {
-                    setResultRunId(data.runId)
-                    setResultMarkdown(data.resultMarkdown)
-                    notifySuccess(
-                        `Pipeline has been completed for the template "${data.templateTitle}".`,
-                    )
-                    return false
-                }
-
-                notifyError(
-                    data.error?.message
-                        ? `Pipeline failed: ${data.error.message}`
-                        : `Pipeline failed for the template "${data.templateTitle}".`,
-                )
-                return false
-            } catch (error) {
-                setActiveRunId(null)
-                setIsRunning(false)
-                notifyError(
-                    error instanceof Error ? error.message : 'Unable to determine pipeline status.',
-                )
-                return false
-            }
-        }
-
-        const runPolling = async () => {
-            while (!cancelled) {
-                const shouldContinue = await pollStatus()
-                if (!shouldContinue || cancelled) {
-                    break
-                }
-                await sleep(POLL_INTERVAL_MS)
-            }
-        }
-
-        void runPolling()
-
-        return () => {
-            cancelled = true
-            if (timeoutId !== undefined) {
-                window.clearTimeout(timeoutId)
-            }
-        }
-    }, [activeRunId, notifyInfo, notifySuccess, notifyError])
-
-    return { isRunning, resultRunId, resultMarkdown, run }
-}
diff --git a/plugin/src/runPoller.ts b/plugin/src/runPoller.ts
new file mode 100644
index 0000000..368e00c
--- /dev/null
+++ b/plugin/src/runPoller.ts
@@ -0,0 +1,58 @@
+import { getPipelineStatus } from '@/client'
+import type { PipelineStatusResponse } from '@/types'
+
+const DEFAULT_POLL_INTERVAL_MS = 10_000
+
+type PollRunStatusCallbacks = {
+    onUpdate: (status: PipelineStatusResponse) => void
+    onSettle?: (status: PipelineStatusResponse) => void
+    onError?: (error: unknown) => void
+}
+
+/**
+ * Polls a single run's status until it settles (succeeded/failed), then stops on its
+ * own. Framework-free: no React, no knowledge of any store — just one run, one loop.
+ * Returns a `stop()` that cancels any pending fetch/timeout immediately.
+ */
+export function pollRunStatus(
+    runId: string,
+    { onUpdate, onSettle, onError }: PollRunStatusCallbacks,
+    intervalMs = DEFAULT_POLL_INTERVAL_MS,
+): () => void {
+    let cancelled = false
+    let timeoutId: ReturnType<typeof window.setTimeout> | undefined
+
+    const tick = async () => {
+        try {
+            const status = await getPipelineStatus(runId)
+            if (cancelled) {
+                return
+            }
+
+            onUpdate(status)
+
+            if (status.status === 'succeeded' || status.status === 'failed') {
+                onSettle?.(status)
+                return
+            }
+
+            timeoutId = window.setTimeout(() => {
+                void tick()
+            }, intervalMs)
+        } catch (error) {
+            if (!cancelled) {
+                onError?.(error)
+            }
+        }
+    }
+
+    void tick()
+
+    return () => {
+        cancelled = true
+        if (timeoutId !== undefined) {
+            window.clearTimeout(timeoutId)
+            timeoutId = undefined
+        }
+    }
+}
diff --git a/plugin/src/types.ts b/plugin/src/types.ts
index ca6c79f..c858609 100644
--- a/plugin/src/types.ts
+++ b/plugin/src/types.ts
@@ -28,14 +28,6 @@ export type TemplateDetail = {
     scope: TemplateScope
 }
 
-export type PipelineRunResponse = {
-    status: string
-    runId: string
-    questionnaireUuid: string
-    templateUuid: string
-    templateTitle: string
-}
-
 export type PipelineStatusResponse = {
     runId: string
     status: 'queued' | 'running' | 'succeeded' | 'failed'
@@ -52,4 +44,14 @@ export type PipelineStatusResponse = {
     updatedAt: string
 }
 
+export type PipelineSummaryItem = {
+    runId: string
+    status: 'queued' | 'running' | 'succeeded' | 'failed'
+    templateTitle: string
+    error: PipelineErrorResponse | null
+    progressMessage: string | null
+    createdAt: string
+    updatedAt: string
+}
+
 export type ResultRenderMode = 'formatted' | 'raw'
diff --git a/service/src/ai_document_plugin_service/ai/persistence/assignment_loader_component.py b/service/src/ai_document_plugin_service/ai/persistence/assignment_loader_component.py
index 70143cc..fcfa622 100644
--- a/service/src/ai_document_plugin_service/ai/persistence/assignment_loader_component.py
+++ b/service/src/ai_document_plugin_service/ai/persistence/assignment_loader_component.py
@@ -15,7 +15,7 @@ def __init__(self, database: Database) -> None:
         assignments=JsonValue | None,
         found=bool,
     )
-    async def run_async(self, knowledge_model_uuid: str, template_uuid: UUID) -> dict[str, Any]:
+    async def run_async(self, knowledge_model_uuid: UUID, template_uuid: UUID) -> dict[str, Any]:
         assignments = await self.database.get_assignments(knowledge_model_uuid, template_uuid)
 
         return {
@@ -27,7 +27,7 @@ async def run_async(self, knowledge_model_uuid: str, template_uuid: UUID) -> dic
         assignments=JsonValue | None,
         found=bool,
     )
-    def run(self, knowledge_model_uuid: str, template_uuid: UUID) -> dict[str, Any]:
+    def run(self, knowledge_model_uuid: UUID, template_uuid: UUID) -> dict[str, Any]:
         """Async-only component; the sync pipeline entrypoint is intentionally unsupported."""
         msg = f'{type(self).__name__} is async-only; use run_async() / AsyncPipeline.run_async()'
         raise NotImplementedError(
diff --git a/service/src/ai_document_plugin_service/ai/persistence/assignment_saver_component.py b/service/src/ai_document_plugin_service/ai/persistence/assignment_saver_component.py
index 530449f..675d417 100644
--- a/service/src/ai_document_plugin_service/ai/persistence/assignment_saver_component.py
+++ b/service/src/ai_document_plugin_service/ai/persistence/assignment_saver_component.py
@@ -44,7 +44,7 @@ def __init__(self, saver: Saver) -> None:
     @component.output_types(assignments=list[SerializedSectionAssignment], stats=AssignmentStats)
     async def run_async(
         self,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         knowledge_model_name: str,
         knowledge_model_version: str,
         template_uuid: UUID,
@@ -80,7 +80,7 @@ async def run_async(
     @component.output_types(assignments=list[SerializedSectionAssignment], stats=AssignmentStats)
     def run(
         self,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         knowledge_model_name: str,
         knowledge_model_version: str,
         template_uuid: UUID,
@@ -101,7 +101,7 @@ class Saver(ABC):
     @abstractmethod
     async def save(
         self,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         knowledge_model_name: str,
         knowledge_model_version: str,
         assignments: JsonValue,
@@ -118,7 +118,7 @@ async def save(
 class FileSaver(Saver):
     async def save(
         self,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         knowledge_model_name: str,
         knowledge_model_version: str,
         assignments: JsonValue,
@@ -154,12 +154,12 @@ async def save(
 
     @staticmethod
     def _build_filename(
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         knowledge_model_name: str,
         knowledge_model_version: str,
         created_at: datetime | None = None,
     ) -> str:
-        normalized_uuid = _normalize_filename_part(knowledge_model_uuid)
+        normalized_uuid = _normalize_filename_part(str(knowledge_model_uuid))
         normalized_name = _normalize_filename_part(knowledge_model_name)
         normalized_version = _normalize_filename_part(knowledge_model_version)
 
@@ -176,7 +176,7 @@ def __init__(self, database: Database) -> None:
 
     async def save(
         self,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         knowledge_model_name: str,
         knowledge_model_version: str,
         assignments: JsonValue,
diff --git a/service/src/ai_document_plugin_service/ai/persistence/database.py b/service/src/ai_document_plugin_service/ai/persistence/database.py
index e65d132..1782de6 100644
--- a/service/src/ai_document_plugin_service/ai/persistence/database.py
+++ b/service/src/ai_document_plugin_service/ai/persistence/database.py
@@ -5,7 +5,7 @@
 from contextvars import ContextVar
 from dataclasses import dataclass
 from datetime import UTC, datetime
-from typing import Any
+from typing import Any, TypedDict, Unpack
 from uuid import UUID, uuid4
 
 from sqlalchemy import ColumnElement, Connection, Row, and_, inspect, or_
@@ -54,6 +54,54 @@ def from_row(cls, row: Row) -> 'TemplateRecord':
         )
 
 
+class GenerationUpdate(TypedDict, total=False):
+    status: str
+    knowledge_model_uuid: UUID | None
+    error_type: str | None
+    error_message: str | None
+    result_markdown: str | None
+    progress_message: str | None
+
+
+@dataclass(frozen=True)
+class GenerationRecord:
+    """A raw generation (pipeline run) row."""
+
+    run_id: UUID
+    questionnaire_uuid: UUID
+    template_uuid: UUID
+    title: str
+    knowledge_model_uuid: UUID | None
+    user_uuid: UUID
+    tenant_uuid: UUID
+    status: str
+    error_type: str | None
+    error_message: str | None
+    result_markdown: str | None
+    progress_message: str | None
+    created_at: datetime
+    updated_at: datetime
+
+    @classmethod
+    def from_row(cls, row: Row) -> 'GenerationRecord':
+        return cls(
+            run_id=row.run_id,
+            questionnaire_uuid=row.questionnaire_uuid,
+            template_uuid=row.template_uuid,
+            title=row.title,
+            knowledge_model_uuid=row.knowledge_model_uuid,
+            user_uuid=row.user_uuid,
+            tenant_uuid=row.tenant_uuid,
+            status=row.status,
+            error_type=row.error_type,
+            error_message=row.error_message,
+            result_markdown=row.result_markdown,
+            progress_message=row.progress_message,
+            created_at=row.created_at,
+            updated_at=row.updated_at,
+        )
+
+
 class Database(ABC):
     @abstractmethod
     def transaction(self) -> AbstractAsyncContextManager[None]:
@@ -103,7 +151,7 @@ async def delete_template(
     @abstractmethod
     async def save_assignments(
         self,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         knowledge_model_name: str,
         knowledge_model_version: str,
         assignments: JsonValue,
@@ -126,7 +174,7 @@ async def save_template(
     @abstractmethod
     async def get_assignments(
         self,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         template_uuid: UUID,
     ) -> JsonValue | None:
         """Get assignments from a database backend."""
@@ -153,7 +201,7 @@ async def get_template(
     async def save_result(
         self,
         template_uuid: UUID,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         user_uuid: UUID,
         tenant_uuid: UUID,
         prepolished_markdown: str,
@@ -183,6 +231,50 @@ async def update_result(
     ) -> None:
         """Persist a markdown result in a database backend."""
 
+    @abstractmethod
+    async def create_generation(
+        self,
+        questionnaire_uuid: UUID,
+        template_uuid: UUID,
+        title: str,
+        user_uuid: UUID,
+        tenant_uuid: UUID,
+        status: str,
+    ) -> UUID:
+        """Create a new generation (pipeline run) row. Return the created run id."""
+
+    @abstractmethod
+    async def update_generation(
+        self,
+        run_id: UUID,
+        tenant_uuid: UUID,
+        **updates: Unpack[GenerationUpdate],
+    ) -> GenerationRecord | None:
+        """Partially update a generation row and return the updated record.
+
+        Only the fields passed in ``updates`` are changed; any nullable field may be
+        set to ``None`` to clear it. Returns ``None`` if no row matches
+        ``run_id``/``tenant_uuid``.
+        """
+
+    @abstractmethod
+    async def get_generation(
+        self,
+        run_id: UUID,
+        tenant_uuid: UUID,
+        user_uuid: UUID,
+    ) -> GenerationRecord | None:
+        """Get a single generation row, scoped to its owning tenant and user."""
+
+    @abstractmethod
+    async def list_generations(
+        self,
+        questionnaire_uuid: UUID,
+        tenant_uuid: UUID,
+        user_uuid: UUID,
+    ) -> list[GenerationRecord]:
+        """List a user's generations for a project, newest first."""
+
 
 class PostgresDB(Database):
     def __init__(
@@ -204,6 +296,7 @@ def __init__(
         self.assignment_table = schema.assignment_table
         self.template_table = schema.template_table
         self.result_table = schema.result_table
+        self.generation_table = schema.generation_table
         self._database_verified = False
 
     async def dispose(self) -> None:
@@ -252,7 +345,7 @@ async def _ensure_schema(self) -> None:
         async with self.engine.connect() as connection:
             existing_tables = await connection.run_sync(self._list_existing_tables)
 
-        required_tables = {'alembic_version', 'template', 'assignment', 'result'}
+        required_tables = {'alembic_version', 'template', 'assignment', 'result', 'generation'}
         missing_tables = sorted(required_tables - existing_tables)
 
         if missing_tables:
@@ -267,7 +360,7 @@ async def _ensure_schema(self) -> None:
 
     async def save_assignments(
         self,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         knowledge_model_name: str,
         knowledge_model_version: str,
         assignments: JsonValue,
@@ -419,7 +512,7 @@ async def save_template(
 
     async def get_assignments(
         self,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         template_uuid: UUID,
     ) -> JsonValue | None:
         await self._ensure_schema()
@@ -509,7 +602,7 @@ async def get_template(
     async def save_result(
         self,
         template_uuid: UUID,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         user_uuid: UUID,
         tenant_uuid: UUID,
         prepolished_markdown: str,
@@ -620,6 +713,121 @@ async def update_result(
             self.schema_name,
         )
 
+    async def create_generation(
+        self,
+        questionnaire_uuid: UUID,
+        template_uuid: UUID,
+        title: str,
+        user_uuid: UUID,
+        tenant_uuid: UUID,
+        status: str,
+    ) -> UUID:
+        run_id = uuid4()
+        await self._ensure_schema()
+        statement = self.generation_table.insert().values(
+            run_id=run_id,
+            questionnaire_uuid=questionnaire_uuid,
+            template_uuid=template_uuid,
+            title=title,
+            user_uuid=user_uuid,
+            tenant_uuid=tenant_uuid,
+            status=status,
+        )
+
+        async with self._connect() as connection:
+            await connection.execute(statement)
+
+        logger.debug(
+            'Created generation run_id=%s in %s.generation',
+            run_id,
+            self.schema_name,
+        )
+        return run_id
+
+    async def update_generation(
+        self,
+        run_id: UUID,
+        tenant_uuid: UUID,
+        **updates: Unpack[GenerationUpdate],
+    ) -> GenerationRecord | None:
+        await self._ensure_schema()
+
+        unknown_fields = set(updates) - GenerationUpdate.__optional_keys__
+        if unknown_fields:
+            msg = f'Cannot update unknown generation fields: {sorted(unknown_fields)}'
+            raise ValueError(msg)
+
+        now = datetime.now(tz=UTC)
+        statement = (
+            self.generation_table.update()
+            .where(
+                (self.generation_table.c.run_id == run_id)
+                & (self.generation_table.c.tenant_uuid == tenant_uuid)
+            )
+            .values(**updates, updated_at=now)
+            .returning(*self.generation_table.c)
+        )
+
+        async with self._connect() as connection:
+            result = await connection.execute(statement)
+            row = result.fetchone()
+
+        if row is None:
+            return None
+
+        logger.debug(
+            'Updated generation run_id=%s in %s.generation',
+            run_id,
+            self.schema_name,
+        )
+        return GenerationRecord.from_row(row)
+
+    async def get_generation(
+        self,
+        run_id: UUID,
+        tenant_uuid: UUID,
+        user_uuid: UUID,
+    ) -> GenerationRecord | None:
+        await self._ensure_schema()
+        statement = self.generation_table.select().where(
+            and_(
+                self.generation_table.c.run_id == run_id,
+                self.generation_table.c.tenant_uuid == tenant_uuid,
+                self.generation_table.c.user_uuid == user_uuid,
+            ),
+        )
+
+        async with self._connect() as connection:
+            result = await connection.execute(statement)
+            row = result.fetchone()
+
+        return GenerationRecord.from_row(row) if row is not None else None
+
+    async def list_generations(
+        self,
+        questionnaire_uuid: UUID,
+        tenant_uuid: UUID,
+        user_uuid: UUID,
+    ) -> list[GenerationRecord]:
+        await self._ensure_schema()
+        statement = (
+            self.generation_table.select()
+            .where(
+                and_(
+                    self.generation_table.c.questionnaire_uuid == questionnaire_uuid,
+                    self.generation_table.c.tenant_uuid == tenant_uuid,
+                    self.generation_table.c.user_uuid == user_uuid,
+                ),
+            )
+            .order_by(self.generation_table.c.created_at.desc())
+        )
+
+        async with self._connect() as connection:
+            result = await connection.execute(statement)
+            rows = result.fetchall()
+
+        return [GenerationRecord.from_row(row) for row in rows]
+
 
 def _validate_identifier(value: str) -> str:
     if not value.replace('_', '').isalnum() or not (value[0].isalpha() or value[0] == '_'):
diff --git a/service/src/ai_document_plugin_service/ai/persistence/saver_component.py b/service/src/ai_document_plugin_service/ai/persistence/saver_component.py
index b19bae0..872b6c7 100644
--- a/service/src/ai_document_plugin_service/ai/persistence/saver_component.py
+++ b/service/src/ai_document_plugin_service/ai/persistence/saver_component.py
@@ -20,7 +20,7 @@ def __init__(self, database: Database) -> None:
     async def run_async(
         self,
         template_uuid: UUID,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         user_uuid: UUID,
         tenant_uuid: UUID,
         debug_markdown: str,
@@ -44,7 +44,7 @@ async def run_async(
     def run(
         self,
         template_uuid: UUID,
-        knowledge_model_uuid: str,
+        knowledge_model_uuid: UUID,
         user_uuid: UUID,
         tenant_uuid: UUID,
         debug_markdown: str,
diff --git a/service/src/ai_document_plugin_service/ai/persistence/schema.py b/service/src/ai_document_plugin_service/ai/persistence/schema.py
index ee1a47d..b358fa0 100644
--- a/service/src/ai_document_plugin_service/ai/persistence/schema.py
+++ b/service/src/ai_document_plugin_service/ai/persistence/schema.py
@@ -22,6 +22,7 @@ class PersistenceSchema:
     assignment_table: Table
     template_table: Table
     result_table: Table
+    generation_table: Table
 
 
 def create_persistence_schema(schema_name: str) -> PersistenceSchema:
@@ -116,9 +117,47 @@ def create_persistence_schema(schema_name: str) -> PersistenceSchema:
         ),
     )
 
+    generation_table = Table(
+        'generation',
+        metadata,
+        Column('run_id', UUID(as_uuid=True), primary_key=True),
+        Column('questionnaire_uuid', UUID(as_uuid=True), nullable=False),
+        Column('template_uuid', UUID(as_uuid=True), ForeignKey('template.uuid'), nullable=False),
+        Column('title', Text, nullable=False),
+        # Only known once the run has fetched the questionnaire from DSW.
+        Column('knowledge_model_uuid', UUID(as_uuid=True), nullable=True),
+        Column('user_uuid', UUID(as_uuid=True), nullable=False),
+        Column('tenant_uuid', UUID(as_uuid=True), nullable=False),
+        Column('status', Text, nullable=False),
+        Column('error_type', Text, nullable=True),
+        Column('error_message', Text, nullable=True),
+        Column('result_markdown', Text, nullable=True),
+        Column('progress_message', Text, nullable=True),
+        Column(
+            'created_at',
+            DateTime(timezone=True),
+            nullable=False,
+            server_default=func.now(),
+        ),
+        Column(
+            'updated_at',
+            DateTime(timezone=True),
+            nullable=False,
+            server_default=func.now(),
+        ),
+        Index(
+            'ix_generation_questionnaire_user_tenant_created_at',
+            'questionnaire_uuid',
+            'user_uuid',
+            'tenant_uuid',
+            'created_at',
+        ),
+    )
+
     return PersistenceSchema(
         metadata=metadata,
         assignment_table=assignment_table,
         template_table=template_table,
         result_table=result_table,
+        generation_table=generation_table,
     )
diff --git a/service/src/ai_document_plugin_service/ai/run_pipeline.py b/service/src/ai_document_plugin_service/ai/run_pipeline.py
index ee128ee..0df8efe 100644
--- a/service/src/ai_document_plugin_service/ai/run_pipeline.py
+++ b/service/src/ai_document_plugin_service/ai/run_pipeline.py
@@ -3,8 +3,9 @@
 import argparse
 import logging
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from typing import TYPE_CHECKING
+from uuid import UUID
 
 from haystack import AsyncPipeline
 from haystack.components.routers import ConditionalRouter
@@ -30,9 +31,6 @@
 from ai_document_plugin_service.ai.polishing.llm import SectionPolishingLLM
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
-    from uuid import UUID
-
     from haystack.components.routers.conditional_router import Route
 
     from ai_document_plugin_service.ai.common.llm_client import LLMClient
@@ -122,13 +120,13 @@ async def run_pipeline(
     dsw_client: DSWClient,
     model_name: str,
     on_progress: ProgressCallback | None = None,
-) -> tuple[str, str]:
+) -> tuple[UUID, str]:
     t1 = time.time()
     km_data = await dsw_client.get_questionnaire_detail(questionnaire_uuid=questionnaire_uuid)
 
     replies = km_data['replies']
     km = km_data['knowledgeModel']
-    knowledge_model_uuid = km_data['knowledgeModelPackage']['uuid']
+    knowledge_model_uuid = UUID(km_data['knowledgeModelPackage']['uuid'])
     knowledge_model_name = km_data['knowledgeModelPackage']['name']
     knowledge_model_version = km_data['knowledgeModelPackage']['version']
 
diff --git a/service/src/ai_document_plugin_service/api/auth.py b/service/src/ai_document_plugin_service/api/auth.py
index 6e06671..48647c5 100644
--- a/service/src/ai_document_plugin_service/api/auth.py
+++ b/service/src/ai_document_plugin_service/api/auth.py
@@ -12,6 +12,7 @@
 DSW_USER_VALIDATION_TIMEOUT_SECONDS = 10.0
 DSW_USER_VALIDATION_SUCCESS_STATUS = 200
 DSW_ADMIN_ROLE = 'admin'
+DSW_ADMIN_PERMISSION = 'SettingsManageRolePermission'
 
 
 @dataclass(frozen=True)
@@ -20,11 +21,7 @@ class AuthenticatedUser:
     api_url: str
     user_uuid: UUID
     tenant_uuid: UUID
-    role: str
-
-    @property
-    def is_admin(self) -> bool:
-        return self.role.strip().lower() == DSW_ADMIN_ROLE
+    is_admin: bool
 
 
 def is_allowed_request(api_url: str, tenant_uuid: UUID, allowed_apis: tuple[AllowedApi, ...]) -> bool:
@@ -77,16 +74,22 @@ def _fetch_dsw_user(api_url: str, token: str) -> dict[str, object] | None:
     return user
 
 
-def _extract_role(user: dict[str, object], api_url: str) -> str:
+def _is_admin(user: dict[str, object], api_url: str) -> bool:
     role = user.get('role')
-    if not isinstance(role, str) or not role.strip():
-        msg = (
-            f'Unexpected response from DSW at {api_url}: the /users/current payload '
-            f'did not include a valid string "role" (got {role!r}). '
-            f'The tenant may be running an incompatible DSW version. Received payload: {user}'
-        )
-        raise ValueError(msg)
-    return role
+    if isinstance(role, str):
+        # DSW version < 0.4.33
+        return role == DSW_ADMIN_ROLE
+    if isinstance(role, dict):
+        # DSW version >= 0.4.33
+        permissions = role.get('permissions')
+        if isinstance(permissions, list):
+            return DSW_ADMIN_PERMISSION in permissions
+    msg = (
+        f'Unexpected response from DSW at {api_url}: the /users/current payload '
+        f'did not include a valid "role" string or a "role" object with a "permissions" list. '
+        f'The tenant may be running an incompatible DSW version. Received payload: {user}'
+    )
+    raise ValueError(msg)
 
 
 def verify_authenticated(
@@ -116,11 +119,10 @@ def verify_authenticated(
     if user is None:
         raise fastapi.HTTPException(status_code=401, detail='Unauthorized')
 
-    role = _extract_role(user, normalized_api_url)
     return AuthenticatedUser(
         token=token,
         api_url=normalized_api_url,
         user_uuid=user_uuid,
         tenant_uuid=tenant_uuid,
-        role=role,
+        is_admin=_is_admin(user, normalized_api_url),
     )
diff --git a/service/src/ai_document_plugin_service/api/routes.py b/service/src/ai_document_plugin_service/api/routes.py
index be77858..7e245e8 100644
--- a/service/src/ai_document_plugin_service/api/routes.py
+++ b/service/src/ai_document_plugin_service/api/routes.py
@@ -1,19 +1,18 @@
-from uuid import UUID, uuid4
+from typing import Annotated
+from uuid import UUID
 
 import fastapi
 
 from ai_document_plugin_service.api.auth import verify_authenticated
 from ai_document_plugin_service.api.types import (
     PipelineRunRequest,
-    PipelineRunResponse,
     PipelineSaveRequest,
-    PipelineStatus,
     PipelineStatusResponse,
+    PipelineSummaryResponse,
     TemplateCreateRequest,
     TemplateDetail,
     TemplateListItem,
     TemplateUpdateRequest,
-    _model_from_fields,
 )
 from ai_document_plugin_service.di import AuthenticatedDI, ConfigDI, PipelineServiceDI, TemplateServiceDI
 from ai_document_plugin_service.service.errors import NotFoundError
@@ -66,32 +65,37 @@ async def start_pipeline(
     config: ConfigDI,
     templates: TemplateServiceDI,
     pipeline: PipelineServiceDI,
-) -> PipelineRunResponse:
+) -> PipelineStatusResponse:
     template = await templates.get(auth, payload.template_uuid)
 
-    run_id = str(uuid4())
-    pipeline.enqueue_pipeline_job(
-        run_id,
+    run_id = await pipeline.enqueue_pipeline_job(
         payload,
         template.title,
         auth,
         config,
     )
-    return _model_from_fields(
-        PipelineRunResponse,
-        status=PipelineStatus.ACCEPTED,
-        run_id=run_id,
-        questionnaire_uuid=payload.questionnaire_uuid,
-        user_uuid=auth.user_uuid,
-        tenant_uuid=auth.tenant_uuid,
-        template_uuid=payload.template_uuid,
-        template_title=template.title,
-    )
+    status = await pipeline.get_pipeline_status(run_id, auth)
+    if status is None:
+        raise NotFoundError(NotFoundError.PIPELINE_RUN_MESSAGE)
+    return status
+
+
+@protected_router.get('/pipelines')
+async def list_pipeline_history(
+    pipeline: PipelineServiceDI,
+    auth: AuthenticatedDI,
+    questionnaire_uuid: Annotated[UUID, fastapi.Query(alias='questionnaireUuid')],
+) -> list[PipelineSummaryResponse]:
+    return await pipeline.list_history(questionnaire_uuid, auth)
 
 
 @protected_router.get('/pipelines/status/{run_id}')
-def get_pipeline_status(run_id: str, pipeline: PipelineServiceDI) -> PipelineStatusResponse:
-    status = pipeline.get_pipeline_status(run_id)
+async def get_pipeline_status(
+    run_id: UUID,
+    pipeline: PipelineServiceDI,
+    auth: AuthenticatedDI,
+) -> PipelineStatusResponse:
+    status = await pipeline.get_pipeline_status(run_id, auth)
     if status is None:
         raise NotFoundError(NotFoundError.PIPELINE_RUN_MESSAGE)
     return status
@@ -99,6 +103,6 @@ def get_pipeline_status(run_id: str, pipeline: PipelineServiceDI) -> PipelineSta
 
 @protected_router.post('/pipelines/status/{run_id}/save')
 async def save_pipeline_result(
-    run_id: str, save_request: PipelineSaveRequest, pipeline: PipelineServiceDI, auth: AuthenticatedDI
+    run_id: UUID, save_request: PipelineSaveRequest, pipeline: PipelineServiceDI, auth: AuthenticatedDI
 ) -> PipelineStatusResponse:
     return await pipeline.update_pipeline_result(run_id, save_request, auth)
diff --git a/service/src/ai_document_plugin_service/api/types.py b/service/src/ai_document_plugin_service/api/types.py
index 31a80e3..9158b72 100644
--- a/service/src/ai_document_plugin_service/api/types.py
+++ b/service/src/ai_document_plugin_service/api/types.py
@@ -2,17 +2,15 @@
 from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field
-
-
-def _model_from_fields[T: ApiModel](
-    model_type: type[T],
-    **data: object,
-) -> T:
-    return model_type.model_validate(data)
+from pydantic.alias_generators import to_camel
 
 
 class ApiModel(BaseModel):
-    model_config = ConfigDict(populate_by_name=True, serialize_by_alias=True)
+    model_config = ConfigDict(
+        populate_by_name=True,
+        alias_generator=to_camel,
+        serialize_by_alias=True,
+    )
 
 
 class ErrorType(StrEnum):
@@ -22,7 +20,6 @@ class ErrorType(StrEnum):
 
 
 class PipelineStatus(StrEnum):
-    ACCEPTED = 'accepted'
     QUEUED = 'queued'
     RUNNING = 'running'
     SUCCEEDED = 'succeeded'
@@ -64,24 +61,16 @@ class TemplateUpdateRequest(ApiModel):
 
 
 class PipelineRunRequest(ApiModel):
-    questionnaire_uuid: UUID = Field(alias='questionnaireUuid')
-    template_uuid: UUID = Field(alias='templateUuid')
-    llm_model: str = Field(alias='llmModel')
-    llm_api_key: str = Field(alias='llmApiKey')
-    llm_api_url: str = Field(alias='llmApiUrl')
-    llm_max_workers: int | None = Field(default=None, alias='llmMaxWorkers', ge=1)
-
-
-class PipelineRunResponse(ApiModel):
-    status: PipelineStatus
-    run_id: str = Field(alias='runId')
-    questionnaire_uuid: UUID = Field(alias='questionnaireUuid')
-    template_uuid: UUID = Field(alias='templateUuid')
-    template_title: str = Field(alias='templateTitle')
+    questionnaire_uuid: UUID
+    template_uuid: UUID
+    llm_model: str
+    llm_api_key: str
+    llm_api_url: str
+    llm_max_workers: int | None = Field(default=None, ge=1)
 
 
 class PipelineSaveRequest(ApiModel):
-    result_markdown: str = Field(alias='resultMarkdown')
+    result_markdown: str
 
 
 class PipelineErrorResponse(ApiModel):
@@ -89,15 +78,25 @@ class PipelineErrorResponse(ApiModel):
     message: str
 
 
+class PipelineSummaryResponse(ApiModel):
+    run_id: UUID
+    status: PipelineStatus
+    template_title: str
+    error: PipelineErrorResponse | None = None
+    progress_message: str | None = None
+    created_at: str
+    updated_at: str
+
+
 class PipelineStatusResponse(ApiModel):
-    run_id: str = Field(alias='runId')
+    run_id: UUID
     status: PipelineStatus
-    questionnaire_uuid: UUID = Field(alias='questionnaireUuid')
-    knowledge_model_uuid: UUID | None = Field(default=None, alias='knowledgeModelUuid')
-    template_uuid: UUID = Field(alias='templateUuid')
-    template_title: str = Field(alias='templateTitle')
+    questionnaire_uuid: UUID
+    knowledge_model_uuid: UUID | None = None
+    template_uuid: UUID
+    template_title: str
     error: PipelineErrorResponse | None = None
-    result_format: str | None = Field(default=None, alias='resultFormat')
-    result_markdown: str | None = Field(default=None, alias='resultMarkdown')
-    progress_message: str | None = Field(default=None, alias='progressMessage')
-    updated_at: str = Field(alias='updatedAt')
+    result_format: str | None = None
+    result_markdown: str | None = None
+    progress_message: str | None = None
+    updated_at: str
diff --git a/service/src/ai_document_plugin_service/migrations/versions/20260807_01_create_generation_table.py b/service/src/ai_document_plugin_service/migrations/versions/20260807_01_create_generation_table.py
new file mode 100644
index 0000000..6f59ec4
--- /dev/null
+++ b/service/src/ai_document_plugin_service/migrations/versions/20260807_01_create_generation_table.py
@@ -0,0 +1,80 @@
+"""Create generation table.
+
+Persists pipeline run status and history (previously only kept in an
+in-memory, per-process store), scoped per user so each user's project tab
+only ever lists their own generations.
+
+Revision ID: 20260807_01
+Revises: 20260720_01
+Create Date: 2026-08-07 00:00:00
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import context, op
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = '20260807_01'
+down_revision = '20260720_01'
+branch_labels = None
+depends_on = None
+
+
+def _qualified_column_reference(schema: str | None, table: str, column: str) -> str:
+    if schema:
+        return f'{schema}.{table}.{column}'
+    return f'{table}.{column}'
+
+
+def upgrade() -> None:
+    schema = context.get_context().version_table_schema
+
+    op.create_table(
+        'generation',
+        sa.Column('run_id', postgresql.UUID(as_uuid=True), nullable=False),
+        sa.Column('questionnaire_uuid', postgresql.UUID(as_uuid=True), nullable=False),
+        sa.Column('template_uuid', postgresql.UUID(as_uuid=True), nullable=False),
+        sa.Column('title', sa.Text(), nullable=False),
+        sa.Column('knowledge_model_uuid', postgresql.UUID(as_uuid=True), nullable=True),
+        sa.Column('user_uuid', postgresql.UUID(as_uuid=True), nullable=False),
+        sa.Column('tenant_uuid', postgresql.UUID(as_uuid=True), nullable=False),
+        sa.Column('status', sa.Text(), nullable=False),
+        sa.Column('error_type', sa.Text(), nullable=True),
+        sa.Column('error_message', sa.Text(), nullable=True),
+        sa.Column('result_markdown', sa.Text(), nullable=True),
+        sa.Column('progress_message', sa.Text(), nullable=True),
+        sa.Column(
+            'created_at',
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            'updated_at',
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.ForeignKeyConstraint(
+            ['template_uuid'],
+            [_qualified_column_reference(schema, 'template', 'uuid')],
+            name='fk_generation_template_uuid',
+        ),
+        sa.PrimaryKeyConstraint('run_id', name='pk_generation'),
+        schema=schema,
+    )
+
+    op.create_index(
+        'ix_generation_questionnaire_user_tenant_created_at',
+        'generation',
+        ['questionnaire_uuid', 'user_uuid', 'tenant_uuid', 'created_at'],
+        schema=schema,
+    )
+
+
+def downgrade() -> None:
+    schema = context.get_context().version_table_schema
+    op.drop_index('ix_generation_questionnaire_user_tenant_created_at', 'generation', schema=schema)
+    op.drop_table('generation', schema=schema)
diff --git a/service/src/ai_document_plugin_service/service/pipeline_queue_manager.py b/service/src/ai_document_plugin_service/service/pipeline_queue_manager.py
index 18d7e67..33862b4 100644
--- a/service/src/ai_document_plugin_service/service/pipeline_queue_manager.py
+++ b/service/src/ai_document_plugin_service/service/pipeline_queue_manager.py
@@ -4,6 +4,7 @@
 from collections.abc import Callable, Coroutine
 from concurrent.futures import Future
 from typing import Any
+from uuid import UUID
 
 logger = logging.getLogger(__name__)
 
@@ -27,7 +28,7 @@ class PipelineQueueManager:
 
     def __init__(self, max_concurrent_jobs: int) -> None:
         self._max_concurrent_jobs = max_concurrent_jobs
-        self._order: list[str] = []
+        self._order: list[UUID] = []
         self._order_lock = threading.Lock()
         self._semaphore = asyncio.Semaphore(max_concurrent_jobs)
         self._loop = asyncio.new_event_loop()
@@ -42,25 +43,25 @@ def _run_loop(self) -> None:
         asyncio.set_event_loop(self._loop)
         self._loop.run_forever()
 
-    def enqueue(self, run_id: str, job: JobFactory) -> None:
+    def enqueue(self, run_id: UUID, job: JobFactory) -> None:
         with self._order_lock:
             self._order.append(run_id)
 
         future = asyncio.run_coroutine_threadsafe(self._run_job(run_id, job), self._loop)
         future.add_done_callback(self._log_job_failure)
 
-    def progress_message(self, run_id: str) -> str | None:
+    def progress_message(self, run_id: UUID) -> str | None:
         jobs_waiting_ahead = self._jobs_waiting_ahead(run_id)
         if jobs_waiting_ahead is None:
             return None
         return format_queue_progress(jobs_waiting_ahead)
 
-    def remove(self, run_id: str) -> None:
+    def remove(self, run_id: UUID) -> None:
         with self._order_lock:
             if run_id in self._order:
                 self._order.remove(run_id)
 
-    def _jobs_waiting_ahead(self, run_id: str) -> int | None:
+    def _jobs_waiting_ahead(self, run_id: UUID) -> int | None:
         with self._order_lock:
             try:
                 queue_index = self._order.index(run_id)
@@ -68,7 +69,7 @@ def _jobs_waiting_ahead(self, run_id: str) -> int | None:
                 return None
         return queue_index - self._max_concurrent_jobs
 
-    async def _run_job(self, run_id: str, job: JobFactory) -> None:
+    async def _run_job(self, run_id: UUID, job: JobFactory) -> None:
         try:
             async with self._semaphore:
                 await job()
diff --git a/service/src/ai_document_plugin_service/service/pipeline_service.py b/service/src/ai_document_plugin_service/service/pipeline_service.py
index 7e9892a..44e516e 100644
--- a/service/src/ai_document_plugin_service/service/pipeline_service.py
+++ b/service/src/ai_document_plugin_service/service/pipeline_service.py
@@ -1,6 +1,7 @@
+import asyncio
 import logging
 import threading
-from datetime import UTC, datetime
+from asyncio import Task
 from uuid import UUID
 
 from openai import AuthenticationError
@@ -12,7 +13,7 @@
 from ai_document_plugin_service.ai.common.llm_client import LLMClient
 from ai_document_plugin_service.ai.knowledgemodel.dsw_client import DSWClient
 from ai_document_plugin_service.ai.persistence.assignment_saver_component import DBSaver
-from ai_document_plugin_service.ai.persistence.database import Database
+from ai_document_plugin_service.ai.persistence.database import Database, GenerationRecord
 from ai_document_plugin_service.ai.run_pipeline import build_pipeline, run_pipeline
 from ai_document_plugin_service.api.auth import AuthenticatedUser
 from ai_document_plugin_service.api.types import (
@@ -22,7 +23,7 @@
     PipelineSaveRequest,
     PipelineStatus,
     PipelineStatusResponse,
-    _model_from_fields,
+    PipelineSummaryResponse,
 )
 from ai_document_plugin_service.service.errors import InternalError, NotFoundError
 from ai_document_plugin_service.service.pipeline_queue_manager import PipelineQueueManager
@@ -47,8 +48,38 @@ def _pipeline_error_from_exception(error: Exception) -> PipelineErrorResponse:
     )
 
 
-def _now() -> str:
-    return datetime.now(tz=UTC).isoformat()
+def _generation_error(record: GenerationRecord) -> PipelineErrorResponse | None:
+    if record.error_type is None or record.error_message is None:
+        return None
+    return PipelineErrorResponse(type=ErrorType(record.error_type), message=record.error_message)
+
+
+def _generation_record_to_status_response(record: GenerationRecord) -> PipelineStatusResponse:
+    return PipelineStatusResponse(
+        run_id=record.run_id,
+        status=PipelineStatus(record.status),
+        questionnaire_uuid=record.questionnaire_uuid,
+        knowledge_model_uuid=record.knowledge_model_uuid,
+        template_uuid=record.template_uuid,
+        template_title=record.title,
+        error=_generation_error(record),
+        result_format='markdown' if record.result_markdown is not None else None,
+        result_markdown=record.result_markdown,
+        progress_message=record.progress_message,
+        updated_at=record.updated_at.isoformat(),
+    )
+
+
+def _generation_record_to_summary_response(record: GenerationRecord) -> PipelineSummaryResponse:
+    return PipelineSummaryResponse(
+        run_id=record.run_id,
+        status=PipelineStatus(record.status),
+        template_title=record.title,
+        error=_generation_error(record),
+        progress_message=record.progress_message,
+        created_at=record.created_at.isoformat(),
+        updated_at=record.updated_at.isoformat(),
+    )
 
 
 class LlmClientTenantStore:
@@ -72,69 +103,58 @@ def get_llm_client(self, tenant_uuid: UUID) -> LLMClient:
             return self._clients[tenant_uuid]
 
 
-class PipelineRunStore:
-    """Thread-safe in-memory store of pipeline run statuses."""
-
-    def __init__(self) -> None:
-        self._runs: dict[str, PipelineStatusResponse] = {}
-        self._lock = threading.Lock()
-
-    def get(self, run_id: str) -> PipelineStatusResponse | None:
-        with self._lock:
-            return self._runs.get(run_id)
-
-    def set(self, run_id: str, status: PipelineStatusResponse) -> None:
-        with self._lock:
-            self._runs[run_id] = status
-
-    def update(self, run_id: str, **updates: object) -> PipelineStatusResponse | None:
-        """Store a copy of the current status with ``updates`` applied and a fresh ``updated_at``."""
-        with self._lock:
-            current = self._runs.get(run_id)
-            if current is None:
-                return None
-            status = current.model_copy(update={**updates, 'updated_at': _now()})
-            self._runs[run_id] = status
-            return status
+def _log_background_update_failure(task: Task[object]) -> None:
+    # Progress-message updates are best-effort and fired without awaiting; this guards
+    # against an unhandled exception being silently swallowed.
+    if task.cancelled():
+        return
+    error = task.exception()
+    if error is not None:
+        logger.error('Failed to persist pipeline progress message', exc_info=error)
 
 
 class PipelineService:
     def __init__(self, pipeline_queue_manager: PipelineQueueManager, database: Database) -> None:
         self.pipeline_queue_manager = pipeline_queue_manager
         self.database = database
-        self._runs = PipelineRunStore()
         self._llm_clients = LlmClientTenantStore()
 
-    def get_pipeline_status(self, run_id: str) -> PipelineStatusResponse | None:
-        status = self._runs.get(run_id)
-        if status is None or status.status != PipelineStatus.QUEUED:
+    async def get_pipeline_status(self, run_id: UUID, auth: AuthenticatedUser) -> PipelineStatusResponse | None:
+        record = await self.database.get_generation(run_id, auth.tenant_uuid, auth.user_uuid)
+        if record is None:
+            return None
+
+        status = _generation_record_to_status_response(record)
+        if status.status != PipelineStatus.QUEUED:
             return status
 
+        # Handle queued progress message (x dmps ahead in queue)
         progress_message = self.pipeline_queue_manager.progress_message(run_id)
         if progress_message is None:
             return status
 
         return status.model_copy(update={'progress_message': progress_message})
 
-    def enqueue_pipeline_job(
+    async def list_history(self, questionnaire_uuid: UUID, auth: AuthenticatedUser) -> list[PipelineSummaryResponse]:
+        records = await self.database.list_generations(questionnaire_uuid, auth.tenant_uuid, auth.user_uuid)
+        return [_generation_record_to_summary_response(record) for record in records]
+
+    async def enqueue_pipeline_job(
         self,
-        run_id: str,
         payload: PipelineRunRequest,
-        template_title: str,
+        title: str,
         auth: AuthenticatedUser,
         config: Config,
-    ) -> None:
+    ) -> UUID:
         """Queue a pipeline job; concurrency is limited by ``pipeline_queue_manager``."""
-        run = _model_from_fields(
-            PipelineStatusResponse,
-            run_id=run_id,
-            status=PipelineStatus.QUEUED,
+        run_id = await self.database.create_generation(
             questionnaire_uuid=payload.questionnaire_uuid,
             template_uuid=payload.template_uuid,
-            template_title=template_title,
-            updated_at=_now(),
+            title=title,
+            user_uuid=auth.user_uuid,
+            tenant_uuid=auth.tenant_uuid,
+            status=PipelineStatus.QUEUED,
         )
-        self._runs.set(run_id, run)
 
         llm_config = LLMConfig(
             model=payload.llm_model,
@@ -144,76 +164,94 @@ def enqueue_pipeline_job(
         )
         self.pipeline_queue_manager.enqueue(
             run_id,
-            lambda: self._run_pipeline_job(run, auth, llm_config, config),
+            lambda: self._run_pipeline_job(
+                run_id,
+                payload.questionnaire_uuid,
+                payload.template_uuid,
+                auth,
+                llm_config,
+                config,
+            ),
         )
+        return run_id
 
     async def update_pipeline_result(
-        self, run_id: str, save_request: PipelineSaveRequest, auth: AuthenticatedUser
+        self, run_id: UUID, save_request: PipelineSaveRequest, auth: AuthenticatedUser
     ) -> PipelineStatusResponse:
-        pipeline_status = self.get_pipeline_status(run_id)
-        if pipeline_status is None:
+        record = await self.database.get_generation(run_id, auth.tenant_uuid, auth.user_uuid)
+        if record is None:
             raise NotFoundError(NotFoundError.PIPELINE_RUN_MESSAGE)
 
-        if pipeline_status.knowledge_model_uuid is None:
+        if record.knowledge_model_uuid is None:
             raise InternalError(InternalError.MISSING_KNOWLEDGE_MODEL_MESSAGE)
 
         await self.database.update_result(
-            template_uuid=pipeline_status.template_uuid,
-            knowledge_model_uuid=pipeline_status.knowledge_model_uuid,
+            template_uuid=record.template_uuid,
+            knowledge_model_uuid=record.knowledge_model_uuid,
             user_uuid=auth.user_uuid,
             tenant_uuid=auth.tenant_uuid,
             markdown=save_request.result_markdown,
         )
 
-        updated_status = self._runs.update(
+        updated_record = await self.database.update_generation(
             run_id,
-            result_format='markdown',
+            auth.tenant_uuid,
             result_markdown=save_request.result_markdown,
             progress_message=None,
         )
-        if updated_status is None:
+        if updated_record is None:
             raise NotFoundError(NotFoundError.PIPELINE_RUN_MESSAGE)
-        return updated_status
+        return _generation_record_to_status_response(updated_record)
 
     async def _run_pipeline_job(
         self,
-        run: PipelineStatusResponse,
+        run_id: UUID,
+        questionnaire_uuid: UUID,
+        template_uuid: UUID,
         auth: AuthenticatedUser,
         llm_config: LLMConfig,
         config: Config,
     ) -> None:
         try:
-            await self._run_pipeline(run, auth, llm_config, config)
+            await self._run_pipeline(run_id, questionnaire_uuid, template_uuid, auth, llm_config, config)
         except Exception as error:
             logger.exception('Pipeline run failed')
-            self._runs.update(
-                run.run_id,
+            pipeline_error = _pipeline_error_from_exception(error)
+            await self.database.update_generation(
+                run_id,
+                auth.tenant_uuid,
                 status=PipelineStatus.FAILED,
-                error=_pipeline_error_from_exception(error),
+                error_type=pipeline_error.type,
+                error_message=pipeline_error.message,
                 progress_message=None,
             )
 
     async def _run_pipeline(
         self,
-        run: PipelineStatusResponse,
+        run_id: UUID,
+        questionnaire_uuid: UUID,
+        template_uuid: UUID,
         auth: AuthenticatedUser,
         llm_config: LLMConfig,
         config: Config,
     ) -> None:
-        run_id = run.run_id
-        template = await self.database.get_template(run.template_uuid, auth.tenant_uuid)
+        template = await self.database.get_template(template_uuid, auth.tenant_uuid)
         if template is None:
-            self._runs.update(
+            await self.database.update_generation(
                 run_id,
+                auth.tenant_uuid,
                 status=PipelineStatus.FAILED,
-                error=PipelineErrorResponse(
-                    type=ErrorType.TEMPLATE_NOT_FOUND,
-                    message=TEMPLATE_NOT_FOUND_MESSAGE,
-                ),
+                error_type=ErrorType.TEMPLATE_NOT_FOUND,
+                error_message=TEMPLATE_NOT_FOUND_MESSAGE,
             )
             return
 
-        self._runs.update(run_id, status=PipelineStatus.RUNNING, progress_message='Starting pipeline...')
+        await self.database.update_generation(
+            run_id,
+            auth.tenant_uuid,
+            status=PipelineStatus.RUNNING,
+            progress_message='Starting pipeline...',
+        )
 
         llm_client = self._llm_clients.get_llm_client(auth.tenant_uuid)
         llm_client.update_config(llm_config.model, llm_config.api_key, llm_config.api_url, llm_config.parallel_workers)
@@ -225,11 +263,16 @@ async def _run_pipeline(
         )
 
         def on_progress(message: str) -> None:
-            self._runs.update(run_id, progress_message=message)
+            # Called synchronously from deep inside the (async) pipeline; fire the DB
+            # write without awaiting it so progress reporting never blocks generation.
+            task = asyncio.ensure_future(
+                self.database.update_generation(run_id, auth.tenant_uuid, progress_message=message),
+            )
+            task.add_done_callback(_log_background_update_failure)
 
         knowledge_model_uuid, result = await run_pipeline(
-            questionnaire_uuid=run.questionnaire_uuid,
-            template_uuid=run.template_uuid,
+            questionnaire_uuid=questionnaire_uuid,
+            template_uuid=template_uuid,
             template_title=template.title,
             template_data=template.content,
             user_uuid=auth.user_uuid,
@@ -241,11 +284,11 @@ def on_progress(message: str) -> None:
             dsw_client=DSWClient(auth.token, auth.api_url),
         )
 
-        self._runs.update(
+        await self.database.update_generation(
             run_id,
+            auth.tenant_uuid,
             status=PipelineStatus.SUCCEEDED,
             knowledge_model_uuid=knowledge_model_uuid,
-            result_format='markdown',
             result_markdown=result,
             progress_message=None,
         )
diff --git a/service/src/ai_document_plugin_service/service/template_service.py b/service/src/ai_document_plugin_service/service/template_service.py
index b3fb665..a734a8b 100644
--- a/service/src/ai_document_plugin_service/service/template_service.py
+++ b/service/src/ai_document_plugin_service/service/template_service.py
@@ -9,7 +9,6 @@
     TemplateListItem,
     TemplateScope,
     TemplateUpdateRequest,
-    _model_from_fields,
 )
 from ai_document_plugin_service.service.errors import (
     AccessDeniedError,
@@ -56,8 +55,7 @@ async def create(self, auth: AuthenticatedUser, payload: TemplateCreateRequest)
         except TemplateTitleConflictError as error:
             raise ConflictError(str(error)) from error
 
-        return _model_from_fields(
-            TemplateDetail,
+        return TemplateDetail(
             uuid=template_uuid,
             title=trimmed_title,
             content=payload.content,
@@ -91,8 +89,7 @@ async def update(
             except TemplateTitleConflictError as error:
                 raise ConflictError(str(error)) from error
 
-        return _model_from_fields(
-            TemplateDetail,
+        return TemplateDetail(
             uuid=template_uuid,
             title=trimmed_title,
             content=payload.content,
@@ -122,8 +119,7 @@ def _can_mutate(auth: AuthenticatedUser, scope: TemplateScope, owner_uuid: UUID
 
     @staticmethod
     def _to_list_item(record: TemplateRecord) -> TemplateListItem:
-        return _model_from_fields(
-            TemplateListItem,
+        return TemplateListItem(
             uuid=str(record.uuid),
             title=record.title,
             scope=record.scope,
@@ -131,8 +127,7 @@ def _to_list_item(record: TemplateRecord) -> TemplateListItem:
 
     @staticmethod
     def _to_detail(record: TemplateRecord) -> TemplateDetail:
-        return _model_from_fields(
-            TemplateDetail,
+        return TemplateDetail(
             uuid=record.uuid,
             title=record.title,
             content=record.content,
diff --git a/service/tests/api/test_auth.py b/service/tests/api/test_auth.py
index 6b4c3c5..ecf1411 100644
--- a/service/tests/api/test_auth.py
+++ b/service/tests/api/test_auth.py
@@ -113,7 +113,13 @@ def test_protected_route_succeeds_when_dsw_validates_user(
     mock_httpx_get.return_value = httpx.Response(
         200,
         request=httpx.Request('GET', ALLOWED_URL),
-        json={'role': 'researcher'},
+        json={
+            'role': {
+                'name': 'Researcher',
+                'permissions': ['ProjectsViewRolePermission'],
+                'uuid': '31ccc093-3ab0-4459-b109-ab1d8dc2313f',
+            }
+        },
     )
     template_uuid = UUID('99999999-9999-9999-9999-999999999999')
     mock_postgres_db.return_value.list_templates = AsyncMock(
@@ -137,3 +143,39 @@ def test_protected_route_succeeds_when_dsw_validates_user(
     assert response.status_code == 200
     assert response.json() == [{'uuid': str(template_uuid), 'title': 'Template 1', 'scope': 'tenant'}]
     mock_httpx_get.assert_called_once()
+
+
+@patch('ai_document_plugin_service.api.auth.httpx.get')
+@patch('ai_document_plugin_service.di.PostgresDB')
+def test_protected_route_succeeds_when_dsw_validates_user(
+    mock_postgres_db: MagicMock,
+    mock_httpx_get: MagicMock,
+    monkeypatch,
+) -> None:
+    mock_httpx_get.return_value = httpx.Response(
+        200,
+        request=httpx.Request('GET', ALLOWED_URL),
+        json={'role': 'researcher'}, # Test DSW version below 4.33
+    )
+    template_uuid = UUID('99999999-9999-9999-9999-999999999999')
+    mock_postgres_db.return_value.list_templates = AsyncMock(
+        return_value=[
+            TemplateRecord(
+                uuid=template_uuid,
+                title='Template 1',
+                content={'sections': []},
+                tenant_uuid=UUID(ALLOWED_TENANT_UUID),
+                user_uuid=None,
+            ),
+        ],
+    )
+    mock_postgres_db.return_value.dispose = AsyncMock()
+
+    _use_test_config(monkeypatch)
+
+    client = TestClient(create_app(run_migrations=False))
+    response = client.get('/templates', headers=_auth_headers())
+
+    assert response.status_code == 200
+    assert response.json() == [{'uuid': str(template_uuid), 'title': 'Template 1', 'scope': 'tenant'}]
+    mock_httpx_get.assert_called_once()
\ No newline at end of file
diff --git a/service/tests/service/test_template_service.py b/service/tests/service/test_template_service.py
index df6c686..21514e3 100644
--- a/service/tests/service/test_template_service.py
+++ b/service/tests/service/test_template_service.py
@@ -38,13 +38,13 @@ def _database() -> AsyncMock:
     return database
 
 
-def _user(*, role: str = 'researcher', user_uuid: uuid.UUID = USER_UUID) -> AuthenticatedUser:
+def _user(*, is_admin: bool = False, user_uuid: uuid.UUID = USER_UUID) -> AuthenticatedUser:
     return AuthenticatedUser(
         token='token',
         api_url='https://dsw.example.com/wizard-api',
         user_uuid=user_uuid,
         tenant_uuid=TENANT_UUID,
-        role=role,
+        is_admin=is_admin,
     )
 
 
@@ -144,7 +144,7 @@ async def test_create_tenant_template_by_admin_has_no_owner() -> None:
     database.create_template.return_value = template_uuid
     payload = TemplateCreateRequest(title='Common', content=VALID_CONTENT, scope=TemplateScope.TENANT)
 
-    detail = await TemplateService(database).create(_user(role='admin'), payload)
+    detail = await TemplateService(database).create(_user(is_admin=True), payload)
 
     database.create_template.assert_awaited_once_with(
         title='Common',
@@ -160,7 +160,7 @@ async def test_create_tenant_template_by_non_admin_is_denied() -> None:
     payload = TemplateCreateRequest(title='Common', content=VALID_CONTENT, scope=TemplateScope.TENANT)
 
     with pytest.raises(AccessDeniedError):
-        await TemplateService(database).create(_user(role='researcher'), payload)
+        await TemplateService(database).create(_user(is_admin=False), payload)
 
     database.create_template.assert_not_awaited()
 
@@ -172,7 +172,7 @@ async def test_create_authorizes_before_validating() -> None:
     payload = TemplateCreateRequest(title='', content={}, scope=TemplateScope.TENANT)
 
     with pytest.raises(AccessDeniedError):
-        await TemplateService(database).create(_user(role='researcher'), payload)
+        await TemplateService(database).create(_user(is_admin=False), payload)
 
 
 async def test_create_rejects_blank_title() -> None:
@@ -228,7 +228,7 @@ async def test_update_tenant_template_by_admin() -> None:
     database.update_template.return_value = True
     payload = TemplateUpdateRequest(title='Renamed', content=VALID_CONTENT)
 
-    detail = await TemplateService(database).update(_user(role='admin'), template_uuid, payload)
+    detail = await TemplateService(database).update(_user(is_admin=True), template_uuid, payload)
 
     assert detail.scope is TemplateScope.TENANT
     database.update_template.assert_awaited_once()
@@ -241,7 +241,7 @@ async def test_update_tenant_template_by_non_admin_is_denied() -> None:
     payload = TemplateUpdateRequest(title='Renamed', content=VALID_CONTENT)
 
     with pytest.raises(AccessDeniedError):
-        await TemplateService(database).update(_user(role='researcher'), template_uuid, payload)
+        await TemplateService(database).update(_user(is_admin=False), template_uuid, payload)
 
     database.update_template.assert_not_awaited()
 
@@ -293,7 +293,7 @@ async def test_delete_tenant_template_by_admin() -> None:
     database = _database()
     database.get_template.return_value = _record(template_uuid=template_uuid, user_uuid=None)
 
-    await TemplateService(database).delete(_user(role='admin'), template_uuid)
+    await TemplateService(database).delete(_user(is_admin=True), template_uuid)
 
     database.delete_template.assert_awaited_once_with(template_uuid, TENANT_UUID)
 
@@ -304,7 +304,7 @@ async def test_delete_tenant_template_by_non_admin_is_denied() -> None:
     database.get_template.return_value = _record(template_uuid=template_uuid, user_uuid=None)
 
     with pytest.raises(AccessDeniedError):
-        await TemplateService(database).delete(_user(role='researcher'), template_uuid)
+        await TemplateService(database).delete(_user(is_admin=False), template_uuid)
 
     database.delete_template.assert_not_awaited()
 
@@ -325,7 +325,7 @@ async def test_delete_other_users_by_admin_is_hidden() -> None:
     database.get_template.return_value = _record(template_uuid=template_uuid, user_uuid=OTHER_USER_UUID)
 
     with pytest.raises(NotFoundError):
-        await TemplateService(database).delete(_user(role="admin"), template_uuid)
+        await TemplateService(database).delete(_user(is_admin=True), template_uuid)
 
     database.delete_template.assert_not_awaited()