WolfeWriter user guide

This guide describes Wolfe as it works in the current Mac App Store build: what you can use today, which actions modify local data, and which features stay review-gated. It is not a product roadmap.

1. What Wolfe Is

Wolfe is a local-first macOS writing app for fiction. The current app is built around these workflows:

• Save books, chapters, manuscript text, plan-board data, and Story Memory on this Mac.
• Write prose in a native editor.
• Maintain per-chapter planning data such as outline, beats, characters, places, and threads.
• Extract local candidate characters, places, and story threads from manuscript text and show them on the plan board for review.
• Use local annotation, manuscript monitoring, and review-gated writing assistance where available in the App Store build.
• Require user approval before AI output changes manuscript text or Story Memory.

The default data directory is:

~/Wolfe/

The main database file is:

~/Wolfe/wolfe.sqlite

You can also view the library location in Settings under Privacy & Local, reveal it in Finder, or choose a new library folder. Changing the library folder copies the current local library and uses the new location after restarting Wolfe.

Core Features

Wolfe’s current feature set is designed around long-form fiction rather than generic text editing:

• Native macOS manuscript editor with chapter-first writing.
• AppKit/TextKit 2 text editing path for system-native selection, IME composition, and long-form text behavior.
• macOS-native SwiftUI/AppKit shell with Liquid Glass-style controls, panels, and writing surfaces where supported.
• Local book library stored on the user’s Mac.
• Markdown/plain-text manuscript import and export.
• Per-chapter Plan Board for outline, beats, characters, places, threads, tone, POV, and target word count.
• Story Memory for durable book knowledge: people, places, world rules, terminology, threads, timeline events, and canon facts.
• Guided Book Guide setup for genre, voice, POV, prose rules, dialogue rules, pacing rules, hard constraints, and soft preferences.
• Local annotation that finds reviewable story candidates from manuscript text.
• Separate CJK and Latin/English local extraction paths, because Chinese/Japanese/Korean prose and English-style prose require different rules.
• @ recall from Story Memory, accepted plan-board entries, and local annotation candidates.
• Ask Wolfe command sessions for drafting, rewriting, critique, continuity checks, dialogue passes, style passes, pacing analysis, brainstorming, and scene planning.
• Proposal-based AI edits: generated manuscript changes are not canonical until accepted.
• Apple Foundation Models-assisted local analysis where available. External API-key provider setup is not included in the Mac App Store build.

Why Wolfe

Wolfe exists for writers who want AI help without giving up control of the manuscript.

Most writing tools sit in one of two categories: a strong manuscript organizer with little story intelligence, or an AI chat/generation surface that treats the manuscript as context pasted into a model. Wolfe is designed as a third category: a local-first narrative operating system.

That means:

• The manuscript stays primary. AI appears as commands, proposals, plan-board suggestions, and review surfaces around the manuscript, not as a permanent chat-first workspace.
• The app feels like a Mac app. Wolfe uses native macOS windows, menus, keyboard shortcuts, AppKit text editing, and Liquid Glass-style UI surfaces instead of a browser-shell writing box.
• Your book has memory. Story Memory, Book Guide, plan-board fields, annotations, and narrative-state candidates are structured local context, not scattered prompt notes.
• AI output is reviewable. Drafts, rewrites, extracted facts, and candidate canon stay pending until the writer accepts or ignores them.
• Long-book continuity is a first-class concern. Wolfe keeps chapter plans, references, candidate entities, Story Memory, and continuity checks tied to the current book.
• You can start from an idea, an outline, or an existing manuscript. External provider setup is not required, and is not included in the Mac App Store build, to create, import, open, edit, or organize a book.
• The app is built for macOS and local ownership rather than a cloud manuscript dependency.

The practical answer to “Why Wolfe?” is: Wolfe is for authors who want the speed of AI assistance, the structure of a serious novel workspace, and the safety of local manuscript ownership with explicit approval gates.

Native macOS, Liquid Glass, And TextKit 2

Wolfe is built as a native macOS app, not an Electron-first or web-shell writing environment.

That matters for writers because:

• The manuscript editor uses an AppKit-backed text view path. On modern macOS, this gives Wolfe the system text engine behavior needed for long-form selection, scrolling, keyboard handling, and IME composition.
• TextKit 2 is worth mentioning as a trust signal for serious writing, but the user-facing point is not the framework name. The point is that Wolfe treats text input as a first-class native writing surface, especially for CJK input and large manuscripts.
• SwiftUI and AppKit are used together: SwiftUI owns the app shell and panels; AppKit owns the sensitive text-editing path.
• Liquid Glass-style materials and controls are used for modern macOS surfaces such as library actions, planning controls, command surfaces, and contextual panels where supported.
• Native menus and shortcuts are part of the product, not an afterthought.

In short: Wolfe’s UI direction is modern macOS, but the editing core stays practical and text-native.

Local-First Does Not Mean Intelligence-Free

Wolfe’s local-first boundary is data ownership and durability:

• Books, manuscript text, Story Memory, Book Guide, plan-board data, annotation records, and indexes live locally.
• The app can open, edit, inspect, save, import, and export projects without a remote service.
• The Mac App Store build does not include external API-key provider setup.
• Apple Foundation Models-assisted local analysis is used where the system supports it.

Local-first means the manuscript, book project, Story Memory, Book Guide, snapshots, and annotation state remain locally owned. Wolfe keeps project data and mutation gates local while using available on-device intelligence for local analysis.

How Wolfe Uses Local Rules And AFM

Wolfe’s intelligence stack is layered:

AFM is not presented as another heavy-generation provider. In Wolfe’s architecture it is a local context-awareness layer: useful for semantic labeling, compression, intent/scope support, and small-window enrichment when the system and device support it.

Measured Boundaries

Wolfe publishes measurements with the fixture and scope because extraction quality, local processing time, and provider generation time are different things. These numbers are versioned validation evidence, not a guarantee for every manuscript, Mac, language, or model.

The narrative graph is typed rather than a list of co-occurring names. Its current story relations include appearsIn, occursAt, involves, advances, causes, resolves, foreshadows, contradicts, and hasPOV. Narrative-state relations separately encode supersedes, contradicts, supports, derivedFrom, resolves, and dependsOn. Queries can return current truth, character or POV knowledge, reader knowledge, open promises, unresolved conflicts, payoff candidates, and lineage evidence.

The intended path is: extracted span → evidence-backed observation → reviewable candidate → confirmed narrative state → typed relation edge → query-specific context → reviewable proposal. A relation edge does not itself rewrite the manuscript or promote a candidate to canon.

Generation does not use one fixed prompt size. The default context package is 16,000 estimated tokens, with nominal caps of 6,400 high-priority, 4,800 medium-priority, 3,200 low-priority, and 1,600 advisory context. Critical user intent and hard constraints are preserved when the budget is tight. Provider-specific limits are derived from the model context window after reserving output and overhead, with a 4,000-token floor. Each run records the actual requested and included context tokens, dropped or truncated sections, provider prompt/completion usage when available, context-build time, time to first text, and total provider time.

These figures describe the current validation boundary; they do not mean that Wolfe automatically turns extracted candidates into canon or that every generation consumes exactly 16,000 tokens. The writer still reviews candidates, graph changes, and generated proposals before they become part of the book.

How Wolfe Differs From Other Writing Apps

This is a category-level comparison, not a claim about every current feature of every product.

Wolfe’s goal is not to visually copy any of these tools. The goal is practical writing usefulness: start a book, import existing work, plan in writer language, draft scenes, ask for help, revise, and keep control of what becomes part of the book.

2. Launch And Library

When Wolfe starts, it opens either the writing desk or the Writing Library.

The Writing Library provides:

• New Book: create a new book.
• Import: import an existing manuscript.
• Open / Manage All: open and manage existing books.
• Active / Archived / Needs Attention filters.
• Archive, Restore, and Delete bulk actions.

If there are no books yet, the writing desk shows a “What is this book about?” prompt. Enter a short description and choose Create Book.

3. Create A New Book

There are two entry points for creating a book:

• New Book at the top of the Library.
• The opening prompt on an empty writing desk.

After creation, Wolfe opens the main writing interface. The book is stored in the local database and does not require a remote service to open or edit.

4. Import A Manuscript

Entry points:

• File > Import Manuscript…
• Import at the top of the Library.
• The editor import surface.

Current supported formats:

• Markdown: .md, .markdown, .mdown
• Plain text: .txt

Markdown import uses heading levels to recover structure:

# Book Title

## Chapter Title

### Scene Title

Scene body...

Plain text has no reliable structure metadata, so Wolfe conservatively imports it as one chapter/scene.

Import replaces the current manuscript and is therefore destructive. Wolfe parses the file first, shows a preview with chapter count, scene count, and character count, then asks you to confirm Replace. Canceling does not change the manuscript.

After import, Wolfe runs local annotation and plan-board candidate extraction in the background. Bulk import does not run a remote provider by default.

5. Main Writing Interface

The main interface has three areas:

• Left Project Navigator: books, chapters, scenes, and the selected chapter’s Plan Board.
• Center Manuscript Editor: the current chapter or scene text.
• Bottom/overlay surfaces: Ask Wolfe, Story Memory, scene context, proactive suggestions, proposal review, and related temporary panels.

Common toolbar buttons:

• Library: return to the library.
• Focus Mode: hide distractions and focus on the manuscript.
• Ask Wolfe: open a Wolfe command session for the current context.

Keyboard shortcuts:

• ⌘K: Command Palette.
• ⇧⌘R: Ask Wolfe.
• ⌃⌘F: Focus Mode.
• ⌘F: Find.
• ⌘G: Find Next.
• ⇧⌘G: Find Previous.
• ⌘/: Keyboard Shortcuts.

6. Write Manuscript Text

Manuscript editing uses the AppKit/TextKit editor path. Chinese IME, selection, cursor movement, and text input are owned by the editor buffer first; saving, metadata, annotation, recommendations, and indexing run later in the background after idle time.

While writing, you can:

• Type or paste directly.
• Type @ to trigger mention autocomplete.
• Use the Find bar to search the current scene/manuscript.
• Use Focus Mode to clear side context.
• Accept New Scene or dismiss it when Wolfe detects a scene break.

@ recall can include:

• Confirmed Story Memory.
• Accepted plan-board entries.
• Annotation-projected candidates.
• Local CJK / Latin candidates.

Candidates are ranked by confirmed state, accepted plan-board state, high-confidence candidate state, semantic/fuzzy match, and related signals. Stale popovers are cleared when switching scene or project.

7. Manage Chapters And Scenes

The Books section in the left sidebar shows chapters. Single-scene chapters appear as flat chapter rows; multi-scene chapters can expand into a scene tree.

Chapter actions include:

• New Chapter.
• Draft Chapter.
• Review Chapter.
• Generate Chapter Outline.
• Finalize Chapter.
• Move Chapter Up / Down.
• Delete Chapter.
• Export Chapter as Markdown / Plain Text.
• Select multiple chapters and delete them in bulk.

Scene actions include:

• Draft Scene.
• Edit Scene.
• Review Scene.
• Generate Scene Beats.
• Move Scene Up / Down.
• New Scene.

After deleting a chapter, Wolfe shows an undo toast. You can undo the deletion; dismissing the toast permanently deletes the chapter.

8. Plan Board

After selecting a chapter, the bottom of the left sidebar shows that chapter’s Plan Board. Current tabs:

• Outline
• Beats
• Threads
• Characters
• Places

The Plan Board shows:

• Status, word count, target word count, and POV.
• Writer-authored plan data.
• Planning data inferred from import, local edit, or accepted generation.
• Candidates found in manuscript but not yet added to the plan.
• Linked Story Memory entries.

Candidate rows show source, status, confidence, and review actions. Current actions include:

• Add to this chapter plan.
• Ignore this candidate.
• Request local semantic review.
• Request deeper review where available in the current build.

Important boundaries:

• Local extraction only creates candidates; it does not confirm canon.
• Accepting a candidate can add it to the planning / Story Memory reference path, but it does not automatically rewrite narrative canon.
• Deeper review is explicit and does not run as a default whole-book scan during bulk import.

9. Story Memory

Story Memory is the current book’s long-term memory. It is not just a notes sidebar; it is Wolfe’s local structure for characters, places, world details, story threads, and canon information.

Entry points:

• Command Palette > Story Memory.
• Story Memory buttons in the editor or bottom context surfaces.
• Candidate review actions from the Plan Board.

Current major Story Memory entry types include:

• Characters
• Locations
• Factions / worldbuilding
• Timeline events
• World rules
• Terminology
• Threads
• Canon facts

The Story Memory editor lets you edit fields such as name, role, status, kind, body, notes, and tags. Edits are saved to the local database.

Wolfe does not silently turn model output or manuscript extraction results into Story Memory. Candidates must be accepted, ignored, merged, or otherwise reviewed by the user.

10. Book Guide

The Book Guide is the writing guide for a book. It corresponds to Wolfe’s internal SOUL document, but the user interface does not require raw markdown editing.

Entry points:

• Book Guide button in the editor header.
• Command Palette > Book Guide Setup.
• Settings > Book Setup.
• The first-run Set up your Book Guide banner.

The Book Guide records:

• Genre, voice, POV, and tense.
• Prose, dialogue, and pacing rules.
• Hard constraints and soft preferences.
• Unresolved decisions.

Settings > Book Setup shows completion status, hard rule / soft rule counts, and missing high-value sections.

11. Ask Wolfe And Writing Commands

Ask Wolfe is a command session for the current context, not a default persistent chat rail. It can read the current selection, chapter/scene, Book Guide, Story Memory, and available context, but it does not directly change manuscript text.

Common writing commands and review surfaces include:

• Rewrite: rewrite the selected text, paragraph, or scene as a proposal.
• Continue Scene: draft the next beat of the current scene as a proposal.
• Draft: draft prose for the current scene/chapter as a proposal.
• Critique: analyze without editing the manuscript.
• Dialogue Pass: audit dialogue without editing the manuscript.
• Continuity Check: check against Story Memory without editing the manuscript.
• Describe: tune descriptive detail with sensory density, emotion, POV, and related controls as a proposal.
• Expand: enrich the selected text, paragraph, or scene as a proposal.
• Condense: tighten the selected text, paragraph, or scene as a proposal.
• Scene Planning: generate scene/chapter beats for analysis/planning.
• Brainstorm: generate comparable story ideas for analysis/planning.
• Style Pass: rewrite for voice and style as a proposal.
• Pacing Pass: analyze drag, rush, pressure, and pacing.

Commands that change manuscript text produce a proposal. You must Accept the proposal before it is written into the manuscript; Dismiss/Reject leaves the manuscript unchanged.

In the Mac App Store build, unavailable external-provider commands show unavailable messaging instead of opening API-key setup.

12. App Store Build And Developer Provider Settings

The Mac App Store build focuses on the included native writing workspace, Book Guide, Story Memory, local annotation, monitoring, and available Apple Foundation Models-assisted local analysis. It does not include external API-key provider setup.

Developer and local builds may expose additional provider settings for testing external or local OpenAI-compatible generation backends. Those settings are not part of the App Store build described by this guide.

If you are using a non-App-Store development build, keep provider keys out of project files, snapshots, logs, and shared diagnostics.

13. Export

Entry points:

• Books menu in the left sidebar: Export Book as Markdown / Plain Text.
• Chapter menu: Export Chapter as Markdown / Plain Text.
• The editor export surface.

Current supported formats:

• Markdown: preserves book/chapter/scene structure.
• Plain text: prose-friendly interchange format.

Wolfe currently does not support EPUB, DOCX, PDF, Kindle formatting, or other publishing exports.

14. Settings

Current Settings panes:

• General: language and default writing behavior.
• Writing: font, size, line spacing, editor width, typewriter mode, focus mode, proactive suggestions, and quiet mode.
• Book Setup: Book Guide completion and setup.
• Intelligence: local annotation and available Apple Foundation Models-assisted analysis settings.
• Privacy & Local: library folder, database file, Reveal in Finder, library folder changes, and Advanced Mode.
• Appearance: editor theme.
• Wolfe Pro: entry point for whole-book narrative intelligence.
• Support: version, diagnostics, and support information.

Advanced Mode exposes more system-context surfaces, such as Story Memory. It can stay off for the normal writing workflow.

15. Local Annotation And Multilingual Extraction

The current annotation pipeline runs in layers:

• Typing/import first runs deterministic local extraction.
• CJK and Latin/English use separate local rules.
• AFM / local semantic review is reserved for small-window semantic enrichment.
• Deeper review is used only for explicit review actions or writing commands where available.

CJK local extraction focuses on:

• Personal names, role titles, and official titles.
• Place names and location suffixes.
• Items and symbolic objects.
• Time expressions.
• Dialogue and speech actions.
• Threads and story signals.

Latin/English local extraction focuses on:

• Titles and aliases, such as Mr. Darcy and Darcy.
• Possessives, such as treating Darcy's as alias evidence rather than a separate person.
• Broken newline names, such as Lady\nCatherine.
• Known place patterns.
• Gutenberg boilerplate filtering.

All extraction results are candidates. The Plan Board shows active Tier 1 candidates; weak/rejected results are folded away or kept in diagnostics.

16. Privacy And Data Boundaries

Wolfe stores manuscript text, Story Memory, Book Guide data, annotation data, and indexes locally by default.

Bulk import does not send the whole book to a remote provider by default. The Mac App Store build does not include external API-key provider setup.

Debugging and diagnostics must not contain API keys, private manuscript dumps, or full unredacted project state.

17. Current Limitations

Based on the current implementation, these areas are not complete shipping surfaces:

• EPUB / DOCX / PDF / Kindle export.
• Collaboration, cloud manuscript hosting, or mobile sync.
• Bundled local LLM or local training model.
• Automatic confirmation of narrative canon.
• Automatic remote deep analysis of the whole book after bulk import.
• Perfect entity disambiguation in every language; candidates still need review.

For large manuscripts, Wolfe’s design goal is that the input hot path only updates the editor buffer and lightweight state. Saving, annotation, recommendations, and indexing run in background or explicit review paths.

Call project facts from the manuscript workspace

While drafting chapter three, a writer can type @ in the manuscript and call up a character detail, place rule, timeline event, or thread from the project context. The project record appears beside the chapter text.

WolfeWriter keeps the manuscript, Plan Board, Story Memory, and local annotations in the Mac writing workspace. The Plan Board holds the chapter outline and its beats.

The facts a writer has chosen to carry across chapters live in Story Memory. The app can find candidate characters, places, and story threads in manuscript text and show them for review. If an extraction proposes a character with the wrong role or a place with the wrong detail, the writer can reject or correct it before acceptance. Nothing extracted becomes durable project state or manuscript text until the writer accepts it.

See the WolfeWriter home for the writing-room overview.