sumeru-worldbuilder

Web Novel Creation World Builder (worldbuilder)

Trigger Keywords

I want to write a novel, Write a web novel, Create a novel from scratch, Help me write a novel of XX genre, I want to write a novel, Give me the entire novel creation process, Auto-write a novel, One-stop novel creation service, Help me finish a novel, How to write a novel with only an idea, Write a web novel from scratch, Full-process novel creation

Core Features

worldbuilder is a one-stop master skill for web novel creation, responsible for coordinating the complete creation chain from idea germination to final draft, and building a complete and unified story world. Through intelligent orchestration of the calling sequence and parameter transfer of each specialized skill, it achieves an automated, assembly-line web novel creation experience:

Topic Planning: Call
```
sumeru-topic
```
for market analysis, topic positioning, and generate core ideas and selling points
Outline Design: Call
```
sumeru-outline
```
to build a complete worldview, character settings, volume outlines, and detailed chapter outlines
Content Creation: Call
```
sumeru-write
```
to write chapter-by-chapter content according to the outline, maintaining a consistent style (Must complete all chapters before proceeding to the next stage)
Logic Review: Call
```
sumeru-review
```
to conduct a comprehensive review of all completed chapters, verifying timeline consistency, character behavior logic, and plot coherence
Content Polishing: Call
```
sumeru-polish
```
to optimize writing style, enrich details, and adjust pacing for all reviewed chapters
Finalization Check: Call
```
sumeru-finalize
```
to complete typo checking, punctuation standardization, final logical loophole排查, and work packaging for all polished chapters

⚠️ Global Constraint: Sub-Agent Parallel Processing Rules

When coordinating all sub-skills involving chapter-level operations, worldbuilder enforces the Sub-Agent Parallel Processing Rules defined in AGENTS.md:

Each sub-Agent is responsible for a maximum of 3 chapters (hard constraint, see AGENTS.md "Sub-Agent Parallel Processing Rules")

This rule applies to all the following stages:

Writing Stage (sumeru-write)
Review Stage (sumeru-review): Review and lightweight fixes
Polishing Stage (sumeru-polish)
Finalization Stage (sumeru-finalize)
Detailed Outline Generation (sumeru-outline)

Design Rationale: See AGENTS.md "Sub-Agent Parallel Processing Rules"

worldbuilder's Scheduling Responsibilities:

When calling each sub-skill, worldbuilder must ensure that the sub-skill follows the 3 chapters/Agent constraint
If the sub-skill does not automatically comply with this constraint, worldbuilder needs to enforce it through parameters or instructions
Monitor the execution process of sub-skills to confirm that Agent allocation meets the constraint

Skill Coordination Flow

worldbuilder is responsible for the following data flow and coordination work:

User Requirements
    ↓
[Collect Creation Requirements → Save to .sumeru/session/requirements.json]
    ↓
[sumeru-topic] Topic Planning
    → Output: Topic Planning Report.md, .sumeru/topic/options.json
    ↓
[sumeru-outline] Outline Design (**Generate complete detailed chapter outlines**)
    → Input: .sumeru/topic/options.json (optional)
    → Output: Novel Outline_*.md, .sumeru/outline/*.json (including chapter-outlines.json)
    ↓
[Stage Checkpoint 1] Check outline completeness, confirm detailed chapter outlines are generated
    ↓
[sumeru-write] Chapter Writing (**Outline-driven, parallel batch generation, max 3 chapters per Agent**)
    → Input: .sumeru/outline/chapter-outlines.json
    → Output: chapters/*.md, .sumeru/write/*.json
    → ✅ **Must complete all chapters** (Check that the number of chapters matches the outline)
    → ⚠️ **Follow global 3 chapters/Agent constraint**
    ↓
[Stage Checkpoint 2] Verify all chapters are completed, record writing progress
    ↓
[sumeru-review] Logic Review (**Review all chapters, max 3 chapters per Agent**)
    → Input: .sumeru/outline/*.json, chapters/*.md
    → Output: Plot Review Report.md, .sumeru/review/*.json, .sumeru/review/fix-plan.json
    → ✅ **Must complete full-book review**
    → ⚠️ **Follow global 3 chapters/Agent constraint**
    ↓
[Stage Checkpoint 3] Verify review completion, check if fix-plan.json has rewrite repair items
    ↓
{Does fix-plan.json have rewrite repair items?}
    →|Yes| [Call sumeru-write to rewrite specified chapters → Directly modify chapters/ (auto-backup to .sumeru/write/original/)]
    →|No| Continue
    ↓
[Review lightweight fixes have directly modified chapters/, no additional application steps required]
    ↓
[sumeru-polish] Content Polishing (**Polish all chapters, max 3 chapters per Agent**)
    → Input: chapters/*.md, .sumeru/review/*.json
    → Output: chapters/*.md (directly modified after polishing, auto-backup to .sumeru/write/original/), .sumeru/polish/*.json
    → ✅ **Must complete full-book polishing**
    → 📝 **Polishing results directly modify chapters/, auto-backup to .sumeru/write/original/ before modification**
    → ⚠️ **Follow global 3 chapters/Agent constraint**
    ↓
[Stage Checkpoint 4] Verify polishing completion
    ↓
[sumeru-finalize] Finalization Check (**Process all chapters, max 3 chapters per Agent**)
    → Input: chapters/*.md (already includes review fixes and polished content)
    → Output: publish/*, .sumeru/finalize/*
    → ⚠️ **Follow global 3 chapters/Agent constraint**

Key Stage Checkpoint Instructions

After each stage is completed,

WORKBUILDER_PROGRESS.json

is automatically updated. When the task restarts, it continues from the last unfinished stage:

Outline Stage: Confirm
```
chapter-outlines.json
```
is generated and contains a complete chapter list
Creation Stage: Check that the number of generated chapters in the
```
chapters/
```
directory matches the outline
Review Stage: Confirm
```
Plot Review Report.md
```
is generated and contains full-book review results, and confirm
```
fix-plan.json
```
is generated. Review lightweight fixes have directly modified
```
chapters/
```
, with auto-backup to
```
.sumeru/write/original/
```
before modification
Polishing Stage: Confirm polishing has directly modified files in
```
chapters/
```
. Auto-backup to
```
.sumeru/write/original/
```
before polishing modification
Finalization Stage: Confirm export of various platform formats in the
```
publish/
```
directory is completed

Data Sharing Mechanism

All skills share data through the

.sumeru/

directory:

```
session/
```
- Global session configuration, user requirements, progress status
```
topic/
```
- Topic data → Used by outline
```
outline/
```
- Outline data → Used by write, review
- chapter-outlines.json
  - Complete detailed chapter outlines → Used by write for parallel batch generation
```
write/
```
- Creation progress → Used by review
```
review/
```
- Review issues → Used by write, polish
```
polish/
```
- Polishing results → Used by finalize
```
finalize/
```
- Finalized work data

Execution Flow

mermaid

flowchart LR
    A[Receive Creation Requirements] --> B[Parameter Validation & Initialization]
    B --> C[Call topic for Topic Planning]
    C --> D[Call outline for Outline Design]
    D --> E[Call write for Complete Chapter Writing]
    E -->|✅ All Chapters Completed| F[Call review for Full-Book Logic Review]
    F --> G{Does fix-plan.json have rewrite items?}
    G -->|Yes| H[Call write to rewrite specified chapters]
    H --> I[Directly modify chapters/, auto-backup to .sumeru/write/original/]
    I --> J[Call polish for Full-Book Content Polishing]
    G -->|No| J
    J --> K{Polishing Confirmation?}
    K -->|No| L[Targeted Adjustment Polishing]
    L --> J
    K -->|Yes| M[Call finalize for Finalization Check]
    M --> N[Generate Creation Report & Work Files]
    
    subgraph Progress Saving
        O[WORKBUILDER_PROGRESS.json]
        E -->|Save Progress| O
        F -->|Save Progress| O
        J -->|Save Progress| O
        M -->|Save Progress| O
    end

Detailed Flow Explanation:

Initialization Phase: Validate input parameter validity, create working directories, initialize creation status, and create the
```
WORKBUILDER_PROGRESS.json
```
progress file
Requirements Collection Phase: Intelligently judge whether the information provided by the user is sufficient. If information is insufficient, automatically trigger interactive questions to guide the user to supplement requirements, then proceed to the next stage after confirming all requirements
Topic Phase: Generate 3-5 precise topic options based on the collected complete requirements for selection. After confirmation, proceed to outline design, and update the progress file upon completion
Outline Phase: First output worldview and character settings, then generate a complete outline and all detailed chapter outlines after confirmation. Update the progress file upon completion
Creation Phase: Batch create all chapters driven by the outline, supporting parallel generation. Must complete all chapters before proceeding to the next stage (follow global 3 chapters/Agent constraint). Update the progress file upon completion
Review Phase: Call
```
sumeru-review
```
to execute the three-stage review and repair process (follow global 3 chapters/Agent constraint):
- Phase 1: Global Review: Analyze overall plot脉络, timeline, setting consistency, conflict distribution, and foreshadowing resolution status
- Phase 2: Chapter Detail Review: Check word count, timeline, character OOC, item status, scene quality, and foreshadowing setup chapter by chapter
- Phase 3: Unified Repair:
  - Merge global and chapter issues, develop a repair plan based on severity
  - Execute lightweight fixes (text correction, paragraph adjustment, word count filling, etc.), directly modifying
    chapters/
    files (auto-backup to
    .sumeru/write/original/
    )
  - For chapters requiring rewrite repair, generate
    fix-plan.json
    to record issues and repair suggestions
- Word Count Check & Filling: In Phase 2, count word count chapter by chapter, automatically fill content for chapters with insufficient word count (enhance scene descriptions, enrich dialogues, supplement psychological activities, etc.)
- Auto-Fix All Issues: Not just raise issues, but automatically fix all lightweight issues
- worldbuilder reads
```
fix-plan.json
```
  , and if there are rewrite items, calls
```
sumeru-write
```
  to rewrite specified chapters, directly modifying
```
chapters/
```
- Re-verify after repair to ensure all issues are resolved
- Update the progress file upon completion
Polishing Phase: Call
```
sumeru-polish
```
for full-book content polishing (follow global 3 chapters/Agent constraint), providing multiple polishing style options (concise/detailed/lyrical/passionate, etc.)
- After polishing, directly modify files in
```
chapters/
```
  (auto-backup to
```
.sumeru/write/original/
```
  before modification)
- Record polishing process and results in the
```
.sumeru/polish/
```
  directory
- Update the progress file upon completion
Finalization Phase: Call
```
sumeru-finalize
```
to conduct finalization checks on all polished chapters (follow global 3 chapters/Agent constraint), read the final content from the
```
chapters/
```
directory (already includes review fixes and polished results), output multiple formats (Markdown/HTML/EPUB) to the
```
publish/
```
directory, generate a creation summary report, and update the progress file to the final completed status upon completion

Interactive Requirements Guidance

When the information provided by the user is too brief (only input genre and a few keywords), the system will automatically trigger interactive questions, guiding the user to clarify creation requirements step by step to ensure the generated content fully meets expectations.

Question Dimensions (by Priority)

Basic Information Confirmation (Mandatory)

🎯 Genre Confirmation: Confirm specific sub-genre, e.g., "Xuanhuan" → "High Martial Xuanhuan/Cultivation Xuanhuan/Other World Xuanhuan/System Xuanhuan"
📏 Expected Length: Confirm target word count/chapter count, whether it's short/medium/long/extra-long
🎯 Core Hook Points: The type of core excitement the user values most, e.g., "face-slapping/level-up/making money/romance/political intrigue"
👥 Audience Positioning: Target reader group, male-oriented/female-oriented/all-age, preferred age group

Core Setting Guidance (Optional, based on requirement depth)

🦸 Protagonist Setting Preferences: Protagonist personality (forbearing/arrogant/scheming/funny), identity (underdog/prodigy/reincarnator/reborn), preferred "golden finger" type
🎭 Antagonist Setting Preferences: Antagonist type (family enemy/sect rival/foreign race/heavenly way), antagonist strength
🌍 Worldview Preferences: Preferred worldview setting, whether there are specific liked/disliked settings
📖 Reference Works: Whether there are reference works with similar styles for more precise style matching

Style Preference Settings (Optional)

✍️ Writing Style: Preference for fast-paced爽文/detailed quality work/humorous work/dark depressing work
📱 Publishing Platform: Planned publishing platform, adapting to the platform's pacing and word count requirements
⚠️ Forbidden Content: Clear unwanted plots, settings, character types

Interaction Modes

Detailed Guidance Mode: Forcefully enable full interactive questioning, going through the complete requirement confirmation process even if the user provides sufficient information
Quick Mode: Only ask the 3 most core questions (genre confirmation, length, core hook points), use default values for others
Silent Mode: Turn off interactive questioning, generate directly based on existing information, suitable for users who clearly know their requirements

Requirements Confirmation Mechanism

All user answers are automatically saved to
```
.sumeru/session/user-requirements.json
```
, shared across all stages of the full process
After questioning is completed, generate a requirements confirmation summary, and start formal creation only after the user confirms it is correct
Support mid-process modification, users can adjust previous answers at any time

Guidance Example

> /worldbuilder Xuanhuan "Underdog Counterattack"
🤖 Let me help you refine your creation requirements, just answer a few simple questions:
1️⃣ What specific sub-genre of Xuanhuan do you want? [High Martial Xuanhuan/Cultivation Xuanhuan/Other World Xuanhuan/System Xuanhuan/Other]
> System Xuanhuan
2️⃣ What's the expected total word count? [Under 200k/200k-500k/500k-1M/Over 1M]
> Over 1M
3️⃣ What core hook points do you value most? [Face-slapping/Level-up/Hiding Strength/Recruiting Subordinates/Harem/Other]
> Face-slapping + Hiding Strength
4️⃣ Preferred protagonist personality? [Forbearing & Scheming/Arrogant & Domineering/Funny & Humorous/Gentle & Steady/Other]
> Forbearing & Scheming
5️⃣ Are there any favorite reference works? For example, a style similar to "XX"
> Similar to the funny style of "King of Slaughter"
...

✅ Requirements collection completed, let's confirm:
Genre: System Xuanhuan
Length: Over 1 million words
Core Hook Points: Face-slapping + Hiding Strength
Protagonist Personality: Forbearing & Scheming
Style Reference: Funny style of "King of Slaughter"
Confirm? [Y/n]
> Y
🚀 Start creation!

Parameter Description

The following information is required for creation:

Work Genre (Required): e.g., Xuanhuan, Urban, Xianxia, Sci-Fi, Romance, Mystery, etc.
Core Idea Keywords (Required): Core idea keywords, support multiple keywords connected with "+", e.g., "Underdog Counterattack+System Flow+Son-in-law"

Optional Information (use default values or auto-generate if not provided):

Work Title: Auto-generate if not provided
Expected Length: Short (under 200k words)/Medium (200k-500k words)/Long (500k-1M words)/Extra-long (over 1M words), default is Medium
Writing Style: Fast-paced/Balanced/Detailed/Literary, default is Balanced
Overall Tone: Humorous/Serious/Inspirational/Dark, default is Neutral
Output Directory: Output directory path for the work, default is ./output
Resume Creation: Pass the session ID of the last creation session to resume from the breakpoint
Skip Stages: Skip specified stages (topic/outline/write/review/polish/final), suitable for continuation or team division of labor

Usage Examples

Basic Usage

# Simplest call method, only specify genre and keywords
/worldbuilder Xuanhuan "Underdog Counterattack+System Flow"

# Urban romance work, specify title
/worldbuilder Romance "Domineering CEO+Contract Relationship" title"The CEO's Contract Bride"

# Sci-fi mystery, long length, fast-paced style
/worldbuilder Sci-Fi "Time Loop+Locked Room Puzzle" long fast-paced

Advanced Usage

# Complete call with detailed parameters
/worldbuilder Xianxia "Rebirth+Invincible Flow+Sect" title"Rebirth of the Supreme Sect Leader" long detailed-style inspirational-tone

# Resume creation from breakpoint
/worldbuilder Xuanhuan "Underdog Counterattack+System Flow" resume-last-session

# Skip topic stage, continue creation directly from existing outline
/worldbuilder Urban "Workplace+Rebirth" skip-topic-stage

Multi-Style Combination

# Humorous urban cultivation
/worldbuilder Urban "Cultivation+Part-time Job+Funny" balanced-style humorous-tone

# Dark mystery推理
/worldbuilder Mystery "Serial Murder+Psychological Profiling+Twist" detailed-style dark-tone

# Passionate inspirational sports
/worldbuilder Sports "Basketball+Talent+Counterattack" fast-paced inspirational-tone

Error Handling Instructions

Common Error Types and Solutions

Error Code	Error Message	Cause Analysis	Solution
`INVALID_GENRE`	Unsupported work genre	The passed genre parameter is not in the supported list	Check genre spelling. Supported genres: Xuanhuan, Urban, Xianxia, Sci-Fi, Romance, Mystery, History, Game, Sports, Military, Wuxia, Light Novel
`KEYWORDS_TOO_LONG`	Keywords too long	The keywords parameter exceeds the 100-character limit	Simplify keywords, keep the core 3-5 keywords
`DEPENDENCY_MISSING`	Missing dependent skills	Required sub-skills (such as topic) are not installed	Run `/find-skills` to find and install all dependent skills
`OUTPUT_DIR_PERMISSION`	No permission for output directory	The specified output-dir has no write permission	Change to a directory with permission, or use the default directory
`INVALID_SESSION_ID`	Invalid session ID	The session ID passed in the resume parameter does not exist	Check if the session ID is correct, or start creation again
`STAGE_SKIP_CONFLICT`	Stage skip conflict	The skipped stage has dependencies with subsequent stages	Remove the skip of the prerequisite stage, or provide necessary prerequisite files
`CONTENT_GENERATION_FAILED`	Content generation failed	Content review or model restrictions encountered during creation	Adjust keywords or style parameters, or confirm manually stage by stage

Error Recovery Mechanism

Auto-Retry: Automatically retry 3 times with 5-second intervals for temporary network errors
Breakpoint Saving: Automatically save status after completing each stage, supporting resume from breakpoint
Rollback Option: Roll back to the previous node to restart for unsatisfactory stages
Error Report: Generate a detailed error log file located at
```
{output-dir}/error.log
```

Advanced Usage Scenarios

Scenario 1: Team Collaborative Creation

# After planning completes topic and outline, hand over to writer
/worldbuilder Xuanhuan "Underdog Counterattack+System Flow" skip-writing, skip-review, skip-polish, skip-finalize stages

# Writer takes over, continues from creation stage
/worldbuilder Xuanhuan "Underdog Counterattack+System Flow" skip-topic, skip-outline stages resume-last-session

Scenario 2: Multi-Version Comparison Creation

# Generate multiple versions for comparison
/worldbuilder Romance "Time Travel+Palace Intrigue" title"Qing Palace·Legend of Zhen Huan" literary-style
/worldbuilder Romance "Time Travel+Palace Intrigue" title"Qing Palace·Startling by Each Step" fast-paced

Scenario 3: Customized Series Works

# First installment
/worldbuilder Xuanhuan "System+Level-up" title"The Martial Emperor Arrives" medium

# Second installment (reuse worldview)
/worldbuilder Xuanhuan "System+Level-up" skip-topic, skip-outline stages resume-last-session title"The Martial Emperor Arrives 2"

Scenario 4: A/B Testing Optimization

# Test different opening styles
/worldbuilder Urban "Rebirth+Business War" skip-writing, skip-review, skip-polish, skip-finalize stages
# Manually modify opening settings in the outline, then continue
/worldbuilder Urban "Rebirth+Business War" skip-topic-stage resume-last-session

Scenario 5: Batch Generate Material Library

# Generate multiple topic options for later selection
/worldbuilder Xuanhuan "Underdog" skip-outline, skip-writing, skip-review, skip-polish, skip-finalize stages
/worldbuilder Xuanhuan "System" skip-outline, skip-writing, skip-review, skip-polish, skip-finalize stages
/worldbuilder Xuanhuan "Rebirth" skip-outline, skip-writing, skip-review, skip-polish, skip-finalize stages

Data Persistence Specification

All intermediate state data is uniformly stored in the

.sumeru/

directory of the current working directory to avoid data loss caused by context compression or cleanup:

Global Storage Structure

.sumeru/
├── session/          # Global session data
│   ├── config.json   # Creation configuration parameters
│   ├── status.json   # Current progress status
│   └── history.log   # Operation history record
├── topic/            # Topic stage output
│   ├── report.md     # Complete topic planning report
│   └── options.json  # Raw data of multiple topic options
├── outline/          # Outline stage output
│   ├── world.md      # Worldview settings
│   ├── characters.json # Character setting cards
│   ├── plot.md       # Plot outline
│   ├── plot-outline.json # Structured plot outline data
│   └── chapter-outlines.json # **Complete detailed chapter outlines (core output)**
├── write/            # Creation stage output
│   ├── draft/        # Chapter drafts
│   ├── original/     # Original chapter backups (auto-backup before review/polish modification)
│   └── progress.json # Creation progress tracking
├── review/           # Review stage output
│   ├── timeline.json # Timeline data
│   ├── issues.json   # Issue list
│   ├── fix-plan.json # Rewrite repair plan
│   └── plot-map.json # Plot脉络图
├── polish/           # Polishing stage output
│   └── diff.json     # Modification comparison record
└── finalize/         # Finalization stage output
    ├── clean/        # Clean full text
    ├── platforms/    # Platform-specific export versions
    └── report.md     # Finalization check report

Progress Saving Mechanism (WORKBUILDER_PROGRESS.json)

json

{
  "session_id": "session-20240315-abc123",
  "created_at": "2024-03-15T10:00:00",
  "updated_at": "2024-03-15T14:30:00",
  "current_stage": "review",
  "stages": {
    "topic": {
      "status": "completed",
      "completed_at": "2024-03-15T10:15:00",
      "output_files": [
        "Topic Planning Report.md",
        ".sumeru/topic/options.json"
      ]
    },
    "outline": {
      "status": "completed", 
      "completed_at": "2024-03-15T11:20:00",
      "output_files": [
        "Novel Outline_Xuanhuan System Flow.md",
        ".sumeru/outline/chapter-outlines.json"
      ]
    },
    "write": {
      "status": "completed",
      "completed_at": "2024-03-15T13:45:00",
      "output_files": [
        "chapters/001-Underdog Awakens System.md",
        "chapters/002-System Sign-in Reward.md",
        ".sumeru/write/progress.json"
      ],
      "statistics": {
        "total_chapters": 100,
        "completed_chapters": 100,
        "total_words": 520000
      }
    },
    "review": {
      "status": "completed",
      "completed_at": "2024-03-15T14:45:00",
      "output_files": [
        "Plot Review Report.md",
        ".sumeru/review/issues.json",
        ".sumeru/review/fix-plan.json"
      ],
      "statistics": {
        "total_issues_found": 8,
        "critical_issues": 2,
        "issues_fixed": 6,
        "issues_rewritten": 2
      },
      "fix_plan_generated": true
    },
    "polish": {
      "status": "in_progress",
      "started_at": "2024-03-15T15:00:00",
      "progress": "60%",
      "polish_level": "moderate",
      "style": "Light爽文"
    },
    "finalize": {
      "status": "pending"
    }
  }
}

Data Lifecycle Management

Auto-Save: Automatically write data to the corresponding directory after completing each stage, supporting idempotent writing
Progress Tracking: Automatically update
```
WORKBUILDER_PROGRESS.json
```
after each stage is completed, recording stage status and completion time
Version Control: Automatically generate version snapshots at key nodes, named in the format
```
{stage}-{timestamp}.json
```
Breakpoint Resume: Automatically read corresponding stage data from the
```
.sumeru/
```
directory when resuming creation
Cleanup Rules: Support cleaning all intermediate data, default to keep the latest 3 versions
Data Reuse: Directly reference
```
.sumeru/
```
directory data from other projects to achieve worldview/character setting reuse

Advanced Configuration: Custom Stage Hooks

Custom processing can be inserted before and after each stage through the configuration file

{output-dir}/hooks.json