From 0859c661522ffdbc0a0a48cf4f78abc988409869 Mon Sep 17 00:00:00 2001
From: Robbie Davis <robbie@therobbiedavis.com>
Date: Wed, 19 Aug 2026 22:45:19 -0400
Subject: [PATCH] feat: add library date-added sorting and filtering

---
 fe/src/__tests__/AudiobooksView.spec.ts       |   87 +
 fe/src/__tests__/CustomFilterModal.spec.ts    |   55 +
 .../__tests__/customFilterEvaluator.spec.ts   |   24 +
 .../domain/collection/CustomFilterModal.vue   |   31 +-
 fe/src/types/index.ts                         |    1 +
 fe/src/utils/customFilterEvaluator.ts         |   56 +
 fe/src/views/library/AudiobooksView.vue       |   14 +-
 .../Features/Library/LibraryAddWorkflow.cs    |    1 +
 .../Audiobooks/Catalog/LibraryAddService.cs   |    1 +
 .../Catalog/LibraryAudiobookListItem.cs       |    1 +
 .../Audiobooks/Catalog/LibraryListService.cs  |    1 +
 .../Audiobooks/Common/AudiobookDto.cs         |    1 +
 .../Mapping/AudiobookDtoFactory.cs            |    1 +
 listenarr.domain/Audiobooks/Audiobook.cs      |    1 +
 ...rastructureStartupCompositionExtensions.cs |    6 +
 .../Configurations/AudiobookConfiguration.cs  |   16 +
 .../ListenarrDatabaseMigrationPreflight.cs    |   54 +-
 ...20015101_AddAudiobookAddedDate.Designer.cs | 2565 +++++++++++++++++
 .../20260820015101_AddAudiobookAddedDate.cs   |   29 +
 .../ListenArrDbContextModelSnapshot.cs        |   41 +-
 ...yController_LibraryListSlimPayloadTests.cs |    4 +
 .../Api/Models/AudiobookDtoFactoryTests.cs    |    3 +
 ...uctureStartupCompositionExtensionsTests.cs |   75 +
 .../Migrations/MigrationMetadataTests.cs      |   30 +
 .../Migrations/ReleasedSchemaUpgradeTests.cs  |   42 +
 .../Persistence/SqliteMigrationSchemaTests.cs |    5 +-
 26 files changed, 3120 insertions(+), 25 deletions(-)
 create mode 100644 fe/src/__tests__/CustomFilterModal.spec.ts
 create mode 100644 listenarr.infrastructure/Persistence/Migrations/20260820015101_AddAudiobookAddedDate.Designer.cs
 create mode 100644 listenarr.infrastructure/Persistence/Migrations/20260820015101_AddAudiobookAddedDate.cs

diff --git a/fe/src/__tests__/AudiobooksView.spec.ts b/fe/src/__tests__/AudiobooksView.spec.ts
index 718836de9..bdec6f5cd 100644
--- a/fe/src/__tests__/AudiobooksView.spec.ts
+++ b/fe/src/__tests__/AudiobooksView.spec.ts
@@ -39,6 +39,11 @@ type AudiobooksVm = {
   showItemDetails?: boolean
   groupBy?: string
   visibleRange?: { start: number; end: number }
+  sortKey?: string
+  sortOrder?: 'asc' | 'desc'
+  sortKeyProxy?: string
+  sortOptions?: Array<{ value: string; label: string }>
+  audiobooks?: Array<{ title?: string }>
 }
 
 const getVm = (wrapper: ReturnType<typeof mount>) => wrapper.vm as unknown as AudiobooksVm
@@ -118,6 +123,88 @@ describe('AudiobooksView', () => {
     expect(wrapper.text()).toContain('Test Publisher')
     expect(wrapper.text()).toContain('2020')
   })
+
+  it('sorts by canonical date added with unknown dates last', async () => {
+    if (
+      typeof (globalThis as unknown as { ResizeObserver?: unknown }).ResizeObserver === 'undefined'
+    ) {
+      ;(globalThis as unknown as Record<string, unknown>).ResizeObserver = class {
+        observe() {}
+        disconnect() {}
+      }
+    }
+    if (typeof (globalThis as unknown as { WebSocket?: unknown }).WebSocket === 'undefined') {
+      ;(globalThis as unknown as Record<string, unknown>).WebSocket = function () {
+        /* noop */
+      }
+    }
+
+    const pinia = createPinia()
+    setActivePinia(pinia)
+    const router = createRouter({
+      history: createMemoryHistory(),
+      routes: [
+        { path: '/', name: 'home', component: { template: '<div />' } },
+        { path: '/audiobooks', name: 'audiobooks', component: AudiobooksView },
+      ],
+    })
+    await router.push('/audiobooks')
+    await router.isReady().catch(() => {})
+
+    const store = useLibraryStore()
+    store.audiobooks = [
+      { id: 1, title: 'Oldest', authors: ['A'], added: '2023-01-01T00:00:00Z', files: [] },
+      { id: 2, title: 'Newest', authors: ['A'], added: '2025-06-01T00:00:00Z', files: [] },
+      { id: 3, title: 'Middle', authors: ['A'], added: '2024-03-15T00:00:00Z', files: [] },
+      { id: 4, title: 'Unknown', authors: ['A'], added: null, files: [] },
+    ] as import('@/types').Audiobook[]
+    store.fetchLibrary = vi.fn(async () => undefined)
+
+    const wrapper = mount(AudiobooksView, {
+      global: {
+        plugins: [pinia, router],
+        stubs: [
+          'BulkEditModal',
+          'EditAudiobookModal',
+          'CustomFilterModal',
+          'FiltersDropdown',
+          'CustomSelect',
+        ],
+      },
+    })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    const vm = getVm(wrapper)
+    await vm.setGroupBy?.('books')
+    await wrapper.vm.$nextTick()
+    expect(vm.sortOptions?.map((option) => option.value)).toContain('added')
+
+    vm.sortKey = 'added'
+    vm.sortOrder = 'desc'
+    await wrapper.vm.$nextTick()
+    expect(vm.audiobooks?.map((book) => book.title)).toEqual([
+      'Newest',
+      'Middle',
+      'Oldest',
+      'Unknown',
+    ])
+
+    vm.sortOrder = 'asc'
+    await wrapper.vm.$nextTick()
+    expect(vm.audiobooks?.map((book) => book.title)).toEqual([
+      'Oldest',
+      'Middle',
+      'Newest',
+      'Unknown',
+    ])
+
+    vm.sortKey = 'title'
+    vm.sortOrder = 'asc'
+    vm.sortKeyProxy = 'added'
+    await wrapper.vm.$nextTick()
+    expect(vm.sortKey).toBe('added')
+    expect(vm.sortOrder).toBe('desc')
+  })
 })
 
 describe('AudiobooksView Grouping', () => {
diff --git a/fe/src/__tests__/CustomFilterModal.spec.ts b/fe/src/__tests__/CustomFilterModal.spec.ts
new file mode 100644
index 000000000..f0a52552e
--- /dev/null
+++ b/fe/src/__tests__/CustomFilterModal.spec.ts
@@ -0,0 +1,55 @@
+/*
+ * Listenarr - Audiobook Management System
+ * Copyright (C) 2024-2026 Listenarr Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { describe, expect, it } from 'vitest'
+import { mount } from '@vue/test-utils'
+import CustomFilterModal from '@/components/domain/collection/CustomFilterModal.vue'
+
+const modalStub = {
+  template: '<div><slot name="header" /><slot /><slot name="footer" /></div>',
+}
+const modalBodyStub = {
+  template: '<div><slot /></div>',
+}
+
+describe('CustomFilterModal', () => {
+  it('resets the operator and value when a rule changes to Date Added', async () => {
+    const wrapper = mount(CustomFilterModal, {
+      props: {
+        isOpen: true,
+        filter: {
+          id: 'recent',
+          label: 'Recent',
+          rules: [{ field: 'title', operator: 'contains', value: 'existing title' }],
+        },
+      },
+      global: {
+        stubs: {
+          Modal: modalStub,
+          ModalHeader: true,
+          ModalBody: modalBodyStub,
+        },
+      },
+    })
+
+    const field = wrapper.get('select.field-select')
+    await field.setValue('added')
+
+    expect((wrapper.get('select.op-select').element as HTMLSelectElement).value).toBe('eq')
+    expect((wrapper.get('input[type="date"]').element as HTMLInputElement).value).toBe('')
+  })
+})
diff --git a/fe/src/__tests__/customFilterEvaluator.spec.ts b/fe/src/__tests__/customFilterEvaluator.spec.ts
index 5069595e5..630b3a730 100644
--- a/fe/src/__tests__/customFilterEvaluator.spec.ts
+++ b/fe/src/__tests__/customFilterEvaluator.spec.ts
@@ -70,6 +70,30 @@ describe('customFilterEvaluator - grouping and precedence', () => {
     expect(evaluateRules(b4 as Audiobook, rules)).toBe(false)
   })
 
+  it('compares date-added rules by the user-local calendar date and excludes unknown dates', () => {
+    const added = new Date(2026, 7, 19, 12, 30, 0)
+    const addedKey = `${added.getFullYear().toString().padStart(4, '0')}-${(added.getMonth() + 1)
+      .toString()
+      .padStart(2, '0')}-${added.getDate().toString().padStart(2, '0')}`
+    const previousDay = new Date(added.getFullYear(), added.getMonth(), added.getDate() - 1)
+    const previousDayKey = `${previousDay.getFullYear().toString().padStart(4, '0')}-${(
+      previousDay.getMonth() + 1
+    )
+      .toString()
+      .padStart(2, '0')}-${previousDay.getDate().toString().padStart(2, '0')}`
+    const book = { ...base, added: added.toISOString() } as Audiobook
+
+    expect(evaluateRules(book, [{ field: 'added', operator: 'eq', value: addedKey }])).toBe(true)
+    expect(evaluateRules(book, [{ field: 'added', operator: 'gt', value: previousDayKey }])).toBe(
+      true,
+    )
+    expect(
+      evaluateRules({ ...book, added: null }, [
+        { field: 'added', operator: 'ne', value: addedKey },
+      ]),
+    ).toBe(false)
+  })
+
   it('uses slim list file summary fields for path, filesize, and file count filters', () => {
     const slimBook = {
       ...base,
diff --git a/fe/src/components/domain/collection/CustomFilterModal.vue b/fe/src/components/domain/collection/CustomFilterModal.vue
index c6697c346..8e594d0c3 100644
--- a/fe/src/components/domain/collection/CustomFilterModal.vue
+++ b/fe/src/components/domain/collection/CustomFilterModal.vue
@@ -55,7 +55,11 @@
                   >
                     (
                   </button>
-                  <select v-model="r.field" class="form-select field-select">
+                  <select
+                    v-model="r.field"
+                    class="form-select field-select"
+                    @change="onFieldChange(r)"
+                  >
                     <option value="monitored">Monitored</option>
                     <option value="title">Title</option>
                     <option value="author">Author</option>
@@ -64,6 +68,7 @@
                     <option value="publisher">Publisher</option>
                     <option value="qualityProfileId">Quality Profile</option>
                     <option value="publishYear">Published Year</option>
+                    <option value="added">Date Added</option>
                     <option value="path">Path</option>
                     <option value="files">Files</option>
                     <option value="filesize">Filesize</option>
@@ -75,7 +80,9 @@
                     </template>
                     <template
                       v-else-if="
-                        ['publishYear', 'publishedYear', 'files', 'filesize'].includes(r.field)
+                        ['publishYear', 'publishedYear', 'files', 'filesize', 'added'].includes(
+                          r.field,
+                        )
                       "
                     >
                       <option value="eq">=</option>
@@ -120,6 +127,9 @@
                       placeholder="e.g. 2023"
                     />
                   </template>
+                  <template v-else-if="r.field === 'added'">
+                    <input v-model="r.value" type="date" class="form-input value-input" />
+                  </template>
                   <template v-else-if="r.field === 'files'">
                     <input
                       v-model.number="r.value"
@@ -303,6 +313,23 @@ watch(
   { immediate: true },
 )
 
+function onFieldChange(r: Rule) {
+  r.value = ''
+
+  if (r.field === 'monitored') {
+    r.operator = 'is'
+    r.value = 'true'
+    return
+  }
+
+  if (['publishYear', 'publishedYear', 'files', 'filesize', 'added'].includes(r.field)) {
+    r.operator = 'eq'
+    return
+  }
+
+  r.operator = 'contains'
+}
+
 function addRule() {
   local.value.rules.push({
     field: 'title',
diff --git a/fe/src/types/index.ts b/fe/src/types/index.ts
index 417c2eb77..bb3fd7185 100644
--- a/fe/src/types/index.ts
+++ b/fe/src/types/index.ts
@@ -710,6 +710,7 @@ export interface Audiobook {
   authors?: string[]
   publishedDate?: string
   publishYear?: string
+  added?: string | null
   series?: string
   seriesNumber?: string
   seriesMemberships?: AudiobookSeriesMembership[]
diff --git a/fe/src/utils/customFilterEvaluator.ts b/fe/src/utils/customFilterEvaluator.ts
index 31ca3cb2c..71415f3cc 100644
--- a/fe/src/utils/customFilterEvaluator.ts
+++ b/fe/src/utils/customFilterEvaluator.ts
@@ -30,6 +30,34 @@ function normalizeString(s: unknown) {
   return (s ?? '').toString().toLowerCase()
 }
 
+function toLocalDateKey(value: string | null | undefined): string | null {
+  if (!value) return null
+
+  const date = new Date(value)
+  if (Number.isNaN(date.getTime())) return null
+
+  const year = date.getFullYear().toString().padStart(4, '0')
+  const month = (date.getMonth() + 1).toString().padStart(2, '0')
+  const day = date.getDate().toString().padStart(2, '0')
+  return `${year}-${month}-${day}`
+}
+
+function normalizeDateRuleValue(value: string): string | null {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return null
+
+  const [year, month, day] = value.split('-').map(Number)
+  const date = new Date(Date.UTC(year, month - 1, day))
+  if (
+    date.getUTCFullYear() !== year ||
+    date.getUTCMonth() !== month - 1 ||
+    date.getUTCDate() !== day
+  ) {
+    return null
+  }
+
+  return value
+}
+
 function resolveFileCount(a: Audiobook): number {
   if (Array.isArray(a.files)) {
     return a.files.length
@@ -88,6 +116,9 @@ function evalSingle(a: Audiobook, r: RuleLike): boolean {
     case 'filesize':
       left = String((a as unknown as Record<string, unknown>)['fileSize'] ?? '')
       break
+    case 'added':
+      left = toLocalDateKey(a.added) ?? ''
+      break
     default:
       left = String((a as unknown as Record<string, unknown>)[field] ?? '')
       break
@@ -96,6 +127,31 @@ function evalSingle(a: Audiobook, r: RuleLike): boolean {
   const l = normalizeString(left)
   const v = normalizeString(val)
 
+  if (field === 'added') {
+    const leftDate = left || null
+    const valueDate = normalizeDateRuleValue(val)
+    if (!leftDate || !valueDate) return false
+
+    switch (op) {
+      case 'eq':
+      case 'is':
+        return leftDate === valueDate
+      case 'ne':
+      case 'is_not':
+        return leftDate !== valueDate
+      case 'lt':
+        return leftDate < valueDate
+      case 'lte':
+        return leftDate <= valueDate
+      case 'gt':
+        return leftDate > valueDate
+      case 'gte':
+        return leftDate >= valueDate
+      default:
+        return true
+    }
+  }
+
   const numericFields = new Set(['publishYear', 'publishedYear', 'files', 'filesize'])
   if (numericFields.has(field)) {
     const leftNum = Number(left)
diff --git a/fe/src/views/library/AudiobooksView.vue b/fe/src/views/library/AudiobooksView.vue
index 205e432d3..c2c88c182 100644
--- a/fe/src/views/library/AudiobooksView.vue
+++ b/fe/src/views/library/AudiobooksView.vue
@@ -1175,6 +1175,17 @@ const filteredAndSortedAudiobooks = computed(() => {
         av = getAudiobookStatus(a)
         bv = getAudiobookStatus(b)
         break
+      case 'added': {
+        const aTime = a.added ? Date.parse(a.added) : Number.NaN
+        const bTime = b.added ? Date.parse(b.added) : Number.NaN
+        const aHasDate = Number.isFinite(aTime)
+        const bHasDate = Number.isFinite(bTime)
+
+        if (!aHasDate && !bHasDate) return 0
+        if (!aHasDate) return 1
+        if (!bHasDate) return -1
+        return (aTime - bTime) * (sortOrder.value === 'asc' ? 1 : -1)
+      }
     }
 
     if (typeof av === 'boolean' && typeof bv === 'boolean') {
@@ -1557,6 +1568,7 @@ const sortOptions = computed(() => {
       { value: 'narrator-first', label: 'Narrator First Name' },
       { value: 'publisher', label: 'Publisher' },
       { value: 'year', label: 'Release Year' },
+      { value: 'added', label: 'Date Added' },
       { value: 'monitored', label: 'Monitored' },
       { value: 'status', label: 'Status' },
     ]
@@ -1586,7 +1598,7 @@ const sortKeyProxy = computed<string>({
       sortOrder.value = sortOrder.value === 'asc' ? 'desc' : 'asc'
     } else {
       sortKey.value = val
-      sortOrder.value = 'asc'
+      sortOrder.value = val === 'added' ? 'desc' : 'asc'
     }
   },
 })
diff --git a/listenarr.api/Features/Library/LibraryAddWorkflow.cs b/listenarr.api/Features/Library/LibraryAddWorkflow.cs
index 08b879e1f..a9e1ded18 100644
--- a/listenarr.api/Features/Library/LibraryAddWorkflow.cs
+++ b/listenarr.api/Features/Library/LibraryAddWorkflow.cs
@@ -227,6 +227,7 @@ private async Task<IActionResult> AddCoreAsync(LibraryController.AddToLibraryReq
                 return new ConflictObjectResult(new { message = "Audiobook already exists in library", audiobook = ex.Audiobook });
             }
 
+            audiobook.Added = DateTime.UtcNow;
             await _repo.AddAsync(audiobook);
             await ResolveAuthorAsinsAsync(audiobook);
             await SendAddedNotificationAsync(audiobook);
diff --git a/listenarr.application/Audiobooks/Catalog/LibraryAddService.cs b/listenarr.application/Audiobooks/Catalog/LibraryAddService.cs
index aa305b1c7..0d535c349 100644
--- a/listenarr.application/Audiobooks/Catalog/LibraryAddService.cs
+++ b/listenarr.application/Audiobooks/Catalog/LibraryAddService.cs
@@ -256,6 +256,7 @@ private async Task<LibraryAddOperationResult> CommitAsync(
             }
 
             audiobook.ImageUrl = preparedImage.FallbackImageUrl;
+            audiobook.Added = DateTime.UtcNow;
             cancellationToken.ThrowIfCancellationRequested();
             await _commitStore.CommitAsync(
                 audiobook,
diff --git a/listenarr.application/Audiobooks/Catalog/LibraryAudiobookListItem.cs b/listenarr.application/Audiobooks/Catalog/LibraryAudiobookListItem.cs
index 4c19f20c5..14682592c 100644
--- a/listenarr.application/Audiobooks/Catalog/LibraryAudiobookListItem.cs
+++ b/listenarr.application/Audiobooks/Catalog/LibraryAudiobookListItem.cs
@@ -26,6 +26,7 @@ public class LibraryAudiobookListItem
         public string[]? Narrators { get; set; }
         public string? PublishYear { get; set; }
         public string? PublishedDate { get; set; }
+        public DateTime? Added { get; set; }
         public string? Series { get; set; }
         public string? SeriesNumber { get; set; }
         public AudiobookSeriesMembershipDto[]? SeriesMemberships { get; set; }
diff --git a/listenarr.application/Audiobooks/Catalog/LibraryListService.cs b/listenarr.application/Audiobooks/Catalog/LibraryListService.cs
index 9191b81c4..b7a00be37 100644
--- a/listenarr.application/Audiobooks/Catalog/LibraryListService.cs
+++ b/listenarr.application/Audiobooks/Catalog/LibraryListService.cs
@@ -111,6 +111,7 @@ public async Task<IReadOnlyList<LibraryAudiobookListItem>> GetAllAsync()
                     Narrators = a.Narrators?.ToArray(),
                     PublishYear = a.PublishYear,
                     PublishedDate = a.PublishedDate,
+                    Added = a.Added,
                     Series = a.Series,
                     SeriesNumber = a.SeriesNumber,
                     SeriesMemberships = membershipsByAudiobookId.TryGetValue(a.Id, out var memberships) && memberships.Count > 0
diff --git a/listenarr.application/Audiobooks/Common/AudiobookDto.cs b/listenarr.application/Audiobooks/Common/AudiobookDto.cs
index 4e7f2e279..9dd33d375 100644
--- a/listenarr.application/Audiobooks/Common/AudiobookDto.cs
+++ b/listenarr.application/Audiobooks/Common/AudiobookDto.cs
@@ -46,6 +46,7 @@ public class AudiobookDto
         public List<string>? Genres { get; set; }
         public string[]? Tags { get; set; }
         public string? Description { get; set; }
+        public DateTime? Added { get; set; }
         public string? PublishYear { get; set; }
         public string? PublishedDate { get; set; }
         public string? Series { get; set; }
diff --git a/listenarr.application/Mapping/AudiobookDtoFactory.cs b/listenarr.application/Mapping/AudiobookDtoFactory.cs
index 47d55850e..b5a1d9077 100644
--- a/listenarr.application/Mapping/AudiobookDtoFactory.cs
+++ b/listenarr.application/Mapping/AudiobookDtoFactory.cs
@@ -53,6 +53,7 @@ public static AudiobookDto BuildFromEntity(Audiobook audiobook)
                 Genres = audiobook.Genres,
                 Tags = audiobook.Tags?.ToArray(),
                 Description = audiobook.Description,
+                Added = audiobook.Added,
                 PublishYear = audiobook.PublishYear,
                 PublishedDate = audiobook.PublishedDate,
                 Series = audiobook.Series,
diff --git a/listenarr.domain/Audiobooks/Audiobook.cs b/listenarr.domain/Audiobooks/Audiobook.cs
index 33f70d10a..0c879c71a 100644
--- a/listenarr.domain/Audiobooks/Audiobook.cs
+++ b/listenarr.domain/Audiobooks/Audiobook.cs
@@ -36,6 +36,7 @@ public class Audiobook
         public string? SeriesNumber { get; set; }
         public List<AudiobookSeriesMembership>? SeriesMemberships { get; set; }
         public string? Description { get; set; }
+        public DateTime? Added { get; set; } = DateTime.UtcNow;
         public List<string>? Genres { get; set; }
         public List<string>? Tags { get; set; }
         public List<string>? Narrators { get; set; }
diff --git a/listenarr.infrastructure/DependencyInjection/InfrastructureStartupCompositionExtensions.cs b/listenarr.infrastructure/DependencyInjection/InfrastructureStartupCompositionExtensions.cs
index 3cdd67a04..163be9f9f 100644
--- a/listenarr.infrastructure/DependencyInjection/InfrastructureStartupCompositionExtensions.cs
+++ b/listenarr.infrastructure/DependencyInjection/InfrastructureStartupCompositionExtensions.cs
@@ -80,6 +80,12 @@ public static void ApplyListenarrDatabaseMigrations(this IServiceProvider servic
                     "[Startup] Normalized {Count} legacy move job row(s) after applying durable move migrations",
                     repairedPostMigrationData.MoveJobsRepaired);
             }
+            if (repairedPostMigrationData.AudiobookAddedDatesBackfilled > 0)
+            {
+                Log.Logger.Information(
+                    "[Startup] Backfilled Date Added for {Count} legacy audiobook row(s) from durable library evidence",
+                    repairedPostMigrationData.AudiobookAddedDatesBackfilled);
+            }
             Log.Logger.Information("[Startup] EF Core migrations applied successfully");
         }
         catch (Exception ex) when (ex is not OperationCanceledException && ex is not OutOfMemoryException && ex is not StackOverflowException)
diff --git a/listenarr.infrastructure/Persistence/Configurations/AudiobookConfiguration.cs b/listenarr.infrastructure/Persistence/Configurations/AudiobookConfiguration.cs
index 93446995a..de8e6e670 100644
--- a/listenarr.infrastructure/Persistence/Configurations/AudiobookConfiguration.cs
+++ b/listenarr.infrastructure/Persistence/Configurations/AudiobookConfiguration.cs
@@ -83,6 +83,22 @@ public void Configure(EntityTypeBuilder<Audiobook> builder)
                 .HasColumnType("TEXT");
             authorAsinsProp.Metadata.SetValueComparer(authorAsinsComparer);
 
+            // SQLite stores DateTime as TEXT without the DateTimeKind flag. Added is a UTC
+            // instant, so restore that contract when values are materialized and normalize
+            // any local values before persistence.
+            var addedUtcConverter = new ValueConverter<DateTime?, DateTime?>(
+                value => value.HasValue
+                    ? value.Value.Kind == DateTimeKind.Local
+                        ? value.Value.ToUniversalTime()
+                        : DateTime.SpecifyKind(value.Value, DateTimeKind.Utc)
+                    : value,
+                value => value.HasValue
+                    ? DateTime.SpecifyKind(value.Value, DateTimeKind.Utc)
+                    : value);
+            builder.Property(e => e.Added)
+                .HasConversion(addedUtcConverter)
+                .HasColumnType("TEXT");
+
             // One-to-many: Audiobook -> AudiobookFiles
             builder.HasMany(a => a.Files)
                 .WithOne(f => f.Audiobook)
diff --git a/listenarr.infrastructure/Persistence/ListenarrDatabaseMigrationPreflight.cs b/listenarr.infrastructure/Persistence/ListenarrDatabaseMigrationPreflight.cs
index fee2a9ef6..933b94a94 100644
--- a/listenarr.infrastructure/Persistence/ListenarrDatabaseMigrationPreflight.cs
+++ b/listenarr.infrastructure/Persistence/ListenarrDatabaseMigrationPreflight.cs
@@ -8,6 +8,8 @@ internal static class ListenarrDatabaseMigrationPreflight
         "20260810160602_AddDurableFilesystemRecovery";
     internal const string RootFoldersMigrationId =
         "20260101172733_AddRootFolders";
+    internal const string AudiobookAddedDateMigrationId =
+        "20260820015101_AddAudiobookAddedDate";
 
     public static ListenarrDatabaseMigrationPreflightResult RepairLegacyData(
         ListenArrDbContext context)
@@ -72,9 +74,56 @@ public static ListenarrDatabasePostMigrationRepairResult RepairPostMigrationData
                   OR "Error" IS NULL
               );
             """);
+
+        var audiobookAddedDatesBackfilled = 0;
+        if (applied.Contains(AudiobookAddedDateMigrationId))
+        {
+            audiobookAddedDatesBackfilled = context.Database.ExecuteSqlRaw(
+                """
+                WITH "Evidence" AS (
+                    SELECT
+                        "AudiobookId",
+                        MIN("Timestamp") AS "ObservedAt",
+                        0 AS "Priority"
+                    FROM "History"
+                    WHERE "EventType" = 'Added'
+                      AND "AudiobookId" IS NOT NULL
+                    GROUP BY "AudiobookId"
+
+                    UNION ALL
+
+                    SELECT
+                        "AudiobookId",
+                        MIN("CreatedAt") AS "ObservedAt",
+                        1 AS "Priority"
+                    FROM "AudiobookFiles"
+                    GROUP BY "AudiobookId"
+                ),
+                "BestEvidence" AS (
+                    SELECT
+                        "AudiobookId",
+                        COALESCE(
+                            MIN(CASE WHEN "Priority" = 0 THEN "ObservedAt" END),
+                            MIN(CASE WHEN "Priority" = 1 THEN "ObservedAt" END)
+                        ) AS "ObservedAt"
+                    FROM "Evidence"
+                    GROUP BY "AudiobookId"
+                )
+                UPDATE "Audiobooks"
+                SET "Added" = (
+                    SELECT "BestEvidence"."ObservedAt"
+                    FROM "BestEvidence"
+                    WHERE "BestEvidence"."AudiobookId" = "Audiobooks"."Id"
+                )
+                WHERE "Added" IS NULL
+                  AND "Id" IN (SELECT "AudiobookId" FROM "BestEvidence");
+                """);
+        }
         transaction.Commit();
 
-        return new ListenarrDatabasePostMigrationRepairResult(moveJobsRepaired);
+        return new ListenarrDatabasePostMigrationRepairResult(
+            moveJobsRepaired,
+            audiobookAddedDatesBackfilled);
     }
 }
 
@@ -82,4 +131,5 @@ internal readonly record struct ListenarrDatabaseMigrationPreflightResult(
     int DefaultRootsNormalized);
 
 internal readonly record struct ListenarrDatabasePostMigrationRepairResult(
-    int MoveJobsRepaired);
+    int MoveJobsRepaired,
+    int AudiobookAddedDatesBackfilled);
diff --git a/listenarr.infrastructure/Persistence/Migrations/20260820015101_AddAudiobookAddedDate.Designer.cs b/listenarr.infrastructure/Persistence/Migrations/20260820015101_AddAudiobookAddedDate.Designer.cs
new file mode 100644
index 000000000..b1fac7487
--- /dev/null
+++ b/listenarr.infrastructure/Persistence/Migrations/20260820015101_AddAudiobookAddedDate.Designer.cs
@@ -0,0 +1,2565 @@
+// <auto-generated />
+using System;
+using Listenarr.Infrastructure.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Listenarr.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(ListenArrDbContext))]
+    [Migration("20260820015101_AddAudiobookAddedDate")]
+    partial class AddAudiobookAddedDate
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.8");
+
+            modelBuilder.Entity("Listenarr.Domain.ActivityHistory.DownloadHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("AudiobookId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DownloadClient")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DownloadClientId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DownloadId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("EventDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("EventType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("ImportedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OutputPath")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Protocol")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("WasImported")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AudiobookId");
+
+                    b.HasIndex("DownloadId");
+
+                    b.HasIndex("EventDate");
+
+                    b.HasIndex("DownloadId", "EventType");
+
+                    b.ToTable("DownloadHistories", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.ActivityHistory.History", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AudiobookExternalId")
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("AudiobookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AudiobookTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CorrelationId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DownloadClientId")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DownloadId")
+                        .HasMaxLength(150)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Error")
+                        .HasMaxLength(4000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("IdempotencyKey")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Message")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("NotificationSent")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Outcome")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ParentEventId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Source")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceTitle")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AudiobookExternalId");
+
+                    b.HasIndex("CorrelationId");
+
+                    b.HasIndex("DownloadClientId");
+
+                    b.HasIndex("DownloadId");
+
+                    b.HasIndex("EventType");
+
+                    b.HasIndex("IdempotencyKey")
+                        .IsUnique()
+                        .HasFilter("\"IdempotencyKey\" IS NOT NULL");
+
+                    b.HasIndex("Outcome");
+
+                    b.HasIndex("Timestamp");
+
+                    b.ToTable("History");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.ActivityHistory.ProcessExecutionLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Arguments")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DurationMs")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ExitCode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Source")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Stderr")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Stdout")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("TimedOut")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ProcessExecutionLogs");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.Audiobook", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Abridged")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("Added")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Asin")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AuthorAsins")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Authors")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("BasePath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Edition")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Explicit")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FilePath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long?>("FileSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Genres")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ImageUrl")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Isbn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastSearchTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Monitored")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Narrators")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OpenLibraryId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PublishYear")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PublishedDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Publisher")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Quality")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("QualityProfileId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Runtime")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Series")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Subtitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tags")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LastSearchTime");
+
+                    b.HasIndex("Monitored");
+
+                    b.HasIndex("QualityProfileId");
+
+                    b.ToTable("Audiobooks");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.AudiobookDeletionIntent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AudiobookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("DeleteFolder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Error")
+                        .HasMaxLength(2048)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AudiobookId")
+                        .IsUnique()
+                        .HasFilter("\"State\" <> 'Completed'");
+
+                    b.HasIndex("UpdatedAt");
+
+                    b.HasIndex("AudiobookId", "State");
+
+                    b.ToTable("AudiobookDeletionIntents", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.AudiobookExternalIdentifier", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudiobookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Region")
+                        .HasMaxLength(8)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ValueNormalized")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ValueRaw")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AudiobookId");
+
+                    b.HasIndex("Type", "ValueNormalized");
+
+                    b.HasIndex("AudiobookId", "Type", "IsPrimary");
+
+                    b.HasIndex("Type", "ValueNormalized", "Region");
+
+                    b.ToTable("AudiobookExternalIdentifiers", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.AudiobookFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudiobookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Bitrate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CanonicalPath")
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Channels")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Container")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<double?>("DurationSeconds")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("Format")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathCaseSensitivity")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("Unknown");
+
+                    b.Property<string>("PathCaseSensitivityMode")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("Auto");
+
+                    b.Property<string>("PathIdentityBoundary")
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathIdentityLookupKey")
+                        .HasMaxLength(160)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathIdentityReason")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathIdentityState")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("Unavailable");
+
+                    b.Property<int>("PathIdentityVersion")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("PathOwnershipKey")
+                        .HasMaxLength(160)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathSyntax")
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("PhysicalIdentityObservedAtUtc")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PhysicalIdentityVersion")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("PhysicalObjectIdentity")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SampleRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long?>("Size")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Source")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AudiobookId");
+
+                    b.HasIndex("PathIdentityLookupKey");
+
+                    b.HasIndex("PathOwnershipKey")
+                        .IsUnique()
+                        .HasFilter("\"PathOwnershipKey\" IS NOT NULL");
+
+                    b.ToTable("AudiobookFiles");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.AudiobookSeriesMembership", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudiobookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SeriesAsin")
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesName")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesNumber")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AudiobookId");
+
+                    b.HasIndex("AudiobookId", "IsPrimary");
+
+                    b.HasIndex("AudiobookId", "SortOrder");
+
+                    b.ToTable("AudiobookSeriesMemberships", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.AuthorCacheEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AuthorAsin")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AuthorNameNormalized")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CatalogBooks")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ImageUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastFetchedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Region")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SimilarAuthors")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AuthorAsin", "Region");
+
+                    b.HasIndex("AuthorNameNormalized", "Region")
+                        .IsUnique();
+
+                    b.ToTable("AuthorCacheEntries");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.LibraryDirectoryOwnership", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("AudiobookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CanonicalPath")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CreationOperationId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreationWorkflow")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DirectoryObjectIdentity")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DirectoryObjectIdentityUnavailableReason")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DirectoryObjectIdentityVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ManagedRootFolderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OwnershipToken")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathCaseSensitivity")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathCaseSensitivityMode")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathIdentityBoundary")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathIdentityLookupKey")
+                        .IsRequired()
+                        .HasMaxLength(160)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathOwnershipKey")
+                        .HasMaxLength(160)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathSyntax")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("StateReason")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ManagedRootFolderId");
+
+                    b.HasIndex("OwnershipToken")
+                        .IsUnique();
+
+                    b.HasIndex("PathIdentityLookupKey");
+
+                    b.HasIndex("PathOwnershipKey")
+                        .IsUnique()
+                        .HasFilter("\"PathOwnershipKey\" IS NOT NULL");
+
+                    b.HasIndex("CreationOperationId", "State");
+
+                    b.ToTable("LibraryDirectoryOwnerships", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.LibraryDirectoryOwnershipPathMigration", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("OwnershipId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("RelocationId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceCanonicalPath")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceCaseSensitivity")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceCaseSensitivityMode")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceIdentityBoundary")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceIdentityLookupKey")
+                        .IsRequired()
+                        .HasMaxLength(160)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceOwnershipKey")
+                        .IsRequired()
+                        .HasMaxLength(160)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourcePathSyntax")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetCanonicalPath")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetCaseSensitivity")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetCaseSensitivityMode")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetIdentityBoundary")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetIdentityLookupKey")
+                        .IsRequired()
+                        .HasMaxLength(160)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetOwnershipKey")
+                        .IsRequired()
+                        .HasMaxLength(160)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetPathSyntax")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RelocationId");
+
+                    b.HasIndex("TargetOwnershipKey")
+                        .IsUnique();
+
+                    b.HasIndex("OwnershipId", "RelocationId")
+                        .IsUnique();
+
+                    b.ToTable("LibraryDirectoryOwnershipPathMigrations", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.MonitoredAuthor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AuthorAsin")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AuthorNameNormalized")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastCheckedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastSuccessfulSyncAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Region")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LastCheckedAt");
+
+                    b.HasIndex("AuthorNameNormalized", "Region", "Language")
+                        .IsUnique();
+
+                    b.ToTable("MonitoredAuthors");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.MonitoredSeries", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastCheckedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastSuccessfulSyncAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Region")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesAsin")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesNameNormalized")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LastCheckedAt");
+
+                    b.HasIndex("SeriesNameNormalized", "Region", "Language")
+                        .IsUnique();
+
+                    b.ToTable("MonitoredSeries");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.MoveJob", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ActiveDeduplicationKey")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AttemptCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudiobookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("DeleteEmptySource")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("EnqueuedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ExecutionProtocolVersion")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0);
+
+                    b.Property<string>("FailureKind")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("None");
+
+                    b.Property<int>("IdentityKeyVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LeaseExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("LeaseGeneration")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0);
+
+                    b.Property<string>("LeaseOwner")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("NextAttemptAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Phase")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("None");
+
+                    b.Property<Guid?>("RelocationId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RequestedPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceCaseSensitivity")
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceCaseSensitivityMode")
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceCleanupBoundary")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceDirectoryCleanupState")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(24)
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("Pending");
+
+                    b.Property<string>("SourceDirectoryObjectIdentity")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceIdentityBoundary")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourcePath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourcePathSyntax")
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetCaseSensitivity")
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetCaseSensitivityMode")
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetDirectoryObjectIdentity")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetIdentityBoundary")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetPathSyntax")
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActiveDeduplicationKey")
+                        .IsUnique()
+                        .HasFilter("\"ActiveDeduplicationKey\" IS NOT NULL");
+
+                    b.HasIndex("RelocationId");
+
+                    b.HasIndex("AudiobookId", "Status");
+
+                    b.HasIndex("Status", "NextAttemptAt", "LeaseExpiresAt");
+
+                    b.ToTable("MoveJobs");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.MoveJobCreatedDirectory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("DirectoryObjectIdentity")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("MoveJobId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MoveJobId", "Path")
+                        .IsUnique();
+
+                    b.ToTable("MoveJobCreatedDirectories", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.MoveJobEntry", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CleanupProtectionVersion")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0);
+
+                    b.Property<string>("CleanupState")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CopyState")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EntryType")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastWriteTimeUtc")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("Length")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("MoveJobId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Sha256")
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourcePhysicalObjectIdentity")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetPhysicalObjectIdentity")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MoveJobId", "RelativePath")
+                        .IsUnique();
+
+                    b.ToTable("MoveJobEntries", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.MoveScanHandoff", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ActiveScanJobId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AttemptGeneration")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudiobookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(4000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LeaseExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("LeaseGeneration")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("LeaseOwner")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("MoveJobId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("NextAttemptAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetPath")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MoveJobId")
+                        .IsUnique();
+
+                    b.HasIndex("Status", "NextAttemptAt", "LeaseExpiresAt");
+
+                    b.ToTable("MoveScanHandoffs", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.QualityProfile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CustomGroupNames")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("CustomGroupNames");
+
+                    b.Property<string>("CutoffQuality")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaximumAge")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaximumSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MinimumScore")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MinimumSeeders")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MinimumSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MustContain")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("MustContain");
+
+                    b.Property<string>("MustNotContain")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("MustNotContain");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PreferNewerReleases")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PreferredFormats")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("PreferredFormats");
+
+                    b.Property<string>("PreferredLanguages")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("PreferredLanguages");
+
+                    b.PrimitiveCollection<string>("PreferredWords")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Qualities")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("Qualities");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("QualityProfiles");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.RootFolder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CaseSensitivityMode")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("Auto");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<string>("DirectoryObjectIdentity")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DirectoryObjectIdentityUnavailableReason")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DirectoryObjectIdentityVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsDefault")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathIdentityKey")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PathIdentityState")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("Unavailable");
+
+                    b.Property<string>("ResolvedCaseSensitivity")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("Unknown");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsDefault")
+                        .IsUnique()
+                        .HasDatabaseName("IX_RootFolders_SingleDefault")
+                        .HasFilter("\"IsDefault\" = 1");
+
+                    b.HasIndex("Name");
+
+                    b.HasIndex("Path")
+                        .IsUnique();
+
+                    b.HasIndex("PathIdentityKey")
+                        .IsUnique()
+                        .HasFilter("\"PathIdentityKey\" IS NOT NULL");
+
+                    b.ToTable("RootFolders", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.RootFolderRelocation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ActiveRootFolderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("CompletedJobs")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("DeleteEmptySource")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("DesiredIsDefault")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("DesiredName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Error")
+                        .HasMaxLength(4000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Mode")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("RootFolderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SourceCaseSensitivityMode")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("Auto");
+
+                    b.Property<string>("SourcePath")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetCaseSensitivityMode")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetDirectoryObjectIdentity")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetDirectoryObjectIdentityUnavailableReason")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TargetDirectoryObjectIdentityVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("TargetIdentityEnrollmentState")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(24)
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("Authorized");
+
+                    b.Property<string>("TargetPath")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TotalJobs")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActiveRootFolderId")
+                        .IsUnique()
+                        .HasFilter("\"ActiveRootFolderId\" IS NOT NULL");
+
+                    b.HasIndex("RootFolderId");
+
+                    b.ToTable("RootFolderRelocations", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.RootFolderRelocationCreatedDirectory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CanonicalPath")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DirectoryObjectIdentity")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DirectoryObjectIdentityVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OwnershipToken")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("RelocationId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OwnershipToken")
+                        .IsUnique();
+
+                    b.HasIndex("RelocationId", "CanonicalPath")
+                        .IsUnique();
+
+                    b.ToTable("RootFolderRelocationCreatedDirectories", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.RootFolderRelocationSkippedItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AudiobookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("RelocationId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RelocationId", "AudiobookId")
+                        .IsUnique();
+
+                    b.ToTable("RootFolderRelocationSkippedItems", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.SeriesCacheEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CatalogBooks")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ImageUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastFetchedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Region")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesAsin")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesNameNormalized")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeriesAsin", "Region");
+
+                    b.HasIndex("SeriesNameNormalized", "Region")
+                        .IsUnique();
+
+                    b.ToTable("SeriesCacheEntries");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Configuration.ApiConfiguration", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApiKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Headers")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("HeadersJson");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastUsed")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Parameters")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ParametersJson");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("RateLimitPerMinute")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApiConfigurations");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Configuration.ApplicationSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AllowedFileExtensions")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AudnexusApiUrl")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("CompletedFileAction")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("DefaultSearchLanguage")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DefaultSearchRegion")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DiscordApplicationId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DiscordBotAvatar")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("DiscordBotEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("DiscordBotToken")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DiscordBotUsername")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DiscordChannelId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DiscordCommandGroupName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DiscordCommandSubcommandName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DiscordGuildId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("DownloadCompletionStabilitySeconds")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableAmazonSearch")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableAudibleSearch")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableCoverArtDownload")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableMetadataProcessing")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableNotifications")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableOpenLibrarySearch")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("EnabledNotificationTriggers")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("ExtractArchives")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("FailedDownloadAutoSearch")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("FailedDownloadHandlingEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FileNamingPattern")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FolderNamingPattern")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("HistoryRetentionDays")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ImportBlacklistExtensions")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MaxConcurrentDownloads")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MissingSourceMaxRetries")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MissingSourceRetryInitialDelaySeconds")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MultiFileNamingPattern")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OutputPath")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PollingIntervalSeconds")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ProwlarrApiKeyEncrypted")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ProwlarrPort")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ProwlarrTagFilter")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProwlarrUrl")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("ShowCompletedExternalDownloads")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("UnmatchedScanConcurrency")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Version")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("WebhookUrl")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Webhooks")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApplicationSettings");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Downloads.Download", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ActiveAudiobookDeduplicationKey")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Album")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Artist")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Asin")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("AudiobookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DownloadClientId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DownloadPath")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("DownloadedSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long?>("ExpectedFileSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FinalPath")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("HistoryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ImportAttempts")
+                        .HasColumnType("INTEGER");
+
+                    b.PrimitiveCollection<string>("ImportBlockMessages")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ImportBlockReason")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Isbn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastImportedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Metadata")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("Metadata");
+
+                    b.Property<string>("OriginalUrl")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Progress")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Publisher")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Runtime")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Series")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("TotalSize")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActiveAudiobookDeduplicationKey")
+                        .IsUnique()
+                        .HasFilter("\"ActiveAudiobookDeduplicationKey\" IS NOT NULL");
+
+                    b.HasIndex("CompletedAt");
+
+                    b.HasIndex("DownloadClientId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("Downloads");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Downloads.DownloadClientConfiguration", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DownloadPath")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Host")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Port")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("RemoveCompletedDownloads")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Settings")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("SettingsJson");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("UseSSL")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DownloadClientConfigurations");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Downloads.DownloadProcessingJob", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ActiveDeduplicationKey")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DownloadClientId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DownloadId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("JobData")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("JobData");
+
+                    b.Property<int>("JobType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaxRetries")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("NextRetryAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("INTEGER");
+
+                    b.PrimitiveCollection<string>("ProcessingLog")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SourcePath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActiveDeduplicationKey")
+                        .IsUnique()
+                        .HasFilter("\"ActiveDeduplicationKey\" IS NOT NULL");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("DownloadId", "Status");
+
+                    b.ToTable("DownloadProcessingJobs");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Downloads.FileMutationJournal", b =>
+                {
+                    b.Property<Guid>("OperationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("AudiobookFileId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("AudiobookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationParentDirectoryObjectIdentity")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationPath")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Error")
+                        .HasMaxLength(2048)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProtocolVersion")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1);
+
+                    b.Property<long>("SourceLength")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SourceParentDirectoryObjectIdentity")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourcePath")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourcePhysicalObjectIdentity")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceSha256")
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetPhysicalObjectIdentity")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("OperationId");
+
+                    b.HasIndex("State");
+
+                    b.HasIndex("UpdatedAt");
+
+                    b.ToTable("FileMutationJournals", (string)null);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Downloads.RemotePathMapping", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DownloadClientId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LocalPath")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RemotePath")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RemotePathMappings");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Identity.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsAdmin")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Identity.UserSession", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsAdmin")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastAccessed")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("RememberMe")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExpiresAt");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.HasIndex("Username");
+
+                    b.ToTable("UserSessions");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Search.Indexer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AdditionalSettings")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnimeCategories")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApiKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Categories")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EnableAnimeStandardSearch")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableAutomaticSearch")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableInteractiveSearch")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableRss")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Implementation")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("LastTestError")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool?>("LastTestSuccessful")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastTestedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MaximumSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MinimumAge")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Retention")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Tags")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Indexers");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.Audiobook", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.QualityProfile", "QualityProfile")
+                        .WithMany()
+                        .HasForeignKey("QualityProfileId");
+
+                    b.Navigation("QualityProfile");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.AudiobookExternalIdentifier", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.Audiobook", null)
+                        .WithMany("ExternalIdentifiers")
+                        .HasForeignKey("AudiobookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.AudiobookFile", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.Audiobook", "Audiobook")
+                        .WithMany("Files")
+                        .HasForeignKey("AudiobookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Audiobook");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.AudiobookSeriesMembership", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.Audiobook", "Audiobook")
+                        .WithMany("SeriesMemberships")
+                        .HasForeignKey("AudiobookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Audiobook");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.LibraryDirectoryOwnership", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.RootFolder", null)
+                        .WithMany()
+                        .HasForeignKey("ManagedRootFolderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.LibraryDirectoryOwnershipPathMigration", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.LibraryDirectoryOwnership", "Ownership")
+                        .WithMany("PathMigrations")
+                        .HasForeignKey("OwnershipId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Listenarr.Domain.Audiobooks.RootFolderRelocation", "Relocation")
+                        .WithMany("OwnershipPathMigrations")
+                        .HasForeignKey("RelocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Ownership");
+
+                    b.Navigation("Relocation");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.MoveJob", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.RootFolderRelocation", "Relocation")
+                        .WithMany("MoveJobs")
+                        .HasForeignKey("RelocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Relocation");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.MoveJobCreatedDirectory", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.MoveJob", "MoveJob")
+                        .WithMany("CreatedDirectories")
+                        .HasForeignKey("MoveJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MoveJob");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.MoveJobEntry", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.MoveJob", "MoveJob")
+                        .WithMany("Entries")
+                        .HasForeignKey("MoveJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MoveJob");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.MoveScanHandoff", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.MoveJob", "MoveJob")
+                        .WithOne("ScanHandoff")
+                        .HasForeignKey("Listenarr.Domain.Audiobooks.MoveScanHandoff", "MoveJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MoveJob");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.RootFolderRelocation", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.RootFolder", "RootFolder")
+                        .WithMany("Relocations")
+                        .HasForeignKey("RootFolderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("RootFolder");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.RootFolderRelocationCreatedDirectory", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.RootFolderRelocation", "Relocation")
+                        .WithMany("CreatedDirectories")
+                        .HasForeignKey("RelocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Relocation");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.RootFolderRelocationSkippedItem", b =>
+                {
+                    b.HasOne("Listenarr.Domain.Audiobooks.RootFolderRelocation", "Relocation")
+                        .WithMany("SkippedItems")
+                        .HasForeignKey("RelocationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Relocation");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.Audiobook", b =>
+                {
+                    b.Navigation("ExternalIdentifiers");
+
+                    b.Navigation("Files");
+
+                    b.Navigation("SeriesMemberships");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.LibraryDirectoryOwnership", b =>
+                {
+                    b.Navigation("PathMigrations");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.MoveJob", b =>
+                {
+                    b.Navigation("CreatedDirectories");
+
+                    b.Navigation("Entries");
+
+                    b.Navigation("ScanHandoff");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.RootFolder", b =>
+                {
+                    b.Navigation("Relocations");
+                });
+
+            modelBuilder.Entity("Listenarr.Domain.Audiobooks.RootFolderRelocation", b =>
+                {
+                    b.Navigation("CreatedDirectories");
+
+                    b.Navigation("MoveJobs");
+
+                    b.Navigation("OwnershipPathMigrations");
+
+                    b.Navigation("SkippedItems");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/listenarr.infrastructure/Persistence/Migrations/20260820015101_AddAudiobookAddedDate.cs b/listenarr.infrastructure/Persistence/Migrations/20260820015101_AddAudiobookAddedDate.cs
new file mode 100644
index 000000000..dc3a2d3db
--- /dev/null
+++ b/listenarr.infrastructure/Persistence/Migrations/20260820015101_AddAudiobookAddedDate.cs
@@ -0,0 +1,29 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Listenarr.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddAudiobookAddedDate : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTime>(
+                name: "Added",
+                table: "Audiobooks",
+                type: "TEXT",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Added",
+                table: "Audiobooks");
+        }
+    }
+}
diff --git a/listenarr.infrastructure/Persistence/Migrations/ListenArrDbContextModelSnapshot.cs b/listenarr.infrastructure/Persistence/Migrations/ListenArrDbContextModelSnapshot.cs
index f4a49242a..b0740b2bd 100644
--- a/listenarr.infrastructure/Persistence/Migrations/ListenArrDbContextModelSnapshot.cs
+++ b/listenarr.infrastructure/Persistence/Migrations/ListenArrDbContextModelSnapshot.cs
@@ -178,7 +178,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("Timestamp");
 
-                    b.ToTable("History", (string)null);
+                    b.ToTable("History");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.ActivityHistory.ProcessExecutionLog", b =>
@@ -216,7 +216,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
-                    b.ToTable("ProcessExecutionLogs", (string)null);
+                    b.ToTable("ProcessExecutionLogs");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Audiobooks.Audiobook", b =>
@@ -228,6 +228,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<bool>("Abridged")
                         .HasColumnType("INTEGER");
 
+                    b.Property<DateTime?>("Added")
+                        .HasColumnType("TEXT");
+
                     b.Property<string>("Asin")
                         .HasColumnType("TEXT");
 
@@ -323,7 +326,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("QualityProfileId");
 
-                    b.ToTable("Audiobooks", (string)null);
+                    b.ToTable("Audiobooks");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Audiobooks.AudiobookDeletionIntent", b =>
@@ -535,7 +538,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsUnique()
                         .HasFilter("\"PathOwnershipKey\" IS NOT NULL");
 
-                    b.ToTable("AudiobookFiles", (string)null);
+                    b.ToTable("AudiobookFiles");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Audiobooks.AudiobookSeriesMembership", b =>
@@ -630,7 +633,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.HasIndex("AuthorNameNormalized", "Region")
                         .IsUnique();
 
-                    b.ToTable("AuthorCacheEntries", (string)null);
+                    b.ToTable("AuthorCacheEntries");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Audiobooks.LibraryDirectoryOwnership", b =>
@@ -895,7 +898,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.HasIndex("AuthorNameNormalized", "Region", "Language")
                         .IsUnique();
 
-                    b.ToTable("MonitoredAuthors", (string)null);
+                    b.ToTable("MonitoredAuthors");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Audiobooks.MonitoredSeries", b =>
@@ -951,7 +954,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.HasIndex("SeriesNameNormalized", "Region", "Language")
                         .IsUnique();
 
-                    b.ToTable("MonitoredSeries", (string)null);
+                    b.ToTable("MonitoredSeries");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Audiobooks.MoveJob", b =>
@@ -1096,7 +1099,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("Status", "NextAttemptAt", "LeaseExpiresAt");
 
-                    b.ToTable("MoveJobs", (string)null);
+                    b.ToTable("MoveJobs");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Audiobooks.MoveJobCreatedDirectory", b =>
@@ -1330,7 +1333,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
-                    b.ToTable("QualityProfiles", (string)null);
+                    b.ToTable("QualityProfiles");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Audiobooks.RootFolder", b =>
@@ -1647,7 +1650,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.HasIndex("SeriesNameNormalized", "Region")
                         .IsUnique();
 
-                    b.ToTable("SeriesCacheEntries", (string)null);
+                    b.ToTable("SeriesCacheEntries");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Configuration.ApiConfiguration", b =>
@@ -1698,7 +1701,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
-                    b.ToTable("ApiConfigurations", (string)null);
+                    b.ToTable("ApiConfigurations");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Configuration.ApplicationSettings", b =>
@@ -1853,7 +1856,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
-                    b.ToTable("ApplicationSettings", (string)null);
+                    b.ToTable("ApplicationSettings");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Downloads.Download", b =>
@@ -1972,7 +1975,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("Status");
 
-                    b.ToTable("Downloads", (string)null);
+                    b.ToTable("Downloads");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Downloads.DownloadClientConfiguration", b =>
@@ -2027,7 +2030,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
-                    b.ToTable("DownloadClientConfigurations", (string)null);
+                    b.ToTable("DownloadClientConfigurations");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Downloads.DownloadProcessingJob", b =>
@@ -2101,7 +2104,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("DownloadId", "Status");
 
-                    b.ToTable("DownloadProcessingJobs", (string)null);
+                    b.ToTable("DownloadProcessingJobs");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Downloads.FileMutationJournal", b =>
@@ -2215,7 +2218,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
-                    b.ToTable("RemotePathMappings", (string)null);
+                    b.ToTable("RemotePathMappings");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Identity.User", b =>
@@ -2243,7 +2246,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
-                    b.ToTable("Users", (string)null);
+                    b.ToTable("Users");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Identity.UserSession", b =>
@@ -2286,7 +2289,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("Username");
 
-                    b.ToTable("UserSessions", (string)null);
+                    b.ToTable("UserSessions");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Search.Indexer", b =>
@@ -2370,7 +2373,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
-                    b.ToTable("Indexers", (string)null);
+                    b.ToTable("Indexers");
                 });
 
             modelBuilder.Entity("Listenarr.Domain.Audiobooks.Audiobook", b =>
diff --git a/tests/Features/Api/Features/Library/LibraryController_LibraryListSlimPayloadTests.cs b/tests/Features/Api/Features/Library/LibraryController_LibraryListSlimPayloadTests.cs
index 466ac91d8..e12b15a73 100644
--- a/tests/Features/Api/Features/Library/LibraryController_LibraryListSlimPayloadTests.cs
+++ b/tests/Features/Api/Features/Library/LibraryController_LibraryListSlimPayloadTests.cs
@@ -87,6 +87,10 @@ await _downloadRepository.AddAsync(new DownloadBuilder()
             Assert.Equal(book.FilePath, item.GetProperty("filePath").GetString());
             Assert.Equal(book.FileSize, item.GetProperty("fileSize").GetInt64());
             Assert.Equal(1, item.GetProperty("fileCount").GetInt32());
+            Assert.True(item.TryGetProperty("added", out var added));
+            Assert.NotNull(book.Added);
+            Assert.Equal(book.Added.Value, added.GetDateTime());
+            Assert.EndsWith("Z", added.GetString(), StringComparison.Ordinal);
 
             Assert.False(item.TryGetProperty("files", out _));
             Assert.False(item.TryGetProperty("description", out _));
diff --git a/tests/Features/Api/Models/AudiobookDtoFactoryTests.cs b/tests/Features/Api/Models/AudiobookDtoFactoryTests.cs
index eab254e01..bfb84fe59 100644
--- a/tests/Features/Api/Models/AudiobookDtoFactoryTests.cs
+++ b/tests/Features/Api/Models/AudiobookDtoFactoryTests.cs
@@ -32,9 +32,11 @@ public async Task BuildFromEntity_MapsFieldsAndFiles_AndComputesWanted()
 
             using var db = new ListenArrDbContext(options);
 
+            var added = new DateTime(2026, 8, 19, 18, 30, 0, DateTimeKind.Utc);
             var book = new Audiobook
             {
                 Title = "Factory Book",
+                Added = added,
                 Authors = new System.Collections.Generic.List<string> { "Author One" },
                 Edition = "Collector's Edition",
                 Series = "Primary Series",
@@ -78,6 +80,7 @@ public async Task BuildFromEntity_MapsFieldsAndFiles_AndComputesWanted()
             Assert.Equal(book.Title, dto.Title);
             Assert.Contains("Author One", dto.Authors ?? new string[] { });
             Assert.Equal(book.Edition, dto.Edition);
+            Assert.Equal(added, dto.Added);
             Assert.Equal(book.BasePath, dto.BasePath);
             Assert.NotNull(dto.SeriesMemberships);
             Assert.Equal(2, dto.SeriesMemberships!.Length);
diff --git a/tests/Features/Infrastructure/DependencyInjection/InfrastructureStartupCompositionExtensionsTests.cs b/tests/Features/Infrastructure/DependencyInjection/InfrastructureStartupCompositionExtensionsTests.cs
index a4f19b352..8f025074b 100644
--- a/tests/Features/Infrastructure/DependencyInjection/InfrastructureStartupCompositionExtensionsTests.cs
+++ b/tests/Features/Infrastructure/DependencyInjection/InfrastructureStartupCompositionExtensionsTests.cs
@@ -109,6 +109,81 @@ public void ApplyListenarrDatabaseMigrations_NormalizesLegacyCanaryDataBeforeCon
             "UPDATE \"RootFolders\" SET \"IsDefault\" = 1 WHERE \"Id\" = 20"));
     }
 
+    [Fact]
+    [Trait("Scenario", "AudiobookAddedDateBackfill")]
+    public void ApplyListenarrDatabaseMigrations_BackfillsAudiobookAddedDateFromBestAvailableEvidence()
+    {
+        using var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        var options = new DbContextOptionsBuilder<ListenArrDbContext>()
+            .UseSqlite(connection, sqlite =>
+                sqlite.MigrationsAssembly(typeof(ListenArrDbContext).Assembly.GetName().Name))
+            .Options;
+        var historyAddedAt = new DateTime(2025, 5, 4, 12, 30, 0, DateTimeKind.Utc);
+        var laterHistoryAddedAt = historyAddedAt.AddDays(2);
+        var misleadingEarlierFileAt = historyAddedAt.AddYears(-1);
+        var fileAddedAt = new DateTime(2025, 7, 8, 9, 15, 0, DateTimeKind.Utc);
+        var laterFileAddedAt = fileAddedAt.AddHours(3);
+        const int historyBookId = 910001;
+        const int fileBookId = 910002;
+        const int unknownBookId = 910003;
+
+        using (var baseline = new ListenArrDbContext(options))
+        {
+            baseline.GetService<IMigrator>().Migrate(
+                "20260818132300_AddFileMutationParentGenerationProofs");
+            baseline.Database.ExecuteSqlInterpolated($"""
+                INSERT INTO "Audiobooks" ("Id", "Title", "Explicit", "Abridged", "Monitored")
+                VALUES
+                    ({historyBookId}, {"History Book"}, {false}, {false}, {true}),
+                    ({fileBookId}, {"File Book"}, {false}, {false}, {true}),
+                    ({unknownBookId}, {"Unknown Book"}, {false}, {false}, {true});
+                """);
+            baseline.Database.ExecuteSqlInterpolated($"""
+                INSERT INTO "History" (
+                    "AudiobookId", "AudiobookTitle", "EventType", "Timestamp",
+                    "NotificationSent", "Outcome", "CorrelationId")
+                VALUES
+                    ({historyBookId}, {"History Book"}, {"Added"}, {laterHistoryAddedAt},
+                     {false}, {(int)HistoryOutcome.Succeeded}, {Guid.NewGuid().ToString("N")}),
+                    ({historyBookId}, {"History Book"}, {"Added"}, {historyAddedAt},
+                     {false}, {(int)HistoryOutcome.Succeeded}, {Guid.NewGuid().ToString("N")});
+                """);
+            baseline.Database.ExecuteSqlInterpolated($"""
+                INSERT INTO "AudiobookFiles" ("AudiobookId", "CreatedAt")
+                VALUES
+                    ({historyBookId}, {misleadingEarlierFileAt}),
+                    ({fileBookId}, {laterFileAddedAt}),
+                    ({fileBookId}, {fileAddedAt});
+                """);
+        }
+
+        var services = new ServiceCollection();
+        services.AddDbContextFactory<ListenArrDbContext>(builder =>
+            builder.UseSqlite(connection, sqlite =>
+                sqlite.MigrationsAssembly(typeof(ListenArrDbContext).Assembly.GetName().Name)));
+        using var provider = services.BuildServiceProvider();
+
+        provider.ApplyListenarrDatabaseMigrations();
+        provider.ApplyListenarrDatabaseMigrations();
+
+        using var verified = provider
+            .GetRequiredService<IDbContextFactory<ListenArrDbContext>>()
+            .CreateDbContext();
+        var historyBook = verified.Audiobooks.AsNoTracking()
+            .Single(book => book.Id == historyBookId);
+        var fileBook = verified.Audiobooks.AsNoTracking()
+            .Single(book => book.Id == fileBookId);
+        var unknownBook = verified.Audiobooks.AsNoTracking()
+            .Single(book => book.Id == unknownBookId);
+
+        Assert.Equal(historyAddedAt, historyBook.Added);
+        Assert.Equal(DateTimeKind.Utc, historyBook.Added!.Value.Kind);
+        Assert.Equal(fileAddedAt, fileBook.Added);
+        Assert.Equal(DateTimeKind.Utc, fileBook.Added!.Value.Kind);
+        Assert.Null(unknownBook.Added);
+    }
+
     [Fact]
     [Trait("Scenario", "RepeatedMigrationStartup")]
     public void ApplyListenarrDatabaseMigrations_RepeatedStartupPreservesCurrentMoveIdentity()
diff --git a/tests/Features/Infrastructure/Migrations/MigrationMetadataTests.cs b/tests/Features/Infrastructure/Migrations/MigrationMetadataTests.cs
index 3fb801308..7313d6174 100644
--- a/tests/Features/Infrastructure/Migrations/MigrationMetadataTests.cs
+++ b/tests/Features/Infrastructure/Migrations/MigrationMetadataTests.cs
@@ -173,6 +173,36 @@ public void AddFileMutationParentGenerationProofs_IsDiscoverableAndIsolated()
         Assert.Empty(downBuilder.Operations.OfType<AlterColumnOperation>());
     }
 
+    [Fact]
+    public void AddAudiobookAddedDate_IsDiscoverableAndSchemaOnly()
+    {
+        AssertMigrationId<AddAudiobookAddedDate>(
+            "20260820015101_AddAudiobookAddedDate");
+
+        var migration = new AddAudiobookAddedDate();
+        var upBuilder = BuildOperations(migration, "Up");
+        var downBuilder = BuildOperations(migration, "Down");
+
+        var addition = Assert.Single(upBuilder.Operations.OfType<AddColumnOperation>());
+        Assert.Equal("Added", addition.Name);
+        Assert.Equal("Audiobooks", addition.Table);
+        Assert.Equal(typeof(DateTime), addition.ClrType);
+        Assert.True(addition.IsNullable);
+
+        Assert.Single(upBuilder.Operations);
+        Assert.Empty(upBuilder.Operations.OfType<SqlOperation>());
+
+        var removal = Assert.Single(downBuilder.Operations.OfType<DropColumnOperation>());
+        Assert.Equal("Added", removal.Name);
+        Assert.Equal("Audiobooks", removal.Table);
+        Assert.Single(downBuilder.Operations);
+
+        var audiobook = AssertEntity(
+            migration.TargetModel,
+            "Listenarr.Domain.Audiobooks.Audiobook");
+        Assert.True(audiobook.FindProperty("Added")?.IsNullable);
+    }
+
     [Fact]
     public void FinalMoveMigration_TargetModelMatchesFinalContracts()
     {
diff --git a/tests/Features/Infrastructure/Migrations/ReleasedSchemaUpgradeTests.cs b/tests/Features/Infrastructure/Migrations/ReleasedSchemaUpgradeTests.cs
index 7182157c8..d98762ca1 100644
--- a/tests/Features/Infrastructure/Migrations/ReleasedSchemaUpgradeTests.cs
+++ b/tests/Features/Infrastructure/Migrations/ReleasedSchemaUpgradeTests.cs
@@ -16,6 +16,48 @@ namespace Listenarr.Tests.Features.Infrastructure.Migrations;
 
 public sealed class ReleasedSchemaUpgradeTests
 {
+    [Fact]
+    public async Task PreviousSchema_AddsNullableAudiobookAddedDateWithoutInventingHistory()
+    {
+        var databasePath = Path.Join(
+            Path.GetTempPath(),
+            "listenarr-tests",
+            $"audiobook-added-upgrade-{Guid.NewGuid():N}.db");
+        Directory.CreateDirectory(Path.GetDirectoryName(databasePath)!);
+        var options = new DbContextOptionsBuilder<ListenArrDbContext>()
+            .UseSqlite($"Data Source={databasePath};Pooling=False")
+            .Options;
+        const int legacyBookId = 910001;
+
+        try
+        {
+            await using (var db = new ListenArrDbContext(options))
+            {
+                var migrator = db.GetService<IMigrator>();
+                await migrator.MigrateAsync("20260818132300_AddFileMutationParentGenerationProofs");
+                await db.Database.ExecuteSqlInterpolatedAsync($"""
+                    INSERT INTO "Audiobooks" ("Id", "Title", "Explicit", "Abridged", "Monitored")
+                    VALUES ({legacyBookId}, {"Legacy Book"}, {false}, {false}, {true});
+                    """);
+                await migrator.MigrateAsync();
+            }
+
+            await using var verified = new ListenArrDbContext(options);
+            var legacyBook = await verified.Audiobooks.AsNoTracking()
+                .SingleAsync(book => book.Id == legacyBookId);
+
+            Assert.Null(legacyBook.Added);
+            Assert.Empty(await verified.Database.GetPendingMigrationsAsync());
+        }
+        finally
+        {
+            if (File.Exists(databasePath))
+            {
+                File.Delete(databasePath);
+            }
+        }
+    }
+
     [Fact]
     public async Task PreviousMoveSchema_PreservesLegacyJournalProtocolAndDefaultsNewRowsToCurrent()
     {
diff --git a/tests/Features/Infrastructure/Persistence/SqliteMigrationSchemaTests.cs b/tests/Features/Infrastructure/Persistence/SqliteMigrationSchemaTests.cs
index 0d11d21a5..e7a3f85b9 100644
--- a/tests/Features/Infrastructure/Persistence/SqliteMigrationSchemaTests.cs
+++ b/tests/Features/Infrastructure/Persistence/SqliteMigrationSchemaTests.cs
@@ -38,6 +38,8 @@ public class SqliteMigrationSchemaTests : BaseTests
         "20260810160640_AddMoveJobRelocationForeignKey";
     private const string FileMutationParentGenerationProofsMigrationId =
         "20260818132300_AddFileMutationParentGenerationProofs";
+    private const string AudiobookAddedDateMigrationId =
+        "20260820015101_AddAudiobookAddedDate";
 
     private static (SqliteConnection Connection, ListenArrDbContext Context)
         CreateMigratedSqliteContext()
@@ -161,7 +163,8 @@ public async Task MigrationHistory_ContainsOnlyRetainedRepairsAndConsolidatedPrM
                 ProcessExecutionLogRepairId,
                 ConsolidatedMigrationId,
                 MoveJobRelocationForeignKeyMigrationId,
-                FileMutationParentGenerationProofsMigrationId
+                FileMutationParentGenerationProofsMigrationId,
+                AudiobookAddedDateMigrationId
             ],
             postCanary);
         Assert.Contains("20251124102000_AddMoveJobSourcePath", applied);