Prose

A local novel-writing engine: SQL Server canon for whole fictional universes, a desktop Writer, and a CLI and MCP server so Claude can draft, read and repair books against that canon.

Prose runs on your own machine. There is no hosted version: the hosted deployment was retired on 2026-08-23 and the project is local-only by design.

Why

• Keep a whole fictional universe straight. Characters, places, factions, gear and in-world documents live in one SQL Server database with a relationship graph and full temporal history, so a fact is stored once and every book reads the same one.
• Write a novel with Claude without losing the plot between sessions. The work queue, recorded decisions and read receipts live in the database, so the next session starts from the book's real state, not from someone's memory of it.
• Never ship a book nobody has read. The read gate refuses to export while any beat is unread as it stands, and there is no override.
• Edit prose by hand in a real editor. The Writer is a desktop window over the same database the CLI and MCP tools use.
• Know which checks earn their keep. Every quality instrument is measured by how many of its findings were ever applied; the ones that never helped are switched off, not left burning tokens.
• Run several universes side by side (cyberpunk, fantasy, horror, nonfiction and more) with scoping that fails closed instead of leaking one universe into another.

Features

One resident server

Prose.Hub is an ASP.NET Core process bound to 127.0.0.1:5900. It is the only process that touches the database. It hosts the engine's services, the Writer pages and an observability dashboard. The CLI and the MCP server are thin clients that forward every call to it and refuse to start when it is not healthy.

The Writer

Writer.exe is a WPF + WebView2 window that finds or starts the Hub and opens its /writer page. The editor itself (Prose.WriterUi) is compiled into the Hub, with a book editor, a reader view (/read) and a canon browser (/repo). Launcher.exe is a small picker that opens the Writer or the KDP publishing app, starting the Hub first when needed.

The observability dashboard

Prose.ObserverUi is served by the Hub at /app: dashboard, beats, logs, a 2D and 3D graph view, Dynamic Context Memory runs and the canon repositories, pushed live over SignalR.

The Novel Factory

The current way of working (RFC 0015, approved 2026-09-23). Every book moves through computed stations: planned, written, captured, read, clean, verified, pressed. Work is driven by work orders, decisions are recorded as rulings, and each Claude session is a row in the database. No LLM judges, votes or scores. See The Novel Factory below.

Canon as a database

Every canon row belongs to exactly one universe. Books are a tree of nodes (series, book, chapter) over beats, the atomic unit of story. Beats and nodes are system-versioned, so every edit can be rewound. Entities carry embeddings, typed relationship edges with story-time validity windows, and an append-only state ledger.

Writing and repair tools

• Exact-text splices across a whole book, dry run first, verified by read-back (--splice-beats).
• Read in true order with each beat's recorded point-of-view character attached (--read-beats), with read receipts and read notes.
• Clone, archive and restore books; move beats between books byte for byte.
• An enriched generation pipeline (ProseWriterRouter) for drafting beats from canon.

Checks that stay on

• The logic sweep: causality, knowledge states, timeline, plant and payoff, orphan references and inserted-beat drift.
• Ledger adjudication: same-predicate contradictions in the fact ledger, judged against the prose they came from.
• A deterministic prose linter for echo words, crutch phrases, pet words and attribution runs.
• Text integrity scanning for corrupted currency symbols, dashes and diacritics.

Export and audio

--export-node renders a book to .docx, EPUB, PDF and plain text with metadata files. Audiobook export renders a whole book through ElevenLabs. A separate WPF app, Prose.KdpPublish, drives the Amazon KDP site to publish and republish books.

MCP server

285 tools in 51 families, surfaced to any MCP client as mcp__prose__<name>. Claude can read and write beats, entities, rulings and work orders through the same Hub the CLI uses.

Quick start

Prerequisites:

• Windows (the Writer, Launcher and KdpPublish are WPF apps; the deploy scripts are PowerShell).
• .NET 10 SDK.
• SQL Server LocalDB (the default connection is (localdb)\MSSQLLocalDB, database Prose).
• At least one LLM provider key, only for the commands that call a model (see LLM providers).

Clone, wire up the git hooks and build:

git clone https://github.com/mindattic/Prose.git
cd Prose
git config core.hooksPath .githooks
dotnet build src\Prose.slnx

Without the core.hooksPath line the repo's pre-commit and post-commit hooks silently never run.

Publish and start the Hub. It applies any pending EF Core migrations at startup, then waits for /api/health:

powershell -ExecutionPolicy Bypass -File deploy.ps1 -Apps Hub -Start Hub

Enable temporal versioning on a fresh database and check the CLI can reach the Hub:

.\prose.cmd --migrate-sql --schema
.\prose.cmd agent bootstrap
.\prose.cmd --list-books --universe glmz

agent bootstrap prints ready when the Hub is healthy. Open the editor:

powershell -ExecutionPolicy Bypass -File deploy.ps1 -Apps Writer -Start Writer

Register the MCP server with Claude Code (one time):

claude mcp add prose dotnet run --project <path-to-your-clone>/src/Prose.Mcp/Prose.Mcp.csproj --no-build --configuration Release

Build src/Prose.Mcp in Release first. The tools appear as mcp__prose__*. For Claude Desktop, see src/Prose.Mcp/README.md.

How it works

 prose.cmd / Prose.Cli ----POST /api/cli-invoke----+
 Prose.Mcp (stdio MCP) ----POST /api/mcp-invoke----+
 Prose.Writer.exe (WebView2) ----GET /writer-------+--> Prose.Hub (Hub.exe, 127.0.0.1:5900) --> SQL Server
 Prose.Launcher.exe ----starts the Hub if down-----+      hosts the Prose.Core services,
                                                          Prose.WriterUi (/writer, /read, /repo)
                                                          and Prose.ObserverUi (/app)

• The Hub owns the database. It holds the Core services, the universe graph and the Dynamic Context Memory state. Every other front door forwards into it.
• The CLI and MCP server are thin clients. Both refuse to start when the Hub is not healthy (HubGate.EnsureReachableOrExit, no in-process fallback). The CLI forwards a handler class name plus its arguments; the Hub's CliDispatch runs the handler from Prose.Cli. MCP tools forward through HubInvoker to /api/mcp-invoke, where ToolDispatch runs the tool's body.
• The Writer is a window, not an app. Prose.Writer has no Prose.Core reference. All editor code lives in Prose.WriterUi, compiled into the Hub, so an editor change needs a Hub redeploy.
• Fail-closed health. /api/health returns 503 when SQL Server is unreachable. Protected endpoints take an X-Prose-Key header that the CLI and MCP server read from Settings.json.
• Universe scope travels with each call. Pass --universe <slug> or set PROSE_UNIVERSE. A content command with no universe is refused rather than defaulted.

Hub HTTP endpoints include /api/health, /api/cli-invoke, /api/mcp-invoke, /api/factory/*, /api/universes/*, /api/outbox/{consumer}, /api/generate-scene and /api/agent/bootstrap, plus SignalR at /hubs/observability.

Data layer principles

1. SQL is the only canon store. Markdown and JSON files are documentation or export mirrors, never the live read path. engine_data/*.json is a seed and export mirror, not canon.
2. Temporal tables. Beats, Nodes and other canon tables are system-versioned, so every edit is rewindable with FOR SYSTEM_TIME ALL.
3. Static and dynamic facts are split. Identity facts (name, height, ancestry) live on entity tables; story state (location, ammunition, life status) lives in the append-only EntityStateEvents ledger.
4. One format. Everything is a tree of nodes over beats: SeriesNode, BookNode and ChapterNode on one Nodes table, linked by ParentNodeId.
5. Every row belongs to exactly one universe. Enforced by an EF Core global query filter keyed on IUniverseContext, not by convention. An entity needed in two universes gets two rows.
6. Nothing reaches the database except through the Hub, reads and writes, no exceptions (2026-08-22). No raw sqlcmd, not even a read-only lookup.

The Novel Factory

RFC 0015 replaced loose plans and memory with state in the Hub. The agent protocol is docs/agent/PROSE_PROTOCOL.md; the design is docs/rfc/0015-novel-factory.md.

The laws

1. The book is its beats; the world is its entities. No outline, spine, blueprint, ledger or summary is stored about the story.
2. Every story change is a logged Hub call (MCP or the CLI). Never raw SQL.
3. Repo changes need an open engine work order whose paths cover them, and a commit that names it (WO:<id>).
4. Done is computed (a station passes) or Hub-validated (a work order's checks). Claims do not count.
5. A decision goes into the world the moment it is made, as a ruling or an entity record, with a read-back.
6. The book is read and written whole. A chapter is a unit of work, never a boundary of sight.
7. Deterministic checks only. No LLM judges, votes or scores.
8. A failed check is reported, never compensated with a new system.
9. No override on the read gate. Export only what has been read as it stands.
10. Every session ends with a summary in which every decision references a ruling or an order.

The line

| Station | Scope | Passes when | Cleared by | | --- | --- | --- | --- | | F2 Planned | chapter | at least one beat, and each has text or a title and a description | insert_beat | | F3 Written | chapter | every beat has text and a recorded write reason | update_beat_text, splice_beats | | F4 Captured | chapter | no uncaptured names and no untagged known names | create_*, add_entity_tags, an incidental ruling | | F5 Read | chapter | the read gate shows every beat read as it stands | read_beats with markRead | | F6 Clean | chapter | no open defect notes and no law-pattern hits in the prose | splice_beats, re-read, resolve_read_note | | F1 Verified | chapter | every tagged entity verified at its current version | verify_entity_begin, verify_entity_commit | | F7 Pressed | book | all chapters pass, metrics pass, docx, epub and pdf exports at the current fingerprint | --export-node | | A Audio | book | an mp3 export at the current fingerprint | audiobook export |

The read gate marks a beat unread when its text changes, when it moves, or when an entity it mentions changes. factory_next walks chapters in reading order and returns the first actionable statio