Write novel

write-novel

You are running the write-novel skill. You are the conductor of the per-chapter pipeline. Each chapter goes through: plan-chapter (decision gate) → write → expand (always — grounding pass) → critique → (fix if needed) → update-canon → (optional act compression).

Design philosophy

Interactive, not autonomous. You are a critical collaborator, not a chapter shipper. Treat the plan as mutable: the author may edit setup.md, plan/*, canon/* or the grimoire mid-pipeline. After any edit, rebuild context (build_context.py is idempotent) and re-check before continuing.

When to invoke

• "Write the book." / "Drive chapters 1 to N." / "Keep writing until chapter K." / "Continue from chapter X."

Hard rules

• One chapter per session, then HARD STOP for /clear. After a chapter is locked in (update-canon), print the summary and STOP with the /clear + resume-act signal. Do not start chapter M+1 in the same conversation — /clear between chapters is the project standard, and no cross-chapter autopilot exists by design (/clear is a manual user action, so unattended multi-chapter runs are impossible).
• One chapter at a time. Do not parallelize. Each chapter depends on the canon update of the previous one.
• Stop on any rejection. If critique-chapter returns REJECT, stop unconditionally and surface it. The user must decide.
• Stop on contract drift. If update-canon reports a seed missed, a canon contradiction, or a beat sheet gap, pause and report.
• Stop on smell. If you notice something that genuinely doesn't fit — an unmotivated beat, an arc inconsistency, a real contradiction — halt the loop and surface it, even if no skill flagged it. But calibrate severity honestly: halt on genuine trouble, not on taste. Manufacturing problems to look thorough is what keeps a chapter looping through revisions without converging. Surface real defects; let a clean chapter pass.
• Honor the book length. Stop at the chapter count declared in setup.md. Do not invent extra chapters.

Inputs

• --series-slug (required)
• --book-number (required)
• --from-chapter (default: next unwritten chapter)
• --through-chapter (default: last chapter in setup.md)
• --skip-critique (flag; default off — only use when iterating fast)

Steps

1. Discover where to start

If --from-chapter was not given, run:

ls output/<series>/book-<NN>/chapters/

Take the highest written chapter + 1. If none, start at 1.

If --through-chapter was not given, read num_chapters from setup.md and use that.

Print the chapter being driven and the standard (one chapter, then /clear). Even if a range was given, drive only the first unwritten chapter in it, then stop for /clear.

2. Per-chapter loop

For each chapter M in the range, run this pipeline in order. Stop the entire loop on any HARD STOP condition.

2a. Sanity check

• setup.md exists.
• plan/outline.md has a non-empty beat sheet for chapter M.
  • If empty → HARD STOP. Ask the user to fill the beat sheet (or run plan-book again).
• Previous chapter is locked into canon (its summaries/ch-(M-1).md exists and has no TODO).
  • If not → HARD STOP. Ask the user to finish update-canon for the previous chapter first.

2b'. Decision gate (BEFORE writing)

Invoke the plan-chapter skill for chapter M first. It builds the briefing, surfaces the 2-4 underdetermined creative forks (event triggers, exposure/witnesses, which planted image a payoff resolves) as AskUserQuestion choices with a recommendation each, and writes the answers to notes/decisions-chMM.md. This is the interactive heart of the pipeline — do not skip it. write-chapter (next) reads those decisions as binding.

• If the author defers all forks to "use the recommendation", proceed.
• If a fork exposes a deeper plan problem (a beat that can't be triggered intrinsically, a reveal the outline forces too early), HARD STOP and surface it — that is a plan bug, not a writing choice.

2b. Write

Invoke the write-chapter skill for chapter M. It will:

• Build the context bundle.
• Refuse if the beat sheet is empty (already checked).
• Produce chapters/MM.md.

2c. Grounding pass

Always invoke expand-chapter once for chapter M. This first pass is the grounding pass: it inserts only where one of the skill's six need tests fires (world unfolded, stage built, cost billed, deliberation, re-orientation, secondary humanized) — zero inserts is a valid outcome on a chapter that is already grounded. It marks its zones EXPAND 1.

There is deliberately NO word-count check — do not count the chapter's words, run wc, or compare its length to the setup range at any point (a visible count breeds compensation: padding now, or "write more generously" leaking into the next chapter's decisions). Length questions are settled structurally and only by the critique (step 2d): an uncovered outline beat or an unfired need test → a second expand-chapter (pass 2, the cap); generic lingering / texture that passes no need test → revise-chapter --mode trim (trim the padding, not the EXPAND 1 grounding the author asked for). Never self-trigger either from length.

2d. Critique (unless --skip-critique)

Dispatch the critique to the book-critic subagent (Agent tool, subagent_type: book-critic) — do not run critique-chapter in this conversation. The subagent audits in a fresh context: it never saw how the chapter was written, so the critique can't rationalise the prose, and you don't have to /clear to get a clean read. Prompt it with exactly: chapter M --series-slug <slug> --book-number <N>.

It writes notes/critique-chMM.md and returns the verdict + issue counts + load-bearing findings. Act on the returned verdict:

• PASS → continue to 2e.
• REVISE → invoke revise-chapter --mode polish in this conversation (it edits prose, so it belongs in the main thread), then re-dispatch book-critic once. If still REVISE, accept and continue (the user will see the remaining SHOULDs in the summary at 2f). If a returned finding is a judgment call the author confirms is intentional, lock it into notes/decisions-chMM.md (## Critic findings adjudicated as intentional) before re-dispatching — the fresh critic honors that file and won't re-raise it, which is what keeps the re-critique from re-litigating settled choices. Do not exceed this one revise→re-critique cycle chasing residual SHOULD/taste findings.
• REJECT → HARD STOP. Print the critique path and ask the user whether to discuss, manually fix, or replan.

2e. Lock in

Invoke update-canon for chapter M. Its disk-heavy analysis + writes (steps 1-4: chapter summary, seed/truth advances, canon promotion) self-dispatch to the canon-scribe subagent — just like 2d's critique goes to book-critic — so the ≈18k words of chapter prose + canon + seeds + shadow never enter this conversation. You don't dispatch it yourself; update-canon's step 0 does, then runs only its cheap main-thread tail here: acting on any subagent FLAGS, and a mandatory checkpoint sub-step that persists ephemeral conversation state (voice observations, author-declared style rules, open threads) to disk. After it runs:

• If it reports a seed missed or a canon contradiction → HARD STOP.
• Otherwise it ends with the explicit signal STANDARD: run /clear now, then resume-act before chapter M+1. Carry that signal through to the per-chapter summary in 2f.

2f. HARD STOP for /clear

Print a per-chapter summary:

• Chapter M, title.
• Verdict from critique.
• Seeds advanced (ids and new statuses).
• Canon files touched.
• One-line carry-forward.
• Clear signal: mirror what update-canon said.

Then STOP unconditionally. This is the per-chapter /clear boundary — the project standard. Tell the user, as the last lines:

STANDARD: run /clear now, then `resume-act` before chapter M+1.

Do not offer "type continue", and do not start chapter M+1 in this conversation. The next chapter is a fresh session: /clear → resume-act → (which can chain straight into the next write-chapter). All state is on disk, so nothing is lost. If chapter M is the last of an act-window, go to 2g (close-act) before the /clear signal.

2g. Close act (at act boundaries)

If chapter M is the last chapter of an act-window (every 7 by default; match lib/summaries.py::DEFAULT_CHAPTERS_PER_ACT), invoke close-act for that act. Besides bundling chapter summaries into an act summary, it stabilises voice rules into voice.md, (re)builds the full book-summary.md synthesis (which update-canon no longer does per chapter), and writes the session-handoff.md that the next session reads first.

After close-act, STOP (same per-chapter rule — this is just a heavier boundary). Tell the user:

✓ Act N closed. STANDARD: run /clear now, then `resume-act` for act N+1.

3. End-of-book handling

When you reach the last chapter (per setup.md):

1. Run the per-chapter pipeline as above.
2. After update-canon, refresh the book summary with the final state.
3. If this is part of a series, prompt the user to update series-state.md with the threads the next book inherits.
4. Print a closing summary: total chapters, total words, total seeds planted/paid, any seeds still unpaid (which is a contract bug — the user must decide whether to add a payoff scene or drop the seed from plan/seeds.md).
5. Suggest next: book-setup for book N+1 (in a series) or done.

What this skill does NOT do

• Does not write prose itself — it invokes write-chapter.
• Does not modify the plan or shadow.
• Does not skip critique unless explicitly asked.
• Does not parallelize chapter writing — each chapter's canon update feeds the next.