# Changelog

All notable changes to this project are recorded here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

## [0.1.1] - 2026-10-17

### Fixed

- **Models that refuse a temperature (ChatGPT's GPT-6.1 Sol).** Every call the Studio makes outside an agent's run — digests, reviews, a chapter written in one request — sends the role's temperature, and DSH passes it on as it is. ChatGPT's endpoint answers `Unsupported parameter: temperature` (HTTP 400), so on a ChatGPT subscription every such call failed. A route that refuses one now gets the call again without it, and is sent none after that (`src/host/llm-backend.ts`); the record of calls no longer says a temperature went where none did, on direct routes either (`LlmResponse.unsent`).
- **A batch that writes goes on when a digest fails.** Written one after the other, each chapter waited for the digest of the one before, and a digest that failed kept every chapter after it from being written: asked for three chapters, the batch wrote one. A chapter now waits for that digest to be over, however it ended, and is written from the text before it where it failed — its cell says so (*the chapter before is not in memory: written from its text*). A chapter that could not be written still keeps the next from being written (`BatchStep.waits`).

## [0.1.0] - 2026-10-17

### Added

- **GPT-6.1 Sol by default on a ChatGPT subscription.** The one-click puts the writer and the crew on GPT-6.1 Sol (recommendations issue 4). DSH 0.2.0-rc.2's model catalog does not have it yet; where DSH's own `openai-codex` route lacks it, the one-click declares it in the route's profile — a `models` list of the catalog's models by id, and GPT-6.1 Sol with its context window (500k), output cap, input and reasoning levels, taken from the recommendations' new `newer` entries (`ChatGPTSetup.declareModels`). A later DSH whose catalog has it is left as it is; so is a route Codex Connect serves.
- **ChatGPT Plus / Pro in one click.** DSH can sign in to ChatGPT by itself — its model adapter (`dsh-llm-pi-ai`) carries the flow for the `openai-codex` route — but none of its pages starts it. The guide page's first card, **ChatGPT subscription (Plus / Pro)**, does: *Sign in with ChatGPT and set up* runs DSH's own sign-in through its authorization seam (the grant stays in DSH's credential store, renewed by DSH; the Studio keeps no copy) and shows the page to open, with a box for the address the browser landed on when it cannot come back to `localhost:1455`, and a device code as the other way. Once signed in, the card adds the route to DSH's model settings (named *ChatGPT*), puts the writer and the crew on its models (GPT-6 Sol for both, from the recommendations' new `text` table; two fields to choose others), makes the writer's model DSH's default for new conversations on a first setup (a box), and has pictures drawn by the subscription's GPT Image. *Sign in again* and *Sign out* are on the card. Where Codex Connect serves the route, its own sign-in is used and nothing is signed in. The showrunner's `novel_settings action=setup service=codex` does the same where ChatGPT is signed in, and sends the author to the guide page where not (`src/host/chatgpt.ts`, `ChatGPTCard`). Step by step: `docs/chatgpt.md` / `docs/chatgpt.zh.md`.
- **Pictures on DSH's own ChatGPT sign-in.** A third bridge for `image.provider: codex`, `dsh`: the grant DSH keeps (`llm-pi-ai/openai-codex`) asks the image endpoint Codex's own image client uses (`…/codex/images/generations`; `…/images/edits` with up to five reference pictures), renewing a grant near its end in DSH's store under its lock first. *Automatic* takes Codex Connect, then DSH's sign-in, then the Codex CLI. Recommendations issue 3.

- **The showrunner opens the page of somebody or something.** `novel_show` takes `of` — a character or an entry of the world, by id, name or alias — and opens its page in the Read view (people or world). A name nobody has is an error, so the showrunner can no longer say a page is open when it opened the list instead (`src/agent/tools/studio.ts`, `store.navigate`).
- **A picture's caption is the director's.** When the director frames a picture it also writes a caption — the moment and who does what, in the book's language, without shot size, angle or light — and a picture put into the text is captioned with it (up to 120 characters, cut at a full stop). Where there is none, an opening sentence that only frames the shot ("Medium shot, eye-level view.") is dropped from the description used instead (`captionFrom`).
- **A README for strangers, and a website.** The two READMEs are rewritten for somebody who has never heard of the project: what it is, two books to read online, the crew, the highlights with screenshots (the English one of *Alice's Adventures in Wonderland* in the English interface, the Chinese one of 《红楼梦》), install, quick start. The long feature notes moved to `docs/features.md` / `docs/features.zh.md`. Covers, banners and the social preview are in `art/` and `docs/images/`; the project page is <https://whalesong.xuhao1.me>, with both books published from the Studio.
- **Reviews and revisions start from four layers, steadiest first — and nothing is proposed twice.** A review of a chapter used to start from the earlier text word for word, as much as half the model's window holds, at every step of an agent that had tools to read with anyway; whoever then settled the changes read the chapter again from a pack of its own; and nobody was told what was on file, so a second look filed the same fault again and had it mended again — two proposals for one sentence, in the same direction.
  - **Four layers** (`src/core/pipelines/editorial.ts`): the book's base (what it is, its style and what the author added for whoever writes it, the author's notes, everybody and everything of the bible a line each, the outline, the threads still open), the story so far as a summary a chapter (only ever added to at its end), the chapter in hand (its plan, where its people stood before it, how the chapter before ends, its text), and what this piece of work is about, said last. The planner's revision task is laid out the same way, the author's sentence last. On a copy of an 84-chapter book: chapter 41's review began at 333k tokens and begins at 53k; chapter 84's, 503k against 74k.
  - **Claims rest on quotes.** An issue that says the chapter is at odds with something (continuity, timeline, world, character) quotes the words and says where they stand (`ReviewIssue.against`); they are looked for there (`checkEvidence`) — sent back where they are not found, let go of after two sendings; an issue that quotes nothing is filed and marked unchecked (`unverified`). The card shows what an issue rests on. `book_find` lists every place some exact words stand, in one call. `context.readTokens` (40k unless set; a book may have its own) caps what a review or a revision reads with its tools.
  - **What is on file is said** (`onfile.ts`): the issues still open, the changes that wait (what they replace, with what, for which issue), the changes the author turned down — to every review and every pass of the planner. A new review keeps what is on file unless it says the text no longer has it (`gone`), or the words it quoted are gone; an issue said again keeps its id and what waits for it. **One place, one change that waits** (`proposeSpan`): the same words again are no new proposal; other words take the earlier one's place (turned down, it comes back).
  - **The reviewer closes what it can** where reviews hand their findings on: a small change written out is the proposal as it stands (`wroteBy: analyst`, no further call); a passage described goes to the writer, who is handed the place, what stands around it and what the reviewer said — nothing of the book is packed again (`material: 'place'`, also for places the planner hands over); what takes a change in another chapter goes to the planner (`wider`), with that chapter's text along; what is the author's to decide waits. The issue card has one *Revise* button that does what the review said; *Through the book*, *Rewrite the quoted place anew* and *Rewrite the whole chapter* are in its menu.
  - **Accepting a change settles the issues it names** — no call; only open issues whose words it moved are read again. A change applied outright (by the showrunner, by a round of writing in rounds) settles its issues the same way.

- **What follows by itself can be switched for one book.** The six things the Studio does unasked once text is written, changed or reviewed — a chapter digested (`autoDigest`), the names without a card looked through after digests (`siftCast`), suggestions for the bible settled by the planner (`settleSuggestions`), a plan set by its text (`plansFollow`), what a review found mended (`reviewMends`), open issues read again once a revision is accepted (`recheckIssues`) — were switches for every book alike: a long book taken in was digested chapter by chapter because a short one was. Each can now be a book's own — the same names in its `novel.json`, `true` or `false`; absent, the Studio's holds. *Done by itself* is a section on both sides of the settings page: under *This book* each switch reads *As for every book: on / off*, *This book: on* or *This book: off*; what a book has of its own is listed at the top of the page with a way back, and said beneath the switch on the Studio's side. Every place that starts such work asks for the book in hand (`NovelCore.autoFor`, `autoOf`): the digest after an edit, a revision accepted, a chapter written or gone through; the look through the names; the settling; the plan; the mending after a review (one chapter or a batch); the reading again. The writing page, the overview and the batch dialog say *digests are off* by what holds for the book; the small menu beside the review buttons flips the book's own switch where the book has one. For a role: `novel_settings action=book fields.autoDigest=false` (null: the Studio's again), and `action=get` says what holds for the book in hand; the showrunner's status says of this book whether its chapters are digested by themselves.
  - The settings page writes `siftCast`, `settleSuggestions`, `plansFollow`, `reviewMends` and `recheckIssues` into the file only where one was set, as it does the settings of writing and revising.
- **Who writes a revision is told place by place.** A change made by places had two ways: the crew's model wrote every place itself, or the writer's model rewrote every place — a word put right as much as a paragraph written new, each with what stands around it sent again. `mendBy` has a third, `auto`, and it is what holds where nothing is set: **the planner tells, place by place** — a small change (a word put for another, a name or a number put right, half a sentence gone, a sentence or two added) it writes itself, and that is the proposal; a place where a passage is to be written new or over it hands to the writer's model, saying how. So the writer's model — as a rule the dearer one — is called only where prose is to be written. The planner hands each place in with a `replace` (its own words) or a `how` (for the writer); one that has neither is sent back. It holds for every revision by places — issues mended (one, several, what a review found), a sentence of the author's carried out, a request through the book. An issue mended at its quote goes to the planner too where it judges, in one request with that chapter before it (an agent's steps would each send the chapter again for a few words); where one model or the other is set, the quoted place is rewritten by that model outright, as before. A chapter gone through to an instruction is the planner's own work then. What a revision came to says whose words were whose (`ReviseBookResult.wrote`; on the page: *3 written by the planner itself, 1 by the writer*). The settings page (*Writing and revising → Who writes a revision*) and the small menu beside the buttons that revise have the three; a book may have its own.
  - A settings file that stores `planner` or `writer` is read once as saying nothing (settings revision 4): every save of the settings page wrote one of the two, so neither told a choice from the default. Picked again, it stays. A book's own `mendBy` is untouched. The page now writes `mendBy`, `rewriteBy` and `mendReach` only where one was picked, and each step of the settings migration runs only for files saved before the round that brought it.
  - Fixed with it: an issue mended at its quote went by the Studio's `mendBy` where the book had its own.
- **A style's extra system prompt.** A style (*Bible → Style*) has one more field, **Extra system prompt** (`system` in `bible/styles/<id>.md`): the author's own words for the system prompt, sent as they were written — after the style, under a heading of their own (`【作者的额外要求】` / `FROM THE AUTHOR`) — to every call that writes the words of the book in that style: a chapter written or gone on with (the writer as an agent too), a passage or a chapter rewritten, an interlude turned into prose, and the *Try it* sample of the style, so that what was added is heard before a chapter is written. Whoever hands its work in as something other than prose — a chapter revised place by place, the planner writing the words of a revision itself, a turn of an interlude — is told them too, as holding for the words it writes into the book, with how it hands them in left as it was (the planner is told with the style, in what it is asked; its own system prompt stays its own). Nothing of the Studio's writes the field: not a style derived from a sample, not a role (the showrunner sets it only on the author's word). Empty, nothing is added. What was sent is in the record of calls (*Jobs* → *Requests*).
- **How a book is written and revised: a section of its own in the settings, and any of it a book's own.** A book could have its own of one of them (`materialBy`), set by a lone field at the foot of *Models* on the book's side of the settings — and the link from the writing page led to the other side. They are a section now, **Writing and revising**, on both sides of the settings page: who prepares what the writer is handed (`materialBy`), beats to a part (`partBeats`), who writes a revision (`mendBy`), who rewrites a passage or a chapter (`rewriteBy`), how far a revision goes (`mendReach`). For every book they are the Studio's; a book may have its own of any of them — the same names in its `novel.json`, set under *This book* (each field starts at *As for every book: …*), listed at the top of the page with a way back, and said beneath the field on the Studio's side (*"…" has its own: …*). What holds: what is said for the piece → the book's own → the Studio's → the default (`writingOf`, one function for the Host and the page). The small menus beside the buttons that revise and rewrite show what holds for the book in hand, say when it is the book's own, and save a pick where what holds is kept — in the book then, else in the Studio's settings. For a role: `novel_settings action=book fields.<name>` (null takes one off the book); `action=get` says what holds for the book in hand.
- **A book may have its own way of writing.** Who prepares what the writer is handed — the Studio by rule, the planner looking first, or nobody, the writer as an agent — was one setting for every book. A book can now say its own (`materialBy` in `novel.json`; the settings page under *This book*; the showrunner's `novel_settings action=book`): it holds for that book in place of the Studio's, and the writing page's menu says which of the two it starts from. What is picked on the writing page for that page still comes before both.
- **What every job sent to a model can be read from the job — a role working as an agent too.** The record of calls kept the Studio's own calls and left out what a role works out step by step on the Harness's loop: such a job showed its reasoning and nothing of what it was sent. Each request of a role's run is now a call on the record (`CallLog.keepStep`, told by the role runner from the session as the request goes out: `Session.deriveMessages()`, `requestHeader()`): the system prompt, the tools it was offered (each with what it is for and what it takes), what the earlier requests of the run had already sent, what is new with this one — the task on the first, then what the model last said and asked of its tools and what they answered — and the reply with the tools it asks for next; tokens, cache, time and how it ended as for any call. A step holds only what is new with it and names the step before (`prev`): a run of forty steps is kept once, and a step whose earlier steps are gone from the record says so. In **Jobs** every row of the book's jobs has **Requests**, with how many are on record: it opens that job's calls alone (`calls.list` `job`), the latest first — read whole, laid side by side, or two of them against each other. The showrunner's `novel_calls` lists a job's calls and reads the new part (`tools`).
- **Review and revision: one bar, one name, one logic.** *Review → Issues* and *Review → Book-wide revision* are one tab, **Review and revision** (审校和修订), and what was two forms — *Review by a lead* and the book-wide instruction — is one bar (`ReviseBar`). **Nothing said, it reviews**: the button says what — the chapters of the line nobody reviewed yet, all of them again (asked first), the ones picked, the chapter in hand. **A sentence said, the planner tells what it is** (`mendTask` with `lead`, `reviewByLead`): something the author noticed that is wrong is found where it shows, filed as issues of its chapters (marked as the author's own) and mended beneath them; a change the author wants made is carried through the places it reaches — nothing filed, the changes one round of proposals; where it is both it is taken as the fault, mended the way they say; *Find only* changes nothing either way. The planner's note says which it took it for, and so does what is said when it ends. The bar takes pictures to go by (`ai.reviewLead` `guides`) and offers a changed world entry or character card said for the author, as the book-wide page did. It is the same bar on the review page (a line of the plot, or chapters of it), in the writing page's issue panel and over the reader (the chapter in hand); the button beside the writing page's brief box is it as well — *Review* while the box is empty, *Revise* once something is said, with *Find only* and *Write the chapter over* under its triangle — and *Something is wrong here…* on a selected passage is *Review and revise…*. The separate review buttons of those pages, the book-wide tab and the writing page's *Revise: the planner goes through it to the brief* are gone into it (the in-place engine stays, for the showrunner's `novel_revise scope=chapter`). In Chinese the family is called 修订 throughout — the buttons on an issue, the bars, the notices, the settings (*修订由谁写*, *修订改多少*); the showrunner's `novel_revise scope=lead` is described as the same thing and answers how the planner took the sentence.
- **A review hands what it found on to be mended.** Saying a sentence about a chapter (*Mend the chapter*) came back with the changes beneath what was found; a review only listed what was wrong, and every issue was the author's to hand over by hand. Now, once a chapter is reviewed — from the review page, the writing page, the reader — its open issues that nobody was handed yet go to the planner together, as when the author ticks them and presses *Mend together* (`mendReviewed` → `fixIssues`): a job of its own (`mend review`) started as the review ends, so the issues can be read while it works and it is stopped by itself; it takes its turn among the mendings, and every change waits as a proposal beneath its issue — who writes the words and how far it reaches are the settings every mending has (`mendBy`, `mendReach`). A batch of reviews (`batch.text` with `review`) is followed by one mending for all it found; chapters written in rounds are mended by their rounds, as before. It is a setting, `reviewMends` (yes unless switched off): first page of the settings under *Done by itself*, and the small triangle beside the buttons that review; `ai.review` and `batch.text` take `mend` to say otherwise for one. The showrunner's `novel_review` does it where asked to (`mend`). While it works the issues say so, and its ending is said: how many changes wait, and where.
- **Every change that waits, taken or turned down in one go — wherever changes are listed.** *Accept all* / *Reject all* stood over the proposals of a chapter (writing page, *Proposals*) and over one round of them (*Review → Proposals*). They now also stand where changes are shown beneath the issues they mend: over the issue list beside a chapter (the writing page's *Issues* panel, the reader's), over each chapter of *Review → Issues*, and over that page as a whole — and over *Review → Proposals* where several rounds wait. One control (`SettleAll`, `MendsBar`): the changes are settled in the order they stand in the text; turning down is asked first, and so is taking a set that reaches into more than one chapter.
- **A chapter with beats is written by its beats, whatever length is asked for.** Writing in parts — the beats of the plan in runs, a request a run, the same material and the text so far each time — was kept for a chapter asked to be longer than one request yields. It is now how a chapter with beats is written wherever the writer writes in one request (`materialBy` `planner` or `rules`), with a length asked for or none: `partBeats` beats to a part (3 unless set; on the settings' first page, and `novel_settings`), every part told which beats are its own and — but for the last — not to close the chapter. With no length asked for, a part's own is the writer's to judge, told that what is said of length is said of the whole chapter. `partBeats: 0` is the way it was: one go, and parts only where the length needs them. Every beat gets its room this way, and a chapter comes out longer than one written in one go (measured on a test chapter of nine beats with no length set: about 5,500 words in three parts, where one request wrote about 2,500).
- **The way of writing picked on the writing page is for that page.** The setting (`materialBy`, first page of the settings: packed by rule, prepared by the planner — the default — or the writer as an agent) is the default. The menu under the brief box of the writing page, and the ones beside the buttons that rewrite, no longer change it: they pick the way for what is asked for from that page — *as the settings have it*, or one of the three *here* — kept while the page is open and said beside the menu ("picked here; the settings have …"). `ai.write`, `ai.reviseSpan` and `ai.reviseChapter` take it as `material`.
- **A third way of writing a chapter: the writer as an agent.** Beside "packed by rule, written in one request" and "prepared by the planner, written in one request" (`materialBy` `rules` / `planner`), `materialBy: agent` has nobody prepare anything (`src/core/pipelines/compose.ts`, `composeChapter`): the writer — its own model, its own rules and the book's style — is given the work and what it stands on (the chapter's plan and what it was planned with, the book, the core of its world, where the chapter joins), and reads the rest in the book for itself with `book_read` / `book_search`. It hands the text in with a tool (`chapter_write`; `append` for a text that one call cannot hold), and the text is then its draft to work on: `chapter_read` shows it, `chapter_edit` changes a place (`find` → `replace`, a place found once; `all` for a word throughout), `chapter_write` hands the whole of it in again — as often as it sees fit. What stands when it calls `chapter_done` is the chapter; a run that stops without calling it leaves what was handed in, and says so. Where a length is asked for, the tools say where the text stands against it, and a chapter well short of it is called done twice. A writer whose model cannot run as an agent, or whose run hands nothing in, does not leave the chapter unwritten: it is written in one request from prepared material, and the result says why (`MaterialUsed.instead`). Chosen where the other two are — the settings, the line under the brief box of the writing page, `novel_settings` — and one of the ways a comparison lays side by side (`trial.write` `materials: ['rules', 'planner', 'agent']`): the same model, the same brief, a draft by each. A passage rewritten and a chapter written over keep the planner's material. (`tests/compose.test.ts`.)
- **A chapter asked to be long is written in parts, by its beats.** Asked for ten thousand words in one request, a model writes the chapter to its end in half of that and stops; nothing brought the other half. Where the length asked for is more than a model writes in one go (about 4,000 words) and the chapter's plan has beats, the chapter is written over several requests (`partsOf`, `partHow`): the beats in runs, each with its share of the length, each request with the same material and the text so far — so the head of every request is the one the provider has kept — and told which beats are its own and that it is not to close the chapter, but for the last. Both one-request ways go by it. What comes out more than 15% short of the length asked for is said (`WriteResult.short`): on the page, and to the showrunner.
- **A chapter's memory can be cleared, and every chapter says whether it has one.** *Clear memory* in the memory panel beside a chapter (writing page) and in the chapter's menu on the outline page; the showrunner's `novel_digest` with `forget` and the chapters named; RPC `chapter.forget` (`forgetChapter`). The digest goes, and with it what it left in the book: the blanks of the chapter's plan it had filled, its marks on the threads (planted, advanced, paid off here) and the threads only it had proposed that nobody confirmed, the suggestions of its that still wait, the stretch summaries it was part of; where its people were first and last seen is read off the digests left. The text is not touched; a digest brings the memory back. On the chapter lists of the writing page and the outline, and beside the chapter's name in the outline's editor, each chapter with text says *memory*, *memory stale* (digested, and the text changed since) or *no memory* (`ChapterInfo.memory`: `current` | `stale`, absent for none).
- **What a writer is handed is prepared for the piece.** Where the author asks for a piece of writing — a chapter, a chapter gone on with, a passage rewritten, a chapter written over — the planner looks first: told the work and shown what the book has by name and size, it reads as far as the piece needs and hands in the material (`pipelines/material.ts`, tool `writing_material`): task, situation, what must hold, form and voice in its own words, and by name the cards, entries, threads, chapters (whole or in outline) and stretches of text that go along — checked on the spot, held to a budget, and packed with what the work stands on (`packContext` `chosen`, strategy `chosen`). A line small enough lies before the planner whole and it prepares in one request (`context.plannerWholeTokens`, 32,000). Setting `materialBy` (`planner` by default; `rules` is the packing as it was); where the planner cannot be asked the piece is packed by rule and the result says why (`MaterialUsed.why`). What the latest piece of writing on a chapter read is kept for the author (`.novel/material/<chapter>.json`, `material.read`) and read from a line under the brief box of the writing page, which also switches who prepares.
- **The two ways of preparing, compared.** The writing page's comparison takes the ways beside the models (`trial.write` `materials`): with both, every model writes a draft by each, from one preparation. A draft says which way it was written by and what it was written from (`TrialDraft.by` / `material`, `VersionMade.material`), and all its writer read is kept beside its version (`material.read` `version`) and goes with it.
- **A picture there already, for every place one is drawn.** Beside each button that draws for a place of its own — a portrait, a design sheet (a look's, a stretch's), a moment's portrait, the design art of a place, a house or a thing, the picture of a turn of its course, the cover — one button opens the book's pictures, with *From this computer…* in the same dialog (`ReadyPicture`; `PickPicture` `bring`). A picture of the book is hung there by `image.use`, which now takes `look`, `stage` and `event`; one that hangs elsewhere is asked about first. It replaces the lone import button of those places.
- **People's cards and the bible's entries, picked and deleted together.** The *Select* bar over those lists is there in a book of one line of the plot too, and deletes what is picked (kept among the lately deleted, to be put back); filing under lines stays where there are lines.
- **One place for what several pages start.** A chapter reviewed, chapters digested, the planner looking over names without a card, a set of proposals taken or turned down: each was written out on every page that has a button for it; they are in `client/actions.ts` (`useBookActions`) now. A column of the side-by-side control can carry a line on how its thing came to be (`CompareItem.note`).
- **The record of calls: what every call to a text model was sent, and what it said.** A model answers from what it is sent and from nothing else; until now the Studio kept how much a call used and nothing of the call. Every call it makes to a text model for a book — writing, continuing, rewriting, memory, reviews, plans — is now kept (`src/core/calls.ts`, around the backend outside the retries: a call made again until it worked is one call): the rules of the role, what opened the request, the request, the reply as it came, the model, its reasoning level, temperature and output limit as they were sent, tokens as the provider counted them, how long it took and how it ended — a call that failed with why, one that was stopped with what it had said. It is filed under the job it was made in, the chapter it was for and, in a batch, the step (`callsFor`). Kept in the book (`.novel/calls/`: `index.json`, one document a call, `parts/` for what a run of calls has in common — the rules, the story so far — kept once), so a sealed book's record is sealed with it; a book keeps `callsMb` megabytes of it (200 unless set; 0 keeps none; 3,000 calls at most), the oldest going first. Read on the writing page under *Calls* beside a chapter, and for the whole book from *Jobs* and *Usage*: a row a call; pressed, the call whole, part by part in the order it was sent; ticked, calls laid side by side (the shared `Compare`), two of them read against each other — how each was set, and for each part whether it was the same to the letter or what differs — or taken off the record. RPC `calls.list` / `calls.read` / `calls.remove`. Calls made by a role working as an agent are DSH's own loop and are not in it: such a run is opened from its job, as before. (`tests/calls.test.ts`.)
- **Things laid side by side, one control for it.** What a comparison shows — drafts of a chapter, versions of it, pictures, plans, clips — is laid out by one control (`Compare`): any number of the things in a row or one alone (pressed in and out by name; *this one alone* on a column), the columns sized by − / ＋, a pinch, or *Fit* (as many as are shown on one screen), a thing that can be deleted deleted there. A dialog that compares can be made the whole window (`Modal` `roomy`). The versions panel of the writing page ticks versions to lay them side by side — or one to read alone — and to delete them (`VersionsPanel`, `chapter.versions`, `chapter.dropVersions`; the original of a translated chapter is never deleted); the gallery lays the pictures picked side by side (`PicturesCompare`). The dialog that has several models write a chapter lays anything among the chapter's versions and the text as it stands beside its drafts, offers the last round's drafts when opened again, takes up a round still being written, and says when one ended with the dialog closed; while drafts are written the chapter is not held as "being written".
- **A draft written to be compared says who wrote it.** Beside the version (`.novel/versions/<chapter>/<id>.json`, `VersionInfo.made`): the model by its own name, the level it thought at, the brief, and the round it is one of. The versions list names a version by what it is first, then when.
- **What a comparison adds can be taken away again; it opens on what it compared last; and it takes more.** A picked model has a × on its row; a row added for another model or voice can be removed; the models (with their levels) and the rows of the picture and speech comparisons are kept on the device and the dialog opens on them. A comparison of models or of speech setups takes 32 runs at once (`TRIAL_MOST`), not eight. A model typed into a row of the speech comparison (not picked from its list) is spoken to by that model's own protocol.

- **A tutorial for newcomers, in English and Chinese.** [`docs/tutorial.md`](./docs/tutorial.md) / [`docs/tutorial.zh.md`](./docs/tutorial.zh.md): installing on DSH, connecting the models, bringing in a finished book, the workflow of a chapter (derive → beats → write → digest → review and mend → cards → design sheets and portraits), the gallery and the album, and what else there is — with a diagram of the workflow and 33 screenshots in each language (`docs/images/tutorial/`). Linked from both READMEs.

- **Derivation records: how the outline came to be, kept with the book and handed to whoever plans and writes.** Every derivation — chapters, a chapter's beats, a beat by a sentence, a what-if, a new book's foundation — leaves a record (`derivations/index.json`; `DerivationRecord`): the author's direction in their words, every hand-in with what the planner said of it (a turn more for each adjustment), the chapters it became, and whether it waits, entered the outline or was let go. Read on *Outline → Derivation records* (by chapter, by kind; `derivations.list`), by `book_read` / `novel_read` `what=derivations`. The record a chapter's stretch came of goes along where its beats are laid out and where it is written or revised (`renderIntent`; context section `intent`, `included.intent`) — with which chapters it covers and where the one in hand stands among them, and which holds where: the outline for what happens, the record for the key; the writer's closing ask names the key again. A derivation of what comes next is given the line's latest stretches (`intents`). The author adds to a record, keeps it back (`carry: false`), takes it away and puts it back, and writes one down for chapters that have none (`derivations.note`). The page tells a plan's record what became of it (`outline.settleDerived` `entered`). Laying out a chapter's beats now also reads the chapters before it that are not written yet and the next chapter's outline, and says why it laid them out as it did (`rationale`).

- **One beat by a sentence.** Above a chapter's beats (outline page; the writing page's plan panel) a sentence adds one beat — where the author says, or where the planner sees it belongs — or, with beats ticked, changes those and no other; one that by the sentence goes may be taken out. One plain request to the planner, which is shown every beat and hands in only what it made or was to change (`touchBeats`, RPC `ai.beat`, the showrunner's `novel_derive kind=beat` with `beats` / `after`). Until now a change to the beats meant laying all of them out anew.
- **Jottings: the author's loose notes, found by whoever works on the book.** *Bible → Jottings* (and a button in the header of every page) keeps turns of the plot not thought through, settings not settled, lines for some day — with the book (`jottings/index.json`), each of a kind (plot, setting, other), one taken away to be put back. They are a source of the search (`jotting`), a kind the read tools list (`book_read` / `novel_read what=jottings`), told of in a role's rules, and — up to three that bear on it — a part of what a chapter is planned and written with (`ContextPack.included.jottings`); always named as ideas, not canon. The author keeps one from being found (`hidden`), or all of them (`search: false`): such a jotting is in no index and in no list an agent reads. RPC `jottings.list / save / remove / restore / search`; the showrunner's `novel_jot` (list, add, update, remove). The bible page's tabs wrap where they do not fit in a row.
- **A review led by the author.** What the author noticed in their book already — "his glasses come and go", "the days between chapters 3 and 4 do not add up" — is said in a sentence (*Review → Issues*, the bar at the top; the same bar kept to one chapter in the writing page's issue panel and over the reader's page; `ai.reviewLead`; the showrunner's `novel_revise scope=lead`). The planner finds where it shows — each place quoted, checked against the text, and filed as an issue of its chapter marked *Yours* (`ReviewIssue.lead`) — and mends it in the same run, each change a small proposal beneath the issue it is for. *Find only* files and changes nothing; nothing found says where the planner looked. A chapter that holds only such issues still counts as not reviewed (`ChapterReview.unread`), and a new review keeps the author's open findings.
- **Who writes a change made by places: the crew's model, or the writer's.** `mendBy` (first page of the settings; the small menu beside the buttons that mend). With `planner` — the default, and what an unset value means — the planner hands in what each place is to read and that is the proposal — no writer's model is asked — for issues mended, a review led by the author, a revision through the book, the quoted place of an issue and a chapter revised in place (whose agent is then the planner). `writer` is the two-model way it was.
- **Who rewrites a passage or a whole chapter: the writer's model, or the crew's.** `rewriteBy` (first page of the settings; a small menu beside *Rewrite* on the writing page, and in the menu beside the buttons that mend): a selection polished, expanded, tightened or changed to an instruction, a chapter written over whole, and the chapters a mending says cannot be mended by places. `writer` by default; `planner` hands them to the crew's model. Results say who wrote (`ReviseResult.who`).
- **A review led by the author, where the chapter is edited.** On the writing page a selection has *Something is wrong here…*: a sentence on what is wrong with it, *Find and mend* or *File only*; the passage goes along as where the author was pointing (`ai.reviewLead` `passage`), and what else it touches in the chapter is looked for too. Beside the brief box, *Mend the chapter* hands the sentence written there in as something the author noticed — one button where *Revise* and *It has a problem* stood side by side; the small triangle beside it holds the other ways: *Revise* as it was (the chapter gone through to a brief, place by place), the finding alone, and the chapter written over.

- **A chapter revised where it stands, by the writer as an agent.** Asked to change one chapter to an instruction, the writer no longer hands the chapter back written again: it goes through it with tools — `chapter_edit` (`find` → `replace`, a place found once; `all` for a word throughout; `edits` for several places in one call), `chapter_read`, `submit_revision` — and only what it changes is output. Each call is checked as it is made (not found, found more than once, most of the chapter in one place, a picture added) and a picture's line is never touched. What comes back is the places that changed, told apart sentence by sentence (`changedParts`): a span proposal each, with the writer's reason, under one round — settled one by one, or all at once from the row above them (`pipelines/amend.ts`, `amendChapter`; `ai.reviseChapter`, with `whole: true` for the chapter written over as before; the showrunner's `novel_revise scope=chapter`, `whole=true`). A writer whose model cannot run as an agent is asked once for the list of changes, made by the same rules. The writing page has *Revise* beside *Continue*; *Write the chapter over* stays in the menu. The writer is listed among a job's agents.
- **Proposals that were turned down are kept in sight, and put back.** *Review → Archive* lists what the author turned down (and what was accepted), the latest first, a round together, by chapter where asked; the writing page folds the chapter's own under the proposals that wait. One turned down is put back to wait or accepted after all, a round all at once (`proposal.archive`, `proposal.restore`; `Proposal.settledAt`, `ProjectState.turnedDown`); one whose sentences are gone from its chapter says so. The showrunner has `novel_revise scope=turned_down` and `scope=restore`.

- **What the Studio does by itself, switched off on the first page of the settings.** *Done by itself* gathers the five things that follow once text is written or changed — a chapter digested, the planner looking through new names, suggestions settled, a plan set by its text, issues read again after a revision — each with its switch (the last had none; the digest's stood among the advanced options). With digests off nothing digests on its own: the overview and the writing page's memory panel say so and lead to the switch, *Digest* there still does it, and the showrunner is told the saving is the author's — its status no longer makes a digest its next step, and a write or an edit no longer ends in "run novel_digest". `novel_settings` takes `siftCast`, `settleSuggestions` and `recheckIssues` beside the others.

- **The copies DSH keeps of a sealed book's pictures are sealed with it.** Every picture shown to a model — by the showrunner's `novel_look`, as a guide picture, through the model set up to look at pictures — leaves a plain copy in DSH's attachment store, for good. For a sealed book these copies now go under its seal while it is locked (encrypted into the Studio's own directory, the plain objects removed, DSH's cache of scaled versions cleared) and come back when it is unlocked. A copy a conversation shows goes only once the book's conversations are under the seal. The lock page says how many are kept.
- **A chapter's plan follows its text by itself.** Once a chapter that was digested before is changed — a proposal accepted, the chapter rewritten or edited — its plan is read against the text a moment later: synopsis, place, time, point of view, cast and beats, several chapters in one job, with a word on what changed and the old plan in its history. A plan already read from the text its chapter has is left alone. Setting `planFollowsText` (on by default; *Settings*). Several chapters' plans can also be set by their texts at once from the Outline's multi-select (`ai.plansOfText`).
- **The showrunner adjusts a plan that waits through the planner that derived it.** `novel_derive kind=chapters apply=false` now keeps its plan with the book (the Outline page shows the same one); `feedback` hands the author's words to the planner that derived it — in its own conversation while it is at hand —, `waiting=show / add / discard` reads, enters or drops the plan. A waiting plan remembers the line of the plot and the chapter it was derived to follow, and is added there.

- **A plan derived to be looked at is kept with the book.** Chapters derived as a preview used to live in the form that asked for them: closed while the planner worked — or after — and they were gone. What comes back is now kept with the book (`.novel/derived.json`; `outline.derived`, `ProjectState.derived`) until it is added to the outline or discarded: the form opened again shows it, a derivation still at work is followed by whichever form is open, the buttons that open the form say that a plan waits, and a finished derivation in the list of jobs leads back to it. Nothing is added to the outline behind the author.
- **A derived plan adjusted by what the author says of it — by the planner that derived it.** Beneath a plan that waits there is *What to change* and *Adjust by this* (`ai.deriveChapters` with `revise`): the planner hands the plan back adjusted — what the author spoke of changed, the rest as it was. It is the same planner, in the same conversation: an agent that hands in a plan to be looked at is kept after its run (`RoleTask.keep` / `resume`, `RoleRunner.has` / `release`; half an hour, or until the plan is settled), and the author's word is said to it as the next message — what it handed in, as JSON, what the author wants changed, and to hand it in again. Where it is gone, somebody new is handed the plan and the word, whole; the result says which it was.

- **The showrunner looks at the book's pictures.** `novel_look` hands the pictures themselves back with its result — portraits, sheets, design art, illustrations, panels, the cover, pictures brought in; by id or path, or by whose they are (`of`) — the way DSH's own image tool does, as image blocks beside the words (a tool's outcome may now hold `images`). They are read through the Studio, so a picture of a sealed book that is unlocked — one on the private shelf, whose file on disk is ciphertext and cannot be copied anywhere — is seen like any other. Where the conversation's model takes no pictures, the model set up to look at pictures says in words what each shows. A picture opened large has *Quote to chat*: what it is and its path land in the composer of the conversation beside the Studio (copied, where there is none) — `〔图：立绘 · 沈蘅｜assets/images/….png〕` — and the showrunner is told that such a quote is a picture to look at and to work on by that path.
- **A chapter's plan set right by its text.** Once a chapter is written — or edited, or changed by a revision — its plan can be read off it again (`ai.planOfText`; the showrunner's `novel_derive kind=plan`, or `kind=beats from_text=true` for the beats alone): the synopsis, place, time, point of view, cast and beats as the text has them, by the continuity editor in one plain request. A beat that still holds keeps its words and its id; what the text does not say of place or time stays as planned; purpose, notes and threads are not touched; the plan as it was stays in its history. *Update the plan from the text* stands on the chapter's plan in the Outline and beside the text where it is written, with *Beats only* next to it.
- **A picture set straight by hand: cropped, turned, mirrored — the original kept.** A picture opened large has *Crop · rotate…*: quarter turns, mirrorings, a box dragged over the part to keep (free, the picture's own shape, 1:1, 4:3, 3:2, 16:9 and their upright forms). Saved, it is a picture of its own (`image.adjust`; record field `edited`) that stands wherever the one worked on stood, that one staying after it. Worked on again it starts from the original with the box as it was left; what is made replaces the earlier one (removed, unless a chapter's text shows it), and everything reset is the original restored. Drawn in the page, kept by the Host; the author's alone — no agent tool.
- **How large pictures stand in the text, and a picture at its largest.** The reading settings have *Pictures* for the pictures of the text and of the script — smaller than the text's width, or larger: out of the column on both sides, as far as the screen it is read on (`ReaderPrefs.pictures`; kept on the device, carried into a published site; see *Changed* for the sizes). A picture pressed fills the window, in proportion, and is put away by another press or Escape — in the Studio's viewer, on a phone and on a published site alike; the album's pictures open the same way.
- **What a picture is for, said of any picture.** A picture opened large has *Use as…*: somebody's portrait (of one of their moments, where said) or design sheet, the design art of a place, a house or a thing, a picture of a chapter's, nobody's — and whether it is the book's cover (`image.use`). It is taken down from who held it, hung where it is said to belong, and filed as that; where the text or a storyboard shows it, it stays. A picture drawn here keeps what it was drawn as on its record (`madeAs`), and the record's notes are no longer measured against whose it is now. *Make it the cover* moved from the gallery into this, so every page that shows a picture has it.
- **Pictures listed by where they came from.** The gallery and the picture chooser have *Drawn here* / *Brought in*, used with the other filters; a picture brought in carries a mark in the gallery.
- **A photograph or a picture of the author's own, wherever one is drawn.** *Import* stands beside the buttons that draw the design art of a place, a house or a thing — and the picture of one turn of its course — and beside the cover's, as it did beside a portrait's and a design sheet's: the file joins the pictures kept (the main one unless the author chose another) and is on record as brought in. The chooser of the book's pictures has *From this computer…*, so a picture that is not in the book yet goes straight into a chapter's text (the side panel has the button too) or takes the place of one there. The gallery brings in many at once, said first what they are: pictures of the gallery, the design art of an entry, somebody's sheets or portraits; it lists what was brought in. A design sheet says whether it shows three views or the front alone, and the author can put it right where its shape told it wrong (`image.import` with `kind`: `art` | `cover` | `picture`, `event`, `chapter`; the result carries the record).
- **A chapter's pictures show in the text where it is written.** The writing page lays the chapter out in turn: prose in text boxes as tall as their words, and each picture's line of markup as the picture itself, with its caption. A picture there is opened like any other — how it was made, redrawn, changed, compared — and what comes of it is the one the text has; it can be replaced by another of the book's, given another caption, moved a line up or down, or taken out. A picture whose file is gone says so, with the way to take its line out. The chapter stays one plain text: offsets, find, a marked selection and the editor's keys work across the boxes, and the arrow keys step past a picture (`textBlocks`, `withProse`, `pictureChanged` in `shared/embedded.ts`; `ChapterText`).
- **A picture changed with other pictures to go by.** *Change this picture* takes pictures beside the sentence — of the book, or brought in — each with a word on what is wanted of it: a dress to put on her, a face, a lamp. The picture to change goes first and they follow, numbered from 2, so the sentence can speak of them ("the brush of Image 2 in her hand"); one line after the sentence says which is the one to change. With none, the picture and the sentence are all that goes, as before. A picture made so is changed again with the same pictures unless others are named (`image.redraw` with `change` and `references`).
- **A design sheet drawn by somebody else's, for kin.** The row of pictures given to a design sheet has *Somebody else's sheet…*: pick a person, and their sheet goes along as another person's — named, with what the cards say the two are to each other. Unless the author says what is wanted of it, that is the likeness of family: the cut of the face, with age, hair, build and clothing as the card has them; and what is sent is the head and shoulders of that sheet's front view only (`parts.references[].face`). A picture chosen among the book's that is another character's sheet or portrait is known for it the same way.
- **Design art kept side by side, with a main picture.** The design pictures of a place, a house or a thing are kept together like a person's design sheets: one drawn again takes none away, the entry's page shows them in a row — the main one, those kept, those drawn to compare and not taken, earlier ones the gallery still has — and any of them can be made the main picture (`visualImages`, `visualMain`). Chosen, it stays whatever is drawn after; a picture taken of several compared is the main one.
- **Pictures drawn to be compared are kept, and chosen later.** A comparison goes on drawing when its dialog is closed, and everything it draws waits: a picture there was, drawn again by several services, now waits like the others, saying whose place it would take (`trial.hang`: `instead`). The header shows how many wait on every page (`ProjectState.waiting`); the dialog opened again on the same thing shows what was drawn of it before and not taken, takes up a job still drawing, and offers a round of many things to be taken whole as before; a job that ends unwatched is announced. A second picture taken of one comparison takes the place from the first.
- **Reference pictures of the author's for a design sheet and for design art.** A person's design sheet and the design art of a place, a house or a thing can be given pictures to go by — the book's own or brought in from the computer — each with a word on what is wanted of it (`image.create` with `references`; the showrunner's `novel_illustrate references=[…]`). Where that is said, the director takes the words that speak of the same thing out of the prompt and points to the picture in their place, and the record names what was taken out (`sent.compact.replaced`); where nothing is said, the look of the person or thing points to the picture and its words are not sent. They go after the pictures the Studio itself draws against, and the record marks them as the author's (`references[].given`).
- **What is asked of one picture is worked into its prompt.** A sentence added to a design sheet or a plain likeness is no longer a line put after the others: the director rewrites the parts of the prompt it speaks of, and what the brief said against it goes — a figure asked to hold a cane no longer has "arms at the sides", and somebody asked to be without the glasses their sheet shows has that said in their line. The record says the prompt was written by what was asked.
- **A moment is framed before it is drawn.** A portrait of a signature scene used to be drawn from the scene as the card tells it — a telling, with nothing of what the person wears at that point or what is around them. The director, as an agent, now reads the paragraphs of the chapter that tell the moment and frames it: the action in a short sentence, what they wear then (their usual clothes where the text says nothing), the surroundings, who and what is there. The frame is kept on the moment (`visual.scenes[].shot`), shown under it on the card, and used until the moment's words change; the brief gains the lines *surroundings* and *wearing now*. A portrait guided by what the author asks takes its frame from the same answer that picks the moment.
- **Every button that draws offers several models.** One control beside each — portraits and sheets (of a person, a stretch of their life, an outfit, a moment), design art, the cover, the picture of a passage, panels of the motion comic, a new picture in the gallery, batches of art and one-click production: a picture each by several image services or models, side by side, nothing counted until one is taken. A picture taken lands where a plain draw would have (`trial.adopt`); many at once are a round, taken whole by service (`trial.adoptRound`) or one by one under *Stage → Illustrations → Waiting to be taken*.
- **The pictures of a chapter beside its text.** Where a chapter is written, a panel lists the pictures its text carries, in order, each with the sentence before it: moved up and down, moved to after the paragraph the caret is in, taken out, or another put in from the gallery.
- **Pictures from outside.** A portrait or a design sheet — of a person, of a stretch of their life, of an outfit, of one of their moments — can be brought in from the computer (`image.import`): hung and recorded like one that was drawn, and marked as imported.
- **References changed for a redraw.** *Rewrite the prompt and redraw* lists the reference pictures the picture went with; any can be taken away and others added (`image.redraw` with `references`). The numbers the prompt points by follow, and somebody whose picture was taken away is written out in words.
- **Finding in the text, and a title changed where it stands.** Cmd/Ctrl+F on the writing page opens a find bar over the chapter (Enter and Cmd/Ctrl+G go on, Shift goes back); the chapter's title is renamed by a double click on it, or by the pen beside it where the page is narrow.
- **Cards for the walk-ons picked.** The list of names without a card takes a selection: the names picked are given cards together and the cards are written whole — looks, bearing, where they come from — from what the digests noted of them, as the intake of a book does; somebody the notes say too little of is read up in the book by the planner (`cast.card`).

- **References: the books a book goes by.** A book can go by other books — their world, settings, style, plot, wording — under *Bible → References*: a book of the shelf, consulted as it is organised there and as far as the author opens it (world, characters, style, plot, text), or a manuscript taken in for this book alone as plain text (with a link to import it as a book of the shelf where it should be organised first). Each carries the author's line on how to go by it. Nothing of a reference is put into a task whole: the planner, the script supervisor and the director read in them with tools of their own (`reference_read`, `reference_search`), kept to what is open; before a chapter is written the planner takes notes for it, kept on the chapter's plan and handed to the writer. The showrunner has `novel_reference`.
- **What is asked of the references at large.** The references page has one field, above the list, for how the book goes by its references altogether — which for the world, which for the way of writing, whether people may be borrowed — in the author's own words. It is kept with the book (`references/index.json`: `guide`) and said to everybody who works with the references at hand: among the crew's rules, in the planner's note-taking for a chapter, and to the writer with the notes. What is said of one reference still holds for that one.
- **Derivations and reviews look in the references first.** Until now a role had the tools to read in the references and was told to look "where the work touches them" — which left it to the model whether to look at all. Three switches on the references page now say which work looks first: writing (as before), deriving (chapters, beats, a what-if) and reviewing; all on. A derivation or a review is told to look, is sent back if it hands in without having read or searched in a reference (twice at most), and reports what it read — counted off its calls — under its result (`referenced`). A review is also handed the notes the chapter's writer was given, and files what is at odds with the references as issues. A role that works in plain calls cannot look, and the result says so.
- **The picture of a passage.** A passage selected where a chapter is written or read can be drawn: the director, as an agent, tells from the text before it and the bible who is meant, where, with what in hand, and writes the picture; the brief is laid out from that, each person held against their sheet. The record keeps the passage and the director's account.
- **A portrait is a pair.** Asked for with nothing said of it, a portrait is two pictures — a plain likeness, which stands for the person and stands in the text where they first come on, and their signature scene, which stands where the chapter tells it; where the two places are the same or near, the scene alone stands there (`image.portraits`: `both`, `scene`, `plain`; a book may have its own).
- **The picture of a moment is chosen.** A moment drawn more than once lists every picture of it in the panel of somebody's moments; *Use this one* makes another of them the moment's own — in the panel, and in the text.
- **A prompt rewritten whole.** *Rewrite the prompt and redraw* opens everything the image model was sent — the whole prompt, art direction and the line on reference pictures included — and what was kept out, in a field of its own; the two go again as they stand (`image.redraw` with `prompt` and `avoid`; `image.whole`; the showrunner's `redraw=… whole=…`).

- **A book may draw and speak with services of its own.** Under *This book* in the settings, a book can name its own image service (address, model, sizes — the whole setup, with none of the Studio's mixed in), its own speech setup, and its own way with sound; everything it does not name follows the settings for every book. Keys are never kept in a book: the one saved for the address is used. What the page says a book can do, and which model each role of its crew really runs on, is told for the book in hand — and a model the book names that DSH no longer lists is said outright, with the way back.
- **A service left for another is remembered.** Moving the pictures or the speech from one service to another keeps what the one left was set up with — its address, model, sizes, workflow — and puts it back when the author returns to it; the list marks which were set up before.
- **Comparing services and models.** The same piece of work done by several at once, side by side: a portrait (or any picture there already is, from the picture panel) drawn once with each of several image services — the one in force, the ones set up before, another model of the same service; a chapter written by several of DSH's models; chapters to come planned by several. Nothing a comparison makes takes the place of anything until the author takes one: pictures stand in the gallery out of the text, drafts are kept among the chapter's versions, plans are only shown. The showrunner can draw such a comparison too (`novel_illustrate compare=[…]`).
- **Pictures to steer the story by.** A derivation of chapters and the writing of a chapter can be given a few pictures — chosen among the book's own, or brought in from the computer — each with a word said of it. Where the model doing the work takes pictures (DSH's own list of models says so), it is shown them, the way DSH sends pictures; where it takes none, a model set up to look at pictures (*Settings → Models → Looks at pictures*, Studio-wide or a book's own) says in words what each shows, once, and those words go into the task — and without one the work is refused before it starts, with where to set it. Pictures given to a chapter stay on its plan and go with every pass at it and with its beats; the planner says which chapter goes by which picture, and that chapter keeps it. The showrunner passes pictures the author pointed at (`novel_derive pictures`, `novel_write pictures`).
- **Several design sheets of a person, kept side by side.** A sheet drawn again takes none away: every sheet stays on the card, each used as something — the main sheet (what every picture of them is drawn against), the sheet of a stretch of their life, or kept without being in use. The author says which on the person's page: *Make it the main sheet*, or a stretch picked under *Used for*; a chosen main sheet stays whatever is drawn after it (the new one waits beside it, and the page says so). *Change this one…* draws a sheet from another with a sentence — a scar added, some years taken off — and the result takes that one's place, which stays right behind it; marked as a stretch's, the main sheet is the one behind it again. Sheets the gallery still had from before are listed too, to be taken up or removed. Whether a sheet is the front view alone is kept with the sheet, whatever it is used as.
- **The portrait that stands for a person is chosen.** On their page any portrait can be made the one that stands for them — in the lists, as their avatar, on the stage, and in the text where they first come on — and it stays so whatever is drawn after; until one is chosen it is the newest, and the page says so. A moment's picture can be the one: it then stands in two places, the moment's and the first appearance, each hidden or shown by itself.
- **Pictures to steer by, for a what-if, a revision of the book and the rewriting of a passage** — the same control as beside a derivation or a chapter's brief. Every branch of a what-if counts them in; a revision of the book shows them to the planner that scopes it and to each rewrite; a passage is rewritten by the pictures given for that rewrite alone. A whole chapter rewritten to mend what a review found goes by the pictures kept with the chapter.
- **Which portraits the text carries.** A portrait of one of somebody's moments stands where the chapter tells the moment; one portrait of the person stands where they first come on — unless a moment of theirs is shown in that same chapter: then that is the picture of them there, at the moment. Of several pictures of one moment, or of the person, the first in the author's order is the one. The rest are listed with why they are out and can be asked in one by one; any that stands can be kept out. Which the text carries is said where a portrait is met: on a figure in the reading view, behind *Portraits* on the reading and the writing page, and beside the portrait on the person's own page.
- **A line spoken by several speech setups, side by side.** *Compare…* beside a character's audition and in the audio workbench has the same words spoken once by each — the setup in force, the ones set up before, another model or voice of the same service — as that character's line would sound in each. They are samples: nobody is cast and no setup changes until one is taken, for this book or for every book.
- **Retrieval, context budgets and how much goes out at once can be a book's own**, like its pictures and its speech: its own embedding endpoint and model, the budgets it names, and numbers of parallel requests by kind — counted for that book alone, beside whatever the Studio is doing for the others.
- **One way to pick a model of a service.** Where services are picked to be compared, the model is chosen with the control the settings use: the endpoint's own list, with what it says of each model, read again on a press. The list of DSH's models in a comparison of writers or planners can be read again too.
- **The gallery, listed by who and what its pictures show** — people, places, houses, things, chapters, each with a count — besides the kind of picture; and several pictures picked at once to be deleted together.
- **A phone's way with lists and dialogs.** On a screen as narrow as a phone's a list and the page of what is chosen from it are one at a time, the whole screen each — people, the bible's entries, styles, the outline alike, by one control — with the way back at the top and under a swipe from the left; a dialog is the whole screen and goes by the same swipe.
- **The private shelf opens the way a sealed book does** — by its password, or by this computer's own unlock (a fingerprint, the computer's password) once the author lets it: the same form, the same keeper.

### Changed

- **The package is `whalesong-studio`.** It was `dsh-novel-writer` — a name another DSH fiction plugin holds on npm. The rows are `whalesong-studio` and `whalesong-studio/agent`, a tarball is `whalesong-studio-<version>.tgz`. DSH checks that a linked or installed package carries the name it was installed under, so **an install under the old name loses the Studio**: remove `dsh-novel-writer` from the profile (Desktop: Plugins; elsewhere `dsh plugin --profile <p> remove dsh-novel-writer`) and add the plugin again. Books, settings, saved keys and conversations are not touched — none of them go by the package's name. `scripts/dev.mjs` drops an earlier name that links the same stage.
- **A name of its own: 鲸歌工坊 · Whalesong Studio.** The plugin was 小说工坊 · Novel Studio — and both `dsh-novel-writer` on npm and *Novel Studio* are other DSH fiction plugins'. The new name is on its screens, in its messages and in what the showrunner and the crew are told (the crew's personas still call the place a long-form fiction studio). The repository is now [`xuhao1/whalesong-studio`](https://github.com/xuhao1/whalesong-studio) and the website <https://whalesong.xuhao1.me>; the package is `whalesong-studio` (see below), and the settings folder (`~/.dsh/novel-writer/`) and the scope saved keys live under do not change.
- **Packed by rule is what holds where nothing is set.** `materialBy` unset means `rules` again, not `planner` (the author's word of 2026-10-14). A settings file saved while the planner was the default has `planner` written in it by every save of the page, chosen or not: such a file is read once as saying nothing (settings revision 3), and the page no longer writes out a way nobody picked. The writer as an agent, which was only ever there by choice, stays.
- **Beats to a part at 0 means never in parts.** It meant "in one go, but in parts all the same where the length asked for is more than one request yields" — so a chapter asked to be long was still written in parts with the setting at 0, which read as the setting not taking. At 0 a chapter is now written in one go whatever length is asked for; where it comes out short of that length, the notice says parts are switched off rather than that the plan has no beats (`WriteResult.partsOff`).
- **A chapter's plan is no longer set by its text unless the author asks.** The follow-up that read a changed chapter's plan off its text by itself (release 105) is off by default: a plan is the author's design, and text a model wrote does not become the outline behind their back. The buttons stand as they were (*Update the plan from the text*, the beats alone, several chapters from the Outline's multi-select); the automatic one is a switch under *Done by itself*, `plansFollow`, off unless switched on. `planFollowsText` is retired and read no more — it meant yes when unset and was written out as `true` by every save of the settings page. The showrunner is told that `novel_derive kind=plan` / `from_text=true` are the author's to ask for.

- **A mending goes through by default.** `mendReach` (first page of the settings, *How far a change goes*; the small menu beside the buttons that mend, an issue card's menu, the triangle beside *Mend the chapter*; the showrunner's `novel_revise reach` for one run). `bold` — the default, and what an unset value means — has the planner mend a problem through: every place it shows, what has to change with each, a place taking in as much as has to move (a paragraph where a sentence will not do), a short passage written new where it takes one; a chapter gone through to an instruction is carried through every place it has a hold on; an issue mended at its quote hands the rewriter the paragraph the quote stands in (`widenedPlace`). `careful` is the least change, as before. The guards hold either way — quoted as it stands, found once, never most of a chapter, pictures kept, a proposal narrowed to what changed — and a bold mending is told to lose nothing the text told and to make up no fact. The card's first button reads *Mend it* where it read *Mend one place*.

- **A brief holds what is in the picture: two lines are gone from every prompt.** The first line of a portrait, a picture of a passage or a chapter, a storyboard panel and a picture of the author's own prompt said what the picture was for ("用途：小说人物立绘：「某某」的名场面" / "Purpose: a character portrait for a novel…") — nothing a model draws; these briefs now open with the picture itself. (A plain likeness says "this one person alone" in its framing. Design sheets, design art and covers keep a first line: there it names the form the picture must take.) And the line on the reference pictures says which picture shows whom and stops: the sentence after it on which gives way to which — faces to the pictures, clothes to the words where those say otherwise, nothing redesigned — is no longer written (`referenceLineOf`); only what has to be said of particular pictures still follows it (a sheet drawn after a portrait, a place at another time, a reference the author gave, the picture to change among several). A picture drawn before keeps both lines on its record, as sent; its whole prompt handed over to be rewritten (`image.whole`) and a redraw from its record go without them.
- **A run of chapters is written without its digests when the author leaves them out.** *Digest* in the batch dialog was ticked and locked whenever *Write* was; it is a step like the others now, unticked to begin with where automatic digests are off. Written without it, each chapter goes by the text of the ones before it (and their outlines beyond the window). Rounds (`order=iterate`) add the review they go by and no longer the digest: what a round changed is digested again only where that step is ticked.
- **Minor parts and walk-ons are listed like everyone else.** The characters page no longer folds the long tail by itself; a group folds when its head is pressed, and shows again while somebody is looked for.
- **Pictures given to a model that takes none count by what they are called.** Work with guide pictures — a chapter written, chapters or beats derived, a what-if, a revision — used to be refused where the working model takes no pictures and no model was set up to look at them. It now goes on by each picture's title: what the book records of it (*portrait · A Tang · the paper in the rain*) and what the author said of it — and is told that this is all it has. The result says so (`PicturesRead.by: 'titles'`, with how many had nothing to be called by). A model set up to look at pictures still puts them into words where there is one.

- **What the author asks of the whole book is done by places too.** *Revise the book* (`ai.reviseBook`, `novel_revise scope=book`) no longer has the planner pick chapters for the writer to write over: the planner names the places the request reaches, the writer rewrites those, and each waits as a small proposal — a chapter is written over only where the request is one for the whole of it (its voice, its point of view) or the planner says places will not do. Chapters the author names are the only ones the planner is shown and may change. The summary counts places, chapters written over and chapters left alone.
- **A place is pinned: found once, changed inside, and proposed no wider than what changed.** The planner's quote is all the writer may change, so it is to take in the sentence or two that have to change and no stretches; a quote that stands more than once in its chapter is sent back (which place is meant?). The writer is told that only the place changes and that what the instruction does not speak of is handed back as it stands. What comes back is narrowed to the sentences that differ (`changedCore`; widened until it is found once), and a proposal knows where its passage stood (`Proposal.at`): where the same words stand twice in a chapter, the one meant is the one replaced.
- **Deriving chapters from the writing page waits to be asked.** *Derive the next chapters* there used to start the planner the moment its dialog opened on the main line, before a direction, a number of chapters or a place for them could be filled in. The dialog now opens on its form, on every line.

- **What a review found is mended by places; no chapter is written again for it.** An issue that quotes nothing — or one of things not agreeing (a fact, a time, a cause, how somebody behaves), whatever it quotes — used to have its chapter rewritten whole. Now the planner, as an agent that reads the book, settles which place mends it with the least change — a problem can usually be taken hold of in more than one, and the place may be in another chapter than the one it was found in — quoting the text word for word; what it quotes is looked for at once and sent back when it is not there. The writer rewrites those places and nothing else, and each comes back as a small proposal of its own beneath the issue. *Mend it everywhere*, a ticked batch, *mend the grave ones* and writing in rounds work the same way: places named across the chapters, not chapters rewritten. An issue card's first button is *Mend one place* (or *Mend it here* for style, language and pace at a quoted place); *Rewrite the whole chapter* is in the card's ⋯ menu, for when that is what is wanted — and the planner may still name a chapter to be written over where places will not do.

- **The door for a phone stays open until it is closed, and its link is a new one each time DSH starts.** It no longer closes itself after twelve hours. Its token lives in the process only: across the Studio's own *Restart* the link is the same, across a restart of DSH the old link and a phone's kept cookie are refused with a sentence saying why. What is kept on disk is only that the door is wanted (`phone-door.json` in the Studio's settings folder; no token): the Studio's page on the computer opens it again when it is next shown, and says so in a notice that stays long enough to read. A checkbox turns the reopening off; *Close* takes the wish back too. The phone icon is lit while the door is open (`remote.keep`; `RemoteStatus.kept`, no `until`).
- **The door for a phone stays open through the Studio's own restart, and its button stands wherever the Studio does.** A door open when the Host half is replaced (an update taken in with *Restart*) is handed to the Host half that comes next — the same port, link and hours (`RemoteDoor.park` / `resume`, in the process's memory alone) — where every release used to shut a phone out. A restart of DSH still closes it. The way to the door (the phone icon in the header, *On a phone* on the home page) is shown in a tab beside a conversation too, not on the Studio's own page alone; the dialog says which address keeps working when the router gives the computer another one (the `.local` name).
- **The standard size of a picture is the text's width; smaller and larger from there.** A picture of the text or the script stands as wide as the text unless the reader says otherwise — a moment's portrait too, which used to be capped. *Pictures* in the reading settings is a stepper in place of the row of named sizes: 50%, 65%, 80%, the standard, 125%, 150%, the screen (`ReaderPrefs.pictures` is a number or `'screen'`; names kept by a device read as the nearest step). A step that would change nothing on the page being looked at is passed over: on a narrow pane one press goes from the standard to the screen's width.
- **With their picture along, the state somebody is in is not described at length.** Beside the pointer to a design sheet, a stretch of their life adds a word of what is different then; a stretch that says a look whole is named, with their age, and not written out ("see Image 2; at this time: after the illness (nineteen)") — the words are kept on the picture's record, which says so and where to go for a picture of them as they are then (a design sheet of the stretch). The frame of a moment says what is not as usual in a few words, under "just then" (it was "wearing in this moment", a sentence), and its action says nothing of features, hair or clothing; the pictures the director writes for a passage, a panel and the cover likewise.
- **With their picture along, how somebody looks is not said again — without exception.** A person whose design sheet goes with a prompt has a line that points to it ("see Image 1"); the cases that still wrote the whole look out are gone: the words changed after the sheet was drawn (the picture's record now notes it instead), a stretch of their life that says something of its own about their looks (only what that stretch says is added: "see Image 1; at this time (…): …"), and a look just amended from the author's notes (only what was just said is added). The frame the director makes of a moment gives what is worn only where it is not as usual (`SceneShot.v` 2; an earlier frame that wrote the usual clothes out is made anew before it is drawn from). The line on reference pictures now leaves hair, like clothing, to the words where they say otherwise.
- **A picture that is another one changed is drawn again by changing that picture again.** Such a picture was made of two things — the picture it came from and one sentence — and *Rewrite the prompt and redraw* now opens those two: the sentence to rewrite, with the picture it came from beside it. Drawn again, that picture goes to the image model with the sentence as it reads now, and what comes back takes the changed picture's place. It used to open a brief put together from words, and to draw the whole picture anew from it. Drawing it from words is still there, a link away; it is what happens by itself where the picture it came from is gone. Compared across services, such a picture is likewise the same picture changed by the same sentence (`image.whole` says `changed`; `image.redraw` and `image.whole` take `fromWords`).
- **One text of how somebody looks.** A card had an appearance, for the writer, and a *visual anchor* beside it, for image models: two texts of one thing. There is the appearance alone now — a paragraph in the book's language, which the writer writes by and every picture is drawn by; the director writes it (and rewrites it by the art direction) where it used to distil an anchor, and the planner completing a card writes no second text. A card that still has an anchor is drawn from it, as before, until it is folded into the appearance — a button on the card, and one above the list for every card — or the author rewrites the appearance or drops it. What must not be drawn on somebody stays a field of its own.
- A brief no longer tells the image model how to read it ("who does what is as the picture says"): it holds what is in the picture.
- **One brief for every picture.** Prompts are no longer run together in one sentence, in another order for every kind of picture: each is laid out a line a part under its name, in one order — purpose, the picture, framing, people, place, things, what was asked, art direction, reference pictures by number, exclusions — the way the documentation of GPT Image and Qwen-Image asks. The brief is sent as it is; the director writes it out only where it does not fit the model, or for every picture where the author says so (`image.promptWrite`: `fit`, `always`, `never`; `image.promptLang: en` for a model that reads English alone).
- **A person whose picture goes along is pointed to, not described again** (`image.looks`: `pictured`, `always`) — unless their look was rewritten since that picture, an outfit has no sheet of its own, or the service leaves the picture behind.
- **View stands apart in the bar.** The way to the viewing side is no longer one of the tabs where the book is made: it is a button of its own beside the book's name, lit while it is where one is.

### Fixed

- **Works on DSH 0.2.1** (checked on 0.2.1-alpha.4, and again on 0.2.0-rc.2). Two things broke there. **Every showrunner turn failed** before its request — `unknown prompt variable "{{cwd}}"`: 0.2.1 took `{{cwd}}` away (its working-directory service tells the model where a session works), and the *Novelist* preset's persona ended with `Your working directory is {{cwd}}.`. The preset no longer says it; on a DSH without that service the agent half says it, as before (`src/agent/mount.ts`). **The crew never ran as agents under a conversation**: 0.2.1 has no `ctx.subagents.start()` — a child is started as an activation it manages (`startActivation`), which turns away a run whose id is a session it has — so each role fell back to one request, one answer. On 0.2.1 a role is now started that way, with an id of its own for the activation and the result handed to the Studio alone; it is listed under its conversation as 0.2.0 lists it (the same one-shot catalog entry and descriptor), and a role kept for a word that may follow (a plan to adjust) is left alive when DSH ends the activation. On 0.2.0 nothing changes (`src/host/roles.ts`). Installing on 0.2.1 needs nothing: the plugin declares no `engines.dsh`, and its peer range `>=0.2.0-rc.2 <0.3.0` takes 0.2.1's prereleases.
- **A speaker written with their aliases, or whose card came after the script, is voiced as the card.** The director is shown the cast as `Name(alias/alias)` and sometimes hands the whole of it back as the speaker — every line of Alice's in *Alice's Adventures in Wonderland* came back as "Alice(Mary Ann)". Only an exact name or alias was taken, so such lines were spoken in a stranger's voice; so were the lines of a script written before the book had its cards. A line with no card is now looked up by its speaker's name when it is voiced — whole, then the name before the brackets and each name inside them (`speakerCard`); the script is written as that card, and lines voiced as a stranger are voiced again.
- **People with a card are no longer filed in the world.** Importing *Alice*, the world pass made the Hatter, the March Hare and four others "terms" under the same ids as their cards. Names that are somebody's card are left out of the world an analysis collects and out of what the planner hands back, and a suggested new entry named after a person is let go of without asking. A byname counts only for a term or other entry — 通灵宝玉 is an alias of 石头 and also a thing. A book that has such entries is told so in the overview, with one button to take them out of the world (`peopleInWorld`; the cards stay, and the entries can be put back).
- **A picture in a chapter no longer makes it "not digested".** The digest kept a fingerprint of the whole text, picture lines included, so putting a picture in undid it. It goes by the prose alone now (`digestOf`); fingerprints kept the old way still count.
- **When Codex draws nothing, the error says what Codex said.** A run of the Codex CLI that ended without a picture was reported as the plan perhaps not including pictures; Codex's own last message is kept from its `--json` output and quoted, and the plan is only mentioned when it said nothing.
- **The showrunner answers in the language the author writes in** — not the language of the book or of what else is in its context (a workspace's notes in Chinese had it answer English questions in Chinese).
- **The reader shows emphasis as emphasis.** `_italic_`, `*italic*` and `**bold**` in a chapter were shown with their marks; they are set in italics and bold (`EMPHASIS` in `src/shared/text.ts`).
- **Smaller things on the pages.** The buttons under a cover wrap instead of running over the summary; the writing page's top bar wraps instead of running under the panel beside it; "1 people… have", "Named in 1 chapters", "1 scheduling notes" are singular; the set-up guide's colons follow the language; a page of the Read view opens at its top, its breadcrumb in sight.
- **The showrunner is told the name of every review issue.** What `novel_review` and `novel_read what=review` handed back listed each issue by a number, how grave and what it said; its id was only in the structured result, which goes to the Studio's pages and not to the model — while `novel_revise scope=issues` and `novel_manage action=resolve_issue` take an issue by `<chapter>:<issue id>`. So the showrunner told the author the ids were only to be had on the Studio's pages. Each issue is now listed under that name, with where it stands (open or dealt with, the author's own, handed over to be mended, the proposals that wait beneath it as the pages show them, a change the reviewer wrote out, what it is at odds with) and what the tools do with it. `novel_read what=review` without `ref` lists every open issue of the book, chapter by chapter (`offset` / `limit` page through them). `action=resolve_issue` takes the issue as `<chapter>:<issue id>`, and a chapter by its number as well as its id (it took the id only: "3" found nothing); an issue the review does not have is said to be missing, not reported as marked. Which proposals wait beneath an issue is one rule for the pages and the tools (`src/shared/issues.ts`).
- **"Last time" is the last time.** The line under the bar that says what the author's last sentence came to — and the unfolding of the chapters it was found in — took the oldest such run of the session for the latest (the Host lists jobs newest first, and the last of the list was read). It goes by when the runs were started.
- **A page no longer keeps a state of the book that misses the last change.** A book's state was stamped with the revision at the moment it was handed over, not the one it was begun at: whatever was written while it was being read — the last of several proposals a planner writes one after another — was missing from it, and the page, told it held the newest, never asked again (a proposal short until the page was loaded anew). It is stamped with the revision it was begun at.
- **What the planner does while it prepares a chapter's material no longer shows where the chapter is being written.** An agent's steps are written into the text of the job it works in; in a writing job that text is the chapter the page is showing, so the planner's `› book_read chapter 4 — …` lines — two dozen of them on a test chapter — stood there until the writer's first words replaced them. The same went for the planner reading the references before a chapter, and for the material of a passage rewritten or a chapter written over. What is done beside the writer in such a job is now said where the job's progress is, and nothing of it is written into the job's text (`beside`, `src/core/pipelines/material.ts` — the digest that follows a chapter goes by it too). What the writer was handed was never touched by it.
- **The digest that follows a chapter no longer shows where the chapter was being written.** A digest streams its reply into the text of the job it runs in; run at the end of a writing job, it replaced the chapter the page was showing with its own JSON — which read as the writer's output ending in a great deal of "memory". The writer never wrote it, and it took nothing of the writer's length: the digest is a request of its own, by the scribe. It now runs apart from the job's text. A digest that fails after a chapter was written — the text is saved all the same — is said, where it used to be logged and nothing more (`WriteResult.undigested`).
- **A chapter drafted anew is no longer written by what its last draft happened to be.** Once a chapter had been digested, drafting it again from the top sent the writer what the digest of the old draft had left: the plan's blanks it had filled — where the old draft took place, its story time, who was in it — and the threads it had touched, moved to the head of the list and starred as this chapter's, with "advanced in" this very chapter. The second draft was steered by the first. Now a chapter that is drafted (`writeChapter` mode `draft`, a comparison's drafts too) is seen as one never written, on both ways of preparing the material: the plan goes as it was meant (`planAsMeant`: without the fields marked `fromText`, and — in a plan filled before that was marked — without a synopsis, place or time that holds to the letter what the digest gives), the threads go without the chapter's own marks and without a thread only its digest proposed (`threadWithout`), and the planner preparing the material is shown no text and no memory of it, in its task, through `book_read` and through `book_search`. Written by rule, the second draft of a chapter is sent the same request as the first, to the letter (`tests/chapter-memory.test.ts`). A chapter gone on with, revised or reviewed is taken as it stands, as before.
- **A chapter digested again takes back what its digest before left.** Thread marks were only ever added: a thread the old draft had advanced stayed "advanced in" the chapter after a new draft that never touched it, a thread only the old draft had planted stayed a thread, and what the old draft had suggested kept waiting. A digest read anew now takes the earlier one's marks, plan blanks and suggestions back first, and fills the blanks from the chapter as it is. What a digest fills into a plan is marked (`ChapterPlan.fromText`); a field anybody sets afterwards is theirs and off the list.
- **`npm install`, `npm pack` and `npm publish` leave a `lib/` that is there alone.** `prepare` was the build itself, so any of the three put the working tree — finished or not — into `lib/`, which is what a linked copy of the plugin is running; listing the package's files with `npm pack --dry-run` did exactly that. `prepare` is now `scripts/prepare.mjs`: where `lib/build.json` exists nothing is done, and a checkout without a build (a fresh clone) still gets one. A release is `npm run release`, as before.
- **A chapter revised is handed its neighbours, not the book.** Written over whole to an instruction, or gone through and changed in place, a chapter went with what a chapter is written with — on an 80-chapter book 436K tokens (counted), and for the one that works as an agent that much again with every step. The rewrite sent so came back identical to the chapter, character for character. Both now get a context of their own size (`context.chapterTokens`, 60,000 by default, per book too: the chapters next to it word for word, the rest in outline; the chapter itself comes besides, whole). Same chapter, instruction and model: 436K → 54K tokens in, the ending rewritten as asked and the rest untouched; a run in place took seven steps of 56–61K. The planner's ways of mending (30–38K a step) and reviews (as much of the text before as fits) are as they were.
- **The chapter that is revised or reviewed always travels whole.** Its own text took what was left of the side budget and was cut to its end when that ran out — right for going on with a chapter, wrong for writing it over or judging it: on a model with a small window (or a context cut to size) a rewrite or a review saw the chapter's last three thousand characters. It no longer competes; where the window is short, the other chapters' text gives way to it.

- **A selected passage rewritten to an instruction is rewritten.** It was handed what a chapter is written with — half the model's window in the chapters before, the chapters after whole — so that in a long book the instruction was one line after hundreds of thousands of tokens (433K measured for a paragraph of 159 characters), under rules that said to keep what it did not ask to change; the passage came back copied with a few words added. It now gets a context of its own size (`context.passageTokens`, 24,000 by default: the bible, the people, the story around its chapter, and the chapter itself around the passage), the instruction before the passage and once more at the end, and rules that say the instruction is to be carried through and holds over outline and surrounding text. Same paragraph, instruction and model: 433K → 19K input tokens, 18 s → 4 s, and sentences rewritten rather than padded.

- **Chapters derived onto the end of a line follow its last chapter, written or not.** With a chapter planned and not written at the end of the outline, the planner took "the next chapters" to start after the last one that was written, and planned that chapter a second time. The task now names the chapter the new ones follow and says that no chapter the outline has is planned again (`deriveChaptersTask` `follows`).

- **A menu opens where it is not cut off, as wide as what it says.** A menu anchored to a small button near the Studio's edge ran out of the panel on the side it was asked to open, and its labels wrapped at the least width; it now takes the other side when the asked one does not hold it, and its labels' width.
- **A chapter's plan set by its text is read anew — and its purpose with it.** Asked to leave the beats that "still fit" word for word, a model handed the old beats back, and a scene the text had gained since went without one (a chapter's closing knock at the door: "4 of 4 as before"). The beats there were are no longer shown to it: the text is gone through from its first line to its last, a beat a scene. *What the chapter is for* is now set by the text too (against the synopses of the chapters on either side), with the synopsis, place, time, point of view and cast; the notes for the writer and the threads stay. Somebody in a plan's cast who has no card is shown by name on the Outline page instead of being left out.
- **A mending that goes on from waiting changes reads what it is checked against.** Its planner quotes the chapter with those changes laid in, but its reading tool showed the saved text: copying from the tool, it was sent back, read again, and went round (35 steps in one run). The tool now shows the chapter as the work goes by it.
- **Paragraphs in a proposed change are parted the chapter's way.** A single line break in what a model hands in for a place becomes the empty line the chapter keeps between paragraphs.

- **What a writing or revising job came to is said on the page that shows it at work.** A job whose text the writing page showed as it came counted as "somebody is waiting for it", so its closing notice — pictures put back into a rewritten text, and now how many places a revision changed — never appeared there. Only a job started and awaited by a caller is that caller's to report.

- **A link into the settings goes to its section.** A link that opened the settings at one of their parts ("speech is not set up", the outside help's *More*) opened the part and stayed at the top of the page: taking the request off the store rendered the page again, and the effect's own cleanup cancelled the scroll it had just asked for.
- **A Host half that was replaced left a watcher behind.** After the Studio's *Restart*, a request the old Host half was still answering could open the book again in a core that had been taken down — with a file watcher nobody closed. From then until DSH quit, it took every write of the new half for a change made outside the Studio: false "changed outside Novel Studio" lines on the book's record, a digest attempted by dead code, entries of the record lost to two writers. A core that was taken down now opens nothing, and the page asks the new half again.
- **The pictures in a chapter's text were dropped when the text was written anew.** A picture is a line of the text (`![caption](path)`), and a model asked to change the words often handed the text back without it. Whoever rewrites a passage or a chapter is now told what such a line is and to hand it back where it stood — and what comes back is held against the original: a picture left out goes back after the line that the one it followed became (as far down the text as it stood where nothing reads alike), a path the model spoilt is put right, a picture line of its own making is taken out, and the caption stays the author's. The same holds for a chapter drafted over again (its pictures go into the new draft), for text the showrunner puts in the place of text (a picture goes out only by deleting its own line), and for a translation that lost one. The story so far now travels to the writer as prose, without picture lines, so it writes none of its own. Where anything was put back or taken out, the proposal and the result say so.

- A picture of the album opened large was laid out in the page's own box — as tall as the page — where the viewer sits in a pane; it is put over the window now. A published site carries whether names, lore and moments are shown in the text, with the author's other reading settings.
- **Pictures in the text went by a portrait instead of the design sheet.** Somebody in a stretch of their life that has a look written whole and a portrait of its own, but no sheet of its own, was read at that chapter as having no sheet at all — so the stretch's portrait, often a scene with other people in it, went along as their reference in every passage picture, illustration and panel. A picture with somebody in it is now held against a sheet: the stretch's own, else the card's main sheet with the stretch's look written out beside it. A portrait stands in only for somebody who has no sheet anywhere.
- **A passage selected for rewriting stayed selected in state, but stopped showing.** A text box paints its selection only while it has the caret: the moment the author went to say what to do with the passage — the box for how to rewrite it, a button of the bar, a dialog — the text looked as if nothing were selected, and stayed so after *Rewrite*. The passage is now marked behind the text whenever the caret is elsewhere (the same words laid out the same, under the box), until the author selects something else or the text changes.
- **A design sheet somebody has was drawn again for every portrait that had them in it.** Whoever a moment shows beside its subject was read as the moment's chapter has them; in a stretch of their life that says something of how they look, that reading showed no sheet — and the main sheet they had was drawn anew, each time. Whether somebody has a sheet is now read off their card as the book has it. A stretch that only says what is different then keeps the card's sheet, with the difference said in words; one with a look of its own, written whole, is held against its own sheet.
- **The button under the hand did nothing.** With *Rewrite and redraw* or *Change this picture* open, the button that opened it stayed lit at the foot of the dialog while the form's own button stood across the dialog, under the picture. The foot of the dialog now holds the open form's buttons — cancel, several models, draw — in that place.
- A moment that had been drawn could show as *not drawn* in the panel of somebody's moments: its picture was tied to it only by a note on the card, which a chapter digested again (its moments numbered anew), a comparison of services, or a card of the older single-paragraph form did not keep. A picture is of the moment its own record says it is of; a moment that was drawn is no longer dropped from the card when the digests come to weigh others more; and a portrait is attached to its moment on the card as the card is when the picture is there, not as it was before.
- A prompt the director wrote out copied the list of exclusions into the prompt where the service takes it in a field of its own.
- The record of a picture said "the visual anchor was changed since" of a picture whose prompt only pointed to the person's sheet, and "an earlier portrait" of a moment's picture.
- Two pictures drawn from the same words in the same instant were given one file name: the second was written over the first. Each picture file now has a name of its own.
- *Compare…* on a picture there already is answered "say what to draw": the services to compare were dropped on the way to the redraw. They are passed on now, and a test reads the table of calls beside the Host's handlers so that a parameter cannot be left out unnoticed again.
- A model of Bailian's that takes no reference pictures (Z-Image) refused a picture sent with them; it is now drawn from the words alone, and its record says why — as with every other service.

- **The Studio from a phone.** Two things, both meant to go again once DSH's own page is at home on a small screen. The Studio's page can lie over all of DSH's frame — sidebar and bars — so a phone's whole screen is the Studio (a switch in its bar uncovers DSH; on a small screen and through the door it starts covered), with what is pressed sized for a finger. And a door: *On a phone* (the home page, the phone icon in the bar) opens an address on the local network through which a phone reaches the page DSH serves on this computer — a small reverse proxy of the Studio's own, because DSH's page answers only to the loopback. It is let in by a random token (the link and its QR code; a cookie after the first visit), passes every request on as this computer's browser would send it, keeps DSH's sign-in on this computer, closes after twelve hours, and is never remembered across a restart. It hands on all of DSH, not the Studio alone, and says so. It needs DSH running as `dsh web`: the desktop app has no page to hand on.
- **What the digests propose is settled by the planner, not accepted one by one.** A new place, thing, house or term, a thread, somebody worth a card: the planner looks the suggestions over in one request and enters what is worth entering, folds another name into what is there, and leaves the rest out — each with a reason. *Review → Suggestions* shows what entered (open it, change it, take it back) and what was left out (enter it after all). It runs after chapters are digested and after the names without a card were looked through; people the story leans on then get a card written from what the digests saw of them. A change to what somebody already wrote still waits for the author. A setting turns it off (`settleSuggestions`).
- **A book is taken in by one pass that leaves little to ask again.** The digest of a chapter now also writes down how each person is shown (age, face, dress) and bears themselves, and what a place or a thing looks like. With that in hand the cast, the world, the growth of the people and the ties are each one request a batch, side by side, instead of an agent reading the book again for every card; the signature scenes the digests noted go onto the cards as they are made; and what the digests proposed is settled at the end. The world pass may leave out what is not worth an entry (a study, a bed, "outside the city"), on record. Nothing a review finds is mended by itself.
- **A style knows what language it is written in.** A style profile has a *register* — classical, the vernacular of the old chaptered novels, modern prose… with the period and the words that mark it — which leads the profile and what the writer is given. It is judged by the words on the page, not by when the story is set, from passages of three places of the book rather than one. *Dream of the Red Chamber* no longer comes out as modern prose.
- **Reading a book again from its text alone.** *Digest again…* has a third way: everything read off the text — digests, cards, entries, ties, threads, suggestions, what reviews found, what the outlines took from the chapters — is cleared, and the book is taken in anew. The text and its versions stay, as do pictures, voices, storyboards and videos; a picture goes back onto the card or entry of the same name. What was cleared is in each thing's history, or among the removed ones.
- **Versions of the volumes, the lines of the plot, the table of ties, an audio script and a storyboard** — like everything else that is written. A chapter's text as it was before a translation is kept for good, whether translated in the Studio or as it was imported.
- **A private shelf.** Books can be put on a shelf that shows nothing until its password is given: no title, no cover, not in the list. A book on it opens with the shelf, or keeps a password of its own on top. A sealed book shows no cover on the open shelf either.
- **Names in the text, quieter and of more kinds.** Places, houses, things and terms are marked like people — each once a chapter, on its first mention, in a thin line of low saturation; either kind can be switched off in the reading settings. Selecting a name (a long press on a phone) opens its card; the card's picture is larger; from a person's or an entry's page *Back to the text* returns to where the reader was. A person's page carries a small graph of who they are bound to, and an entry of the bible lists the chapters that mention it, each a way to the passage.
- **A picture is told what to draw in order, and takes who and what it shows.** A portrait of a signature scene is composed a line a part — the scene, the framing, the person, those beside them, the place, the things — and carries the design sheets of the others in it and the art of its place and things; sheets that are missing are drawn first, side by side. A drawn signature scene also appears in its chapter's text, after the passage it shows. A design sheet can be the front view alone (a setting of the Studio or of a book — kinder to small image models). A motion comic takes the art of the things in a panel, or leaves it (a box on its page).
- **Writing in rounds.** Beside *in sequence* and *side by side*: chapters are written, digested and reviewed, then what the reviews found is mended across the batch by the planner, and reviewed again — for as many rounds as asked, or until nothing from a severity up is left.
- **The plot graph is worked by hand.** A chapter is dragged to another place or another line; the two ends of a line are dragged to where it leaves and where it joins. The writing page lists its chapters with the outline's own control — drag, insert, multi-select, move, translate — and *Translate* is a button of its bar.
- **A book's own settings are marked.** The settings page says whose settings it shows; a book with settings of its own opens on them, each one that differs from the Studio's marked and resettable; pictures have four settings a book can carry.
- **The way to the viewer looks like one.** *View* is one button, the same on every page, set apart from the buttons that change things.

- **Translation, by a glossary.** Chapters are translated into another language by the writer model — from the writing page (*Translate…* in a chapter's menu: this chapter, or every written chapter of the line), as a manuscript comes in (*The manuscript is in* on the import form: a book in another language is translated into the book's own as it is imported, and digested, carded and outlined from the translation), or by the showrunner (`novel_translate`; `novel_import translate_from`). What keeps a long translation saying one thing one way is a glossary (`bible/glossary.json`, one a language): how every name and every word of the book's own is written in the other language. It is settled before a line is translated — off the cards, where who somebody is decides how their name and their forms of address come out; out of the text where the book has no cards yet —, the terms a chapter uses go along with that chapter and say who and what they are, a translation that meets a name without a rendering settles one and adds it, and afterwards the cards take the translated names as other names they go by, so that the digests, the marks in the text and the context of the next chapter still tell people by name. The glossary is read and corrected in the same dialog (what the author sets is theirs; no later pass writes over it). A translation takes the place of the chapter's text (a long chapter goes stretch by stretch, each going on in the voice the one before ends in; several chapters at once, as the text gate allows); what it was translated from is kept as a version of the chapter (`before-translate`) and noted as its original (`.novel/translations.json`) — the chapter says *From …* beside its title, and its menu puts the original back, title and all. A picture in the text keeps its path. When every written chapter is in the language, it becomes the book's (`translatedFrom` says what it was). RPC: `ai.translate`, `ai.settleTerms`, `glossary.read / save`, `chapter.untranslate`; `ai.import` takes `translate`.
- **Versions of everything written, not of the chapters' text alone.** A character card, an entry of the bible, a style, a chapter's plan, a thread and the book's own info each keep how they were before a change (`.novel/history/<kind>/<id>/`), named by when and by what changed them — the author, the showrunner, a job by its title, a version put back, a deletion. A version is kept only when what the thing says changes: not for its pictures (those stay until somebody deletes them, and a version put back leaves the pictures of now), not for what the Studio keeps on it by itself, and once a sitting for the author's own saves. *History* — one button and one dialog beside each of these, wherever it is edited — lists the versions and shows every field in which the one chosen differs from now, as a diff; the whole version is put back, or one field of it, and what it replaced is kept so that it can be undone. A card, entry or style that was deleted is listed at the foot of its list (*Deleted…*) and comes back as it last was — or is removed for good there. The showrunner has the same record: `novel_manage action=history` (the versions of a thing; with `version`, what it differs in; without `fields`, what was deleted) and `action=restore_history` (`fields.only` for some fields). RPC: `history.list / read / restore / removed / forget`.
- **People's names are marked in the text, and say who they are.** Wherever a chapter names somebody the book has a card for — by name or by another name they go by — the name is underlined in a colour of that person's own; pressed, it opens a small card under it: their portrait, who they are in a line, their other names, and the way to their page in the album. In the viewer's text (read or listened to, with review notes on or off), on a phone and on a published site alike — it is the page all three share. The longest name is tried first, a name two people share is the weightier one's, a single character is never taken for a name, and people kept to another line of the plot are not marked. *Reading settings → More* turns it off (`names`).

- **A panel of a motion comic is a picture of the book like any other.** Panels were drawn off the record: they were in no gallery, opened in no viewer, and could be changed only by rewriting a panel's prompt. A panel is now kept on record as it is drawn (kind `panel`, of its chapter; its prompt part by part, the pictures that went along, the words as sent), and those drawn before are listed with what is known of them (`Project.pictures`, which `image.list` answers with). So the gallery shows them — its own kind among the filters — and a panel's picture opens in the viewer every picture opens in: the record of its making, *rewrite and redraw*, *change this picture*, *delete*. Drawn again there, the new picture is the panel's (`replacePicture` reaches into storyboards); taken away, the panel is a panel without a picture (`removePicture` likewise). A panel with nothing on record but the director's words is redrawn against what its storyboard says is in it.
- **A picture the book has can be placed anywhere in the text.** From the picture: every picture opened large has *Place in the text…* — a chapter, then the paragraph it is to follow (or the top). From the text: with a passage selected on the writing page, *Place a picture…* offers everything the book has drawn — this chapter's scenes and panels first — and puts the one chosen after that passage. Nothing is drawn; the text is changed at that one spot and nowhere else, and the text as it was is kept as a version (`Project.placePicture`, `image.place`).
- **Several drawings of one chapter's panels, and several productions, side by side.** While one panel was being drawn again, every other panel's button waited; while any one-click production ran — even one chapter's, started from its own page — the production board let nothing else be started. A panel is now drawn again while others are (each drawing says which panels it is on, and those alone wait; the progress line counts them together and stops them together), and the board starts another production beside those under way for any chapter none of them is on. Behind it, a drawing keeps its panels into the storyboard as it stands at that moment (`patchComicPanels`, under the file's lock) and no longer writes its own copy of the board over what another drawing kept.

- **Chapters are dragged into place on the outline, and a new one goes between two that are there.** A chapter moved up or down one step at a time through a menu, and a new chapter could only be added at the end of a volume or a line. In the outline's list a chapter is now taken by its row and let go between two others — a line shows where — or on the last row of a volume or of the line, to end up there; with several ticked, taking one of them takes them all, in their order (`move-chapters`, so what would tie the plot into a knot is refused as before). What a line shares with the one it parts from is that line's to order, and is not taken from here. Every row has a way to put a new chapter right after it, beside the way to take the row out, and the chapter's own menu has *Insert a chapter before / after* (`add-chapter` with `before` / `after`, which the operation always took). An outline operation is now shown the moment it is done rather than when the page next hears of the change.

- **Chapters can be moved to another place in the plot — the plot re-wired by hand.** A chapter could be reordered on its line; it could not leave it, and where a line leaves the story could be said only when the line was opened. A chapter, or a run of them, now moves elsewhere on its line, onto another line, or onto a line opened for it (its name, and the chapter it leaves after — or none: a story of its own from the first page): a side story that was imported among the chapters of the main line is parted from it this way. One dialog does it, opened from the plot graph (a chapter: *Move to…*, *Part this chapter and what follows into a line…*), from the outline (a chapter's menu; several ticked at once) and from the writing page (the chapter's menu). Everything made from a chapter goes with it — a chapter is found by its id wherever it lies — and lines that leave after a moved chapter, or arrive at one, follow it. What would tie a line into a knot (a line leaving after one of its own chapters, a way round in a circle) is refused with nothing moved; the dialog does not offer such a line. A line's own dialog says where it leaves for an existing line too (`update-line from`, `null` for nowhere). Behind it: `Project.moveChapters`, the outline op `move-chapters` (also the showrunner's).

- **One control for a picture, wherever one is shown.** Opened large — from the gallery, a person's page, an entry of the bible — a picture has the record of its making beside it, and now what can be done with a picture, the same everywhere: keep a copy, *rewrite its words and draw it again*, *change one thing in it* (the picture itself goes to the image model as what to draw again, with what to change — for a picture that is right but for one thing), and take it out of the book. Behind it, `redrawPicture` draws any picture again from its record, whatever kind it is — its words rewritten go in the subject's place, with the art direction as the book has it now, what the picture kept out and the references it had — and the new picture takes the old one's place wherever that hangs (`Project.replacePicture`: a card's sheet, a look's, a stretch's pictures, a moment's portrait, an entry's art, a turn's picture, the cover), the old one staying in the gallery (`image.redraw`; the showrunner's `novel_illustrate redraw=…`). Taking a picture away lets go of it in all those places too, and works by path for a picture that has no record (`Project.removePicture`; `image.delete` takes `path`); beside a portrait, a design sheet, an entry's art and the cover there is the way to it without opening anything.
- **Portraits are kept side by side.** A portrait drawn again replaced the one before on the card; the earlier ones were in the gallery and nowhere a person's page showed. A card now keeps every portrait (`visual.portraits`, the first being `visual.portrait` — their face in the lists): a new one goes first and the others stay, the strip under the picture shows them all — with those the gallery still has of them from before — and the one shown can be moved forward and back, made the first, or removed.
- **A house or an organisation has design art.** Places and things could be drawn; a family, a guild, a sect could not. An entry of that kind is drawn as the one picture that stands for it — its seat, its emblem and banner, or its people gathered — from a look the director writes for it (what can be seen of it; nobody in particular), and redrawn and removed like any other.
- **Signature scenes come with the digests.** The moments somebody is remembered by were found by the director reading the book for one person at a time — a run each, over the same chapters, the first time a portrait was asked for. A chapter is read once already, when it is digested: its digest now notes in passing which of its moments a reader would remember somebody by, as a picture and with a weight (`ChapterMemory.scenes`), and a card's list is put together from those notes — the weightiest first, six at most — with nobody reading anything again. It is on the card as soon as the chapter is digested, and a portrait asked for nothing shows the first of it without a director's run. Such a list is brought up to date as chapters are digested for as long as nobody has taken it in hand (`SignatureScene.from: 'digest'`); a moment the author changes, chooses or removes, or a list the director looked over, is theirs and is let be. "Have the director look" is still there, and starts from what the digests noted.

- **A server of your own takes reference pictures where it says it does.** The author's image server learned to (`POST /v1/images/edits`, a form with the picture as a file — what OpenAI's `images.edit()` sends — and a row in `GET /v1/models` saying `capabilities.image_edit` and `reference_images.max_count`), and the Studio went on saying it took none: on the OpenAI-compatible path it told by the model's *name* — anything but GPT Image was sent the words alone, unasked. Now the service says: a model's row is read for how many pictures it takes (none where `image_edit` is false), that many go to the edits endpoint (one as `image`, several as `image[]`; with the seed where `edit_defaults.seed` gives one), busy answers are waited out there as on the generations endpoint, and *Settings → Images* shows the figure beside the model. Where no list says anything the pictures are sent, and a refusal that is about the request (400, 404, 405, 415, 422, 501 — not the key, not being busy) comes back as `REFERENCES_REFUSED`: the picture is then drawn from the words alone, its prompt written anew without a word of any picture, and what the service answered is kept on its record (`parts.leftWhy`). An endpoint that is not there at all is not asked a second time for half an hour — not for good. Pictures a service's measure kept back (it takes one, two were to go) are on the record as well (`parts.left`). Run for real on the author's server: a portrait from the words, its sheet against that portrait, a scene against the sheet.
- **What a picture is drawn against can be chosen where the pictures are.** Which of a person's two pictures leads was a setting, and nothing on their page said — or let the author say — what the next sheet would be held against: with the sheet leading (the default) there was no way from a portrait to a sheet that matches it short of changing the setting. Beside the two buttons there are now two choices, *the portrait from: the design sheet / the words alone* and *the sheet from: the portrait / the words alone*; each starts as the setting has it and holds for what is drawn from that page. `from` on a picture's request takes `sheet` for a portrait (theirs is drawn first where there is none — from the words, not against the portrait they have) beside `portrait` and `words`; the question put before a portrait is answered by the same choice. The note that goes with a portrait sent along for a sheet now says what the sheet *is* — standing straight, hands empty — besides what to leave behind: told only the latter, a model that takes a picture along drew the umbrella she held into all three views.

- **Full screen for reading, listening and watching.** The viewer's bar has a way to the whole screen (`F` in and out, `Esc` out). The frame that goes there holds every half of the viewer — the text as page, script or motion comic and film, the people, the world, the side stories — so changing between them stays full. In it the viewer is a reader's: the page, the play bar and the controls of reading; the workshop's own (review notes, the production desk, the way to a phone, to editing, the picture strip over a selection) stay behind and are as they were on leaving. While the pointer rests, the bar and the pointer fade; the strip the bar leaves reads as the page's margin, so nothing jumps. The screen is asked for through the Fullscreen API; where the page may not have it, the frame fills the window instead, and where a host grants it and takes it straight back, likewise. Dialogs opened while full go inside the frame. (`src/client/reader/full.tsx`, among the parts the Studio and the phone reader share.)

- **Which picture of a person leads is the author's to choose.** A design sheet came first, always: drawn from the words alone, with the portrait and everything else drawn against it. The other order is as sound — a portrait the author likes, and a sheet that matches it — so *Settings → Images* has a choice of three in the place of "draw a missing design sheet first" (`image.lead`). *The design sheet* (as before). *The portrait*: a portrait is drawn from the words alone and never against the sheet; the sheet is drawn against the portrait — after it, where there is none ("after it, 1 design sheet drawn against the portrait": asked first, as ever) — told what the reference is for (who they are; not the background, the pose, what is held, the light); other pictures are held against the sheet. *Neither*: nothing is drawn for another picture's sake. References still run one way in each. A sheet or a portrait already there is never redrawn behind the author's back: the page says which has fallen behind. The art batch orders its two steps accordingly; `novel_illustrate kind=sheet` takes `from` (`portrait` | `words`) for one picture. `sheetFirst: false` reads as *neither*.

- **A prompt that fits the model: the director rewrites one that is too long.** An image model reads so many tokens of a prompt and silently drops the rest — and the Studio's prompts end with the art direction and what to keep out. The limit is now a setting (`image.promptTokens`; where unset, what a server of the author's own says of its model, `limits.max_prompt_tokens`), and a prompt that comes to more is written again by the director before the picture is drawn: the same picture in fewer words, in order of what matters, with what to keep out worked in and talk of reference pictures dropped where none go. What is handed in is measured (the Studio's own count, on the safe side, held to nine tenths of the limit) and handed back if over; the nearest try with its end left off, or the prompt as it was, where that fails — and the picture's record says which (`sent.compact`), beside both prompts. A prompt fitted once is kept for the same picture drawn again. Settings → Images: *Prompt limit (tokens)* and a tick box to turn the rewriting off (`image.promptCompact = false`); a listed model shows how many tokens it reads.

- **Pictures from an OpenAI-compatible server of your own.** The custom images endpoint took any address and any model id already, but asked every endpoint as it asks a service on the net: eight pictures at once, at the Studio's own sizes, with a quality where one was chosen, and never without a key. A model on the author's machine or network behind `/v1/images/generations` (`client.images.generate()` in OpenAI's SDK) is now asked the way one graphics card wants to be: **one picture at a time** whatever number is set; each **at the nearest in shape of the sizes it draws** (`image.sizes`; `768x768`, `768x512`, `512x768` while none are named); **sent `model`, `prompt`, `n: 1` and `size` and nothing else** — no quality, no reference pictures; **waited for as long as it says** when it answers `429` with a `Retry-After`; and with **a key only where it wants one**. Which endpoint is such a server is read off its address — this machine, a private network, a Tailscale-like VPN — unless the model is one of OpenAI's, and is said outright with `image.local` where the address misleads; the settings show it as a tick box under the custom endpoint, with the sizes beside it and what each kind of picture comes to. A refusal that carries its words in `detail` (FastAPI's way) is now quoted like any other. Nothing changes for a service on the net: GPT Image is asked as before.

- **Who and what belongs to which line of the plot.** In a world that holds several stories, a character's card and a world entry can name the lines they belong to (`lines`; `main` is the main line) — *Plot lines* on the card and on the entry, shown only in a book with more than one line. One that names none belongs to all; one kept to some lines is left out of what the writer of any other line is told (its card, its entry). Beside a name the page shows the lines it is kept to — or, where nothing is said, the lines the person is seen on, read off the digests along each line.

- **Another story line, imported into the same world.** A book's plot could already hold a line that parts from the story's very beginning; what was missing was a way to bring a finished manuscript in as one. *Import another story line* on the plot graph takes a file (.txt / .md / .epub / .docx), has the editor find its chapters, and puts them on a line of their own that begins where the story begins and joins nothing — sharing the book's bible: people and places it has in common are recognised by name as its chapters are digested, and whoever is new comes up as suggestions. Lives, stages and signature scenes are read along a line as before. To the showrunner: `novel_import action=line` (`line.import`).

- **People grow along the book.** A card said one age and one face, of no chapter in particular. Now it keeps the **stretches of a life** (`stages`): from which chapter on, how old ("about thirteen (a youth)"), what turned, and — where they differ — how the person looks and who they are in that stretch, with a design sheet and a portrait of its own. **The planner finds them**: an agent that reads the book for how old somebody is as they enter and for the points where they become somebody else to look at or to describe (a stage of life, a station, a look) — a stretch is not an episode of the plot, and most people have one to three. It runs as a step of the import analysis (`growth`), for one person from their card (*Growth → Have the planner find the turns*, with a word beside it), and for everyone listed in one go (*Read their growth*). **What follows from a stretch**: the writer is told which one holds at the chapter in hand (age, look, bearing); an illustration or a panel of a chapter shows each person as that chapter has them — the stretch's own anchor and sheet; a portrait of a signature scene shows the stretch that scene falls in. A stretch that looks different gets its own anchor — written by the director from the card's, so that it is the same person in words — and its own sheet, drawn from those words alone (held against the card's sheet, it came back as the card's sheet). To the showrunner: `novel_bible action=derive_growth`, `novel_illustrate … stage=<id>`.

- **Pictures from a model on this machine: ComfyUI and Diffusers.** Two more ways to draw, for trying local models against a book. *ComfyUI* talks to a running server over its HTTP API and runs the author's own workflow (exported in API format, with `%prompt%`, `%negative_prompt%`, `%width%`, `%height%`, `%seed%`, `%steps%`, `%scale%`, `%model%` filled in; a second workflow with `%image1%`… takes the reference pictures) — or a small built-in graph for a plain checkpoint. *Diffusers* starts the author's own Python with a worker that loads the model named (a Hugging Face id, a folder, a `.safetensors` file), keeps it loaded between pictures, and passes each pipeline only what its call takes. Neither holds a key; both keep the picture's record like every service. Settings → Image generation → Service; `image.provider: comfyui | diffusers`.

- **What a review found is mended in batches, across chapters.** Mending issue by issue rewrote one place at a time, and two fixes of the same fact could disagree. The review page now lists every open issue of the book, chapter by chapter, each with a box for what the author says of it — kept with the issue (`note`), not with the screen — and a tick box. *Mend the chosen together* hands the ticked ones, with a word on the batch, to one planner: it reads them side by side, settles which chapters change and how — also chapters nobody named, where they tell of the same facts — and each chapter is rewritten once, for everything that concerns it; the bible's changes wait as suggestions, the chapters' as proposals. *Mend the grave ones* does the same for every open issue from a chosen severity up, in one click. An issue handed over says so until the author settles it. To the showrunner: `novel_revise scope=issues` (`issues` as `<chapter>:<issue id>`, or `severity`). The same tick boxes and the same bar are in the editor's review panel and in the reader's list of a chapter's notes; on the review page the issues are read chapter by chapter — a row per chapter that unfolds its own. **Once proposals are accepted, what is still open is looked at again**: the reviewer reads the open issues of the chapters that changed — and those handed over with the same batch, wherever they are — against the text as it stands; what the change settled is marked settled (with why), what reads differently has its quote and wording brought up to the text, and the Studio says how many of each. **What was made to mend an issue shows beneath that issue**: the diff, with *Accept* and *Reject*, right where the fix was asked for — on the review page, in the editor's panel, in the reader — instead of a trip to the proposals tab (a proposal carries the issues it mends, `issues`; a rewrite that mends several of a chapter's is folded under each). *Check again* on the review page asks for the same look at any time (`review.recheck`); `recheckIssues: false` in the settings turns the automatic one off.

- **Signature scenes: the moments a person is remembered by, and a portrait of any of them.** A portrait used to be a face on a plain ground, the same picture for everybody. Now a character's card keeps their signature scenes — Lin Daiyu burying the flowers, first — in a panel of its own (*Signature scenes*, `visual.scenes`): what each is called, the chapter it is from (a click reads it), the moment written as a picture, why it is theirs, and the portrait drawn of it. The director finds them in the book — an agent that reads the text, handed the digests' notes on the person as leads — most their own first, as many as there are; the author rewrites them, adds and removes them, marks which one a portrait shows by default, and has the list looked over again with a wish beside it. Beside the portrait button a choice says which moment the next portrait shows (or a plain likeness), and each row draws its own. Nobody is stopped to be asked before a first portrait: the list is there to read and to choose from. **What the author asks of one portrait guides the pick instead of replacing it**: "brighter" has the director settle — among the moments kept, or another of the book's — the one that answers to it, and say how the wish was used; that moment is for the one picture, and one click adds it to the list. **Which moments are fit to be shown is the author's to say** — the book's avoid list, what they ask: the task rules no kind of moment out (a martyr's portrait may be the martyrdom, a general's the fight), with one line that is not the author's to move — somebody under age is not written into a moment of intimacy or nudity. A book with nothing written is not asked, and somebody the book has no moment for gets the plain portrait and the reason. The interlude stage draws plain figures; `image.portraitScene = false` turns it off. A card of an earlier version that kept one paragraph (`visual.scene`) reads as a list of one. To the showrunner: `novel_bible action=derive_scene` (`direction` guides it), `novel_illustrate kind=portrait scene=<id>`, `prompt` / `notes` on a portrait guide its moment, `plain=true` draws the plain one.

- **How a picture came to be, beside the picture.** Opening a picture large — somebody's portrait or design sheet on their card, the design art of a place or a thing, anything in the gallery — shows all there is on record of its making: how it stands against the book as it is now (is it the picture in use; were the visual anchor and the art direction changed since; was a portrait drawn against the sheet in use, an earlier one, or none); the reference pictures that went with the prompt, each opening its own record, so that a look can be followed back from picture to picture; what the prompt was put together from, part by part in the order sent, with where each part is changed; and what the image model was sent, word for word. For that, a picture now keeps the parts of its subject (`parts.pieces`), what its prompt said of the references (`parts.referenceNote`), the service and the size it was drawn with, and `sent` — the prompt as it left, with what the way to that model adds: the things to keep out where the service has no field for them, the shape of the frame where it takes no size, an agent's wrapping. The showrunner reads the same with `novel_manage action=show_image`. It is the author's alone: the reader on a phone and a published site carry none of it.

### Fixed

- **Enter that takes a word from an input method no longer sends the form.** A text field sees the Enter that confirms a candidate — how Chinese, Japanese and Korean are typed — as a key like any other, and eleven fields that go on Enter went on it: a picture changed with half a sentence, a brief sent to the writer mid-word, a passage rewritten by what was typed so far, a person or an entry created under the letters of its name. One check (`plainEnter`: not composing, not key code 229) now stands before every one of them.
- **A picture drawn again stays open — on the picture that came of it.** The viewer closed itself the moment a redraw was done: the author, who had asked for a change in order to look at it, was back on the page with the picture gone from view, and the next clicks went to whatever lay under where the buttons had been. It now shows the new picture with its record, ready to be changed again (`onChanged(now)`; a page that names what is open follows). While a picture is being drawn its form stays where it is — the two ways in and *Delete* wait — instead of being put away by a second click on the button that opened it, which had looked like nothing happening; pressed again, a way stays open, and its form has *Cancel*. Closing the viewer does not stop the drawing: the job bar shows it.
- **A server's image model is not left out of the list for what it is called.** *Read the model list* kept, for the image slot of a custom endpoint, only ids that looked like image models (`image`, `flux`, `wan`…): the author's server gained a third model, `noct-q-v4-nf4`, and the list went on showing two. What a row says of its model now decides — `capabilities` (`text_to_image`, `image_edit`), the limits of its pictures, `architecture.output_modalities` — and only a row that says nothing is told by its name; on a server of the author's own, and wherever the list would otherwise be empty, a model that neither the server nor its name speaks for is offered after the others, marked as such (`unsure`), never hidden. The same for speech and embedding models. And the listing a drawing reads for a model's limits (kept for half an hour) is read again — at most once a minute — for a model it did not have: one put on the server since draws with its real sizes and prompt length at once, not half an hour later.

- **A line's people are that line's: what older digests took for one person across stories is read aright.** Chosen a line, the people page listed people of other lines — in a book of several stories, most of all those called what a story calls somebody: 我, 妈妈, 老板. Until release 68 a name was whoever bore it anywhere in the book, and that was written down: a digest of the second story put its narrator on the first story's card (by id — and an id is made of the name), the cast filled into an empty plan was copied from that, and the pointing of digests at cards after a consolidation went by name over the whole book. Release 68 made new digests tell the stories apart; what was on disk stayed, and "digest those chapters again" was the only way out. Now one place says whose card a digest's note is (`whose`, from `Project.castResolver`), and everything that reads a digest asks it: who is on a line, a life along a line, what somebody came to know, the walk-ons, a plan's cast, the consolidation's re-pointing (which now covers every line, and goes by the story). A digest says on each note who settled the card (`by`: the chapter's own story, or somebody of another the digest was asked about); a note without it holds within the stories its card is of — told by the lines the author filed the card under, the chapter it first appeared in, the plan of a chapter not digested yet — and in another story goes by its name again. So the two narrators are apart as soon as the book is read, without digesting anything again; the one that is not the card's is a walk-on of its own story, to be given a card there. Somebody who really crossed from one story into another in a digest of before is not counted there until that chapter is digested again (the digest is then asked) or the author files the card under both lines.
- **The bible's pages by line no longer show another story's things as "shared".** With a line chosen, everything filed under no line was listed as what the lines share — including what only another story's text names, which is that story's in all but the filing. Shared is now what the line's own story names, or what no text names yet; the rest is a third group, folded: "unfiled, named on other lines only", with one press to file it by the text. (Lines that parted from one another tell one story: what one of them names is not another story's to the others. `lines.seen` says which story each line tells.) The people page says how many of those listed on a line are in no chapter yet — every line's until one writes them.

- **People of the same name in different stories are no longer one person.** Who a name is went by the name alone, book-wide — when a chapter was digested, when lives and line casts were read back, in the list of walk-ons, and when a suggested card was taken up. Two first-person stories in one world shared one "我". Now a name is read by the story its chapter is of (a line that parts from another tells that one's story on; a line of its own from the first page is a story of its own): somebody of that story by the name, else a card no story has yet. A card of another story is another person where the name is only how a narrator calls themself, or where the author filed that card under lines of its own; for a proper name the digest is asked, in the same pass and only when the chapter's text spells it — the same person come over, or a namesake. Whoever is told apart is kept under the name with their story after it ("我（城南的铺子）"), so that the card made for them is a card of their own and nothing that goes by names confuses the two; in a story beside the main one a narrator is kept so from the first. The digest is shown the people on file for its story, not the book's. Taking up a suggested card looks for a namesake in the story the person appears in, and makes a new card where there is none. Walk-ons are listed by story — and from every line: the list read the main line's chapters only, so somebody without a card on another line was never listed nor sifted. (`Project.castResolver`.) Chapters digested before keep whom they were noted under until they are digested again.

- **A prompt no longer speaks of reference pictures that are not sent.** A way to the model that takes none — a server whose model list says so, ComfyUI with no workflow for them, a model OpenRouter lists without `input_references` — got "Reference images: #1 shows …; whoever they show must match their reference" all the same, with no picture behind it, and the record of the picture warned that the prompt spoke of references and none were sent. Every such way now says so to the Studio before anything is drawn (`PromptRoom.references`): nothing is read off the disk for it, the prompt is written without a word of any, and what stayed behind is kept with the picture (`parts.left`) and said in plain words beside it — once it is drawn, not before. Where it cannot be known beforehand (Diffusers, until the pipeline is loaded), the warning stays, in clearer words.

- **A picture of the author's own prompt knows the people it names.** *New picture → Free prompt* lets the author tick who is in it, and said their visual anchors and design sheets went along — only the sheets did. A service that takes reference pictures knew them by those; a server of the author's own, which takes none, had "she" and drew anybody (the same line twice: a white robe, then a black one). Each named person is in the words now, after what was asked: their name and how they look — the anchor, or the card's prose where there is none, with the outfit chosen for the picture. Nobody is added to a prompt sent as written (`raw`).

- **What is picked looks picked.** A handful of rules coloured a chosen thing with `--nv-accent`, a variable the stylesheet never defined — so the chosen lines of the plot on a card, the first of somebody's signature scenes, and the focus ring of the album's line choice showed nothing, and the new tick marks of a batch were transparent over a portrait. They take the brand colour now.

- **A server of the author's own is asked what its model draws, and a picture drawn again is another picture.** Run against the real server for the first time (a FastAPI app in front of Qwen-Image 2.1, plain and Turbo), three things were not as assumed. *Sizes*: it takes any side from 256 to 768 in steps of 32, not three sizes — and says how large a model draws in its model list (`GET /models`: `limits`), so a 16:9 scene is now asked for at 736×416 instead of the 3:2 of the nearest of three. *Seed*: it draws from seed 42 unless sent another, so the same prompt gave the very same picture, pixel for pixel — every request now carries a seed of its own where the list shows a default one, kept in the picture's record (`sent.seed`). *Prompt*: it refuses one longer than its `max_prompt_chars` (2000) — the prompt is cut to that. The settings show beside a model what the server says of it, and what each kind of picture comes to; the author's own list of sizes still has the last word, and a server that lists nothing is asked as before.

- **OpenRouter's image models are asked for what each of them takes.** Every picture went out with a shape, a fineness (`resolution`) and `output_format: png`, "which every model there understands" — and they do not: 36 of the 59 models behind `/images`, GPT Image among them, have no fineness to choose, the others have different tiers (Gemini has neither `768` nor `1.5K`, which is what a design sheet was asked at), and a model refuses a value it does not have (*resolution: not supported. Accepted: 512, 1K, 2K, 4K*). With the sheet drawn first, every picture of a person failed on such a model. The Studio now reads OpenRouter's own listing of what each image model takes (`GET /images/models`) and sends those parameters only, each at the nearest value the model has; a quality the model does not know and reference pictures beyond what it holds stay behind. What the providers an account may use refuse on top of that is read from the refusal (*Accepted: …*) and asked for next, and remembered. An account whose privacy settings leave a model no provider is told so, with where the setting is. The model list offered in the settings is the images endpoint's own.

### Changed

- **Jobs that had no name on the task bar have one**: digesting a chapter, sifting the new names, checking a review again, setting the art direction, reading somebody's growth, finding their scenes, writing what a place looks like, importing a line of the plot.

- **A storyboard's director is told what the chapter is about, and a panel is drawn with the bible's own looks.** The director cutting a storyboard had the lines, a look for each speaker, the places the text named and the art direction — and wrote, in sixty to a hundred and twenty characters a panel, the whole of what the image model got: whoever was in it described from memory and in brief, what they wore that day left out, and a thing of this world ("the old pen") drawn as the commonest thing of that name. It is now given the chapter (its title, where and when it is set, what happens in it), who each person is and what else they have to wear, and whatever of the bible the chapter has to do with — things, houses, rules, words of this world, found in the chapter's plan and digest as well as in its lines — with what each is and what there is of it to see. It writes what happens in the frame (who is where, doing what, in what light), names what the panel shows (`wearing`, `things`, kept on the panel as `looks` and `things`), and no longer restates looks. When the panel is drawn the Studio puts after the director's words, from the bible as it stands now and in full: how everyone in it looks in what they wear there (and the sheet that goes along is that look's), how its place looks, how the things it shows look (`panelMakings`; the record of the picture has each as a part of its own). Run for real: a chapter recut in one request, the pen it turns on named on the panels that show it, and a panel drawn as the scene has it.
- **A design sheet goes along as its front view.** A sheet shows its person three times over, and a portrait or a scene held against it came back with three people (reproduced on the model the Studio is tried on; telling it in words what a sheet is — three wordings, run for real — changed nothing: a model draws the picture it is handed). What goes along with any picture that is not itself a sheet is now the sheet's first figure, cut out of it: found by looking for the ground between the figures (so four figures, or uneven ones, part as well as three), in a PNG read and written by the Studio's own code — a JPEG or WebP sheet is turned into one where ffmpeg is at hand — and the whole sheet where nothing can be told apart. The record names the sheet and says that its front view went (`references[].sheet`, `.front`). Tried on twenty-six sheets drawn by nine models, and on the portrait that had come back as three: one person.

- **A picture changed in one thing is sent as the picture and the change — nothing else.** *Change this picture* sent the picture with everything its record held in words besides: the description it was first drawn from, a sentence saying to draw the reference again changing only this, a note on what the reference was for, the art direction, what to keep out. All of it said a second time what the picture itself says, at a length that — on a model reading a few hundred tokens — sent the prompt to the director to be fitted before anything was drawn. Now the author's words are the whole prompt (on a way to the model with no field for a size, the shape of the frame is still its one sentence; the Codex CLI is told the attached picture is the one to change: `ImageRequest.change`). The record says so — `parts.subject` is the change (a piece `of: 'change'`), `references` the picture it came from — and keeps beside it, unsent, what the picture shows in words (`parts.base`: the earlier subject with the change after it, the art direction, what is kept out, what the earlier picture was held against), which is what it is drawn from when its words are rewritten later (`pictureWords`). The new picture is asked for in the frame the old one *has* (read off its file: `pixelsOf`), not the Studio's default where the old record named no size. Where the image service takes no picture — known before, refused when sent, or shown only by the drawing — the picture's words stand in for it, the change after them, as any picture is drawn, and the record says the picture stayed behind. Run for real: one sentence and the picture, and only that one thing changed.
- **The people page lists everyone.** In a book of more than two dozen people it opened on those who carry the story, the rest a click away. It opens on all of them now, in the order of their weight as before; narrowing is the author's to ask for. (Where people are picked *for* something — a batch of pictures, a chapter's cast — a large cast still starts with the leads.)

- **Work that has everything in its task is asked in one request.** Every piece of work handed to a role ran as an agent where the role was set to: with the tools to read the book, and steps to take. For work that goes by nothing but what its task holds, that loop added tokens to every request and room to wander — an audio script was slow to come and came back with talk in it. Ten kinds of work now say so (`Assignment.plain`) and are one plain call whatever the role is set to: a chapter's audio script, a chapter's digest, a storyboard from a script, a prompt fitted to a model, an author's notes sorted, a life told in a paragraph, a style learned from samples, open issues looked at again after a revision, the foundation of a new book, volumes and premise from the chapters' summaries. Whatever reads the book — a review, the cast, ties, scenes, growth, deriving chapters — works as an agent as before.

- **What an image service did not take is said with the picture, not before it.** The question before a picture ("this will first draw N design sheets") warned that "the image service in use takes no reference pictures" — of a picture not yet drawn, from what was last known of a service that had changed since. Nothing of the kind is said before any more (`image.sheetsFirst` no longer answers `unheld`; nor does the showrunner's `sheet_first=ask`). Once the picture is there it is said with it: on the job (`result.left`), in the notice that the picture is ready, in the showrunner's result, in the count of panels that went without (`unheld` on a chapter's panels), and — as before — in the picture's record, which now tells "takes none", "takes one, these stayed behind" and "was sent them and would not have them: …" apart.

- **The bible, line by line.** Every page of the bible listed all of it whichever line was in hand, and whatever a digest found on a line beside the main one became the whole book's — handed to the main line's writer too. Now: **the digest says whose each new thing is** — in a book of several lines it is told which story the chapter is of and answers, in the same pass, whether a thing is that story's alone or the world's (`newEntities[].scope`); its suggestion says so, and a thing of the story alone is filed, when taken up, under the lines that read the chapter (where a digest did not say: a thing found beside the main line is that line's, one found on the main line the world's). A book of one line is asked nothing of the kind. **The bible's pages list the line in hand** (places, houses, things, the world): the line's own entries above, what the lines share in a group of its own below, with a choice at their head — each line and how many it has, *filed under none*, *every line*; along a line beside the main one, how often an entry is named and how much it weighs are read along that line (`world.presence`). An entry nobody filed stays every line's — it is not guessed from where the text happens to spell its name out, since an entry a whole book stands on may be named on one line only — but where the text names it is said beside it (`lines.seen` → `world`).

- **A batch filed under lines of the plot at once.** *Select* over the bible's lists and the list of people turns a click on a row into a tick; *File under lines…* then says which lines the ticked ones belong to — those and no other — or takes the filing back. *File by where the text has them* does it by the book: each under the lines it is found on, an entry where the text names it and a person where the chapters have them; what every line has, or none yet, is left as it was and counted. (`lines.assign`, with `byText`; to the showrunner `novel_bible action=file`.)

- **More image models recommended on OpenRouter (issue 2 of the recommendations).** Beside GPT Image 2.5, which stays the default, the model field now offers the models that were drawn with for real through the Studio on 2026-10-09 — a design sheet and a portrait against it on each: Gemini 3 Pro Image, Gemini 3.1 Flash Image, Grok Imagine Image 2.0 and Grok Imagine Image Quality — ahead of GPT Image 2.5 Flare, Seedream 5.0 Pro, GPT Image 2 and Qwen-Image 3 Pro. No setting moves: the recommended model itself is what it was.

- **Mendings no longer lock each other out: in line, or apart.** While one mending ran, the buttons that start another said "mending…" and waited. Now any number can be asked for, and a small triangle beside the buttons says how a new one is taken (`order` on `ai.fixIssue`, `ai.fixIssues`, `ai.reviseBook`; on the showrunner's `novel_revise`): **in line** (the default — the surer way) waits for the mendings asked for before it and then goes on from what they left waiting; **apart** starts at once on the text as it stands, for mendings that have nothing to do with each other — another line of the plot, a far part of the story. Going on from what waits (`onto`): the writer reads a chapter as it would stand with its waiting changes accepted. A passage the book still has as it was gets a proposal of its own, as before; a passage a waiting change made, or a chapter rewritten whole, gets **one** proposal for the chapter with all of it in, which stands for the ones it took in (`supersedes`, `batches`; they are settled by it, `supersededBy`) and carries their issues — accepted, they are all in; turned down, they come back to wait by themselves. A change applied outright never goes on from what waits: it accepts nothing on the author's behalf. While mendings run, the bar says how many and what a new one will do.
- **A graph built for a ComfyUI model is sampled as that server samples it.** The built-in graph used guidance 7 whatever the model — right for a Stable Diffusion checkpoint, and harsh on a newer diffusion model (a picture drawn at 7 where the model's own workflows use 3 came out hard-edged and flat). Where the settings leave steps or guidance empty, the Studio now reads the server's history for its latest run that loaded this model and made a picture — the author's own runs before the Studio's — and takes its steps, guidance, sampler and scheduler; with no such run, 7 for a checkpoint and 3.5 for a diffusion model that comes alone. What a picture was sampled with, and where the figures came from, is kept with it (`sent.sampling`) and shown in its record. Workflows are run as they are, as before.
- **The Outline's chapters are listed one line of the plot at a time, and deriving is part of that page.** Every line's chapters stood one under the other in a single column, and what comes next was asked of the planner on a tab of its own, which did not know which line was in hand. The chapters page now has the line chosen at its head — the main one with its volumes, or another as it is read: what it shares with the line it parts from, greyed, then its own — and *Derive* on the same bar opens the planner's panel beside the list, for the line shown. A chapter opened from elsewhere takes the page to its line. The Derive tab is gone.
- **One line of the plot in hand, on every page.** Each page kept its own choice of line — the outline, the people, the writing, the reading, the album — and the production board had none: somebody at work on a line beside the main one chose it again on every page they came to. The Studio now has one line in hand (`snapshot.line`, kept per book on the device): what the outline lists, what is derived, the chapters of the write and read pages, the album, whose people are listed, the production board and a book-wide revision are all that line's. Changed on any page, it is changed on all; a chapter opened from elsewhere that the line does not read takes the Studio to its own line, and a line taken in hand puts the Studio on a chapter of it. *Produce in one go* got its selector, and lists a line's own chapters (what it shares with the line it parts from is produced on that line).
- **A release no longer takes an open Studio off the screen.** The host swaps the Studio's code in place and renders the open page with the new code on the old page's state; where a page's hooks differ between the two versions that render throws, and the host removed the whole Studio. The Studio now catches a render error at its root and puts its pages up afresh — same book, same page — and hands the error on only when it comes straight back.
- **A run of chapters is written in order, or side by side.** A batch always wrote one chapter after the other, each waiting for the one before and its digest — the way to chapters that agree, and slow. The start button of *Batch: writing and upkeep* now has a small triangle beside it: *In order* (as before, and the default) or *Side by side* — as many chapters at once as the settings allow, their digests side by side too, the arcs brought up once at the end. Written side by side, a chapter is given its own outline, the text there was before the batch, and — new in the writer's context — the outlines of the chapters before it that are not written yet, with the word that their text is not there and their part is not to be told again. The choice is kept. `novel_batch what=text order=together` for the showrunner, which keeps to the order unless the author asks for speed.
- **ComfyUI: a workflow saved on the server is chosen from a list and used as it is.** The settings wanted a file on this computer, exported in API format, with placeholders written into it by hand — while the workflow sits on the machine ComfyUI runs on, saved by its editor in a format its own server does not run. *Settings → Images → Workflows saved on the server* now lists them; choosing one fetches it, turns it into the graph the server runs (what each node takes is asked of the server; notes, a seed's "after generate", the upload button and what leads to no output are left out), and writes the placeholders: words, size, seed, and each `LoadImage` as a reference picture's place. One that loads pictures becomes the workflow for pictures with references, any other the plain one; each is kept in the settings with where it came from. With that, pictures drawn on ComfyUI hold to a design sheet: drawn for real with a one-reference workflow, the same person in another scene.
- **ComfyUI: what the server has is asked of the server.** *Settings → Images → Connect* lists the server's checkpoints, diffusion models, text encoders and VAEs, with its version and device, and the model is chosen from the list instead of typed. A server that holds its models as parts — a diffusion model beside a text encoder and a VAE, and no checkpoint — used to answer "no checkpoint to draw with"; the built-in graph now loads such a model with `UNETLoader`, `CLIPLoader` and `VAELoader` (`image.textEncoder`, `image.vae`, `image.encoderType`, each chosen from the server's own lists), and where a choice is left open the error names it. *Use it as the workflow* takes the server's last run that made a picture as the template, kept in the settings: the words, the size and the seed become the Studio's to fill, the models and the sampling stay as the server ran them. Drawn for real for the first time, on a ComfyUI 0.39 server, both ways.

- **A digest proposes nobody for a card; the planner says who is worth one.** Every name a chapter's digest met and the bible did not know became a "new character" suggestion — the doorman as much as the rival — and a long book buried its cast under a hundred of them. A digest no longer does that. Every name without a card is on the list of walk-ons, as it always was; once digests have settled, the planner looks through the names it has not looked at yet, side by side and with the book to read (`siftCast`, the job *sift cast*), and says of each: **worth a card** — a suggestion marked as the planner's, with its reason, a part and a line of who they are —, **another name** of somebody — a suggestion of a new kind (`alias`) that folds the name into that card when accepted, or, where it is another name of somebody found worth a card in the same pass, an alias on that suggestion —, or a **walk-on**, left on the list with what the planner said of them. The judgement is the planner's: no threshold of appearances. A name looked at is not asked about again until it is seen in more chapters. Nothing is made or folded by the pass. The suggestions an older version made chapter by chapter are looked through with the rest: kept with a reason, turned into another name, or taken back. People → Walk-ons shows what the planner said beside each name and has *Have the planner look (N)*; Review → Suggestions lists the planner's first, says how many names were left as walk-ons, and offers the pass while anything is unlooked-at. *Settings → After digests, have the planner look through the new names* (`siftCast`) switches the automatic pass off. For the showrunner: `novel_manage action=sift_walkons`.

- **The interface says what a thing is, and stops.** Hints, tooltips, confirmations and notices all over the Studio and the reader explained how things work behind them, repeated what the button beside them already said, or added an aside in brackets. They were gone through one by one — some four hundred of them — and cut to what the author needs at that spot: a hint is one short sentence or none, a tooltip a phrase, a confirmation what will happen and whether it can be undone. The English text was cut with the Chinese, and calls the host DSH throughout.

- **A look is written with the art direction in hand, and the period it fixes holds over the source text.** An art direction may say more than how to paint: "dress and buildings of the Ming". Appended after the subject of a picture it could only colour what the subject had already said — and the director, who writes a character's visual anchor from the card and the text, never saw it: an anchor followed the novel's words to "one thick queue", and no art direction could take the queue out again. The director is now handed the art direction wherever it writes down a look that lasts — a visual anchor, ideas sorted into one, the look of a place or a thing, a place at a turn of its course — and told what of it binds: the forms of a period (how hair is dressed, the cut of clothes, how a house is built) are written as the art direction fixes them, not carried over from the text and not blended with it; what is the person's or the place's own is kept; the forms most likely to creep in go onto the never-drawn list. Scenes, covers and storyboards are told the same of what they describe. An anchor written again keeps what nothing speaks against (*Have the director rewrite* on the card). Anchors already written do not change by themselves: *Bible → Art* says so and lists whose looks are written down, each a step from where it is rewritten.

- **A card no longer says "active" or "dead".** A character's card carried one word for where they stood in the book, beside the life read off the digests; the two were told apart, and the word was still there — on the card's head, in its form, on a board of five columns. It is gone. A book is not one straight road: it has lines of the plot that part and chapters written again after the ones that follow them, and a word on a card is true of one line at one moment. Where somebody is, is their **life on the page**, along the line looked at: under their name in a line ("comes on in chapter 9 · dies in chapter 12"), chapter by chapter below it, and in a paragraph that is theirs. The lifecycle board and the presence grid are one table now — *People → Lives*: a row a person, a column a chapter of the line; on the page, coming on or back, leaving, dying, planned by the outline, planned but missing, point of view. In the lists a death or a leaving stands with its chapter, and nothing stands for everybody else. A `status:` line in the front matter of an older card is not read, and is left out when the card is next saved; digests no longer ask "mark as dead?" — the digest says it by itself.
- **The writer is told who is gone as of the chapter in hand, on that chapter's own line.** The list of the dead came from the labels: whoever was marked dead was dead to the writer of every chapter, the fifth written again as much as the fortieth, and on every line. It is read off the digests of the chapters *before* the one in hand now, along its line — with those who left for good beside the dead, each with their chapter. Everyone's card travels the same whatever the chapter, with no word on it that changes as the story moves: the head of a request stays what a provider has cached. An interlude offers who is alive where it is set, not who is alive at the end.
- **The sheet comes first.** A portrait asked for somebody without a design sheet draws the sheet first, and the portrait against it; a scene, a panel and a cover do the same for whoever of their people comes back in the book (a part that carries it, or in two chapters or more). It is never done behind the author's back: the job says "first the design sheet of …" while it runs, the picture names the sheets drawn for it when it is done (to the showrunner as well), a batch of portraits shows the sheets as steps of their own, and two pictures that need one sheet at once wait for one drawing of it. `image.sheetFirst = false` turns it off.
- **The notes on the ensemble can be put away.** Above the People page they were a block on every tab but one, and a line that could not be dismissed on that one. They are one line by default now, on every tab; they unfold, fold, and *Hide* takes them out of the way — a small mark at the end of the tabs, with their number, brings them back. What they say no longer speaks of labels: who with a part has been away, whom the outline casts after their death, how many are on the page at once, which lead lacks a motive or an arc.
- **Before sheets are drawn first, the author is asked.** Wherever a picture is started — a portrait, a passage, a chapter's panels, the cover, the gallery, a batch, one-click production — the Studio works out whose design sheets it would draw first (`image.sheetsFirst`, nothing is drawn) and, where there are any, says "this will first draw N design sheets: …" with three answers: draw them first, not this time, cancel. Where nobody lacks a sheet nothing is asked. The showrunner asks the same way (`sheet_first=ask | draw | skip` on `novel_illustrate` and `novel_comic`).
- **A mark of the author's own in a life.** A digest misses things, gets things wrong, and cannot see what lies before the first page. *Write a mark* on a person's page puts down that they come on, come back, leave or die at a chapter — or were dead or gone before the story begins. It is an event with its chapter, not a state: it holds over the digest of that chapter and on every line that reads it; after a death or a leaving written down this way, later chapters only remember the person until a return is written. Marks show as the author's on the strip, in the table of lives and in the notes; they are kept on the card (`lifeMarks`), and the showrunner writes them with `novel_bible action=mark_life`. The writer is told of "dead before the story begins" like of any other death.
- **Ideas jotted down beside the buttons that draw somebody.** A box under *Draw portrait* and *Design sheet* takes whatever comes to mind, mixed as it comes. The director sorts it when the picture is drawn: what is of the person goes into their look for good — the visual anchor, and a sentence of the appearance where the card lacks it —, what is of this one picture ("a snowy night, looking back") directs this picture and is kept nowhere, and what the picture has no place for is left out. How each idea was sorted is listed when the picture is done; where no model answers nothing is guessed. To the showrunner it is `notes` on `novel_illustrate`.

### Fixed

- **A line of the plot is worked on from that line alone.** A book may hold several stories in one world, each from its own first page; whoever worked on one was still handed the others. The tools every role reads the book with knew the main line only: a planner deriving chapters for another line that looked at the outline saw the main line's, "chapter 3" read the main line's third chapter, the cast and the threads were the whole book's, and a search found passages of any line — so chapters derived for a side story leaned on another story, numbered by it. Now a piece of work says which line it is on, and its tools are kept to it (`core/reading.ts`, `bookTools(…, line)`): the outline, the chapter numbers, memories, reviews, the cast with each life read along the line, the threads as they stand at its end, and what a search finds. The context a chapter is written, derived or reviewed with keeps to the line the same way (`Project.lineScope`): **people** are a line's where the author said so, else where they are — in its chapters by their digests or cast by their plans; a card no chapter has yet is every line's — so nobody has to be marked by hand; **threads** are the lines' that planted or advanced them, and one paid off on the main line still waits on a line that parted before; the book's **premise** — the main line's story — gives way to the line's own name and what the author said of it where the line is apart from the first page; and the planner's overview no longer lists "the other ways the story goes". Somebody named by a chapter's plan or by the task itself is still given, whichever line they are of. The showrunner is kept to no line: `novel_read` and `novel_search` take `line`, the whole outline lists every line with its own numbering, and `novel_crew` takes the line a task is on.
- **Deriving from the Outline went to the main line whatever line was in hand.** The Derive tab started on the main line; with a chapter of another line selected it now starts on that line.
- **Review issues of other lines were dropped when mended in a batch, and their chapters were not on the review page.** Batch mending and book-wide revision looked at the main line only: an issue found in a chapter of another line was silently left out, and "mend the grave ones" never saw it. A batch is now mended line by line — one planner a line, reading that line — and a book-wide revision can be asked of a line. The review page lists every line's chapters under the line's name, each with the number it has there.
- **Choosing a line on the People page changes who is listed.** The choice only changed along which line lives were read. It now lists that line's people (with how many each line has), says how many more belong to other lines only, and offers "every line".
- **A character's growth and signature scenes are read along the line that character is of**, not along the main line whoever they are.

- **A design sheet drawn again came back as the sheet before.** A character's main sheet was drawn with their current sheet — lacking one, their portrait — as a reference image, under a line that told the image model the hair and the clothing must match it. So nothing the author changed could reach it: an anchor rewritten, an art direction given a period ("dress and buildings of the Ming"), and the model handed back the old sheet with a new background. The main sheet is drawn from the words alone now — the visual anchor, the art direction, what is asked of this one — every time, also where somebody has a portrait and no sheet; it is what every other picture of them is held against, and a picture cannot be held against itself. A look (outfit) is still drawn against the main sheet, and its prompt now says what that reference is for — the face, hair colour and build from the picture, the outfit from the words — instead of also saying that the clothing must match. (The Codex CLI was told the same "keep hair and clothing faithful" around every prompt with references; it is told to keep what the description says to keep.) A portrait drawn before the sheet in use says so on the card, until it is drawn again.
- **Opening the motion comic of a chapter took the whole Studio off the screen.** The page that asks before sheets are drawn was given its hook below the place where the page returns early while a chapter's script and storyboard load; once they had arrived the page rendered with one hook more than before, React threw, and the host removed the Studio — a blank page where a book was. The hook is asked for before the returns. Nothing of this shows in a type check or a build, so the sources are read for it now: `tests/hooks.test.ts` goes through every screen of the Studio and the reader for a hook reached after an early return.
- **A book kept inside another book's folder: the Studio beside an agent opened the outer one.** Which book a conversation is on was looked for in its folder before anything else but the author's own choice. A role's run is a new conversation, handed the folder of the conversation it works for — and a folder can be a book of its own with others inside it (the first book made in an empty workspace is the folder; the next go inside). So the Studio brought beside a scribe recording a chapter of the inner book showed the outer book's overview, and a subagent the showrunner sent out was told the outer book was in play. A conversation that works for another one is now on the book that work is about — the one its task names, else the book of the conversation it works for — and only then on the book of its folder. The Studio beside it stays on the book, and the page, the author was on.
- **Stepping from the Studio into an agent at work took the Studio away.** A role's run is a conversation of its own, with a column on the right that has nothing in it. Pressing a progress bar (*Watch the planner*), a run in the list of jobs or a cell of a batch's table now takes the Studio along: it is put beside the run, on the book and the page the author was on — from the Studio's own page as well as from a Studio beside a conversation, every time it is asked, also where the author had closed it there before. Two things had been wrong. The Studio's own page was never followed at all (only a Studio beside a conversation was). And DSH drops a page that is opened in a conversation's column in the moment the conversation is first shown — so beside an agent that had only just started, the very case of watching one at work, nothing appeared; the page is now opened once the column is set up, and again for as long as no Studio stands there (`src/client/beside.ts`).
- **A chapter could start playing by itself two chapters after one ran out.** A chapter that ran out goes on to the next, which starts once its script has arrived. Where the next had no script, the wish was kept — and the first chapter with a script that the reader opened afterwards started by itself. The wish is for the chapter gone on to and no other.
- **A picture deleted from the gallery left whoever held it pointing at a file that was gone.** A portrait, a design sheet, a look's sheet, the design art of a place or a thing: the card or the entry went on naming the deleted file and showed a broken picture. Deleting a picture now takes it off whoever held it up as theirs and says whose it was (in the gallery, and to the showrunner); where chapter text shows it, the text is not touched, as before.
- **On a low, wide screen the motion comic was squeezed to a strip.** Its picture stood in a column that scrolls and gave up its height to it; and where it kept its height it was cut to the window's shape instead of keeping its own. It keeps both now.
- **A button that waited for a job could go on saying it was busy.** The list of running jobs is brought up to date by the Studio's watch, which rests while the Studio is out of sight; whoever waited for a job to end now brings the list up to date themselves when it does.
- **When a site was last published was shown by the clock of Greenwich**, not the computer's.
- **Chapters of a line beside the main one were never digested on request.** *Digest* went through the main line's chapters only: a chapter of another line that was named was passed over without a word, and none of them counted as pending. Every line's chapters are digested now — which is what lives, the world along a line and the comparison of lines are read from.
- **A published site lost every picture and sound whose file had a name outside ASCII.** Media were written under percent-escaped names, and a host decodes an address before it looks for the file — so a portrait named after its character in Chinese was never found. Files are written under their own names now; publishing into the same folder again puts them right and removes the wrongly named ones.
- **The cover on a book's overview spread over the page.** Once the cover became the way into reading it sat inside a button, where the rule that sizes it no longer reached it: it was shown at the size it was painted, over the title and the premise.
- **A chapter's video had no subtitles to see.** Post-production put them into the file as a subtitle track where this computer's ffmpeg could not draw text (Homebrew's cannot), and the Studio's player — a web player — shows nothing of a track inside an MP4. The Studio now keeps the track's words beside the file and its player shows them; a video cut before this gets them the first time it is opened. The line under the player says whether the words are in the picture or carried as a track.
- **A chapter's page in the outline listed everyone in the book.** The plan editor laid out every character and every thread of the book to be ticked — 345 names and 146 threads in an imported *Dream of the Red Chamber* — which read as a chapter with everybody in it. It now shows who is in the chapter and which threads it touches; what the digest found beyond the plan is offered to add; anyone else comes through a picker that narrows by the weight of the part and by name.
- **A subtitle that was nothing but a closing quote.** Lines are cut into pieces a screen holds; a closing quote, a mark of an ellipsis, now stay with what they close, an opening quote goes on with what it opens, and joined paragraphs leave no gap in a script that has no spaces.
- **A chapter could be removed, by whoever found out how.** The way to do it showed only under the pointer. It is always there now, on every row of both chapter lists; several chapters can be ticked and removed together.
- **Stepping into an agent's conversation took the Studio away.** DSH keeps a column of pages per conversation, and a role's run is a conversation of its own with nothing in its column. Where the conversation the author comes from had the Studio beside it and the one they step into is about the same book, the Studio opens there too, on the same page.
- **A cut that ran out of tool calls had nothing to hand in.** The note of how much of its budget a role has used rode on the role's own tools only, and post-production works in a shell: it never read one. The note now comes beside whatever tool was used last (DSH's `tools/post-execute`), at half, three quarters and nine tenths, and a task may add what it still owes — for a cut, "nothing has passed the checks yet". What an unfinished cut left in its working directory is named to the next one. Post-production's default budget is 200 calls, up from 80.
- **A chapter added after one was removed could get its number** — and with it the digest, versions and voices of the removed one.
- Where ffmpeg is missing, the hint how to install it named macOS only.

- **The Studio no longer falls out from under an author whose DSH runs off a checkout.** A build used to empty `lib/` and write it again; a DSH that was running swapped the Studio in its window for whatever it found there — and dropped back to the conversation — while its Host half ran on as it had been loaded. Builds now go to a directory of their own and are put into `lib/` file by file, each one whole, only the files that changed, the entry DSH watches last (`npm run release`); day-to-day builds do not touch `lib/` at all (`npm run check` builds a staged copy the dev launcher runs).
- **A Studio that is newer than its Host says so.** When the plugin is updated on disk while DSH runs, DSH puts the new Studio in the window at once and keeps the Host half it started with. The Studio now knows — the Host names the build it runs and the one installed — and says "restart DSH" at its top instead of failing with `unknown method`; a call an older Host does not know says the same.
- **Swapped or reloaded, the Studio is where it was**: the same book, view, chapter and tab, and its own page is open again if it was.
- **The leads of an imported book were missing from its cast.** Two causes. What the chapter digests found was kept in a list of two hundred, and the oldest were dropped first — in an imported book, the people met in the first chapters. And an import that was cut short never came to make the cast at all. Nothing found is dropped now; see *The cast of an imported book* below.
- A conversation started in a folder that is itself a locked book showed "could not reach the Novel Studio service" beside it; it shows the lock. The showrunner is told which other books are in reach, and a conversation can be moved from a locked book onto another.
- Conversations of a sealed book that were left in the open when DSH quit are taken under its seal when DSH starts — the pass ran before DSH's session store was up and found nothing. After unlocking or locking in the Studio, DSH's list of conversations is read again, so what came back shows at once.
- Reading a side line of the plot, the chapter where it left the main line did not offer the main line as a way on.

### Added

- **A published site carries its pictures as JPEG.** Pictures lie in the book as the PNGs the image model made, megabytes each; published, they go out as `.jpg` at the encoder's finest setting with colour at full resolution — looking the same (40 dB and more of the original, measured), a fifth to a tenth the size: 273.7 MB of pictures became 47.2 MB. The data and the prose name the smaller file; the book keeps its own. A picture that is see-through somewhere stays PNG. Ticked by default in the publish dialog (*Compress pictures to JPG*), `jpeg=false` for the showrunner; needs ffmpeg, and says so where there is none. Only pictures that changed are compressed again.
- **People can be moved on the relation graph.** On the whole picture a person is taken hold of and put elsewhere; the lines follow, everybody else stays where the layout has them, and the place is kept with the book (`.novel/graph.json`). A small mark on whoever was moved lets them go again; *Lay out again* lets everybody go. A click is still what arranges the picture around somebody.
- **The people and the world along a line of the plot.** Where a book goes more than one way, the album is of one of them: the bar that tells the story's time also says whose world this is and changes it. Along another line the time is that line's chapters, a life is what its digests note (the man who dies on the main line leaves on the other), a place's course tells the turns that happen on it, and a tie that begins on one way does not hold on the other. In the Studio's viewer, on other devices (the line being read) and on a published site, which carries the album of every way it offers (`data/<book>/album/<line>.json`).
- **A place or a thing is shown as it is at the chapter looked at.** A turn of its course — built, changed, fallen to ruin, destroyed — can have a picture of its own (*Draw it then* on the turn's row; `novel_illustrate … event=<chapter>[:<kind>]`). The director first writes what is there to be seen once it has happened, from how the place usually looks and from what that chapter says of it, and that is drawn, without people: a change or a decline against the entry's design art, as the same sight altered; a beginning or an end from the words alone. With the viewer's slider at or past the turn's chapter, that picture is the entry's — until a later turn has one, or it is built anew; a picture of its beginning holds until the next thing happens to it. A published site carries the pictures of the turns it tells of.
- **Places, houses and things have a course.** What happens to an entry at which chapter — it begins, changes, declines, ends (`events`) — written down by the planner with the ties, and by hand on the entry's page. The viewer tells it on the entry's page and goes by it at the chapter looked at: what is not built yet is not there, what has ended stands back.
- **Reading goes on where it stopped, on whichever device.** The chapter a book was last read at is kept with the book; the Studio's viewer and the reader on other devices both leave their place there and pick the latest up: a phone offers *Continue: chapter N — read in the Studio on the computer*, the Studio's shelf opens the book where the phone left it.
- **Design art is drawn from what the book says a place or a thing looks like.** Where an entry has no visual description, the director writes one first — from the entry and the sentences of the text that name it — and keeps it on the entry; then the picture is drawn, and drawn the same again. It can be asked for by itself (*Have the director write it*; `novel_bible action=derive_visual kind=world`).
- **Faces in the relation graph.** Whoever has a portrait is shown by it; the marks of those who carry the story are larger for it.
- **The reader on a tablet, and on a phone held sideways.** Upright on a tablet the contents page has its cover and title large and a chapter is set in a column of a printed page's width; on its side the contents page is the book to the left and its chapters to the right. A phone on its side gives a motion comic or a video the height there is.
- **Each step of a batch leads to the agent working on it.** A batch runs many agents at once, and the progress bar opened whichever started last. A cell of the batch's table that an agent works on (or worked on) now opens that agent's own run.
- **What each person knows along a line of the plot.** The world along a line now tells what everybody has come to know on the way — read off what the digests note as learned, chapter by chapter — and two lines held against each other say what a person learned after the parting on each: the same man who dies on one line knowing he was fooled leaves on the other knowing which side of the mirror to look into.
- **An imported book comes with its world tied together.** Reading a book in has a pass more, after the cast and the world: the planner works out what place is in what, where each house has its seat, who belongs where and lives where, who holds what — and what happens to the places, houses and things over the story — so the viewer's *World* can be walked, and its slider means something, without anyone asking for it. An analysis begun before the pass existed is whole without it; `steps=ties` runs it by name. A book with no places, houses or things has nothing to tie, and that is no pass left undone.
- **The showrunner can read and change how the world stands.** The ties between people, places, houses and things, the marks on a place's picture and the planner's two passes over the bible were the Studio's pages' alone. `novel_bible` now has them: `ties` (look), `tie` / `untie`, `derive_ties`, `tidy` (the planner's proposal of duplicates and wrong categories), `pin`; an entry's `weight` and its course (`events`, chapters by id or number) are saved with it. What is only looked at stays off the book's record; what is changed is on it in words ("wrote down a tie: … lives at …").
- **A reader can take the other lines of the plot.** On another device and on a published site a book was its main line and nothing else. Where it goes more than one way, the contents page now offers the lines to choose between — every line not put aside that has a written chapter of its own — the chapters listed are what is read along the line chosen, and at the end of the chapter where the story parts the other ways on are offered, each in the words of its choice. A published site carries them with the whole book (*With the other lines of the plot*; `lines=false`), a part of the book stays a part of the main line.
- **The album is leafed through.** Every person's and every entry's page leads to the page before and the page after it, in the order the first pages show them, by button and by the arrow keys; pages arrive softly. Readers on another device or a site are offered *where I am* on the slider: the album as it stood at the chapter they last read.
- **The way to the viewer from where a book is worked on.** *View* is on a chapter's plan in the outline, on every chapter of the review (opening it with the review's notes in the text) and at the top right of *Stage* — the same button the people's and the bible's pages have.
- **A chapter's finished video is watched in the viewer.** *Watch* played the motion comic only; the file post-production cut could be seen under *Stage* and nowhere else. It is in the viewer now — in the Studio, on another device, on a published site — played by the browser's own player with the cut's subtitles as a track; where a chapter has a video and a motion comic, a switch beside its title changes between them. A published site carries the videos (`assets/video/<chapter>.mp4` and `.vtt`; *With the finished videos* in the dialog, with what they weigh, and `video=false` of `novel_share action=publish`). The small server for other devices hands out a video in pieces, as a player asks for it — and nothing from the bench it was cut on.
- **What the crew may do is chosen beside its model.** Since the settings page was shortened, whether the roles work as agents and with which tools could only be set role by role under *Advanced*. *Models* now has it as one choice next to the crew's model — *agent, with its own tools* (the default), *agent, with all tools*, *not an agent* — for all four at once, in a book's own settings too; where the four differ it says so. Under *Advanced* each role has the same single choice, in place of two.
- **The first page of the world is laid out by weight.** It started from the places that are in nothing — so the garden half the book happens in was two steps down from a tile for its house, and a book with one country at the top of its map opened on one tile. Places, houses and things are now shown by how much of the story each carries, wherever it lies: the heart of the story first and large, what the story keeps coming back to after it, the long tail behind a fold (what has a picture stays in sight). A tile says where the thing lies; the outermost places are named above, as the way in from the outside. The slider for the chapter of the story works on it as before.
- **A published site carries its sound compressed.** Voices, ambience and effects lie in the book as uncompressed WAV; published, they go out as AAC in `.m4a` — played by every browser, at a rate chosen so that it sounds the same (four bits a sample: 96 kbit/s for a voice at 24 kHz), about a quarter the size. The book's own files are not touched, the reader is told the smaller file's name, and publishing again compresses only sound that changed. It is ticked by default in *Publish as a site* and can be left off there or with `press=false` of `novel_share action=publish`. The work is ffmpeg's: without it the dialog says so where the choice is, sound goes out as WAV, and the result says that it did; a sound that cannot be compressed goes out as it is and is named. (`core/media/press.ts`)
- **Side stories in the viewer.** An interlude kept as a side story is read, by whoever reads the book, as a transcript of how it went: a fourth half of the viewer (*Side stories*) in the Studio, on other devices and on a published site (`data/<book>/sides.json`, an option of the dialog). Playing an interlude stays what it was — the author's, with the models on their computer; the page where one is played and the page where one is read show the same transcript (`client/reader/sides.tsx`).
- **Publishing a part at a time, the way the author reads, and from the conversation.** *Publish as a site* can stop at a chapter (the album is cut there with it), writes the publisher's reading settings into the site as what a visitor starts with, and is at the showrunner's hand as `novel_share action=publish` (a sealed book only from the dialog, where the author confirms).
- **The world along a line, and two lines held against each other.** With a line chosen on the plot graph, the Studio shows who has come on along it and how they stand where its digests end, and which threads it leaves open; another line can be held against it: where the two part, and for whom it ended differently, who only one of them comes to, which threads one paid off and the other did not (`line.world`, `shared/worldline.ts`).
- **Tidying the bible.** *Tidy* under *Bible* has the planner look the entries over for one thing written down as several (a mansion under its formal name, the side of the city it stands on, a short form) and for entries filed under the wrong kind, each with a line of grounds; the author ticks what to go by and chooses the name that stays. Merging entries (`world.merge`, *Merge…* on an entry's page, `novel_bible action=merge`) carries names, text, picture, scene marks, ties and gallery records to the entry that stays.
- **A place's picture is a scene to step into.** In the album, a place or a house that has design art and something standing in it shows the picture large with that marked on it — its courtyards, the houses seated there, whoever lives there — each mark a way in. Marks are laid out by themselves; the author can drag one to where the thing is in the picture (*Arrange*), and it is pinned there for every reader (`spots` on the entry, `world.pin`). On a narrow screen the picture keeps its height and is moved sideways.
- **A thing's design art goes along with the panels that show it.** A panel of a motion comic whose description names a thing that has design art is drawn with it as a reference, where the people and the place leave a seat.
- **Things in the art batch.** *Draw in a batch* and `novel_batch what=art` have `items` beside `places`: design art for the things of weight that have none, drawn before the scenes that show them.
- **The album: the people and the world, in the viewer.** What a reader looks at beside the text — everybody of the book laid out by the weight of their part, somebody's page with their picture large, who they are, what they go through and who and what stands around them; the places, houses, things and ideas of the world, each a page with its design art, what is written of it, the chapters that name it and what stands around it to step into; a slider for the chapter of the story on every page. It is one set of pages (`client/reader/album.tsx`) fed by one answer (`readAlbum` in `core/reader.ts`), shown in three places: the Studio's viewer (*View*, formerly *Read*: Text · People · World), the reader other devices are served, and a published site (`data/<book>/album.json`, an option of the dialog). A reader is given who and what the text has come to and what a collection of settings prints of a card; plans, secrets, notes and everything about how a thing is written, drawn or voiced stay with the author. A book published a part at a time has its album cut at the last chapter published. From any page of the album one press leads to where the thing is edited, and one press leads back. *Explore*, which walked the world under *Bible*, is the album's *World* now; having the planner work out the ties is offered there and above the lists of places and houses.
- **The world can be walked.** The things of a book's world now stand to each other: a courtyard is in a garden, a house has its seat in a city, somebody belongs to a house, lives in a courtyard, holds a token — one table of such ties (`bible/relations.json`), each of which may say from which chapter to which it holds. The planner works them out from the bible and the chapter digests on request (`ai.ties`), making an entry for a place, a house or a thing a tie needs and the bible lacks, and saying what it did; every tie can be added and taken away by hand on the page of either end (*In the world*, on a place's, a house's, a thing's and a person's page). The walk (the viewer's *World*, see *The album*): one thing large with its picture, what is in it, the houses seated there, the people who live there or belong to it, the things they hold — each to step into, with the way back above — and a slider for the chapter of the story: ties that do not hold then are not shown, and everyone says whether they are on yet, present, away, gone or dead at that time. Places and houses can be listed as a tree, by what is in what.
- **A character's life on the page.** A lifecycle was one label on a card, set by hand. Every chapter's digest already notes who was in the chapter, what they went through, how they stood at its end and whether they came on, left, returned or died; laid out along a line of the plot, that is a life. A person's page shows it: a strip of the line's chapters with the ones they are in filled (the coming on, a leaving, a death marked), a line saying where they come on, the stretches they stay and where they leave or die, every chapter's note behind a fold — and a paragraph that tells it, which continuity writes from the digests on request (`life` on the card) and the author edits. Read along another line of the plot it is another life: somebody dead on one line is alive on the one that parted before.
- **The lifecycle board at a chapter.** *People → Lifecycle* shows the labels on the cards, as before — or **as the story stood** at a chapter of the chosen line, by a slider: who is not on yet, who is present, away, gone, dead, read off the digests up to there. The scheduling notes say when a label on a card and the text disagree about somebody being dead or gone, with one button to set those labels from the text.
- **Design art for the things that matter.** An entry of the bible that is a thing — a token, a sword, a letter — can have design art like a place has: the object alone, whole, on a plain ground (*Bible → Things*, `novel_illustrate kind=item`). A picture that shows the thing is drawn with it as a reference, so it is the same thing every time. Its shape per kind of picture is `item` in the picture sizes (1:1).
- **A book as a site of its own.** *Show it to somebody* (the phone button in the reader's bar) has a second way out beside reading on the network: **Publish as a site** writes a folder that any static host serves — the reader a phone gets, the book's chapters, voices, motion comic and pictures — and that needs neither DSH nor the author's computer. Only what a reader is given goes in; nothing can be changed on a site. Published again into the same folder, only what changed is written and what is no longer part of the book is removed, without touching files that were not published from here. A sealed book is published in the open, and only on the author's explicit word.
- **The recommended setup is a file, published with every version.** Which image, speech and retrieval model each service is used with, the model a kind of endpoint falls back on when a slot names none, the models offered beside a field, and the context windows of the usual model families were all written into the code. They are `recommended.json` now — an issue with a number and a date, read when the Host half starts — and no model is named in the code any more. *Settings → One-click setup* shows the issue in force and a switch, **Follow updates** (on by default): following, a setting that still is what an issue recommended moves to what the next one recommends, and a notice at the top of the Studio says what moved, with **Take it back**; a model the author chose is never touched. Not following, the notice says what the issue would change, with **Adopt** and **Keep mine**, and nothing is changed. The narrator's voice moves only together with its speech model.
- **Restart, from the Studio.** When the plugin has been updated while DSH runs, the banner that used to say "restart DSH" has a *Restart* button: the Studio's own Host half is taken down and the installed one put up in its place, in a couple of seconds, with DSH and its conversations left as they are. The entry DSH loads is now only a door (`lib/index.js`); the Host half proper (`lib/host.js`) is put up by it as a plugin of its own, in Cordis's terms, so replacing it is an ordinary unload and load. Jobs that run are stopped and sealed books lock, as when DSH restarts — the button asks first when jobs are running. A new half that will not load leaves the running one up. (A Host from before this still needs DSH restarted, once.)
- **Removed chapters can be put back.** A chapter that is removed is kept — its plan, where it stood, its text — under *Recently removed* at the foot of the outline's chapter list, and *Put back* returns it to its place with what was made from it (digest, review, voices, pictures), which was never taken away. `restore-chapter` for the showrunner.
- **A plan's blanks, filled from the digest.** A chapter that arrived written — an imported one above all — has no plan beyond its title. Digesting a chapter now fills what its plan leaves empty (a line of synopsis, place, time, cast, threads) from what the chapter turned out to be; nothing that is written is replaced. *Fill from the digests* on the outline page does it for a book digested before this.
- **With subtitles**, a switch on the video card and in the stage batch (on by default; `subtitles=false` for `novel_video` and `novel_batch`). The Studio asks for an outcome and checks it — the lines in the picture, or carried as a track — and leaves the means to post-production: on a computer whose ffmpeg draws no text it found `pango-view` by itself and drew the words as pictures.
- The Studio's own page opens on the book of the conversation the author comes from, and on the shelf when that conversation is about no book; put back after a swap or a reload, it is where it was.
- The Studio's icon heads its home page.
- **Digest again**, on a book's overview: every chapter with text or a stretch of them, with what it writes anew and what it leaves alone said before it starts.
- **A book's cover and its title lead to reading it**, at the chapter this device read last — on the shelf and on the book's overview; the workbench has its own button on the shelf.
- **The chapter's title is the switch** on the Stage: press it for the list, the arrows beside it for the chapters before and after. Chapters of every line of the plot are listed, not the main line's only.
- **The storyboard has a frame of its own.** A chapter cut finely has dozens of panels, and laid out in full they pushed the video card and everything else off the page. The panels now scroll in their own frame — a grid that scrolls down or one row that scrolls sideways — whose height a grip changes; and several can be chosen at once (click, Shift-click a stretch, drag a box, or all) to be redrawn or removed together.
- **Outside help installs with one press.** Settings → The crew lists Claude Code and Codex with an *Install* button each (and *Remove* once installed); it goes through DSH's own plugin manager, the same road as DSH's Settings → Plugins. Where help would be of use and none is installed — on the video card — one line offers the same buttons. The paragraph of instructions is gone.
- **Every book has a look of its own, settled from the book.** The art direction left the Studio's settings for the book's bible (*Bible → Art*). The director settles it from what the book is — its period and place, the temper of its prose, its leads and places — as the last pass of importing a manuscript and of drafting a new bible, and again whenever the author asks, with a word on which way. A look the author has given a book is never replaced unasked; an analysis finished before this pass existed is not called unfinished for lacking it. What was once entered Studio-wide stays in force for books without their own and is shown, with a way to clear it, instead of being kept or dropped in silence.
- **Fineness and shape of pictures.** One fineness for all pictures (720p, 1080p, 2K, 4K — as many pixels as a screen of that name) and a shape per kind of picture (cover, portrait, design sheet, place, scene, panel: 1:1, 3:4, 4:3, 16:9, 9:16, 3:2, 2:3 or exact pixels), each showing the pixels it comes to. With nothing chosen every kind keeps the size it always had; the sizes that were fixed in the code now read these settings.
- **One order for the cast**: by the weight of the part, then by how many chapters someone is in, then by who came first — wherever people are listed, instead of by file name. The cast filter can order by first appearance or by name instead.

- **A conversation for every book.** A book made on the shelf — new or imported — gets a conversation of its own: a novelist's, in the book's workspace, named after the book and put on it. The overview says so and opens it; *Talk it over* on the overview goes back to it any time. A book made beside a conversation has that one. *Start a conversation* on the first page opens a novelist's conversation directly, with nothing to set up by hand.
- **The cast of an imported book.** The people the chapters name get their cards in rounds, the most present first: whoever comes back again and again a whole card, whoever comes back once a line, and whoever passes through a single chapter stays a walk-on. Each round is told who is known already, so another name of somebody becomes an alias — 凤姐 is 王熙凤 — instead of a second card. Cards nobody has worked on are filled in or folded together; a card somebody wrote is left as it is. It can be run on any book again (*Make the cast* on the overview, when people who keep coming back have no card; `novel_import action=analyze steps=["cast"]`).
- **An analysis that can be taken up again.** Reading an imported book — digests, cast, world, synopses and volumes, style — is a pipeline of its own that notes how far it came. Cut short, the overview says what is left and goes on from there (`novel_import action=analyze`); any pass can be run again by name.
- **Who a screen is about.** One control wherever characters are listed or chosen: a chip per kind of part with how many there are, "main parts only", and a search box. In a large cast it starts with those who carry the story. The ensemble view uses it for its board, presence table and ties; *Draw a batch* uses it to say whom the design sheets, portraits and voices are for; `novel_batch what=art` takes `roles`, and "all" characters of a large cast means its main parts.
- Settings: `context.sideTokens` (what the bible, threads and retrieved passages may take; unset, as before), `context.playTokens` (what a turn of an interlude carries; 24,000), `image.references` (reference images per picture; 3).

### Changed

- **What plays in a chapter, and how the page behaves while it does, is said once** (`src/client/reader/playback.ts`): the Studio's viewer and the reader on other devices each had their own copy of the player's wiring — turning to the script when play is pressed over the prose, keeping the line being spoken in sight, starting the chapter after one that ran out. Both use `useChapterPlayback` now, and the *Watch* tab is the mode switch's own. Nothing a reader sees has changed.
- **Places, houses, things and ideas each have a page.** The bible's *World* tab listed everything that is not a person in one list. It is four pages now: **Places**, **Houses** (families and organizations), **Things**, and **World** — which keeps the ideas: rules, premises, institutions, history. They are still one kind of entry with a category; changing an entry's category moves it to its page.
- **What is somewhere or something has a weight in the story**: core, major, minor, or passed once — read off how many chapters name it (by its name or one of its other names, or where a chapter's digest wrote the place down), unless the author sets it. Places, houses and things are listed by weight, heaviest first, those passed once folded away; an entry's page says in which chapters it is named. This is not the entry's *importance*, which decides whether its text travels with every request to a model and is now labelled as that. Place art in a batch defaults to the places of weight; a page says which core and major places and things still have no picture.
- **What a reader is given is made in one place.** The small server for other devices assembled the books, chapters, scripts and storyboards it serves by itself. That is one module of the engine now (`core/reader.ts`), which the server asks and a published site is written from — so what a phone shows and what a site shows cannot drift apart.
- **The reader has three faces and one play button.** *Read* and *Listen* were two modes, and the motion comic played on another screen. A chapter now has three faces in the reader — **Prose**, **Script** (who says what, how, over which sound, a line each) and **Watch** (the motion comic, where the chapter has one) — and listening is no longer a mode but the **player** under the first two: press play on either, the line being spoken is marked where it stands by a tint that runs through it at the pace of the voice, and the page follows. Pressing play over the prose turns to the script, unless *Turn to the script on play* is switched off. The script shows the chapter's pictures where the prose has them. The shelf's *Watch* leads here.
- **The reader on a phone, and on a published site, is the same reader.** It has the three faces and the one player too: *Prose*, *Script*, *Watch*, the line being spoken marked at the pace of the voice, pressing play turning to the script. The script as a reader has it — speaker, line, the sound under it, the chapter's pictures where the prose has them — is one page the Studio and the phone share; the Studio's table of takes, with its tools, is what *Produce* brings.
- **Reading settings are one panel.** Type size, paper, typeface and the speed of the voice in sight; behind *More*, whether play turns to the script, whether a chapter goes on to the next, the sound notes beside the text, the sound under the voice (and, in the Studio, the notes of a review). It opens from the reader's bar and from the player; on a phone it comes up from the bottom. *Settings → Reading* in the Studio is the same panel, not a second form. What is set is kept on the device it was set on.
- **Listening is for listening.** The production desk of the audio version, and the tools on every line of the script, used to take the top of the page whenever a chapter was listened to. They come with the *Produce* button in the reader's bar now, and go with it.
- **The home page is the shelf.** With no book open the Studio used to show a short shelf above a long form for making a book. The shelf is the page now. Above it, a banner with the two things an author comes for otherwise: **Talk to the showrunner** — which asks which book the conversation is about, opens (or makes) that book's own conversation, and sends *a new novel* to where books are made — and **New work**, which has a page of its own for starting a book from an idea or bringing one in whole. Every book on the shelf has the ways into it under its cover — *Read*, *Listen*, *Watch*, each shown only where the book has something to read, hear or watch, each opening at the first chapter that does — and *Work on it* on the cover's corner. At the foot: who made this, under what licence, the project's site and the author's page. The whale maid of the icon is on the banner, on the empty shelf and at the head of *New work*.
- **One page for a book's people.** Characters had two homes — their cards under *Bible*, and the lifecycle board, presence grid and relationship graph under *Cast* — each with a list of its own. They are one page now, **People** (人物), beside *Bible* in the bar: *Cards*, *Lifecycle*, *Presence*, *Relationships*, *Walk-ons*, with one filter above them all saying who the page is about. *Bible* keeps the world, the prose style and the art direction. Every way to "open the card" — the board, the graph, a search hit, a tool row in the conversation — leads to the card on that page.
- **A person's page shows the person.** The portrait was a thumbnail beside the name, and the design sheet lay far down the form. The picture now stands large in a column of its own that stays in view while the form scrolls: the portrait, with the design sheet and a sheet per look as thumbnails to switch to, each opening at full size; drawing and redrawing are right under it. Beside it the name, the part and the stage of life, the one-line identity and where they have been on the page — then the form. Narrow, the picture goes above.
- **The settings page starts short.** *Models* is two rows — the writer's model, and one model for the whole crew — and pictures, speech, sound and retrieval are one line each that says what is in use and unfolds when pressed. A switch, *Advanced*, brings the rest and stays as it was left: a block per role with its model, reasoning level, temperature and output cap and — what used to be a second section, *The crew* — whether it works as an agent, its tools and its steps; how many requests go out at once; the context budgets, now with fields for `context.sideTokens` and `context.playTokens`; the shape of each kind of picture and `image.references`. A link that leads to a part of the page opens it, whatever was folded.
- **Nothing in the plugin is compiled, and nothing in it belongs to one system.** The helper that asked a Mac's owner to prove presence before a sealed book's key is released was a small Swift program built with the plugin. It is gone, with its build step: the Mac is asked through `osascript`, as Windows is through PowerShell, and a book opens with its password where a system offers no such check. DSH itself has no owner check a plugin could call (see `docs/design.md`); when it has, the Studio will use it.
- **Work an agent can do is not done for it.** The Studio gives material, says what is wanted and checks the result; commands are the agent's. And the limit that binds the plugin — to run wherever DSH runs — does not bind an agent at work, which faces one computer and may use whatever that computer has.

- **Limits nobody chose are gone.** What a section of the context holds is decided by its share of the model's window and nothing else: the one-line list of other characters (it stopped at 80), open threads (30), relevant lore (8), retrieved passages (16). The import no longer stops at 90 people and 140 world names, or tells the planner "40 at most"; the world, like the cast, is collected in rounds. A derivation is as long as it is asked for, previewed or not. Every picture of a chapter is material for its video. All of an author's style samples are read as far as nine thousand characters go. The book's record keeps five thousand entries (it kept three hundred).
- **The ensemble's notes weigh the part.** Somebody with a part who has gone missing is a note; small parts that are not seen again are one line together, with one button to mark them offstage. "Too many active at once" counts those with a part.
- The agent half (`lib/agent.js`) holds no code of its own any more: it asks the Host half that is running to mount the tools, so the two a session works with are always of one build.

### Changed

- **How much goes out at once is one number per kind of request, and it holds over everything.** Lines spoken, pictures drawn, sounds made and pieces of text work each pass through a gate that counts across every chapter and every job. The default is 8 and the most is 256 (it was 3, at most 8, for speech; 2 for pictures and sounds; 2–4 for text). When a service answers "too fast", the gate slows down by itself — fewer at once, a pause — makes the refused request again instead of losing it, and climbs back as requests go through; the Studio says so while it lasts. Speech figures that were only ever an old default (2 or 3) follow the new one.
- **The story so far travels as an outline and as text.** A model that works on a chapter reads the nearest chapters word for word — whole chapters, as many as half of its context window holds, or the author's figure — and the chapters before those as an outline. It was all or nothing: the whole manuscript while it fit, then summaries and the last 3,000 characters. A chapter that already has chapters after it (one being rewritten) is given what follows too, and told to lead into it.
- **Requests are laid out for the providers' prefix caches.** What stays the same from one chapter to the next comes first — the book, the world, everybody in it, the outline of what came before, the text — and each new chapter only adds to its end; the chapter's own outline, where its people stand now and the brief come after. The window of text does not slide chapter by chapter: it holds its first chapter until the chapters no longer fit, then lets go of a quarter at once. The writer's standing instructions no longer carry the chapter's length. The usage ledger counts what a provider read from its cache, and prices it separately where a price is given.
- **A chapter's length is a recommendation, and there need be none.** A chapter may carry a recommended length, and so may the book; where neither does, the writer judges the length from what the chapter has to do (and is told how long the book's chapters have been running). New books are no longer stamped with 3,000 words a chapter, and that stamp on existing books no longer counts as a wish (`chapterBudget` in `novel.json` replaces `chapterWords`).
- **What happens on another line of the plot stays there.** Chapters that are not on the main line are digested like any other, but nobody is marked dead in the book for dying on a line, and no thread of the main line moves.

### Added

- **Batches: the same work for many, in one click.** One job does a set of steps for many chapters, characters or places; whatever can run side by side does; every step first looks whether anything is left to do, so a batch run again does what was left; a step that fails is the only thing that fails, and the batch says which. Three kinds: **the stage** (*Stage → Produce*: where every chapter stands — script, voices, sound, storyboard, pictures, video — and one button for what is missing; a chapter's voices, sounds and storyboard are made side by side once its script stands), **the text** (*Write → Write a run*: chapter after chapter, beats first where there are none and memory in between; or beats, memory and reviews for many chapters at once), **pictures and voices** (*Illustrations → Draw in a batch*: design sheets and place art first, then the portraits, chapter illustrations and cover drawn against them, and a voice per character). The listening desk makes a chapter's whole audio version — script, voices, sound — in one click, the motion-comic page the whole chapter. The showrunner has all of it as `novel_batch`.
- **The plot as a graph.** The outline's volumes are the main line; beside it there may be other lines — another way on the planner derived, an interlude played out, what the outline said before it was rewritten. A line leaves after a chapter and may arrive at one again. *Outline → Plot graph* draws them as tracks and stations and is where a line is opened, named, given the choice that leads onto it, joined to another, put aside, removed or **made the main line** (what the main line had in its place becomes a line; nothing is lost).
- **Rewrite, or go another way.** Deriving chapters now says where and how: at the end of a line, after any chapter, in place of what follows it (`replace` — chapters that are written are kept as a line put aside, never thrown away) or as a line of its own (`branch`). More than ten chapters are derived in rounds, up to 200 in one job. A what-if branch can be opened as a line.
- **Which way next.** The Write page lists one line at a time and switches between them; after a chapter where the story parts, it asks which line to go on with. `novel_write` takes a `line`. The reader follows a line too, and offers the choice at a fork — the words that were written down as what is decided there.
- **An interlude as a line.** What was played can be novelized as the first chapter of a line of its own, leaving where the scene branched off, with the player's first move as the choice.
- **Conversations go under the seal with their book.** DSH keeps every conversation as a plain log, and a conversation about a book holds that book. When a sealed book is locked, the conversations about it — the showrunner's, the runs of the roles, whatever a tool reached the book from — are encrypted to the book and taken out of DSH's store; when it is unlocked they are put back as they were. A sealed book's `novel.json` carries a public key for this (a drop), so it works while the book is locked; a conversation that is in use is sealed once it is let go, at the latest when DSH next starts.

### Changed

- **The crew are agents of DSH.** Continuity (场记, the `analyst` role), the planner (策划, `architect`), the director (导演) and the new post-production (后期, `producer`) are no longer prompts answered in one call: each is an agent with a persona, standing rules, skills, tools and permissions of its own, on DSH's own agent loop. A run is a **subagent of the conversation** that asked for the work — started through `ctx.subagents` by a provider this plugin registers — so it joins that conversation's composition, takes its permissions with approval pinned to "never", counts against the delegation depth, and is listed in the catalog of subagents in the conversation's header, where every step can be read with its tokens and time. Every place a pipeline asked a model for a JSON (digest, review, bible expansion, outline and beat derivation, what-if, foundation, the import's cast, world and volumes, audio scripts, storyboards, visual anchors, the scope of a book-wide revision) now hands the work to a role with tools to read the book and one tool to hand the result in with; what is handed in is validated on the spot and the turn ends there, so work whose material is complete still costs one request. A role that is set to plain calls, or whose agent run hands nothing in, answers in one call as before — and the job says which, and why. Jobs list the roles that worked in them, with a way into each run.
- **Text models are DSH's, and only DSH's.** Every text role runs on a model from DSH's *Settings → Models*; the Studio no longer connects text endpoints of its own, and the one-click setup fills only pictures, speech and retrieval. This is what lets every role be an agent, and it means a vendor is configured once. A role saved with an endpoint of its own by an earlier build keeps working by plain calls, and the Settings screen says so.
- Audio scripts, storyboards, visual anchors and illustration prompts are the director's work now (they were the analyst's); role names in the interface follow the crew: 场记, 策划, 导演, 后期.
- The Chinese interface calls the host DSH.

### Added

- **Who may use what.** *Settings → The crew*: per role, agent or plain calls; its own tools (the Studio's, plus the few of the conversation's that its work calls for — the planner searches the web, post-production has a shell and file tools) or all of DSH's; and a step budget. The preset now mounts a shell, job control and DSH's delegation tool for outside agents, so a role can be given them; the showrunner's own `novel_*` tools and the tools that need a person in the room are never a role's.
- **A task in words.** `novel_crew` hands a role a task that has no tool of its own — a question that takes reading and judging, research — and returns its report.
- **Skills per role.** Guides shipped under `crew/<role>/skills/` and registered for that role's runs alone: `novel-video-editing` for post-production, `novel-trend-research` for the planner.
- **A chapter's video, cut by an agent.** *Stage → Video* and `novel_video`: the chapter's voice, sound cues and storyboard pictures are laid out on one timeline — as JSON, and as one aligned voice track, subtitles, tables and a base script for a shell — and handed to post-production, which writes its own ffmpeg script, runs it, checks the result and hands in an MP4. The Studio only judges: a picture, a sound that is not silence, a length that matches the telling, no long black stretches. Outside help is DSH's own subagent: with `@deepseek-ai/dsh-subagent-claude-code` or `@deepseek-ai/dsh-subagent-codex` installed, post-production can hand the work on.
- **Settings that travel with a book.** *Model roles* and *The crew* are saved for every book or with the open one (its `novel.json` carries `models` and `crew`); `novel_settings action=book` does the same.
- **Sealing at creation.** A new book can be sealed as it is made: what is drafted or imported is ciphertext from its first file on.
- **A form that waits.** What is typed on the creation page is kept while the Studio is open: going to the settings and back no longer empties it.
- **What can be added can be taken away.** Chapters are deleted on the Write page; a line of an audio script and a whole script, a panel of a storyboard and a whole storyboard, a chapter's review and a chapter's video can each be removed — on their screens, and by the showrunner (`novel_manage action=delete_line | delete_script | delete_panel | delete_storyboard | delete_review`, `novel_video action=delete`).
- **Derive where you write.** The Write page asks the planner for the next chapters (reviewed before they join the outline) and for the open chapter's beats.

## [0.1.0] - 2026-10-07

First release, for DeepSeek Harness 0.2.0-rc.2.

### Added

- **Roles.** A showrunner agent preset (小说家 Novelist) that plans and coordinates, and four model roles it — or the author — calls: writer, architect, analyst and director, each routed to any model configured in the Harness.
- **Projects.** A book as a plain directory: `novel.json`, `outline.json`, a Markdown story bible (characters with structured personas, ranked world entries, style profiles), one Markdown file per chapter, and machine memory under `.novel/`.
- **Pipelines.** Foundation from an idea; chapter and beat derivation; what-if branches; drafting with automatic continuation; passage, chapter and book-wide revision as reviewable proposals; chapter digests with arc summaries; editorial review; bible expansion; style learning and sampling; import of existing manuscripts; export to Markdown, text, HTML and EPUB.
- **Memory and context.** Per-chapter digests (facts, character states, entities, thread movements), suggestions for the bible and character lifecycles, a context packer that switches between whole-manuscript and layered retrieval, and hybrid search (BM25 with CJK bigrams, optional embeddings). The context budget is 500,000 tokens by default and is held to 70 % of what the model can read; a role can state its model's window when nobody else knows it.
- **Novel Studio.** A page in the left sidebar and a per-session tab in the right sidebar with eight views: overview, bible, outline, write, read, cast, review, stage. Live streaming of drafts, selection-based revision, diffs, versions, search and find.
- **Stage.** Illustrations embedded in the text; audio drama with one voice per character, delivery directions and procedurally synthesized ambience; motion comics; playable interludes that can be discarded, kept as side stories or novelized into chapters.
- **One look per book, nothing hidden.** An art direction per book that the first picture writes into `novel.json` (from the Studio-wide direction or the built-in one) and that is shown with its origin wherever pictures are made; avoid lists per Studio, book, character and call; a visual anchor per character, distilled for an image model from the prose of the card; character design sheets (front, side, back), further looks (outfits) with sheets derived from the main one, and reference art for places — all sent to the image model as reference images where it takes them; and a record on every picture of what its prompt was assembled from.
- **Providers.** Speech: Bailian audio generation (`qwen-audio-3.1-tts-next`, with one reference clip per voice so a character sounds the same throughout), Qwen Omni realtime (WebSocket), DashScope Qwen-TTS with voice design, OpenRouter, OpenAI-compatible. Images: OpenRouter (GPT Image 2.5 and others), OpenAI-compatible, DashScope multimodal generation, and the GPT Image of a ChatGPT subscription through the Codex Connect plugin or the Codex CLI. Embeddings: OpenAI-compatible (Bailian, OpenRouter, OpenAI).
- **Setup.** A first-run guide and one-click setup per service (Aliyun Bailian, OpenRouter, OpenAI, ChatGPT subscription): paste one key and writing models, images, speech and retrieval are configured as recommended. Every slot can then name its own service, endpoint, key, model and reasoning level, choosing from a list of everything the endpoint serves (for speech: every model that can speak, with the protocol that drives it). Text roles may use any provider the Harness already reaches — keyed or signed in, such as a ChatGPT subscription through Codex Connect — or call any OpenAI-compatible endpoint directly.
- **Keys.** Typed into the settings and saved with them, into the Harness credential store — one record per endpoint host, shared by every slot on that service, never written to the settings file and never sent back to the page. The usual environment variables are picked up by themselves.
- **Books in.** Import of `.txt`, `.md`, `.epub` and `.docx` from the entry page (drag and drop) or from the conversation, and creation of a new Harness workspace on the spot.
- **The book in play.** A conversation is on one book at a time and the Studio beside it shows the same one. Changing book on either side moves both; the showrunner is told, in the conversation's own record, which book is in play and which one earlier turns were about. Every tool takes an optional `book` to touch another one once, results say which book they are about once a conversation has been on several, and a call always acts on the book its model was last told about.
- **Usage and cost.** A ledger of every model call the Studio makes — tokens per role, pictures, speech — summed by model, role, book and day, and costed at the unit prices the author enters. Also available to the showrunner (`novel_settings action=usage`).
- **Said, not swallowed.** Work that needs images or speech before they are set up, or that fails for a missing key or sign-in, opens a prompt that leads to the one-click setup or to the right section of the settings — for jobs nobody was waiting on too. Voicing a chapter shows the lines done, the line in the booth, the time taken and the time left.
- **One page to read and to listen.** The reader shows a chapter two ways: as prose, and as an audio drama with the sentence being spoken lit in the text, any sentence a place to start from, and chapters following one another. The author's production desk for the audio version sits above the same page.
- **On a phone.** The reader can be served to other devices on the local network: off until switched on for a book, read-only, behind an address with a random token that can be replaced, shown as a link and as a code to scan.
- **One voice, one level.** A voice sheet per book so every speaker — with a card or without — keeps one voice across chapters and interludes; a listening check on every synthesized line (cut short, silent, padded, or not in its voice) with automatic retakes; all lines brought to one loudness; scripts that keep narration whole and say so when a passage could not be directed.
- **No cap of the Studio's own on what a model writes.** A model that reasons spends its reasoning out of the same allowance as its answer; replies run as long as the model allows unless a role sets `maxTokens`, and one cut off at a limit fails with that reason instead of being patched up.
- **Storyboards cut as fine as asked.** A density per book (sparse, balanced, dense, or left to the director) and a ceiling on panels; panels that may change in the middle of a long line; a director that is asked for the rest when it stops early.
- **The shelf.** Covers on the bookshelf and the overview, any illustration as cover, and removal of a book into the system trash — the book's own files only, nothing erased.
- **Nothing that looks like nothing.** Every button that starts work shows what it is doing until it ends, and a bar at the foot of the Studio lists everything in progress with a way to stop it.
- **A narrator who tells a story.** Narration that follows narration is spoken in one take (up to about 180 syllables, long paragraphs cut evenly at sentence ends), so the narrator is one person telling a story rather than a new voice at every paragraph. A "he said" stranded between two spoken lines is marked as a tag and left unspoken — as an audio drama does — unless the book is set to read every word; any line can be switched either way. Scripts cut the older, finer way are reshaped on request without calling a model, keeping the recordings of unchanged lines.
- **Sound design.** Besides its lines a script now says what each scene sounds like: the bed of the place, spot effects, music. Each cue has a caption the reader sees beside the text — in reading as in listening — and a description for a sound model. Effects, music and beds are generated by the speech setup's own model where that can make sound as well as speech (Bailian audio generation), or by an endpoint named for sound; without one the cues stay captions and beds are synthesized by the player. Every cue can be heard, reworded, made again, added or removed.
- **Listening opens on the script.** The view the author works in — who says what, how, over which sound — is what the listening mode shows first; the prose is one press away.
- **The ensemble knows its people.** A person on the lifecycle board, in the presence table or in the relationship graph opens their card. People the page names who have no card — gathered from chapter memories, suggestions, audio scripts and the voice sheet — are listed as walk-ons and settled one by one: a card of their own (keeping the voice and the lines they had), an alias of a known character, or off the list.
- **Faces in the cast list.** The character list shows everyone's portrait (or the front view of their design sheet) by default wherever there is one or a way to draw one, grouped into leads, supporting and minor parts, with one button to draw every missing portrait; a minimal mode shows names only.
- **Reading along with the model.** What a model thinks before and between its words — the chain of thought where the model shows it, the summary where it does not — is kept with every job and can be read live: above the prose as a chapter is written, and from the bar at the foot of the Studio for any other job.
- **The showrunner's own hands, and one road for every change.** `novel_edit` makes exact changes to a chapter — replace, insert, append, delete, set — for what is not writing: the author's own words, a name, a slip of fact. `novel_memory` corrects what the book remembers of a chapter. Every change by any tool keeps a version, digests memory again and goes on the book's record, shown on the overview with one-press undo for manuscript edits. Raw file tools aimed at a book's own files are refused with the name of the tool to use (or asked about, or let through, as the author sets); files changed outside the Studio all the same are noticed, recorded, and their chapters digested again.
- **A book on another device, to read or to change.** A shared book is read-only or — when the author chooses — changeable: its text can be edited from a phone (a version is kept, the change is on the record) and its interludes played there. The phone reader also plays the motion comic, shows the sound notes, and skips the lines left unspoken.
- **Sealed books.** A book can be sealed: every file of it — text, bible, outline, memory, pictures, audio, exports — is encrypted where it lies (AES-256-GCM), file names included. It opens with its password or with the computer's own unlock (Touch ID or the Mac's password on macOS; Windows Hello on Windows, untested), stays open until it is locked or the Harness quits, and is invisible to the showrunner while locked. A device reading it over the network shows the password once and is then remembered by a grant the author can withdraw.
- **An icon.** DeepSeek-chan, the whale-girl maid of the Chinese internet, reading a novel — drawn for this project. Character reference: 溟月 by 上善无形, in ZipZipPipe's DeepSeek maid design.
- **Import finds a book's real chapters — an editor that looks, on the Harness's own agent loop.** Chapters used to be found by rule (a heading alone on a line, else pieces of a set size), and a manuscript scraped from a web page — every heading glued to the site's navigation, one or two written differently — came out as two hundred numbered pieces. They are now found by an agent: an editor with eight tools over the text (`look`, `search`, `clean`, `split`, `amend`, `list`, `sections`, `finish`) that reads the opening, works out how the headings are written, removes what is not the book, splits, and reads the report of what came out — gaps in the numbering, pieces too short or too long, "titles" that are sentences of prose (told apart by the numbering into places where the text only mentions a chapter, and real headings with their first sentence on the same line, each with the correction to copy) — then puts it right and commits, with a note to the author on what it found. It never rewrites prose. Its steps scroll by in the import's progress; its reasoning is in the job's thought. Guard rails are the tools' own: a pattern that would delete a fifth of the book is refused, one that backtracks without end is cut off, committing over a sounder earlier split needs saying so, and an editor that runs out of steps leaves its best split behind rather than nothing. This is the first role that is an agent rather than a call: it is created through `ctx.agents` with a scope that holds only its persona and its tools, so requests, retries, tool calls, the session log, the token meter and cancellation are the Harness's (see *Roles as agents* in docs/design.md). Where no agent can run — a role set to an endpoint the Studio calls itself — the old rules stand in and the result says so.
- **Calls that fail in passing are made again.** The Harness retries a failed model request for its agent's turns and for nobody else: a call a plugin makes through the model seam used to end at the first busy server, rate limit or dropped stream. The Studio now runs the provider's own retry policy (from Settings → Models; five tries with a growing wait by default) for every call it makes, says so on the job's progress line while it waits, and counts every attempt in the usage ledger. A reply that completes with reasoning in it and no answer at all — which providers produce now and then, and which the adapters let through as a normal end — is treated the same way and asked for again, unchanged, up to three times; when a model spends its whole output allowance reasoning, that is said at once, with what to change. Failures of this kind are worded in the book's language.
- **Agent surface.** Twenty-four `novel_*` tools covering everything the Studio's screens can do — including its settings (`novel_settings`), showing a screen to the author (`novel_show`) and the small hand edits (`novel_manage`) — a project digest in the prompt, working modes, the `/novel` command, five workflow skills, tool rows that open the Studio, a Studio tab that opens by itself when the showrunner starts working and follows what it shows, and a confirmation gate for writes in read-only sessions, for removing a book and for opening one to the local network.

[Unreleased]: https://github.com/xuhao1/whalesong-studio/compare/v0.1.1...HEAD
[0.1.1]: https://github.com/xuhao1/whalesong-studio/releases/tag/v0.1.1
[0.1.0]: https://github.com/xuhao1/whalesong-studio/releases/tag/v0.1.0