diff --git a/docs/superpowers/specs/2026-06-08-local-txt-books-design.md b/docs/superpowers/specs/2026-06-08-local-txt-books-design.md
new file mode 100644
index 0000000..0772cd2
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-08-local-txt-books-design.md
@@ -0,0 +1,123 @@
+# 本地 TXT 小说服务端书架导入设计
+
+## 目标
+
+允许用户上传本地 `.txt` 小说到服务端书架。上传后小说像普通书籍一样出现在书架里，可打开阅读、查看目录、保存阅读进度，并能在同一服务端账号下跨设备读取。
+
+## 推荐方案
+
+采用“服务端本地书籍”方案：
+
+1. 前端提供上传 `.txt` 文件入口。
+2. 后端接收文件，校验扩展名和内容大小。
+3. 后端把原始文本保存到 `storage/local_books/`。
+4. 后端解析章节并保存章节索引。
+5. 后端创建或更新一个书架 `Book`，使用本地协议标识：`local-txt:<hash>`。
+6. 现有阅读器通过新增本地 TXT 分支读取目录和章节内容。
+
+## 数据模型
+
+本地 TXT 书籍复用现有 `Book` 和 `BookChapter`：
+
+- `Book.bookUrl`: `local-txt:<hash>`
+- `Book.origin`: `local-txt`
+- `Book.originName`: `本地 TXT`
+- `Book.canUpdate`: `false`
+- `Book.totalChapterNum`: 解析出的章节数量
+- `Book.latestChapterTitle`: 最后一章标题
+- `Book.name`: 文件名去扩展名，后续可支持用户编辑
+- `Book.author`: 默认 `本地导入`
+
+本地文件存储建议：
+
+```text
+storage/local_books/<hash>/book.txt
+storage/local_books/<hash>/chapters.json
+```
+
+`chapters.json` 记录每章标题、章节序号、正文起止字节或字符区间。实现优先选择字符区间，简单稳定。
+
+## 章节解析规则
+
+章节标题按常见中文小说格式识别：
+
+- `第十二章 标题`
+- `第12章 标题`
+- `第十二回 标题`
+- `第12节 标题`
+- `卷一 标题`
+
+规则要求：
+
+- 标题必须出现在单独一行。
+- 标题行长度限制在 80 个字符以内，避免误切正文。
+- 识别不到章节时，把整本书作为 `正文` 一章。
+- 每章内容保留原文本换行。
+
+## 后端接口
+
+新增接口：
+
+```http
+POST /reader3/uploadTxtBook
+Content-Type: multipart/form-data
+field: file
+```
+
+返回上传后创建的 `Book`。
+
+后端阅读分支：
+
+- 获取目录时，如果 `bookSourceUrl/origin` 是 `local-txt`，读取 `chapters.json`。
+- 获取正文时，如果章节 URL 是 `local-txt:<hash>#<index>`，读取 `book.txt` 对应区间。
+
+错误处理：
+
+- 非 `.txt`：返回 400。
+- 空文件：返回 400。
+- 文件过大：返回 400，限制由实现中的常量控制，默认 50MB。
+- 解析或保存失败：返回现有统一错误格式。
+
+## 前端交互
+
+在书架/阅读器入口提供“上传 TXT”按钮：
+
+1. 选择 `.txt` 文件。
+2. 调用 `/reader3/uploadTxtBook`。
+3. 上传成功后刷新书架。
+4. 默认打开新导入书籍的第一章。
+
+显示约束：
+
+- 上传中按钮禁用并显示“上传中”。
+- 上传失败显示现有错误提示风格。
+- 本地 TXT 书籍没有封面时继续使用现有占位封面。
+
+## 测试策略
+
+后端优先测试纯解析逻辑：
+
+- 能切分 `第1章` / `第二章`。
+- 识别不到章节时生成单章。
+- 章节 URL 使用 `local-txt:<hash>#<index>`。
+
+接口测试聚焦：
+
+- 上传 TXT 返回 Book。
+- 非 TXT 被拒绝。
+
+前端测试或构建聚焦：
+
+- API 封装存在。
+- 类型通过。
+- `npm run build` 通过。
+
+## 范围外
+
+本次不做：
+
+- EPUB/PDF/Word 导入。
+- 封面提取。
+- TXT 编码手动选择 UI。
+- 在线更新本地 TXT。
+- 删除书籍时自动物理删除本地文件。
diff --git a/frontend/src/api/bookshelf.ts b/frontend/src/api/bookshelf.ts
index dc25f4f..07fd31c 100644
--- a/frontend/src/api/bookshelf.ts
+++ b/frontend/src/api/bookshelf.ts
@@ -21,6 +21,14 @@ export function saveBooks(books: Partial<Book>[]) {
   return http.post<Book[]>('/saveBooks', books).then((r) => r.data)
 }
 
+export function uploadTxtBook(file: File) {
+  const formData = new FormData()
+  formData.append('file', file)
+  return http.post<Book>('/uploadTxtBook', formData, {
+    headers: { 'Content-Type': 'multipart/form-data' },
+  }).then((r) => r.data)
+}
+
 export function deleteBook(book: Partial<Book>) {
   return http.post<string>('/deleteBook', book).then((r) => r.data)
 }
diff --git a/frontend/src/components/BookCard.vue b/frontend/src/components/BookCard.vue
index ba93b2f..24d684d 100644
--- a/frontend/src/components/BookCard.vue
+++ b/frontend/src/components/BookCard.vue
@@ -102,6 +102,7 @@
 <script setup lang="ts">
 import { computed, ref } from 'vue'
 import { getCoverUrl } from '../api/bookshelf'
+import { isLocalTxtBook } from '../utils/localBook'
 import type { Book, SearchBook } from '../types'
 
 const props = defineProps<{
@@ -156,8 +157,8 @@ const unreadCount = computed(() => {
   return Math.max(0, b.totalChapterNum - 1 - b.durChapterIndex)
 })
 
-const browserCachedCount = computed(() => Math.max(0, asBook.value.browserCachedChapterCount || 0))
-const serverCachedCount = computed(() => Math.max(0, asBook.value.cachedChapterCount || 0))
+const browserCachedCount = computed(() => isLocalTxtBook(asBook.value) ? 0 : Math.max(0, asBook.value.browserCachedChapterCount || 0))
+const serverCachedCount = computed(() => isLocalTxtBook(asBook.value) ? 0 : Math.max(0, asBook.value.cachedChapterCount || 0))
 const latestChapterText = computed(() => {
   if (props.isSearch) {
     return asSearchBook.value.lastChapter || asBook.value.latestChapterTitle || ''
diff --git a/frontend/src/components/CacheLibraryModal.vue b/frontend/src/components/CacheLibraryModal.vue
index 28ec3a7..2545f37 100644
--- a/frontend/src/components/CacheLibraryModal.vue
+++ b/frontend/src/components/CacheLibraryModal.vue
@@ -74,6 +74,7 @@ import type { Book } from '../types'
 import { deleteBrowserBookCache, listBrowserCacheSummary } from '../utils/browserCache'
 import { cacheBookToBrowser } from '../utils/bookCache'
 import { cacheBookSSE } from '../api/cache'
+import { isLocalTxtBook } from '../utils/localBook'
 
 const props = defineProps<{
   modelValue: boolean
@@ -94,14 +95,16 @@ const mergedBooks = computed(() => {
   const serverMap = new Map(serverBooks.value.map((book) => [book.bookUrl, book.cachedChapterCount || 0]))
   const browserMap = new Map(browserSummaries.value.map((item) => [item.bookUrl, item.cachedChapterCount]))
 
-  return shelfStore.books.map((book) => ({
-    book,
-    bookUrl: book.bookUrl,
-    name: book.name,
-    author: book.author,
-    serverCachedCount: serverMap.get(book.bookUrl) || 0,
-    browserCachedCount: browserMap.get(book.bookUrl) || 0,
-  }))
+  return shelfStore.books
+    .filter((book) => !isLocalTxtBook(book))
+    .map((book) => ({
+      book,
+      bookUrl: book.bookUrl,
+      name: book.name,
+      author: book.author,
+      serverCachedCount: serverMap.get(book.bookUrl) || 0,
+      browserCachedCount: browserMap.get(book.bookUrl) || 0,
+    }))
 })
 
 const offlineReadyCount = computed(() => mergedBooks.value.filter((item) => item.browserCachedCount > 0).length)
diff --git a/frontend/src/components/reader/CacheManager.vue b/frontend/src/components/reader/CacheManager.vue
index 125d60c..f88062f 100644
--- a/frontend/src/components/reader/CacheManager.vue
+++ b/frontend/src/components/reader/CacheManager.vue
@@ -13,7 +13,7 @@
     </div>
 
     <div class="cache-body">
-      <div class="summary-grid">
+      <div v-if="!isLocalTxt" class="summary-grid">
         <div class="summary-card">
           <span class="summary-label">服务端缓存</span>
           <strong>{{ serverCachedCount }}</strong>
@@ -42,59 +42,65 @@
       </div>
 
       <div v-else class="cache-sections">
-        <div class="info-card">
-          <p>服务端缓存保存在后端存储目录；浏览器缓存保存在当前设备的 IndexedDB。断网时阅读页会优先读取浏览器已缓存章节。</p>
+        <div v-if="isLocalTxt" class="info-card">
+          <p>本地 TXT 已存放在服务端书架文件中，不需要额外缓存；阅读时会直接读取上传后的本地文件。</p>
         </div>
 
-        <section class="cache-section">
-          <div class="section-head">
-            <h4>缓存到服务端</h4>
-            <button class="link-btn" @click="refreshStats">刷新</button>
+        <template v-else>
+          <div class="info-card">
+            <p>服务端缓存保存在后端存储目录；浏览器缓存保存在当前设备的 IndexedDB。断网时阅读页会优先读取浏览器已缓存章节。</p>
           </div>
-          <div class="option-list">
-            <button class="cache-opt" @click="startServerCaching(50)">
-              <span class="label">缓存后续 50 章</span>
-              <span class="sub">适合当前追更</span>
-            </button>
-            <button class="cache-opt" @click="startServerCaching(100)">
-              <span class="label">缓存后续 100 章</span>
-              <span class="sub">中度离线阅读</span>
-            </button>
-            <button class="cache-opt primary" @click="startServerCaching(0)">
-              <span class="label">全本缓存到服务端</span>
-              <span class="sub">保存到服务器磁盘</span>
-            </button>
-            <button class="cache-opt danger" @click="clearServerCache">
-              <span class="label">清除服务端缓存</span>
-              <span class="sub">删除当前书所有服务端缓存</span>
-            </button>
-          </div>
-        </section>
 
-        <section class="cache-section">
-          <div class="section-head">
-            <h4>缓存到浏览器</h4>
-            <button class="link-btn" @click="refreshStats">刷新</button>
-          </div>
-          <div class="option-list">
-            <button class="cache-opt" @click="startBrowserCaching(50)">
-              <span class="label">缓存后续 50 章</span>
-              <span class="sub">只保留在当前浏览器</span>
-            </button>
-            <button class="cache-opt" @click="startBrowserCaching(100)">
-              <span class="label">缓存后续 100 章</span>
-              <span class="sub">适合本地离线使用</span>
-            </button>
-            <button class="cache-opt primary" @click="startBrowserCaching(0)">
-              <span class="label">全本缓存到浏览器</span>
-              <span class="sub">持久化到 IndexedDB</span>
-            </button>
-            <button class="cache-opt danger" @click="clearBrowserCache">
-              <span class="label">清除浏览器缓存</span>
-              <span class="sub">删除当前设备离线缓存</span>
-            </button>
-          </div>
-        </section>
+          <section class="cache-section">
+            <div class="section-head">
+              <h4>缓存到服务端</h4>
+              <button class="link-btn" @click="refreshStats">刷新</button>
+            </div>
+            <div class="option-list">
+              <button class="cache-opt" @click="startServerCaching(50)">
+                <span class="label">缓存后续 50 章</span>
+                <span class="sub">适合当前追更</span>
+              </button>
+              <button class="cache-opt" @click="startServerCaching(100)">
+                <span class="label">缓存后续 100 章</span>
+                <span class="sub">中度离线阅读</span>
+              </button>
+              <button class="cache-opt primary" @click="startServerCaching(0)">
+                <span class="label">全本缓存到服务端</span>
+                <span class="sub">保存到服务器磁盘</span>
+              </button>
+              <button class="cache-opt danger" @click="clearServerCache">
+                <span class="label">清除服务端缓存</span>
+                <span class="sub">删除当前书所有服务端缓存</span>
+              </button>
+            </div>
+          </section>
+
+          <section class="cache-section">
+            <div class="section-head">
+              <h4>缓存到浏览器</h4>
+              <button class="link-btn" @click="refreshStats">刷新</button>
+            </div>
+            <div class="option-list">
+              <button class="cache-opt" @click="startBrowserCaching(50)">
+                <span class="label">缓存后续 50 章</span>
+                <span class="sub">只保留在当前浏览器</span>
+              </button>
+              <button class="cache-opt" @click="startBrowserCaching(100)">
+                <span class="label">缓存后续 100 章</span>
+                <span class="sub">适合本地离线使用</span>
+              </button>
+              <button class="cache-opt primary" @click="startBrowserCaching(0)">
+                <span class="label">全本缓存到浏览器</span>
+                <span class="sub">持久化到 IndexedDB</span>
+              </button>
+              <button class="cache-opt danger" @click="clearBrowserCache">
+                <span class="label">清除浏览器缓存</span>
+                <span class="sub">删除当前设备离线缓存</span>
+              </button>
+            </div>
+          </section>
+        </template>
       </div>
     </div>
   </div>
@@ -108,6 +114,7 @@ import { cacheBookSSE } from '../../api/cache'
 import { getBookshelfWithCacheInfo, deleteBookCache } from '../../api/bookshelf'
 import { countBrowserBookCache, deleteBrowserBookCache } from '../../utils/browserCache'
 import { cacheBookToBrowser, resolveBookChapters } from '../../utils/bookCache'
+import { isLocalTxtBook } from '../../utils/localBook'
 
 const store = useReaderStore()
 const appStore = useAppStore()
@@ -119,6 +126,7 @@ const currentStatus = ref('准备中...')
 const currentChapterName = ref('')
 const serverCachedCount = ref(0)
 const browserCachedCount = ref(0)
+const isLocalTxt = computed(() => isLocalTxtBook(store.book))
 let sse: EventSource | null = null
 let browserSignal = { cancelled: false }
 
@@ -132,6 +140,11 @@ onUnmounted(() => {
 
 async function refreshStats() {
   if (!store.book) return
+  if (isLocalTxt.value) {
+    serverCachedCount.value = 0
+    browserCachedCount.value = 0
+    return
+  }
   const [serverList, browserCount] = await Promise.all([
     getBookshelfWithCacheInfo().catch(() => []),
     countBrowserBookCache(store.book.bookUrl).catch(() => 0),
@@ -142,7 +155,7 @@ async function refreshStats() {
 }
 
 function startServerCaching(count: number) {
-  if (!store.book) return
+  if (!store.book || isLocalTxt.value) return
   stopWorking()
   working.value = true
   progress.value = 0
@@ -198,7 +211,7 @@ function startServerCaching(count: number) {
 }
 
 async function startBrowserCaching(count: number) {
-  if (!store.book) return
+  if (!store.book || isLocalTxt.value) return
   stopWorking()
   browserSignal = { cancelled: false }
   working.value = true
@@ -240,14 +253,14 @@ async function startBrowserCaching(count: number) {
 }
 
 async function clearServerCache() {
-  if (!store.book) return
+  if (!store.book || isLocalTxt.value) return
   await deleteBookCache(store.book.bookUrl)
   appStore.showToast('服务端缓存已清除', 'success')
   await refreshStats()
 }
 
 async function clearBrowserCache() {
-  if (!store.book) return
+  if (!store.book || isLocalTxt.value) return
   await deleteBrowserBookCache(store.book.bookUrl)
   appStore.showToast('浏览器缓存已清除', 'success')
   await refreshStats()
diff --git a/frontend/src/components/reader/ReaderCatalog.vue b/frontend/src/components/reader/ReaderCatalog.vue
index 15bdda2..8e849c1 100644
--- a/frontend/src/components/reader/ReaderCatalog.vue
+++ b/frontend/src/components/reader/ReaderCatalog.vue
@@ -141,6 +141,7 @@ import { useReaderStore } from '../../stores/reader'
 import { useAppStore } from '../../stores/app'
 import type { Bookmark } from '../../types'
 import { listBrowserCachedChapterUrls } from '../../utils/browserCache'
+import { isLocalTxtBook } from '../../utils/localBook'
 
 const props = withDefaults(defineProps<{
   initialTab?: 'chapters' | 'bookmarks'
@@ -227,7 +228,7 @@ async function refreshCatalog() {
 }
 
 async function refreshCachedChapterState() {
-  if (!store.book || !store.chapters.length) {
+  if (!store.book || isLocalTxtBook(store.book) || !store.chapters.length) {
     cachedChapterUrls.value = new Set()
     return
   }
diff --git a/frontend/src/stores/bookshelf.test.ts b/frontend/src/stores/bookshelf.test.ts
index 72842a5..2c6e8d0 100644
--- a/frontend/src/stores/bookshelf.test.ts
+++ b/frontend/src/stores/bookshelf.test.ts
@@ -1,6 +1,8 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { createPinia, setActivePinia } from 'pinia'
 import { useBookshelfStore } from './bookshelf'
+import { getBookshelfWithCacheInfo } from '../api/bookshelf'
+import { listBrowserCacheSummary } from '../utils/browserCache'
 
 vi.mock('../api/bookshelf', () => ({
   getBookshelfWithCacheInfo: vi.fn(),
@@ -28,6 +30,8 @@ vi.mock('../utils/recentBooks', () => ({
 describe('bookshelf search state', () => {
   beforeEach(() => {
     setActivePinia(createPinia())
+    vi.mocked(getBookshelfWithCacheInfo).mockResolvedValue([])
+    vi.mocked(listBrowserCacheSummary).mockResolvedValue([])
   })
 
   it('starts searches in single-source scope by default', () => {
@@ -41,6 +45,35 @@ describe('bookshelf search state', () => {
     expect(store.searchGroup).toBe('')
   })
 
+
+  it('does not display browser cache counts for uploaded local txt books', async () => {
+    vi.mocked(getBookshelfWithCacheInfo).mockResolvedValue([
+      {
+        name: '本地书',
+        author: '本地导入',
+        origin: 'local-txt',
+        bookUrl: 'local-txt:abc',
+        cachedChapterCount: 12,
+      },
+      {
+        name: '远程书',
+        author: '作者',
+        origin: 'https://source.example',
+        bookUrl: 'https://book.example/1',
+      },
+    ] as never)
+    vi.mocked(listBrowserCacheSummary).mockResolvedValue([
+      { bookUrl: 'local-txt:abc', cachedChapterCount: 12, bytes: 100, updatedAt: 1 },
+      { bookUrl: 'https://book.example/1', cachedChapterCount: 3, bytes: 200, updatedAt: 2 },
+    ])
+    const store = useBookshelfStore()
+
+    await store.fetchBooks()
+
+    expect(store.books.find((book) => book.bookUrl === 'local-txt:abc')?.browserCachedChapterCount).toBe(0)
+    expect(store.books.find((book) => book.bookUrl === 'https://book.example/1')?.browserCachedChapterCount).toBe(3)
+  })
+
   it('can start a search with the active explore source selected', () => {
     const store = useBookshelfStore()
 
diff --git a/frontend/src/stores/bookshelf.ts b/frontend/src/stores/bookshelf.ts
index 02c5712..47fa5ce 100644
--- a/frontend/src/stores/bookshelf.ts
+++ b/frontend/src/stores/bookshelf.ts
@@ -12,6 +12,7 @@ import {
 } from '../api/bookshelf'
 import type { Book, BookGroup, SearchBook } from '../types'
 import { deleteBrowserBookCache, listBrowserCacheSummary } from '../utils/browserCache'
+import { isLocalTxtBook } from '../utils/localBook'
 import { clearRecentReadBooks, getRecentReadBookKey, loadRecentReadBooks, removeRecentReadBook } from '../utils/recentBooks'
 
 export const useBookshelfStore = defineStore('bookshelf', () => {
@@ -38,7 +39,7 @@ export const useBookshelfStore = defineStore('bookshelf', () => {
         : entry
       return {
         ...merged,
-        browserCachedChapterCount: browserMap.get(merged.bookUrl) || merged.browserCachedChapterCount || 0,
+        browserCachedChapterCount: isLocalTxtBook(merged) ? 0 : browserMap.get(merged.bookUrl) || merged.browserCachedChapterCount || 0,
       }
     })
   }
@@ -63,7 +64,7 @@ export const useBookshelfStore = defineStore('bookshelf', () => {
       const browserMap = new Map(browserSummaries.map((item) => [item.bookUrl, item.cachedChapterCount]))
       books.value = serverBooks.map((book) => ({
         ...book,
-        browserCachedChapterCount: browserMap.get(book.bookUrl) || 0,
+        browserCachedChapterCount: isLocalTxtBook(book) ? 0 : browserMap.get(book.bookUrl) || 0,
       }))
       await refreshRecentBooks()
     } finally {
@@ -81,7 +82,7 @@ export const useBookshelfStore = defineStore('bookshelf', () => {
       const browserMap = new Map(browserSummaries.map((item) => [item.bookUrl, item.cachedChapterCount]))
       books.value = serverBooks.map((book) => ({
         ...book,
-        browserCachedChapterCount: browserMap.get(book.bookUrl) || 0,
+        browserCachedChapterCount: isLocalTxtBook(book) ? 0 : browserMap.get(book.bookUrl) || 0,
       }))
       await refreshRecentBooks()
     } finally {
diff --git a/frontend/src/stores/reader.test.ts b/frontend/src/stores/reader.test.ts
new file mode 100644
index 0000000..504e796
--- /dev/null
+++ b/frontend/src/stores/reader.test.ts
@@ -0,0 +1,79 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import { useAppStore } from './app'
+import { useReaderStore } from './reader'
+import { getBookContent } from '../api/bookshelf'
+import { getBrowserCachedChapter } from '../utils/browserCache'
+
+vi.mock('../api/bookshelf', () => ({
+  getChapterList: vi.fn(),
+  getBookContent: vi.fn(),
+  saveBookProgress: vi.fn(),
+  setBookSource: vi.fn(),
+}))
+
+vi.mock('../api/bookmark', () => ({
+  getBookmarks: vi.fn(),
+  saveBookmark: vi.fn(),
+  deleteBookmark: vi.fn(),
+  deleteBookmarks: vi.fn(),
+}))
+
+vi.mock('../api/replaceRule', () => ({
+  getReplaceRules: vi.fn(),
+}))
+
+vi.mock('../utils/browserCache', () => ({
+  getBrowserCachedChapter: vi.fn(),
+  setBrowserCachedChapter: vi.fn(),
+}))
+
+vi.mock('../utils/recentBooks', () => ({
+  saveRecentReadBook: vi.fn(),
+}))
+
+vi.mock('../utils/openaiSpeech', () => ({
+  DEFAULT_OPENAI_BASE_URL: 'https://api.openai.com/v1',
+  requestOpenAISpeechAudio: vi.fn(),
+}))
+
+describe('reader local txt chapters', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    const storage = new Map<string, string>()
+    vi.stubGlobal('localStorage', {
+      getItem: vi.fn((key: string) => storage.get(key) ?? null),
+      setItem: vi.fn((key: string, value: string) => storage.set(key, value)),
+      removeItem: vi.fn((key: string) => storage.delete(key)),
+      clear: vi.fn(() => storage.clear()),
+    })
+    vi.mocked(getBookContent).mockReset()
+    vi.mocked(getBrowserCachedChapter).mockReset()
+  })
+
+  it('fetches uploaded local txt content from backend even when browser reports offline', async () => {
+    vi.mocked(getBookContent).mockResolvedValue('本地正文')
+    vi.mocked(getBrowserCachedChapter).mockResolvedValue(null)
+    const appStore = useAppStore()
+    const readerStore = useReaderStore()
+    appStore.setOnlineStatus(false)
+    readerStore.book = {
+      name: '本地书',
+      author: '本地导入',
+      origin: 'local-txt',
+      bookUrl: 'local-txt:abc123',
+    }
+    readerStore.chapters = [
+      { title: '第一章', url: 'local-txt:abc123#0', index: 0 },
+    ]
+
+    await expect(readerStore.fetchChapterContent(0)).resolves.toBe('本地正文')
+
+    expect(getBrowserCachedChapter).not.toHaveBeenCalled()
+    expect(getBookContent).toHaveBeenCalledWith({
+      chapterUrl: 'local-txt:abc123#0',
+      bookSourceUrl: 'local-txt',
+      refresh: 0,
+    })
+  })
+})
diff --git a/frontend/src/stores/reader.ts b/frontend/src/stores/reader.ts
index 61f62aa..86a1490 100644
--- a/frontend/src/stores/reader.ts
+++ b/frontend/src/stores/reader.ts
@@ -18,6 +18,7 @@ import {
 import { getReplaceRules } from '../api/replaceRule'
 import type { Book, BookChapter, Bookmark, ReplaceRule } from '../types'
 import { getBrowserCachedChapter, setBrowserCachedChapter } from '../utils/browserCache'
+import { isLocalTxtBook } from '../utils/localBook'
 import { saveRecentReadBook } from '../utils/recentBooks'
 import {
   DEFAULT_OPENAI_BASE_URL,
@@ -1276,13 +1277,17 @@ export const useReaderStore = defineStore('reader', () => {
 
     const chapter = chapters.value[index]
 
-    const browserCached = await getBrowserCachedChapter(book.value.bookUrl, chapter.url).catch(() => null)
+    const isLocalTxt = isLocalTxtBook(book.value)
+    const useBrowserCache = !isLocalTxt
+    const browserCached = useBrowserCache
+      ? await getBrowserCachedChapter(book.value.bookUrl, chapter.url).catch(() => null)
+      : null
 
     if (!forceRefresh && browserCached) {
       return browserCached
     }
 
-    if (!appStore.isOnline) {
+    if (!appStore.isOnline && !isLocalTxt) {
       if (browserCached) {
         return browserCached
       }
@@ -1304,12 +1309,14 @@ export const useReaderStore = defineStore('reader', () => {
       throw error
     }
 
-    await setBrowserCachedChapter({
-      bookUrl: book.value.bookUrl,
-      chapterUrl: chapter.url,
-      chapterTitle: chapter.title,
-      content: chapterContent,
-    }).catch(() => undefined)
+    if (useBrowserCache) {
+      await setBrowserCachedChapter({
+        bookUrl: book.value.bookUrl,
+        chapterUrl: chapter.url,
+        chapterTitle: chapter.title,
+        content: chapterContent,
+      }).catch(() => undefined)
+    }
 
     return chapterContent
   }
diff --git a/frontend/src/utils/localBook.test.ts b/frontend/src/utils/localBook.test.ts
new file mode 100644
index 0000000..d538f6f
--- /dev/null
+++ b/frontend/src/utils/localBook.test.ts
@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest'
+import { isLocalTxtBook } from './localBook'
+
+describe('isLocalTxtBook', () => {
+  it('detects uploaded local txt books by origin or url', () => {
+    expect(isLocalTxtBook({ origin: 'local-txt', bookUrl: 'anything' })).toBe(true)
+    expect(isLocalTxtBook({ origin: 'remote', bookUrl: 'local-txt:abc' })).toBe(true)
+    expect(isLocalTxtBook({ origin: 'remote', bookUrl: 'https://example.test/book' })).toBe(false)
+    expect(isLocalTxtBook(null)).toBe(false)
+  })
+})
diff --git a/frontend/src/utils/localBook.ts b/frontend/src/utils/localBook.ts
new file mode 100644
index 0000000..d01d5c7
--- /dev/null
+++ b/frontend/src/utils/localBook.ts
@@ -0,0 +1,8 @@
+import type { Book, SearchBook } from '../types'
+
+type BookLike = Pick<Book | SearchBook, 'origin' | 'bookUrl'>
+
+export function isLocalTxtBook(book?: BookLike | null) {
+  if (!book) return false
+  return book.origin?.trim() === 'local-txt' || book.bookUrl?.trim().startsWith('local-txt:')
+}
diff --git a/frontend/src/views/HomeView.vue b/frontend/src/views/HomeView.vue
index 41b52fe..587c2d7 100644
--- a/frontend/src/views/HomeView.vue
+++ b/frontend/src/views/HomeView.vue
@@ -31,6 +31,18 @@
               <span class="shelf-btn-label">取消全选</span>
             </button>
           </template>
+          <button class="shelf-btn" type="button" title="上传 TXT" aria-label="上传 TXT" @click="triggerTxtUpload" :disabled="txtUploading">
+            <svg v-if="!txtUploading" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+              <path d="M12 3v12" />
+              <path d="m7 8 5-5 5 5" />
+              <path d="M5 21h14" />
+            </svg>
+            <svg v-else class="spinning" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+              <path d="M21 12a9 9 0 0 0-15.55-6.2L3 8" />
+              <path d="M3 3v5h5" />
+            </svg>
+            <span class="shelf-btn-label">{{ txtUploading ? '上传中' : '上传 TXT' }}</span>
+          </button>
           <button class="shelf-btn" type="button" title="刷新书架" aria-label="刷新书架" @click="handleRefreshBooks" :disabled="shelfStore.refreshing">
             <svg :class="{ spinning: shelfStore.refreshing }" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
               <path d="M21 12a9 9 0 0 0-15.55-6.2L3 8" />
@@ -75,6 +87,14 @@
         </div>
       </div>
 
+      <input
+        ref="txtFileInputRef"
+        type="file"
+        accept=".txt,text/plain"
+        class="hidden-input"
+        @change="handleTxtFileChange"
+      />
+
       <!-- Group Tabs -->
       <div class="group-tabs">
         <div class="tabs-scroll">
@@ -151,6 +171,7 @@ import { useRouter } from 'vue-router'
 import { useBookshelfStore } from '../stores/bookshelf'
 import { useReaderStore } from '../stores/reader'
 import { useAppStore } from '../stores/app'
+import { uploadTxtBook } from '../api/bookshelf'
 import BookGrid from '../components/BookGrid.vue'
 import BookDetailModal from '../components/BookDetailModal.vue'
 import GroupSelectModal from '../components/bookshelf/GroupSelectModal.vue'
@@ -170,6 +191,8 @@ const showGroupManager = ref(false)
 const showCacheManager = ref(false)
 const selectedBook = ref<Book | SearchBook | null>(null)
 const openingBookUrl = ref('')
+const txtFileInputRef = ref<HTMLInputElement | null>(null)
+const txtUploading = ref(false)
 
 onMounted(async () => {
   await appStore.fetchUserInfo()
@@ -186,6 +209,35 @@ onMounted(async () => {
   }
 })
 
+function triggerTxtUpload() {
+  if (txtUploading.value) return
+  txtFileInputRef.value?.click()
+}
+
+async function handleTxtFileChange(event: Event) {
+  const input = event.target as HTMLInputElement
+  const file = input.files?.[0]
+  input.value = ''
+  if (!file) return
+
+  if (!file.name.toLowerCase().endsWith('.txt')) {
+    appStore.showToast('只支持上传 .txt 文件', 'warning')
+    return
+  }
+
+  txtUploading.value = true
+  try {
+    const book = await uploadTxtBook(file)
+    await shelfStore.fetchBooks()
+    appStore.showToast(`已导入《${book.name}》`, 'success')
+    await handleBookClick(book)
+  } catch (e: unknown) {
+    appStore.showToast((e as Error).message || 'TXT 上传失败', 'error')
+  } finally {
+    txtUploading.value = false
+  }
+}
+
 async function handleBookClick(book: Book | SearchBook) {
   const b = book as Book
   if (openingBookUrl.value === b.bookUrl) return
@@ -300,6 +352,10 @@ async function handleRefreshBooks() {
 }
 
 
+.hidden-input {
+  display: none;
+}
+
 .shelf-header {
   display: flex;
   align-items: center;
diff --git a/src/api/handlers/book.rs b/src/api/handlers/book.rs
index dea09e2..4227eaf 100644
--- a/src/api/handlers/book.rs
+++ b/src/api/handlers/book.rs
@@ -2,6 +2,7 @@ use crate::api::auth::AuthContext;
 use crate::api::AppState;
 use crate::error::error::{ApiResponse, AppError};
 use crate::model::{book::Book, book_source::BookSource, search::SearchBook};
+use crate::service::local_txt_book::{is_local_txt_origin, is_local_txt_url, LOCAL_TXT_ORIGIN};
 use crate::util::text::{normalize_source_url, repair_encoded_url};
 use axum::body::Body;
 use axum::body::Bytes;
@@ -9,7 +10,7 @@ use axum::http::{header, StatusCode};
 use axum::response::sse::Event;
 use axum::response::{IntoResponse, Response, Sse};
 use axum::{
-    extract::{Query, State},
+    extract::{Multipart, Query, State},
     Json,
 };
 use futures::stream::FuturesUnordered;
@@ -448,6 +449,20 @@ pub async fn get_book_info(
         .url
         .ok_or_else(|| AppError::BadRequest("url required".to_string()))?;
     let url = repair_encoded_url(&url);
+    if is_local_txt_url(&url)
+        || req
+            .book_source_url
+            .as_deref()
+            .is_some_and(is_local_txt_origin)
+    {
+        let book = state
+            .local_txt_book_service
+            .get_book_info(&user_ns, &url)
+            .await?;
+        return Ok(Json(ApiResponse::ok(
+            serde_json::to_value(book).unwrap_or_default(),
+        )));
+    }
     let source = resolve_book_source(
         &state,
         &user_ns,
@@ -496,6 +511,27 @@ pub async fn get_chapter_list(
 
     let do_refresh = req.refresh.unwrap_or(0) > 0;
 
+    if req
+        .book_source_url
+        .as_deref()
+        .is_some_and(is_local_txt_origin)
+        || req.book_url.as_deref().is_some_and(is_local_txt_url)
+        || req.toc_url.as_deref().is_some_and(is_local_txt_url)
+    {
+        let book_url = req
+            .book_url
+            .as_deref()
+            .or(req.toc_url.as_deref())
+            .ok_or_else(|| AppError::BadRequest("tocUrl or bookUrl required".to_string()))?;
+        let chapters = state
+            .local_txt_book_service
+            .get_chapter_list(&user_ns, &repair_encoded_url(book_url))
+            .await?;
+        return Ok(Json(ApiResponse::ok(
+            serde_json::to_value(chapters).unwrap_or_default(),
+        )));
+    }
+
     let source = resolve_book_source(
         &state,
         &user_ns,
@@ -647,6 +683,33 @@ pub async fn get_book_content(
 
     let do_refresh = req.refresh.unwrap_or(0) > 0;
 
+    if req
+        .book_source_url
+        .as_deref()
+        .is_some_and(is_local_txt_origin)
+        || req.chapter_url.as_deref().is_some_and(is_local_txt_url)
+    {
+        let url = req
+            .chapter_url
+            .as_deref()
+            .ok_or_else(|| AppError::BadRequest("chapterUrl required".to_string()))?;
+        let chapter_url = if is_local_txt_url(url) && !url.contains('#') {
+            let index = req.index.unwrap_or(0).max(0) as usize;
+            format!(
+                "{}#{}",
+                repair_encoded_url(url).trim_end_matches('#'),
+                index
+            )
+        } else {
+            repair_encoded_url(url)
+        };
+        let content = state
+            .local_txt_book_service
+            .get_content(&user_ns, &chapter_url)
+            .await?;
+        return Ok(Json(ApiResponse::ok(serde_json::Value::String(content))));
+    }
+
     // Determine book_url and chapter_url
     let (book_url, chapter_url) = if let Some(url) = &req.chapter_url {
         // Check if url looks like a book URL (not a chapter URL) and we have an index
@@ -845,6 +908,49 @@ pub async fn get_bookshelf(
     )))
 }
 
+pub async fn upload_txt_book(
+    State(state): State<AppState>,
+    auth: AuthContext,
+    mut multipart: Multipart,
+) -> Result<Json<ApiResponse<Value>>, AppError> {
+    let user_ns = state
+        .user_service
+        .resolve_user_ns_with_override(auth.access_token(), auth.secure_key(), auth.user_ns())
+        .await
+        .map_err(|_| AppError::BadRequest("NEED_LOGIN".to_string()))?;
+
+    let mut file_name = String::new();
+    let mut bytes: Option<Bytes> = None;
+    while let Some(field) = multipart
+        .next_field()
+        .await
+        .map_err(|e| AppError::BadRequest(e.to_string()))?
+    {
+        let field_name = field.name().unwrap_or_default().to_string();
+        if field_name != "file" {
+            continue;
+        }
+        file_name = field.file_name().unwrap_or("book.txt").to_string();
+        bytes = Some(
+            field
+                .bytes()
+                .await
+                .map_err(|e| AppError::BadRequest(e.to_string()))?,
+        );
+        break;
+    }
+
+    let bytes = bytes.ok_or_else(|| AppError::BadRequest("file required".to_string()))?;
+    let book = state
+        .local_txt_book_service
+        .import_txt_book(&user_ns, &file_name, &bytes)
+        .await?;
+    let saved = state.book_service.save_book(&user_ns, book).await?;
+    Ok(Json(ApiResponse::ok(
+        serde_json::to_value(saved).unwrap_or_default(),
+    )))
+}
+
 pub async fn save_book(
     State(state): State<AppState>,
     auth: AuthContext,
@@ -1048,6 +1154,7 @@ pub async fn delete_book(
         return Err(AppError::BadRequest("书架书籍不存在".to_string()));
     }
     cleanup_ai_book_memories(&state, &user_ns, &removed_books).await;
+    cleanup_local_txt_book_files(&state, &user_ns, &removed_books).await;
     Ok(Json(ApiResponse::ok(serde_json::json!("删除书籍成功"))))
 }
 
@@ -1064,6 +1171,7 @@ pub async fn delete_books(
     let removed_books = find_matching_books(&state, &user_ns, &books).await?;
     let count = state.book_service.delete_books(&user_ns, books).await?;
     cleanup_ai_book_memories(&state, &user_ns, &removed_books).await;
+    cleanup_local_txt_book_files(&state, &user_ns, &removed_books).await;
     Ok(Json(ApiResponse::ok(serde_json::json!({"deleted": count}))))
 }
 
@@ -1097,7 +1205,21 @@ pub async fn save_book_progress(
 
     let mut updated = shelf_book.clone();
     let mut chapter_title: Option<String> = None;
-    if let (Some(toc_url), Ok(Some(source))) = (
+    if is_local_txt_origin(&shelf_book.origin) || is_local_txt_url(&shelf_book.book_url) {
+        if let Ok(chapters) = state
+            .local_txt_book_service
+            .get_chapter_list(&user_ns, &shelf_book.book_url)
+            .await
+        {
+            if index >= 0 && (index as usize) < chapters.len() {
+                chapter_title = Some(chapters[index as usize].title.clone());
+            }
+            updated.total_chapter_num = Some(chapters.len() as i32);
+            if let Some(last) = chapters.last() {
+                updated.latest_chapter_title = Some(last.title.clone());
+            }
+        }
+    } else if let (Some(toc_url), Ok(Some(source))) = (
         shelf_book.toc_url.clone(),
         state
             .book_source_service
@@ -1172,6 +1294,18 @@ pub async fn get_shelf_book_with_cache_info(
     for book in books {
         let mut cached_count = 0usize;
 
+        if is_local_txt_origin(&book.origin) || is_local_txt_url(&book.book_url) {
+            let mut val = serde_json::to_value(&book).unwrap_or(serde_json::json!({}));
+            if let Value::Object(ref mut map) = val {
+                map.insert(
+                    "cachedChapterCount".to_string(),
+                    serde_json::json!(cache_count_for_shelf_display(&book, cached_count)),
+                );
+            }
+            result.push(val);
+            continue;
+        }
+
         let candidate_toc_urls = if let Some(toc_url) = &book.toc_url {
             vec![toc_url.clone(), book.book_url.clone()]
         } else {
@@ -2263,6 +2397,15 @@ async fn resolve_book_source(
     if let Some(src) = book_source {
         return Ok(src);
     }
+    if book_source_url.as_deref().is_some_and(is_local_txt_origin)
+        || book_url.is_some_and(is_local_txt_url)
+    {
+        return Ok(BookSource {
+            book_source_name: "本地 TXT".to_string(),
+            book_source_url: LOCAL_TXT_ORIGIN.to_string(),
+            ..BookSource::default()
+        });
+    }
     if let Some(url) = &book_source_url {
         let normalized = normalize_source_url(url);
         if !normalized.is_empty() {
@@ -2408,10 +2551,36 @@ async fn cleanup_ai_book_memories(state: &AppState, user_ns: &str, books: &[Book
     }
 }
 
+async fn cleanup_local_txt_book_files(state: &AppState, user_ns: &str, books: &[Book]) {
+    for book in books {
+        if !(is_local_txt_origin(&book.origin) || is_local_txt_url(&book.book_url)) {
+            continue;
+        }
+        if let Err(err) = state
+            .local_txt_book_service
+            .delete_book_files(user_ns, &book.book_url)
+            .await
+        {
+            tracing::warn!(
+                "failed to delete local txt book files for {}: {:?}",
+                book.book_url,
+                err
+            );
+        }
+    }
+}
+
 fn book_matches_delete_target(shelf_book: &Book, target: &Book) -> bool {
     if !target.book_url.is_empty() && shelf_book.book_url == target.book_url {
         return true;
     }
+    if is_local_txt_origin(&shelf_book.origin)
+        || is_local_txt_url(&shelf_book.book_url)
+        || is_local_txt_origin(&target.origin)
+        || is_local_txt_url(&target.book_url)
+    {
+        return false;
+    }
     !target.name.is_empty()
         && !target.author.is_empty()
         && shelf_book.name == target.name
@@ -2475,6 +2644,14 @@ fn build_available_book_source_response(
     }
 }
 
+fn cache_count_for_shelf_display(book: &Book, cached_count: usize) -> usize {
+    if is_local_txt_origin(&book.origin) || is_local_txt_url(&book.book_url) {
+        0
+    } else {
+        cached_count
+    }
+}
+
 fn available_source_sse_result_key(book: &SearchBook) -> String {
     format!("{}::{}", book.origin, book.book_url)
 }
@@ -2565,9 +2742,10 @@ fn take_available_source_sse_matches(
 #[cfg(test)]
 mod tests {
     use super::{
-        book_matches_delete_target, build_available_book_source_response, fallback_available_book,
-        should_use_available_source_cache, take_available_source_cached_matches,
-        take_available_source_sse_matches, GetAvailableBookSourceRequest,
+        book_matches_delete_target, build_available_book_source_response,
+        cache_count_for_shelf_display, fallback_available_book, should_use_available_source_cache,
+        take_available_source_cached_matches, take_available_source_sse_matches,
+        GetAvailableBookSourceRequest,
     };
     use crate::model::{book::Book, search::SearchBook};
     use std::collections::HashSet;
@@ -2628,6 +2806,17 @@ mod tests {
         assert!(response.has_more);
     }
 
+    #[test]
+    fn local_txt_books_do_not_report_remote_cache_count_for_shelf_display() {
+        let book = Book {
+            origin: "local-txt".to_string(),
+            book_url: "local-txt:abc".to_string(),
+            ..Book::default()
+        };
+
+        assert_eq!(cache_count_for_shelf_display(&book, 42), 0);
+    }
+
     #[test]
     fn available_book_source_paged_requests_skip_complete_cache() {
         assert!(should_use_available_source_cache(false, None, None));
diff --git a/src/api/mod.rs b/src/api/mod.rs
index 725aecc..f4a6e7b 100644
--- a/src/api/mod.rs
+++ b/src/api/mod.rs
@@ -7,7 +7,7 @@ use crate::service::{
     ai_book_service::AiBookService, ai_model_service::AiModelService,
     book_group_service::BookGroupService, book_service::BookService,
     book_source_service::BookSourceService, json_document_service::JsonDocumentService,
-    update_service::UpdateService, user_service::UserService,
+    local_txt_book::LocalTxtBookService, update_service::UpdateService, user_service::UserService,
 };
 use std::sync::Arc;
 
@@ -18,6 +18,7 @@ pub struct AppState {
     pub book_source_service: Arc<BookSourceService>,
     pub user_service: Arc<UserService>,
     pub book_group_service: Arc<BookGroupService>,
+    pub local_txt_book_service: Arc<LocalTxtBookService>,
     pub json_document_service: Arc<JsonDocumentService>,
     pub ai_book_service: Arc<AiBookService>,
     pub ai_model_service: Arc<AiModelService>,
diff --git a/src/api/router.rs b/src/api/router.rs
index 51d9bbf..26c9fb4 100644
--- a/src/api/router.rs
+++ b/src/api/router.rs
@@ -118,6 +118,7 @@ pub fn build_router(state: AppState) -> Router {
             "/reader3/removeBookGroupMulti",
             post(handlers::remove_book_group_multi),
         )
+        .route("/reader3/uploadTxtBook", post(handlers::upload_txt_book))
         .route("/reader3/saveBook", post(handlers::save_book))
         .route("/reader3/saveBooks", post(handlers::save_books))
         .route("/reader3/setBookSource", post(handlers::set_book_source))
diff --git a/src/app/bootstrap.rs b/src/app/bootstrap.rs
index ad58122..c639fbc 100644
--- a/src/app/bootstrap.rs
+++ b/src/app/bootstrap.rs
@@ -11,7 +11,7 @@ use crate::service::{
     ai_book_service::AiBookService, ai_model_service::AiModelService,
     book_group_service::BookGroupService, book_service::BookService,
     book_source_service::BookSourceService, json_document_service::JsonDocumentService,
-    update_service::UpdateService, user_service::UserService,
+    local_txt_book::LocalTxtBookService, update_service::UpdateService, user_service::UserService,
 };
 use crate::storage::{cache::file_cache::FileCache, db, fs::storage_fs::StorageFs};
 
@@ -42,6 +42,7 @@ pub async fn run() -> anyhow::Result<()> {
 
     let book_service = Arc::new(BookService::new(http, parser, cache, &cfg.storage_dir));
     let book_source_service = Arc::new(BookSourceService::new(repo, &cfg.storage_dir));
+    let local_txt_book_service = Arc::new(LocalTxtBookService::new(&cfg.storage_dir));
     let json_document_service = Arc::new(JsonDocumentService::new(pool.clone(), &cfg.storage_dir));
     let user_service = Arc::new(UserService::new(cfg.clone(), pool.clone()));
     user_service.migrate_legacy_users_from_json().await?;
@@ -63,6 +64,7 @@ pub async fn run() -> anyhow::Result<()> {
         book_source_service,
         user_service,
         book_group_service,
+        local_txt_book_service,
         json_document_service,
         ai_book_service,
         ai_model_service,
diff --git a/src/service/book_service.rs b/src/service/book_service.rs
index d10e220..62ed315 100644
--- a/src/service/book_service.rs
+++ b/src/service/book_service.rs
@@ -911,9 +911,7 @@ impl BookService {
         let mut list = self.read_bookshelf(user_ns).await?;
         let mut exist_idx: Option<usize> = None;
         for (i, b) in list.iter().enumerate() {
-            if b.book_url == book.book_url
-                || (!b.name.is_empty() && b.name == book.name && b.author == book.author)
-            {
+            if books_match_for_save(b, &book) {
                 exist_idx = Some(i);
                 break;
             }
@@ -972,34 +970,10 @@ impl BookService {
         let orig_len = list.len();
         let removed: Vec<Book> = list
             .iter()
-            .filter(|b| {
-                if !book.book_url.is_empty() && b.book_url == book.book_url {
-                    return true;
-                }
-                if !book.name.is_empty()
-                    && !book.author.is_empty()
-                    && b.name == book.name
-                    && b.author == book.author
-                {
-                    return true;
-                }
-                false
-            })
+            .filter(|b| books_match_for_delete(b, book))
             .cloned()
             .collect();
-        list.retain(|b| {
-            if !book.book_url.is_empty() && b.book_url == book.book_url {
-                return false;
-            }
-            if !book.name.is_empty()
-                && !book.author.is_empty()
-                && b.name == book.name
-                && b.author == book.author
-            {
-                return false;
-            }
-            true
-        });
+        list.retain(|b| !books_match_for_delete(b, book));
         let deleted = list.len() != orig_len;
         if deleted {
             self.write_bookshelf(user_ns, &list).await?;
@@ -1017,36 +991,12 @@ impl BookService {
         for book in books {
             let matched: Vec<Book> = list
                 .iter()
-                .filter(|b| {
-                    if !book.book_url.is_empty() && b.book_url == book.book_url {
-                        return true;
-                    }
-                    if !book.name.is_empty()
-                        && !book.author.is_empty()
-                        && b.name == book.name
-                        && b.author == book.author
-                    {
-                        return true;
-                    }
-                    false
-                })
+                .filter(|b| books_match_for_delete(b, &book))
                 .cloned()
                 .collect();
             removed_books.extend(matched);
             let before = list.len();
-            list.retain(|b| {
-                if !book.book_url.is_empty() && b.book_url == book.book_url {
-                    return false;
-                }
-                if !book.name.is_empty()
-                    && !book.author.is_empty()
-                    && b.name == book.name
-                    && b.author == book.author
-                {
-                    return false;
-                }
-                true
-            });
+            list.retain(|b| !books_match_for_delete(b, &book));
             if list.len() != before {
                 deleted += 1;
             }
@@ -1620,6 +1570,35 @@ fn cookie_domain(source_url: &str) -> String {
     }
 }
 
+fn is_local_txt_book(book: &Book) -> bool {
+    book.origin.trim() == "local-txt" || book.book_url.trim().starts_with("local-txt:")
+}
+
+fn books_match_for_save(existing: &Book, incoming: &Book) -> bool {
+    if existing.book_url == incoming.book_url {
+        return true;
+    }
+    if is_local_txt_book(existing) || is_local_txt_book(incoming) {
+        return false;
+    }
+    !existing.name.is_empty()
+        && existing.name == incoming.name
+        && existing.author == incoming.author
+}
+
+fn books_match_for_delete(existing: &Book, target: &Book) -> bool {
+    if !target.book_url.is_empty() && existing.book_url == target.book_url {
+        return true;
+    }
+    if is_local_txt_book(existing) || is_local_txt_book(target) {
+        return false;
+    }
+    !target.name.is_empty()
+        && !target.author.is_empty()
+        && existing.name == target.name
+        && existing.author == target.author
+}
+
 fn sanitize_book_urls(book: &mut Book) {
     book.book_url = repair_encoded_url(&book.book_url);
     book.origin = normalize_source_url(&book.origin);
diff --git a/src/service/local_txt_book.rs b/src/service/local_txt_book.rs
new file mode 100644
index 0000000..7c27ae3
--- /dev/null
+++ b/src/service/local_txt_book.rs
@@ -0,0 +1,422 @@
+use crate::error::error::AppError;
+use crate::model::{book::Book, book_chapter::BookChapter};
+use crate::util::hash::md5_hex;
+use encoding_rs::GB18030;
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+use tokio::fs;
+
+pub const LOCAL_TXT_ORIGIN: &str = "local-txt";
+pub const LOCAL_TXT_ORIGIN_NAME: &str = "本地 TXT";
+pub const MAX_TXT_UPLOAD_BYTES: usize = 50 * 1024 * 1024;
+const LOCAL_BOOK_DIR: &str = "local_books";
+const LOCAL_TXT_HASH_LEN: usize = 32;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ParsedTxtChapter {
+    pub title: String,
+    pub url: String,
+    pub index: i32,
+    pub start: usize,
+    pub end: usize,
+    pub content: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct StoredTxtChapter {
+    title: String,
+    url: String,
+    index: i32,
+    start: usize,
+    end: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct StoredTxtIndex {
+    book_url: String,
+    name: String,
+    file_name: String,
+    byte_len: usize,
+    char_len: usize,
+    chapters: Vec<StoredTxtChapter>,
+}
+
+pub fn is_local_txt_origin(value: &str) -> bool {
+    value.trim() == LOCAL_TXT_ORIGIN
+}
+
+pub fn is_local_txt_url(value: &str) -> bool {
+    value.trim().starts_with("local-txt:")
+}
+
+pub fn build_chapter_url(book_url: &str, index: usize) -> String {
+    format!("{}#{}", book_url.trim_end_matches('#'), index)
+}
+
+pub fn parse_txt_chapters(book_url: &str, text: &str) -> Vec<ParsedTxtChapter> {
+    let Some(heading_re) = chapter_heading_regex() else {
+        return fallback_chapter(book_url, text);
+    };
+
+    let mut headings: Vec<(usize, usize, String)> = Vec::new();
+    let mut offset = 0usize;
+    for line in text.split_inclusive('\n') {
+        let raw_line = line.trim_end_matches(['\r', '\n']);
+        let title = raw_line.trim();
+        let content_len = raw_line.len();
+        if is_chapter_heading(title, &heading_re) {
+            let leading_ws = raw_line.len().saturating_sub(raw_line.trim_start().len());
+            headings.push((offset + leading_ws, offset + content_len, title.to_string()));
+        }
+        offset += line.len();
+    }
+
+    if offset < text.len() {
+        let raw_line = &text[offset..];
+        let title = raw_line.trim();
+        if is_chapter_heading(title, &heading_re) {
+            let leading_ws = raw_line.len().saturating_sub(raw_line.trim_start().len());
+            headings.push((offset + leading_ws, text.len(), title.to_string()));
+        }
+    }
+
+    if headings.is_empty() {
+        return fallback_chapter(book_url, text);
+    }
+
+    let mut chapters = Vec::new();
+    let first_start = headings[0].0;
+    if text[..first_start].trim().len() > 0 {
+        chapters.push(ParsedTxtChapter {
+            title: "序章".to_string(),
+            url: build_chapter_url(book_url, 0),
+            index: 0,
+            start: 0,
+            end: trim_chapter_end(text, first_start),
+            content: text[..trim_chapter_end(text, first_start)].to_string(),
+        });
+    }
+
+    for (heading_index, (title_start, title_end, title)) in headings.iter().enumerate() {
+        let content_start = skip_line_break(text, *title_end);
+        let next_start = headings
+            .get(heading_index + 1)
+            .map(|(start, _, _)| *start)
+            .unwrap_or(text.len());
+        let end = trim_chapter_end(text, next_start).max(content_start);
+        let index = chapters.len() as i32;
+        chapters.push(ParsedTxtChapter {
+            title: title.clone(),
+            url: build_chapter_url(book_url, index as usize),
+            index,
+            start: content_start,
+            end,
+            content: text[content_start..end].to_string(),
+        });
+        if *title_start >= text.len() {
+            break;
+        }
+    }
+
+    if chapters.is_empty() {
+        fallback_chapter(book_url, text)
+    } else {
+        chapters
+    }
+}
+
+pub fn decode_txt_bytes(bytes: &[u8]) -> String {
+    if bytes.starts_with(&[0xEF, 0xBB, 0xBF]) {
+        return String::from_utf8_lossy(&bytes[3..]).into_owned();
+    }
+    match std::str::from_utf8(bytes) {
+        Ok(value) => value.to_string(),
+        Err(_) => {
+            let (decoded, _, _) = GB18030.decode(bytes);
+            decoded.into_owned()
+        }
+    }
+}
+
+pub fn sanitize_txt_file_name(file_name: &str) -> String {
+    let name = Path::new(file_name)
+        .file_name()
+        .and_then(|value| value.to_str())
+        .unwrap_or("book.txt")
+        .trim()
+        .to_string();
+    if name.is_empty() {
+        "book.txt".to_string()
+    } else {
+        name
+    }
+}
+
+pub fn book_name_from_file_name(file_name: &str) -> String {
+    let safe = sanitize_txt_file_name(file_name);
+    Path::new(&safe)
+        .file_stem()
+        .and_then(|value| value.to_str())
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .unwrap_or("本地小说")
+        .to_string()
+}
+
+pub fn validate_txt_upload(file_name: &str, byte_len: usize) -> Result<(), AppError> {
+    let safe = sanitize_txt_file_name(file_name);
+    if !safe.to_lowercase().ends_with(".txt") {
+        return Err(AppError::BadRequest("仅支持上传 .txt 文件".to_string()));
+    }
+    if byte_len == 0 {
+        return Err(AppError::BadRequest("TXT 文件不能为空".to_string()));
+    }
+    if byte_len > MAX_TXT_UPLOAD_BYTES {
+        return Err(AppError::BadRequest("TXT 文件不能超过 50MB".to_string()));
+    }
+    Ok(())
+}
+
+#[derive(Clone)]
+pub struct LocalTxtBookService {
+    storage_dir: PathBuf,
+}
+
+impl LocalTxtBookService {
+    pub fn new(storage_dir: impl AsRef<Path>) -> Self {
+        Self {
+            storage_dir: storage_dir.as_ref().to_path_buf(),
+        }
+    }
+
+    pub async fn import_txt_book(
+        &self,
+        user_ns: &str,
+        file_name: &str,
+        bytes: &[u8],
+    ) -> Result<Book, AppError> {
+        validate_txt_upload(file_name, bytes.len())?;
+        let safe_file_name = sanitize_txt_file_name(file_name);
+        let text = decode_txt_bytes(bytes);
+        if text.trim().is_empty() {
+            return Err(AppError::BadRequest("TXT 文件内容不能为空".to_string()));
+        }
+
+        let hash = md5_hex(&format!(
+            "{}:{}:{}",
+            user_ns,
+            safe_file_name,
+            md5_hex(&text)
+        ));
+        let book_url = format!("{}:{}", LOCAL_TXT_ORIGIN, hash);
+        let chapters = parse_txt_chapters(&book_url, &text);
+        let book_dir = self.book_dir(user_ns, &book_url)?;
+        fs::create_dir_all(&book_dir)
+            .await
+            .map_err(|e| AppError::Internal(e.into()))?;
+        fs::write(book_dir.join("book.txt"), text.as_bytes())
+            .await
+            .map_err(|e| AppError::Internal(e.into()))?;
+
+        let index = StoredTxtIndex {
+            book_url: book_url.clone(),
+            name: book_name_from_file_name(&safe_file_name),
+            file_name: safe_file_name,
+            byte_len: bytes.len(),
+            char_len: text.chars().count(),
+            chapters: chapters
+                .iter()
+                .map(|chapter| StoredTxtChapter {
+                    title: chapter.title.clone(),
+                    url: chapter.url.clone(),
+                    index: chapter.index,
+                    start: chapter.start,
+                    end: chapter.end,
+                })
+                .collect(),
+        };
+        let data =
+            serde_json::to_string_pretty(&index).map_err(|e| AppError::Internal(e.into()))?;
+        fs::write(book_dir.join("chapters.json"), data)
+            .await
+            .map_err(|e| AppError::Internal(e.into()))?;
+
+        Ok(Book {
+            name: index.name,
+            author: "本地导入".to_string(),
+            book_url: book_url.clone(),
+            origin: LOCAL_TXT_ORIGIN.to_string(),
+            origin_name: Some(LOCAL_TXT_ORIGIN_NAME.to_string()),
+            toc_url: Some(book_url),
+            can_update: Some(false),
+            dur_chapter_index: Some(0),
+            dur_chapter_pos: Some(0),
+            total_chapter_num: Some(index.chapters.len() as i32),
+            latest_chapter_title: index.chapters.last().map(|chapter| chapter.title.clone()),
+            kind: Some("本地TXT".to_string()),
+            word_count: Some(format!("{}字", index.char_len)),
+            ..Book::default()
+        })
+    }
+
+    pub async fn get_book_info(&self, user_ns: &str, book_url: &str) -> Result<Book, AppError> {
+        let index = self.read_index(user_ns, book_url).await?;
+        Ok(Book {
+            name: index.name,
+            author: "本地导入".to_string(),
+            book_url: index.book_url.clone(),
+            origin: LOCAL_TXT_ORIGIN.to_string(),
+            origin_name: Some(LOCAL_TXT_ORIGIN_NAME.to_string()),
+            toc_url: Some(index.book_url.clone()),
+            can_update: Some(false),
+            total_chapter_num: Some(index.chapters.len() as i32),
+            latest_chapter_title: index.chapters.last().map(|chapter| chapter.title.clone()),
+            kind: Some("本地TXT".to_string()),
+            word_count: Some(format!("{}字", index.char_len)),
+            ..Book::default()
+        })
+    }
+
+    pub async fn get_chapter_list(
+        &self,
+        user_ns: &str,
+        book_url: &str,
+    ) -> Result<Vec<BookChapter>, AppError> {
+        let index = self.read_index(user_ns, book_url).await?;
+        Ok(index
+            .chapters
+            .into_iter()
+            .map(|chapter| BookChapter {
+                title: chapter.title,
+                url: chapter.url,
+                index: chapter.index,
+                ..BookChapter::default()
+            })
+            .collect())
+    }
+
+    pub async fn get_content(&self, user_ns: &str, chapter_url: &str) -> Result<String, AppError> {
+        let (book_url, requested_index) = parse_chapter_url(chapter_url)?;
+        let index = self.read_index(user_ns, &book_url).await?;
+        let chapter = index
+            .chapters
+            .iter()
+            .find(|chapter| chapter.index == requested_index)
+            .ok_or_else(|| AppError::BadRequest("章节不存在".to_string()))?;
+        let text = fs::read_to_string(self.book_dir(user_ns, &book_url)?.join("book.txt"))
+            .await
+            .map_err(map_local_txt_read_error)?;
+        if chapter.start > chapter.end || chapter.end > text.len() {
+            return Err(AppError::BadRequest("章节索引无效".to_string()));
+        }
+        Ok(text[chapter.start..chapter.end].to_string())
+    }
+
+    pub async fn delete_book_files(&self, user_ns: &str, book_url: &str) -> Result<bool, AppError> {
+        let book_dir = self.book_dir(user_ns, book_url)?;
+        match fs::remove_dir_all(book_dir).await {
+            Ok(()) => Ok(true),
+            Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(false),
+            Err(err) => Err(AppError::Internal(err.into())),
+        }
+    }
+
+    fn local_root(&self, user_ns: &str) -> PathBuf {
+        self.storage_dir
+            .join("data")
+            .join(user_ns)
+            .join(LOCAL_BOOK_DIR)
+    }
+
+    fn book_dir(&self, user_ns: &str, book_url: &str) -> Result<PathBuf, AppError> {
+        let hash = local_txt_hash_from_url(book_url)?;
+        Ok(self.local_root(user_ns).join(hash))
+    }
+
+    async fn read_index(&self, user_ns: &str, book_url: &str) -> Result<StoredTxtIndex, AppError> {
+        let path = self.book_dir(user_ns, book_url)?.join("chapters.json");
+        let data = fs::read_to_string(path)
+            .await
+            .map_err(map_local_txt_read_error)?;
+        serde_json::from_str(&data).map_err(|e| AppError::BadRequest(e.to_string()))
+    }
+}
+
+fn fallback_chapter(book_url: &str, text: &str) -> Vec<ParsedTxtChapter> {
+    vec![ParsedTxtChapter {
+        title: "正文".to_string(),
+        url: build_chapter_url(book_url, 0),
+        index: 0,
+        start: 0,
+        end: text.len(),
+        content: text.to_string(),
+    }]
+}
+
+fn chapter_heading_regex() -> Option<Regex> {
+    Regex::new(r"^(?:第[\p{N}零〇一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+[章节回卷部集篇]|卷[\p{N}零〇一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+)(?:$|[\s:：、.．\-—].*|[^\s:：、.．\-—](?:.*[^。！？!?；;，,、])?)$").ok()
+}
+
+fn is_chapter_heading(line: &str, re: &Regex) -> bool {
+    if line.is_empty() || line.chars().count() > 80 {
+        return false;
+    }
+    re.is_match(line)
+}
+
+fn skip_line_break(text: &str, offset: usize) -> usize {
+    let rest = &text[offset..];
+    if rest.starts_with("\r\n") {
+        offset + 2
+    } else if rest.starts_with('\n') || rest.starts_with('\r') {
+        offset + 1
+    } else {
+        offset
+    }
+}
+
+fn trim_chapter_end(text: &str, mut end: usize) -> usize {
+    while end > 0 {
+        let prev = text[..end].chars().next_back();
+        match prev {
+            Some('\n') | Some('\r') => end -= prev.unwrap().len_utf8(),
+            _ => break,
+        }
+    }
+    end
+}
+
+fn parse_chapter_url(chapter_url: &str) -> Result<(String, i32), AppError> {
+    let (book_url, raw_index) = chapter_url
+        .rsplit_once('#')
+        .ok_or_else(|| AppError::BadRequest("章节地址无效".to_string()))?;
+    if !is_local_txt_url(book_url) {
+        return Err(AppError::BadRequest("章节地址无效".to_string()));
+    }
+    let index = raw_index
+        .parse::<i32>()
+        .map_err(|_| AppError::BadRequest("章节序号无效".to_string()))?;
+    Ok((book_url.to_string(), index))
+}
+
+fn local_txt_hash_from_url(book_url: &str) -> Result<&str, AppError> {
+    let hash = book_url
+        .strip_prefix("local-txt:")
+        .filter(|value| {
+            value.len() == LOCAL_TXT_HASH_LEN && value.chars().all(|ch| ch.is_ascii_hexdigit())
+        })
+        .ok_or_else(|| AppError::BadRequest("本地 TXT 地址无效".to_string()))?;
+    Ok(hash)
+}
+
+fn map_local_txt_read_error(err: std::io::Error) -> AppError {
+    if err.kind() == std::io::ErrorKind::NotFound {
+        AppError::BadRequest("本地 TXT 不存在".to_string())
+    } else {
+        AppError::Internal(err.into())
+    }
+}
diff --git a/src/service/mod.rs b/src/service/mod.rs
index 17c0b48..96956d1 100644
--- a/src/service/mod.rs
+++ b/src/service/mod.rs
@@ -4,5 +4,6 @@ pub mod book_group_service;
 pub mod book_service;
 pub mod book_source_service;
 pub mod json_document_service;
+pub mod local_txt_book;
 pub mod update_service;
 pub mod user_service;
diff --git a/tests/local_txt_book.rs b/tests/local_txt_book.rs
new file mode 100644
index 0000000..f347c30
--- /dev/null
+++ b/tests/local_txt_book.rs
@@ -0,0 +1,215 @@
+use reader_rust::service::local_txt_book::{build_chapter_url, parse_txt_chapters};
+
+#[test]
+fn txt_parser_splits_common_chapter_headings() {
+    let text = "序言\n这里是序言。\n第1章 初见\n第一章正文。\n第二章 重逢\n第二章正文。\n";
+
+    let chapters = parse_txt_chapters("local-txt:abc123", text);
+
+    assert_eq!(chapters.len(), 3);
+    assert_eq!(chapters[0].title, "序章");
+    assert_eq!(chapters[0].url, "local-txt:abc123#0");
+    assert_eq!(chapters[0].content.trim(), "序言\n这里是序言。");
+    assert_eq!(chapters[1].title, "第1章 初见");
+    assert_eq!(chapters[1].content.trim(), "第一章正文。");
+    assert_eq!(chapters[2].title, "第二章 重逢");
+    assert_eq!(chapters[2].content.trim(), "第二章正文。");
+}
+
+#[test]
+fn txt_parser_splits_no_space_chapter_headings() {
+    let text = "第一章初见\n第一章正文。\n第2章重逢\n第二章正文。\n";
+
+    let chapters = parse_txt_chapters("local-txt:nospace", text);
+
+    assert_eq!(chapters.len(), 2);
+    assert_eq!(chapters[0].title, "第一章初见");
+    assert_eq!(chapters[0].content.trim(), "第一章正文。");
+    assert_eq!(chapters[1].title, "第2章重逢");
+    assert_eq!(chapters[1].content.trim(), "第二章正文。");
+}
+
+#[test]
+fn txt_parser_falls_back_to_single_body_chapter() {
+    let text = "没有章节标题\n只有正文\n";
+
+    let chapters = parse_txt_chapters("local-txt:book", text);
+
+    assert_eq!(chapters.len(), 1);
+    assert_eq!(chapters[0].title, "正文");
+    assert_eq!(chapters[0].url, "local-txt:book#0");
+    assert_eq!(chapters[0].content, text);
+}
+
+#[test]
+fn txt_parser_allows_empty_chapters_between_adjacent_headings() {
+    let text = "第1章 空章\n第二章 正文\n第二章内容。\n";
+
+    let chapters = parse_txt_chapters("local-txt:empty", text);
+
+    assert_eq!(chapters.len(), 2);
+    assert_eq!(chapters[0].title, "第1章 空章");
+    assert_eq!(chapters[0].content, "");
+    assert_eq!(chapters[1].title, "第二章 正文");
+    assert_eq!(chapters[1].content.trim(), "第二章内容。");
+}
+
+#[test]
+fn txt_chapter_urls_are_stable_by_book_url_and_index() {
+    assert_eq!(
+        build_chapter_url("local-txt:abc123", 7),
+        "local-txt:abc123#7"
+    );
+}
+
+#[tokio::test]
+async fn txt_import_saves_book_index_and_content_for_server_bookshelf() {
+    let storage_dir =
+        std::env::temp_dir().join(format!("reader-rust-local-txt-test-{}", std::process::id()));
+    if storage_dir.exists() {
+        std::fs::remove_dir_all(&storage_dir).unwrap();
+    }
+    let service = reader_rust::service::local_txt_book::LocalTxtBookService::new(&storage_dir);
+    let bytes = "第1章 开始\n第一章内容。\n第二章 后来\n第二章内容。".as_bytes();
+
+    let book = service
+        .import_txt_book("alice", "测试小说.txt", bytes)
+        .await
+        .unwrap();
+    let chapters = service
+        .get_chapter_list("alice", &book.book_url)
+        .await
+        .unwrap();
+    let content = service
+        .get_content("alice", &chapters[1].url)
+        .await
+        .unwrap();
+
+    assert_eq!(book.name, "测试小说");
+    assert_eq!(book.origin, "local-txt");
+    assert_eq!(book.origin_name.as_deref(), Some("本地 TXT"));
+    assert_eq!(book.can_update, Some(false));
+    assert_eq!(chapters.len(), 2);
+    assert_eq!(chapters[0].title, "第1章 开始");
+    assert_eq!(chapters[1].title, "第二章 后来");
+    assert_eq!(content.trim(), "第二章内容。");
+
+    let _ = std::fs::remove_dir_all(storage_dir);
+}
+
+#[tokio::test]
+async fn txt_import_rejects_non_txt_files() {
+    let storage_dir = std::env::temp_dir().join(format!(
+        "reader-rust-local-txt-reject-test-{}",
+        std::process::id()
+    ));
+    let service = reader_rust::service::local_txt_book::LocalTxtBookService::new(&storage_dir);
+
+    let err = service
+        .import_txt_book("alice", "测试小说.md", "正文".as_bytes())
+        .await
+        .expect_err("non txt file should be rejected");
+
+    assert!(err.to_string().contains(".txt"));
+    let _ = std::fs::remove_dir_all(storage_dir);
+}
+
+#[tokio::test]
+async fn txt_service_rejects_non_hash_local_txt_urls() {
+    let storage_dir = std::env::temp_dir().join(format!(
+        "reader-rust-local-txt-path-test-{}",
+        std::process::id()
+    ));
+    let service = reader_rust::service::local_txt_book::LocalTxtBookService::new(&storage_dir);
+
+    let err = service
+        .get_chapter_list("alice", "local-txt:/tmp/escape")
+        .await
+        .expect_err("absolute local txt paths should be rejected");
+
+    assert!(err.to_string().contains("本地 TXT 地址无效"));
+    let _ = std::fs::remove_dir_all(storage_dir);
+}
+
+#[tokio::test]
+async fn txt_delete_removes_imported_book_files() {
+    let storage_dir = std::env::temp_dir().join(format!(
+        "reader-rust-local-txt-delete-test-{}",
+        std::process::id()
+    ));
+    if storage_dir.exists() {
+        std::fs::remove_dir_all(&storage_dir).unwrap();
+    }
+    let service = reader_rust::service::local_txt_book::LocalTxtBookService::new(&storage_dir);
+    let book = service
+        .import_txt_book("alice", "待删除.txt", "第一章 开始\n正文".as_bytes())
+        .await
+        .unwrap();
+    let chapters = service
+        .get_chapter_list("alice", &book.book_url)
+        .await
+        .unwrap();
+
+    assert!(service
+        .delete_book_files("alice", &book.book_url)
+        .await
+        .unwrap());
+    let err = service
+        .get_content("alice", &chapters[0].url)
+        .await
+        .expect_err("deleted local txt content should not remain readable");
+
+    assert!(err.to_string().contains("不存在") || err.to_string().contains("No such file"));
+    let _ = std::fs::remove_dir_all(storage_dir);
+}
+
+#[tokio::test]
+async fn saving_same_named_local_txt_books_keeps_distinct_book_urls() {
+    use reader_rust::crawler::http_client::HttpClient;
+    use reader_rust::parser::rule_engine::RuleEngine;
+    use reader_rust::service::book_service::BookService;
+    use reader_rust::storage::cache::file_cache::FileCache;
+
+    let storage_dir = std::env::temp_dir().join(format!(
+        "reader-rust-local-txt-save-test-{}",
+        std::process::id()
+    ));
+    if storage_dir.exists() {
+        std::fs::remove_dir_all(&storage_dir).unwrap();
+    }
+
+    let local_service =
+        reader_rust::service::local_txt_book::LocalTxtBookService::new(&storage_dir);
+    let book_service = BookService::new(
+        HttpClient::new(5, None).unwrap(),
+        RuleEngine::new().unwrap(),
+        FileCache::new(storage_dir.join("cache")),
+        storage_dir.to_str().unwrap(),
+    );
+
+    let first = local_service
+        .import_txt_book("alice", "同名小说.txt", "第一版正文".as_bytes())
+        .await
+        .unwrap();
+    let second = local_service
+        .import_txt_book("alice", "同名小说.txt", "第二版正文".as_bytes())
+        .await
+        .unwrap();
+
+    book_service
+        .save_book("alice", first.clone())
+        .await
+        .unwrap();
+    book_service
+        .save_book("alice", second.clone())
+        .await
+        .unwrap();
+    let shelf = book_service.get_bookshelf("alice").await.unwrap();
+
+    assert_ne!(first.book_url, second.book_url);
+    assert_eq!(shelf.len(), 2);
+    assert!(shelf.iter().any(|book| book.book_url == first.book_url));
+    assert!(shelf.iter().any(|book| book.book_url == second.book_url));
+
+    let _ = std::fs::remove_dir_all(storage_dir);
+}