merge: integrate writing-pipeline-systemic-repair into master

Combines 43 commits of autoresearch pipeline improvements with
master's chapter-number anchoring fixes.

Key features merged:
- Hook seed excerpt system (replacing lifecycle pressure)
- Audit drift isolation (audit_drift.md)
- Cadence analysis (mood/scene/title fatigue detection)
- State validation retry + degraded recovery
- Review reject rollback
- Title collapse auto-repair
- Chapter number anchoring (contiguous prefix)
- Sequence-level fatigue excluded from revision blockers

packages/cli/src/__tests__/analytics.test.ts

@@ -40,6 +40,21 @@ describe("computeAnalytics", () => {
     expect(result.auditPassRate).toBe(67);
   });
 
+  it("counts state-degraded chapters as audited but not passed", () => {
+    const chapters = [
+      { number: 1, status: "approved", wordCount: 3000, auditIssues: [] },
+      { number: 2, status: "state-degraded", wordCount: 2800, auditIssues: ["[warning] state validation drift"] },
+      { number: 3, status: "drafted", wordCount: 2600, auditIssues: [] },
+    ];
+    const result = computeAnalytics("book-state-degraded", chapters);
+    expect(result.auditPassRate).toBe(50);
+    expect(result.statusDistribution).toEqual({
+      approved: 1,
+      "state-degraded": 1,
+      drafted: 1,
+    });
+  });
+
   it("extracts issue categories from formatted strings", () => {
     const chapters = [
       {

packages/cli/src/__tests__/cli-integration.test.ts

@@ -318,6 +318,50 @@ describe("CLI integration", () => {
       expect(output).not.toContain("7字");
     });
 
+    it("shows degraded chapter counts and issues explicitly", async () => {
+      const bookDir = join(projectDir, "books", "degraded-status");
+      await mkdir(join(bookDir, "chapters"), { recursive: true });
+      await writeFile(
+        join(bookDir, "book.json"),
+        JSON.stringify({
+          id: "degraded-status",
+          title: "Degraded Status Book",
+          platform: "other",
+          genre: "other",
+          status: "active",
+          targetChapters: 10,
+          chapterWordCount: 2200,
+          createdAt: "2026-04-01T00:00:00.000Z",
+          updatedAt: "2026-04-01T00:00:00.000Z",
+        }, null, 2),
+        "utf-8",
+      );
+      await writeFile(
+        join(bookDir, "chapters", "index.json"),
+        JSON.stringify([
+          {
+            number: 1,
+            title: "Broken State",
+            status: "state-degraded",
+            wordCount: 1800,
+            createdAt: "2026-04-01T00:00:00.000Z",
+            updatedAt: "2026-04-01T00:00:00.000Z",
+            auditIssues: ["[warning] state validation still failed after retry"],
+            lengthWarnings: [],
+          },
+        ], null, 2),
+        "utf-8",
+      );
+
+      const output = run(["status", "degraded-status", "--chapters"]);
+      expect(output).toContain("Degraded: 1");
+      expect(output).toContain('Ch.1 "Broken State" | 1800字 | state-degraded');
+      expect(output).toContain("[warning] state validation still failed after retry");
+
+      const json = JSON.parse(run(["status", "degraded-status", "--json"]));
+      expect(json.books[0]?.degraded).toBe(1);
+    });
+
     it("shows a migration hint for legacy pre-v0.6 books", async () => {
       const bookDir = join(projectDir, "books", "legacy-status-hint");
       const storyDir = join(bookDir, "story");
@@ -620,6 +664,75 @@ describe("CLI integration", () => {
     });
   });
 
+  describe("inkos review", () => {
+    it("preserves the original chapter snapshot when approving review", async () => {
+      const configPath = join(projectDir, "inkos.json");
+      const initialized = await stat(configPath).then(() => true).catch(() => false);
+      if (!initialized) run(["init"]);
+
+      const state = new StateManager(projectDir);
+      const bookId = "review-approve-cli";
+      const bookDir = join(projectDir, "books", bookId);
+      const storyDir = join(bookDir, "story");
+      const chaptersDir = join(bookDir, "chapters");
+      await mkdir(chaptersDir, { recursive: true });
+      await mkdir(storyDir, { recursive: true });
+
+      await writeFile(
+        join(bookDir, "book.json"),
+        JSON.stringify({
+          id: bookId,
+          title: "Review Approve CLI",
+          platform: "other",
+          genre: "other",
+          status: "active",
+          targetChapters: 10,
+          chapterWordCount: 2200,
+          createdAt: "2026-03-22T00:00:00.000Z",
+          updatedAt: "2026-03-22T00:00:00.000Z",
+        }, null, 2),
+        "utf-8",
+      );
+      await writeFile(join(storyDir, "current_state.md"), "State at ch1", "utf-8");
+      await writeFile(join(storyDir, "pending_hooks.md"), "Hooks at ch1", "utf-8");
+      await writeFile(join(chaptersDir, "0001_ch1.md"), "# Chapter 1\n\nContent 1", "utf-8");
+      await writeFile(
+        join(chaptersDir, "index.json"),
+        JSON.stringify([
+          {
+            number: 1,
+            title: "Ch1",
+            status: "ready-for-review",
+            wordCount: 100,
+            createdAt: "",
+            updatedAt: "",
+            auditIssues: [],
+            lengthWarnings: [],
+          },
+        ], null, 2),
+        "utf-8",
+      );
+
+      await state.snapshotState(bookId, 1);
+
+      await writeFile(join(storyDir, "current_state.md"), "State at ch3", "utf-8");
+      await writeFile(join(storyDir, "pending_hooks.md"), "Hooks at ch3", "utf-8");
+
+      const output = run(["review", "approve", bookId, "1"]);
+      expect(output).toContain("Chapter 1 approved");
+
+      await expect(
+        readFile(join(storyDir, "snapshots", "1", "current_state.md"), "utf-8"),
+      ).resolves.toBe("State at ch1");
+      await expect(
+        readFile(join(storyDir, "snapshots", "1", "pending_hooks.md"), "utf-8"),
+      ).resolves.toBe("Hooks at ch1");
+
+      const index = await state.loadChapterIndex(bookId);
+      expect(index[0]?.status).toBe("approved");
+    });
+  });
+
   describe("inkos plan/compose", () => {
     beforeAll(async () => {
       const configPath = join(projectDir, "inkos.json");

packages/cli/src/commands/daemon.ts

@@ -50,7 +50,11 @@ export const upCommand = new Command("up")
         cooldownAfterChapterMs: config.daemon.cooldownAfterChapterMs,
         maxChaptersPerDay: config.daemon.maxChaptersPerDay,
         onChapterComplete: (bookId, chapter, status) => {
-          const icon = status === "ready-for-review" ? "+" : "!";
+          const icon = status === "ready-for-review"
+            ? "+"
+            : status === "state-degraded"
+              ? "x"
+              : "!";
           log(`  [${icon}] ${bookId} Ch.${chapter} — ${status}`);
         },
         onError: (bookId, error) => {

packages/cli/src/commands/review.ts

@@ -106,7 +106,7 @@ function parseBookAndChapter(
 
 reviewCommand
   .command("approve")
-  .description("Approve a chapter: approve [book-id] <chapter>")
+  .description("Approve a chapter and commit its state: approve [book-id] <chapter>")
   .argument("<args...>", "Book ID (optional) and chapter number")
   .option("--json", "Output JSON")
   .action(async (args: ReadonlyArray<string>, opts) => {
@@ -132,7 +132,7 @@ reviewCommand
       if (opts.json) {
         log(JSON.stringify({ bookId, chapter: chapterNum, status: "approved" }));
       } else {
-        log(`Chapter ${chapterNum} approved.`);
+        log(`Chapter ${chapterNum} approved (state committed).`);
       }
     } catch (e) {
       if (opts.json) {
@@ -186,9 +186,10 @@ reviewCommand
 
 reviewCommand
   .command("reject")
-  .description("Reject a chapter: reject [book-id] <chapter>")
+  .description("Reject a chapter and roll back state: reject [book-id] <chapter>")
   .argument("<args...>", "Book ID (optional) and chapter number")
   .option("--reason <reason>", "Rejection reason")
+  .option("--keep-subsequent", "Only reject this chapter, do not discard subsequent chapters")
   .option("--json", "Output JSON")
   .action(async (args: ReadonlyArray<string>, opts) => {
     try {
@@ -197,24 +198,49 @@ reviewCommand
       const bookId = await resolveBookId(bookIdArg, root);
 
       const state = new StateManager(root);
-      const index = [...(await state.loadChapterIndex(bookId))];
+      const index = await state.loadChapterIndex(bookId);
       const idx = index.findIndex((ch) => ch.number === chapterNum);
       if (idx === -1) {
         throw new Error(`Chapter ${chapterNum} not found in "${bookId}"`);
       }
 
-      index[idx] = {
-        ...index[idx]!,
-        status: "rejected",
-        reviewNote: opts.reason ?? "Rejected without reason",
-        updatedAt: new Date().toISOString(),
-      };
-      await state.saveChapterIndex(bookId, index);
+      if (opts.keepSubsequent) {
+        // Legacy behavior: only mark as rejected, no state rollback
+        const updated = [...index];
+        updated[idx] = {
+          ...updated[idx]!,
+          status: "rejected",
+          reviewNote: opts.reason ?? "Rejected without reason",
+          updatedAt: new Date().toISOString(),
+        };
+        await state.saveChapterIndex(bookId, updated);
+
+        if (opts.json) {
+          log(JSON.stringify({ bookId, chapter: chapterNum, status: "rejected", discarded: [] }));
+        } else {
+          log(`Chapter ${chapterNum} rejected (state not rolled back).`);
+        }
+        return;
+      }
+
+      // Default: roll back state to before the rejected chapter and discard
+      // it along with all subsequent chapters that depend on its state.
+      const rollbackTarget = chapterNum - 1;
+      const discarded = await state.rollbackToChapter(bookId, rollbackTarget);
 
       if (opts.json) {
-        log(JSON.stringify({ bookId, chapter: chapterNum, status: "rejected" }));
+        log(JSON.stringify({
+          bookId,
+          chapter: chapterNum,
+          status: "rejected",
+          rolledBackTo: rollbackTarget,
+          discarded,
+        }));
       } else {
-        log(`Chapter ${chapterNum} rejected.`);
+        log(`Chapter ${chapterNum} rejected. State rolled back to chapter ${rollbackTarget}.`);
+        if (discarded.length > 1) {
+          log(`  Also discarded ${discarded.length - 1} subsequent chapter(s): ${discarded.filter((n) => n !== chapterNum).join(", ")}`);
+        }
       }
     } catch (e) {
       if (opts.json) {

packages/cli/src/commands/status.ts

@@ -44,6 +44,9 @@ export const statusCommand = new Command("status")
         const failed = index.filter(
           (ch) => ch.status === "audit-failed",
         ).length;
+        const degraded = index.filter(
+          (ch) => ch.status === "state-degraded",
+        ).length;
         const totalWords = index.reduce((sum, ch) => sum + ch.wordCount, 0);
         const avgWords = index.length > 0 ? Math.round(totalWords / index.length) : 0;
 
@@ -60,6 +63,7 @@ export const statusCommand = new Command("status")
           approved,
           pending,
           failed,
+          degraded,
           ...(migrationHint ? { migrationHint } : {}),
           ...(opts.chapters ? {
             chapterList: index.map((ch) => ({
@@ -67,7 +71,9 @@ export const statusCommand = new Command("status")
               title: ch.title,
               status: ch.status,
               wordCount: ch.wordCount,
-              ...(ch.status === "audit-failed" ? { issues: ch.auditIssues } : {}),
+              ...(ch.status === "audit-failed" || ch.status === "state-degraded"
+                ? { issues: ch.auditIssues }
+                : {}),
             })),
           } : {}),
         });
@@ -78,7 +84,7 @@ export const statusCommand = new Command("status")
           log(`    Platform: ${book.platform} | Genre: ${book.genre}`);
           log(`    Chapters: ${persistedChapterCount} / ${book.targetChapters}`);
           log(`    Words: ${totalWords.toLocaleString()} (avg ${avgWords}/ch)`);
-          log(`    Approved: ${approved} | Pending: ${pending} | Failed: ${failed}`);
+          log(`    Approved: ${approved} | Pending: ${pending} | Failed: ${failed} | Degraded: ${degraded}`);
           if (migrationHint) {
             log(`    Migration: ${migrationHint}`);
           }
@@ -86,9 +92,15 @@ export const statusCommand = new Command("status")
           if (opts.chapters && index.length > 0) {
             log("");
             for (const ch of index) {
-              const icon = ch.status === "approved" ? "+" : ch.status === "audit-failed" ? "!" : "~";
+              const icon = ch.status === "approved"
+                ? "+"
+                : ch.status === "audit-failed"
+                  ? "!"
+                  : ch.status === "state-degraded"
+                    ? "x"
+                    : "~";
               log(`    [${icon}] Ch.${ch.number} "${ch.title}" | ${formatLengthCount(ch.wordCount, countingMode)} | ${ch.status}`);
-              if (ch.status === "audit-failed" && ch.auditIssues.length > 0) {
+              if ((ch.status === "audit-failed" || ch.status === "state-degraded") && ch.auditIssues.length > 0) {
                 const criticals = ch.auditIssues.filter((i: string) => i.startsWith("[critical]"));
                 const warnings = ch.auditIssues.filter((i: string) => i.startsWith("[warning]"));
                 if (criticals.length > 0) {
@@ -97,7 +109,13 @@ export const statusCommand = new Command("status")
                   }
                 }
                 if (warnings.length > 0) {
-                  log(`        + ${warnings.length} warning(s)`);
+                  if (ch.status === "state-degraded") {
+                    for (const issue of warnings) {
+                      log(`        ${issue}`);
+                    }
+                  } else {
+                    log(`        + ${warnings.length} warning(s)`);
+                  }
                 }
               }
             }

packages/cli/src/commands/write.ts

@@ -59,6 +59,15 @@ writeCommand
           }
           log("");
         }
+
+        if (result.status === "state-degraded") {
+          if (!opts.json) {
+            log(language === "en"
+              ? "State repair required before continuing. Stopping batch."
+              : "需要先修复 state，已停止后续连写。");
+          }
+          break;
+        }
       }
 
       if (opts.json) {
@@ -189,3 +198,58 @@ writeCommand
       process.exit(1);
     }
   });
+
+writeCommand
+  .command("repair-state")
+  .description("Rebuild truth files for a persisted state-degraded chapter without rewriting body text")
+  .argument("<args...>", "Book ID (optional) and chapter number")
+  .option("--json", "Output JSON")
+  .action(async (args: ReadonlyArray<string>, opts) => {
+    try {
+      const root = findProjectRoot();
+
+      let bookId: string;
+      let chapter: number;
+      if (args.length === 1) {
+        chapter = parseInt(args[0]!, 10);
+        if (isNaN(chapter)) throw new Error(`Expected chapter number, got "${args[0]}"`);
+        bookId = await resolveBookId(undefined, root);
+      } else if (args.length === 2) {
+        chapter = parseInt(args[1]!, 10);
+        if (isNaN(chapter)) throw new Error(`Expected chapter number, got "${args[1]}"`);
+        bookId = await resolveBookId(args[0], root);
+      } else {
+        throw new Error("Usage: inkos write repair-state [book-id] <chapter>");
+      }
+
+      const state = new StateManager(root);
+      const book = await state.loadBookConfig(bookId);
+      const language = resolveCliLanguage(book.language);
+      const config = await loadConfig();
+      const pipeline = new PipelineRunner(buildPipelineConfig(config, root));
+      const result = await pipeline.repairChapterState(bookId, chapter);
+
+      if (opts.json) {
+        log(JSON.stringify(result, null, 2));
+      } else {
+        for (const line of formatWriteNextResultLines(language, {
+          chapterNumber: result.chapterNumber,
+          title: result.title,
+          wordCount: result.wordCount,
+          auditPassed: result.auditResult.passed,
+          revised: result.revised,
+          status: result.status,
+          issues: result.auditResult.issues,
+        })) {
+          log(line);
+        }
+      }
+    } catch (e) {
+      if (opts.json) {
+        log(JSON.stringify({ error: String(e) }));
+      } else {
+        logError(`Failed to repair chapter state: ${e}`);
+      }
+      process.exit(1);
+    }
+  });

packages/core/src/__tests__/architect.test.ts

@@ -206,7 +206,7 @@ describe("ArchitectAgent", () => {
 
     const result = await agent.generateFoundation(book);
 
-    expect(result.pendingHooks).toContain("| H01 | 1 | 主线 | 未开启 | 0 | 10章 | 主线核心钩子 |");
+    expect(result.pendingHooks).toContain("| H01 | 1 | 主线 | 未开启 | 0 | 10章 | 中程 | 主线核心钩子 |");
     expect(result.pendingHooks).not.toContain("如果你愿意");
     expect(result.pendingHooks).not.toContain("前10章逐章细纲");
   });
@@ -268,7 +268,7 @@ describe("ArchitectAgent", () => {
 
     const result = await agent.generateFoundation(book);
 
-    expect(result.pendingHooks).toContain("| H13 | 22 | 舆情操盘 | 待推进 | 0 | 51-60章 | 庄蔓出场后逐步揭露（初始线索：一家自媒体公司在多个旧案节点同步接单） |");
+    expect(result.pendingHooks).toContain("| H13 | 22 | 舆情操盘 | 待推进 | 0 | 51-60章 | 中程 | 庄蔓出场后逐步揭露（初始线索：一家自媒体公司在多个旧案节点同步接单） |");
   });
 
   it("accepts section labels with spacing and punctuation drift from non-strict models", async () => {
@@ -332,7 +332,7 @@ describe("ArchitectAgent", () => {
     expect(result.volumeOutline).toBe("# 卷纲");
     expect(result.bookRules).toContain("version: \"1.0\"");
     expect(result.currentState).toBe("# 当前状态");
-    expect(result.pendingHooks).toContain("| H01 | 1 | mystery | open | 0 | 10章 | 初始钩子 |");
+    expect(result.pendingHooks).toContain("| H01 | 1 | mystery | open | 0 | 10章 | 中程 | 初始钩子 |");
   });
 
   it("throws when a required foundation section is missing", async () => {

packages/core/src/__tests__/cadence-policy.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import {
+  CADENCE_PRESSURE_THRESHOLDS,
+  CADENCE_WINDOW_DEFAULTS,
+  LONG_SPAN_FATIGUE_THRESHOLDS,
+  resolveCadencePressure,
+} from "../utils/cadence-policy.js";
+
+describe("cadence-policy", () => {
+  it("exposes shared cadence and fatigue defaults from one policy surface", () => {
+    expect(CADENCE_WINDOW_DEFAULTS.summaryLookback).toBe(4);
+    expect(CADENCE_WINDOW_DEFAULTS.englishVarianceLookback).toBeGreaterThan(
+      CADENCE_WINDOW_DEFAULTS.summaryLookback,
+    );
+    expect(LONG_SPAN_FATIGUE_THRESHOLDS.boundarySimilarityFloor).toBe(0.72);
+    expect(LONG_SPAN_FATIGUE_THRESHOLDS.boundarySentenceMinLength).toBe(18);
+  });
+
+  it("resolves shared medium/high cadence pressure without duplicating threshold logic", () => {
+    expect(resolveCadencePressure({
+      count: 3,
+      total: 4,
+      highThreshold: CADENCE_PRESSURE_THRESHOLDS.scene.highCount,
+      mediumThreshold: CADENCE_PRESSURE_THRESHOLDS.scene.mediumCount,
+      mediumWindowFloor: CADENCE_PRESSURE_THRESHOLDS.scene.mediumWindowFloor,
+    })).toBe("high");
+
+    expect(resolveCadencePressure({
+      count: 2,
+      total: 4,
+      highThreshold: CADENCE_PRESSURE_THRESHOLDS.mood.highCount,
+      mediumThreshold: CADENCE_PRESSURE_THRESHOLDS.mood.mediumCount,
+      mediumWindowFloor: CADENCE_PRESSURE_THRESHOLDS.mood.mediumWindowFloor,
+    })).toBe("medium");
+
+    expect(resolveCadencePressure({
+      count: 1,
+      total: 3,
+      highThreshold: CADENCE_PRESSURE_THRESHOLDS.title.highCount,
+      mediumThreshold: CADENCE_PRESSURE_THRESHOLDS.title.mediumCount,
+      mediumWindowFloor: CADENCE_PRESSURE_THRESHOLDS.title.mediumWindowFloor,
+    })).toBeUndefined();
+  });
+});

packages/core/src/__tests__/chapter-cadence.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from "vitest";
+import { analyzeChapterCadence } from "../utils/chapter-cadence.js";
+
+describe("analyzeChapterCadence", () => {
+  it("surfaces stacked scene, mood, and title pressure from recent summary rows", () => {
+    const analysis = analyzeChapterCadence({
+      language: "zh",
+      rows: [
+        {
+          chapter: 1,
+          title: "名单之前",
+          mood: "紧张、压抑",
+          chapterType: "调查章",
+        },
+        {
+          chapter: 2,
+          title: "名单之后",
+          mood: "冷硬、逼仄",
+          chapterType: "调查章",
+        },
+        {
+          chapter: 3,
+          title: "名单还在",
+          mood: "压迫、窒息",
+          chapterType: "调查章",
+        },
+        {
+          chapter: 4,
+          title: "名单未落",
+          mood: "肃杀、凝重",
+          chapterType: "调查章",
+        },
+      ],
+    });
+
+    expect(analysis.scenePressure).toEqual(expect.objectContaining({
+      repeatedType: "调查章",
+      pressure: "high",
+      streak: 4,
+    }));
+    expect(analysis.moodPressure).toEqual(expect.objectContaining({
+      pressure: "high",
+      highTensionStreak: 4,
+    }));
+    expect(analysis.titlePressure).toEqual(expect.objectContaining({
+      repeatedToken: "名单",
+      pressure: "high",
+      count: 4,
+    }));
+  });
+
+  it("stays quiet when scene, mood, and title cadence are varied", () => {
+    const analysis = analyzeChapterCadence({
+      language: "en",
+      rows: [
+        {
+          chapter: 1,
+          title: "Morning Harbor",
+          mood: "warm, gentle",
+          chapterType: "slice-of-life",
+        },
+        {
+          chapter: 2,
+          title: "Sudden Rain",
+          mood: "tense, ominous",
+          chapterType: "tension",
+        },
+        {
+          chapter: 3,
+          title: "Open Gate",
+          mood: "hopeful, light",
+          chapterType: "transition",
+        },
+        {
+          chapter: 4,
+          title: "After the Letter",
+          mood: "melancholy, reflective",
+          chapterType: "introspection",
+        },
+      ],
+    });
+
+    expect(analysis.scenePressure).toBeUndefined();
+    expect(analysis.moodPressure).toBeUndefined();
+    expect(analysis.titlePressure).toBeUndefined();
+  });
+});

packages/core/src/__tests__/chapter-persistence.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it, vi } from "vitest";
+import type { AuditIssue, AuditResult } from "../agents/continuity.js";
+import type { ChapterMeta } from "../models/chapter.js";
+import { persistChapterArtifacts } from "../pipeline/chapter-persistence.js";
+
+const ZERO_USAGE = {
+  promptTokens: 0,
+  completionTokens: 0,
+  totalTokens: 0,
+} as const;
+
+function createIssue(overrides?: Partial<AuditIssue>): AuditIssue {
+  return {
+    severity: "warning",
+    category: "continuity",
+    description: "issue",
+    suggestion: "fix",
+    ...overrides,
+  };
+}
+
+function createAuditResult(overrides?: Partial<AuditResult>): AuditResult {
+  return {
+    passed: true,
+    issues: [],
+    summary: "clean",
+    ...overrides,
+  };
+}
+
+describe("persistChapterArtifacts", () => {
+  it("persists truth files, index, drift guidance, and snapshots for reviewable chapters", async () => {
+    const saveChapter = vi.fn().mockResolvedValue(undefined);
+    const saveTruthFiles = vi.fn().mockResolvedValue(undefined);
+    const saveChapterIndex = vi.fn().mockResolvedValue(undefined);
+    const markBookActiveIfNeeded = vi.fn().mockResolvedValue(undefined);
+    const persistAuditDriftGuidance = vi.fn().mockResolvedValue(undefined);
+    const snapshotState = vi.fn().mockResolvedValue(undefined);
+    const syncCurrentStateFactHistory = vi.fn().mockResolvedValue(undefined);
+    const logSnapshotStage = vi.fn();
+
+    await persistChapterArtifacts({
+      chapterNumber: 3,
+      chapterTitle: "Chapter Title",
+      status: "ready-for-review",
+      auditResult: createAuditResult({
+        issues: [
+          createIssue({ severity: "info", description: "ignore me" }),
+          createIssue({ severity: "warning", description: "keep me" }),
+          createIssue({ severity: "critical", description: "keep me too" }),
+        ],
+      }),
+      finalWordCount: 888,
+      lengthWarnings: ["warn"],
+      degradedIssues: [],
+      tokenUsage: ZERO_USAGE,
+      loadChapterIndex: async () => [] satisfies ReadonlyArray<ChapterMeta>,
+      saveChapter,
+      saveTruthFiles,
+      saveChapterIndex,
+      markBookActiveIfNeeded,
+      persistAuditDriftGuidance,
+      snapshotState,
+      syncCurrentStateFactHistory,
+      logSnapshotStage,
+      now: () => "2026-04-01T00:00:00.000Z",
+    });
+
+    expect(saveChapter).toHaveBeenCalledTimes(1);
+    expect(saveTruthFiles).toHaveBeenCalledTimes(1);
+    expect(saveChapterIndex).toHaveBeenCalledWith([
+      expect.objectContaining({
+        number: 3,
+        title: "Chapter Title",
+        status: "ready-for-review",
+        wordCount: 888,
+        auditIssues: [
+          "[info] ignore me",
+          "[warning] keep me",
+          "[critical] keep me too",
+        ],
+        reviewNote: undefined,
+        tokenUsage: ZERO_USAGE,
+      }),
+    ]);
+    expect(markBookActiveIfNeeded).toHaveBeenCalledTimes(1);
+    expect(persistAuditDriftGuidance).toHaveBeenCalledWith([
+      expect.objectContaining({ severity: "warning", description: "keep me" }),
+      expect.objectContaining({ severity: "critical", description: "keep me too" }),
+    ]);
+    expect(logSnapshotStage).toHaveBeenCalledTimes(1);
+    expect(snapshotState).toHaveBeenCalledTimes(1);
+    expect(syncCurrentStateFactHistory).toHaveBeenCalledTimes(1);
+  });
+
+  it("skips truth persistence and snapshots for state-degraded chapters while preserving review note", async () => {
+    const saveChapter = vi.fn().mockResolvedValue(undefined);
+    const saveTruthFiles = vi.fn().mockResolvedValue(undefined);
+    const saveChapterIndex = vi.fn().mockResolvedValue(undefined);
+    const markBookActiveIfNeeded = vi.fn().mockResolvedValue(undefined);
+    const persistAuditDriftGuidance = vi.fn().mockResolvedValue(undefined);
+    const snapshotState = vi.fn().mockResolvedValue(undefined);
+    const syncCurrentStateFactHistory = vi.fn().mockResolvedValue(undefined);
+    const logSnapshotStage = vi.fn();
+
+    await persistChapterArtifacts({
+      chapterNumber: 4,
+      chapterTitle: "Degraded Chapter",
+      status: "state-degraded",
+      auditResult: createAuditResult({
+        passed: false,
+        issues: [createIssue({ description: "audit issue" })],
+        summary: "needs review",
+      }),
+      finalWordCount: 512,
+      lengthWarnings: [],
+      degradedIssues: [createIssue({ description: "state mismatch" })],
+      tokenUsage: ZERO_USAGE,
+      loadChapterIndex: async () => [] satisfies ReadonlyArray<ChapterMeta>,
+      saveChapter,
+      saveTruthFiles,
+      saveChapterIndex,
+      markBookActiveIfNeeded,
+      persistAuditDriftGuidance,
+      snapshotState,
+      syncCurrentStateFactHistory,
+      logSnapshotStage,
+      now: () => "2026-04-01T00:00:00.000Z",
+    });
+
+    expect(saveChapter).toHaveBeenCalledTimes(1);
+    expect(saveTruthFiles).not.toHaveBeenCalled();
+    expect(saveChapterIndex).toHaveBeenCalledWith([
+      expect.objectContaining({
+        number: 4,
+        title: "Degraded Chapter",
+        status: "state-degraded",
+        reviewNote: expect.any(String),
+      }),
+    ]);
+    const reviewNote = saveChapterIndex.mock.calls[0]?.[0]?.[0]?.reviewNote as string;
+    expect(JSON.parse(reviewNote)).toMatchObject({
+      kind: "state-degraded",
+      baseStatus: "audit-failed",
+      injectedIssues: ["[warning] state mismatch"],
+    });
+    expect(persistAuditDriftGuidance).toHaveBeenCalledWith([]);
+    expect(logSnapshotStage).not.toHaveBeenCalled();
+    expect(snapshotState).not.toHaveBeenCalled();
+    expect(syncCurrentStateFactHistory).not.toHaveBeenCalled();
+  });
+});

packages/core/src/__tests__/chapter-review-cycle.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it, vi } from "vitest";
+import { runChapterReviewCycle } from "../pipeline/chapter-review-cycle.js";
+import type { AuditResult, AuditIssue } from "../agents/continuity.js";
+import type { LengthSpec } from "../models/length-governance.js";
+
+const LENGTH_SPEC: LengthSpec = {
+  target: 220,
+  softMin: 190,
+  softMax: 250,
+  hardMin: 160,
+  hardMax: 280,
+  countingMode: "zh_chars",
+  normalizeMode: "none",
+};
+
+const ZERO_USAGE = {
+  promptTokens: 0,
+  completionTokens: 0,
+  totalTokens: 0,
+} as const;
+
+function createAuditResult(overrides?: Partial<AuditResult>): AuditResult {
+  return {
+    passed: true,
+    issues: [],
+    summary: "clean",
+    ...overrides,
+  };
+}
+
+describe("runChapterReviewCycle", () => {
+  it("applies post-write spot-fix before the first audit pass", async () => {
+    const auditChapter = vi.fn()
+      .mockResolvedValue(createAuditResult());
+    const reviseChapter = vi.fn().mockResolvedValue({
+      revisedContent: "fixed draft",
+      wordCount: 10,
+      fixedIssues: ["fixed"],
+      updatedState: "",
+      updatedLedger: "",
+      updatedHooks: "",
+      tokenUsage: ZERO_USAGE,
+    });
+    const normalizeDraftLengthIfNeeded = vi.fn()
+      .mockResolvedValue({
+        content: "fixed draft",
+        wordCount: 10,
+        applied: false,
+        tokenUsage: ZERO_USAGE,
+      });
+
+    const result = await runChapterReviewCycle({
+      book: { genre: "xuanhuan" },
+      bookDir: "/tmp/book",
+      chapterNumber: 1,
+      initialOutput: {
+        content: "raw draft",
+        wordCount: 9,
+        postWriteErrors: [{
+          rule: "paragraph-shape",
+          description: "too fragmented",
+          suggestion: "merge short fragments",
+          severity: "error",
+        }],
+      },
+      lengthSpec: LENGTH_SPEC,
+      reducedControlInput: undefined,
+      initialUsage: ZERO_USAGE,
+      createReviser: () => ({ reviseChapter }),
+      auditor: { auditChapter },
+      normalizeDraftLengthIfNeeded,
+      assertChapterContentNotEmpty: () => undefined,
+      addUsage: (left, right) => ({
+        promptTokens: left.promptTokens + (right?.promptTokens ?? 0),
+        completionTokens: left.completionTokens + (right?.completionTokens ?? 0),
+        totalTokens: left.totalTokens + (right?.totalTokens ?? 0),
+      }),
+      restoreLostAuditIssues: (_previous, next) => next,
+      analyzeAITells: () => ({ issues: [] as AuditIssue[] }),
+      analyzeSensitiveWords: () => ({ found: [] as Array<{ severity: "warn" | "block" }>, issues: [] as AuditIssue[] }),
+      logWarn: () => undefined,
+      logStage: () => undefined,
+    });
+
+    expect(reviseChapter).toHaveBeenCalledTimes(1);
+    expect(auditChapter).toHaveBeenCalledTimes(1);
+    expect(auditChapter).toHaveBeenCalledWith(
+      "/tmp/book",
+      "fixed draft",
+      1,
+      "xuanhuan",
+      undefined,
+    );
+    expect(result.finalContent).toBe("fixed draft");
+    expect(result.revised).toBe(true);
+  });
+
+  it("drops auto-revision when it increases AI tells and re-audits the original draft", async () => {
+    const failingAudit = createAuditResult({
+      passed: false,
+      issues: [{
+        severity: "critical",
+        category: "continuity",
+        description: "broken continuity",
+        suggestion: "fix it",
+      }],
+      summary: "bad",
+    });
+    const auditChapter = vi.fn()
+      .mockResolvedValueOnce(failingAudit)
+      .mockResolvedValueOnce(createAuditResult());
+    const reviseChapter = vi.fn().mockResolvedValue({
+      revisedContent: "rewritten draft",
+      wordCount: 15,
+      fixedIssues: ["fixed"],
+      updatedState: "",
+      updatedLedger: "",
+      updatedHooks: "",
+      tokenUsage: ZERO_USAGE,
+    });
+    const normalizeDraftLengthIfNeeded = vi.fn()
+      .mockResolvedValueOnce({
+        content: "original draft",
+        wordCount: 13,
+        applied: false,
+        tokenUsage: ZERO_USAGE,
+      })
+      .mockResolvedValueOnce({
+        content: "rewritten draft",
+        wordCount: 15,
+        applied: false,
+        tokenUsage: ZERO_USAGE,
+      });
+    const analyzeAITells = vi.fn((content: string) => ({
+      issues: content === "rewritten draft"
+        ? [{ severity: "warning", category: "ai", description: "more ai", suggestion: "reduce" } satisfies AuditIssue]
+        : [],
+    }));
+
+    const result = await runChapterReviewCycle({
+      book: { genre: "xuanhuan" },
+      bookDir: "/tmp/book",
+      chapterNumber: 1,
+      initialOutput: {
+        content: "original draft",
+        wordCount: 13,
+        postWriteErrors: [],
+      },
+      lengthSpec: LENGTH_SPEC,
+      reducedControlInput: undefined,
+      initialUsage: ZERO_USAGE,
+      createReviser: () => ({ reviseChapter }),
+      auditor: { auditChapter },
+      normalizeDraftLengthIfNeeded,
+      assertChapterContentNotEmpty: () => undefined,
+      addUsage: (left, right) => ({
+        promptTokens: left.promptTokens + (right?.promptTokens ?? 0),
+        completionTokens: left.completionTokens + (right?.completionTokens ?? 0),
+        totalTokens: left.totalTokens + (right?.totalTokens ?? 0),
+      }),
+      restoreLostAuditIssues: (_previous, next) => next,
+      analyzeAITells,
+      analyzeSensitiveWords: () => ({ found: [] as Array<{ severity: "warn" | "block" }>, issues: [] as AuditIssue[] }),
+      logWarn: () => undefined,
+      logStage: () => undefined,
+    });
+
+    expect(reviseChapter).toHaveBeenCalledTimes(1);
+    expect(auditChapter).toHaveBeenNthCalledWith(1, "/tmp/book", "original draft", 1, "xuanhuan", undefined);
+    expect(auditChapter).toHaveBeenNthCalledWith(2, "/tmp/book", "original draft", 1, "xuanhuan", { temperature: 0 });
+    expect(result.finalContent).toBe("original draft");
+    expect(result.revised).toBe(false);
+  });
+});

packages/core/src/__tests__/chapter-state-recovery.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, it, vi } from "vitest";
+import type { AuditIssue } from "../agents/continuity.js";
+import type {
+  ValidationResult,
+  ValidationWarning,
+} from "../agents/state-validator.js";
+import type { WriteChapterOutput } from "../agents/writer.js";
+import type { BookConfig } from "../models/book.js";
+import type { ChapterMeta } from "../models/chapter.js";
+import {
+  buildStateDegradedPersistenceOutput,
+  buildStateDegradedReviewNote,
+  parseStateDegradedReviewNote,
+  resolveStateDegradedBaseStatus,
+  retrySettlementAfterValidationFailure,
+} from "../pipeline/chapter-state-recovery.js";
+
+function createBook(): BookConfig {
+  return {
+    id: "test-book",
+    title: "Test Book",
+    platform: "tomato",
+    genre: "xuanhuan",
+    status: "active",
+    targetChapters: 10,
+    chapterWordCount: 3000,
+    createdAt: "2026-04-01T00:00:00.000Z",
+    updatedAt: "2026-04-01T00:00:00.000Z",
+  };
+}
+
+function createValidationWarning(
+  overrides: Partial<ValidationWarning> = {},
+): ValidationWarning {
+  return {
+    category: overrides.category ?? "current-state",
+    description: overrides.description ?? "铜牌位置与正文矛盾",
+  };
+}
+
+function createValidationResult(
+  overrides: Partial<ValidationResult> = {},
+): ValidationResult {
+  return {
+    passed: overrides.passed ?? false,
+    warnings: overrides.warnings ?? [createValidationWarning()],
+  };
+}
+
+function createWriteChapterOutput(
+  overrides: Partial<WriteChapterOutput> = {},
+): WriteChapterOutput {
+  return {
+    chapterNumber: 3,
+    title: "第三章",
+    content: "铜牌贴在胸口。",
+    wordCount: "铜牌贴在胸口。".length,
+    preWriteCheck: "ok",
+    postSettlement: "ok",
+    updatedState: "new state",
+    updatedLedger: "new ledger",
+    updatedHooks: "new hooks",
+    chapterSummary: "| 3 | 第三章 |",
+    updatedSubplots: "new subplots",
+    updatedEmotionalArcs: "new emotional arcs",
+    updatedCharacterMatrix: "new character matrix",
+    postWriteErrors: [],
+    postWriteWarnings: [],
+    ...overrides,
+  };
+}
+
+function createChapterMeta(
+  overrides: Partial<ChapterMeta> = {},
+): ChapterMeta {
+  return {
+    number: 3,
+    title: "第三章",
+    status: "state-degraded",
+    wordCount: 1200,
+    createdAt: "2026-04-01T00:00:00.000Z",
+    updatedAt: "2026-04-01T00:00:00.000Z",
+    auditIssues: [],
+    lengthWarnings: [],
+    ...overrides,
+  };
+}
+
+describe("chapter-state-recovery", () => {
+  it("retries settlement with localized validation feedback and recovers on a clean retry", async () => {
+    let capturedFeedback = "";
+    const writer = {
+      settleChapterState: vi.fn(async (input: { validationFeedback?: string }) => {
+        capturedFeedback = input.validationFeedback ?? "";
+        return createWriteChapterOutput({
+          updatedState: "fixed state",
+          updatedHooks: "fixed hooks",
+        });
+      }),
+    };
+    const validator = {
+      validate: vi.fn(async () => createValidationResult({
+        passed: true,
+        warnings: [],
+      })),
+    };
+    const logWarn = vi.fn();
+    const warn = vi.fn();
+
+    const result = await retrySettlementAfterValidationFailure({
+      writer: writer as never,
+      validator: validator as never,
+      book: createBook(),
+      bookDir: "/tmp/test-book",
+      chapterNumber: 3,
+      title: "第三章",
+      content: "铜牌贴在胸口。",
+      oldState: "old state",
+      oldHooks: "old hooks",
+      originalValidation: createValidationResult(),
+      language: "zh",
+      logWarn,
+      logger: { warn } as never,
+    });
+
+    expect(result.kind).toBe("recovered");
+    expect(capturedFeedback).toContain("上一次状态结算未通过校验");
+    expect(capturedFeedback).toContain("铜牌位置与正文矛盾");
+    expect(logWarn).toHaveBeenCalledWith(expect.objectContaining({
+      zh: expect.stringContaining("仅重试结算层"),
+    }));
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it("returns localized degraded issues when settlement retry still fails", async () => {
+    const validatorWarning = createValidationWarning({
+      description: "挂坠状态仍与正文冲突",
+    });
+    const result = await retrySettlementAfterValidationFailure({
+      writer: {
+        settleChapterState: vi.fn(async () => createWriteChapterOutput()),
+      } as never,
+      validator: {
+        validate: vi.fn(async () => createValidationResult({
+          passed: false,
+          warnings: [validatorWarning],
+        })),
+      } as never,
+      book: createBook(),
+      bookDir: "/tmp/test-book",
+      chapterNumber: 3,
+      title: "第三章",
+      content: "铜牌贴在胸口。",
+      oldState: "old state",
+      oldHooks: "old hooks",
+      originalValidation: createValidationResult({
+        warnings: [validatorWarning],
+      }),
+      language: "zh",
+      logWarn: vi.fn(),
+      logger: { warn: vi.fn() } as never,
+    });
+
+    expect(result.kind).toBe("degraded");
+    if (result.kind === "degraded") {
+      expect(result.issues).toEqual([
+        expect.objectContaining({
+          category: "state-validation",
+          description: "挂坠状态仍与正文冲突",
+          suggestion: "请先基于已保存正文修复本章 state，再继续后续章节。",
+        }),
+      ]);
+    }
+  });
+
+  it("freezes truth outputs when degrading persisted settlement", () => {
+    const output = createWriteChapterOutput({
+      runtimeStateDelta: { chapter: 3 } as never,
+      runtimeStateSnapshot: {
+        chapter: 3,
+        facts: [],
+        hooks: [],
+        chapterSummary: undefined,
+      } as never,
+      updatedChapterSummaries: "| 3 | 新摘要 |",
+    });
+
+    const degraded = buildStateDegradedPersistenceOutput({
+      output,
+      oldState: "stable state",
+      oldHooks: "stable hooks",
+      oldLedger: "stable ledger",
+    });
+
+    expect(degraded.updatedState).toBe("stable state");
+    expect(degraded.updatedHooks).toBe("stable hooks");
+    expect(degraded.updatedLedger).toBe("stable ledger");
+    expect(degraded.runtimeStateDelta).toBeUndefined();
+    expect(degraded.runtimeStateSnapshot).toBeUndefined();
+    expect(degraded.updatedChapterSummaries).toBeUndefined();
+  });
+
+  it("round-trips degraded review metadata and resolves fallback base status", () => {
+    const issues: AuditIssue[] = [{
+      severity: "warning",
+      category: "state-validation",
+      description: "状态结算重试后仍未通过校验。",
+      suggestion: "请先基于已保存正文修复本章 state，再继续后续章节。",
+    }];
+    const note = buildStateDegradedReviewNote("audit-failed", issues);
+
+    expect(parseStateDegradedReviewNote(note)).toEqual({
+      kind: "state-degraded",
+      baseStatus: "audit-failed",
+      injectedIssues: ["[warning] 状态结算重试后仍未通过校验。"],
+    });
+
+    expect(resolveStateDegradedBaseStatus(createChapterMeta({
+      reviewNote: note,
+    }))).toBe("audit-failed");
+
+    expect(resolveStateDegradedBaseStatus(createChapterMeta({
+      reviewNote: "{bad json",
+      auditIssues: ["[critical] still broken"],
+    }))).toBe("audit-failed");
+
+    expect(resolveStateDegradedBaseStatus(createChapterMeta({
+      reviewNote: "{bad json",
+      auditIssues: ["[warning] needs review"],
+    }))).toBe("ready-for-review");
+  });
+});

packages/core/src/__tests__/chapter-truth-validation.test.ts

@@ -0,0 +1,205 @@
+import { describe, expect, it, vi } from "vitest";
+import type { AuditIssue, AuditResult } from "../agents/continuity.js";
+import type { ValidationResult } from "../agents/state-validator.js";
+import type { WriteChapterOutput } from "../agents/writer.js";
+import type { BookConfig } from "../models/book.js";
+import { validateChapterTruthPersistence } from "../pipeline/chapter-truth-validation.js";
+
+const ZERO_USAGE = {
+  promptTokens: 0,
+  completionTokens: 0,
+  totalTokens: 0,
+} as const;
+
+function createAuditResult(overrides?: Partial<AuditResult>): AuditResult {
+  return {
+    passed: true,
+    issues: [],
+    summary: "clean",
+    tokenUsage: ZERO_USAGE,
+    ...overrides,
+  };
+}
+
+function createValidationResult(overrides?: Partial<ValidationResult>): ValidationResult {
+  return {
+    passed: true,
+    warnings: [],
+    ...overrides,
+  };
+}
+
+function createWriterOutput(overrides: Partial<WriteChapterOutput> = {}): WriteChapterOutput {
+  return {
+    chapterNumber: 1,
+    title: "Test Chapter",
+    content: "Healthy chapter body with the copper token in his coat.",
+    wordCount: "Healthy chapter body with the copper token in his coat.".length,
+    preWriteCheck: "check",
+    postSettlement: "settled",
+    updatedState: "writer state",
+    updatedLedger: "writer ledger",
+    updatedHooks: "writer hooks",
+    chapterSummary: "| 1 | Original summary |",
+    updatedSubplots: "writer subplots",
+    updatedEmotionalArcs: "writer emotions",
+    updatedCharacterMatrix: "writer matrix",
+    postWriteErrors: [],
+    postWriteWarnings: [],
+    tokenUsage: ZERO_USAGE,
+    ...overrides,
+  };
+}
+
+const BOOK: BookConfig = {
+  id: "book-1",
+  title: "Book",
+  platform: "other",
+  genre: "xuanhuan",
+  status: "active",
+  targetChapters: 10,
+  chapterWordCount: 2000,
+  createdAt: "2026-04-01T00:00:00.000Z",
+  updatedAt: "2026-04-01T00:00:00.000Z",
+};
+
+describe("validateChapterTruthPersistence", () => {
+  it("uses recovered settlement output when retry succeeds", async () => {
+    const validator = {
+      validate: vi.fn()
+        .mockResolvedValueOnce(createValidationResult({
+          passed: false,
+          warnings: [{
+            category: "unsupported_change",
+            description: "正文写铜牌在怀里，但 state 说未携带。",
+          }],
+        }))
+        .mockResolvedValueOnce(createValidationResult()),
+    };
+    const writer = {
+      settleChapterState: vi.fn().mockResolvedValue(
+        createWriterOutput({
+          updatedState: "fixed state",
+          updatedHooks: "fixed hooks",
+          updatedLedger: "fixed ledger",
+        }),
+      ),
+    };
+    const logWarn = vi.fn();
+    const logger = { warn: vi.fn() };
+
+    const result = await validateChapterTruthPersistence({
+      writer,
+      validator,
+      book: BOOK,
+      bookDir: "/tmp/book",
+      chapterNumber: 3,
+      title: "Test Chapter",
+      content: "Healthy chapter body with the copper token in his coat.",
+      persistenceOutput: createWriterOutput({
+        updatedState: "broken state",
+        updatedHooks: "broken hooks",
+        updatedLedger: "broken ledger",
+      }),
+      auditResult: createAuditResult(),
+      previousTruth: {
+        oldState: "stable state",
+        oldHooks: "stable hooks",
+        oldLedger: "stable ledger",
+      },
+      language: "zh",
+      logWarn,
+      logger,
+    });
+
+    expect(writer.settleChapterState).toHaveBeenCalledTimes(1);
+    expect(writer.settleChapterState).toHaveBeenCalledWith(expect.objectContaining({
+      chapterNumber: 3,
+      title: "Test Chapter",
+      validationFeedback: expect.stringContaining("铜牌在怀里"),
+    }));
+    expect(result.chapterStatus).toBeNull();
+    expect(result.persistenceOutput.updatedState).toBe("fixed state");
+    expect(result.persistenceOutput.updatedHooks).toBe("fixed hooks");
+    expect(result.auditResult.issues).toEqual([]);
+    expect(logger.warn).toHaveBeenCalledWith("  [unsupported_change] 正文写铜牌在怀里，但 state 说未携带。");
+  });
+
+  it("degrades persistence output and appends audit issues when retry still fails", async () => {
+    const validator = {
+      validate: vi.fn()
+        .mockResolvedValueOnce(createValidationResult({
+          passed: false,
+          warnings: [{
+            category: "unsupported_change",
+            description: "第一次校验失败。",
+          }],
+        }))
+        .mockResolvedValueOnce(createValidationResult({
+          passed: false,
+          warnings: [{
+            category: "unsupported_change",
+            description: "重试后仍然失败。",
+          }],
+        })),
+    };
+    const writer = {
+      settleChapterState: vi.fn().mockResolvedValue(
+        createWriterOutput({
+          updatedState: "still broken state",
+          updatedHooks: "still broken hooks",
+          updatedLedger: "still broken ledger",
+        }),
+      ),
+    };
+    const baseIssue: AuditIssue = {
+      severity: "warning",
+      category: "title-dedup",
+      description: "title adjusted",
+      suggestion: "check title",
+    };
+
+    const result = await validateChapterTruthPersistence({
+      writer,
+      validator,
+      book: BOOK,
+      bookDir: "/tmp/book",
+      chapterNumber: 4,
+      title: "Test Chapter",
+      content: "Healthy chapter body with the copper token in his coat.",
+      persistenceOutput: createWriterOutput({
+        updatedState: "broken state",
+        updatedHooks: "broken hooks",
+        updatedLedger: "broken ledger",
+      }),
+      auditResult: createAuditResult({ issues: [baseIssue] }),
+      previousTruth: {
+        oldState: "stable state",
+        oldHooks: "stable hooks",
+        oldLedger: "stable ledger",
+      },
+      language: "zh",
+      logWarn: vi.fn(),
+      logger: { warn: vi.fn() },
+    });
+
+    expect(result.chapterStatus).toBe("state-degraded");
+    expect(result.degradedIssues).toEqual([
+      expect.objectContaining({
+        severity: "warning",
+        category: "state-validation",
+        description: "重试后仍然失败。",
+      }),
+    ]);
+    expect(result.persistenceOutput.updatedState).toBe("stable state");
+    expect(result.persistenceOutput.updatedHooks).toBe("stable hooks");
+    expect(result.persistenceOutput.updatedLedger).toBe("stable ledger");
+    expect(result.auditResult.issues).toEqual([
+      baseIssue,
+      expect.objectContaining({
+        category: "state-validation",
+        description: "重试后仍然失败。",
+      }),
+    ]);
+  });
+});

packages/core/src/__tests__/composer.test.ts

@@ -73,6 +73,7 @@ describe("ComposerAgent", () => {
           },
         ],
         hookAgenda: {
+          pressureMap: [],
           mustAdvance: [],
           eligibleResolve: [],
           staleDebt: [],
@@ -391,4 +392,180 @@ describe("ComposerAgent", () => {
     expect(volumeEntry).toBeDefined();
     expect(volumeEntry?.excerpt).toContain("mentor oath");
   });
+
+  it("adds explicit title history, mood trail, and canon evidence for governed writing", async () => {
+    await Promise.all([
+      writeFile(
+        join(storyDir, "chapter_summaries.md"),
+        [
+          "# Chapter Summaries",
+          "",
+          "| chapter | title | characters | events | stateChanges | hookActivity | mood | chapterType |",
+          "| --- | --- | --- | --- | --- | --- | --- | --- |",
+          "| 1 | Ledger in Rain | Lin Yue | First ledger clue appears | None | none | tight | investigation |",
+          "| 2 | Ledger at Dusk | Lin Yue | Second ledger clue appears | None | none | tight | investigation |",
+          "| 3 | Harbor Ledger | Lin Yue | Third ledger clue appears | None | none | tight | investigation |",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "parent_canon.md"),
+        "# Parent Canon\n\nThe mentor does not learn about the archive fire until volume two.\n",
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "fanfic_canon.md"),
+        "# Fanfic Canon\n\nMara may diverge from the archive route, but the oath debt logic must stay intact.\n",
+        "utf-8",
+      ),
+    ]);
+
+    const composer = new ComposerAgent({
+      client: {} as ConstructorParameters<typeof ComposerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await composer.composeChapter({
+      book,
+      bookDir,
+      chapterNumber: 4,
+      plan,
+    });
+
+    const selectedSources = result.contextPackage.selectedContext.map((entry) => entry.source);
+    expect(selectedSources).toContain("story/chapter_summaries.md#recent_titles");
+    expect(selectedSources).toContain("story/chapter_summaries.md#recent_mood_type_trail");
+    expect(selectedSources).toContain("story/parent_canon.md");
+    expect(selectedSources).toContain("story/fanfic_canon.md");
+
+    const titleEntry = result.contextPackage.selectedContext.find((entry) =>
+      entry.source === "story/chapter_summaries.md#recent_titles",
+    );
+    const moodEntry = result.contextPackage.selectedContext.find((entry) =>
+      entry.source === "story/chapter_summaries.md#recent_mood_type_trail",
+    );
+    const parentCanonEntry = result.contextPackage.selectedContext.find((entry) =>
+      entry.source === "story/parent_canon.md",
+    );
+    const fanficCanonEntry = result.contextPackage.selectedContext.find((entry) =>
+      entry.source === "story/fanfic_canon.md",
+    );
+
+    expect(titleEntry?.excerpt).toContain("Ledger in Rain");
+    expect(moodEntry?.excerpt).toContain("tight / investigation");
+    expect(parentCanonEntry?.excerpt).toContain("archive fire");
+    expect(fanficCanonEntry?.excerpt).toContain("oath debt logic");
+  });
+
+  it("includes dedicated audit drift guidance instead of relying on current_state pollution", async () => {
+    await writeFile(
+      join(storyDir, "audit_drift.md"),
+      [
+        "# Audit Drift",
+        "",
+        "## 审计纠偏（自动生成，下一章写作前参照）",
+        "",
+        "> - [warning] 节奏单调: 最近4章章节类型持续停留在“调查章”。",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const composer = new ComposerAgent({
+      client: {} as ConstructorParameters<typeof ComposerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await composer.composeChapter({
+      book,
+      bookDir,
+      chapterNumber: 4,
+      plan,
+    });
+
+    const driftEntry = result.contextPackage.selectedContext.find((entry) =>
+      entry.source === "story/audit_drift.md",
+    );
+    expect(driftEntry).toBeDefined();
+    expect(driftEntry?.excerpt).toContain("节奏单调");
+  });
+
+  it("emits hook debt briefs for agenda-targeted hooks", async () => {
+    await Promise.all([
+      writeFile(
+        join(storyDir, "pending_hooks.md"),
+        [
+          "# Pending Hooks",
+          "",
+          "| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 回收节奏 | 备注 |",
+          "| --- | --- | --- | --- | --- | --- | --- | --- |",
+          "| mentor-oath | 8 | relationship | progressing | 9 | 揭开师债为何断裂 | 慢烧 | 师债需要跨更大弧线回收 |",
+          "| guild-route | 1 | mystery | open | 2 | 查清商会路线背后的买家 | 近期 | 商会路线仍在旁支干扰 |",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "chapter_summaries.md"),
+        [
+          "# Chapter Summaries",
+          "",
+          "| 7 | Broken Letter | Lin Yue | A torn letter mentions the mentor | Lin Yue reopens the old oath | mentor-oath seeded | uneasy | mystery |",
+          "| 8 | River Camp | Lin Yue | Mentor debt becomes personal | Lin Yue cannot let go | mentor-oath advanced | raw | confrontation |",
+          "| 9 | Trial Echo | Lin Yue | Mentor left without explanation | Oath token matters again | mentor-oath advanced | aching | fallout |",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    const composer = new ComposerAgent({
+      client: {} as ConstructorParameters<typeof ComposerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await composer.composeChapter({
+      book,
+      bookDir,
+      chapterNumber: 10,
+      plan: {
+        ...plan,
+        intent: {
+          ...plan.intent,
+          chapter: 10,
+          goal: "Bring the focus back to the mentor oath conflict.",
+          hookAgenda: {
+            pressureMap: [{
+              hookId: "mentor-oath",
+              type: "relationship",
+              payoffTiming: "slow-burn",
+              phase: "middle",
+              pressure: "high",
+              movement: "partial-payoff",
+              reason: "stale-promise",
+              blockSiblingHooks: true,
+            }],
+            mustAdvance: ["mentor-oath"],
+            eligibleResolve: [],
+            staleDebt: [],
+            avoidNewHookFamilies: ["relationship"],
+          },
+        },
+      },
+    });
+
+    const hookDebtEntry = result.contextPackage.selectedContext.find((entry) => entry.source === "runtime/hook_debt#mentor-oath");
+    expect(hookDebtEntry).toBeDefined();
+    expect(hookDebtEntry?.excerpt).toContain("mentor-oath");
+    expect(hookDebtEntry?.excerpt).toContain("主要旧债");
+    expect(hookDebtEntry?.excerpt).toContain("读者承诺");
+    expect(hookDebtEntry?.excerpt).toContain("River Camp");
+    expect(hookDebtEntry?.excerpt).toContain("Trial Echo");
+  });
 });

packages/core/src/__tests__/context-filter.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { filterSummaries } from "../utils/context-filter.js";
+import { filterEmotionalArcs, filterSummaries } from "../utils/context-filter.js";
 
 describe("context-filter", () => {
   it("filters old chapter summary rows even when titles start with 'Chapter'", () => {
@@ -8,13 +8,34 @@ describe("context-filter", () => {
       "",
       "| 1 | Chapter 1 | Lin Yue | Old event | state-1 | side-quest-1 | tense | drama |",
       "| 97 | Chapter 97 | Lin Yue | Recent event | state-97 | side-quest-97 | tense | drama |",
+      "| 98 | Chapter 98 | Lin Yue | New event | state-98 | side-quest-98 | tense | drama |",
       "| 100 | Chapter 100 | Lin Yue | Latest event | state-100 | mentor-oath advanced | tense | drama |",
     ].join("\n");
 
     const filtered = filterSummaries(summaries, 101);
 
     expect(filtered).not.toContain("| 1 | Chapter 1 |");
-    expect(filtered).toContain("| 97 | Chapter 97 |");
+    expect(filtered).not.toContain("| 97 | Chapter 97 |");
+    expect(filtered).toContain("| 98 | Chapter 98 |");
     expect(filtered).toContain("| 100 | Chapter 100 |");
   });
+
+  it("keeps only the cadence-sized recent emotional arc rows by default", () => {
+    const arcs = [
+      "# Emotional Arcs",
+      "",
+      "| Character | Chapter | Emotional State | Trigger Event | Intensity (1-10) | Arc Direction |",
+      "| --- | --- | --- | --- | --- | --- |",
+      "| Lin Yue | 97 | guarded | old wound | 4 | holding |",
+      "| Lin Yue | 98 | tense | harbor clue | 6 | rising |",
+      "| Lin Yue | 99 | strained | mentor echo | 7 | tightening |",
+      "| Lin Yue | 100 | brittle | oath pressure | 8 | compressing |",
+    ].join("\n");
+
+    const filtered = filterEmotionalArcs(arcs, 101);
+
+    expect(filtered).not.toContain("| Lin Yue | 97 |");
+    expect(filtered).toContain("| Lin Yue | 98 |");
+    expect(filtered).toContain("| Lin Yue | 100 |");
+  });
 });

packages/core/src/__tests__/continuity.test.ts

@@ -156,6 +156,12 @@ describe("ContinuityAuditor", () => {
 
       expect(systemPrompt).toContain("Hook Check");
       expect(systemPrompt).toContain("Outline Drift Check");
+      expect(systemPrompt).toContain("stays dormant long enough to feel abandoned");
+      expect(systemPrompt).toContain("holds one pressure shape across a run");
+      expect(systemPrompt).toContain("same mode long enough to flatten rhythm");
+      expect(systemPrompt).not.toContain("more than 5 chapters");
+      expect(systemPrompt).not.toContain("3 straight chapters");
+      expect(systemPrompt).not.toContain("3+ consecutive chapters");
       expect(systemPrompt).not.toContain("伏笔检查");
       expect(systemPrompt).not.toContain("大纲偏离检测");
 

packages/core/src/__tests__/governed-working-set.test.ts

@@ -31,8 +31,8 @@ describe("governed-working-set", () => {
       language: "zh",
     });
 
-    expect(filtered).toContain("| opening-call | 1 | mystery | open | 0 | 8 | 匿名来电开篇出现 |");
-    expect(filtered).toContain("| nearby-ledger | 4 | evidence | open | 0 | 12 | 近期开启的账本线 |");
+    expect(filtered).toContain("opening-call");
+    expect(filtered).toContain("nearby-ledger");
     expect(filtered).not.toContain("future-pr-machine");
     expect(filtered).not.toContain("future-template");
   });
@@ -83,6 +83,28 @@ describe("governed-working-set", () => {
     expect(filtered).not.toContain("future-pr-machine");
   });
 
+  it("keeps recently-advanced hooks in the governed working set while filtering far-future hooks", () => {
+    const hooks = [
+      "| hook_id | start_chapter | type | status | last_advanced | expected_payoff | payoff_timing | notes |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| river-oath | 8 | relationship | progressing | 16 | Reveal why the river oath was broken | slow-burn | Long debt should stay visible through the middle game |",
+      "| future-pr-machine | 45 | system | open | 0 | Future hook should stay hidden | endgame | Future hook should stay hidden |",
+    ].join("\n");
+
+    const filtered = buildGovernedHookWorkingSet({
+      hooksMarkdown: hooks,
+      contextPackage: {
+        chapter: 20,
+        selectedContext: [],
+      },
+      chapterNumber: 20,
+      language: "en",
+    });
+
+    expect(filtered).toContain("river-oath");
+    expect(filtered).not.toContain("future-pr-machine");
+  });
+
   it("filters character matrix by exact governed character mentions instead of broad capitalized tokens", () => {
     const matrix = [
       "# Character Matrix",

packages/core/src/__tests__/hook-agenda.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildPlannerHookAgenda,
+  isHookWithinChapterWindow,
+} from "../utils/hook-agenda.js";
+import type { StoredHook } from "../state/memory-db.js";
+
+function createHook(overrides: Partial<StoredHook> = {}): StoredHook {
+  return {
+    hookId: overrides.hookId ?? "mentor-oath",
+    startChapter: overrides.startChapter ?? 8,
+    type: overrides.type ?? "relationship",
+    status: overrides.status ?? "open",
+    lastAdvancedChapter: overrides.lastAdvancedChapter ?? 9,
+    expectedPayoff: overrides.expectedPayoff ?? "Reveal why the mentor broke the oath",
+    payoffTiming: overrides.payoffTiming ?? "slow-burn",
+    notes: overrides.notes ?? "Long debt should stay visible",
+  };
+}
+
+describe("hook-agenda", () => {
+  it("builds agenda with stalest-first sorting and chapter-window filtering", () => {
+    const staleSlowBurn = createHook({
+      hookId: "mentor-oath",
+      startChapter: 4,
+      lastAdvancedChapter: 7,
+      notes: "Long debt is stalling",
+    });
+    const readyMystery = createHook({
+      hookId: "ledger-fragment",
+      type: "mystery",
+      startChapter: 2,
+      lastAdvancedChapter: 10,
+      payoffTiming: "near-term",
+      expectedPayoff: "Reveal the ledger fragment's origin",
+      notes: "Ready to cash out",
+    });
+
+    const agenda = buildPlannerHookAgenda({
+      hooks: [staleSlowBurn, readyMystery],
+      chapterNumber: 12,
+      targetChapters: 24,
+      language: "en",
+    });
+
+    expect(agenda.mustAdvance).toContain("mentor-oath");
+
+    expect(isHookWithinChapterWindow(staleSlowBurn, 12, 5)).toBe(true);
+    expect(isHookWithinChapterWindow(readyMystery, 12, 5)).toBe(true);
+  });
+});

packages/core/src/__tests__/hook-health.test.ts

@@ -10,6 +10,7 @@ function createHook(overrides: Partial<HookRecord> = {}): HookRecord {
     status: overrides.status ?? "open",
     lastAdvancedChapter: overrides.lastAdvancedChapter ?? 1,
     expectedPayoff: overrides.expectedPayoff ?? "Reveal the hidden ledger",
+    payoffTiming: overrides.payoffTiming,
     notes: overrides.notes ?? "Still unresolved",
   };
 }
@@ -49,18 +50,41 @@ describe("analyzeHookHealth", () => {
     expect(issues.some((issue) => issue.category === "Hook Debt" && issue.description.includes("5 active hooks"))).toBe(true);
   });
 
-  it("warns when no hook has materially advanced for several chapters", () => {
+  it("warns when a short-payoff hook is already under payoff pressure without real movement", () => {
+    const issues = analyzeHookHealth({
+      language: "en",
+      chapterNumber: 4,
+      hooks: [
+        createHook({
+          hookId: "H001",
+          startChapter: 1,
+          lastAdvancedChapter: 1,
+          payoffTiming: "immediate",
+          expectedPayoff: "Reveal the hidden ledger immediately after the theft.",
+        }),
+      ],
+    });
+
+    expect(issues.some((issue) => issue.description.includes("payoff pressure"))).toBe(true);
+  });
+
+  it("does not warn when only endgame hooks are dormant before the story reaches late phase", () => {
     const issues = analyzeHookHealth({
       language: "en",
       chapterNumber: 20,
+      targetChapters: 40,
       hooks: [
-        createHook({ hookId: "H001", lastAdvancedChapter: 12 }),
-        createHook({ hookId: "H002", lastAdvancedChapter: 11 }),
+        createHook({
+          hookId: "H001",
+          startChapter: 10,
+          lastAdvancedChapter: 15,
+          payoffTiming: "endgame",
+          expectedPayoff: "Final reveal in the endgame.",
+        }),
       ],
-      noAdvanceWindow: 5,
     });
 
-    expect(issues.some((issue) => issue.description.includes("No real hook advancement"))).toBe(true);
+    expect(issues).toHaveLength(0);
   });
 
   it("warns when stale hooks receive no disposition in the current chapter", () => {

packages/core/src/__tests__/hook-policy.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import {
+  HOOK_ACTIVITY_THRESHOLDS,
+  HOOK_AGENDA_LIMITS,
+  HOOK_HEALTH_DEFAULTS,
+  HOOK_PHASE_THRESHOLDS,
+  HOOK_PRESSURE_WEIGHTS,
+  HOOK_TIMING_PROFILES,
+  resolveHookVisibilityWindow,
+} from "../utils/hook-policy.js";
+
+describe("hook-policy", () => {
+  it("exposes shared lifecycle timing profiles from a single policy surface", () => {
+    expect(HOOK_TIMING_PROFILES.immediate.earliestResolveAge).toBe(1);
+    expect(HOOK_TIMING_PROFILES["slow-burn"].minimumPhase).toBe("middle");
+    expect(HOOK_TIMING_PROFILES.endgame.overdueAge).toBeGreaterThan(
+      HOOK_TIMING_PROFILES["near-term"].overdueAge,
+    );
+  });
+
+  it("widens visibility windows for longer-payoff hooks", () => {
+    expect(resolveHookVisibilityWindow("immediate")).toBe(5);
+    expect(resolveHookVisibilityWindow("mid-arc")).toBeGreaterThan(resolveHookVisibilityWindow("near-term"));
+    expect(resolveHookVisibilityWindow("endgame")).toBeGreaterThan(resolveHookVisibilityWindow("slow-burn"));
+  });
+
+  it("keeps shared agenda, phase, pressure, and health defaults together", () => {
+    expect(HOOK_AGENDA_LIMITS.light.mustAdvance).toBeLessThan(HOOK_AGENDA_LIMITS.heavy.mustAdvance);
+    expect(HOOK_AGENDA_LIMITS.heavy.eligibleResolve).toBeGreaterThan(HOOK_AGENDA_LIMITS.light.eligibleResolve);
+    expect(HOOK_HEALTH_DEFAULTS.maxActiveHooks).toBe(12);
+    expect(HOOK_PHASE_THRESHOLDS.lateProgress).toBeGreaterThan(HOOK_PHASE_THRESHOLDS.middleProgress);
+    expect(HOOK_PRESSURE_WEIGHTS.resolveBiasMultiplier).toBe(10);
+  });
+
+  it("keeps lifecycle activity and refresh thresholds on the same policy surface", () => {
+    expect(HOOK_ACTIVITY_THRESHOLDS.recentlyTouchedDormancy).toBe(1);
+    expect(HOOK_ACTIVITY_THRESHOLDS.longArcQuietHoldMaxAge).toBeGreaterThan(
+      HOOK_ACTIVITY_THRESHOLDS.freshPromiseAge,
+    );
+    expect(HOOK_ACTIVITY_THRESHOLDS.refreshDormancy).toBeGreaterThan(
+      HOOK_ACTIVITY_THRESHOLDS.longArcQuietHoldMaxDormancy,
+    );
+  });
+});

packages/core/src/__tests__/long-span-fatigue.test.ts

@@ -121,4 +121,40 @@ describe("analyzeLongSpanFatigue", () => {
       await rm(join(bookDir, ".."), { recursive: true, force: true });
     }
   });
+
+  it("warns when title focus collapses and high-tension mood never releases", async () => {
+    const bookDir = await createBookDir("inkos-long-span-cadence-test-");
+
+    await Promise.all([
+      writeChapter(bookDir, 1, "名单之前", "风贴着走廊吹。周谨川没有停，手指一直压着那份发潮的薄册。"),
+      writeChapter(bookDir, 2, "名单之后", "楼道里只有脚步声。周谨川顺着裂灯往下走，肩背始终绷着。"),
+      writeFile(
+        join(bookDir, "story", "chapter_summaries.md"),
+        [
+          "# 章节摘要",
+          "",
+          "| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |",
+          "|------|------|----------|----------|----------|----------|----------|----------|",
+          "| 1 | 名单之前 | 周谨川 | 初次接触名单 | 压力上升 | 名单线继续发酵 | 紧张、压抑 | 调查章 |",
+          "| 2 | 名单之后 | 周谨川 | 顺着名单继续追查 | 目标未变 | 名单线继续发酵 | 冷硬、逼仄 | 调查章 |",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    try {
+      const result = await analyzeLongSpanFatigue({
+        bookDir,
+        chapterNumber: 3,
+        chapterContent: "墙角的灰一直没落定。周谨川盯着名单最后一行，喉结很轻地滚了一下，还是没有把气松出来。",
+        chapterSummary: "| 3 | 名单未落 | 周谨川 | 名单追查继续推进 | 目标未变 | 名单线继续发酵 | 压迫、窒息 | 调查章 |",
+        language: "zh",
+      });
+
+      expect(result.issues.some((issue) => issue.category === "标题重复")).toBe(true);
+      expect(result.issues.some((issue) => issue.category === "情绪单调")).toBe(true);
+    } finally {
+      await rm(join(bookDir, ".."), { recursive: true, force: true });
+    }
+  });
 });

packages/core/src/__tests__/memory-retrieval.test.ts

@@ -896,6 +896,108 @@ describe("retrieveMemorySelection", () => {
     expect(result.hooks.map((hook) => hook.hookId)).not.toContain("stale-resolved");
   });
 
+  it("surfaces multiple stale hook families when debt pressure clusters instead of only one stale extra", async () => {
+    root = await mkdtemp(join(tmpdir(), "inkos-memory-retrieval-stale-cluster-test-"));
+    const bookDir = join(root, "book");
+    const storyDir = join(bookDir, "story");
+    const stateDir = join(storyDir, "state");
+    await mkdir(stateDir, { recursive: true });
+
+    await Promise.all([
+      writeFile(
+        join(stateDir, "manifest.json"),
+        JSON.stringify({
+          schemaVersion: 2,
+          language: "en",
+          lastAppliedChapter: 50,
+          projectionVersion: 1,
+          migrationWarnings: [],
+        }, null, 2),
+        "utf-8",
+      ),
+      writeFile(
+        join(stateDir, "current_state.json"),
+        JSON.stringify({
+          chapter: 50,
+          facts: [],
+        }, null, 2),
+        "utf-8",
+      ),
+      writeFile(
+        join(stateDir, "chapter_summaries.json"),
+        JSON.stringify({
+          rows: [],
+        }, null, 2),
+        "utf-8",
+      ),
+      writeFile(
+        join(stateDir, "hooks.json"),
+        JSON.stringify({
+          hooks: [
+            {
+              hookId: "recent-route",
+              startChapter: 47,
+              type: "route",
+              status: "open",
+              lastAdvancedChapter: 49,
+              expectedPayoff: "Recent route payoff",
+              notes: "Recent route remains active.",
+            },
+            {
+              hookId: "recent-guild",
+              startChapter: 46,
+              type: "politics",
+              status: "progressing",
+              lastAdvancedChapter: 48,
+              expectedPayoff: "Guild payoff",
+              notes: "Recent guild pressure remains active.",
+            },
+            {
+              hookId: "recent-token",
+              startChapter: 45,
+              type: "artifact",
+              status: "open",
+              lastAdvancedChapter: 47,
+              expectedPayoff: "Token payoff",
+              notes: "Recent token route remains active.",
+            },
+            {
+              hookId: "stale-omega",
+              startChapter: 6,
+              type: "relationship",
+              status: "open",
+              lastAdvancedChapter: 12,
+              expectedPayoff: "Old relic payoff",
+              notes: "Dormant unresolved relationship line.",
+            },
+            {
+              hookId: "stale-sable",
+              startChapter: 8,
+              type: "mystery",
+              status: "open",
+              lastAdvancedChapter: 14,
+              expectedPayoff: "Archive payoff",
+              notes: "Dormant unresolved mystery line.",
+            },
+          ],
+        }, null, 2),
+        "utf-8",
+      ),
+    ]);
+
+    const result = await retrieveMemorySelection({
+      bookDir,
+      chapterNumber: 51,
+      goal: "Keep the chapter on the debt cluster and route pressure together.",
+      mustKeep: ["The old debt cluster must stay legible."],
+    });
+
+    expect(result.hooks.map((hook) => hook.hookId)).toEqual(expect.arrayContaining([
+      "stale-omega",
+      "stale-sable",
+    ]));
+  });
+
   it("does not surface far-future unstarted hooks in early chapter retrieval", async () => {
     root = await mkdtemp(join(tmpdir(), "inkos-memory-retrieval-future-hook-gate-test-"));
     const bookDir = join(root, "book");
@@ -1085,4 +1187,160 @@ describe("parsePendingHooksMarkdown", () => {
 
     expect(hooks.map((hook) => hook.hookId)).toEqual(["H009", "H010"]);
   });
+
+  it("parses semantic payoff timing from extended pending hooks tables", () => {
+    const hooks = memoryRetrieval.parsePendingHooksMarkdown([
+      "| hook_id | start_chapter | type | status | last_advanced | expected_payoff | payoff_timing | notes |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| oath-debt | 8 | relationship | open | 12 | Reveal why the mentor broke the oath | slow-burn | Long-buried debt stays unresolved |",
+      "| kiln-key | 15 | mystery | open | 15 | Find out what the kiln key opens next chapter | immediate | Fresh key with a fast local payoff |",
+      "",
+    ].join("\n"));
+
+    expect(hooks).toEqual([
+      expect.objectContaining({
+        hookId: "oath-debt",
+        payoffTiming: "slow-burn",
+        notes: "Long-buried debt stays unresolved",
+      }),
+      expect.objectContaining({
+        hookId: "kiln-key",
+        payoffTiming: "immediate",
+        notes: "Fresh key with a fast local payoff",
+      }),
+    ]);
+  });
+
+  it("sorts must-advance by stalest-first and resolve by earliest-started", () => {
+    const agenda = memoryRetrieval.buildPlannerHookAgenda({
+      chapterNumber: 18,
+      hooks: [
+        {
+          hookId: "slow-oath",
+          startChapter: 10,
+          type: "relationship",
+          status: "progressing",
+          lastAdvancedChapter: 17,
+          expectedPayoff: "Reveal why the mentor buried the oath debt",
+          payoffTiming: "slow-burn",
+          notes: "The debt should simmer across the wider arc.",
+        },
+        {
+          hookId: "ready-packet",
+          startChapter: 14,
+          type: "mystery",
+          status: "progressing",
+          lastAdvancedChapter: 17,
+          expectedPayoff: "Open the missing packet and expose the inside hand",
+          payoffTiming: "near-term",
+          notes: "The local sequence is ready for a concrete payoff.",
+        },
+      ] as never,
+      maxMustAdvance: 2,
+      maxEligibleResolve: 2,
+      targetChapters: 40,
+    } as never);
+
+    expect(agenda.mustAdvance).toContain("slow-oath");
+    expect(agenda.mustAdvance).toContain("ready-packet");
+    expect(agenda.eligibleResolve).toContain("slow-oath");
+    expect(agenda.eligibleResolve).toContain("ready-packet");
+    expect(agenda.pressureMap).toEqual([]);
+  });
+
+  it("limits eligible resolve to default max of 1 when not overridden", () => {
+    const agenda = memoryRetrieval.buildPlannerHookAgenda({
+      chapterNumber: 8,
+      targetChapters: 12,
+      hooks: [
+        {
+          hookId: "packet-drop",
+          startChapter: 5,
+          type: "mystery",
+          status: "progressing",
+          lastAdvancedChapter: 7,
+          expectedPayoff: "Open the dropped packet and expose who planted it",
+          payoffTiming: "near-term",
+          notes: "The packet has been foregrounded for two chapters already.",
+        },
+        {
+          hookId: "seal-crack",
+          startChapter: 4,
+          type: "artifact",
+          status: "progressing",
+          lastAdvancedChapter: 7,
+          expectedPayoff: "Reveal what the cracked seal is hiding",
+          payoffTiming: "immediate",
+          notes: "The cracked seal should pay off in the current local sequence.",
+        },
+        {
+          hookId: "witness-turn",
+          startChapter: 5,
+          type: "relationship",
+          status: "progressing",
+          lastAdvancedChapter: 7,
+          expectedPayoff: "Force the silent witness to choose a side",
+          payoffTiming: "near-term",
+          notes: "The witness line is ready for a concrete turn now.",
+        },
+      ] as never,
+    } as never);
+
+    expect(agenda.eligibleResolve.length).toBe(1);
+    expect(agenda.pressureMap).toEqual([]);
+  });
+
+  it("picks stalest hooks for must-advance regardless of type family", () => {
+    const agenda = memoryRetrieval.buildPlannerHookAgenda({
+      chapterNumber: 15,
+      targetChapters: 30,
+      hooks: [
+        {
+          hookId: "mentor-oath-a",
+          startChapter: 1,
+          type: "relationship",
+          status: "open",
+          lastAdvancedChapter: 2,
+          expectedPayoff: "Explain the first layer of the mentor oath debt",
+          payoffTiming: "mid-arc",
+          notes: "Old relationship debt keeps surfacing without movement.",
+        },
+        {
+          hookId: "mentor-oath-b",
+          startChapter: 2,
+          type: "relationship",
+          status: "open",
+          lastAdvancedChapter: 3,
+          expectedPayoff: "Show what the second oath witness is hiding",
+          payoffTiming: "mid-arc",
+          notes: "Another branch of the same relationship family is also stale.",
+        },
+        {
+          hookId: "mentor-oath-c",
+          startChapter: 3,
+          type: "relationship",
+          status: "open",
+          lastAdvancedChapter: 4,
+          expectedPayoff: "Reveal why the oath cannot be spoken aloud",
+          payoffTiming: "mid-arc",
+          notes: "The third relationship branch is still hanging.",
+        },
+        {
+          hookId: "kiln-key",
+          startChapter: 4,
+          type: "artifact",
+          status: "open",
+          lastAdvancedChapter: 5,
+          expectedPayoff: "Show what the kiln key unlocks",
+          payoffTiming: "mid-arc",
+          notes: "Artifact debt is also stale and should not vanish behind relationship debt.",
+        },
+      ] as never,
+    } as never);
+
+    expect(agenda.mustAdvance).toEqual(["mentor-oath-a", "mentor-oath-b"]);
+    expect(agenda.mustAdvance).toEqual(expect.arrayContaining([
+      expect.stringMatching(/^mentor-oath-/),
+    ]));
+  });
 });

packages/core/src/__tests__/models.test.ts

@@ -281,19 +281,21 @@ describe("ChapterStatusSchema", () => {
     "auditing",
     "audit-passed",
     "audit-failed",
+    "state-degraded",
     "revising",
     "ready-for-review",
     "approved",
     "rejected",
     "published",
+    "imported",
   ] as const;
 
   it.each(allStatuses)("accepts '%s'", (value) => {
     expect(ChapterStatusSchema.parse(value)).toBe(value);
   });
 
-  it("has exactly 12 valid statuses", () => {
-    expect(ChapterStatusSchema.options).toHaveLength(12);
+  it("has exactly 13 valid statuses", () => {
+    expect(ChapterStatusSchema.options).toHaveLength(13);
   });
 
   it("rejects unknown status", () => {
@@ -495,6 +497,10 @@ describe("ChapterIntentSchema", () => {
       chapter: 12,
       goal: "Pull focus back to the mentor conflict",
       outlineNode: "Volume 2 / Chapter 12",
+      sceneDirective: "Break the repeated investigation-room rhythm with a location change.",
+      arcDirective: "Advance toward the next concrete arc beat instead of replaying the fallback setup.",
+      moodDirective: "Release pressure for one chapter before the next escalation.",
+      titleDirective: "Avoid another ledger title and use a new concrete image.",
       mustKeep: ["Protagonist remains injured"],
       mustAvoid: ["Do not reveal the mastermind"],
       styleEmphasis: ["dialogue tension", "character conflict"],
@@ -505,6 +511,18 @@ describe("ChapterIntentSchema", () => {
         },
       ],
       hookAgenda: {
+        pressureMap: [
+          {
+            hookId: "H019",
+            type: "relationship",
+            payoffTiming: "slow-burn",
+            phase: "middle",
+            pressure: "high",
+            movement: "partial-payoff",
+            reason: "stale-promise",
+            blockSiblingHooks: true,
+          },
+        ],
         mustAdvance: ["H019"],
         eligibleResolve: ["H045"],
         staleDebt: ["H023", "H027"],
@@ -517,7 +535,22 @@ describe("ChapterIntentSchema", () => {
 
     expect(result.chapter).toBe(12);
     expect(result.goal).toContain("mentor conflict");
+    expect(result.sceneDirective).toContain("location change");
+    expect(result.arcDirective).toContain("arc beat");
+    expect(result.moodDirective).toContain("Release pressure");
+    expect(result.titleDirective).toContain("ledger title");
     expect(result.conflicts).toHaveLength(1);
+    expect(result.hookAgenda.pressureMap).toEqual([
+      expect.objectContaining({
+        hookId: "H019",
+        type: "relationship",
+        phase: "middle",
+        movement: "partial-payoff",
+        pressure: "high",
+        payoffTiming: "slow-burn",
+        reason: "stale-promise",
+      }),
+    ]);
     expect(result.hookAgenda.mustAdvance).toEqual(["H019"]);
     expect(result.hookAgenda.eligibleResolve).toEqual(["H045"]);
     expect(result.hookAgenda.staleDebt).toEqual(["H023", "H027"]);
@@ -533,10 +566,15 @@ describe("ChapterIntentSchema", () => {
       goal: "Establish the protagonist's first setback",
     });
 
+    expect(result.sceneDirective).toBeUndefined();
+    expect(result.arcDirective).toBeUndefined();
+    expect(result.moodDirective).toBeUndefined();
+    expect(result.titleDirective).toBeUndefined();
     expect(result.mustKeep).toEqual([]);
     expect(result.mustAvoid).toEqual([]);
     expect(result.styleEmphasis).toEqual([]);
     expect(result.conflicts).toEqual([]);
+    expect(result.hookAgenda.pressureMap).toEqual([]);
     expect(result.hookAgenda.mustAdvance).toEqual([]);
     expect(result.hookAgenda.eligibleResolve).toEqual([]);
     expect(result.hookAgenda.staleDebt).toEqual([]);

packages/core/src/__tests__/persisted-governed-plan.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadPersistedPlan, relativeToBookDir } from "../pipeline/persisted-governed-plan.js";
+
+describe("persisted governed plan helpers", () => {
+  it("parses a persisted intent markdown file into a reusable plan", async () => {
+    const bookDir = await mkdtemp(join(tmpdir(), "inkos-persisted-plan-"));
+    const runtimeDir = join(bookDir, "story", "runtime");
+    await mkdir(runtimeDir, { recursive: true });
+
+    const runtimePath = join(runtimeDir, "chapter-0007.intent.md");
+    await writeFile(
+      runtimePath,
+      [
+        "# Chapter Intent",
+        "",
+        "## Goal",
+        "Bring the focus back to the mentor oath conflict.",
+        "",
+        "## Outline Node",
+        "Track the mentor oath fallout.",
+        "",
+        "## Must Keep",
+        "- Lin Yue keeps the oath token hidden.",
+        "- Mentor debt stays unresolved.",
+        "",
+        "## Must Avoid",
+        "- Open a new guild-route mystery.",
+        "",
+        "## Style Emphasis",
+        "- restrained prose",
+        "",
+        "## Conflicts",
+        "- duty: repay the oath without exposing the token",
+        "- trust: keep the mentor debt personal",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    try {
+      const plan = await loadPersistedPlan(bookDir, 7);
+
+      expect(plan).not.toBeNull();
+      expect(plan?.runtimePath).toBe(runtimePath);
+      expect(plan?.intent.goal).toBe("Bring the focus back to the mentor oath conflict.");
+      expect(plan?.intent.outlineNode).toBe("Track the mentor oath fallout.");
+      expect(plan?.intent.mustKeep).toEqual([
+        "Lin Yue keeps the oath token hidden.",
+        "Mentor debt stays unresolved.",
+      ]);
+      expect(plan?.intent.mustAvoid).toEqual(["Open a new guild-route mystery."]);
+      expect(plan?.intent.styleEmphasis).toEqual(["restrained prose"]);
+      expect(plan?.intent.conflicts).toEqual([
+        { type: "duty", resolution: "repay the oath without exposing the token" },
+        { type: "trust", resolution: "keep the mentor debt personal" },
+      ]);
+      expect(plan?.plannerInputs).toEqual([runtimePath]);
+    } finally {
+      await rm(bookDir, { recursive: true, force: true });
+    }
+  });
+
+  it("rejects persisted intents whose goal is still a placeholder", async () => {
+    const bookDir = await mkdtemp(join(tmpdir(), "inkos-persisted-plan-invalid-"));
+    const runtimeDir = join(bookDir, "story", "runtime");
+    await mkdir(runtimeDir, { recursive: true });
+
+    await writeFile(
+      join(runtimeDir, "chapter-0003.intent.md"),
+      [
+        "# Chapter Intent",
+        "",
+        "## Goal",
+        "(describe the goal here)",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    try {
+      await expect(loadPersistedPlan(bookDir, 3)).resolves.toBeNull();
+    } finally {
+      await rm(bookDir, { recursive: true, force: true });
+    }
+  });
+
+  it("normalizes persisted artifact paths relative to the book directory", () => {
+    expect(relativeToBookDir(
+      "/tmp/book",
+      "/tmp/book/story/runtime/chapter-0001.intent.md",
+    )).toBe("story/runtime/chapter-0001.intent.md");
+  });
+});

packages/core/src/__tests__/pipeline-agent.test.ts

@@ -117,6 +117,39 @@ describe("agent pipeline tools", () => {
       .resolves.toContain("mentor fallout");
   });
 
+  it("keeps update_current_focus usable for explicit local overrides through the tool surface", async () => {
+    await executeAgentTool(pipeline, state, config, "update_current_focus", {
+      bookId,
+      content: [
+        "# Current Focus",
+        "",
+        "## Active Focus",
+        "",
+        "Keep the merchant guild trail visible in the background.",
+        "",
+        "## Local Override",
+        "",
+        "Stay inside the mentor debt confrontation first and delay the guild chase by one chapter.",
+        "",
+      ].join("\n"),
+    });
+
+    const planResult = JSON.parse(await executeAgentTool(
+      pipeline,
+      state,
+      config,
+      "plan_chapter",
+      { bookId },
+    ));
+
+    const runtimePath = join(state.bookDir(bookId), planResult.intentPath);
+    const intentMarkdown = await readFile(runtimePath, "utf-8");
+    expect(intentMarkdown).toContain([
+      "## Goal",
+      "Stay inside the mentor debt confrontation first and delay the guild chase by one chapter.",
+    ].join("\n"));
+  });
+
   it("blocks write_full_pipeline when runtime progress is ahead of the chapter index", async () => {
     const stateDir = join(state.bookDir(bookId), "story", "state");
     await mkdir(stateDir, { recursive: true });

packages/core/src/__tests__/pipeline-runner.test.ts

@@ -4,6 +4,7 @@ import { mkdtemp, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { PipelineRunner } from "../pipeline/runner.js";
+import * as llmProvider from "../llm/provider.js";
 import { StateManager } from "../state/manager.js";
 import { ArchitectAgent } from "../agents/architect.js";
 import { PlannerAgent } from "../agents/planner.js";
@@ -1224,7 +1225,7 @@ describe("PipelineRunner", () => {
     }
   });
 
-  it("writes English audit drift correction blocks for English books", async () => {
+  it("writes English audit drift guidance into a dedicated file without polluting current_state", async () => {
     const { root, runner, state, bookId } = await createRunnerFixture();
     const englishBook = {
       ...(await state.loadBookConfig(bookId)),
@@ -1278,11 +1279,13 @@ describe("PipelineRunner", () => {
     try {
       await runner.writeNextChapter(bookId, 220);
 
+      const driftFile = await readFile(join(state.bookDir(bookId), "story", "audit_drift.md"), "utf-8");
       const currentState = await readFile(join(state.bookDir(bookId), "story", "current_state.md"), "utf-8");
-      expect(currentState).toContain("## Audit Drift Correction");
-      expect(currentState).toContain("> Chapter 1 audit found the following issues");
-      expect(currentState).not.toContain("## 审计纠偏");
-      expect(currentState).not.toContain("下一章写作前参照");
+      expect(driftFile).toContain("## Audit Drift Correction");
+      expect(driftFile).toContain("> Chapter 1 audit found the following issues");
+      expect(driftFile).not.toContain("## 审计纠偏");
+      expect(driftFile).not.toContain("下一章写作前参照");
+      expect(currentState).not.toContain("Audit Drift Correction");
     } finally {
       await rm(root, { recursive: true, force: true });
     }
@@ -2144,6 +2147,257 @@ describe("PipelineRunner", () => {
     await rm(root, { recursive: true, force: true });
   });
 
+  it("retries settlement after state contradictions without rewriting the chapter body", async () => {
+    const { root, runner, state, bookId } = await createRunnerFixture({
+      inputGovernanceMode: "legacy",
+    });
+    const storyDir = join(state.bookDir(bookId), "story");
+
+    await Promise.all([
+      writeFile(join(storyDir, "current_state.md"), "stable state", "utf-8"),
+      writeFile(join(storyDir, "pending_hooks.md"), "stable hooks", "utf-8"),
+      writeFile(join(storyDir, "particle_ledger.md"), "stable ledger", "utf-8"),
+    ]);
+
+    const writeSpy = vi.spyOn(WriterAgent.prototype, "writeChapter").mockResolvedValue(
+      createWriterOutput({
+        content: "Healthy chapter body with the copper token in his coat.",
+        wordCount: "Healthy chapter body with the copper token in his coat.".length,
+        updatedState: "broken state",
+        updatedHooks: "broken hooks",
+        updatedLedger: "broken ledger",
+      }),
+    );
+    const settleSpy = vi.spyOn(
+      WriterAgent.prototype as unknown as {
+        settleChapterState: (input: Record<string, unknown>) => Promise<WriteChapterOutput>;
+      },
+      "settleChapterState",
+    ).mockResolvedValue(
+      createWriterOutput({
+        content: "Healthy chapter body with the copper token in his coat.",
+        wordCount: "Healthy chapter body with the copper token in his coat.".length,
+        updatedState: "fixed state",
+        updatedHooks: "fixed hooks",
+        updatedLedger: "fixed ledger",
+      }),
+    );
+    vi.spyOn(ContinuityAuditor.prototype, "auditChapter").mockResolvedValue(
+      createAuditResult({
+        passed: true,
+        issues: [],
+        summary: "clean",
+      }),
+    );
+    vi.spyOn(StateValidatorAgent.prototype, "validate")
+      .mockResolvedValueOnce({
+        passed: false,
+        warnings: [{
+          category: "unsupported_change",
+          description: "状态写成铜牌未带在身上，但正文明确写了怀里的铜牌。",
+        }],
+      })
+      .mockResolvedValueOnce({
+        passed: true,
+        warnings: [],
+      });
+
+    const result = await runner.writeNextChapter(bookId);
+
+    expect(result.status).toBe("ready-for-review");
+    expect(writeSpy).toHaveBeenCalledTimes(1);
+    expect(settleSpy).toHaveBeenCalledTimes(1);
+    expect(settleSpy).toHaveBeenCalledWith(expect.objectContaining({
+      chapterNumber: 1,
+      title: "Test Chapter",
+      content: "Healthy chapter body with the copper token in his coat.",
+      validationFeedback: expect.stringContaining("怀里的铜牌"),
+    }));
+    await expect(readFile(join(storyDir, "current_state.md"), "utf-8")).resolves.toBe("fixed state");
+    await expect(readFile(join(storyDir, "pending_hooks.md"), "utf-8")).resolves.toBe("fixed hooks");
+
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it("persists a state-degraded chapter without advancing truth files when settlement retry still contradicts the body", async () => {
+    const { root, runner, state, bookId } = await createRunnerFixture({
+      inputGovernanceMode: "legacy",
+    });
+    const bookDir = state.bookDir(bookId);
+    const storyDir = join(bookDir, "story");
+    const chaptersDir = join(bookDir, "chapters");
+
+    await Promise.all([
+      writeFile(join(storyDir, "current_state.md"), "stable state", "utf-8"),
+      writeFile(join(storyDir, "pending_hooks.md"), "stable hooks", "utf-8"),
+      writeFile(join(storyDir, "particle_ledger.md"), "stable ledger", "utf-8"),
+    ]);
+
+    vi.spyOn(WriterAgent.prototype, "writeChapter").mockResolvedValue(
+      createWriterOutput({
+        content: "Healthy chapter body with the copper token in his coat.",
+        wordCount: "Healthy chapter body with the copper token in his coat.".length,
+        updatedState: "broken state",
+        updatedHooks: "broken hooks",
+        updatedLedger: "broken ledger",
+      }),
+    );
+    vi.spyOn(
+      WriterAgent.prototype as unknown as {
+        settleChapterState: (input: Record<string, unknown>) => Promise<WriteChapterOutput>;
+      },
+      "settleChapterState",
+    ).mockResolvedValue(
+      createWriterOutput({
+        content: "Healthy chapter body with the copper token in his coat.",
+        wordCount: "Healthy chapter body with the copper token in his coat.".length,
+        updatedState: "still broken state",
+        updatedHooks: "still broken hooks",
+        updatedLedger: "still broken ledger",
+      }),
+    );
+    vi.spyOn(ContinuityAuditor.prototype, "auditChapter").mockResolvedValue(
+      createAuditResult({
+        passed: true,
+        issues: [],
+        summary: "clean",
+      }),
+    );
+    vi.spyOn(StateValidatorAgent.prototype, "validate")
+      .mockResolvedValueOnce({
+        passed: false,
+        warnings: [{
+          category: "unsupported_change",
+          description: "settler 把铜牌写没了，但正文仍然明确带在身上。",
+        }],
+      })
+      .mockResolvedValueOnce({
+        passed: false,
+        warnings: [{
+          category: "unsupported_change",
+          description: "重试后仍然把铜牌写没了。",
+        }],
+      });
+
+    const result = await runner.writeNextChapter(bookId);
+    const savedIndex = await state.loadChapterIndex(bookId);
+
+    expect(result.status).toBe("state-degraded");
+    expect(savedIndex[0]?.status).toBe("state-degraded");
+    expect(savedIndex[0]?.auditIssues).toContain("[warning] 重试后仍然把铜牌写没了。");
+    await expect(readFile(join(storyDir, "current_state.md"), "utf-8")).resolves.toBe("stable state");
+    await expect(readFile(join(storyDir, "pending_hooks.md"), "utf-8")).resolves.toBe("stable hooks");
+    await expect(readFile(join(storyDir, "particle_ledger.md"), "utf-8")).resolves.toBe("stable ledger");
+    await expect(readdir(chaptersDir)).resolves.toContain("0001_Test_Chapter.md");
+    await expect(stat(join(storyDir, "snapshots", "1"))).rejects.toThrow();
+
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it("blocks writing a new chapter when the latest persisted chapter is state-degraded", async () => {
+    const { root, runner, state, bookId } = await createRunnerFixture({
+      inputGovernanceMode: "legacy",
+    });
+    const now = "2026-03-19T00:00:00.000Z";
+    const storyDir = join(state.bookDir(bookId), "story");
+
+    await Promise.all([
+      writeFile(join(storyDir, "current_state.md"), "stable state", "utf-8"),
+      writeFile(join(storyDir, "pending_hooks.md"), "stable hooks", "utf-8"),
+      state.saveChapterIndex(bookId, [{
+        number: 1,
+        title: "Broken Persistence",
+        status: "state-degraded" as ChapterMeta["status"],
+        wordCount: 1234,
+        createdAt: now,
+        updatedAt: now,
+        auditIssues: ["[warning] state validation degraded"],
+        lengthWarnings: [],
+      }]),
+      writeFile(join(state.bookDir(bookId), "chapters", "0001_Broken_Persistence.md"), "# 第1章 Broken Persistence\n\nbody", "utf-8"),
+    ]);
+
+    await expect(runner.writeNextChapter(bookId)).rejects.toThrow(/state-degraded/i);
+
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it("repairs the latest state-degraded chapter from persisted body without rewriting it", async () => {
+    const { root, runner, state, bookId } = await createRunnerFixture({
+      inputGovernanceMode: "legacy",
+    });
+    const now = "2026-03-19T00:00:00.000Z";
+    const bookDir = state.bookDir(bookId);
+    const storyDir = join(bookDir, "story");
+
+    await Promise.all([
+      writeFile(join(storyDir, "current_state.md"), "stable state", "utf-8"),
+      writeFile(join(storyDir, "pending_hooks.md"), "stable hooks", "utf-8"),
+      writeFile(join(storyDir, "particle_ledger.md"), "stable ledger", "utf-8"),
+      writeFile(
+        join(bookDir, "chapters", "0001_Broken_Persistence.md"),
+        "# 第1章 Broken Persistence\n\nHealthy chapter body with the copper token in his coat.",
+        "utf-8",
+      ),
+      state.saveChapterIndex(bookId, [{
+        number: 1,
+        title: "Broken Persistence",
+        status: "state-degraded" as ChapterMeta["status"],
+        wordCount: 55,
+        createdAt: now,
+        updatedAt: now,
+        auditIssues: ["[warning] 重试后仍然把铜牌写没了。"],
+        lengthWarnings: [],
+        reviewNote: JSON.stringify({
+          kind: "state-degraded",
+          baseStatus: "ready-for-review",
+          injectedIssues: ["[warning] 重试后仍然把铜牌写没了。"],
+        }),
+      }]),
+    ]);
+
+    vi.spyOn(
+      WriterAgent.prototype as unknown as {
+        settleChapterState: (input: Record<string, unknown>) => Promise<WriteChapterOutput>;
+      },
+      "settleChapterState",
+    ).mockResolvedValue(
+      createWriterOutput({
+        chapterNumber: 1,
+        title: "Broken Persistence",
+        content: "Healthy chapter body with the copper token in his coat.",
+        wordCount: "Healthy chapter body with the copper token in his coat.".length,
+        updatedState: "fixed state",
+        updatedHooks: "fixed hooks",
+        updatedLedger: "fixed ledger",
+      }),
+    );
+    vi.spyOn(StateValidatorAgent.prototype, "validate").mockResolvedValue({
+      passed: true,
+      warnings: [],
+    });
+
+    const result = await (
+      runner as unknown as {
+        repairChapterState: (bookId: string, chapterNumber?: number) => Promise<{
+          status: string;
+          chapterNumber: number;
+        }>;
+      }
+    ).repairChapterState(bookId, 1);
+    const savedIndex = await state.loadChapterIndex(bookId);
+
+    expect(result.status).toBe("ready-for-review");
+    expect(result.chapterNumber).toBe(1);
+    await expect(readFile(join(storyDir, "current_state.md"), "utf-8")).resolves.toBe("fixed state");
+    await expect(readFile(join(storyDir, "pending_hooks.md"), "utf-8")).resolves.toBe("fixed hooks");
+    expect(savedIndex[0]?.status).toBe("ready-for-review");
+    expect(savedIndex[0]?.auditIssues).toEqual([]);
+    expect(savedIndex[0]?.reviewNote).toBeUndefined();
+
+    await rm(root, { recursive: true, force: true });
+  });
+
   it("still persists the chapter when the state validator appends markdown after a valid JSON verdict", async () => {
     vi.restoreAllMocks();
     vi.spyOn(LengthNormalizerAgent.prototype, "normalizeChapter").mockImplementation(
@@ -2321,6 +2575,150 @@ describe("PipelineRunner", () => {
     await rm(root, { recursive: true, force: true });
   });
 
+  it("keeps fanfic initialization running when style guide extraction fails", async () => {
+    const { root, runner, state } = await createRunnerFixture();
+    const bookId = "fanfic-style-fallback";
+    const now = "2026-03-19T00:00:00.000Z";
+    const book: BookConfig = {
+      id: bookId,
+      title: "Fanfic Fallback",
+      platform: "tomato",
+      genre: "xuanhuan",
+      status: "active",
+      targetChapters: 10,
+      chapterWordCount: 3000,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    vi.spyOn(runner, "importFanficCanon").mockImplementation(async (targetBookId) => {
+      const storyDir = join(state.bookDir(targetBookId), "story");
+      await mkdir(storyDir, { recursive: true });
+      await writeFile(join(storyDir, "fanfic_canon.md"), "# Fanfic Canon\n", "utf-8");
+      return "# Fanfic Canon\n";
+    });
+    vi.spyOn(ArchitectAgent.prototype, "generateFanficFoundation").mockResolvedValue({
+      storyBible: "# Story Bible\n",
+      volumeOutline: "# Volume Outline\n",
+      bookRules: "---\nversion: \"1.0\"\n---\n\n# Book Rules\n",
+      currentState: createStateCard({
+        chapter: 0,
+        location: "Lantern quay",
+        protagonistState: "Lin Yue enters the fanfic timeline with a hidden debt.",
+        goal: "Find the canon fissure.",
+        conflict: "The old faction watches every move.",
+      }),
+      pendingHooks: "# Pending Hooks\n",
+    });
+    vi.spyOn(runner, "generateStyleGuide").mockRejectedValue(new Error("style failed"));
+
+    try {
+      await expect(runner.initFanficBook(book, "A".repeat(600), "canon.txt", "canon")).resolves.toBeUndefined();
+
+      expect(await state.loadChapterIndex(bookId)).toEqual([]);
+      await expect(readFile(join(state.bookDir(bookId), "story", "fanfic_canon.md"), "utf-8")).resolves.toContain("Fanfic Canon");
+      await expect(stat(join(state.bookDir(bookId), "story", "snapshots", "0"))).resolves.toBeTruthy();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps canon import running when style guide extraction fails", async () => {
+    const { root, runner, state, bookId } = await createRunnerFixture();
+    const parentBookId = "parent-book";
+    const now = "2026-03-19T00:00:00.000Z";
+    const parentBook: BookConfig = {
+      id: parentBookId,
+      title: "Parent Book",
+      platform: "tomato",
+      genre: "xuanhuan",
+      status: "active",
+      targetChapters: 10,
+      chapterWordCount: 3000,
+      createdAt: now,
+      updatedAt: now,
+    };
+    const parentStoryDir = join(state.bookDir(parentBookId), "story");
+    const parentChaptersDir = join(state.bookDir(parentBookId), "chapters");
+
+    await state.saveBookConfig(parentBookId, parentBook);
+    await mkdir(parentStoryDir, { recursive: true });
+    await mkdir(parentChaptersDir, { recursive: true });
+    await Promise.all([
+      writeFile(join(parentStoryDir, "story_bible.md"), "# Story Bible\n", "utf-8"),
+      writeFile(join(parentStoryDir, "current_state.md"), createStateCard({
+        chapter: 3,
+        location: "North watchtower",
+        protagonistState: "The mentor debt is no longer secret.",
+        goal: "Protect the watchtower archive.",
+        conflict: "Guild spies are already inside the archive.",
+      }), "utf-8"),
+      writeFile(join(parentStoryDir, "particle_ledger.md"), "# Ledger\n", "utf-8"),
+      writeFile(join(parentStoryDir, "pending_hooks.md"), "# Pending Hooks\n", "utf-8"),
+      writeFile(join(parentStoryDir, "chapter_summaries.md"), "# Chapter Summaries\n", "utf-8"),
+      writeFile(join(parentChaptersDir, "0001_Parent.md"), `# Chapter 1\n\n${"Parent text. ".repeat(60)}`, "utf-8"),
+    ]);
+
+    vi.spyOn(llmProvider, "chatCompletion").mockResolvedValue({
+      content: "# Parent Canon\n\nImported canon body.",
+    } as Awaited<ReturnType<typeof llmProvider.chatCompletion>>);
+    vi.spyOn(runner, "generateStyleGuide").mockRejectedValue(new Error("style failed"));
+
+    try {
+      const canon = await runner.importCanon(bookId, parentBookId);
+
+      expect(canon).toContain("# Parent Canon");
+      await expect(readFile(join(state.bookDir(bookId), "story", "parent_canon.md"), "utf-8")).resolves.toContain("Imported canon body.");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps chapter import running when style guide extraction fails", async () => {
+    const { root, runner, state, bookId } = await createRunnerFixture();
+    const chapterContent = "章节正文。".repeat(120);
+
+    vi.spyOn(ArchitectAgent.prototype, "generateFoundationFromImport").mockResolvedValue({
+      storyBible: "# Story Bible\n",
+      volumeOutline: "# Volume Outline\n",
+      bookRules: "---\nversion: \"1.0\"\n---\n\n# Book Rules\n",
+      currentState: createStateCard({
+        chapter: 0,
+        location: "Ashen ferry crossing",
+        protagonistState: "Lin Yue still hides the oath token.",
+        goal: "Find the vanished mentor.",
+        conflict: "The mentor debt is still personal.",
+      }),
+      pendingHooks: "# Pending Hooks\n",
+    });
+    vi.spyOn(ChapterAnalyzerAgent.prototype, "analyzeChapter").mockResolvedValue(
+      createAnalyzedOutput({
+        chapterNumber: 1,
+        title: "Prelude",
+        content: chapterContent,
+        wordCount: chapterContent.length,
+      }),
+    );
+    vi.spyOn(WriterAgent.prototype, "saveChapter").mockResolvedValue(undefined);
+    vi.spyOn(WriterAgent.prototype, "saveNewTruthFiles").mockResolvedValue(undefined);
+    vi.spyOn(runner, "generateStyleGuide").mockRejectedValue(new Error("style failed"));
+
+    try {
+      const result = await runner.importChapters({
+        bookId,
+        chapters: [
+          { title: "Prelude", content: chapterContent },
+        ],
+      });
+
+      expect(result.importedCount).toBe(1);
+      expect((await state.loadChapterIndex(bookId))[0]?.status).toBe("imported");
+      await expect(readFile(join(state.bookDir(bookId), "story", "story_bible.md"), "utf-8")).resolves.toContain("# Story Bible");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
   sqliteIt("rebuilds fact history from imported chapter snapshots", async () => {
     const { root, runner, state, bookId } = await createRunnerFixture();
 
@@ -2967,7 +3365,7 @@ describe("PipelineRunner", () => {
     }
   });
 
-  it("feeds long-span fatigue warnings back into pipeline audit and drift correction", async () => {
+  it("feeds long-span fatigue warnings back into pipeline audit and dedicated drift guidance", async () => {
     const { root, runner, state, bookId } = await createRunnerFixture();
     const storyDir = join(state.bookDir(bookId), "story");
     const now = "2026-03-19T00:00:00.000Z";
@@ -3047,16 +3445,18 @@ describe("PipelineRunner", () => {
 
     try {
       const result = await runner.writeNextChapter(bookId);
+      const driftFile = await readFile(join(storyDir, "audit_drift.md"), "utf-8");
       const currentState = await readFile(join(storyDir, "current_state.md"), "utf-8");
 
       expect(result.auditResult.issues.some((issue) => issue.category === "节奏单调")).toBe(true);
-      expect(currentState).toContain("节奏单调");
+      expect(driftFile).toContain("节奏单调");
+      expect(currentState).not.toContain("节奏单调");
     } finally {
       await rm(root, { recursive: true, force: true });
     }
   });
 
-  it("feeds hook health warnings back into pipeline audit and drift correction", async () => {
+  it("feeds hook health warnings back into pipeline audit and dedicated drift guidance", async () => {
     const { root, runner, state, bookId } = await createRunnerFixture();
     const storyDir = join(state.bookDir(bookId), "story");
 
@@ -3106,11 +3506,13 @@ describe("PipelineRunner", () => {
 
     try {
       const result = await runner.writeNextChapter(bookId);
+      const driftFile = await readFile(join(storyDir, "audit_drift.md"), "utf-8");
       const currentState = await readFile(join(storyDir, "current_state.md"), "utf-8");
       const savedIndex = await state.loadChapterIndex(bookId);
 
       expect(result.auditResult.issues.some((issue) => issue.category === "伏笔债务")).toBe(true);
-      expect(currentState).toContain("伏笔债务");
+      expect(driftFile).toContain("伏笔债务");
+      expect(currentState).not.toContain("伏笔债务");
       expect(savedIndex[0]?.auditIssues).toEqual(
         expect.arrayContaining([
           expect.stringContaining("活跃伏笔过多"),
@@ -3243,8 +3645,8 @@ describe("PipelineRunner", () => {
       createWriterOutput({
         chapterNumber: 2,
         title: "回声",
-        content: "这次的正文完全不同，只是标题碰巧重复了。",
-        wordCount: "这次的正文完全不同，只是标题碰巧重复了。".length,
+        content: "啊。",
+        wordCount: "啊。".length,
       }),
     );
     vi.spyOn(ContinuityAuditor.prototype, "auditChapter").mockResolvedValue(
@@ -3266,6 +3668,62 @@ describe("PipelineRunner", () => {
     }
   });
 
+  it("regenerates duplicate chapter titles before falling back to numeric suffixes", async () => {
+    const { root, runner, state, bookId } = await createRunnerFixture();
+    const storyDir = join(state.bookDir(bookId), "story");
+    const chaptersDir = join(state.bookDir(bookId), "chapters");
+    const now = "2026-03-19T00:00:00.000Z";
+
+    await Promise.all([
+      writeFile(join(chaptersDir, "0001_回声.md"), "# 第1章 回声\n\n旧章节。", "utf-8"),
+      writeFile(join(storyDir, "current_state.md"), createStateCard({
+        chapter: 1,
+        location: "Ashen ferry crossing",
+        protagonistState: "Lin Yue still hides the oath token.",
+        goal: "Find the vanished mentor.",
+        conflict: "The debt trail keeps narrowing.",
+      }), "utf-8"),
+      writeFile(join(storyDir, "pending_hooks.md"), "# Pending Hooks\n", "utf-8"),
+    ]);
+    await state.saveChapterIndex(bookId, [{
+      number: 1,
+      title: "回声",
+      status: "ready-for-review",
+      wordCount: 12,
+      createdAt: now,
+      updatedAt: now,
+      auditIssues: [],
+      lengthWarnings: [],
+    }]);
+
+    vi.spyOn(WriterAgent.prototype, "writeChapter").mockResolvedValue(
+      createWriterOutput({
+        chapterNumber: 2,
+        title: "回声",
+        content: "塔楼里的铜铃只响了一声，风从缺口灌进来，守夜人没有回头。",
+        wordCount: "塔楼里的铜铃只响了一声，风从缺口灌进来，守夜人没有回头。".length,
+      }),
+    );
+    vi.spyOn(ContinuityAuditor.prototype, "auditChapter").mockResolvedValue(
+      createAuditResult({
+        passed: true,
+        issues: [],
+        summary: "clean",
+      }),
+    );
+
+    try {
+      const result = await runner.writeNextChapter(bookId, 120);
+      const index = await state.loadChapterIndex(bookId);
+
+      expect(result.title).toContain("塔楼");
+      expect(result.title).not.toBe("回声（2）");
+      expect(index.at(-1)?.title).toBe(result.title);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
   it("defaults manual reviseDraft to spot-fix when mode is omitted", async () => {
     const { root, runner, state, bookId } = await createRunnerFixture();
     const storyDir = join(state.bookDir(bookId), "story");

packages/core/src/__tests__/planner.test.ts

@@ -77,7 +77,418 @@ describe("PlannerAgent", () => {
     await rm(root, { recursive: true, force: true });
   });
 
-  it("uses current focus as the chapter goal and writes a chapter intent file", async () => {
+  it("uses current focus as the chapter goal when no outline node is available", async () => {
+    await writeFile(
+      join(storyDir, "volume_outline.md"),
+      "# Volume Outline\n",
+      "utf-8",
+    );
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 3,
+    });
+
+    expect(result.intent.goal).toContain("mentor conflict");
+    await expect(readFile(result.runtimePath, "utf-8")).resolves.toContain("mentor conflict");
+  });
+
+  it("prefers a matched outline node over ordinary current focus text", async () => {
+    await Promise.all([
+      writeFile(
+        join(storyDir, "current_focus.md"),
+        [
+          "# Current Focus",
+          "",
+          "## Active Focus",
+          "",
+          "Pull the next chapter back toward the mentor fallout instead of the guild route.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        [
+          "# Volume Outline",
+          "",
+          "## Chapter 3",
+          "Track the merchant guild's escape route through the western canal.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 3,
+    });
+
+    expect(result.intent.outlineNode).toContain("merchant guild's escape route");
+    expect(result.intent.goal).toContain("merchant guild's escape route");
+    expect(result.intent.goal).not.toContain("mentor fallout");
+    expect(result.intent.conflicts).toEqual([]);
+  });
+
+  it("lets explicit local override focus beat the matched outline node", async () => {
+    await Promise.all([
+      writeFile(
+        join(storyDir, "current_focus.md"),
+        [
+          "# Current Focus",
+          "",
+          "## Active Focus",
+          "",
+          "Keep pressure on the guild route in the background.",
+          "",
+          "## Local Override",
+          "",
+          "Stay inside the mentor debt confrontation first and delay the canal pursuit by one chapter.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        [
+          "# Volume Outline",
+          "",
+          "## Chapter 3",
+          "Track the merchant guild's escape route through the western canal.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 3,
+    });
+
+    expect(result.intent.outlineNode).toContain("merchant guild's escape route");
+    expect(result.intent.goal).toContain("mentor debt confrontation");
+    expect(result.intent.goal).not.toContain("merchant guild's escape route");
+    expect(result.intent.conflicts).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: "outline_vs_current_focus",
+        resolution: "allow explicit current focus override",
+      }),
+    ]));
+  });
+
+  it("keeps external context above both outline anchors and current focus", async () => {
+    await Promise.all([
+      writeFile(
+        join(storyDir, "current_focus.md"),
+        [
+          "# Current Focus",
+          "",
+          "## Active Focus",
+          "",
+          "Pull the next chapter back toward the mentor fallout instead of the guild route.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        [
+          "# Volume Outline",
+          "",
+          "## Chapter 3",
+          "Track the merchant guild's escape route through the western canal.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 3,
+      externalContext: "Ignore the canal pursuit for now and force the next chapter into the mentor debt confrontation.",
+    });
+
+    expect(result.intent.goal).toContain("mentor debt confrontation");
+    expect(result.intent.goal).not.toContain("merchant guild's escape route");
+    expect(result.intent.conflicts).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: "outline_vs_request",
+        resolution: "allow local outline deferral",
+      }),
+    ]));
+  });
+
+  it("emits structured directives when fallback planning, chapter type repetition, and title collapse stack up", async () => {
+    book = {
+      ...book,
+      genre: "other",
+      language: "en",
+    };
+
+    await Promise.all([
+      writeFile(
+        join(storyDir, "author_intent.md"),
+        "# Author Intent\n\n(Describe the long-horizon vision for this book here.)\n",
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "current_focus.md"),
+        [
+          "# Current Focus",
+          "",
+          "## Active Focus",
+          "",
+          "(Describe what the next 1-3 chapters should prioritize.)",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        [
+          "# Volume Outline",
+          "",
+          "## Chapter 8",
+          "Expose the registry clerk's hidden ledger in the floodgate archive.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "chapter_summaries.md"),
+        [
+          "# Chapter Summaries",
+          "",
+          "| chapter | title | characters | events | stateChanges | hookActivity | mood | chapterType |",
+          "| --- | --- | --- | --- | --- | --- | --- | --- |",
+          "| 1 | Ledger in Rain | Taryn | Taryn checks the first false folio | None | hook advanced | tight | investigation |",
+          "| 2 | Ledger at Dusk | Taryn | Taryn questions the dock clerk | None | hook advanced | tight | investigation |",
+          "| 3 | Ledger Below | Taryn | Taryn searches the under-archive | None | hook advanced | tight | investigation |",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 4,
+    });
+
+    expect(result.intent.arcDirective).toContain("fallback");
+    expect(result.intent.sceneDirective).toContain("investigation");
+    expect(result.intent.titleDirective?.toLowerCase()).toContain("ledger");
+    expect(result.intent.moodDirective).toBeUndefined();
+  });
+
+  it("emits a mood directive when recent chapters are all high-tension", async () => {
+    book = {
+      ...book,
+      genre: "other",
+      language: "zh",
+    };
+
+    await Promise.all([
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        "# Volume Outline\n\n## Chapter 5\n进入新的地点。\n",
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "chapter_summaries.md"),
+        [
+          "# Chapter Summaries",
+          "",
+          "| chapter | title | characters | events | stateChanges | hookActivity | mood | chapterType |",
+          "| --- | --- | --- | --- | --- | --- | --- | --- |",
+          "| 1 | 暗巷追踪 | 周谨川 | 追踪目标 | None | none | 紧张、压抑 | 悬念验证章 |",
+          "| 2 | 旧楼对峙 | 周谨川 | 对峙 | None | none | 冷硬、逼仄 | 冲突章 |",
+          "| 3 | 夜色围堵 | 周谨川 | 围堵 | None | none | 肃杀、凝重 | 追击章 |",
+          "| 4 | 地下通道 | 周谨川 | 逃脱 | None | none | 压迫、窒息 | 逃亡章 |",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 5,
+    });
+
+    expect(result.intent.moodDirective).toBeDefined();
+    expect(result.intent.moodDirective).toContain("降调");
+    expect(result.intent.moodDirective).toContain("日常");
+  });
+
+  it("does not emit a mood directive when recent moods are varied", async () => {
+    book = {
+      ...book,
+      genre: "other",
+      language: "en",
+    };
+
+    await Promise.all([
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        "# Volume Outline\n\n## Chapter 5\nMove to the harbor.\n",
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "chapter_summaries.md"),
+        [
+          "# Chapter Summaries",
+          "",
+          "| chapter | title | characters | events | stateChanges | hookActivity | mood | chapterType |",
+          "| --- | --- | --- | --- | --- | --- | --- | --- |",
+          "| 1 | Morning Calm | Taryn | A quiet walk | None | none | warm, gentle | slice-of-life |",
+          "| 2 | Sudden Rain | Taryn | Storm arrives | None | none | tense, ominous | tension |",
+          "| 3 | Harbor Light | Taryn | Finds shelter | None | none | hopeful, light | transition |",
+          "| 4 | The Letter | Taryn | Reads bad news | None | none | melancholy, reflective | introspection |",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 5,
+    });
+
+    expect(result.intent.moodDirective).toBeUndefined();
+  });
+
+  it("ignores the default current_focus placeholder and falls back to author intent when no chapter outline is available", async () => {
+    await Promise.all([
+      writeFile(
+        join(storyDir, "current_focus.md"),
+        [
+          "# Current Focus",
+          "",
+          "## Active Focus",
+          "",
+          "(Describe what the next 1-3 chapters should prioritize.)",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        "# Volume Outline\n",
+        "utf-8",
+      ),
+    ]);
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 3,
+    });
+
+    expect(result.intent.goal).toContain("mentor-student bond");
+    expect(result.intent.goal).not.toContain("Describe what the next 1-3 chapters should prioritize");
+  });
+
+  it("uses bullet-style volume outline chapter nodes as the fallback goal when control docs are placeholders", async () => {
+    await Promise.all([
+      writeFile(
+        join(storyDir, "author_intent.md"),
+        "# Author Intent\n\n(Describe the long-horizon vision for this book here.)\n",
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "current_focus.md"),
+        [
+          "# Current Focus",
+          "",
+          "## Active Focus",
+          "",
+          "(Describe what the next 1-3 chapters should prioritize.)",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        [
+          "## Volume 1",
+          "**Chapter range:** 1-8",
+          "",
+          "**Key turning points:**",
+          "- **Chapter 3:** Track the merchant guild's escape route through the western canal.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
     const planner = new PlannerAgent({
       client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
       model: "test-model",
@@ -91,11 +502,18 @@ describe("PlannerAgent", () => {
       chapterNumber: 3,
     });
 
-    expect(result.intent.goal).toContain("mentor conflict");
-    await expect(readFile(result.runtimePath, "utf-8")).resolves.toContain("mentor conflict");
+    expect(result.intent.outlineNode).toContain("merchant guild's escape route");
+    expect(result.intent.goal).toContain("merchant guild's escape route");
+    expect(result.intent.goal).not.toContain("Advance chapter 3 with clear narrative focus.");
   });
 
-  it("ignores the default current_focus placeholder and falls back to author intent when no chapter outline is available", async () => {
+  it("uses the next paragraph for bold standalone English chapter labels instead of capturing markdown markers", async () => {
+    book = {
+      ...book,
+      genre: "other",
+      language: "en",
+    };
+
     await Promise.all([
       writeFile(
         join(storyDir, "current_focus.md"),
@@ -111,7 +529,19 @@ describe("PlannerAgent", () => {
       ),
       writeFile(
         join(storyDir, "volume_outline.md"),
-        "# Volume Outline\n",
+        [
+          "## Volume 1 - The Dead Examiner",
+          "**Chapter Range:** 1-12",
+          "",
+          "**Key Turning Points:**",
+          "- Ch1: Renn dies after summoning Taryn to review irregular treaty folios.",
+          "",
+          "### Golden First Three Chapters Rule",
+          "",
+          "**Chapter 2:**",
+          "Show Taryn's edge through action, not exposition. He uses registry numbering logic to identify which folios are decoys and which conceal a ledger fragment.",
+          "",
+        ].join("\n"),
         "utf-8",
       ),
     ]);
@@ -126,14 +556,70 @@ describe("PlannerAgent", () => {
     const result = await planner.planChapter({
       book,
       bookDir,
-      chapterNumber: 3,
+      chapterNumber: 2,
     });
 
-    expect(result.intent.goal).toContain("mentor-student bond");
-    expect(result.intent.goal).not.toContain("Describe what the next 1-3 chapters should prioritize");
+    expect(result.intent.outlineNode).toContain("Show Taryn's edge through action");
+    expect(result.intent.outlineNode).not.toBe("**");
+    expect(result.intent.goal).toContain("Show Taryn's edge through action");
+    expect(result.intent.goal).not.toBe("**");
   });
 
-  it("uses bullet-style volume outline chapter nodes as the fallback goal when control docs are placeholders", async () => {
+  it("does not confuse Chapter 1 with Chapter 10 when matching exact English chapter labels", async () => {
+    book = {
+      ...book,
+      genre: "other",
+      language: "en",
+    };
+
+    await Promise.all([
+      writeFile(
+        join(storyDir, "current_focus.md"),
+        [
+          "# Current Focus",
+          "",
+          "## Active Focus",
+          "",
+          "(Describe what the next 1-3 chapters should prioritize.)",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        [
+          "# Volume Outline",
+          "",
+          "### Chapter 10",
+          "This late-volume node should not be selected for chapter one.",
+          "",
+          "### Chapter 1",
+          "Open with the dead examiner and the sealed folio dispute.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 1,
+    });
+
+    expect(result.intent.outlineNode).toContain("dead examiner");
+    expect(result.intent.outlineNode).not.toContain("late-volume");
+    expect(result.intent.goal).toContain("dead examiner");
+  });
+
+  it("uses inline Chinese exact chapter labels with a title suffix", async () => {
     await Promise.all([
       writeFile(
         join(storyDir, "author_intent.md"),
@@ -155,11 +641,9 @@ describe("PlannerAgent", () => {
       writeFile(
         join(storyDir, "volume_outline.md"),
         [
-          "## Volume 1",
-          "**Chapter range:** 1-8",
+          "# Volume Outline",
           "",
-          "**Key turning points:**",
-          "- **Chapter 3:** Track the merchant guild's escape route through the western canal.",
+          "第 7 章：在码头接头并截住逃跑账房。",
           "",
         ].join("\n"),
         "utf-8",
@@ -176,15 +660,68 @@ describe("PlannerAgent", () => {
     const result = await planner.planChapter({
       book,
       bookDir,
-      chapterNumber: 3,
+      chapterNumber: 7,
+    });
+
+    expect(result.intent.outlineNode).toContain("在码头接头");
+    expect(result.intent.goal).toContain("在码头接头");
+    expect(result.intent.goal).not.toContain("Describe the long-horizon vision");
+  });
+
+  it("uses standalone Chinese chapter-range labels when the chapter falls inside the range", async () => {
+    await Promise.all([
+      writeFile(
+        join(storyDir, "author_intent.md"),
+        "# Author Intent\n\n(Describe the long-horizon vision for this book here.)\n",
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "current_focus.md"),
+        [
+          "# Current Focus",
+          "",
+          "## Active Focus",
+          "",
+          "(Describe what the next 1-3 chapters should prioritize.)",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        [
+          "# Volume Outline",
+          "",
+          "第1-6章",
+          "Stay with the early city setup and mentor fallout.",
+          "",
+          "第7-20章",
+          "Track the merchant guild's escape route through the western canal.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 7,
     });
 
     expect(result.intent.outlineNode).toContain("merchant guild's escape route");
     expect(result.intent.goal).toContain("merchant guild's escape route");
-    expect(result.intent.goal).not.toContain("Advance chapter 3 with clear narrative focus.");
+    expect(result.intent.goal).not.toContain("Describe the long-horizon vision");
   });
 
-  it("uses the next paragraph for bold standalone English chapter labels instead of capturing markdown markers", async () => {
+  it("uses standalone English chapter-range labels at the start of the range", async () => {
     book = {
       ...book,
       genre: "other",
@@ -192,6 +729,11 @@ describe("PlannerAgent", () => {
     };
 
     await Promise.all([
+      writeFile(
+        join(storyDir, "author_intent.md"),
+        "# Author Intent\n\n(Describe the long-horizon vision for this book here.)\n",
+        "utf-8",
+      ),
       writeFile(
         join(storyDir, "current_focus.md"),
         [
@@ -207,16 +749,76 @@ describe("PlannerAgent", () => {
       writeFile(
         join(storyDir, "volume_outline.md"),
         [
-          "## Volume 1 - The Dead Examiner",
-          "**Chapter Range:** 1-12",
+          "# Volume Outline",
           "",
-          "**Key Turning Points:**",
-          "- Ch1: Renn dies after summoning Taryn to review irregular treaty folios.",
+          "Chapter 1-3",
+          "Keep the opening pressure on the first examiner.",
           "",
-          "### Golden First Three Chapters Rule",
+          "Chapter 4-6",
+          "Recover the sealed ledger before dawn.",
           "",
-          "**Chapter 2:**",
-          "Show Taryn's edge through action, not exposition. He uses registry numbering logic to identify which folios are decoys and which conceal a ledger fragment.",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 4,
+    });
+
+    expect(result.intent.outlineNode).toContain("sealed ledger");
+    expect(result.intent.goal).toContain("sealed ledger");
+    expect(result.intent.outlineNode).not.toContain("6");
+    expect(result.intent.goal).not.toContain("Describe the long-horizon vision");
+  });
+
+  it("uses the next paragraph for bold standalone English chapter-range labels instead of bleeding into the next range", async () => {
+    book = {
+      ...book,
+      genre: "other",
+      language: "en",
+    };
+
+    await Promise.all([
+      writeFile(
+        join(storyDir, "author_intent.md"),
+        "# Author Intent\n\n(Describe the long-horizon vision for this book here.)\n",
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "current_focus.md"),
+        [
+          "# Current Focus",
+          "",
+          "## Active Focus",
+          "",
+          "(Describe what the next 1-3 chapters should prioritize.)",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        [
+          "# Volume Outline",
+          "",
+          "**Chapter 1-3:**",
+          "Keep the opening pressure on the first examiner.",
+          "",
+          "**Chapter 4-6:**",
+          "Recover the sealed ledger before dawn.",
+          "",
+          "**Chapter 7-9:**",
+          "Trigger the registry fire and expose the false witness.",
           "",
         ].join("\n"),
         "utf-8",
@@ -233,13 +835,66 @@ describe("PlannerAgent", () => {
     const result = await planner.planChapter({
       book,
       bookDir,
-      chapterNumber: 2,
+      chapterNumber: 4,
     });
 
-    expect(result.intent.outlineNode).toContain("Show Taryn's edge through action");
-    expect(result.intent.outlineNode).not.toBe("**");
-    expect(result.intent.goal).toContain("Show Taryn's edge through action");
-    expect(result.intent.goal).not.toBe("**");
+    expect(result.intent.outlineNode).toContain("sealed ledger");
+    expect(result.intent.outlineNode).not.toContain("registry fire");
+    expect(result.intent.goal).toContain("sealed ledger");
+  });
+
+  it("falls back to the first outline directive when no standalone range matches", async () => {
+    await Promise.all([
+      writeFile(
+        join(storyDir, "author_intent.md"),
+        "# Author Intent\n\n(Describe the long-horizon vision for this book here.)\n",
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "current_focus.md"),
+        [
+          "# Current Focus",
+          "",
+          "## Active Focus",
+          "",
+          "(Describe what the next 1-3 chapters should prioritize.)",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        [
+          "# Volume Outline",
+          "",
+          "第1-6章",
+          "Stay with the early city setup and mentor fallout.",
+          "",
+          "第7-20章",
+          "Track the merchant guild's escape route through the western canal.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+    ]);
+
+    const planner = new PlannerAgent({
+      client: {} as ConstructorParameters<typeof PlannerAgent>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      bookId: book.id,
+    });
+
+    const result = await planner.planChapter({
+      book,
+      bookDir,
+      chapterNumber: 25,
+    });
+
+    expect(result.intent.outlineNode).toContain("Stay with the early city setup");
+    expect(result.intent.goal).toContain("Stay with the early city setup");
+    expect(result.intent.outlineNode).not.toBe("第1-6章");
+    expect(result.intent.goal).not.toContain("merchant guild's escape route");
   });
 
   it("preserves hard facts from state and canon in mustKeep", async () => {
@@ -386,7 +1041,7 @@ describe("PlannerAgent", () => {
     });
 
     const intentMarkdown = await readFile(result.runtimePath, "utf-8");
-    expect(intentMarkdown).toContain("| hook_id | start_chapter | type | status | last_advanced | expected_payoff | notes |");
+    expect(intentMarkdown).toContain("| hook_id | start_chapter | type | status | last_advanced | expected_payoff | payoff_timing | notes |");
     expect(intentMarkdown).toContain("| chapter | title | characters | events | stateChanges | hookActivity | mood | chapterType |");
     expect(intentMarkdown).not.toContain("| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 备注 |");
     expect(intentMarkdown).not.toContain("| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |");
@@ -424,6 +1079,11 @@ describe("PlannerAgent", () => {
         ].join("\n"),
         "utf-8",
       ),
+      writeFile(
+        join(storyDir, "volume_outline.md"),
+        "# Volume Outline\n",
+        "utf-8",
+      ),
     ]);
 
     const planner = new PlannerAgent({
@@ -436,7 +1096,7 @@ describe("PlannerAgent", () => {
     const result = await planner.planChapter({
       book,
       bookDir,
-      chapterNumber: 3,
+      chapterNumber: 2,
     });
 
     expect(result.intent.goal).toContain("private confrontation");
@@ -543,13 +1203,14 @@ describe("PlannerAgent", () => {
       externalContext: "Keep the chapter on the mainline debt conflict.",
     });
 
-    expect(result.intent.hookAgenda.mustAdvance).toEqual(["recent-route", "ready-payoff"]);
+    expect(result.intent.hookAgenda.mustAdvance).toEqual(["stale-debt", "ready-payoff"]);
     expect(result.intent.hookAgenda.eligibleResolve).toEqual(["ready-payoff"]);
     expect(result.intent.hookAgenda.staleDebt).toEqual(["stale-debt"]);
+    expect(result.intent.hookAgenda.avoidNewHookFamilies).toContain("relationship");
+    expect(result.intent.hookAgenda.pressureMap).toEqual([]);
 
     const intentMarkdown = await readFile(result.runtimePath, "utf-8");
     expect(intentMarkdown).toContain("## Hook Agenda");
-    expect(intentMarkdown).toContain("recent-route");
     expect(intentMarkdown).toContain("ready-payoff");
     expect(intentMarkdown).toContain("stale-debt");
   });
@@ -660,7 +1321,12 @@ describe("PlannerAgent", () => {
       externalContext: "Keep the chapter on the route pressure.",
     });
 
-    expect(result.intent.hookAgenda.mustAdvance).toEqual(["recent-route", "recent-guild"]);
+    expect(result.intent.hookAgenda.mustAdvance).toEqual(["stale-omega", "stale-sable"]);
     expect(result.intent.hookAgenda.staleDebt).toEqual(["stale-omega", "stale-sable"]);
+    expect(result.intent.hookAgenda.avoidNewHookFamilies).toEqual(expect.arrayContaining([
+      "relationship",
+      "mystery",
+    ]));
+    expect(result.intent.hookAgenda.pressureMap).toEqual([]);
   });
 });

packages/core/src/__tests__/post-write-validator.test.ts

@@ -3,6 +3,7 @@ import {
   detectDuplicateTitle,
   detectParagraphLengthDrift,
   detectParagraphShapeWarnings,
+  resolveDuplicateTitle,
   validatePostWrite,
   type PostWriteViolation,
 } from "../agents/post-write-validator.js";
@@ -244,4 +245,33 @@ describe("validatePostWrite", () => {
     const result = detectDuplicateTitle("Echo-2", ["Echo 2"]);
     expect(findRule(result, "near-duplicate-title")).toBeDefined();
   });
+
+  it("prefers regenerating a duplicate title from chapter content before numeric suffix fallback", () => {
+    const result = resolveDuplicateTitle(
+      "回声",
+      ["旧路", "回声"],
+      "zh",
+      {
+        content: "塔楼里的铜铃只响了一声，风从缺口灌进来，守夜人没有回头。",
+      },
+    );
+
+    expect(result.title).toContain("塔楼");
+    expect(result.title).not.toBe("回声（2）");
+  });
+
+  it("regenerates a title when it continues a collapsed recent title shell", () => {
+    const result = resolveDuplicateTitle(
+      "名单未落",
+      ["名单之前", "名单之后", "名单还在"],
+      "zh",
+      {
+        content: "塔楼里的铜铃只响了一声，守夜人没有回头，风从缺口灌进来。",
+      },
+    );
+
+    expect(result.issues.some((issue) => issue.rule === "title-collapse")).toBe(true);
+    expect(result.title).not.toContain("名单");
+    expect(result.title).toContain("塔楼");
+  });
 });

packages/core/src/__tests__/scheduler.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { Scheduler, type SchedulerConfig } from "../pipeline/scheduler.js";
+import type { BookConfig } from "../models/book.js";
 
 function createConfig(): SchedulerConfig {
   return {
@@ -65,4 +66,58 @@ describe("Scheduler", () => {
     await blockedCycle;
     scheduler.stop();
   });
+
+  it("treats state-degraded chapter results as handled failures", async () => {
+    const onChapterComplete = vi.fn();
+    const scheduler = new Scheduler({
+      ...createConfig(),
+      onChapterComplete,
+    });
+    const bookConfig: BookConfig = {
+      id: "book-1",
+      title: "Book 1",
+      platform: "other",
+      genre: "other",
+      status: "active",
+      targetChapters: 10,
+      chapterWordCount: 2200,
+      createdAt: "2026-04-01T00:00:00.000Z",
+      updatedAt: "2026-04-01T00:00:00.000Z",
+    };
+
+    vi.spyOn(
+      (scheduler as unknown as { pipeline: { writeNextChapter: (bookId: string, words?: number, temp?: number) => Promise<unknown> } }).pipeline,
+      "writeNextChapter",
+    ).mockResolvedValue({
+        chapterNumber: 3,
+        title: "Broken State",
+        wordCount: 2100,
+        revised: false,
+        status: "state-degraded",
+        auditResult: {
+          passed: true,
+          issues: [{
+            severity: "warning",
+            category: "state-validation",
+            description: "state validation still failed after retry",
+            suggestion: "repair state before continuing",
+          }],
+          summary: "clean",
+        },
+    });
+    const handleAuditFailure = vi.spyOn(
+      scheduler as unknown as { handleAuditFailure: (bookId: string, chapterNumber: number, issueCategories?: string[]) => Promise<void> },
+      "handleAuditFailure",
+    ).mockResolvedValue(undefined);
+
+    const success = await (
+      scheduler as unknown as {
+        writeOneChapter: (bookId: string, bookConfig: BookConfig) => Promise<boolean>;
+      }
+    ).writeOneChapter("book-1", bookConfig);
+
+    expect(success).toBe(false);
+    expect(handleAuditFailure).toHaveBeenCalledWith("book-1", 3, ["state-validation"]);
+    expect(onChapterComplete).toHaveBeenCalledWith("book-1", 3, "state-degraded");
+  });
 });

packages/core/src/__tests__/state-manager.test.ts

@@ -1111,4 +1111,143 @@ describe("StateManager", () => {
       expect(hooks.hooks.map((hook) => hook.hookId)).toEqual(["H009"]);
     });
   });
+
+  // -------------------------------------------------------------------------
+  // rollbackToChapter — reject a chapter and discard downstream state
+  // -------------------------------------------------------------------------
+
+  describe("rollbackToChapter", () => {
+    const bookId = "rollback-book";
+
+    async function setupRollbackBook(): Promise<void> {
+      await manager.saveBookConfig(bookId, {
+        id: bookId,
+        title: "Rollback Test",
+        platform: "tomato",
+        genre: "xuanhuan",
+        status: "active",
+        targetChapters: 10,
+        chapterWordCount: 3000,
+        createdAt: "2026-03-31T00:00:00Z",
+        updatedAt: "2026-03-31T00:00:00Z",
+      });
+
+      const bookDir = manager.bookDir(bookId);
+      const storyDir = join(bookDir, "story");
+      const chaptersDir = join(bookDir, "chapters");
+      const runtimeDir = join(storyDir, "runtime");
+      await mkdir(runtimeDir, { recursive: true });
+      await mkdir(chaptersDir, { recursive: true });
+
+      // Write initial state (chapter 0 baseline)
+      await writeFile(join(storyDir, "current_state.md"), "# State\n\n- Initial state.\n", "utf-8");
+      await writeFile(join(storyDir, "pending_hooks.md"), "# Hooks\n\n- hook-1\n", "utf-8");
+      await writeFile(join(storyDir, "chapter_summaries.md"), "# Summaries\n", "utf-8");
+      await manager.snapshotState(bookId, 0);
+
+      // Write chapter 1 state + file
+      await writeFile(join(storyDir, "current_state.md"), "# State\n\n- After chapter 1.\n", "utf-8");
+      await writeFile(join(storyDir, "pending_hooks.md"), "# Hooks\n\n- hook-1\n- hook-2\n", "utf-8");
+      await writeFile(join(storyDir, "chapter_summaries.md"), "# Summaries\n\n| 1 | Title 1 |\n", "utf-8");
+      await writeFile(join(chaptersDir, "0001_Title_One.md"), "# Chapter 1\n\nContent 1.", "utf-8");
+      await manager.snapshotState(bookId, 1);
+
+      // Write chapter 2 state + file
+      await writeFile(join(storyDir, "current_state.md"), "# State\n\n- After chapter 2.\n", "utf-8");
+      await writeFile(join(storyDir, "pending_hooks.md"), "# Hooks\n\n- hook-1\n- hook-2\n- hook-3\n", "utf-8");
+      await writeFile(join(storyDir, "chapter_summaries.md"), "# Summaries\n\n| 1 | Title 1 |\n| 2 | Title 2 |\n", "utf-8");
+      await writeFile(join(chaptersDir, "0002_Title_Two.md"), "# Chapter 2\n\nContent 2.", "utf-8");
+      await writeFile(join(runtimeDir, "chapter-002.intent.md"), "intent 2", "utf-8");
+      await manager.snapshotState(bookId, 2);
+
+      // Write chapter 3 state + file
+      await writeFile(join(storyDir, "current_state.md"), "# State\n\n- After chapter 3.\n", "utf-8");
+      await writeFile(join(storyDir, "pending_hooks.md"), "# Hooks\n\n- hook-1\n- hook-2\n- hook-3\n- hook-4\n", "utf-8");
+      await writeFile(join(storyDir, "chapter_summaries.md"), "# Summaries\n\n| 1 | Title 1 |\n| 2 | Title 2 |\n| 3 | Title 3 |\n", "utf-8");
+      await writeFile(join(chaptersDir, "0003_Title_Three.md"), "# Chapter 3\n\nContent 3.", "utf-8");
+      await writeFile(join(runtimeDir, "chapter-003.intent.md"), "intent 3", "utf-8");
+      await manager.snapshotState(bookId, 3);
+
+      // Save index with all 3 chapters
+      const now = "2026-03-31T00:00:00Z";
+      await manager.saveChapterIndex(bookId, [
+        { number: 1, title: "Title One", status: "approved", wordCount: 100, createdAt: now, updatedAt: now, auditIssues: [], lengthWarnings: [] },
+        { number: 2, title: "Title Two", status: "ready-for-review", wordCount: 100, createdAt: now, updatedAt: now, auditIssues: [], lengthWarnings: [] },
+        { number: 3, title: "Title Three", status: "audit-failed", wordCount: 100, createdAt: now, updatedAt: now, auditIssues: ["pacing"], lengthWarnings: [] },
+      ]);
+    }
+
+    it("restores state to the target chapter and removes subsequent chapters", async () => {
+      await setupRollbackBook();
+
+      const discarded = await manager.rollbackToChapter(bookId, 1);
+
+      expect(discarded).toEqual([2, 3]);
+
+      // State should be restored to chapter 1 snapshot
+      const bookDir = manager.bookDir(bookId);
+      const state = await readFile(join(bookDir, "story", "current_state.md"), "utf-8");
+      expect(state).toContain("After chapter 1");
+      expect(state).not.toContain("After chapter 3");
+
+      const hooks = await readFile(join(bookDir, "story", "pending_hooks.md"), "utf-8");
+      expect(hooks).toContain("hook-2");
+      expect(hooks).not.toContain("hook-4");
+
+      // Chapter index should only have chapter 1
+      const index = await manager.loadChapterIndex(bookId);
+      expect(index).toHaveLength(1);
+      expect(index[0]!.number).toBe(1);
+      expect(index[0]!.status).toBe("approved");
+
+      // Chapter files for 2 and 3 should be deleted
+      const chaptersDir = join(bookDir, "chapters");
+      const { readdir: rd } = await import("node:fs/promises");
+      const remaining = (await rd(chaptersDir)).filter((f) => f.endsWith(".md"));
+      expect(remaining).toEqual(["0001_Title_One.md"]);
+
+      // Snapshots for 2 and 3 should be deleted
+      const snapshotsDir = join(bookDir, "story", "snapshots");
+      const snapshots = await rd(snapshotsDir);
+      expect(snapshots.sort()).toEqual(["0", "1"]);
+    });
+
+    it("rolls back to chapter 0 (initial state) when rejecting chapter 1", async () => {
+      await setupRollbackBook();
+
+      const discarded = await manager.rollbackToChapter(bookId, 0);
+
+      expect(discarded).toEqual([1, 2, 3]);
+
+      const bookDir = manager.bookDir(bookId);
+      const state = await readFile(join(bookDir, "story", "current_state.md"), "utf-8");
+      expect(state).toContain("Initial state");
+
+      const index = await manager.loadChapterIndex(bookId);
+      expect(index).toHaveLength(0);
+    });
+
+    it("throws when the target snapshot does not exist", async () => {
+      await setupRollbackBook();
+
+      await expect(manager.rollbackToChapter(bookId, 99)).rejects.toThrow("Cannot restore snapshot");
+    });
+
+    it("removes sqlite memory files when rolling back", async () => {
+      await setupRollbackBook();
+
+      const storyDir = join(manager.bookDir(bookId), "story");
+      await Promise.all([
+        writeFile(join(storyDir, "memory.db"), "stale db", "utf-8"),
+        writeFile(join(storyDir, "memory.db-shm"), "stale shm", "utf-8"),
+        writeFile(join(storyDir, "memory.db-wal"), "stale wal", "utf-8"),
+      ]);
+
+      await manager.rollbackToChapter(bookId, 1);
+
+      await expect(stat(join(storyDir, "memory.db"))).rejects.toThrow();
+      await expect(stat(join(storyDir, "memory.db-shm"))).rejects.toThrow();
+      await expect(stat(join(storyDir, "memory.db-wal"))).rejects.toThrow();
+    });
+  });
 });

packages/core/src/__tests__/state-projections.test.ts

@@ -33,10 +33,10 @@ describe("state projections", () => {
     expect(markdown).toBe([
       "# Pending Hooks",
       "",
-      "| hook_id | start_chapter | type | status | last_advanced_chapter | expected_payoff | notes |",
-      "| --- | --- | --- | --- | --- | --- | --- |",
-      "| a-debt | 4 | relationship | progressing | 11 | Reveal the debt. | Old oath token resurfaces. |",
-      "| b-courier | 12 | mystery | open | 13 | Identify the courier. | The seal is still broken. |",
+      "| hook_id | start_chapter | type | status | last_advanced_chapter | expected_payoff | payoff_timing | notes |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| a-debt | 4 | relationship | progressing | 11 | Reveal the debt. | mid-arc | Old oath token resurfaces. |",
+      "| b-courier | 12 | mystery | open | 13 | Identify the courier. | mid-arc | The seal is still broken. |",
       "",
     ].join("\n"));
   });

packages/core/src/__tests__/writer.test.ts

@@ -205,6 +205,11 @@ describe("WriterAgent", () => {
               reason: "Carry forward unresolved hook.",
               excerpt: "relationship | open | 101 | Mentor oath debt with Lin Yue",
             },
+            {
+              source: "runtime/hook_debt#mentor-oath",
+              reason: "Explicit hook debt brief for the agenda target.",
+              excerpt: "mentor-oath | cadence: slow-burn | seed: ch8 River Camp - Mentor debt becomes personal | latest: ch99 Locked Gate - Lin Yue chooses the mentor line over the guild line | unpaid: reveal why the mentor broke the oath",
+            },
           ],
         },
         ruleStack: {
@@ -224,7 +229,9 @@ describe("WriterAgent", () => {
       expect(settlePrompt).toContain("## 本章控制输入");
       expect(settlePrompt).toContain("story/chapter_summaries.md#99");
       expect(settlePrompt).toContain("| 99 | Locked Gate |");
-      expect(settlePrompt).toContain("| stale-ledger | 14 | mystery | open | 70 | 120 | Old ledger debt is dormant but unresolved |");
+      expect(settlePrompt).toContain("## Hook Debt Briefs");
+      expect(settlePrompt).toContain("mentor-oath | cadence: slow-burn");
+      expect(settlePrompt).toContain("| stale-ledger | 14 | mystery | open | 70 | 120 | 中程 | Old ledger debt is dormant but unresolved |");
       expect(settlePrompt).not.toContain("| 1 | Guild Trail |");
       expect(settlePrompt).not.toContain("old-seal");
       expect(settlePrompt).not.toContain("Guildmaster Ren");
@@ -908,4 +915,295 @@ describe("WriterAgent", () => {
       await rm(root, { recursive: true, force: true });
     }
   });
+
+  it("renders explicit title history, mood trail, and canon blocks in governed creative prompts", async () => {
+    const root = await mkdtemp(join(tmpdir(), "inkos-writer-governed-evidence-test-"));
+    const bookDir = join(root, "book");
+    const storyDir = join(bookDir, "story");
+    await mkdir(storyDir, { recursive: true });
+
+    await Promise.all([
+      writeFile(join(storyDir, "story_bible.md"), "# Story Bible\n\n- Registry seals still matter.\n", "utf-8"),
+      writeFile(join(storyDir, "volume_outline.md"), "# Volume Outline\n\n## Chapter 4\nPush Mara back toward the archive ledger.\n", "utf-8"),
+      writeFile(join(storyDir, "style_guide.md"), "# Style Guide\n\n- Keep the prose lean.\n", "utf-8"),
+      writeFile(join(storyDir, "current_state.md"), "# Current State\n\n- Mara still hides the ledger fragment.\n", "utf-8"),
+      writeFile(join(storyDir, "pending_hooks.md"), "# Pending Hooks\n\n- ledger-fragment\n", "utf-8"),
+      writeFile(join(storyDir, "chapter_summaries.md"), "# Chapter Summaries\n", "utf-8"),
+    ]);
+
+    const agent = new WriterAgent({
+      client: {
+        provider: "openai",
+        apiFormat: "chat",
+        stream: false,
+        defaults: {
+          temperature: 0.7,
+          maxTokens: 4096,
+          thinkingBudget: 0, maxTokensCap: null,
+          extra: {},
+        },
+      },
+      model: "test-model",
+      projectRoot: root,
+    });
+
+    const chatSpy = vi.spyOn(WriterAgent.prototype as never, "chat" as never)
+      .mockResolvedValueOnce({
+        content: [
+          "=== CHAPTER_TITLE ===",
+          "Archive Pressure",
+          "",
+          "=== CHAPTER_CONTENT ===",
+          "Mara corners Taryn beside the archive ledger.",
+          "",
+          "=== PRE_WRITE_CHECK ===",
+          "- ok",
+        ].join("\n"),
+        usage: ZERO_USAGE,
+      })
+      .mockResolvedValueOnce({
+        content: "=== OBSERVATIONS ===\n- observed",
+        usage: ZERO_USAGE,
+      })
+      .mockResolvedValueOnce({
+        content: [
+          "=== POST_SETTLEMENT ===",
+          "- ledger-fragment advanced",
+          "",
+          "=== UPDATED_STATE ===",
+          "state",
+          "",
+          "=== UPDATED_HOOKS ===",
+          "hooks",
+          "",
+          "=== CHAPTER_SUMMARY ===",
+          "| 4 | Archive Pressure | Mara,Taryn | Pressure rises | Trail narrows | ledger-fragment advanced | tense | confrontation |",
+          "",
+          "=== UPDATED_SUBPLOTS ===",
+          "subplots",
+          "",
+          "=== UPDATED_EMOTIONAL_ARCS ===",
+          "arcs",
+          "",
+          "=== UPDATED_CHARACTER_MATRIX ===",
+          "matrix",
+        ].join("\n"),
+        usage: ZERO_USAGE,
+      });
+
+    try {
+      await agent.writeChapter({
+        book: {
+          id: "writer-book",
+          title: "Writer Book",
+          platform: "other",
+          genre: "other",
+          status: "active",
+          targetChapters: 20,
+          chapterWordCount: 2200,
+          language: "en",
+          createdAt: "2026-03-26T00:00:00.000Z",
+          updatedAt: "2026-03-26T00:00:00.000Z",
+        },
+        bookDir,
+        chapterNumber: 4,
+        chapterIntent: "# Chapter Intent\n\n## Goal\nPush Mara back toward the archive ledger.\n",
+        contextPackage: {
+          chapter: 4,
+          selectedContext: [
+            {
+              source: "story/chapter_summaries.md#recent_titles",
+              reason: "Avoid repeated ledger titles.",
+              excerpt: "1: Ledger in Rain | 2: Ledger at Dusk | 3: Harbor Ledger",
+            },
+            {
+              source: "story/chapter_summaries.md#recent_mood_type_trail",
+              reason: "Track recent emotional and chapter-type cadence.",
+              excerpt: "1: tight / investigation | 2: tight / investigation | 3: tight / investigation",
+            },
+            {
+              source: "story/parent_canon.md",
+              reason: "Preserve parent canon constraints.",
+              excerpt: "The mentor does not learn about the archive fire until volume two.",
+            },
+            {
+              source: "story/fanfic_canon.md",
+              reason: "Preserve extracted fanfic canon constraints.",
+              excerpt: "Mara may diverge from the archive route, but the oath debt logic must stay intact.",
+            },
+          ],
+        },
+        ruleStack: {
+          layers: [{ id: "L4", name: "current_task", precedence: 70, scope: "local" }],
+          sections: {
+            hard: ["current_state"],
+            soft: ["current_focus"],
+            diagnostic: ["continuity_audit"],
+          },
+          overrideEdges: [],
+          activeOverrides: [],
+        },
+        lengthSpec: buildLengthSpec(2200, "en"),
+      });
+
+      const creativePrompt = (chatSpy.mock.calls[0]?.[0] as ReadonlyArray<{ content: string }> | undefined)?.[1]?.content ?? "";
+      expect(creativePrompt).toContain("## Recent Title History");
+      expect(creativePrompt).toContain("Ledger in Rain");
+      expect(creativePrompt).toContain("## Recent Mood / Chapter Type Trail");
+      expect(creativePrompt).toContain("tight / investigation");
+      expect(creativePrompt).toContain("## Canon Evidence");
+      expect(creativePrompt).toContain("archive fire until volume two");
+      expect(creativePrompt).toContain("oath debt logic must stay intact");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("renders an explicit hook agenda block and removes placeholder hook ids from the governed write contract", async () => {
+    const root = await mkdtemp(join(tmpdir(), "inkos-writer-hook-agenda-test-"));
+    const bookDir = join(root, "book");
+    const storyDir = join(bookDir, "story");
+    await mkdir(storyDir, { recursive: true });
+
+    await Promise.all([
+      writeFile(join(storyDir, "story_bible.md"), "# Story Bible\n\n- Registry seals still matter.\n", "utf-8"),
+      writeFile(join(storyDir, "volume_outline.md"), "# Volume Outline\n\n## Chapter 4\nPush Mara back toward the archive ledger.\n", "utf-8"),
+      writeFile(join(storyDir, "style_guide.md"), "# Style Guide\n\n- Keep the prose lean.\n", "utf-8"),
+      writeFile(join(storyDir, "current_state.md"), "# Current State\n\n- Mara still hides the ledger fragment.\n", "utf-8"),
+      writeFile(join(storyDir, "pending_hooks.md"), "# Pending Hooks\n\n- ledger-fragment\n", "utf-8"),
+      writeFile(join(storyDir, "chapter_summaries.md"), "# Chapter Summaries\n", "utf-8"),
+    ]);
+
+    const agent = new WriterAgent({
+      client: {
+        provider: "openai",
+        apiFormat: "chat",
+        stream: false,
+        defaults: {
+          temperature: 0.7,
+          maxTokens: 4096,
+          thinkingBudget: 0, maxTokensCap: null,
+          extra: {},
+        },
+      },
+      model: "test-model",
+      projectRoot: root,
+    });
+
+    const chatSpy = vi.spyOn(WriterAgent.prototype as never, "chat" as never)
+      .mockResolvedValueOnce({
+        content: [
+          "=== CHAPTER_TITLE ===",
+          "Archive Pressure",
+          "",
+          "=== CHAPTER_CONTENT ===",
+          "Mara corners Taryn beside the archive ledger.",
+          "",
+          "=== PRE_WRITE_CHECK ===",
+          "- ok",
+        ].join("\n"),
+        usage: ZERO_USAGE,
+      })
+      .mockResolvedValueOnce({
+        content: "=== OBSERVATIONS ===\n- observed",
+        usage: ZERO_USAGE,
+      })
+      .mockResolvedValueOnce({
+        content: [
+          "=== POST_SETTLEMENT ===",
+          "- ledger-fragment advanced",
+          "",
+          "=== UPDATED_STATE ===",
+          "state",
+          "",
+          "=== UPDATED_HOOKS ===",
+          "hooks",
+          "",
+          "=== CHAPTER_SUMMARY ===",
+          "| 4 | Archive Pressure | Mara,Taryn | Pressure rises | Trail narrows | ledger-fragment advanced | tense | confrontation |",
+          "",
+          "=== UPDATED_SUBPLOTS ===",
+          "subplots",
+          "",
+          "=== UPDATED_EMOTIONAL_ARCS ===",
+          "arcs",
+          "",
+          "=== UPDATED_CHARACTER_MATRIX ===",
+          "matrix",
+        ].join("\n"),
+        usage: ZERO_USAGE,
+      });
+
+    try {
+      await agent.writeChapter({
+        book: {
+          id: "writer-book",
+          title: "Writer Book",
+          platform: "other",
+          genre: "other",
+          status: "active",
+          targetChapters: 20,
+          chapterWordCount: 2200,
+          language: "en",
+          createdAt: "2026-03-26T00:00:00.000Z",
+          updatedAt: "2026-03-26T00:00:00.000Z",
+        },
+        bookDir,
+        chapterNumber: 4,
+        chapterIntent: [
+          "# Chapter Intent",
+          "",
+          "## Goal",
+          "Push Mara back toward the archive ledger.",
+          "",
+          "## Hook Agenda",
+          "### Must Advance",
+          "- mentor-oath",
+          "",
+          "### Eligible Resolve",
+          "- ledger-fragment",
+          "",
+          "### Stale Debt",
+          "- stale-ledger",
+          "",
+          "### Avoid New Hook Families",
+          "- relationship",
+        ].join("\n"),
+        contextPackage: {
+          chapter: 4,
+          selectedContext: [
+            {
+              source: "story/pending_hooks.md#mentor-oath",
+              reason: "Carry the unresolved oath line.",
+              excerpt: "relationship | open | old oath debt",
+            },
+          ],
+        },
+        ruleStack: {
+          layers: [{ id: "L4", name: "current_task", precedence: 70, scope: "local" }],
+          sections: {
+            hard: ["current_state"],
+            soft: ["current_focus"],
+            diagnostic: ["continuity_audit"],
+          },
+          overrideEdges: [],
+          activeOverrides: [],
+        },
+        lengthSpec: buildLengthSpec(2200, "en"),
+      });
+
+      const systemPrompt = (chatSpy.mock.calls[0]?.[0] as ReadonlyArray<{ content: string }> | undefined)?.[0]?.content ?? "";
+      const creativePrompt = (chatSpy.mock.calls[0]?.[0] as ReadonlyArray<{ content: string }> | undefined)?.[1]?.content ?? "";
+
+      expect(systemPrompt).not.toContain("Hook-A / Hook-B");
+      expect(systemPrompt).toContain("真实 hook_id");
+      expect(creativePrompt).toContain("## Explicit Hook Agenda");
+      expect(creativePrompt).toContain("mentor-oath");
+      expect(creativePrompt).toContain("ledger-fragment");
+      expect(creativePrompt).toContain("stale-ledger");
+      expect(creativePrompt).toContain("relationship");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
 });

packages/core/src/agents/architect.ts

@@ -195,18 +195,20 @@ enableFullCastTracking: false
 
     const pendingHooksPrompt = resolvedLanguage === "en"
       ? `Initial hook pool (Markdown table):
-| hook_id | start_chapter | type | status | last_advanced_chapter | expected_payoff | notes |
+| hook_id | start_chapter | type | status | last_advanced_chapter | expected_payoff | payoff_timing | notes |
 
 Rules for the hook table:
 - Column 5 must be a pure chapter number, never natural-language description
 - During book creation, all planned hooks are still unapplied, so last_advanced_chapter = 0
+- Column 7 must be one of: immediate / near-term / mid-arc / slow-burn / endgame
 - If you want to describe the initial clue/signal, put it in notes instead of column 5`
       : `初始伏笔池（Markdown表格）：
-| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 备注 |
+| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 回收节奏 | 备注 |
 
 伏笔表规则：
 - 第5列必须是纯数字章节号，不能写自然语言描述
 - 建书阶段所有伏笔都还没正式推进，所以第5列统一填 0
+- 第7列必须填写：立即 / 近期 / 中程 / 慢烧 / 终局 之一
 - 如果要说明“初始线索/最初信号”，写进备注，不要写进第5列`;
 
     const finalRequirementsPrompt = resolvedLanguage === "en"
@@ -489,9 +491,9 @@ enableFullCastTracking: false
 
     const pendingHooksPrompt = resolvedLanguage === "en"
       ? `Identify all active hooks from the source text (Markdown table):
-| hook_id | start_chapter | type | status | latest_progress | expected_payoff | notes |`
+| hook_id | start_chapter | type | status | latest_progress | expected_payoff | payoff_timing | notes |`
       : `从正文中识别的所有伏笔（Markdown表格）：
-| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 备注 |`;
+| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 回收节奏 | 备注 |`;
 
     const keyPrinciplesPrompt = resolvedLanguage === "en"
       ? `## Key Principles
@@ -745,7 +747,8 @@ prohibitions:
         status: row[3] ?? "open",
         lastAdvancedChapter: normalizedProgress,
         expectedPayoff: row[5] ?? "",
-        notes,
+        payoffTiming: row.length >= 8 ? row[6] ?? "" : "",
+        notes: row.length >= 8 ? this.mergeHookNotes(row[7] ?? "", seedNote, language) : notes,
       };
     });
 

packages/core/src/agents/chapter-analyzer.ts

@@ -279,7 +279,7 @@ Updated state card as a Markdown table reflecting the end-of-chapter state:
 
 === UPDATED_HOOKS ===
 Updated hooks pool as a Markdown table with the latest status of every known hook:
-| hook_id | start_chapter | type | status | last_advanced_chapter | expected_payoff | notes |
+| hook_id | start_chapter | type | status | last_advanced_chapter | expected_payoff | payoff_timing | notes |
 
 === CHAPTER_SUMMARY ===
 Single Markdown table row:
@@ -372,7 +372,7 @@ ${bookRulesBody ? `## 本书规则\n\n${bookRulesBody}` : ""}
 
 === UPDATED_HOOKS ===
 更新后的伏笔池（Markdown表格），包含所有已知伏笔的最新状态：
-| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 备注 |
+| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 回收节奏 | 备注 |
 
 === CHAPTER_SUMMARY ===
 本章摘要（Markdown表格行）：

packages/core/src/agents/composer.ts

@@ -12,7 +12,10 @@ import {
   type RuleStack,
 } from "../models/input-governance.js";
 import type { PlanChapterOutput } from "./planner.js";
-import { retrieveMemorySelection } from "../utils/memory-retrieval.js";
+import {
+  parseChapterSummariesMarkdown,
+  retrieveMemorySelection,
+} from "../utils/memory-retrieval.js";
 
 export interface ComposeChapterInput {
   readonly book: BookConfig;
@@ -40,7 +43,11 @@ export class ComposerAgent extends BaseAgent {
     const runtimeDir = join(storyDir, "runtime");
     await mkdir(runtimeDir, { recursive: true });
 
-    const selectedContext = await this.collectSelectedContext(storyDir, input.plan);
+    const selectedContext = await this.collectSelectedContext(
+      storyDir,
+      input.plan,
+      input.book.language ?? "zh",
+    );
     const contextPackage = ContextPackageSchema.parse({
       chapter: input.chapterNumber,
       selectedContext,
@@ -100,9 +107,18 @@ export class ComposerAgent extends BaseAgent {
     };
   }
 
-  private async collectSelectedContext(storyDir: string, plan: PlanChapterOutput): Promise<ContextPackage["selectedContext"]> {
+  private async collectSelectedContext(
+    storyDir: string,
+    plan: PlanChapterOutput,
+    language: "zh" | "en",
+  ): Promise<ContextPackage["selectedContext"]> {
     const entries = await Promise.all([
       this.maybeContextSource(storyDir, "current_focus.md", "Current task focus for this chapter."),
+      this.maybeContextSource(
+        storyDir,
+        "audit_drift.md",
+        "Carry forward audit drift guidance from the previous chapter without polluting hard state facts.",
+      ),
       this.maybeContextSource(
         storyDir,
         "current_state.md",
@@ -121,7 +137,18 @@ export class ComposerAgent extends BaseAgent {
         "Anchor the default planning node for this chapter.",
         plan.intent.outlineNode ? [plan.intent.outlineNode] : [],
       ),
+      this.maybeContextSource(
+        storyDir,
+        "parent_canon.md",
+        "Preserve parent canon constraints for governed continuation or fanfic writing.",
+      ),
+      this.maybeContextSource(
+        storyDir,
+        "fanfic_canon.md",
+        "Preserve extracted fanfic canon constraints for governed writing.",
+      ),
     ]);
+    const trailEntries = await this.buildRecentChapterTrailEntries(storyDir, plan.intent.chapter);
 
     const planningAnchor = plan.intent.conflicts.length > 0 ? undefined : plan.intent.outlineNode;
     const memorySelection = await retrieveMemorySelection({
@@ -131,6 +158,12 @@ export class ComposerAgent extends BaseAgent {
       outlineNode: planningAnchor,
       mustKeep: plan.intent.mustKeep,
     });
+    const hookDebtEntries = await this.buildHookDebtEntries(
+      storyDir,
+      plan,
+      memorySelection.activeHooks,
+      language,
+    );
 
     const summaryEntries = memorySelection.summaries.map((summary) => ({
       source: `story/chapter_summaries.md#${summary.chapter}`,
@@ -147,7 +180,7 @@ export class ComposerAgent extends BaseAgent {
     const hookEntries = memorySelection.hooks.map((hook) => ({
       source: `story/pending_hooks.md#${hook.hookId}`,
       reason: "Carry forward unresolved hooks that match the chapter focus.",
-      excerpt: [hook.type, hook.status, hook.expectedPayoff, hook.notes]
+      excerpt: [hook.type, hook.status, hook.expectedPayoff, hook.payoffTiming, hook.notes]
         .filter(Boolean)
         .join(" | "),
     }));
@@ -159,6 +192,8 @@ export class ComposerAgent extends BaseAgent {
 
     return [
       ...entries.filter((entry): entry is NonNullable<typeof entry> => entry !== null),
+      ...trailEntries,
+      ...hookDebtEntries,
       ...factEntries,
       ...summaryEntries,
       ...volumeSummaryEntries,
@@ -166,6 +201,122 @@ export class ComposerAgent extends BaseAgent {
     ];
   }
 
+  private async buildRecentChapterTrailEntries(
+    storyDir: string,
+    chapterNumber: number,
+  ): Promise<ContextPackage["selectedContext"]> {
+    const content = await this.readFileOrDefault(join(storyDir, "chapter_summaries.md"));
+    if (!content || content === "(文件尚未创建)") {
+      return [];
+    }
+
+    const recentSummaries = parseChapterSummariesMarkdown(content)
+      .filter((summary) => summary.chapter < chapterNumber)
+      .sort((left, right) => right.chapter - left.chapter)
+      .slice(0, 5);
+    if (recentSummaries.length === 0) {
+      return [];
+    }
+
+    const entries: ContextPackage["selectedContext"] = [];
+    const recentTitles = recentSummaries
+      .map((summary) => [summary.chapter, summary.title].filter(Boolean).join(": "))
+      .filter(Boolean)
+      .join(" | ");
+    if (recentTitles) {
+      entries.push({
+        source: "story/chapter_summaries.md#recent_titles",
+        reason: "Keep recent title history visible to avoid repetitive chapter naming.",
+        excerpt: recentTitles,
+      });
+    }
+
+    const moodTrail = recentSummaries
+      .filter((summary) => summary.mood || summary.chapterType)
+      .map((summary) => `${summary.chapter}: ${summary.mood || "(none)"} / ${summary.chapterType || "(none)"}`)
+      .join(" | ");
+    if (moodTrail) {
+      entries.push({
+        source: "story/chapter_summaries.md#recent_mood_type_trail",
+        reason: "Keep recent mood and chapter-type cadence visible before writing the next chapter.",
+        excerpt: moodTrail,
+      });
+    }
+
+    return entries;
+  }
+
+  private async buildHookDebtEntries(
+    storyDir: string,
+    plan: PlanChapterOutput,
+    activeHooks: ReadonlyArray<{
+      readonly hookId: string;
+      readonly startChapter: number;
+      readonly type: string;
+      readonly status: string;
+      readonly lastAdvancedChapter: number;
+      readonly expectedPayoff: string;
+      readonly payoffTiming?: string;
+      readonly notes: string;
+    }>,
+    language: "zh" | "en",
+  ): Promise<ContextPackage["selectedContext"]> {
+    const targetHookIds = [
+      ...new Set([
+        ...plan.intent.hookAgenda.pressureMap.map((entry) => entry.hookId),
+        ...plan.intent.hookAgenda.eligibleResolve,
+        ...plan.intent.hookAgenda.mustAdvance,
+        ...plan.intent.hookAgenda.staleDebt,
+      ]),
+    ];
+    if (targetHookIds.length === 0) {
+      return [];
+    }
+
+    const summaries = parseChapterSummariesMarkdown(
+      await this.readFileOrDefault(join(storyDir, "chapter_summaries.md")),
+    );
+
+    return targetHookIds.flatMap((hookId) => {
+      const hook = activeHooks.find((entry) => entry.hookId === hookId);
+      if (!hook) {
+        return [];
+      }
+
+      const seedSummary = this.findHookSummary(summaries, hook.hookId, hook.startChapter, "seed");
+      const latestSummary = this.findHookSummary(summaries, hook.hookId, hook.lastAdvancedChapter, "latest");
+      const role = this.describeHookAgendaRole(plan, hook.hookId, language);
+      const promise = hook.expectedPayoff || (language === "en" ? "(unspecified)" : "（未写明）");
+      const seedBeat = seedSummary
+        ? this.renderHookDebtBeat(seedSummary)
+        : (hook.notes || promise);
+      const latestBeat = latestSummary && latestSummary !== seedSummary
+        ? this.renderHookDebtBeat(latestSummary)
+        : undefined;
+      const age = Math.max(0, plan.intent.chapter - Math.max(1, hook.startChapter));
+
+      return [{
+        source: `runtime/hook_debt#${hook.hookId}`,
+        reason: language === "en"
+          ? "Narrative debt brief with original seed text for this hook agenda target."
+          : "含原始种子文本的叙事债务简报。",
+        excerpt: language === "en"
+          ? [
+              `${hook.hookId} (${hook.type}, ${role}, open ${age} chapters)`,
+              `reader promise: ${promise}`,
+              `original seed (ch${hook.startChapter}): ${seedBeat}`,
+              latestBeat ? `latest turn (ch${hook.lastAdvancedChapter}): ${latestBeat}` : undefined,
+            ].filter(Boolean).join(" | ")
+          : [
+              `${hook.hookId}（${hook.type}，${role}，已开${age}章）`,
+              `读者承诺：${promise}`,
+              `种于第${hook.startChapter}章：${seedBeat}`,
+              latestBeat ? `推进于第${hook.lastAdvancedChapter}章：${latestBeat}` : undefined,
+            ].filter(Boolean).join(" | "),
+      }];
+    });
+  }
+
   private async maybeContextSource(
     storyDir: string,
     fileName: string,
@@ -210,4 +361,55 @@ export class ComposerAgent extends BaseAgent {
       return "(文件尚未创建)";
     }
   }
+
+  private describeHookAgendaRole(
+    plan: PlanChapterOutput,
+    hookId: string,
+    language: "zh" | "en",
+  ): string {
+    if (plan.intent.hookAgenda.eligibleResolve.includes(hookId)) {
+      return language === "en" ? "payoff-ready debt" : "可兑现旧债";
+    }
+    if (plan.intent.hookAgenda.staleDebt.includes(hookId)) {
+      return language === "en" ? "high-pressure debt" : "高压旧债";
+    }
+    return language === "en" ? "mainline debt" : "主要旧债";
+  }
+
+  private findHookSummary(
+    summaries: ReadonlyArray<ReturnType<typeof parseChapterSummariesMarkdown>[number]>,
+    hookId: string,
+    chapter: number,
+    mode: "seed" | "latest",
+  ) {
+    const directChapterHit = summaries.find((summary) => summary.chapter === chapter);
+    const hookMentions = summaries.filter((summary) => this.summaryMentionsHook(summary, hookId));
+    if (mode === "seed") {
+      return hookMentions.find((summary) => summary.chapter === chapter)
+        ?? hookMentions.at(0)
+        ?? directChapterHit;
+    }
+
+    return [...hookMentions].reverse().find((summary) => summary.chapter === chapter)
+      ?? hookMentions.at(-1)
+      ?? directChapterHit;
+  }
+
+  private summaryMentionsHook(
+    summary: ReturnType<typeof parseChapterSummariesMarkdown>[number],
+    hookId: string,
+  ): boolean {
+    return [
+      summary.title,
+      summary.events,
+      summary.stateChanges,
+      summary.hookActivity,
+    ].some((text) => text.includes(hookId));
+  }
+
+  private renderHookDebtBeat(
+    summary: ReturnType<typeof parseChapterSummariesMarkdown>[number],
+  ): string {
+    return `ch${summary.chapter} ${summary.title} - ${summary.events || summary.hookActivity || summary.stateChanges || "(none)"}`;
+  }
 }

packages/core/src/agents/continuity.ts

@@ -170,16 +170,16 @@ function buildDimensionNote(
         : "检查视角切换是否有过渡、是否与设定视角一致";
     case 24:
       return language === "en"
-        ? "Cross-check subplot_board and chapter_summaries: if any subplot goes unmentioned or unadvanced for more than 5 chapters -> warning. If subplots exist but none move in the last 3 chapters -> warning."
-        : "对照 subplot_board 和 chapter_summaries：如果任何支线超过5章未被提及或推进→warning。如果存在支线但近3章完全没有任何支线推进→warning";
+        ? "Cross-check subplot_board and chapter_summaries: flag any subplot that stays dormant long enough to feel abandoned, or a recent run where every subplot is only restated instead of genuinely moving."
+        : "对照 subplot_board 和 chapter_summaries：标记那些沉寂到接近被遗忘的支线，或近期连续只被重复提及、没有真实推进的支线。";
     case 25:
       return language === "en"
-        ? "Cross-check emotional_arcs and chapter_summaries: if a major character shows no emotional change for 3 straight chapters (no new pressure, release, or turn) -> warning. Distinguish unchanged circumstances from unchanged inner movement."
-        : "对照 emotional_arcs 和 chapter_summaries：如果主要角色连续3章情绪状态无变化（没有新的压力、释放、转变）→warning。注意区分'角色处境未变'和'角色内心未变'";
+        ? "Cross-check emotional_arcs and chapter_summaries: flag any major character whose emotional line holds one pressure shape across a run instead of taking new pressure, release, reversal, or reinterpretation. Distinguish unchanged circumstances from unchanged inner movement."
+        : "对照 emotional_arcs 和 chapter_summaries：标记主要角色在一段时间内始终停留在同一种情绪压力形态、没有新压力、释放、转折或重估的情况。注意区分'处境未变'和'内心未变'。";
     case 26:
       return language === "en"
-        ? "Cross-check chapter_summaries for chapter-type distribution: 3+ consecutive chapters of the same type -> warning. No payoff or climax chapter for 5+ chapters -> warning. Explicitly list the recent type sequence."
-        : "对照 chapter_summaries 的章节类型分布：连续≥3章相同类型（如连续3个事件章/战斗章/布局章）→warning。≥5章没有出现回收章或高潮章→warning。请明确列出最近章节的类型序列";
+        ? "Cross-check chapter_summaries for chapter-type distribution: warn when the recent sequence stays in the same mode long enough to flatten rhythm, or when payoff / release beats disappear for too long. Explicitly list the recent type sequence."
+        : "对照 chapter_summaries 的章节类型分布：当近期章节长时间停留在同一种模式、把节奏压平，或回收/释放/高潮章节缺席过久时给出 warning。请明确列出最近章节的类型序列。";
     case 28:
       return language === "en"
         ? "Check whether spinoff events contradict the mainline canon constraints."
@@ -198,8 +198,8 @@ function buildDimensionNote(
         : "检查番外是否越权回收正传伏笔（warning级别）";
     case 32:
       return language === "en"
-        ? "Check: does the chapter ending provide a hook? Has there been a meaningful payoff within the last 3-5 chapters? Is emotional pressure being suppressed for more than 3 chapters without release? Are reader expectation gaps accumulating or being satisfied?"
-        : "检查：章尾是否有钩子？最近3-5章内是否有爽点落地？是否存在超过3章的情绪压制无释放？读者的情绪缺口是否在积累或被满足？";
+        ? "Check whether the ending renews curiosity, whether promised payoffs are landing on the cadence their hooks imply, whether pressure gets any release, and whether reader expectation gaps are accumulating faster than they are being satisfied."
+        : "检查：章尾是否重新点燃好奇心，已经承诺的回收是否按伏笔自身节奏落地，压力是否得到释放，读者期待缺口是在持续累积还是在被满足。";
     case 33:
       return language === "en"
         ? "Cross-check volume_outline: does this chapter match the planned beat for the current chapter range? Did it skip planned nodes or consume later nodes too early? Does actual pacing match the planned chapter span? If a beat planned for N chapters is consumed in 1-2 chapters -> critical."

packages/core/src/agents/fanfic-canon-importer.ts

@@ -6,6 +6,7 @@ export interface FanficCanonOutput {
   readonly characterProfiles: string;
   readonly keyEvents: string;
   readonly powerSystem: string;
+  readonly writingStyle: string;
   readonly fullDocument: string;
 }
 
@@ -68,10 +69,24 @@ export class FanficCanonImporter extends BaseAgent {
 力量/能力体系（如果适用）。包括等级划分、核心规则、已知限制。
 如果原作没有明确的力量体系，输出"（原作无明确力量体系）"。
 
+=== SECTION: writing_style ===
+原作写作风格特征（供同人写作模仿）：
+
+1. 叙事人称与视角（第一人称/第三人称有限/全知，是否频繁切换）
+2. 句式节奏（长短句交替模式、段落平均长度感受、对话占比）
+3. 场景描写手法（五感偏好、意象选择、环境描写密度）
+4. 对话标记习惯（说/道/笑道 等用法，对话前后是否有动作/表情补充）
+5. 情绪表达方式（直白内心独白 vs 动作外化 vs 环境映射）
+6. 比喻/修辞倾向（常用比喻类型、修辞频率）
+7. 节奏转换（紧张→舒缓的过渡方式、章节结尾习惯）
+
+每项用1-2个原文例句佐证。只提取原文实际存在的特征，不要泛泛描述。
+
 提取原则：
 - 忠实于原作素材，不捏造原作中没有的信息
 - 信息不足时标注"（素材未提及）"而非编造
 - 角色语癖是最重要的字段——同人读者最在意角色"像不像"
+- 写作风格提取必须基于实际文本特征，附原文例句
 ${truncated ? "\n注意：原作素材过长，已截断。请基于已有部分提取。" : ""}`;
 
     const response = await this.chat(
@@ -95,6 +110,7 @@ ${truncated ? "\n注意：原作素材过长，已截断。请基于已有部分
     const characterProfiles = extract("character_profiles");
     const keyEvents = extract("key_events");
     const powerSystem = extract("power_system");
+    const writingStyle = extract("writing_style");
 
     const meta = [
       "---",
@@ -119,9 +135,12 @@ ${truncated ? "\n注意：原作素材过长，已截断。请基于已有部分
       "## 力量体系",
       powerSystem || "（原作无明确力量体系）",
       "",
+      "## 原作写作风格",
+      writingStyle || "（素材不足以提取风格特征）",
+      "",
       meta,
     ].join("\n");
 
-    return { worldRules, characterProfiles, keyEvents, powerSystem, fullDocument };
+    return { worldRules, characterProfiles, keyEvents, powerSystem, writingStyle, fullDocument };
   }
 }

packages/core/src/agents/planner.ts

@@ -5,11 +5,13 @@ import type { BookConfig } from "../models/book.js";
 import { parseBookRules } from "../models/book-rules.js";
 import { ChapterIntentSchema, type ChapterConflict, type ChapterIntent } from "../models/input-governance.js";
 import {
-  buildPlannerHookAgenda,
+  parseChapterSummariesMarkdown,
   renderHookSnapshot,
   renderSummarySnapshot,
   retrieveMemorySelection,
 } from "../utils/memory-retrieval.js";
+import { analyzeChapterCadence } from "../utils/chapter-cadence.js";
+import { buildPlannerHookAgenda } from "../utils/hook-agenda.js";
 
 export interface PlanChapterInput {
   readonly book: BookConfig;
@@ -40,6 +42,7 @@ export class PlannerAgent extends BaseAgent {
       currentFocus: join(storyDir, "current_focus.md"),
       storyBible: join(storyDir, "story_bible.md"),
       volumeOutline: join(storyDir, "volume_outline.md"),
+      chapterSummaries: join(storyDir, "chapter_summaries.md"),
       bookRules: join(storyDir, "book_rules.md"),
       currentState: join(storyDir, "current_state.md"),
     } as const;
@@ -49,6 +52,7 @@ export class PlannerAgent extends BaseAgent {
       currentFocus,
       storyBible,
       volumeOutline,
+      chapterSummaries,
       bookRulesRaw,
       currentState,
     ] = await Promise.all([
@@ -56,17 +60,19 @@ export class PlannerAgent extends BaseAgent {
       this.readFileOrDefault(sourcePaths.currentFocus),
       this.readFileOrDefault(sourcePaths.storyBible),
       this.readFileOrDefault(sourcePaths.volumeOutline),
+      this.readFileOrDefault(sourcePaths.chapterSummaries),
       this.readFileOrDefault(sourcePaths.bookRules),
       this.readFileOrDefault(sourcePaths.currentState),
     ]);
 
     const outlineNode = this.findOutlineNode(volumeOutline, input.chapterNumber);
+    const matchedOutlineAnchor = this.hasMatchedOutlineAnchor(volumeOutline, input.chapterNumber);
     const goal = this.deriveGoal(input.externalContext, currentFocus, authorIntent, outlineNode, input.chapterNumber);
     const parsedRules = parseBookRules(bookRulesRaw);
     const mustKeep = this.collectMustKeep(currentState, storyBible);
     const mustAvoid = this.collectMustAvoid(currentFocus, parsedRules.rules.prohibitions);
     const styleEmphasis = this.collectStyleEmphasis(authorIntent, currentFocus);
-    const conflicts = this.collectConflicts(input.externalContext, outlineNode, volumeOutline);
+    const conflicts = this.collectConflicts(input.externalContext, currentFocus, outlineNode, volumeOutline);
     const planningAnchor = conflicts.length > 0 ? undefined : outlineNode;
     const memorySelection = await retrieveMemorySelection({
       bookDir: input.bookDir,
@@ -78,12 +84,23 @@ export class PlannerAgent extends BaseAgent {
     const hookAgenda = buildPlannerHookAgenda({
       hooks: memorySelection.activeHooks,
       chapterNumber: input.chapterNumber,
+      targetChapters: input.book.targetChapters,
+      language: input.book.language ?? "zh",
+    });
+    const directives = this.buildStructuredDirectives({
+      chapterNumber: input.chapterNumber,
+      language: input.book.language,
+      volumeOutline,
+      outlineNode,
+      matchedOutlineAnchor,
+      chapterSummaries,
     });
 
     const intent = ChapterIntentSchema.parse({
       chapter: input.chapterNumber,
       goal,
       outlineNode,
+      ...directives,
       mustKeep,
       mustAvoid,
       styleEmphasis,
@@ -94,6 +111,7 @@ export class PlannerAgent extends BaseAgent {
     const runtimePath = join(runtimeDir, `chapter-${String(input.chapterNumber).padStart(4, "0")}.intent.md`);
     const intentMarkdown = this.renderIntentMarkdown(
       intent,
+      input.book.language ?? "zh",
       renderHookSnapshot(memorySelection.hooks, input.book.language ?? "zh"),
       renderSummarySnapshot(memorySelection.summaries, input.book.language ?? "zh"),
     );
@@ -105,13 +123,47 @@ export class PlannerAgent extends BaseAgent {
       plannerInputs: [
         ...Object.values(sourcePaths),
         join(storyDir, "pending_hooks.md"),
-        join(storyDir, "chapter_summaries.md"),
         ...(memorySelection.dbPath ? [memorySelection.dbPath] : []),
       ],
       runtimePath,
     };
   }
 
+  private buildStructuredDirectives(input: {
+    readonly chapterNumber: number;
+    readonly language?: string;
+    readonly volumeOutline: string;
+    readonly outlineNode: string | undefined;
+    readonly matchedOutlineAnchor: boolean;
+    readonly chapterSummaries: string;
+  }): Pick<ChapterIntent, "sceneDirective" | "arcDirective" | "moodDirective" | "titleDirective"> {
+    const recentSummaries = parseChapterSummariesMarkdown(input.chapterSummaries)
+      .filter((summary) => summary.chapter < input.chapterNumber)
+      .sort((left, right) => left.chapter - right.chapter)
+      .slice(-4);
+    const cadence = analyzeChapterCadence({
+      language: this.isChineseLanguage(input.language) ? "zh" : "en",
+      rows: recentSummaries.map((summary) => ({
+        chapter: summary.chapter,
+        title: summary.title,
+        mood: summary.mood,
+        chapterType: summary.chapterType,
+      })),
+    });
+
+    return {
+      arcDirective: this.buildArcDirective(
+        input.language,
+        input.volumeOutline,
+        input.outlineNode,
+        input.matchedOutlineAnchor,
+      ),
+      sceneDirective: this.buildSceneDirective(input.language, cadence),
+      moodDirective: this.buildMoodDirective(input.language, cadence),
+      titleDirective: this.buildTitleDirective(input.language, cadence),
+    };
+  }
+
   private deriveGoal(
     externalContext: string | undefined,
     currentFocus: string,
@@ -121,10 +173,12 @@ export class PlannerAgent extends BaseAgent {
   ): string {
     const first = this.extractFirstDirective(externalContext);
     if (first) return first;
-    const focus = this.extractFocusGoal(currentFocus);
-    if (focus) return focus;
+    const localOverride = this.extractLocalOverrideGoal(currentFocus);
+    if (localOverride) return localOverride;
     const outline = this.extractFirstDirective(outlineNode);
     if (outline) return outline;
+    const focus = this.extractFocusGoal(currentFocus);
+    if (focus) return focus;
     const author = this.extractFirstDirective(authorIntent);
     if (author) return author;
     return `Advance chapter ${chapterNumber} with clear narrative focus.`;
@@ -169,19 +223,34 @@ export class PlannerAgent extends BaseAgent {
 
   private collectConflicts(
     externalContext: string | undefined,
+    currentFocus: string,
     outlineNode: string | undefined,
     volumeOutline: string,
   ): ChapterConflict[] {
-    if (!externalContext) return [];
     const outlineText = outlineNode ?? volumeOutline;
     if (!outlineText || outlineText === "(文件尚未创建)") return [];
-    const indicatesOverride = /ignore|skip|defer|instead|不要|别|先别|暂停/i.test(externalContext);
-    if (!indicatesOverride && this.hasKeywordOverlap(externalContext, outlineText)) return [];
+    if (externalContext) {
+      const indicatesOverride = /ignore|skip|defer|instead|不要|别|先别|暂停/i.test(externalContext);
+      if (!indicatesOverride && this.hasKeywordOverlap(externalContext, outlineText)) return [];
+
+      return [
+        {
+          type: "outline_vs_request",
+          resolution: "allow local outline deferral",
+        },
+      ];
+    }
+
+    const localOverride = this.extractLocalOverrideGoal(currentFocus);
+    if (!localOverride || !outlineNode) {
+      return [];
+    }
 
     return [
       {
-        type: "outline_vs_request",
-        resolution: "allow local outline deferral",
+        type: "outline_vs_current_focus",
+        resolution: "allow explicit current focus override",
+        detail: localOverride,
       },
     ];
   }
@@ -224,6 +293,29 @@ export class PlannerAgent extends BaseAgent {
     return directives.join(this.containsChinese(focusSection) ? "；" : "; ");
   }
 
+  private extractLocalOverrideGoal(currentFocus: string): string | undefined {
+    const overrideSection = this.extractSection(currentFocus, [
+      "local override",
+      "explicit override",
+      "chapter override",
+      "local task override",
+      "局部覆盖",
+      "本章覆盖",
+      "临时覆盖",
+      "当前覆盖",
+    ]);
+    if (!overrideSection) {
+      return undefined;
+    }
+
+    const directives = this.extractListItems(overrideSection, 3);
+    if (directives.length > 0) {
+      return directives.join(this.containsChinese(overrideSection) ? "；" : "; ");
+    }
+
+    return this.extractFirstDirective(overrideSection);
+  }
+
   private extractFocusStyleItems(currentFocus: string, limit = 3): string[] {
     const focusSection = this.extractSection(currentFocus, [
       "active focus",
@@ -235,6 +327,63 @@ export class PlannerAgent extends BaseAgent {
     return this.extractListItems(focusSection, limit);
   }
 
+  private buildArcDirective(
+    language: string | undefined,
+    volumeOutline: string,
+    outlineNode: string | undefined,
+    matchedOutlineAnchor: boolean,
+  ): string | undefined {
+    if (matchedOutlineAnchor || !outlineNode || volumeOutline === "(文件尚未创建)") {
+      return undefined;
+    }
+
+    return this.isChineseLanguage(language)
+      ? "不要继续依赖卷纲的 fallback 指令，必须把本章推进到新的弧线节点或地点变化。"
+      : "Do not keep leaning on the outline fallback. Force this chapter toward a fresh arc beat or location change.";
+  }
+
+  private buildSceneDirective(
+    language: string | undefined,
+    cadence: ReturnType<typeof analyzeChapterCadence>,
+  ): string | undefined {
+    if (cadence.scenePressure?.pressure !== "high") {
+      return undefined;
+    }
+    const repeatedType = cadence.scenePressure.repeatedType;
+
+    return this.isChineseLanguage(language)
+      ? `最近章节连续停留在“${repeatedType}”，本章必须更换场景容器、地点或行动方式。`
+      : `Recent chapters are stuck in repeated ${repeatedType} beats. Change the scene container, location, or action pattern this chapter.`;
+  }
+
+  private buildMoodDirective(
+    language: string | undefined,
+    cadence: ReturnType<typeof analyzeChapterCadence>,
+  ): string | undefined {
+    if (cadence.moodPressure?.pressure !== "high") {
+      return undefined;
+    }
+    const moods = cadence.moodPressure.recentMoods;
+
+    return this.isChineseLanguage(language)
+      ? `最近${moods.length}章情绪持续高压（${moods.slice(0, 3).join("、")}），本章必须降调——安排日常/喘息/温情/幽默场景，让读者呼吸。`
+      : `The last ${moods.length} chapters have been relentlessly tense (${moods.slice(0, 3).join(", ")}). This chapter must downshift — write a quieter scene with warmth, humor, or breathing room.`;
+  }
+
+  private buildTitleDirective(
+    language: string | undefined,
+    cadence: ReturnType<typeof analyzeChapterCadence>,
+  ): string | undefined {
+    if (cadence.titlePressure?.pressure !== "high") {
+      return undefined;
+    }
+    const repeatedToken = cadence.titlePressure.repeatedToken;
+
+    return this.isChineseLanguage(language)
+      ? `标题不要再围绕“${repeatedToken}”重复命名，换一个新的意象或动作焦点。`
+      : `Avoid another ${repeatedToken}-centric title. Pick a new image or action focus for this chapter title.`;
+  }
+
   private extractSection(content: string, headings: ReadonlyArray<string>): string | undefined {
     const targets = headings.map((heading) => this.normalizeHeading(heading));
     const lines = content.split("\n");
@@ -299,20 +448,10 @@ export class PlannerAgent extends BaseAgent {
 
   private findOutlineNode(volumeOutline: string, chapterNumber: number): string | undefined {
     const lines = volumeOutline.split("\n").map((line) => line.trim()).filter(Boolean);
-    const chapterPatterns = [
-      new RegExp(`^#+\\s*Chapter\\s*${chapterNumber}\\b`, "i"),
-      new RegExp(`^#+\\s*第\\s*${chapterNumber}\\s*章`),
-    ];
-    const inlinePatterns = [
-      new RegExp(`^(?:[-*]\\s+)?(?:\\*\\*)?Chapter\\s*${chapterNumber}(?:[:：-])?(?:\\*\\*)?\\s*(.+)$`, "i"),
-      new RegExp(`^(?:[-*]\\s+)?(?:\\*\\*)?第\\s*${chapterNumber}\\s*章(?:[:：-])?(?:\\*\\*)?\\s*(.+)$`),
-    ];
 
     for (let index = 0; index < lines.length; index += 1) {
       const line = lines[index]!;
-      const match = inlinePatterns
-        .map((pattern) => line.match(pattern))
-        .find((result): result is RegExpMatchArray => Boolean(result));
+      const match = this.matchExactOutlineLine(line, chapterNumber);
       if (!match) continue;
 
       const inlineContent = this.cleanOutlineContent(match[1]);
@@ -326,12 +465,51 @@ export class PlannerAgent extends BaseAgent {
       }
     }
 
-    const heading = lines.find((line) => chapterPatterns.some((pattern) => pattern.test(line)));
-    if (!heading) return this.extractFirstDirective(volumeOutline);
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index]!;
+      const match = this.matchRangeOutlineLine(line, chapterNumber);
+      if (!match) continue;
+
+      const inlineContent = this.cleanOutlineContent(match[3]);
+      if (inlineContent) {
+        return inlineContent;
+      }
 
-    const headingIndex = lines.indexOf(heading);
-    const nextLine = lines[headingIndex + 1];
-    return nextLine && !nextLine.startsWith("#") ? nextLine : heading.replace(/^#+\s*/, "");
+      const nextContent = this.findNextOutlineContent(lines, index + 1);
+      if (nextContent) {
+        return nextContent;
+      }
+    }
+
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index]!;
+      if (!this.isOutlineAnchorLine(line)) continue;
+
+      const exactMatch = this.matchAnyExactOutlineLine(line);
+      if (exactMatch) {
+        const inlineContent = this.cleanOutlineContent(exactMatch[1]);
+        if (inlineContent) {
+          return inlineContent;
+        }
+      }
+
+      const rangeMatch = this.matchAnyRangeOutlineLine(line);
+      if (rangeMatch) {
+        const inlineContent = this.cleanOutlineContent(rangeMatch[3]);
+        if (inlineContent) {
+          return inlineContent;
+        }
+      }
+
+      const nextContent = this.findNextOutlineContent(lines, index + 1);
+      if (nextContent) {
+        return nextContent;
+      }
+
+      break;
+    }
+
+    return this.extractFirstDirective(volumeOutline);
   }
 
   private cleanOutlineContent(content?: string): string | undefined {
@@ -344,17 +522,18 @@ export class PlannerAgent extends BaseAgent {
   private findNextOutlineContent(lines: ReadonlyArray<string>, startIndex: number): string | undefined {
     for (let index = startIndex; index < lines.length; index += 1) {
       const line = lines[index]!;
-      if (!line || line.startsWith("#")) {
+      if (!line) {
         continue;
       }
 
-      if (
-        /^(?:[-*]\s+)?(?:\*\*)?Chapter\s*\d+(?:[:：-])?(?:\*\*)?\s*$/i.test(line)
-        || /^(?:[-*]\s+)?(?:\*\*)?第\s*\d+\s*章(?:[:：-])?(?:\*\*)?\s*$/.test(line)
-      ) {
+      if (this.isOutlineAnchorLine(line)) {
         return undefined;
       }
 
+      if (line.startsWith("#")) {
+        continue;
+      }
+
       const cleaned = this.cleanOutlineContent(line);
       if (cleaned) {
         return cleaned;
@@ -364,6 +543,71 @@ export class PlannerAgent extends BaseAgent {
     return undefined;
   }
 
+  private hasMatchedOutlineAnchor(volumeOutline: string, chapterNumber: number): boolean {
+    const lines = volumeOutline.split("\n").map((line) => line.trim()).filter(Boolean);
+    return lines.some((line) =>
+      this.matchExactOutlineLine(line, chapterNumber) !== undefined
+      || this.matchRangeOutlineLine(line, chapterNumber) !== undefined,
+    );
+  }
+
+  private matchExactOutlineLine(line: string, chapterNumber: number): RegExpMatchArray | undefined {
+    const patterns = [
+      new RegExp(`^(?:#+\\s*)?(?:[-*]\\s+)?(?:\\*\\*)?Chapter\\s*${chapterNumber}(?!\\d|\\s*[-~–—]\\s*\\d)(?:[:：-])?(?:\\*\\*)?\\s*(.*)$`, "i"),
+      new RegExp(`^(?:#+\\s*)?(?:[-*]\\s+)?(?:\\*\\*)?第\\s*${chapterNumber}\\s*章(?!\\d|\\s*[-~–—]\\s*\\d)(?:[:：-])?(?:\\*\\*)?\\s*(.*)$`),
+    ];
+
+    return patterns
+      .map((pattern) => line.match(pattern))
+      .find((result): result is RegExpMatchArray => Boolean(result));
+  }
+
+  private matchAnyExactOutlineLine(line: string): RegExpMatchArray | undefined {
+    const patterns = [
+      /^(?:#+\s*)?(?:[-*]\s+)?(?:\*\*)?Chapter\s*\d+(?!\s*[-~–—]\s*\d)(?:[:：-])?(?:\*\*)?\s*(.*)$/i,
+      /^(?:#+\s*)?(?:[-*]\s+)?(?:\*\*)?第\s*\d+\s*章(?!\s*[-~–—]\s*\d)(?:[:：-])?(?:\*\*)?\s*(.*)$/i,
+    ];
+
+    return patterns
+      .map((pattern) => line.match(pattern))
+      .find((result): result is RegExpMatchArray => Boolean(result));
+  }
+
+  private matchRangeOutlineLine(line: string, chapterNumber: number): RegExpMatchArray | undefined {
+    const match = this.matchAnyRangeOutlineLine(line);
+    if (!match) return undefined;
+    if (this.isChapterWithinRange(match[1], match[2], chapterNumber)) {
+      return match;
+    }
+
+    return undefined;
+  }
+
+  private matchAnyRangeOutlineLine(line: string): RegExpMatchArray | undefined {
+    const patterns = [
+      /^(?:#+\s*)?(?:[-*]\s+)?(?:\*\*)?Chapter\s*(\d+)\s*[-~–—]\s*(\d+)\b(?:[:：-])?(?:\*\*)?\s*(.*)$/i,
+      /^(?:#+\s*)?(?:[-*]\s+)?(?:\*\*)?第\s*(\d+)\s*[-~–—]\s*(\d+)\s*章(?:[:：-])?(?:\*\*)?\s*(.*)$/i,
+    ];
+
+    return patterns
+      .map((pattern) => line.match(pattern))
+      .find((result): result is RegExpMatchArray => Boolean(result));
+  }
+
+  private isOutlineAnchorLine(line: string): boolean {
+    return this.matchAnyExactOutlineLine(line) !== undefined
+      || this.matchAnyRangeOutlineLine(line) !== undefined;
+  }
+
+  private isChapterWithinRange(startText: string | undefined, endText: string | undefined, chapterNumber: number): boolean {
+    const start = Number.parseInt(startText ?? "", 10);
+    const end = Number.parseInt(endText ?? "", 10);
+    if (!Number.isFinite(start) || !Number.isFinite(end)) return false;
+    const lower = Math.min(start, end);
+    const upper = Math.max(start, end);
+    return chapterNumber >= lower && chapterNumber <= upper;
+  }
+
   private hasKeywordOverlap(left: string, right: string): boolean {
     const keywords = this.extractKeywords(left);
     if (keywords.length === 0) return false;
@@ -379,6 +623,7 @@ export class PlannerAgent extends BaseAgent {
 
   private renderIntentMarkdown(
     intent: ChapterIntent,
+    language: "zh" | "en",
     pendingHooks: string,
     chapterSummaries: string,
   ): string {
@@ -397,6 +642,12 @@ export class PlannerAgent extends BaseAgent {
     const styleEmphasis = intent.styleEmphasis.length > 0
       ? intent.styleEmphasis.map((item) => `- ${item}`).join("\n")
       : "- none";
+    const directives = [
+      intent.arcDirective ? `- arc: ${intent.arcDirective}` : undefined,
+      intent.sceneDirective ? `- scene: ${intent.sceneDirective}` : undefined,
+      intent.moodDirective ? `- mood: ${intent.moodDirective}` : undefined,
+      intent.titleDirective ? `- title: ${intent.titleDirective}` : undefined,
+    ].filter(Boolean).join("\n") || "- none";
     const hookAgenda = [
       "### Must Advance",
       intent.hookAgenda.mustAdvance.length > 0
@@ -437,6 +688,9 @@ export class PlannerAgent extends BaseAgent {
       "## Style Emphasis",
       styleEmphasis,
       "",
+      "## Structured Directives",
+      directives,
+      "",
       "## Hook Agenda",
       hookAgenda,
       "",
@@ -456,6 +710,10 @@ export class PlannerAgent extends BaseAgent {
     return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
   }
 
+  private isChineseLanguage(language: string | undefined): boolean {
+    return (language ?? "zh").toLowerCase().startsWith("zh");
+  }
+
   private async readFileOrDefault(path: string): Promise<string> {
     try {
       return await readFile(path, "utf-8");

packages/core/src/agents/post-write-validator.ts

@@ -5,6 +5,7 @@
  * Catches violations that prompt-only rules cannot guarantee.
  */
 
+import { analyzeChapterCadence } from "../utils/chapter-cadence.js";
 import type { BookRules } from "../models/book-rules.js";
 import type { GenreProfile } from "../models/genre-profile.js";
 
@@ -561,6 +562,21 @@ const ENGLISH_NAME_STOP_WORDS = new Set([
   "They",
 ]);
 
+const CHINESE_TITLE_STOP_WORDS = new Set([
+  "这次",
+  "正文",
+  "标题",
+  "重复",
+  "不同",
+  "完全",
+  "只是",
+  "碰巧",
+  "没有",
+  "回头",
+]);
+
+const CHINESE_TITLE_STOP_CHARS = new Set(["的", "了", "着", "一", "只", "从", "在", "和", "与", "把", "被", "有", "没", "里", "又", "才"]);
+
 /**
  * Detect duplicate or near-duplicate chapter titles.
  * Compares the new title against existing chapter titles from index.
@@ -609,6 +625,9 @@ export function resolveDuplicateTitle(
   newTitle: string,
   existingTitles: ReadonlyArray<string>,
   language: "zh" | "en" = "zh",
+  options?: {
+    readonly content?: string;
+  },
 ): {
   readonly title: string;
   readonly issues: ReadonlyArray<PostWriteViolation>;
@@ -618,21 +637,200 @@ export function resolveDuplicateTitle(
     return { title: newTitle, issues: [] };
   }
 
-  const issues = detectDuplicateTitle(trimmed, existingTitles);
-  if (issues.length === 0) {
+  const duplicateIssues = detectDuplicateTitle(trimmed, existingTitles);
+  if (duplicateIssues.length > 0) {
+    const regenerated = regenerateDuplicateTitle(trimmed, existingTitles, language, options?.content);
+    if (regenerated && detectDuplicateTitle(regenerated, existingTitles).length === 0) {
+      return { title: regenerated, issues: duplicateIssues };
+    }
+
+    let counter = 2;
+    while (counter < 100) {
+      const candidate = language === "en"
+        ? `${trimmed} (${counter})`
+        : `${trimmed}（${counter}）`;
+      if (detectDuplicateTitle(candidate, existingTitles).length === 0) {
+        return { title: candidate, issues: duplicateIssues };
+      }
+      counter++;
+    }
+
+    return { title: trimmed, issues: duplicateIssues };
+  }
+
+  const collapseIssues = detectTitleCollapse(trimmed, existingTitles, language);
+  if (collapseIssues.length === 0) {
     return { title: trimmed, issues: [] };
   }
 
-  let counter = 2;
-  while (counter < 100) {
-    const candidate = language === "en"
-      ? `${trimmed} (${counter})`
-      : `${trimmed}（${counter}）`;
-    if (detectDuplicateTitle(candidate, existingTitles).length === 0) {
-      return { title: candidate, issues };
+  const regenerated = regenerateCollapsedTitle(trimmed, existingTitles, language, options?.content);
+  if (
+    regenerated
+    && detectDuplicateTitle(regenerated, existingTitles).length === 0
+    && detectTitleCollapse(regenerated, existingTitles, language).length === 0
+  ) {
+    return { title: regenerated, issues: collapseIssues };
+  }
+
+  return { title: trimmed, issues: collapseIssues };
+}
+
+function detectTitleCollapse(
+  newTitle: string,
+  existingTitles: ReadonlyArray<string>,
+  language: "zh" | "en",
+): ReadonlyArray<PostWriteViolation> {
+  const recentTitles = existingTitles
+    .map((title) => title.trim())
+    .filter(Boolean)
+    .slice(-3);
+  if (recentTitles.length < 3) {
+    return [];
+  }
+
+  const cadence = analyzeChapterCadence({
+    language,
+    rows: [...recentTitles, newTitle].map((title, index) => ({
+      chapter: index + 1,
+      title,
+      mood: "",
+      chapterType: "",
+    })),
+  });
+  const titlePressure = cadence.titlePressure;
+  if (!titlePressure || titlePressure.pressure !== "high") {
+    return [];
+  }
+  if (!newTitle.includes(titlePressure.repeatedToken)) {
+    return [];
+  }
+
+  return [
+    language === "en"
+      ? {
+          rule: "title-collapse",
+          severity: "warning",
+          description: `Chapter title "${newTitle}" keeps leaning on the recent "${titlePressure.repeatedToken}" title shell.`,
+          suggestion: "Rename the chapter around a new image, action, consequence, or character focus.",
+        }
+      : {
+          rule: "title-collapse",
+          severity: "warning",
+          description: `章节标题"${newTitle}"仍在沿用近期围绕“${titlePressure.repeatedToken}”的命名壳。`,
+          suggestion: "换一个新的意象、动作、后果或人物焦点来命名。",
+        },
+  ];
+}
+
+function regenerateDuplicateTitle(
+  baseTitle: string,
+  existingTitles: ReadonlyArray<string>,
+  language: "zh" | "en",
+  content?: string,
+): string | undefined {
+  if (!content || !content.trim()) {
+    return undefined;
+  }
+
+  const qualifier = language === "en"
+    ? extractEnglishTitleQualifier(baseTitle, existingTitles, content)
+    : extractChineseTitleQualifier(baseTitle, existingTitles, content);
+  if (!qualifier) {
+    return undefined;
+  }
+
+  return language === "en"
+    ? `${baseTitle}: ${qualifier}`
+    : `${baseTitle}：${qualifier}`;
+}
+
+function regenerateCollapsedTitle(
+  baseTitle: string,
+  existingTitles: ReadonlyArray<string>,
+  language: "zh" | "en",
+  content?: string,
+): string | undefined {
+  if (!content || !content.trim()) {
+    return undefined;
+  }
+
+  const fresh = language === "en"
+    ? extractEnglishTitleQualifier(baseTitle, existingTitles, content)
+    : extractChineseTitleQualifier(baseTitle, existingTitles, content);
+  if (!fresh) {
+    return undefined;
+  }
+
+  return fresh === baseTitle ? undefined : fresh;
+}
+
+function extractEnglishTitleQualifier(
+  baseTitle: string,
+  existingTitles: ReadonlyArray<string>,
+  content: string,
+): string | undefined {
+  const blocked = new Set(extractEnglishTitleTerms([baseTitle, ...existingTitles].join(" ")));
+  const words = (content.match(/[A-Za-z]{4,}/g) ?? [])
+    .map((word) => word.toLowerCase())
+    .filter((word) => !ENGLISH_NAME_STOP_WORDS.has(capitalize(word)))
+    .filter((word) => !blocked.has(word));
+  const first = words[0];
+  if (!first) {
+    return undefined;
+  }
+
+  const second = words.find((word) => word !== first && !blocked.has(word));
+  return second
+    ? `${capitalize(first)} ${capitalize(second)}`
+    : capitalize(first);
+}
+
+function extractChineseTitleQualifier(
+  baseTitle: string,
+  existingTitles: ReadonlyArray<string>,
+  content: string,
+): string | undefined {
+  const blocked = new Set(extractChineseTitleTerms([baseTitle, ...existingTitles].join("")));
+  const segments = content.match(/[\u4e00-\u9fff]+/g) ?? [];
+
+  for (const segment of segments) {
+    for (let start = 0; start < segment.length; start += 1) {
+      for (let size = 2; size <= 4; size += 1) {
+        const candidate = segment.slice(start, start + size).trim();
+        if (candidate.length < 2) continue;
+        if (CHINESE_TITLE_STOP_WORDS.has(candidate)) continue;
+        if ([...candidate].some((char) => CHINESE_TITLE_STOP_CHARS.has(char))) continue;
+        if (blocked.has(candidate)) continue;
+        return candidate;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function extractEnglishTitleTerms(text: string): string[] {
+  return [...new Set((text.match(/[A-Za-z]{4,}/g) ?? []).map((word) => word.toLowerCase()))];
+}
+
+function extractChineseTitleTerms(text: string): string[] {
+  const terms = new Set<string>();
+  const segments = text.match(/[\u4e00-\u9fff]+/g) ?? [];
+
+  for (const segment of segments) {
+    for (let start = 0; start < segment.length; start += 1) {
+      for (let size = 2; size <= 4; size += 1) {
+        const candidate = segment.slice(start, start + size).trim();
+        if (candidate.length < 2) continue;
+        if ([...candidate].some((char) => CHINESE_TITLE_STOP_CHARS.has(char))) continue;
+        terms.add(candidate);
+      }
     }
-    counter++;
   }
 
-  return { title: trimmed, issues };
+  return [...terms];
+}
+
+function capitalize(word: string): string {
+  return word.length === 0 ? word : `${word[0]!.toUpperCase()}${word.slice(1)}`;
 }

packages/core/src/agents/settler-prompts.ts

@@ -22,8 +22,9 @@ export function buildSettlerSystemPrompt(
 - 提及伏笔：已有伏笔在本章被提到，但没有新增信息、没有改变读者或角色对该问题的理解 → 放入 mention 数组，不要更新最近推进
 - 推进伏笔：已有伏笔在本章出现了新的事实、证据、关系变化、风险升级或范围收缩 → **必须**更新"最近推进"列为当前章节号，更新状态和备注
 - 回收伏笔：伏笔在本章被明确揭示、解决、或不再成立 → 状态改为"已回收"，备注回收方式
-- 延后伏笔：超过5章未推进 → 标注"延后"，备注原因
+- 延后伏笔：只有当正文明确显示该线被主动搁置、转入后台、或被剧情压后时，才标注"延后"；不要因为“已经过了几章”就机械延后
 - brand-new unresolved thread：不要直接发明新的 hookId。把候选放进 newHookCandidates，由系统决定它是映射到旧 hook、变成真正新 hook，还是被拒绝为重述
+- payoffTiming 使用语义节奏，不用硬写章节号：只允许 immediate / near-term / mid-arc / slow-burn / endgame
 - **铁律**：不要把“再次提到”“换个说法重述”“抽象复盘”当成推进。只有状态真的变了，才更新最近推进。只是出现过的旧 hook，放进 mention 数组。`;
 
   const fullCastBlock = bookRules?.enableFullCastTracking
@@ -114,6 +115,7 @@ function buildSettlerOutputFormat(gp: GenreProfile): string {
         "status": "progressing",
         "lastAdvancedChapter": 12,
         "expectedPayoff": "揭开师债真相",
+        "payoffTiming": "slow-burn",
         "notes": "本章为何推进/延后/回收"
       }
     ],
@@ -125,6 +127,7 @@ function buildSettlerOutputFormat(gp: GenreProfile): string {
     {
       "type": "mystery",
       "expectedPayoff": "新伏笔未来要回收到哪里",
+      "payoffTiming": "near-term",
       "notes": "本章为什么会形成新的未解问题"
     }
   ],
@@ -171,6 +174,7 @@ export function buildSettlerUserPrompt(params: {
   readonly observations?: string;
   readonly selectedEvidenceBlock?: string;
   readonly governedControlBlock?: string;
+  readonly validationFeedback?: string;
 }): string {
   const ledgerBlock = params.ledger
     ? `\n## 当前资源账本\n${params.ledger}\n`
@@ -202,9 +206,13 @@ export function buildSettlerUserPrompt(params: {
   const outlineBlock = controlBlock.length === 0
     ? `\n## 卷纲\n${params.volumeOutline}\n`
     : "";
+  const validationFeedbackBlock = params.validationFeedback
+    ? `\n## 状态校验反馈\n${params.validationFeedback}\n\n请严格纠正这些矛盾，只修正 truth files，不要改写正文，不要引入正文中不存在的新事实。\n`
+    : "";
 
   return `请分析第${params.chapterNumber}章「${params.title}」的正文，更新所有追踪文件。
 ${observationsBlock}
+${validationFeedbackBlock}
 ## 本章正文
 
 ${params.content}

packages/core/src/agents/writer-prompts.ts

@@ -105,6 +105,9 @@ function buildGovernedInputContract(language: "zh" | "en", governed: boolean): s
 - When the runtime rule stack records an active L4 -> L3 override, follow the current task over local planning.
 - Keep hard guardrails compact: canon, continuity facts, and explicit prohibitions still win.
 - If an English Variance Brief is provided, obey it: avoid the listed phrase/opening/ending patterns and satisfy the scene obligation.
+- If Hook Debt Briefs are provided, they contain the ORIGINAL SEED TEXT from the chapter where each hook was planted. Use this text to write a continuation or payoff that feels connected to what the reader already saw — not a vague mention, but a scene that builds on the specific promise.
+- When the explicit hook agenda names an eligible resolve target, land a concrete payoff beat that answers the reader's original question from the seed chapter.
+- When stale debt is present, do not open sibling hooks casually; clear pressure from old promises before minting fresh debt.
 - In multi-character scenes, include at least one resistance-bearing exchange instead of reducing the beat to summary or explanation.`;
   }
 
@@ -115,6 +118,9 @@ function buildGovernedInputContract(language: "zh" | "en", governed: boolean): s
 - 当 runtime rule stack 明确记录了 L4 -> L3 的 active override 时，优先执行当前任务意图，再局部调整规划层。
 - 真正不能突破的只有硬护栏：世界设定、连续性事实、显式禁令。
 - 如果提供了 English Variance Brief，必须主动避开其中列出的高频短语、重复开头和重复结尾模式，并完成 scene obligation。
+- 如果提供了 Hook Debt 简报，里面包含每个伏笔种下时的**原始文本片段**。用这些原文来写延续或兑现场景——不是模糊地提一嘴，而是接着读者已经看到的具体承诺来写。
+- 如果显式 hook agenda 里出现了可回收目标，本章必须写出具体兑现片段，回答种子章节中读者的原始疑问。
+- 如果存在 stale debt，先消化旧承诺的压力，再决定是否开新坑；同类 sibling hook 不得随手再开。
 - 多角色场景里，至少给出一轮带阻力的直接交锋，不要把人物关系写成纯解释或纯总结。`;
 }
 
@@ -525,7 +531,7 @@ function buildCreativeOutputFormat(book: BookConfig, gp: GenreProfile, lengthSpe
 | 大纲锚定 | 当前卷名/阶段 + 本章应推进的具体节点 | 严禁跳过节点或提前消耗后续剧情 |
 | 上下文范围 | 第X章至第Y章 / 状态卡 / 设定文件 | |
 | 当前锚点 | 地点 / 对手 / 收益目标 | 锚点必须具体 |
-${resourceRow}| 待回收伏笔 | Hook-A / Hook-B | 与伏笔池一致 |
+${resourceRow}| 待回收伏笔 | 用真实 hook_id 填写（无则写 none） | 与伏笔池一致 |
 | 本章冲突 | 一句话概括 | |
 | 章节类型 | ${gp.chapterTypes.join("/")} | |
 | 风险扫描 | OOC/信息越界/设定冲突${gp.powerScaling ? "/战力崩坏" : ""}/节奏/词汇疲劳 | |`;
@@ -535,7 +541,7 @@ ${resourceRow}| 待回收伏笔 | Hook-A / Hook-B | 与伏笔池一致 |
 ${preWriteTable}
 
 === CHAPTER_TITLE ===
-(章节标题，不含"第X章"。标题必须与已有章节标题不同，不要重复使用相同或相似的标题)
+(章节标题，不含"第X章"。标题必须与已有章节标题不同，不要重复使用相同或相似的标题；若提供了 recent title history 或高频标题词，必须主动避开重复词根和高频意象)
 
 === CHAPTER_CONTENT ===
 (正文内容，目标${lengthSpec.target}字，允许区间${lengthSpec.softMin}-${lengthSpec.softMax}字)
@@ -560,7 +566,7 @@ function buildOutputFormat(book: BookConfig, gp: GenreProfile, lengthSpec: Lengt
 | 大纲锚定 | 当前卷名/阶段 + 本章应推进的具体节点 | 严禁跳过节点或提前消耗后续剧情 |
 | 上下文范围 | 第X章至第Y章 / 状态卡 / 设定文件 | |
 | 当前锚点 | 地点 / 对手 / 收益目标 | 锚点必须具体 |
-${resourceRow}| 待回收伏笔 | Hook-A / Hook-B | 与伏笔池一致 |
+${resourceRow}| 待回收伏笔 | 用真实 hook_id 填写（无则写 none） | 与伏笔池一致 |
 | 本章冲突 | 一句话概括 | |
 | 章节类型 | ${gp.chapterTypes.join("/")} | |
 | 风险扫描 | OOC/信息越界/设定冲突${gp.powerScaling ? "/战力崩坏" : ""}/节奏/词汇疲劳 | |`;
@@ -588,7 +594,7 @@ ${resourceRow}| 待回收伏笔 | Hook-A / Hook-B | 与伏笔池一致 |
 ${preWriteTable}
 
 === CHAPTER_TITLE ===
-(章节标题，不含"第X章"。标题必须与已有章节标题不同，不要重复使用相同或相似的标题)
+(章节标题，不含"第X章"。标题必须与已有章节标题不同，不要重复使用相同或相似的标题；若提供了 recent title history 或高频标题词，必须主动避开重复词根和高频意象)
 
 === CHAPTER_CONTENT ===
 (正文内容，目标${lengthSpec.target}字，允许区间${lengthSpec.softMin}-${lengthSpec.softMax}字)

packages/core/src/agents/writer.ts

@@ -18,7 +18,7 @@ import { analyzeAITells } from "./ai-tells.js";
 import type { ChapterTrace, ContextPackage, RuleStack } from "../models/input-governance.js";
 import type { LengthSpec } from "../models/length-governance.js";
 import type { RuntimeStateDelta } from "../models/runtime-state.js";
-import { buildLengthSpec } from "../utils/length-metrics.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 {
@@ -51,6 +51,18 @@ export interface WriteChapterInput {
   readonly temperatureOverride?: number;
 }
 
+export interface SettleChapterStateInput {
+  readonly book: BookConfig;
+  readonly bookDir: string;
+  readonly chapterNumber: number;
+  readonly title: string;
+  readonly content: string;
+  readonly chapterIntent?: string;
+  readonly contextPackage?: ContextPackage;
+  readonly ruleStack?: RuleStack;
+  readonly validationFeedback?: string;
+}
+
 export interface TokenUsage {
   readonly promptTokens: number;
   readonly completionTokens: number;
@@ -147,7 +159,7 @@ export class WriterAgent extends BaseAgent {
     const targetWords = input.lengthSpec?.target ?? input.wordCountOverride ?? book.chapterWordCount;
     const resolvedLengthSpec = input.lengthSpec ?? buildLengthSpec(targetWords, resolvedLanguage);
     const governedMemoryBlocks = input.contextPackage
-      ? buildGovernedMemoryEvidenceBlocks(input.contextPackage)
+      ? buildGovernedMemoryEvidenceBlocks(input.contextPackage, resolvedLanguage)
       : undefined;
     const englishVarianceBrief = resolvedLanguage === "en"
       ? await buildEnglishVarianceBrief({
@@ -183,6 +195,7 @@ export class WriterAgent extends BaseAgent {
           lengthSpec: resolvedLengthSpec,
           language: book.language ?? genreProfile.language,
           varianceBrief: englishVarianceBrief?.text,
+          selectedEvidenceBlock: this.joinGovernedEvidenceBlocks(governedMemoryBlocks),
         })
       : (() => {
           // Smart context filtering: inject only relevant parts of truth files
@@ -289,17 +302,12 @@ export class WriterAgent extends BaseAgent {
       characterMatrix: filteredMatrixForSettlement,
       volumeOutline,
       selectedEvidenceBlock: governedMemoryBlocks
-        ? [
-            governedMemoryBlocks.hooksBlock,
-            governedMemoryBlocks.summariesBlock,
-            governedMemoryBlocks.volumeSummariesBlock,
-          ]
-          .filter(Boolean)
-          .join("\n")
+        ? this.joinGovernedEvidenceBlocks(governedMemoryBlocks)
         : undefined,
       chapterIntent: input.chapterIntent,
       contextPackage: input.contextPackage,
       ruleStack: input.ruleStack,
+      validationFeedback: undefined,
       originalHooks: hooks,
       originalSubplots: subplotBoard,
       originalEmotionalArcs: emotionalArcs,
@@ -320,6 +328,7 @@ export class WriterAgent extends BaseAgent {
       ? analyzeHookHealth({
           language: resolvedLanguage,
           chapterNumber,
+          targetChapters: book.targetChapters,
           hooks: (runtimeStateArtifacts?.snapshot ?? settlement.runtimeStateSnapshot)!.hooks.hooks,
           delta: resolvedRuntimeStateDelta,
           existingHookIds: [...priorHookIds],
@@ -398,6 +407,98 @@ export class WriterAgent extends BaseAgent {
     };
   }
 
+  async settleChapterState(input: SettleChapterStateInput): Promise<WriteChapterOutput> {
+    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,
+    );
+
+    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,
+    };
+  }
+
   private async settle(params: {
     readonly book: BookConfig;
     readonly genreProfile: GenreProfile;
@@ -417,6 +518,7 @@ export class WriterAgent extends BaseAgent {
     readonly chapterIntent?: string;
     readonly contextPackage?: ContextPackage;
     readonly ruleStack?: RuleStack;
+    readonly validationFeedback?: string;
     readonly originalHooks: string;
     readonly originalSubplots: string;
     readonly originalEmotionalArcs: string;
@@ -478,6 +580,7 @@ export class WriterAgent extends BaseAgent {
       observations,
       selectedEvidenceBlock: params.selectedEvidenceBlock,
       governedControlBlock,
+      validationFeedback: params.validationFeedback,
     });
 
     // Settler outputs all truth files — scale with content size
@@ -709,6 +812,7 @@ ${lengthRequirementBlock}
     readonly lengthSpec: LengthSpec;
     readonly language?: "zh" | "en";
     readonly varianceBrief?: string;
+    readonly selectedEvidenceBlock?: string;
   }): string {
     const contextSections = params.contextPackage.selectedContext
       .map((entry) => [
@@ -735,6 +839,15 @@ ${lengthRequirementBlock}
     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}.
@@ -744,6 +857,8 @@ ${params.chapterIntent}
 
 ## Selected Context
 ${contextSections || "(none)"}
+${selectedEvidenceBlock}
+${hookAgendaBlock}
 
 ## Rule Stack
 - Hard: ${params.ruleStack.sections.hard.join(", ") || "(none)"}
@@ -769,6 +884,8 @@ ${params.chapterIntent}
 
 ## 已选上下文
 ${contextSections || "(无)"}
+${selectedEvidenceBlock}
+${hookAgendaBlock}
 
 ## 规则栈
 - 硬护栏：${params.ruleStack.sections.hard.join("、") || "(无)"}
@@ -787,6 +904,49 @@ ${lengthRequirementBlock}
 - 只需输出 PRE_WRITE_CHECK、CHAPTER_TITLE、CHAPTER_CONTENT 三个区块`;
   }
 
+  private joinGovernedEvidenceBlocks(blocks: ReturnType<typeof buildGovernedMemoryEvidenceBlocks> | undefined): string | undefined {
+    if (!blocks) {
+      return undefined;
+    }
+
+    const joined = [
+      blocks.titleHistoryBlock,
+      blocks.moodTrailBlock,
+      blocks.canonBlock,
+      blocks.hookDebtBlock,
+      blocks.hooksBlock,
+      blocks.summariesBlock,
+      blocks.volumeSummariesBlock,
+    ]
+      .filter((block): block is string => Boolean(block))
+      .join("\n");
+
+    return joined || undefined;
+  }
+
+  private extractMarkdownSection(content: string, heading: string): string | undefined {
+    const lines = content.split("\n");
+    let buffer: string[] | null = 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;
+  }
+
   private buildSettlerGovernedControlBlock(
     chapterIntent: string,
     contextPackage: ContextPackage,

packages/core/src/index.ts

@@ -38,6 +38,9 @@ export {
 } from "./models/runtime-state.js";
 export {
   type ChapterConflict,
+  type HookMovement,
+  type HookPressureLevel,
+  type HookPressure,
   type ChapterIntent,
   type ContextSource,
   type ContextPackage,
@@ -49,6 +52,9 @@ export {
   type RuleStack,
   type ChapterTrace,
   ChapterConflictSchema,
+  HookMovementSchema,
+  HookPressureLevelSchema,
+  HookPressureSchema,
   ChapterIntentSchema,
   ContextSourceSchema,
   ContextPackageSchema,

packages/core/src/llm/provider.ts

@@ -135,15 +135,38 @@ export function createLLMClient(config: LLMConfig): LLMClient {
     };
   }
   // openai or custom — both use OpenAI SDK
+  const extraHeaders = config.headers ?? parseEnvHeaders();
   return {
     provider: "openai",
     apiFormat,
     stream,
-    _openai: new OpenAI({ apiKey: config.apiKey, baseURL: config.baseUrl }),
+    _openai: new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl,
+      ...(extraHeaders ? { defaultHeaders: extraHeaders } : {}),
+    }),
     defaults,
   };
 }
 
+function parseEnvHeaders(): Record<string, string> | undefined {
+  const raw = process.env.INKOS_LLM_HEADERS;
+  if (!raw) return undefined;
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as Record<string, string>;
+    }
+  } catch {
+    // not JSON — treat as single "Key: Value" pair
+    const idx = raw.indexOf(":");
+    if (idx > 0) {
+      return { [raw.slice(0, idx).trim()]: raw.slice(idx + 1).trim() };
+    }
+  }
+  return undefined;
+}
+
 // === Partial Response (stream interrupted but usable content received) ===
 
 export class PartialResponseError extends Error {

packages/core/src/models/chapter.ts

@@ -8,6 +8,7 @@ export const ChapterStatusSchema = z.enum([
   "auditing",
   "audit-passed",
   "audit-failed",
+  "state-degraded",
   "revising",
   "ready-for-review",
   "approved",

packages/core/src/models/input-governance.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { HookPayoffTimingSchema } from "./runtime-state.js";
 
 export const ChapterConflictSchema = z.object({
   type: z.string().min(1),
@@ -8,7 +9,46 @@ export const ChapterConflictSchema = z.object({
 
 export type ChapterConflict = z.infer<typeof ChapterConflictSchema>;
 
+export const HookPressurePhaseSchema = z.enum(["opening", "middle", "late"]);
+export type HookPressurePhase = z.infer<typeof HookPressurePhaseSchema>;
+
+export const HookMovementSchema = z.enum([
+  "quiet-hold",
+  "refresh",
+  "advance",
+  "partial-payoff",
+  "full-payoff",
+]);
+export type HookMovement = z.infer<typeof HookMovementSchema>;
+
+export const HookPressureLevelSchema = z.enum(["low", "medium", "high", "critical"]);
+export type HookPressureLevel = z.infer<typeof HookPressureLevelSchema>;
+
+export const HookPressureReasonSchema = z.enum([
+  "fresh-promise",
+  "building-debt",
+  "stale-promise",
+  "ripe-payoff",
+  "overdue-payoff",
+  "long-arc-hold",
+]);
+export type HookPressureReason = z.infer<typeof HookPressureReasonSchema>;
+
+export const HookPressureSchema = z.object({
+  hookId: z.string().min(1),
+  type: z.string().min(1),
+  movement: HookMovementSchema,
+  pressure: HookPressureLevelSchema,
+  payoffTiming: HookPayoffTimingSchema.optional(),
+  phase: HookPressurePhaseSchema,
+  reason: HookPressureReasonSchema,
+  blockSiblingHooks: z.boolean().default(false),
+});
+
+export type HookPressure = z.infer<typeof HookPressureSchema>;
+
 export const HookAgendaSchema = z.object({
+  pressureMap: z.array(HookPressureSchema).default([]),
   mustAdvance: z.array(z.string().min(1)).default([]),
   eligibleResolve: z.array(z.string().min(1)).default([]),
   staleDebt: z.array(z.string().min(1)).default([]),
@@ -21,11 +61,16 @@ export const ChapterIntentSchema = z.object({
   chapter: z.number().int().min(1),
   goal: z.string().min(1),
   outlineNode: z.string().optional(),
+  sceneDirective: z.string().min(1).optional(),
+  arcDirective: z.string().min(1).optional(),
+  moodDirective: z.string().min(1).optional(),
+  titleDirective: z.string().min(1).optional(),
   mustKeep: z.array(z.string()).default([]),
   mustAvoid: z.array(z.string()).default([]),
   styleEmphasis: z.array(z.string()).default([]),
   conflicts: z.array(ChapterConflictSchema).default([]),
   hookAgenda: HookAgendaSchema.default({
+    pressureMap: [],
     mustAdvance: [],
     eligibleResolve: [],
     staleDebt: [],

packages/core/src/models/project.ts

@@ -9,6 +9,7 @@ export const LLMConfigSchema = z.object({
   maxTokens: z.number().int().min(1).default(8192),
   thinkingBudget: z.number().int().min(0).default(0),
   extra: z.record(z.unknown()).optional(),
+  headers: z.record(z.string()).optional(),
   apiFormat: z.enum(["chat", "responses"]).default("chat"),
   stream: z.boolean().default(true),
 });

packages/core/src/models/runtime-state.ts

@@ -16,6 +16,15 @@ export type StateManifest = z.infer<typeof StateManifestSchema>;
 export const HookStatusSchema = z.enum(["open", "progressing", "deferred", "resolved"]);
 export type HookStatus = z.infer<typeof HookStatusSchema>;
 
+export const HookPayoffTimingSchema = z.enum([
+  "immediate",
+  "near-term",
+  "mid-arc",
+  "slow-burn",
+  "endgame",
+]);
+export type HookPayoffTiming = z.infer<typeof HookPayoffTimingSchema>;
+
 export const HookRecordSchema = z.object({
   hookId: z.string().min(1),
   startChapter: z.number().int().min(0),
@@ -23,6 +32,7 @@ export const HookRecordSchema = z.object({
   status: HookStatusSchema,
   lastAdvancedChapter: z.number().int().min(0),
   expectedPayoff: z.string().default(""),
+  payoffTiming: HookPayoffTimingSchema.optional(),
   notes: z.string().default(""),
 });
 
@@ -94,6 +104,7 @@ export type HookOps = z.infer<typeof HookOpsSchema>;
 export const NewHookCandidateSchema = z.object({
   type: z.string().min(1),
   expectedPayoff: z.string().default(""),
+  payoffTiming: HookPayoffTimingSchema.optional(),
   notes: z.string().default(""),
 });
 

packages/core/src/pipeline/chapter-persistence.ts

@@ -0,0 +1,75 @@
+import type { AuditIssue, AuditResult } from "../agents/continuity.js";
+import type { ChapterMeta } from "../models/chapter.js";
+import type { LengthTelemetry } from "../models/length-governance.js";
+import { buildStateDegradedReviewNote } from "./chapter-state-recovery.js";
+
+export interface ChapterPersistenceUsage {
+  readonly promptTokens: number;
+  readonly completionTokens: number;
+  readonly totalTokens: number;
+}
+
+export type ChapterPersistenceStatus = "ready-for-review" | "audit-failed" | "state-degraded";
+
+export async function persistChapterArtifacts(params: {
+  readonly chapterNumber: number;
+  readonly chapterTitle: string;
+  readonly status: ChapterPersistenceStatus;
+  readonly auditResult: AuditResult;
+  readonly finalWordCount: number;
+  readonly lengthWarnings: ReadonlyArray<string>;
+  readonly lengthTelemetry?: LengthTelemetry;
+  readonly degradedIssues: ReadonlyArray<AuditIssue>;
+  readonly tokenUsage?: ChapterPersistenceUsage;
+  readonly loadChapterIndex: () => Promise<ReadonlyArray<ChapterMeta>>;
+  readonly saveChapter: () => Promise<void>;
+  readonly saveTruthFiles: () => Promise<void>;
+  readonly saveChapterIndex: (index: ReadonlyArray<ChapterMeta>) => Promise<void>;
+  readonly markBookActiveIfNeeded: () => Promise<void>;
+  readonly persistAuditDriftGuidance: (issues: ReadonlyArray<AuditIssue>) => Promise<void>;
+  readonly snapshotState: () => Promise<void>;
+  readonly syncCurrentStateFactHistory: () => Promise<void>;
+  readonly logSnapshotStage: () => void;
+  readonly now?: () => string;
+}): Promise<{ readonly entry: ChapterMeta }> {
+  await params.saveChapter();
+  if (params.status !== "state-degraded") {
+    await params.saveTruthFiles();
+  }
+
+  const existingIndex = await params.loadChapterIndex();
+  const now = params.now?.() ?? new Date().toISOString();
+  const entry: ChapterMeta = {
+    number: params.chapterNumber,
+    title: params.chapterTitle,
+    status: params.status,
+    wordCount: params.finalWordCount,
+    createdAt: now,
+    updatedAt: now,
+    auditIssues: params.auditResult.issues.map((issue) => `[${issue.severity}] ${issue.description}`),
+    lengthWarnings: [...params.lengthWarnings],
+    reviewNote: params.status === "state-degraded"
+      ? buildStateDegradedReviewNote(
+          params.auditResult.passed ? "ready-for-review" : "audit-failed",
+          params.degradedIssues,
+        )
+      : undefined,
+    lengthTelemetry: params.lengthTelemetry,
+    tokenUsage: params.tokenUsage,
+  };
+  await params.saveChapterIndex([...existingIndex, entry]);
+  await params.markBookActiveIfNeeded();
+
+  const driftIssues = params.auditResult.issues.filter(
+    (issue) => issue.severity === "critical" || issue.severity === "warning",
+  );
+  await params.persistAuditDriftGuidance(params.status === "state-degraded" ? [] : driftIssues);
+
+  if (params.status !== "state-degraded") {
+    params.logSnapshotStage();
+    await params.snapshotState();
+    await params.syncCurrentStateFactHistory();
+  }
+
+  return { entry };
+}

packages/core/src/pipeline/chapter-review-cycle.ts

@@ -0,0 +1,218 @@
+import type { AuditIssue, AuditResult } from "../agents/continuity.js";
+import type { ReviseOutput } from "../agents/reviser.js";
+import type { WriteChapterOutput } from "../agents/writer.js";
+import type { ContextPackage, RuleStack } from "../models/input-governance.js";
+import type { LengthSpec } from "../models/length-governance.js";
+
+export interface ChapterReviewCycleUsage {
+  readonly promptTokens: number;
+  readonly completionTokens: number;
+  readonly totalTokens: number;
+}
+
+export interface ChapterReviewCycleControlInput {
+  readonly chapterIntent: string;
+  readonly contextPackage: ContextPackage;
+  readonly ruleStack: RuleStack;
+}
+
+export interface ChapterReviewCycleResult {
+  readonly finalContent: string;
+  readonly finalWordCount: number;
+  readonly preAuditNormalizedWordCount: number;
+  readonly revised: boolean;
+  readonly auditResult: AuditResult;
+  readonly totalUsage: ChapterReviewCycleUsage;
+  readonly postReviseCount: number;
+  readonly normalizeApplied: boolean;
+}
+
+export async function runChapterReviewCycle(params: {
+  readonly book: Pick<{ genre: string }, "genre">;
+  readonly bookDir: string;
+  readonly chapterNumber: number;
+  readonly initialOutput: Pick<WriteChapterOutput, "content" | "wordCount" | "postWriteErrors">;
+  readonly reducedControlInput?: ChapterReviewCycleControlInput;
+  readonly lengthSpec: LengthSpec;
+  readonly initialUsage: ChapterReviewCycleUsage;
+  readonly createReviser: () => {
+    reviseChapter: (
+      bookDir: string,
+      chapterContent: string,
+      chapterNumber: number,
+      issues: ReadonlyArray<AuditIssue>,
+      mode: "spot-fix",
+      genre?: string,
+      options?: {
+        chapterIntent?: string;
+        contextPackage?: ContextPackage;
+        ruleStack?: RuleStack;
+        lengthSpec?: LengthSpec;
+      },
+    ) => Promise<ReviseOutput>;
+  };
+  readonly auditor: {
+    auditChapter: (
+      bookDir: string,
+      chapterContent: string,
+      chapterNumber: number,
+      genre?: string,
+      options?: {
+        temperature?: number;
+        chapterIntent?: string;
+        contextPackage?: ContextPackage;
+        ruleStack?: RuleStack;
+      },
+    ) => Promise<AuditResult>;
+  };
+  readonly normalizeDraftLengthIfNeeded: (chapterContent: string) => Promise<{
+    content: string;
+    wordCount: number;
+    applied: boolean;
+    tokenUsage?: ChapterReviewCycleUsage;
+  }>;
+  readonly assertChapterContentNotEmpty: (content: string, stage: string) => void;
+  readonly addUsage: (
+    left: ChapterReviewCycleUsage,
+    right?: ChapterReviewCycleUsage,
+  ) => ChapterReviewCycleUsage;
+  readonly restoreLostAuditIssues: (previous: AuditResult, next: AuditResult) => AuditResult;
+  readonly analyzeAITells: (content: string) => { issues: ReadonlyArray<AuditIssue> };
+  readonly analyzeSensitiveWords: (content: string) => {
+    found: ReadonlyArray<{ severity: string }>;
+    issues: ReadonlyArray<AuditIssue>;
+  };
+  readonly logWarn: (message: { zh: string; en: string }) => void;
+  readonly logStage: (message: { zh: string; en: string }) => void;
+}): Promise<ChapterReviewCycleResult> {
+  let totalUsage = params.initialUsage;
+  let postReviseCount = 0;
+  let normalizeApplied = false;
+  let finalContent = params.initialOutput.content;
+  let finalWordCount = params.initialOutput.wordCount;
+  let revised = false;
+
+  if (params.initialOutput.postWriteErrors.length > 0) {
+    params.logWarn({
+      zh: `检测到 ${params.initialOutput.postWriteErrors.length} 个后写错误，审计前触发 spot-fix 修补`,
+      en: `${params.initialOutput.postWriteErrors.length} post-write errors detected, triggering spot-fix before audit`,
+    });
+    const reviser = params.createReviser();
+    const spotFixIssues = params.initialOutput.postWriteErrors.map((violation) => ({
+      severity: "critical" as const,
+      category: violation.rule,
+      description: violation.description,
+      suggestion: violation.suggestion,
+    }));
+    const fixResult = await reviser.reviseChapter(
+      params.bookDir,
+      finalContent,
+      params.chapterNumber,
+      spotFixIssues,
+      "spot-fix",
+      params.book.genre,
+      {
+        ...params.reducedControlInput,
+        lengthSpec: params.lengthSpec,
+      },
+    );
+    totalUsage = params.addUsage(totalUsage, fixResult.tokenUsage);
+    if (fixResult.revisedContent.length > 0) {
+      finalContent = fixResult.revisedContent;
+      finalWordCount = fixResult.wordCount;
+      revised = true;
+    }
+  }
+
+  const normalizedBeforeAudit = await params.normalizeDraftLengthIfNeeded(finalContent);
+  totalUsage = params.addUsage(totalUsage, normalizedBeforeAudit.tokenUsage);
+  finalContent = normalizedBeforeAudit.content;
+  finalWordCount = normalizedBeforeAudit.wordCount;
+  normalizeApplied = normalizeApplied || normalizedBeforeAudit.applied;
+  params.assertChapterContentNotEmpty(finalContent, "draft generation");
+
+  params.logStage({ zh: "审计草稿", en: "auditing draft" });
+  const llmAudit = await params.auditor.auditChapter(
+    params.bookDir,
+    finalContent,
+    params.chapterNumber,
+    params.book.genre,
+    params.reducedControlInput,
+  );
+  totalUsage = params.addUsage(totalUsage, llmAudit.tokenUsage);
+  const aiTellsResult = params.analyzeAITells(finalContent);
+  const sensitiveWriteResult = params.analyzeSensitiveWords(finalContent);
+  const hasBlockedWriteWords = sensitiveWriteResult.found.some((item) => item.severity === "block");
+  let auditResult: AuditResult = {
+    passed: hasBlockedWriteWords ? false : llmAudit.passed,
+    issues: [...llmAudit.issues, ...aiTellsResult.issues, ...sensitiveWriteResult.issues],
+    summary: llmAudit.summary,
+  };
+
+  if (!auditResult.passed) {
+    const criticalIssues = auditResult.issues.filter((issue) => issue.severity === "critical");
+    if (criticalIssues.length > 0) {
+      const reviser = params.createReviser();
+      params.logStage({ zh: "自动修复关键问题", en: "auto-revising critical issues" });
+      const reviseOutput = await reviser.reviseChapter(
+        params.bookDir,
+        finalContent,
+        params.chapterNumber,
+        auditResult.issues,
+        "spot-fix",
+        params.book.genre,
+        {
+          ...params.reducedControlInput,
+          lengthSpec: params.lengthSpec,
+        },
+      );
+      totalUsage = params.addUsage(totalUsage, reviseOutput.tokenUsage);
+
+      if (reviseOutput.revisedContent.length > 0) {
+        const normalizedRevision = await params.normalizeDraftLengthIfNeeded(reviseOutput.revisedContent);
+        totalUsage = params.addUsage(totalUsage, normalizedRevision.tokenUsage);
+        postReviseCount = normalizedRevision.wordCount;
+        normalizeApplied = normalizeApplied || normalizedRevision.applied;
+
+        const preMarkers = params.analyzeAITells(finalContent);
+        const postMarkers = params.analyzeAITells(normalizedRevision.content);
+        if (postMarkers.issues.length <= preMarkers.issues.length) {
+          finalContent = normalizedRevision.content;
+          finalWordCount = normalizedRevision.wordCount;
+          revised = true;
+          params.assertChapterContentNotEmpty(finalContent, "revision");
+        }
+
+        const reAudit = await params.auditor.auditChapter(
+          params.bookDir,
+          finalContent,
+          params.chapterNumber,
+          params.book.genre,
+          params.reducedControlInput
+            ? { ...params.reducedControlInput, temperature: 0 }
+            : { temperature: 0 },
+        );
+        totalUsage = params.addUsage(totalUsage, reAudit.tokenUsage);
+        const reAITells = params.analyzeAITells(finalContent);
+        const reSensitive = params.analyzeSensitiveWords(finalContent);
+        const reHasBlocked = reSensitive.found.some((item) => item.severity === "block");
+        auditResult = params.restoreLostAuditIssues(auditResult, {
+          passed: reHasBlocked ? false : reAudit.passed,
+          issues: [...reAudit.issues, ...reAITells.issues, ...reSensitive.issues],
+          summary: reAudit.summary,
+        });
+      }
+    }
+  }
+
+  return {
+    finalContent,
+    finalWordCount,
+    preAuditNormalizedWordCount: normalizedBeforeAudit.wordCount,
+    revised,
+    auditResult,
+    totalUsage,
+    postReviseCount,
+    normalizeApplied,
+  };
+}

packages/core/src/pipeline/chapter-state-recovery.ts

@@ -0,0 +1,235 @@
+import type { AuditIssue } from "../agents/continuity.js";
+import type {
+  ValidationResult,
+  ValidationWarning,
+} from "../agents/state-validator.js";
+import type { StateValidatorAgent } from "../agents/state-validator.js";
+import type { WriteChapterOutput } from "../agents/writer.js";
+import type { WriterAgent } from "../agents/writer.js";
+import type { Logger } from "../utils/logger.js";
+import type { BookConfig } from "../models/book.js";
+import type { ChapterMeta } from "../models/chapter.js";
+import type { ContextPackage, RuleStack } from "../models/input-governance.js";
+import type { LengthLanguage } from "../utils/length-metrics.js";
+
+export interface SettlementRetryParams {
+  readonly writer: Pick<WriterAgent, "settleChapterState">;
+  readonly validator: Pick<StateValidatorAgent, "validate">;
+  readonly book: BookConfig;
+  readonly bookDir: string;
+  readonly chapterNumber: number;
+  readonly title: string;
+  readonly content: string;
+  readonly reducedControlInput?: {
+    chapterIntent: string;
+    contextPackage: ContextPackage;
+    ruleStack: RuleStack;
+  };
+  readonly oldState: string;
+  readonly oldHooks: string;
+  readonly originalValidation: ValidationResult;
+  readonly language: LengthLanguage;
+  readonly logWarn?: (message: { zh: string; en: string }) => void;
+  readonly logger?: Pick<Logger, "warn">;
+}
+
+export type SettlementRetryResult =
+  | {
+    readonly kind: "recovered";
+    readonly output: WriteChapterOutput;
+    readonly validation: ValidationResult;
+  }
+  | {
+    readonly kind: "degraded";
+    readonly issues: ReadonlyArray<AuditIssue>;
+  };
+
+export async function retrySettlementAfterValidationFailure(
+  params: SettlementRetryParams,
+): Promise<SettlementRetryResult> {
+  params.logWarn?.({
+    zh: `状态校验失败，正在仅重试结算层（第${params.chapterNumber}章）`,
+    en: `State validation failed; retrying settlement only for chapter ${params.chapterNumber}`,
+  });
+
+  const retryOutput = await params.writer.settleChapterState({
+    book: params.book,
+    bookDir: params.bookDir,
+    chapterNumber: params.chapterNumber,
+    title: params.title,
+    content: params.content,
+    chapterIntent: params.reducedControlInput?.chapterIntent,
+    contextPackage: params.reducedControlInput?.contextPackage,
+    ruleStack: params.reducedControlInput?.ruleStack,
+    validationFeedback: buildStateValidationFeedback(
+      params.originalValidation.warnings,
+      params.language,
+    ),
+  });
+
+  let retryValidation: ValidationResult;
+  try {
+    retryValidation = await params.validator.validate(
+      params.content,
+      params.chapterNumber,
+      params.oldState,
+      retryOutput.updatedState,
+      params.oldHooks,
+      retryOutput.updatedHooks,
+      params.language,
+    );
+  } catch (error) {
+    throw new Error(`State validation retry failed for chapter ${params.chapterNumber}: ${String(error)}`);
+  }
+
+  if (retryValidation.warnings.length > 0) {
+    params.logWarn?.({
+      zh: `状态校验重试后，第${params.chapterNumber}章仍有 ${retryValidation.warnings.length} 条警告`,
+      en: `State validation retry still reports ${retryValidation.warnings.length} warning(s) for chapter ${params.chapterNumber}`,
+    });
+    for (const warning of retryValidation.warnings) {
+      params.logger?.warn(`  [${warning.category}] ${warning.description}`);
+    }
+  }
+
+  if (retryValidation.passed) {
+    return {
+      kind: "recovered",
+      output: retryOutput,
+      validation: retryValidation,
+    };
+  }
+
+  return {
+    kind: "degraded",
+    issues: buildStateDegradedIssues(retryValidation.warnings, params.language),
+  };
+}
+
+export function buildStateValidationFeedback(
+  warnings: ReadonlyArray<ValidationWarning>,
+  language: LengthLanguage,
+): string {
+  if (warnings.length === 0) {
+    return language === "en"
+      ? "The previous settlement contradicted the chapter text. Reconcile truth files strictly to the body."
+      : "上一次状态结算与正文矛盾。请严格以正文为准修正 truth files。";
+  }
+
+  if (language === "en") {
+    return [
+      "The previous settlement failed validation. Fix these contradictions against the chapter body:",
+      ...warnings.map((warning) => `- [${warning.category}] ${warning.description}`),
+    ].join("\n");
+  }
+
+  return [
+    "上一次状态结算未通过校验。请对照正文修正以下矛盾：",
+    ...warnings.map((warning) => `- [${warning.category}] ${warning.description}`),
+  ].join("\n");
+}
+
+export function buildStateDegradedIssues(
+  warnings: ReadonlyArray<ValidationWarning>,
+  language: LengthLanguage,
+): ReadonlyArray<AuditIssue> {
+  if (warnings.length > 0) {
+    return warnings.map((warning) => ({
+      severity: "warning" as const,
+      category: "state-validation",
+      description: warning.description,
+      suggestion: language === "en"
+        ? "Repair chapter state from the persisted body before continuing."
+        : "请先基于已保存正文修复本章 state，再继续后续章节。",
+    }));
+  }
+
+  return [{
+    severity: "warning",
+    category: "state-validation",
+    description: language === "en"
+      ? "State validation still failed after settlement retry."
+      : "状态结算重试后仍未通过校验。",
+    suggestion: language === "en"
+      ? "Repair chapter state from the persisted body before continuing."
+      : "请先基于已保存正文修复本章 state，再继续后续章节。",
+  }];
+}
+
+export function buildStateDegradedPersistenceOutput(params: {
+  readonly output: WriteChapterOutput;
+  readonly oldState: string;
+  readonly oldHooks: string;
+  readonly oldLedger: string;
+}): WriteChapterOutput {
+  return {
+    ...params.output,
+    runtimeStateDelta: undefined,
+    runtimeStateSnapshot: undefined,
+    updatedState: params.oldState,
+    updatedLedger: params.oldLedger,
+    updatedHooks: params.oldHooks,
+    updatedChapterSummaries: undefined,
+  };
+}
+
+export interface StateDegradedReviewNote {
+  readonly kind: "state-degraded";
+  readonly baseStatus: "ready-for-review" | "audit-failed";
+  readonly injectedIssues: ReadonlyArray<string>;
+}
+
+export function buildStateDegradedReviewNote(
+  baseStatus: "ready-for-review" | "audit-failed",
+  issues: ReadonlyArray<AuditIssue>,
+): string {
+  return JSON.stringify({
+    kind: "state-degraded",
+    baseStatus,
+    injectedIssues: issues.map((issue) => `[${issue.severity}] ${issue.description}`),
+  } satisfies StateDegradedReviewNote);
+}
+
+export function parseStateDegradedReviewNote(
+  reviewNote?: string,
+): StateDegradedReviewNote | null {
+  if (!reviewNote) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(reviewNote) as {
+      kind?: unknown;
+      baseStatus?: unknown;
+      injectedIssues?: unknown;
+    };
+    if (
+      parsed.kind !== "state-degraded"
+      || (parsed.baseStatus !== "ready-for-review" && parsed.baseStatus !== "audit-failed")
+      || !Array.isArray(parsed.injectedIssues)
+    ) {
+      return null;
+    }
+
+    return {
+      kind: "state-degraded",
+      baseStatus: parsed.baseStatus,
+      injectedIssues: parsed.injectedIssues.filter((issue): issue is string => typeof issue === "string"),
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function resolveStateDegradedBaseStatus(
+  chapter: Pick<ChapterMeta, "reviewNote" | "auditIssues">,
+): "ready-for-review" | "audit-failed" {
+  const metadata = parseStateDegradedReviewNote(chapter.reviewNote);
+  if (metadata) {
+    return metadata.baseStatus;
+  }
+
+  return chapter.auditIssues.some((issue) => issue.startsWith("[critical]"))
+    ? "audit-failed"
+    : "ready-for-review";
+}

packages/core/src/pipeline/chapter-truth-validation.ts

@@ -0,0 +1,117 @@
+import type { AuditIssue, AuditResult } from "../agents/continuity.js";
+import type { ValidationResult, StateValidatorAgent } from "../agents/state-validator.js";
+import type { WriteChapterOutput, WriterAgent } from "../agents/writer.js";
+import type { BookConfig } from "../models/book.js";
+import type { ContextPackage, RuleStack } from "../models/input-governance.js";
+import type { Logger } from "../utils/logger.js";
+import type { LengthLanguage } from "../utils/length-metrics.js";
+import {
+  buildStateDegradedPersistenceOutput,
+  retrySettlementAfterValidationFailure,
+} from "./chapter-state-recovery.js";
+
+export async function validateChapterTruthPersistence(params: {
+  readonly writer: Pick<WriterAgent, "settleChapterState">;
+  readonly validator: Pick<StateValidatorAgent, "validate">;
+  readonly book: BookConfig;
+  readonly bookDir: string;
+  readonly chapterNumber: number;
+  readonly title: string;
+  readonly content: string;
+  readonly persistenceOutput: WriteChapterOutput;
+  readonly auditResult: AuditResult;
+  readonly previousTruth: {
+    readonly oldState: string;
+    readonly oldHooks: string;
+    readonly oldLedger: string;
+  };
+  readonly reducedControlInput?: {
+    chapterIntent: string;
+    contextPackage: ContextPackage;
+    ruleStack: RuleStack;
+  };
+  readonly language: LengthLanguage;
+  readonly logWarn: (message: { zh: string; en: string }) => void;
+  readonly logger?: Pick<Logger, "warn">;
+}): Promise<{
+  readonly validation: ValidationResult;
+  readonly chapterStatus: "state-degraded" | null;
+  readonly degradedIssues: ReadonlyArray<AuditIssue>;
+  readonly persistenceOutput: WriteChapterOutput;
+  readonly auditResult: AuditResult;
+}> {
+  let validation: ValidationResult;
+  let chapterStatus: "state-degraded" | null = null;
+  let degradedIssues: ReadonlyArray<AuditIssue> = [];
+  let persistenceOutput = params.persistenceOutput;
+  let auditResult = params.auditResult;
+
+  try {
+    validation = await params.validator.validate(
+      params.content,
+      params.chapterNumber,
+      params.previousTruth.oldState,
+      persistenceOutput.updatedState,
+      params.previousTruth.oldHooks,
+      persistenceOutput.updatedHooks,
+      params.language,
+    );
+  } catch (error) {
+    throw new Error(`State validation failed for chapter ${params.chapterNumber}: ${String(error)}`);
+  }
+
+  if (validation.warnings.length > 0) {
+    params.logWarn({
+      zh: `状态校验：第${params.chapterNumber}章发现 ${validation.warnings.length} 条警告`,
+      en: `State validation: ${validation.warnings.length} warning(s) for chapter ${params.chapterNumber}`,
+    });
+    for (const warning of validation.warnings) {
+      params.logger?.warn(`  [${warning.category}] ${warning.description}`);
+    }
+  }
+
+  if (!validation.passed) {
+    const recovery = await retrySettlementAfterValidationFailure({
+      writer: params.writer,
+      validator: params.validator,
+      book: params.book,
+      bookDir: params.bookDir,
+      chapterNumber: params.chapterNumber,
+      title: params.title,
+      content: params.content,
+      reducedControlInput: params.reducedControlInput,
+      oldState: params.previousTruth.oldState,
+      oldHooks: params.previousTruth.oldHooks,
+      originalValidation: validation,
+      language: params.language,
+      logWarn: params.logWarn,
+      logger: params.logger,
+    });
+
+    if (recovery.kind === "recovered") {
+      persistenceOutput = recovery.output;
+      validation = recovery.validation;
+    } else {
+      chapterStatus = "state-degraded";
+      degradedIssues = recovery.issues;
+      persistenceOutput = buildStateDegradedPersistenceOutput({
+        output: persistenceOutput,
+        oldState: params.previousTruth.oldState,
+        oldHooks: params.previousTruth.oldHooks,
+        oldLedger: params.previousTruth.oldLedger,
+      });
+      auditResult = {
+        ...auditResult,
+        issues: [...auditResult.issues, ...recovery.issues],
+      };
+    }
+  }
+
+  return {
+    validation,
+    chapterStatus,
+    degradedIssues,
+    persistenceOutput,
+    auditResult,
+  };
+}

packages/core/src/pipeline/persisted-governed-plan.ts

@@ -0,0 +1,101 @@
+import { readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import type { PlanChapterOutput } from "../agents/planner.js";
+import { ChapterIntentSchema } from "../models/input-governance.js";
+
+export async function loadPersistedPlan(
+  bookDir: string,
+  chapterNumber: number,
+): Promise<PlanChapterOutput | null> {
+  const runtimePath = join(
+    bookDir,
+    "story",
+    "runtime",
+    `chapter-${String(chapterNumber).padStart(4, "0")}.intent.md`,
+  );
+
+  try {
+    const intentMarkdown = await readFile(runtimePath, "utf-8");
+    const sections = parseIntentSections(intentMarkdown);
+    const goal = readIntentScalar(sections, "Goal");
+    if (!goal || isInvalidPersistedIntentScalar(goal)) return null;
+
+    const outlineNode = readIntentScalar(sections, "Outline Node");
+    if (outlineNode && outlineNode !== "(not found)" && isInvalidPersistedIntentScalar(outlineNode)) {
+      return null;
+    }
+    const conflicts = 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 is { type: string; resolution: string } => conflict !== null);
+
+    return {
+      intent: ChapterIntentSchema.parse({
+        chapter: chapterNumber,
+        goal,
+        outlineNode: outlineNode && outlineNode !== "(not found)" ? outlineNode : undefined,
+        mustKeep: readIntentList(sections, "Must Keep"),
+        mustAvoid: readIntentList(sections, "Must Avoid"),
+        styleEmphasis: readIntentList(sections, "Style Emphasis"),
+        conflicts,
+      }),
+      intentMarkdown,
+      plannerInputs: [runtimePath],
+      runtimePath,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function relativeToBookDir(bookDir: string, absolutePath: string): string {
+  return relative(bookDir, absolutePath).replaceAll("\\", "/");
+}
+
+function parseIntentSections(markdown: string): Map<string, string[]> {
+  const sections = new Map<string, string[]>();
+  let current: string | null = 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;
+}
+
+function readIntentScalar(sections: Map<string, string[]>, name: string): string | undefined {
+  const lines = sections.get(name) ?? [];
+  const value = lines.map((line) => line.trim()).find((line) => line.length > 0);
+  return value && value !== "- none" ? value : undefined;
+}
+
+function readIntentList(sections: Map<string, string[]>, name: string): string[] {
+  return (sections.get(name) ?? [])
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("-") && line !== "- none")
+    .map((line) => line.replace(/^-\s*/, ""));
+}
+
+function isInvalidPersistedIntentScalar(value: string): boolean {
+  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)
+  );
+}

packages/core/src/pipeline/runner.ts

@@ -13,7 +13,7 @@ import { LengthNormalizerAgent } from "../agents/length-normalizer.js";
 import { ChapterAnalyzerAgent } from "../agents/chapter-analyzer.js";
 import { ContinuityAuditor } from "../agents/continuity.js";
 import { ReviserAgent, DEFAULT_REVISE_MODE, type ReviseMode } from "../agents/reviser.js";
-import { StateValidatorAgent } from "../agents/state-validator.js";
+import { StateValidatorAgent, type ValidationResult, type ValidationWarning } from "../agents/state-validator.js";
 import { RadarAgent } from "../agents/radar.js";
 import type { RadarSource } from "../agents/radar-source.js";
 import { readGenreProfile } from "../agents/rules-reader.js";
@@ -27,13 +27,35 @@ import type { AgentContext } from "../agents/base.js";
 import type { AuditResult, AuditIssue } from "../agents/continuity.js";
 import type { RadarResult } from "../agents/radar.js";
 import type { LengthSpec, LengthTelemetry } from "../models/length-governance.js";
-import { ChapterIntentSchema, type ContextPackage, type RuleStack } from "../models/input-governance.js";
+import type { ContextPackage, RuleStack } from "../models/input-governance.js";
 import { buildLengthSpec, countChapterLength, formatLengthCount, isOutsideHardRange, isOutsideSoftRange, resolveLengthCountingMode, type LengthLanguage } 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, rename, rm, stat } from "node:fs/promises";
-import { join, relative } from "node:path";
+import { join } from "node:path";
+import {
+  parseStateDegradedReviewNote,
+  resolveStateDegradedBaseStatus,
+  retrySettlementAfterValidationFailure,
+} from "./chapter-state-recovery.js";
+import { persistChapterArtifacts } from "./chapter-persistence.js";
+import { runChapterReviewCycle } from "./chapter-review-cycle.js";
+import { validateChapterTruthPersistence } from "./chapter-truth-validation.js";
+import { loadPersistedPlan, relativeToBookDir } from "./persisted-governed-plan.js";
+
+const SEQUENCE_LEVEL_CATEGORIES = new Set([
+  "Pacing Monotony", "节奏单调",
+  "Mood Monotony", "情绪单调",
+  "Title Collapse", "标题重复",
+  "Title Clustering", "标题聚集",
+  "Opening Pattern Repetition", "开头同构",
+  "Ending Pattern Repetition", "结尾同构",
+]);
+
+function isSequenceLevelCategory(category: string): boolean {
+  return SEQUENCE_LEVEL_CATEGORIES.has(category);
+}
 
 export interface PipelineConfig {
   readonly client: LLMClient;
@@ -61,7 +83,7 @@ export interface ChapterPipelineResult {
   readonly wordCount: number;
   readonly auditResult: AuditResult;
   readonly revised: boolean;
-  readonly status: "ready-for-review" | "audit-failed";
+  readonly status: "ready-for-review" | "audit-failed" | "state-degraded";
   readonly lengthWarnings?: ReadonlyArray<string>;
   readonly lengthTelemetry?: LengthTelemetry;
   readonly tokenUsage?: TokenUsageSummary;
@@ -202,6 +224,24 @@ export class PipelineRunner {
     this.config.logger?.warn(this.localize(language, message));
   }
 
+  private async tryGenerateStyleGuide(
+    bookId: string,
+    referenceText: string,
+    sourceName: string | undefined,
+    language?: LengthLanguage,
+  ): Promise<void> {
+    try {
+      await this.generateStyleGuide(bookId, referenceText, sourceName);
+    } catch (error) {
+      const resolvedLanguage = language ?? await this.resolveBookLanguageById(bookId);
+      const detail = error instanceof Error ? error.message : String(error);
+      this.logWarn(resolvedLanguage, {
+        zh: `风格指纹提取失败，已跳过：${detail}`,
+        en: `Style fingerprint extraction failed and was skipped: ${detail}`,
+      });
+    }
+  }
+
   private agentCtx(bookId?: string): AgentContext {
     return {
       client: this.config.client,
@@ -396,7 +436,13 @@ export class PipelineRunner {
     this.logStage(stageLanguage, { zh: "初始化控制文档", en: "initializing control documents" });
     await this.state.ensureControlDocuments(book.id, this.config.externalContext);
 
-    // Step 3: Initialize chapters directory + snapshot
+    // Step 3: Generate style guide from source material
+    if (sourceText.length >= 500) {
+      this.logStage(stageLanguage, { zh: "提取原作风格指纹", en: "extracting source style fingerprint" });
+      await this.tryGenerateStyleGuide(book.id, sourceText, sourceName, stageLanguage);
+    }
+
+    // Step 4: 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, []);
@@ -552,7 +598,7 @@ export class PipelineRunner {
     return {
       bookId,
       chapterNumber,
-      intentPath: this.relativeToBookDir(bookDir, plan.runtimePath),
+      intentPath: relativeToBookDir(bookDir, plan.runtimePath),
       goal: plan.intent.goal,
       conflicts: plan.intent.conflicts.map((conflict) => `${conflict.type}: ${conflict.resolution}`),
     };
@@ -576,12 +622,12 @@ export class PipelineRunner {
     return {
       bookId,
       chapterNumber,
-      intentPath: this.relativeToBookDir(bookDir, plan.runtimePath),
+      intentPath: 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),
+      contextPath: relativeToBookDir(bookDir, composed.contextPath),
+      ruleStackPath: relativeToBookDir(bookDir, composed.ruleStackPath),
+      tracePath: relativeToBookDir(bookDir, composed.tracePath),
     };
   }
 
@@ -625,6 +671,15 @@ export class PipelineRunner {
         : ch,
     );
     await this.state.saveChapterIndex(bookId, updated);
+    const latestChapter = index.length > 0 ? Math.max(...index.map((chapter) => chapter.number)) : targetChapter;
+    if (targetChapter === latestChapter) {
+      await this.persistAuditDriftGuidance({
+        bookDir,
+        chapterNumber: targetChapter,
+        issues: result.issues.filter((issue) => issue.severity === "critical" || issue.severity === "warning"),
+        language,
+      }).catch(() => undefined);
+    }
 
     await this.emitWebhook(
       result.passed ? "audit-passed" : "audit-failed",
@@ -861,6 +916,17 @@ export class PipelineRunner {
           : ch,
       );
       await this.state.saveChapterIndex(bookId, updatedIndex);
+      const latestChapter = index.length > 0 ? Math.max(...index.map((chapter) => chapter.number)) : targetChapter;
+      if (targetChapter === latestChapter) {
+        await this.persistAuditDriftGuidance({
+          bookDir,
+          chapterNumber: targetChapter,
+          issues: effectivePostRevision.auditResult.issues.filter(
+            (issue) => issue.severity === "critical" || issue.severity === "warning",
+          ),
+          language,
+        }).catch(() => undefined);
+      }
 
       // Re-snapshot
       this.logStage(stageLanguage, {
@@ -948,10 +1014,20 @@ export class PipelineRunner {
     }
   }
 
+  async repairChapterState(bookId: string, chapterNumber?: number): Promise<ChapterPipelineResult> {
+    const releaseLock = await this.state.acquireBookLock(bookId);
+    try {
+      return await this._repairChapterStateLocked(bookId, chapterNumber);
+    } finally {
+      await releaseLock();
+    }
+  }
+
   private async _writeNextChapterLocked(bookId: string, wordCount?: number, temperatureOverride?: number): Promise<ChapterPipelineResult> {
     await this.state.ensureControlDocuments(bookId);
     const book = await this.state.loadBookConfig(bookId);
     const bookDir = this.state.bookDir(bookId);
+    await this.assertNoPendingStateRepair(bookId);
     const chapterNumber = await this.state.getNextChapterNumber(bookId);
     const stageLanguage = await this.resolveBookLanguage(book);
     this.logStage(stageLanguage, { zh: "准备章节输入", en: "preparing chapter inputs" });
@@ -991,148 +1067,40 @@ export class PipelineRunner {
 
     // Token usage accumulator
     let totalUsage: TokenUsageSummary = 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.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" as const,
-        category: v.rule,
-        description: v.description,
-        suggestion: v.suggestion,
-      }));
-      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;
-        finalWordCount = fixResult.wordCount;
-        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;
-    this.assertChapterContentNotEmpty(finalContent, chapterNumber, "draft generation");
-
-    // 2b. LLM audit
     const auditor = new ContinuityAuditor(this.agentCtxFor("auditor", bookId));
-    this.logStage(stageLanguage, { zh: "审计草稿", en: "auditing draft" });
-    const llmAudit = await auditor.auditChapter(
+    const reviewResult = await runChapterReviewCycle({
+      book: { genre: book.genre },
       bookDir,
-      finalContent,
       chapterNumber,
-      book.genre,
+      initialOutput: output,
       reducedControlInput,
-    );
-    totalUsage = PipelineRunner.addUsage(totalUsage, llmAudit.tokenUsage);
-    const aiTellsResult = analyzeAITells(finalContent);
-    const sensitiveWriteResult = analyzeSensitiveWords(finalContent);
-    const hasBlockedWriteWords = sensitiveWriteResult.found.some((f) => f.severity === "block");
-    let auditResult: AuditResult = {
-      passed: hasBlockedWriteWords ? false : llmAudit.passed,
-      issues: [...llmAudit.issues, ...aiTellsResult.issues, ...sensitiveWriteResult.issues],
-      summary: llmAudit.summary,
-    };
-
-    // 3. If audit fails, try auto-revise once
-    if (!auditResult.passed) {
-      const criticalIssues = auditResult.issues.filter(
-        (i) => i.severity === "critical",
-      );
-      if (criticalIssues.length > 0) {
-        const reviser = new ReviserAgent(this.agentCtxFor("reviser", bookId));
-        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(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 = normalizedRevision.content;
-            finalWordCount = normalizedRevision.wordCount;
-            revised = true;
-            this.assertChapterContentNotEmpty(finalContent, chapterNumber, "revision");
-          }
-
-          // Re-audit the (possibly revised) content
-          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 = this.restoreLostAuditIssues(auditResult, {
-            passed: reHasBlocked ? false : reAudit.passed,
-            issues: [...reAudit.issues, ...reAITells.issues, ...reSensitive.issues],
-            summary: reAudit.summary,
-          });
-        }
-      }
-    }
+      lengthSpec,
+      initialUsage: totalUsage,
+      createReviser: () => new ReviserAgent(this.agentCtxFor("reviser", bookId)),
+      auditor,
+      normalizeDraftLengthIfNeeded: (chapterContent) => this.normalizeDraftLengthIfNeeded({
+        bookId,
+        chapterNumber,
+        chapterContent,
+        lengthSpec,
+        chapterIntent: writeInput.chapterIntent,
+      }),
+      assertChapterContentNotEmpty: (content, stage) =>
+        this.assertChapterContentNotEmpty(content, chapterNumber, stage),
+      addUsage: PipelineRunner.addUsage,
+      restoreLostAuditIssues: (previous, next) => this.restoreLostAuditIssues(previous, next),
+      analyzeAITells,
+      analyzeSensitiveWords,
+      logWarn: (message) => this.logWarn(pipelineLang, message),
+      logStage: (message) => this.logStage(stageLanguage, message),
+    });
+    totalUsage = reviewResult.totalUsage;
+    let finalContent = reviewResult.finalContent;
+    let finalWordCount = reviewResult.finalWordCount;
+    let revised = reviewResult.revised;
+    let auditResult = reviewResult.auditResult;
+    const postReviseCount = reviewResult.postReviseCount;
+    const normalizeApplied = reviewResult.normalizeApplied;
 
     // 4. Save the final chapter and truth files from a single persistence source
     this.logStage(stageLanguage, { zh: "落盘最终章节", en: "persisting final chapter" });
@@ -1143,6 +1111,7 @@ export class PipelineRunner {
       output.title,
       chapterIndexBeforePersist.map((chapter) => chapter.title),
       pipelineLang,
+      { content: finalContent },
     );
     let persistenceOutput = await this.buildPersistenceOutput(
       bookId,
@@ -1160,6 +1129,7 @@ export class PipelineRunner {
       persistenceOutput.title,
       chapterIndexBeforePersist.map((chapter) => chapter.title),
       pipelineLang,
+      { content: finalContent },
     );
     if (finalTitleResolution.title !== persistenceOutput.title) {
       persistenceOutput = {
@@ -1169,8 +1139,8 @@ export class PipelineRunner {
     }
     if (persistenceOutput.title !== output.title) {
       const description = pipelineLang === "en"
-        ? `Duplicate chapter title "${output.title}" was auto-renamed to "${persistenceOutput.title}".`
-        : `章节标题"${output.title}"与已有标题重复，已自动改为"${persistenceOutput.title}"。`;
+        ? `Chapter title "${output.title}" was auto-adjusted to "${persistenceOutput.title}".`
+        : `章节标题"${output.title}"已自动调整为"${persistenceOutput.title}"。`;
       this.config.logger?.warn(`[title] ${description}`);
       auditResult = {
         ...auditResult,
@@ -1208,7 +1178,7 @@ export class PipelineRunner {
     const lengthTelemetry = this.buildLengthTelemetry({
       lengthSpec,
       writerCount,
-      postWriterNormalizeCount: normalizedBeforeAudit.wordCount,
+      postWriterNormalizeCount: reviewResult.preAuditNormalizedWordCount,
       postReviseCount,
       finalCount: finalWordCount,
       normalizeApplied,
@@ -1219,36 +1189,36 @@ export class PipelineRunner {
     // 4.1 Validate settler output before writing
     this.logStage(stageLanguage, { zh: "校验真相文件变更", en: "validating truth file updates" });
     const storyDir = join(bookDir, "story");
-    const [oldState, oldHooks] = await Promise.all([
+    const [oldState, oldHooks, oldLedger] = await Promise.all([
       readFile(join(storyDir, "current_state.md"), "utf-8").catch(() => ""),
       readFile(join(storyDir, "pending_hooks.md"), "utf-8").catch(() => ""),
+      readFile(join(storyDir, "particle_ledger.md"), "utf-8").catch(() => ""),
     ]);
     const validator = new StateValidatorAgent(this.agentCtxFor("state-validator", bookId));
-    let validation;
-    try {
-      validation = await validator.validate(
-        finalContent, chapterNumber,
-        oldState, persistenceOutput.updatedState,
-        oldHooks, persistenceOutput.updatedHooks,
-        pipelineLang,
-      );
-    } catch (error) {
-      throw new Error(`State validation failed for chapter ${chapterNumber}: ${String(error)}`);
-    }
-
-    if (validation.warnings.length > 0) {
-      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}`);
-      }
-    }
-    if (!validation.passed) {
-      const reason = validation.warnings[0]?.description ?? "validator reported contradictions";
-      throw new Error(`State validation failed for chapter ${chapterNumber}: ${reason}`);
-    }
+    const truthValidation = await validateChapterTruthPersistence({
+      writer,
+      validator,
+      book,
+      bookDir,
+      chapterNumber,
+      title: persistenceOutput.title,
+      content: finalContent,
+      persistenceOutput,
+      auditResult,
+      previousTruth: {
+        oldState,
+        oldHooks,
+        oldLedger,
+      },
+      reducedControlInput,
+      language: pipelineLang,
+      logWarn: (message) => this.logWarn(pipelineLang, message),
+      logger: this.config.logger,
+    });
+    let chapterStatus: ChapterPipelineResult["status"] | null = truthValidation.chapterStatus;
+    let degradedIssues: ReadonlyArray<AuditIssue> = truthValidation.degradedIssues;
+    persistenceOutput = truthValidation.persistenceOutput;
+    auditResult = truthValidation.auditResult;
 
     // 4.2 Final paragraph shape check on persisted content (post-normalize, post-revise)
     {
@@ -1284,85 +1254,53 @@ export class PipelineRunner {
       }
     }
 
-    await writer.saveChapter(bookDir, persistenceOutput, gp.numericalSystem, pipelineLang);
-    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();
-    const newEntry: ChapterMeta = {
-      number: chapterNumber,
-      title: persistenceOutput.title,
-      status: auditResult.passed ? "ready-for-review" : "audit-failed",
-      wordCount: finalWordCount,
-      createdAt: now,
-      updatedAt: now,
-      auditIssues: auditResult.issues.map(
-        (i) => `[${i.severity}] ${i.description}`,
-      ),
+    const resolvedStatus = chapterStatus ?? (auditResult.passed ? "ready-for-review" : "audit-failed");
+    await persistChapterArtifacts({
+      chapterNumber,
+      chapterTitle: persistenceOutput.title,
+      status: resolvedStatus,
+      auditResult,
+      finalWordCount,
       lengthWarnings,
       lengthTelemetry,
+      degradedIssues,
       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",
-    );
-    if (driftIssues.length > 0) {
-      const storyDir = join(bookDir, "story");
-      try {
-        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 = this.localize(stageLanguage, {
-          zh: "## 审计纠偏（自动生成，下一章写作前参照）",
-          en: "## Audit Drift Correction",
-        });
-        const correctionBlock = [
-          correctionHeader,
-          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");
-
-        // Replace existing correction block or append
-        const existingCorrectionIdx = currentState.indexOf(correctionHeader);
-        const updatedState = existingCorrectionIdx >= 0
-          ? currentState.slice(0, existingCorrectionIdx) + correctionBlock
-          : currentState + "\n\n" + correctionBlock;
-
-        await writeFile(statePath, updatedState, "utf-8");
-      } catch {
-        // Non-critical — don't block pipeline if drift correction fails
-      }
-    }
-
-    // 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);
+      loadChapterIndex: () => this.state.loadChapterIndex(bookId),
+      saveChapter: () => writer.saveChapter(bookDir, persistenceOutput, gp.numericalSystem, pipelineLang),
+      saveTruthFiles: async () => {
+        await writer.saveNewTruthFiles(bookDir, persistenceOutput, pipelineLang);
+        await this.syncLegacyStructuredStateFromMarkdown(bookDir, chapterNumber, persistenceOutput);
+        this.logStage(stageLanguage, { zh: "同步记忆索引", en: "syncing memory indexes" });
+        await this.syncNarrativeMemoryIndex(bookId);
+      },
+      saveChapterIndex: (index) => this.state.saveChapterIndex(bookId, index),
+      markBookActiveIfNeeded: () => this.markBookActiveIfNeeded(bookId),
+      persistAuditDriftGuidance: (issues) => this.persistAuditDriftGuidance({
+        bookDir,
+        chapterNumber,
+        issues,
+        language: stageLanguage,
+      }).catch(() => undefined),
+      snapshotState: () => this.state.snapshotState(bookId, chapterNumber),
+      syncCurrentStateFactHistory: () => this.syncCurrentStateFactHistory(bookId, chapterNumber),
+      logSnapshotStage: () =>
+        this.logStage(stageLanguage, { zh: "更新章节索引与快照", en: "updating chapter index and snapshots" }),
+    });
 
     // 6. Send notification
     if (this.config.notifyChannels && this.config.notifyChannels.length > 0) {
-      const statusEmoji = auditResult.passed ? "✅" : "⚠️";
+      const statusEmoji = resolvedStatus === "state-degraded"
+        ? "🧯"
+        : auditResult.passed ? "✅" : "⚠️";
       const chapterLength = formatLengthCount(finalWordCount, lengthSpec.countingMode);
       await dispatchNotification(this.config.notifyChannels, {
         title: `${statusEmoji} ${book.title} 第${chapterNumber}章`,
         body: [
           `**${persistenceOutput.title}** | ${chapterLength}`,
           revised ? "📝 已自动修正" : "",
-          `审稿: ${auditResult.passed ? "通过" : "需人工审核"}`,
+          resolvedStatus === "state-degraded"
+            ? "状态结算: 已降级保存，需先修复 state 再继续"
+            : `审稿: ${auditResult.passed ? "通过" : "需人工审核"}`,
           ...auditResult.issues
             .filter((i) => i.severity !== "info")
             .map((i) => `- [${i.severity}] ${i.description}`),
@@ -1377,6 +1315,7 @@ export class PipelineRunner {
       wordCount: finalWordCount,
       passed: auditResult.passed,
       revised,
+      status: resolvedStatus,
     });
 
     return {
@@ -1385,13 +1324,132 @@ export class PipelineRunner {
       wordCount: finalWordCount,
       auditResult,
       revised,
-      status: auditResult.passed ? "ready-for-review" : "audit-failed",
+      status: resolvedStatus,
       lengthWarnings,
       lengthTelemetry,
       tokenUsage: totalUsage,
     };
   }
 
+  private async _repairChapterStateLocked(bookId: string, chapterNumber?: number): Promise<ChapterPipelineResult> {
+    const book = await this.state.loadBookConfig(bookId);
+    const bookDir = this.state.bookDir(bookId);
+    const stageLanguage = await this.resolveBookLanguage(book);
+    const index = [...(await this.state.loadChapterIndex(bookId))];
+    if (index.length === 0) {
+      throw new Error(`Book "${bookId}" has no persisted chapters to repair.`);
+    }
+
+    const targetChapter = chapterNumber ?? index[index.length - 1]!.number;
+    const targetIndex = index.findIndex((chapter) => chapter.number === targetChapter);
+    if (targetIndex < 0) {
+      throw new Error(`Chapter ${targetChapter} not found in "${bookId}".`);
+    }
+    const targetMeta = index[targetIndex]!;
+    const latestChapter = Math.max(...index.map((chapter) => chapter.number));
+    if (targetMeta.status !== "state-degraded") {
+      throw new Error(`Chapter ${targetChapter} is not state-degraded.`);
+    }
+    if (targetChapter !== latestChapter) {
+      throw new Error(`Only the latest state-degraded chapter can be repaired safely (latest is ${latestChapter}).`);
+    }
+
+    this.logStage(stageLanguage, { zh: "修复章节状态结算", en: "repairing chapter state settlement" });
+    const { profile: gp } = await this.loadGenreProfile(book.genre);
+    const pipelineLang = book.language ?? gp.language;
+    const content = await this.readChapterContent(bookDir, targetChapter);
+    const storyDir = join(bookDir, "story");
+    const [oldState, oldHooks] = await Promise.all([
+      readFile(join(storyDir, "current_state.md"), "utf-8").catch(() => ""),
+      readFile(join(storyDir, "pending_hooks.md"), "utf-8").catch(() => ""),
+    ]);
+
+    const writer = new WriterAgent(this.agentCtxFor("writer", bookId));
+    let repairedOutput = await writer.settleChapterState({
+      book,
+      bookDir,
+      chapterNumber: targetChapter,
+      title: targetMeta.title,
+      content,
+    });
+    const validator = new StateValidatorAgent(this.agentCtxFor("state-validator", bookId));
+    let validation = await validator.validate(
+      content,
+      targetChapter,
+      oldState,
+      repairedOutput.updatedState,
+      oldHooks,
+      repairedOutput.updatedHooks,
+      pipelineLang,
+    );
+
+    if (!validation.passed) {
+      const recovery = await retrySettlementAfterValidationFailure({
+        writer,
+        validator,
+        book,
+        bookDir,
+        chapterNumber: targetChapter,
+        title: targetMeta.title,
+        content,
+        oldState,
+        oldHooks,
+        originalValidation: validation,
+        language: pipelineLang,
+        logWarn: (message) => this.logWarn(pipelineLang, message),
+        logger: this.config.logger,
+      });
+      if (recovery.kind !== "recovered") {
+        throw new Error(
+          recovery.issues[0]?.description
+            ?? `State repair still failed for chapter ${targetChapter}.`,
+        );
+      }
+      repairedOutput = recovery.output;
+      validation = recovery.validation;
+    }
+
+    if (!validation.passed) {
+      throw new Error(`State repair still failed for chapter ${targetChapter}.`);
+    }
+
+    await writer.saveChapter(bookDir, repairedOutput, gp.numericalSystem, pipelineLang);
+    await writer.saveNewTruthFiles(bookDir, repairedOutput, pipelineLang);
+    await this.syncLegacyStructuredStateFromMarkdown(bookDir, targetChapter, repairedOutput);
+    await this.syncNarrativeMemoryIndex(bookId);
+    await this.state.snapshotState(bookId, targetChapter);
+    await this.syncCurrentStateFactHistory(bookId, targetChapter);
+
+    const baseStatus = resolveStateDegradedBaseStatus(targetMeta);
+    const degradedMetadata = parseStateDegradedReviewNote(targetMeta.reviewNote);
+    const injectedIssues = new Set(degradedMetadata?.injectedIssues ?? []);
+    index[targetIndex] = {
+      ...targetMeta,
+      status: baseStatus,
+      updatedAt: new Date().toISOString(),
+      auditIssues: targetMeta.auditIssues.filter((issue) => !injectedIssues.has(issue)),
+      reviewNote: undefined,
+    };
+    await this.state.saveChapterIndex(bookId, index);
+
+    const repairedPassesAudit = baseStatus !== "audit-failed";
+    return {
+      chapterNumber: targetChapter,
+      title: targetMeta.title,
+      wordCount: targetMeta.wordCount,
+      auditResult: {
+        passed: repairedPassesAudit,
+        issues: [],
+        summary: repairedPassesAudit ? "state repaired" : "state repaired but chapter still needs review",
+      },
+      revised: false,
+      status: baseStatus,
+      lengthWarnings: targetMeta.lengthWarnings,
+      lengthTelemetry: targetMeta.lengthTelemetry,
+      tokenUsage: targetMeta.tokenUsage,
+    };
+  }
+
   // ---------------------------------------------------------------------------
   // Import operations (style imitation + canon for spinoff)
   // ---------------------------------------------------------------------------
@@ -1587,9 +1645,38 @@ ${matrix}`,
     const canon = response.content + metaBlock;
 
     await writeFile(join(storyDir, "parent_canon.md"), canon, "utf-8");
+
+    // Also generate style guide from parent's chapter text if available
+    const parentChaptersDir = join(parentDir, "chapters");
+    const parentChapterText = await this.readParentChapterSample(parentChaptersDir);
+    if (parentChapterText.length >= 500) {
+      await this.tryGenerateStyleGuide(targetBookId, parentChapterText, parentBook.title);
+    }
+
     return canon;
   }
 
+  private async readParentChapterSample(chaptersDir: string): Promise<string> {
+    try {
+      const entries = await readdir(chaptersDir);
+      const mdFiles = entries
+        .filter((file) => file.endsWith(".md"))
+        .sort()
+        .slice(0, 5);
+      const chunks: string[] = [];
+      let totalLength = 0;
+      for (const file of mdFiles) {
+        if (totalLength >= 20000) break;
+        const content = await readFile(join(chaptersDir, file), "utf-8");
+        chunks.push(content);
+        totalLength += content.length;
+      }
+      return chunks.join("\n\n---\n\n");
+    } catch {
+      return "";
+    }
+  }
+
   // ---------------------------------------------------------------------------
   // Chapter import (for continuation writing from existing chapters)
   // ---------------------------------------------------------------------------
@@ -1636,6 +1723,16 @@ ${matrix}`,
         await this.resetImportReplayTruthFiles(bookDir, resolvedLanguage);
         await this.state.saveChapterIndex(input.bookId, []);
         await this.state.snapshotState(input.bookId, 0);
+
+        // Generate style guide from imported chapters
+        if (allText.length >= 500) {
+          log?.info(this.localize(resolvedLanguage, {
+            zh: "提取原文风格指纹...",
+            en: "Extracting source style fingerprint...",
+          }));
+          await this.tryGenerateStyleGuide(input.bookId, allText, book.title, resolvedLanguage);
+        }
+
         log?.info(this.localize(resolvedLanguage, {
           zh: "基础设定已生成。",
           en: "Foundation generated.",
@@ -1794,6 +1891,18 @@ ${matrix}`,
     };
   }
 
+  private async assertNoPendingStateRepair(bookId: string): Promise<void> {
+    const existingIndex = await this.state.loadChapterIndex(bookId);
+    const latestChapter = [...existingIndex].sort((left, right) => right.number - left.number)[0];
+    if (latestChapter?.status !== "state-degraded") {
+      return;
+    }
+
+    throw new Error(
+      `Latest chapter ${latestChapter.number} is state-degraded. Repair state or rewrite that chapter before continuing.`,
+    );
+  }
+
   // ---------------------------------------------------------------------------
   // Helpers
   // ---------------------------------------------------------------------------
@@ -2259,6 +2368,72 @@ ${matrix}`,
     };
   }
 
+  private async persistAuditDriftGuidance(params: {
+    readonly bookDir: string;
+    readonly chapterNumber: number;
+    readonly issues: ReadonlyArray<AuditIssue>;
+    readonly language: LengthLanguage;
+  }): Promise<void> {
+    const storyDir = join(params.bookDir, "story");
+    const driftPath = join(storyDir, "audit_drift.md");
+    const statePath = join(storyDir, "current_state.md");
+    const currentState = await readFile(statePath, "utf-8").catch(() => "");
+    const sanitizedState = this.stripAuditDriftCorrectionBlock(currentState).trimEnd();
+
+    if (sanitizedState !== currentState) {
+      await writeFile(statePath, sanitizedState, "utf-8");
+    }
+
+    if (params.issues.length === 0) {
+      await rm(driftPath, { force: true }).catch(() => undefined);
+      return;
+    }
+
+    const block = [
+      this.localize(params.language, {
+        zh: "# 审计纠偏",
+        en: "# Audit Drift",
+      }),
+      "",
+      this.localize(params.language, {
+        zh: "## 审计纠偏（自动生成，下一章写作前参照）",
+        en: "## Audit Drift Correction",
+      }),
+      "",
+      this.localize(params.language, {
+        zh: `> 第${params.chapterNumber}章审计发现以下问题，下一章写作时必须避免：`,
+        en: `> Chapter ${params.chapterNumber} audit found the following issues to avoid in the next chapter:`,
+      }),
+      ...params.issues.map((issue) => `> - [${issue.severity}] ${issue.category}: ${issue.description}`),
+      "",
+    ].join("\n");
+
+    await writeFile(driftPath, block, "utf-8");
+  }
+
+  private stripAuditDriftCorrectionBlock(currentState: string): string {
+    const headers = [
+      "## 审计纠偏（自动生成，下一章写作前参照）",
+      "## Audit Drift Correction",
+      "# 审计纠偏",
+      "# Audit Drift",
+    ];
+
+    let cutIndex = -1;
+    for (const header of headers) {
+      const index = currentState.indexOf(header);
+      if (index >= 0 && (cutIndex < 0 || index < cutIndex)) {
+        cutIndex = index;
+      }
+    }
+
+    if (cutIndex < 0) {
+      return currentState;
+    }
+
+    return currentState.slice(0, cutIndex).trimEnd();
+  }
+
   private logLengthWarnings(lengthWarnings: ReadonlyArray<string>): void {
     for (const warning of lengthWarnings) {
       this.config.logger?.warn(warning);
@@ -2348,6 +2523,9 @@ ${matrix}`,
       ...sensitiveResult.issues,
       ...longSpanFatigue.issues,
     ];
+    // revisionBlockingIssues excludes long-span-fatigue issues by
+    // construction (not by category name) so that an LLM-reported issue
+    // sharing a category label with a long-span issue is still counted.
     const revisionBlockingIssues: ReadonlyArray<AuditIssue> = [
       ...llmAudit.issues,
       ...aiTells.issues,
@@ -2417,7 +2595,7 @@ ${matrix}`,
       options?.reuseExistingIntentWhenContextMissing &&
       (!externalContext || externalContext.trim().length === 0)
     ) {
-      const persisted = await this.loadPersistedPlan(bookDir, chapterNumber);
+      const persisted = await loadPersistedPlan(bookDir, chapterNumber);
       if (persisted) return persisted;
     }
 
@@ -2430,100 +2608,6 @@ ${matrix}`,
     });
   }
 
-  private async loadPersistedPlan(bookDir: string, chapterNumber: number): Promise<PlanChapterOutput | null> {
-    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 is { type: string; resolution: string } => 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;
-    }
-  }
-
-  private parseIntentSections(markdown: string): Map<string, string[]> {
-    const sections = new Map<string, string[]>();
-    let current: string | null = 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;
-  }
-
-  private readIntentScalar(sections: Map<string, string[]>, name: string): string | undefined {
-    const lines = sections.get(name) ?? [];
-    const value = lines.map((line) => line.trim()).find((line) => line.length > 0);
-    return value && value !== "- none" ? value : undefined;
-  }
-
-  private readIntentList(sections: Map<string, string[]>, name: string): string[] {
-    return (sections.get(name) ?? [])
-      .map((line) => line.trim())
-      .filter((line) => line.startsWith("-") && line !== "- none")
-      .map((line) => line.replace(/^-\s*/, ""));
-  }
-
-  private isInvalidPersistedIntentScalar(value: string): boolean {
-    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)
-    );
-  }
-
-  private relativeToBookDir(bookDir: string, absolutePath: string): string {
-    return relative(bookDir, absolutePath).replaceAll("\\", "/");
-  }
-
   private async emitWebhook(
     event: WebhookEvent,
     bookId: string,

packages/core/src/state/manager.ts

@@ -208,11 +208,11 @@ export class StateManager {
     const durableChapter = await resolveDurableStoryProgress({
       bookDir: this.bookDir(bookId),
     });
-    await bootstrapStructuredStateFromMarkdown({
+    const runtimeState = await bootstrapStructuredStateFromMarkdown({
       bookDir: this.bookDir(bookId),
       fallbackChapter: durableChapter,
     });
-    return durableChapter + 1;
+    return Math.max(durableChapter, runtimeState.manifest.lastAppliedChapter) + 1;
   }
 
   async getPersistedChapterCount(bookId: string): Promise<number> {
@@ -388,6 +388,110 @@ export class StateManager {
     }
   }
 
+  /**
+   * Roll back state to the snapshot at `targetChapter`, removing all chapters
+   * after it and their associated files (chapter markdown, snapshots, runtime).
+   * Used by review reject to undo a bad chapter and everything that followed.
+   *
+   * Returns the list of chapter numbers that were discarded.
+   */
+  async rollbackToChapter(
+    bookId: string,
+    targetChapter: number,
+  ): Promise<ReadonlyArray<number>> {
+    const restored = await this.restoreState(bookId, targetChapter);
+    if (!restored) {
+      throw new Error(`Cannot restore snapshot for chapter ${targetChapter} in "${bookId}"`);
+    }
+
+    const bookDir = this.bookDir(bookId);
+    const chaptersDir = join(bookDir, "chapters");
+    const index = await this.loadChapterIndex(bookId);
+
+    const kept: ChapterMeta[] = [];
+    const discarded: number[] = [];
+
+    for (const entry of index) {
+      if (entry.number <= targetChapter) {
+        kept.push(entry);
+      } else {
+        discarded.push(entry.number);
+      }
+    }
+
+    // Delete chapter markdown files for discarded chapters
+    try {
+      const files = await readdir(chaptersDir);
+      for (const file of files) {
+        const match = file.match(/^(\d+)_.*\.md$/);
+        if (!match) continue;
+        const num = parseInt(match[1]!, 10);
+        if (num > targetChapter) {
+          await unlink(join(chaptersDir, file)).catch(() => {});
+        }
+      }
+    } catch {
+      // chapters directory missing
+    }
+
+    // Delete snapshots for discarded chapters
+    const snapshotsDir = join(bookDir, "story", "snapshots");
+    try {
+      const snapshots = await readdir(snapshotsDir);
+      for (const snap of snapshots) {
+        const num = parseInt(snap, 10);
+        if (Number.isFinite(num) && num > targetChapter) {
+          await rm(join(snapshotsDir, snap), { recursive: true, force: true });
+        }
+      }
+    } catch {
+      // snapshots directory missing
+    }
+
+    // Delete runtime artifacts for discarded chapters
+    const runtimeDir = join(bookDir, "story", "runtime");
+    try {
+      const runtimeFiles = await readdir(runtimeDir);
+      for (const file of runtimeFiles) {
+        const match = file.match(/^chapter-(\d+)\./);
+        if (!match) continue;
+        const num = parseInt(match[1]!, 10);
+        if (num > targetChapter) {
+          await unlink(join(runtimeDir, file)).catch(() => {});
+        }
+      }
+    } catch {
+      // runtime directory missing
+    }
+
+    // Also check story/drafts/ for discarded chapter files
+    const draftsDir = join(bookDir, "story", "drafts");
+    try {
+      const draftFiles = await readdir(draftsDir);
+      for (const file of draftFiles) {
+        const match = file.match(/^(\d+)_.*\.md$/);
+        if (!match) continue;
+        const num = parseInt(match[1]!, 10);
+        if (num > targetChapter) {
+          await unlink(join(draftsDir, file)).catch(() => {});
+        }
+      }
+    } catch {
+      // drafts directory missing
+    }
+
+    // Drop any persisted sqlite acceleration index so discarded chapters
+    // cannot leak back into retrieval after the markdown/state rollback.
+    await Promise.all([
+      rm(join(bookDir, "story", "memory.db"), { force: true }),
+      rm(join(bookDir, "story", "memory.db-shm"), { force: true }),
+      rm(join(bookDir, "story", "memory.db-wal"), { force: true }),
+    ]);
+
+    await this.saveChapterIndex(bookId, kept);
+    return discarded;
+  }
+
   private async writeIfMissing(path: string, content: string): Promise<void> {
     try {
       await stat(path);

packages/core/src/state/memory-db.ts

@@ -52,6 +52,7 @@ export interface StoredHook {
   readonly status: string;
   readonly lastAdvancedChapter: number;
   readonly expectedPayoff: string;
+  readonly payoffTiming?: string;
   readonly notes: string;
 }
 
@@ -99,6 +100,7 @@ export class MemoryDB {
         status TEXT NOT NULL DEFAULT 'open',
         last_advanced_chapter INTEGER NOT NULL DEFAULT 0,
         expected_payoff TEXT NOT NULL DEFAULT '',
+        payoff_timing TEXT NOT NULL DEFAULT '',
         notes TEXT NOT NULL DEFAULT ''
       );
 
@@ -108,6 +110,16 @@ export class MemoryDB {
       CREATE INDEX IF NOT EXISTS idx_hooks_status ON hooks(status);
       CREATE INDEX IF NOT EXISTS idx_hooks_last_advanced ON hooks(last_advanced_chapter);
     `);
+
+    this.ensureColumn("hooks", "payoff_timing", "TEXT NOT NULL DEFAULT ''");
+  }
+
+  private ensureColumn(table: string, column: string, definition: string): void {
+    try {
+      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+    } catch {
+      // Column already exists on existing databases.
+    }
   }
 
   // ---------------------------------------------------------------------------
@@ -289,8 +301,8 @@ export class MemoryDB {
 
   upsertHook(hook: StoredHook): void {
     this.db.prepare(
-      `INSERT OR REPLACE INTO hooks (hook_id, start_chapter, type, status, last_advanced_chapter, expected_payoff, notes)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      `INSERT OR REPLACE INTO hooks (hook_id, start_chapter, type, status, last_advanced_chapter, expected_payoff, payoff_timing, notes)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
     ).run(
       hook.hookId,
       hook.startChapter,
@@ -298,6 +310,7 @@ export class MemoryDB {
       hook.status,
       hook.lastAdvancedChapter,
       hook.expectedPayoff,
+      hook.payoffTiming ?? "",
       hook.notes,
     );
   }
@@ -318,6 +331,7 @@ export class MemoryDB {
          status,
          last_advanced_chapter AS lastAdvancedChapter,
          expected_payoff AS expectedPayoff,
+         payoff_timing AS payoffTiming,
          notes
        FROM hooks
        WHERE lower(status) NOT IN ('resolved', 'closed', '已回收', '已解决')

packages/core/src/state/runtime-state-store.ts

@@ -109,15 +109,16 @@ export async function loadNarrativeMemorySeed(bookDir: string): Promise<Narrativ
       mood: row.mood,
       chapterType: row.chapterType,
     })),
-    hooks: snapshot.hooks.hooks.map((hook) => ({
-      hookId: hook.hookId,
-      startChapter: hook.startChapter,
-      type: hook.type,
-      status: hook.status,
-      lastAdvancedChapter: hook.lastAdvancedChapter,
-      expectedPayoff: hook.expectedPayoff,
-      notes: hook.notes,
-    })),
+      hooks: snapshot.hooks.hooks.map((hook) => ({
+        hookId: hook.hookId,
+        startChapter: hook.startChapter,
+        type: hook.type,
+        status: hook.status,
+        lastAdvancedChapter: hook.lastAdvancedChapter,
+        expectedPayoff: hook.expectedPayoff,
+        payoffTiming: hook.payoffTiming,
+        notes: hook.notes,
+      })),
   };
 }
 

packages/core/src/state/state-bootstrap.ts

@@ -10,7 +10,24 @@ import {
   type HookStatus,
   type StateManifest,
 } from "../models/runtime-state.js";
-import type { Fact, StoredHook, StoredSummary } from "./memory-db.js";
+import type { Fact, StoredHook } from "./memory-db.js";
+import { normalizeHookPayoffTiming } from "../utils/hook-lifecycle.js";
+import {
+  inferFactSubject,
+  isCurrentChapterLabel,
+  isStateTableHeaderRow,
+  normalizeHookId,
+  parseChapterSummariesMarkdown,
+  parseInteger,
+  parseMarkdownTableRows,
+} from "../utils/story-markdown.js";
+
+export {
+  normalizeHookId,
+  parseChapterSummariesMarkdown,
+  parseCurrentStateFacts,
+  parsePendingHooksMarkdown,
+} from "../utils/story-markdown.js";
 
 export interface BootstrapStructuredStateResult {
   readonly createdFiles: ReadonlyArray<string>;
@@ -71,7 +88,10 @@ export async function bootstrapStructuredStateFromMarkdown(params: {
     warnings,
     bootstrapState: markdownState.currentState,
   });
-  const derivedProgress = markdownState.durableStoryProgress;
+  const derivedProgress = Math.max(
+    markdownState.durableStoryProgress,
+    currentState.chapter,
+  );
   if ((existingManifest?.lastAppliedChapter ?? 0) > derivedProgress) {
     appendWarning(
       warnings,
@@ -131,7 +151,10 @@ export async function rewriteStructuredStateFromMarkdown(params: {
   const manifest = StateManifestSchema.parse({
     schemaVersion: 2,
     language,
-    lastAppliedChapter: markdownState.durableStoryProgress,
+    lastAppliedChapter: Math.max(
+      markdownState.durableStoryProgress,
+      currentState.chapter,
+    ),
     projectionVersion: existingManifest?.projectionVersion ?? 1,
     migrationWarnings: uniqueStrings([
       ...(existingManifest?.migrationWarnings ?? []),
@@ -153,64 +176,6 @@ export async function rewriteStructuredStateFromMarkdown(params: {
   };
 }
 
-export function parseChapterSummariesMarkdown(markdown: string): StoredSummary[] {
-  const rows = parseMarkdownTableRows(markdown)
-    .filter((row) => /^\d+$/.test(row[0] ?? ""));
-
-  return rows.map((row) => ({
-    chapter: parseInt(row[0]!, 10),
-    title: row[1] ?? "",
-    characters: row[2] ?? "",
-    events: row[3] ?? "",
-    stateChanges: row[4] ?? "",
-    hookActivity: row[5] ?? "",
-    mood: row[6] ?? "",
-    chapterType: row[7] ?? "",
-  }));
-}
-
-export function parsePendingHooksMarkdown(markdown: string): StoredHook[] {
-  const tableRows = parseMarkdownTableRows(markdown)
-    .filter((row) => (row[0] ?? "").toLowerCase() !== "hook_id");
-
-  if (tableRows.length > 0) {
-    return tableRows
-      .filter((row) => normalizeHookId(row[0]).length > 0)
-      .map((row) => ({
-        hookId: normalizeHookId(row[0]),
-        startChapter: parseStrictInteger(row[1]),
-        type: row[2] ?? "",
-        status: row[3] ?? "open",
-        lastAdvancedChapter: parseStrictInteger(row[4]),
-        expectedPayoff: row[5] ?? "",
-        notes: row[6] ?? "",
-      }));
-  }
-
-  return markdown
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line.startsWith("-"))
-    .map((line) => line.replace(/^-\s*/, ""))
-    .filter(Boolean)
-    .map((line, index) => ({
-      hookId: `hook-${index + 1}`,
-      startChapter: 0,
-      type: "unspecified",
-      status: "open",
-      lastAdvancedChapter: 0,
-      expectedPayoff: "",
-      notes: line,
-    }));
-}
-
-export function parseCurrentStateFacts(
-  markdown: string,
-  fallbackChapter: number,
-): Fact[] {
-  return parseCurrentStateStateMarkdown(markdown, fallbackChapter, []).facts;
-}
-
 async function loadOrBootstrapCurrentState(params: {
   readonly storyDir: string;
   readonly statePath: string;
@@ -323,6 +288,7 @@ function parsePendingHooksStateMarkdown(markdown: string, warnings: string[]) {
         .filter((row) => normalizeHookId(row[0]).length > 0)
         .map((row) => {
           const hookId = normalizeHookId(row[0]);
+          const legacyShape = row.length < 8;
           return {
             hookId,
             startChapter: parseStrictIntegerWithWarning(row[1], warnings, `${hookId}:startChapter`),
@@ -330,7 +296,8 @@ function parsePendingHooksStateMarkdown(markdown: string, warnings: string[]) {
             status: normalizeHookStatus(row[3], warnings, hookId),
             lastAdvancedChapter: parseStrictIntegerWithWarning(row[4], warnings, `${hookId}:lastAdvancedChapter`),
             expectedPayoff: row[5] ?? "",
-            notes: row[6] ?? "",
+            payoffTiming: legacyShape ? undefined : normalizeHookPayoffTiming(row[6]),
+            notes: legacyShape ? (row[6] ?? "") : (row[7] ?? ""),
           };
         }),
     });
@@ -350,6 +317,7 @@ function parsePendingHooksStateMarkdown(markdown: string, warnings: string[]) {
         status: "open" as HookStatus,
         lastAdvancedChapter: 0,
         expectedPayoff: "",
+        payoffTiming: undefined,
         notes: line,
       })),
   });
@@ -562,24 +530,6 @@ export function resolveContiguousChapterPrefix(chapterNumbers: ReadonlyArray<num
   return contiguousChapter;
 }
 
-export function normalizeHookId(value: string | undefined): string {
-  let normalized = (value ?? "").trim();
-  let previous = "";
-  while (normalized && normalized !== previous) {
-    previous = normalized;
-    normalized = normalized
-      .replace(/^\[(.+?)\]\([^)]+\)$/u, "$1")
-      .replace(/^\*\*(.+)\*\*$/u, "$1")
-      .replace(/^__(.+)__$/u, "$1")
-      .replace(/^\*(.+)\*$/u, "$1")
-      .replace(/^_(.+)_$/u, "$1")
-      .replace(/^`(.+)`$/u, "$1")
-      .replace(/^~~(.+)~~$/u, "$1")
-      .trim();
-  }
-  return normalized;
-}
-
 function normalizeHookStatus(value: string | undefined, warnings: string[], hookId: string): HookStatus {
   const normalized = (value ?? "").trim().toLowerCase();
   if (!normalized) return "open";
@@ -616,46 +566,6 @@ function parseIntegerWithFallback(
   return parseInt(match[0], 10);
 }
 
-function parseMarkdownTableRows(markdown: string): string[][] {
-  return markdown
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line.startsWith("|"))
-    .filter((line) => !line.includes("---"))
-    .map((line) => line.split("|").slice(1, -1).map((cell) => cell.trim()))
-    .filter((cells) => cells.some(Boolean));
-}
-
-function isStateTableHeaderRow(row: ReadonlyArray<string>): boolean {
-  const first = (row[0] ?? "").trim().toLowerCase();
-  const second = (row[1] ?? "").trim().toLowerCase();
-  return (first === "字段" && second === "值") || (first === "field" && second === "value");
-}
-
-function isCurrentChapterLabel(label: string): boolean {
-  return /^(当前章节|current chapter)$/i.test(label.trim());
-}
-
-function inferFactSubject(label: string): string {
-  if (/^(当前位置|current location)$/i.test(label)) return "protagonist";
-  if (/^(主角状态|protagonist state)$/i.test(label)) return "protagonist";
-  if (/^(当前目标|current goal)$/i.test(label)) return "protagonist";
-  if (/^(当前限制|current constraint)$/i.test(label)) return "protagonist";
-  if (/^(当前敌我|current alliances|current relationships)$/i.test(label)) return "protagonist";
-  if (/^(当前冲突|current conflict)$/i.test(label)) return "protagonist";
-  return "current_state";
-}
-
-function parseInteger(value: string | undefined): number {
-  if (!value) return 0;
-  const match = value.match(/\d+/);
-  return match ? parseInt(match[0], 10) : 0;
-}
-
-function parseStrictInteger(value: string | undefined): number {
-  return parseStrictIntegerCell(value) ?? 0;
-}
-
 function parseStrictIntegerCell(value: string | undefined): number | null {
   if (!value) return null;
   const normalized = normalizeHookId(value);
@@ -672,6 +582,7 @@ function normalizeExplicitChapter(value: number | undefined): number {
   return value;
 }
 
+
 function appendWarning(warnings: string[], warning: string): void {
   if (!warnings.includes(warning)) {
     warnings.push(warning);

packages/core/src/state/state-projections.ts

@@ -3,6 +3,10 @@ import type {
   CurrentStateState,
   HooksState,
 } from "../models/runtime-state.js";
+import {
+  localizeHookPayoffTiming,
+  resolveHookPayoffTiming,
+} from "../utils/hook-lifecycle.js";
 
 export function renderHooksProjection(
   state: HooksState,
@@ -11,12 +15,12 @@ export function renderHooksProjection(
   const title = language === "en" ? "# Pending Hooks" : "# 伏笔池";
   const headers = language === "en"
     ? [
-      "| hook_id | start_chapter | type | status | last_advanced_chapter | expected_payoff | notes |",
-      "| --- | --- | --- | --- | --- | --- | --- |",
+      "| hook_id | start_chapter | type | status | last_advanced_chapter | expected_payoff | payoff_timing | notes |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
     ]
     : [
-      "| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 备注 |",
-      "| --- | --- | --- | --- | --- | --- | --- |",
+      "| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 回收节奏 | 备注 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
     ];
 
   const rows = [...state.hooks]
@@ -33,6 +37,7 @@ export function renderHooksProjection(
         hook.status,
         hook.lastAdvancedChapter,
         hook.expectedPayoff,
+        localizeHookPayoffTiming(resolveHookPayoffTiming(hook), language),
         hook.notes,
       ].map(escapeTableCell).join(" | ")
     } |`);

packages/core/src/state/state-reducer.ts

@@ -12,6 +12,7 @@ import {
   type StateManifest,
 } from "../models/runtime-state.js";
 import { evaluateHookAdmission } from "../utils/hook-governance.js";
+import { resolveHookPayoffTiming } from "../utils/hook-lifecycle.js";
 import { validateRuntimeState } from "./state-validator.js";
 
 export interface RuntimeStateSnapshot {
@@ -153,6 +154,11 @@ function mergeDuplicateHookFamily(existing: HookRecord, incoming: HookRecord): H
         : existing.status,
     lastAdvancedChapter: advanced,
     expectedPayoff,
+    payoffTiming: resolveHookPayoffTiming({
+      payoffTiming: incoming.payoffTiming ?? existing.payoffTiming,
+      expectedPayoff,
+      notes,
+    }),
     notes,
   };
 }

packages/core/src/utils/cadence-policy.ts

@@ -0,0 +1,46 @@
+export const CADENCE_WINDOW_DEFAULTS = {
+  summaryLookback: 4,
+  englishVarianceLookback: 24,
+  recentBoundaryPatternBodies: 2,
+} as const;
+
+export const CADENCE_PRESSURE_THRESHOLDS = {
+  scene: {
+    highCount: 3,
+    mediumCount: 2,
+    mediumWindowFloor: 4,
+  },
+  mood: {
+    highCount: 3,
+    mediumCount: 2,
+    mediumWindowFloor: 4,
+  },
+  title: {
+    minimumRepeatedCount: 2,
+    highCount: 3,
+    mediumCount: 2,
+    mediumWindowFloor: 4,
+  },
+} as const;
+
+export const LONG_SPAN_FATIGUE_THRESHOLDS = {
+  boundarySimilarityFloor: 0.72,
+  boundarySentenceMinLength: 18,
+  boundaryPatternMinBodies: 3,
+} as const;
+
+export function resolveCadencePressure(params: {
+  readonly count: number;
+  readonly total: number;
+  readonly highThreshold: number;
+  readonly mediumThreshold: number;
+  readonly mediumWindowFloor: number;
+}): "medium" | "high" | undefined {
+  if (params.count >= params.highThreshold) {
+    return "high";
+  }
+  if (params.count >= params.mediumThreshold && params.total >= params.mediumWindowFloor) {
+    return "medium";
+  }
+  return undefined;
+}

packages/core/src/utils/chapter-cadence.ts

@@ -0,0 +1,209 @@
+import {
+  CADENCE_PRESSURE_THRESHOLDS,
+  CADENCE_WINDOW_DEFAULTS,
+  resolveCadencePressure,
+} from "./cadence-policy.js";
+
+export interface CadenceSummaryRow {
+  readonly chapter: number;
+  readonly title: string;
+  readonly mood: string;
+  readonly chapterType: string;
+}
+
+export interface SceneCadencePressure {
+  readonly pressure: "medium" | "high";
+  readonly repeatedType: string;
+  readonly streak: number;
+}
+
+export interface MoodCadencePressure {
+  readonly pressure: "medium" | "high";
+  readonly highTensionStreak: number;
+  readonly recentMoods: ReadonlyArray<string>;
+}
+
+export interface TitleCadencePressure {
+  readonly pressure: "medium" | "high";
+  readonly repeatedToken: string;
+  readonly count: number;
+  readonly recentTitles: ReadonlyArray<string>;
+}
+
+export interface ChapterCadenceAnalysis {
+  readonly scenePressure?: SceneCadencePressure;
+  readonly moodPressure?: MoodCadencePressure;
+  readonly titlePressure?: TitleCadencePressure;
+}
+
+export const DEFAULT_CHAPTER_CADENCE_WINDOW = CADENCE_WINDOW_DEFAULTS.summaryLookback;
+
+const HIGH_TENSION_KEYWORDS = [
+  "紧张", "冷硬", "压抑", "逼仄", "肃杀", "沉重", "凝重",
+  "冷峻", "压迫", "阴沉", "焦灼", "窒息", "凛冽", "锋利",
+  "克制", "危机", "对峙", "绷紧", "僵持", "杀意",
+  "tense", "cold", "oppressive", "grim", "ominous", "dark",
+  "bleak", "hostile", "threatening", "heavy", "suffocating",
+];
+
+const ENGLISH_STOP_WORDS = new Set([
+  "the", "and", "with", "from", "into", "after", "before",
+  "over", "under", "this", "that", "your", "their",
+]);
+
+export function analyzeChapterCadence(params: {
+  readonly rows: ReadonlyArray<CadenceSummaryRow>;
+  readonly language: "zh" | "en";
+}): ChapterCadenceAnalysis {
+  const recentRows = [...params.rows]
+    .sort((left, right) => left.chapter - right.chapter)
+    .slice(-CADENCE_WINDOW_DEFAULTS.summaryLookback);
+
+  return {
+    scenePressure: analyzeScenePressure(recentRows),
+    moodPressure: analyzeMoodPressure(recentRows),
+    titlePressure: analyzeTitlePressure(recentRows, params.language),
+  };
+}
+
+export function isHighTensionMood(mood: string): boolean {
+  const lowerMood = mood.toLowerCase();
+  return HIGH_TENSION_KEYWORDS.some((keyword) => lowerMood.includes(keyword));
+}
+
+function analyzeScenePressure(
+  rows: ReadonlyArray<CadenceSummaryRow>,
+): SceneCadencePressure | undefined {
+  const types = rows
+    .map((row) => row.chapterType.trim())
+    .filter((value) => isMeaningfulValue(value));
+  if (types.length < 2) {
+    return undefined;
+  }
+
+  const repeatedType = types.at(-1);
+  if (!repeatedType) {
+    return undefined;
+  }
+
+  let streak = 0;
+  for (const type of [...types].reverse()) {
+    if (type.toLowerCase() !== repeatedType.toLowerCase()) {
+      break;
+    }
+    streak += 1;
+  }
+
+  const pressure = resolveCadencePressure({
+    count: streak,
+    total: types.length,
+    highThreshold: CADENCE_PRESSURE_THRESHOLDS.scene.highCount,
+    mediumThreshold: CADENCE_PRESSURE_THRESHOLDS.scene.mediumCount,
+    mediumWindowFloor: CADENCE_PRESSURE_THRESHOLDS.scene.mediumWindowFloor,
+  });
+  if (pressure) {
+    return { pressure, repeatedType, streak };
+  }
+  return undefined;
+}
+
+function analyzeMoodPressure(
+  rows: ReadonlyArray<CadenceSummaryRow>,
+): MoodCadencePressure | undefined {
+  const moods = rows
+    .map((row) => row.mood.trim())
+    .filter((value) => isMeaningfulValue(value));
+  if (moods.length < 2) {
+    return undefined;
+  }
+
+  const recentMoods: string[] = [];
+  let highTensionStreak = 0;
+  for (const mood of [...moods].reverse()) {
+    if (!isHighTensionMood(mood)) {
+      break;
+    }
+    recentMoods.unshift(mood);
+    highTensionStreak += 1;
+  }
+
+  const pressure = resolveCadencePressure({
+    count: highTensionStreak,
+    total: moods.length,
+    highThreshold: CADENCE_PRESSURE_THRESHOLDS.mood.highCount,
+    mediumThreshold: CADENCE_PRESSURE_THRESHOLDS.mood.mediumCount,
+    mediumWindowFloor: CADENCE_PRESSURE_THRESHOLDS.mood.mediumWindowFloor,
+  });
+  if (pressure) {
+    return { pressure, highTensionStreak, recentMoods };
+  }
+  return undefined;
+}
+
+function analyzeTitlePressure(
+  rows: ReadonlyArray<CadenceSummaryRow>,
+  language: "zh" | "en",
+): TitleCadencePressure | undefined {
+  const titles = rows
+    .map((row) => row.title.trim())
+    .filter((value) => isMeaningfulValue(value));
+  if (titles.length < 2) {
+    return undefined;
+  }
+
+  const counts = new Map<string, number>();
+  for (const title of titles) {
+    for (const token of extractTitleTokens(title, language)) {
+      counts.set(token, (counts.get(token) ?? 0) + 1);
+    }
+  }
+
+  const repeated = [...counts.entries()]
+    .sort((left, right) => right[1] - left[1] || right[0].length - left[0].length || left[0].localeCompare(right[0]))
+    .find((entry) => entry[1] >= CADENCE_PRESSURE_THRESHOLDS.title.minimumRepeatedCount);
+  if (!repeated) {
+    return undefined;
+  }
+
+  const [repeatedToken, count] = repeated;
+  const pressure = resolveCadencePressure({
+    count,
+    total: titles.length,
+    highThreshold: CADENCE_PRESSURE_THRESHOLDS.title.highCount,
+    mediumThreshold: CADENCE_PRESSURE_THRESHOLDS.title.mediumCount,
+    mediumWindowFloor: CADENCE_PRESSURE_THRESHOLDS.title.mediumWindowFloor,
+  });
+  if (pressure) {
+    return { pressure, repeatedToken, count, recentTitles: titles };
+  }
+  return undefined;
+}
+
+function extractTitleTokens(title: string, language: "zh" | "en"): string[] {
+  if (language === "en") {
+    const words = title.match(/[a-z]{4,}/gi) ?? [];
+    return [...new Set(
+      words
+        .map((word) => word.toLowerCase())
+        .filter((word) => !ENGLISH_STOP_WORDS.has(word)),
+    )];
+  }
+
+  const segments = title.match(/[\u4e00-\u9fff]{2,}/g) ?? [];
+  const tokens = new Set<string>();
+  for (const segment of segments) {
+    for (let size = 2; size <= Math.min(4, segment.length); size += 1) {
+      for (let index = 0; index <= segment.length - size; index += 1) {
+        tokens.add(segment.slice(index, index + size));
+      }
+    }
+  }
+
+  return [...tokens];
+}
+
+function isMeaningfulValue(value: string): boolean {
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) return false;
+  return normalized !== "none" && normalized !== "(none)" && normalized !== "无";
+}

packages/core/src/utils/context-filter.ts

@@ -5,6 +5,8 @@
  * Every filter falls back to the full input if filtering would empty it.
  */
 
+import { DEFAULT_CHAPTER_CADENCE_WINDOW } from "./chapter-cadence.js";
+
 /** Filter pending_hooks: remove resolved/closed hooks. */
 export function filterHooks(hooks: string): string {
   if (!hooks || hooks === "(文件尚未创建)") return hooks;
@@ -15,7 +17,11 @@ export function filterHooks(hooks: string): string {
 }
 
 /** Filter chapter_summaries: keep only the most recent N chapters. */
-export function filterSummaries(summaries: string, currentChapter: number, keepRecent = 5): string {
+export function filterSummaries(
+  summaries: string,
+  currentChapter: number,
+  keepRecent = DEFAULT_CHAPTER_CADENCE_WINDOW,
+): string {
   if (!summaries || summaries === "(文件尚未创建)") return summaries;
   return filterTableRows(summaries, (row) => {
     const match = row.match(/\|\s*(\d+)\s*\|/);
@@ -34,7 +40,11 @@ export function filterSubplots(board: string): string {
 }
 
 /** Filter emotional_arcs: keep only the most recent N chapters. */
-export function filterEmotionalArcs(arcs: string, currentChapter: number, keepRecent = 5): string {
+export function filterEmotionalArcs(
+  arcs: string,
+  currentChapter: number,
+  keepRecent = DEFAULT_CHAPTER_CADENCE_WINDOW,
+): string {
   if (!arcs || arcs === "(文件尚未创建)") return arcs;
   return filterTableRows(arcs, (row) => {
     const match = row.match(/\|\s*(\d+)\s*\|/);

packages/core/src/utils/governed-context.ts

@@ -4,22 +4,45 @@ export function buildGovernedMemoryEvidenceBlocks(
   contextPackage: ContextPackage,
   language?: "zh" | "en",
 ): {
+  readonly hookDebtBlock?: string;
   readonly hooksBlock?: string;
   readonly summariesBlock?: string;
   readonly volumeSummariesBlock?: string;
+  readonly titleHistoryBlock?: string;
+  readonly moodTrailBlock?: string;
+  readonly canonBlock?: string;
 } {
   const resolvedLanguage = language ?? "zh";
   const hookEntries = contextPackage.selectedContext.filter((entry) =>
     entry.source.startsWith("story/pending_hooks.md#"),
   );
+  const hookDebtEntries = contextPackage.selectedContext.filter((entry) =>
+    entry.source.startsWith("runtime/hook_debt#"),
+  );
   const summaryEntries = contextPackage.selectedContext.filter((entry) =>
     entry.source.startsWith("story/chapter_summaries.md#"),
   );
   const volumeSummaryEntries = contextPackage.selectedContext.filter((entry) =>
     entry.source.startsWith("story/volume_summaries.md#"),
   );
+  const titleHistoryEntries = contextPackage.selectedContext.filter((entry) =>
+    entry.source === "story/chapter_summaries.md#recent_titles",
+  );
+  const moodTrailEntries = contextPackage.selectedContext.filter((entry) =>
+    entry.source === "story/chapter_summaries.md#recent_mood_type_trail",
+  );
+  const canonEntries = contextPackage.selectedContext.filter((entry) =>
+    entry.source === "story/parent_canon.md"
+    || entry.source === "story/fanfic_canon.md",
+  );
 
   return {
+    hookDebtBlock: hookDebtEntries.length > 0
+      ? renderHookDebtBlock(
+          resolvedLanguage === "en" ? "Hook Debt Briefs" : "Hook Debt Briefs",
+          hookDebtEntries,
+        )
+      : undefined,
     hooksBlock: hookEntries.length > 0
       ? renderEvidenceBlock(
           resolvedLanguage === "en" ? "Selected Hook Evidence" : "已选伏笔证据",
@@ -38,9 +61,34 @@ export function buildGovernedMemoryEvidenceBlocks(
           volumeSummaryEntries,
         )
       : undefined,
+    titleHistoryBlock: titleHistoryEntries.length > 0
+      ? renderEvidenceBlock(
+          resolvedLanguage === "en" ? "Recent Title History" : "近期标题历史",
+          titleHistoryEntries,
+        )
+      : undefined,
+    moodTrailBlock: moodTrailEntries.length > 0
+      ? renderEvidenceBlock(
+          resolvedLanguage === "en" ? "Recent Mood / Chapter Type Trail" : "近期情绪/章节类型轨迹",
+          moodTrailEntries,
+        )
+      : undefined,
+    canonBlock: canonEntries.length > 0
+      ? renderEvidenceBlock(
+          resolvedLanguage === "en" ? "Canon Evidence" : "正典约束证据",
+          canonEntries,
+        )
+      : undefined,
   };
 }
 
+function renderHookDebtBlock(
+  heading: string,
+  entries: ContextPackage["selectedContext"],
+): string {
+  return `\n## ${heading}\n${entries.map((entry) => `- ${entry.excerpt ?? entry.reason}`).join("\n")}\n`;
+}
+
 function renderEvidenceBlock(
   heading: string,
   entries: ContextPackage["selectedContext"],

packages/core/src/utils/governed-working-set.ts

@@ -1,9 +1,11 @@
 import type { ContextPackage } from "../models/input-governance.js";
 import {
-  isHookWithinChapterWindow,
   parsePendingHooksMarkdown,
   renderHookSnapshot,
 } from "./memory-retrieval.js";
+import {
+  isHookWithinChapterWindow,
+} from "./hook-agenda.js";
 
 export function buildGovernedHookWorkingSet(params: {
   readonly hooksMarkdown: string;
@@ -33,7 +35,11 @@ export function buildGovernedHookWorkingSet(params: {
   const workingSet = hooks.filter((hook) =>
     selectedIds.has(hook.hookId)
       || agendaIds.has(hook.hookId)
-      || isHookWithinChapterWindow(hook, params.chapterNumber, params.keepRecent ?? 5),
+      || isHookWithinChapterWindow(
+          hook,
+          params.chapterNumber,
+          params.keepRecent ?? 5,
+        ),
   );
 
   if (workingSet.length === 0 || workingSet.length >= hooks.length) {

packages/core/src/utils/hook-agenda.ts

@@ -0,0 +1,134 @@
+import type { HookAgenda } from "../models/input-governance.js";
+import type { HookRecord, HookStatus } from "../models/runtime-state.js";
+import type { StoredHook } from "../state/memory-db.js";
+import { resolveHookPayoffTiming } from "./hook-lifecycle.js";
+
+export const DEFAULT_HOOK_LOOKAHEAD_CHAPTERS = 3;
+
+/**
+ * Build the hook agenda using simple stalest-first sorting.
+ * No lifecycle pressure formulas — just pick the hooks that have been
+ * dormant the longest and the ones that are ripe for resolution.
+ */
+export function buildPlannerHookAgenda(params: {
+  readonly hooks: ReadonlyArray<StoredHook>;
+  readonly chapterNumber: number;
+  readonly targetChapters?: number;
+  readonly language?: "zh" | "en";
+  readonly maxMustAdvance?: number;
+  readonly maxEligibleResolve?: number;
+  readonly maxStaleDebt?: number;
+}): HookAgenda {
+  const agendaHooks = params.hooks
+    .map(normalizeStoredHook)
+    .filter((hook) => !isFuturePlannedHook(hook, params.chapterNumber, 0))
+    .filter((hook) => hook.status !== "resolved" && hook.status !== "deferred");
+
+  // mustAdvance: stalest first (lowest lastAdvancedChapter)
+  const mustAdvanceHooks = agendaHooks
+    .slice()
+    .sort((left, right) => (
+      left.lastAdvancedChapter - right.lastAdvancedChapter
+      || left.startChapter - right.startChapter
+      || left.hookId.localeCompare(right.hookId)
+    ))
+    .slice(0, params.maxMustAdvance ?? 2);
+
+  // staleDebt: hooks not advanced for 10+ chapters
+  const staleThreshold = params.chapterNumber - 10;
+  const staleDebtHooks = agendaHooks
+    .filter((hook) => {
+      const lastTouch = Math.max(hook.startChapter, hook.lastAdvancedChapter);
+      return lastTouch > 0 && lastTouch <= staleThreshold;
+    })
+    .sort((left, right) => (
+      left.lastAdvancedChapter - right.lastAdvancedChapter
+      || left.startChapter - right.startChapter
+      || left.hookId.localeCompare(right.hookId)
+    ))
+    .slice(0, params.maxStaleDebt ?? 2);
+
+  // eligibleResolve: started 3+ chapters ago AND recently advanced
+  const eligibleResolveHooks = agendaHooks
+    .filter((hook) => hook.startChapter <= params.chapterNumber - 3)
+    .filter((hook) => hook.lastAdvancedChapter >= params.chapterNumber - 2)
+    .sort((left, right) => (
+      left.startChapter - right.startChapter
+      || right.lastAdvancedChapter - left.lastAdvancedChapter
+      || left.hookId.localeCompare(right.hookId)
+    ))
+    .slice(0, params.maxEligibleResolve ?? 1);
+
+  const avoidNewHookFamilies = [...new Set([
+    ...staleDebtHooks.map((hook) => hook.type.trim()).filter(Boolean),
+    ...mustAdvanceHooks.map((hook) => hook.type.trim()).filter(Boolean),
+    ...eligibleResolveHooks.map((hook) => hook.type.trim()).filter(Boolean),
+  ])].slice(0, 3);
+
+  return {
+    pressureMap: [],
+    mustAdvance: mustAdvanceHooks.map((hook) => hook.hookId),
+    eligibleResolve: eligibleResolveHooks.map((hook) => hook.hookId),
+    staleDebt: staleDebtHooks.map((hook) => hook.hookId),
+    avoidNewHookFamilies,
+  };
+}
+
+function normalizeStoredHook(hook: StoredHook): HookRecord {
+  return {
+    hookId: hook.hookId,
+    startChapter: Math.max(0, hook.startChapter),
+    type: hook.type,
+    status: normalizeStoredHookStatus(hook.status),
+    lastAdvancedChapter: Math.max(0, hook.lastAdvancedChapter),
+    expectedPayoff: hook.expectedPayoff,
+    payoffTiming: resolveHookPayoffTiming(hook),
+    notes: hook.notes,
+  };
+}
+
+function normalizeStoredHookStatus(status: string): HookStatus {
+  if (/^(resolved|closed|done|已回收|已解决)$/i.test(status.trim())) return "resolved";
+  if (/^(deferred|paused|hold|延后|延期|搁置|暂缓)$/i.test(status.trim())) return "deferred";
+  if (/^(progressing|advanced|重大推进|持续推进)$/i.test(status.trim())) return "progressing";
+  return "open";
+}
+
+export function filterActiveHooks(hooks: ReadonlyArray<StoredHook>): StoredHook[] {
+  return hooks.filter((hook) => normalizeStoredHookStatus(hook.status) !== "resolved");
+}
+
+export function isFuturePlannedHook(
+  hook: StoredHook,
+  chapterNumber: number,
+  lookahead: number = DEFAULT_HOOK_LOOKAHEAD_CHAPTERS,
+): boolean {
+  return hook.lastAdvancedChapter <= 0 && hook.startChapter > chapterNumber + lookahead;
+}
+
+export function isHookWithinChapterWindow(
+  hook: StoredHook,
+  chapterNumber: number,
+  recentWindow: number = 5,
+  lookahead: number = DEFAULT_HOOK_LOOKAHEAD_CHAPTERS,
+): boolean {
+  const recentCutoff = Math.max(0, chapterNumber - recentWindow);
+
+  if (hook.lastAdvancedChapter > 0 && hook.lastAdvancedChapter >= recentCutoff) {
+    return true;
+  }
+
+  if (hook.lastAdvancedChapter > 0) {
+    return false;
+  }
+
+  if (hook.startChapter <= 0) {
+    return true;
+  }
+
+  if (hook.startChapter >= recentCutoff && hook.startChapter <= chapterNumber) {
+    return true;
+  }
+
+  return hook.startChapter > chapterNumber && hook.startChapter <= chapterNumber + lookahead;
+}

packages/core/src/utils/hook-arbiter.ts

@@ -5,6 +5,7 @@ import {
   type RuntimeStateDelta,
 } from "../models/runtime-state.js";
 import { evaluateHookAdmission } from "./hook-governance.js";
+import { resolveHookPayoffTiming } from "./hook-lifecycle.js";
 
 export interface HookArbiterDecision {
   readonly action: "created" | "mapped" | "mentioned" | "rejected";
@@ -154,6 +155,11 @@ function mergeCandidateIntoExistingHook(
     status: existing.status === "resolved" ? "resolved" : "progressing",
     lastAdvancedChapter: Math.max(existing.lastAdvancedChapter, chapter),
     expectedPayoff: preferRicherText(existing.expectedPayoff, candidate.expectedPayoff),
+    payoffTiming: resolveHookPayoffTiming({
+      payoffTiming: candidate.payoffTiming ?? existing.payoffTiming,
+      expectedPayoff: preferRicherText(existing.expectedPayoff, candidate.expectedPayoff),
+      notes: preferRicherText(existing.notes, candidate.notes),
+    }),
     notes: preferRicherText(existing.notes, candidate.notes),
   };
 }
@@ -170,6 +176,7 @@ function createCanonicalHook(params: {
     status: "open",
     lastAdvancedChapter: params.chapter,
     expectedPayoff: params.candidate.expectedPayoff.trim(),
+    payoffTiming: resolveHookPayoffTiming(params.candidate),
     notes: params.candidate.notes.trim(),
   };
 }

packages/core/src/utils/hook-governance.ts

@@ -1,10 +1,12 @@
 import type { HookRecord, RuntimeStateDelta } from "../models/runtime-state.js";
+import { describeHookLifecycle } from "./hook-lifecycle.js";
 
 export type HookDisposition = "none" | "mention" | "advance" | "resolve" | "defer";
 
 export interface HookAdmissionCandidate {
   readonly type: string;
   readonly expectedPayoff?: string;
+  readonly payoffTiming?: string;
   readonly notes?: string;
 }
 
@@ -17,15 +19,30 @@ export interface HookAdmissionDecision {
 export function collectStaleHookDebt(params: {
   readonly hooks: ReadonlyArray<HookRecord>;
   readonly chapterNumber: number;
+  readonly targetChapters?: number;
   readonly staleAfterChapters?: number;
 }): HookRecord[] {
-  const staleAfterChapters = params.staleAfterChapters ?? 10;
-  const staleCutoff = params.chapterNumber - staleAfterChapters;
-
   return params.hooks
     .filter((hook) => hook.status !== "resolved" && hook.status !== "deferred")
     .filter((hook) => hook.startChapter <= params.chapterNumber)
-    .filter((hook) => hook.lastAdvancedChapter <= staleCutoff)
+    .filter((hook) => {
+      const lifecycle = describeHookLifecycle({
+        payoffTiming: hook.payoffTiming,
+        expectedPayoff: hook.expectedPayoff,
+        notes: hook.notes,
+        startChapter: hook.startChapter,
+        lastAdvancedChapter: hook.lastAdvancedChapter,
+        status: hook.status,
+        chapterNumber: params.chapterNumber,
+        targetChapters: params.targetChapters,
+      });
+
+      if (params.staleAfterChapters !== undefined) {
+        return hook.lastAdvancedChapter <= params.chapterNumber - params.staleAfterChapters;
+      }
+
+      return lifecycle.stale || lifecycle.overdue;
+    })
     .sort((left, right) => (
       left.lastAdvancedChapter - right.lastAdvancedChapter
       || left.startChapter - right.startChapter
@@ -60,6 +77,7 @@ export function evaluateHookAdmission(params: {
   const candidateNormalized = normalizeText([
     params.candidate.type,
     params.candidate.expectedPayoff ?? "",
+    params.candidate.payoffTiming ?? "",
     params.candidate.notes ?? "",
   ].join(" "));
   const candidateTerms = extractTerms(candidateNormalized);
@@ -69,6 +87,7 @@ export function evaluateHookAdmission(params: {
     const activeNormalized = normalizeText([
       hook.type,
       hook.expectedPayoff,
+      hook.payoffTiming ?? "",
       hook.notes,
     ].join(" "));
 

packages/core/src/utils/hook-health.ts

@@ -1,10 +1,13 @@
 import type { AuditIssue } from "../agents/continuity.js";
 import type { HookRecord, RuntimeStateDelta } from "../models/runtime-state.js";
 import { classifyHookDisposition, collectStaleHookDebt } from "./hook-governance.js";
+import { describeHookLifecycle, localizeHookPayoffTiming } from "./hook-lifecycle.js";
+import { HOOK_HEALTH_DEFAULTS } from "./hook-policy.js";
 
 export function analyzeHookHealth(params: {
   readonly language: "zh" | "en";
   readonly chapterNumber: number;
+  readonly targetChapters?: number;
   readonly hooks: ReadonlyArray<HookRecord>;
   readonly delta?: Pick<RuntimeStateDelta, "chapter" | "hookOps">;
   readonly existingHookIds?: ReadonlyArray<string>;
@@ -13,13 +16,26 @@ export function analyzeHookHealth(params: {
   readonly noAdvanceWindow?: number;
   readonly newHookBurstThreshold?: number;
 }): AuditIssue[] {
-  const maxActiveHooks = params.maxActiveHooks ?? 12;
-  const staleAfterChapters = params.staleAfterChapters ?? 10;
-  const noAdvanceWindow = params.noAdvanceWindow ?? 5;
-  const newHookBurstThreshold = params.newHookBurstThreshold ?? 2;
+  const maxActiveHooks = params.maxActiveHooks ?? HOOK_HEALTH_DEFAULTS.maxActiveHooks;
+  const staleAfterChapters = params.staleAfterChapters ?? HOOK_HEALTH_DEFAULTS.staleAfterChapters;
+  const noAdvanceWindow = params.noAdvanceWindow ?? HOOK_HEALTH_DEFAULTS.noAdvanceWindow;
+  const newHookBurstThreshold = params.newHookBurstThreshold ?? HOOK_HEALTH_DEFAULTS.newHookBurstThreshold;
   const issues: AuditIssue[] = [];
 
   const activeHooks = params.hooks.filter((hook) => hook.status !== "resolved");
+  const lifecycleEntries = activeHooks.map((hook) => ({
+    hook,
+    lifecycle: describeHookLifecycle({
+      payoffTiming: hook.payoffTiming,
+      expectedPayoff: hook.expectedPayoff,
+      notes: hook.notes,
+      startChapter: hook.startChapter,
+      lastAdvancedChapter: hook.lastAdvancedChapter,
+      status: hook.status,
+      chapterNumber: params.chapterNumber,
+      targetChapters: params.targetChapters,
+    }),
+  }));
 
   if (activeHooks.length > maxActiveHooks) {
     issues.push(warning(
@@ -33,45 +49,58 @@ export function analyzeHookHealth(params: {
     ));
   }
 
-  const latestRealAdvance = activeHooks.reduce(
-    (max, hook) => Math.max(max, hook.lastAdvancedChapter),
-    0,
+  const staleHookIds = new Set(collectStaleHookDebt({
+    hooks: activeHooks,
+    chapterNumber: params.chapterNumber,
+    targetChapters: params.targetChapters,
+    staleAfterChapters,
+  }).map((hook) => hook.hookId));
+  const pressuredHooks = lifecycleEntries.filter(({ hook, lifecycle }) =>
+    staleHookIds.has(hook.hookId)
+    || lifecycle.readyToResolve
+    || lifecycle.overdue,
   );
-  if (activeHooks.length > 0 && params.chapterNumber - latestRealAdvance >= noAdvanceWindow) {
+  const unresolvedPressure = pressuredHooks.filter(({ hook }) => {
+    if (!params.delta) {
+      return true;
+    }
+
+    const disposition = classifyHookDisposition({
+      hookId: hook.hookId,
+      delta: params.delta,
+    });
+    return disposition === "none" || disposition === "mention";
+  });
+  if (unresolvedPressure.length > 0) {
     issues.push(warning(
       params.language,
+      buildPressureDescription({
+        language: params.language,
+        entries: unresolvedPressure,
+        mentionsCurrentChapter: Boolean(params.delta),
+      }),
       params.language === "en"
-        ? `No real hook advancement has landed for ${params.chapterNumber - latestRealAdvance} chapters.`
-        : `已经连续 ${params.chapterNumber - latestRealAdvance} 章没有真实伏笔推进。`,
-      params.language === "en"
-        ? "Schedule one old hook for real movement instead of opening parallel restatements."
-        : "下一章优先让一个旧伏笔发生真实推进，而不是继续平行重述。",
+        ? "Move one pressured hook with a real payoff, escalation, or explicit defer before opening adjacent debt."
+        : "先让一个已进入压力区的伏笔发生真实推进、回收或明确延后，再继续扩展同类债务。",
     ));
-  }
-
-  const staleHooks = collectStaleHookDebt({
-    hooks: activeHooks,
-    chapterNumber: params.chapterNumber,
-    staleAfterChapters,
-  });
-  if (params.delta && staleHooks.length > 0) {
-    const untouchedStale = staleHooks.filter((hook) => {
-      const disposition = classifyHookDisposition({
-        hookId: hook.hookId,
-        delta: params.delta!,
-      });
-      return disposition === "none" || disposition === "mention";
-    });
-
-    if (untouchedStale.length > 0) {
+  } else {
+    const latestRealAdvance = activeHooks.reduce(
+      (max, hook) => Math.max(max, hook.lastAdvancedChapter),
+      0,
+    );
+    if (
+      params.noAdvanceWindow !== undefined
+      && activeHooks.length > 0
+      && params.chapterNumber - latestRealAdvance >= noAdvanceWindow
+    ) {
       issues.push(warning(
         params.language,
         params.language === "en"
-          ? `Stale hooks received no real disposition this chapter: ${untouchedStale.map((hook) => hook.hookId).join(", ")}.`
-          : `本章没有真正处理这些陈旧伏笔：${untouchedStale.map((hook) => hook.hookId).join("、")}。`,
+          ? `No real hook advancement has landed for ${params.chapterNumber - latestRealAdvance} chapters.`
+          : `已经连续 ${params.chapterNumber - latestRealAdvance} 章没有真实伏笔推进。`,
         params.language === "en"
-          ? "Advance, resolve, or explicitly defer at least one stale hook."
-          : "至少推进、回收或明确延后一个陈旧伏笔。",
+          ? "Schedule one old hook for real movement instead of opening parallel restatements."
+          : "下一章优先让一个旧伏笔发生真实推进，而不是继续平行重述。",
       ));
     }
   }
@@ -99,6 +128,53 @@ export function analyzeHookHealth(params: {
   return issues;
 }
 
+function buildPressureDescription(params: {
+  readonly language: "zh" | "en";
+  readonly entries: ReadonlyArray<{
+    readonly hook: HookRecord;
+    readonly lifecycle: ReturnType<typeof describeHookLifecycle>;
+  }>;
+  readonly mentionsCurrentChapter: boolean;
+}): string {
+  const summarized = params.entries
+    .slice(0, 3)
+    .map(({ hook, lifecycle }) => {
+      const timing = localizeHookPayoffTiming(lifecycle.timing, params.language);
+      const pressure = localizePressureLabel(lifecycle, params.language);
+      return params.language === "en"
+        ? `${hook.hookId} (${timing}, ${pressure})`
+        : `${hook.hookId}（${timing}，${pressure}）`;
+    });
+  const suffix = params.entries.length > summarized.length
+    ? params.language === "en"
+      ? `, +${params.entries.length - summarized.length} more`
+      : `，另有 ${params.entries.length - summarized.length} 条`
+    : "";
+
+  if (params.language === "en") {
+    return params.mentionsCurrentChapter
+      ? `Hooks are already under payoff pressure but this chapter left them untouched: ${summarized.join(", ")}${suffix}.`
+      : `Hooks are already under payoff pressure without recent movement: ${summarized.join(", ")}${suffix}.`;
+  }
+
+  return params.mentionsCurrentChapter
+    ? `这些伏笔已经进入回收/推进压力，但本章没有真正处理：${summarized.join("、")}${suffix}。`
+    : `这些伏笔已经进入回收/推进压力，但近期没有真实推进：${summarized.join("、")}${suffix}。`;
+}
+
+function localizePressureLabel(
+  lifecycle: ReturnType<typeof describeHookLifecycle>,
+  language: "zh" | "en",
+): string {
+  if (lifecycle.overdue) {
+    return language === "en" ? "overdue" : "已逾期";
+  }
+  if (lifecycle.readyToResolve) {
+    return language === "en" ? "ready to pay off" : "可回收";
+  }
+  return language === "en" ? "stale" : "陈旧";
+}
+
 function warning(
   language: "zh" | "en",
   description: string,

packages/core/src/utils/hook-lifecycle.ts

@@ -0,0 +1,175 @@
+import type { HookPayoffTiming } from "../models/runtime-state.js";
+import {
+  HOOK_ACTIVITY_THRESHOLDS,
+  HOOK_PHASE_THRESHOLDS,
+  HOOK_PHASE_WEIGHT,
+  HOOK_PRESSURE_WEIGHTS,
+  HOOK_TIMING_PROFILES,
+  type HookPhase,
+} from "./hook-policy.js";
+
+const LABELS: Record<"zh" | "en", Record<HookPayoffTiming, string>> = {
+  en: {
+    immediate: "immediate",
+    "near-term": "near-term",
+    "mid-arc": "mid-arc",
+    "slow-burn": "slow-burn",
+    endgame: "endgame",
+  },
+  zh: {
+    immediate: "立即",
+    "near-term": "近期",
+    "mid-arc": "中程",
+    "slow-burn": "慢烧",
+    endgame: "终局",
+  },
+};
+
+const TIMING_ALIASES: Array<[HookPayoffTiming, RegExp]> = [
+  ["immediate", /^(?:立即|马上|当章|本章|下一章|immediate|instant|next(?:\s+chapter|\s+beat)?|right\s+away)$/i],
+  ["near-term", /^(?:近期|近几章|短线|soon|short(?:\s+run)?|near(?:\s*-\s*|\s+)term|current\s+sequence)$/i],
+  ["mid-arc", /^(?:中程|中期|卷中|mid(?:\s*-\s*|\s+)arc|mid(?:\s*-\s*|\s+)book|middle)$/i],
+  ["slow-burn", /^(?:慢烧|长线|后续|later|late(?:r)?|long(?:\s*-\s*|\s+)arc|slow(?:\s*-\s*|\s+)burn)$/i],
+  ["endgame", /^(?:终局|终章|大结局|最终|climax|finale|endgame|late\s+book)$/i],
+];
+
+const SIGNAL_PATTERNS: Array<[HookPayoffTiming, RegExp]> = [
+  ["endgame", /(终局|终章|大结局|最终揭晓|最终摊牌|climax|finale|endgame|final reveal|last act)/i],
+  ["immediate", /(当章|本章|下一章|马上|立刻|即刻|immediate|next chapter|right away|at once)/i],
+  ["near-term", /(近期|近几章|很快|短线|soon|near-term|short run|current sequence)/i],
+  ["mid-arc", /(中期|卷中|本卷中段|mid-book|mid arc|middle of the arc)/i],
+  ["slow-burn", /(长线|慢烧|后续发酵|慢慢揭开|later|slow burn|long arc|long tail)/i],
+];
+
+export function normalizeHookPayoffTiming(value: string | undefined | null): HookPayoffTiming | undefined {
+  const normalized = value?.trim();
+  if (!normalized) return undefined;
+
+  for (const [timing, pattern] of TIMING_ALIASES) {
+    if (pattern.test(normalized)) {
+      return timing;
+    }
+  }
+
+  return undefined;
+}
+
+export function inferHookPayoffTiming(params: {
+  readonly expectedPayoff?: string;
+  readonly notes?: string;
+}): HookPayoffTiming {
+  const combined = [params.expectedPayoff, params.notes]
+    .filter((value): value is string => Boolean(value && value.trim()))
+    .join(" ")
+    .trim();
+  if (!combined) return "mid-arc";
+
+  for (const [timing, pattern] of SIGNAL_PATTERNS) {
+    if (pattern.test(combined)) {
+      return timing;
+    }
+  }
+
+  return "mid-arc";
+}
+
+export function resolveHookPayoffTiming(params: {
+  readonly payoffTiming?: string | null;
+  readonly expectedPayoff?: string;
+  readonly notes?: string;
+}): HookPayoffTiming {
+  return normalizeHookPayoffTiming(params.payoffTiming)
+    ?? inferHookPayoffTiming({
+      expectedPayoff: params.expectedPayoff,
+      notes: params.notes,
+    });
+}
+
+export function localizeHookPayoffTiming(
+  timing: HookPayoffTiming,
+  language: "zh" | "en",
+): string {
+  return LABELS[language][timing];
+}
+
+export function describeHookLifecycle(params: {
+  readonly payoffTiming?: string | null;
+  readonly expectedPayoff?: string;
+  readonly notes?: string;
+  readonly startChapter: number;
+  readonly lastAdvancedChapter: number;
+  readonly status: string;
+  readonly chapterNumber: number;
+  readonly targetChapters?: number;
+}): {
+  readonly timing: HookPayoffTiming;
+  readonly phase: HookPhase;
+  readonly age: number;
+  readonly dormancy: number;
+  readonly readyToResolve: boolean;
+  readonly stale: boolean;
+  readonly overdue: boolean;
+  readonly advancePressure: number;
+  readonly resolvePressure: number;
+} {
+  const timing = resolveHookPayoffTiming(params);
+  const profile = HOOK_TIMING_PROFILES[timing];
+  const phase = resolveHookPhase(params.chapterNumber, params.targetChapters);
+  const age = Math.max(0, params.chapterNumber - Math.max(1, params.startChapter));
+  const lastTouchChapter = Math.max(params.startChapter, params.lastAdvancedChapter);
+  const dormancy = Math.max(0, params.chapterNumber - Math.max(1, lastTouchChapter));
+  const explicitProgressing = /^(progressing|advanced|重大推进|持续推进)$/i.test(params.status.trim());
+  const phaseReady = HOOK_PHASE_WEIGHT[phase] >= HOOK_PHASE_WEIGHT[profile.minimumPhase];
+  const recentlyTouched = dormancy <= HOOK_ACTIVITY_THRESHOLDS.recentlyTouchedDormancy;
+  const overdue = phaseReady && age >= profile.overdueAge;
+  const cadenceReady = timing === "slow-burn"
+    ? phase === "late" || overdue
+    : timing === "endgame"
+      ? phase === "late"
+      : true;
+  const momentum = explicitProgressing || recentlyTouched;
+  const stale = phaseReady && (
+    dormancy >= profile.staleDormancy
+    || (overdue && !momentum)
+  );
+  const readyToResolve = phaseReady
+    && cadenceReady
+    && age >= profile.earliestResolveAge
+    && (momentum || (overdue && explicitProgressing));
+
+  return {
+    timing,
+    phase,
+    age,
+    dormancy,
+    readyToResolve,
+    stale,
+    overdue,
+    advancePressure: age
+      + dormancy
+      + (stale ? HOOK_PRESSURE_WEIGHTS.staleAdvanceBonus : 0)
+      + (overdue ? HOOK_PRESSURE_WEIGHTS.overdueAdvanceBonus : 0),
+    resolvePressure: readyToResolve
+      ? profile.resolveBias * HOOK_PRESSURE_WEIGHTS.resolveBiasMultiplier
+        + (explicitProgressing ? HOOK_PRESSURE_WEIGHTS.progressingResolveBonus : 0)
+        + Math.min(
+          HOOK_PRESSURE_WEIGHTS.maxDormancyResolveBonus,
+          dormancy * HOOK_PRESSURE_WEIGHTS.dormancyResolveMultiplier,
+        )
+        + (overdue ? HOOK_PRESSURE_WEIGHTS.overdueResolveBonus : 0)
+      : 0,
+  };
+}
+
+function resolveHookPhase(chapterNumber: number, targetChapters?: number): HookPhase {
+  if (targetChapters && targetChapters > 0) {
+    const progress = chapterNumber / targetChapters;
+    if (progress >= HOOK_PHASE_THRESHOLDS.lateProgress) return "late";
+    if (progress >= HOOK_PHASE_THRESHOLDS.middleProgress) return "middle";
+    return "opening";
+  }
+
+  if (chapterNumber >= HOOK_PHASE_THRESHOLDS.lateChapter) return "late";
+  if (chapterNumber >= HOOK_PHASE_THRESHOLDS.middleChapter) return "middle";
+  return "opening";
+}

packages/core/src/utils/hook-policy.ts

@@ -0,0 +1,153 @@
+import type { HookPayoffTiming } from "../models/runtime-state.js";
+
+export type HookPhase = "opening" | "middle" | "late";
+export type HookAgendaLoad = "light" | "medium" | "heavy";
+
+export interface HookLifecycleProfile {
+  readonly earliestResolveAge: number;
+  readonly staleDormancy: number;
+  readonly overdueAge: number;
+  readonly minimumPhase: HookPhase;
+  readonly resolveBias: number;
+}
+
+export const HOOK_TIMING_PROFILES: Record<HookPayoffTiming, HookLifecycleProfile> = {
+  immediate: {
+    earliestResolveAge: 1,
+    staleDormancy: 1,
+    overdueAge: 3,
+    minimumPhase: "opening",
+    resolveBias: 5,
+  },
+  "near-term": {
+    earliestResolveAge: 1,
+    staleDormancy: 2,
+    overdueAge: 5,
+    minimumPhase: "opening",
+    resolveBias: 4,
+  },
+  "mid-arc": {
+    earliestResolveAge: 2,
+    staleDormancy: 4,
+    overdueAge: 8,
+    minimumPhase: "opening",
+    resolveBias: 3,
+  },
+  "slow-burn": {
+    earliestResolveAge: 4,
+    staleDormancy: 5,
+    overdueAge: 12,
+    minimumPhase: "middle",
+    resolveBias: 2,
+  },
+  endgame: {
+    earliestResolveAge: 6,
+    staleDormancy: 6,
+    overdueAge: 16,
+    minimumPhase: "late",
+    resolveBias: 1,
+  },
+};
+
+export const HOOK_PHASE_WEIGHT: Record<HookPhase, number> = {
+  opening: 0,
+  middle: 1,
+  late: 2,
+};
+
+export const HOOK_PHASE_THRESHOLDS = {
+  middleProgress: 0.33,
+  lateProgress: 0.72,
+  middleChapter: 8,
+  lateChapter: 24,
+} as const;
+
+export const HOOK_PRESSURE_WEIGHTS = {
+  staleAdvanceBonus: 8,
+  overdueAdvanceBonus: 6,
+  resolveBiasMultiplier: 10,
+  progressingResolveBonus: 5,
+  dormancyResolveMultiplier: 2,
+  maxDormancyResolveBonus: 12,
+  overdueResolveBonus: 10,
+  mustAdvancePressureFloor: 8,
+  criticalResolvePressure: 40,
+} as const;
+
+export const HOOK_ACTIVITY_THRESHOLDS = {
+  recentlyTouchedDormancy: 1,
+  longArcQuietHoldMaxAge: 2,
+  longArcQuietHoldMaxDormancy: 1,
+  refreshDormancy: 2,
+  freshPromiseAge: 1,
+} as const;
+
+export const HOOK_AGENDA_LIMITS: Record<HookAgendaLoad, {
+  readonly staleDebt: number;
+  readonly mustAdvance: number;
+  readonly eligibleResolve: number;
+  readonly avoidFamilies: number;
+}> = {
+  light: {
+    staleDebt: 1,
+    mustAdvance: 2,
+    eligibleResolve: 1,
+    avoidFamilies: 2,
+  },
+  medium: {
+    staleDebt: 2,
+    mustAdvance: 2,
+    eligibleResolve: 1,
+    avoidFamilies: 3,
+  },
+  heavy: {
+    staleDebt: 3,
+    mustAdvance: 3,
+    eligibleResolve: 2,
+    avoidFamilies: 4,
+  },
+};
+
+export const HOOK_AGENDA_LOAD_THRESHOLDS = {
+  heavyReadyCount: 3,
+  heavyStaleCount: 4,
+  heavyCriticalCount: 3,
+  heavyPressuredCount: 6,
+  mediumReadyCount: 2,
+  mediumStaleCount: 2,
+  mediumCriticalCount: 1,
+  mediumPressuredFamilies: 3,
+} as const;
+
+export const HOOK_VISIBILITY_WINDOWS: Record<HookPayoffTiming, number> = {
+  immediate: 5,
+  "near-term": 5,
+  "mid-arc": 6,
+  "slow-burn": 8,
+  endgame: 10,
+};
+
+export const HOOK_RELEVANT_SELECTION_DEFAULTS = {
+  primary: {
+    baseLimit: 3,
+    pressuredExpansionLimit: 4,
+    pressuredThreshold: 4,
+  },
+  stale: {
+    defaultLimit: 1,
+    expandedLimit: 2,
+    overdueThreshold: 2,
+    familySpreadThreshold: 2,
+  },
+} as const;
+
+export const HOOK_HEALTH_DEFAULTS = {
+  maxActiveHooks: 12,
+  staleAfterChapters: 10,
+  noAdvanceWindow: 5,
+  newHookBurstThreshold: 2,
+} as const;
+
+export function resolveHookVisibilityWindow(timing: HookPayoffTiming): number {
+  return HOOK_VISIBILITY_WINDOWS[timing];
+}

packages/core/src/utils/long-span-fatigue.ts

@@ -1,5 +1,10 @@
 import { readFile, readdir } from "node:fs/promises";
 import { join } from "node:path";
+import { analyzeChapterCadence } from "./chapter-cadence.js";
+import {
+  CADENCE_WINDOW_DEFAULTS,
+  LONG_SPAN_FATIGUE_THRESHOLDS,
+} from "./cadence-policy.js";
 
 export interface LongSpanFatigueIssue {
   readonly severity: "warning";
@@ -31,7 +36,6 @@ interface SummaryRow {
   readonly chapterType: string;
 }
 
-const SENTENCE_SIMILARITY_THRESHOLD = 0.72;
 const CHINESE_PUNCTUATION = /[，。！？；：“”‘’（）《》、\s\-—…·]/g;
 const ENGLISH_PUNCTUATION = /[^a-z0-9]+/gi;
 
@@ -39,7 +43,11 @@ export async function buildEnglishVarianceBrief(params: {
   readonly bookDir: string;
   readonly chapterNumber: number;
 }): Promise<EnglishVarianceBrief | null> {
-  const chapterBodies = await loadPreviousChapterBodies(params.bookDir, params.chapterNumber, 24);
+  const chapterBodies = await loadPreviousChapterBodies(
+    params.bookDir,
+    params.chapterNumber,
+    CADENCE_WINDOW_DEFAULTS.englishVarianceLookback,
+  );
   if (chapterBodies.length < 2) {
     return null;
   }
@@ -48,12 +56,16 @@ export async function buildEnglishVarianceBrief(params: {
   const recentRows = summaryRows
     .filter((row) => row.chapter < params.chapterNumber)
     .sort((left, right) => left.chapter - right.chapter)
-    .slice(-3);
+    .slice(-CADENCE_WINDOW_DEFAULTS.summaryLookback);
 
   const highFrequencyPhrases = collectRepeatedEnglishPhrases(chapterBodies);
   const repeatedOpeningPatterns = collectRepeatedBoundaryPatterns(chapterBodies, "opening");
   const repeatedEndingShapes = collectRepeatedBoundaryPatterns(chapterBodies, "ending");
-  const sceneObligation = chooseSceneObligation(recentRows, repeatedOpeningPatterns, repeatedEndingShapes);
+  const cadence = analyzeChapterCadence({
+    rows: recentRows,
+    language: "en",
+  });
+  const sceneObligation = chooseSceneObligation(cadence, repeatedOpeningPatterns, repeatedEndingShapes);
 
   const lines = [
     "## English Variance Brief",
@@ -84,13 +96,27 @@ export async function analyzeLongSpanFatigue(
   const recentRows = mergedRows
     .filter((row) => row.chapter <= input.chapterNumber)
     .sort((left, right) => left.chapter - right.chapter)
-    .slice(-3);
+    .slice(-CADENCE_WINDOW_DEFAULTS.summaryLookback);
+  const cadence = analyzeChapterCadence({
+    rows: recentRows,
+    language,
+  });
 
-  const chapterTypeIssue = buildChapterTypeIssue(recentRows, language);
+  const chapterTypeIssue = buildChapterTypeIssue(cadence, language);
   if (chapterTypeIssue) {
     issues.push(chapterTypeIssue);
   }
 
+  const moodIssue = buildMoodIssue(cadence, language);
+  if (moodIssue) {
+    issues.push(moodIssue);
+  }
+
+  const titleIssue = buildTitleIssue(cadence, language);
+  if (titleIssue) {
+    issues.push(titleIssue);
+  }
+
   const recentChapterBodies = await loadRecentChapterBodies(
     input.bookDir,
     input.chapterNumber,
@@ -181,26 +207,19 @@ function parseSummaryRow(line: string): SummaryRow | null {
 }
 
 function buildChapterTypeIssue(
-  rows: ReadonlyArray<SummaryRow>,
+  cadence: ReturnType<typeof analyzeChapterCadence>,
   language: "zh" | "en",
 ): LongSpanFatigueIssue | null {
-  if (rows.length < 3) return null;
-
-  const types = rows
-    .map((row) => row.chapterType.trim())
-    .filter((value) => isMeaningfulValue(value));
-  if (types.length < 3) return null;
-
-  const normalized = types.map((value) => value.toLowerCase());
-  if (!normalized.every((value) => value === normalized[0])) {
+  if (cadence.scenePressure?.pressure !== "high") {
     return null;
   }
+  const { repeatedType, streak } = cadence.scenePressure;
 
   if (language === "en") {
     return {
       severity: "warning",
       category: "Pacing Monotony",
-      description: `The last 3 chapter types are identical: ${types.join(" -> ")}, which suggests macro pacing monotony.`,
+      description: `The last ${streak} chapter types have stayed on ${repeatedType}, which suggests macro pacing monotony.`,
       suggestion: "Switch the next chapter's function instead of extending the same beat again. Rotate setup, payoff, reversal, and fallout more deliberately.",
     };
   }
@@ -208,11 +227,63 @@ function buildChapterTypeIssue(
   return {
     severity: "warning",
     category: "节奏单调",
-    description: `最近3章章节类型完全一致：${types.join(" -> ")}，长篇节奏可能开始固化。`,
+    description: `最近${streak}章章节类型持续停留在“${repeatedType}”，长篇节奏可能开始固化。`,
     suggestion: "下一章应切换章节功能，不要连续重复同一种布局/推进节拍。",
   };
 }
 
+function buildMoodIssue(
+  cadence: ReturnType<typeof analyzeChapterCadence>,
+  language: "zh" | "en",
+): LongSpanFatigueIssue | null {
+  if (cadence.moodPressure?.pressure !== "high") {
+    return null;
+  }
+  const { highTensionStreak, recentMoods } = cadence.moodPressure;
+
+  if (language === "en") {
+    return {
+      severity: "warning",
+      category: "Mood Monotony",
+      description: `High-tension mood has locked in for ${highTensionStreak} chapters (${recentMoods.join(" -> ")}), with no visible emotional release.`,
+      suggestion: "Insert a release beat, warmth, humor, intimacy, or reflective quiet before escalating again.",
+    };
+  }
+
+  return {
+    severity: "warning",
+    category: "情绪单调",
+    description: `最近${highTensionStreak}章持续高压（${recentMoods.join(" -> ")}），缺少明显的情绪释放。`,
+    suggestion: "下一章安排一次喘息、温情、幽默或静场释放，再继续加压。",
+  };
+}
+
+function buildTitleIssue(
+  cadence: ReturnType<typeof analyzeChapterCadence>,
+  language: "zh" | "en",
+): LongSpanFatigueIssue | null {
+  if (cadence.titlePressure?.pressure !== "high") {
+    return null;
+  }
+  const { repeatedToken, count } = cadence.titlePressure;
+
+  if (language === "en") {
+    return {
+      severity: "warning",
+      category: "Title Collapse",
+      description: `Recent titles keep collapsing around "${repeatedToken}" (${count} hits in the current window), which makes chapter naming feel formulaic.`,
+      suggestion: "Change the next title anchor. Use a new image, action, consequence, or character vector instead of the same keyword shell.",
+    };
+  }
+
+  return {
+    severity: "warning",
+    category: "标题重复",
+    description: `最近标题持续围绕“${repeatedToken}”命名（当前窗口命中${count}次），命名开始坍缩。`,
+    suggestion: "下一章标题换一个新的意象、动作、后果或人物焦点，不要继续套同一个关键词壳。",
+  };
+}
+
 async function loadRecentChapterBodies(
   bookDir: string,
   currentChapter: number,
@@ -225,9 +296,9 @@ async function loadRecentChapterBodies(
       .map((file) => ({ file, chapter: Number.parseInt(file.slice(0, 4), 10) }))
       .filter((entry) => Number.isFinite(entry.chapter) && entry.chapter < currentChapter && entry.file.endsWith(".md"))
       .sort((left, right) => left.chapter - right.chapter)
-      .slice(-2);
+      .slice(-CADENCE_WINDOW_DEFAULTS.recentBoundaryPatternBodies);
 
-    if (previousFiles.length < 2) {
+    if (previousFiles.length < CADENCE_WINDOW_DEFAULTS.recentBoundaryPatternBodies) {
       return [];
     }
 
@@ -246,7 +317,7 @@ function buildSentencePatternIssue(
   boundary: "opening" | "ending",
   language: "zh" | "en",
 ): LongSpanFatigueIssue | null {
-  if (chapterBodies.length < 3) return null;
+  if (chapterBodies.length < LONG_SPAN_FATIGUE_THRESHOLDS.boundaryPatternMinBodies) return null;
 
   const sentences = chapterBodies.map((body) => extractBoundarySentence(body, boundary));
   if (sentences.some((sentence) => sentence === null)) {
@@ -255,7 +326,7 @@ function buildSentencePatternIssue(
 
   const normalized = sentences
     .map((sentence) => normalizeSentence(sentence!, language));
-  if (normalized.some((sentence) => sentence.length < 18)) {
+  if (normalized.some((sentence) => sentence.length < LONG_SPAN_FATIGUE_THRESHOLDS.boundarySentenceMinLength)) {
     return null;
   }
 
@@ -263,7 +334,7 @@ function buildSentencePatternIssue(
     diceCoefficient(normalized[0]!, normalized[1]!),
     diceCoefficient(normalized[1]!, normalized[2]!),
   ];
-  if (Math.min(...similarities) < SENTENCE_SIMILARITY_THRESHOLD) {
+  if (Math.min(...similarities) < LONG_SPAN_FATIGUE_THRESHOLDS.boundarySimilarityFloor) {
     return null;
   }
 
@@ -352,15 +423,11 @@ function collectRepeatedBoundaryPatterns(
 }
 
 function chooseSceneObligation(
-  rows: ReadonlyArray<SummaryRow>,
+  cadence: ReturnType<typeof analyzeChapterCadence>,
   repeatedOpenings: ReadonlyArray<string>,
   repeatedEndings: ReadonlyArray<string>,
 ): string {
-  const recentTypes = rows
-    .map((row) => row.chapterType.trim().toLowerCase())
-    .filter((type) => type.length > 0);
-
-  if (recentTypes.length >= 3 && recentTypes.every((type) => type === recentTypes[0])) {
+  if (cadence.scenePressure?.pressure === "high") {
     return "confrontation under pressure";
   }
   if (repeatedEndings.length > 0) {

packages/core/src/utils/memory-retrieval.ts

@@ -1,19 +1,37 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import type { HookAgenda } from "../models/input-governance.js";
 import {
   ChapterSummariesStateSchema,
   CurrentStateStateSchema,
   HooksStateSchema,
-  type HookRecord,
-  type HookStatus,
 } from "../models/runtime-state.js";
 import { MemoryDB, type Fact, type StoredHook, type StoredSummary } from "../state/memory-db.js";
+import { bootstrapStructuredStateFromMarkdown } from "../state/state-bootstrap.js";
 import {
-  bootstrapStructuredStateFromMarkdown,
-  parsePendingHooksMarkdown as parseStatePendingHooksMarkdown,
-} from "../state/state-bootstrap.js";
-import { collectStaleHookDebt } from "./hook-governance.js";
+  buildPlannerHookAgenda,
+  filterActiveHooks,
+  isFuturePlannedHook,
+  isHookWithinChapterWindow,
+} from "./hook-agenda.js";
+import {
+  parseChapterSummariesMarkdown,
+  parseCurrentStateFacts,
+  parsePendingHooksMarkdown,
+  renderHookSnapshot,
+  renderSummarySnapshot,
+} from "./story-markdown.js";
+export {
+  buildPlannerHookAgenda,
+  isFuturePlannedHook,
+  isHookWithinChapterWindow,
+} from "./hook-agenda.js";
+export {
+  parseChapterSummariesMarkdown,
+  parseCurrentStateFacts,
+  parsePendingHooksMarkdown,
+  renderHookSnapshot,
+  renderSummarySnapshot,
+} from "./story-markdown.js";
 
 export interface MemorySelection {
   readonly summaries: ReadonlyArray<StoredSummary>;
@@ -30,8 +48,6 @@ export interface VolumeSummarySelection {
   readonly anchor: string;
 }
 
-export const DEFAULT_HOOK_LOOKAHEAD_CHAPTERS = 3;
-
 export async function retrieveMemorySelection(params: {
   readonly bookDir: string;
   readonly chapterNumber: number;
@@ -155,112 +171,6 @@ export function extractQueryTerms(goal: string, outlineNode: string | undefined,
   ]).slice(0, 12);
 }
 
-export function renderSummarySnapshot(
-  summaries: ReadonlyArray<StoredSummary>,
-  language: "zh" | "en" = "zh",
-): string {
-  if (summaries.length === 0) return "- none";
-
-  const headers = language === "en"
-    ? [
-      "| chapter | title | characters | events | stateChanges | hookActivity | mood | chapterType |",
-      "| --- | --- | --- | --- | --- | --- | --- | --- |",
-    ]
-    : [
-      "| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |",
-      "| --- | --- | --- | --- | --- | --- | --- | --- |",
-    ];
-
-  return [
-    ...headers,
-    ...summaries.map((summary) => [
-      summary.chapter,
-      summary.title,
-      summary.characters,
-      summary.events,
-      summary.stateChanges,
-      summary.hookActivity,
-      summary.mood,
-      summary.chapterType,
-    ].map(escapeTableCell).join(" | ")).map((row) => `| ${row} |`),
-  ].join("\n");
-}
-
-export function renderHookSnapshot(
-  hooks: ReadonlyArray<StoredHook>,
-  language: "zh" | "en" = "zh",
-): string {
-  if (hooks.length === 0) return "- none";
-
-  const headers = language === "en"
-    ? [
-      "| hook_id | start_chapter | type | status | last_advanced | expected_payoff | notes |",
-      "| --- | --- | --- | --- | --- | --- | --- |",
-    ]
-    : [
-      "| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 备注 |",
-      "| --- | --- | --- | --- | --- | --- | --- |",
-    ];
-
-  return [
-    ...headers,
-    ...hooks.map((hook) => [
-      hook.hookId,
-      hook.startChapter,
-      hook.type,
-      hook.status,
-      hook.lastAdvancedChapter,
-      hook.expectedPayoff,
-      hook.notes,
-    ].map((cell) => escapeTableCell(String(cell))).join(" | ")).map((row) => `| ${row} |`),
-  ].join("\n");
-}
-
-export function buildPlannerHookAgenda(params: {
-  readonly hooks: ReadonlyArray<StoredHook>;
-  readonly chapterNumber: number;
-  readonly maxMustAdvance?: number;
-  readonly maxEligibleResolve?: number;
-  readonly maxStaleDebt?: number;
-}): HookAgenda {
-  const agendaHooks = params.hooks
-    .map(normalizeStoredHook)
-    .filter((hook) => !isFuturePlannedHook(hook, params.chapterNumber, 0))
-    .filter((hook) => hook.status !== "resolved" && hook.status !== "deferred");
-  const mustAdvance = agendaHooks
-    .slice()
-    .sort((left, right) => (
-      right.lastAdvancedChapter - left.lastAdvancedChapter
-      || left.startChapter - right.startChapter
-      || left.hookId.localeCompare(right.hookId)
-    ))
-    .slice(0, params.maxMustAdvance ?? 2)
-    .map((hook) => hook.hookId);
-  const staleDebt = collectStaleHookDebt({
-    hooks: agendaHooks,
-    chapterNumber: params.chapterNumber,
-  })
-    .slice(0, params.maxStaleDebt ?? 2)
-    .map((hook) => hook.hookId);
-  const eligibleResolve = agendaHooks
-    .filter((hook) => hook.startChapter <= params.chapterNumber - 3)
-    .filter((hook) => hook.lastAdvancedChapter >= params.chapterNumber - 2)
-    .sort((left, right) => (
-      left.startChapter - right.startChapter
-      || right.lastAdvancedChapter - left.lastAdvancedChapter
-      || left.hookId.localeCompare(right.hookId)
-    ))
-    .slice(0, params.maxEligibleResolve ?? 1)
-    .map((hook) => hook.hookId);
-
-  return {
-    mustAdvance,
-    eligibleResolve,
-    staleDebt,
-    avoidNewHookFamilies: [],
-  };
-}
-
 function openMemoryDB(bookDir: string): MemoryDB | null {
   try {
     return new MemoryDB(bookDir);
@@ -367,84 +277,6 @@ function uniqueTerms(terms: ReadonlyArray<string>): string[] {
   return result;
 }
 
-export function parseChapterSummariesMarkdown(markdown: string): StoredSummary[] {
-  const rows = parseMarkdownTableRows(markdown)
-    .filter((row) => /^\d+$/.test(row[0] ?? ""));
-
-  return rows.map((row) => ({
-    chapter: parseInt(row[0]!, 10),
-    title: row[1] ?? "",
-    characters: row[2] ?? "",
-    events: row[3] ?? "",
-    stateChanges: row[4] ?? "",
-    hookActivity: row[5] ?? "",
-    mood: row[6] ?? "",
-    chapterType: row[7] ?? "",
-  }));
-}
-
-export function parsePendingHooksMarkdown(markdown: string): StoredHook[] {
-  return parseStatePendingHooksMarkdown(markdown);
-}
-
-export function parseCurrentStateFacts(
-  markdown: string,
-  fallbackChapter: number,
-): Fact[] {
-  const tableRows = parseMarkdownTableRows(markdown);
-  const fieldValueRows = tableRows
-    .filter((row) => row.length >= 2)
-    .filter((row) => !isStateTableHeaderRow(row));
-
-  if (fieldValueRows.length > 0) {
-    const chapterFromTable = fieldValueRows.find((row) => isCurrentChapterLabel(row[0] ?? ""));
-    const stateChapter = parseInteger(chapterFromTable?.[1]) || fallbackChapter;
-
-    return fieldValueRows
-      .filter((row) => !isCurrentChapterLabel(row[0] ?? ""))
-      .flatMap((row): Fact[] => {
-        const label = (row[0] ?? "").trim();
-        const value = (row[1] ?? "").trim();
-        if (!label || !value) return [];
-
-        return [{
-          subject: inferFactSubject(label),
-          predicate: label,
-          object: value,
-          validFromChapter: stateChapter,
-          validUntilChapter: null,
-          sourceChapter: stateChapter,
-        }];
-      });
-  }
-
-  const bulletFacts = markdown
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line.startsWith("-"))
-    .map((line) => line.replace(/^-\s*/, ""))
-    .filter(Boolean);
-
-  return bulletFacts.map((line, index) => ({
-    subject: "current_state",
-    predicate: `note_${index + 1}`,
-    object: line,
-    validFromChapter: fallbackChapter,
-    validUntilChapter: null,
-    sourceChapter: fallbackChapter,
-  }));
-}
-
-function parseMarkdownTableRows(markdown: string): string[][] {
-  return markdown
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line.startsWith("|"))
-    .filter((line) => !line.includes("---"))
-    .map((line) => line.split("|").slice(1, -1).map((cell) => cell.trim()))
-    .filter((cells) => cells.some(Boolean));
-}
-
 function parseVolumeSummariesMarkdown(markdown: string): VolumeSummarySelection[] {
   if (!markdown.trim()) return [];
 
@@ -466,26 +298,6 @@ function parseVolumeSummariesMarkdown(markdown: string): VolumeSummarySelection[
   }).filter((section) => section.heading.length > 0 && section.content.length > 0);
 }
 
-function isStateTableHeaderRow(row: ReadonlyArray<string>): boolean {
-  const first = (row[0] ?? "").trim().toLowerCase();
-  const second = (row[1] ?? "").trim().toLowerCase();
-  return (first === "字段" && second === "值") || (first === "field" && second === "value");
-}
-
-function isCurrentChapterLabel(label: string): boolean {
-  return /^(当前章节|current chapter)$/i.test(label.trim());
-}
-
-function inferFactSubject(label: string): string {
-  if (/^(当前位置|current location)$/i.test(label)) return "protagonist";
-  if (/^(主角状态|protagonist state)$/i.test(label)) return "protagonist";
-  if (/^(当前目标|current goal)$/i.test(label)) return "protagonist";
-  if (/^(当前限制|current constraint)$/i.test(label)) return "protagonist";
-  if (/^(当前敌我|current alliances|current relationships)$/i.test(label)) return "protagonist";
-  if (/^(当前冲突|current conflict)$/i.test(label)) return "protagonist";
-  return "current_state";
-}
-
 function isUnresolvedHook(status: string): boolean {
   return status.trim().length === 0 || /open|待定|推进|active|progressing/i.test(status);
 }
@@ -524,36 +336,34 @@ function selectRelevantHooks(
   const ranked = hooks
     .map((hook) => ({
       hook,
-      score: scoreHook(hook, queryTerms),
+      score: scoreHook(hook, queryTerms, chapterNumber),
       matched: matchesAny(
-        [hook.hookId, hook.type, hook.expectedPayoff, hook.notes].join(" "),
+        [hook.hookId, hook.type, hook.expectedPayoff, hook.payoffTiming ?? "", hook.notes].join(" "),
         queryTerms,
       ),
     }))
-    .filter((entry) => entry.matched || isUnresolvedHook(entry.hook.status));
+    .filter((entry: { hook: StoredHook; score: number; matched: boolean }) =>
+      entry.matched || isUnresolvedHook(entry.hook.status),
+    );
 
-  const recentCutoff = Math.max(0, chapterNumber - 5);
-  const staleCutoff = Math.max(0, chapterNumber - 10);
   const primary = ranked
-    .filter((entry) => (
-      entry.matched
-      || isHookWithinChapterWindow(entry.hook, chapterNumber, 5)
-    ))
+    .filter((entry: { hook: StoredHook; score: number; matched: boolean }) =>
+      entry.matched || isHookWithinChapterWindow(entry.hook, chapterNumber, 5),
+    )
     .sort((left, right) => right.score - left.score || right.hook.lastAdvancedChapter - left.hook.lastAdvancedChapter)
-    .slice(0, 3);
+    .slice(0, 6);
 
-  const selectedIds = new Set(primary.map((entry) => entry.hook.hookId));
+  const selectedIds = new Set(primary.map((entry: { hook: StoredHook; score: number; matched: boolean }) => entry.hook.hookId));
   const stale = ranked
-    .filter((entry) => (
+    .filter((entry: { hook: StoredHook; score: number; matched: boolean }) =>
       !selectedIds.has(entry.hook.hookId)
       && !isFuturePlannedHook(entry.hook, chapterNumber)
-      && entry.hook.lastAdvancedChapter <= staleCutoff
-      && isUnresolvedHook(entry.hook.status)
-    ))
+      && isUnresolvedHook(entry.hook.status),
+    )
     .sort((left, right) => left.hook.lastAdvancedChapter - right.hook.lastAdvancedChapter || right.score - left.score)
-    .slice(0, 1);
+    .slice(0, 2);
 
-  return [...primary, ...stale].map((entry) => entry.hook);
+  return [...primary, ...stale].map((entry: { hook: StoredHook; score: number; matched: boolean }) => entry.hook);
 }
 
 function selectRelevantFacts(
@@ -636,71 +446,17 @@ function scoreSummary(summary: StoredSummary, chapterNumber: number, queryTerms:
   return recencyScore + termScore;
 }
 
-function scoreHook(hook: StoredHook, queryTerms: ReadonlyArray<string>): number {
-  const text = [hook.hookId, hook.type, hook.expectedPayoff, hook.notes].join(" ");
+function scoreHook(
+  hook: StoredHook,
+  queryTerms: ReadonlyArray<string>,
+  _chapterNumber: number,
+): number {
+  const text = [hook.hookId, hook.type, hook.expectedPayoff, hook.payoffTiming ?? "", hook.notes].join(" ");
   const freshness = Math.max(0, hook.lastAdvancedChapter);
   const termScore = queryTerms.reduce((score, term) => score + (includesTerm(text, term) ? Math.max(8, term.length * 2) : 0), 0);
   return termScore + freshness;
 }
 
-function normalizeStoredHook(hook: StoredHook): HookRecord {
-  return {
-    hookId: hook.hookId,
-    startChapter: Math.max(0, hook.startChapter),
-    type: hook.type,
-    status: normalizeStoredHookStatus(hook.status),
-    lastAdvancedChapter: Math.max(0, hook.lastAdvancedChapter),
-    expectedPayoff: hook.expectedPayoff,
-    notes: hook.notes,
-  };
-}
-
-function normalizeStoredHookStatus(status: string): HookStatus {
-  if (/^(resolved|closed|done|已回收|已解决)$/i.test(status.trim())) return "resolved";
-  if (/^(deferred|paused|hold|延后|延期|搁置|暂缓)$/i.test(status.trim())) return "deferred";
-  if (/^(progressing|advanced|重大推进|持续推进)$/i.test(status.trim())) return "progressing";
-  return "open";
-}
-
-function filterActiveHooks(hooks: ReadonlyArray<StoredHook>): StoredHook[] {
-  return hooks.filter((hook) => normalizeStoredHookStatus(hook.status) !== "resolved");
-}
-
-export function isFuturePlannedHook(
-  hook: StoredHook,
-  chapterNumber: number,
-  lookahead: number = DEFAULT_HOOK_LOOKAHEAD_CHAPTERS,
-): boolean {
-  return hook.lastAdvancedChapter <= 0 && hook.startChapter > chapterNumber + lookahead;
-}
-
-export function isHookWithinChapterWindow(
-  hook: StoredHook,
-  chapterNumber: number,
-  recentWindow: number = 5,
-  lookahead: number = DEFAULT_HOOK_LOOKAHEAD_CHAPTERS,
-): boolean {
-  const recentCutoff = Math.max(0, chapterNumber - recentWindow);
-
-  if (hook.lastAdvancedChapter > 0 && hook.lastAdvancedChapter >= recentCutoff) {
-    return true;
-  }
-
-  if (hook.lastAdvancedChapter > 0) {
-    return false;
-  }
-
-  if (hook.startChapter <= 0) {
-    return true;
-  }
-
-  if (hook.startChapter >= recentCutoff && hook.startChapter <= chapterNumber) {
-    return true;
-  }
-
-  return hook.startChapter > chapterNumber && hook.startChapter <= chapterNumber + lookahead;
-}
-
 function matchesAny(text: string, queryTerms: ReadonlyArray<string>): boolean {
   return queryTerms.some((term) => includesTerm(text, term));
 }
@@ -709,16 +465,6 @@ function includesTerm(text: string, term: string): boolean {
   return text.toLowerCase().includes(term.toLowerCase());
 }
 
-function parseInteger(value: string | undefined): number {
-  if (!value) return 0;
-  const match = value.match(/\d+/);
-  return match ? parseInt(match[0], 10) : 0;
-}
-
-function escapeTableCell(value: string | number): string {
-  return String(value).replace(/\|/g, "\\|").trim();
-}
-
 function slugifyAnchor(value: string): string {
   return value
     .trim()

packages/core/src/utils/story-markdown.ts

@@ -0,0 +1,235 @@
+import type { Fact, StoredHook, StoredSummary } from "../state/memory-db.js";
+import {
+  localizeHookPayoffTiming,
+  normalizeHookPayoffTiming,
+  resolveHookPayoffTiming,
+} from "./hook-lifecycle.js";
+
+export function renderSummarySnapshot(
+  summaries: ReadonlyArray<StoredSummary>,
+  language: "zh" | "en" = "zh",
+): string {
+  if (summaries.length === 0) return "- none";
+
+  const headers = language === "en"
+    ? [
+      "| chapter | title | characters | events | stateChanges | hookActivity | mood | chapterType |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+    ]
+    : [
+      "| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+    ];
+
+  return [
+    ...headers,
+    ...summaries.map((summary) => [
+      summary.chapter,
+      summary.title,
+      summary.characters,
+      summary.events,
+      summary.stateChanges,
+      summary.hookActivity,
+      summary.mood,
+      summary.chapterType,
+    ].map(escapeTableCell).join(" | ")).map((row) => `| ${row} |`),
+  ].join("\n");
+}
+
+export function renderHookSnapshot(
+  hooks: ReadonlyArray<StoredHook>,
+  language: "zh" | "en" = "zh",
+): string {
+  if (hooks.length === 0) return "- none";
+
+  const headers = language === "en"
+    ? [
+      "| hook_id | start_chapter | type | status | last_advanced | expected_payoff | payoff_timing | notes |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+    ]
+    : [
+      "| hook_id | 起始章节 | 类型 | 状态 | 最近推进 | 预期回收 | 回收节奏 | 备注 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+    ];
+
+  return [
+    ...headers,
+    ...hooks.map((hook) => [
+      hook.hookId,
+      hook.startChapter,
+      hook.type,
+      hook.status,
+      hook.lastAdvancedChapter,
+      hook.expectedPayoff,
+      localizeHookPayoffTiming(resolveHookPayoffTiming(hook), language),
+      hook.notes,
+    ].map((cell) => escapeTableCell(String(cell))).join(" | ")).map((row) => `| ${row} |`),
+  ].join("\n");
+}
+
+export function parseChapterSummariesMarkdown(markdown: string): StoredSummary[] {
+  const rows = parseMarkdownTableRows(markdown)
+    .filter((row) => /^\d+$/.test(row[0] ?? ""));
+
+  return rows.map((row) => ({
+    chapter: parseInt(row[0]!, 10),
+    title: row[1] ?? "",
+    characters: row[2] ?? "",
+    events: row[3] ?? "",
+    stateChanges: row[4] ?? "",
+    hookActivity: row[5] ?? "",
+    mood: row[6] ?? "",
+    chapterType: row[7] ?? "",
+  }));
+}
+
+export function parsePendingHooksMarkdown(markdown: string): StoredHook[] {
+  const tableRows = parseMarkdownTableRows(markdown)
+    .filter((row) => (row[0] ?? "").toLowerCase() !== "hook_id");
+
+  if (tableRows.length > 0) {
+    return tableRows
+      .filter((row) => normalizeHookId(row[0]).length > 0)
+      .map((row) => parsePendingHookRow(row));
+  }
+
+  return markdown
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("-"))
+    .map((line) => line.replace(/^-\s*/, ""))
+    .filter(Boolean)
+    .map((line, index) => ({
+      hookId: `hook-${index + 1}`,
+      startChapter: 0,
+      type: "unspecified",
+      status: "open",
+      lastAdvancedChapter: 0,
+      expectedPayoff: "",
+      payoffTiming: undefined,
+      notes: line,
+    }));
+}
+
+export function parseCurrentStateFacts(
+  markdown: string,
+  fallbackChapter: number,
+): Fact[] {
+  const tableRows = parseMarkdownTableRows(markdown);
+  const fieldValueRows = tableRows
+    .filter((row) => row.length >= 2)
+    .filter((row) => !isStateTableHeaderRow(row));
+
+  if (fieldValueRows.length > 0) {
+    const chapterFromTable = fieldValueRows.find((row) => isCurrentChapterLabel(row[0] ?? ""));
+    const stateChapter = parseInteger(chapterFromTable?.[1]) || fallbackChapter;
+
+    return fieldValueRows
+      .filter((row) => !isCurrentChapterLabel(row[0] ?? ""))
+      .flatMap((row): Fact[] => {
+        const label = (row[0] ?? "").trim();
+        const value = (row[1] ?? "").trim();
+        if (!label || !value) return [];
+
+        return [{
+          subject: inferFactSubject(label),
+          predicate: label,
+          object: value,
+          validFromChapter: stateChapter,
+          validUntilChapter: null,
+          sourceChapter: stateChapter,
+        }];
+      });
+  }
+
+  const bulletFacts = markdown
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("-"))
+    .map((line) => line.replace(/^-\s*/, ""))
+    .filter(Boolean);
+
+  return bulletFacts.map((line, index) => ({
+    subject: "current_state",
+    predicate: `note_${index + 1}`,
+    object: line,
+    validFromChapter: fallbackChapter,
+    validUntilChapter: null,
+    sourceChapter: fallbackChapter,
+  }));
+}
+
+export function parseMarkdownTableRows(markdown: string): string[][] {
+  return markdown
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("|"))
+    .filter((line) => !line.includes("---"))
+    .map((line) => line.split("|").slice(1, -1).map((cell) => cell.trim()))
+    .filter((cells) => cells.some(Boolean));
+}
+
+export function isStateTableHeaderRow(row: ReadonlyArray<string>): boolean {
+  const first = (row[0] ?? "").trim().toLowerCase();
+  const second = (row[1] ?? "").trim().toLowerCase();
+  return (first === "字段" && second === "值") || (first === "field" && second === "value");
+}
+
+export function isCurrentChapterLabel(label: string): boolean {
+  return /^(当前章节|current chapter)$/i.test(label.trim());
+}
+
+export function inferFactSubject(label: string): string {
+  if (/^(当前位置|current location)$/i.test(label)) return "protagonist";
+  if (/^(主角状态|protagonist state)$/i.test(label)) return "protagonist";
+  if (/^(当前目标|current goal)$/i.test(label)) return "protagonist";
+  if (/^(当前限制|current constraint)$/i.test(label)) return "protagonist";
+  if (/^(当前敌我|current alliances|current relationships)$/i.test(label)) return "protagonist";
+  if (/^(当前冲突|current conflict)$/i.test(label)) return "protagonist";
+  return "current_state";
+}
+
+export function parseInteger(value: string | undefined): number {
+  if (!value) return 0;
+  const match = value.match(/\d+/);
+  return match ? parseInt(match[0], 10) : 0;
+}
+
+export function normalizeHookId(value: string | undefined): string {
+  let normalized = (value ?? "").trim();
+  let previous = "";
+  while (normalized && normalized !== previous) {
+    previous = normalized;
+    normalized = normalized
+      .replace(/^\[(.+?)\]\([^)]+\)$/u, "$1")
+      .replace(/^\*\*(.+)\*\*$/u, "$1")
+      .replace(/^__(.+)__$/u, "$1")
+      .replace(/^\*(.+)\*$/u, "$1")
+      .replace(/^_(.+)_$/u, "$1")
+      .replace(/^`(.+)`$/u, "$1")
+      .replace(/^~~(.+)~~$/u, "$1")
+      .trim();
+  }
+  return normalized;
+}
+
+function parsePendingHookRow(row: ReadonlyArray<string | undefined>): StoredHook {
+  const legacyShape = row.length < 8;
+  const payoffTiming = legacyShape ? undefined : normalizeHookPayoffTiming(row[6]);
+  const notes = legacyShape ? (row[6] ?? "") : (row[7] ?? "");
+
+  return {
+    hookId: normalizeHookId(row[0]),
+    startChapter: parseInteger(row[1]),
+    type: row[2] ?? "",
+    status: row[3] ?? "open",
+    lastAdvancedChapter: parseInteger(row[4]),
+    expectedPayoff: row[5] ?? "",
+    payoffTiming,
+    notes,
+  };
+}
+
+function escapeTableCell(value: string | number): string {
+  return String(value).replace(/\|/g, "\\|").trim();
+}