novelforge-agent 0.2.0 → 0.3.0

package/src/core/prompts/en-US.ts

@@ -79,6 +79,56 @@ Rules:
     };
 }
 
+function buildStyleGuidePrompt(input: PromptBuildInput): BuiltPrompt {
+return {
+      purpose: 'style_guide',
+      expectedFormat: 'JSON matching StyleGuideSchema',
+      prompt: `You are the style editor for a long-form novel. From the user prompt, metadata, and story bible, create a style guide that chapter writing and review can enforce over the whole project.
+
+## User Prompt
+${input.state.initialPrompt}
+
+${input.context ? `## Existing Context\n${input.context}\n` : ''}## Output Requirements
+Output valid JSON only, in this shape:
+{
+  "narrativeVoice": "Narration person, POV distance, narrator texture, emotional temperature",
+  "pacing": "Rules for openings, transitions, conflict movement, and chapter-end hooks",
+  "diction": "Word choice, sentence density, genre terminology boundaries",
+  "dialogueRules": [
+    "Rules for core character dialogue length, tone, subtext, and forms of address"
+  ],
+  "prohibitedPatterns": [
+    "Patterns to avoid: modern memes, explanatory narration, lore dumping, voice drift, etc."
+  ],
+  "proseRhythm": {
+    "sentenceRhythm": "How short, medium, and long sentences should be used; short sentences should serve turns, danger, or emotional landings, not default narration",
+    "paragraphing": "Paragraphs should form complete narrative units; avoid consecutive one-sentence paragraphs and line breaks used as fake rhythm",
+    "interiorityMode": "How interiority should be refracted through action, hesitation, and sensory response; avoid frequent direct explanation of thoughts",
+    "emphasisBudget": "Budget for repetition, dashes, isolated short sentences, and other emphasis tools",
+    "antiPatterns": [
+      "3 or more consecutive one-sentence short paragraphs",
+      "many short sentences used to simulate tension",
+      "explaining psychology immediately after every action",
+      "repeating the same sentence pattern to create fake rhythm"
+    ]
+  },
+  "sampleParagraph": "A 120-250 word target-style sample. Do not turn it into plot outline.",
+  "consistencyChecks": [
+    "Concrete checks future chapter reviews should use to detect style drift"
+  ]
+}
+
+Rules:
+- Match genre, premise, character identities, and reader expectations.
+- Do not rely on abstract adjectives only; every field must guide actual prose.
+- proseRhythm must not be fixed word-count rules; describe reviewable rhythm principles and anti-patterns.
+- sampleParagraph demonstrates prose texture only. Do not reveal future plot.
+- prohibitedPatterns must contain at least 3 entries; consistencyChecks must contain at least 3 entries.
+- proseRhythm.antiPatterns must contain at least 4 entries.
+${strictJsonOutputRules()}`,
+    };
+}
+
 function buildArchitecturePrompt(input: PromptBuildInput): BuiltPrompt {
 return {
       purpose: 'architecture',
@@ -89,7 +139,7 @@ return {
 ${input.state.initialPrompt}
 
 ## Goals
-- Generate at least ${input.state.targetChapters} chapter architectures for this first run.
+- Whole-book target is about ${input.state.plannedTotalChapters ?? input.state.targetChapters} chapters; generate only the first ${input.state.targetChapters} chapter architectures in this first batch.
 - The full-book architecture should define the long-term main line and ending direction.
 - Volume architecture should define phase conflict, climax, and volume-end hooks.
 - Chapter architecture must cover only what should happen in that chapter and must not reveal later concrete events early.
@@ -131,6 +181,7 @@ Output valid JSON only, in this shape:
 
 Rules:
 - chapters.length must be at least ${input.state.targetChapters}.
+- chapters do not need to cover the whole book; when writing reaches the boundary, the workflow will request architecture_extension.
 - chapterNumber must start at 1 and increase contiguously.
 - volumeId must reference an id from volumes.
 - volumePacing must provide one pacing board for every volume.
@@ -139,6 +190,72 @@ ${strictJsonOutputRules()}`,
     };
 }
 
+function buildArchitectureExtensionPrompt(input: PromptBuildInput): BuiltPrompt {
+  const start = input.state.currentChapter;
+  const total = input.state.plannedTotalChapters ?? input.state.targetChapters;
+  const end = Math.min(total, start + input.state.targetChapters - 1);
+  return {
+    purpose: 'architecture_extension',
+    expectedFormat: 'JSON matching ArchitectureExtensionPayloadSchema',
+    prompt: `You are the chief architect for a long-form novel. The manuscript has reached the edge of the existing chapter plan; extend the architecture from current continuity.
+
+## Extension Range
+- Start at chapter ${start}.
+- This batch should plan through chapter ${end} at most.
+- The whole-book target ends at chapter ${total}.
+
+## Extension Principles
+- Do not rewrite existing chapter architecture; append only new chapter architecture.
+- New chapters must follow recent memory, the character state table, active foreshadow threads, and volume pacing boards.
+- If the next chapters enter a new volume, add volumes and volumePacing. If they remain in an existing volume, you may provide an updated pacing board for that volume.
+- If the full-book direction needs adjustment because of written material, include fullUpdate. fullUpdate must be a complete replacement for architecture/full.md, not a change note.
+- Chapter architecture must cover only what should happen in that chapter and must not reveal later concrete events early.
+
+${input.context ? `## Existing Context\n${input.context}\n` : ''}## Output Requirements
+Output valid JSON only, in this shape:
+{
+  "fullUpdate": "optional complete updated full-book architecture",
+  "volumes": [
+    {
+      "id": "v2",
+      "title": "New or updated volume title",
+      "summary": "Volume goal, conflict, climax, and end hook",
+      "order": 2
+    }
+  ],
+  "volumePacing": [
+    {
+      "volumeId": "v2",
+      "start": "Volume starting state",
+      "promise": "Volume promise",
+      "keyTurns": ["Key turn 1", "Key turn 2"],
+      "midpoint": "Midpoint turn",
+      "climax": "Volume climax",
+      "payoffs": ["Planned payoffs"],
+      "lingeringMysteries": ["Lingering mysteries"]
+    }
+  ],
+  "chapters": [
+    {
+      "chapterNumber": ${start},
+      "title": "Chapter title",
+      "volumeId": "v1",
+      "summary": "Chapter plot summary",
+      "requiredBeats": ["Required beat 1"]
+    }
+  ]
+}
+
+Rules:
+- chapters[0].chapterNumber must equal ${start}.
+- chapterNumber must increase contiguously and must not exceed ${total}.
+- chapters.length should be ${end - start + 1} unless the book has reached its ending.
+- requiredBeats must include at least one concrete, actionable beat.
+- volumeId must reference an existing volume id or a volume id supplied in this response.
+${strictJsonOutputRules()}`,
+    };
+}
+
 function buildChapterPrompt(input: PromptBuildInput): BuiltPrompt {
   const ch = input.state.currentChapter;
   const isFirstChapter = ch <= 1;
@@ -148,7 +265,7 @@ function buildChapterPrompt(input: PromptBuildInput): BuiltPrompt {
     prompt: `You are a professional long-form fiction writer. Write chapter ${ch} directly.
 
 ## Priority Order
-1. Strictly follow the current chapter architecture, user additions, story bible hard constraints, and previous-chapter continuity.
+1. Strictly follow the current chapter architecture, user additions, story bible hard constraints, style guide, and previous-chapter continuity.
 2. Use relevant memory, prior text evidence, and active foreshadow threads.
 3. Treat full-book and volume plans as distant planning context only. Do not write concrete future events early.
 
@@ -163,6 +280,8 @@ ${isFirstChapter
 - The chapter must end on a clear hook: cliffhanger, mystery, emotional resonance, reveal, or volume close — per the chapter architecture endHookFocus. Default: cliffhanger.
 
 ## Style
+- Enforce the Style Guide from context. Treat sampleParagraph as prose texture only; do not copy its content.
+- Enforce Style Guide.proseRhythm: short sentences, one-line paragraphs, repeated sentences, and dashes are emphasis tools, not default narration. Ordinary narration should form natural sentence groups.
 - Match the novel's genre, world, character identities, and emotional tone.
 - Natural, stable, readable language; prioritize narrative progress, character work, and emotional accumulation.
 - Dialogue fits each character's identity, relationship, and situation.
@@ -258,7 +377,7 @@ ${strictJsonOutputRules()}`,
 }
 
 function buildContinuityReviewPrompt(input: PromptBuildInput): BuiltPrompt {
-const end = Math.max(input.state.targetChapters, input.state.currentChapter - 1);
+const end = Math.max(input.state.plannedTotalChapters ?? input.state.targetChapters, input.state.currentChapter - 1);
 return {
       purpose: 'continuity_review',
       expectedFormat: 'JSON matching ContinuityReviewSchema',
@@ -308,6 +427,8 @@ ${input.context ? `## Review Context\n${input.context}\n` : ''}## Review Focus
 - Whether every requiredBeat is fulfilled; missing beats must appear in acceptance.requiredBeats.missingBeats.
 - Whether this chapter advances the main line, character state, or active foreshadow threads. If it is static, at least one of narrativeProgress/characterProgress/foreshadowProgress must fail.
 - Whether it violates the story bible, character state table, volume pacing board, or prior memory.
+- Whether it violates the Style Guide: narrative voice, sentence density, genre diction, dialogue rules, or prohibited patterns.
+- Whether it violates Style Guide.proseRhythm: excessive short-sentence density, consecutive one-sentence paragraphs, fake rhythm through line breaks, overly direct interior explanation, or repeated sentence patterns.
 - Whether the ending has a clear hook that matches the chapter architecture endHookFocus.
 - Whether it repeats prior chapter beats, conflict patterns, reveals, or dialogue functions.
 - Character voice, motivation, and state vs the story bible and prior memory.
@@ -343,6 +464,10 @@ Output valid JSON only, in this shape:
       "status": "pass | fail",
       "evidence": "Whether it matches the story bible, character state table, and world rules"
     },
+    "proseRhythm": {
+      "status": "pass | fail",
+      "evidence": "Whether it follows Style Guide.proseRhythm; explain whether short sentences, one-line paragraphs, repetition, and interior explanation are controlled"
+    },
     "endingHook": {
       "status": "pass | fail",
       "evidence": "The ending hook passage and its function"
@@ -440,8 +565,12 @@ function buildPromptForStep(input: PromptBuildInput): BuiltPrompt {
       return buildMetadataPrompt(input);
     case 'story_bible':
       return buildStoryBiblePrompt(input);
+    case 'style_guide':
+      return buildStyleGuidePrompt(input);
     case 'architecture':
       return buildArchitecturePrompt(input);
+    case 'architecture_extension':
+      return buildArchitectureExtensionPrompt(input);
     case 'chapter':
       return buildChapterPrompt(input);
     case 'memory_card':

package/src/core/prompts/types.ts

@@ -3,7 +3,9 @@ import { AgentState } from '../types.js';
 export type PromptPurpose =
   | 'novel_metadata'
   | 'story_bible'
+  | 'style_guide'
   | 'architecture'
+  | 'architecture_extension'
   | 'chapter'
   | 'memory_card'
   | 'continuity_review'

package/src/core/prompts/zh-CN.ts

@@ -79,6 +79,56 @@ ${input.context ? `## 已有上下文\n${input.context}\n` : ''}## 输出结构
   };
 }
 
+function buildStyleGuidePrompt(input: PromptBuildInput): BuiltPrompt {
+return {
+    purpose: 'style_guide',
+    expectedFormat: 'JSON matching StyleGuideSchema',
+    prompt: `你是一名长篇小说文风主编。请根据用户提示、metadata 和故事圣经，生成可被每章写作与审稿长期执行的风格圣经。
+
+## 用户提示词
+${input.state.initialPrompt}
+
+${input.context ? `## 已有上下文\n${input.context}\n` : ''}## 输出要求
+请只输出合法 JSON，格式如下：
+{
+  "narrativeVoice": "叙事人称、视角距离、旁白气质、情绪温度",
+  "pacing": "开章、转场、冲突推进、章末钩子的节奏规则",
+  "diction": "词汇选择、句式密度、题材术语使用边界",
+  "dialogueRules": [
+    "核心人物对白的长度、语气、潜台词、称谓规则"
+  ],
+  "prohibitedPatterns": [
+    "禁止出现的现代梗、解释型旁白、设定堆砌、口吻漂移等"
+  ],
+  "proseRhythm": {
+    "sentenceRhythm": "短句、中句、长句的使用原则；短句应服务转折、危险、情绪落点，而不是默认叙述单位",
+    "paragraphing": "段落应形成完整叙事单元；避免连续单句成段、靠频繁换行制造伪节奏",
+    "interiorityMode": "心理活动如何通过动作、迟疑、感官反应折射；避免频繁直接解释人物想法",
+    "emphasisBudget": "重复句、破折号、孤立短句等强调资源的使用预算",
+    "antiPatterns": [
+      "连续 3 个以上单句短段",
+      "用大量短句模拟紧张感",
+      "每个动作后立刻解释心理",
+      "重复同一句式制造伪节奏"
+    ]
+  },
+  "sampleParagraph": "一段 120-250 字的目标风格示例，不要写成剧情大纲",
+  "consistencyChecks": [
+    "后续章节审稿时用于判断风格是否跑偏的具体检查项"
+  ]
+}
+
+要求：
+- 风格必须匹配 genre、premise、人物身份和目标读者预期。
+- 不要只写抽象形容词；每个字段都要能指导实际行文。
+- proseRhythm 不要写成固定字数规则；要描述可审稿的节奏原则和反模式。
+- sampleParagraph 只展示语言质感，不要提前泄露后续剧情。
+- prohibitedPatterns 至少 3 条，consistencyChecks 至少 3 条。
+- proseRhythm.antiPatterns 至少 4 条。
+${strictJsonOutputRules()}`,
+  };
+}
+
 function buildArchitecturePrompt(input: PromptBuildInput): BuiltPrompt {
 return {
     purpose: 'architecture',
@@ -89,7 +139,7 @@ return {
 ${input.state.initialPrompt}
 
 ## 目标
-- 本次至少生成 ${input.state.targetChapters} 个章架构。
+- 全本目标约 ${input.state.plannedTotalChapters ?? input.state.targetChapters} 章；本次只生成首批 ${input.state.targetChapters} 个章架构。
 - 全本架构负责长期主线和结局方向。
 - 卷架构负责阶段冲突、高潮和卷尾钩子。
 - 章架构必须只覆盖本章应发生的内容，不要提前泄露后续具体事件。
@@ -131,6 +181,7 @@ ${input.context ? `## 已有上下文\n${input.context}\n` : ''}## 输出要求
 
 要求：
 - chapters.length 必须大于等于 ${input.state.targetChapters}。
+- chapters 不需要一次覆盖全本；后续写到边界时会进入 architecture_extension 续规划。
 - chapterNumber 从 1 开始连续递增。
 - volumeId 必须引用 volumes 中存在的 id。
 - volumePacing 必须为每个 volume 提供节奏板。
@@ -139,6 +190,72 @@ ${strictJsonOutputRules()}`,
   };
 }
 
+function buildArchitectureExtensionPrompt(input: PromptBuildInput): BuiltPrompt {
+  const start = input.state.currentChapter;
+  const total = input.state.plannedTotalChapters ?? input.state.targetChapters;
+  const end = Math.min(total, start + input.state.targetChapters - 1);
+  return {
+    purpose: 'architecture_extension',
+    expectedFormat: 'JSON matching ArchitectureExtensionPayloadSchema',
+    prompt: `你是一名长篇小说总架构师。当前已写到既有章纲边界，请基于已有内容续写后续章架构。
+
+## 续规划范围
+- 从第 ${start} 章开始。
+- 本批最多规划到第 ${end} 章。
+- 全本目标到第 ${total} 章结束。
+
+## 续规划原则
+- 不要改写已经存在的章节架构；只追加新的 chapter architecture。
+- 新增章节必须承接最近记忆、角色状态表、活跃伏笔和卷级节奏板。
+- 如果后续章节进入新卷，可以新增 volumes 和 volumePacing；如果仍在旧卷，可以补充/更新该卷节奏板。
+- 如果全本方向因已写内容需要微调，可以输出 fullUpdate；fullUpdate 必须是可覆盖 architecture/full.md 的完整更新版，而不是变更说明。
+- 章架构必须只覆盖本章应发生的内容，不要提前泄露更后面的具体事件。
+
+${input.context ? `## 已有上下文\n${input.context}\n` : ''}## 输出要求
+请只输出合法 JSON，格式如下：
+{
+  "fullUpdate": "可选：完整更新后的全本架构 Markdown/文本",
+  "volumes": [
+    {
+      "id": "v2",
+      "title": "新增或更新卷标题",
+      "summary": "本卷目标、冲突、高潮和卷尾钩子",
+      "order": 2
+    }
+  ],
+  "volumePacing": [
+    {
+      "volumeId": "v2",
+      "start": "本卷起点",
+      "promise": "本卷承诺",
+      "keyTurns": ["关键转折1", "关键转折2"],
+      "midpoint": "中点转折",
+      "climax": "本卷高潮",
+      "payoffs": ["计划回收点"],
+      "lingeringMysteries": ["遗留悬念"]
+    }
+  ],
+  "chapters": [
+    {
+      "chapterNumber": ${start},
+      "title": "章标题",
+      "volumeId": "v1",
+      "summary": "本章剧情摘要",
+      "requiredBeats": ["必须完成的情节点1"]
+    }
+  ]
+}
+
+要求：
+- chapters[0].chapterNumber 必须等于 ${start}。
+- chapterNumber 必须连续递增，且不能超过 ${total}。
+- chapters.length 建议为 ${end - start + 1}，除非已经到全本结尾。
+- requiredBeats 至少 1 条，且必须具体可执行。
+- volumeId 必须引用已有或本次新增 volumes 中存在的 id。
+${strictJsonOutputRules()}`,
+  };
+}
+
 function buildChapterPrompt(input: PromptBuildInput): BuiltPrompt {
   const ch = input.state.currentChapter;
   const isFirstChapter = ch <= 1;
@@ -148,7 +265,7 @@ function buildChapterPrompt(input: PromptBuildInput): BuiltPrompt {
     prompt: `你是一位擅长创作长篇网络小说的职业作者。请直接完成第 ${ch} 章正文。
 
 ## 执行优先级
-1. 先严格遵守"本章架构、用户补充要求、故事圣经硬约束、上一章承接"。
+1. 先严格遵守"本章架构、用户补充要求、故事圣经硬约束、风格圣经、上一章承接"。
 2. 再参考"历史相关记忆、历史原文证据、活跃伏笔"保证一致性。
 3. 最后才参考"全本/本卷远场规划"，且不得提前写出尚未发生的情节。
 
@@ -163,6 +280,8 @@ ${isFirstChapter
 - 章末必须有清晰的"钩子"：可以是悬念、反转、剧情承诺、情绪余韵或卷末高潮——按本章架构 endHookFocus 字段决定。如果未指定，默认用悬念。
 
 ## 风格
+- 严格执行上下文中的 Style Guide；sampleParagraph 只作为语言质感参考，不要复写其内容。
+- 严格执行 Style Guide.proseRhythm：短句、单句段、重复句、破折号是强调资源，不是默认叙述单位；常规叙述要形成自然句群。
 - 文风必须与本书题材、世界观、人物身份、情感基调一致。
 - 语言自然、稳定、可读，优先服务叙事推进、人物塑造和情绪积累。
 - 对话符合人物身份、关系和处境；重要情绪通过动作、神态、节奏、潜台词体现。
@@ -257,7 +376,7 @@ ${strictJsonOutputRules()}`,
 }
 
 function buildContinuityReviewPrompt(input: PromptBuildInput): BuiltPrompt {
-const end = Math.max(input.state.targetChapters, input.state.currentChapter - 1);
+const end = Math.max(input.state.plannedTotalChapters ?? input.state.targetChapters, input.state.currentChapter - 1);
 return {
     purpose: 'continuity_review',
     expectedFormat: 'JSON matching ContinuityReviewSchema',
@@ -307,6 +426,8 @@ ${input.context ? `## 审阅上下文\n${input.context}\n` : ''}## 审阅重点
 - requiredBeats 是否全部完成；缺失项必须写入 acceptance.requiredBeats.missingBeats。
 - 本章是否推进主线、人物状态或活跃伏笔；如果完全原地踏步，narrativeProgress/characterProgress/foreshadowProgress 至少一项必须 fail。
 - 是否违反故事圣经、角色状态表、卷级节奏板或历史记忆。
+- 是否违反 Style Guide：叙事声音、句式密度、题材词汇、对白规则和禁用模式。
+- 是否违反 Style Guide.proseRhythm：短句密度过高、连续单句短段、靠换行制造伪节奏、心理解释过直白、重复同一句式。
 - 章末是否有清晰钩子，且符合本章 endHookFocus。
 - 是否重复之前章节已经完成的桥段、冲突结构、信息揭示或对话功能。
 - 人物声音、动机、状态是否符合故事圣经与历史记忆。
@@ -342,6 +463,10 @@ ${input.context ? `## 审阅上下文\n${input.context}\n` : ''}## 审阅重点
       "status": "pass | fail",
       "evidence": "是否符合故事圣经、角色状态表和世界规则"
     },
+    "proseRhythm": {
+      "status": "pass | fail",
+      "evidence": "是否符合 Style Guide.proseRhythm；说明短句/单句段/重复句/心理解释是否被合理控制"
+    },
     "endingHook": {
       "status": "pass | fail",
       "evidence": "章末钩子的具体段落和作用"
@@ -439,8 +564,12 @@ function buildPromptForStep(input: PromptBuildInput): BuiltPrompt {
       return buildMetadataPrompt(input);
     case 'story_bible':
       return buildStoryBiblePrompt(input);
+    case 'style_guide':
+      return buildStyleGuidePrompt(input);
     case 'architecture':
       return buildArchitecturePrompt(input);
+    case 'architecture_extension':
+      return buildArchitectureExtensionPrompt(input);
     case 'chapter':
       return buildChapterPrompt(input);
     case 'memory_card':

package/src/core/schemas.ts

@@ -15,6 +15,23 @@ export const NovelMetadataSchema = z.object({
   coreCast: z.array(CoreCastMemberSchema).min(1),
 });
 
+export const StyleGuideSchema = z.object({
+  narrativeVoice: z.string().min(1),
+  pacing: z.string().min(1),
+  diction: z.string().min(1),
+  dialogueRules: z.array(z.string().min(1)).min(1),
+  prohibitedPatterns: z.array(z.string().min(1)).min(1),
+  proseRhythm: z.object({
+    sentenceRhythm: z.string().min(1),
+    paragraphing: z.string().min(1),
+    interiorityMode: z.string().min(1),
+    emphasisBudget: z.string().min(1),
+    antiPatterns: z.array(z.string().min(1)).min(1),
+  }),
+  sampleParagraph: z.string().min(1),
+  consistencyChecks: z.array(z.string().min(1)).min(1),
+});
+
 export const VolumeArchitectureSchema = z.object({
   id: z.string().min(1),
   title: z.string().min(1),
@@ -61,6 +78,13 @@ export const ArchitecturePayloadSchema = z.object({
   chapters: z.array(ChapterArchitectureSchema).min(1),
 });
 
+export const ArchitectureExtensionPayloadSchema = z.object({
+  fullUpdate: z.string().min(1).optional(),
+  volumes: z.array(VolumeArchitectureSchema).optional(),
+  volumePacing: z.array(VolumePacingBoardSchema).optional(),
+  chapters: z.array(ChapterArchitectureSchema).min(1),
+});
+
 export const ThreadActionSchema = z.object({
   kind: z.enum(['plant', 'build', 'pay', 'drop']),
   threadId: z.string().min(1).optional(),
@@ -181,6 +205,7 @@ export const ChapterAcceptanceGateSchema = z.object({
   characterProgress: ChapterAcceptanceCheckSchema,
   foreshadowProgress: ChapterAcceptanceCheckSchema,
   storyBibleConsistency: ChapterAcceptanceCheckSchema,
+  proseRhythm: ChapterAcceptanceCheckSchema,
   endingHook: ChapterAcceptanceCheckSchema,
   repetition: ChapterAcceptanceCheckSchema,
 });

package/src/core/steps/architectureExtension.ts

@@ -0,0 +1,88 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ArchitectureExtensionPayloadSchema } from '../schemas.js';
+import {
+  AgentState,
+  ChapterArchitecture,
+  VolumeArchitecture,
+  VolumePacingBoard,
+} from '../types.js';
+import { saveJsonFile, saveMarkdownFile } from '../projectStore.js';
+import { StepHandler, parseJson } from './types.js';
+
+async function readJsonArray<T>(projectPath: string, relativePath: string): Promise<T[]> {
+  try {
+    const raw = await readFile(join(projectPath, relativePath), 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed as T[] : [];
+  } catch {
+    return [];
+  }
+}
+
+function assertContiguousExtension(
+  state: AgentState,
+  existing: ChapterArchitecture[],
+  nextChapters: ChapterArchitecture[]
+): void {
+  const expectedStart = state.currentChapter;
+  const total = state.plannedTotalChapters ?? state.targetChapters;
+  const existingNumbers = new Set(existing.map((chapter) => chapter.chapterNumber));
+
+  for (let index = 0; index < nextChapters.length; index += 1) {
+    const chapter = nextChapters[index];
+    const expected = expectedStart + index;
+    if (chapter.chapterNumber !== expected) {
+      throw new Error(`architecture_extension chapters must start at chapter ${expectedStart} and be contiguous; expected ${expected}, got ${chapter.chapterNumber}`);
+    }
+    if (chapter.chapterNumber > total) {
+      throw new Error(`architecture_extension chapter ${chapter.chapterNumber} exceeds plannedTotalChapters ${total}`);
+    }
+    if (existingNumbers.has(chapter.chapterNumber)) {
+      throw new Error(`architecture_extension cannot overwrite existing chapter architecture ${chapter.chapterNumber}`);
+    }
+  }
+}
+
+function mergeByKey<T>(existing: T[], incoming: T[] | undefined, keyOf: (item: T) => string): T[] {
+  const map = new Map<string, T>();
+  for (const item of existing) map.set(keyOf(item), item);
+  for (const item of incoming ?? []) map.set(keyOf(item), item);
+  return [...map.values()];
+}
+
+export const architectureExtensionHandler: StepHandler = async (state, content) => {
+  const parsed = ArchitectureExtensionPayloadSchema.parse(parseJson(content));
+  const existingChapters = await readJsonArray<ChapterArchitecture>(state.projectPath, 'architecture/chapters.json');
+  assertContiguousExtension(state, existingChapters, parsed.chapters);
+
+  const chapters = [...existingChapters, ...parsed.chapters]
+    .sort((a, b) => a.chapterNumber - b.chapterNumber);
+  const existingVolumes = await readJsonArray<VolumeArchitecture>(state.projectPath, 'architecture/volumes.json');
+  const volumes = mergeByKey(existingVolumes, parsed.volumes, (volume) => volume.id)
+    .sort((a, b) => a.order - b.order);
+  const existingPacing = await readJsonArray<VolumePacingBoard>(state.projectPath, 'architecture/volume-pacing.json');
+  const volumePacing = mergeByKey(existingPacing, parsed.volumePacing, (board) => board.volumeId);
+
+  const savedPaths = [
+    await saveJsonFile(state.projectPath, 'architecture/chapters.json', chapters),
+    await saveJsonFile(state.projectPath, 'architecture/volumes.json', volumes),
+  ];
+
+  const hasVolumePacing = Boolean(parsed.volumePacing || existingPacing.length);
+  if (hasVolumePacing) {
+    savedPaths.push(await saveJsonFile(state.projectPath, 'architecture/volume-pacing.json', volumePacing));
+  }
+  if (parsed.fullUpdate) {
+    savedPaths.push(await saveMarkdownFile(state.projectPath, 'architecture/full.md', parsed.fullUpdate));
+  }
+
+  return {
+    savedPaths,
+    fileEntries: {
+      architecture: 'architecture/chapters.json',
+      ...(hasVolumePacing ? { volumePacing: 'architecture/volume-pacing.json' } : {}),
+    },
+    next: { kind: 'linear', nextStep: 'chapter' },
+  };
+};

package/src/core/steps/chapterReview.ts

@@ -6,6 +6,7 @@ import { StepHandler, parseJson } from './types.js';
 
 export const chapterReviewHandler: StepHandler = async (state, content) => {
   const parsed = ChapterReviewSchema.parse(parseJson(content));
+  const hasFailedAcceptance = Object.values(parsed.acceptance).some((check) => check.status === 'fail');
   const target = state.pendingAction?.chapterNumber ?? parsed.chapterNumber;
   const relative = join('reviews/chapter', chapterReviewFileName(target));
   const path = await saveJsonFile(state.projectPath, relative, parsed);
@@ -17,7 +18,7 @@ export const chapterReviewHandler: StepHandler = async (state, content) => {
     };
   }
 
-  if (parsed.status === 'clean') {
+  if (parsed.status === 'clean' && !hasFailedAcceptance) {
     return {
       savedPaths: [path],
       fileEntries: { [`review-chapter-${target}`]: relative },

package/src/core/steps/index.ts

@@ -1,4 +1,5 @@
 import { WorkflowStep } from '../types.js';
+import { architectureExtensionHandler } from './architectureExtension.js';
 import { architectureHandler } from './architecture.js';
 import { chapterHandler } from './chapter.js';
 import { chapterReviewHandler } from './chapterReview.js';
@@ -7,6 +8,7 @@ import { continuityReviewHandler } from './continuityReview.js';
 import { crossChapterReviewHandler } from './crossChapterReview.js';
 import { memoryCardHandler } from './memoryCard.js';
 import { novelMetadataHandler } from './novelMetadata.js';
+import { styleGuideHandler } from './styleGuide.js';
 import { storyBibleHandler } from './storyBible.js';
 import { StepHandler } from './types.js';
 
@@ -15,7 +17,9 @@ export type { StepApplyNext, StepApplyResult, StepHandler } from './types.js';
 export const STEP_HANDLERS: Partial<Record<WorkflowStep, StepHandler>> = {
   novel_metadata: novelMetadataHandler,
   story_bible: storyBibleHandler,
+  style_guide: styleGuideHandler,
   architecture: architectureHandler,
+  architecture_extension: architectureExtensionHandler,
   chapter: chapterHandler,
   memory_card: memoryCardHandler,
   continuity_review: continuityReviewHandler,

package/src/core/steps/memoryCard.ts

@@ -1,3 +1,4 @@
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { MemoryCardSchema } from '../schemas.js';
 import { saveJsonFile } from '../projectStore.js';
@@ -7,6 +8,19 @@ import { ingestMemoryCardThreads } from '../threadStore.js';
 import { applyCharacterUpdates } from '../characterStore.js';
 import { StepHandler, parseJson } from './types.js';
 
+async function maxPlannedChapter(projectPath: string): Promise<number> {
+  try {
+    const raw = await readFile(join(projectPath, 'architecture/chapters.json'), 'utf8');
+    const chapters = JSON.parse(raw) as Array<{ chapterNumber?: number }>;
+    return chapters.reduce((max, chapter) => {
+      const value = Number(chapter.chapterNumber);
+      return Number.isFinite(value) && value > max ? value : max;
+    }, 0);
+  } catch {
+    return 0;
+  }
+}
+
 export const memoryCardHandler: StepHandler = async (state, content) => {
   const parsed = MemoryCardSchema.parse(parseJson(content));
   const relative = join('memory', memoryFileName(state.currentChapter));
@@ -15,12 +29,20 @@ export const memoryCardHandler: StepHandler = async (state, content) => {
   await ingestMemoryCardThreads(state.projectPath, state.currentChapter, parsed.threadActions);
   await applyCharacterUpdates(state.projectPath, state.currentChapter, parsed.characterUpdates);
   const nextChapter = state.currentChapter + 1;
+  const plannedTotalChapters = state.plannedTotalChapters ?? state.targetChapters;
+  const plannedMax = await maxPlannedChapter(state.projectPath);
+  const nextStep =
+    nextChapter > plannedTotalChapters
+      ? 'continuity_review'
+      : nextChapter > plannedMax
+        ? 'architecture_extension'
+        : 'chapter';
   return {
     savedPaths: [path],
     fileEntries: { [`memory-${state.currentChapter}`]: relative },
     next: {
       kind: 'linear',
-      nextStep: nextChapter > state.targetChapters ? 'continuity_review' : 'chapter',
+      nextStep,
       statePatch: { currentChapter: nextChapter },
     },
   };

package/src/core/steps/storyBible.ts

@@ -9,6 +9,6 @@ export const storyBibleHandler: StepHandler = async (state, content) => {
   return {
     savedPaths: [path],
     fileEntries: { storyBible: 'story-bible.md' },
-    next: { kind: 'linear', nextStep: 'architecture' },
+    next: { kind: 'linear', nextStep: 'style_guide' },
   };
 };

package/src/core/steps/styleGuide.ts

@@ -0,0 +1,13 @@
+import { StyleGuideSchema } from '../schemas.js';
+import { saveJsonFile } from '../projectStore.js';
+import { StepHandler, parseJson } from './types.js';
+
+export const styleGuideHandler: StepHandler = async (state, content) => {
+  const parsed = StyleGuideSchema.parse(parseJson(content));
+  const path = await saveJsonFile(state.projectPath, 'style-guide.json', parsed);
+  return {
+    savedPaths: [path],
+    fileEntries: { styleGuide: 'style-guide.json' },
+    next: { kind: 'linear', nextStep: 'architecture' },
+  };
+};