Status: M0–M3 implemented as a local development build. See verification evidence, architecture decisions, and user guide. M4 release qualification remains outstanding.
This plan turns the product direction in README.md into a sequence of deliverable milestones. It establishes a small native writing app first, while preserving the information needed for detailed prose analysis later. Milestones are ordered by dependencies, not promised calendar dates.
| Milestone | Delivered | Verification |
|---|---|---|
| M0 | Xcode app/test targets, TextKit 2 editor, bundled font/license, toolchain and storage decisions | Clean universal Release build, native editor tests, recorded 50k/200k measurements |
| M1 | SQLite schema/migration, library/outline operations, exact bodies/counts, backups and staged restore | Atomic ordering/deletion/moves, corrupt and damaged-library recovery, exact reopen tests |
| M2 | Autosave and failure retention, native commands/find, appearance/focus, export and recovery UI | Native UI journey, concurrent flush/composition/undo tests, disk-full rollback, byte-exact UI export |
| M3 | Goal editor/calculator, live pace, daily progress and calendar refresh, user guide | Documented arithmetic examples, DST/leap/time-zone tests, persisted goals/progress and 200k-word revision journey |
See testing for measured results and the remaining M4 release-validation matrix. No advanced analysis feature has been added.
Build a personal, offline macOS app where an author can:
- Create a novel and organize it into ordered acts and chapters.
- Write and revise chapter text with dependable native editing and autosave.
- Check spelling without automatic changes to their prose.
- Set a total manuscript word target and deadline, then see the daily pace needed to finish.
- Switch between light, dark, and system appearance in an interface set in DM Mono.
- Reopen their work, recover a backup, and export readable text.
Initial assumptions: one local library containing multiple novels, one main editing window, one chapter visible at a time, one current goal per novel, plain-text chapter bodies, and every calendar day available for writing. Create a default act and chapter so a new novel is immediately writable. Acts are author-defined; do not impose a three-act structure. English is the first language for evaluated writing feedback, while editing must preserve arbitrary Unicode text.
Add grammar, active/passive voice, a thesaurus, repetition and rhythm analysis, descriptive style profiles, and other local assistance. These features must work at paragraph, sentence, token, and arbitrary text-range levels, with summaries at chapter, act, and novel levels.
Rich text, scenes, manuscript-wide search, additional languages, and richer export formats may follow demonstrated needs. Other desktop platforms remain a future option, without influencing the initial native UI.
No generated prose, scene continuation, paragraph rewriting, chatbot authoring, or style imitation. A local generative model would still violate this boundary. Use rules, dictionaries, classifiers, taggers, and other non-generative models for analysis; explanations can use authored templates. Never apply a finding without the author's explicit action.
No manuscript upload or training on private writing. The planned product needs no account or backend. Do not add sync, collaboration, a plugin platform, or remote analysis to these milestones.
Use Swift, SwiftUI, AppKit, and SQLite. Start with one application target and test targets, organized into folders. Prefer concrete types and direct calls. Introduce a protocol only at a boundary that needs substitution, such as an analyzer or a test clock; do not add a dependency-injection framework or generic repository system.
| Area | Responsibility |
|---|---|
| App | Application lifecycle, window, commands, dependency creation, and settings. |
| Manuscripts | Novel/act/chapter navigation and structural operations. |
| Editor | Native text view, selection, undo, spelling, appearance, and save coordination. |
| Goals | Goal configuration, shared word-count policy, and calendar calculations. |
| Persistence | SQLite access, migrations, manuscript transactions, backups, and restoration. |
| Analysis, later | Segmentation, analyzers, derived findings, and feedback presentation. |
The intended flow is: native editor → save coordinator → persistence transaction. Goal calculations consume current manuscript counts. Later, the analysis scheduler consumes immutable text snapshots and returns revision-bound results to the UI. Analysis never sits in the typing or saving path.
Use SwiftUI for the application shell and embed an AppKit NSTextView using NSViewRepresentable.
Native text editing and spell-check controls are available through
NSTextView; the representable
API bridges AppKit views
into SwiftUI.
- Prototype the editor before building the rest of the interface. Verify long documents, selection, undo/redo, marked text, input methods, spelling, and future range decorations.
- Evaluate TextKit 2 during the prototype and record the chosen configuration. Verify API availability against the selected deployment target; avoid accidentally switching text-layout implementations.
- Keep one editing buffer for the active chapter. Do not replace the complete text view contents on each SwiftUI update or reset selection and undo history during autosave.
- Give each chapter clear editing/undo ownership. Switching chapters must never allow an undo operation to change a different chapter.
- Start with plain text, paragraph spacing, configurable writing size, and a comfortable line width. Pasting formatted text preserves its textual content without importing fonts or attachments.
- Offer standard keyboard commands, a collapsible outline, a restrained word-count/goal footer, and a focus mode that hides supporting UI.
- Use native spelling underlines and correction menus. Make automatic spelling correction opt-in; keep grammar analysis out of the first release.
- Disable generative Writing Tools in app-controlled text surfaces and disable inline predictive
completion. Verify the editor and title fields against each supported macOS version. Apple
documents opting out using
writingToolsBehavior = .nonein Get started with Writing Tools. Do not attempt to police text pasted by the user or unrelated system software.
Bundle DM Mono for manuscript text, labels, navigation, and app-controlled settings. Include the font's license and attribution; the upstream project identifies its SIL Open Font License. Use system font fallback for unsupported characters and leave OS-managed menus and dialogs native.
Define a small set of semantic colors for background, text, secondary text, selection, separators, and feedback. Support light, dark, and system appearance from the beginning. Keep appropriate contrast, visible keyboard focus, VoiceOver labels, scalable writing text, and reduced-motion behavior. Review spelling underlines, selection, and future analysis highlights in both themes; information must not depend on color alone.
Start with a single SQLite database in the app's Application Support directory. UI-only settings
such as theme and font size may live in UserDefaults; manuscript content and goals belong in
SQLite. Defer a custom document-package format and multi-window editing.
Use the system SQLite library through a thin, typed persistence layer: prepared statements, explicit transactions, migration scripts, and consistent error handling. Keep SQL out of views. Add a small established SQLite package only if the first persistence milestone demonstrates that it materially reduces complexity; record the decision before adding it.
Serialize writes and run database work away from the main thread. Start with one owned connection on
a dedicated serial executor/queue, keeping transactions synchronous within that owner. Do not
suspend an open transaction across an await. Add read connections only when measurements show a
need. Enable foreign keys on every connection, configure a bounded busy timeout, and use WAL on
local storage. Verify the shipped SQLite version and pragmas in the storage tests. See SQLite
foreign keys and WAL
behavior.
These are logical records; write the actual SQL and migration only in the persistence milestone. Use stable UUIDs for user-owned entities, UTC timestamps for instants, explicit ordering, and database constraints for ownership.
| Record | Principal fields and rules |
|---|---|
| Novel | ID, title, language, calendar time-zone identifier, created/updated timestamps. |
| Act | ID, novel ID, title, integer sort position, timestamps. |
| Chapter | ID, act ID, title, sort position, body text, monotonically increasing content revision, cached word count, word-count algorithm version, timestamps. Its novel is determined through its act. |
| Writing goal | ID, unique novel ID, positive target word count, deadline as a calendar date, timestamps. Completion and overdue status are calculated, not separate mutable flags. |
| Daily progress | Novel ID, local date, time-zone identifier, net word delta from manuscript changes. Unique per novel/date/time zone; updated in the same transaction as the corresponding change. |
| Schema version | Ordered migration identifier and application metadata needed to open the database safely. |
Enforce foreign keys and index parent/order lookups. Keep chapter positions unique within an act and act positions unique within a novel, using a transaction with temporary positions when reordering. Make creation, movement, deletion, and reordering atomic. Allow moves between acts of the same novel initially. Refuse to delete a nonempty act until the user explicitly chooses to delete its chapters or move them elsewhere.
Chapter body text is the canonical manuscript. Store the exact text without silently normalizing spelling, punctuation, Unicode, or line breaks. Do not make token rows, rendered text, or analysis output authoritative. Cache counts for fast totals but make them reproducible from chapter bodies. Titles and structural metadata are excluded from word counts.
Content revision advances only when the body changes. A rename or reorder does not invalidate linguistic analysis, though it can change presentation or future aggregate ordering. Revision numbers identify text states; they are not a promise of full revision history. Do not store a complete copy of the novel on every keystroke.
Design these contracts now; create their tables when the first analysis feature needs them.
| Record | Purpose and essential provenance |
|---|---|
| Analysis snapshot | Chapter ID, content revision, text hash, language, creation time, and the exact body used for a retained run. Old snapshots have a bounded retention policy. |
| Segment set and segments | Snapshot ID, segmenter ID/version, segment IDs, type (paragraph/sentence/token), parent segment, ordinal, and text range. IDs are stable within a segment set, not across arbitrary edits. |
| Analysis run | Snapshot ID, segment-set ID if used, analyzer ID/version, model/rule version, configuration hash, locale/OS version when relevant, status, and timing. |
| Finding and finding spans | Run ID, rule/category, message key and structured explanation data, severity, optional confidence, and one or more exact source ranges. Supports noncontiguous evidence without assuming one word per finding. |
| Measurements | Run/segment scope, metric name and version, typed value and unit; derive larger summaries from compatible current runs. |
| Feedback decisions | Accepted/dismissed/ignored state, rule ID, scope, source identity, and timestamps. Author preferences are distinct from disposable analysis output. |
Keep commonly queried fields typed and indexed. Reserve small, versioned JSON payloads for analyzer-specific evidence; do not put all findings in an opaque chapter-sized blob. Avoid a general entity-attribute-value schema, knowledge graph, or vector database before a feature requires one.
Build granularity around exact source ranges plus provenance, not an assumption that words or sentences have permanent identities. Findings can address a token, phrase, sentence, paragraph, or several spans. Novel/act/chapter summaries record the source revision set and report partial coverage when some chapters are stale or unanalyzed.
Use half-open UTF-16 ranges [start, end) relative to the exact chapter snapshot, matching the
editor's range coordinate system. Persist the offset convention. Convert explicitly at Swift string
boundaries; never treat byte counts, grapheme counts, and UTF-16 offsets as interchangeable.
Validate ranges, surrogate pairs, combining marks, emoji, and right-to-left text before highlighting
or replacing anything.
An analysis result is eligible for display only when its snapshot revision and analyzer configuration match the current source. An unsaved editor change also makes previous results stale immediately: use an editing generation token so a stored revision cannot incorrectly match a changed buffer. Cancel superseded work and check identity again when results arrive.
Start by invalidating and reanalyzing the changed chapter after a pause. This is simpler and safer than remapping stale offsets. Add paragraph-level incremental analysis only after profiling, with explicit context expansion for rules that depend on neighboring sentences. A replacement must revalidate the current range and original text and enter the native undo stack as one deliberate edit.
- Keep forward-only, ordered schema migrations under version control. Existing manuscripts must migrate safely; there is no requirement to support older app versions opening newer databases.
- Create a verified backup before migrating. Apply migrations transactionally where supported, record the schema version only on success, and reject an unknown newer schema with an actionable message.
- Provide automatic rotating backups and an explicit backup action. Use SQLite's online backup API to create consistent copies; copying an open main database file alone can omit committed data still in the WAL.
- Before restoration, validate the candidate backup and preserve the current database. Close database connections before replacement, restore through a staged operation, and reopen only after integrity checks succeed.
- Define bounded backup and analysis-snapshot retention. Clearly document that deleted content may remain in retained backups; purging derived analysis must not remove manuscript text or feedback preferences.
- Keep storage local rather than opening the live database in a network or cloud-sync folder. Exported backups can be moved by the user. Do not claim application-level encryption unless it is implemented and tested.
- Provide an ordered UTF-8 plain-text export with act and chapter headings. State that text export preserves prose and order, while a database backup also preserves goals and metadata.
Save coalesced body edits after a short pause, with a maximum interval during continuous typing. Starting budgets are a 500 ms debounce and a two-second maximum interval; measure and adjust during the editor milestone. Do not interfere with marked-text composition.
Each successful save transaction updates the chapter body, content revision, cached count, and daily progress together. Compute the net delta against the last committed count, not a stale UI estimate. Use the expected revision when committing so a delayed save cannot overwrite a newer edit. Retrying an already committed change must not count it twice. Structural deletion updates totals and progress atomically too; reordering does not affect them.
Flush pending edits on chapter/novel switches, explicit save, and orderly termination. A failed flush must retain the editing buffer and make retry or export possible. Do not report “Saved” before the transaction commits. Preserve the buffer and show a visible error for disk-full, access, or database failures. Handle sleep/resume, and document that a forced termination may lose edits since the last successful save; autosave is not an absolute zero-loss guarantee.
Use one versioned word-count implementation for chapter, act, novel, goal, and daily progress values. Specify and test apostrophes, hyphens, numbers, punctuation-only text, whitespace, Unicode, and languages without spaces. Document the supported counting policy rather than claiming every external word processor will match it. Changes to the algorithm require recounting cached totals without recording the recount as new writing.
Show responsive counts from the active buffer, but serialize persisted updates through the save path. The live novel total substitutes the active buffer's count for that chapter's last saved count. Avoid rescanning the entire novel on each edit; count the active chapter off the main thread and discard outdated calculations.
Let T be the target total manuscript words, W the current manuscript total, and D the
remaining calendar days, including today and the deadline date in the novel's selected time zone.
R = max(0, T - W)
if R == 0:
state = complete
required_daily_pace = 0
else if deadline < today:
state = overdue
required_daily_pace = unavailable
else:
state = active
required_daily_pace = ceil(R / D)
Use calendar arithmetic, not seconds divided by 86,400. The deadline is a date, not a UTC midnight timestamp. Default the novel's time zone to the system zone at creation, then retain it until the author changes it. Recompute on content changes, goal edits, midnight in that zone, launch, and resume from sleep. An explicit time-zone change affects future day boundaries; retain historical progress with its recorded date and zone.
| Situation | Required behavior |
|---|---|
| Target 80,000; current 60,000; 10 days left | Show 20,000 remaining and a pace of 2,000/day. |
| No writing before the next day | With 9 days left, show 2,223/day. No separate missed-day penalty is added. |
| Then add 3,000 words that day | With 17,000 remaining and 9 days left, show 1,889/day. |
| Deadline is today | One day remains; all remaining words form the required pace. |
| Deadline has passed and words remain | Show words remaining and “Deadline passed”; offer to change the goal. Do not divide by zero or move the deadline automatically. |
| Target has been reached or exceeded | Show completion and zero required pace, even if the deadline has passed. |
| Words are deleted after completion | Recalculate from the new total; the goal can become active or overdue again. |
| Target or deadline changes | Recalculate immediately without rewriting historical progress. |
| No goal exists | Show manuscript counts and an unobtrusive action to set a goal. |
Label this value Required daily pace: it is the average still needed across the remaining days and changes while the author writes. It is not a fixed daily quota. Show Today's net word change separately; do not present those two numbers as a frozen daily completion target.
Daily progress is net manuscript growth, not effort, time spent, or original words composed. Deletions can produce a negative value; pasted text counts toward it. A future import contributes to the manuscript total, with import-specific activity semantics decided before that feature ships. Undo follows the same net-count rules. Days with no changes display zero without requiring a background process. Attribute committed deltas to the save's local day; flush at day rollover where possible and document this convention.
Validate positive integer targets and real calendar dates. Scheduled writing weekdays, rest days, pause/resume, multiple concurrent goals, and effort-based statistics are deferred.
- Capture an immutable chapter snapshot after saving and a debounce, or when the author requests analysis.
- Segment the text and record language and segmenter version.
- Run selected analyzers on a bounded background queue. Pass the snapshot and required context through a small analyzer contract.
- Validate result structure, source ranges, and provenance before storing a complete run transactionally.
- Publish only results that still match the editor generation and committed source; cancel or discard obsolete work.
- Present optional underlines and an on-demand inspector with the passage, explanation, and dismiss/ignore controls. Keep detailed analysis quiet while drafting.
Failures must leave editing and saving available. Bound concurrency, CPU use, cached results, and snapshot retention. Starting analyzers work on full chapters; request broader context only for an actual cross-chapter feature. Derived storage should be rebuildable from current text plus versioned configuration. Never require a successful analysis run to open or export a manuscript.
| Stage | Features | Approach and completion evidence |
|---|---|---|
| Structural analysis | Paragraph/sentence/token inspection, sentence lengths, repeated words. | Deterministic measurements and versioned segmentation; accurate ranges and correct invalidation under edits. |
| Grammar and voice | Grammar/usage findings and active/passive classification. | Evaluate local rule-based or non-generative tagging/parsing tools. Display evidence and uncertainty; test dialogue and intentional fragments. Passive voice is a description, not automatically an error. |
| Thesaurus | Definitions, sense-grouped synonyms, part of speech, and deliberate replacement. | Select a licensed offline lexical dataset. Preserve its provenance and review inflection and context; never replace automatically. |
| Style analysis | Sentence-length distribution, repetition patterns, lexical variation, and change across an author's own drafts. | Combine documented descriptive metrics with locally executed classifiers where they improve measured usefulness. Avoid a single unsupported “writing quality” score. |
| Intelligent feedback | Prioritized, contextual observations with source evidence. | Use rule/model outputs and authored explanations. Offer bounded spelling, grammar, or dictionary substitutions only; no generated sentences or rewrites. |
Apple's Natural Language framework is a candidate for segmentation and linguistic tags. Core ML is a candidate runtime for non-generative models on the device. Neither choice establishes grammar or passive-voice quality by itself: compare candidates on a licensed evaluation corpus and record language coverage, errors, latency, model size, and data rights before committing.
Separate linguistic metadata from product feedback so improved analyzers do not require changing the editor's storage format. Version analyzer configuration and models, invalidate affected caches on upgrades, and avoid presenting results from incompatible model versions as comparable trends. Test upgrades and rollback with retained user preferences.
Steps:
- Create the macOS Xcode project and test targets; choose supported macOS, Xcode, Swift, and hardware versions based on the owner's Mac and the editor prototype.
- Build a disposable native-editor spike with DM Mono, light/dark appearance, native spelling, and Writing Tools disabled.
- Exercise a 50,000-word chapter and a fixture representing a 200,000-word novel. Test input methods, undo/redo, selection, paste, and candidate highlight APIs.
- Record the editor/TextKit configuration, SQLite approach, and local-library decision in short architecture decision records.
- Replace the README's setup placeholder with verified build, run, and test commands.
Exit criteria: the chosen native editor behaves correctly with representative text; performance measurements and toolchain choices are recorded; the project builds and tests from a clean checkout.
Depends on M0.
Steps:
- Implement the initial schema, migrations, database owner, and typed manuscript operations.
- Add novel creation/opening and the act/chapter outline, including rename, reorder, move, and guarded deletion.
- Implement shared word counting and transactional cached totals.
- Establish a backup/restore primitive before later features depend on the database.
- Document data ownership, storage paths, schema constraints, counting rules, and migration behavior.
Exit criteria: an organized novel survives relaunch unchanged; structural edits are atomic; migrations and backup restoration pass fixture-based tests; counts remain correct after moving or deleting content.
Depends on M1. Appearance work may develop alongside persistence once M0 is settled.
Steps:
- Integrate the native editor with revision-aware autosave, unsaved/error states, and chapter switching.
- Complete native editing commands, find within the current chapter, spelling controls, and correct per-chapter undo behavior.
- Implement DM Mono styling, appearance preferences, comfortable spacing, focus mode, and keyboard navigation.
- Add the plain-text export flow and visible backup/recovery actions.
- Perform accessibility, offline, long-session, failure-recovery, and performance checks.
Exit criteria: the author can write and revise for an extended session, switch chapters, quit, reopen, and export exact prose in order; failed saves preserve the in-memory buffer and expose recovery; spelling and appearance work in both themes.
Depends on M1 and the live-count/save path from M2.
Steps:
- Implement a pure goal calculator with an injected date/calendar context.
- Add goal creation/editing and the required-pace/progress display.
- Persist net daily progress with chapter changes and refresh at the relevant day boundary.
- Test all goal cases above, including missed days, due-today, overdue, deletion after completion, leap days, daylight-saving changes, time-zone changes, and relaunch after absence.
- Write the user guide for counting and goal semantics.
Exit criteria: every documented example has an automated assertion; live and reopened totals agree; missing days changes the pace automatically without background execution or manual adjustment.
Depends on M0–M3. This is the first release boundary; analysis is not a prerequisite.
Steps:
- Run the full writing/recovery/export journey on a clean install and an upgraded database.
- Fix data-loss, accessibility, editing, and performance issues before expanding scope.
- Verify backup rotation, restoration failures, malformed files, disk-full behavior, and application termination while a save is pending.
- Add macOS CI for build and tests, record performance baselines, and prepare signing, notarization, and a simple installable app build. Decide the distribution channel in a release decision record.
- Complete quick start, shortcuts, backup/recovery instructions, privacy statement, third-party notices, release notes, and a release checklist.
Exit criteria: all first-release scenarios pass offline on supported macOS versions; installation and an upgrade preserve writing; known limitations are documented; the author can use the app daily without another tool for basic manuscript safety.
Depends on M4.
Steps:
- Add the analysis snapshot, segment, run, finding, and feedback records through tested migrations.
- Implement the UTF-16 range contract, editor generation checks, scheduler, cancellation, and cache retention.
- Ship a small deterministic analyzer for sentence lengths and repeated words to exercise the full pipeline.
- Add optional highlights and an inspector with evidence, dismissal, and rule-level controls.
- Document the analyzer contract, provenance, stale-result rules, and a sample analyzer.
Exit criteria: edits during analysis never produce misplaced current highlights; clearing derived data preserves manuscripts and preferences; analysis failures or slow runs do not interrupt typing or saving.
Depends on M5. Deliver each capability separately rather than waiting for one large release.
Steps:
- Select and license local grammar/lexical resources; document language coverage and resource-update behavior.
- Add grammar/usage checks, active/passive voice evidence, and an offline thesaurus.
- Implement explicit, range-validated local corrections through the native undo system.
- Evaluate false positives on varied fiction, dialogue, fragments, dialect, names, and deliberate stylistic choices.
- Document each rule category and allow per-novel preferences and dismissals.
Exit criteria: findings explain their evidence; unsupported language or low-confidence cases are handled honestly; no automatic edits or generative rewriting occur; correction and undo preserve surrounding Unicode text.
Depends on M5 and evidence from M6.
Steps:
- Define specific writer questions, such as “where does sentence length become repetitive?” before selecting a model.
- Establish rights-cleared evaluation datasets and simple deterministic baselines.
- Evaluate non-generative local models, including Core ML where suitable, against those baselines.
- Add useful style measurements, source-linked trends, and authored contextual explanations incrementally.
- Document each model's purpose, training/evaluation provenance, language limitations, resource needs, versioning, and failure modes.
Exit criteria: each model improves a defined, measured task enough to justify its complexity; inference works offline within an explicit device budget; every observation links to evidence and respects the author's control.
Consider richer formats, scenes, manuscript-wide search, additional languages, and additional platforms only after actual use establishes priorities. For another platform, reuse data semantics and file-format documentation first; choose its UI separately. Do not prebuild portability layers, cloud infrastructure, or a marketplace.
| Area | Required evidence |
|---|---|
| Domain logic | Focused unit tests for counting, ordering, goal arithmetic, and date/time-zone boundaries. |
| Persistence | Temporary-database integration tests for transactions, constraints, retries, migrations from each released schema, backup/restore, and interrupted writes. |
| Editor | Native integration and manual checks for undo/redo, selection retention, spelling, IME/marked text, large paste, long chapters, and switching during save. |
| Recovery | Forced termination, disk-full/access failures, failed migrations, corrupted backup rejection, and recovery without overwriting the only good copy. |
| Analysis | Unicode span fixtures, repeated identical passages, sentence-boundary edits, stale results, cancellation, model upgrades, multi-span findings, and complete cache rebuilds. |
| Product quality | Keyboard-only and VoiceOver journeys, light/dark contrast, offline use, install/upgrade, and plaintext export comparison. |
| Language quality | Rights-cleared labeled examples with precision/recall or appropriate per-task metrics, false-positive review, and language/genre coverage. |
Initial performance budgets, to be measured and finalized in M0: p95 edit-to-display latency below 50 ms and p95 chapter switching below 250 ms on a recorded reference Mac with the representative fixtures. Measure cold open separately. Saving and analysis must avoid main-thread database or inference work. Report actual measurements rather than implying these targets have already been achieved.
Run checks appropriate to each milestone. Avoid tests that merely mirror UI implementation details; prioritize data integrity and observable writing behavior. Do not add another feature while a known manuscript-loss or corruption defect remains unresolved.
M0–M3 implementation and documentation now exist. The schedule below distinguishes implemented documentation from later release/analysis work; the user guide was brought forward to support the usable development build.
| Planned document | Milestone | Contents |
|---|---|---|
README.md |
M0 onward | Product scope, actual implementation status, supported platforms, and verified build/run/test instructions. |
docs/decisions/ |
M0 onward | Short records of consequential decisions: context, selected approach, alternatives considered, and consequences. |
docs/architecture.md |
M0–M2 | UI/domain/persistence boundaries, editor lifecycle, concurrency, and save flow. |
docs/data-model.md |
M1 onward | Schema, constraints, ordering, source-of-truth rules, revisions, migrations, backup format, and later analysis tables. |
docs/writing-goals.md |
M1–M3 | Word-count policy, goal formula, examples, progress semantics, and calendar behavior. |
docs/design.md |
M2 | DM Mono assets, semantic colors, layout, appearance, accessibility, and interaction states. |
docs/testing.md |
M0–M4 onward | Commands, fixtures, supported test matrix, failure simulations, reference hardware, and measured budgets. |
docs/user-guide.md |
M4 | Creating a novel, organizing chapters, spelling, goals, shortcuts, export, backup, and restoration. |
docs/privacy.md |
M4 | Local data location, diagnostics policy, retention, deletion/backups, and OS-service boundaries. |
docs/releasing.md |
M4 | Signing, notarization, distribution, migration checks, release checklist, and recovery from a failed update. |
THIRD_PARTY_NOTICES.md |
M0 onward | DM Mono license and later library, dictionary, corpus, and model attribution. |
CHANGELOG.md |
First usable build onward | User-visible changes, database migrations, and known limitations. |
docs/analysis.md |
M5 onward | Snapshot/range contracts, pipeline, analyzer API, versioning, preferences, and retention. |
docs/models/ |
M6–M7 | Resource licenses, evaluation methods/results, model documentation, and limits. |
Update the implementation, tests, and affected documentation together. Track milestone completion with evidence, and keep the README explicit about what has actually shipped.
- Create the Xcode app and test targets; record the toolchain and deployment baseline.
- Validate the native editor with DM Mono, spelling, both themes, realistic text, and generation disabled.
- Record the editor and storage decisions, then build the initial SQLite migration and persistence tests.
- Complete one vertical slice: create novel → create/open chapter → type → save → quit → reopen with identical text.
- Add act/chapter organization, recovery, and export around that slice.
- Implement the documented goal calculator and progress UI.
- Finish M4's release checks before starting advanced analysis.