@musnows/scriverse 0.9.3 → 0.9.5

package/dist/store.js

@@ -9,11 +9,13 @@ 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 { countWords, documentShortSearchTerms, escapeSqlLikePattern, id, json, normalizeDocumentSearchText, normalizeParagraphSpacing, now, splitDocumentParagraphs } from "./utils.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 { 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;
@@ -534,6 +536,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 +806,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 +873,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);
             }
@@ -1201,8 +1207,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 });
         });
@@ -2103,9 +2110,10 @@ export class Store {
         const current = this.getChapter(chapterId);
         this.assertExpectedRevision("chapter", chapterId, expectedVersionNo, "章节", Number(current.versionNo));
         const nextTitle = input.title ?? String(current.title);
-        const nextContent = input.content === undefined ? String(current.content) : normalizeParagraphSpacing(input.content);
+        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 +2124,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 +2164,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 +2329,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 +2487,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
@@ -2555,9 +2608,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 });
@@ -2787,16 +2846,16 @@ export class Store {
     insertChapter(workId, volumeId, title, content, sortOrder, source, sourceRef, chapterType = "正文") {
         const chapterId = id("chapter");
         const timestamp = now();
-        const normalizedContent = normalizeParagraphSpacing(content);
-        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, normalizedContent, chapterType, sortOrder, countWords(normalizedContent), timestamp, timestamp);
-        this.syncChapterParagraphSearch(workId, chapterId, normalizedContent);
+        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,
             chapterId,
             versionNo: 1,
             title,
-            content: normalizedContent,
+            content,
             volumeId,
             sortOrder,
             chapterType,
@@ -3092,6 +3151,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,
@@ -3124,7 +3185,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) {
@@ -5579,6 +5641,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);
@@ -5646,6 +5709,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);
@@ -5658,16 +5722,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") {
@@ -6311,6 +6419,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)
@@ -6336,10 +6708,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: (optionalString(conversation, "task_type") ?? (roleplayCharacterId ? "roleplay" : "chat")),
+            roleplayCharacterId,
             roleplayUserCharacterId: optionalString(conversation, "roleplay_user_character_id"),
+            roleplayMemories: roleplayCharacterId ? this.getRoleplayMemoryPromptItems(workId, roleplayCharacterId) : [],
             summary: requiredString(conversation, "compacted_summary"),
             compactedMessageCount,
             totalMessageCount,
@@ -7044,6 +7419,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");
     }
@@ -7751,8 +8169,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, "没有形成可写入的时间轴事件。")];
         }