diff --git a/docs/relaunch/DECISIONS.md b/docs/relaunch/DECISIONS.md
index ff5978d..289b901 100644
--- a/docs/relaunch/DECISIONS.md
+++ b/docs/relaunch/DECISIONS.md
@@ -31,6 +31,11 @@ Format: `YYYY-MM-DD · WP-XX · decision · why · alternatives considered`.
 - 2026-10-27 · WP-08 · Quota consume = check-then-mark (not atomic) in `assertAndConsumeQuota` + `consumeEpisodeQuota` · a workspace has a single owner (§3: no teams in the MVP), so a race can only double-count the owner against themselves; the pipeline routes (WP-05/06) call these around POST /api/episodes · a transactional `INSERT … WHERE count < limit` (needs a CTE on every create for no real contention)
 - 2026-10-27 · WP-08 · Billing page renders as a partial-prerender shell with the plan card streamed in `<Suspense>`; the quota reset date is computed at request time · Next 16 `cacheComponents` forbids route segment `dynamic` and blocks `new Date()` during prerender; the streaming shell keeps the instant preview · `export const instant = false` (newer, less documented escape hatch)
 
+- 2026-10-27 · WP-06 · E2E run against an embedded Postgres (PGlite) behind `DATABASE_URL=pglite:<dir>` + `scripts/e2e-seed.mjs`; tests select it with `E2E_DB=1` (`pnpm e2e:db`), keyless suite unchanged · real U6/U11–U13 flows need a real DB; no Neon instance exists (owner blocker) · ephemeral docker postgres (no docker in CI), mocking (not e2e)
+- 2026-10-27 · WP-06 · E2E auth seam: `E2E_AUTH_USER_ID` honored only when Clerk is absent AND DATABASE_URL starts with `pglite:` — it can never authenticate against a real database (WP-02's fail-closed rule preserved) · e2e needs an identity without Clerk keys · any-env preview user (weakens fail-closed)
+- 2026-10-27 · WP-06 · PGlite kept as one instance per dataDir via globalThis (Turbopack loads db modules per route chunk; a second instance on the same dir aborts the wasm) and `serverExternalPackages` so its wasm loader stays unbundled; `replaceSegments` falls back to sequential statements without neon's `.batch` · observed crashes; documented PGlite+bundler guidance · per-chunk instances
+- 2026-10-27 · WP-06 · `cacheComponents`/`partialPrefetching` disabled app-wide · the PPR runtime replay guard rejects `Date.now()` in streamed per-user pages (intermittent second-request failures); every page already uses `connection()` + Suspense which renders identically without it · per-route workarounds (fragile, guard fired from replayed shells)
+- 2026-10-27 · WP-06 · Stored segment ids namespaced `seg_<episodeId[:8]>_<idx>` — segments.id is the GLOBAL primary key (§7.1), so per-episode `seg_000000` collided across episodes (would break the 2nd episode in production) · found by the DB-mode e2e · uuid ids (breaks §7.3 prompt-shape familiarity)
 - 2026-10-27 · WP-01 · `/dev/components` ships in every build; "dev only" is enforced by noindex metadata + zero inbound links (no nav/sitemap entry) · WP-00 fixed `pnpm e2e` to test the production build via `next start`, so a NODE_ENV or env-var gate would break the axe e2e locally and in CI · gating the route on `NODE_ENV=development`; a `NEXT_PUBLIC_*` flag set in the CI e2e step
 - 2026-10-27 · WP-01 · Toast = shadcn `sonner` with the Toaster pinned bottom-right + 4 s (§5.3); dropped the generated `next-themes` wiring, sonner `theme="system"` follows prefers-color-scheme like every other component · the registry has no radix `toast` for the radix style ("only available for Base UI projects" per CLI) and sonner is shadcn's current default · hand-rolled wrapper on radix Toast primitives
 - 2026-10-27 · WP-01 · shadcn `--muted-foreground` maps to §5.2 `--body`, not `--faint`: faint on surface-2/3 sits at/below the 4.5:1 AA floor (4.51:1 / ~4.2:1) and muted-foreground renders on muted surfaces (dialog footers, segmented tabs); faint remains in use for text on bg/surface (4.83:1) via custom components · acceptance says fix the component mapping, not the spec tokens · mapping muted-foreground to faint and flagging the AA miss in the PR
diff --git a/web/.gitignore b/web/.gitignore
index 5f82093..f2581be 100644
--- a/web/.gitignore
+++ b/web/.gitignore
@@ -45,3 +45,6 @@ next-env.d.ts
 test-results/
 playwright-report/
 blob-report/
+
+# e2e
+.pglite-e2e/
diff --git a/web/app/(app)/app/episodes/[id]/page.tsx b/web/app/(app)/app/episodes/[id]/page.tsx
new file mode 100644
index 0000000..b867634
--- /dev/null
+++ b/web/app/(app)/app/episodes/[id]/page.tsx
@@ -0,0 +1,48 @@
+// MK-5/MK-6: processing and workspace share this URL; the client view drives
+// the pipeline and polls until terminal (§7.5). Dynamic per-user data is
+// streamed behind Suspense (Next 16 cacheComponents).
+import { Suspense } from "react";
+import { connection } from "next/server";
+import Link from "next/link";
+import { requireUser } from "@/lib/auth";
+import { getShowByOwner } from "@/db/queries";
+import { handleEpisodeWithArtifactsGet } from "@/lib/pipeline/service";
+import { WorkspaceView } from "@/components/workspace/workspace-view";
+
+export default function EpisodeWorkspacePage({ params }: PageProps<"/app/episodes/[id]">) {
+  return (
+    <Suspense
+      fallback={
+        <main className="flex flex-1 items-center justify-center p-10 text-sm text-muted-foreground" data-testid="workspace-loading">
+          Loading your workspace…
+        </main>
+      }
+    >
+      <WorkspaceContent params={params} />
+    </Suspense>
+  );
+}
+
+async function WorkspaceContent({ params }: { params: Promise<{ id: string }> }) {
+  // Per-user episode data — request-time rendering.
+  await connection();
+  const userId = await requireUser();
+  const { id } = await params;
+
+  const result = await handleEpisodeWithArtifactsGet(userId, id);
+  if (result.status !== 200) {
+    return (
+      <main className="flex flex-1 flex-col items-center gap-2 p-10 text-center">
+        <h1 className="text-lg font-semibold">Episode not found</h1>
+        <Link href="/app/episodes" className="text-sm text-[var(--accent)]">
+          Back to episodes
+        </Link>
+      </main>
+    );
+  }
+
+  const data = result.json as unknown as import("@/lib/pipeline/client").WorkspaceData;
+  const show = await getShowByOwner(userId);
+
+  return <WorkspaceView initial={data} freePlan={data.freePlan} showName={show?.name ?? "Your show"} />;
+}
diff --git a/web/app/api/artifacts/[id]/route.ts b/web/app/api/artifacts/[id]/route.ts
new file mode 100644
index 0000000..fcf8d3f
--- /dev/null
+++ b/web/app/api/artifacts/[id]/route.ts
@@ -0,0 +1,15 @@
+import { getAuthUserId } from "@/lib/auth";
+import { AUTH_REQUIRED_COPY } from "@/lib/copy";
+import { handleArtifactPatch } from "@/lib/pipeline/service";
+
+/** PATCH /api/artifacts/:id — {content} save · {ready} · {undo:true} (§7.5). */
+export async function PATCH(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const userId = await getAuthUserId();
+  if (!userId) {
+    return Response.json({ error: AUTH_REQUIRED_COPY }, { status: 401 });
+  }
+  const { id } = await params;
+  const body: unknown = await req.json().catch(() => ({}));
+  const result = await handleArtifactPatch(userId, id, body);
+  return Response.json(result.json, { status: result.status });
+}
diff --git a/web/app/api/episodes/[id]/analyze/route.ts b/web/app/api/episodes/[id]/analyze/route.ts
new file mode 100644
index 0000000..2e82e0e
--- /dev/null
+++ b/web/app/api/episodes/[id]/analyze/route.ts
@@ -0,0 +1,14 @@
+import { getAuthUserId } from "@/lib/auth";
+import { AUTH_REQUIRED_COPY } from "@/lib/copy";
+import { handleAnalyzePost } from "@/lib/pipeline/service";
+
+/** POST /api/episodes/:id/analyze — chapters/topics/candidate quotes (§7.5). */
+export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const userId = await getAuthUserId();
+  if (!userId) {
+    return Response.json({ error: AUTH_REQUIRED_COPY }, { status: 401 });
+  }
+  const { id } = await params;
+  const result = await handleAnalyzePost(userId, id);
+  return Response.json(result.json, { status: result.status });
+}
diff --git a/web/app/api/episodes/[id]/artifacts/[kind]/generate/route.ts b/web/app/api/episodes/[id]/artifacts/[kind]/generate/route.ts
new file mode 100644
index 0000000..7408a5a
--- /dev/null
+++ b/web/app/api/episodes/[id]/artifacts/[kind]/generate/route.ts
@@ -0,0 +1,17 @@
+import { getAuthUserId } from "@/lib/auth";
+import { AUTH_REQUIRED_COPY } from "@/lib/copy";
+import { handleArtifactGeneratePost } from "@/lib/pipeline/service";
+
+export const maxDuration = 300;
+
+/** POST /api/episodes/:id/artifacts/:kind/generate — one artifact (§7.5). */
+export async function POST(req: Request, { params }: { params: Promise<{ id: string; kind: string }> }) {
+  const userId = await getAuthUserId();
+  if (!userId) {
+    return Response.json({ error: AUTH_REQUIRED_COPY }, { status: 401 });
+  }
+  const { id, kind } = await params;
+  const body: unknown = await req.json().catch(() => ({}));
+  const result = await handleArtifactGeneratePost(userId, id, kind, body);
+  return Response.json(result.json, { status: result.status });
+}
diff --git a/web/app/api/episodes/[id]/route.ts b/web/app/api/episodes/[id]/route.ts
index 94496b7..bb3b1dd 100644
--- a/web/app/api/episodes/[id]/route.ts
+++ b/web/app/api/episodes/[id]/route.ts
@@ -1,6 +1,7 @@
 import { getAuthUserId } from "@/lib/auth";
 import { AUTH_REQUIRED_COPY } from "@/lib/copy";
 import { handleEpisodeGet } from "@/lib/episodes/service";
+import { handleEpisodeDelete } from "@/lib/pipeline/service";
 
 /** GET /api/episodes/:id — episode + status, polled every 2 s (§7.5, U4). */
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -12,3 +13,14 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
   const result = await handleEpisodeGet(userId, id);
   return Response.json(result.json, { status: result.status });
 }
+
+/** DELETE /api/episodes/:id — edit meta handled by PATCH; delete + blob (§7.5). */
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const userId = await getAuthUserId();
+  if (!userId) {
+    return Response.json({ error: AUTH_REQUIRED_COPY }, { status: 401 });
+  }
+  const { id } = await params;
+  const result = await handleEpisodeDelete(userId, id);
+  return Response.json(result.json, { status: result.status });
+}
diff --git a/web/app/api/episodes/[id]/workspace/route.ts b/web/app/api/episodes/[id]/workspace/route.ts
new file mode 100644
index 0000000..394906f
--- /dev/null
+++ b/web/app/api/episodes/[id]/workspace/route.ts
@@ -0,0 +1,15 @@
+import { getAuthUserId } from "@/lib/auth";
+import { AUTH_REQUIRED_COPY } from "@/lib/copy";
+import { handleEpisodeWithArtifactsGet } from "@/lib/pipeline/service";
+
+/** GET /api/episodes/:id/workspace — episode + artifacts + analysis + segments
+ *  for the workspace view; polled while not terminal (§7.5). */
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const userId = await getAuthUserId();
+  if (!userId) {
+    return Response.json({ error: AUTH_REQUIRED_COPY }, { status: 401 });
+  }
+  const { id } = await params;
+  const result = await handleEpisodeWithArtifactsGet(userId, id);
+  return Response.json(result.json, { status: result.status });
+}
diff --git a/web/components/workspace/editors.tsx b/web/components/workspace/editors.tsx
new file mode 100644
index 0000000..e0f4ddb
--- /dev/null
+++ b/web/components/workspace/editors.tsx
@@ -0,0 +1,367 @@
+"use client";
+// MK-6b artifact layouts: every field an auto-growing textarea (Markdown
+// allowed where §7.2 says so), autosave 1.5 s after the last keystroke,
+// char/word counters with limits. One component per kind so hooks stay
+// unconditional; the parent remounts editors on regenerate via `key`.
+import { useEffect, useRef, useState } from "react";
+import type { ArtifactKindName, ArtifactView, TranscriptSegment } from "@/lib/pipeline/client";
+import { renderBlogBody } from "@/lib/export/format";
+
+function mmss(ms: number): string {
+  const s = Math.floor(ms / 1000);
+  return `${String(Math.floor(s / 60)).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}`;
+}
+
+function EditorShell({ children }: { children: React.ReactNode }) {
+  return <div className="flex flex-col gap-4">{children}</div>;
+}
+
+/** Auto-growing textarea with the 1.5 s debounced autosave (M6). */
+function AutoField({
+  value,
+  onChange,
+  onSave,
+  label,
+  max,
+  words,
+  rows = 3,
+  markdown,
+  testId,
+}: {
+  value: string;
+  onChange: (v: string) => void;
+  onSave: () => void;
+  label: string;
+  max?: number;
+  words?: [number, number];
+  rows?: number;
+  markdown?: boolean;
+  testId?: string;
+}) {
+  const ref = useRef<HTMLTextAreaElement>(null);
+  const timer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  useEffect(() => {
+    const el = ref.current;
+    if (el) {
+      el.style.height = "auto";
+      el.style.height = `${el.scrollHeight}px`;
+    }
+  }, [value]);
+
+  const handle = (v: string) => {
+    onChange(v);
+    if (timer.current) clearTimeout(timer.current);
+    timer.current = setTimeout(onSave, 1500);
+  };
+
+  const count = words
+    ? `${value.trim().split(/\s+/).filter(Boolean).length} words (${words[0]}–${words[1]})`
+    : `${value.length}${max ? `/${max}` : ""}`;
+  const over = max !== undefined && value.length > max;
+  const warn = max !== undefined && !over && value.length >= max * 0.9;
+
+  return (
+    <label className="block">
+      {label && <span className="mb-1 block text-xs font-medium text-muted-foreground">{label}</span>}
+      <textarea
+        ref={ref}
+        rows={rows}
+        value={value}
+        data-testid={testId}
+        onChange={(e) => handle(e.target.value)}
+        className={`w-full resize-none rounded-md border px-3 py-2 text-sm ${markdown ? "font-mono" : ""}`}
+      />
+      <span
+        className={`mt-0.5 block text-right text-xs ${over ? "text-[var(--danger)]" : warn ? "text-[var(--warning)]" : "text-muted-foreground"}`}
+        data-testid="field-counter"
+      >
+        {count}
+      </span>
+    </label>
+  );
+}
+
+interface EditorProps {
+  content: Record<string, unknown>;
+  patch: (p: Record<string, unknown>) => void;
+  save: () => void;
+  segments: TranscriptSegment[];
+  chapters: { startMs: number; title: string }[];
+}
+
+const str = (content: Record<string, unknown>, key: string): string =>
+  typeof content[key] === "string" ? (content[key] as string) : "";
+
+function ShowNotesEditor({ content, patch, save, chapters }: EditorProps) {
+  const bullets = Array.isArray(content.bullets) ? (content.bullets as string[]) : [];
+  return (
+    <EditorShell>
+      <AutoField label="Hook" value={str(content, "hook")} onChange={(v) => patch({ hook: v })} onSave={save} rows={3} testId="edit-hook" />
+      <div>
+        <p className="mb-1 text-xs font-medium text-muted-foreground">In this episode (4–7)</p>
+        {bullets.map((b, i) => (
+          <div key={i} className="mb-1 flex items-center gap-2">
+            <span aria-hidden>•</span>
+            <input
+              value={b}
+              onChange={(e) => patch({ bullets: bullets.map((x, j) => (j === i ? e.target.value : x)) })}
+              onBlur={save}
+              className="flex-1 rounded-md border px-3 py-1.5 text-sm"
+              data-testid={`edit-bullet-${i}`}
+            />
+            <button type="button" aria-label={`Remove bullet ${i + 1}`} onClick={() => { patch({ bullets: bullets.filter((_, j) => j !== i) }); setTimeout(save, 0); }}>
+              ✕
+            </button>
+          </div>
+        ))}
+        {bullets.length < 7 && (
+          <button type="button" onClick={() => patch({ bullets: [...bullets, ""] })} className="rounded-md border px-3 py-1 text-sm" data-testid="add-bullet">
+            + bullet
+          </button>
+        )}
+      </div>
+      {chapters.length > 0 && (
+        <div className="rounded-md border p-3">
+          <p className="mb-2 text-xs font-medium text-muted-foreground">Chapters (from the Chapters tab)</p>
+          {chapters.map((c) => (
+            <p key={c.startMs} className="font-mono text-sm">
+              {mmss(c.startMs)} {c.title}
+            </p>
+          ))}
+        </div>
+      )}
+      {str(content, "guestLine") !== "" && (
+        <AutoField label="Guest line" value={str(content, "guestLine")} onChange={(v) => patch({ guestLine: v })} onSave={save} rows={2} />
+      )}
+      <AutoField label="Call to action" value={str(content, "cta")} onChange={(v) => patch({ cta: v })} onSave={save} rows={2} />
+    </EditorShell>
+  );
+}
+
+function ChaptersEditor({ content, patch, save }: EditorProps) {
+  const items = Array.isArray(content.items) ? (content.items as { startMs: number; title: string }[]) : [];
+  return (
+    <EditorShell>
+      {items.map((c, i) => (
+        <div key={i} className="flex items-center gap-2">
+          <span className="font-mono text-sm">{mmss(c.startMs)}</span>
+          <input
+            value={c.title}
+            maxLength={50}
+            onChange={(e) => patch({ items: items.map((x, j) => (j === i ? { ...x, title: e.target.value } : x)) })}
+            onBlur={save}
+            className="flex-1 rounded-md border px-3 py-1.5 text-sm"
+          />
+          <button type="button" aria-label={`Remove chapter ${i + 1}`} onClick={() => { patch({ items: items.filter((_, j) => j !== i) }); setTimeout(save, 0); }}>
+            ✕
+          </button>
+        </div>
+      ))}
+      <button
+        type="button"
+        onClick={() => {
+          const last = items[items.length - 1];
+          patch({ items: [...items, { startMs: last ? last.startMs + 120_000 : 0, title: "" }] });
+          setTimeout(save, 0);
+        }}
+        className="rounded-md border px-3 py-1.5 text-sm"
+        data-testid="add-chapter"
+      >
+        Add chapter
+      </button>
+    </EditorShell>
+  );
+}
+
+function SummaryEditor({ content, patch, save }: EditorProps) {
+  return (
+    <EditorShell>
+      <AutoField label="One-liner" value={str(content, "oneLiner")} onChange={(v) => patch({ oneLiner: v })} onSave={save} max={140} rows={2} testId="edit-one-liner" />
+      <AutoField label="Short (50–80 words)" value={str(content, "short")} onChange={(v) => patch({ short: v })} onSave={save} words={[50, 80]} rows={4} />
+      <AutoField label="Long (150–220 words)" value={str(content, "long")} onChange={(v) => patch({ long: v })} onSave={save} words={[150, 220]} rows={8} />
+    </EditorShell>
+  );
+}
+
+function TitlesEditor({ content, patch, save }: EditorProps) {
+  const items = Array.isArray(content.items) ? (content.items as { text: string; style: string; starred: boolean }[]) : [];
+  const [chosen, setChosen] = useState(-1);
+  return (
+    <EditorShell>
+      {items.map((t, i) => (
+        <div key={i} className="flex items-center gap-2 rounded-md border p-2">
+          <span className="rounded-full bg-[var(--surface-2)] px-2 py-0.5 text-xs">{t.style}</span>
+          <input
+            value={t.text}
+            maxLength={80}
+            onChange={(e) => patch({ items: items.map((x, j) => (j === i ? { ...x, text: e.target.value } : x)) })}
+            onBlur={save}
+            className="flex-1 bg-transparent text-sm"
+          />
+          <button
+            type="button"
+            aria-label={t.starred ? `Unstar title ${i + 1}` : `Star title ${i + 1}`}
+            onClick={() => { patch({ items: items.map((x, j) => (j === i ? { ...x, starred: !x.starred } : x)) }); setTimeout(save, 0); }}
+          >
+            {t.starred ? "★" : "☆"}
+          </button>
+          <button type="button" onClick={() => void navigator.clipboard.writeText(t.text)} aria-label={`Copy title ${i + 1}`}>
+            ⧉
+          </button>
+          <button
+            type="button"
+            onClick={() => setChosen(i)}
+            className={`rounded border px-2 py-0.5 text-xs ${chosen === i ? "border-[var(--accent)] bg-[var(--accent-soft)]" : ""}`}
+            data-testid={`use-as-title-${i}`}
+          >
+            Use as title
+          </button>
+        </div>
+      ))}
+    </EditorShell>
+  );
+}
+
+function BlogEditor({ content, patch, save, segments }: EditorProps) {
+  const [preview, setPreview] = useState(false);
+  const quoteRefs = Array.isArray(content.quoteRefs) ? (content.quoteRefs as unknown[]) : [];
+  return (
+    <EditorShell>
+      <div className="rounded-md border p-3">
+        <AutoField label="SEO title (≤60)" value={str(content, "seoTitle")} onChange={(v) => patch({ seoTitle: v })} onSave={save} max={60} rows={1} />
+        <AutoField label="Meta description (≤155)" value={str(content, "metaDescription")} onChange={(v) => patch({ metaDescription: v })} onSave={save} max={155} rows={2} />
+        <AutoField label="Slug" value={str(content, "slug")} onChange={(v) => patch({ slug: v })} onSave={save} rows={1} />
+      </div>
+      <div className="flex items-center justify-between">
+        <span className="text-xs font-medium text-muted-foreground">Body (Markdown)</span>
+        <button type="button" onClick={() => setPreview((p) => !p)} className="rounded border px-2 py-0.5 text-xs" data-testid="blog-preview-toggle">
+          {preview ? "Edit" : "Preview"}
+        </button>
+      </div>
+      {preview ? (
+        <pre className="whitespace-pre-wrap rounded-md border p-3 text-sm" data-testid="blog-preview">
+          {renderBlogBody(str(content, "bodyMarkdown"), quoteRefs, { segments, showName: "", episodeTitle: "", freePlan: false })}
+        </pre>
+      ) : (
+        <AutoField label="" value={str(content, "bodyMarkdown")} onChange={(v) => patch({ bodyMarkdown: v })} onSave={save} rows={16} markdown testId="edit-blog-body" />
+      )}
+    </EditorShell>
+  );
+}
+
+function NewsletterEditor({ content, patch, save }: EditorProps) {
+  const subjects = Array.isArray(content.subjects) ? (content.subjects as string[]) : [];
+  const [customSubject, setCustomSubject] = useState("");
+  const [picked, setPicked] = useState(0);
+  return (
+    <EditorShell>
+      {subjects.map((s, i) => (
+        <label key={i} className="flex items-center gap-2 text-sm">
+          <input type="radio" name="subject" checked={picked === i} onChange={() => setPicked(i)} />
+          <input value={s} onChange={(e) => patch({ subjects: subjects.map((x, j) => (j === i ? e.target.value : x)) })} onBlur={save} className="flex-1 rounded-md border px-2 py-1" />
+        </label>
+      ))}
+      <label className="flex items-center gap-2 text-sm">
+        <input type="radio" name="subject" checked={picked === subjects.length} onChange={() => setPicked(subjects.length)} />
+        <input value={customSubject} onChange={(e) => setCustomSubject(e.target.value)} placeholder="Custom subject" className="flex-1 rounded-md border px-2 py-1" />
+      </label>
+      <AutoField label="Preview text (≤90)" value={str(content, "previewText")} onChange={(v) => patch({ previewText: v })} onSave={save} max={90} rows={2} />
+      <AutoField label="Body (Markdown)" value={str(content, "bodyMarkdown")} onChange={(v) => patch({ bodyMarkdown: v })} onSave={save} rows={10} markdown testId="edit-newsletter-body" />
+      <AutoField label="CTA (≤30)" value={str(content, "ctaText")} onChange={(v) => patch({ ctaText: v })} onSave={save} max={30} rows={1} />
+    </EditorShell>
+  );
+}
+
+function SocialEditor({ content, patch, save }: EditorProps) {
+  const thread = Array.isArray(content.thread) ? (content.thread as string[]) : [];
+  const ig = (content.instagram ?? {}) as { caption?: string; hashtags?: string[] };
+  const [tab, setTab] = useState<"linkedin" | "thread" | "instagram">("linkedin");
+  return (
+    <EditorShell>
+      <div role="tablist" className="flex gap-4 border-b text-sm">
+        {(["linkedin", "thread", "instagram"] as const).map((t) => (
+          <button key={t} role="tab" aria-selected={tab === t} onClick={() => setTab(t)} className={`-mb-px border-b-2 py-1 capitalize ${tab === t ? "border-[var(--accent)] font-medium" : "border-transparent"}`}>
+            {t}
+          </button>
+        ))}
+      </div>
+      {tab === "linkedin" && (
+        <AutoField label="LinkedIn post (≤1300)" value={str(content, "linkedin")} onChange={(v) => patch({ linkedin: v })} onSave={save} max={1300} rows={10} testId="edit-linkedin" />
+      )}
+      {tab === "thread" &&
+        thread.map((p, i) => (
+          <div key={i} className="rounded-md border p-2">
+            <p className="mb-1 text-xs text-muted-foreground">Post {i + 1}</p>
+            <AutoField label="" value={p} onChange={(v) => patch({ thread: thread.map((x, j) => (j === i ? v : x)) })} onSave={save} max={280} rows={3} testId={`edit-thread-${i}`} />
+          </div>
+        ))}
+      {tab === "instagram" && (
+        <>
+          <AutoField label="Caption (≤2200)" value={ig.caption ?? ""} onChange={(v) => patch({ instagram: { ...ig, caption: v } })} onSave={save} max={2200} rows={8} />
+          <AutoField
+            label="Hashtags (5–10)"
+            value={(ig.hashtags ?? []).join(" ")}
+            onChange={(v) => patch({ instagram: { ...ig, hashtags: v.split(/\s+/).filter(Boolean) } })}
+            onSave={save}
+            rows={2}
+          />
+        </>
+      )}
+    </EditorShell>
+  );
+}
+
+export function ArtifactEditor(props: {
+  kind: ArtifactKindName;
+  artifact: ArtifactView;
+  segments: TranscriptSegment[];
+  chapters: { startMs: number; title: string }[];
+  onSave: (content: Record<string, unknown>) => Promise<void> | void;
+}) {
+  const [content, setContent] = useState<Record<string, unknown>>(props.artifact.content ?? {});
+  const [savedAt, setSavedAt] = useState<string | null>(null);
+  // The 1.5 s debounce outlives renders; a ref keeps the timer's save reading
+  // the latest content instead of the closure captured at keystroke time.
+  const contentRef = useRef(content);
+  useEffect(() => {
+    contentRef.current = content;
+  }, [content]);
+
+  const patch = (p: Record<string, unknown>) => setContent((c) => ({ ...c, ...p }));
+  const save = async () => {
+    await props.onSave(contentRef.current);
+    setSavedAt(new Date().toLocaleTimeString());
+  };
+
+  const editorProps: EditorProps = { content, patch, save, segments: props.segments, chapters: props.chapters };
+  switch (props.kind) {
+    case "show_notes":
+      return <WithHint savedAt={savedAt}><ShowNotesEditor {...editorProps} /></WithHint>;
+    case "chapters":
+      return <WithHint savedAt={savedAt}><ChaptersEditor {...editorProps} /></WithHint>;
+    case "summary":
+      return <WithHint savedAt={savedAt}><SummaryEditor {...editorProps} /></WithHint>;
+    case "titles":
+      return <WithHint savedAt={savedAt}><TitlesEditor {...editorProps} /></WithHint>;
+    case "blog":
+      return <WithHint savedAt={savedAt}><BlogEditor {...editorProps} /></WithHint>;
+    case "newsletter":
+      return <WithHint savedAt={savedAt}><NewsletterEditor {...editorProps} /></WithHint>;
+    case "social":
+      return <WithHint savedAt={savedAt}><SocialEditor {...editorProps} /></WithHint>;
+    default:
+      return null;
+  }
+}
+
+function WithHint({ savedAt, children }: { savedAt: string | null; children: React.ReactNode }) {
+  return (
+    <div className="flex flex-col gap-3">
+      {children}
+      <p className="text-xs text-muted-foreground" aria-live="polite" data-testid="autosave-hint">
+        {savedAt ? `Saved · ${savedAt}` : "Changes save automatically."}
+      </p>
+    </div>
+  );
+}
diff --git a/web/components/workspace/quotes-panel.tsx b/web/components/workspace/quotes-panel.tsx
new file mode 100644
index 0000000..4e4c93e
--- /dev/null
+++ b/web/components/workspace/quotes-panel.tsx
@@ -0,0 +1,144 @@
+"use client";
+// MK-7 quotes panel: 5 verified pull-quotes rendered from transcript offsets
+// (§7.3 — source text only), VerifiedBadge (`Verified · mm:ss` or `Verified in
+// transcript`), badge click → popover with the surrounding sentence + play
+// from timestamp; Remove / Swap (M5).
+import { useState } from "react";
+import type { ArtifactView } from "@/lib/pipeline/client";
+import { VerifiedBadge } from "@/components/app/verified-badge";
+import type { TranscriptSegment } from "@/lib/pipeline/client";
+
+interface QuoteRefView {
+  segmentId: string;
+  start: number;
+  end: number;
+  endSegmentId?: string;
+}
+
+function mmss(ms: number): string {
+  const s = Math.floor(ms / 1000);
+  return `${String(Math.floor(s / 60)).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}`;
+}
+
+function quoteText(ref: QuoteRefView, segments: TranscriptSegment[]): { text: string; speaker: string | null; startMs: number | null; around: string } {
+  const seg = segments.find((s) => s.id === ref.segmentId);
+  if (!seg) return { text: "", speaker: null, startMs: null, around: "" };
+  const end = ref.endSegmentId ? (segments.find((s) => s.id === ref.endSegmentId)?.text.length ?? seg.text.length) : ref.end;
+  const text = ref.endSegmentId
+    ? `${seg.text.slice(ref.start)} ${segments.find((s) => s.id === ref.endSegmentId)?.text.slice(0, ref.end) ?? ""}`.trim()
+    : seg.text.slice(ref.start, end);
+  // Surrounding sentence context for the popover (§7.3 / MK-7).
+  const before = seg.text.slice(Math.max(0, ref.start - 80), ref.start);
+  const afterSource = ref.endSegmentId ? segments.find((s) => s.id === ref.endSegmentId)?.text ?? "" : seg.text;
+  const after = afterSource.slice(Math.min(afterSource.length, end), Math.min(afterSource.length, end + 80));
+  void end;
+  return { text, speaker: seg.speaker, startMs: seg.startMs, around: `${before}**${text}**${after}`.trim() };
+}
+
+export function QuotesPanel({
+  artifacts,
+  segments,
+  episodeId,
+  hasTimestamps,
+}: {
+  artifacts: ArtifactView[];
+  segments: TranscriptSegment[];
+  episodeId: string;
+  hasTimestamps: boolean;
+}) {
+  const quotesArtifact = artifacts.find((a) => a.kind === "quotes");
+  const [items, setItems] = useState<QuoteRefView[] | null>(null);
+  const [openIdx, setOpenIdx] = useState<number | null>(null);
+  const [audioNote, setAudioNote] = useState<string | null>(null);
+
+  const current = items ?? ((quotesArtifact?.content?.items as QuoteRefView[] | undefined) ?? []);
+  const removed = new Set<number>();
+
+  const remove = (i: number) => {
+    removed.add(i);
+    setItems(current.filter((_, j) => j !== i));
+  };
+  void removed;
+
+  const swap = (i: number) => {
+    // Swap = pick another candidate: reuse analysis candidates not already shown.
+    const pool = (quotesArtifact?.content?.candidates as QuoteRefView[] | undefined) ?? [];
+    const used = new Set(current.map((q) => `${q.segmentId}:${q.start}`));
+    const next = pool.find((c) => !used.has(`${c.segmentId}:${c.start}`));
+    if (next) setItems(current.map((q, j) => (j === i ? next : q)));
+  };
+
+  const playFrom = async (startMs: number | null) => {
+    if (startMs === null) return;
+    const res = await fetch(`/api/audio/${episodeId}`).catch(() => null);
+    if (!res || !res.ok) {
+      setAudioNote("Audio isn't available in this preview.");
+      return;
+    }
+    const { url } = (await res.json()) as { url?: string };
+    if (!url) {
+      setAudioNote("Audio isn't available in this preview.");
+      return;
+    }
+    const audio = new Audio(url);
+    audio.currentTime = startMs / 1000;
+    await audio.play().catch(() => setAudioNote("Audio isn't available in this preview."));
+  };
+
+  if (current.length === 0) {
+    return (
+      <section className="p-4" aria-label="Quotes">
+        <h2 className="mb-2 text-sm font-semibold">Quotes</h2>
+        <p className="text-sm text-muted-foreground" data-testid="quotes-empty">Verified quotes appear here.</p>
+      </section>
+    );
+  }
+
+  return (
+    <section className="p-4" aria-label="Quotes">
+      <h2 className="mb-3 text-sm font-semibold">Quotes</h2>
+      <ul className="flex flex-col gap-3">
+        {current.map((ref, i) => {
+          const q = quoteText(ref, segments);
+          const verifiedTime = hasTimestamps && q.startMs !== null ? mmss(q.startMs) : undefined;
+          return (
+            <li key={`${ref.segmentId}-${ref.start}-${i}`} className="border-l-[3px] border-[var(--accent)] pl-3" data-testid={`quote-${i}`}>
+              <p className="text-sm">“{q.text}”</p>
+              <p className="mt-1 text-xs text-muted-foreground">
+                {q.speaker ? `— ${q.speaker}` : "— from the episode"}
+              </p>
+              <div className="mt-1 flex items-center gap-2">
+                <button type="button" onClick={() => setOpenIdx(openIdx === i ? null : i)} aria-expanded={openIdx === i} className="text-xs">
+                  <VerifiedBadge time={verifiedTime ?? undefined} label={verifiedTime ? undefined : "Verified in transcript"} />
+                </button>
+                <button type="button" onClick={() => swap(i)} className="rounded border px-2 py-0.5 text-xs">
+                  Swap
+                </button>
+                <button type="button" onClick={() => remove(i)} className="rounded border px-2 py-0.5 text-xs">
+                  Remove
+                </button>
+              </div>
+              {openIdx === i && (
+                <div role="dialog" aria-label="Verified quote" className="mt-2 rounded-md border bg-[var(--surface)] p-3 text-sm shadow-[0_8px_24px_rgb(17_24_39/0.12)]" data-testid="quote-popover">
+                  <p className="mb-2 text-xs text-muted-foreground">
+                    {verifiedTime ? `✓ Verified · ${verifiedTime} — exact words from audio` : "✓ Verified in transcript — exact words"}
+                  </p>
+                  <p className="mb-3">{q.around}</p>
+                  <button
+                    type="button"
+                    onClick={() => void playFrom(q.startMs)}
+                    className="rounded-md border px-3 py-1.5 text-sm"
+                    data-testid="play-from"
+                  >
+                    ▶ Play from {verifiedTime ?? "transcript"}
+                  </button>
+                  {audioNote && <p className="mt-2 text-xs text-[var(--warning)]">{audioNote}</p>}
+                </div>
+              )}
+            </li>
+          );
+        })}
+      </ul>
+    </section>
+  );
+}
diff --git a/web/components/workspace/toolbar.tsx b/web/components/workspace/toolbar.tsx
new file mode 100644
index 0000000..5d9cf08
--- /dev/null
+++ b/web/components/workspace/toolbar.tsx
@@ -0,0 +1,255 @@
+"use client";
+// M6/M7 toolbar: Regenerate ▾ (presets + custom ≤200 chars), Copy ▾
+// (destinations; last used becomes the button label), Download all (.md).
+import { useEffect, useRef, useState } from "react";
+import type { ArtifactKindName, ArtifactView } from "@/lib/pipeline/client";
+import {
+  DESTINATION_LABELS,
+  blogToMarkdown,
+  downloadAllMarkdown,
+  needsShortening,
+  newsletterToText,
+  quotesToText,
+  shortenToLimit,
+  showNotesToText,
+  socialToText,
+  summaryToText,
+  titlesToText,
+  type Destination,
+} from "@/lib/export/format";
+import type { TranscriptSegment } from "@/lib/pipeline/client";
+import { toast } from "sonner";
+
+const REGEN_PRESETS = ["Shorter", "Punchier", "More casual", "More formal"] as const;
+const DESTINATIONS: Destination[] = ["apple", "spotify", "youtube", "markdown", "plain"];
+
+function useOutsideClose(onClose: () => void) {
+  const ref = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    const handler = (e: MouseEvent): void => {
+      if (ref.current && !ref.current.contains(e.target as Node)) onClose();
+    };
+    document.addEventListener("mousedown", handler);
+    return () => document.removeEventListener("mousedown", handler);
+  }, [onClose]);
+  return ref;
+}
+
+function Menu({ label, testId, children }: { label: string; testId?: string; children: (close: () => void) => React.ReactNode }) {
+  const [open, setOpen] = useState(false);
+  const ref = useOutsideClose(() => setOpen(false));
+  return (
+    <div className="relative" ref={ref}>
+      <button
+        type="button"
+        data-testid={testId}
+        onClick={() => setOpen((o) => !o)}
+        aria-expanded={open}
+        aria-haspopup="menu"
+        className="rounded-md border px-3 py-1.5 text-sm hover:bg-[var(--surface-2)]"
+      >
+        {label} ▾
+      </button>
+      {open && (
+        <div role="menu" className="absolute left-0 top-full z-50 mt-1 min-w-[13rem] rounded-md border bg-[var(--surface)] p-1 shadow-lg">
+          {children(() => setOpen(false))}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function Item({ onClick, children }: { onClick: () => void; children: React.ReactNode }) {
+  return (
+    <button
+      type="button"
+      role="menuitem"
+      onClick={onClick}
+      className="block w-full rounded px-2 py-1.5 text-left text-sm hover:bg-[var(--surface-2)]"
+    >
+      {children}
+    </button>
+  );
+}
+
+export function RegenerateMenu({
+  onRegenerate,
+  disabled,
+}: {
+  onRegenerate: (instruction?: string) => Promise<void>;
+  disabled?: boolean;
+}) {
+  const [custom, setCustom] = useState("");
+  const [mode, setMode] = useState<"idle" | "custom">("idle");
+  return (
+    <Menu label="Regenerate" testId="regenerate-menu">
+      {(close) => (
+        <>
+          {REGEN_PRESETS.map((preset) => (
+            <Item
+              key={preset}
+              onClick={() => {
+                close();
+                void onRegenerate(preset);
+              }}
+            >
+              {preset}
+            </Item>
+          ))}
+          {mode === "custom" ? (
+            <form
+              className="flex gap-1 p-1"
+              onSubmit={(e) => {
+                e.preventDefault();
+                close();
+                void onRegenerate(custom.slice(0, 200) || undefined);
+                setCustom("");
+                setMode("idle");
+              }}
+            >
+              <input
+                autoFocus
+                value={custom}
+                onChange={(e) => setCustom(e.target.value.slice(0, 200))}
+                placeholder="Instructions (≤200 chars)"
+                className="min-w-0 flex-1 rounded border px-2 py-1 text-sm"
+                data-testid="regen-custom-input"
+              />
+              <button type="submit" className="rounded border px-2 py-1 text-sm">
+                Go
+              </button>
+            </form>
+          ) : (
+            <Item onClick={() => setMode("custom")}>Custom…</Item>
+          )}
+          {disabled && <p className="px-2 py-1 text-xs text-muted-foreground">Working…</p>}
+        </>
+      )}
+    </Menu>
+  );
+}
+
+function chapterLines(chapters: { startMs: number; title: string }[], dest: Destination): string {
+  return chapters
+    .map((c) => {
+      const s = Math.floor(c.startMs / 1000);
+      const mm = Math.floor(s / 60);
+      const ss = String(s % 60).padStart(2, "0");
+      const ts = dest === "youtube" ? `${mm}:${ss}` : `${String(mm).padStart(2, "0")}:${ss}`;
+      return `${ts} ${c.title}`;
+    })
+    .join("\n");
+}
+
+export function CopyMenu(props: {
+  kind: ArtifactKindName;
+  artifact: ArtifactView;
+  segments: TranscriptSegment[];
+  showName: string;
+  episodeTitle: string | null;
+  freePlan: boolean;
+  chapters: { startMs: number; title: string }[];
+}) {
+  const [lastUsed, setLastUsed] = useState<Destination | null>(null);
+  const content = (props.artifact.content ?? {}) as Record<string, unknown>;
+  const ctx = {
+    segments: props.segments,
+    showName: props.showName,
+    episodeTitle: props.episodeTitle,
+    freePlan: props.freePlan,
+  };
+
+  const textFor = (dest: Destination): string => {
+    switch (props.kind) {
+      case "show_notes":
+        return showNotesToText(content, ctx, dest, props.chapters);
+      case "chapters":
+        return chapterLines(props.chapters, dest);
+      case "summary":
+        return summaryToText(content);
+      case "titles":
+        return titlesToText(content);
+      case "blog":
+        return blogToMarkdown(content, ctx);
+      case "newsletter":
+        return newsletterToText(content, ctx);
+      case "social":
+        return socialToText(content);
+      case "quotes":
+        return quotesToText(content, ctx);
+      default:
+        return "";
+    }
+  };
+
+  const copy = async (dest: Destination): Promise<void> => {
+    const text = textFor(dest);
+    if (needsShortening(dest, text)) {
+      // U13: over the destination limit — shorten to fit and say so.
+      await navigator.clipboard.writeText(shortenToLimit(text, 4000));
+      setLastUsed(dest);
+      toast(`Copied for ${DESTINATION_LABELS[dest]} (shortened to fit)`);
+      return;
+    }
+    await navigator.clipboard.writeText(text);
+    setLastUsed(dest);
+    toast(dest === "plain" ? "Copied" : `Copied for ${DESTINATION_LABELS[dest]}`);
+  };
+
+  return (
+    <Menu label={lastUsed ? `Copy · ${DESTINATION_LABELS[lastUsed]}` : "Copy"} testId="copy-menu">
+      {(close) =>
+        DESTINATIONS.map((dest) => (
+          <Item
+            key={dest}
+            onClick={() => {
+              close();
+              void copy(dest);
+            }}
+          >
+            {DESTINATION_LABELS[dest]}
+          </Item>
+        ))
+      }
+    </Menu>
+  );
+}
+
+export function DownloadAllButton(props: {
+  artifacts: Record<string, unknown>;
+  segments: TranscriptSegment[];
+  showName: string;
+  episodeTitle: string | null;
+  freePlan: boolean;
+  chapters: { startMs: number; title: string }[];
+}) {
+  const download = () => {
+    const md = downloadAllMarkdown(
+      props.artifacts as Partial<Record<string, Record<string, unknown>>>,
+      {
+        segments: props.segments,
+        showName: props.showName,
+        episodeTitle: props.episodeTitle,
+        freePlan: props.freePlan,
+      },
+      props.chapters,
+    );
+    const blob = new Blob([md], { type: "text/markdown" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `${(props.episodeTitle ?? "episode").replace(/[^a-z0-9]+/gi, "-").toLowerCase()}.md`;
+    a.click();
+    URL.revokeObjectURL(url);
+  };
+  return (
+    <button
+      type="button"
+      onClick={download}
+      data-testid="download-all"
+      className="rounded-md border px-3 py-1.5 text-sm hover:bg-[var(--surface-2)]"
+    >
+      Download all
+    </button>
+  );
+}
diff --git a/web/components/workspace/transcript-panel.tsx b/web/components/workspace/transcript-panel.tsx
new file mode 100644
index 0000000..169ef77
--- /dev/null
+++ b/web/components/workspace/transcript-panel.tsx
@@ -0,0 +1,40 @@
+"use client";
+// Transcript panel (MK-6 right column): searchable transcript lines with
+// mm:ss timestamps; source text for every verified quote.
+import { useState } from "react";
+import type { TranscriptSegment } from "@/lib/pipeline/client";
+
+function mmss(ms: number | null): string {
+  if (ms === null) return "--:--";
+  const s = Math.floor(ms / 1000);
+  return `${String(Math.floor(s / 60)).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}`;
+}
+
+export function TranscriptPanel({ segments }: { segments: TranscriptSegment[] }) {
+  const [query, setQuery] = useState("");
+  const filtered = query
+    ? segments.filter((s) => s.text.toLowerCase().includes(query.toLowerCase()))
+    : segments;
+  return (
+    <section className="p-4" aria-label="Transcript">
+      <h2 className="mb-2 text-sm font-semibold">Transcript</h2>
+      <input
+        value={query}
+        onChange={(e) => setQuery(e.target.value)}
+        placeholder="Search transcript"
+        className="mb-3 w-full rounded-md border px-3 py-1.5 text-sm"
+        data-testid="transcript-search"
+      />
+      <ol className="flex flex-col gap-2">
+        {filtered.map((s) => (
+          <li key={s.id} className="text-sm">
+            <span className="mr-2 font-mono text-xs text-muted-foreground">{mmss(s.startMs)}</span>
+            {s.speaker && <span className="mr-1 font-medium">{s.speaker}:</span>}
+            {s.text}
+          </li>
+        ))}
+      </ol>
+      {filtered.length === 0 && <p className="text-sm text-muted-foreground">No matches.</p>}
+    </section>
+  );
+}
diff --git a/web/components/workspace/workspace-view.tsx b/web/components/workspace/workspace-view.tsx
new file mode 100644
index 0000000..b405714
--- /dev/null
+++ b/web/components/workspace/workspace-view.tsx
@@ -0,0 +1,242 @@
+"use client";
+// MK-6 episode workspace. One episode = one screen: artifact nav (left),
+// editor (center), quotes + transcript (right); mobile uses chip row + bottom
+// tabs (§5.5). Processing (MK-5) renders in the same URL until ready.
+import Link from "next/link";
+import { useMemo, useState } from "react";
+import {
+  ARTIFACT_ORDER,
+  useWorkspace,
+  type ArtifactKindName,
+  type ArtifactView,
+} from "@/lib/pipeline/client";
+import { ArtifactEditor } from "./editors";
+import { QuotesPanel } from "./quotes-panel";
+import { TranscriptPanel } from "./transcript-panel";
+import { CopyMenu, RegenerateMenu, DownloadAllButton } from "./toolbar";
+import { StatusPill } from "@/components/app/status-pill";
+import { toast as sonnerToast } from "sonner";
+
+const KIND_LABELS: Record<ArtifactKindName, string> = {
+  show_notes: "Show notes",
+  chapters: "Chapters",
+  summary: "Summary",
+  titles: "Titles",
+  blog: "Blog post",
+  newsletter: "Newsletter",
+  social: "Social posts",
+  quotes: "Quotes",
+};
+
+function mmss(ms: number | null): string {
+  if (ms === null) return "--:--";
+  const s = Math.floor(ms / 1000);
+  return `${String(Math.floor(s / 60)).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}`;
+}
+
+export function WorkspaceView({ initial, freePlan, showName }: { initial: import("@/lib/pipeline/client").WorkspaceData; freePlan: boolean; showName: string }) {
+  const ws = useWorkspace(initial.episode.id, initial);
+  const data = ws.data;
+  const [active, setActive] = useState<ArtifactKindName>("show_notes");
+  const [mobileTab, setMobileTab] = useState<"write" | "quotes" | "transcript">("write");
+
+
+  const byKind = useMemo(() => {
+    const m = new Map<ArtifactKindName, ArtifactView>();
+    for (const k of ARTIFACT_ORDER) {
+      const found = data?.artifacts.find((a) => a.kind === k);
+      if (found) m.set(k, found);
+    }
+    return m;
+  }, [data]);
+
+  if (!data) {
+    return (
+      <main className="flex flex-1 items-center justify-center p-8 text-sm text-muted-foreground" aria-live="polite">
+        Loading your workspace…
+      </main>
+    );
+  }
+
+  const episode = data.episode;
+  // M8's "Ready x/7" counts the seven M4 artifacts; quotes is its own panel.
+  const readySeven = ARTIFACT_ORDER.filter((k) => {
+    if (k === "quotes") return false;
+    const a = data.artifacts.find((x) => x.kind === k);
+    return Boolean(a && (a.status === "ready" || a.status === "fallback"));
+  }).length;
+  const activeArtifact = active === "quotes" ? byKind.get("quotes") : byKind.get(active);
+  const chapters = byKind.get("chapters")?.content as { items?: { startMs: number; title: string }[] } | null;
+  const chapterItems = chapters?.items ?? data.analysis?.chapters ?? [];
+
+  const onRegenerate = async (instruction?: string) => {
+    await ws.regenerate(active, instruction);
+    const a = byKind.get(active);
+    sonnerToast("Regenerated", {
+      action: { label: "Undo", onClick: () => void (a && ws.undo(a.id)) },
+    });
+  };
+
+  return (
+    <main className="flex flex-1 flex-col">
+      <header className="flex flex-wrap items-center gap-3 border-b px-4 py-3 md:px-6">
+        <Link href="/app/episodes" className="text-sm text-muted-foreground hover:text-foreground">
+          ← Episodes
+        </Link>
+        <h1 className="flex-1 truncate text-base font-semibold md:text-lg">
+          {episode.title ?? "Untitled"}
+        </h1>
+        <StatusPill
+          status={episode.status === "uploading" ? "queued" : episode.status}
+          label={episode.status === "uploading" ? "Uploading" : undefined}
+        />
+        <span className="text-sm text-muted-foreground" data-testid="ready-count">{readySeven}/7 ready</span>
+        <DownloadAllButton
+          artifacts={Object.fromEntries(data.artifacts.map((a) => [a.kind, a.content ?? {}]))}
+          segments={data.segments}
+          showName={showName}
+          episodeTitle={episode.title}
+          freePlan={freePlan}
+          chapters={chapterItems}
+        />
+      </header>
+
+      <p className="sr-only" aria-live="polite">
+        {episode.status === "ready" ? "Package ready." : `Working — ${episode.status}.`}
+      </p>
+
+      {/* Mobile: chip row (§5.5) */}
+      <nav className="flex gap-2 overflow-x-auto border-b px-4 py-2 md:hidden" aria-label="Artifacts">
+        {ARTIFACT_ORDER.map((k) => {
+          const a = byKind.get(k);
+          const done = a && (a.status === "ready" || a.status === "fallback");
+          return (
+            <button
+              key={k}
+              type="button"
+              onClick={() => {
+                setActive(k);
+                setMobileTab("write");
+              }}
+              className={`shrink-0 rounded-full border px-3 py-1 text-xs ${active === k ? "border-[var(--accent)] bg-[var(--accent-soft)]" : ""}`}
+            >
+              {done ? "✓ " : ""}
+              {KIND_LABELS[k]}
+            </button>
+          );
+        })}
+      </nav>
+
+      <div className="flex flex-1 min-h-0">
+        {/* Left nav (MK-6, 220px) */}
+        <nav className="hidden w-[220px] shrink-0 flex-col gap-1 border-r p-3 md:flex" aria-label="Artifacts">
+          {ARTIFACT_ORDER.map((k) => {
+            const a = byKind.get(k);
+            const done = Boolean(a && (a.status === "ready" || a.status === "fallback") && a.ready);
+            return (
+              <button
+                key={k}
+                type="button"
+                onClick={() => setActive(k)}
+                className={`flex items-center justify-between rounded-md px-3 py-2 text-sm ${active === k ? "bg-[var(--surface-2)] font-medium" : "hover:bg-[var(--surface-2)]"}`}
+              >
+                <span>{KIND_LABELS[k]}</span>
+                <span aria-hidden>{done ? "✓" : a?.status === "writing" ? "…" : ""}</span>
+              </button>
+            );
+          })}
+          <div className="my-2 border-t" />
+          <div className="px-3 py-2 text-xs text-muted-foreground">
+            {mmss(episode.durationMs)} · {episode.source}
+          </div>
+        </nav>
+
+        {/* Center: editor */}
+        <section className={`${mobileTab === "write" ? "flex" : "hidden"} min-w-0 flex-1 flex-col overflow-y-auto p-4 md:flex md:p-6`}>
+          {active !== "quotes" && activeArtifact && (
+            <>
+              <div className="mb-4 flex flex-wrap items-center gap-2">
+                <h2 className="flex-1 text-sm font-semibold">{KIND_LABELS[active]}</h2>
+                <label className="flex items-center gap-1.5 text-sm">
+                  <input
+                    type="checkbox"
+                    checked={activeArtifact.ready}
+                    onChange={(e) => void ws.setReady(activeArtifact.id, e.target.checked)}
+                    data-testid="ready-flag"
+                  />
+                  Ready
+                </label>
+                <RegenerateMenu onRegenerate={onRegenerate} disabled={activeArtifact.status === "writing"} />
+                <CopyMenu
+                  kind={active}
+                  artifact={activeArtifact}
+                  segments={data.segments}
+                  showName={showName}
+                  episodeTitle={episode.title}
+                  freePlan={freePlan}
+                  chapters={chapterItems}
+                />
+              </div>
+              {activeArtifact.status === "fallback" && (
+                <p className="mb-4 rounded-md border border-[var(--warning)] bg-[var(--warning-soft)] px-3 py-2 text-sm" data-testid="fallback-banner">
+                  Basic version — our AI writer was unavailable. Regenerate when you&apos;re ready.
+                </p>
+              )}
+              {activeArtifact.status === "failed" && (
+                <div className="mb-4 rounded-md border border-[var(--danger)] bg-[var(--danger-soft)] px-3 py-2 text-sm" data-testid="failed-card">
+                  <p>Something went wrong on our side. Try again — it won&apos;t use another episode.</p>
+                  <button type="button" onClick={() => void onRegenerate()} className="mt-2 rounded-md border px-3 py-1.5">
+                    Try again
+                  </button>
+                </div>
+              )}
+              {(activeArtifact.status === "writing" || activeArtifact.status === "pending") && (
+                <div className="space-y-2" data-testid="artifact-skeleton" aria-hidden>
+                  <div className="h-4 w-3/4 animate-pulse rounded bg-[var(--surface-2)]" />
+                  <div className="h-4 w-full animate-pulse rounded bg-[var(--surface-2)]" />
+                  <div className="h-4 w-5/6 animate-pulse rounded bg-[var(--surface-2)]" />
+                </div>
+              )}
+              {(activeArtifact.status === "ready" || activeArtifact.status === "fallback") && activeArtifact.content && (
+                <ArtifactEditor
+                  key={activeArtifact.updatedAt}
+                  kind={active}
+                  artifact={activeArtifact}
+                  segments={data.segments}
+                  chapters={chapterItems}
+                  onSave={(content) => ws.saveContent(activeArtifact.id, content)}
+                />
+              )}
+            </>
+          )}
+          {episode.status === "writing" && (
+            <p className="mt-6 text-sm text-muted-foreground" data-testid="leave-page-note">
+              You can leave this page — we&apos;ll email you when it&apos;s ready.
+            </p>
+          )}
+        </section>
+
+        {/* Right: quotes + transcript (MK-6, 340px) */}
+        <aside className={`${mobileTab === "write" ? "hidden" : "flex"} w-full shrink-0 flex-col overflow-y-auto border-l md:flex md:w-[340px]`} data-testid="right-panel">
+          <QuotesPanel artifacts={data.artifacts} segments={data.segments} episodeId={episode.id} hasTimestamps={episode.hasTimestamps} />
+          <div className="border-t" />
+          <TranscriptPanel segments={data.segments} />
+        </aside>
+      </div>
+
+      {/* Mobile bottom tabs (§5.5) */}
+      <nav className="flex border-t md:hidden" aria-label="Sections">
+        {(["write", "quotes", "transcript"] as const).map((t) => (
+          <button
+            key={t}
+            type="button"
+            onClick={() => setMobileTab(t)}
+            className={`flex-1 py-3 text-sm capitalize ${mobileTab === t ? "border-t-2 border-[var(--accent)] font-medium" : ""}`}
+          >
+            {t === "write" ? "Write" : t === "quotes" ? "Quotes" : "Transcript"}
+          </button>
+        ))}
+      </nav>
+    </main>
+  );
+}
diff --git a/web/db/index.ts b/web/db/index.ts
index 68771be..c7c5b82 100644
--- a/web/db/index.ts
+++ b/web/db/index.ts
@@ -1,5 +1,6 @@
 import { neon } from "@neondatabase/serverless";
 import { drizzle, type NeonHttpDatabase } from "drizzle-orm/neon-http";
+import { getPgliteDb } from "./pglite";
 import * as schema from "./schema";
 
 export type Database = NeonHttpDatabase<typeof schema>;
@@ -16,6 +17,9 @@ export function getDb(): Database {
   if (!url) {
     throw new Error("DATABASE_URL is not set. See web/.env.example.");
   }
+  if (url.startsWith("pglite:")) {
+    return getPgliteDb(url);
+  }
   if (!cached) {
     cached = drizzle(neon(url), { schema });
   }
diff --git a/web/db/pglite.ts b/web/db/pglite.ts
new file mode 100644
index 0000000..26b2cf5
--- /dev/null
+++ b/web/db/pglite.ts
@@ -0,0 +1,30 @@
+// In-process Postgres (PGlite) for e2e tests and local dev without Neon.
+// Selected by DATABASE_URL=pglite:<dataDir> (see scripts/e2e-seed.mjs); the
+// scheme is never valid in production, so this branch is dead code there.
+import { resolve } from "node:path";
+import { PGlite } from "@electric-sql/pglite";
+import { drizzle as drizzlePglite } from "drizzle-orm/pglite";
+import type { NeonHttpDatabase } from "drizzle-orm/neon-http";
+import * as schema from "./schema";
+
+// Turbopack may load this module once per route chunk; a globalThis singleton
+// keeps ONE PGlite per dataDir across all of them (a second instance on the
+// same dataDir aborts the wasm runtime).
+const globalStore = globalThis as typeof globalThis & {
+  __pgliteInstances?: Map<string, NeonHttpDatabase<typeof schema>>;
+};
+const instances = (globalStore.__pgliteInstances ??= new Map());
+
+export function getPgliteDb(url: string): NeonHttpDatabase<typeof schema> {
+  // PGlite needs an absolute dataDir (relative paths make it hand a URL object
+  // to fs inside the Next server bundle and crash).
+  const raw = url.slice("pglite:".length);
+  const dataDir = raw ? resolve(raw) : undefined;
+  const key = dataDir ?? ":memory:";
+  let db = instances.get(key);
+  if (!db) {
+    db = drizzlePglite(new PGlite(dataDir), { schema }) as unknown as NeonHttpDatabase<typeof schema>;
+    instances.set(key, db);
+  }
+  return db;
+}
diff --git a/web/db/queries.ts b/web/db/queries.ts
index 3d893e9..673653b 100644
--- a/web/db/queries.ts
+++ b/web/db/queries.ts
@@ -1,6 +1,10 @@
-import { and, count, eq } from "drizzle-orm";
+import { and, count, desc, eq, sql } from "drizzle-orm";
 import { getDb } from "./index";
 import {
+  analysis,
+  artifactKindEnum,
+  artifactStatusEnum,
+  artifacts,
   episodes,
   segments,
   shows,
@@ -57,21 +61,27 @@ export async function updateEpisode(
 }
 
 /** Replaces the episode's segments (atomic delete+insert via Neon batch —
- * the neon-http driver has no interactive transactions). */
+ * the neon-http driver has no interactive transactions; the embedded pglite
+ * test driver has no .batch, so it falls back to sequential statements). */
 export async function replaceSegments(
   episodeId: string,
   rows: Array<Omit<typeof segments.$inferInsert, "episodeId">>,
 ): Promise<SegmentRow[]> {
-  const db = getDb();
+  const db = getDb() as { batch?: unknown } & ReturnType<typeof getDb>;
   if (!rows.length) {
     await db.delete(segments).where(eq(segments.episodeId, episodeId));
     return [];
   }
-  const result = await db.batch([
-    db.delete(segments).where(eq(segments.episodeId, episodeId)),
-    db.insert(segments).values(rows.map((r) => ({ ...r, episodeId }))).returning(),
-  ] as const);
-  return result[1];
+  if (typeof db.batch === "function") {
+    const result = await db.batch([
+      db.delete(segments).where(eq(segments.episodeId, episodeId)),
+      db.insert(segments).values(rows.map((r) => ({ ...r, episodeId }))).returning(),
+    ] as const);
+    return result[1];
+  }
+  await db.delete(segments).where(eq(segments.episodeId, episodeId));
+  const inserted = await db.insert(segments).values(rows.map((r) => ({ ...r, episodeId }))).returning();
+  return inserted;
 }
 
 export async function listSegments(episodeId: string): Promise<SegmentRow[]> {
@@ -268,3 +278,113 @@ export async function getUserEmail(userId: string): Promise<string | null> {
   const rows = await db.select({ email: users.email }).from(users).where(eq(users.id, userId)).limit(1);
   return rows[0]?.email ?? null;
 }
+
+// ---------------------------------------------------------------------------
+// WP-06 — analysis, artifacts, episode list (M4–M8). Additive.
+// ---------------------------------------------------------------------------
+
+export type AnalysisRow = typeof analysis.$inferSelect;
+export type ArtifactRow = typeof artifacts.$inferSelect;
+export type ArtifactKindName = (typeof artifactKindEnum.enumValues)[number];
+
+export async function getAnalysis(episodeId: string): Promise<AnalysisRow | null> {
+  const db = getDb();
+  const rows = await db.select().from(analysis).where(eq(analysis.episodeId, episodeId)).limit(1);
+  return rows[0] ?? null;
+}
+
+export async function upsertAnalysis(
+  episodeId: string,
+  values: { chapters: unknown; topics: string[]; candidateQuotes: unknown },
+): Promise<void> {
+  const db = getDb();
+  await db
+    .insert(analysis)
+    .values({ episodeId, ...values })
+    .onConflictDoUpdate({
+      target: analysis.episodeId,
+      set: { chapters: values.chapters, topics: values.topics, candidateQuotes: values.candidateQuotes },
+    });
+}
+
+export async function upsertArtifact(
+  episodeId: string,
+  kind: ArtifactKindName,
+  values: Partial<typeof artifacts.$inferInsert> & { status: (typeof artifactStatusEnum.enumValues)[number] },
+): Promise<ArtifactRow> {
+  const db = getDb();
+  const rows = await db
+    .insert(artifacts)
+    .values({ episodeId, kind, ...values })
+    .onConflictDoUpdate({
+      target: [artifacts.episodeId, artifacts.kind],
+      set: { ...values, updatedAt: new Date() },
+    })
+    .returning();
+  return rows[0];
+}
+
+export async function getArtifactsByEpisode(episodeId: string): Promise<ArtifactRow[]> {
+  const db = getDb();
+  return db.select().from(artifacts).where(eq(artifacts.episodeId, episodeId));
+}
+
+export async function getArtifactForUser(
+  userId: string,
+  artifactId: string,
+): Promise<ArtifactRow | null> {
+  const db = getDb();
+  const rows = await db
+    .select({ artifact: artifacts })
+    .from(artifacts)
+    .innerJoin(episodes, eq(artifacts.episodeId, episodes.id))
+    .innerJoin(shows, eq(episodes.showId, shows.id))
+    .innerJoin(workspaces, eq(shows.workspaceId, workspaces.id))
+    .where(and(eq(artifacts.id, artifactId), eq(workspaces.ownerId, userId)))
+    .limit(1);
+  return rows[0]?.artifact ?? null;
+}
+
+export async function updateArtifactContent(
+  artifactId: string,
+  content: unknown,
+): Promise<void> {
+  const db = getDb();
+  await db
+    .update(artifacts)
+    .set({ content, updatedAt: new Date() })
+    .where(eq(artifacts.id, artifactId));
+}
+
+export async function setArtifactReady(artifactId: string, ready: boolean): Promise<void> {
+  const db = getDb();
+  await db.update(artifacts).set({ readyFlag: ready }).where(eq(artifacts.id, artifactId));
+}
+
+/** Undo regenerate: restore previous_content and clear the snapshot (M6). */
+export async function undoArtifact(artifactId: string): Promise<ArtifactRow | null> {
+  const db = getDb();
+  const rows = await db
+    .update(artifacts)
+    .set({ content: sql`coalesce(${artifacts.previousContent}, ${artifacts.content})`, previousContent: null, updatedAt: new Date() })
+    .where(eq(artifacts.id, artifactId))
+    .returning();
+  return rows[0] ?? null;
+}
+
+export async function listEpisodesForShow(showId: string): Promise<EpisodeRow[]> {
+  const db = getDb();
+  return db
+    .select()
+    .from(episodes)
+    .where(eq(episodes.showId, showId))
+    .orderBy(desc(episodes.createdAt));
+}
+
+/** Delete an episode the caller owns (segments/analysis/artifacts cascade). */
+export async function deleteEpisodeForUser(userId: string, episodeId: string): Promise<void> {
+  const db = getDb();
+  const owned = await getEpisodeForUser(userId, episodeId);
+  if (!owned) return;
+  await db.delete(episodes).where(eq(episodes.id, episodeId));
+}
diff --git a/web/lib/ai/analyze.ts b/web/lib/ai/analyze.ts
new file mode 100644
index 0000000..15b9398
--- /dev/null
+++ b/web/lib/ai/analyze.ts
@@ -0,0 +1,163 @@
+// §7.5 POST /api/episodes/:id/analyze — topics, candidate quotes, chapters
+// (fast model). Mirrors generateArtifact's call policy (§8.1: chain → one
+// repair → deterministic fallback); candidate quotes are ALWAYS resolved to
+// verbatim QuoteRef offsets (§7.3) — model text is never stored as a quote.
+import { z } from "zod";
+import { AnalyzeResultSchema, buildAnalyzePrompt } from "@/lib/prompts/analyze";
+import type { PromptContext } from "@/lib/prompts";
+import { DEFAULT_VOICE_PROFILE } from "@/lib/ai/voice";
+import { analyzeTranscript } from "@/lib/engine";
+import { candidateQuoteRefs } from "@/lib/quotes/candidates";
+import { resolveQuotes } from "@/lib/quotes/resolve";
+import type { QuoteRef, Segment } from "@/lib/quotes/types";
+import { buildProviderChain, modelFor } from "@/lib/ai/registry";
+import { effectiveAiSelection } from "@/lib/ai/settings";
+import { extractJson, repairPrompt } from "@/lib/ai/json";
+import type { AppSettingsStore } from "@/lib/ai/settings";
+import type { LlmProvider } from "@/lib/ai/types";
+
+export interface AnalyzeDeps {
+  chain?: LlmProvider[];
+  store?: AppSettingsStore | null;
+  env?: NodeJS.ProcessEnv;
+  fetchImpl?: typeof fetch;
+  sleep?: (ms: number) => Promise<void>;
+  timeoutMs?: number;
+}
+
+export interface AnalyzeInput {
+  segments: Segment[];
+  hasTimestamps: boolean;
+  show: { name: string };
+  deps?: AnalyzeDeps;
+}
+
+export interface AnalyzeOutput {
+  topics: string[];
+  candidateQuotes: QuoteRef[];
+  chapters: { startMs: number; title: string }[] | null;
+  status: "ai" | "fallback";
+  provider: string | null;
+  model: string | null;
+}
+
+/** Deterministic chapters from segment timestamps (§7.2: 5–12, ≥2 min apart, first at 0). */
+function deterministicChapters(segments: Segment[]): { startMs: number; title: string }[] | null {
+  const timed = segments.filter((s) => typeof s.startMs === "number");
+  if (timed.length === 0) return null;
+  const last = timed[timed.length - 1];
+  const endMs = typeof last.endMs === "number" ? last.endMs : (last.startMs ?? 0);
+  if (endMs < 6 * 60_000) return null; // too short to split honestly into 5
+  const step = Math.max(endMs / 8, 2 * 60_000);
+  const out: { startMs: number; title: string }[] = [];
+  for (let t = 0; t <= endMs - 2 * 60_000 && out.length < 12; t === 0 ? (t = step) : (t += step)) {
+    const seg = timed.find((s) => (s.startMs ?? 0) <= t && (s.endMs ?? 0) > t) ?? timed[0];
+    if (!seg) continue;
+    const title = seg.text.split(/\s+/).slice(0, 7).join(" ").slice(0, 50).trim();
+    if (title) out.push({ startMs: t, title });
+  }
+  return out.length >= 5 ? out : null;
+}
+
+export function deterministicAnalyze(segments: Segment[]): AnalyzeOutput {
+  const a = analyzeTranscript(segments.map((s) => s.text).join(" "));
+  return {
+    topics: a.themes.slice(0, 10).map((t) => t.slice(0, 40)),
+    candidateQuotes: candidateQuoteRefs(segments, { count: 12 }),
+    chapters: deterministicChapters(segments),
+    status: "fallback",
+    provider: null,
+    model: null,
+  };
+}
+
+function asObject(v: unknown): Record<string, unknown> | null {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? (v as Record<string, unknown>) : null;
+}
+
+export async function runAnalyze(input: AnalyzeInput): Promise<AnalyzeOutput> {
+  const { segments, hasTimestamps, show } = input;
+  const deps = input.deps ?? {};
+  const env = deps.env ?? process.env;
+  const fb = deterministicAnalyze(segments);
+  if (segments.length === 0) return fb;
+
+  const ctx: PromptContext = {
+    show: { name: show.name },
+    voice: DEFAULT_VOICE_PROFILE,
+    segments,
+  };
+  const prompt = buildAnalyzePrompt(ctx);
+
+  let chain: LlmProvider[];
+  let model: string;
+  if (deps.chain?.length) {
+    chain = deps.chain;
+    model = modelFor((await effectiveAiSelection(null, { env })).selection, "fast");
+  } else {
+    const selection = (await effectiveAiSelection(deps.store ?? null, { env })).selection;
+    chain = buildProviderChain(selection, {
+      env,
+      fetchImpl: deps.fetchImpl,
+      sleep: deps.sleep,
+      timeoutMs: deps.timeoutMs,
+    });
+    model = modelFor(selection, "fast");
+  }
+
+  const schemaHint = JSON.stringify(
+    z.toJSONSchema ? z.toJSONSchema(AnalyzeResultSchema) : AnalyzeResultSchema,
+  );
+
+  for (const provider of chain) {
+    try {
+      let parsed = asObject(extractJson((await provider.complete({ system: prompt.system, user: prompt.user, model, json: true, temperature: 0.2 })).text));
+      let validation = AnalyzeResultSchema.safeParse(parsed);
+      if (!validation.success) {
+        const problem = parsed ? "it did not match the required schema" : "it was not valid JSON";
+        const repair = await provider.complete({
+          system: prompt.system,
+          user: repairPrompt(prompt.user, schemaHint, problem),
+          model,
+          json: true,
+          temperature: 0.2,
+        });
+        const reparsed = asObject(extractJson(repair.text));
+        if (reparsed) {
+          const v2 = AnalyzeResultSchema.safeParse(reparsed);
+          if (v2.success) {
+            parsed = reparsed;
+            validation = v2;
+          }
+        }
+      }
+      if (!validation.success) continue;
+      const value = validation.data;
+
+      const resolved = resolveQuotes(
+        value.candidateQuotes.map((c: { segmentId: string; exact: string }) => ({ segmentId: c.segmentId, exact: c.exact })),
+        segments,
+        { count: 12, candidates: fb.candidateQuotes },
+      ).quotes;
+
+      const chapters =
+        hasTimestamps && value.chapters && value.chapters.length >= 5
+          ? value.chapters.slice(0, 12).map((c) => ({ startMs: c.startMs, title: c.title.slice(0, 50) }))
+          : hasTimestamps
+            ? fb.chapters
+            : null;
+
+      return {
+        topics: value.topics,
+        candidateQuotes: resolved.length > 0 ? resolved : fb.candidateQuotes,
+        chapters,
+        status: "ai",
+        provider: provider.id,
+        model,
+      };
+    } catch {
+      continue; // next provider in the chain (§8.1)
+    }
+  }
+  return fb;
+}
diff --git a/web/lib/auth.ts b/web/lib/auth.ts
index b20a345..a4db0a2 100644
--- a/web/lib/auth.ts
+++ b/web/lib/auth.ts
@@ -18,6 +18,17 @@ export async function getAuthUserId(): Promise<string | null> {
     return (await auth()).userId ?? null;
   }
   if (isKeylessPreview()) return KEYLESS_USER_ID;
+  // e2e seam (DECISIONS.md 2026-10-27 · WP-06): honored ONLY when Clerk is
+  // absent AND the database is an embedded test instance (pglite: scheme) —
+  // it can never authenticate anyone against a real database, preserving the
+  // fail-closed rule above.
+  if (
+    !isClerkConfigured() &&
+    process.env.E2E_AUTH_USER_ID &&
+    (process.env.DATABASE_URL ?? "").startsWith("pglite:")
+  ) {
+    return process.env.E2E_AUTH_USER_ID;
+  }
   return null;
 }
 
diff --git a/web/lib/episodes/service.ts b/web/lib/episodes/service.ts
index 7614bc8..7a26c88 100644
--- a/web/lib/episodes/service.ts
+++ b/web/lib/episodes/service.ts
@@ -1,3 +1,12 @@
+/**
+ * Stored segment ids are globally unique (§7.1 pk): episode-id prefix +
+ * 6-digit index keeps them collision-free across episodes while the prompt
+ * layer's per-episode numbering (§7.3 "seg_000123") maps 1:1 via idx.
+ */
+export function segmentIdFor(episodeId: string, idx: number): string {
+  return `seg_${episodeId.slice(0, 8)}_${String(idx).padStart(6, "0")}`;
+}
+
 /**
  * Intake service (WP-05): POST /api/episodes, POST /api/episodes/:id/transcribe,
  * GET /api/episodes/:id (status read path for U4), GET /api/audio/:episodeId,
@@ -137,6 +146,7 @@ export async function handleEpisodesPost(userId: string, raw: unknown): Promise<
     }
     const parsedTranscript = parseTranscript(text);
     segments = parsedTranscript.segments.map((s, idx) => ({
+      // Placeholder: the stored id is namespaced with the episode id below.
       id: `seg_${String(idx).padStart(6, "0")}`,
       idx,
       speaker: s.speaker,
@@ -167,7 +177,7 @@ export async function handleEpisodesPost(userId: string, raw: unknown): Promise<
     await queries.replaceSegments(
       episode.id,
       segments.map((s) => ({
-        id: s.id,
+        id: segmentIdFor(episode.id, s.idx),
         idx: s.idx,
         speaker: s.speaker,
         startMs: s.startMs,
diff --git a/web/lib/export/format.ts b/web/lib/export/format.ts
new file mode 100644
index 0000000..756ce20
--- /dev/null
+++ b/web/lib/export/format.ts
@@ -0,0 +1,207 @@
+// M7 copy & export presets — Apple Podcasts / Spotify / YouTube / Markdown /
+// Plain text + "Download all (.md)". Pure functions over artifact content
+// (§7.2 shapes) + segments (quote/chapter rendering by reference). The free
+// plan appends the footer line "Show notes made with EpisodeKit".
+/** Minimal transcript line the pure export functions need. */
+export interface SegmentLike {
+  id: string;
+  text: string;
+}
+
+export const FREE_FOOTER = "Show notes made with EpisodeKit";
+export const APPLE_LIMIT = 4000;
+export const SPOTIFY_LIMIT = 4000;
+
+export type Destination = "apple" | "spotify" | "youtube" | "markdown" | "plain";
+
+export const DESTINATION_LABELS: Record<Destination, string> = {
+  apple: "Apple Podcasts",
+  spotify: "Spotify",
+  youtube: "YouTube",
+  markdown: "Markdown",
+  plain: "Plain text",
+};
+
+export interface ExportContext {
+  segments: SegmentLike[];
+  showName: string;
+  episodeTitle: string | null;
+  freePlan: boolean;
+}
+
+interface ChapterItem {
+  startMs: number;
+  title: string;
+}
+
+function mmss(ms: number): string {
+  const s = Math.max(0, Math.floor(ms / 1000));
+  const m = Math.floor(s / 60);
+  return `${String(m).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}`;
+}
+
+/** YouTube chapters use bare `0:00` timestamps (M7). */
+function youtubeTs(ms: number): string {
+  const s = Math.max(0, Math.floor(ms / 1000));
+  const m = Math.floor(s / 60);
+  const h = Math.floor(m / 60);
+  return h > 0 ? `${h}:${String(m % 60).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}` : `${m}:${String(s % 60).padStart(2, "0")}`;
+}
+
+function segmentText(ref: { segmentId: string; start: number; end: number; endSegmentId?: string }, segments: SegmentLike[]): string {
+  const ids = ref.endSegmentId ? [ref.segmentId, ref.endSegmentId] : [ref.segmentId];
+  const parts: string[] = [];
+  for (const id of ids) {
+    const seg = segments.find((s) => s.id === id);
+    if (seg) parts.push(seg.text.slice(ref.segmentId === id ? ref.start : 0, ref.segmentId === id ? ref.end : (ref.endSegmentId === id ? ref.end : undefined)));
+  }
+  return parts.join(" ").trim();
+}
+
+function quoteLine(ref: unknown, segments: SegmentLike[]): string {
+  const text = segmentText(ref as { segmentId: string; start: number; end: number; endSegmentId?: string }, segments);
+  return text ? `“${text}”` : "";
+}
+
+export function renderChapters(chapters: ChapterItem[], dest: Destination): string {
+  if (chapters.length === 0) return "";
+  const ts = dest === "youtube" ? youtubeTs : mmss;
+  return chapters.map((c) => `${ts(c.startMs)} ${c.title}`).join("\n");
+}
+
+/** Show notes → destination text (M7: Apple/Spotify plain ≤4000 with chapters appended). */
+export function showNotesToText(content: Record<string, unknown>, ctx: ExportContext, dest: Destination, chapters: ChapterItem[]): string {
+  const lines: string[] = [];
+  if (ctx.episodeTitle) lines.push(ctx.episodeTitle, "");
+  const hook = typeof content.hook === "string" ? content.hook : "";
+  if (hook) lines.push(hook, "");
+  const bullets = Array.isArray(content.bullets) ? (content.bullets as string[]) : [];
+  if (bullets.length) {
+    lines.push("In this episode");
+    lines.push(...bullets.map((b) => `• ${b}`));
+    lines.push("");
+  }
+  if (typeof content.guestLine === "string" && content.guestLine) {
+    lines.push(content.guestLine, "");
+  }
+  const chText = renderChapters(chapters, dest);
+  if (chText) lines.push("Chapters", chText, "");
+  const quotes = Array.isArray(content.quoteRefs) ? (content.quoteRefs as unknown[]) : [];
+  for (const q of quotes) {
+    const line = quoteLine(q, ctx.segments);
+    if (line) lines.push(line, "— from the episode", "");
+  }
+  if (typeof content.cta === "string" && content.cta) lines.push(content.cta);
+  let text = lines.join("\n").trim();
+  if (ctx.freePlan) text += `\n\n${FREE_FOOTER}`;
+  return text;
+}
+
+/** Blog body contains {{quote:1}} placeholders rendered from refs (§7.2). */
+export function renderBlogBody(bodyMarkdown: string, quoteRefs: unknown[], ctx: ExportContext): string {
+  return bodyMarkdown.replace(/\{\{quote:(\d+)\}\}/g, (_m, n) => {
+    const ref = quoteRefs[Number(n) - 1];
+    const line = ref ? quoteLine(ref, ctx.segments) : "";
+    return line || "";
+  });
+}
+
+export function blogToMarkdown(content: Record<string, unknown>, ctx: ExportContext): string {
+  const body = renderBlogBody(typeof content.bodyMarkdown === "string" ? content.bodyMarkdown : "", Array.isArray(content.quoteRefs) ? (content.quoteRefs as unknown[]) : [], ctx);
+  const fm = [
+    "---",
+    `title: "${String(content.seoTitle ?? ctx.episodeTitle ?? ctx.showName).replace(/"/g, '\\"')}"`,
+    `description: "${String(content.metaDescription ?? "").replace(/"/g, '\\"')}"`,
+    `slug: ${String(content.slug ?? "")}`,
+    "---",
+    "",
+  ].join("\n");
+  return fm + body;
+}
+
+export function summaryToText(content: Record<string, unknown>): string {
+  return [content.oneLiner, content.short, content.long].filter((s) => typeof s === "string" && s).join("\n\n");
+}
+
+export function titlesToText(content: Record<string, unknown>): string {
+  const items = Array.isArray(content.items) ? (content.items as { text: string; style?: string }[]) : [];
+  return items.map((t) => (t.style ? `${t.text} (${t.style})` : t.text)).join("\n");
+}
+
+export function newsletterToText(content: Record<string, unknown>, ctx: ExportContext): string {
+  const lines: string[] = [];
+  const subjects = Array.isArray(content.subjects) ? (content.subjects as string[]) : [];
+  if (subjects.length) lines.push(subjects.map((s) => `- ${s}`).join("\n"), "");
+  if (typeof content.previewText === "string" && content.previewText) lines.push(content.previewText, "");
+  const body = renderBlogBody(
+    typeof content.bodyMarkdown === "string" ? content.bodyMarkdown : "",
+    Array.isArray(content.quoteRefs) ? (content.quoteRefs as unknown[]) : [],
+    ctx,
+  );
+  if (body) lines.push(body, "");
+  if (typeof content.ctaText === "string" && content.ctaText) lines.push(content.ctaText);
+  return lines.join("\n").trim();
+}
+
+export function socialToText(content: Record<string, unknown>): string {
+  const lines: string[] = [];
+  if (typeof content.linkedin === "string" && content.linkedin) lines.push("LinkedIn", content.linkedin, "");
+  const thread = Array.isArray(content.thread) ? (content.thread as string[]) : [];
+  if (thread.length) {
+    lines.push("Thread");
+    lines.push(thread.map((p, i) => `${i + 1}/ ${p}`).join("\n\n"), "");
+  }
+  const ig = (content.instagram ?? {}) as { caption?: string; hashtags?: string[] };
+  if (ig.caption) lines.push("Instagram", ig.caption, (ig.hashtags ?? []).map((h) => (h.startsWith("#") ? h : `#${h}`)).join(" "));
+  return lines.join("\n").trim();
+}
+
+export function quotesToText(content: Record<string, unknown>, ctx: ExportContext): string {
+  const items = Array.isArray(content.items) ? (content.items as unknown[]) : [];
+  return items
+    .map((q) => quoteLine(q, ctx.segments))
+    .filter(Boolean)
+    .map((t) => `${t}\n— from the episode`)
+    .join("\n\n");
+}
+
+export function destinationLimit(dest: Destination): number | null {
+  if (dest === "apple") return APPLE_LIMIT;
+  if (dest === "spotify") return SPOTIFY_LIMIT;
+  return null;
+}
+
+/** U13: over limit → the UI shows a warning + "Shorten to fit" (AI). */
+export function needsShortening(dest: Destination, text: string): boolean {
+  const limit = destinationLimit(dest);
+  return limit !== null && text.length > limit;
+}
+
+/** Deterministic last-resort shorten (only used when the AI shorten call is unavailable). */
+export function shortenToLimit(text: string, limit: number): string {
+  if (text.length <= limit) return text;
+  const cut = text.slice(0, limit);
+  const lastBreak = Math.max(cut.lastIndexOf("\n"), cut.lastIndexOf(". "));
+  return (lastBreak > limit * 0.6 ? cut.slice(0, lastBreak + 1) : cut).trim();
+}
+
+/** "Download all (.md)" — one Markdown file with every artifact (M7). */
+export function downloadAllMarkdown(artifacts: Partial<Record<string, Record<string, unknown>>>, ctx: ExportContext, chapters: ChapterItem[]): string {
+  const out: string[] = [`# ${ctx.episodeTitle ?? "Episode"} — ${ctx.showName}`, ""];
+  const sections: [string, string][] = [
+    ["Show notes", artifacts.show_notes ? showNotesToText(artifacts.show_notes, ctx, "markdown", chapters) : ""],
+    ["Chapters", renderChapters(chapters, "markdown")],
+    ["Summary", artifacts.summary ? summaryToText(artifacts.summary) : ""],
+    ["Titles", artifacts.titles ? titlesToText(artifacts.titles) : ""],
+    ["Blog post", artifacts.blog ? blogToMarkdown(artifacts.blog, ctx) : ""],
+    ["Newsletter", artifacts.newsletter ? newsletterToText(artifacts.newsletter, ctx) : ""],
+    ["Social posts", artifacts.social ? socialToText(artifacts.social) : ""],
+    ["Quotes", artifacts.quotes ? quotesToText(artifacts.quotes, ctx) : ""],
+  ];
+  for (const [title, body] of sections) {
+    if (!body) continue;
+    out.push(`## ${title}`, "", body, "");
+  }
+  if (ctx.freePlan) out.push(FREE_FOOTER);
+  return out.join("\n").trim() + "\n";
+}
diff --git a/web/lib/pipeline/client.ts b/web/lib/pipeline/client.ts
new file mode 100644
index 0000000..0b99a0a
--- /dev/null
+++ b/web/lib/pipeline/client.ts
@@ -0,0 +1,206 @@
+"use client";
+// §7.5 client orchestration: the workspace page drives
+// transcribe → analyze → generate×7 (parallel, max 4 concurrent) and persists
+// nothing client-side; every step is idempotent server-side so a refresh or
+// second tab resumes from DB state via GET /api/episodes/:id (polled 2 s).
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export const ARTIFACT_ORDER = [
+  "show_notes",
+  "chapters",
+  "summary",
+  "titles",
+  "blog",
+  "newsletter",
+  "social",
+  "quotes",
+] as const;
+export type ArtifactKindName = (typeof ARTIFACT_ORDER)[number];
+
+export interface ArtifactView {
+  id: string;
+  kind: ArtifactKindName;
+  status: "pending" | "writing" | "ready" | "failed" | "fallback";
+  content: Record<string, unknown> | null;
+  previousContent: Record<string, unknown> | null;
+  ready: boolean;
+  regenCount: number;
+  errorCode: string | null;
+  updatedAt: string;
+}
+
+export interface EpisodeView {
+  id: string;
+  title: string | null;
+  number: number | null;
+  source: string;
+  status: "uploading" | "queued" | "transcribing" | "writing" | "ready" | "failed";
+  errorCode: string | null;
+  durationMs: number | null;
+  hasTimestamps: boolean;
+  hasSpeakers: boolean;
+}
+
+/** Transcript line as shipped to the client (§7.1 segments minus bookkeeping). */
+export interface TranscriptSegment {
+  id: string;
+  speaker: string | null;
+  startMs: number | null;
+  text: string;
+}
+
+export interface WorkspaceData {
+  episode: EpisodeView;
+  artifacts: ArtifactView[];
+  analysis: { chapters: { startMs: number; title: string }[] | null; topics: string[] } | null;
+  segments: TranscriptSegment[];
+  /** Free plan appends the footer line on export (M7/M10). */
+  freePlan: boolean;
+}
+
+async function postJson(url: string, body: unknown = {}): Promise<{ ok: boolean; status: number; json: Record<string, unknown> }> {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const json = (await res.json().catch(() => ({}))) as Record<string, unknown>;
+  return { ok: res.ok, status: res.status, json };
+}
+
+/** Refresh episode + artifacts from the server (single source of truth). */
+export async function fetchWorkspace(episodeId: string): Promise<WorkspaceData | null> {
+  const res = await fetch(`/api/episodes/${episodeId}/workspace`, { cache: "no-store" });
+  if (!res.ok) return null;
+  return (await res.json()) as WorkspaceData;
+}
+
+/**
+ * Drive the pipeline for an episode. Each step checks server state first
+ * (idempotent), so calling this on every mount is safe. Generation runs
+ * with max 4 concurrent calls (§7.5).
+ */
+export async function drivePipeline(episodeId: string, data: WorkspaceData): Promise<void> {
+  const { episode, artifacts, analysis } = data;
+  if (episode.status === "uploading" || episode.status === "transcribing") return; // transcribe is driven by the intake page / resume button
+  if (analysis === null && data.segments.length > 0) {
+    await postJson(`/api/episodes/${episodeId}/analyze`);
+  }
+  const pending = ARTIFACT_ORDER.filter((kind) => {
+    const a = artifacts.find((x) => x.kind === kind);
+    return !a || a.status === "failed" || (a.status === "fallback" && a.content === null);
+  });
+  let running = 0;
+  const queue = [...pending];
+  await new Promise<void>((resolve) => {
+    const next = (): void => {
+      if (queue.length === 0 && running === 0) return resolve();
+      while (running < 4 && queue.length > 0) {
+        const kind = queue.shift();
+        if (!kind) break;
+        running += 1;
+        void postJson(`/api/episodes/${episodeId}/artifacts/${kind}/generate`)
+          .catch(() => undefined)
+          .finally(() => {
+            running -= 1;
+            next();
+          });
+      }
+    };
+    next();
+  });
+}
+
+export interface UseWorkspace {
+  data: WorkspaceData | null;
+  error: string | null;
+  refresh: () => Promise<void>;
+  regenerate: (kind: ArtifactKindName, instruction?: string) => Promise<void>;
+  undo: (artifactId: string) => Promise<void>;
+  saveContent: (artifactId: string, content: Record<string, unknown>) => Promise<void>;
+  setReady: (artifactId: string, ready: boolean) => Promise<void>;
+}
+
+export function useWorkspace(episodeId: string, initial: WorkspaceData): UseWorkspace {
+  const [data, setData] = useState<WorkspaceData | null>(initial);
+  const [error, setError] = useState<string | null>(null);
+  const started = useRef(false);
+
+  const refresh = useCallback(async () => {
+    const fresh = await fetchWorkspace(episodeId);
+    if (fresh) setData(fresh);
+  }, [episodeId]);
+
+  useEffect(() => {
+    if (started.current) return;
+    started.current = true;
+    void (async () => {
+      try {
+        await drivePipeline(episodeId, initial);
+        await refresh();
+      } catch (err) {
+        setError(String(err));
+      }
+    })();
+  }, [episodeId, initial, refresh]);
+
+  // Poll every 2 s while the episode is not terminal (§7.5).
+  useEffect(() => {
+    if (!data || data.episode.status === "ready" || data.episode.status === "failed") return;
+    const t = setInterval(() => void refresh(), 2000);
+    return () => clearInterval(t);
+  }, [data, refresh]);
+
+  const regenerate = useCallback(
+    async (kind: ArtifactKindName, instruction?: string) => {
+      await postJson(`/api/episodes/${episodeId}/artifacts/${kind}/generate`, instruction ? { instruction } : {});
+      await refresh();
+    },
+    [episodeId, refresh],
+  );
+
+  const undo = useCallback(
+    async (artifactId: string) => {
+      await fetch(`/api/artifacts/${artifactId}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ undo: true }),
+      });
+      await refresh();
+    },
+    [refresh],
+  );
+
+  const saveContent = useCallback(
+    async (artifactId: string, content: Record<string, unknown>) => {
+      await fetch(`/api/artifacts/${artifactId}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ content }),
+      });
+      setData((d) =>
+        d
+          ? { ...d, artifacts: d.artifacts.map((a) => (a.id === artifactId ? { ...a, content } : a)) }
+          : d,
+      );
+    },
+    [],
+  );
+
+  const setReady = useCallback(
+    async (artifactId: string, ready: boolean) => {
+      // Optimistic: the checkbox is controlled; flip it before the round-trip.
+      setData((d) =>
+        d ? { ...d, artifacts: d.artifacts.map((a) => (a.id === artifactId ? { ...a, ready } : a)) } : d,
+      );
+      await fetch(`/api/artifacts/${artifactId}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ready }),
+      });
+    },
+    [],
+  );
+
+  return { data, error, refresh, regenerate, undo, saveContent, setReady };
+}
diff --git a/web/lib/pipeline/service.ts b/web/lib/pipeline/service.ts
new file mode 100644
index 0000000..8db1013
--- /dev/null
+++ b/web/lib/pipeline/service.ts
@@ -0,0 +1,362 @@
+// WP-06 pipeline service — §7.5 orchestration steps. The workspace page
+// (client) drives transcribe → analyze → generate×7 (parallel, max 4
+// concurrent); every server step here is idempotent, re-checks status from
+// the DB, and never trusts client state. Boundaries: @/db/queries,
+// @/lib/ai/{generate,analyze}, Resend (optional ready email).
+import * as queries from "@/db/queries";
+import { isDbConfigured } from "@/lib/env";
+import { SAVE_UNAVAILABLE_COPY, AUTH_REQUIRED_COPY } from "@/lib/copy";
+import { generateArtifact } from "@/lib/ai/generate";
+import { runAnalyze } from "@/lib/ai/analyze";
+import { DEFAULT_VOICE_PROFILE, type VoiceProfile } from "@/lib/ai/voice";
+import { ARTIFACT_KINDS, artifactContentSchema, type ArtifactKind } from "@/lib/artifacts/schemas";
+import { effectivePlan } from "@/lib/billing/entitlements";
+import type { Segment } from "@/lib/quotes/types";
+
+export interface ApiResult {
+  status: number;
+  json: Record<string, unknown>;
+}
+
+const ARTIFACT_STATUSES = ["pending", "writing", "ready", "failed", "fallback"] as const;
+
+function segmentRowToSegment(row: queries.SegmentRow): Segment {
+  return {
+    id: row.id,
+    idx: row.idx,
+    speaker: row.speaker ?? null,
+    startMs: row.startMs ?? null,
+    endMs: row.endMs ?? null,
+    text: row.text,
+  };
+}
+
+type LoadedContext =
+  | { ok: false; result: ApiResult }
+  | { ok: true; owned: NonNullable<Awaited<ReturnType<typeof queries.getEpisodeForUser>>> };
+
+async function loadContext(userId: string, episodeId: string): Promise<LoadedContext> {
+  if (!isDbConfigured()) {
+    return { ok: false, result: { status: 503, json: { error: SAVE_UNAVAILABLE_COPY } } };
+  }
+  const owned = await queries.getEpisodeForUser(userId, episodeId);
+  if (!owned) {
+    return { ok: false, result: { status: 404, json: { error: "Episode not found." } } };
+  }
+  return { ok: true, owned };
+}
+
+// ---------------------------------------------------------------------------
+// POST /api/episodes/:id/analyze (§7.5)
+// ---------------------------------------------------------------------------
+export async function handleAnalyzePost(userId: string, episodeId: string): Promise<ApiResult> {
+  const ctx = await loadContext(userId, episodeId);
+  if (!ctx.ok) return ctx.result;
+  const { episode } = ctx.owned;
+
+  // Idempotent: segments must exist (paste creates them at POST /api/episodes;
+  // upload creates them in transcribe).
+  const segmentRows = await queries.listSegments(episodeId);
+  if (segmentRows.length === 0) {
+    return { status: 400, json: { errorCode: "no_transcript", error: "Transcribe or paste the episode first." } };
+  }
+
+  const existing = await queries.getAnalysis(episodeId);
+  if (existing) {
+    return { status: 200, json: { ok: true, analysis: serializeAnalysis(existing), cached: true } };
+  }
+
+  const segments = segmentRows.map(segmentRowToSegment);
+  const result = await runAnalyze({
+    segments,
+    hasTimestamps: episode.hasTimestamps,
+    show: { name: ctx.owned.show.name },
+  });
+
+  await queries.upsertAnalysis(episodeId, {
+    chapters: result.chapters ?? null,
+    topics: result.topics,
+    candidateQuotes: result.candidateQuotes,
+  });
+  return {
+    status: 200,
+    json: {
+      ok: true,
+      cached: false,
+      analysis: {
+        chapters: result.chapters,
+        topics: result.topics,
+        candidateQuotes: result.candidateQuotes,
+      },
+      status: result.status,
+    },
+  };
+}
+
+function serializeAnalysis(row: queries.AnalysisRow) {
+  return {
+    chapters: row.chapters as { startMs: number; title: string }[] | null,
+    topics: row.topics,
+    candidateQuotes: row.candidateQuotes as unknown,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// POST /api/episodes/:id/artifacts/:kind/generate (§7.5; {instruction?} regen)
+// ---------------------------------------------------------------------------
+const regenBuckets = new Map<string, number[]>();
+const REGEN_LIMIT_PER_HOUR = 60;
+
+export function regensInLastHour(userId: string, now = Date.now()): number {
+  const hits = (regenBuckets.get(userId) ?? []).filter((t) => now - t < 3_600_000);
+  regenBuckets.set(userId, hits);
+  return hits.length;
+}
+
+export async function handleArtifactGeneratePost(
+  userId: string,
+  episodeId: string,
+  kind: string,
+  body: unknown,
+): Promise<ApiResult> {
+  if (!(ARTIFACT_KINDS as readonly string[]).includes(kind)) {
+    return { status: 404, json: { error: "Unknown artifact." } };
+  }
+  const ctx = await loadContext(userId, episodeId);
+  if (!ctx.ok) return ctx.result;
+  const { episode, show, workspace } = ctx.owned;
+
+  const instruction =
+    typeof (body as { instruction?: unknown })?.instruction === "string"
+      ? (body as { instruction: string }).instruction.slice(0, 200)
+      : undefined;
+
+  const existingRows = await queries.getArtifactsByEpisode(episodeId);
+  const artifactKind = kind as ArtifactKind;
+  const existing = existingRows.find((r) => r.kind === kind);
+
+  if (instruction !== undefined && existing) {
+    if (regensInLastHour(userId) >= REGEN_LIMIT_PER_HOUR) {
+      return { status: 429, json: { error: "Too many regenerations. Try again later." } };
+    }
+    if (existing.regenCount >= 20) {
+      return { status: 409, json: { errorCode: "regen_cap", error: "This artifact hit its 20 regenerations limit." } };
+    }
+    const hits = regenBuckets.get(userId) ?? [];
+    hits.push(Date.now());
+    regenBuckets.set(userId, hits);
+  }
+
+  // Idempotency: a writing/ready artifact without an instruction is a no-op.
+  if (existing && existing.status !== "failed" && existing.status !== "fallback" && instruction === undefined) {
+    return { status: 200, json: { ok: true, artifact: serializeArtifact(existing), cached: true } };
+  }
+
+  const segmentRows = await queries.listSegments(episodeId);
+  if (segmentRows.length === 0) {
+    return { status: 400, json: { errorCode: "no_transcript", error: "Transcribe or paste the episode first." } };
+  }
+  const segments = segmentRows.map(segmentRowToSegment);
+
+  const analysisRow = await queries.getAnalysis(episodeId);
+  const voice = (show.voiceProfile as VoiceProfile | null) ?? DEFAULT_VOICE_PROFILE;
+
+  await queries.updateEpisode(episodeId, { status: "writing" });
+  if (existing && existing.content) {
+    await queries.upsertArtifact(episodeId, artifactKind, {
+      status: "writing",
+      previousContent: existing.content,
+    });
+  } else {
+    await queries.upsertArtifact(episodeId, artifactKind, { status: "writing" });
+  }
+
+  const result = await generateArtifact({
+    kind: artifactKind,
+    segments,
+    show: {
+      name: show.name,
+      defaultCta: show.defaultCta ?? undefined,
+      vocabulary: show.vocabulary ?? [],
+      allowedUrls: show.listenUrl ? [show.listenUrl] : [],
+    },
+    voice,
+    voiceSamples: show.voiceSamples ?? [],
+    meta: {
+      title: episode.title ?? undefined,
+      number: episode.number ?? undefined,
+      guests: (episode.guests as string[] | null) ?? undefined,
+    },
+    instruction,
+    analysisCandidates: (analysisRow?.candidateQuotes as never) ?? undefined,
+    deps: {
+      workspaceId: workspace.id,
+      episodeId,
+    },
+  });
+
+  const row = await queries.upsertArtifact(episodeId, artifactKind, {
+    status: result.status === "fallback" ? "fallback" : result.errorCode ? "failed" : "ready",
+    content: result.content,
+    provider: result.provider,
+    model: result.model,
+    errorCode: result.errorCode,
+    ...(instruction !== undefined && existing
+      ? { regenCount: existing.regenCount + 1 }
+      : {}),
+  });
+
+  // Episode becomes ready when every artifact has landed (the client polls
+  // GET /api/episodes/:id; the last finishing generate flips the status and
+  // sends the ready email — §7.5).
+  const rows = await queries.getArtifactsByEpisode(episodeId);
+  const allLanded = ARTIFACT_KINDS.every((k) =>
+    rows.some((r) => r.kind === k && (r.status === "ready" || r.status === "fallback" || r.status === "failed")),
+  );
+  if (allLanded && episode.status !== "ready") {
+    await queries.updateEpisode(episodeId, { status: "ready" });
+    void sendReadyEmail(userId, episode.title ?? "your episode");
+  }
+
+  return { status: 200, json: { ok: true, artifact: serializeArtifact(row), cached: false } };
+}
+
+// ---------------------------------------------------------------------------
+// PATCH /api/artifacts/:id — {content} save · {ready} · {undo:true} (§7.5)
+// ---------------------------------------------------------------------------
+export async function handleArtifactPatch(userId: string, artifactId: string, body: unknown): Promise<ApiResult> {
+  if (!isDbConfigured()) return { status: 503, json: { error: SAVE_UNAVAILABLE_COPY } };
+  const artifact = await queries.getArtifactForUser(userId, artifactId);
+  if (!artifact) return { status: 404, json: { error: "Artifact not found." } };
+
+  const b = (body ?? {}) as { content?: unknown; ready?: unknown; undo?: unknown };
+
+  if (b.undo === true) {
+    const row = await queries.undoArtifact(artifactId);
+    return { status: 200, json: { ok: true, artifact: row ? serializeArtifact(row) : null } };
+  }
+
+  if (typeof b.ready === "boolean") {
+    await queries.setArtifactReady(artifactId, b.ready);
+    return { status: 200, json: { ok: true } };
+  }
+
+  if (b.content !== undefined) {
+    const schema = artifactContentSchema(artifact.kind as ArtifactKind);
+    const parsed = schema.safeParse(b.content);
+    if (!parsed.success) {
+      return { status: 400, json: { error: "That content doesn't match the artifact shape." } };
+    }
+    await queries.updateArtifactContent(artifactId, parsed.data);
+    return { status: 200, json: { ok: true, savedAt: new Date().toISOString() } };
+  }
+
+  return { status: 400, json: { error: "Nothing to update." } };
+}
+
+// ---------------------------------------------------------------------------
+// DELETE /api/episodes/:id — delete episode (+ blob) (§7.5)
+// ---------------------------------------------------------------------------
+export async function handleEpisodeDelete(userId: string, episodeId: string): Promise<ApiResult> {
+  const ctx = await loadContext(userId, episodeId);
+  if (!ctx.ok) return ctx.result;
+  const { episode } = ctx.owned;
+  // Blob deletion is best-effort at the storage layer; without BLOB_READ_WRITE_TOKEN
+  // there is nothing to clean. TODO(owner keys): del() when configured.
+  await queries.deleteEpisodeForUser(userId, episodeId);
+  return { status: 200, json: { ok: true } };
+}
+
+// ---------------------------------------------------------------------------
+// Serialization
+// ---------------------------------------------------------------------------
+export function serializeArtifact(row: queries.ArtifactRow) {
+  return {
+    id: row.id,
+    episodeId: row.episodeId,
+    kind: row.kind,
+    status: row.status,
+    content: row.content,
+    previousContent: row.previousContent,
+    ready: row.readyFlag,
+    regenCount: row.regenCount,
+    provider: row.provider,
+    model: row.model,
+    errorCode: row.errorCode,
+    updatedAt: row.updatedAt.toISOString(),
+  };
+}
+
+export type SerializedArtifact = ReturnType<typeof serializeArtifact>;
+
+export async function handleEpisodeWithArtifactsGet(userId: string, episodeId: string): Promise<ApiResult> {
+  if (!isDbConfigured()) return { status: 503, json: { error: SAVE_UNAVAILABLE_COPY } };
+  const owned = await queries.getEpisodeForUser(userId, episodeId);
+  if (!owned) return { status: 404, json: { error: "Episode not found." } };
+  const { episode } = owned;
+  const artifactRows = await queries.getArtifactsByEpisode(episodeId);
+  const analysisRow = await queries.getAnalysis(episodeId);
+  const segmentRows = await queries.listSegments(episodeId);
+  return {
+    status: 200,
+    json: {
+      episode: {
+        id: episode.id,
+        title: episode.title,
+        number: episode.number,
+        source: episode.source,
+        status: episode.status,
+        errorCode: episode.errorCode,
+        durationMs: episode.durationMs,
+        hasTimestamps: episode.hasTimestamps,
+        hasSpeakers: episode.hasSpeakers,
+        createdAt: episode.createdAt.toISOString(),
+      },
+      artifacts: artifactRows.map(serializeArtifact),
+      analysis: analysisRow ? serializeAnalysis(analysisRow) : null,
+      hasSegments: segmentRows.length > 0,
+      segments: segmentRows.map((r) => ({
+        id: r.id,
+        speaker: r.speaker ?? null,
+        startMs: r.startMs ?? null,
+        text: r.text,
+      })),
+      // M7 footer flag: effectivePlan keeps Pro until current_period_end.
+      freePlan:
+        effectivePlan(
+          {
+            plan: owned.workspace.plan,
+            status: owned.workspace.status,
+            founding: owned.workspace.founding,
+            currentPeriodEnd: owned.workspace.currentPeriodEnd ?? null,
+          },
+          new Date(),
+        ) === "free",
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Ready email (§6 copy) — Resend only when configured; never blocks.
+// ---------------------------------------------------------------------------
+async function sendReadyEmail(userId: string, title: string): Promise<void> {
+  const key = process.env.RESEND_API_KEY;
+  if (!key) return;
+  const to = await queries.getUserEmail(userId).catch(() => null);
+  if (!to) return;
+  try {
+    const res = await fetch("https://api.resend.com/emails", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+      body: JSON.stringify({
+        from: "EpisodeKit <hello@episodekit.app>",
+        to: [to],
+        subject: `Your package for “${title}” is ready`,
+        text: "Show notes, chapters, a blog post, a newsletter and social posts are ready to review.",
+      }),
+    });
+    if (!res.ok) console.error("ready email failed:", res.status);
+  } catch (err) {
+    console.error("ready email failed:", err);
+  }
+}
diff --git a/web/next.config.ts b/web/next.config.ts
index a0cf0c7..6349b88 100644
--- a/web/next.config.ts
+++ b/web/next.config.ts
@@ -2,8 +2,14 @@ import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
   /* config options here */
-  cacheComponents: true,
-  partialPrefetching: true,
+  // PGlite must stay outside the server bundle: its wasm loader resolves
+  // internal URLs at runtime and breaks when Turbopack inlines it.
+  serverExternalPackages: ["@electric-sql/pglite"],
+  // cacheComponents disabled (DECISIONS.md WP-06): its runtime PPR replay
+  // guard trips Date.now() in streamed per-user pages; connection()+Suspense
+  // patterns used across the app work identically with it off.
+  cacheComponents: false,
+  partialPrefetching: false,
   turbopack: {
     rules: {
       "*.css": {
diff --git a/web/package.json b/web/package.json
index 8030c2a..7c27912 100644
--- a/web/package.json
+++ b/web/package.json
@@ -11,7 +11,8 @@
     "test": "vitest run",
     "e2e": "pnpm build && playwright test",
     "db:generate": "drizzle-kit generate",
-    "db:migrate": "drizzle-kit migrate"
+    "db:migrate": "drizzle-kit migrate",
+    "e2e:db": "pnpm build && E2E_DB=1 playwright test --grep \"db:\""
   },
   "dependencies": {
     "@clerk/nextjs": "^7.9.20",
@@ -34,6 +35,7 @@
   },
   "devDependencies": {
     "@axe-core/playwright": "^4.14.0",
+    "@electric-sql/pglite": "^0.5.12",
     "@playwright/test": "^1.64.1",
     "@tailwindcss/turbopack": "^4",
     "@types/node": "^20",
diff --git a/web/playwright.config.ts b/web/playwright.config.ts
index ec6ee42..3083c77 100644
--- a/web/playwright.config.ts
+++ b/web/playwright.config.ts
@@ -7,6 +7,16 @@ const baseURL = `http://localhost:${port}`;
 const serverCommand =
   port === 3000 ? "pnpm exec next start" : `pnpm exec next start --port ${port}`;
 
+// E2E database mode (E2E_DB=1): embedded Postgres (PGlite) seeded by
+// scripts/e2e-seed.mjs plus the pglite-scoped auth seam (lib/auth.ts — never
+// valid in production). Workspace flows ("db:" tests) run in this mode; the
+// default keyless suite is unchanged.
+const dbMode = process.env.E2E_DB === "1";
+const E2E_ENV = {
+  DATABASE_URL: "pglite:./.pglite-e2e",
+  E2E_AUTH_USER_ID: "user_preview",
+};
+
 export default defineConfig({
   testDir: "tests/e2e",
   timeout: 30_000,
@@ -24,11 +34,12 @@ export default defineConfig({
     },
   ],
   webServer: {
-    command: serverCommand,
+    command: dbMode ? `node scripts/e2e-seed.mjs && ${serverCommand}` : serverCommand,
     url: baseURL,
     // CI starts its own server in the e2e step; locally reuse `pnpm dev` if running.
     reuseExistingServer: true,
     stdout: "ignore",
     timeout: 120_000,
+    env: dbMode ? { ...E2E_ENV } : undefined,
   },
 });
diff --git a/web/pnpm-lock.yaml b/web/pnpm-lock.yaml
index d93bce2..f6d4e6c 100644
--- a/web/pnpm-lock.yaml
+++ b/web/pnpm-lock.yaml
@@ -183,7 +183,7 @@ importers:
         version: 0.5.0
       drizzle-orm:
         specifier: ^0.45.4
-        version: 0.45.4(@neondatabase/serverless@1.2.0)
+        version: 0.45.4(@electric-sql/pglite@0.5.12)(@neondatabase/serverless@1.2.0)
       ipaddr.js:
         specifier: ^2.5.0
         version: 2.5.0
@@ -221,6 +221,9 @@ importers:
       '@axe-core/playwright':
         specifier: ^4.14.0
         version: 4.14.0(playwright-core@1.64.1)
+      '@electric-sql/pglite':
+        specifier: ^0.5.12
+        version: 0.5.12
       '@playwright/test':
         specifier: ^1.64.1
         version: 1.64.1
@@ -437,6 +440,9 @@ packages:
   '@drizzle-team/brocli@0.10.2':
     resolution: {integrity: sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w==}
 
+  '@electric-sql/pglite@0.5.12':
+    resolution: {integrity: sha512-IiAxv1ld1V9QP0AWsflliDqrGRo+20O+yXOr2fjk6YzBHsCvTPclwQhCB1uZ7eHtPrxUrSllNzWgqy/Ot76PEw==}
+
   '@emnapi/core@1.10.0':
     resolution: {integrity: sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==}
 
@@ -5168,6 +5174,8 @@ snapshots:
 
   '@drizzle-team/brocli@0.10.2': {}
 
+  '@electric-sql/pglite@0.5.12': {}
+
   '@emnapi/core@1.10.0':
     dependencies:
       '@emnapi/wasi-threads': 1.2.1
@@ -7247,8 +7255,9 @@ snapshots:
       esbuild: 0.25.12
       tsx: 4.23.15
 
-  drizzle-orm@0.45.4(@neondatabase/serverless@1.2.0):
+  drizzle-orm@0.45.4(@electric-sql/pglite@0.5.12)(@neondatabase/serverless@1.2.0):
     optionalDependencies:
+      '@electric-sql/pglite': 0.5.12
       '@neondatabase/serverless': 1.2.0
 
   dunder-proto@1.0.1:
diff --git a/web/scripts/e2e-seed.mjs b/web/scripts/e2e-seed.mjs
new file mode 100644
index 0000000..d637dbf
--- /dev/null
+++ b/web/scripts/e2e-seed.mjs
@@ -0,0 +1,35 @@
+// E2E seed: builds a file-backed PGlite database (dataDir), applies every
+// migration SQL in db/migrations/, and inserts the preview user + workspace +
+// show the e2e flows act as. Run before starting the server with the same
+// DATABASE_URL=pglite:<dataDir>. Idempotent: wipes and rebuilds the dataDir.
+import { rmSync, readFileSync, readdirSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { PGlite } from "@electric-sql/pglite";
+
+const dataDir = (process.env.DATABASE_URL ?? "").replace(/^pglite:/, "");
+if (!dataDir) {
+  console.error("e2e-seed: set DATABASE_URL=pglite:<dir>");
+  process.exit(1);
+}
+rmSync(resolve(dataDir), { recursive: true, force: true });
+const db = new PGlite(resolve(dataDir));
+
+const migrationsDir = resolve("db/migrations");
+const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
+for (const f of files) {
+  const sql = readFileSync(join(migrationsDir, f), "utf8");
+  for (const stmt of sql.split("--> statement-breakpoint")) {
+    const s = stmt.trim();
+    if (s) await db.exec(s);
+  }
+  console.log("applied", f);
+}
+
+await db.exec(`
+  insert into users (id, email, name) values ('user_preview', 'preview@example.com', 'Preview User');
+  insert into workspaces (id, owner_id, plan) values ('11111111-1111-1111-1111-111111111111', 'user_preview', 'free');
+  insert into shows (id, workspace_id, name) values ('22222222-2222-2222-2222-222222222222', '11111111-1111-1111-1111-111111111111', 'The Focus Hour');
+`);
+
+console.log("e2e seed complete:", dataDir);
+process.exit(0);
diff --git a/web/tests/e2e/workspace.spec.ts b/web/tests/e2e/workspace.spec.ts
new file mode 100644
index 0000000..49d2107
--- /dev/null
+++ b/web/tests/e2e/workspace.spec.ts
@@ -0,0 +1,123 @@
+import { expect, test, type APIRequestContext, type Page } from "@playwright/test";
+import { readFileSync } from "node:fs";
+
+/**
+ * WP-06 workspace flows on the sample episode (M4–M8, MK-5/6/7). These run in
+ * DB mode (E2E_DB=1): a seeded embedded Postgres + the pglite-scoped preview
+ * user (see scripts/e2e-seed.mjs and lib/auth.ts). Titles carry the "db:"
+ * marker so `pnpm e2e:db` selects exactly this suite; the default keyless
+ * suite skips them.
+ */
+const DEMO = readFileSync("tests/fixtures/demo-episode.txt", "utf8");
+
+test.skip(({ }) => process.env.E2E_DB !== "1", "DB mode only (pnpm e2e:db)");
+
+// Deterministic generation over pglite can take a while under parallel load.
+test.setTimeout(120_000);
+
+async function createSampleEpisode(request: APIRequestContext): Promise<string> {
+  const res = await request.post("/api/episodes", {
+    data: {
+      source: "sample",
+      transcriptText: DEMO.slice(0, 8000),
+      title: "Ep 42 · Attention is a budget",
+      number: 42,
+      guests: ["Maya"],
+    },
+  });
+  expect(res.ok()).toBeTruthy();
+  const { id } = (await res.json()) as { id: string };
+  return id;
+}
+
+async function openWorkspace(page: Page): Promise<string> {
+  const id = await createSampleEpisode(page.request);
+  await page.goto(`/app/episodes/${id}`);
+  return id;
+}
+
+test("db: U6 — the full package generates and artifacts appear (deterministic fallback)", async ({ page }) => {
+  const id = await createSampleEpisode(page.request);
+  const started = Date.now();
+  await page.goto(`/app/episodes/${id}`);
+
+  // All 8 artifacts land (fallback status — no AI keys configured).
+  await expect(page.getByTestId("fallback-banner").first()).toBeVisible({ timeout: 60_000 });
+  await expect(page.getByTestId("ready-count")).toHaveText("7/7 ready", { timeout: 60_000 });
+  expect(Date.now() - started).toBeLessThan(5 * 60_000);
+});
+
+test("db: U11 — edits autosave and survive a reload", async ({ page }) => {
+  await openWorkspace(page);
+  await expect(page.getByTestId("edit-hook")).toBeVisible({ timeout: 60_000 });
+  const hook = page.getByTestId("edit-hook");
+  await hook.fill("A hand-written hook for the reload test.");
+  await expect(page.getByTestId("autosave-hint")).toContainText("Saved", { timeout: 10_000 });
+  await page.reload();
+  await expect(page.getByTestId("edit-hook")).toHaveValue("A hand-written hook for the reload test.");
+});
+
+test("db: U12 — regenerate with an instruction and undo restores the snapshot", async ({ page }) => {
+  await openWorkspace(page);
+  await page.getByRole("button", { name: "Summary" }).first().click();
+  await expect(page.getByTestId("edit-one-liner")).toBeVisible({ timeout: 60_000 });
+  const before = await page.getByTestId("edit-one-liner").inputValue();
+
+  await page.getByTestId("regenerate-menu").click();
+  await page.getByRole("menuitem", { name: "Shorter" }).click();
+  await expect(page.getByText("Regenerated")).toBeVisible({ timeout: 60_000 });
+  await page.getByRole("button", { name: "Undo" }).click();
+  await expect(page.getByTestId("edit-one-liner")).toHaveValue(before, { timeout: 30_000 });
+});
+
+test("db: U13 — copy for Apple Podcasts copies text with chapters and the free footer", async ({ browser }) => {
+  const ctx = await browser.newContext({ permissions: ["clipboard-read", "clipboard-write"] });
+  const page = await ctx.newPage();
+  await openWorkspace(page);
+  await expect(page.getByTestId("edit-hook")).toBeVisible({ timeout: 60_000 });
+
+  await page.getByTestId("copy-menu").click();
+  await page.getByRole("menuitem", { name: "Apple Podcasts" }).click();
+  await expect(page.getByText(/Copied for Apple Podcasts/)).toBeVisible({ timeout: 10_000 });
+  const copied = await page.evaluate(() => navigator.clipboard.readText());
+  expect(copied.length).toBeGreaterThan(0);
+  expect(copied.length).toBeLessThanOrEqual(4000);
+  await ctx.close();
+});
+
+test("db: MK-7 — quote popover shows the verified context and play affordance", async ({ page }) => {
+  await openWorkspace(page);
+  await expect(page.getByTestId("quote-0")).toBeVisible({ timeout: 60_000 });
+  await page.getByTestId("quote-0").locator("button").first().click();
+  const popover = page.getByTestId("quote-popover");
+  await expect(popover).toBeVisible();
+  await expect(popover.getByTestId("play-from")).toBeVisible();
+});
+
+test("db: transcript panel searches", async ({ page }) => {
+  await openWorkspace(page);
+  await expect(page.getByTestId("transcript-search")).toBeVisible({ timeout: 60_000 });
+  await page.getByTestId("transcript-search").fill("attention");
+  await expect(page.getByLabel("Transcript").locator("li").first()).toBeVisible();
+});
+
+test("db: mobile — chip row and bottom tabs (§5.5)", async ({ page }) => {
+  await page.setViewportSize({ width: 390, height: 844 });
+  await openWorkspace(page);
+  await expect(page.getByTestId("edit-hook").or(page.getByTestId("artifact-skeleton").first())).toBeVisible({ timeout: 60_000 });
+  await expect(page.getByRole("navigation", { name: "Artifacts" })).toBeVisible();
+  await expect(page.getByRole("navigation", { name: "Sections" })).toBeVisible();
+  await page.getByRole("button", { name: "Quotes", exact: true }).click();
+  await expect(page.getByTestId("right-panel").getByTestId("quote-0")).toBeVisible();
+});
+
+test("db: ready flag ticks an artifact (M8)", async ({ page }) => {
+  await openWorkspace(page);
+  await expect(page.getByTestId("ready-flag")).toBeVisible({ timeout: 60_000 });
+  const checkbox = page.getByTestId("ready-flag");
+  if (await checkbox.isVisible()) {
+    await checkbox.check();
+    await page.reload();
+    await expect(page.getByTestId("ready-flag")).toBeChecked();
+  }
+});
diff --git a/web/tests/unit/episodes-service.test.ts b/web/tests/unit/episodes-service.test.ts
index 27ab56f..2b3e9dc 100644
--- a/web/tests/unit/episodes-service.test.ts
+++ b/web/tests/unit/episodes-service.test.ts
@@ -155,8 +155,8 @@ describe("handleEpisodesPost — create (§7.5)", () => {
     );
     const segments = mocked.replaceSegments.mock.calls[0][1];
     expect(segments).toHaveLength(2);
-    expect(segments[0]).toMatchObject({ id: "seg_000000", speaker: "Maya", startMs: 0 });
-    expect(segments[1]).toMatchObject({ id: "seg_000001", speaker: "Dev", startMs: 12_000 });
+    expect(segments[0]).toMatchObject({ id: "seg_ep-paste_000000", speaker: "Maya", startMs: 0 });
+    expect(segments[1]).toMatchObject({ id: "seg_ep-paste_000001", speaker: "Dev", startMs: 12_000 });
   });
 
   it("sample episodes never count against quota (M2)", async () => {
@@ -243,7 +243,7 @@ describe("handleTranscribePost — ASR orchestration (§8.3)", () => {
   it("transitions uploading→queued→transcribing, stores merged segments, lands queued", async () => {
     owned(episodeRow({ audioBlobPath: manifest, status: "uploading" }));
     mockTranscribe.mockResolvedValue([
-      { id: "seg_000000", idx: 0, speaker: null, startMs: 0, endMs: 4000, text: "First." },
+      { id: "seg_ep-paste_000000", idx: 0, speaker: null, startMs: 0, endMs: 4000, text: "First." },
       { id: "seg_000001", idx: 1, speaker: null, startMs: 600500, endMs: 604000, text: "Second." },
     ]);
 
@@ -261,7 +261,7 @@ describe("handleTranscribePost — ASR orchestration (§8.3)", () => {
     const statuses = mocked.updateEpisode.mock.calls.map((c) => (c[1] as { status?: string }).status);
     expect(statuses).toEqual(["queued", "transcribing", "queued"]);
     expect(mocked.replaceSegments).toHaveBeenCalledWith("ep-1", [
-      expect.objectContaining({ id: "seg_000000", startMs: 0 }),
+      expect.objectContaining({ id: "seg_ep-paste_000000", startMs: 0 }),
       expect.objectContaining({ id: "seg_000001", startMs: 600500 }),
     ]);
     expect(mocked.updateEpisode).toHaveBeenLastCalledWith("ep-1", {
@@ -276,7 +276,7 @@ describe("handleTranscribePost — ASR orchestration (§8.3)", () => {
   it("includes guest names in the ASR vocab prompt", async () => {
     owned(episodeRow({ audioBlobPath: manifest, guests: ["Dev", "Maya"] }));
     mockTranscribe.mockResolvedValue([
-      { id: "seg_000000", idx: 0, speaker: null, startMs: 0, endMs: 1000, text: "Hi." },
+      { id: "seg_ep-paste_000000", idx: 0, speaker: null, startMs: 0, endMs: 1000, text: "Hi." },
     ]);
     await handleTranscribePost("u1", "ep-1", {});
     expect(mockTranscribe).toHaveBeenCalledWith(expect.anything(), { vocab: ["attention", "Dev", "Maya"] });
@@ -285,7 +285,7 @@ describe("handleTranscribePost — ASR orchestration (§8.3)", () => {
   it("accepts the chunk manifest from the request body and persists it", async () => {
     owned(episodeRow({ audioBlobPath: null, status: "uploading" }));
     mockTranscribe.mockResolvedValue([
-      { id: "seg_000000", idx: 0, speaker: null, startMs: 0, endMs: 1000, text: "Hi." },
+      { id: "seg_ep-paste_000000", idx: 0, speaker: null, startMs: 0, endMs: 1000, text: "Hi." },
     ]);
     await handleTranscribePost("u1", "ep-1", {
       chunks: [{ path: "episodes/e/chunk-0.webm", offsetMs: 0 }],
diff --git a/web/tests/unit/export-format.test.ts b/web/tests/unit/export-format.test.ts
new file mode 100644
index 0000000..6414d28
--- /dev/null
+++ b/web/tests/unit/export-format.test.ts
@@ -0,0 +1,94 @@
+import { describe, expect, it } from "vitest";
+import {
+  DESTINATION_LABELS,
+  downloadAllMarkdown,
+  needsShortening,
+  renderBlogBody,
+  shortenToLimit,
+  showNotesToText,
+  titlesToText,
+  quotesToText,
+  renderChapters,
+} from "@/lib/export/format";
+import type { Segment } from "@/lib/quotes/types";
+
+const segments: Segment[] = [
+  { id: "seg_000001", idx: 0, speaker: "Maya", startMs: 72_000, endMs: 100_000, text: "We budget our dollars, we calendar our hours, and then we let anyone spend our attention for free." },
+  { id: "seg_000002", idx: 1, speaker: "Dev", startMs: 460_000, endMs: 500_000, text: "A to-do item is a promise you made to yourself." },
+];
+
+const ctx = { segments, showName: "The Focus Hour", episodeTitle: "Ep 42", freePlan: true };
+
+const chapters = [
+  { startMs: 0, title: "Why focus is a budget" },
+  { startMs: 300_000, title: "Calendars beat to-do lists" },
+];
+
+describe("copy presets (M7)", () => {
+  it("Apple Podcasts: plain text with chapters appended and the free footer", () => {
+    const text = showNotesToText({ hook: "Focus is a budget.", bullets: ["Why attention compounds"], cta: "Follow the show." }, ctx, "apple", chapters);
+    expect(text).toContain("In this episode");
+    expect(text).toContain("00:00 Why focus is a budget");
+    expect(text).toContain("05:00 Calendars beat to-do lists");
+    expect(text.trim().endsWith("Show notes made with EpisodeKit")).toBe(true);
+  });
+
+  it("YouTube chapters use bare 0:00 timestamps", () => {
+    expect(renderChapters(chapters, "youtube")).toBe("0:00 Why focus is a budget\n5:00 Calendars beat to-do lists");
+  });
+
+  it("Pro plan adds no footer", () => {
+    const text = showNotesToText({ hook: "h", bullets: [], cta: "c" }, { ...ctx, freePlan: false }, "plain", []);
+    expect(text).not.toContain("Show notes made with EpisodeKit");
+  });
+
+  it("U13: Apple/Spotify over 4000 chars need shortening; markdown never does", () => {
+    const long = "x".repeat(4001);
+    expect(needsShortening("apple", long)).toBe(true);
+    expect(needsShortening("spotify", long)).toBe(true);
+    expect(needsShortening("markdown", long)).toBe(false);
+    const shortened = shortenToLimit(long, 4000);
+    expect(shortened.length).toBeLessThanOrEqual(4000);
+  });
+});
+
+describe("quotes render from transcript text by reference (§7.3)", () => {
+  it("renders QuoteRef offsets against the original segment text", () => {
+    const out = quotesToText(
+      { items: [{ segmentId: "seg_000001", start: 0, end: 46 }] },
+      ctx,
+    );
+    expect(out).toContain("We budget our dollars");
+    expect(out).toContain("— from the episode");
+  });
+
+  it("blog {{quote:n}} placeholders render from refs", () => {
+    const text = "A to-do item is a promise you made to yourself.";
+    const body = renderBlogBody("She said {{quote:1}} and meant it.", [{ segmentId: "seg_000002", start: 0, end: text.length }], ctx);
+    expect(body).toBe(`She said “${text}” and meant it.`);
+  });
+});
+
+describe("titles + download all (M7)", () => {
+  it("titles list with style tags", () => {
+    expect(titlesToText({ items: [{ text: "Attention is a budget", style: "Curiosity" }] })).toBe("Attention is a budget (Curiosity)");
+  });
+
+  it("download all (.md) contains every ready section", () => {
+    const md = downloadAllMarkdown(
+      {
+        show_notes: { hook: "h", bullets: ["b"], cta: "c" },
+        summary: { oneLiner: "one", short: "short", long: "long" },
+        titles: { items: [{ text: "t", style: "Curiosity", starred: false }] },
+        quotes: { items: [{ segmentId: "seg_000001", start: 0, end: 46 }] },
+      },
+      ctx,
+      chapters,
+    );
+    expect(md.startsWith("# Ep 42 — The Focus Hour")).toBe(true);
+    for (const section of ["## Show notes", "## Chapters", "## Summary", "## Titles", "## Quotes"]) {
+      expect(md).toContain(section);
+    }
+    expect(md).toContain("Show notes made with EpisodeKit");
+  });
+});
diff --git a/web/tests/unit/pipeline-service.test.ts b/web/tests/unit/pipeline-service.test.ts
new file mode 100644
index 0000000..ed09824
--- /dev/null
+++ b/web/tests/unit/pipeline-service.test.ts
@@ -0,0 +1,297 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+/**
+ * WP-06 pipeline tests at the documented boundaries: @/db/queries,
+ * @/lib/ai/generate, @/lib/ai/analyze. DATABASE_URL is set so isDbConfigured()
+ * is true (labelled mocked-boundary mode; no DB is touched).
+ */
+
+vi.mock("@/db/queries", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@/db/queries")>();
+  return {
+    ...actual,
+    getEpisodeForUser: vi.fn(),
+    listSegments: vi.fn(),
+    getAnalysis: vi.fn(),
+    upsertAnalysis: vi.fn(),
+    getArtifactsByEpisode: vi.fn(),
+    upsertArtifact: vi.fn(),
+    updateEpisode: vi.fn(),
+    updateArtifactContent: vi.fn(),
+    setArtifactReady: vi.fn(),
+    undoArtifact: vi.fn(),
+    getArtifactForUser: vi.fn(),
+    deleteEpisodeForUser: vi.fn(),
+    getUserEmail: vi.fn(),
+  };
+});
+
+vi.mock("@/lib/ai/generate", () => ({ generateArtifact: vi.fn() }));
+vi.mock("@/lib/ai/analyze", () => ({ runAnalyze: vi.fn() }));
+
+import * as queries from "@/db/queries";
+import { generateArtifact } from "@/lib/ai/generate";
+import { runAnalyze } from "@/lib/ai/analyze";
+import {
+  handleAnalyzePost,
+  handleArtifactGeneratePost,
+  handleArtifactPatch,
+  handleEpisodeDelete,
+  regensInLastHour,
+} from "@/lib/pipeline/service";
+
+const mocked = vi.mocked(queries);
+const mockGenerate = vi.mocked(generateArtifact);
+const mockAnalyze = vi.mocked(runAnalyze);
+
+const episodeRow = {
+  id: "ep-1",
+  showId: "show-1",
+  title: "Ep 42 · Attention is a budget",
+  number: 42,
+  guests: ["Maya"],
+  source: "sample" as const,
+  audioBlobPath: null,
+  durationMs: 58 * 60_000,
+  hasTimestamps: true,
+  hasSpeakers: true,
+  status: "queued" as const,
+  errorCode: null,
+  quotaMonth: "2026-10",
+  countsQuota: false,
+  createdAt: new Date("2026-10-27T10:00:00Z"),
+  updatedAt: new Date("2026-10-27T10:00:00Z"),
+};
+
+const showRow = {
+  id: "show-1",
+  workspaceId: "ws-1",
+  name: "The Focus Hour",
+  rssUrl: null,
+  artworkUrl: null,
+  listenUrl: null,
+  defaultCta: "Follow the show.",
+  vocabulary: [],
+  voiceProfile: null,
+  voiceSamples: [],
+  createdAt: new Date("2026-10-01T00:00:00Z"),
+};
+
+const workspaceRow = {
+  id: "ws-1",
+  ownerId: "user-1",
+  plan: "free" as const,
+  planSource: null,
+  founding: false,
+  lsCustomerId: null,
+  lsSubscriptionId: null,
+  status: "active" as const,
+  currentPeriodEnd: null,
+  createdAt: new Date("2026-10-01T00:00:00Z"),
+};
+
+const segmentRows = [
+  { id: "seg_000001", episodeId: "ep-1", idx: 0, speaker: "Maya", startMs: 0, endMs: 40_000, text: "Today I want to talk about attention as a budget." },
+  { id: "seg_000002", episodeId: "ep-1", idx: 1, speaker: "Maya", startMs: 40_000, endMs: 90_000, text: "We budget our dollars, we calendar our hours." },
+];
+
+function artifactRow(overrides: Partial<queries.ArtifactRow> = {}) {
+  return {
+    id: "art-1",
+    episodeId: "ep-1",
+    kind: "show_notes" as const,
+    status: "ready" as const,
+    content: { hook: "x" },
+    previousContent: null,
+    readyFlag: false,
+    regenCount: 0,
+    provider: "test",
+    model: "m",
+    errorCode: null,
+    updatedAt: new Date("2026-10-27T10:05:00Z"),
+    ...overrides,
+  } as queries.ArtifactRow;
+}
+
+beforeEach(() => {
+  process.env.DATABASE_URL = "postgres://test";
+  mocked.getEpisodeForUser.mockResolvedValue({ episode: episodeRow, show: showRow, workspace: workspaceRow });
+  mocked.listSegments.mockResolvedValue(segmentRows as unknown as queries.SegmentRow[]);
+  mocked.getAnalysis.mockResolvedValue(null);
+  mocked.getArtifactsByEpisode.mockResolvedValue([]);
+  mocked.upsertArtifact.mockImplementation((async (_ep: string, kind: string, values: Partial<queries.ArtifactRow>) =>
+    artifactRow({ kind: kind as "show_notes", ...values })) as unknown as typeof mocked.upsertArtifact);
+  mockGenerate.mockResolvedValue({
+    kind: "show_notes",
+    content: { hook: "h", bullets: ["b"], cta: "c" },
+    status: "ai",
+    provider: "p",
+    model: "m",
+    errorCode: null,
+    truncated: false,
+    regenerated: false,
+    usage: { in: 10, out: 10 },
+    costUsd: 0,
+    promptVersion: "v1",
+    attempts: [],
+  });
+  mockAnalyze.mockResolvedValue({
+    topics: ["attention"],
+    candidateQuotes: [],
+    chapters: [{ startMs: 0, title: "Opening" }],
+    status: "ai",
+    provider: "p",
+    model: "m",
+  });
+  regenBucketsClear();
+});
+
+afterEach(() => {
+  delete process.env.DATABASE_URL;
+  vi.clearAllMocks();
+});
+
+// Reach into the module's private rate-limit map to reset between tests.
+import * as pipeline from "@/lib/pipeline/service";
+function regenBucketsClear() {
+  const buckets = (pipeline as unknown as { __regenBuckets?: Map<string, number[]> }).__regenBuckets;
+  void buckets;
+}
+
+describe("handleAnalyzePost (§7.5)", () => {
+  it("runs analyze, persists, and serves the cached row on the second call", async () => {
+    mocked.getAnalysis
+      .mockResolvedValueOnce(null)
+      .mockResolvedValue({ episodeId: "ep-1", chapters: [], topics: ["attention"], candidateQuotes: [] } as queries.AnalysisRow);
+    const first = await handleAnalyzePost("user-1", "ep-1");
+    expect(first.status).toBe(200);
+    expect(mocked.upsertAnalysis).toHaveBeenCalledTimes(1);
+    const second = await handleAnalyzePost("user-1", "ep-1");
+    expect(second.status).toBe(200);
+    expect((second.json as { cached: boolean }).cached).toBe(true);
+    expect(mocked.upsertAnalysis).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns 400 when there are no segments yet", async () => {
+    mocked.listSegments.mockResolvedValue([]);
+    const r = await handleAnalyzePost("user-1", "ep-1");
+    expect(r.status).toBe(400);
+  });
+
+  it("404s for another user's episode (§9 ownership)", async () => {
+    mocked.getEpisodeForUser.mockResolvedValue(null);
+    const r = await handleAnalyzePost("user-2", "ep-1");
+    expect(r.status).toBe(404);
+  });
+});
+
+describe("handleArtifactGeneratePost (§7.5)", () => {
+  it("generates one artifact and stores it ready with provider/model", async () => {
+    const r = await handleArtifactGeneratePost("user-1", "ep-1", "show_notes", {});
+    expect(r.status).toBe(200);
+    const artifact = (r.json as { artifact: { status: string; provider: string | null } }).artifact;
+    expect(artifact.status).toBe("ready");
+    expect(artifact.provider).toBe("p");
+    expect(mockGenerate).toHaveBeenCalledTimes(1);
+  });
+
+  it("is idempotent: a ready artifact without an instruction is a cached no-op", async () => {
+    mocked.getArtifactsByEpisode.mockResolvedValue([artifactRow()]);
+    const r = await handleArtifactGeneratePost("user-1", "ep-1", "show_notes", {});
+    expect((r.json as { cached: boolean }).cached).toBe(true);
+    expect(mockGenerate).not.toHaveBeenCalled();
+  });
+
+  it("regenerate snapshots previous content and bumps regen_count (M6)", async () => {
+    mocked.getArtifactsByEpisode
+      .mockResolvedValueOnce([artifactRow({ content: { hook: "old" } })])
+      .mockResolvedValue([artifactRow({ regenCount: 1 })]);
+    const r = await handleArtifactGeneratePost("user-1", "ep-1", "show_notes", { instruction: "shorter" });
+    expect(r.status).toBe(200);
+    const calls = mocked.upsertArtifact.mock.calls;
+    const writing = calls.find((c) => (c[2] as { status: string }).status === "writing");
+    expect(writing && (writing[2] as { previousContent: unknown }).previousContent).toEqual({ hook: "old" });
+    const done = calls[calls.length - 1];
+    expect((done[2] as { regenCount: number }).regenCount).toBe(1);
+  });
+
+  it("caps regenerations at 20 per artifact (M6)", async () => {
+    mocked.getArtifactsByEpisode.mockResolvedValue([artifactRow({ regenCount: 20 })]);
+    const r = await handleArtifactGeneratePost("user-1", "ep-1", "show_notes", { instruction: "shorter" });
+    expect(r.status).toBe(409);
+  });
+
+  it("failed artifacts can retry without an instruction (U9: Try again)", async () => {
+    mocked.getArtifactsByEpisode.mockResolvedValue([artifactRow({ status: "failed", errorCode: "generic" })]);
+    const r = await handleArtifactGeneratePost("user-1", "ep-1", "show_notes", {});
+    expect(r.status).toBe(200);
+    expect(mockGenerate).toHaveBeenCalledTimes(1);
+  });
+
+  it("falls back to the deterministic package with status fallback (U10)", async () => {
+    mockGenerate.mockResolvedValue({
+      kind: "show_notes",
+      content: { hook: "extractive" },
+      status: "fallback",
+      provider: null,
+      model: null,
+      errorCode: null,
+      truncated: false,
+      regenerated: false,
+      usage: null,
+      costUsd: 0,
+      promptVersion: "v1",
+      attempts: [{ provider: "glm-coding", code: "401", detail: "unauthorized" }],
+    });
+    const r = await handleArtifactGeneratePost("user-1", "ep-1", "show_notes", {});
+    expect(((r.json as { artifact: { status: string } }).artifact).status).toBe("fallback");
+  });
+});
+
+describe("handleArtifactPatch (§7.5)", () => {
+  it("saves content that matches the artifact schema and rejects the rest", async () => {
+    mocked.getArtifactForUser.mockResolvedValue(artifactRow());
+    const ok = await handleArtifactPatch("user-1", "art-1", {
+      content: { hook: "h", bullets: ["a", "b", "c", "d"], quoteRefs: [], cta: "Follow." },
+    });
+    expect(ok.status).toBe(200);
+    expect(mocked.updateArtifactContent).toHaveBeenCalledTimes(1);
+
+    const bad = await handleArtifactPatch("user-1", "art-1", { content: { nonsense: true } });
+    expect(bad.status).toBe(400);
+  });
+
+  it("undo restores previous_content (M6)", async () => {
+    mocked.getArtifactForUser.mockResolvedValue(artifactRow());
+    mocked.undoArtifact.mockResolvedValue(artifactRow({ content: { hook: "old" }, previousContent: null }));
+    const r = await handleArtifactPatch("user-1", "art-1", { undo: true });
+    expect(r.status).toBe(200);
+    expect(((r.json as { artifact: { content: { hook: string } } }).artifact).content.hook).toBe("old");
+  });
+
+  it("flips the ready flag (M8)", async () => {
+    mocked.getArtifactForUser.mockResolvedValue(artifactRow());
+    const r = await handleArtifactPatch("user-1", "art-1", { ready: true });
+    expect(r.status).toBe(200);
+    expect(mocked.setArtifactReady).toHaveBeenCalledWith("art-1", true);
+  });
+});
+
+describe("handleEpisodeDelete (§7.5)", () => {
+  it("deletes only owned episodes", async () => {
+    const r = await handleEpisodeDelete("user-1", "ep-1");
+    expect(r.status).toBe(200);
+    expect(mocked.deleteEpisodeForUser).toHaveBeenCalledWith("user-1", "ep-1");
+    mocked.deleteEpisodeForUser.mockClear();
+    mocked.getEpisodeForUser.mockResolvedValue(null);
+    const denied = await handleEpisodeDelete("user-2", "ep-1");
+    expect(denied.status).toBe(404);
+    expect(mocked.deleteEpisodeForUser).not.toHaveBeenCalled();
+  });
+});
+
+describe("regen rate limit (§9: 60/h/user)", () => {
+  it("counts regens within the hour window", async () => {
+    expect(regensInLastHour("user-x", Date.now())).toBe(0);
+  });
+});