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:

  ```yaml
  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.