inkos-n-core 1.2.0

package/dist/agents/writer.js

@@ -0,0 +1,1052 @@
+import { BaseAgent } from "./base.js";
+import { buildWriterSystemPrompt } from "./writer-prompts.js";
+import { buildSettlerSystemPrompt, buildSettlerUserPrompt } from "./settler-prompts.js";
+import { buildObserverSystemPrompt, buildObserverUserPrompt } from "./observer-prompts.js";
+import { parseSettlerDeltaOutput } from "./settler-delta-parser.js";
+import { parseSettlementOutput } from "./settler-parser.js";
+import { readGenreProfile, readBookRules } from "./rules-reader.js";
+import { detectCrossChapterRepetition, detectParagraphLengthDrift, validatePostWrite, } from "./post-write-validator.js";
+import { analyzeAITells } from "./ai-tells.js";
+import { buildLengthSpec, countChapterLength } from "../utils/length-metrics.js";
+import { filterHooks, filterSummaries, filterSubplots, filterEmotionalArcs, filterCharacterMatrix } from "../utils/context-filter.js";
+import { buildGovernedMemoryEvidenceBlocks } from "../utils/governed-context.js";
+import { buildGovernedCharacterMatrixWorkingSet, buildGovernedHookWorkingSet, mergeCharacterMatrixMarkdown, mergeTableMarkdownByKey, } from "../utils/governed-working-set.js";
+import { extractPOVFromOutline, filterMatrixByPOV, filterHooksByPOV } from "../utils/pov-filter.js";
+import { parseCreativeOutput } from "./writer-parser.js";
+import { buildRuntimeStateArtifacts, saveRuntimeStateSnapshot } from "../state/runtime-state-store.js";
+import { parsePendingHooksMarkdown } from "../utils/memory-retrieval.js";
+import { analyzeHookHealth } from "../utils/hook-health.js";
+import { buildEnglishVarianceBrief } from "../utils/long-span-fatigue.js";
+import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+import { join } from "node:path";
+export class WriterAgent extends BaseAgent {
+    get name() {
+        return "writer";
+    }
+    localize(language, messages) {
+        return language === "en" ? messages.en : messages.zh;
+    }
+    logInfo(language, messages) {
+        this.ctx.logger?.info(this.localize(language, messages));
+    }
+    logWarn(language, messages) {
+        this.ctx.logger?.warn(this.localize(language, messages));
+    }
+    async writeChapter(input) {
+        const { book, bookDir, chapterNumber } = input;
+        const [storyBible, volumeOutline, styleGuide, currentState, ledger, hooks, chapterSummaries, subplotBoard, emotionalArcs, characterMatrix, styleProfileRaw, parentCanon, fanficCanonRaw,] = await Promise.all([
+            this.readFileOrDefault(join(bookDir, "story/story_bible.md")),
+            this.readFileOrDefault(join(bookDir, "story/volume_outline.md")),
+            this.readFileOrDefault(join(bookDir, "story/style_guide.md")),
+            this.readFileOrDefault(join(bookDir, "story/current_state.md")),
+            this.readFileOrDefault(join(bookDir, "story/particle_ledger.md")),
+            this.readFileOrDefault(join(bookDir, "story/pending_hooks.md")),
+            this.readFileOrDefault(join(bookDir, "story/chapter_summaries.md")),
+            this.readFileOrDefault(join(bookDir, "story/subplot_board.md")),
+            this.readFileOrDefault(join(bookDir, "story/emotional_arcs.md")),
+            this.readFileOrDefault(join(bookDir, "story/character_matrix.md")),
+            this.readFileOrDefault(join(bookDir, "story/style_profile.json")),
+            this.readFileOrDefault(join(bookDir, "story/parent_canon.md")),
+            this.readFileOrDefault(join(bookDir, "story/fanfic_canon.md")),
+        ]);
+        const recentChapters = await this.loadRecentChapters(bookDir, chapterNumber);
+        // Load more chapters for dialogue fingerprint extraction (voice consistency over longer span)
+        const fingerprintChapters = await this.loadRecentChapters(bookDir, chapterNumber, 5);
+        // Load genre profile + book rules
+        const { profile: genreProfile, body: genreBody } = await readGenreProfile(this.ctx.projectRoot, book.genre);
+        const parsedBookRules = await readBookRules(bookDir);
+        const bookRules = parsedBookRules?.rules ?? null;
+        const bookRulesBody = parsedBookRules?.body ?? "";
+        const styleFingerprint = this.buildStyleFingerprint(styleProfileRaw);
+        const dialogueFingerprints = this.extractDialogueFingerprints(fingerprintChapters, storyBible);
+        const relevantSummaries = this.findRelevantSummaries(chapterSummaries, volumeOutline, chapterNumber);
+        const hasParentCanon = parentCanon !== "(文件尚未创建)";
+        const hasFanficCanon = fanficCanonRaw !== "(文件尚未创建)";
+        const resolvedLanguage = book.language ?? genreProfile.language;
+        const targetWords = input.lengthSpec?.target ?? input.wordCountOverride ?? book.chapterWordCount;
+        const resolvedLengthSpec = input.lengthSpec ?? buildLengthSpec(targetWords, resolvedLanguage);
+        const governedMemoryBlocks = input.contextPackage
+            ? buildGovernedMemoryEvidenceBlocks(input.contextPackage, resolvedLanguage)
+            : undefined;
+        const englishVarianceBrief = resolvedLanguage === "en"
+            ? await buildEnglishVarianceBrief({
+                bookDir,
+                chapterNumber,
+            })
+            : null;
+        // Build fanfic context if fanfic_canon.md exists
+        const fanficContext = hasFanficCanon && bookRules?.fanficMode
+            ? {
+                fanficCanon: fanficCanonRaw,
+                fanficMode: bookRules.fanficMode,
+                allowedDeviations: bookRules.allowedDeviations ?? [],
+            }
+            : undefined;
+        // ── Phase 1: Creative writing (temperature 0.7) ──
+        const creativeSystemPrompt = buildWriterSystemPrompt(book, genreProfile, bookRules, bookRulesBody, genreBody, styleGuide, styleFingerprint, chapterNumber, "creative", fanficContext, resolvedLanguage, input.chapterIntent ? "governed" : "legacy", resolvedLengthSpec);
+        const creativeUserPrompt = input.chapterIntent && input.contextPackage && input.ruleStack
+            ? this.buildGovernedUserPrompt({
+                chapterNumber,
+                chapterIntent: input.chapterIntent,
+                contextPackage: input.contextPackage,
+                ruleStack: input.ruleStack,
+                trace: input.trace,
+                lengthSpec: resolvedLengthSpec,
+                language: book.language ?? genreProfile.language,
+                varianceBrief: englishVarianceBrief?.text,
+                selectedEvidenceBlock: this.joinGovernedEvidenceBlocks(governedMemoryBlocks),
+            })
+            : (() => {
+                // Smart context filtering: inject only relevant parts of truth files
+                const filteredHooks = filterHooks(hooks);
+                const filteredSummaries = filterSummaries(chapterSummaries, chapterNumber);
+                const filteredSubplots = filterSubplots(subplotBoard);
+                const filteredArcs = filterEmotionalArcs(emotionalArcs, chapterNumber);
+                const filteredMatrix = filterCharacterMatrix(characterMatrix, volumeOutline, bookRules?.protagonist?.name);
+                // POV-aware filtering: limit context to what the POV character knows
+                const povCharacter = extractPOVFromOutline(volumeOutline, chapterNumber);
+                const povFilteredMatrix = povCharacter
+                    ? filterMatrixByPOV(filteredMatrix, povCharacter)
+                    : filteredMatrix;
+                const povFilteredHooks = povCharacter
+                    ? filterHooksByPOV(filteredHooks, povCharacter, chapterSummaries)
+                    : filteredHooks;
+                return this.buildUserPrompt({
+                    chapterNumber,
+                    storyBible,
+                    volumeOutline,
+                    currentState,
+                    ledger: genreProfile.numericalSystem ? ledger : "",
+                    hooks: povFilteredHooks,
+                    recentChapters,
+                    lengthSpec: resolvedLengthSpec,
+                    externalContext: input.externalContext,
+                    chapterSummaries: filteredSummaries,
+                    subplotBoard: filteredSubplots,
+                    emotionalArcs: filteredArcs,
+                    characterMatrix: povFilteredMatrix,
+                    dialogueFingerprints,
+                    relevantSummaries,
+                    parentCanon: hasParentCanon ? parentCanon : undefined,
+                    language: book.language ?? genreProfile.language,
+                });
+            })();
+        const creativeTemperature = input.temperatureOverride ?? 0.7;
+        this.logInfo(resolvedLanguage, {
+            zh: `阶段 1：创作正文（第${chapterNumber}章）`,
+            en: `Phase 1: creative writing for chapter ${chapterNumber}`,
+        });
+        // Scale maxTokens to chapter word count (Chinese ≈ 1.5 tokens/char)
+        const creativeMaxTokens = Math.max(8192, Math.ceil(targetWords * 2));
+        const creativeResponse = await this.chat([
+            { role: "system", content: creativeSystemPrompt },
+            { role: "user", content: creativeUserPrompt },
+        ], { maxTokens: creativeMaxTokens, temperature: creativeTemperature });
+        const creativeUsage = creativeResponse.usage;
+        const creative = parseCreativeOutput(chapterNumber, creativeResponse.content, resolvedLengthSpec.countingMode);
+        // ── Phase 2: State settlement (temperature 0.3) ──
+        this.logInfo(resolvedLanguage, {
+            zh: `阶段 2：状态结算（第${chapterNumber}章，${creative.wordCount}字）`,
+            en: `Phase 2: state settlement for chapter ${chapterNumber} (${creative.wordCount} words)`,
+        });
+        const isGovernedSettlement = Boolean(input.chapterIntent && input.contextPackage && input.ruleStack);
+        const filteredHooksForSettlement = isGovernedSettlement && input.contextPackage
+            ? buildGovernedHookWorkingSet({
+                hooksMarkdown: hooks,
+                contextPackage: input.contextPackage,
+                chapterIntent: input.chapterIntent,
+                chapterNumber,
+                language: resolvedLanguage,
+            })
+            : hooks;
+        const filteredSubplotsForSettlement = isGovernedSettlement
+            ? filterSubplots(subplotBoard)
+            : subplotBoard;
+        const filteredArcsForSettlement = isGovernedSettlement
+            ? filterEmotionalArcs(emotionalArcs, chapterNumber)
+            : emotionalArcs;
+        const filteredMatrixForSettlement = isGovernedSettlement
+            ? buildGovernedCharacterMatrixWorkingSet({
+                matrixMarkdown: characterMatrix,
+                chapterIntent: input.chapterIntent ?? volumeOutline,
+                contextPackage: input.contextPackage,
+                protagonistName: bookRules?.protagonist?.name,
+            })
+            : characterMatrix;
+        const settleResult = await this.settle({
+            book,
+            genreProfile,
+            bookRules,
+            chapterNumber,
+            title: creative.title,
+            content: creative.content,
+            currentState,
+            ledger: genreProfile.numericalSystem ? ledger : "",
+            hooks: filteredHooksForSettlement,
+            chapterSummaries: input.contextPackage ? filterSummaries(chapterSummaries, chapterNumber) : chapterSummaries,
+            subplotBoard: filteredSubplotsForSettlement,
+            emotionalArcs: filteredArcsForSettlement,
+            characterMatrix: filteredMatrixForSettlement,
+            volumeOutline,
+            selectedEvidenceBlock: governedMemoryBlocks
+                ? this.joinGovernedEvidenceBlocks(governedMemoryBlocks)
+                : undefined,
+            chapterIntent: input.chapterIntent,
+            contextPackage: input.contextPackage,
+            ruleStack: input.ruleStack,
+            validationFeedback: undefined,
+            originalHooks: hooks,
+            originalSubplots: subplotBoard,
+            originalEmotionalArcs: emotionalArcs,
+            originalCharacterMatrix: characterMatrix,
+        });
+        const settlement = settleResult.settlement;
+        const settleUsage = settleResult.usage;
+        const runtimeStateArtifacts = await this.buildRuntimeStateArtifactsIfPresent(bookDir, settlement.runtimeStateDelta, resolvedLanguage, chapterNumber);
+        const resolvedRuntimeStateDelta = runtimeStateArtifacts?.resolvedDelta ?? settlement.runtimeStateDelta;
+        const priorHookIds = new Set(parsePendingHooksMarkdown(hooks).map((hook) => hook.hookId));
+        const hookHealthIssues = resolvedRuntimeStateDelta
+            && (runtimeStateArtifacts?.snapshot ?? settlement.runtimeStateSnapshot)
+            ? analyzeHookHealth({
+                language: resolvedLanguage,
+                chapterNumber,
+                targetChapters: book.targetChapters,
+                hooks: (runtimeStateArtifacts?.snapshot ?? settlement.runtimeStateSnapshot).hooks.hooks,
+                delta: resolvedRuntimeStateDelta,
+                existingHookIds: [...priorHookIds],
+            })
+            : [];
+        // ── Post-write validation (regex + rule-based, zero LLM cost) ──
+        const ruleViolations = [
+            ...validatePostWrite(creative.content, genreProfile, bookRules, resolvedLanguage),
+            ...detectCrossChapterRepetition(creative.content, fingerprintChapters, resolvedLanguage),
+            ...detectParagraphLengthDrift(creative.content, fingerprintChapters, resolvedLanguage),
+        ];
+        const aiTellIssues = analyzeAITells(creative.content, resolvedLanguage).issues;
+        const postWriteErrors = ruleViolations.filter(v => v.severity === "error");
+        const postWriteWarnings = ruleViolations.filter(v => v.severity === "warning");
+        if (ruleViolations.length > 0) {
+            this.logWarn(resolvedLanguage, {
+                zh: `后写校验：第${chapterNumber}章 ${postWriteErrors.length} 个错误，${postWriteWarnings.length} 个警告`,
+                en: `Post-write: ${postWriteErrors.length} errors, ${postWriteWarnings.length} warnings in chapter ${chapterNumber}`,
+            });
+            for (const v of ruleViolations) {
+                this.ctx.logger?.warn(`[${v.severity}] ${v.rule}: ${v.description}`);
+            }
+        }
+        if (aiTellIssues.length > 0) {
+            this.logWarn(resolvedLanguage, {
+                zh: `AI 味检查：第${chapterNumber}章发现 ${aiTellIssues.length} 个问题`,
+                en: `AI-tell check: ${aiTellIssues.length} issues in chapter ${chapterNumber}`,
+            });
+            for (const issue of aiTellIssues) {
+                this.ctx.logger?.warn(`[${issue.severity}] ${issue.category}: ${issue.description}`);
+            }
+        }
+        if (hookHealthIssues.length > 0) {
+            this.logWarn(resolvedLanguage, {
+                zh: `伏笔健康：第${chapterNumber}章发现 ${hookHealthIssues.length} 条警告`,
+                en: `Hook health: ${hookHealthIssues.length} warning(s) in chapter ${chapterNumber}`,
+            });
+            for (const issue of hookHealthIssues) {
+                this.ctx.logger?.warn(`[${issue.severity}] ${issue.category}: ${issue.description}`);
+            }
+        }
+        // ── Merge into WriteChapterOutput ──
+        const tokenUsage = {
+            promptTokens: creativeUsage.promptTokens + settleUsage.promptTokens,
+            completionTokens: creativeUsage.completionTokens + settleUsage.completionTokens,
+            totalTokens: creativeUsage.totalTokens + settleUsage.totalTokens,
+        };
+        return {
+            chapterNumber,
+            title: creative.title,
+            content: creative.content,
+            wordCount: creative.wordCount,
+            preWriteCheck: creative.preWriteCheck,
+            postSettlement: settlement.postSettlement,
+            runtimeStateDelta: resolvedRuntimeStateDelta,
+            runtimeStateSnapshot: runtimeStateArtifacts?.snapshot ?? settlement.runtimeStateSnapshot,
+            updatedState: runtimeStateArtifacts?.currentStateMarkdown ?? settlement.updatedState,
+            updatedLedger: settlement.updatedLedger,
+            updatedHooks: runtimeStateArtifacts?.hooksMarkdown ?? settlement.updatedHooks,
+            chapterSummary: resolvedRuntimeStateDelta
+                ? this.renderDeltaSummaryRow(resolvedRuntimeStateDelta)
+                : settlement.chapterSummary,
+            updatedChapterSummaries: runtimeStateArtifacts?.chapterSummariesMarkdown,
+            updatedSubplots: settlement.updatedSubplots,
+            updatedEmotionalArcs: settlement.updatedEmotionalArcs,
+            updatedCharacterMatrix: settlement.updatedCharacterMatrix,
+            postWriteErrors,
+            postWriteWarnings,
+            hookHealthIssues,
+            tokenUsage,
+        };
+    }
+    async settleChapterState(input) {
+        const [currentState, ledger, hooks, chapterSummaries, subplotBoard, emotionalArcs, characterMatrix, volumeOutline,] = await Promise.all([
+            this.readFileOrDefault(join(input.bookDir, "story/current_state.md")),
+            this.readFileOrDefault(join(input.bookDir, "story/particle_ledger.md")),
+            this.readFileOrDefault(join(input.bookDir, "story/pending_hooks.md")),
+            this.readFileOrDefault(join(input.bookDir, "story/chapter_summaries.md")),
+            this.readFileOrDefault(join(input.bookDir, "story/subplot_board.md")),
+            this.readFileOrDefault(join(input.bookDir, "story/emotional_arcs.md")),
+            this.readFileOrDefault(join(input.bookDir, "story/character_matrix.md")),
+            this.readFileOrDefault(join(input.bookDir, "story/volume_outline.md")),
+        ]);
+        const { profile: genreProfile } = await readGenreProfile(this.ctx.projectRoot, input.book.genre);
+        const parsedBookRules = await readBookRules(input.bookDir);
+        const bookRules = parsedBookRules?.rules ?? null;
+        const resolvedLanguage = input.book.language ?? genreProfile.language;
+        const governedMemoryBlocks = input.contextPackage
+            ? buildGovernedMemoryEvidenceBlocks(input.contextPackage, resolvedLanguage)
+            : undefined;
+        const settleResult = await this.settle({
+            book: input.book,
+            genreProfile,
+            bookRules,
+            chapterNumber: input.chapterNumber,
+            title: input.title,
+            content: input.content,
+            currentState,
+            ledger: genreProfile.numericalSystem ? ledger : "",
+            hooks,
+            chapterSummaries,
+            subplotBoard,
+            emotionalArcs,
+            characterMatrix,
+            volumeOutline,
+            selectedEvidenceBlock: governedMemoryBlocks
+                ? this.joinGovernedEvidenceBlocks(governedMemoryBlocks)
+                : undefined,
+            chapterIntent: input.chapterIntent,
+            contextPackage: input.contextPackage,
+            ruleStack: input.ruleStack,
+            validationFeedback: input.validationFeedback,
+            originalHooks: hooks,
+            originalSubplots: subplotBoard,
+            originalEmotionalArcs: emotionalArcs,
+            originalCharacterMatrix: characterMatrix,
+        });
+        const settlement = settleResult.settlement;
+        const runtimeStateArtifacts = await this.buildRuntimeStateArtifactsIfPresent(input.bookDir, settlement.runtimeStateDelta, resolvedLanguage, input.chapterNumber, input.allowReapply);
+        return {
+            chapterNumber: input.chapterNumber,
+            title: input.title,
+            content: input.content,
+            wordCount: countChapterLength(input.content, resolvedLanguage === "en" ? "en_words" : "zh_chars"),
+            preWriteCheck: "",
+            postSettlement: settlement.postSettlement,
+            runtimeStateDelta: runtimeStateArtifacts?.resolvedDelta ?? settlement.runtimeStateDelta,
+            runtimeStateSnapshot: runtimeStateArtifacts?.snapshot ?? settlement.runtimeStateSnapshot,
+            updatedState: runtimeStateArtifacts?.currentStateMarkdown ?? settlement.updatedState,
+            updatedLedger: settlement.updatedLedger,
+            updatedHooks: runtimeStateArtifacts?.hooksMarkdown ?? settlement.updatedHooks,
+            chapterSummary: settlement.runtimeStateDelta
+                ? this.renderDeltaSummaryRow(settlement.runtimeStateDelta)
+                : settlement.chapterSummary,
+            updatedChapterSummaries: runtimeStateArtifacts?.chapterSummariesMarkdown,
+            updatedSubplots: settlement.updatedSubplots,
+            updatedEmotionalArcs: settlement.updatedEmotionalArcs,
+            updatedCharacterMatrix: settlement.updatedCharacterMatrix,
+            postWriteErrors: [],
+            postWriteWarnings: [],
+            tokenUsage: settleResult.usage,
+        };
+    }
+    async settle(params) {
+        // Phase 2a: Observer — extract all facts from the chapter
+        const resolvedLang = params.book.language ?? params.genreProfile.language;
+        const observerSystem = buildObserverSystemPrompt(params.book, params.genreProfile, resolvedLang);
+        const observerUser = buildObserverUserPrompt(params.chapterNumber, params.title, params.content, resolvedLang);
+        this.logInfo(resolvedLang, {
+            zh: `阶段 2a：提取第${params.chapterNumber}章事实`,
+            en: `Phase 2a: observing facts for chapter ${params.chapterNumber}`,
+        });
+        const observerResponse = await this.chat([
+            { role: "system", content: observerSystem },
+            { role: "user", content: observerUser },
+        ], { maxTokens: 4096, temperature: 0.5 });
+        const observations = observerResponse.content;
+        // Phase 2b: Reflector — merge observations into truth files
+        this.logInfo(resolvedLang, {
+            zh: "阶段 2b：把观察结果回写到真相文件",
+            en: "Phase 2b: reflecting observations into truth files",
+        });
+        const settlerSystem = buildSettlerSystemPrompt(params.book, params.genreProfile, params.bookRules, resolvedLang);
+        const governedControlBlock = params.chapterIntent && params.contextPackage && params.ruleStack
+            ? this.buildSettlerGovernedControlBlock(params.chapterIntent, params.contextPackage, params.ruleStack, resolvedLang)
+            : undefined;
+        const settlerUser = buildSettlerUserPrompt({
+            chapterNumber: params.chapterNumber,
+            title: params.title,
+            content: params.content,
+            currentState: params.currentState,
+            ledger: params.ledger,
+            hooks: params.hooks,
+            chapterSummaries: params.chapterSummaries,
+            subplotBoard: params.subplotBoard,
+            emotionalArcs: params.emotionalArcs,
+            characterMatrix: params.characterMatrix,
+            volumeOutline: params.volumeOutline,
+            observations,
+            selectedEvidenceBlock: params.selectedEvidenceBlock,
+            governedControlBlock,
+            validationFeedback: params.validationFeedback,
+        });
+        // Settler outputs all truth files — scale with content size
+        const settlerMaxTokens = Math.max(8192, Math.ceil(params.content.length * 0.8));
+        const response = await this.chat([
+            { role: "system", content: settlerSystem },
+            { role: "user", content: settlerUser },
+        ], { maxTokens: settlerMaxTokens, temperature: 0.3 });
+        let mergedSettlement;
+        try {
+            const deltaOutput = parseSettlerDeltaOutput(response.content);
+            mergedSettlement = {
+                postSettlement: deltaOutput.postSettlement,
+                runtimeStateDelta: deltaOutput.runtimeStateDelta,
+                updatedState: "",
+                updatedLedger: "",
+                updatedHooks: "",
+                chapterSummary: "",
+                updatedSubplots: "",
+                updatedEmotionalArcs: "",
+                updatedCharacterMatrix: "",
+            };
+        }
+        catch {
+            const settlement = parseSettlementOutput(response.content, params.genreProfile);
+            mergedSettlement = governedControlBlock
+                ? {
+                    ...settlement,
+                    updatedHooks: mergeTableMarkdownByKey(params.originalHooks, settlement.updatedHooks, [0]),
+                    updatedSubplots: settlement.updatedSubplots
+                        ? mergeTableMarkdownByKey(params.originalSubplots, settlement.updatedSubplots, [0])
+                        : settlement.updatedSubplots,
+                    updatedEmotionalArcs: settlement.updatedEmotionalArcs
+                        ? mergeTableMarkdownByKey(params.originalEmotionalArcs, settlement.updatedEmotionalArcs, [0, 1])
+                        : settlement.updatedEmotionalArcs,
+                    updatedCharacterMatrix: settlement.updatedCharacterMatrix
+                        ? mergeCharacterMatrixMarkdown(params.originalCharacterMatrix, settlement.updatedCharacterMatrix)
+                        : settlement.updatedCharacterMatrix,
+                }
+                : settlement;
+        }
+        return {
+            settlement: mergedSettlement,
+            usage: response.usage,
+        };
+    }
+    async saveChapter(bookDir, output, numericalSystem = true, language = "zh") {
+        const chaptersDir = join(bookDir, "chapters");
+        const storyDir = join(bookDir, "story");
+        await mkdir(chaptersDir, { recursive: true });
+        const paddedNum = String(output.chapterNumber).padStart(4, "0");
+        const filename = `${paddedNum}_${this.sanitizeFilename(output.title)}.md`;
+        const heading = language === "en"
+            ? `# Chapter ${output.chapterNumber}: ${output.title}`
+            : `# 第${output.chapterNumber}章 ${output.title}`;
+        const chapterContent = [
+            heading,
+            "",
+            output.content,
+        ].join("\n");
+        const runtimeStateArtifacts = await this.resolveRuntimeStateArtifactsForOutput(bookDir, output, language);
+        const writes = [
+            writeFile(join(chaptersDir, filename), chapterContent, "utf-8"),
+            writeFile(join(storyDir, "current_state.md"), runtimeStateArtifacts?.currentStateMarkdown ?? output.updatedState, "utf-8"),
+            writeFile(join(storyDir, "pending_hooks.md"), runtimeStateArtifacts?.hooksMarkdown ?? output.updatedHooks, "utf-8"),
+        ];
+        if (runtimeStateArtifacts?.chapterSummariesMarkdown) {
+            writes.push(writeFile(join(storyDir, "chapter_summaries.md"), runtimeStateArtifacts.chapterSummariesMarkdown, "utf-8"));
+        }
+        if (runtimeStateArtifacts?.snapshot ?? output.runtimeStateSnapshot) {
+            writes.push(saveRuntimeStateSnapshot(bookDir, runtimeStateArtifacts?.snapshot ?? output.runtimeStateSnapshot));
+        }
+        if (numericalSystem) {
+            writes.push(writeFile(join(storyDir, "particle_ledger.md"), output.updatedLedger, "utf-8"));
+        }
+        await Promise.all(writes);
+    }
+    buildUserPrompt(params) {
+        const contextBlock = params.externalContext
+            ? `\n## 外部指令\n以下是来自外部系统的创作指令，请在本章中融入：\n\n${params.externalContext}\n`
+            : "";
+        const ledgerBlock = params.ledger
+            ? `\n## 资源账本\n${params.ledger}\n`
+            : "";
+        const summariesBlock = params.chapterSummaries !== "(文件尚未创建)"
+            ? `\n## 章节摘要（全部历史章节压缩上下文）\n${params.chapterSummaries}\n`
+            : "";
+        const subplotBlock = params.subplotBoard !== "(文件尚未创建)"
+            ? `\n## 支线进度板\n${params.subplotBoard}\n`
+            : "";
+        const emotionalBlock = params.emotionalArcs !== "(文件尚未创建)"
+            ? `\n## 情感弧线\n${params.emotionalArcs}\n`
+            : "";
+        const matrixBlock = params.characterMatrix !== "(文件尚未创建)"
+            ? `\n## 角色交互矩阵\n${params.characterMatrix}\n`
+            : "";
+        const fingerprintBlock = params.dialogueFingerprints
+            ? `\n## 角色对话指纹\n${params.dialogueFingerprints}\n`
+            : "";
+        const relevantBlock = params.relevantSummaries
+            ? `\n## 相关历史章节摘要\n${params.relevantSummaries}\n`
+            : "";
+        const canonBlock = params.parentCanon
+            ? `\n## 正传正典参照（番外写作专用）
+本书是番外作品。以下正典约束不可违反，角色不得引用超出其信息边界的信息。
+${params.parentCanon}\n`
+            : "";
+        const lengthRequirementBlock = this.buildLengthRequirementBlock(params.lengthSpec, params.language ?? "zh");
+        if (params.language === "en") {
+            return `Write chapter ${params.chapterNumber}.
+${contextBlock}
+## Current State
+${params.currentState}
+${ledgerBlock}
+## Plot Threads
+${params.hooks}
+${summariesBlock}${subplotBlock}${emotionalBlock}${matrixBlock}${fingerprintBlock}${relevantBlock}${canonBlock}
+## Recent Chapters
+${params.recentChapters || "(This is the first chapter, no previous text)"}
+
+## Worldbuilding
+${params.storyBible}
+
+## Volume Outline (Hard Constraint — Must Follow)
+${params.volumeOutline}
+
+[Outline Rules]
+- This chapter must advance the plot points assigned to it in the volume outline. Do not skip ahead or consume future plot points.
+- If the outline specifies an event for chapter N, do not resolve it early.
+- Pacing must match the outline's chapter span: if 5 chapters are planned for an arc, do not compress into 1-2.
+- PRE_WRITE_CHECK must identify which outline node this chapter covers.
+
+${lengthRequirementBlock}
+- Output PRE_WRITE_CHECK first, then the chapter
+- Output only PRE_WRITE_CHECK, CHAPTER_TITLE, and CHAPTER_CONTENT blocks`;
+        }
+        return `请续写第${params.chapterNumber}章。
+${contextBlock}
+## 当前状态卡
+${params.currentState}
+${ledgerBlock}
+## 伏笔池
+${params.hooks}
+${summariesBlock}${subplotBlock}${emotionalBlock}${matrixBlock}${fingerprintBlock}${relevantBlock}${canonBlock}
+## 最近章节
+${params.recentChapters || "(这是第一章，无前文)"}
+
+## 世界观设定
+${params.storyBible}
+
+## 卷纲（硬约束——必须遵守）
+${params.volumeOutline}
+
+【卷纲遵守规则】
+- 本章内容必须对应卷纲中当前章节范围内的剧情节点，严禁跳过或提前消耗后续节点
+- 如果卷纲指定了某个事件/转折发生在第N章，不得提前到本章完成
+- 剧情推进速度必须与卷纲规划的章节跨度匹配：如果卷纲规划某段剧情跨5章，不得在1-2章内讲完
+- PRE_WRITE_CHECK中必须明确标注本章对应的卷纲节点
+
+${lengthRequirementBlock}
+- 先输出写作自检表，再写正文
+      - 只需输出 PRE_WRITE_CHECK、CHAPTER_TITLE、CHAPTER_CONTENT 三个区块`;
+    }
+    buildGovernedUserPrompt(params) {
+        const contextSections = params.contextPackage.selectedContext
+            .map((entry) => [
+            `### ${entry.source}`,
+            `- reason: ${entry.reason}`,
+            entry.excerpt ? `- excerpt: ${entry.excerpt}` : "",
+        ].filter(Boolean).join("\n"))
+            .join("\n\n");
+        const overrideLines = params.ruleStack.activeOverrides.length > 0
+            ? params.ruleStack.activeOverrides
+                .map((override) => `- ${override.from} -> ${override.to}: ${override.reason} (${override.target})`)
+                .join("\n")
+            : "- none";
+        const diagnosticLines = params.ruleStack.sections.diagnostic.length > 0
+            ? params.ruleStack.sections.diagnostic.join(", ")
+            : "none";
+        const traceNotes = params.trace && params.trace.notes.length > 0
+            ? params.trace.notes.map((note) => `- ${note}`).join("\n")
+            : "- none";
+        const lengthRequirementBlock = this.buildLengthRequirementBlock(params.lengthSpec, params.language ?? "zh");
+        const varianceBlock = params.varianceBrief
+            ? `\n${params.varianceBrief}\n`
+            : "";
+        const selectedEvidenceBlock = params.selectedEvidenceBlock
+            ? `\n${params.selectedEvidenceBlock}\n`
+            : "";
+        const explicitHookAgenda = this.extractMarkdownSection(params.chapterIntent, "## Hook Agenda");
+        const hookAgendaBlock = explicitHookAgenda
+            ? params.language === "en"
+                ? `\n## Explicit Hook Agenda\n${explicitHookAgenda}\n`
+                : `\n## 显式 Hook Agenda\n${explicitHookAgenda}\n`
+            : "";
+        if (params.language === "en") {
+            return `Write chapter ${params.chapterNumber}.
+
+## Chapter Intent
+${params.chapterIntent}
+
+## Selected Context
+${contextSections || "(none)"}
+${selectedEvidenceBlock}
+${hookAgendaBlock}
+
+## Rule Stack
+- Hard: ${params.ruleStack.sections.hard.join(", ") || "(none)"}
+- Soft: ${params.ruleStack.sections.soft.join(", ") || "(none)"}
+- Diagnostic: ${diagnosticLines}
+
+## Active Overrides
+${overrideLines}
+
+## Trace Notes
+${traceNotes}
+
+${varianceBlock}
+${lengthRequirementBlock}
+- Output PRE_WRITE_CHECK first, then the chapter
+- Output only PRE_WRITE_CHECK, CHAPTER_TITLE, and CHAPTER_CONTENT blocks`;
+        }
+        return `请续写第${params.chapterNumber}章。
+
+## 本章意图
+${params.chapterIntent}
+
+## 已选上下文
+${contextSections || "(无)"}
+${selectedEvidenceBlock}
+${hookAgendaBlock}
+
+## 规则栈
+- 硬护栏：${params.ruleStack.sections.hard.join("、") || "(无)"}
+- 软约束：${params.ruleStack.sections.soft.join("、") || "(无)"}
+- 诊断规则：${diagnosticLines}
+
+## 当前覆盖
+${overrideLines}
+
+## 追踪说明
+${traceNotes}
+
+${varianceBlock}
+${lengthRequirementBlock}
+- 先输出写作自检表，再写正文
+- 只需输出 PRE_WRITE_CHECK、CHAPTER_TITLE、CHAPTER_CONTENT 三个区块`;
+    }
+    joinGovernedEvidenceBlocks(blocks) {
+        if (!blocks) {
+            return undefined;
+        }
+        const joined = [
+            blocks.titleHistoryBlock,
+            blocks.moodTrailBlock,
+            blocks.canonBlock,
+            blocks.hookDebtBlock,
+            blocks.hooksBlock,
+            blocks.summariesBlock,
+            blocks.volumeSummariesBlock,
+        ]
+            .filter((block) => Boolean(block))
+            .join("\n");
+        return joined || undefined;
+    }
+    extractMarkdownSection(content, heading) {
+        const lines = content.split("\n");
+        let buffer = null;
+        for (const line of lines) {
+            if (line.trim() === heading) {
+                buffer = [];
+                continue;
+            }
+            if (buffer && line.startsWith("## ") && line.trim() !== heading) {
+                break;
+            }
+            if (buffer) {
+                buffer.push(line);
+            }
+        }
+        const section = buffer?.join("\n").trim();
+        return section && section.length > 0 ? section : undefined;
+    }
+    buildSettlerGovernedControlBlock(chapterIntent, contextPackage, ruleStack, language) {
+        const selectedContext = contextPackage.selectedContext
+            .map((entry) => `- ${entry.source}: ${entry.reason}${entry.excerpt ? ` | ${entry.excerpt}` : ""}`)
+            .join("\n");
+        const overrides = ruleStack.activeOverrides.length > 0
+            ? ruleStack.activeOverrides
+                .map((override) => `- ${override.from} -> ${override.to}: ${override.reason} (${override.target})`)
+                .join("\n")
+            : "- none";
+        if (language === "en") {
+            return `\n## Chapter Control Inputs
+${chapterIntent}
+
+### Selected Context
+${selectedContext || "- none"}
+
+### Rule Stack
+- Hard guardrails: ${ruleStack.sections.hard.join(", ") || "(none)"}
+- Soft constraints: ${ruleStack.sections.soft.join(", ") || "(none)"}
+- Diagnostic rules: ${ruleStack.sections.diagnostic.join(", ") || "(none)"}
+
+### Active Overrides
+${overrides}\n`;
+        }
+        return `\n## 本章控制输入
+${chapterIntent}
+
+### 已选上下文
+${selectedContext || "- none"}
+
+### 规则栈
+- 硬护栏：${ruleStack.sections.hard.join("、") || "(无)"}
+- 软约束：${ruleStack.sections.soft.join("、") || "(无)"}
+- 诊断规则：${ruleStack.sections.diagnostic.join("、") || "(无)"}
+
+### 当前覆盖
+${overrides}\n`;
+    }
+    buildLengthRequirementBlock(lengthSpec, language) {
+        if (language === "en") {
+            return `Requirements:
+- Target length: ${lengthSpec.target} words
+- Acceptable range: ${lengthSpec.softMin}-${lengthSpec.softMax} words`;
+        }
+        return `要求：
+- 目标字数：${lengthSpec.target}字
+- 允许区间：${lengthSpec.softMin}-${lengthSpec.softMax}字`;
+    }
+    async loadRecentChapters(bookDir, currentChapter, count = 1) {
+        const chaptersDir = join(bookDir, "chapters");
+        try {
+            const files = await readdir(chaptersDir);
+            const mdFiles = files
+                .filter((f) => f.endsWith(".md") && !f.startsWith("index"))
+                .sort()
+                .slice(-count);
+            if (mdFiles.length === 0)
+                return "";
+            const contents = await Promise.all(mdFiles.map(async (f) => {
+                const content = await readFile(join(chaptersDir, f), "utf-8");
+                return content;
+            }));
+            return contents.join("\n\n---\n\n");
+        }
+        catch {
+            return "";
+        }
+    }
+    async readFileOrDefault(path) {
+        try {
+            return await readFile(path, "utf-8");
+        }
+        catch {
+            return "(文件尚未创建)";
+        }
+    }
+    /** Save new truth files (summaries, subplots, emotional arcs, character matrix). */
+    async saveNewTruthFiles(bookDir, output, language = "zh") {
+        const storyDir = join(bookDir, "story");
+        const writes = [];
+        // Append chapter summary to chapter_summaries.md
+        if (!output.runtimeStateDelta && output.updatedChapterSummaries) {
+            writes.push(writeFile(join(storyDir, "chapter_summaries.md"), output.updatedChapterSummaries, "utf-8"));
+        }
+        else if (!output.runtimeStateDelta && output.chapterSummary) {
+            writes.push(this.appendChapterSummary(storyDir, output.chapterSummary, language));
+        }
+        // Overwrite subplot board
+        if (output.updatedSubplots) {
+            writes.push(writeFile(join(storyDir, "subplot_board.md"), output.updatedSubplots, "utf-8"));
+        }
+        // Overwrite emotional arcs
+        if (output.updatedEmotionalArcs) {
+            writes.push(writeFile(join(storyDir, "emotional_arcs.md"), output.updatedEmotionalArcs, "utf-8"));
+        }
+        // Overwrite character matrix
+        if (output.updatedCharacterMatrix) {
+            writes.push(writeFile(join(storyDir, "character_matrix.md"), output.updatedCharacterMatrix, "utf-8"));
+        }
+        await Promise.all(writes);
+    }
+    renderDeltaSummaryRow(delta) {
+        if (!delta.chapterSummary)
+            return "";
+        const summary = delta.chapterSummary;
+        const row = [
+            summary.chapter,
+            summary.title,
+            summary.characters,
+            summary.events,
+            summary.stateChanges,
+            summary.hookActivity,
+            summary.mood,
+            summary.chapterType,
+        ].map((value) => String(value).replace(/\|/g, "\\|").trim()).join(" | ");
+        return `| ${row} |`;
+    }
+    normalizeRuntimeStateDeltaChapter(delta, authoritativeChapterNumber) {
+        const hookOps = delta.hookOps ?? {
+            upsert: [],
+            mention: [],
+            resolve: [],
+            defer: [],
+        };
+        let changed = delta.chapter !== authoritativeChapterNumber;
+        const normalizedUpserts = hookOps.upsert.map((hook) => {
+            const startChapter = Math.min(hook.startChapter, authoritativeChapterNumber);
+            const lastAdvancedChapter = Math.min(hook.lastAdvancedChapter, authoritativeChapterNumber);
+            if (startChapter !== hook.startChapter || lastAdvancedChapter !== hook.lastAdvancedChapter) {
+                changed = true;
+            }
+            if (startChapter === hook.startChapter && lastAdvancedChapter === hook.lastAdvancedChapter) {
+                return hook;
+            }
+            return {
+                ...hook,
+                startChapter,
+                lastAdvancedChapter,
+            };
+        });
+        if (delta.chapterSummary?.chapter !== undefined && delta.chapterSummary.chapter !== authoritativeChapterNumber) {
+            changed = true;
+        }
+        if (!changed) {
+            return delta;
+        }
+        return {
+            ...delta,
+            chapter: authoritativeChapterNumber,
+            hookOps: {
+                ...hookOps,
+                upsert: normalizedUpserts,
+            },
+            chapterSummary: delta.chapterSummary
+                ? {
+                    ...delta.chapterSummary,
+                    chapter: authoritativeChapterNumber,
+                }
+                : undefined,
+        };
+    }
+    async buildRuntimeStateArtifactsIfPresent(bookDir, delta, language, authoritativeChapterNumber, allowReapply) {
+        if (!delta)
+            return null;
+        const safeDelta = authoritativeChapterNumber === undefined
+            ? delta
+            : this.normalizeRuntimeStateDeltaChapter(delta, authoritativeChapterNumber);
+        return buildRuntimeStateArtifacts({
+            bookDir,
+            delta: safeDelta,
+            language,
+            allowReapply,
+        });
+    }
+    async resolveRuntimeStateArtifactsForOutput(bookDir, output, language) {
+        if (!output.runtimeStateDelta)
+            return null;
+        const safeDelta = this.normalizeRuntimeStateDeltaChapter(output.runtimeStateDelta, output.chapterNumber);
+        if (safeDelta === output.runtimeStateDelta
+            && output.runtimeStateSnapshot
+            && output.updatedChapterSummaries
+            && output.updatedState
+            && output.updatedHooks) {
+            return {
+                snapshot: output.runtimeStateSnapshot,
+                resolvedDelta: safeDelta,
+                currentStateMarkdown: output.updatedState,
+                hooksMarkdown: output.updatedHooks,
+                chapterSummariesMarkdown: output.updatedChapterSummaries,
+            };
+        }
+        return buildRuntimeStateArtifacts({
+            bookDir,
+            delta: safeDelta,
+            language,
+        });
+    }
+    async appendChapterSummary(storyDir, summary, language) {
+        const summaryPath = join(storyDir, "chapter_summaries.md");
+        let existing = "";
+        try {
+            existing = await readFile(summaryPath, "utf-8");
+        }
+        catch {
+            // File doesn't exist yet — start with header
+            existing = language === "en"
+                ? "# Chapter Summaries\n\n| Chapter | Title | Characters | Key Events | State Changes | Hook Activity | Mood | Chapter Type |\n| --- | --- | --- | --- | --- | --- | --- | --- |\n"
+                : "# 章节摘要\n\n| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |\n|------|------|----------|----------|----------|----------|----------|----------|\n";
+        }
+        // Extract only the data row(s) from the summary (skip header lines)
+        const dataRows = summary
+            .split("\n")
+            .filter((line) => line.startsWith("|")
+            && !line.startsWith("| 章节")
+            && !line.startsWith("| Chapter")
+            && !line.startsWith("|--")
+            && !line.startsWith("| ---"))
+            .join("\n");
+        if (dataRows) {
+            // Deduplicate: remove existing rows with the same chapter number before appending
+            const newChapterNums = new Set(dataRows.split("\n")
+                .map((line) => line.split("|")[1]?.trim())
+                .filter((ch) => ch && /^\d+$/.test(ch)));
+            const deduped = existing
+                .split("\n")
+                .filter((line) => {
+                if (!line.startsWith("|"))
+                    return true;
+                const chNum = line.split("|")[1]?.trim();
+                return !chNum || !newChapterNums.has(chNum);
+            })
+                .join("\n");
+            await writeFile(summaryPath, `${deduped.trimEnd()}\n${dataRows}\n`, "utf-8");
+        }
+    }
+    buildStyleFingerprint(styleProfileRaw) {
+        if (!styleProfileRaw || styleProfileRaw === "(文件尚未创建)")
+            return undefined;
+        try {
+            const profile = JSON.parse(styleProfileRaw);
+            const lines = [];
+            if (profile.avgSentenceLength)
+                lines.push(`- 平均句长：${profile.avgSentenceLength}字`);
+            if (profile.sentenceLengthStdDev)
+                lines.push(`- 句长标准差：${profile.sentenceLengthStdDev}`);
+            if (profile.avgParagraphLength)
+                lines.push(`- 平均段落长度：${profile.avgParagraphLength}字`);
+            if (profile.paragraphLengthRange)
+                lines.push(`- 段落长度范围：${profile.paragraphLengthRange.min}-${profile.paragraphLengthRange.max}字`);
+            if (profile.vocabularyDiversity)
+                lines.push(`- 词汇多样性(TTR)：${profile.vocabularyDiversity}`);
+            if (profile.topPatterns?.length > 0)
+                lines.push(`- 高频句式：${profile.topPatterns.join("、")}`);
+            if (profile.rhetoricalFeatures?.length > 0)
+                lines.push(`- 修辞特征：${profile.rhetoricalFeatures.join("、")}`);
+            return lines.length > 0 ? lines.join("\n") : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Extract dialogue fingerprints from recent chapters.
+     * For each character with multiple dialogue lines, compute speaking style markers.
+     */
+    extractDialogueFingerprints(recentChapters, _storyBible) {
+        if (!recentChapters)
+            return "";
+        // Match dialogue patterns:
+        // Chinese: "speaker说道：" or dialogue in ""「」
+        // English: "dialogue," speaker said. or "dialogue."
+        const dialogueRegex = /(?:(.{1,6})(?:说道|道|喝道|冷声道|笑道|怒道|低声道|大声道|喝骂道|冷笑道|沉声道|喊道|叫道|问道|答道)\s*[：:]\s*["""「]([^"""」]+)["""」])|["""「]([^"""」]{2,})["""」]|"([^"]{2,})"/g;
+        const characterDialogues = new Map();
+        let match;
+        while ((match = dialogueRegex.exec(recentChapters)) !== null) {
+            const speaker = match[1]?.trim();
+            const line = match[2] ?? match[3] ?? "";
+            if (speaker && line.length > 1) {
+                const existing = characterDialogues.get(speaker) ?? [];
+                characterDialogues.set(speaker, [...existing, line]);
+            }
+        }
+        // Only include characters with >=2 dialogue lines
+        const fingerprints = [];
+        for (const [character, lines] of characterDialogues) {
+            if (lines.length < 2)
+                continue;
+            const avgLen = Math.round(lines.reduce((sum, l) => sum + l.length, 0) / lines.length);
+            const isShort = avgLen < 15;
+            // Find frequent words/phrases (2+ occurrences)
+            const wordCounts = new Map();
+            for (const line of lines) {
+                // Extract 2-3 char segments as "words"
+                for (let i = 0; i < line.length - 1; i++) {
+                    const bigram = line.slice(i, i + 2);
+                    wordCounts.set(bigram, (wordCounts.get(bigram) ?? 0) + 1);
+                }
+            }
+            const frequentWords = [...wordCounts.entries()]
+                .filter(([, count]) => count >= 2)
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 3)
+                .map(([w]) => `「${w}」`);
+            // Detect style markers
+            const markers = [];
+            if (isShort)
+                markers.push("短句为主");
+            else
+                markers.push("长句为主");
+            const questionCount = lines.filter((l) => l.includes("？") || l.includes("?")).length;
+            if (questionCount > lines.length * 0.3)
+                markers.push("反问多");
+            if (frequentWords.length > 0)
+                markers.push(`常用${frequentWords.join("")}`);
+            fingerprints.push(`${character}：${markers.join("，")}`);
+        }
+        return fingerprints.length > 0 ? fingerprints.join("；") : "";
+    }
+    /**
+     * Find relevant chapter summaries based on volume outline context.
+     * Extracts character names and hook IDs from the current volume's outline,
+     * then searches chapter summaries for matching entries.
+     */
+    findRelevantSummaries(chapterSummaries, volumeOutline, chapterNumber) {
+        if (!chapterSummaries || chapterSummaries === "(文件尚未创建)")
+            return "";
+        if (!volumeOutline || volumeOutline === "(文件尚未创建)")
+            return "";
+        // Extract character names from volume outline (Chinese name patterns)
+        const nameRegex = /[\u4e00-\u9fff]{2,4}(?=[，、。：]|$)/g;
+        const outlineNames = new Set();
+        let nameMatch;
+        while ((nameMatch = nameRegex.exec(volumeOutline)) !== null) {
+            outlineNames.add(nameMatch[0]);
+        }
+        // Extract hook IDs from volume outline
+        const hookRegex = /H\d{2,}/g;
+        const hookIds = new Set();
+        let hookMatch;
+        while ((hookMatch = hookRegex.exec(volumeOutline)) !== null) {
+            hookIds.add(hookMatch[0]);
+        }
+        if (outlineNames.size === 0 && hookIds.size === 0)
+            return "";
+        // Search chapter summaries for matching rows
+        const rows = chapterSummaries.split("\n").filter((line) => line.startsWith("|") && !line.startsWith("| 章节") && !line.startsWith("|--") && !line.startsWith("| -"));
+        const matchedRows = rows.filter((row) => {
+            for (const name of outlineNames) {
+                if (row.includes(name))
+                    return true;
+            }
+            for (const hookId of hookIds) {
+                if (row.includes(hookId))
+                    return true;
+            }
+            return false;
+        });
+        // Skip only the last chapter (its full text is already in context via loadRecentChapters)
+        const filteredRows = matchedRows.filter((row) => {
+            const chNumMatch = row.match(/\|\s*(\d+)\s*\|/);
+            if (!chNumMatch)
+                return true;
+            const num = parseInt(chNumMatch[1], 10);
+            return num < chapterNumber - 1;
+        });
+        return filteredRows.length > 0 ? filteredRows.join("\n") : "";
+    }
+    sanitizeFilename(title) {
+        return title
+            .replace(/[/\\?%*:|"<>]/g, "")
+            .replace(/\s+/g, "_")
+            .slice(0, 50);
+    }
+}
+//# sourceMappingURL=writer.js.map