@musnows/scriverse 0.9.4 → 0.9.6

package/dist/store.js

@@ -4,34 +4,70 @@ import { ENTITY_VERSION_BASELINE_MIGRATION_VERSION, PLATFORM_AI_WORK_ID, SYSTEM_
 import { exportWorkDocx } from "./docx-export.js";
 import { createEpubArchive } from "./epub-export.js";
 import { AppError, notFound } from "./errors.js";
-import { documentParagraphLineRanges, normalizeWorkSearchQuery } from "./hybrid-search.js";
+import { documentParagraphLineRanges, hybridSearchPermissionModule, normalizeWorkSearchQuery } from "./hybrid-search.js";
 import { accountReference, logger } from "./logger.js";
 import { paginated, paginationSql } from "./pagination.js";
 import { currentRequestActor } from "./request-context.js";
-import { canWriteWorkModule, classifyWorkModulePermissions, emptyWorkModulePermissions, fullWorkModulePermissions, storedWorkModulePermissions } from "./work-permissions.js";
+import { canReadWorkModule, canWriteWorkModule, classifyWorkModulePermissions, emptyWorkModulePermissions, fullWorkModulePermissions, storedWorkModulePermissions } from "./work-permissions.js";
 import { countWords, documentShortSearchTerms, escapeSqlLikePattern, id, json, normalizeDocumentSearchText, now, splitDocumentParagraphs } from "./utils.js";
 import { buildWritingCalendar, writingDateKey } from "./writing-progress-time.js";
 import { resolveMaxAgentToolCallLimit } from "./ai-tool-results.js";
 import { DEFAULT_AI_STREAM_IDLE_TIMEOUT_SECONDS, normalizeAiStreamIdleTimeoutSeconds } from "./ai-stream-timeout.js";
 import { normalizeRoleplayScenePin, roleplayUserTurnDisplayText, roleplayUserTurnTitleSource } from "./roleplay-turn.js";
+import { chapterAnnotationLineHashes, createChapterLineIds, MAX_CHAPTER_LINE_IDS, parseChapterAnnotationLineIds, parseChapterAnnotationLineHashes, parseChapterLineIds, reconcileChapterLineIds, reanchorChapterAnnotations } from "./chapter-annotation-anchor.js";
+import { renumberChapterTitle } from "./chapter-title-numbering.js";
+import { normalizeRoleplayMemoryContent, roleplayMemoryCandidateIsSafe } from "./roleplay-memory.js";
 const WORK_LIST_BATCH_SIZE = 500;
 const ENTITY_LIST_BATCH_SIZE = 400;
 export const RECYCLE_BIN_RETENTION_DAYS = 30;
 function recycleBinExpiresAt(deletedAt) {
     return new Date(new Date(deletedAt).getTime() + RECYCLE_BIN_RETENTION_DAYS * 24 * 60 * 60_000).toISOString();
 }
+function chapterAnnotationListFilter(kinds, filters = {}) {
+    const where = [];
+    const params = [];
+    if (kinds !== undefined) {
+        if (kinds.length > 0) {
+            where.push(`annotation.kind IN (${kinds.map(() => "?").join(",")})`);
+            params.push(...kinds);
+        }
+        else {
+            where.push("1 = 0");
+        }
+    }
+    if (filters.chapterId) {
+        where.push("annotation.chapter_id = ?");
+        params.push(filters.chapterId);
+    }
+    const normalizedQuery = filters.query?.normalize("NFKC").trim().slice(0, 100) ?? "";
+    if (normalizedQuery) {
+        const pattern = `%${escapeSqlLikePattern(normalizedQuery)}%`;
+        where.push(`(
+      annotation.note LIKE ? ESCAPE '\\' COLLATE NOCASE
+      OR annotation.quote LIKE ? ESCAPE '\\' COLLATE NOCASE
+      OR chapter.title LIKE ? ESCAPE '\\' COLLATE NOCASE
+      OR volume.title LIKE ? ESCAPE '\\' COLLATE NOCASE
+    )`);
+        params.push(pattern, pattern, pattern, pattern);
+    }
+    return {
+        sql: where.map((clause) => ` AND ${clause}`).join(""),
+        params
+    };
+}
 export const attachmentPermissionModules = ["prose", "drafts", "settings", "characters", "races", "organizations", "ai-chat"];
 export const WORK_AGENT_TOOL_IDS = [
     "story_index",
     "read_chapters",
     "grep",
     "search_story_entities",
+    "semantic_search_story",
     "read_character_sections",
     "search_drafts",
     "image",
     "calculate_time"
 ];
-const DEFAULT_WORK_AGENT_TOOLS = [...WORK_AGENT_TOOL_IDS];
+const DEFAULT_WORK_AGENT_TOOLS = WORK_AGENT_TOOL_IDS.filter((toolId) => toolId !== "semantic_search_story");
 const LEGACY_DEFAULT_WORK_AGENT_TOOLS = [
     "story_index",
     "read_chapters",
@@ -217,7 +253,12 @@ const legacyFavoriteTables = {
     organization: "organizations"
 };
 export const AI_CONVERSATION_STREAM_REQUEST_LEASE_MS = 3 * 60_000;
-export const aiConversationTaskTypes = ["chat", "roleplay", "continue", "polish"];
+export const aiConversationTaskTypes = ["chat", "roleplay"];
+function normalizeAiConversationTaskType(value, roleplayCharacterId) {
+    if (roleplayCharacterId || value === "roleplay")
+        return "roleplay";
+    return "chat";
+}
 export function defaultAiConversationTitle(prompt) {
     const normalized = roleplayUserTurnTitleSource(prompt).replace(/\s+/gu, " ").trim();
     return Array.from(normalized).slice(0, 15).join("") || "新对话";
@@ -534,6 +575,8 @@ export class Store {
                 language: entity.language,
                 coverUrl: entity.coverUrl,
                 tags: entity.tags,
+                editorAutoIndentEnabled: entity.editorAutoIndentEnabled,
+                editorTypewriterModeEnabled: entity.editorTypewriterModeEnabled,
                 ownerUserId: entity.ownerUserId
             };
         if (type === "volume")
@@ -802,8 +845,9 @@ export class Store {
             return this.db.transaction(() => {
                 const ownerUserId = this.resolveWorkOwnerUserId(typeof snapshot.ownerUserId === "string" ? snapshot.ownerUserId : null, true);
                 const timestamp = now();
-                this.db.run(`INSERT INTO works (id, title, author, description, language, cover_url, tags_json, version_no, created_at, updated_at, owner_user_id)
-           VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)`, entityId, String(snapshot.title ?? "未命名作品"), String(snapshot.author ?? ""), String(snapshot.description ?? ""), String(snapshot.language ?? "zh-CN"), snapshot.coverUrl ?? null, JSON.stringify(Array.isArray(snapshot.tags) ? snapshot.tags : []), timestamp, timestamp, ownerUserId);
+                this.db.run(`INSERT INTO works (id, title, author, description, language, cover_url, tags_json,
+           editor_auto_indent_enabled, editor_typewriter_mode_enabled, version_no, created_at, updated_at, owner_user_id)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)`, entityId, String(snapshot.title ?? "未命名作品"), String(snapshot.author ?? ""), String(snapshot.description ?? ""), String(snapshot.language ?? "zh-CN"), snapshot.coverUrl ?? null, JSON.stringify(Array.isArray(snapshot.tags) ? snapshot.tags : []), snapshot.editorAutoIndentEnabled === true ? 1 : 0, snapshot.editorTypewriterModeEnabled === true ? 1 : 0, timestamp, timestamp, ownerUserId);
                 if (ownerUserId !== SYSTEM_USER_ID) {
                     this.db.run("INSERT INTO work_memberships (work_id, user_id, role, invited_by_user_id, created_at) VALUES (?, ?, 'owner', ?, ?)", entityId, ownerUserId, ownerUserId, timestamp);
                 }
@@ -868,8 +912,9 @@ export class Store {
         const timestamp = now();
         const resolvedOwnerUserId = this.resolveWorkOwnerUserId(ownerUserId);
         this.db.transaction(() => {
-            this.db.run(`INSERT INTO works (id, title, author, description, language, cover_url, tags_json, created_at, updated_at, owner_user_id)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, workId, input.title, input.author ?? "", input.description ?? "", input.language ?? "zh-CN", input.coverUrl ?? null, JSON.stringify(input.tags ?? []), timestamp, timestamp, resolvedOwnerUserId);
+            this.db.run(`INSERT INTO works (id, title, author, description, language, cover_url, tags_json,
+         editor_auto_indent_enabled, editor_typewriter_mode_enabled, created_at, updated_at, owner_user_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, workId, input.title, input.author ?? "", input.description ?? "", input.language ?? "zh-CN", input.coverUrl ?? null, JSON.stringify(input.tags ?? []), input.editorAutoIndentEnabled === true ? 1 : 0, input.editorTypewriterModeEnabled === true ? 1 : 0, timestamp, timestamp, resolvedOwnerUserId);
             if (resolvedOwnerUserId !== SYSTEM_USER_ID) {
                 this.db.run("INSERT INTO work_memberships (work_id, user_id, role, invited_by_user_id, created_at) VALUES (?, ?, 'owner', ?, ?)", workId, resolvedOwnerUserId, resolvedOwnerUserId, timestamp);
             }
@@ -1065,6 +1110,18 @@ export class Store {
             titleGenerationModelId: row?.title_generation_model_id === null || row?.title_generation_model_id === undefined
                 ? null
                 : String(row.title_generation_model_id),
+            semanticSearchEnabled: Number(row?.semantic_search_enabled ?? 0) === 1,
+            semanticEmbeddingModelId: row?.semantic_embedding_model_id === null || row?.semantic_embedding_model_id === undefined
+                ? null
+                : String(row.semantic_embedding_model_id),
+            semanticRerankModelId: row?.semantic_rerank_model_id === null || row?.semantic_rerank_model_id === undefined
+                ? null
+                : String(row.semantic_rerank_model_id),
+            semanticVectorDimension: Math.min(65_536, Math.max(1, Number(row?.semantic_vector_dimension ?? 1_024) || 1_024)),
+            semanticRecallLimit: Math.min(200, Math.max(1, Number(row?.semantic_recall_limit ?? 20) || 20)),
+            semanticResultLimit: Math.min(100, Math.max(1, Number(row?.semantic_result_limit ?? 12) || 12)),
+            semanticBudgetTokens: Math.min(100_000, Math.max(256, Number(row?.semantic_budget_tokens ?? 4_000) || 4_000)),
+            semanticChannelWeight: Math.min(5, Math.max(0.1, Number(row?.semantic_channel_weight ?? 1) || 1)),
             updatedAt: String(row?.updated_at ?? "")
         };
     }
@@ -1149,6 +1206,95 @@ export class Store {
         });
         return this.getWorkAiSettings(workId);
     }
+    updateWorkSemanticSearchSettings(workId, input) {
+        this.getWork(workId);
+        const current = this.getWorkAiSettings(workId);
+        const enabled = input.enabled ?? Boolean(current.semanticSearchEnabled);
+        const embeddingModelId = input.embeddingModelId === undefined
+            ? current.semanticEmbeddingModelId ? String(current.semanticEmbeddingModelId) : null
+            : input.embeddingModelId?.trim() || null;
+        const rerankModelId = input.rerankModelId === undefined
+            ? current.semanticRerankModelId ? String(current.semanticRerankModelId) : null
+            : input.rerankModelId?.trim() || null;
+        const vectorDimension = Math.min(65_536, Math.max(1, Math.trunc(input.vectorDimension ?? Number(current.semanticVectorDimension))));
+        const recallLimit = Math.min(200, Math.max(1, Math.trunc(input.recallLimit ?? Number(current.semanticRecallLimit))));
+        const resultLimit = Math.min(100, Math.max(1, Math.trunc(input.resultLimit ?? Number(current.semanticResultLimit))));
+        const budgetTokens = Math.min(100_000, Math.max(256, Math.trunc(input.budgetTokens ?? Number(current.semanticBudgetTokens))));
+        const channelWeight = Math.min(5, Math.max(0.1, Number(input.channelWeight ?? current.semanticChannelWeight)));
+        const timestamp = now();
+        this.db.transaction(() => {
+            this.db.run(`INSERT INTO work_ai_settings (
+           work_id, semantic_search_enabled, semantic_embedding_model_id, semantic_rerank_model_id,
+           semantic_vector_dimension, semantic_recall_limit, semantic_result_limit,
+           semantic_budget_tokens, semantic_channel_weight, updated_at
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(work_id) DO UPDATE SET
+           semantic_search_enabled = excluded.semantic_search_enabled,
+           semantic_embedding_model_id = excluded.semantic_embedding_model_id,
+           semantic_rerank_model_id = excluded.semantic_rerank_model_id,
+           semantic_vector_dimension = excluded.semantic_vector_dimension,
+           semantic_recall_limit = excluded.semantic_recall_limit,
+           semantic_result_limit = excluded.semantic_result_limit,
+           semantic_budget_tokens = excluded.semantic_budget_tokens,
+           semantic_channel_weight = excluded.semantic_channel_weight,
+           updated_at = excluded.updated_at`, workId, enabled ? 1 : 0, embeddingModelId, rerankModelId, vectorDimension, recallLimit, resultLimit, budgetTokens, channelWeight, timestamp);
+            this.audit(workId, "semantic.settings.updated", "work-ai-settings", workId, {
+                enabled,
+                embeddingModelId,
+                rerankModelId,
+                vectorDimension,
+                recallLimit,
+                resultLimit,
+                budgetTokens,
+                channelWeight
+            });
+        });
+        return this.getWorkAiSettings(workId);
+    }
+    getSemanticContextSnapshot(snapshotId, workId) {
+        const work = this.getWork(workId);
+        const row = this.db.get("SELECT * FROM semantic_context_snapshots WHERE id = ? AND work_id = ?", snapshotId, workId);
+        if (!row)
+            throw notFound("语义上下文快照");
+        const actor = currentRequestActor();
+        const createdByUserId = row.created_by_user_id === null || row.created_by_user_id === undefined
+            ? null
+            : String(row.created_by_user_id);
+        if (actor?.userId && createdByUserId && actor.userId !== createdByUserId) {
+            throw new AppError(403, "SEMANTIC_SNAPSHOT_ACCESS_DENIED", "不能读取其他用户创建的语义上下文快照");
+        }
+        const permissions = work.modulePermissions;
+        const items = this.db.all("SELECT * FROM semantic_context_snapshot_items WHERE snapshot_id = ? ORDER BY position", snapshotId).flatMap((item) => {
+            const module = hybridSearchPermissionModule(String(item.source_type));
+            if (!module || !canReadWorkModule(permissions, module))
+                return [];
+            return [{
+                    position: Number(item.position),
+                    entryId: String(item.entry_id),
+                    sourceType: String(item.source_type),
+                    sourceId: String(item.source_id),
+                    sectionId: String(item.section_id) || null,
+                    sourceVersion: String(item.source_version),
+                    sourceTitle: String(item.source_title),
+                    startLine: Number(item.start_line),
+                    endLine: Number(item.end_line),
+                    content: String(item.content),
+                    estimatedTokens: Number(item.estimated_tokens),
+                    matchKinds: json(String(item.match_kinds_json), ["semantic"])
+                }];
+        });
+        return {
+            id: String(row.id),
+            workId: String(row.work_id),
+            conversationId: row.conversation_id === null ? null : String(row.conversation_id),
+            query: String(row.query),
+            scope: json(String(row.scope_json), {}),
+            configFingerprint: String(row.config_fingerprint),
+            createdByUserId,
+            createdAt: String(row.created_at),
+            items
+        };
+    }
     clearAutoRunPause(workId) {
         this.getWork(workId);
         const current = this.getWorkAiSettings(workId);
@@ -1201,8 +1347,9 @@ export class Store {
             const current = this.getWork(workId);
             this.assertExpectedVersion("work", workId, expectedVersionNo, "作品", Number(current.versionNo));
             const timestamp = now();
-            this.db.run(`UPDATE works SET title = ?, author = ?, description = ?, language = ?, cover_url = ?, tags_json = ?, version_no = version_no + 1, updated_at = ?
-         WHERE id = ?`, input.title ?? String(current.title), input.author ?? String(current.author), input.description ?? String(current.description), input.language ?? String(current.language), input.coverUrl === undefined ? current.coverUrl : input.coverUrl, JSON.stringify(input.tags ?? current.tags), timestamp, workId);
+            this.db.run(`UPDATE works SET title = ?, author = ?, description = ?, language = ?, cover_url = ?, tags_json = ?,
+         editor_auto_indent_enabled = ?, editor_typewriter_mode_enabled = ?, version_no = version_no + 1, updated_at = ?
+         WHERE id = ?`, input.title ?? String(current.title), input.author ?? String(current.author), input.description ?? String(current.description), input.language ?? String(current.language), input.coverUrl === undefined ? current.coverUrl : input.coverUrl, JSON.stringify(input.tags ?? current.tags), input.editorAutoIndentEnabled === undefined ? (current.editorAutoIndentEnabled ? 1 : 0) : input.editorAutoIndentEnabled ? 1 : 0, input.editorTypewriterModeEnabled === undefined ? (current.editorTypewriterModeEnabled ? 1 : 0) : input.editorTypewriterModeEnabled ? 1 : 0, timestamp, workId);
             this.recordEntityVersion("work", workId, source, sourceRef, changeNote || "更新作品信息", timestamp);
             this.audit(workId, "work.updated", "work", workId, { fields: Object.keys(input), versionNo: Number(current.versionNo) + 1, source, sourceRef, changeNote });
         });
@@ -2106,6 +2253,7 @@ export class Store {
         const nextContent = input.content === undefined ? String(current.content) : input.content;
         const nextExcluded = input.excludedFromAnalysis ?? Boolean(current.excludedFromAnalysis);
         const nextChapterType = input.chapterType ?? String(current.chapterType);
+        const hasContentChange = nextContent !== current.content;
         const hasTextChange = nextTitle !== current.title || nextContent !== current.content;
         const hasTypeChange = nextChapterType !== current.chapterType;
         const hasOtherChange = nextExcluded !== current.excludedFromAnalysis || hasTypeChange;
@@ -2116,12 +2264,23 @@ export class Store {
         this.db.transaction(() => {
             const lockedCurrent = this.getChapter(chapterId);
             this.assertExpectedRevision("chapter", chapterId, expectedVersionNo, "章节", Number(lockedCurrent.versionNo));
+            const storedLineIds = parseChapterLineIds(lockedCurrent.lineIds, String(lockedCurrent.content));
+            const beforeLineIds = storedLineIds.length > 0
+                ? storedLineIds
+                : createChapterLineIds(String(lockedCurrent.content), () => id("chapterLine"));
+            const nextLineIds = hasContentChange
+                ? reconcileChapterLineIds(String(lockedCurrent.content), nextContent, beforeLineIds, input.lineIds, () => id("chapterLine"))
+                : beforeLineIds;
+            if (!nextLineIds)
+                throw new AppError(400, "CHAPTER_LINE_IDS_INVALID", "正文行身份与当前版本不匹配，请刷新后重试");
             this.db.run(`UPDATE chapters SET title = ?, content = ?, chapter_type = ?, word_count = ?, version_no = ?, analysis_status = ?,
-         excluded_from_analysis = ?, updated_at = ? WHERE id = ?`, nextTitle, nextContent, nextChapterType, countWords(nextContent), versionNo, hasTextChange || hasTypeChange ? "expired" : String(current.analysisStatus), nextExcluded ? 1 : 0, timestamp, chapterId);
+         excluded_from_analysis = ?, line_ids_json = ?, updated_at = ? WHERE id = ?`, nextTitle, nextContent, nextChapterType, countWords(nextContent), versionNo, hasTextChange || hasTypeChange ? "expired" : String(current.analysisStatus), nextExcluded ? 1 : 0, JSON.stringify(nextLineIds), timestamp, chapterId);
             if (hasTextChange)
                 this.syncChapterParagraphSearch(String(current.workId), chapterId, nextContent);
             else if (hasTypeChange)
                 this.syncChapterParagraphSearchVersion(chapterId, versionNo);
+            if (hasContentChange)
+                this.reanchorChapterAnnotations(String(current.workId), chapterId, String(lockedCurrent.content), nextContent, nextLineIds, source, timestamp);
             if (hasTextChange || hasTypeChange) {
                 this.insertChapterVersionRow({
                     workId: String(current.workId),
@@ -2145,6 +2304,36 @@ export class Store {
         });
         return this.getChapter(chapterId);
     }
+    reanchorChapterAnnotations(workId, chapterId, beforeContent, afterContent, afterLineIds, source, timestamp) {
+        const annotations = this.db.all(`SELECT id, start_line, end_line, quote, line_hashes_json, anchor_line_ids_json
+       FROM chapter_annotations
+       WHERE chapter_id = ? AND deleted_at IS NULL`, chapterId).map((row) => ({
+            id: requiredString(row, "id"),
+            startLine: numberValue(row, "start_line"),
+            endLine: numberValue(row, "end_line"),
+            quote: requiredString(row, "quote"),
+            lineHashes: parseChapterAnnotationLineHashes(row.line_hashes_json, requiredString(row, "quote")),
+            lineIds: parseChapterAnnotationLineIds(row.anchor_line_ids_json)
+        }));
+        for (const annotation of reanchorChapterAnnotations(beforeContent, afterContent, annotations, afterLineIds)) {
+            if (!annotation.changed)
+                continue;
+            this.db.run(`UPDATE chapter_annotations
+         SET start_line = ?, end_line = ?, quote = ?, line_hashes_json = ?, anchor_line_ids_json = ?, version_no = version_no + 1
+         WHERE id = ?`, annotation.startLine, annotation.endLine, annotation.quote, JSON.stringify(annotation.lineHashes), JSON.stringify(annotation.lineIds), annotation.id);
+            const updated = this.getChapterAnnotation(annotation.id);
+            this.recordChapterAnnotationVersion(updated, "reanchor", timestamp);
+            this.audit(workId, "chapter.annotation.updated", "chapter-annotation", annotation.id, {
+                chapterId,
+                startLine: annotation.startLine,
+                endLine: annotation.endLine,
+                versionNo: updated.versionNo,
+                anchorStrategy: annotation.anchorStrategy,
+                reason: "reanchor",
+                source
+            });
+        }
+    }
     replaceWorkText(workId, input) {
         const find = input.find;
         if (!find)
@@ -2280,10 +2469,11 @@ export class Store {
             ? numberValue(this.db.get("SELECT COALESCE(MAX(sort_order), -1) AS sort_order FROM chapters WHERE volume_id = ? AND deleted_at IS NULL", volumeId) ?? {}, "sort_order") + 1
             : numberValue(version, "sort_order");
         const timestamp = now();
+        const lineIds = createChapterLineIds(content, () => id("chapterLine"));
         const nextVersionNo = numberValue(this.db.get("SELECT COALESCE(MAX(version_no), 0) AS version_no FROM chapter_versions WHERE chapter_id = ?", chapterId) ?? {}, "version_no") + 1;
         this.db.transaction(() => {
-            this.db.run(`INSERT INTO chapters (id, work_id, volume_id, title, content, chapter_type, sort_order, word_count, version_no, analysis_status, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?)`, chapterId, workId, volumeId, title, content, chapterType, sortOrder, countWords(content), nextVersionNo, timestamp, timestamp);
+            this.db.run(`INSERT INTO chapters (id, work_id, volume_id, title, content, line_ids_json, chapter_type, sort_order, word_count, version_no, analysis_status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?)`, chapterId, workId, volumeId, title, content, JSON.stringify(lineIds), chapterType, sortOrder, countWords(content), nextVersionNo, timestamp, timestamp);
             this.syncChapterParagraphSearch(workId, chapterId, content);
             this.insertChapterVersionRow({
                 workId,
@@ -2437,11 +2627,14 @@ export class Store {
         };
     }
     chapterAnnotationSnapshot(annotation) {
+        const anchor = this.db.get("SELECT anchor_line_ids_json FROM chapter_annotations WHERE id = ?", String(annotation.id));
         return {
             kind: annotation.kind,
             startLine: annotation.startLine,
             endLine: annotation.endLine,
             quote: annotation.quote,
+            lineHashes: chapterAnnotationLineHashes(String(annotation.quote)),
+            lineIds: parseChapterAnnotationLineIds(anchor?.anchor_line_ids_json),
             note: annotation.note,
             status: annotation.status,
             deletedAt: annotation.deletedAt ?? null
@@ -2484,7 +2677,8 @@ export class Store {
         return this.db.all(`WITH RECURSIVE annotation_lines(line, end_line) AS (
          SELECT annotation.start_line, annotation.end_line
          FROM chapter_annotations annotation
-         WHERE annotation.chapter_id = ? AND annotation.deleted_at IS NULL${kindFilter.sql}
+         WHERE annotation.chapter_id = ? AND annotation.deleted_at IS NULL
+           AND NOT (annotation.kind = 'todo' AND annotation.status = 'resolved')${kindFilter.sql}
          UNION ALL
          SELECT line + 1, end_line
          FROM annotation_lines
@@ -2495,55 +2689,69 @@ export class Store {
        GROUP BY line
        ORDER BY line`, chapterId, ...kindFilter.params).map((row) => ({ line: Number(row.line), count: Number(row.count) }));
     }
-    listWorkChapterAnnotations(workId, kinds) {
+    listWorkChapterAnnotations(workId, kinds, filters = {}) {
         this.getWork(workId);
-        const kindFilter = kinds === undefined
-            ? { sql: "", params: [] }
-            : kinds.length > 0
-                ? { sql: ` AND annotation.kind IN (${kinds.map(() => "?").join(",")})`, params: [...kinds] }
-                : { sql: " AND 1 = 0", params: [] };
+        const filter = chapterAnnotationListFilter(kinds, filters);
         return this.db.all(`SELECT annotation.*, user.display_name AS actor_display_name, user.username AS actor_username,
         chapter.title AS chapter_title, volume.title AS volume_title
        FROM chapter_annotations annotation
        JOIN chapters chapter ON chapter.id = annotation.chapter_id
        JOIN volumes volume ON volume.id = chapter.volume_id
        LEFT JOIN users user ON user.id = annotation.updated_by_user_id
-       WHERE annotation.work_id = ? AND annotation.deleted_at IS NULL AND chapter.deleted_at IS NULL${kindFilter.sql}
-       ORDER BY CASE annotation.status WHEN 'open' THEN 0 ELSE 1 END,
+       WHERE annotation.work_id = ? AND annotation.deleted_at IS NULL AND chapter.deleted_at IS NULL${filter.sql}
+       ORDER BY CASE
+         WHEN annotation.kind = 'todo' AND annotation.status = 'resolved' THEN 2
+         WHEN annotation.status = 'open' THEN 0
+         ELSE 1
+       END,
          volume.sort_order, volume.created_at, chapter.sort_order, chapter.created_at,
-         annotation.start_line, annotation.created_at`, workId, ...kindFilter.params).map((row) => ({
+         annotation.start_line, annotation.created_at`, workId, ...filter.params).map((row) => ({
             ...this.mapChapterAnnotation(row),
             volumeTitle: requiredString(row, "volume_title"),
             chapterTitle: requiredString(row, "chapter_title")
         }));
     }
-    listWorkChapterAnnotationsPage(workId, pagination, kinds) {
+    listWorkChapterAnnotationsPage(workId, pagination, kinds, filters = {}) {
         this.getWork(workId);
         const page = paginationSql(pagination);
-        const kindFilter = kinds === undefined
-            ? { sql: "", params: [] }
-            : kinds.length > 0
-                ? { sql: ` AND annotation.kind IN (${kinds.map(() => "?").join(",")})`, params: [...kinds] }
-                : { sql: " AND 1 = 0", params: [] };
+        const filter = chapterAnnotationListFilter(kinds, filters);
+        const optionFilter = chapterAnnotationListFilter(kinds);
         const rows = this.db.all(`SELECT annotation.*, user.display_name AS actor_display_name, user.username AS actor_username,
         chapter.title AS chapter_title, volume.title AS volume_title
        FROM chapter_annotations annotation
        JOIN chapters chapter ON chapter.id = annotation.chapter_id
        JOIN volumes volume ON volume.id = chapter.volume_id
        LEFT JOIN users user ON user.id = annotation.updated_by_user_id
-       WHERE annotation.work_id = ? AND annotation.deleted_at IS NULL AND chapter.deleted_at IS NULL${kindFilter.sql}
-       ORDER BY CASE annotation.status WHEN 'open' THEN 0 ELSE 1 END,
+       WHERE annotation.work_id = ? AND annotation.deleted_at IS NULL AND chapter.deleted_at IS NULL${filter.sql}
+       ORDER BY CASE
+         WHEN annotation.kind = 'todo' AND annotation.status = 'resolved' THEN 2
+         WHEN annotation.status = 'open' THEN 0
+         ELSE 1
+       END,
          volume.sort_order, volume.created_at, chapter.sort_order, chapter.created_at,
-         annotation.start_line, annotation.created_at${page.sql}`, workId, ...kindFilter.params, ...page.params);
+         annotation.start_line, annotation.created_at${page.sql}`, workId, ...filter.params, ...page.params);
         const total = numberValue(this.db.get(`SELECT COUNT(*) AS count
        FROM chapter_annotations annotation
        JOIN chapters chapter ON chapter.id = annotation.chapter_id
-       WHERE annotation.work_id = ? AND annotation.deleted_at IS NULL AND chapter.deleted_at IS NULL${kindFilter.sql}`, workId, ...kindFilter.params) ?? {}, "count");
-        return paginated(rows.map((row) => ({
-            ...this.mapChapterAnnotation(row),
-            volumeTitle: requiredString(row, "volume_title"),
-            chapterTitle: requiredString(row, "chapter_title")
-        })), pagination, total);
+       JOIN volumes volume ON volume.id = chapter.volume_id
+       WHERE annotation.work_id = ? AND annotation.deleted_at IS NULL AND chapter.deleted_at IS NULL${filter.sql}`, workId, ...filter.params) ?? {}, "count");
+        const chapterOptions = this.db.all(`SELECT DISTINCT chapter.id, chapter.title, volume.title AS volume_title,
+        volume.sort_order AS volume_sort_order, volume.created_at AS volume_created_at,
+        chapter.sort_order AS chapter_sort_order, chapter.created_at AS chapter_created_at
+       FROM chapter_annotations annotation
+       JOIN chapters chapter ON chapter.id = annotation.chapter_id
+       JOIN volumes volume ON volume.id = chapter.volume_id
+       WHERE annotation.work_id = ? AND annotation.deleted_at IS NULL AND chapter.deleted_at IS NULL${optionFilter.sql}
+       ORDER BY volume.sort_order, volume.created_at, chapter.sort_order, chapter.created_at`, workId, ...optionFilter.params).map((row) => ({
+            id: requiredString(row, "id"),
+            title: requiredString(row, "title"),
+            volumeTitle: requiredString(row, "volume_title")
+        }));
+        return { ...paginated(rows.map((row) => ({
+                ...this.mapChapterAnnotation(row),
+                volumeTitle: requiredString(row, "volume_title"),
+                chapterTitle: requiredString(row, "chapter_title")
+            })), pagination, total), chapterOptions };
     }
     createChapterAnnotation(chapterId, input) {
         const chapter = this.getChapter(chapterId);
@@ -2555,9 +2763,15 @@ export class Store {
         const annotationId = id("chapterAnnotation");
         const timestamp = now();
         const actorId = currentRequestActor()?.userId ?? null;
+        const quote = lines.slice(input.startLine - 1, input.endLine).join("\n");
+        const chapterLineIds = parseChapterLineIds(chapter.lineIds, String(chapter.content));
+        if (lines.length <= MAX_CHAPTER_LINE_IDS && chapterLineIds.length !== lines.length) {
+            throw new AppError(409, "CHAPTER_LINE_IDS_MISSING", "正文行身份尚未初始化，请重新保存正文后再添加评论");
+        }
+        const anchorLineIds = chapterLineIds.slice(input.startLine - 1, input.endLine);
         this.db.transaction(() => {
-            this.db.run(`INSERT INTO chapter_annotations (id, work_id, chapter_id, kind, start_line, end_line, quote, note, status, version_no, created_at, updated_at, created_by_user_id, updated_by_user_id)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'open', 1, ?, ?, ?, ?)`, annotationId, String(chapter.workId), chapterId, input.kind, input.startLine, input.endLine, lines.slice(input.startLine - 1, input.endLine).join("\n"), input.note.trim(), timestamp, timestamp, actorId, actorId);
+            this.db.run(`INSERT INTO chapter_annotations (id, work_id, chapter_id, kind, start_line, end_line, quote, line_hashes_json, anchor_line_ids_json, note, status, version_no, created_at, updated_at, created_by_user_id, updated_by_user_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'open', 1, ?, ?, ?, ?)`, annotationId, String(chapter.workId), chapterId, input.kind, input.startLine, input.endLine, quote, JSON.stringify(chapterAnnotationLineHashes(quote)), JSON.stringify(anchorLineIds), input.note.trim(), timestamp, timestamp, actorId, actorId);
             const annotation = this.getChapterAnnotation(annotationId);
             this.recordChapterAnnotationVersion(annotation, "create", timestamp);
             this.audit(String(chapter.workId), "chapter.annotation.created", "chapter-annotation", annotationId, { kind: input.kind, chapterId, startLine: input.startLine, endLine: input.endLine });
@@ -2603,6 +2817,64 @@ export class Store {
                 return chapter;
             });
             const timestamp = now();
+            if (action.type === "renumberTitles") {
+                if (action.startAt + currentChapters.length - 1 > 999_999) {
+                    throw new AppError(400, "CHAPTER_NUMBER_RANGE", "起始序号与所选章节数量超出最大序号 999999");
+                }
+                const currentById = new Map(currentChapters.map((chapter) => [String(chapter.id), chapter]));
+                const placeholders = currentChapters.map(() => "?").join(", ");
+                const orderedChapters = this.db.all(`SELECT chapter.id FROM chapters chapter
+           JOIN volumes volume ON volume.id = chapter.volume_id
+           WHERE chapter.work_id = ? AND chapter.deleted_at IS NULL
+             AND volume.deleted_at IS NULL AND chapter.id IN (${placeholders})
+           ORDER BY volume.sort_order, volume.created_at, volume.id,
+             chapter.sort_order, chapter.created_at, chapter.id`, workId, ...currentChapters.map((chapter) => String(chapter.id))).map((row) => currentById.get(requiredString(row, "id"))).filter((chapter) => Boolean(chapter));
+                const renumbered = orderedChapters.map((chapter, index) => ({
+                    chapter,
+                    title: renumberChapterTitle(String(chapter.title), action.startAt + index, action.template, action.numberStyle),
+                    sequence: action.startAt + index
+                }));
+                const oversized = renumbered.find((item) => item.title.length > 300);
+                if (oversized) {
+                    throw new AppError(400, "CHAPTER_TITLE_TOO_LONG", `章节“${String(oversized.chapter.title).slice(0, 40)}”重排后的标题超过 300 个字符`);
+                }
+                let updated = 0;
+                for (const item of renumbered) {
+                    const chapter = item.chapter;
+                    if (item.title === chapter.title)
+                        continue;
+                    const chapterId = String(chapter.id);
+                    const versionNo = Number(chapter.versionNo) + 1;
+                    this.db.run("UPDATE chapters SET title = ?, version_no = ?, analysis_status = 'expired', updated_at = ? WHERE id = ?", item.title, versionNo, timestamp, chapterId);
+                    this.syncChapterParagraphSearchVersion(chapterId, versionNo);
+                    this.insertChapterVersionRow({
+                        workId,
+                        chapterId,
+                        versionNo,
+                        title: item.title,
+                        content: String(chapter.content),
+                        volumeId: String(chapter.volumeId),
+                        sortOrder: Number(chapter.sortOrder),
+                        chapterType: String(chapter.chapterType),
+                        source: "manual",
+                        sourceRef: null,
+                        changeNote: "批量重排章节标题序号",
+                        timestamp
+                    });
+                    this.invalidateChapter(workId, chapterId, versionNo);
+                    this.audit(workId, "chapter.saved", "chapter", chapterId, {
+                        previousTitle: chapter.title,
+                        title: item.title,
+                        sequence: item.sequence,
+                        versionNo,
+                        batch: true,
+                        renumbered: true
+                    });
+                    updated += 1;
+                }
+                this.db.run("UPDATE works SET updated_at = ? WHERE id = ?", timestamp, workId);
+                return { processed: currentChapters.length, updated, action: action.type };
+            }
             if (action.type === "move") {
                 const targetVolume = this.getVolume(action.volumeId);
                 if (targetVolume.workId !== workId)
@@ -2787,8 +3059,9 @@ export class Store {
     insertChapter(workId, volumeId, title, content, sortOrder, source, sourceRef, chapterType = "正文") {
         const chapterId = id("chapter");
         const timestamp = now();
-        this.db.run(`INSERT INTO chapters (id, work_id, volume_id, title, content, chapter_type, sort_order, word_count, version_no, analysis_status, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, 'pending', ?, ?)`, chapterId, workId, volumeId, title, content, chapterType, sortOrder, countWords(content), timestamp, timestamp);
+        const lineIds = createChapterLineIds(content, () => id("chapterLine"));
+        this.db.run(`INSERT INTO chapters (id, work_id, volume_id, title, content, line_ids_json, chapter_type, sort_order, word_count, version_no, analysis_status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 'pending', ?, ?)`, chapterId, workId, volumeId, title, content, JSON.stringify(lineIds), chapterType, sortOrder, countWords(content), timestamp, timestamp);
         this.syncChapterParagraphSearch(workId, chapterId, content);
         this.insertChapterVersionRow({
             workId,
@@ -3091,6 +3364,8 @@ export class Store {
                 : optionalString(row, "cover_url"),
             tags: json(requiredString(row, "tags_json"), []),
             offlineAccessEnabled: numberValue(row, "offline_access_enabled") === 1,
+            editorAutoIndentEnabled: numberValue(row, "editor_auto_indent_enabled") === 1,
+            editorTypewriterModeEnabled: numberValue(row, "editor_typewriter_mode_enabled") === 1,
             versionNo: numberValue(row, "version_no") || this.currentEntityVersionNo("work", workId),
             ownerUserId,
             accessRole,
@@ -3123,7 +3398,8 @@ export class Store {
     mapChapter(row) {
         return {
             ...this.mapChapterDirectoryEntry(row),
-            content: requiredString(row, "content")
+            content: requiredString(row, "content"),
+            lineIds: parseChapterLineIds(row.line_ids_json, requiredString(row, "content"))
         };
     }
     mapChapterDirectoryEntry(row) {
@@ -5578,6 +5854,7 @@ export class Store {
         const timelineEvents = this.listTimelineEvents(workId).filter((event) => event.participantIds.includes(sourceId));
         const sourceMemberships = this.db.all("SELECT * FROM character_organization_memberships WHERE character_id = ? ORDER BY organization_id", sourceId);
         const referenceSnapshot = { relationships: sourceRelationships, timelineEvents, memberships: sourceMemberships };
+        let roleplayMemoryMerge = { migrated: 0, deduplicated: 0 };
         this.db.transaction(() => {
             const lockedTarget = this.getCharacter(targetId);
             const lockedSource = this.getCharacter(sourceId);
@@ -5645,6 +5922,7 @@ export class Store {
             this.db.run("UPDATE character_profile_sections SET character_id = ?, updated_at = ? WHERE character_id = ?", targetId, timestamp, sourceId);
             this.db.run("UPDATE character_profile_section_versions SET character_id = ? WHERE character_id = ?", targetId, sourceId);
             this.db.run("UPDATE character_profile_section_search SET character_id = ? WHERE character_id = ?", targetId, sourceId);
+            roleplayMemoryMerge = this.mergeRoleplayMemoriesForCharacters(workId, targetId, sourceId, timestamp);
             const sourceVersionNo = Number(source.versionNo) + 1;
             this.db.run("UPDATE characters SET merged_into_character_id = ?, merged_at = ?, version_no = ?, updated_at = ? WHERE id = ?", targetId, timestamp, sourceVersionNo, timestamp, sourceId);
             this.insertCharacterVersion(sourceId, sourceVersionNo, "merge", mergeId, `合并至角色“${String(target.name)}”`, timestamp);
@@ -5657,16 +5935,60 @@ export class Store {
             this.audit(workId, "character.merged", "character", targetId, {
                 mergeId,
                 sourceCharacterId: sourceId,
-                reviewId: input.reviewId
+                reviewId: input.reviewId,
+                roleplayMemoryMerge
             });
         });
         return {
             mergeId,
             target: this.getCharacter(targetId),
             source: this.getCharacter(sourceId),
-            review: input.reviewId ? this.getReviewItem(input.reviewId) : null
+            review: input.reviewId ? this.getReviewItem(input.reviewId) : null,
+            roleplayMemoryMerge
         };
     }
+    mergeRoleplayMemoriesForCharacters(workId, targetCharacterId, sourceCharacterId, timestamp) {
+        let migrated = 0;
+        let deduplicated = 0;
+        const sourceMemories = this.db.all("SELECT * FROM roleplay_memories WHERE work_id = ? AND character_id = ? ORDER BY created_at, id", workId, sourceCharacterId);
+        for (const sourceMemory of sourceMemories) {
+            const sourceMemoryId = requiredString(sourceMemory, "id");
+            const duplicate = this.db.get("SELECT * FROM roleplay_memories WHERE character_id = ? AND content_hash = ?", targetCharacterId, requiredString(sourceMemory, "content_hash"));
+            if (!duplicate) {
+                this.db.run("UPDATE roleplay_memories SET character_id = ?, updated_by_user_id = ?, updated_at = ? WHERE id = ?", targetCharacterId, currentRequestActor()?.userId ?? null, timestamp, sourceMemoryId);
+                migrated += 1;
+                continue;
+            }
+            const targetMemoryId = requiredString(duplicate, "id");
+            this.db.run("UPDATE roleplay_memories SET superseded_by_memory_id = ? WHERE superseded_by_memory_id = ?", targetMemoryId, sourceMemoryId);
+            for (const source of this.db.all("SELECT * FROM roleplay_memory_sources WHERE memory_id = ? ORDER BY created_at, id", sourceMemoryId)) {
+                this.db.run(`INSERT OR IGNORE INTO roleplay_memory_sources (
+            id, memory_id, conversation_id, message_id, message_role, source_created_by_user_id,
+            source_created_at, evidence_snapshot, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, id("roleplay_memory_source"), targetMemoryId, optionalString(source, "conversation_id"), optionalString(source, "message_id"), requiredString(source, "message_role"), optionalString(source, "source_created_by_user_id"), requiredString(source, "source_created_at"), requiredString(source, "evidence_snapshot"), requiredString(source, "created_at"));
+            }
+            let nextVersion = numberValue(duplicate, "version_no");
+            for (const version of this.db.all("SELECT * FROM roleplay_memory_versions WHERE memory_id = ? ORDER BY version_no", sourceMemoryId)) {
+                nextVersion += 1;
+                this.db.run(`INSERT INTO roleplay_memory_versions (
+            id, memory_id, version_no, category, content, importance, certainty,
+            status, is_pinned, action, actor_user_id, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'merged', ?, ?)`, id("roleplay_memory_version"), targetMemoryId, nextVersion, requiredString(version, "category"), requiredString(version, "content"), requiredString(version, "importance"), requiredString(version, "certainty"), requiredString(version, "status"), booleanValue(version, "is_pinned") ? 1 : 0, currentRequestActor()?.userId ?? optionalString(version, "actor_user_id"), requiredString(version, "created_at"));
+            }
+            nextVersion += 1;
+            this.db.run(`UPDATE roleplay_memories SET is_pinned = CASE WHEN is_pinned = 1 OR ? = 1 THEN 1 ELSE 0 END,
+         status = CASE WHEN status = 'active' OR ? = 'active' THEN 'active' ELSE status END,
+         superseded_by_memory_id = CASE WHEN status = 'active' OR ? = 'active' THEN NULL ELSE superseded_by_memory_id END,
+         version_no = ?, updated_by_user_id = ?, updated_at = ? WHERE id = ?`, booleanValue(sourceMemory, "is_pinned") ? 1 : 0, requiredString(sourceMemory, "status"), requiredString(sourceMemory, "status"), nextVersion, currentRequestActor()?.userId ?? null, timestamp, targetMemoryId);
+            const mergedTarget = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", targetMemoryId);
+            if (!mergedTarget)
+                throw notFound("角色扮演记忆");
+            this.insertRoleplayMemoryVersion(mergedTarget, "merged");
+            this.db.run("DELETE FROM roleplay_memories WHERE id = ?", sourceMemoryId);
+            deduplicated += 1;
+        }
+        return { migrated, deduplicated };
+    }
     resolveCharacterDuplicateReview(reviewId) {
         const review = this.getReviewItem(reviewId);
         if (review.itemType !== "character-duplicate" || review.status !== "pending") {
@@ -6310,6 +6632,270 @@ export class Store {
             messagesPage
         };
     }
+    roleplayMemoryContentHash(content) {
+        return this.hashContent(normalizeRoleplayMemoryContent(content).toLocaleLowerCase("zh-CN"));
+    }
+    insertRoleplayMemoryVersion(memory, action) {
+        this.db.run(`INSERT INTO roleplay_memory_versions (
+        id, memory_id, version_no, category, content, importance, certainty,
+        status, is_pinned, action, actor_user_id, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, id("roleplay_memory_version"), requiredString(memory, "id"), numberValue(memory, "version_no"), requiredString(memory, "category"), requiredString(memory, "content"), requiredString(memory, "importance"), requiredString(memory, "certainty"), requiredString(memory, "status"), booleanValue(memory, "is_pinned") ? 1 : 0, action, currentRequestActor()?.userId ?? optionalString(memory, "updated_by_user_id"), now());
+    }
+    roleplayMemoryListRows(characterId, options = {}) {
+        const cursor = Math.max(0, Math.min(100_000, options.cursor ?? 0));
+        const limit = Math.max(1, Math.min(100, options.limit ?? 20));
+        const where = ["memory.character_id = ?"];
+        const params = [characterId];
+        const statuses = options.statuses?.length ? [...new Set(options.statuses)] : ["active"];
+        where.push(`memory.status IN (${statuses.map(() => "?").join(", ")})`);
+        params.push(...statuses);
+        const categories = options.categories?.length ? [...new Set(options.categories)] : [];
+        if (categories.length > 0) {
+            where.push(`memory.category IN (${categories.map(() => "?").join(", ")})`);
+            params.push(...categories);
+        }
+        const query = normalizeRoleplayMemoryContent(options.query ?? "", 200).toLocaleLowerCase("zh-CN");
+        if (query) {
+            if (Array.from(query).length >= 3) {
+                where.push("memory.id IN (SELECT memory_id FROM roleplay_memory_fts WHERE roleplay_memory_fts MATCH ?)");
+                params.push(JSON.stringify(query));
+            }
+            else {
+                where.push("lower(memory.content) LIKE ? ESCAPE '\\'");
+                params.push(`%${escapeSqlLikePattern(query)}%`);
+            }
+        }
+        const whereSql = where.join(" AND ");
+        const total = Number(this.db.get(`SELECT COUNT(*) AS count FROM roleplay_memories memory WHERE ${whereSql}`, ...params)?.count ?? 0);
+        const rows = this.db.all(`SELECT memory.* FROM roleplay_memories memory
+       WHERE ${whereSql}
+       ORDER BY memory.is_pinned DESC,
+         CASE memory.importance WHEN 'high' THEN 0 WHEN 'medium' THEN 1 ELSE 2 END,
+         memory.updated_at DESC, memory.id
+       LIMIT ? OFFSET ?`, ...params, limit, cursor);
+        return { rows, total, cursor, limit };
+    }
+    listRoleplayMemories(characterId, options = {}) {
+        const character = this.getCharacter(characterId);
+        const page = this.roleplayMemoryListRows(characterId, options);
+        const nextCursor = page.cursor + page.rows.length < page.total ? page.cursor + page.rows.length : null;
+        return {
+            character: { id: character.id, name: character.name, workId: character.workId },
+            items: page.rows.map((memory) => this.mapRoleplayMemory(memory, true)),
+            pagination: { cursor: page.cursor, limit: page.limit, total: page.total, nextCursor }
+        };
+    }
+    isRoleplayMemorySourceTarget(sourceId, conversationId, messageId) {
+        return Boolean(this.db.get(`SELECT source.id
+       FROM roleplay_memory_sources source
+       INNER JOIN roleplay_memories memory ON memory.id = source.memory_id
+       WHERE source.id = ? AND source.conversation_id = ? AND source.message_id = ?`, sourceId, conversationId, messageId));
+    }
+    getRoleplayMemoryPromptItems(workId, characterId, limit = 12) {
+        const character = this.getCharacter(characterId);
+        if (String(character.workId) !== workId)
+            throw new AppError(400, "ROLEPLAY_CHARACTER_WORK_MISMATCH", "角色不属于当前作品");
+        return this.roleplayMemoryListRows(characterId, {
+            statuses: ["active"],
+            limit: Math.max(1, Math.min(30, limit))
+        }).rows.map((memory) => this.mapRoleplayMemory(memory, false));
+    }
+    recallRoleplayMemories(workId, characterId, query, categories, cursor) {
+        const character = this.getCharacter(characterId);
+        if (String(character.workId) !== workId)
+            throw new AppError(400, "ROLEPLAY_CHARACTER_WORK_MISMATCH", "角色不属于当前作品");
+        const result = this.listRoleplayMemories(characterId, { query, categories, statuses: ["active"], cursor, limit: 20 });
+        return {
+            origin: "roleplay",
+            canonical: false,
+            character: result.character,
+            memories: result.items,
+            pagination: result.pagination
+        };
+    }
+    createRoleplayMemory(characterId, input) {
+        const character = this.getCharacter(characterId);
+        if (character.mergedIntoCharacterId)
+            throw new AppError(409, "ROLEPLAY_MEMORY_CHARACTER_MERGED", "已合并角色不能新增角色扮演记忆");
+        const workId = String(character.workId);
+        const content = normalizeRoleplayMemoryContent(input.content);
+        if (!content)
+            throw new AppError(400, "ROLEPLAY_MEMORY_CONTENT_REQUIRED", "请输入记忆内容");
+        const memoryId = id("roleplay_memory");
+        const contentHash = this.roleplayMemoryContentHash(content);
+        const timestamp = now();
+        this.db.transaction(() => {
+            if (this.db.get("SELECT id FROM roleplay_memories WHERE character_id = ? AND content_hash = ?", characterId, contentHash)) {
+                throw new AppError(409, "ROLEPLAY_MEMORY_DUPLICATE", "该角色已经有相同内容的角色扮演记忆");
+            }
+            this.db.run(`INSERT INTO roleplay_memories (
+          id, work_id, character_id, category, content, content_hash, importance, certainty,
+          status, is_pinned, version_no, source_type, created_by_user_id, updated_by_user_id, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, 1, 'manual', ?, ?, ?, ?)`, memoryId, workId, characterId, input.category, content, contentHash, input.importance ?? "medium", input.certainty ?? "experienced", input.isPinned ? 1 : 0, currentRequestActor()?.userId ?? null, currentRequestActor()?.userId ?? null, timestamp, timestamp);
+            const memory = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", memoryId);
+            if (!memory)
+                throw notFound("角色扮演记忆");
+            this.insertRoleplayMemoryVersion(memory, "created");
+            this.audit(workId, "roleplay-memory.created", "roleplay-memory", memoryId, { characterId });
+        });
+        const memory = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", memoryId);
+        if (!memory)
+            throw notFound("角色扮演记忆");
+        return this.mapRoleplayMemory(memory, true);
+    }
+    commitRoleplayMemoryCandidates(conversationId, assistantMessageId, sourceUserMessageId, candidates) {
+        if (candidates.length === 0)
+            return [];
+        const conversation = this.db.get("SELECT * FROM ai_conversations WHERE id = ?", conversationId);
+        if (!conversation)
+            throw notFound("AI 对话");
+        const characterId = optionalString(conversation, "roleplay_character_id");
+        if (!characterId)
+            throw new AppError(409, "ROLEPLAY_MEMORY_REQUIRES_ROLEPLAY", "只有角色扮演对话可以写入角色扮演记忆");
+        const workId = requiredString(conversation, "work_id");
+        const assistant = this.db.get("SELECT * FROM ai_conversation_messages WHERE id = ? AND conversation_id = ? AND role = 'assistant'", assistantMessageId, conversationId);
+        if (!assistant)
+            throw new AppError(400, "ROLEPLAY_MEMORY_ASSISTANT_MISMATCH", "角色扮演记忆来源回复不属于当前对话");
+        const userMessage = this.db.get("SELECT * FROM ai_conversation_messages WHERE id = ? AND conversation_id = ? AND role = 'user'", sourceUserMessageId, conversationId);
+        if (!userMessage)
+            throw new AppError(400, "ROLEPLAY_MEMORY_USER_MESSAGE_MISMATCH", "角色扮演记忆来源消息不属于当前对话");
+        const committedIds = [];
+        this.db.transaction(() => {
+            const validCandidates = candidates.slice(0, 8).flatMap((candidate) => {
+                const content = normalizeRoleplayMemoryContent(candidate.content, 500);
+                if (!content || !roleplayMemoryCandidateIsSafe(content))
+                    return [];
+                return [{ ...candidate, content }];
+            });
+            const insertable = validCandidates.flatMap((candidate) => {
+                const idempotencyKey = this.hashContent(`${assistantMessageId}:${JSON.stringify(candidate)}`);
+                const contentHash = this.roleplayMemoryContentHash(candidate.content);
+                const existing = this.db.get("SELECT id FROM roleplay_memories WHERE character_id = ? AND (idempotency_key = ? OR content_hash = ?)", characterId, idempotencyKey, contentHash);
+                return existing ? [] : [{ candidate, idempotencyKey, contentHash }];
+            });
+            if (insertable.length === 0)
+                return;
+            const timestamp = now();
+            for (const { candidate, idempotencyKey, contentHash } of insertable) {
+                const memoryId = id("roleplay_memory");
+                const superseded = candidate.supersedesMemoryId
+                    ? this.db.get("SELECT * FROM roleplay_memories WHERE id = ? AND character_id = ? AND status = 'active'", candidate.supersedesMemoryId, characterId)
+                    : undefined;
+                this.db.run(`INSERT INTO roleplay_memories (
+            id, work_id, character_id, category, content, content_hash, importance, certainty, status, is_pinned, version_no,
+            source_type, source_assistant_message_id, idempotency_key,
+            created_by_user_id, updated_by_user_id, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, 1, 'ai', ?, ?, ?, ?, ?, ?)`, memoryId, workId, characterId, candidate.category, candidate.content, contentHash, candidate.importance, candidate.certainty, assistantMessageId, idempotencyKey, optionalString(conversation, "created_by_user_id"), optionalString(conversation, "created_by_user_id"), timestamp, timestamp);
+                const memory = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", memoryId);
+                if (!memory)
+                    throw notFound("角色扮演记忆");
+                this.insertRoleplayMemoryVersion(memory, "created");
+                for (const source of [userMessage, assistant]) {
+                    this.db.run(`INSERT INTO roleplay_memory_sources (
+              id, memory_id, conversation_id, message_id, message_role, source_created_by_user_id,
+              source_created_at, evidence_snapshot, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, id("roleplay_memory_source"), memoryId, conversationId, requiredString(source, "id"), requiredString(source, "role"), optionalString(conversation, "created_by_user_id"), requiredString(source, "created_at"), Array.from(requiredString(source, "content")
+                        .replace(/\r\n?/gu, "\n")
+                        .replace(/\n{3,}/gu, "\n\n")
+                        .trim()).slice(0, 2_000).join(""), timestamp);
+                }
+                if (superseded) {
+                    const nextVersion = numberValue(superseded, "version_no") + 1;
+                    this.db.run(`UPDATE roleplay_memories SET status = 'superseded', superseded_by_memory_id = ?,
+             version_no = ?, updated_by_user_id = ?, updated_at = ? WHERE id = ?`, memoryId, nextVersion, optionalString(conversation, "created_by_user_id"), timestamp, requiredString(superseded, "id"));
+                    const updatedSuperseded = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", requiredString(superseded, "id"));
+                    if (updatedSuperseded)
+                        this.insertRoleplayMemoryVersion(updatedSuperseded, "superseded");
+                }
+                committedIds.push(memoryId);
+            }
+            this.audit(workId, "roleplay-memory.ai-committed", "character", characterId, {
+                conversationId,
+                assistantMessageId,
+                memoryCount: committedIds.length
+            });
+        });
+        return committedIds.flatMap((memoryId) => {
+            const memory = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", memoryId);
+            return memory ? [this.mapRoleplayMemory(memory, true)] : [];
+        });
+    }
+    getRoleplayMemoryAccess(memoryId) {
+        const row = this.db.get("SELECT work_id, character_id FROM roleplay_memories WHERE id = ?", memoryId);
+        if (!row)
+            throw notFound("角色扮演记忆");
+        return { workId: requiredString(row, "work_id"), characterId: requiredString(row, "character_id") };
+    }
+    updateRoleplayMemory(memoryId, input) {
+        const memory = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", memoryId);
+        if (!memory)
+            throw notFound("角色扮演记忆");
+        if (numberValue(memory, "version_no") !== input.expectedVersion) {
+            throw new AppError(409, "ROLEPLAY_MEMORY_VERSION_CONFLICT", "记忆已被其他操作更新，请刷新后重试");
+        }
+        const content = input.content === undefined ? requiredString(memory, "content") : normalizeRoleplayMemoryContent(input.content);
+        if (!content)
+            throw new AppError(400, "ROLEPLAY_MEMORY_CONTENT_REQUIRED", "请输入记忆内容");
+        const category = input.category ?? requiredString(memory, "category");
+        const importance = input.importance ?? requiredString(memory, "importance");
+        const certainty = input.certainty ?? requiredString(memory, "certainty");
+        const isPinned = input.isPinned ?? booleanValue(memory, "is_pinned");
+        const contentChanged = content !== requiredString(memory, "content")
+            || category !== requiredString(memory, "category")
+            || importance !== requiredString(memory, "importance")
+            || certainty !== requiredString(memory, "certainty");
+        const pinnedChanged = isPinned !== booleanValue(memory, "is_pinned");
+        if (!contentChanged && !pinnedChanged)
+            return this.mapRoleplayMemory(memory, true);
+        this.db.transaction(() => {
+            const timestamp = now();
+            const contentHash = this.roleplayMemoryContentHash(content);
+            const duplicate = this.db.get("SELECT id FROM roleplay_memories WHERE character_id = ? AND content_hash = ? AND id <> ?", requiredString(memory, "character_id"), contentHash, memoryId);
+            if (duplicate)
+                throw new AppError(409, "ROLEPLAY_MEMORY_DUPLICATE", "该角色已经有相同内容的角色扮演记忆");
+            this.db.run(`UPDATE roleplay_memories SET category = ?, content = ?, content_hash = ?, importance = ?, certainty = ?, is_pinned = ?,
+         version_no = version_no + 1, updated_by_user_id = ?, updated_at = ? WHERE id = ?`, category, content, contentHash, importance, certainty, isPinned ? 1 : 0, currentRequestActor()?.userId ?? null, timestamp, memoryId);
+            const updated = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", memoryId);
+            if (!updated)
+                throw notFound("角色扮演记忆");
+            this.insertRoleplayMemoryVersion(updated, contentChanged ? "edited" : "pinned");
+            this.audit(requiredString(memory, "work_id"), "roleplay-memory.updated", "roleplay-memory", memoryId, {
+                characterId: requiredString(memory, "character_id")
+            });
+        });
+        const updated = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", memoryId);
+        if (!updated)
+            throw notFound("角色扮演记忆");
+        return this.mapRoleplayMemory(updated, true);
+    }
+    setRoleplayMemoryArchived(memoryId, archived, expectedVersion) {
+        const memory = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", memoryId);
+        if (!memory)
+            throw notFound("角色扮演记忆");
+        if (numberValue(memory, "version_no") !== expectedVersion) {
+            throw new AppError(409, "ROLEPLAY_MEMORY_VERSION_CONFLICT", "记忆已被其他操作更新，请刷新后重试");
+        }
+        const nextStatus = archived ? "archived" : "active";
+        if (requiredString(memory, "status") === nextStatus)
+            return this.mapRoleplayMemory(memory, true);
+        this.db.transaction(() => {
+            const timestamp = now();
+            this.db.run(`UPDATE roleplay_memories SET status = ?,
+         superseded_by_memory_id = CASE WHEN ? = 'active' THEN NULL ELSE superseded_by_memory_id END,
+         version_no = version_no + 1, updated_by_user_id = ?, updated_at = ? WHERE id = ?`, nextStatus, nextStatus, currentRequestActor()?.userId ?? null, timestamp, memoryId);
+            const updated = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", memoryId);
+            if (!updated)
+                throw notFound("角色扮演记忆");
+            this.insertRoleplayMemoryVersion(updated, archived ? "archived" : "restored");
+            this.audit(requiredString(memory, "work_id"), archived ? "roleplay-memory.archived" : "roleplay-memory.restored", "roleplay-memory", memoryId, {
+                characterId: requiredString(memory, "character_id")
+            });
+        });
+        const updated = this.db.get("SELECT * FROM roleplay_memories WHERE id = ?", memoryId);
+        if (!updated)
+            throw notFound("角色扮演记忆");
+        return this.mapRoleplayMemory(updated, true);
+    }
     getAiConversationContext(conversationId, workId, excludeMessageId) {
         const conversation = this.db.get("SELECT * FROM ai_conversations WHERE id = ?", conversationId);
         if (!conversation)
@@ -6335,10 +6921,13 @@ export class Store {
            ORDER BY created_at, rowid LIMIT ?`, conversationId, requiredString(boundary, "created_at"), requiredString(boundary, "created_at"), numberValue(boundary, "rowid"), tailMessageCount);
             }
         }
+        const roleplayCharacterId = optionalString(conversation, "roleplay_character_id");
         return {
             workId,
-            roleplayCharacterId: optionalString(conversation, "roleplay_character_id"),
+            taskType: normalizeAiConversationTaskType(optionalString(conversation, "task_type"), roleplayCharacterId),
+            roleplayCharacterId,
             roleplayUserCharacterId: optionalString(conversation, "roleplay_user_character_id"),
+            roleplayMemories: roleplayCharacterId ? this.getRoleplayMemoryPromptItems(workId, roleplayCharacterId) : [],
             summary: requiredString(conversation, "compacted_summary"),
             compactedMessageCount,
             totalMessageCount,
@@ -6577,7 +7166,7 @@ export class Store {
             throw notFound("AI 对话");
         const workId = requiredString(conversation, "work_id");
         const previousCharacterId = optionalString(conversation, "roleplay_character_id");
-        const previousTaskType = optionalString(conversation, "task_type") ?? (previousCharacterId ? "roleplay" : "chat");
+        const previousTaskType = normalizeAiConversationTaskType(optionalString(conversation, "task_type"), previousCharacterId);
         if (previousTaskType === taskType)
             return this.getAiConversationSummary(conversationId);
         const messageCount = Number(this.db.get("SELECT COUNT(*) AS count FROM ai_conversation_messages WHERE conversation_id = ?", conversationId)?.count ?? 0);
@@ -6881,7 +7470,7 @@ export class Store {
         const systemClockText = optionalString(conversation, "system_clock_text") ?? "";
         const scenePinJson = optionalString(conversation, "scene_pin_json") ?? "{}";
         this.db.transaction(() => {
-            this.db.run("INSERT INTO ai_conversations (id, work_id, roleplay_character_id, roleplay_user_character_id, task_type, context_scope_json, title, compacted_summary, compacted_message_count, agent_tools_json, injected_entities_json, system_clock_text, scene_pin_json, created_at, updated_at, created_by_user_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", forkId, workId, optionalString(conversation, "roleplay_character_id"), optionalString(conversation, "roleplay_user_character_id"), optionalString(conversation, "task_type"), optionalString(conversation, "context_scope_json"), title.slice(0, 200), forkSummary, forkCompactedCount, conversation.agent_tools_json == null
+            this.db.run("INSERT INTO ai_conversations (id, work_id, roleplay_character_id, roleplay_user_character_id, task_type, context_scope_json, title, compacted_summary, compacted_message_count, agent_tools_json, injected_entities_json, system_clock_text, scene_pin_json, created_at, updated_at, created_by_user_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", forkId, workId, optionalString(conversation, "roleplay_character_id"), optionalString(conversation, "roleplay_user_character_id"), normalizeAiConversationTaskType(optionalString(conversation, "task_type"), optionalString(conversation, "roleplay_character_id")), optionalString(conversation, "context_scope_json"), title.slice(0, 200), forkSummary, forkCompactedCount, conversation.agent_tools_json == null
                 ? JSON.stringify(normalizeWorkAgentTools(this.getWorkAiSettings(workId).agentTools))
                 : String(conversation.agent_tools_json), injectedEntitiesJson, systemClockText, scenePinJson, timestamp, timestamp, currentRequestActor()?.userId ?? null);
             for (const message of messages.slice(0, targetIndex + 1)) {
@@ -6954,7 +7543,7 @@ export class Store {
             compactedMessageCount: numberValue(row, "compacted_message_count"),
             hasCompactedSummary: Boolean(requiredString(row, "compacted_summary")),
             contextWarningPending: Boolean(optionalString(row, "context_warning_at")),
-            taskType: optionalString(row, "task_type") ?? (roleplayCharacterId ? "roleplay" : "chat"),
+            taskType: normalizeAiConversationTaskType(optionalString(row, "task_type"), roleplayCharacterId),
             ...(lockedModelId ? { modelId: lockedModelId } : {}),
             ...(hasImageAttachments ? { hasImageAttachments: true, modelLockedByImage: true } : {}),
             contextScope: json(optionalString(row, "context_scope_json") ?? "", { type: "none" }),
@@ -7043,6 +7632,49 @@ export class Store {
             createdAt: requiredString(row, "created_at")
         };
     }
+    mapRoleplayMemory(row, includeDetails) {
+        const memoryId = requiredString(row, "id");
+        const actor = currentRequestActor();
+        const sources = includeDetails
+            ? this.db.all(`SELECT source.*, conversation.created_by_user_id AS conversation_owner_id
+           FROM roleplay_memory_sources source
+           LEFT JOIN ai_conversations conversation ON conversation.id = source.conversation_id
+           WHERE source.memory_id = ? ORDER BY source.source_created_at, source.id`, memoryId).map((source) => {
+                const sourceOwnerId = optionalString(source, "conversation_owner_id") ?? optionalString(source, "source_created_by_user_id");
+                const canOpen = actor === null || actor.role === "admin" || (sourceOwnerId !== null && sourceOwnerId === actor.userId);
+                return {
+                    id: requiredString(source, "id"),
+                    role: requiredString(source, "message_role"),
+                    sourceType: requiredString(row, "source_type"),
+                    sourceAt: requiredString(source, "source_created_at"),
+                    canOpen,
+                    restricted: !canOpen,
+                    conversationId: canOpen ? optionalString(source, "conversation_id") : null,
+                    messageId: canOpen ? optionalString(source, "message_id") : null,
+                    evidence: canOpen ? requiredString(source, "evidence_snapshot") : null
+                };
+            })
+            : undefined;
+        return {
+            id: memoryId,
+            workId: requiredString(row, "work_id"),
+            characterId: requiredString(row, "character_id"),
+            category: requiredString(row, "category"),
+            content: requiredString(row, "content"),
+            importance: requiredString(row, "importance"),
+            certainty: requiredString(row, "certainty"),
+            origin: "roleplay",
+            canonical: false,
+            status: requiredString(row, "status"),
+            isPinned: booleanValue(row, "is_pinned"),
+            versionNo: numberValue(row, "version_no"),
+            supersededByMemoryId: optionalString(row, "superseded_by_memory_id"),
+            sourceType: requiredString(row, "source_type"),
+            ...(sources ? { sources } : {}),
+            createdAt: requiredString(row, "created_at"),
+            updatedAt: requiredString(row, "updated_at")
+        };
+    }
     hashContent(content) {
         return createHash("sha256").update(content).digest("hex");
     }
@@ -7750,8 +8382,20 @@ export class Store {
                     return [];
                 }
             });
-            summary = `提取并写入 ${events.length} 个时间轴事件候选。`;
-            metrics = [metric("写入事件", events.length), metric("已不存在", Math.max(0, ids.length - events.length))];
+            const hasChunkMetrics = typeof result.coveredChapterCount === "number" || typeof result.batchCount === "number";
+            summary = hasChunkMetrics
+                ? `覆盖 ${Number(result.coveredChapterCount ?? 0)} 章正文，识别 ${Number(result.rawCandidateCount ?? events.length)} 个原始候选，写入 ${events.length} 个时间轴事件候选。`
+                : `提取并写入 ${events.length} 个时间轴事件候选。`;
+            metrics = [
+                metric("写入事件", events.length),
+                ...(hasChunkMetrics ? [
+                    metric("覆盖章节", result.coveredChapterCount),
+                    metric("正文分片", result.batchCount),
+                    metric("归并批次", result.aggregationBatchCount),
+                    metric("原始候选", result.rawCandidateCount)
+                ] : []),
+                metric("已不存在", Math.max(0, ids.length - events.length))
+            ];
             storageTargets.unshift({ label: "时间轴候选", entity: "时间轴与事件", key: "timeline", count: events.length, note: "以候选状态写入，等待作者确认。" });
             sections = [section("事件候选", events, "没有形成可写入的时间轴事件。")];
         }