Merge branch 'main' into dagangshengji

# Conflicts:
#	src/components/layout/preview-panel.tsx
#	src/components/layout/sidebar-panel.tsx
#	src/components/sources/outline-action-toolbar.tsx
#	src/lib/novel/deep-outline-generation.ts
#	src/lib/novel/outline-generation.spec.ts
#	src/lib/novel/outline-generation.ts

src/components/chat/chat-message.spec.tsx

@@ -42,6 +42,19 @@ describe("chat thinking display", () => {
     expect(html).toContain("max-h-")
     expect(html).toContain("overflow-y-auto")
   })
+
+  it("labels fragmented model reasoning as 思考过程 instead of hundreds of workflow stages", () => {
+    const fragmentedReasoning = ["好的，", "用户", "问", "的是", "当前", "情节", "中", "的人物"]
+      .join("\n\n")
+    const html = renderToStaticMarkup(
+      <StreamingMessage content={`<think>\n${fragmentedReasoning}\n</think>\n\n回答正文`} />,
+    )
+
+    expect(html).toContain("思考过程")
+    expect(html).not.toContain("工作流阶段")
+    expect(html).not.toContain("个阶段")
+    expect(html).toContain("好的，用户问的是当前情节中的人物")
+  })
 })
 
 describe("AI workflow mode toggle style", () => {

src/components/chat/chat-message.tsx

@@ -133,7 +133,7 @@ export function ChatMessage({
       </div>
       <div className={`${isUser ? "w-fit max-w-full lg:max-w-[50vw]" : "min-w-0 flex-1 max-w-full"} flex flex-col gap-1.5`}>
         <div
-          className={`rounded-lg px-3 py-2 text-sm ${
+          className={`w-full min-w-0 rounded-lg px-3 py-2 text-sm ${
             isUser
               ? "bg-primary text-primary-foreground"
               : message.discarded
@@ -800,7 +800,7 @@ function MarkdownContent({ content }: { content: string }) {
   const htmlLang = getHtmlLang(renderLanguage);
 
   return (
-    <div>
+    <div className="w-full min-w-0">
       {thinking && <WorkflowBlock content={thinking} />}
       <div
         className="chat-markdown prose prose-sm max-w-none dark:prose-invert prose-p:my-1 prose-headings:my-2 prose-ul:my-1 prose-ol:my-1 prose-li:my-0 prose-pre:my-2 prose-code:text-xs prose-code:before:content-none prose-code:after:content-none"
@@ -1065,27 +1065,49 @@ function separateThinking(text: string): {
   return { thinking: filteredThinking, answer: answer.trim() };
 }
 
+function countWorkflowStages(content: string): number {
+  return content.split("\n").filter((line) => isWorkflowStageHeader(line)).length
+}
+
+function getThinkingBlockMeta(content: string, streaming: boolean): { title: string; stageCount: number | null } {
+  const stageCount = countWorkflowStages(content)
+  if (stageCount > 0) {
+    return {
+      title: streaming ? "工作流进行中..." : "工作流阶段",
+      stageCount,
+    }
+  }
+  return {
+    title: streaming ? "思考中..." : "思考过程",
+    stageCount: null,
+  }
+}
+
+/** 模型 reasoning 流式输出常带大量换行；合并为连续文本，避免被误切成上百个“阶段”。 */
+function formatThinkingForDisplay(content: string): string {
+  const trimmed = content.trim()
+  if (!trimmed) return ""
+
+  if (countWorkflowStages(trimmed) > 0) {
+    return trimmed.replace(/\n{3,}/g, "\n\n")
+  }
+
+  return trimmed.replace(/\s*\n+\s*/g, "")
+}
+
 /** Streaming workflow: show stages as they come in so user can see progress. */
 function StreamingWorkflowBlock({ content }: { content: string }) {
-  const paragraphs = content
-    .split(/\n\s*\n/)
-    .map((p) => p.replace(/\n/g, " ").trim())
-    .filter((p) => p.length > 0);
+  const displayContent = useMemo(() => formatThinkingForDisplay(content), [content])
+  const { title } = useMemo(() => getThinkingBlockMeta(content, true), [content])
 
   return (
-    <div className="rounded-md border border-dashed border-blue-500/30 bg-blue-50/50 dark:bg-blue-950/20 px-2.5 py-2 min-h-[3rem]">
+    <div className="w-full min-w-0 rounded-md border border-dashed border-blue-500/30 bg-blue-50/50 dark:bg-blue-950/20 px-2.5 py-2 min-h-[3rem]">
       <div className="flex items-center gap-1.5 mb-1.5">
         <span className="text-sm animate-pulse">📋</span>
-        <span className="text-xs font-medium text-blue-700 dark:text-blue-400">
-          工作流进行中...
-        </span>
+        <span className="text-xs font-medium text-blue-700 dark:text-blue-400">{title}</span>
       </div>
-      <div className="max-h-72 overflow-y-auto pr-1 text-xs text-blue-800/70 dark:text-blue-300/60 leading-relaxed whitespace-pre-wrap break-words">
-        {paragraphs.map((p, i) => (
-          <div key={`p-${i}`} className={i > 0 ? "mt-1.5" : ""}>
-            {p}
-          </div>
-        ))}
+      <div className="w-full min-w-0 max-h-72 overflow-y-auto overflow-x-hidden pr-1 text-xs text-blue-800/70 dark:text-blue-300/60 leading-relaxed whitespace-pre-wrap [overflow-wrap:anywhere]">
+        {displayContent}
         <span className="animate-pulse text-blue-500">▊</span>
       </div>
     </div>
@@ -1094,26 +1116,20 @@ function StreamingWorkflowBlock({ content }: { content: string }) {
 
 /** Completed workflow stages: keep visible so user can review what happened. */
 function WorkflowBlock({ content }: { content: string }) {
-  const paragraphs = content
-    .split(/\n\s*\n/)
-    .map((p) => p.replace(/\n/g, " ").trim())
-    .filter((p) => p.length > 0);
+  const displayContent = useMemo(() => formatThinkingForDisplay(content), [content])
+  const { title, stageCount } = useMemo(() => getThinkingBlockMeta(content, false), [content])
 
   return (
-    <div className="mb-2 rounded-md border border-dashed border-blue-500/30 bg-blue-50/50 dark:bg-blue-950/20 min-h-[3rem]">
+    <div className="mb-2 w-full min-w-0 rounded-md border border-dashed border-blue-500/30 bg-blue-50/50 dark:bg-blue-950/20 min-h-[3rem]">
       <div className="flex w-full items-center gap-1.5 px-2.5 py-1.5 text-xs text-blue-700 dark:text-blue-400">
         <span className="text-sm">📋</span>
-        <span className="font-medium">工作流阶段</span>
-        <span className="text-[10px] text-blue-600/60 dark:text-blue-500/60">
-          {paragraphs.length} 个阶段
-        </span>
+        <span className="font-medium">{title}</span>
+        {stageCount !== null && (
+          <span className="text-[10px] text-blue-600/60 dark:text-blue-500/60">{stageCount} 个阶段</span>
+        )}
       </div>
-      <div className="max-h-72 overflow-y-auto border-t border-blue-500/20 px-2.5 py-2 pr-1 text-xs text-blue-800/80 dark:text-blue-300/70 whitespace-pre-wrap break-words leading-relaxed">
-        {paragraphs.map((p, i) => (
-          <div key={`p-${i}`} className={i > 0 ? "mt-1.5" : ""}>
-            {p}
-          </div>
-        ))}
+      <div className="w-full min-w-0 max-h-72 overflow-y-auto overflow-x-hidden border-t border-blue-500/20 px-2.5 py-2 pr-1 text-xs text-blue-800/80 dark:text-blue-300/70 whitespace-pre-wrap leading-relaxed [overflow-wrap:anywhere]">
+        {displayContent}
       </div>
     </div>
   );

src/components/chat/chat-panel.tsx

@@ -1623,6 +1623,10 @@ export function ChatPanel() {
       ))
     abortControllersRef.current[convId]?.abort()
     delete abortControllersRef.current[convId]
+    const finalizeStopped = () => {
+      finalizeStream(`${currentStreamingContent ? `${currentStreamingContent}\n\n` : ""}已停止生成。`, [], convId)
+      delete activeStreamSessionsRef.current[convId]
+    }
     if (sessionId !== undefined) {
       streamSessionGuardRef.current.stop(convId, sessionId, () => {
         if (runningAssistant) {
@@ -1635,10 +1639,12 @@ export function ChatPanel() {
           }))
           clearStreaming(convId)
         } else {
-          finalizeStream(`${currentStreamingContent ? `${currentStreamingContent}\n\n` : ""}已停止生成。`, [], convId)
+          finalizeStopped()
         }
         delete activeStreamSessionsRef.current[convId]
       })
+    } else if (currentStreamingContent !== undefined) {
+      finalizeStopped()
     }
   }, [clearStreaming, finalizeStream])
 

src/components/layout/knowledge-tree.tsx

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react"
-import { BookOpen, ChevronDown, ChevronRight, FileText, Folder, FolderInput, FolderOpen, Globe, Loader2, MessageCircle, Pencil, Plus, Trash2, Check, X } from "lucide-react"
+import { BookOpen, ChevronDown, ChevronRight, FileText, Folder, FolderInput, FolderOpen, Globe, Loader2, MessageCircle, Pencil, Plus, Sparkles, Trash2, Check, X } from "lucide-react"
 import { useTranslation } from "react-i18next"
 import { ScrollArea } from "@/components/ui/scroll-area"
 import { Button } from "@/components/ui/button"
@@ -12,10 +12,36 @@ import { countChapterBodyWords } from "@/lib/chapter-word-count"
 import { normalizeChapterStatus, type ChapterStatus } from "@/lib/novel/chapter-meta"
 import { moveFileToTrash } from "@/lib/trash"
 import { makeChapterFileName, makeDefaultChapterTitle, makeSafeFileSlug } from "@/lib/wiki-filename"
-import { useImportProgressStore } from "@/stores/import-progress-store"
+import { useImportProgressStore, type ImportProgressTask } from "@/stores/import-progress-store"
+import { useOutlineGenerationStore } from "@/stores/outline-generation-store"
+import { startOutlineIngestTask } from "@/lib/novel/outline-generation"
+import { getOutlineFileName, outlineSnapshotExists } from "@/lib/novel/outline-ingest-utils"
 import { saveLastReadChapter } from "@/lib/project-store"
 import type { ReferenceToken } from "@/lib/reference/types"
 
+function formatImportProgressRunningLabel(task: ImportProgressTask, kindLabel: string): string {
+  if (task.cancelling) return `正在取消${kindLabel}提取...`
+
+  const activeTitles = task.activeTitles?.filter(Boolean) ?? []
+
+  if (activeTitles.length > 1) {
+    const preview = activeTitles.slice(0, 2).join("、")
+    return activeTitles.length > 2 ? `${preview} 等${activeTitles.length}个` : preview
+  }
+
+  if (activeTitles.length === 1) return activeTitles[0]!
+  return task.currentTitle || `${kindLabel}提取中`
+}
+
+function formatImportProgressDetail(task: ImportProgressTask): string {
+  const base = `${task.completed}/${task.total}`
+  const activeCount = task.activeTitles?.length ?? 0
+  if ((task.concurrency ?? 1) > 1 && activeCount > 1) {
+    return `${base} · ${activeCount} 路并行`
+  }
+  return base
+}
+
 interface WikiPageInfo {
   path: string
   title: string
@@ -283,13 +309,17 @@ export function KnowledgeTree({
 }: KnowledgeTreeProps) {
   const { t } = useTranslation()
   const project = useWikiStore((s) => s.project)
+  const novelMode = useWikiStore((s) => s.novelMode)
   const selectedFile = useWikiStore((s) => s.selectedFile)
   const setSelectedFile = useWikiStore((s) => s.setSelectedFile)
   const fileTree = useWikiStore((s) => s.fileTree)
   const setFileTree = useWikiStore((s) => s.setFileTree)
   const bumpDataVersion = useWikiStore((s) => s.bumpDataVersion)
   const dataVersion = useWikiStore((s) => s.dataVersion)
+  const outlineTasks = useOutlineGenerationStore((s) => s.tasks)
+  const outlineImportTasks = useImportProgressStore((s) => s.tasks)
   const [pages, setPages] = useState<WikiPageInfo[]>([])
+  const [extractedOutlinePaths, setExtractedOutlinePaths] = useState<Set<string>>(() => new Set())
   const [collapsedFolders, setCollapsedFolders] = useState<Record<string, boolean>>({})
   const [armedPath, setArmedPath] = useState<string | null>(null)
   const [deletingPath, setDeletingPath] = useState<string | null>(null)
@@ -391,6 +421,59 @@ export function KnowledgeTree({
 
   const effectivePages = useMemo(() => [...pageInfoByPath.values()], [pageInfoByPath])
 
+  const outlinePages = useMemo(
+    () => effectivePages.filter((page): page is WikiPageInfo & { type: "outline" } => page.type === "outline"),
+    [effectivePages],
+  )
+
+  useEffect(() => {
+    if (!project || filterType !== "outline" || !novelMode) {
+      setExtractedOutlinePaths(new Set())
+      return
+    }
+    let cancelled = false
+    void (async () => {
+      const extracted = new Set<string>()
+      await Promise.all(outlinePages.map(async (page) => {
+        if (await outlineSnapshotExists(project.path, page.path)) {
+          extracted.add(normalizePath(page.path))
+        }
+      }))
+      if (!cancelled) setExtractedOutlinePaths(extracted)
+    })()
+    return () => {
+      cancelled = true
+    }
+  }, [filterType, novelMode, outlinePages, project, dataVersion, outlineTasks, outlineImportTasks])
+
+  const isOutlinePathIngesting = useCallback((outlinePath: string) => {
+    if (!project) return false
+    const normalizedPath = normalizePath(outlinePath)
+    const fileName = getOutlineFileName(normalizedPath)
+    const pp = normalizePath(project.path)
+    const importRunning = outlineImportTasks.find((task) => (
+      task.projectPath === pp &&
+      task.kind === "outline" &&
+      task.status === "running"
+    ))
+    if (importRunning) {
+      if (importRunning.total === 1 && importRunning.currentTitle === fileName) return true
+      if (importRunning.activeTitles?.includes(fileName)) return true
+    }
+    return outlineTasks.some((task) => (
+      task.projectPath === pp &&
+      task.kind === "ingest" &&
+      task.outlinePath != null &&
+      normalizePath(task.outlinePath) === normalizedPath &&
+      task.status === "ingesting"
+    ))
+  }, [outlineImportTasks, outlineTasks, project])
+
+  const handleOutlineIngest = useCallback((outlinePath: string) => {
+    if (!project || !novelMode || isOutlinePathIngesting(outlinePath)) return
+    startOutlineIngestTask(project.path, outlinePath)
+  }, [isOutlinePathIngesting, novelMode, project])
+
   const sortedChapterPages = useMemo(() => {
     return effectivePages
       .filter((page): page is WikiPageInfo & { type: "chapter" } => page.type === "chapter")
@@ -1154,6 +1237,8 @@ export function KnowledgeTree({
       const isDragSource = dragSource === normalizedPath
       const chapterIndex = chapterIndexMap.get(normalizedPath)
       const isInsertTarget = isDragging && dragInsertIndex !== null && chapterIndex !== undefined && chapterIndex === dragInsertIndex && !isDragSource
+      const isOutlineExtracted = filterType === "outline" && extractedOutlinePaths.has(normalizedPath)
+      const isOutlineIngesting = filterType === "outline" && isOutlinePathIngesting(normalizedPath)
       return [
         <div
           key={normalizedPath}
@@ -1227,6 +1312,27 @@ export function KnowledgeTree({
               </>
             )}
           </button>
+          {filterType === "outline" && novelMode ? (
+            <Button
+              variant="ghost"
+              size="icon"
+              className={`mr-0 h-7 w-7 shrink-0 ${isOutlineExtracted ? "text-emerald-600 hover:text-emerald-700" : ""}`}
+              title={isOutlineExtracted ? t("novel.outlineGenerator.reingestTitle") : t("novel.outlineGenerator.ingest")}
+              disabled={isOutlineIngesting}
+              onClick={(event) => {
+                event.stopPropagation()
+                handleOutlineIngest(normalizedPath)
+              }}
+            >
+              {isOutlineIngesting ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : isOutlineExtracted ? (
+                <Check className="h-4 w-4" />
+              ) : (
+                <Sparkles className="h-4 w-4" />
+              )}
+            </Button>
+          ) : null}
           <DeleteButton
             armed={isArmed}
             deleting={isDeleting}
@@ -1262,6 +1368,10 @@ export function KnowledgeTree({
     dragInsertIndex,
     isDragging,
     sortedChapterPages,
+    novelMode,
+    extractedOutlinePaths,
+    isOutlinePathIngesting,
+    handleOutlineIngest,
     t,
   ])
 
@@ -1615,9 +1725,7 @@ export function RawSourcesSection({ onCancelExtraction }: { onCancelExtraction?:
                       ) : null}
                       <span className={isRunning ? "text-foreground font-medium" : ""}>
                         {isRunning
-                          ? task.cancelling
-                            ? `正在取消${kindLabel}提取...`
-                            : task.currentTitle || `${kindLabel}提取中`
+                          ? formatImportProgressRunningLabel(task, kindLabel)
                           : task.status === "done"
                             ? `${kindLabel}提取完成`
                             : task.status === "error"
@@ -1656,9 +1764,9 @@ export function RawSourcesSection({ onCancelExtraction }: { onCancelExtraction?:
                       />
                     </div>
                   )}
-                  {isRunning && task.completed > 0 && (
+                  {isRunning && (
                     <span className="text-muted-foreground">
-                      {task.completed}/{task.total} · {kindLabel}
+                      {formatImportProgressDetail(task)}
                     </span>
                   )}
                 </div>

src/components/layout/preview-panel.tsx

@@ -2,7 +2,7 @@
 import { useTranslation } from "react-i18next"
 import { Check, MoreHorizontal, X } from "lucide-react"
 import { useWikiStore } from "@/stores/wiki-store"
-import { resolveDefaultModel, resolveNovelModel } from "@/lib/novel/model-resolver"
+import { resolveDefaultModel, resolveNovelModel, formatResolvedModelLabel } from "@/lib/novel/model-resolver"
 import type { FinalChapterSavePhase } from "@/stores/wiki-store"
 import { useReviewStore } from "@/stores/review-store"
 import { deleteFile, fileExists, readFile, writeFile, writeFileAtomic, listDirectory } from "@/commands/fs"
@@ -30,7 +30,8 @@ import {
   saveDeAiSkillConfig,
   setLastChapterDeAiSkill,
 } from "@/lib/novel/de-ai-skill-library"
-import { startOutlineIngestTask } from "@/lib/novel/outline-ingest"
+import { startOutlineIngestTask } from "@/lib/novel/outline-generation"
+import { getOutlineIngestIdentity, getOutlineFileName, outlineSnapshotExists } from "@/lib/novel/outline-ingest-utils"
 import { streamChat } from "@/lib/llm-client"
 import {
   extractChapterNumberFromMarkdown,
@@ -174,6 +175,7 @@ export function PreviewPanel() {
   const pendingEditorHighlight = useWikiStore((s) => s.pendingEditorHighlight)
   const setPendingEditorHighlight = useWikiStore((s) => s.setPendingEditorHighlight)
   const bumpDataVersion = useWikiStore((s) => s.bumpDataVersion)
+  const dataVersion = useWikiStore((s) => s.dataVersion)
   const finalChapterSave = useWikiStore((s) => s.finalChapterSave)
   const setFinalChapterSave = useWikiStore((s) => s.setFinalChapterSave)
   const outlineTasks = useOutlineGenerationStore((s) => s.tasks)
@@ -192,6 +194,7 @@ export function PreviewPanel() {
   const [deAiSourceContent, setDeAiSourceContent] = useState("")
   const [deAiCandidateContent, setDeAiCandidateContent] = useState("")
   const [deAiSkillName, setDeAiSkillName] = useState("")
+  const [deAiModelName, setDeAiModelName] = useState("")
   const [deAiSkillMemoryWarning, setDeAiSkillMemoryWarning] = useState("")
   const [selectionTransformOpen, setSelectionTransformOpen] = useState(false)
   const [selectionTransformAction, setSelectionTransformAction] = useState<ChapterSelectionAction | null>(null)
@@ -199,6 +202,7 @@ export function PreviewPanel() {
   const [selectionTransformSourceContent, setSelectionTransformSourceContent] = useState("")
   const [selectionTransformCandidateContent, setSelectionTransformCandidateContent] = useState("")
   const [selectionTransformSkillName, setSelectionTransformSkillName] = useState("")
+  const [selectionTransformModelName, setSelectionTransformModelName] = useState("")
   const [deAiSkillPickerOpen, setDeAiSkillPickerOpen] = useState(false)
   const [deAiSkillPickerPosition, setDeAiSkillPickerPosition] = useState<CSSProperties>(() => getDeAiSkillPickerPosition())
   const [chapterDeAiSkillId, setChapterDeAiSkillId] = useState<string | null | undefined>(undefined)
@@ -390,7 +394,9 @@ export function PreviewPanel() {
     setSelectionTransformOpen(false)
     setDeAiPreviewOpen(false)
     setDeAiSkillName("")
+    setDeAiModelName("")
     setSelectionTransformSkillName("")
+    setSelectionTransformModelName("")
     setLoadedFilePath(null)
 
     if (!selectedFile) {
@@ -551,6 +557,26 @@ export function PreviewPanel() {
       .sort((a: OutlineGenerationTask, b: OutlineGenerationTask) => b.updatedAt - a.updatedAt)[0] ?? null
   }, [canIngestOutline, outlineTasks, project, selectedFile])
 
+  const outlineIngestProgressRunning = useImportProgressStore((s) => {
+    if (!project || !canIngestOutline || !selectedFile) return null
+    const pp = normalizePath(project.path)
+    return s.tasks.find((task) => (
+      task.projectPath === pp &&
+      task.kind === "outline" &&
+      task.status === "running"
+    )) ?? null
+  })
+  const isOutlineIngesting = useMemo(() => {
+    if (!project || !selectedFile || !canIngestOutline) return false
+    const fileName = getOutlineFileName(selectedFile)
+    if (outlineIngestProgressRunning) {
+      if (outlineIngestProgressRunning.total === 1) return true
+      if (outlineIngestProgressRunning.currentTitle === fileName) return true
+      if (outlineIngestProgressRunning.activeTitles?.includes(fileName)) return true
+    }
+    return currentOutlineTask?.status === "ingesting"
+  }, [canIngestOutline, currentOutlineTask, outlineIngestProgressRunning, project, selectedFile])
+
   // 检测大纲是否已经提取过初始记忆（持久化状态）
   useEffect(() => {
     if (!canIngestOutline || !project || !selectedFile) {
@@ -558,24 +584,29 @@ export function PreviewPanel() {
       setOutlineSnapshotNumber(null)
       return
     }
-    const normalizedOutlinePath = normalizePath(selectedFile)
-    const fileName = normalizedOutlinePath.split("/").pop() ?? "outline"
-    const outlineName = fileName.replace(/\.\w+$/, "")
-    let hash = 0
-    for (let i = 0; i < outlineName.length; i++) {
-      hash = ((hash << 5) - hash + outlineName.charCodeAt(i)) | 0
+    const { chapterNumber } = getOutlineIngestIdentity(project.path, selectedFile)
+    setOutlineSnapshotNumber(chapterNumber)
+    let cancelled = false
+    void outlineSnapshotExists(project.path, selectedFile)
+      .then((exists) => {
+        if (!cancelled) setOutlineIngested(exists)
+      })
+      .catch(() => {
+        if (!cancelled) setOutlineIngested(false)
+      })
+    return () => {
+      cancelled = true
     }
-    const outlineNum = -(Math.abs(hash % 999) + 1)
-    setOutlineSnapshotNumber(outlineNum)
-    const prefix = `outline-${String(Math.abs(outlineNum)).padStart(3, "0")}`
-    const jsonPath = `${normalizePath(project.path)}/.novel/snapshots/${prefix}.snapshot.json`
-    fileExists(jsonPath).then((exists) => setOutlineIngested(exists)).catch(() => setOutlineIngested(false))
-  }, [canIngestOutline, project, selectedFile])
+  }, [canIngestOutline, project, selectedFile, dataVersion, currentOutlineTask?.status, currentOutlineTask?.updatedAt])
   useEffect(() => {
     if (!canIngestOutline) return
     if (!currentOutlineTask?.message) return
+    if (currentOutlineTask.status === "ingesting" && !outlineIngestProgressRunning) {
+      setSaveStatus("")
+      return
+    }
     setSaveStatus(currentOutlineTask.message)
-  }, [canIngestOutline, currentOutlineTask])
+  }, [canIngestOutline, currentOutlineTask, outlineIngestProgressRunning])
   const chapterNumber = useMemo(() => {
     if (!chapterFrontmatter) return null
     const meta = parseChapterMeta(chapterFrontmatter)
@@ -584,7 +615,6 @@ export function PreviewPanel() {
   const canViewSnapshot = Boolean(novelMode && project && chapterNumber !== null)
   const currentFinalChapterSave = finalChapterSave != null && finalChapterSave.projectPath === project?.path && finalChapterSave.filePath === selectedFile ? finalChapterSave : null
   const isFinalChapterSaving = currentFinalChapterSave?.saving ?? isSavingFinal
-  const isOutlineIngesting = currentOutlineTask?.status === "ingesting"
 
   const phaseLabelMap: Record<FinalChapterSavePhase, string> = {
     saving: t("novel.chapter.savingAsFinal"),
@@ -949,12 +979,14 @@ export function PreviewPanel() {
     setDeAiSkillName(skillName)
     const state = useWikiStore.getState()
     const llmConfig = resolveNovelModel(state.llmConfig, state.novelConfig, "deAi")
+    const modelLabel = formatResolvedModelLabel(llmConfig, state.providerConfigs)
+    setDeAiModelName(modelLabel)
     if (!hasUsableLlm(llmConfig, state.providerConfigs)) {
       setDeAiProcessing(false)
       setSaveStatus("未配置可用的 AI 模型，无法去AI味")
       return
     }
-    setSaveStatus(formatDeAiStatus(`去AI味处理中，使用 Skill：${skillName}...`))
+    setSaveStatus(formatDeAiStatus(`去AI味处理中，使用 Skill：${skillName}，模型：${modelLabel}...`))
     let result = ""
     try {
       await streamChat(
@@ -969,7 +1001,7 @@ export function PreviewPanel() {
             setDeAiCandidateContent(result)
             setDeAiPreviewOpen(true)
             setDeAiProcessing(false)
-            setSaveStatus(formatDeAiStatus(`本次使用 Skill：${skillName}`))
+            setSaveStatus(formatDeAiStatus(`本次使用 Skill：${skillName}，模型：${modelLabel}`))
           },
           onError: (error) => {
             console.error("去AI味处理失败:", error)
@@ -986,6 +1018,7 @@ export function PreviewPanel() {
   const handleDeAiApply = useCallback(() => {
     setDeAiPreviewOpen(false)
     setDeAiSkillName("")
+    setDeAiModelName("")
     handleSave(replaceWholeChapterBody(fileContent, deAiCandidateContent))
   }, [deAiCandidateContent, fileContent, handleSave])
 
@@ -1010,6 +1043,7 @@ export function PreviewPanel() {
   const handleDeAiClose = useCallback(() => {
     setDeAiPreviewOpen(false)
     setDeAiSkillName("")
+    setDeAiModelName("")
   }, [])
 
   const runSelectionTransform = useCallback(async (
@@ -1033,9 +1067,11 @@ export function PreviewPanel() {
 
     const actionFile = selectedFileRef.current
     const actionLabel = action === "polish" ? "AI润色" : "去AI味"
+    const modelLabel = formatResolvedModelLabel(llmConfig, state.providerConfigs)
     setSelectionTransformSkillName(action === "de-ai" ? skillName ?? "" : "")
+    setSelectionTransformModelName(action === "de-ai" ? modelLabel : "")
     const transformStatus = action === "de-ai" && skillName
-      ? `${actionLabel}处理中，使用 Skill：${skillName}...`
+      ? `${actionLabel}处理中，使用 Skill：${skillName}，模型：${modelLabel}...`
       : `${actionLabel}处理中...`
     setSaveStatus(action === "de-ai" ? formatDeAiStatus(transformStatus) : transformStatus)
 
@@ -1352,7 +1388,11 @@ export function PreviewPanel() {
                       disabled={isOutlineIngesting}
                       className="block w-full rounded px-2 py-1.5 text-left hover:bg-accent disabled:cursor-not-allowed disabled:opacity-50"
                     >
-                      {isOutlineIngesting ? t("novel.outlineGenerator.ingesting") : outlineIngested ? "已提取记忆" : t("novel.outlineGenerator.ingest")}
+                      {isOutlineIngesting
+                        ? t("novel.outlineGenerator.ingesting")
+                        : outlineIngested
+                          ? t("novel.outlineGenerator.reingestButton")
+                          : t("novel.outlineGenerator.ingest")}
                     </button>
                   ) : null}
                   {canIngestOutline && outlineIngested && outlineSnapshotNumber !== null ? (
@@ -1456,9 +1496,13 @@ export function PreviewPanel() {
                   ? "border-emerald-500/50 text-emerald-700 hover:bg-emerald-50 dark:text-emerald-300 dark:hover:bg-emerald-950/30"
                   : "border-border text-foreground hover:bg-accent"
               }`}
-              title={outlineIngested ? "重新提取初始记忆（将覆盖上次提取的内容）" : t("novel.outlineGenerator.ingest")}
+              title={outlineIngested ? t("novel.outlineGenerator.reingestTitle") : t("novel.outlineGenerator.ingest")}
             >
-              {isOutlineIngesting ? t("novel.outlineGenerator.ingesting") : outlineIngested ? "✓ 已提取记忆" : t("novel.outlineGenerator.ingest")}
+              {isOutlineIngesting
+                ? t("novel.outlineGenerator.ingesting")
+                : outlineIngested
+                  ? t("novel.outlineGenerator.reingestButton")
+                  : t("novel.outlineGenerator.ingest")}
             </button>
           ) : null}
           {!chapterToolbarCompact && canIngestOutline && outlineIngested && outlineSnapshotNumber !== null ? (
@@ -1622,6 +1666,7 @@ export function PreviewPanel() {
         sourceContent={deAiSourceContent}
         candidateContent={deAiCandidateContent}
         skillName={deAiSkillName}
+        modelName={deAiModelName}
         onApply={handleDeAiApply}
         onSaveDraft={() => void handleDeAiSaveDraft()}
         onClose={handleDeAiClose}
@@ -1630,7 +1675,7 @@ export function PreviewPanel() {
         open={selectionTransformOpen}
         title={selectionTransformAction === "polish" ? "AI润色预览" : "去AI味预览"}
         description={selectionTransformAction === "de-ai" && selectionTransformSkillName
-          ? `本次使用 Skill：${selectionTransformSkillName}。确认后会替换当前选中的正文片段。`
+          ? `本次使用 Skill：${selectionTransformSkillName}${selectionTransformModelName ? `，模型：${selectionTransformModelName}` : ""}。确认后会替换当前选中的正文片段。`
           : "确认后会替换当前选中的正文片段。"}
         sourceLabel="原文片段"
         candidateLabel={selectionTransformAction === "polish" ? "润色结果" : "去AI味结果"}

src/components/novel/de-ai-preview-dialog.tsx

@@ -12,6 +12,7 @@ export interface DeAiPreviewDialogProps {
   sourceContent: string
   candidateContent: string
   skillName?: string
+  modelName?: string
   onApply: () => void
   onSaveDraft: () => void
   onClose: () => void
@@ -22,6 +23,7 @@ export function DeAiPreviewDialog({
   sourceContent,
   candidateContent,
   skillName,
+  modelName,
   onApply,
   onSaveDraft,
   onClose,
@@ -32,7 +34,10 @@ export function DeAiPreviewDialog({
         <DialogHeader>
           <DialogTitle>去AI味预览</DialogTitle>
           {skillName ? (
-            <div className="text-xs text-muted-foreground">本次使用 Skill：{skillName}</div>
+            <div className="text-xs text-muted-foreground">
+              本次使用 Skill：{skillName}
+              {modelName ? `，模型：${modelName}` : ""}
+            </div>
           ) : null}
         </DialogHeader>
         <div className="grid grid-cols-2 gap-4">

src/components/sources/outline-action-toolbar.tsx

@@ -1,9 +1,12 @@
-import { useCallback, useMemo, useState } from "react"
-import { Loader2, MessageSquare } from "lucide-react"
+import { useCallback, useState } from "react"
+import { Loader2, MessageSquare, Sparkles } from "lucide-react"
 import { useTranslation } from "react-i18next"
 import { Button } from "@/components/ui/button"
-import { runBulkOutlineIngest } from "@/lib/novel/outline-ingest"
+import { OutlineGeneratorDialog, type OutlineGeneratorMode } from "@/components/sources/outline-generator-dialog"
+import { runBulkOutlineIngest, formatBulkOutlineIngestResult, OutlineIngestNotReadyError } from "@/lib/novel/outline-generation"
 import { cn } from "@/lib/utils"
+import { toast } from "@/lib/toast"
+import { useImportProgressStore } from "@/stores/import-progress-store"
 import { useOutlineGenerationStore } from "@/stores/outline-generation-store"
 import { useWikiStore } from "@/stores/wiki-store"
 
@@ -21,17 +24,25 @@ export function OutlineActionToolbar({
   const { t } = useTranslation()
   const project = useWikiStore((s) => s.project)
   const setActiveView = useWikiStore((s) => s.setActiveView)
-  const outlineTasks = useOutlineGenerationStore((s) => s.tasks)
   const setOutlineChatOpen = useOutlineGenerationStore((s) => s.setPanelOpen)
+  const [outlineDialogOpen, setOutlineDialogOpen] = useState(false)
+  const [outlineDialogMode, setOutlineDialogMode] = useState<OutlineGeneratorMode>("outline")
   const [bulkIngestRunning, setBulkIngestRunning] = useState(false)
 
-  const bulkIngesting = useMemo(() => (
-    project != null && outlineTasks.some((task) => (
+  const bulkOutlineProgressRunning = useImportProgressStore((s) => (
+    project != null && s.tasks.some((task) => (
       task.projectPath === project.path &&
-      task.kind === "ingest" &&
-      task.status === "ingesting"
+      task.kind === "outline" &&
+      task.status === "running"
     ))
-  ), [outlineTasks, project])
+  ))
+
+  const bulkIngestActive = bulkIngestRunning || bulkOutlineProgressRunning
+
+  function openOutlineDialog(mode: OutlineGeneratorMode) {
+    setOutlineDialogMode(mode)
+    setOutlineDialogOpen(true)
+  }
 
   const handleOpenOutlineChat = useCallback(() => {
     if (onToggleOutlineChat) {
@@ -43,45 +54,56 @@ export function OutlineActionToolbar({
   }, [onToggleOutlineChat, setActiveView, setOutlineChatOpen])
 
   const handleBulkIngest = useCallback(async () => {
-    if (!project || bulkIngestRunning || bulkIngesting) return
+    if (!project || bulkIngestActive) return
     setBulkIngestRunning(true)
     onBulkIngestResult?.(null)
     try {
       const result = await runBulkOutlineIngest(project.path)
-      if (result.total === 0) {
-        onBulkIngestResult?.(t("novel.outlineGenerator.bulkIngestEmpty"))
-      } else {
-        onBulkIngestResult?.(t("novel.outlineGenerator.bulkIngestResult", result))
-      }
+      onBulkIngestResult?.(formatBulkOutlineIngestResult(result))
     } catch (err) {
+      if (err instanceof OutlineIngestNotReadyError) {
+        toast.error(err.message)
+        onBulkIngestResult?.(err.message)
+        return
+      }
       const message = err instanceof Error ? err.message : String(err)
       onBulkIngestResult?.(t("novel.outlineGenerator.bulkIngestError", { message }))
     } finally {
       setBulkIngestRunning(false)
     }
-  }, [bulkIngestRunning, bulkIngesting, onBulkIngestResult, project, t])
+  }, [bulkIngestActive, onBulkIngestResult, project, t])
 
   return (
-    <div className={cn("flex flex-wrap gap-1", className)}>
-      <Button size="sm" variant="outline" onClick={handleOpenOutlineChat}>
-        <MessageSquare className="mr-1 h-4 w-4" />
-        AI大纲
-      </Button>
-      <Button
-        size="sm"
-        variant="outline"
-        onClick={() => void handleBulkIngest()}
-        disabled={bulkIngestRunning || bulkIngesting}
-      >
-        {bulkIngestRunning || bulkIngesting ? (
-          <>
-            <Loader2 className="mr-1 h-4 w-4 animate-spin" />
-            {t("novel.outlineGenerator.bulkIngesting")}
-          </>
-        ) : (
-          t("novel.outlineGenerator.bulkIngest")
-        )}
-      </Button>
-    </div>
+    <>
+      <div className={cn("flex flex-wrap gap-1", className)}>
+        <Button size="sm" onClick={() => openOutlineDialog("outline")}>
+          <Sparkles className="mr-1 h-4 w-4" />
+          {t("novel.outlineGenerator.title")}
+        </Button>
+        <Button size="sm" variant="outline" onClick={handleOpenOutlineChat}>
+          <MessageSquare className="mr-1 h-4 w-4" />
+          AI大纲
+        </Button>
+        <Button size="sm" variant="outline" onClick={() => openOutlineDialog("refine")}>
+          {t("novel.outlineGenerator.refineTitle")}
+        </Button>
+        <Button size="sm" variant="outline" onClick={() => void handleBulkIngest()} disabled={bulkIngestActive}>
+          {bulkIngestActive ? (
+            <>
+              <Loader2 className="mr-1 h-4 w-4 animate-spin" />
+              {t("novel.outlineGenerator.bulkIngesting")}
+            </>
+          ) : (
+            t("novel.outlineGenerator.bulkIngest")
+          )}
+        </Button>
+      </div>
+
+      <OutlineGeneratorDialog
+        open={outlineDialogOpen}
+        onOpenChange={setOutlineDialogOpen}
+        mode={outlineDialogMode}
+      />
+    </>
   )
 }

src/components/sources/sources-view.tsx

@@ -24,7 +24,7 @@ export function SourcesView() {
       </div>
 
       {bulkIngestResult ? (
-        <div className="border-b px-4 py-2 text-xs text-muted-foreground">
+        <div className="border-b px-4 py-2 text-xs text-muted-foreground whitespace-pre-line">
           {bulkIngestResult}
         </div>
       ) : null}

src/i18n/en.json

@@ -1400,10 +1400,22 @@
       "error": "Generation failed",
       "ingest": "Extract Initial Memory",
       "ingesting": "Extracting initial memory...",
+      "reingestButton": "Re-extract Memory",
+      "reingestTitle": "Re-extract initial memory (overwrites the previous extraction)",
       "bulkIngest": "Extract All",
       "bulkIngesting": "Extracting all...",
       "bulkIngestEmpty": "There are no outline documents to extract in the current outline library.",
       "bulkIngestResult": "Bulk extraction complete: {{succeeded}} succeeded, {{failed}} failed, {{total}} total.",
+      "bulkIngestResultWithFailures": "Bulk extraction complete: {{succeeded}} succeeded, {{failed}} failed, {{total}} total. Failures:",
+      "bulkIngestMoreFailures": "{{count}} more outline(s) failed to extract.",
+      "bulkIngestCancelled": "Bulk extraction cancelled: {{succeeded}} succeeded, {{failed}} failed, {{total}} total.",
+      "bulkIngestCancelledProgress": "Bulk extraction cancelled. {{succeeded}}/{{total}} succeeded.",
+      "bulkIngestProgressDone": "Bulk extraction complete: {{succeeded}}/{{total}} succeeded.",
+      "bulkIngestProgressWithFailures": "Bulk extraction complete: {{succeeded}} succeeded, {{failed}} failed. {{preview}}",
+      "bulkIngestSyncing": "Writing memory for {{name}}",
+      "bulkIngestParallel": "{{active}}/{{concurrency}} parallel extractions running",
+      "ingestNoLlm": "No usable extract model configured. Please configure an LLM in Settings first.",
+      "ingestCancelledNotification": "Outline ingestion cancelled",
       "bulkIngestError": "Bulk extraction failed: {{message}}",
       "generationMayTakeLong": "Outline generation may take a while. You can hide this dialog and work on something else; we will remind you later.",
       "hideAndContinue": "Hide and keep generating",
@@ -1417,6 +1429,8 @@
       "openedNotification": "Outline opened",
       "ingestingNotification": "Extracting initial project memory...",
       "ingestSuccessNotification": "Initial project memory extracted successfully",
+      "ingestSuccessTruncatedNotification": "Initial project memory extracted (outline truncated to fit context window: {{used}}/{{total}} chars, budget {{budget}} chars)",
+      "ingestProgressTruncated": "{{name}} extracted (truncated {{used}}/{{total}} chars)",
       "ingestFailedNotification": "Initial project memory extraction failed",
       "ingestError": "Initial project memory extraction failed: {{message}}",
       "addedToOutlineList": "Added to the outline list",

src/i18n/zh.json

@@ -1342,10 +1342,22 @@
       "error": "生成失败",
       "ingest": "提取初始记忆",
       "ingesting": "正在提取初始记忆...",
+      "reingestButton": "重新提取记忆",
+      "reingestTitle": "重新提取初始记忆（将覆盖上次提取的内容）",
       "bulkIngest": "一键提取",
       "bulkIngesting": "一键提取中...",
       "bulkIngestEmpty": "当前大纲库里没有可提取的大纲文档。",
       "bulkIngestResult": "一键提取完成：共 {{total}} 个大纲，成功 {{succeeded}} 个，失败 {{failed}} 个。",
+      "bulkIngestResultWithFailures": "一键提取完成：共 {{total}} 个大纲，成功 {{succeeded}} 个，失败 {{failed}} 个。失败明细：",
+      "bulkIngestMoreFailures": "另有 {{count}} 个大纲提取失败。",
+      "bulkIngestCancelled": "一键提取已取消：共 {{total}} 个大纲，成功 {{succeeded}} 个，失败 {{failed}} 个。",
+      "bulkIngestCancelledProgress": "已取消一键提取，成功 {{succeeded}}/{{total}} 个。",
+      "bulkIngestProgressDone": "一键提取完成：成功 {{succeeded}}/{{total}} 个。",
+      "bulkIngestProgressWithFailures": "一键提取完成：成功 {{succeeded}} 个，失败 {{failed}} 个。{{preview}}",
+      "bulkIngestSyncing": "正在写入 {{name}} 的记忆",
+      "bulkIngestParallel": "{{active}}/{{concurrency}} 路并行提取中",
+      "ingestNoLlm": "未配置可用的提取模型，请先在设置中配置 LLM。",
+      "ingestCancelledNotification": "大纲摄取已取消",
       "bulkIngestError": "一键提取失败：{{message}}",
       "generationMayTakeLong": "生成大纲可能需要较长时间，建议隐藏之后先去做其他的，稍后会提醒您。",
       "hideAndContinue": "隐藏并后台生成",
@@ -1359,6 +1371,8 @@
       "openedNotification": "已打开大纲",
       "ingestingNotification": "正在提取项目初始记忆...",
       "ingestSuccessNotification": "项目初始记忆提取成功",
+      "ingestSuccessTruncatedNotification": "项目初始记忆提取成功（大纲过长，已按上下文窗口截断：{{used}}/{{total}} 字，预算 {{budget}} 字）",
+      "ingestProgressTruncated": "{{name}} 提取完成（已截断 {{used}}/{{total}} 字）",
       "ingestFailedNotification": "项目初始记忆提取失败",
       "ingestError": "项目初始记忆提取失败：{{message}}",
       "addedToOutlineList": "已加入到大纲列表",

src/lib/async-pool.spec.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it, vi } from "vitest"
+import { mapWithConcurrency } from "./async-pool"
+
+describe("mapWithConcurrency", () => {
+  it("preserves result order", async () => {
+    const results = await mapWithConcurrency([1, 2, 3, 4], 2, async (value) => value * 2)
+    expect(results).toEqual([2, 4, 6, 8])
+  })
+
+  it("limits active workers", async () => {
+    let active = 0
+    let maxActive = 0
+
+    await mapWithConcurrency([1, 2, 3, 4, 5], 2, async (value) => {
+      active += 1
+      maxActive = Math.max(maxActive, active)
+      await new Promise((resolve) => setTimeout(resolve, 10))
+      active -= 1
+      return value
+    })
+
+    expect(maxActive).toBeLessThanOrEqual(2)
+  })
+
+  it("stops scheduling when signal is aborted", async () => {
+    const controller = new AbortController()
+    controller.abort()
+    const fn = vi.fn(async (value: number) => value)
+
+    await mapWithConcurrency([1, 2, 3], 2, fn, { signal: controller.signal })
+
+    expect(fn).not.toHaveBeenCalled()
+  })
+})

src/lib/async-pool.ts

@@ -0,0 +1,34 @@
+export interface MapWithConcurrencyOptions {
+  signal?: AbortSignal
+  onItemComplete?: (index: number) => void
+}
+
+/**
+ * Map items with a fixed concurrency limit. Result order matches input order.
+ */
+export async function mapWithConcurrency<T, R>(
+  items: readonly T[],
+  concurrency: number,
+  fn: (item: T, index: number) => Promise<R>,
+  options?: MapWithConcurrencyOptions,
+): Promise<R[]> {
+  if (items.length === 0) return []
+
+  const results: R[] = new Array(items.length)
+  let nextIndex = 0
+
+  async function worker(): Promise<void> {
+    while (true) {
+      if (options?.signal?.aborted) return
+      const index = nextIndex
+      nextIndex += 1
+      if (index >= items.length) return
+      results[index] = await fn(items[index], index)
+      options?.onItemComplete?.(index)
+    }
+  }
+
+  const workerCount = Math.max(1, Math.min(concurrency, items.length))
+  await Promise.all(Array.from({ length: workerCount }, () => worker()))
+  return results
+}

src/lib/context-budget.spec.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest"
+import {
+  computeOutlineIngestBodyBudget,
+  OUTLINE_INGEST_MIN_BODY_BUDGET,
+} from "./context-budget"
+
+describe("computeOutlineIngestBodyBudget", () => {
+  const promptOverhead = 2_500
+
+  it("uses at least the legacy floor on large windows", () => {
+    const budget = computeOutlineIngestBodyBudget(204_800, promptOverhead, 1)
+    expect(budget).toBeGreaterThan(OUTLINE_INGEST_MIN_BODY_BUDGET)
+  })
+
+  it("scales down for smaller context windows", () => {
+    const large = computeOutlineIngestBodyBudget(204_800, promptOverhead, 1)
+    const small = computeOutlineIngestBodyBudget(32_768, promptOverhead, 1)
+    expect(small).toBeLessThan(large)
+    expect(small).toBeGreaterThan(0)
+  })
+
+  it("applies CJK language scale", () => {
+    const english = computeOutlineIngestBodyBudget(128_000, promptOverhead, 1)
+    const cjk = computeOutlineIngestBodyBudget(128_000, promptOverhead, 0.425)
+    expect(cjk).toBeLessThan(english)
+  })
+})

src/lib/context-budget.ts

@@ -174,3 +174,39 @@ export function computeNovelContextTokenBudget(
   }
   return cap
 }
+
+/** Legacy single-pass outline ingest floor; kept so small windows still behave predictably. */
+export const OUTLINE_INGEST_MIN_BODY_BUDGET = 8_000
+/** Upper cap aligned with wiki long-source ingest. */
+export const OUTLINE_INGEST_MAX_BODY_BUDGET = 300_000
+
+function clampBudget(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value))
+}
+
+/**
+ * Character budget for the outline body in `ingestOutline`.
+ *
+ * Reserves space for fixed prompts and JSON output, then allocates the
+ * remainder to the outline markdown. Scales with `maxContextSize` and
+ * CJK language scale like other budget helpers.
+ */
+export function computeOutlineIngestBodyBudget(
+  maxContextSize: number | undefined,
+  promptOverheadChars: number,
+  langScale?: number,
+): number {
+  const { maxCtx, responseReserve } = computeContextBudget(maxContextSize, langScale)
+  const outputReserve = Math.max(responseReserve, Math.floor(maxCtx * 0.15))
+  const instructionReserve = Math.max(promptOverheadChars, Math.floor(maxCtx * 0.08))
+  const available = maxCtx - outputReserve - instructionReserve
+  const upper = Math.min(
+    OUTLINE_INGEST_MAX_BODY_BUDGET,
+    Math.max(OUTLINE_INGEST_MIN_BODY_BUDGET, Math.floor(maxCtx * 0.6)),
+  )
+  const min = Math.min(
+    OUTLINE_INGEST_MIN_BODY_BUDGET,
+    Math.max(1_000, Math.floor(available)),
+  )
+  return clampBudget(Math.floor(available), min, upper)
+}

src/lib/novel/chapter-ingest.ts

@@ -21,6 +21,7 @@ import { mergeSnapshotTimeline } from "./timeline"
 import { buildStructuredMemoryDocuments, isValidMemorySnapshot } from "./memory-rebuild"
 import { clearGraphCache } from "@/lib/graph-relevance"
 import { RetrievalStore } from "./retrieval"
+import { computeOutlineIngestBodyBudget } from "@/lib/context-budget"
 
 export interface ValidationWarning {
   type: "entity_new" | "canon_conflict"
@@ -675,6 +676,49 @@ function normalizeOutlineIngestError(err: unknown): Error {
   return new Error(message)
 }
 
+const OUTLINE_INGEST_JSON_TEMPLATE = `输出 JSON：
+{
+  "chapterId": "outline-init",
+  "chapterNumber": 0,
+  "summary": "大纲摘要",
+  "characters": ["初始人物"],
+  "locations": ["初始地点"],
+  "organizations": ["初始组织/势力"],
+  "items": ["关键物品"],
+  "events": ["背景事件"],
+  "characterStateChanges": ["人物初始状态"],
+  "relationshipChanges": ["人物初始关系"],
+  "knowledgeChanges": [],
+  "foreshadowingChanges": ["初始伏笔"],
+  "newCanonFacts": ["世界观正史设定"],
+  "timelineEvents": ["时间线背景"],
+  "conflicts": ["核心冲突"],
+  "endingHook": "",
+  "graphNodes": ["图谱节点列表"],
+  "graphEdges": ["图谱关系边，格式：A->关系->B。关系必须是以下之一：出场于|发生于|属于|持有|敌对|合作|怀疑|隐瞒|知道|不知道|推进伏笔|回收伏笔|新增伏笔|导致|揭示|影响|位于"]
+}`
+
+export interface OutlineIngestResult {
+  snapshot: ChapterSnapshot | null
+  truncated: boolean
+  originalLength: number
+  bodyLength: number
+  bodyBudget: number
+  failureReason?: "no_llm" | null
+}
+
+export interface IngestOutlineOptions {
+  skipSync?: boolean
+}
+
+function buildOutlineIngestUserPrompt(body: string): string {
+  return `请从以下大纲中提取初始设定：
+
+${body}
+
+${OUTLINE_INGEST_JSON_TEMPLATE}`
+}
+
 async function extractSnapshotWithLLM(
   chapterNumber: number,
   chapterBody: string,
@@ -1083,9 +1127,15 @@ export interface SyncSnapshotToMemoryResult {
   memorySyncedAt: string
 }
 
+export interface SyncSnapshotToMemoryOptions {
+  deferStructuredMemoryExport?: boolean
+  deferDerivedRebuild?: boolean
+}
+
 export async function syncSnapshotToMemory(
   projectPath: string,
   snapshot: ChapterSnapshot,
+  options?: SyncSnapshotToMemoryOptions,
 ): Promise<SyncSnapshotToMemoryResult> {
   const pp = normalizePath(projectPath)
   const currentSnapshot = await readCurrentSnapshot(pp, snapshot.chapterNumber)
@@ -1151,9 +1201,13 @@ export async function syncSnapshotToMemory(
 
   await backupSnapshotBeforeOverwrite(pp, syncedSnapshot.chapterNumber)
   await saveSnapshot(pp, syncedSnapshot)
-  const memoryPagePaths = await exportStructuredMemoryToWiki(pp, syncedSnapshot)
-  clearGraphCache()
-  useWikiStore.getState().bumpDataVersion()
+  const memoryPagePaths = options?.deferStructuredMemoryExport
+    ? []
+    : await exportStructuredMemoryToWiki(pp, syncedSnapshot)
+  if (!options?.deferDerivedRebuild) {
+    clearGraphCache()
+    useWikiStore.getState().bumpDataVersion()
+  }
 
   return { writtenEntityPaths, memoryPagePaths, memorySyncedAt }
 }
@@ -1359,6 +1413,13 @@ async function rebuildDerivedMemoryFromSnapshots(projectPath: string, latestSnap
   await writeStructuredMemoryDocuments(projectPath, snapshots)
 }
 
+export async function finalizeProjectMemoryRebuild(projectPath: string): Promise<void> {
+  const pp = normalizePath(projectPath)
+  await rebuildDerivedMemoryFromSnapshots(pp)
+  clearGraphCache()
+  useWikiStore.getState().bumpDataVersion()
+}
+
 async function saveSnapshot(projectPath: string, snapshot: ChapterSnapshot): Promise<void> {
   const canonicalSnapshot = ensureSnapshotIdentity(canonicalizeSnapshotCharacters(snapshot))
   const normalizedSnapshot = normalizeChapterSnapshot(canonicalSnapshot, {
@@ -1532,17 +1593,38 @@ export async function ingestOutline(
   projectPath: string,
   outlinePath: string,
   signal?: AbortSignal,
-): Promise<ChapterSnapshot | null> {
+  options?: IngestOutlineOptions,
+): Promise<OutlineIngestResult> {
+  const emptyResult = (
+    snapshot: ChapterSnapshot | null = null,
+    failureReason: OutlineIngestResult["failureReason"] = null,
+  ): OutlineIngestResult => ({
+    snapshot,
+    truncated: false,
+    originalLength: 0,
+    bodyLength: 0,
+    bodyBudget: 0,
+    failureReason,
+  })
+
   const pp = normalizePath(projectPath)
   const state = useWikiStore.getState()
   const llmConfig = state.llmConfig
   const novelConfig = state.novelConfig
   // 使用 resolveNovelModel 正确解析提取模型（含供应商配置切换），与 ingestChapter 保持一致
   const runtimeLlmConfig = resolveNovelModel(llmConfig, novelConfig, "extract")
-  if (!hasUsableLlm(runtimeLlmConfig, state.providerConfigs)) return null
+  if (!hasUsableLlm(runtimeLlmConfig, state.providerConfigs)) return emptyResult(null, "no_llm")
 
   const content = await readFile(outlinePath)
-  const body = content.length > 8000 ? content.slice(0, 8000) : content
+  const originalLength = content.length
+
+  const outputLang = getOutputLanguage()
+  const langReminder = buildLanguageReminder(outputLang)
+  const systemPrompt = `你是一个专业的小说编辑助手。请从大纲中提取初始设定信息，输出 JSON。${langReminder}`
+  const promptOverhead = systemPrompt.length + buildOutlineIngestUserPrompt("").length
+  const bodyBudget = computeOutlineIngestBodyBudget(runtimeLlmConfig.maxContextSize, promptOverhead)
+  const truncated = content.length > bodyBudget
+  const body = truncated ? content.slice(0, bodyBudget) : content
 
   // 从文件路径提取大纲名称作为标题
   const normalizedOutlinePath = normalizePath(outlinePath)
@@ -1558,36 +1640,7 @@ export async function ingestOutline(
   const outlineNumber = -(Math.abs(hash % 999) + 1) // -1 到 -999
   const chapterId = `outline-${outlineName}`
 
-  const outputLang = getOutputLanguage()
-  const langReminder = buildLanguageReminder(outputLang)
-
-  const systemPrompt = `你是一个专业的小说编辑助手。请从大纲中提取初始设定信息，输出 JSON。${langReminder}`
-
-  const userPrompt = `请从以下大纲中提取初始设定：
-
-${body}
-
-输出 JSON：
-{
-  "chapterId": "outline-init",
-  "chapterNumber": 0,
-  "summary": "大纲摘要",
-  "characters": ["初始人物"],
-  "locations": ["初始地点"],
-  "organizations": ["初始组织/势力"],
-  "items": ["关键物品"],
-  "events": ["背景事件"],
-  "characterStateChanges": ["人物初始状态"],
-  "relationshipChanges": ["人物初始关系"],
-  "knowledgeChanges": [],
-  "foreshadowingChanges": ["初始伏笔"],
-  "newCanonFacts": ["世界观正史设定"],
-  "timelineEvents": ["时间线背景"],
-  "conflicts": ["核心冲突"],
-  "endingHook": "",
-  "graphNodes": ["图谱节点列表"],
-  "graphEdges": ["图谱关系边，格式：A->关系->B。关系必须是以下之一：出场于|发生于|属于|持有|敌对|合作|怀疑|隐瞒|知道|不知道|推进伏笔|回收伏笔|新增伏笔|导致|揭示|影响|位于"]
-}`
+  const userPrompt = buildOutlineIngestUserPrompt(body)
 
   try {
     const messages: ChatMessage[] = [
@@ -1624,8 +1677,26 @@ ${body}
       throw new Error("Outline snapshot payload is invalid.")
     }
 
+    if (options?.skipSync) {
+      return {
+        snapshot,
+        truncated,
+        originalLength,
+        bodyLength: body.length,
+        bodyBudget,
+        failureReason: null,
+      }
+    }
+
     const syncResult = await syncSnapshotToMemory(pp, snapshot)
-    return { ...snapshot, memorySyncedAt: syncResult.memorySyncedAt }
+    return {
+      snapshot: { ...snapshot, memorySyncedAt: syncResult.memorySyncedAt },
+      truncated,
+      originalLength,
+      bodyLength: body.length,
+      bodyBudget,
+      failureReason: null,
+    }
   } catch (err) {
     console.error("[Outline Ingest] Failed:", err)
     throw normalizeOutlineIngestError(err)

src/lib/novel/deep-chapter-generation.spec.ts

@@ -1579,4 +1579,24 @@ describe("runDeepChapterGeneration", () => {
       controller.signal,
     )
   })
+
+  it("stops after review when the user cancels during review", async () => {
+    const controller = new AbortController()
+    const deps: DeepChapterGenerationDeps = {
+      ...createDeps(),
+      reviewChapter: vi.fn(async () => {
+        controller.abort()
+        throw new Error("已停止生成")
+      }),
+    }
+
+    await expect(runDeepChapterGeneration(
+      { projectPath: "E:/Novel", userRequest: "生成第3章", chapterNumber: 3, llmConfig },
+      {},
+      deps,
+      controller.signal,
+    )).rejects.toThrow("已停止生成")
+
+    expect(deps.streamChat).toHaveBeenCalledTimes(2)
+  })
 })

src/lib/novel/deep-outline-generation.ts

@@ -0,0 +1,227 @@
+import type { LlmConfig } from "@/stores/wiki-store"
+import { useWikiStore } from "@/stores/wiki-store"
+import { hasUsableLlm } from "@/lib/has-usable-llm"
+import { streamChat, type ChatMessage, type RequestOverrides, type StreamCallbacks } from "@/lib/llm-client"
+import { USER_ABORT_MESSAGE } from "@/lib/user-abort"
+
+export interface DeepOutlineGenerationInput {
+  llmConfig: LlmConfig
+  userRequest: string
+  context: string
+  historyMessages?: ChatMessage[]
+}
+
+export interface DeepOutlineGenerationCallbacks {
+  onThinking?: (content: string) => void
+  onFinalContent?: (content: string) => void
+}
+
+export interface DeepOutlineGenerationResult {
+  finalContent: string
+  taskBrief: string
+  draftContent: string
+  selfCheck: string
+}
+
+export interface DeepOutlineGenerationDeps {
+  streamChat: (
+    config: LlmConfig,
+    messages: ChatMessage[],
+    callbacks: StreamCallbacks,
+    signal?: AbortSignal,
+    requestOverrides?: RequestOverrides,
+  ) => Promise<void>
+}
+
+const defaultDeps: DeepOutlineGenerationDeps = {
+  streamChat,
+}
+
+export async function runDeepOutlineGeneration(
+  input: DeepOutlineGenerationInput,
+  callbacks: DeepOutlineGenerationCallbacks = {},
+  deps: DeepOutlineGenerationDeps = defaultDeps,
+  signal?: AbortSignal,
+): Promise<DeepOutlineGenerationResult> {
+  const { providerConfigs } = useWikiStore.getState()
+  if (!hasUsableLlm(input.llmConfig, providerConfigs)) {
+    throw new Error("请先在设置中配置并选择一个可用的 AI 模型，或在大纲对话中选择模型后再试。")
+  }
+
+  const safeContext = ensureString(input.context)
+  const safeUserRequest = ensureString(input.userRequest)
+  const history = formatRecentHistory(input.historyMessages ?? [])
+
+  callbacks.onThinking?.(formatStageThinking(
+    "阶段1：大纲上下文分析",
+    [
+      `用户要求：${safeUserRequest || "未提供用户要求"}`,
+      safeContext.trim()
+        ? `已读取大纲/章节上下文，约 ${safeContext.length} 字。`
+        : "未读取到现有大纲或章节上下文，将仅基于本次要求生成。",
+      history ? "已纳入本轮大纲对话历史。" : "暂无可用的大纲对话历史。",
+    ].join("\n"),
+  ))
+
+  const taskBrief = await collectModelText(
+    input.llmConfig,
+    [{ role: "user", content: buildOutlineTaskBriefPrompt(safeContext, history, safeUserRequest) }],
+    deps,
+    signal,
+    (partial) => callbacks.onThinking?.(formatStageThinking("阶段2：大纲任务书", partial)),
+  )
+  callbacks.onThinking?.(formatStageThinking("阶段2：大纲任务书", taskBrief))
+
+  const draftContent = await collectModelText(
+    input.llmConfig,
+    [{ role: "user", content: buildOutlineDraftPrompt(safeContext, history, taskBrief, safeUserRequest) }],
+    deps,
+    signal,
+    (partial) => callbacks.onThinking?.(formatStageThinking("阶段3：大纲草稿", partial)),
+  )
+  callbacks.onThinking?.(formatStageThinking("阶段3：大纲草稿", [
+    draftContent,
+    "",
+    `大纲草稿生成完成，约 ${draftContent.length} 字。`,
+  ].join("\n")))
+
+  const selfCheck = await collectModelText(
+    input.llmConfig,
+    [{ role: "user", content: buildOutlineSelfCheckPrompt(safeContext, history, taskBrief, draftContent, safeUserRequest) }],
+    deps,
+    signal,
+    (partial) => callbacks.onThinking?.(formatStageThinking("阶段4：大纲自检", partial)),
+  )
+  callbacks.onThinking?.(formatStageThinking("阶段4：大纲自检", selfCheck))
+  callbacks.onThinking?.(formatStageThinking("阶段5：完成", "采用自检后的大纲草稿作为最终输出。"))
+  callbacks.onFinalContent?.(draftContent)
+
+  return {
+    finalContent: draftContent,
+    taskBrief,
+    draftContent,
+    selfCheck,
+  }
+}
+
+async function collectModelText(
+  config: LlmConfig,
+  messages: ChatMessage[],
+  deps: DeepOutlineGenerationDeps,
+  signal?: AbortSignal,
+  onUpdate?: (content: string) => void,
+): Promise<string> {
+  let content = ""
+  let streamError: Error | null = null
+
+  await deps.streamChat(
+    config,
+    messages,
+    {
+      onToken: (token) => {
+        content += token
+        onUpdate?.(content)
+      },
+      onDone: () => {},
+      onError: (error) => {
+        streamError = error
+      },
+    },
+    signal,
+    { reasoning: config.reasoning },
+  )
+
+  if (signal?.aborted) throw new Error(USER_ABORT_MESSAGE)
+  if (streamError) throw streamError
+  return content.trim()
+}
+
+function buildOutlineTaskBriefPrompt(context: string, history: string, userRequest: string): string {
+  return [
+    "你是小说大纲规划助手。请先输出一份大纲任务书，不要直接写大纲正文。",
+    "",
+    "任务书必须包含：",
+    "1. 本次要生成或细化的大纲范围。",
+    "2. 必须承接的已有剧情、人物状态、伏笔和时间线。",
+    "3. 必须避免推翻的既定设定。",
+    "4. 本次输出结构和重点。",
+    "",
+    `用户要求：${userRequest}`,
+    history ? `\n近期对话：\n${history}` : "",
+    "",
+    "已有大纲与章节上下文：",
+    context || "暂无可用上下文。",
+  ].join("\n")
+}
+
+function buildOutlineDraftPrompt(context: string, history: string, taskBrief: string, userRequest: string): string {
+  return [
+    "你是小说大纲写作助手。请根据大纲任务书生成大纲草稿。",
+    "",
+    "输出要求：",
+    "1. 只输出可保存为大纲的 Markdown 正文。",
+    "2. 不要输出思考过程、任务书、解释、引用来源或后续建议。",
+    "3. 必须承接已有大纲、章节内容、人物状态和伏笔。",
+    "4. 如果用户要求章节细纲，必须按以下五段结构输出：",
+    "   ### 本章钩子（开局1-2句如何抓住读者、期待感来源）",
+    "   ### 铺垫（本章塑造的舞台、规则、压力、配角作用）",
+    "   ### 爽点（具体反转、如何兑取绪释放）",
+    "   ### 结尾钩子（衔接下一章的悬念点）",
+    "   ### 作者手搓留白（标注哪些地方需要用人设卡/文风/玩梗手工填充，AI不可自行填充）",
+    "",
+    `用户要求：${userRequest}`,
+    history ? `\n近期对话：\n${history}` : "",
+    "",
+    "大纲任务书：",
+    taskBrief,
+    "",
+    "已有大纲与章节上下文：",
+    context || "暂无可用上下文。",
+  ].join("\n")
+}
+
+function buildOutlineSelfCheckPrompt(
+  context: string,
+  history: string,
+  taskBrief: string,
+  draftContent: string,
+  userRequest: string,
+): string {
+  return [
+    "你是小说大纲自检助手。请对大纲草稿做一次简短自检。",
+    "",
+    "只输出自检结论，不要改写正文。检查重点：",
+    "1. 是否承接用户要求。",
+    "2. 是否推翻已有大纲、人物状态、伏笔、时间线或正史规则。",
+    "3. 是否足够具体，能指导后续正文生成。",
+    "4. 是否存在明显缺口，并给出简短修正建议。",
+    "",
+    `用户要求：${userRequest}`,
+    history ? `\n近期对话：\n${history}` : "",
+    "",
+    "大纲任务书：",
+    taskBrief,
+    "",
+    "大纲草稿：",
+    draftContent,
+    "",
+    "已有上下文：",
+    context || "暂无可用上下文。",
+  ].join("\n")
+}
+
+function formatRecentHistory(messages: ChatMessage[]): string {
+  return messages
+    .filter((message) => message.role === "user" || message.role === "assistant")
+    .slice(-6)
+    .map((message) => `${message.role === "user" ? "用户" : "AI"}：${ensureString(message.content).slice(0, 1200)}`)
+    .join("\n\n")
+}
+
+function formatStageThinking(title: string, content: string): string {
+  return `## ${title}\n${ensureString(content).trim()}`
+}
+
+function ensureString(value: unknown): string {
+  return typeof value === "string" ? value : ""
+}

src/lib/novel/mod.ts

@@ -3,7 +3,7 @@ export { parseChapterMeta, isChapterPage, isOutlinePage, type ChapterMeta, type
 export { parseVolumeMeta, isVolumePage, getChapterVolumes, type VolumeMeta } from "./volume"
 export { createChapterPipeline, type ChapterPipeline, type ChapterPipelineDeps } from "./chapter-pipeline"
 export { buildContextPack, contextPackToPrompt, type ContextPack } from "./context-engine"
-export { ingestChapter, ingestChapterPipeline, ingestOutline, loadSnapshot, listSnapshots, deleteChapterSnapshots, type ChapterSnapshot, type CharacterDetail, type LocationDetail, type OrganizationDetail, type ItemDetail, type EventDetail, type IngestResult, type IngestFailReason } from "./chapter-ingest"
+export { ingestChapter, ingestChapterPipeline, ingestOutline, loadSnapshot, listSnapshots, deleteChapterSnapshots, finalizeProjectMemoryRebuild, syncSnapshotToMemory, type ChapterSnapshot, type CharacterDetail, type LocationDetail, type OrganizationDetail, type ItemDetail, type EventDetail, type IngestResult, type IngestFailReason, type OutlineIngestResult, type IngestOutlineOptions, type SyncSnapshotToMemoryOptions } from "./chapter-ingest"
 export { reviewChapter, type NovelReviewResult } from "./review-adapter"
 export { runNovelLint, buildNovelLintPrompt, type NovelLintResult } from "./lint"
 export { resolveNovelModel, type NovelTaskType } from "./model-resolver"

src/lib/novel/model-resolver.ts

@@ -166,3 +166,18 @@ export function resolveNovelModel(
 
   return toUnusableConfig(llmConfig)
 }
+
+export function formatResolvedModelLabel(
+  config: LlmConfig,
+  providerConfigs: Record<string, ProviderOverride>,
+): string {
+  const model = config.model.trim()
+  if (!model) return "未知模型"
+
+  for (const override of Object.values(providerConfigs)) {
+    const found = override.savedModels?.find((saved) => saved.model === model)
+    if (found?.name?.trim()) return found.name.trim()
+  }
+
+  return model
+}

src/lib/novel/outline-generation.spec.ts

@@ -0,0 +1,237 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+const mocks = vi.hoisted(() => ({
+  buildContextPackMock: vi.fn(),
+  ingestOutlineMock: vi.fn(),
+  syncSnapshotToMemoryMock: vi.fn(),
+  finalizeProjectMemoryRebuildMock: vi.fn(),
+  refreshProjectStateMock: vi.fn(),
+  hasUsableLlmMock: vi.fn(() => true),
+  outlineStore: {
+    tasks: [] as Array<{ id: string; projectPath: string; outlinePath: string | null; status: string; message: string; error: string | null; updatedAt: number }>,
+    createTask: vi.fn((input: { projectPath: string; outlinePath?: string | null }) => {
+      const id = `outline-task-${mocks.outlineStore.tasks.length + 1}`
+      mocks.outlineStore.tasks.unshift({
+        id,
+        projectPath: input.projectPath,
+        outlinePath: input.outlinePath ?? null,
+        status: "ingesting",
+        message: "",
+        error: null,
+        updatedAt: Date.now(),
+      })
+      return id
+    }),
+    updateTask: vi.fn((taskId: string, patch: Record<string, unknown>) => {
+      const task = mocks.outlineStore.tasks.find((item) => item.id === taskId)
+      if (task) Object.assign(task, patch)
+    }),
+  },
+  importProgressStore: {
+    tasks: [] as Array<{ id: string; abortController?: AbortController }>,
+    startTask: vi.fn((input: { abortController?: AbortController }) => {
+      const id = `import-progress-${mocks.importProgressStore.tasks.length + 1}`
+      mocks.importProgressStore.tasks.unshift({ id, abortController: input.abortController })
+      return id
+    }),
+    updateTask: vi.fn(),
+    finishTask: vi.fn(),
+  },
+}))
+
+vi.mock("./context-engine", async () => {
+  const actual = await vi.importActual<typeof import("./context-engine")>("./context-engine")
+  return {
+    ...actual,
+    buildContextPack: mocks.buildContextPackMock,
+  }
+})
+
+vi.mock("./chapter-ingest", () => ({
+  ingestOutline: mocks.ingestOutlineMock,
+  syncSnapshotToMemory: mocks.syncSnapshotToMemoryMock,
+  finalizeProjectMemoryRebuild: mocks.finalizeProjectMemoryRebuildMock,
+}))
+
+vi.mock("@/lib/project-refresh", () => ({
+  refreshProjectState: mocks.refreshProjectStateMock,
+}))
+
+vi.mock("@/lib/has-usable-llm", () => ({
+  hasUsableLlm: mocks.hasUsableLlmMock,
+}))
+
+vi.mock("@/stores/wiki-store", () => ({
+  useWikiStore: {
+    getState: () => ({
+      llmConfig: { provider: "custom", model: "test" },
+      novelConfig: { extractModel: "test-model" },
+      providerConfigs: {},
+    }),
+  },
+}))
+
+vi.mock("@/stores/outline-generation-store", () => ({
+  useOutlineGenerationStore: {
+    getState: () => mocks.outlineStore,
+  },
+}))
+
+vi.mock("@/stores/import-progress-store", () => ({
+  useImportProgressStore: {
+    getState: () => mocks.importProgressStore,
+  },
+}))
+
+import {
+  assertOutlineIngestLlmReady,
+  buildOutlineGenerationPrompt,
+  buildOutlineRefinementContext,
+  formatBulkOutlineIngestResult,
+  OutlineIngestNotReadyError,
+  runOutlineIngestPaths,
+} from "./outline-generation"
+
+describe("outline-generation context fallback", () => {
+  beforeEach(() => {
+    mocks.buildContextPackMock.mockReset()
+    mocks.ingestOutlineMock.mockReset()
+    mocks.syncSnapshotToMemoryMock.mockReset()
+    mocks.finalizeProjectMemoryRebuildMock.mockReset()
+    mocks.refreshProjectStateMock.mockReset()
+    mocks.hasUsableLlmMock.mockReset()
+    mocks.hasUsableLlmMock.mockReturnValue(true)
+    mocks.outlineStore.tasks = []
+    mocks.importProgressStore.tasks = []
+    mocks.importProgressStore.startTask.mockClear()
+    mocks.importProgressStore.updateTask.mockClear()
+    mocks.importProgressStore.finishTask.mockClear()
+    mocks.syncSnapshotToMemoryMock.mockResolvedValue({
+      writtenEntityPaths: [],
+      memoryPagePaths: [],
+      memorySyncedAt: "2026-01-01T00:00:00.000Z",
+    })
+    mocks.finalizeProjectMemoryRebuildMock.mockResolvedValue(undefined)
+    mocks.refreshProjectStateMock.mockResolvedValue(undefined)
+  })
+
+  it("still builds a generation prompt when context loading fails", async () => {
+    mocks.buildContextPackMock.mockRejectedValueOnce(new Error("context failed"))
+
+    const prompt = await buildOutlineGenerationPrompt("E:/Novel", "通用", "短篇", "测试")
+
+    expect(prompt).toContain("测试")
+    expect(prompt).toContain("请为以下小说生成大纲")
+  })
+
+  it("returns an empty refinement context when context loading fails", async () => {
+    mocks.buildContextPackMock.mockRejectedValueOnce(new Error("context failed"))
+
+    const result = await buildOutlineRefinementContext("E:/Novel", "测试")
+
+    expect(result).toEqual({
+      context: "",
+      hasOutline: false,
+    })
+  })
+})
+
+describe("bulk outline ingest", () => {
+  beforeEach(() => {
+    mocks.buildContextPackMock.mockReset()
+    mocks.ingestOutlineMock.mockReset()
+    mocks.syncSnapshotToMemoryMock.mockReset()
+    mocks.finalizeProjectMemoryRebuildMock.mockReset()
+    mocks.refreshProjectStateMock.mockReset()
+    mocks.hasUsableLlmMock.mockReset()
+    mocks.hasUsableLlmMock.mockReturnValue(true)
+    mocks.outlineStore.tasks = []
+    mocks.importProgressStore.tasks = []
+    mocks.importProgressStore.startTask.mockClear()
+    mocks.importProgressStore.updateTask.mockClear()
+    mocks.importProgressStore.finishTask.mockClear()
+    mocks.syncSnapshotToMemoryMock.mockResolvedValue({
+      writtenEntityPaths: [],
+      memoryPagePaths: [],
+      memorySyncedAt: "2026-01-01T00:00:00.000Z",
+    })
+    mocks.finalizeProjectMemoryRebuildMock.mockResolvedValue(undefined)
+    mocks.refreshProjectStateMock.mockResolvedValue(undefined)
+  })
+
+  it("throws when extract model is unavailable", () => {
+    mocks.hasUsableLlmMock.mockReturnValue(false)
+    expect(() => assertOutlineIngestLlmReady()).toThrow(OutlineIngestNotReadyError)
+  })
+
+  it("defers memory rebuild until all outlines sync", async () => {
+    mocks.ingestOutlineMock
+      .mockResolvedValueOnce({
+        snapshot: { chapterId: "outline-a", chapterNumber: -1 },
+        truncated: false,
+        originalLength: 100,
+        bodyLength: 100,
+        bodyBudget: 1000,
+        failureReason: null,
+      })
+      .mockResolvedValueOnce({
+        snapshot: { chapterId: "outline-b", chapterNumber: -2 },
+        truncated: false,
+        originalLength: 100,
+        bodyLength: 100,
+        bodyBudget: 1000,
+        failureReason: null,
+      })
+
+    const result = await runOutlineIngestPaths("E:/Novel", [
+      "E:/Novel/wiki/outlines/a.md",
+      "E:/Novel/wiki/outlines/b.md",
+    ])
+
+    expect(result).toMatchObject({ total: 2, succeeded: 2, failed: 0 })
+    expect(mocks.syncSnapshotToMemoryMock).toHaveBeenCalledTimes(2)
+    expect(mocks.syncSnapshotToMemoryMock.mock.calls[0]?.[2]).toEqual({
+      deferStructuredMemoryExport: true,
+      deferDerivedRebuild: true,
+    })
+    expect(mocks.finalizeProjectMemoryRebuildMock).toHaveBeenCalledTimes(1)
+    expect(mocks.refreshProjectStateMock).toHaveBeenCalledTimes(1)
+  })
+
+  it("collects per-file failures", async () => {
+    mocks.ingestOutlineMock
+      .mockResolvedValueOnce({
+        snapshot: { chapterId: "outline-a", chapterNumber: -1 },
+        truncated: false,
+        originalLength: 100,
+        bodyLength: 100,
+        bodyBudget: 1000,
+        failureReason: null,
+      })
+      .mockRejectedValueOnce(new Error("JSON 解析失败"))
+
+    const result = await runOutlineIngestPaths("E:/Novel", [
+      "E:/Novel/wiki/outlines/a.md",
+      "E:/Novel/wiki/outlines/b.md",
+    ])
+
+    expect(result.succeeded).toBe(1)
+    expect(result.failed).toBe(1)
+    expect(result.failures).toHaveLength(1)
+    expect(result.failures[0]?.name).toBe("b")
+    expect(result.failures[0]?.reason).toContain("JSON 解析失败")
+  })
+
+  it("formats failure details for the banner", () => {
+    const message = formatBulkOutlineIngestResult({
+      total: 2,
+      succeeded: 1,
+      failed: 1,
+      failures: [{ name: "b", path: "E:/Novel/wiki/outlines/b.md", reason: "JSON 解析失败" }],
+    })
+
+    expect(message).toContain("失败")
+    expect(message).toContain("b")
+    expect(message).toContain("JSON 解析失败")
+  })
+})

src/lib/novel/outline-generation.ts

@@ -0,0 +1,1198 @@
+import { createDirectory, fileExists, listDirectory, readFile, writeFile } from "@/commands/fs"
+import { streamChat } from "@/lib/llm-client"
+import { getOutputLanguage } from "@/lib/output-language"
+import { getFileName, normalizePath } from "@/lib/path-utils"
+import { refreshProjectState } from "@/lib/project-refresh"
+import i18n from "@/i18n"
+import type { ChatMessage } from "@/lib/llm-providers"
+import { PROMPTS } from "@/lib/novel/prompt-templates"
+import { useOutlineGenerationStore } from "@/stores/outline-generation-store"
+import { useImportProgressStore } from "@/stores/import-progress-store"
+import type { LlmConfig } from "@/stores/wiki-store"
+import { useWikiStore } from "@/stores/wiki-store"
+import { hasUsableLlm } from "@/lib/has-usable-llm"
+import { mapWithConcurrency } from "@/lib/async-pool"
+import {
+  finalizeProjectMemoryRebuild,
+  ingestOutline,
+  syncSnapshotToMemory,
+  type OutlineIngestResult,
+} from "./chapter-ingest"
+import { buildContextPack, type ContextPack } from "./context-engine"
+import { resolveDefaultModel, resolveModelConfig, resolveNovelModel } from "@/lib/novel/model-resolver"
+
+export type OutlineSectionGenerationKey =
+  | "chapterOutlines"
+  | "characterBriefs"
+  | "organizationsOutline"
+  | "powerSystem"
+  | "foreshadowingPlan"
+  | "locationsOutline"
+
+export interface OutlineSectionGenerationConfig {
+  key: OutlineSectionGenerationKey
+  title: string
+  englishTitle: string
+  englishFileName: string
+  requestHint: string
+}
+
+export interface OutlineRefinementResult {
+  primaryPath: string | null
+  sections: Partial<Record<OutlineSectionGenerationKey, string>>
+  writtenPaths: string[]
+}
+
+export type OutlineRefinementWriteMode =
+  | "replaceDefault"
+  | "appendCurrent"
+  | "newFileAndAddToList"
+
+export interface OutlineRefinementWriteOptions {
+  mode?: OutlineRefinementWriteMode
+  targetPath?: string | null
+}
+
+export const OUTLINE_SECTION_GENERATION_CONFIGS: OutlineSectionGenerationConfig[] = [
+  {
+    key: "chapterOutlines",
+    title: "章节细纲",
+    englishTitle: "Chapter Outlines",
+    englishFileName: "chapter-outlines.md",
+    requestHint: "根据已有总纲、分卷大纲与章节推进需要，生成或完善章节细纲，明确每章目标、冲突、转折和结尾钩子。",
+  },
+  {
+    key: "characterBriefs",
+    title: "人物小传",
+    englishTitle: "Character Briefs",
+    englishFileName: "character-briefs.md",
+    requestHint: "根据已有大纲和项目记忆，整理主要人物的小传、动机、弧线、关系网络与当前状态。",
+  },
+  {
+    key: "organizationsOutline",
+    title: "组织势力设定",
+    englishTitle: "Faction Notes",
+    englishFileName: "organizations.md",
+    requestHint: "根据已有大纲和项目记忆，补完组织、势力、阵营目标、关系、冲突与剧情作用。",
+  },
+  {
+    key: "powerSystem",
+    title: "金手指与能力体系",
+    englishTitle: "Power System",
+    englishFileName: "power-system.md",
+    requestHint: "根据已有大纲和项目记忆，整理金手指、能力体系、规则、限制、代价与剧情作用。",
+  },
+  {
+    key: "foreshadowingPlan",
+    title: "伏笔计划",
+    englishTitle: "Foreshadowing Plan",
+    englishFileName: "foreshadowing-plan.md",
+    requestHint: "根据已有大纲和项目记忆，整理伏笔的埋设、推进、回收节奏与对应章节节点。",
+  },
+  {
+    key: "locationsOutline",
+    title: "地点设定",
+    englishTitle: "Location Notes",
+    englishFileName: "locations.md",
+    requestHint: "根据已有大纲和项目记忆，整理重要地点、地点规则、所属势力与剧情作用。",
+  },
+]
+
+function useEnglishOutlineNames(): boolean {
+  return getOutputLanguage() === "English"
+}
+
+function getOutlineSectionTitle(config: OutlineSectionGenerationConfig): string {
+  return useEnglishOutlineNames() ? config.englishTitle : config.title
+}
+
+function getOutlineSectionFileName(config: OutlineSectionGenerationConfig): string {
+  return useEnglishOutlineNames() ? config.englishFileName : `${config.title}.md`
+}
+
+function getStoryOutlineFileName(): string {
+  return useEnglishOutlineNames() ? "story-outline.md" : "总大纲.md"
+}
+
+function outlinePageMarkdown(title: string, content: string): string {
+  return [
+    "---",
+    "type: outline",
+    `title: "${title.replace(/"/g, '\\"')}"`,
+    "---",
+    "",
+    `# ${title}`,
+    "",
+    content.trim(),
+    "",
+  ].join("\n")
+}
+
+function appendContextSection(sections: string[], title: string, content: string | string[]) {
+  const text = Array.isArray(content) ? content.filter(Boolean).join("\n") : content.trim()
+  if (!text) return
+  sections.push(`## ${title}\n${text}`)
+}
+
+function formatOutlineRefinementContext(pack: ContextPack): string {
+  const sections: string[] = []
+  appendContextSection(sections, "已有大纲", pack.outline)
+  appendContextSection(sections, "最近剧情摘要", pack.recentSummaries)
+  appendContextSection(sections, "人物状态变化", pack.characterStates)
+  appendContextSection(sections, "角色认知", pack.cognitionStates)
+  appendContextSection(sections, "伏笔状态", pack.foreshadowingStates)
+  appendContextSection(sections, "时间线", pack.timeline)
+  appendContextSection(sections, "相关设定", pack.relatedSettings)
+  appendContextSection(sections, "正史规则", pack.canonRules)
+  appendContextSection(sections, "关联检索", pack.searchResults)
+  appendContextSection(sections, "图谱关联检索", pack.graphSearchResults)
+  return sections.join("\n\n").slice(0, 20000)
+}
+
+function formatOutlineGenerationContext(pack: ContextPack): string {
+  const sections: string[] = []
+  appendContextSection(sections, "已有故事记忆与项目资料", pack.soulDoc)
+  appendContextSection(sections, "已有大纲与故事骨架", pack.outline)
+  appendContextSection(sections, "最近剧情记忆", pack.recentSummaries)
+  appendContextSection(sections, "人物状态与关系", pack.characterStates)
+  appendContextSection(sections, "角色认知与信息差", pack.cognitionStates)
+  appendContextSection(sections, "伏笔与未回收线索", pack.foreshadowingStates)
+  appendContextSection(sections, "时间线与剧情节点", pack.timeline)
+  appendContextSection(sections, "设定与地点组织", pack.relatedSettings)
+  appendContextSection(sections, "正史规则", pack.canonRules)
+  appendContextSection(sections, "剧情记忆与卡片故事", pack.searchResults)
+  appendContextSection(sections, "图谱关联", pack.graphSearchResults)
+  return sections.join("\n\n").slice(0, 20000)
+}
+
+export async function buildOutlineGenerationPrompt(
+  projectPath: string,
+  genre: string,
+  scale: string,
+  premise: string,
+): Promise<string> {
+  const pack = await safeBuildOutlineContextPack(projectPath, `?????${premise || genre}`)
+  return PROMPTS.outlineGeneration(genre, scale, premise, formatOutlineGenerationContext(pack))
+}
+
+export async function hasOutlineForRefinement(projectPath: string): Promise<boolean> {
+  try {
+    const pp = normalizePath(projectPath)
+    const tree = await listDirectory(`${pp}/wiki/outlines`)
+    const flattenFiles = (nodes: typeof tree): typeof tree => {
+      const files: typeof tree = []
+      for (const node of nodes) {
+        if (node.is_dir && node.children) files.push(...flattenFiles(node.children))
+        else if (!node.is_dir && node.name.endsWith(".md")) files.push(node)
+      }
+      return files
+    }
+    return flattenFiles(tree).length > 0
+  } catch {
+    return false
+  }
+}
+
+export async function buildOutlineRefinementContext(
+  projectPath: string,
+  userRequest: string,
+): Promise<{ context: string; hasOutline: boolean }> {
+  const pack = await safeBuildOutlineContextPack(projectPath, userRequest)
+  return {
+    context: formatOutlineRefinementContext(pack),
+    hasOutline: Boolean(pack.outline.trim()),
+  }
+}
+
+function emptyOutlineContextPack(task: string): ContextPack {
+  return {
+    task,
+    chapterGoal: "",
+    outline: "",
+    recentSummaries: [],
+    previousChapterEnding: "",
+    characterStates: "",
+    soulDoc: "",
+    characterAuras: "",
+    cognitionStates: "",
+    foreshadowingStates: "",
+    timeline: "",
+    relatedSettings: "",
+    canonRules: "",
+    writingStyle: "",
+    searchResults: "",
+    graphSearchResults: "",
+    mustDo: "",
+    mustAvoid: "",
+    nextChapterAdvice: "",
+    revisionDirectives: "",
+  }
+}
+
+async function safeBuildOutlineContextPack(projectPath: string, task: string): Promise<ContextPack> {
+  try {
+    return await buildContextPack(projectPath, task)
+  } catch {
+    return emptyOutlineContextPack(task)
+  }
+}
+
+function buildSectionRefinementPrompt(
+  context: string,
+  config: OutlineSectionGenerationConfig,
+  userRequest: string,
+): string {
+  const sectionTitle = getOutlineSectionTitle(config)
+  return [
+    "请基于已有大纲和项目记忆，生成指定类型的小说设定文件。",
+    "",
+    "硬性约束：",
+    "1. 已有大纲、人物状态、角色认知、伏笔状态、时间线、正史规则和项目记忆都是最高优先级，不得推翻。",
+    "2. 本次用户要求只能用于补充、聚焦和完善，不得改写既定主线和核心设定。",
+    "3. 如果信息不足，只能做最小必要补完，且必须与现有设定兼容。",
+    "4. 只输出正文 Markdown，不要输出 JSON、代码块、解释、前言或额外说明。",
+    "",
+    "已有大纲与项目记忆：",
+    context || "当前暂无可读取的项目记忆，请仅基于已有大纲与本次要求进行细化。",
+    "",
+    "本次细化重点：",
+    userRequest.trim() || "未额外指定，请基于已有大纲与项目记忆完成细化。",
+    "",
+    `本次只生成：${sectionTitle}`,
+    config.requestHint,
+  ].join("\n")
+}
+
+async function streamOutlineSectionContent(
+  llmConfig: LlmConfig,
+  context: string,
+  config: OutlineSectionGenerationConfig,
+  userRequest: string,
+  signal?: AbortSignal,
+): Promise<string> {
+  let content = ""
+  let streamError: Error | null = null
+
+  await streamChat(llmConfig, [{ role: "user", content: buildSectionRefinementPrompt(context, config, userRequest) }], {
+    onToken: (token) => {
+      content += token
+    },
+    onDone: () => {},
+    onError: (err) => {
+      streamError = err
+    },
+  }, signal)
+
+  if (streamError) throw streamError
+  return content.trim()
+}
+
+async function getUniqueOutlinePath(outlinesDir: string, fileName: string): Promise<string> {
+  const firstPath = `${outlinesDir}/${fileName}`
+  if (!(await fileExists(firstPath))) return firstPath
+
+  const extensionIndex = fileName.lastIndexOf(".")
+  const stem = extensionIndex > 0 ? fileName.slice(0, extensionIndex) : fileName
+  const extension = extensionIndex > 0 ? fileName.slice(extensionIndex) : ""
+  for (let index = 2; index <= 99; index += 1) {
+    const candidate = `${outlinesDir}/${stem}-${index}${extension}`
+    if (!(await fileExists(candidate))) return candidate
+  }
+  return `${outlinesDir}/${stem}-${Date.now()}${extension}`
+}
+
+async function writeOutlineSectionFile(
+  projectPath: string,
+  outlinesDir: string,
+  config: OutlineSectionGenerationConfig,
+  sectionContent: string,
+  options: OutlineRefinementWriteOptions = {},
+): Promise<string | null> {
+  if (!sectionContent.trim()) return null
+  const sectionTitle = getOutlineSectionTitle(config)
+  const fileName = getOutlineSectionFileName(config)
+
+  if (options.mode === "appendCurrent" && options.targetPath) {
+    const targetPath = normalizePath(options.targetPath)
+    const existing = await readFile(targetPath).catch(() => "")
+    const appended = [
+      existing.trimEnd(),
+      "",
+      "---",
+      "",
+      `## ${sectionTitle}`,
+      "",
+      sectionContent.trim(),
+      "",
+    ].filter((part, index) => index > 0 || part).join("\n")
+    await writeFile(targetPath, appended)
+    return targetPath
+  }
+
+  const outlinePath = options.mode === "newFileAndAddToList"
+    ? await getUniqueOutlinePath(outlinesDir, fileName)
+    : `${outlinesDir}/${fileName}`
+  await writeFile(outlinePath, outlinePageMarkdown(sectionTitle, sectionContent))
+  if (options.mode === "newFileAndAddToList") {
+    await addOutlineFileToSourceList(projectPath, outlinePath)
+  }
+  return outlinePath
+}
+
+export async function generateOutlineRefinementSectionFile(
+  projectPath: string,
+  llmConfig: LlmConfig,
+  userRequest: string,
+  sectionKey: OutlineSectionGenerationKey,
+  writeOptions: OutlineRefinementWriteOptions = {},
+  signal?: AbortSignal,
+): Promise<string> {
+  const pp = normalizePath(projectPath)
+  const config = OUTLINE_SECTION_GENERATION_CONFIGS.find((item) => item.key === sectionKey)
+  if (!config) {
+    throw new Error("未知的大纲生成类型")
+  }
+
+  const { context, hasOutline } = await buildOutlineRefinementContext(pp, userRequest)
+  if (!hasOutline) {
+    throw new Error(i18n.t("novel.outlineGenerator.refineMissingOutline"))
+  }
+
+  const outlinesDir = `${pp}/wiki/outlines`
+  await createDirectory(outlinesDir)
+  const sectionContent = await streamOutlineSectionContent(llmConfig, context, config, userRequest, signal)
+  const outlinePath = await writeOutlineSectionFile(pp, outlinesDir, config, sectionContent, writeOptions)
+  if (!outlinePath) {
+    throw new Error(i18n.t("novel.outlineGenerator.refineEmpty"))
+  }
+  return outlinePath
+}
+
+export async function generateOutlineRefinementFiles(
+  projectPath: string,
+  llmConfig: LlmConfig,
+  userRequest: string,
+  writeOptions: OutlineRefinementWriteOptions = {},
+  signal?: AbortSignal,
+): Promise<OutlineRefinementResult> {
+  const pp = normalizePath(projectPath)
+  const { context, hasOutline } = await buildOutlineRefinementContext(pp, userRequest)
+  if (!hasOutline) {
+    throw new Error(i18n.t("novel.outlineGenerator.refineMissingOutline"))
+  }
+
+  const outlinesDir = `${pp}/wiki/outlines`
+  await createDirectory(outlinesDir)
+
+  const sections: Partial<Record<OutlineSectionGenerationKey, string>> = {}
+  const writtenPaths: string[] = []
+  let primaryPath: string | null = null
+
+  for (const config of OUTLINE_SECTION_GENERATION_CONFIGS) {
+    if (signal?.aborted) {
+      throw new Error("细化生成已取消")
+    }
+    const sectionContent = await streamOutlineSectionContent(llmConfig, context, config, userRequest, signal)
+    sections[config.key] = sectionContent
+    const outlinePath = await writeOutlineSectionFile(pp, outlinesDir, config, sectionContent, writeOptions)
+    if (!outlinePath) continue
+    writtenPaths.push(outlinePath)
+
+    if (config.key === "chapterOutlines") {
+      primaryPath = outlinePath
+    } else if (!primaryPath) {
+      primaryPath = outlinePath
+    }
+  }
+
+  if (writtenPaths.length === 0) {
+    throw new Error(i18n.t("novel.outlineGenerator.refineEmpty"))
+  }
+
+  return {
+    primaryPath,
+    sections,
+    writtenPaths,
+  }
+}
+
+export async function generateOutlineFile(
+  projectPath: string,
+  llmConfig: LlmConfig,
+  prompt: string,
+  signal?: AbortSignal,
+): Promise<{ outlinePath: string; content: string }> {
+  let content = ""
+  let streamError: Error | null = null
+
+  const messages: ChatMessage[] = [{ role: "user", content: prompt }]
+
+  await streamChat(llmConfig, messages, {
+    onToken: (token) => {
+      content += token
+    },
+    onDone: () => {},
+    onError: (err) => {
+      streamError = err
+    },
+  }, signal)
+
+  if (streamError) {
+    throw streamError
+  }
+
+  const pp = normalizePath(projectPath)
+  const outlinesDir = `${pp}/wiki/outlines`
+  await createDirectory(outlinesDir)
+  const outlineTitle = useEnglishOutlineNames() ? "Story Outline" : "总大纲"
+  const fullContent = outlinePageMarkdown(outlineTitle, content)
+  const outlinePath = `${outlinesDir}/${getStoryOutlineFileName()}`
+  await writeFile(outlinePath, fullContent)
+  return { outlinePath, content }
+}
+
+export async function runOutlineGenerationTask(taskId: string, llmConfig: LlmConfig): Promise<void> {
+  const task = useOutlineGenerationStore.getState().tasks.find((item) => item.id === taskId)
+  if (!task) return
+
+  const { providerConfigs } = useWikiStore.getState()
+  const effectiveLlmConfig = task.modelId
+    ? resolveModelConfig(task.modelId, llmConfig, providerConfigs)
+    : resolveDefaultModel(llmConfig)
+
+  if (!hasUsableLlm(effectiveLlmConfig, providerConfigs)) {
+    throw new Error("请先在设置中配置并选择一个可用的 AI 模型，或在大纲弹窗中选择模型后再试。")
+  }
+
+  const abortController = new AbortController()
+  const progressTaskId = useImportProgressStore.getState().startTask({
+    projectPath: task.projectPath,
+    kind: "outline_generation",
+    total: 100,
+    currentTitle: "生成大纲",
+    message: "正在生成大纲",
+    abortController,
+  })
+
+  try {
+    const { outlinePath } = await generateOutlineFile(task.projectPath, effectiveLlmConfig, task.prompt, abortController.signal)
+    await refreshProjectState(task.projectPath)
+    useOutlineGenerationStore.getState().updateTask(taskId, {
+      status: "generated",
+      outlinePath,
+      message: i18n.t("novel.outlineGenerator.generatedNotification"),
+      error: null,
+    })
+    useImportProgressStore.getState().finishTask(progressTaskId, "done", {
+      completed: 100,
+      total: 100,
+      currentTitle: "",
+      message: "大纲生成完成",
+    })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    useOutlineGenerationStore.getState().updateTask(taskId, {
+      status: "error",
+      error: message,
+      message,
+    })
+    useImportProgressStore.getState().finishTask(progressTaskId, "error", {
+      completed: 0,
+      total: 100,
+      currentTitle: "",
+      message: `大纲生成失败: ${message}`,
+    })
+  }
+}
+
+export async function runOutlineRefinementTask(taskId: string, llmConfig: LlmConfig): Promise<void> {
+  const task = useOutlineGenerationStore.getState().tasks.find((item) => item.id === taskId)
+  if (!task) return
+
+  const { providerConfigs } = useWikiStore.getState()
+  const effectiveLlmConfig = task.modelId
+    ? resolveModelConfig(task.modelId, llmConfig, providerConfigs)
+    : resolveDefaultModel(llmConfig)
+
+  if (!hasUsableLlm(effectiveLlmConfig, providerConfigs)) {
+    throw new Error("请先在设置中配置并选择一个可用的 AI 模型，或在大纲弹窗中选择模型后再试。")
+  }
+
+  const abortController = new AbortController()
+  const progressTaskId = useImportProgressStore.getState().startTask({
+    projectPath: task.projectPath,
+    kind: "outline_refinement",
+    total: 100,
+    currentTitle: task.displayTitle || "细化生成",
+    message: "正在细化生成大纲",
+    abortController,
+  })
+
+  try {
+    let outlinePath: string
+    if (task.selectedSectionKey) {
+      outlinePath = await generateOutlineRefinementSectionFile(
+        task.projectPath,
+        effectiveLlmConfig,
+        task.userRequest,
+        task.selectedSectionKey as OutlineSectionGenerationKey,
+        {
+          mode: (task.writeMode as OutlineRefinementWriteMode | null) ?? undefined,
+          targetPath: task.targetPath,
+        },
+        abortController.signal,
+      )
+    } else {
+      const result = await generateOutlineRefinementFiles(
+        task.projectPath,
+        effectiveLlmConfig,
+        task.userRequest,
+        {
+          mode: (task.writeMode as OutlineRefinementWriteMode | null) ?? undefined,
+          targetPath: task.targetPath,
+        },
+        abortController.signal,
+      )
+      if (!result.primaryPath) {
+        throw new Error(i18n.t("novel.outlineGenerator.refineEmpty"))
+      }
+      outlinePath = result.primaryPath
+    }
+
+    await refreshProjectState(task.projectPath)
+    useOutlineGenerationStore.getState().updateTask(taskId, {
+      status: "generated",
+      outlinePath,
+      message: task.selectedSectionKey && task.displayTitle
+        ? i18n.t("novel.outlineGenerator.sectionGenerated", { title: task.displayTitle })
+        : i18n.t("novel.outlineGenerator.refineGenerated"),
+      error: null,
+    })
+    useImportProgressStore.getState().finishTask(progressTaskId, "done", {
+      completed: 100,
+      total: 100,
+      currentTitle: "",
+      message: task.displayTitle ? `${task.displayTitle} 细化完成` : "细化生成完成",
+    })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    useOutlineGenerationStore.getState().updateTask(taskId, {
+      status: "error",
+      error: message,
+      message,
+    })
+    useImportProgressStore.getState().finishTask(progressTaskId, "error", {
+      completed: 0,
+      total: 100,
+      currentTitle: "",
+      message: `细化生成失败: ${message}`,
+    })
+  }
+}
+
+export async function openGeneratedOutline(taskId: string): Promise<void> {
+  const task = useOutlineGenerationStore.getState().tasks.find((item) => item.id === taskId)
+  if (!task?.outlinePath) return
+  const content = await readFile(task.outlinePath)
+  useWikiStore.getState().setActiveView("sources")
+  useWikiStore.getState().setSelectedFile(task.outlinePath)
+  useWikiStore.getState().setFileContent(content)
+  useOutlineGenerationStore.getState().updateTask(taskId, {
+    status: "generated",
+    message: i18n.t("novel.outlineGenerator.openedNotification"),
+  })
+}
+
+async function getUniqueSourceListPath(projectPath: string, fileName: string): Promise<string> {
+  const sourcesDir = `${normalizePath(projectPath)}/raw/sources`
+  const firstPath = `${sourcesDir}/${fileName}`
+  if (!(await fileExists(firstPath))) return firstPath
+
+  const extensionIndex = fileName.lastIndexOf(".")
+  const stem = extensionIndex > 0 ? fileName.slice(0, extensionIndex) : fileName
+  const extension = extensionIndex > 0 ? fileName.slice(extensionIndex) : ""
+  for (let index = 2; index <= 99; index += 1) {
+    const candidate = `${sourcesDir}/${stem}-${index}${extension}`
+    if (!(await fileExists(candidate))) return candidate
+  }
+  return `${sourcesDir}/${stem}-${Date.now()}${extension}`
+}
+
+export async function addOutlineFileToSourceList(projectPath: string, outlinePath: string): Promise<string> {
+  const pp = normalizePath(projectPath)
+  const normalizedOutlinePath = normalizePath(outlinePath)
+  const sourcesDir = `${pp}/raw/sources`
+  await createDirectory(sourcesDir)
+
+  const content = await readFile(normalizedOutlinePath)
+  const targetPath = await getUniqueSourceListPath(pp, getFileName(normalizedOutlinePath))
+  await writeFile(targetPath, content)
+
+  await refreshProjectState(projectPath)
+  return targetPath
+}
+
+export async function addOutlineTaskToSourceList(taskId: string): Promise<string | null> {
+  const task = useOutlineGenerationStore.getState().tasks.find((item) => item.id === taskId)
+  if (!task?.outlinePath) return null
+  return addOutlineFileToSourceList(task.projectPath, task.outlinePath)
+}
+
+export function createOutlineIngestTask(projectPath: string, outlinePath: string): string {
+  return useOutlineGenerationStore.getState().createTask({
+    projectPath: normalizePath(projectPath),
+    kind: "ingest",
+    outlinePath: normalizePath(outlinePath),
+    status: "ingesting",
+    message: i18n.t("novel.outlineGenerator.ingestingNotification"),
+    error: null,
+  })
+}
+
+export class OutlineIngestNotReadyError extends Error {
+  constructor() {
+    super(i18n.t("novel.outlineGenerator.ingestNoLlm"))
+    this.name = "OutlineIngestNotReadyError"
+  }
+}
+
+export function assertOutlineIngestLlmReady(): void {
+  const state = useWikiStore.getState()
+  const runtimeLlmConfig = resolveNovelModel(state.llmConfig, state.novelConfig, "extract")
+  if (!hasUsableLlm(runtimeLlmConfig, state.providerConfigs)) {
+    throw new OutlineIngestNotReadyError()
+  }
+}
+
+export const BULK_OUTLINE_INGEST_CONCURRENCY = 2
+
+export interface OutlineIngestFailure {
+  name: string
+  path: string
+  reason: string
+}
+
+export interface BulkOutlineIngestResult {
+  total: number
+  succeeded: number
+  failed: number
+  cancelled?: boolean
+  failures: OutlineIngestFailure[]
+}
+
+export interface RunOutlineIngestPathsOptions {
+  onProgressTaskStarted?: (taskId: string) => void
+}
+
+export interface OutlineIngestTaskResult {
+  success: boolean
+  outlinePath: string
+  outlineFileName: string
+  error?: string
+  truncated?: boolean
+  bodyLength?: number
+  originalLength?: number
+  bodyBudget?: number
+}
+
+export interface RunOutlineIngestTaskOptions {
+  signal?: AbortSignal
+  parentProgressId?: string
+  manageProgress?: boolean
+}
+
+import { getOutlineFileName } from "./outline-ingest-utils"
+
+function buildOutlineIngestFailureReason(err: unknown): string {
+  if (err instanceof Error) return err.message
+  return String(err)
+}
+
+function getOutlineIngestCancelledMessage(): string {
+  return i18n.t("novel.outlineGenerator.ingestCancelledNotification")
+}
+
+function finalizeOutstandingIngestTasks(taskIds: string[], cancelled: boolean): void {
+  const message = cancelled
+    ? getOutlineIngestCancelledMessage()
+    : i18n.t("novel.outlineGenerator.ingestFailedNotification")
+  for (const taskId of taskIds) {
+    const task = useOutlineGenerationStore.getState().tasks.find((item) => item.id === taskId)
+    if (task?.status !== "ingesting") continue
+    useOutlineGenerationStore.getState().updateTask(taskId, {
+      status: "error",
+      message,
+      error: message,
+    })
+  }
+}
+
+/** Clear orphaned ingest tasks when no outline import progress is running. */
+export function reconcileStaleOutlineIngestTasks(projectPath: string): void {
+  const pp = normalizePath(projectPath)
+  const hasRunningOutlineImport = useImportProgressStore.getState().tasks.some(
+    (task) => task.projectPath === pp && task.kind === "outline" && task.status === "running",
+  )
+  if (hasRunningOutlineImport) return
+
+  const message = getOutlineIngestCancelledMessage()
+  for (const task of useOutlineGenerationStore.getState().tasks) {
+    if (task.projectPath !== pp || task.kind !== "ingest" || task.status !== "ingesting") continue
+    useOutlineGenerationStore.getState().updateTask(task.id, {
+      status: "error",
+      message,
+      error: message,
+    })
+  }
+}
+
+function buildBulkIngestProgressMessage(result: BulkOutlineIngestResult): string {
+  if (result.cancelled) {
+    return i18n.t("novel.outlineGenerator.bulkIngestCancelledProgress", {
+      succeeded: result.succeeded,
+      total: result.total,
+    })
+  }
+  if (result.failed > 0) {
+    const preview = result.failures
+      .slice(0, 3)
+      .map((failure) => `${failure.name}: ${failure.reason}`)
+      .join("；")
+    return i18n.t("novel.outlineGenerator.bulkIngestProgressWithFailures", {
+      succeeded: result.succeeded,
+      failed: result.failed,
+      preview,
+    })
+  }
+  return i18n.t("novel.outlineGenerator.bulkIngestProgressDone", {
+    succeeded: result.succeeded,
+    total: result.total,
+  })
+}
+
+export function formatBulkOutlineIngestResult(result: BulkOutlineIngestResult): string {
+  if (result.total === 0) {
+    return i18n.t("novel.outlineGenerator.bulkIngestEmpty")
+  }
+  if (result.cancelled) {
+    return i18n.t("novel.outlineGenerator.bulkIngestCancelled", {
+      succeeded: result.succeeded,
+      failed: result.failed,
+      total: result.total,
+    })
+  }
+  if (result.failed === 0) {
+    return i18n.t("novel.outlineGenerator.bulkIngestResult", {
+      total: result.total,
+      succeeded: result.succeeded,
+      failed: result.failed,
+    })
+  }
+
+  const lines = result.failures
+    .slice(0, 5)
+    .map((failure) => `· ${failure.name}: ${failure.reason}`)
+  const extra = result.failures.length > 5
+    ? `\n${i18n.t("novel.outlineGenerator.bulkIngestMoreFailures", { count: result.failures.length - 5 })}`
+    : ""
+
+  return [
+    i18n.t("novel.outlineGenerator.bulkIngestResultWithFailures", {
+      total: result.total,
+      succeeded: result.succeeded,
+      failed: result.failed,
+    }),
+    ...lines,
+  ].join("\n") + extra
+}
+
+type OutlineExtractOutcome =
+  | { kind: "success"; path: string; taskId: string; ingestResult: OutlineIngestResult }
+  | { kind: "failure"; path: string; taskId: string; reason: string }
+  | { kind: "skipped"; path: string; taskId: string }
+
+export async function runOutlineIngestPaths(
+  projectPath: string,
+  outlinePaths: string[],
+  options?: RunOutlineIngestPathsOptions,
+): Promise<BulkOutlineIngestResult> {
+  assertOutlineIngestLlmReady()
+
+  const pp = normalizePath(projectPath)
+  const normalizedPaths = outlinePaths.map((path) => normalizePath(path))
+  if (normalizedPaths.length === 0) {
+    return { total: 0, succeeded: 0, failed: 0, failures: [] }
+  }
+
+  const abortController = new AbortController()
+  const signal = abortController.signal
+  const taskIds = normalizedPaths.map((outlinePath) => createOutlineIngestTask(pp, outlinePath))
+  const progressTaskId = useImportProgressStore.getState().startTask({
+    projectPath: pp,
+    kind: "outline",
+    total: normalizedPaths.length,
+    currentTitle: getOutlineFileName(normalizedPaths[0] ?? ""),
+    message: i18n.t("novel.outlineGenerator.bulkIngesting"),
+    abortController,
+    concurrency: BULK_OUTLINE_INGEST_CONCURRENCY,
+    activeTitles: [],
+  })
+  options?.onProgressTaskStarted?.(progressTaskId)
+
+  const failures: OutlineIngestFailure[] = []
+  const extractProgress = {
+    completed: 0,
+    inFlight: new Set<string>(),
+  }
+
+  function publishExtractProgress(): void {
+    const activeTitles = [...extractProgress.inFlight]
+    useImportProgressStore.getState().updateTask(progressTaskId, {
+      completed: extractProgress.completed,
+      currentTitle: activeTitles[0] ?? "",
+      activeTitles,
+      concurrency: BULK_OUTLINE_INGEST_CONCURRENCY,
+      message: activeTitles.length > 1
+        ? i18n.t("novel.outlineGenerator.bulkIngestParallel", {
+          active: activeTitles.length,
+          concurrency: BULK_OUTLINE_INGEST_CONCURRENCY,
+        })
+        : i18n.t("novel.outlineGenerator.bulkIngesting"),
+    })
+  }
+
+  const extractOutcomes = (await mapWithConcurrency(
+    normalizedPaths,
+    BULK_OUTLINE_INGEST_CONCURRENCY,
+    async (outlinePath, index) => {
+      const outlineFileName = getOutlineFileName(outlinePath)
+      const taskId = taskIds[index]!
+
+      if (signal.aborted) {
+        useOutlineGenerationStore.getState().updateTask(taskId, {
+          status: "error",
+          message: getOutlineIngestCancelledMessage(),
+          error: getOutlineIngestCancelledMessage(),
+        })
+        return { kind: "skipped", path: outlinePath, taskId } satisfies OutlineExtractOutcome
+      }
+
+      extractProgress.inFlight.add(outlineFileName)
+      publishExtractProgress()
+
+      useOutlineGenerationStore.getState().updateTask(taskId, {
+        status: "ingesting",
+        message: i18n.t("novel.outlineGenerator.ingestingNotification"),
+        error: null,
+      })
+
+      try {
+        const ingestResult = await ingestOutline(pp, outlinePath, signal, { skipSync: true })
+        if (ingestResult.failureReason === "no_llm") {
+          const reason = i18n.t("novel.outlineGenerator.ingestNoLlm")
+          useOutlineGenerationStore.getState().updateTask(taskId, {
+            status: "error",
+            message: reason,
+            error: reason,
+          })
+          return { kind: "failure", path: outlinePath, taskId, reason } satisfies OutlineExtractOutcome
+        }
+        if (!ingestResult.snapshot) {
+          const reason = i18n.t("novel.outlineGenerator.ingestFailedNotification")
+          useOutlineGenerationStore.getState().updateTask(taskId, {
+            status: "error",
+            message: reason,
+            error: reason,
+          })
+          return { kind: "failure", path: outlinePath, taskId, reason } satisfies OutlineExtractOutcome
+        }
+        return { kind: "success", path: outlinePath, taskId, ingestResult } satisfies OutlineExtractOutcome
+      } catch (err) {
+        const reason = buildOutlineIngestFailureReason(err)
+        useOutlineGenerationStore.getState().updateTask(taskId, {
+          status: "error",
+          message: reason,
+          error: reason,
+        })
+        return { kind: "failure", path: outlinePath, taskId, reason } satisfies OutlineExtractOutcome
+      } finally {
+        extractProgress.inFlight.delete(outlineFileName)
+        if (!signal.aborted) {
+          extractProgress.completed += 1
+        } else {
+          const task = useOutlineGenerationStore.getState().tasks.find((item) => item.id === taskId)
+          if (task?.status === "ingesting") {
+            useOutlineGenerationStore.getState().updateTask(taskId, {
+              status: "error",
+              message: getOutlineIngestCancelledMessage(),
+              error: getOutlineIngestCancelledMessage(),
+            })
+          }
+        }
+        publishExtractProgress()
+      }
+    },
+    { signal },
+  )).filter((outcome): outcome is OutlineExtractOutcome => outcome != null)
+
+  const cancelled = signal.aborted
+  const extractSuccesses = extractOutcomes.filter(
+    (outcome): outcome is Extract<OutlineExtractOutcome, { kind: "success" }> => outcome.kind === "success",
+  )
+
+  for (const outcome of extractOutcomes) {
+    if (outcome.kind === "failure") {
+      failures.push({
+        name: getOutlineFileName(outcome.path),
+        path: outcome.path,
+        reason: outcome.reason,
+      })
+    }
+  }
+
+  let succeeded = 0
+  let syncCompleted = 0
+
+  for (const item of extractSuccesses) {
+    if (signal.aborted) break
+
+    const outlineFileName = getOutlineFileName(item.path)
+    useImportProgressStore.getState().updateTask(progressTaskId, {
+      completed: syncCompleted,
+      currentTitle: i18n.t("novel.outlineGenerator.bulkIngestSyncing", { name: outlineFileName }),
+      activeTitles: [outlineFileName],
+      concurrency: 1,
+      message: i18n.t("novel.outlineGenerator.bulkIngestSyncing", { name: outlineFileName }),
+    })
+
+    try {
+      await syncSnapshotToMemory(pp, item.ingestResult.snapshot!, {
+        deferStructuredMemoryExport: true,
+        deferDerivedRebuild: true,
+      })
+      const successMessage = item.ingestResult.truncated
+        ? i18n.t("novel.outlineGenerator.ingestSuccessTruncatedNotification", {
+          used: item.ingestResult.bodyLength,
+          total: item.ingestResult.originalLength,
+          budget: item.ingestResult.bodyBudget,
+        })
+        : i18n.t("novel.outlineGenerator.ingestSuccessNotification")
+      useOutlineGenerationStore.getState().updateTask(item.taskId, {
+        status: "done",
+        message: successMessage,
+        error: null,
+      })
+      succeeded += 1
+    } catch (err) {
+      const reason = buildOutlineIngestFailureReason(err)
+      useOutlineGenerationStore.getState().updateTask(item.taskId, {
+        status: "error",
+        message: reason,
+        error: reason,
+      })
+      failures.push({
+        name: outlineFileName,
+        path: item.path,
+        reason,
+      })
+    } finally {
+      syncCompleted += 1
+      useImportProgressStore.getState().updateTask(progressTaskId, {
+        completed: syncCompleted,
+        activeTitles: [],
+      })
+    }
+  }
+
+  if (succeeded > 0) {
+    await finalizeProjectMemoryRebuild(pp)
+    await refreshProjectState(pp)
+  }
+
+  const result: BulkOutlineIngestResult = {
+    total: normalizedPaths.length,
+    succeeded,
+    failed: failures.length,
+    cancelled: cancelled || undefined,
+    failures,
+  }
+
+  useImportProgressStore.getState().finishTask(
+    progressTaskId,
+    cancelled ? "cancelled" : failures.length > 0 ? "error" : "done",
+    {
+      completed: syncCompleted,
+      total: normalizedPaths.length,
+      currentTitle: "",
+      activeTitles: [],
+      message: buildBulkIngestProgressMessage(result),
+    },
+  )
+
+  finalizeOutstandingIngestTasks(taskIds, cancelled)
+
+  return result
+}
+
+export async function runSingleOutlineIngest(
+  projectPath: string,
+  outlinePath: string,
+): Promise<BulkOutlineIngestResult> {
+  return runOutlineIngestPaths(projectPath, [normalizePath(outlinePath)])
+}
+
+export function startOutlineIngestTask(projectPath: string, outlinePath: string): string {
+  const taskId = createOutlineIngestTask(projectPath, outlinePath)
+  void runOutlineIngestTask(taskId)
+  return taskId
+}
+
+function collectOutlineMarkdownPaths(
+  nodes: Array<{ path: string; name: string; is_dir: boolean; children?: Array<{ path: string; name: string; is_dir: boolean; children?: unknown[] }> }>,
+): string[] {
+  const paths: string[] = []
+  for (const node of nodes) {
+    if (node.is_dir && node.children) {
+      paths.push(...collectOutlineMarkdownPaths(node.children as Array<{ path: string; name: string; is_dir: boolean; children?: Array<{ path: string; name: string; is_dir: boolean; children?: unknown[] }> }>))
+      continue
+    }
+    if (!node.is_dir && node.name.endsWith(".md")) {
+      paths.push(normalizePath(node.path))
+    }
+  }
+  return paths
+}
+
+export async function runBulkOutlineIngest(projectPath: string): Promise<BulkOutlineIngestResult> {
+  const pp = normalizePath(projectPath)
+  let outlinePaths: string[] = []
+
+  try {
+    const tree = await listDirectory(`${pp}/wiki/outlines`)
+    outlinePaths = collectOutlineMarkdownPaths(tree as Array<{ path: string; name: string; is_dir: boolean; children?: Array<{ path: string; name: string; is_dir: boolean; children?: unknown[] }> }>)
+      .sort((a, b) => a.localeCompare(b, "zh-CN"))
+  } catch {
+    return { total: 0, succeeded: 0, failed: 0, failures: [] }
+  }
+
+  return runOutlineIngestPaths(pp, outlinePaths)
+}
+
+export async function runOutlineIngestTask(
+  taskId: string,
+  options: RunOutlineIngestTaskOptions = {},
+): Promise<OutlineIngestTaskResult | null> {
+  const task = useOutlineGenerationStore.getState().tasks.find((item) => item.id === taskId)
+  if (!task?.outlinePath) return null
+
+  const outlinePath = task.outlinePath
+  const outlineFileName = getOutlineFileName(outlinePath)
+  const manageProgress = options.manageProgress !== false
+  const abortController = options.signal ? null : new AbortController()
+  const signal = options.signal ?? abortController!.signal
+  let progressTaskId = options.parentProgressId
+
+  if (manageProgress && !progressTaskId) {
+    progressTaskId = useImportProgressStore.getState().startTask({
+      projectPath: task.projectPath,
+      kind: "outline",
+      total: 1,
+      currentTitle: outlineFileName,
+      message: "正在提取大纲记忆",
+      abortController: abortController ?? undefined,
+    })
+  }
+
+  try {
+    useOutlineGenerationStore.getState().updateTask(taskId, {
+      status: "ingesting",
+      message: i18n.t("novel.outlineGenerator.ingestingNotification"),
+      error: null,
+    })
+    const ingestResult = await ingestOutline(task.projectPath, outlinePath, signal)
+    const snapshot = ingestResult.snapshot
+
+    if (ingestResult.failureReason === "no_llm") {
+      const reason = i18n.t("novel.outlineGenerator.ingestNoLlm")
+      useOutlineGenerationStore.getState().updateTask(taskId, {
+        status: "error",
+        message: reason,
+        error: reason,
+      })
+      if (manageProgress && progressTaskId) {
+        useImportProgressStore.getState().finishTask(progressTaskId, "error", {
+          completed: 0,
+          total: 1,
+          currentTitle: "",
+          message: `${outlineFileName} 提取失败：${reason}`,
+        })
+      }
+      return { success: false, outlinePath, outlineFileName, error: reason }
+    }
+
+    if (snapshot) {
+      await refreshProjectState(task.projectPath)
+    }
+
+    const successMessage = snapshot
+      ? ingestResult.truncated
+        ? i18n.t("novel.outlineGenerator.ingestSuccessTruncatedNotification", {
+          used: ingestResult.bodyLength,
+          total: ingestResult.originalLength,
+          budget: ingestResult.bodyBudget,
+        })
+        : i18n.t("novel.outlineGenerator.ingestSuccessNotification")
+      : i18n.t("novel.outlineGenerator.ingestFailedNotification")
+    const errorMessage = snapshot ? undefined : i18n.t("novel.outlineGenerator.ingestFailedNotification")
+
+    useOutlineGenerationStore.getState().updateTask(taskId, {
+      status: snapshot ? "done" : "error",
+      message: successMessage,
+      error: errorMessage ?? null,
+    })
+
+    if (manageProgress && progressTaskId) {
+      useImportProgressStore.getState().finishTask(progressTaskId, snapshot ? "done" : "error", {
+        completed: snapshot ? 1 : 0,
+        total: 1,
+        currentTitle: "",
+        message: snapshot
+          ? ingestResult.truncated
+            ? i18n.t("novel.outlineGenerator.ingestProgressTruncated", {
+              name: outlineFileName,
+              used: ingestResult.bodyLength,
+              total: ingestResult.originalLength,
+            })
+            : `${outlineFileName} 提取完成`
+          : `${outlineFileName} 提取失败`,
+      })
+    }
+
+    return {
+      success: Boolean(snapshot),
+      outlinePath,
+      outlineFileName,
+      error: errorMessage,
+      truncated: ingestResult.truncated,
+      bodyLength: ingestResult.bodyLength,
+      originalLength: ingestResult.originalLength,
+      bodyBudget: ingestResult.bodyBudget,
+    }
+  } catch (err) {
+    const message = buildOutlineIngestFailureReason(err)
+    useOutlineGenerationStore.getState().updateTask(taskId, {
+      status: "error",
+      message,
+      error: message,
+    })
+    if (manageProgress && progressTaskId) {
+      useImportProgressStore.getState().finishTask(progressTaskId, "error", {
+        completed: 0,
+        total: 1,
+        currentTitle: "",
+        message: `${outlineFileName} 提取失败：${message}`,
+      })
+    }
+    return { success: false, outlinePath, outlineFileName, error: message }
+  }
+}

src/lib/novel/outline-ingest-utils.spec.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it, vi } from "vitest"
+import { getOutlineFileName, getOutlineIngestIdentity, outlineSnapshotExists } from "./outline-ingest-utils"
+
+vi.mock("@/commands/fs", () => ({
+  fileExists: vi.fn(),
+}))
+
+import { fileExists } from "@/commands/fs"
+
+describe("getOutlineIngestIdentity", () => {
+  it("derives a stable negative chapter number and snapshot path from outline filename", () => {
+    const identity = getOutlineIngestIdentity("/proj", "/proj/wiki/outlines/vol-1-outline.md")
+    expect(identity.outlineName).toBe("vol-1-outline")
+    expect(identity.chapterNumber).toBeLessThan(0)
+    expect(identity.snapshotJsonPath).toMatch(/\.novel\/snapshots\/outline-\d{3}\.snapshot\.json$/)
+  })
+
+  it("returns the same identity for the same outline path", () => {
+    const left = getOutlineIngestIdentity("/proj", "/proj/wiki/outlines/plot.md")
+    const right = getOutlineIngestIdentity("/proj", "/proj/wiki/outlines/plot.md")
+    expect(left).toEqual(right)
+  })
+})
+
+describe("getOutlineFileName", () => {
+  it("strips extension and falls back when path is empty", () => {
+    expect(getOutlineFileName("/a/b/story-outline.md")).toBe("story-outline")
+    expect(getOutlineFileName("")).toBe("大纲")
+  })
+})
+
+describe("outlineSnapshotExists", () => {
+  it("checks the derived snapshot json path", async () => {
+    vi.mocked(fileExists).mockResolvedValueOnce(true)
+    await expect(outlineSnapshotExists("/proj", "/proj/wiki/outlines/plot.md")).resolves.toBe(true)
+    expect(fileExists).toHaveBeenCalledWith(expect.stringContaining("/proj/.novel/snapshots/outline-"))
+  })
+})

src/lib/novel/outline-ingest-utils.ts

@@ -0,0 +1,37 @@
+import { fileExists } from "@/commands/fs"
+import { normalizePath } from "@/lib/path-utils"
+
+export interface OutlineIngestIdentity {
+  outlineName: string
+  chapterNumber: number
+  snapshotJsonPath: string
+}
+
+export function getOutlineIngestIdentity(projectPath: string, outlinePath: string): OutlineIngestIdentity {
+  const normalizedOutlinePath = normalizePath(outlinePath)
+  const fileName = normalizedOutlinePath.split("/").pop() ?? "outline"
+  const outlineName = fileName.replace(/\.\w+$/, "")
+
+  let hash = 0
+  for (let i = 0; i < outlineName.length; i++) {
+    hash = ((hash << 5) - hash + outlineName.charCodeAt(i)) | 0
+  }
+  const chapterNumber = -(Math.abs(hash % 999) + 1)
+  const prefix = `outline-${String(Math.abs(chapterNumber)).padStart(3, "0")}`
+  const snapshotJsonPath = `${normalizePath(projectPath)}/.novel/snapshots/${prefix}.snapshot.json`
+
+  return { outlineName, chapterNumber, snapshotJsonPath }
+}
+
+export function getOutlineFileName(outlinePath: string): string {
+  return outlinePath.split("/").pop()?.replace(/\.\w+$/, "") || "大纲"
+}
+
+export async function outlineSnapshotExists(projectPath: string, outlinePath: string): Promise<boolean> {
+  const { snapshotJsonPath } = getOutlineIngestIdentity(projectPath, outlinePath)
+  try {
+    return await fileExists(snapshotJsonPath)
+  } catch {
+    return false
+  }
+}

src/lib/novel/previous-chapters-analysis.ts

@@ -19,6 +19,7 @@ export async function analyzePreviousChapters(
   currentChapterNumber: number,
   llmConfig: LlmConfig,
   analysisCount: number = 3,
+  signal?: AbortSignal,
 ): Promise<string> {
   if (currentChapterNumber <= 1) return ""
 
@@ -26,6 +27,7 @@ export async function analyzePreviousChapters(
 
   // 读取前N章的完整内容
   for (let i = Math.max(1, currentChapterNumber - analysisCount); i < currentChapterNumber; i++) {
+    if (signal?.aborted) throw new Error("已停止生成")
     try {
       const results = await searchWiki(projectPath, `chapter_number:${i}`)
       if (results.length > 0) {
@@ -55,9 +57,11 @@ export async function analyzePreviousChapters(
       onToken: (token) => { analysis += token },
       onDone: () => {},
       onError: () => {},
-    }
+    },
+    signal,
   )
 
+  if (signal?.aborted) throw new Error("已停止生成")
   return analysis.trim()
 }
 

src/lib/novel/review-adapter.ts

@@ -7,6 +7,7 @@ import { contextPackToPrompt, buildContextPack, type ContextPack } from "./conte
 import { buildCharacterAuraContext } from "./character-aura"
 import { resolveNovelModel } from "./model-resolver"
 import { hasUsableLlm } from "@/lib/has-usable-llm"
+import { rethrowIfUserAbort } from "@/lib/user-abort"
 
 export interface NovelReviewResult {
   severity: "error" | "warning" | "info"
@@ -309,6 +310,7 @@ ${langReminder}`
 
     return chunkResults.flat()
   } catch (err) {
+    rethrowIfUserAbort(err, signal)
     console.error("[Novel Review] Failed:", err)
     return []
   }

src/lib/user-abort.spec.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest"
+import { isUserAbortError, rethrowIfUserAbort, USER_ABORT_MESSAGE } from "./user-abort"
+
+describe("user-abort", () => {
+  it("detects explicit user abort message", () => {
+    expect(isUserAbortError(new Error(USER_ABORT_MESSAGE))).toBe(true)
+  })
+
+  it("detects aborted signal", () => {
+    const controller = new AbortController()
+    controller.abort()
+    expect(isUserAbortError(new Error("network"), controller.signal)).toBe(true)
+  })
+
+  it("rethrows user abort errors", () => {
+    const controller = new AbortController()
+    controller.abort()
+    expect(() => rethrowIfUserAbort(new Error("timeout"), controller.signal)).toThrow(USER_ABORT_MESSAGE)
+  })
+
+  it("ignores unrelated errors", () => {
+    expect(() => rethrowIfUserAbort(new Error("timeout"))).not.toThrow()
+  })
+})

src/lib/user-abort.ts

@@ -0,0 +1,18 @@
+export const USER_ABORT_MESSAGE = "已停止生成"
+
+export function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) throw new Error(USER_ABORT_MESSAGE)
+}
+
+export function isUserAbortError(error: unknown, signal?: AbortSignal): boolean {
+  if (signal?.aborted) return true
+  if (!(error instanceof Error)) return false
+  if (error.message === USER_ABORT_MESSAGE) return true
+  if (error.name === "AbortError") return true
+  return /request cancelled|request canceled|aborted/i.test(error.message)
+}
+
+export function rethrowIfUserAbort(error: unknown, signal?: AbortSignal): never | void {
+  if (!isUserAbortError(error, signal)) return
+  throw new Error(USER_ABORT_MESSAGE)
+}

src/stores/import-progress-store.ts

@@ -12,6 +12,8 @@ export interface ImportProgressTask {
   completed: number
   total: number
   currentTitle: string
+  activeTitles?: string[]
+  concurrency?: number
   message?: string
   error?: string
   cancelling: boolean
@@ -27,6 +29,8 @@ interface StartImportProgressTaskInput {
   currentTitle?: string
   message?: string
   abortController?: AbortController
+  activeTitles?: string[]
+  concurrency?: number
 }
 
 export interface ImportProgressState {
@@ -62,6 +66,8 @@ export const useImportProgressStore = create<ImportProgressState>((set, get) =>
           total: input.total,
           currentTitle: input.currentTitle ?? "",
           message: input.message,
+          activeTitles: input.activeTitles ?? [],
+          concurrency: input.concurrency,
           cancelling: false,
           createdAt: now,
           updatedAt: now,
@@ -82,7 +88,13 @@ export const useImportProgressStore = create<ImportProgressState>((set, get) =>
     }))
   },
   finishTask: (taskId, status, patch = {}) => {
+    const task = get().tasks.find((item) => item.id === taskId)
     get().updateTask(taskId, { ...patch, status, cancelling: false })
+    if (task?.kind === "outline" && status !== "running") {
+      void import("@/lib/novel/outline-generation").then(({ reconcileStaleOutlineIngestTasks }) => {
+        reconcileStaleOutlineIngestTasks(task.projectPath)
+      })
+    }
   },
   markCancelling: (taskId) => {
     get().updateTask(taskId, { cancelling: true })
@@ -91,7 +103,12 @@ export const useImportProgressStore = create<ImportProgressState>((set, get) =>
     const task = get().tasks.find((t) => t.id === taskId)
     if (!task) return
     task.abortController?.abort()
-    get().updateTask(taskId, { status: "cancelled", cancelling: false })
+    get().updateTask(taskId, { status: "cancelled", cancelling: false, activeTitles: [] })
+    if (task.kind === "outline") {
+      void import("@/lib/novel/outline-generation").then(({ reconcileStaleOutlineIngestTasks }) => {
+        reconcileStaleOutlineIngestTasks(task.projectPath)
+      })
+    }
     setTimeout(() => {
       get().clearTask(taskId)
     }, 3000)