OpenWriterControle/novel/.opencode/command/init.md

description
Initialize a new novel project — interactive scaffolding wizard

/init — Project Scaffolding

Initializes a new novel/series project with the OpenNovelWriter structure.

Concept: one vault, one folder per book

All books live as folders inside one container vault (e.g. "Novels"). A book folder is the workspace: the author creates the folder, opens it as the opencode workspace, and runs /init THERE.

/init scaffolds into the current directory — it does NOT create a nested subfolder. The folder's name is the project name; the "series title" question below is metadata (and may differ from the folder name).

The agent pack (.opencode/) is shared and inherited from the vault root. Never create a copy inside a book folder.

Workflow

Run the wizard interactively. The first question determines the language; all further questions are asked in that language.

Step 0: Confirm the workspace

The current directory IS the book's workspace. Confirm the folder name with the author (it is the project/series name). Do NOT create a subfolder — scaffold directly into the current directory.

Then confirm the shared pack is reachable: an .opencode/ directory must exist in an ancestor directory (the container vault root). opencode finds it by walking up. If there is none, STOP and tell the author to set up the shared pack — never seed a local .opencode/ in the book folder.

Step 1: Ask the writing language (always first)

"Which language will you write in? (e.g. Deutsch, English, Português)"

The author answers. From now on you ask all questions and produce all content in that language. Map the language to its ISO code in .opencode/languages.yaml.

Step 2: Strategic questions (in the chosen language)

Ask these questions one at a time. Record the answers:

1. The baseline telling — the most important question, and the one the author is most likely to want to speak rather than type:

   "Tell me the story — what happens, from the beginning to the end? Take your time."

   Say explicitly that a spoken telling is welcome: many authors dictate into a note app and paste the transcript. If the author pastes one, keep it verbatim in DATA/plot.md §3 — do not tidy it, ASR errors and all; it is the author's voice.

   Then split it into:

   • plot.md §1 Backbone — the beats that must happen, one per line;
   • plot.md §2 Side stories — every thread that is not the main line: whose story it is, which books it spans, its status. Ask "What else is going on besides the main line?" — side stories are expected, not optional.

   Keep asking until the author says there is nothing left to tell. The telling is the seed for the wiki and the timeline, and the baseline every chapter is measured against.

2. Series title (for metadata; defaults to the folder/workspace name)

3. Sequel or standalone?

   • Sequel → "How many books are planned?" (creates 01 … NN)
   • Standalone → only 01

4. Publication languages (multiple allowed; default: the writing language)

5. Genre (fantasy, sci-fi, mystery, …)

6. Target audience / age (children, young adult, adult)

7. Author (name)

8. (optional) Target chapter length (characters per chapter, if the author has one)

Step 3: Generate the structure

Scaffold into the current directory (the workspace/vault the author already created and named):

. (the book folder inside the container vault)
├── AGENTS.md          (this book's metadata; from the template)
├── 01/                (one per book, numbered; title optional, renamed later)
│   ├── DE/            (one folder per publication language, ISO code)
│   ├── EN/
│   └── images/
│       ├── prompts/   (image prompts, one .md per image)
│       └── generated/ (generated image files)
├── 02/  …  (if a sequel)
├── DATA/
│   ├── wiki.yaml.md
│   ├── timeline.yaml.md
│   ├── glossary.yaml.md
│   └── style.md
├── README.md

.opencode/ is deliberately absent here — the pack is shared at the vault root.

• Book folders: numbers only (01, 02). Titles are added later by renaming.
• Language folders: ISO codes only (DE, EN, PT).
• Images: each book gets images/prompts/ and images/generated/.
• Chapter files: create NONE yet. They are created when writing.

Step 4: Populate the DATA files

• plot.md → §1 backbone beats from the telling, §2 the side-story register, §3 the verbatim transcription if the author dictated. The agent measures every chapter against this file, so never leave §1 or §2 empty.

• wiki.yaml.md → meta: block with the answers from Step 2 (title, author, canonical, languages, genre, audience). concept.premise: gets the SHORT premise — plot.md holds the long form.

• timeline.yaml.md → story: MUST be seeded with the premise as the first entry. Do NOT leave it empty. Example:

  story:
    - event: "PREMISE from Step 2 question 1"
      # date optional; add `book: 1` if a sequel
  

  history: stays empty.

• glossary.yaml.md → empty terms: list.

• style.md → placeholder with a note that the StyleAnalyst will extract the voice from sample chapters later.

Verification (mandatory): before finishing, re-read the generated timeline.yaml.md and confirm story: contains the premise. If it is empty, fill it before proceeding.

Step 5: Generate AGENTS.md + README.md

• AGENTS.md → from the answers: canonical language, publication languages, genre, audience, structure note (references docs/SCHEMA.md).
• README.md → human-readable project overview.

Step 6: Finish

Report to the author:

Project "[Title]" created.

Structure:
  - 0N books (numbers; add titles by renaming)
  - languages: DE, EN
  - DATA/ with wiki, timeline, glossary, style

The premise has been seeded into the world wiki and timeline.

Next steps:
  1. Open the project in Obsidian.
  2. Start telling the story right away:
     "Write Chapter 001: [what should happen]".
     (The world builds itself in the background as you write.)

Step 7: Hand over to the author

After reporting, remind the author that the world is built in the background — they do not need to answer world-building questions. They can simply start telling the story:

You can start telling the story right away — I'll build the world in the
background as we go.

Just say: "Write Chapter 001: [what should happen]".

Do NOT offer an interactive world-building questionnaire. If the author wants to define the world up front, they will say so — otherwise, infer it from the story as chapters are written.

Rules

• Scaffold INTO the current directory (the workspace/vault) — never create a nested [Series Title]/ subfolder. The vault's own name is the project name.
• The FIRST question is ALWAYS the writing language; everything after is in that language.
• The SECOND question is ALWAYS the basic plot/premise — it is the seed for the world.
• The premise MUST be written into BOTH wiki.yaml.md (concept.premise) AND timeline.yaml.md (story: first entry). Never leave story: empty.
• Book/language folders ALWAYS as number resp. ISO code — never force a title.
• YAML keys English, values in the canonical language (see SCHEMA §4).
• No chapter files during init — they are created when writing.
• NEVER copy the agent/command files into the book folder. The pack is shared and inherited from the vault root; a local .opencode/ forks the agents and drifts out of date.