@actalk/inkos-core 0.5.1 → 0.6.0

package/dist/pipeline/runner.js

@@ -1,26 +1,72 @@
 import { chatCompletion, createLLMClient } from "../llm/provider.js";
 import { ArchitectAgent } from "../agents/architect.js";
+import { PlannerAgent } from "../agents/planner.js";
+import { ComposerAgent } from "../agents/composer.js";
 import { WriterAgent } from "../agents/writer.js";
+import { LengthNormalizerAgent } from "../agents/length-normalizer.js";
 import { ChapterAnalyzerAgent } from "../agents/chapter-analyzer.js";
 import { ContinuityAuditor } from "../agents/continuity.js";
-import { ReviserAgent } from "../agents/reviser.js";
+import { ReviserAgent, DEFAULT_REVISE_MODE } from "../agents/reviser.js";
 import { StateValidatorAgent } from "../agents/state-validator.js";
 import { RadarAgent } from "../agents/radar.js";
 import { readGenreProfile } from "../agents/rules-reader.js";
 import { analyzeAITells } from "../agents/ai-tells.js";
 import { analyzeSensitiveWords } from "../agents/sensitive-words.js";
 import { StateManager } from "../state/manager.js";
+import { MemoryDB } from "../state/memory-db.js";
 import { dispatchNotification, dispatchWebhookEvent } from "../notify/dispatcher.js";
-import { readFile, readdir, writeFile, mkdir } from "node:fs/promises";
+import { ChapterIntentSchema } from "../models/input-governance.js";
+import { buildLengthSpec, countChapterLength, formatLengthCount, isOutsideHardRange, isOutsideSoftRange, resolveLengthCountingMode } from "../utils/length-metrics.js";
+import { analyzeLongSpanFatigue } from "../utils/long-span-fatigue.js";
+import { loadNarrativeMemorySeed, loadSnapshotCurrentStateFacts } from "../state/runtime-state-store.js";
+import { rewriteStructuredStateFromMarkdown } from "../state/state-bootstrap.js";
+import { readFile, readdir, writeFile, mkdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 export class PipelineRunner {
     state;
     config;
     agentClients = new Map();
+    memoryIndexFallbackWarned = false;
     constructor(config) {
         this.config = config;
         this.state = new StateManager(config.projectRoot);
     }
+    localize(language, messages) {
+        return language === "en" ? messages.en : messages.zh;
+    }
+    async resolveBookLanguage(book) {
+        if (book.language) {
+            return book.language;
+        }
+        try {
+            const { profile } = await this.loadGenreProfile(book.genre);
+            return profile.language;
+        }
+        catch {
+            return "zh";
+        }
+    }
+    async resolveBookLanguageById(bookId) {
+        try {
+            const book = await this.state.loadBookConfig(bookId);
+            return await this.resolveBookLanguage(book);
+        }
+        catch {
+            return "zh";
+        }
+    }
+    languageFromLengthSpec(lengthSpec) {
+        return lengthSpec.countingMode === "en_words" ? "en" : "zh";
+    }
+    logStage(language, message) {
+        this.config.logger?.info(`${this.localize(language, { zh: "阶段：", en: "Stage: " })}${this.localize(language, message)}`);
+    }
+    logInfo(language, message) {
+        this.config.logger?.info(this.localize(language, message));
+    }
+    logWarn(language, message) {
+        this.config.logger?.warn(this.localize(language, message));
+    }
     agentCtx(bookId) {
         return {
             client: this.config.client,
@@ -102,14 +148,21 @@ export class PipelineRunner {
     async initBook(book) {
         const architect = new ArchitectAgent(this.agentCtxFor("architect", book.id));
         const bookDir = this.state.bookDir(book.id);
+        const stageLanguage = await this.resolveBookLanguage(book);
+        this.logStage(stageLanguage, { zh: "保存书籍配置", en: "saving book config" });
         await this.state.saveBookConfig(book.id, book);
+        this.logStage(stageLanguage, { zh: "生成基础设定", en: "generating foundation" });
         const { profile: gp } = await this.loadGenreProfile(book.genre);
         const foundation = await architect.generateFoundation(book, this.config.externalContext);
-        await architect.writeFoundationFiles(bookDir, foundation, gp.numericalSystem);
+        this.logStage(stageLanguage, { zh: "写入基础设定文件", en: "writing foundation files" });
+        await architect.writeFoundationFiles(bookDir, foundation, gp.numericalSystem, book.language ?? gp.language);
+        this.logStage(stageLanguage, { zh: "初始化控制文档", en: "initializing control documents" });
+        await this.state.ensureControlDocuments(book.id, this.config.externalContext);
         // Ensure chapters directory exists (prevents ENOENT if init was previously interrupted)
         await mkdir(join(bookDir, "chapters"), { recursive: true });
         await this.state.saveChapterIndex(book.id, []);
         // Snapshot initial state so rewrite of chapter 1 can restore to pre-chapter state
+        this.logStage(stageLanguage, { zh: "创建初始快照", en: "creating initial snapshot" });
         await this.state.snapshotState(book.id, 0);
     }
     /** Import external source material and generate fanfic_canon.md */
@@ -126,15 +179,23 @@ export class PipelineRunner {
     /** One-step fanfic book creation: create book + import canon + generate foundation */
     async initFanficBook(book, sourceText, sourceName, fanficMode) {
         const bookDir = this.state.bookDir(book.id);
+        const stageLanguage = await this.resolveBookLanguage(book);
+        this.logStage(stageLanguage, { zh: "保存书籍配置", en: "saving book config" });
         await this.state.saveBookConfig(book.id, book);
         // Step 1: Import source material → fanfic_canon.md
+        this.logStage(stageLanguage, { zh: "导入同人正典", en: "importing fanfic canon" });
         const fanficCanon = await this.importFanficCanon(book.id, sourceText, sourceName, fanficMode);
         // Step 2: Generate foundation from fanfic canon (not from scratch)
         const architect = new ArchitectAgent(this.agentCtxFor("architect", book.id));
+        this.logStage(stageLanguage, { zh: "生成同人基础设定", en: "generating fanfic foundation" });
         const { profile: gp } = await this.loadGenreProfile(book.genre);
         const foundation = await architect.generateFanficFoundation(book, fanficCanon, fanficMode);
-        await architect.writeFoundationFiles(bookDir, foundation, gp.numericalSystem);
+        this.logStage(stageLanguage, { zh: "写入基础设定文件", en: "writing foundation files" });
+        await architect.writeFoundationFiles(bookDir, foundation, gp.numericalSystem, book.language ?? gp.language);
+        this.logStage(stageLanguage, { zh: "初始化控制文档", en: "initializing control documents" });
+        await this.state.ensureControlDocuments(book.id, this.config.externalContext);
         // Step 3: Initialize chapters directory + snapshot
+        this.logStage(stageLanguage, { zh: "创建初始快照", en: "creating initial snapshot" });
         await mkdir(join(bookDir, "chapters"), { recursive: true });
         await this.state.saveChapterIndex(book.id, []);
         await this.state.snapshotState(book.id, 0);
@@ -143,58 +204,147 @@ export class PipelineRunner {
     async writeDraft(bookId, context, wordCount) {
         const releaseLock = await this.state.acquireBookLock(bookId);
         try {
+            await this.state.ensureControlDocuments(bookId);
             const book = await this.state.loadBookConfig(bookId);
             const bookDir = this.state.bookDir(bookId);
             const chapterNumber = await this.state.getNextChapterNumber(bookId);
+            const stageLanguage = await this.resolveBookLanguage(book);
+            this.logStage(stageLanguage, { zh: "准备章节输入", en: "preparing chapter inputs" });
+            const writeInput = await this.prepareWriteInput(book, bookDir, chapterNumber, context ?? this.config.externalContext);
             const { profile: gp } = await this.loadGenreProfile(book.genre);
+            const lengthSpec = buildLengthSpec(wordCount ?? book.chapterWordCount, book.language ?? gp.language);
             const writer = new WriterAgent(this.agentCtxFor("writer", bookId));
+            this.logStage(stageLanguage, { zh: "撰写章节草稿", en: "writing chapter draft" });
             const output = await writer.writeChapter({
                 book,
                 bookDir,
                 chapterNumber,
-                externalContext: context ?? this.config.externalContext,
+                ...writeInput,
+                lengthSpec,
                 ...(wordCount ? { wordCountOverride: wordCount } : {}),
             });
+            const writerCount = countChapterLength(output.content, lengthSpec.countingMode);
+            let totalUsage = output.tokenUsage ?? {
+                promptTokens: 0,
+                completionTokens: 0,
+                totalTokens: 0,
+            };
+            const normalizedDraft = await this.normalizeDraftLengthIfNeeded({
+                bookId,
+                chapterNumber,
+                chapterContent: output.content,
+                lengthSpec,
+                chapterIntent: writeInput.chapterIntent,
+            });
+            totalUsage = PipelineRunner.addUsage(totalUsage, normalizedDraft.tokenUsage);
+            const draftOutput = {
+                ...output,
+                content: normalizedDraft.content,
+                wordCount: normalizedDraft.wordCount,
+                tokenUsage: totalUsage,
+            };
+            const lengthWarnings = this.buildLengthWarnings(chapterNumber, draftOutput.wordCount, lengthSpec);
+            const lengthTelemetry = this.buildLengthTelemetry({
+                lengthSpec,
+                writerCount,
+                postWriterNormalizeCount: normalizedDraft.wordCount,
+                postReviseCount: 0,
+                finalCount: draftOutput.wordCount,
+                normalizeApplied: normalizedDraft.applied,
+                lengthWarning: lengthWarnings.length > 0,
+            });
+            this.logLengthWarnings(lengthWarnings);
             // Save chapter file
             const chaptersDir = join(bookDir, "chapters");
             const paddedNum = String(chapterNumber).padStart(4, "0");
-            const sanitized = output.title.replace(/[/\\?%*:|"<>]/g, "").replace(/\s+/g, "_").slice(0, 50);
+            const sanitized = draftOutput.title.replace(/[/\\?%*:|"<>]/g, "").replace(/\s+/g, "_").slice(0, 50);
             const filename = `${paddedNum}_${sanitized}.md`;
             const filePath = join(chaptersDir, filename);
             const resolvedLang = book.language ?? gp.language;
             const heading = resolvedLang === "en"
-                ? `# Chapter ${chapterNumber}: ${output.title}`
-                : `# 第${chapterNumber}章 ${output.title}`;
-            await writeFile(filePath, `${heading}\n\n${output.content}`, "utf-8");
+                ? `# Chapter ${chapterNumber}: ${draftOutput.title}`
+                : `# 第${chapterNumber}章 ${draftOutput.title}`;
+            await writeFile(filePath, `${heading}\n\n${draftOutput.content}`, "utf-8");
             // Save truth files
-            await writer.saveChapter(bookDir, output, gp.numericalSystem, resolvedLang);
-            await writer.saveNewTruthFiles(bookDir, output);
+            this.logStage(stageLanguage, { zh: "落盘草稿与真相文件", en: "persisting draft and truth files" });
+            await writer.saveChapter(bookDir, draftOutput, gp.numericalSystem, resolvedLang);
+            await writer.saveNewTruthFiles(bookDir, draftOutput, resolvedLang);
+            await this.syncLegacyStructuredStateFromMarkdown(bookDir, chapterNumber, draftOutput);
+            await this.syncNarrativeMemoryIndex(bookId);
             // Update index
             const existingIndex = await this.state.loadChapterIndex(bookId);
             const now = new Date().toISOString();
             const newEntry = {
                 number: chapterNumber,
-                title: output.title,
+                title: draftOutput.title,
                 status: "drafted",
-                wordCount: output.wordCount,
+                wordCount: draftOutput.wordCount,
                 createdAt: now,
                 updatedAt: now,
                 auditIssues: [],
-                ...(output.tokenUsage ? { tokenUsage: output.tokenUsage } : {}),
+                lengthWarnings,
+                lengthTelemetry,
+                ...(draftOutput.tokenUsage ? { tokenUsage: draftOutput.tokenUsage } : {}),
             };
             await this.state.saveChapterIndex(bookId, [...existingIndex, newEntry]);
+            await this.markBookActiveIfNeeded(bookId);
             // Snapshot
+            this.logStage(stageLanguage, { zh: "更新章节索引与快照", en: "updating chapter index and snapshots" });
             await this.state.snapshotState(bookId, chapterNumber);
+            await this.syncCurrentStateFactHistory(bookId, chapterNumber);
             await this.emitWebhook("chapter-complete", bookId, chapterNumber, {
-                title: output.title,
-                wordCount: output.wordCount,
+                title: draftOutput.title,
+                wordCount: draftOutput.wordCount,
             });
-            return { chapterNumber, title: output.title, wordCount: output.wordCount, filePath, tokenUsage: output.tokenUsage };
+            return {
+                chapterNumber,
+                title: draftOutput.title,
+                wordCount: draftOutput.wordCount,
+                filePath,
+                lengthWarnings,
+                lengthTelemetry,
+                tokenUsage: draftOutput.tokenUsage,
+            };
         }
         finally {
             await releaseLock();
         }
     }
+    async planChapter(bookId, context) {
+        await this.state.ensureControlDocuments(bookId);
+        const book = await this.state.loadBookConfig(bookId);
+        const bookDir = this.state.bookDir(bookId);
+        const chapterNumber = await this.state.getNextChapterNumber(bookId);
+        const stageLanguage = await this.resolveBookLanguage(book);
+        this.logStage(stageLanguage, { zh: "规划下一章意图", en: "planning next chapter intent" });
+        const { plan } = await this.createGovernedArtifacts(book, bookDir, chapterNumber, context ?? this.config.externalContext, { reuseExistingIntentWhenContextMissing: false });
+        return {
+            bookId,
+            chapterNumber,
+            intentPath: this.relativeToBookDir(bookDir, plan.runtimePath),
+            goal: plan.intent.goal,
+            conflicts: plan.intent.conflicts.map((conflict) => `${conflict.type}: ${conflict.resolution}`),
+        };
+    }
+    async composeChapter(bookId, context) {
+        await this.state.ensureControlDocuments(bookId);
+        const book = await this.state.loadBookConfig(bookId);
+        const bookDir = this.state.bookDir(bookId);
+        const chapterNumber = await this.state.getNextChapterNumber(bookId);
+        const stageLanguage = await this.resolveBookLanguage(book);
+        this.logStage(stageLanguage, { zh: "组装章节运行时上下文", en: "composing chapter runtime context" });
+        const { plan, composed } = await this.createGovernedArtifacts(book, bookDir, chapterNumber, context ?? this.config.externalContext, { reuseExistingIntentWhenContextMissing: true });
+        return {
+            bookId,
+            chapterNumber,
+            intentPath: this.relativeToBookDir(bookDir, plan.runtimePath),
+            goal: plan.intent.goal,
+            conflicts: plan.intent.conflicts.map((conflict) => `${conflict.type}: ${conflict.resolution}`),
+            contextPath: this.relativeToBookDir(bookDir, composed.contextPath),
+            ruleStackPath: this.relativeToBookDir(bookDir, composed.ruleStackPath),
+            tracePath: this.relativeToBookDir(bookDir, composed.tracePath),
+        };
+    }
     /** Audit the latest (or specified) chapter. Read-only, no lock needed. */
     async auditDraft(bookId, chapterNumber) {
         const book = await this.state.loadBookConfig(bookId);
@@ -205,22 +355,21 @@ export class PipelineRunner {
         }
         const content = await this.readChapterContent(bookDir, targetChapter);
         const auditor = new ContinuityAuditor(this.agentCtxFor("auditor", bookId));
-        const llmResult = await auditor.auditChapter(bookDir, content, targetChapter, book.genre);
-        // Merge rule-based AI-tell detection
-        const aiTells = analyzeAITells(content);
-        // Merge sensitive word detection
-        const sensitiveResult = analyzeSensitiveWords(content);
-        const hasBlockedWords = sensitiveResult.found.some((f) => f.severity === "block");
-        const mergedIssues = [
-            ...llmResult.issues,
-            ...aiTells.issues,
-            ...sensitiveResult.issues,
-        ];
-        const result = {
-            passed: hasBlockedWords ? false : llmResult.passed,
-            issues: mergedIssues,
-            summary: llmResult.summary,
-        };
+        const { profile: gp } = await this.loadGenreProfile(book.genre);
+        const language = book.language ?? gp.language;
+        this.logStage(language, {
+            zh: `审计第${targetChapter}章`,
+            en: `auditing chapter ${targetChapter}`,
+        });
+        const evaluation = await this.evaluateMergedAudit({
+            auditor,
+            book,
+            bookDir,
+            chapterContent: content,
+            chapterNumber: targetChapter,
+            language,
+        });
+        const result = evaluation.auditResult;
         // Update index with audit result
         const index = await this.state.loadChapterIndex(bookId);
         const updated = index.map((ch) => ch.number === targetChapter
@@ -236,7 +385,7 @@ export class PipelineRunner {
         return { ...result, chapterNumber: targetChapter };
     }
     /** Revise the latest (or specified) chapter based on audit issues. */
-    async reviseDraft(bookId, chapterNumber, mode = "rewrite") {
+    async reviseDraft(bookId, chapterNumber, mode = DEFAULT_REVISE_MODE) {
         const releaseLock = await this.state.acquireBookLock(bookId);
         try {
             const book = await this.state.loadBookConfig(bookId);
@@ -245,7 +394,12 @@ export class PipelineRunner {
             if (targetChapter < 1) {
                 throw new Error(`No chapters to revise for "${bookId}"`);
             }
+            const stageLanguage = await this.resolveBookLanguage(book);
             // Read the current audit issues from index
+            this.logStage(stageLanguage, {
+                zh: `加载第${targetChapter}章修订上下文`,
+                en: `loading revision context for chapter ${targetChapter}`,
+            });
             const index = await this.state.loadChapterIndex(bookId);
             const chapterMeta = index.find((ch) => ch.number === targetChapter);
             if (!chapterMeta) {
@@ -254,17 +408,129 @@ export class PipelineRunner {
             // Re-audit to get structured issues (index only stores strings)
             const content = await this.readChapterContent(bookDir, targetChapter);
             const auditor = new ContinuityAuditor(this.agentCtxFor("auditor", bookId));
-            const auditResult = await auditor.auditChapter(bookDir, content, targetChapter, book.genre);
-            if (auditResult.passed && auditResult.issues.filter(i => i.severity === "warning" || i.severity === "critical").length === 0) {
-                return { chapterNumber: targetChapter, wordCount: content.length, fixedIssues: [] };
-            }
             const { profile: gp } = await this.loadGenreProfile(book.genre);
+            const language = book.language ?? gp.language;
+            const countingMode = resolveLengthCountingMode(language);
+            const reviseControlInput = (this.config.inputGovernanceMode ?? "v2") === "legacy"
+                ? undefined
+                : await this.createGovernedArtifacts(book, bookDir, targetChapter, undefined, { reuseExistingIntentWhenContextMissing: true });
+            const preRevision = await this.evaluateMergedAudit({
+                auditor,
+                book,
+                bookDir,
+                chapterContent: content,
+                chapterNumber: targetChapter,
+                language,
+                auditOptions: reviseControlInput
+                    ? {
+                        chapterIntent: reviseControlInput.plan.intentMarkdown,
+                        contextPackage: reviseControlInput.composed.contextPackage,
+                        ruleStack: reviseControlInput.composed.ruleStack,
+                    }
+                    : undefined,
+            });
+            if (preRevision.blockingCount === 0 && preRevision.aiTellCount === 0) {
+                return {
+                    chapterNumber: targetChapter,
+                    wordCount: countChapterLength(content, countingMode),
+                    fixedIssues: [],
+                    applied: false,
+                    status: "unchanged",
+                    skippedReason: "No warning, critical, or AI-tell issues to fix.",
+                };
+            }
+            const chapterLengthTarget = chapterMeta.lengthTelemetry?.target ?? book.chapterWordCount;
+            const lengthLanguage = chapterMeta.lengthTelemetry?.countingMode === "en_words"
+                ? "en"
+                : language;
+            const lengthSpec = buildLengthSpec(chapterLengthTarget, lengthLanguage);
             const reviser = new ReviserAgent(this.agentCtxFor("reviser", bookId));
-            const reviseOutput = await reviser.reviseChapter(bookDir, content, targetChapter, auditResult.issues, mode, book.genre);
+            this.logStage(stageLanguage, {
+                zh: `修订第${targetChapter}章`,
+                en: `revising chapter ${targetChapter}`,
+            });
+            const reviseOutput = await reviser.reviseChapter(bookDir, content, targetChapter, preRevision.auditResult.issues, mode, book.genre, reviseControlInput
+                ? {
+                    chapterIntent: reviseControlInput.plan.intentMarkdown,
+                    contextPackage: reviseControlInput.composed.contextPackage,
+                    ruleStack: reviseControlInput.composed.ruleStack,
+                    lengthSpec,
+                }
+                : { lengthSpec });
             if (reviseOutput.revisedContent.length === 0) {
                 throw new Error("Reviser returned empty content");
             }
+            const normalizedRevision = await this.normalizeDraftLengthIfNeeded({
+                bookId,
+                chapterNumber: targetChapter,
+                chapterContent: reviseOutput.revisedContent,
+                lengthSpec,
+            });
+            const postRevision = await this.evaluateMergedAudit({
+                auditor,
+                book,
+                bookDir,
+                chapterContent: normalizedRevision.content,
+                chapterNumber: targetChapter,
+                language,
+                auditOptions: reviseControlInput
+                    ? {
+                        temperature: 0,
+                        chapterIntent: reviseControlInput.plan.intentMarkdown,
+                        contextPackage: reviseControlInput.composed.contextPackage,
+                        ruleStack: reviseControlInput.composed.ruleStack,
+                        truthFileOverrides: {
+                            currentState: reviseOutput.updatedState !== "(状态卡未更新)" ? reviseOutput.updatedState : undefined,
+                            ledger: reviseOutput.updatedLedger !== "(账本未更新)" ? reviseOutput.updatedLedger : undefined,
+                            hooks: reviseOutput.updatedHooks !== "(伏笔池未更新)" ? reviseOutput.updatedHooks : undefined,
+                        },
+                    }
+                    : {
+                        temperature: 0,
+                        truthFileOverrides: {
+                            currentState: reviseOutput.updatedState !== "(状态卡未更新)" ? reviseOutput.updatedState : undefined,
+                            ledger: reviseOutput.updatedLedger !== "(账本未更新)" ? reviseOutput.updatedLedger : undefined,
+                            hooks: reviseOutput.updatedHooks !== "(伏笔池未更新)" ? reviseOutput.updatedHooks : undefined,
+                        },
+                    },
+            });
+            const effectivePostRevision = this.restoreActionableAuditIfLost(preRevision, postRevision);
+            const revisionBaseCount = countChapterLength(content, lengthSpec.countingMode);
+            const lengthWarnings = this.buildLengthWarnings(targetChapter, normalizedRevision.wordCount, lengthSpec);
+            const lengthTelemetry = this.buildLengthTelemetry({
+                lengthSpec,
+                writerCount: revisionBaseCount,
+                postWriterNormalizeCount: 0,
+                postReviseCount: normalizedRevision.wordCount,
+                finalCount: normalizedRevision.wordCount,
+                normalizeApplied: normalizedRevision.applied,
+                lengthWarning: lengthWarnings.length > 0,
+            });
+            const improvedBlocking = effectivePostRevision.blockingCount < preRevision.blockingCount;
+            const improvedAITells = effectivePostRevision.aiTellCount < preRevision.aiTellCount;
+            const blockingDidNotWorsen = effectivePostRevision.blockingCount <= preRevision.blockingCount;
+            const criticalDidNotWorsen = effectivePostRevision.criticalCount <= preRevision.criticalCount;
+            const aiDidNotWorsen = effectivePostRevision.aiTellCount <= preRevision.aiTellCount;
+            const shouldApplyRevision = blockingDidNotWorsen
+                && criticalDidNotWorsen
+                && aiDidNotWorsen
+                && (improvedBlocking || improvedAITells);
+            if (!shouldApplyRevision) {
+                return {
+                    chapterNumber: targetChapter,
+                    wordCount: revisionBaseCount,
+                    fixedIssues: [],
+                    applied: false,
+                    status: "unchanged",
+                    skippedReason: "Manual revision did not improve merged audit or AI-tell metrics; kept original chapter.",
+                };
+            }
+            this.logLengthWarnings(lengthWarnings);
             // Save revised chapter file
+            this.logStage(stageLanguage, {
+                zh: `落盘第${targetChapter}章修订结果`,
+                en: `persisting revision for chapter ${targetChapter}`,
+            });
             const chaptersDir = join(bookDir, "chapters");
             const files = await readdir(chaptersDir);
             const paddedNum = String(targetChapter).padStart(4, "0");
@@ -276,7 +542,7 @@ export class PipelineRunner {
             const reviseHeading = reviseLang === "en"
                 ? `# Chapter ${targetChapter}: ${chapterMeta.title}`
                 : `# 第${targetChapter}章 ${chapterMeta.title}`;
-            await writeFile(join(chaptersDir, existingFile), `${reviseHeading}\n\n${reviseOutput.revisedContent}`, "utf-8");
+            await writeFile(join(chaptersDir, existingFile), `${reviseHeading}\n\n${normalizedRevision.content}`, "utf-8");
             // Update truth files
             const storyDir = join(bookDir, "story");
             if (reviseOutput.updatedState !== "(状态卡未更新)") {
@@ -288,26 +554,40 @@ export class PipelineRunner {
             if (reviseOutput.updatedHooks !== "(伏笔池未更新)") {
                 await writeFile(join(storyDir, "pending_hooks.md"), reviseOutput.updatedHooks, "utf-8");
             }
+            await this.syncLegacyStructuredStateFromMarkdown(bookDir, targetChapter);
             // Update index
             const updatedIndex = index.map((ch) => ch.number === targetChapter
                 ? {
                     ...ch,
-                    status: "ready-for-review",
-                    wordCount: reviseOutput.wordCount,
+                    status: (effectivePostRevision.auditResult.passed ? "ready-for-review" : "audit-failed"),
+                    wordCount: normalizedRevision.wordCount,
                     updatedAt: new Date().toISOString(),
+                    auditIssues: effectivePostRevision.auditResult.issues.map((i) => `[${i.severity}] ${i.description}`),
+                    lengthWarnings,
+                    lengthTelemetry,
                 }
                 : ch);
             await this.state.saveChapterIndex(bookId, updatedIndex);
             // Re-snapshot
+            this.logStage(stageLanguage, {
+                zh: `更新第${targetChapter}章索引与快照`,
+                en: `updating chapter index and snapshots for chapter ${targetChapter}`,
+            });
             await this.state.snapshotState(bookId, targetChapter);
+            await this.syncNarrativeMemoryIndex(bookId);
+            await this.syncCurrentStateFactHistory(bookId, targetChapter);
             await this.emitWebhook("revision-complete", bookId, targetChapter, {
-                wordCount: reviseOutput.wordCount,
+                wordCount: normalizedRevision.wordCount,
                 fixedCount: reviseOutput.fixedIssues.length,
             });
             return {
                 chapterNumber: targetChapter,
-                wordCount: reviseOutput.wordCount,
+                wordCount: normalizedRevision.wordCount,
                 fixedIssues: reviseOutput.fixedIssues,
+                applied: true,
+                status: effectivePostRevision.auditResult.passed ? "ready-for-review" : "audit-failed",
+                lengthWarnings,
+                lengthTelemetry,
             };
         }
         finally {
@@ -367,28 +647,49 @@ export class PipelineRunner {
         }
     }
     async _writeNextChapterLocked(bookId, wordCount, temperatureOverride) {
+        await this.state.ensureControlDocuments(bookId);
         const book = await this.state.loadBookConfig(bookId);
         const bookDir = this.state.bookDir(bookId);
         const chapterNumber = await this.state.getNextChapterNumber(bookId);
+        const stageLanguage = await this.resolveBookLanguage(book);
+        this.logStage(stageLanguage, { zh: "准备章节输入", en: "preparing chapter inputs" });
+        const writeInput = await this.prepareWriteInput(book, bookDir, chapterNumber, this.config.externalContext);
+        const reducedControlInput = writeInput.chapterIntent && writeInput.contextPackage && writeInput.ruleStack
+            ? {
+                chapterIntent: writeInput.chapterIntent,
+                contextPackage: writeInput.contextPackage,
+                ruleStack: writeInput.ruleStack,
+            }
+            : undefined;
         const { profile: gp } = await this.loadGenreProfile(book.genre);
+        const pipelineLang = book.language ?? gp.language;
+        const lengthSpec = buildLengthSpec(wordCount ?? book.chapterWordCount, pipelineLang);
         // 1. Write chapter
         const writer = new WriterAgent(this.agentCtxFor("writer", bookId));
+        this.logStage(stageLanguage, { zh: "撰写章节草稿", en: "writing chapter draft" });
         const output = await writer.writeChapter({
             book,
             bookDir,
             chapterNumber,
-            externalContext: this.config.externalContext,
+            ...writeInput,
+            lengthSpec,
             ...(wordCount ? { wordCountOverride: wordCount } : {}),
             ...(temperatureOverride ? { temperatureOverride } : {}),
         });
+        const writerCount = countChapterLength(output.content, lengthSpec.countingMode);
         // Token usage accumulator
         let totalUsage = output.tokenUsage ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+        let postReviseCount = 0;
+        let normalizeApplied = false;
         // 2a. Post-write error gate: if deterministic rules found errors, auto-fix before LLM audit
         let finalContent = output.content;
         let finalWordCount = output.wordCount;
         let revised = false;
         if (output.postWriteErrors.length > 0) {
-            this.config.logger?.warn(`${output.postWriteErrors.length} post-write errors detected, triggering spot-fix before audit`);
+            this.logWarn(pipelineLang, {
+                zh: `检测到 ${output.postWriteErrors.length} 个后写错误，审计前触发 spot-fix 修补`,
+                en: `${output.postWriteErrors.length} post-write errors detected, triggering spot-fix before audit`,
+            });
             const reviser = new ReviserAgent(this.agentCtxFor("reviser", bookId));
             const spotFixIssues = output.postWriteErrors.map((v) => ({
                 severity: "critical",
@@ -396,7 +697,10 @@ export class PipelineRunner {
                 description: v.description,
                 suggestion: v.suggestion,
             }));
-            const fixResult = await reviser.reviseChapter(bookDir, finalContent, chapterNumber, spotFixIssues, "spot-fix", book.genre);
+            const fixResult = await reviser.reviseChapter(bookDir, finalContent, chapterNumber, spotFixIssues, "spot-fix", book.genre, {
+                ...reducedControlInput,
+                lengthSpec,
+            });
             totalUsage = PipelineRunner.addUsage(totalUsage, fixResult.tokenUsage);
             if (fixResult.revisedContent.length > 0) {
                 finalContent = fixResult.revisedContent;
@@ -404,9 +708,21 @@ export class PipelineRunner {
                 revised = true;
             }
         }
+        const normalizedBeforeAudit = await this.normalizeDraftLengthIfNeeded({
+            bookId,
+            chapterNumber,
+            chapterContent: finalContent,
+            lengthSpec,
+            chapterIntent: writeInput.chapterIntent,
+        });
+        totalUsage = PipelineRunner.addUsage(totalUsage, normalizedBeforeAudit.tokenUsage);
+        finalContent = normalizedBeforeAudit.content;
+        finalWordCount = normalizedBeforeAudit.wordCount;
+        normalizeApplied = normalizeApplied || normalizedBeforeAudit.applied;
         // 2b. LLM audit
         const auditor = new ContinuityAuditor(this.agentCtxFor("auditor", bookId));
-        const llmAudit = await auditor.auditChapter(bookDir, finalContent, chapterNumber, book.genre);
+        this.logStage(stageLanguage, { zh: "审计草稿", en: "auditing draft" });
+        const llmAudit = await auditor.auditChapter(bookDir, finalContent, chapterNumber, book.genre, reducedControlInput);
         totalUsage = PipelineRunner.addUsage(totalUsage, llmAudit.tokenUsage);
         const aiTellsResult = analyzeAITells(finalContent);
         const sensitiveWriteResult = analyzeSensitiveWords(finalContent);
@@ -421,42 +737,84 @@ export class PipelineRunner {
             const criticalIssues = auditResult.issues.filter((i) => i.severity === "critical");
             if (criticalIssues.length > 0) {
                 const reviser = new ReviserAgent(this.agentCtxFor("reviser", bookId));
-                const reviseOutput = await reviser.reviseChapter(bookDir, finalContent, chapterNumber, auditResult.issues, "spot-fix", book.genre);
+                this.logStage(stageLanguage, { zh: "自动修复关键问题", en: "auto-revising critical issues" });
+                const reviseOutput = await reviser.reviseChapter(bookDir, finalContent, chapterNumber, auditResult.issues, "spot-fix", book.genre, {
+                    ...reducedControlInput,
+                    lengthSpec,
+                });
                 totalUsage = PipelineRunner.addUsage(totalUsage, reviseOutput.tokenUsage);
                 if (reviseOutput.revisedContent.length > 0) {
+                    const normalizedRevision = await this.normalizeDraftLengthIfNeeded({
+                        bookId,
+                        chapterNumber,
+                        chapterContent: reviseOutput.revisedContent,
+                        lengthSpec,
+                        chapterIntent: writeInput.chapterIntent,
+                    });
+                    totalUsage = PipelineRunner.addUsage(totalUsage, normalizedRevision.tokenUsage);
+                    postReviseCount = normalizedRevision.wordCount;
+                    normalizeApplied = normalizeApplied || normalizedRevision.applied;
                     // Guard: reject revision if AI markers increased
                     const preMarkers = analyzeAITells(finalContent);
-                    const postMarkers = analyzeAITells(reviseOutput.revisedContent);
+                    const postMarkers = analyzeAITells(normalizedRevision.content);
                     const preCount = preMarkers.issues.length;
                     const postCount = postMarkers.issues.length;
                     if (postCount > preCount) {
                         // Revision made text MORE AI-like — discard it, keep original
                     }
                     else {
-                        finalContent = reviseOutput.revisedContent;
-                        finalWordCount = reviseOutput.wordCount;
+                        finalContent = normalizedRevision.content;
+                        finalWordCount = normalizedRevision.wordCount;
                         revised = true;
                     }
                     // Re-audit the (possibly revised) content
-                    const reAudit = await auditor.auditChapter(bookDir, finalContent, chapterNumber, book.genre, { temperature: 0 });
+                    const reAudit = await auditor.auditChapter(bookDir, finalContent, chapterNumber, book.genre, { ...reducedControlInput, temperature: 0 });
                     totalUsage = PipelineRunner.addUsage(totalUsage, reAudit.tokenUsage);
                     const reAITells = analyzeAITells(finalContent);
                     const reSensitive = analyzeSensitiveWords(finalContent);
                     const reHasBlocked = reSensitive.found.some((f) => f.severity === "block");
-                    auditResult = {
+                    auditResult = this.restoreLostAuditIssues(auditResult, {
                         passed: reHasBlocked ? false : reAudit.passed,
                         issues: [...reAudit.issues, ...reAITells.issues, ...reSensitive.issues],
                         summary: reAudit.summary,
-                    };
+                    });
                 }
             }
         }
         // 4. Save the final chapter and truth files from a single persistence source
+        this.logStage(stageLanguage, { zh: "落盘最终章节", en: "persisting final chapter" });
+        this.logStage(stageLanguage, { zh: "生成最终真相文件", en: "rebuilding final truth files" });
         const persistenceOutput = await this.buildPersistenceOutput(bookId, book, bookDir, chapterNumber, output, finalContent);
+        const longSpanFatigue = await analyzeLongSpanFatigue({
+            bookDir,
+            chapterNumber,
+            chapterContent: finalContent,
+            chapterSummary: persistenceOutput.chapterSummary,
+            language: pipelineLang,
+        });
+        auditResult = {
+            ...auditResult,
+            issues: [
+                ...auditResult.issues,
+                ...longSpanFatigue.issues,
+                ...(persistenceOutput.hookHealthIssues ?? []),
+            ],
+        };
         finalWordCount = persistenceOutput.wordCount;
-        const pipelineLang = book.language ?? gp.language;
+        const lengthWarnings = this.buildLengthWarnings(chapterNumber, finalWordCount, lengthSpec);
+        const lengthTelemetry = this.buildLengthTelemetry({
+            lengthSpec,
+            writerCount,
+            postWriterNormalizeCount: normalizedBeforeAudit.wordCount,
+            postReviseCount,
+            finalCount: finalWordCount,
+            normalizeApplied,
+            lengthWarning: lengthWarnings.length > 0,
+        });
+        this.logLengthWarnings(lengthWarnings);
         // 4.1 Validate settler output before writing (non-blocking)
         try {
+            this.logStage(stageLanguage, { zh: "校验真相文件变更", en: "validating truth file updates" });
             const storyDir = join(bookDir, "story");
             const [oldState, oldHooks] = await Promise.all([
                 readFile(join(storyDir, "current_state.md"), "utf-8").catch(() => ""),
@@ -465,17 +823,26 @@ export class PipelineRunner {
             const validator = new StateValidatorAgent(this.agentCtxFor("state-validator", bookId));
             const validation = await validator.validate(finalContent, chapterNumber, oldState, persistenceOutput.updatedState, oldHooks, persistenceOutput.updatedHooks, pipelineLang);
             if (validation.warnings.length > 0) {
-                this.config.logger?.warn(`State validation: ${validation.warnings.length} warning(s) for chapter ${chapterNumber}`);
+                this.logWarn(pipelineLang, {
+                    zh: `状态校验：第${chapterNumber}章发现 ${validation.warnings.length} 条警告`,
+                    en: `State validation: ${validation.warnings.length} warning(s) for chapter ${chapterNumber}`,
+                });
                 for (const w of validation.warnings) {
                     this.config.logger?.warn(`  [${w.category}] ${w.description}`);
                 }
             }
         }
         catch (e) {
-            this.config.logger?.warn(`State validation skipped: ${e}`);
+            this.logWarn(pipelineLang, {
+                zh: `状态校验已跳过：${String(e)}`,
+                en: `State validation skipped: ${String(e)}`,
+            });
         }
         await writer.saveChapter(bookDir, persistenceOutput, gp.numericalSystem, pipelineLang);
-        await writer.saveNewTruthFiles(bookDir, persistenceOutput);
+        await writer.saveNewTruthFiles(bookDir, persistenceOutput, pipelineLang);
+        await this.syncLegacyStructuredStateFromMarkdown(bookDir, chapterNumber, persistenceOutput);
+        this.logStage(stageLanguage, { zh: "同步记忆索引", en: "syncing memory indexes" });
+        await this.syncNarrativeMemoryIndex(bookId);
         // 5. Update chapter index
         const existingIndex = await this.state.loadChapterIndex(bookId);
         const now = new Date().toISOString();
@@ -487,9 +854,12 @@ export class PipelineRunner {
             createdAt: now,
             updatedAt: now,
             auditIssues: auditResult.issues.map((i) => `[${i.severity}] ${i.description}`),
+            lengthWarnings,
+            lengthTelemetry,
             tokenUsage: totalUsage,
         };
         await this.state.saveChapterIndex(bookId, [...existingIndex, newEntry]);
+        await this.markBookActiveIfNeeded(bookId);
         // 5.5 Audit drift correction — feed audit findings back into state
         // This prevents the writer from repeating mistakes in the next chapter
         const driftIssues = auditResult.issues.filter((i) => i.severity === "critical" || i.severity === "warning");
@@ -499,10 +869,16 @@ export class PipelineRunner {
                 const statePath = join(storyDir, "current_state.md");
                 const currentState = await readFile(statePath, "utf-8").catch(() => "");
                 // Append drift correction section (or replace existing one)
-                const correctionHeader = "## 审计纠偏（自动生成，下一章写作前参照）";
+                const correctionHeader = this.localize(stageLanguage, {
+                    zh: "## 审计纠偏（自动生成，下一章写作前参照）",
+                    en: "## Audit Drift Correction",
+                });
                 const correctionBlock = [
                     correctionHeader,
-                    `> 第${chapterNumber}章审计发现以下问题，下一章写作时必须避免：`,
+                    this.localize(stageLanguage, {
+                        zh: `> 第${chapterNumber}章审计发现以下问题，下一章写作时必须避免：`,
+                        en: `> Chapter ${chapterNumber} audit found the following issues to avoid in the next chapter:`,
+                    }),
                     ...driftIssues.map((i) => `> - [${i.severity}] ${i.category}: ${i.description}`),
                     "",
                 ].join("\n");
@@ -518,14 +894,17 @@ export class PipelineRunner {
             }
         }
         // 5.6 Snapshot state for rollback support
+        this.logStage(stageLanguage, { zh: "更新章节索引与快照", en: "updating chapter index and snapshots" });
         await this.state.snapshotState(bookId, chapterNumber);
+        await this.syncCurrentStateFactHistory(bookId, chapterNumber);
         // 6. Send notification
         if (this.config.notifyChannels && this.config.notifyChannels.length > 0) {
             const statusEmoji = auditResult.passed ? "✅" : "⚠️";
+            const chapterLength = formatLengthCount(finalWordCount, lengthSpec.countingMode);
             await dispatchNotification(this.config.notifyChannels, {
                 title: `${statusEmoji} ${book.title} 第${chapterNumber}章`,
                 body: [
-                    `**${persistenceOutput.title}** | ${finalWordCount}字`,
+                    `**${persistenceOutput.title}** | ${chapterLength}`,
                     revised ? "📝 已自动修正" : "",
                     `审稿: ${auditResult.passed ? "通过" : "需人工审核"}`,
                     ...auditResult.issues
@@ -549,6 +928,8 @@ export class PipelineRunner {
             auditResult,
             revised,
             status: auditResult.passed ? "ready-for-review" : "audit-failed",
+            lengthWarnings,
+            lengthTelemetry,
             tokenUsage: totalUsage,
         };
     }
@@ -756,28 +1137,46 @@ ${matrix}`,
             const book = await this.state.loadBookConfig(input.bookId);
             const bookDir = this.state.bookDir(input.bookId);
             const { profile: gp } = await this.loadGenreProfile(book.genre);
+            const resolvedLanguage = book.language ?? gp.language;
             const startFrom = input.resumeFrom ?? 1;
             const log = this.config.logger?.child("import");
             // Step 1: Generate foundation on first run (not on resume)
             if (startFrom === 1) {
-                log?.info(`Step 1: Generating foundation from ${input.chapters.length} chapters...`);
-                const allText = input.chapters.map((c, i) => `第${i + 1}章 ${c.title}\n\n${c.content}`).join("\n\n---\n\n");
+                log?.info(this.localize(resolvedLanguage, {
+                    zh: `步骤 1：从 ${input.chapters.length} 章生成基础设定...`,
+                    en: `Step 1: Generating foundation from ${input.chapters.length} chapters...`,
+                }));
+                const allText = input.chapters.map((c, i) => resolvedLanguage === "en"
+                    ? `Chapter ${i + 1}: ${c.title}\n\n${c.content}`
+                    : `第${i + 1}章 ${c.title}\n\n${c.content}`).join("\n\n---\n\n");
                 const architect = new ArchitectAgent(this.agentCtxFor("architect", input.bookId));
                 const foundation = await architect.generateFoundationFromImport(book, allText);
-                await architect.writeFoundationFiles(bookDir, foundation, gp.numericalSystem);
+                await architect.writeFoundationFiles(bookDir, foundation, gp.numericalSystem, resolvedLanguage);
+                await this.resetImportReplayTruthFiles(bookDir, resolvedLanguage);
                 await this.state.saveChapterIndex(input.bookId, []);
-                log?.info("Foundation generated.");
+                await this.state.snapshotState(input.bookId, 0);
+                log?.info(this.localize(resolvedLanguage, {
+                    zh: "基础设定已生成。",
+                    en: "Foundation generated.",
+                }));
             }
             // Step 2: Sequential replay
-            log?.info(`Step 2: Sequential replay from chapter ${startFrom}...`);
+            log?.info(this.localize(resolvedLanguage, {
+                zh: `步骤 2：从第 ${startFrom} 章开始顺序回放...`,
+                en: `Step 2: Sequential replay from chapter ${startFrom}...`,
+            }));
             const analyzer = new ChapterAnalyzerAgent(this.agentCtxFor("chapter-analyzer", input.bookId));
             const writer = new WriterAgent(this.agentCtxFor("writer", input.bookId));
+            const countingMode = resolveLengthCountingMode(book.language ?? gp.language);
             let totalWords = 0;
             let importedCount = 0;
             for (let i = startFrom - 1; i < input.chapters.length; i++) {
                 const ch = input.chapters[i];
                 const chapterNumber = i + 1;
-                log?.info(`Analyzing chapter ${chapterNumber}/${input.chapters.length}: ${ch.title}...`);
+                log?.info(this.localize(resolvedLanguage, {
+                    zh: `分析章节 ${chapterNumber}/${input.chapters.length}：${ch.title}...`,
+                    en: `Analyzing chapter ${chapterNumber}/${input.chapters.length}: ${ch.title}...`,
+                }));
                 // Analyze chapter to get truth file updates
                 const output = await analyzer.analyzeChapter({
                     book,
@@ -791,24 +1190,28 @@ ${matrix}`,
                     ...output,
                     postWriteErrors: [],
                     postWriteWarnings: [],
-                }, gp.numericalSystem);
+                }, gp.numericalSystem, resolvedLanguage);
                 // Save extended truth files (summaries, subplots, emotional arcs, character matrix)
                 await writer.saveNewTruthFiles(bookDir, {
                     ...output,
                     postWriteErrors: [],
                     postWriteWarnings: [],
-                });
+                }, resolvedLanguage);
+                await this.syncLegacyStructuredStateFromMarkdown(bookDir, chapterNumber, output);
+                await this.syncNarrativeMemoryIndex(input.bookId);
                 // Update chapter index
                 const existingIndex = await this.state.loadChapterIndex(input.bookId);
                 const now = new Date().toISOString();
+                const chapterWordCount = countChapterLength(ch.content, countingMode);
                 const newEntry = {
                     number: chapterNumber,
                     title: output.title,
                     status: "imported",
-                    wordCount: ch.content.length,
+                    wordCount: chapterWordCount,
                     createdAt: now,
                     updatedAt: now,
                     auditIssues: [],
+                    lengthWarnings: [],
                 };
                 // Replace if exists (resume case), otherwise append
                 const existingIdx = existingIndex.findIndex((e) => e.number === chapterNumber);
@@ -819,10 +1222,17 @@ ${matrix}`,
                 // Snapshot state after each chapter for rollback + resume support
                 await this.state.snapshotState(input.bookId, chapterNumber);
                 importedCount++;
-                totalWords += ch.content.length;
+                totalWords += chapterWordCount;
+            }
+            if (input.chapters.length > 0) {
+                await this.markBookActiveIfNeeded(input.bookId);
+                await this.syncCurrentStateFactHistory(input.bookId, input.chapters.length);
             }
             const nextChapter = input.chapters.length + 1;
-            log?.info(`Done. ${importedCount} chapters imported, ${totalWords} chars. Next chapter: ${nextChapter}`);
+            log?.info(this.localize(resolvedLanguage, {
+                zh: `完成。已导入 ${importedCount} 章，共 ${formatLengthCount(totalWords, countingMode)}。下一章：${nextChapter}`,
+                en: `Done. ${importedCount} chapters imported, ${formatLengthCount(totalWords, countingMode)}. Next chapter: ${nextChapter}`,
+            }));
             return {
                 bookId: input.bookId,
                 importedCount,
@@ -859,12 +1269,558 @@ ${matrix}`,
             ...analyzed,
             postWriteErrors: [],
             postWriteWarnings: [],
+            hookHealthIssues: output.hookHealthIssues,
             tokenUsage: output.tokenUsage,
         };
     }
     // ---------------------------------------------------------------------------
     // Helpers
     // ---------------------------------------------------------------------------
+    async prepareWriteInput(book, bookDir, chapterNumber, externalContext) {
+        if ((this.config.inputGovernanceMode ?? "v2") === "legacy") {
+            return { externalContext };
+        }
+        const { plan, composed } = await this.createGovernedArtifacts(book, bookDir, chapterNumber, externalContext, { reuseExistingIntentWhenContextMissing: true });
+        return {
+            chapterIntent: plan.intentMarkdown,
+            contextPackage: composed.contextPackage,
+            ruleStack: composed.ruleStack,
+            trace: composed.trace,
+        };
+    }
+    async resetImportReplayTruthFiles(bookDir, language) {
+        const storyDir = join(bookDir, "story");
+        await Promise.all([
+            writeFile(join(storyDir, "current_state.md"), this.buildImportReplayStateSeed(language), "utf-8"),
+            writeFile(join(storyDir, "pending_hooks.md"), this.buildImportReplayHooksSeed(language), "utf-8"),
+            rm(join(storyDir, "chapter_summaries.md"), { force: true }),
+            rm(join(storyDir, "subplot_board.md"), { force: true }),
+            rm(join(storyDir, "emotional_arcs.md"), { force: true }),
+            rm(join(storyDir, "character_matrix.md"), { force: true }),
+            rm(join(storyDir, "volume_summaries.md"), { force: true }),
+            rm(join(storyDir, "particle_ledger.md"), { force: true }),
+            rm(join(storyDir, "memory.db"), { force: true }),
+            rm(join(storyDir, "memory.db-shm"), { force: true }),
+            rm(join(storyDir, "memory.db-wal"), { force: true }),
+            rm(join(storyDir, "state"), { recursive: true, force: true }),
+            rm(join(storyDir, "snapshots"), { recursive: true, force: true }),
+        ]);
+    }
+    buildImportReplayStateSeed(language) {
+        if (language === "en") {
+            return [
+                "# Current State",
+                "",
+                "| Field | Value |",
+                "| --- | --- |",
+                "| Current Chapter | 0 |",
+                "| Current Location | (not set) |",
+                "| Protagonist State | (not set) |",
+                "| Current Goal | (not set) |",
+                "| Current Constraint | (not set) |",
+                "| Current Alliances | (not set) |",
+                "| Current Conflict | (not set) |",
+                "",
+            ].join("\n");
+        }
+        return [
+            "# 当前状态",
+            "",
+            "| 字段 | 值 |",
+            "| --- | --- |",
+            "| 当前章节 | 0 |",
+            "| 当前位置 | （未设定） |",
+            "| 主角状态 | （未设定） |",
+            "| 当前目标 | （未设定） |",
+            "| 当前限制 | （未设定） |",
+            "| 当前敌我 | （未设定） |",
+            "| 当前冲突 | （未设定） |",
+            "",
+        ].join("\n");
+    }
+    buildImportReplayHooksSeed(language) {
+        if (language === "en") {
+            return [
+                "# Pending Hooks",
+                "",
+                "| hook_id | start_chapter | type | status | last_advanced_chapter | expected_payoff | notes |",
+                "| --- | --- | --- | --- | --- | --- | --- |",
+                "",
+            ].join("\n");
+        }
+        return [
+            "# 伏笔池",
+            "",
+            "| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 备注 |",
+            "| --- | --- | --- | --- | --- | --- | --- |",
+            "",
+        ].join("\n");
+    }
+    async normalizeDraftLengthIfNeeded(params) {
+        const writerCount = countChapterLength(params.chapterContent, params.lengthSpec.countingMode);
+        if (!isOutsideSoftRange(writerCount, params.lengthSpec)) {
+            return {
+                content: params.chapterContent,
+                wordCount: writerCount,
+                applied: false,
+            };
+        }
+        const normalizer = new LengthNormalizerAgent(this.agentCtxFor("length-normalizer", params.bookId));
+        const normalized = await normalizer.normalizeChapter({
+            chapterContent: params.chapterContent,
+            lengthSpec: params.lengthSpec,
+            chapterIntent: params.chapterIntent,
+        });
+        // Safety net: if normalizer output is less than 25% of original, it was too destructive.
+        // Reject and keep original content.
+        if (normalized.finalCount < writerCount * 0.25) {
+            this.logWarn(this.languageFromLengthSpec(params.lengthSpec), {
+                zh: `字数归一化被拒绝：第${params.chapterNumber}章 ${writerCount} -> ${normalized.finalCount}（砍了${Math.round((1 - normalized.finalCount / writerCount) * 100)}%，超过安全阈值）`,
+                en: `Length normalization rejected for chapter ${params.chapterNumber}: ${writerCount} -> ${normalized.finalCount} (cut ${Math.round((1 - normalized.finalCount / writerCount) * 100)}%, exceeds safety threshold)`,
+            });
+            return {
+                content: params.chapterContent,
+                wordCount: writerCount,
+                applied: false,
+            };
+        }
+        this.logInfo(this.languageFromLengthSpec(params.lengthSpec), {
+            zh: `审计前字数归一化：第${params.chapterNumber}章 ${writerCount} -> ${normalized.finalCount}`,
+            en: `Length normalization before audit for chapter ${params.chapterNumber}: ${writerCount} -> ${normalized.finalCount}`,
+        });
+        return {
+            content: normalized.normalizedContent,
+            wordCount: normalized.finalCount,
+            applied: normalized.applied,
+            tokenUsage: normalized.tokenUsage,
+        };
+    }
+    async syncCurrentStateFactHistory(bookId, uptoChapter) {
+        const bookDir = this.state.bookDir(bookId);
+        try {
+            await this.rebuildCurrentStateFactHistory(bookDir, uptoChapter);
+        }
+        catch (error) {
+            if (this.isMemoryIndexUnavailableError(error)) {
+                if (this.canOpenMemoryIndex(bookDir)) {
+                    try {
+                        await this.rebuildCurrentStateFactHistory(bookDir, uptoChapter);
+                        return;
+                    }
+                    catch (retryError) {
+                        error = retryError;
+                    }
+                }
+                else {
+                    if (!this.memoryIndexFallbackWarned) {
+                        this.memoryIndexFallbackWarned = true;
+                        this.logWarn(await this.resolveBookLanguageById(bookId), {
+                            zh: "当前 Node 运行时不支持 SQLite 记忆索引，继续使用 Markdown 回退方案。",
+                            en: "SQLite memory index unavailable on this Node runtime; continuing with markdown fallback.",
+                        });
+                        await this.logMemoryIndexDebugInfo(bookId, error);
+                    }
+                    return;
+                }
+            }
+            this.logWarn(await this.resolveBookLanguageById(bookId), {
+                zh: `状态事实同步已跳过：${String(error)}`,
+                en: `State fact sync skipped: ${String(error)}`,
+            });
+        }
+    }
+    async syncLegacyStructuredStateFromMarkdown(bookDir, chapterNumber, output) {
+        if (output?.runtimeStateDelta || output?.runtimeStateSnapshot) {
+            return;
+        }
+        await rewriteStructuredStateFromMarkdown({
+            bookDir,
+            fallbackChapter: chapterNumber,
+        });
+    }
+    async syncNarrativeMemoryIndex(bookId) {
+        const bookDir = this.state.bookDir(bookId);
+        try {
+            await this.rebuildNarrativeMemoryIndex(bookDir);
+        }
+        catch (error) {
+            if (this.isMemoryIndexUnavailableError(error)) {
+                if (this.canOpenMemoryIndex(bookDir)) {
+                    try {
+                        await this.rebuildNarrativeMemoryIndex(bookDir);
+                        return;
+                    }
+                    catch (retryError) {
+                        error = retryError;
+                    }
+                }
+                else {
+                    if (!this.memoryIndexFallbackWarned) {
+                        this.memoryIndexFallbackWarned = true;
+                        this.logWarn(await this.resolveBookLanguageById(bookId), {
+                            zh: "当前 Node 运行时不支持 SQLite 记忆索引，继续使用 Markdown 回退方案。",
+                            en: "SQLite memory index unavailable on this Node runtime; continuing with markdown fallback.",
+                        });
+                        await this.logMemoryIndexDebugInfo(bookId, error);
+                    }
+                    return;
+                }
+            }
+            this.logWarn(await this.resolveBookLanguageById(bookId), {
+                zh: `叙事记忆同步已跳过：${String(error)}`,
+                en: `Narrative memory sync skipped: ${String(error)}`,
+            });
+        }
+    }
+    async rebuildCurrentStateFactHistory(bookDir, uptoChapter) {
+        const memoryDb = await this.withMemoryIndexRetry(async () => {
+            const db = new MemoryDB(bookDir);
+            try {
+                db.resetFacts();
+                const activeFacts = new Map();
+                for (let chapter = 0; chapter <= uptoChapter; chapter++) {
+                    const snapshotFacts = await loadSnapshotCurrentStateFacts(bookDir, chapter);
+                    if (snapshotFacts.length === 0)
+                        continue;
+                    const nextFacts = new Map();
+                    for (const fact of snapshotFacts) {
+                        nextFacts.set(this.factKey(fact), {
+                            subject: fact.subject,
+                            predicate: fact.predicate,
+                            object: fact.object,
+                            validFromChapter: chapter,
+                            validUntilChapter: null,
+                            sourceChapter: chapter,
+                        });
+                    }
+                    for (const [key, previous] of activeFacts.entries()) {
+                        const next = nextFacts.get(key);
+                        if (!next || next.object !== previous.object) {
+                            db.invalidateFact(previous.id, chapter);
+                            activeFacts.delete(key);
+                        }
+                    }
+                    for (const [key, fact] of nextFacts.entries()) {
+                        if (activeFacts.has(key))
+                            continue;
+                        const id = db.addFact(fact);
+                        activeFacts.set(key, { id, object: fact.object });
+                    }
+                }
+                return db;
+            }
+            catch (error) {
+                db.close();
+                throw error;
+            }
+        });
+        try {
+            // No-op: keep the db open only for the duration of the rebuild.
+        }
+        finally {
+            memoryDb.close();
+        }
+    }
+    async rebuildNarrativeMemoryIndex(bookDir) {
+        const memorySeed = await loadNarrativeMemorySeed(bookDir);
+        const memoryDb = await this.withMemoryIndexRetry(() => {
+            const db = new MemoryDB(bookDir);
+            try {
+                db.replaceSummaries(memorySeed.summaries);
+                db.replaceHooks(memorySeed.hooks);
+                return db;
+            }
+            catch (error) {
+                db.close();
+                throw error;
+            }
+        });
+        try {
+            // No-op: keep the db open only for the duration of the rebuild.
+        }
+        finally {
+            memoryDb.close();
+        }
+    }
+    canOpenMemoryIndex(bookDir) {
+        let memoryDb = null;
+        try {
+            memoryDb = new MemoryDB(bookDir);
+            return true;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            memoryDb?.close();
+        }
+    }
+    async logMemoryIndexDebugInfo(bookId, error) {
+        if (process.env.INKOS_DEBUG_SQLITE_MEMORY !== "1") {
+            return;
+        }
+        const code = typeof error === "object" && error !== null && "code" in error
+            ? String(error.code ?? "")
+            : "";
+        const message = error instanceof Error
+            ? error.message
+            : String(error);
+        this.logWarn(await this.resolveBookLanguageById(bookId), {
+            zh: `SQLite 记忆索引调试：node=${process.version}; execArgv=${JSON.stringify(process.execArgv)}; code=${code || "(none)"}; message=${message}`,
+            en: `SQLite memory debug: node=${process.version}; execArgv=${JSON.stringify(process.execArgv)}; code=${code || "(none)"}; message=${message}`,
+        });
+    }
+    async withMemoryIndexRetry(operation) {
+        const retryDelaysMs = [0, 25, 75];
+        let lastError;
+        for (let attempt = 0; attempt < retryDelaysMs.length; attempt += 1) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                if (!this.isMemoryIndexBusyError(error) || attempt === retryDelaysMs.length - 1) {
+                    throw error;
+                }
+                await new Promise((resolve) => setTimeout(resolve, retryDelaysMs[attempt + 1]));
+            }
+        }
+        throw lastError;
+    }
+    isMemoryIndexUnavailableError(error) {
+        if (!error)
+            return false;
+        const code = typeof error === "object" && error !== null && "code" in error
+            ? String(error.code ?? "")
+            : "";
+        const message = error instanceof Error
+            ? error.message
+            : String(error);
+        const normalizedMessage = message.trim();
+        return /^No such built-in module:\s*node:sqlite$/i.test(normalizedMessage)
+            || /^Cannot find module ['"]node:sqlite['"]$/i.test(normalizedMessage)
+            || (code === "ERR_UNKNOWN_BUILTIN_MODULE" && /\bnode:sqlite\b/i.test(normalizedMessage));
+    }
+    isMemoryIndexBusyError(error) {
+        if (!error)
+            return false;
+        const code = typeof error === "object" && error !== null && "code" in error
+            ? String(error.code ?? "")
+            : "";
+        const message = error instanceof Error
+            ? error.message
+            : String(error);
+        return code === "SQLITE_BUSY"
+            || code === "SQLITE_LOCKED"
+            || /\bSQLITE_BUSY\b/i.test(message)
+            || /\bSQLITE_LOCKED\b/i.test(message)
+            || /database is locked/i.test(message)
+            || /database is busy/i.test(message);
+    }
+    factKey(fact) {
+        return `${fact.subject}::${fact.predicate}`;
+    }
+    buildLengthWarnings(chapterNumber, finalCount, lengthSpec) {
+        if (!isOutsideHardRange(finalCount, lengthSpec)) {
+            return [];
+        }
+        return [
+            this.localize(this.languageFromLengthSpec(lengthSpec), {
+                zh: `第${chapterNumber}章经过一次字数归一化后仍超出硬区间（${lengthSpec.hardMin}-${lengthSpec.hardMax}，实际 ${finalCount}）。`,
+                en: `Chapter ${chapterNumber} remains outside hard range (${lengthSpec.hardMin}-${lengthSpec.hardMax}, actual ${finalCount}) after a single normalization pass.`,
+            }),
+        ];
+    }
+    buildLengthTelemetry(params) {
+        return {
+            target: params.lengthSpec.target,
+            softMin: params.lengthSpec.softMin,
+            softMax: params.lengthSpec.softMax,
+            hardMin: params.lengthSpec.hardMin,
+            hardMax: params.lengthSpec.hardMax,
+            countingMode: params.lengthSpec.countingMode,
+            writerCount: params.writerCount,
+            postWriterNormalizeCount: params.postWriterNormalizeCount,
+            postReviseCount: params.postReviseCount,
+            finalCount: params.finalCount,
+            normalizeApplied: params.normalizeApplied,
+            lengthWarning: params.lengthWarning,
+        };
+    }
+    logLengthWarnings(lengthWarnings) {
+        for (const warning of lengthWarnings) {
+            this.config.logger?.warn(warning);
+        }
+    }
+    restoreLostAuditIssues(previous, next) {
+        if (next.passed || next.issues.length > 0 || previous.issues.length === 0) {
+            return next;
+        }
+        return {
+            ...next,
+            issues: previous.issues,
+            summary: next.summary || previous.summary,
+        };
+    }
+    restoreActionableAuditIfLost(previous, next) {
+        const auditResult = this.restoreLostAuditIssues(previous.auditResult, next.auditResult);
+        if (auditResult === next.auditResult) {
+            return next;
+        }
+        return {
+            ...next,
+            auditResult,
+            blockingCount: auditResult.issues.filter((issue) => issue.severity === "warning" || issue.severity === "critical").length,
+            criticalCount: auditResult.issues.filter((issue) => issue.severity === "critical").length,
+        };
+    }
+    async evaluateMergedAudit(params) {
+        const llmAudit = await params.auditor.auditChapter(params.bookDir, params.chapterContent, params.chapterNumber, params.book.genre, params.auditOptions);
+        const aiTells = analyzeAITells(params.chapterContent);
+        const sensitiveResult = analyzeSensitiveWords(params.chapterContent);
+        const longSpanFatigue = await analyzeLongSpanFatigue({
+            bookDir: params.bookDir,
+            chapterNumber: params.chapterNumber,
+            chapterContent: params.chapterContent,
+            language: params.language,
+        });
+        const hasBlockedWords = sensitiveResult.found.some((f) => f.severity === "block");
+        const issues = [
+            ...llmAudit.issues,
+            ...aiTells.issues,
+            ...sensitiveResult.issues,
+            ...longSpanFatigue.issues,
+        ];
+        return {
+            auditResult: {
+                passed: hasBlockedWords ? false : llmAudit.passed,
+                issues,
+                summary: llmAudit.summary,
+                tokenUsage: llmAudit.tokenUsage,
+            },
+            aiTellCount: aiTells.issues.length,
+            blockingCount: issues.filter((issue) => issue.severity === "warning" || issue.severity === "critical").length,
+            criticalCount: issues.filter((issue) => issue.severity === "critical").length,
+        };
+    }
+    async markBookActiveIfNeeded(bookId) {
+        const book = await this.state.loadBookConfig(bookId);
+        if (book.status !== "outlining")
+            return;
+        await this.state.saveBookConfig(bookId, {
+            ...book,
+            status: "active",
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    async createGovernedArtifacts(book, bookDir, chapterNumber, externalContext, options) {
+        const plan = await this.resolveGovernedPlan(book, bookDir, chapterNumber, externalContext, options);
+        const composer = new ComposerAgent(this.agentCtxFor("composer", book.id));
+        const composed = await composer.composeChapter({
+            book,
+            bookDir,
+            chapterNumber,
+            plan,
+        });
+        return { plan, composed };
+    }
+    async resolveGovernedPlan(book, bookDir, chapterNumber, externalContext, options) {
+        if (options?.reuseExistingIntentWhenContextMissing &&
+            (!externalContext || externalContext.trim().length === 0)) {
+            const persisted = await this.loadPersistedPlan(bookDir, chapterNumber);
+            if (persisted)
+                return persisted;
+        }
+        const planner = new PlannerAgent(this.agentCtxFor("planner", book.id));
+        return planner.planChapter({
+            book,
+            bookDir,
+            chapterNumber,
+            externalContext,
+        });
+    }
+    async loadPersistedPlan(bookDir, chapterNumber) {
+        const runtimePath = join(bookDir, "story", "runtime", `chapter-${String(chapterNumber).padStart(4, "0")}.intent.md`);
+        try {
+            const intentMarkdown = await readFile(runtimePath, "utf-8");
+            const sections = this.parseIntentSections(intentMarkdown);
+            const goal = this.readIntentScalar(sections, "Goal");
+            if (!goal || this.isInvalidPersistedIntentScalar(goal))
+                return null;
+            const outlineNode = this.readIntentScalar(sections, "Outline Node");
+            if (outlineNode && outlineNode !== "(not found)" && this.isInvalidPersistedIntentScalar(outlineNode)) {
+                return null;
+            }
+            const conflicts = this.readIntentList(sections, "Conflicts")
+                .map((line) => {
+                const separator = line.indexOf(":");
+                if (separator < 0)
+                    return null;
+                const type = line.slice(0, separator).trim();
+                const resolution = line.slice(separator + 1).trim();
+                if (!type || !resolution)
+                    return null;
+                return { type, resolution };
+            })
+                .filter((conflict) => conflict !== null);
+            return {
+                intent: ChapterIntentSchema.parse({
+                    chapter: chapterNumber,
+                    goal,
+                    outlineNode: outlineNode && outlineNode !== "(not found)" ? outlineNode : undefined,
+                    mustKeep: this.readIntentList(sections, "Must Keep"),
+                    mustAvoid: this.readIntentList(sections, "Must Avoid"),
+                    styleEmphasis: this.readIntentList(sections, "Style Emphasis"),
+                    conflicts,
+                }),
+                intentMarkdown,
+                plannerInputs: [runtimePath],
+                runtimePath,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    parseIntentSections(markdown) {
+        const sections = new Map();
+        let current = null;
+        for (const line of markdown.split("\n")) {
+            if (line.startsWith("## ")) {
+                current = line.slice(3).trim();
+                sections.set(current, []);
+                continue;
+            }
+            if (!current)
+                continue;
+            sections.get(current)?.push(line);
+        }
+        return sections;
+    }
+    readIntentScalar(sections, name) {
+        const lines = sections.get(name) ?? [];
+        const value = lines.map((line) => line.trim()).find((line) => line.length > 0);
+        return value && value !== "- none" ? value : undefined;
+    }
+    readIntentList(sections, name) {
+        return (sections.get(name) ?? [])
+            .map((line) => line.trim())
+            .filter((line) => line.startsWith("-") && line !== "- none")
+            .map((line) => line.replace(/^-\s*/, ""));
+    }
+    isInvalidPersistedIntentScalar(value) {
+        const normalized = value.trim();
+        if (!normalized)
+            return true;
+        if (/^[*_`~:：|.-]+$/.test(normalized))
+            return true;
+        return (/^\((describe|briefly describe|write)\b[\s\S]*\)$/i.test(normalized)
+            || /^（(?:在这里描述|描述|填写|写下)[\s\S]*）$/u.test(normalized));
+    }
+    relativeToBookDir(bookDir, absolutePath) {
+        const prefix = `${bookDir}/`;
+        return absolutePath.startsWith(prefix) ? absolutePath.slice(prefix.length) : absolutePath;
+    }
     async emitWebhook(event, bookId, chapterNumber, data) {
         if (!this.config.notifyChannels || this.config.notifyChannels.length === 0)
             return;