@musnows/scriverse 0.9.4 → 0.9.6

package/dist/app.js

@@ -1,3 +1,4 @@
+import compression from "compression";
 import express from "express";
 import JSZip from "jszip";
 import multer from "multer";
@@ -16,10 +17,12 @@ import { DEFAULT_AI_CHAT_TAB_LIMIT } from "./ai-chat-tab-limit.js";
 import { MAX_AI_STREAM_IDLE_TIMEOUT_SECONDS, MIN_AI_STREAM_IDLE_TIMEOUT_SECONDS, normalizeAiStreamIdleTimeoutSeconds } from "./ai-stream-timeout.js";
 import { AttachmentStorage } from "./attachment-storage.js";
 import { attachmentDownloadFileName, inlineContentDisposition } from "./attachment-download.js";
-import { AiManager } from "./ai.js";
+import { AI_MODEL_KINDS, AiManager } from "./ai.js";
 import { LiteLlmPriceCache } from "./ai-model-pricing.js";
 import { resolveMaxAgentToolCallLimit } from "./ai-tool-results.js";
+import { SEMANTIC_SOURCE_TYPES } from "./semantic-search.js";
 import { CHARACTER_EXTRACTION_MAX_ALIASES, CHARACTER_EXTRACTION_MAX_CANDIDATES, CHARACTER_EXTRACTION_MAX_IDENTITY_LENGTH, CHARACTER_EXTRACTION_MAX_NAME_LENGTH, CHARACTER_EXTRACTION_MAX_SPECIES_LENGTH } from "./character-extraction.js";
+import { AiWritePlanManager, AI_USER_QUESTION_STATUSES, AI_WRITE_PLAN_STATUSES, aiWriteToolDescriptions, aiWriteToolLabels, aiWriteToolsUpdateSchema, answerAiUserQuestionSchema, resolveAiWritePlanMaxOperations } from "./ai-write-plans.js";
 import { CredentialVault } from "./credential-vault.js";
 import { Database } from "./database.js";
 import { assertSafeDocxArchive } from "./docx-security.js";
@@ -29,8 +32,11 @@ import { AppError } from "./errors.js";
 import { isOfficialGoogleVertexBaseUrl, parseGoogleServiceAccount } from "./google-vertex-auth.js";
 import { HYBRID_SEARCH_TYPES, MAXIMUM_WORK_SEARCH_QUERY_LENGTH, readableHybridSearchTypes } from "./hybrid-search.js";
 import { applyImportFileHints, parseNovelText } from "./parser.js";
+import { MAX_CHAPTER_LINE_IDS } from "./chapter-annotation-anchor.js";
+import { isChapterNumberTemplate } from "./chapter-title-numbering.js";
 import { aiConversationTaskTypes, attachmentPermissionModules, RECYCLE_BIN_RETENTION_DAYS, Store, versionedEntityTypes, WORK_AGENT_TOOL_IDS } from "./store.js";
 import { composeRoleplayStoredUserContent } from "./roleplay-turn.js";
+import { ROLEPLAY_MEMORY_CATEGORIES, ROLEPLAY_MEMORY_CERTAINTY, ROLEPLAY_MEMORY_IMPORTANCE, ROLEPLAY_MEMORY_STATUSES } from "./roleplay-memory.js";
 import { paginated, parsePagination } from "./pagination.js";
 import { normalizeUploadFileName } from "./utils.js";
 import { assertSafeAiEndpoint, assertSafeS3Endpoint, createApiRateLimitMiddleware, createAuthenticationRateLimitMiddleware, createBasicAuthMiddleware, createCaptchaRateLimitMiddleware, createExpensiveApiRateLimitMiddleware, createSameOriginMiddleware, createSecurityHeadersMiddleware, createUploadRateLimitMiddleware, enforceCaseInsensitiveRouting, normalizeApiPath, resolveTrustProxySetting, verifySetupToken } from "./security.js";
@@ -50,6 +56,7 @@ import { canReadWorkModule, canWriteWorkModule, chapterAnnotationPermissionModul
 import { CollaborationPresence, editorPageKey, entityEditorPageKey, modulePageKey, presencePageKinds } from "./collaboration-presence.js";
 import { PresenceStore } from "./presence-store.js";
 import { analysisTaskReadModules, clearSessionCookie, createCliApiScopeMiddleware, createUserSessionMiddleware, createWorkAuthorizationMiddleware, relationshipAnalysisReadModules, setSessionCookie, UserAuthService } from "./user-auth.js";
+import { extractStaticModuleImports, injectModulePreloads } from "./ui-module-preload.js";
 const chapterAnnotationKinds = ["note", "todo"];
 function readableChapterAnnotationKinds(permissions) {
     return chapterAnnotationKinds.filter((kind) => canReadWorkModule(permissions, chapterAnnotationPermissionModule(kind)));
@@ -62,6 +69,23 @@ const optionalStrings = z.array(z.string()).optional();
 const jsonObject = z.record(z.string(), z.unknown());
 const chapterTypeSchema = z.enum(["正文", "设定", "作者的话", "其他"]);
 const aiConversationTaskTypeSchema = z.enum(aiConversationTaskTypes);
+const roleplayMemoryInputSchema = z.object({
+    category: z.enum(ROLEPLAY_MEMORY_CATEGORIES),
+    content: z.string().trim().min(1).max(2_000),
+    importance: z.enum(ROLEPLAY_MEMORY_IMPORTANCE).optional(),
+    certainty: z.enum(ROLEPLAY_MEMORY_CERTAINTY).optional(),
+    isPinned: z.boolean().optional()
+}).strict();
+const roleplayMemoryListQuerySchema = z.object({
+    q: z.string().trim().max(200).optional(),
+    categories: z.preprocess((value) => typeof value === "string" ? value.split(",").filter(Boolean) : value, z.array(z.enum(ROLEPLAY_MEMORY_CATEGORIES)).max(ROLEPLAY_MEMORY_CATEGORIES.length).optional()),
+    statuses: z.preprocess((value) => typeof value === "string" ? value.split(",").filter(Boolean) : value, z.array(z.enum(ROLEPLAY_MEMORY_STATUSES)).max(ROLEPLAY_MEMORY_STATUSES.length).optional()),
+    cursor: z.coerce.number().int().min(0).max(100_000).optional(),
+    limit: z.coerce.number().int().min(1).max(100).optional()
+}).strict();
+const roleplayMemoryUpdateSchema = roleplayMemoryInputSchema.partial().extend({
+    expectedVersion: z.number().int().min(1)
+}).strict().refine((value) => Object.keys(value).some((key) => key !== "expectedVersion"), "至少提供一个要修改的字段");
 const versionedEntityTypeSchema = z.enum(versionedEntityTypes);
 const attachmentPermissionModuleSchema = z.enum(attachmentPermissionModules);
 const maximumImportedTextLength = 20_000_000;
@@ -211,7 +235,9 @@ const workSchema = z.object({
     description: z.string().max(10_000).optional(),
     language: z.string().max(30).optional(),
     coverUrl: z.string().url().nullable().optional(),
-    tags: optionalStrings
+    tags: optionalStrings,
+    editorAutoIndentEnabled: z.boolean().optional(),
+    editorTypewriterModeEnabled: z.boolean().optional()
 });
 const workOfflineAccessSchema = z.object({ enabled: z.boolean() }).strict();
 const settingSchema = z.object({
@@ -461,6 +487,7 @@ const providerUpdateSchema = providerBaseSchema.partial().superRefine((value, ct
 const modelSchema = z.object({
     displayName: nonEmpty.max(200),
     modelId: nonEmpty.max(300),
+    modelKind: z.enum(AI_MODEL_KINDS).optional(),
     purposes: optionalStrings,
     contextNote: z.string().max(10_000).optional(),
     contextWindow: z.number().int().min(32_768, "模型上下文不能低于 32768 Token").max(2_000_000).optional(),
@@ -627,11 +654,38 @@ const workAiSettingsSchema = z.object({
     titleGenerationModelId: z.string().trim().max(200).optional(),
     imageToolModelId: identifier.nullable().optional()
 }).strict();
+const semanticSearchSettingsSchema = z.object({
+    enabled: z.boolean().optional(),
+    embeddingModelId: identifier.nullable().optional(),
+    rerankModelId: identifier.nullable().optional(),
+    vectorDimension: z.number().int().min(1).max(65_536).optional(),
+    recallLimit: z.number().int().min(1).max(200).optional(),
+    resultLimit: z.number().int().min(1).max(100).optional(),
+    budgetTokens: z.number().int().min(256).max(100_000).optional(),
+    channelWeight: z.number().min(0.1).max(5).optional()
+}).strict();
+const semanticSearchRequestSchema = z.object({
+    query: z.string().trim().min(1).max(2_000),
+    types: z.array(z.enum(SEMANTIC_SOURCE_TYPES)).max(SEMANTIC_SOURCE_TYPES.length).optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+    includeKeyword: z.boolean().optional(),
+    currentChapterId: identifier.optional(),
+    selection: z.string().max(4_000).optional()
+}).strict();
+const semanticSnapshotSchema = z.object({
+    query: z.string().trim().min(1).max(2_000),
+    entryIds: z.array(identifier).min(1).max(30),
+    scope: jsonObject.optional(),
+    conversationId: identifier.optional()
+}).strict();
 const contextSchema = z.object({
     type: z.enum(["none", "selection", "chapter", "volume", "book", "settings-catalog", "entities"]),
     chapterId: identifier.optional(),
     volumeId: identifier.optional(),
     selection: z.string().max(200_000).optional(),
+    selectionStart: z.number().int().min(0).max(10_000_000).optional(),
+    selectionEnd: z.number().int().min(0).max(10_000_000).optional(),
+    writingChapterVersion: z.number().int().min(1).max(2_000_000_000).optional(),
     chapterIds: z.array(identifier).max(20).optional(),
     volumeIds: z.array(identifier).max(20).optional(),
     characterIds: optionalStrings,
@@ -639,6 +693,7 @@ const contextSchema = z.object({
     settingIds: optionalStrings,
     raceIds: optionalStrings,
     organizationIds: optionalStrings,
+    semanticSnapshotId: identifier.optional(),
     includeBookSummary: z.boolean().optional(),
     includeSettingInfo: z.boolean().optional()
 });
@@ -997,7 +1052,7 @@ function redactAiCallContext(record, permissions) {
     const redactedScope = { ...scope };
     let restricted = false;
     if (permissions.prose === "none") {
-        for (const field of ["selection", "chapterId", "volumeId", "chapterIds", "includeBookSummary"]) {
+        for (const field of ["selection", "selectionStart", "selectionEnd", "writingChapterVersion", "chapterId", "volumeId", "chapterIds", "includeBookSummary"]) {
             if (field in redactedScope) {
                 delete redactedScope[field];
                 restricted = true;
@@ -1340,6 +1395,15 @@ export function createRuntime(options) {
         liteLlmPriceCache,
         allowPrivateAiEndpoints: options.security?.allowPrivateAiEndpoints === true
     });
+    // AI 可写工具与审批工作流：计划创建只能由侧边栏 AI 发起，确认入口只接收审批 ID。
+    const aiWritePlanManager = new AiWritePlanManager({
+        database,
+        store,
+        auth,
+        resolveAnalysisTask: (workId, input) => ai.resolveTaskInput(workId, input),
+        startAnalysisTask: (workId, input) => store.createTask(workId, input)
+    });
+    ai.attachWritePlanManager(aiWritePlanManager);
     const app = express();
     enforceCaseInsensitiveRouting(app);
     const upload = multer({
@@ -1905,7 +1969,7 @@ export function createRuntime(options) {
     });
     app.get("/api/chapters/:chapterId", (request, response) => data(response, store.getChapter(request.params.chapterId)));
     app.patch("/api/chapters/:chapterId", (request, response) => {
-        const input = parse(z.object({ title: nonEmpty.max(300).optional(), content: z.string().max(2_000_000).optional(), excludedFromAnalysis: z.boolean().optional(), chapterType: chapterTypeSchema.optional(), source: z.enum(["manual", "auto"]).optional(), changeNote: changeNoteSchema, expectedVersionNo: expectedVersionNoSchema }).strict(), request.body);
+        const input = parse(z.object({ title: nonEmpty.max(300).optional(), content: z.string().max(2_000_000).optional(), lineIds: z.array(z.union([identifier, z.null()])).max(MAX_CHAPTER_LINE_IDS).optional(), excludedFromAnalysis: z.boolean().optional(), chapterType: chapterTypeSchema.optional(), source: z.enum(["manual", "auto"]).optional(), changeNote: changeNoteSchema, expectedVersionNo: expectedVersionNoSchema }).strict(), request.body);
         const { source, changeNote, expectedVersionNo, ...chapterInput } = input;
         const chapter = store.saveChapter(request.params.chapterId, chapterInput, source ?? "manual", null, changeNote, expectedVersionNo);
         publishEditorChange(String(chapter.workId), String(chapter.id));
@@ -1944,10 +2008,13 @@ export function createRuntime(options) {
     });
     app.get("/api/works/:workId/chapter-annotations", (request, response) => {
         const pagination = parsePagination(request.query);
+        const chapterId = request.query.chapterId === undefined ? undefined : parse(identifier, request.query.chapterId);
+        const query = request.query.q === undefined ? undefined : parse(z.string().trim().max(100), request.query.q);
+        const filters = { chapterId, query };
         const permissions = requestPermissions(request, String(request.params.workId));
         data(response, pagination
-            ? store.listWorkChapterAnnotationsPage(request.params.workId, pagination, readableChapterAnnotationKinds(permissions))
-            : store.listWorkChapterAnnotations(request.params.workId, readableChapterAnnotationKinds(permissions)));
+            ? store.listWorkChapterAnnotationsPage(request.params.workId, pagination, readableChapterAnnotationKinds(permissions), filters)
+            : store.listWorkChapterAnnotations(request.params.workId, readableChapterAnnotationKinds(permissions), filters));
     });
     app.post("/api/chapters/:chapterId/annotations", (request, response) => {
         const input = parse(z.object({
@@ -1984,6 +2051,12 @@ export function createRuntime(options) {
             z.object({ type: z.literal("move"), volumeId: identifier }).strict(),
             z.object({ type: z.literal("setType"), chapterType: chapterTypeSchema }).strict(),
             z.object({ type: z.literal("setAnalysisExclusion"), excludedFromAnalysis: z.boolean() }).strict(),
+            z.object({
+                type: z.literal("renumberTitles"),
+                template: z.string().min(1).max(50).refine(isChapterNumberTemplate, "标题格式必须且只能包含一个 {n} 占位符，且不能包含换行或控制字符"),
+                numberStyle: z.enum(["arabic", "chinese"]),
+                startAt: z.number().int().min(1).max(999_999)
+            }).strict(),
             z.object({ type: z.literal("delete") }).strict()
         ]);
         const input = parse(z.object({ chapters: selectedChapters, action }).strict(), request.body);
@@ -2813,6 +2886,12 @@ export function createRuntime(options) {
         data(response, { ...queued, queuedAt: new Date().toISOString() }, 202);
     });
     app.get("/api/works/:workId/ai-settings", (request, response) => data(response, store.getWorkAiSettings(request.params.workId)));
+    app.get("/api/works/:workId/ai-settings/mcp-servers", (request, response) => {
+        data(response, ai.getRemoteMcpSettings(request.params.workId));
+    });
+    app.put("/api/works/:workId/ai-settings/mcp-servers", async (request, response) => {
+        data(response, await ai.updateRemoteMcpSettings(request.params.workId, request.body));
+    });
     app.get("/api/works/:workId/ai-settings/usage", (request, response) => {
         const query = parse(aiUsageQuerySchema, request.query);
         data(response, ai.getWorkTokenUsage(request.params.workId, query.timezoneOffset));
@@ -2820,6 +2899,20 @@ export function createRuntime(options) {
     app.get("/api/works/:workId/ai-settings/relationship-search-index", (request, response) => {
         data(response, ai.getRelationshipSearchIndexStatus(request.params.workId));
     });
+    app.get("/api/works/:workId/ai-settings/semantic-search-index", (request, response) => {
+        data(response, ai.getSemanticSearchIndexStatus(request.params.workId));
+    });
+    app.patch("/api/works/:workId/ai-settings/semantic-search", async (request, response) => {
+        data(response, await ai.updateSemanticSearchSettings(request.params.workId, parse(semanticSearchSettingsSchema, request.body)));
+    });
+    app.post("/api/works/:workId/ai-settings/semantic-search-index/sync", (request, response) => {
+        parse(z.object({}).strict(), request.body ?? {});
+        data(response, ai.syncSemanticSearchIndex(request.params.workId), 202);
+    });
+    app.post("/api/works/:workId/ai-settings/semantic-search-index/rebuild", (request, response) => {
+        parse(z.object({}).strict(), request.body ?? {});
+        data(response, ai.rebuildSemanticSearchIndex(request.params.workId), 202);
+    });
     app.post("/api/works/:workId/ai-settings/relationship-search-index/sync", (request, response) => {
         const workId = request.params.workId;
         const result = ai.syncRelationshipSearchIndex(workId);
@@ -2875,6 +2968,16 @@ export function createRuntime(options) {
         data(response, store.createAiConversation(request.params.workId, input.title, input.taskType), 201);
     });
     app.use("/api/ai-conversations/:conversationId", (request, _response, next) => {
+        const sourceId = typeof request.query.roleplayMemorySourceId === "string"
+            ? request.query.roleplayMemorySourceId
+            : null;
+        const messageId = typeof request.query.messageId === "string" ? request.query.messageId : null;
+        if (["GET", "HEAD"].includes(request.method)
+            && request.authUser?.role === "admin"
+            && sourceId !== null
+            && messageId !== null
+            && store.isRoleplayMemorySourceTarget(sourceId, request.params.conversationId, messageId))
+            return next();
         assertRequestAiConversationOwner(request, request.params.conversationId);
         next();
     });
@@ -2942,6 +3045,20 @@ export function createRuntime(options) {
         const permissions = requestPermissions(request, String(updated.workId));
         data(response, redactAiConversation(updated, permissions));
     });
+    app.get("/api/characters/:characterId/roleplay-memories", (request, response) => {
+        const query = parse(roleplayMemoryListQuerySchema, request.query);
+        data(response, store.listRoleplayMemories(request.params.characterId, {
+            query: query.q,
+            categories: query.categories,
+            statuses: query.statuses,
+            cursor: query.cursor,
+            limit: query.limit
+        }));
+    });
+    app.post("/api/characters/:characterId/roleplay-memories", (request, response) => {
+        const input = parse(roleplayMemoryInputSchema, request.body);
+        data(response, store.createRoleplayMemory(request.params.characterId, input), 201);
+    });
     app.post("/api/ai-conversations/:conversationId/messages", (request, response) => {
         const input = parse(z.object({
             role: z.enum(["user", "assistant"]),
@@ -2975,12 +3092,24 @@ export function createRuntime(options) {
             ignoreContextWarning: z.boolean().optional()
         }).strict(), request.body ?? {});
         const conversation = store.getAiConversation(request.params.conversationId);
+        const permissions = requestPermissions(request, String(conversation.workId));
+        const writingSkillRequest = conversation.roleplayCharacter
+            ? { skillName: null, instruction: input.instruction }
+            : ai.resolveWritingSkillInstruction(input.instruction);
+        if (writingSkillRequest.skillName && !canReadWorkModule(permissions, "prose")) {
+            throw new AppError(403, "WORK_MODULE_READ_DENIED", "你没有读取当前章节正文以使用写作 Skill 的权限");
+        }
+        const citedInstruction = instructionWithCitations(writingSkillRequest.instruction, input.citations ?? []);
+        const preparedScope = conversation.roleplayCharacter
+            ? input.scope
+            : ai.resolveWritingSkillScope(String(conversation.workId), "chat", input.instruction, input.scope);
         data(response, await ai.prepareConversationContext({
             conversationId: request.params.conversationId,
             workId: String(conversation.workId),
             modelId: input.modelId,
-            scope: input.scope,
-            instruction: instructionWithCitations(input.instruction, input.citations ?? [])
+            scope: preparedScope,
+            instruction: citedInstruction,
+            skillInstruction: input.instruction
         }, { ignoreWarning: input.ignoreContextWarning === true }));
     });
     app.post("/api/ai-conversations/:conversationId/compact", async (request, response) => {
@@ -3004,6 +3133,130 @@ export function createRuntime(options) {
             })
         });
     });
+    app.patch("/api/roleplay-memories/:memoryId", (request, response) => {
+        const input = parse(roleplayMemoryUpdateSchema, request.body);
+        data(response, store.updateRoleplayMemory(request.params.memoryId, input));
+    });
+    app.delete("/api/roleplay-memories/:memoryId", (request, response) => {
+        const input = parse(z.object({ expectedVersion: z.number().int().min(1) }).strict(), request.body);
+        data(response, store.setRoleplayMemoryArchived(request.params.memoryId, true, input.expectedVersion));
+    });
+    app.post("/api/roleplay-memories/:memoryId/restore", (request, response) => {
+        const input = parse(z.object({ expectedVersion: z.number().int().min(1) }).strict(), request.body);
+        data(response, store.setRoleplayMemoryArchived(request.params.memoryId, false, input.expectedVersion));
+    });
+    // ---------------------------------------------------------------- AI 可写工具与审批中心
+    const planViewer = () => {
+        const actor = currentRequestActor();
+        return actor ? { userId: actor.userId, role: actor.role } : null;
+    };
+    app.get("/api/works/:workId/ai/tools", (request, response) => {
+        store.getWork(request.params.workId);
+        data(response, {
+            tools: aiWritePlanManager.getEnabledTools(request.params.workId),
+            labels: aiWriteToolLabels,
+            descriptions: aiWriteToolDescriptions,
+            maxOperations: resolveAiWritePlanMaxOperations(process.env.AI_WRITE_PLAN_MAX_OPERATIONS)
+        });
+    });
+    app.put("/api/works/:workId/ai/tools", (request, response) => {
+        const input = parse(aiWriteToolsUpdateSchema, request.body ?? {});
+        data(response, {
+            tools: aiWritePlanManager.updateToolSettings(request.params.workId, input.tools, currentRequestActor()?.userId ?? null)
+        });
+    });
+    app.get("/api/works/:workId/ai/write-plans", (request, response) => {
+        const status = typeof request.query.status === "string"
+            ? parse(z.enum(AI_WRITE_PLAN_STATUSES), request.query.status)
+            : undefined;
+        const limit = Number.parseInt(typeof request.query.limit === "string" ? request.query.limit : "", 10);
+        data(response, {
+            plans: aiWritePlanManager.listPlansForWork(request.params.workId, planViewer(), {
+                status,
+                ...(Number.isFinite(limit) ? { limit } : {})
+            })
+        });
+    });
+    app.get("/api/works/:workId/ai/write-plans/:planId", (request, response) => {
+        data(response, aiWritePlanManager.getPlanDetail(request.params.planId, request.params.workId, planViewer()));
+    });
+    app.post("/api/works/:workId/ai/write-plans/:planId/confirm", async (request, response) => {
+        data(response, await aiWritePlanManager.confirmPlan(request.params.planId, request.params.workId, planViewer()));
+    });
+    app.post("/api/works/:workId/ai/write-plans/:planId/reject", (request, response) => {
+        data(response, aiWritePlanManager.rejectPlan(request.params.planId, request.params.workId, planViewer()));
+    });
+    app.post("/api/works/:workId/ai/write-plans/:planId/undo", (request, response) => {
+        data(response, aiWritePlanManager.createUndoPlan(request.params.planId, request.params.workId, planViewer()), 201);
+    });
+    app.get("/api/works/:workId/ai/questions", (request, response) => {
+        const conversationId = typeof request.query.conversationId === "string"
+            ? parse(identifier, request.query.conversationId)
+            : undefined;
+        const status = typeof request.query.status === "string"
+            ? parse(z.enum(AI_USER_QUESTION_STATUSES), request.query.status)
+            : undefined;
+        const limit = Number.parseInt(typeof request.query.limit === "string" ? request.query.limit : "", 10);
+        data(response, {
+            questions: aiWritePlanManager.listQuestions(request.params.workId, planViewer(), {
+                ...(conversationId !== undefined ? { conversationId } : {}),
+                ...(status !== undefined ? { status } : {}),
+                ...(Number.isFinite(limit) ? { limit } : {})
+            })
+        });
+    });
+    app.get("/api/works/:workId/ai/questions/:questionId", (request, response) => {
+        data(response, aiWritePlanManager.getQuestion(request.params.questionId, request.params.workId, planViewer()));
+    });
+    const resumeQuestionWorkflow = async (questionId, workId, viewer) => {
+        const continuation = aiWritePlanManager.claimQuestionContinuation(questionId, workId, viewer);
+        if (!continuation)
+            return;
+        try {
+            const conversationId = typeof continuation.conversationId === "string" ? continuation.conversationId : "";
+            if (!conversationId)
+                throw new AppError(409, "AI_QUESTION_CONTINUATION_MISSING", "提问缺少可恢复的对话状态");
+            const scope = parse(contextSchema, continuation.scope ?? { type: "none" });
+            const resumed = await ai.resumeUserQuestion({
+                questionId,
+                workId,
+                conversationId,
+                scope,
+                status: String(continuation.status ?? "rejected"),
+                answerText: String(continuation.answerText ?? ""),
+                selectedOptionLabel: typeof continuation.selectedOptionLabel === "string" ? continuation.selectedOptionLabel : null,
+                supplementalAnswer: typeof continuation.customAnswer === "string" ? continuation.customAnswer : "",
+                ...(typeof continuation.modelId === "string" && continuation.modelId ? { modelId: continuation.modelId } : {}),
+                ...(typeof continuation.toolCallId === "string" && continuation.toolCallId ? { toolCallId: continuation.toolCallId } : {}),
+                ...(typeof continuation.assistantMessageRequestId === "string" && continuation.assistantMessageRequestId
+                    ? { assistantMessageRequestId: continuation.assistantMessageRequestId }
+                    : {}),
+                ...(continuation.questionView && typeof continuation.questionView === "object" && !Array.isArray(continuation.questionView)
+                    ? { questionView: continuation.questionView }
+                    : {}),
+                ...(typeof continuation.round === "number" ? { round: continuation.round } : {}),
+                ...(Array.isArray(continuation.toolMessages) ? { toolMessages: continuation.toolMessages } : {})
+            });
+            aiWritePlanManager.finishQuestionContinuation(questionId, { callId: resumed.callId ?? null, completed: true });
+        }
+        catch (error) {
+            aiWritePlanManager.finishQuestionContinuation(questionId, { message: error instanceof Error ? error.message : "恢复失败" }, true);
+            throw error;
+        }
+    };
+    app.post("/api/works/:workId/ai/questions/:questionId/answer", async (request, response) => {
+        const input = parse(answerAiUserQuestionSchema, request.body ?? {});
+        const viewer = planViewer();
+        aiWritePlanManager.answerQuestion(request.params.questionId, request.params.workId, viewer, { ...(input.selectedOption !== undefined ? { selectedOption: input.selectedOption } : {}), ...(input.customAnswer !== undefined ? { customAnswer: input.customAnswer } : {}) });
+        await resumeQuestionWorkflow(request.params.questionId, request.params.workId, viewer);
+        data(response, aiWritePlanManager.getQuestion(request.params.questionId, request.params.workId, viewer));
+    });
+    app.post("/api/works/:workId/ai/questions/:questionId/reject", async (request, response) => {
+        const viewer = planViewer();
+        aiWritePlanManager.rejectQuestion(request.params.questionId, request.params.workId, viewer);
+        await resumeQuestionWorkflow(request.params.questionId, request.params.workId, viewer);
+        data(response, aiWritePlanManager.getQuestion(request.params.questionId, request.params.workId, viewer));
+    });
     app.get("/api/works/:workId/providers", (request, response) => {
         store.getWork(request.params.workId);
         data(response, ai.listProviders());
@@ -3045,6 +3298,9 @@ export function createRuntime(options) {
         const pagination = parsePagination(request.query);
         data(response, pagination ? ai.listWorkModelsPage(request.params.workId, pagination) : ai.listWorkModels(request.params.workId));
     });
+    app.get("/api/works/:workId/semantic-models", (request, response) => {
+        data(response, ai.listWorkSemanticModels(request.params.workId));
+    });
     app.get("/api/works/:workId/task-defaults", (request, response) => {
         const pagination = parsePagination(request.query);
         data(response, pagination ? ai.listTaskDefaultsPage(request.params.workId, pagination) : ai.listTaskDefaults(request.params.workId));
@@ -3200,10 +3456,19 @@ export function createRuntime(options) {
         const storedUserContent = isRoleplay
             ? composeRoleplayStoredUserContent(sceneDirection, instructionText)
             : instructionText;
-        const resolvedInstruction = instructionWithCitations(instructionText, citations);
+        const permissions = requestPermissions(request, request.params.workId);
+        const writingSkillRequest = isRoleplay
+            ? { skillName: null, instruction: instructionText }
+            : ai.resolveWritingSkillInstruction(instructionText);
+        const resolvedInstruction = instructionWithCitations(writingSkillRequest.instruction, citations);
+        if (writingSkillRequest.skillName && !canReadWorkModule(permissions, "prose")) {
+            throw new AppError(403, "WORK_MODULE_READ_DENIED", "你没有读取当前章节正文以使用写作 Skill 的权限");
+        }
+        const requestScope = isRoleplay
+            ? input.scope
+            : ai.resolveWritingSkillScope(request.params.workId, "chat", instructionText, input.scope);
         const mentionSource = [sceneDirection, resolvedInstruction].filter(Boolean).join("\n");
         const modelId = resolveConversationModelId(request.params.workId, conversationId, input.modelId);
-        const permissions = requestPermissions(request, request.params.workId);
         const controller = new AbortController();
         let streamRequestId = null;
         let streamRequestFinished = false;
@@ -3258,8 +3523,9 @@ export function createRuntime(options) {
                     conversationId,
                     workId: request.params.workId,
                     modelId,
-                    scope: input.scope,
+                    scope: requestScope,
                     instruction: mentionSource,
+                    skillInstruction: instructionText,
                     excludeConversationMessageId: input.currentMessageId
                 }, { ignoreWarning: input.ignoreContextWarning === true });
                 preparedConversation = redactAiConversation(store.getAiConversationSummary(conversationId), permissions);
@@ -3280,12 +3546,12 @@ export function createRuntime(options) {
                 }
             }
             const resolvedScope = input.currentMessageId
-                ? input.scope
+                ? requestScope
                 : ai.resolveInstructionMentions({
                     workId: request.params.workId,
                     taskType: "chat",
                     instruction: mentionSource,
-                    scope: input.scope,
+                    scope: requestScope,
                     conversationId
                 });
             const mentionCharacterIds = [...new Set([
@@ -3304,11 +3570,12 @@ export function createRuntime(options) {
                     content: storedUserContent,
                     citations,
                     ...(input.currentMessageId ? { existingMessageId: input.currentMessageId } : {}),
-                    ...((modelId || mentionCharacterIds.length || mentionRaceIds.length || mentionOrganizationIds.length || input.imageAttachmentIds?.length) ? { metadata: {
+                    ...((modelId || mentionCharacterIds.length || mentionRaceIds.length || mentionOrganizationIds.length || input.imageAttachmentIds?.length || input.scope.semanticSnapshotId) ? { metadata: {
                             ...(modelId ? { modelId } : {}),
                             ...(mentionCharacterIds.length ? { mentionCharacterIds } : {}),
                             ...(mentionRaceIds.length ? { mentionRaceIds } : {}),
                             ...(mentionOrganizationIds.length ? { mentionOrganizationIds } : {}),
+                            ...(input.scope.semanticSnapshotId ? { semanticSnapshotId: input.scope.semanticSnapshotId } : {}),
                             ...(input.imageAttachmentIds?.length ? { chatImageAttachmentIds: [...new Set(input.imageAttachmentIds)] } : {})
                         } } : {})
                 }
@@ -3323,6 +3590,15 @@ export function createRuntime(options) {
                 }
                 if (begun.request.status === "completed" && begun.assistantMessage) {
                     const content = String(begun.assistantMessage.content ?? "");
+                    const assistantMetadata = begun.assistantMessage.metadata && typeof begun.assistantMessage.metadata === "object"
+                        ? begun.assistantMessage.metadata
+                        : {};
+                    const writingSuggestionId = typeof assistantMetadata.writingSuggestionId === "string"
+                        ? assistantMetadata.writingSuggestionId
+                        : "";
+                    const writingSuggestion = writingSuggestionId
+                        ? redactSuggestion(ai.getSuggestion(writingSuggestionId), permissions)
+                        : null;
                     if (content)
                         sendEvent("delta", { delta: content, replayed: true });
                     sendEvent("complete", {
@@ -3330,7 +3606,8 @@ export function createRuntime(options) {
                         conversationId,
                         conversationTitle: store.getAiConversationSummary(conversationId).title,
                         messageId: begun.assistantMessage.id,
-                        messageCreatedAt: begun.assistantMessage.createdAt
+                        messageCreatedAt: begun.assistantMessage.createdAt,
+                        ...(writingSuggestion ? { writingSuggestion } : {})
                     });
                 }
                 else {
@@ -3356,12 +3633,16 @@ export function createRuntime(options) {
             const currentMessageId = String(begun.userMessage?.id ?? input.currentMessageId ?? "");
             if (begun.userMessage)
                 sendEvent("user_message", { message: redactAiConversationMessage(begun.userMessage, permissions) });
+            if (aiWritePlanManager.latestPendingQuestion(conversationId)) {
+                throw new AppError(409, "AI_QUESTION_PENDING", "当前对话仍有待回答问题，请先回答或拒绝后再继续");
+            }
             const suggestion = await ai.createStreamingChat({
                 workId: request.params.workId,
                 instruction: resolvedInstruction,
+                skillInstruction: instructionText,
                 ...(sceneDirection ? { sceneDirection } : {}),
                 // 仍由生成路径基于原始范围持久化累计注入，保证预解析不会吞掉本轮自动命中。
-                scope: input.scope,
+                scope: requestScope,
                 signal: controller.signal,
                 onToolCall: (toolCall, round) => sendEvent("tool_call", { ...toolCall, round }),
                 onProcessStep: (step) => sendEvent("process_step", step),
@@ -3394,6 +3675,7 @@ export function createRuntime(options) {
                 contextUsage: suggestion.contextUsage,
                 conversationId,
                 conversationTitle: suggestion.conversationTitle,
+                ...(suggestion.action !== "note" ? { writingSuggestion: redactSuggestion(suggestion, permissions) } : {}),
                 messageId: typeof suggestion.conversationMessage === "object" && suggestion.conversationMessage !== null
                     ? suggestion.conversationMessage.id
                     : undefined,
@@ -3456,6 +3738,11 @@ export function createRuntime(options) {
     });
     app.post("/api/suggestions/:suggestionId/accept", (request, response) => {
         const input = parse(z.object({ content: z.string().max(2_000_000).optional() }), request.body ?? {});
+        const suggestion = ai.getSuggestion(request.params.suggestionId);
+        const permissions = requestPermissions(request, String(suggestion.workId));
+        if (!canWriteWorkModule(permissions, "prose")) {
+            throw new AppError(403, "WORK_MODULE_WRITE_DENIED", "你没有将 AI 建议写入正文的权限");
+        }
         data(response, ai.acceptSuggestion(request.params.suggestionId, input.content));
     });
     app.post("/api/suggestions/:suggestionId/reject", (request, response) => {
@@ -3484,6 +3771,27 @@ export function createRuntime(options) {
             conversationOwnerUserId: request.authUser?.userId
         }));
     });
+    app.post("/api/works/:workId/semantic-search", async (request, response) => {
+        const input = parse(semanticSearchRequestSchema, request.body);
+        const permissions = requestPermissions(request, request.params.workId);
+        const allowedTypes = readableHybridSearchTypes(permissions)
+            .filter((type) => SEMANTIC_SOURCE_TYPES.includes(type));
+        data(response, await ai.semanticSearchStory(request.params.workId, input.query, {
+            allowedTypes,
+            types: input.types,
+            limit: input.limit,
+            includeKeyword: input.includeKeyword,
+            conversationOwnerUserId: request.authUser?.userId,
+            currentChapterId: input.currentChapterId,
+            selection: input.selection
+        }));
+    });
+    app.post("/api/works/:workId/semantic-search/snapshots", (request, response) => {
+        const input = parse(semanticSnapshotSchema, request.body);
+        if (input.conversationId)
+            assertRequestAiConversationOwner(request, input.conversationId);
+        data(response, ai.createSemanticContextSnapshot(request.params.workId, input), 201);
+    });
     app.head("/api/works/:workId/export", (request, response) => {
         parse(z.enum(["epub"]), request.query.format ?? "epub");
         store.getWork(request.params.workId);
@@ -3540,11 +3848,14 @@ export function createRuntime(options) {
     });
     if (options.serveUi ?? true) {
         const publicPath = options.publicPath ?? join(process.cwd(), "src", "public");
+        const publicApplicationModuleImports = extractStaticModuleImports(readFileSync(join(publicPath, "app.js"), "utf8"));
+        // API 与 SSE 路由已经在此前注册；压缩只作用于页面和静态资源，避免缓冲流式响应。
+        app.use(compression());
         // index.html 按登录态动态下发：未登录时注入 login-route 类，首帧直接渲染登录页；
         // 已登录时保持骨架屏，由前端恢复会话后进入工作台，避免两种闪烁。
         const sendIndexHtml = (request, response) => {
             const authenticated = options.disableUserAuth === true || auth.authenticate(request) !== null;
-            let html = readFileSync(join(publicPath, "index.html"), "utf8");
+            let html = injectModulePreloads(readFileSync(join(publicPath, "index.html"), "utf8"), publicApplicationModuleImports);
             if (!authenticated)
                 html = html.replace('<html lang="zh-CN">', '<html lang="zh-CN" class="login-route">');
             if (options.disableUserAuth === true) {