Every update, in order

Branching for writers, without one word of git. On any Words document,

Rehearse opens a scratch copy beside the original and lets you wreck

it gloriously; Adopt brings back only what you keep, and Discard

leaves the original as if nothing had happened.

• Rehearse. On the Review tab, in the right-click menu, in the

palette and in F6's More: one click writes Essay (rehearsal).md

beside Essay.md and opens it in the other pane of the split, badged

as the rehearsal. It is an ordinary file, so every picture, wiki-link

and AI action works exactly as it does on the original. Press Rehearse

again and you are taken to the rehearsal already open; a rehearsal

cannot itself be rehearsed.

• Adopt, one change at a time. Adopt… paints the whole difference

onto the original in the marked-changes clothing you know from Talk

after and Recompose: a paragraph, heading, list or table replaced,

added or removed is one change, and a one-for-one paragraph shows the

words that moved. Click a change to drop it, click again to keep it;

the band counts what is kept. Adopt lands what you kept as ONE edit,

so one Ctrl+Z takes the whole adoption back, and the original's

history gains exactly one snapshot (Pre-adopt) for the entire

rehearsal. The scratch file then goes to the recycle bin.

• Discard. The scratch goes to the recycle bin and the original is

untouched, byte for byte. The dialogue says so before it acts.

• Nothing is lost quietly. Close the app mid-rehearsal and the next

time you open the original its band offers Resume or Discard; a

rehearsal that comes back with your session simply wears its badge

again.

• Words only, honestly. On Rich Words, Numbers, the Map and Diagrams

the door says why it stands down; Rich Words already carries tracked

changes, which is its own rehearsal.

The names (Rehearse · Adopt · Discard) are the seed's, provisional until

Andre rules the warm edge. The lexicon rows and the guide's chapter

arrive with the relay's close.

The panel's third plane opens. Type what you want in plain words and

the Concierge answers with one line and one door.

• Say it, and it happens. "Translate this to French" comes back as

one sentence and a gold door reading Run · Translate; Enter fires

it. Asking for a place opens the place. The Concierge can only name

things the app really declares, so it can never offer a door that

goes nowhere; when nothing fits, it says so honestly and shows the

nearest matches.

• Four guided journeys. Ask to be taken through it and the

Concierge walks with you, one step at a time — translate this and

share it; make a clean PDF and mail it; pin an action so it is one

key away; take this document to the other Room. Each step is stated,

done on your Yes, and skippable; a step that cannot run where you

are standing says why.

• Every stance, including none. The ask runs on your quick model

under whatever Privacy & Sovereignty stance you keep. With no model

set up at all, the Concierge matches your words to what the app can

do and tells you in one line that this is what it is doing. It is

never a dead end on a fresh machine.

• What travels, stated. Your sentence and the app's own list of

actions go to your chosen model, under your stance. The document

does not travel with them. The guide and the Control Room page both

say so.

• The guide's new chapter. Help ▸ User Guide gains the F6 chapter,

where the Concierge introduces itself and states plainly what it

does not yet do.

This closes the F6 relay: one quiet key that acts on whatever is

selected, asks what you want on an empty morning, keeps your own

actions a letter away, and answers in plain words when you would

rather just say it.

The panel that arrived in 0.135.0 gains its other two working planes.

• Reception. Press F6 on an empty morning and Markelangelo asks

what you want to do: write a document, write something to hand over,

work some numbers, map an idea — each with one honest line about

what you get — plus "Continue" with your most recent document when

there is one. Two keystrokes take you from a blank shell to writing.

"Something else…" opens the full New-document chooser.

• Mine. The second plane is your quick-action chip row, whole: the

same pinned prompts and actions, read from the same list, so the two

views can never disagree. The panel widens, your own words wrap

rather than truncate, and each pin can carry a letter.

• Letters are yours. Assign a letter to a pin and F6-letter-Enter

fires it from anywhere — any plane, any Room the pin applies to.

Lens letters keep their meaning; the Control Room warns you at the

moment you create a clash, rather than silently repointing a key.

• The Control Room page. Settings gains "The F6 panel": for each

kind of selection, choose and order the verbs the panel offers, from

the app's declared truth only; assign letters; restore defaults per

kind. Restoring keeps you on the app's shipped list as it improves,

rather than freezing today's list into your file.

• The chip tooltips now show a pin's letter, and holding a chord key

anywhere no longer repeats the action.

Nothing here invents a menu: every row the panel shows, on every

plane, projects a declaration that already exists somewhere else in

the app.

The key the product is named after now exists. Press F6 with

something selected — a sentence, a range of cells, a picture, a node

on a Map — and a small panel appears beside it with the few verbs that

matter for that thing, each with a letter. Press the letter, press

Enter, and it is done. Release with Esc (or F6 again, or a click back

into the page) and the panel vanishes without disturbing a character.

• One gesture, every Room. The same press does the right things on

Words, Rich Words, Numbers and the Map. Nothing selected is a

selection too: it means now, and the panel offers the document's

own verbs (Save, Share, Print, Survey…).

• Six plus More, always. At most six verbs, chosen from what can

actually run here; More opens everything else this surface

offers, with the reason shown wherever something cannot run. Where

fewer than six verbs exist, you see what exists — the panel never

pads.

• The one box. The panel greets you with a box. Type a verb's

letter and it surfaces as the top hit — F6, letter, Enter is the

whole gesture. Keep typing and it becomes a sentence for the

Concierge, who arrives with a later release and says so honestly in

the meantime.

• Projected, never listed. The panel reads the same declarations

every menu and the palette read. It owns no list of its own, so it

can never drift from the truth.

• Mine and the Concierge are next. Their tabs are already on the

panel; each opens one honest sentence until its release. The

command palette keeps its job (search everything); F6's job is

relevant now.

Under the hood: the F6 key was first measured free on every surface in

the built app (the probe and its report are in the repo); the panel

claims it in the window's capture phase, the same route Zen's F9 has

always used, so it works with the caret inside the Word page and the

Numbers grid alike. Holding the key no longer means thirty presses

anywhere: chords now act once per press.

The register's name is settled: Sign & Mark, confirmed by the

owner. The provisional notes come off the vocabulary, the parity map

and the User Guide; nothing else changes, because the register was

built under this name from the start.

The marks a person makes on a document, especially at the moment it

leaves, now have their register. Its name is provisional and on the

owner's desk; everything under it is built.

• Sign. Draw your signature once and Markelangelo keeps it, on this

machine only, never synced, a picture of your signature rather than a

cryptographic one, and the dialog says exactly that. **Insert

signature** places it in whatever you are writing: an ordinary

picture in a markdown note, a real Word picture in a Word document.

Because it is a picture, it survives every exit — PDF, Word, HTML,

Rich Switch, Share. Draw again or remove it from Settings.

• Mark. The Word ribbon's Draw tab is now Sign & Mark: the pen

and highlighter strokes anchor to the paragraph beside them and ride

in the file as pictures any copy of Word can see.

• No mark vanishes on paper any more. The research pass measured a

lying door: strokes survived a plain document's PDF and silently

vanished from any document with a header, footer or mixed paper,

because that route rebuilds the pages and left the ink layer behind.

The pages now carry their ink on every route, fixture-proven.

Sign, then Share: a signed PDF handed to your mail app is two clicks

from either writing Room.

The Sign and Mark research pass measured the Share door's artefacts and

found a real defect: a multi-page Word document shared as PDF arrived as

a single page, everything past the first sheet gone. The print

stylesheet unfolded the document pane but not the pane wrappers and the

window shell around it, so the print clipped at one viewport.

Fixed at root, both branches:

• the whole height chain now unfolds when a Word document prints, so

every page reaches the PDF (a five-page document measured five-plus

pages; the torture document nine);

• Share's PDF now leaves by the same fork the app's own export door

uses, so a document with headers, footers or mixed paper takes the

paginated route and keeps its furniture on every page, instead of the

direct route that printed it once.

A standing fixture now counts the pages of a shared multi-page PDF, so

this cannot quietly return.

Documents now leave well. File ▸ Share (also on the ribbon's File

pill, the tab's right-click menu and the palette) opens one door on

every document: pick the form, pick the channel, and the document is on

its way, in a shape the recipient can actually open, with nothing

riding along that you did not choose.

• The forms are self-contained by default. A markdown note offers

PDF, Word, HTML with its pictures inlined, or the source as a

Bundle: one .zip of the document, its assets folder and, if you

tick it, its comments. A Word document offers itself or a PDF. A

workbook offers itself, a PDF or HTML, riding the same print layout

the Numbers Room already trusts.

• The channels are honest. Send to Mail opens your own mail app's

compose window with the file attached and never presses Send: the

sentence is "Handed to your mail app". Where no desktop mail app is

set up, the door says so and points at the one that always works:

Copy the file, which puts the file itself on the clipboard to

paste anywhere, including web mail. Reveal in Folder and Copy as

HTML are always there beside them.

• The leak guard. Before anything leaves, the What travels

panel states what the chosen form carries (tracked changes ride

inside a shared .docx), what it does not (a PDF carries no

frontmatter), and what stays behind on this machine: your AI

comments live beside the document and never travel, and now you are

told. Clean copy takes the named notes out where the form can be

cleaned, item by item, never silently; where it cannot be cleaned

here, the panel says what to do instead.

• No accounts, no share links, no cloud in the middle: the file goes

person to person by your own channels. Your machine, your business,

most of all at the exit door.

The export dialog remains the formatting room; Share is the leaving

room, and each points at the other. Shared renders always leave in the

light dress, whatever theme you write in: the Export dialog is where

you choose otherwise.

The close of the Numbers export-parity wave (NE2). All three rooms now

offer the same export doors from the same File menu.

• File ▸ Export as HTML works on a workbook. The dialogue asks a

workbook the two things it can answer, a title and what to export

(Selection · This sheet · Whole workbook), and writes one

self-contained HTML file of real styled tables: values exactly as

the grid shows them, number formats applied, fonts, colours, fills,

borders, alignment and merges carried, charts inline as pictures,

each sheet under its own heading. The paper furniture (running

headers, page bands) stays on paper, where it belongs.

• Copy as HTML works on a workbook. One click copies the selection

(or the active sheet) as a table that pastes into Word, Outlook and

mail looking exactly as it exports, with a plain tab-separated

fallback for plain editors. Measured, not promised: the pasted

table renders identical to the exported file.

• The parity story is written down. The User Guide's Numbers

chapter now carries the three-room export table, including the one

deliberate absence: a workbook exported to Excel is File ▸ Save As,

so there is no separate Export as Word door to mislead you.

• The last "arrives with a later wave" grey is retired. Every export

door a workbook shows is real.

First thing to try: open a workbook, export it as PDF and as HTML from

the same File menu the other rooms use, then copy a range and paste it

into an email: it arrives as a real table.

The first piece of the Numbers export-parity wave (NE1). Consistency

is king: a workbook now carries the same Export as PDF door the Words

and Rich Words rooms have, on the File menu, the File pill and the

command palette.

• File ▸ Export as PDF works on a workbook. The door opens the

familiar print view wearing its PDF face: the same live page

preview, the same honest scope chooser (Selection · This sheet ·

Whole workbook), the workbook's own saved page setup read out, and

one action at the foot: Save as PDF.

• The PDF is the print truth. Export renders exactly what Print

renders: the same pagination, the same page breaks and print areas,

each sheet of a whole-workbook job on its own paper, charts and

pictures composed in. There is one layout engine and both doors use

it, so the preview cannot lie and the two routes cannot drift.

• The old grey excuse ("a workbook's own export routes arrive with a

later wave") is retired from this door. Export as HTML and Copy as

HTML follow in the next piece of the wave.

First thing to try: open a workbook with a few sheets, File ▸ Export

as PDF, pick Whole workbook, and compare it with what Print shows:

they are the same pages.

The final piece of the Diagrams relay (DG4). Two new AI verbs, on the

same engine, keys and privacy stances as everything else:

• Describe a diagram. Select a passage and ask, and the selection

becomes a diagram; or ask with nothing selected and a small form

takes your description (and, if you like, the diagram type). The

result arrives in the AI panel for you to insert — nothing is ever

written silently.

• Fix this diagram. The door sits right on the error card under a

diagram that will not draw. The model is given the source and the

real error, in both plain English and the engine's own words, and

the mended source lands back on the fence as a reviewable change.

• Every candidate is checked before you see it. The app parses and

test-draws what the model wrote; a broken answer goes back once with

the error, automatically. The panel then tells the truth: "this

diagram draws", "the first answer did not draw, this is the second",

or "this still does not draw" with the reason.

• Both verbs respect your Privacy and Sovereignty stance, work with a

local model, and show the stopped door rather than sending anything

a stance does not serve.

The relay also closes its books in this release: the User Guide gains

its Diagrams chapter (including the honest limitation: the engine

places nodes itself, and wide flowcharts can outgrow a page), and the

cross-surface parity map records diagrams as a Words-world capability

with the Word surface receiving the picture on export.

First thing to try: put a flowchart in a note, export it as PDF and as

Word and see a real diagram in both, then break the Mermaid on purpose

and let Fix mend it.

The third piece of the Diagrams relay (DG3). A ```mermaid fence stops

being a plain-text box:

• Mistakes are explained, on the right line, as you type. Break a

diagram and a plain sentence appears where the trouble is ("Line 2: a

shape opened here is never closed. Check the brackets around the

label."), with the engine's own detail kept underneath for those who

want it. The checker parses AND test-draws, because some mistakes

parse cleanly and still cannot draw.

• Diagram source is coloured — keywords, arrows, strings and

comments, aware of which diagram type you are writing. It is the

first code fence the editor has ever coloured.

• Completion offers the words that fit the diagram type you are in.
• Insert ▸ Diagram starts one in one act: a starter for each of the

thirteen stable types, and the newer experimental types behind a

Preview types disclosure. The slash menu carries the same door.

• Big diagrams pan and zoom in place — Ctrl+wheel to zoom about the

cursor, drag to pan, one Fit chip to come home.

• Experimental types wear a Preview badge on their preview: a small

chip that opens into one honest sentence about upstream syntax still

changing.

Under the bonnet: the diagram engine's official parser joins the tree

(the same copy the engine itself uses, enforced), and the CodeMirror

pieces the assistance is built on are pinned to the exact versions the

editor already carried.

First thing to try: type ```mermaid, pick a starter from Insert ▸

Diagram, then break a bracket on purpose and watch the explanation

arrive on the right line.

The second piece of the Diagrams relay (DG2), and this one you can see.

• Diagrams in ordinary notes now wear the app's own colours. A

document with no Look used to draw its diagrams in Mermaid's stock

lavender, whatever theme you were in. Every diagram now takes the

house dress: the same token mapping the Style Studio's Looks use,

resolved against whichever theme is live, so a flowchart on Midnight

is a Midnight flowchart. A document that wears a Look is untouched;

it was already dressed.

• Gantt and quadrant charts join the themed family. Both types

previously leaked Mermaid's built-in colours (a red today-line, grey

done bars, four near-identical quadrant fills). They now draw from

the same palette as everything else: sections alternate the wash and

the paper, and the one accent carries the active bar, the critical

bar and the today line.

• User journey diagrams stand down honestly. The upstream renderer

hardcodes its colours in its drawing code, so no theme can reach

them. They render as before; the limitation is recorded rather than

papered over.

• The theming map (which engine variable takes which house value, and

why) is recorded with the Diagram corpus, and the golden-file suite

was re-cut for the new dress.

First thing to try: open any note with a ```mermaid flowchart in it,

then switch themes and watch the diagram follow.

The first piece of the Diagrams relay (DG1). Honest framing first: the

headline behaviour — a Mermaid diagram exporting as a real drawing, not

source code — already ships; it landed with the F6 sweep's export work

and the Mind Map relay's vector door into Word. What 0.127.0 adds is

everything that keeps that guarantee true:

• The diagram engine is pinned exactly (Mermaid 11.15.0, previously

a floating range). Half of Mermaid's diagram catalogue is flagged

experimental upstream and syntax can change between minor versions; a

floating range meant a fresh install could quietly get a different

engine than the one we tested.

• A golden-file render suite now guards the pin: one fixture per

stable diagram type, rendered by the real app and compared

structurally (element census, label census, canvas size) against

committed signatures. A future engine upgrade becomes a reviewed diff

instead of a leap of faith.

• The Diagrams vocabulary enters the product lexicon (Diagrams ·

Diagram · Diagram source · Preview type), ahead of the authoring

surface and AI pieces that will speak it.

• Evidence for the whole export path (editor preview, HTML, PDF, Word)

captured and committed with the relay's records.

Nothing user-visible changes in this release; it is the foundation the

next Diagrams pieces stand on.

The Cartographer's fourth piece, and the relay's close. The survey

pass grows a second door: inside a Project Room it can now read the

project's shelf as one corpus and offer the ways the whole body of

work could be taken apart.

Survey the shelf

On the room's masthead, beside Plan it with me: choose the whole

project or one shelf, and the survey reads every document it is

allowed to read, in shelf order, under the briefcase's own rules.

Documents you have not adopted are named and never opened; a workbook,

a map or a picture in scope is counted out loud rather than silently

skipped, and the scope line says how far down the shelf the reading

ceiling reached. Every sample names the document it came out of, and

tapping it opens that document on the flashed passage, even if it was

not open before.

One map from a corpus

Make the map lands a single Map as a Draft card on the project's

board, through the room's own never-overwrite channel. Every node's

mini-doc threads back to its own source document: Go to the passage

crosses documents exactly as it does within one.

Ceilings, stated

Recompose does not run on a corpus map: composing a new version of

five documents at once is the Binder's work, and the greyed door says

so rather than pretending. Coverage you can see on the map (an

argument node with no thread to the shelf as a visible gap) stays on

the roadmap; the per-node source threads shipped here are the ground

it will stand on. The whole feature runs on any stance, Totally Local

included.

The relay closed

The in-app User Guide gains its Cartographer chapter (Help ▸ User

Guide § 9c), and the acceptance sheet walking the seed's four recorded

rules against what shipped is docs/kickoffs/CARTOGRAPHER-ACCEPTANCE.md.

The Cartographer's third piece, and the way back. Drag the map's

argument into a better order, press Recompose, and a new version

of the document is composed in that order: your passages carried word

for word, the AI writing only the joins the restructure created.

Recompose

The door sits on the Map ribbon's AI tab, offered on any map the

Cartographer read out of a document (on any other map it greys and

says why). The model is never shown your document — only the edges of

each seam the new order broke, so it cannot rewrite a passage it was

never given. A seam that still flows from the source order asks for

nothing at all; a map that never broke one composes without spending

a run.

A version nobody has written yet

The result opens as an unsaved draft: every AI-written join painted

so it cannot be missed, and a banner counting what happened

("12 passages carried verbatim · 4 joins written"), counted from the

composition itself, never claimed by the model. Two doors: Adopt

writes Essay v2.md beside the original (taken numbers climb, nothing

is ever overwritten) with the run's provenance in its frontmatter;

Discard closes the draft, and nothing was ever on disk. The

original is untouched by construction: no code path in the act opens

it for writing.

Honest at the edges

A join the model never answered arrives as a plain paragraph break,

not an invention. A passage whose source sentence has been rewritten

since decomposition is carried from the map and counted as such in

the banner. A map beyond 120 nodes is a corpus, not an essay, and the

door says so before a pass is spent. The whole walk runs on any

stance, Totally Local included.

The Cartographer's second piece. The survey's offer now leads

somewhere: pick an axis and the document is decomposed into a real

Map, born as a sibling file, the original untouched.

Make the map

Every axis in the Survey panel now carries a live Make the map

door. Press it and a second pass extracts every element of that axis

with its hierarchy; a progress line counts them as they arrive, with

Stop beside it. On completion the map lands as a sibling markdown

file (Essay.md gets Essay Map.md, a taken name is numbered, never

overwritten) and opens as a Map tab. Cancel writes nothing at all.

Every node carries its mini-doc

Click a node and the Node panel shows its Mini-doc: the passage

that earned the node, carried word for word, a notes area of your

own, and Go to the passage, which lands you on the sentence in

the source document, flashed. A node whose passage the AI could not

quote verbatim still lands as its reading of the document, but

carries no thread, because a pointer at a sentence nobody wrote is

worse than none.

An ordinary Map, on purpose

The decomposed map is not a special object. Drag branches into a new

order, fold, find, Expand a thin node with the Map's own AI (Ghosts

and all), flatten it back to an outline: everything the Map Room does

works here, and one undo behaves as it always has. The whole walk

runs on any stance, Totally Local included.

The first piece of the Cartographer, the semantic door between a

document and a Map. Before anything is decomposed, the AI reads the

document once and makes you an offer.

The survey

Press Survey on the AI tab, in the Writing Room or the Document

Room. A Survey panel opens on the Desk and fills, live, with the

semantic axes this document actually contains: arguments and their

evidence, the people in it, the questions it raises, whatever this

text earned. Each axis carries its count, and one wears

Recommended.

Samples you can stand on

Unfold an axis and its samples appear: a short label with the passage

that earned it. Tap a sample and the document scrolls to that passage

and flashes it. A quote the document does not contain word for word is

never given a place: the sample says it could not be placed, and it

does not navigate. The chooser is where a false pattern dies, and it

can only do that job if what it shows is true.

Honest at every door

A survey refuses politely before spending anything: too little text,

no document, a workbook or a Map (cells and nodes are not passages).

A pass the parser could not read says so, which is a different answer

from a document with nothing to offer. The whole feature runs on any

stance, Totally Local included, and each axis's Make the map door

states plainly that decomposition arrives with the next piece.

The fifth and final piece of the Numbers Wave. With it, every

arrives-later sentence in the workbook Print dialogue is gone, because

each thing arrived.

Print what you mean

The dialogue's "Print what" now offers three honest scopes.

Selection prints just the range you have selected, as a one-off

that leaves your saved print area alone. This sheet is unchanged.

Whole workbook finally enables: the job walks every visible sheet

in tab order, each on its own saved paper, orientation, margins,

titles and breaks — a portrait sheet and a landscape sheet keep their

own shapes in one PDF — and the dialogue states the size of the job:

"11 pages across 3 sheets".

Page numbers that count

A header or footer asking for "Page &P of &N" now gets real numbers,

counted across the whole job the way Excel counts a multi-sheet print.

Date, time, file and sheet-name codes were already real and still are.

Fitting that fits

"Fit to one page tall" now genuinely shrinks a long sheet to one page,

by Excel's rule: both axes propose a scale, the smaller wins, and

fitting never scales up.

Large workbooks print instead of being refused

The old 50,000-cell refusal predated the new page layout, so it was

re-measured rather than trusted: 100,000 cells lay out in under four

seconds. The cap is now 200,000 cells and the refusal names its true

reason, time, and the way out (a smaller print area). Better still,

the measurement found that very large workbooks, which stream in

rather than loading whole, were refused outright no matter their

size — printing now waits for the load instead of turning you away.

Still stated, because still true

A whole-workbook job composes charts only for the sheet on screen (a

chart is captured from the live grid, which draws one sheet at a

time); the dialogue counts what it left off. Charts anchored outside

the printed area stay off the page, as in Excel.

This closes the Numbers Wave (v0.118.0 to v0.122.0): Form Mode, Create

from Selection, Protect sheet, Breaks and Page Layout, and print

parity. The full story is in each release note and the ledger.

The fourth piece of the Numbers Wave. "My table split across two pages"

is the oldest spreadsheet complaint there is; the Numbers Room now has

the whole answer.

See where the pages fall

View ▸ Page break preview draws the page edges over your live grid:

dashed where the paper forces a break, solid where you placed one. A

chip on the tab row names the paper the lines were drawn for (and is

the way to put them away). The lines are computed from the same

pagination the print uses, so what you see is what the paper does, and

an orientation change moves them where it moves the print.

Say where a page ends

Page Layout ▸ Breaks: Insert page break (above the selected row, or

left of the selected column), Remove page break, Reset all page breaks.

Breaks are kept in the file exactly where Excel keeps them, so Excel

prints the same pages, and a workbook Excel broke up arrives here with

its breaks drawn and honoured. The print dialogue's old caveat that

breaks were "preserved but not applied" is gone, because it stopped

being true.

Wide sheets stop losing columns

Found on the way: printing paginates downwards and silently clipped

whatever ran off the paper's right edge, so a wide sheet was losing its

right-hand columns without a word. A sheet wider than the paper now

continues onto further pages, splitting at the paper's edge and at your

column breaks, with your repeated heading columns down the left of

every continuation page. Repeated print titles grew from rows-only to

rows and columns in the print dialogue. The too-wide notice now says

the sheet continues, and still offers fit-to-width as the one-click

alternative.

A sheet that fits on one page with no breaks prints byte-for-byte as it

did before this release.

The third piece of the Numbers Wave, and the one bound by an honesty

rule before a line was written: protection stops mistakes, and no

surface may imply it does more.

Protect a sheet, and mean it

Review ▸ Protect sheet (or the palette): a dialog whose first line is

the whole promise — "This stops accidental changes. It does not make

the file secret, and it will not stop someone determined." Protect,

and nothing can be typed into that sheet and no AI edit can land on

it, while reading, selecting and copying stay as they were. A

Protected chip appears on the band's tab row and is the door out.

A refused keystroke gets a short honest notice naming the way back;

the AI is refused in the same voice before anything is sent; Form

Mode's door stands down. The protection is written into the file, so

Excel honours it too.

The door that was lying, closed

The measurement pass found the real defect: the vendored Review tab

had carried a Protect Sheet button since the transplant that recorded

protection into the file while the grid went on accepting every

keystroke and every AI edit. Worse, a workbook someone protected in

Excel arrived here unprotected on screen, and an AI edit could land on

it. Both halves now move together, whichever door asks: protecting

sets the engine and the file in one act, and a file's saved protection

seeds the engine the moment the workbook opens.

The ceilings, stated where you meet them

Three things are deliberately not offered, and the dialog itself says

so rather than pretending:

• Passwords are not set here. The embedded engine has no password

concept, and a password field that cannot be proven into the file

and back does not ship. A sheet Excel protected with a password

still arrives protected; its Unprotect door says plainly that

Markelangelo cannot take that one off, and to do it in Excel.

• Protect workbook (structure) is not offered. Measured: the

engine does not enforce blocking sheet add, delete or rename, and a

button that protects nothing is exactly the kind of control this

product removed once already.

• **Excel's unlocked-cells-on-a-protected-sheet convention is not

honoured.** Protection here is the whole sheet. Cell lock flags in

the file are preserved untouched for Excel's benefit, and the dialog

says they are not what is being enforced.

The second piece of the Numbers Wave. A formula that says =SUM(B2:B13)

teaches nothing and breaks when a row is inserted. The workbook already

knows what B2:B13 is, because you labelled it.

Names from your own headings, in one act

Select a block with its headings and choose Create from Selection

(Formulas ▸ Defined Names, or Ctrl+Shift+F3, Excel's own chord, or the

palette). A dialog guesses where your labels are — top row, left column,

or both — and says exactly what it will make before it makes it: every

name against its range, an adjusted spelling shown adjusted ("Q1

Revenue" cannot be a name, so it becomes Q1_Revenue), an unlabelled

column named as skipped. Create, and every column becomes a name

covering its own data.

From then on =SUM(Q1_Revenue) says what it means, survives rows being

inserted, and reads back as English — which also makes an AI-suggested

formula something you can check at a glance rather than take on faith.

The Name Manager lists everything that was made; one Ctrl+Z takes the

whole act back; and the names are written into the file itself, so

Excel sees them too.

Run it again on the same block and the collision is stated plainly:

existing names are kept unless you tick Replace, and if every name

already exists the Create button says why it has nothing to do rather

than pretending otherwise. Copying a named block into a Word document

as a linked range now remembers the name, which survives edits an

address cannot.

Also recorded in the parity map on the way: turning a selection into a

real Excel table already ships as Insert ▸ Table, so no second door was

added for it.

The first piece of the Numbers Wave. People keep lists, and entering the

fiftieth record through a grid means arrowing across columns, losing your

row, and typing into the wrong cell. Form Mode shows one record at a time.

Form Mode, on the Desk beside its grid

Open a workbook with a list in it and click Form Mode on the Data tab

(or run it from the palette, or press Ctrl+Alt+F). The Desk opens a form

of one record: the column headings become field labels, Previous and Next

walk the records, and "Record 2 of 5" tells you where you are. The grid

stays visible beside the form, so every save is seen landing.

The fields are dressed by the workbook's own data validation, so the

grid, the form and Excel all enforce the same rules: a column with a

dropdown rule is a dropdown carrying its choices, a date rule gives a

date field, a number rule a number field. A formula column is shown as

Worked out and never written; the form does not invent formulas.

Entry is keyboard-first, built for the person entering fifty records,

not five: Enter moves field to field, Enter on the last field (or

Ctrl+Enter anywhere) saves, and after adding a record the form clears

ready for the next. A counter states how many records you entered this

session. Saving a record, adding one and deleting one are each one undo

step.

It is not a database, and it says so in its own footer: no queries, no

relations, no second file format. The data is ordinary cells in an

ordinary workbook any tool can read, and sorting and filtering remain

the grid's job. On a sheet with no list to serve, neither door is

offered.

Undo for row changes, repaired at the root

Found on the way, measured before designing around it: inserting or

removing a row in the Numbers Room could not be taken back. The row

removal was never missing from the undo stack; it was buried under it.

After a row change the spreadsheet loader refetches the visible area

from the file, and every one of those "put the file back on screen"

writes was pushing an undo entry of its own. On a real workbook the

deleted row came back on the fifth Ctrl+Z, and the four presses before

it scrambled the totals on the way, so undo was quietly corrupting the

grid.

Fixed where it belongs: the loader's own writes no longer enter the

undo stack at all, exactly as they already stayed out of the save

journal. Deleting a row and pressing Ctrl+Z once now restores it whole,

and the save writes the original workbook back, proven against the

saved file rather than the screen. A side benefit: scrolling a large

streaming workbook no longer fills the undo stack with junk.

One known edge remains and is recorded: on a streamed workbook, a

restored row's formula cell can show blank on screen until the workbook

is saved and reopened; the file itself is written correctly.

Nothing in the app changes in this release. The change is to the Journey

Suite, the third testing tier that walks the app the way a person does.

The suite now knows a right refusal when it sees one

Under a locked privacy stance with no served writing model, asking the AI

to do anything is rightly refused before a single token leaves the

machine: the stopped door opens, says the honest sentence ("Under your EU

Only stance, that model is not served for writing. Nothing was sent.")

and offers the repair. The journey suite's gate helper only knew the

older consent dialog, so it waited for an answer that was rightly never

sent and filed four broken-behaviour findings against an app that was

behaving exactly as designed.

The suite has been taught. The gate helper recognises both dialogs; a

refusal is asserted as green behaviour (the dialog appeared, said the

honest sentence, and nothing landed in the document); and the journeys

whose whole subject needs a live run record a plain observation and end

whole. On a profile whose stance serves the model, nothing about the

journeys changes.

Measured on the real EU Only profile: the smoke tier walks 13 of 13

journeys with zero blocked and zero broken findings.

The small booked debts from the Project Room relay, each closed at root.

Every date now follows the app's language

Six surfaces were formatting dates by the machine's locale rather than the

app's: the History panel's timestamps, the Recents list, a tab's recent-files

menu, the relative-time labels, and two corners of the model management pages.

All of them now go through one shared helper that asks the app which language

it is speaking, so switching the interface language switches every date with

it. Token counts in the Flows run dialog follow the same rule. A lint test now

scans the source for machine-locale formatting, so a seventh surface cannot

slip in.

The board says where a dragged shelf will land

Dragging a shelf across the Project Room board now shows a slim gold bar in

the gutter where the shelf will come to rest: to the right of the column under

the pointer when dragging right, to the left when dragging left. Dropping a

card still outlines its target column, so the two drags read differently. The

spine menu's Move left and Move right stay as the precise path.

The lock says what it is

The lock is the Project Room's own discipline, and it now says so: the Lock

button's tooltip reads "Locked in this room only. The file itself is untouched

and still opens anywhere else", and the card sheet's closing paragraph says

the same in full. Nothing about the lock's behaviour changed; only its

honesty.

A comments file is called what it is

A document's comments sidecar (<name>.comments.json) used to stand on the

ladder as a generic "reference · locked". It now reads "comments · held", and

its card explains: Markelangelo writes it beside the document; it is history,

not machinery. It keeps its place in the locked group, because it is locked by

nature.

Housekeeping

A retired View-menu popover that had been dead code since the ribbon

normalisation is deleted, along with its ten orphaned catalogue strings; the

tooltip-nesting trap it carried is now banned by the same lint test.

The Home folder (v0.114.0) now reaches everyone. New projects nest

inside it, and anyone who was already using Markelangelo before Home

existed is told about it exactly once.

What you will see

• Projects live inside Home. On a fresh install with a Home

folder set, new projects are made in a Projects folder inside it.

If you already have a Markelangelo Projects folder in Documents,

nothing changes: your projects stay where they are and new ones

keep landing there. A Projects root you chose yourself always wins

and is never moved.

• A one-time welcome-back. If your profile predates the Home

folder, your first launch after this update shows one banner:

Markelangelo can now keep your work in one Home folder. Use the

folder you are already working in, choose another, or press Not

now. Whatever you answer, you are never asked again, and Settings ▸

Home folder remains the door. Dismissing changes nothing at all.

• Copy that tells the new truth. The welcome tour's workspace

card and the user guide now say where work lives by default, and

say just as plainly that any folder anywhere still opens exactly as

it always did.

A default root, never a boundary: nothing in this release refuses,

warns about or gates a file for living outside Home.

The relay closes

This is the second and final piece of the Home Folder relay

(v0.114.0 to v0.115.0). The full record: the ledger in

docs/BUILD-QUEUE.md §K and the OPEN FOR ANDRE block at the top of

UI Review/IMPLEMENTATION-LOG.md (I-126 to I-128).

Your work now has a Home. On a first run the welcome tour opens with

one question before anything else: where should your work live? It

offers Documents\Markelangelo, you accept it or choose your own

folder, and the Library lands there while the tour is still open.

From then on, "everything you make in Markelangelo lives in your Home

folder unless you say otherwise" is a true sentence.

A default root, never a boundary: Home is where things go when you do

not say otherwise. Files anywhere else on your disk open exactly as

they always did, any folder can still be opened or promoted, and

nothing anywhere refuses a file for living outside Home.

What you will see

• The tour asks first. The Home folder offer is the first block of

the welcome tour, above the sovereignty stances: the address, then

the promise about where your words may go.

• Settings declares the address. A new Home folder section in

Settings (above Projects) shows where Home is and lets it move.

Moving re-points where new work goes; nothing already on your disk

is moved or copied, and the section says so.

• The Library has a floor. On a fresh profile, or whenever the

remembered workspace is gone (a deleted folder, a lost session),

the Library opens at Home instead of at nothing. A Library you

deliberately closed stays closed; Home is a floor, not a nag.

• Open Folder starts at Home. The folder picker begins at your

Home folder once one is set.

• The user guide gains a short Home passage stating the promise

and the non-wall.

For the toolchain rather than the user: the test-harness window now

opens on a display away from the one holding the mouse pointer, so a

running suite no longer flashes over the screen being worked on

(MK_TEST_DISPLAY pins a display for deterministic captures).

This is piece H1 of the Home Folder relay

(docs/kickoffs/HOME-FOLDER-RELAY.md; ledger docs/BUILD-QUEUE.md

§K). H2 follows: the Projects root nesting inside Home for fresh

installs, and a one-time welcome-back offer for existing users.

The sovereignty watcher no longer stands on one aggregator's word.

Requesty publishes per-model sovereignty metadata OpenRouter does not

serve — retention as a figure in DAYS, whether data trains, where the

route sits — from a public endpoint that needs no key. It now feeds

the watcher as a second witness: never gospel, never mixed into a

ruled definition, and never something the app waits on.

What you will see

• "Two sources" on corroborated rows. Under Zero Data Retention

and No Training, a model whose Requesty twin agrees with the

stance's own claim wears it on the chip: the curated list stands on

two published sources rather than one. A model the second witness

has nothing to say about reads exactly as before.

• Differences put in front of you, as differences. Where

Requesty describes its own route to a model's provider differently

— thirty-day retention where the stance's endpoint is

zero-retention, say — the watcher's log gains an "a second witness

differs" line naming the days. The wording is deliberate: it is a

different pipe, not a contradiction of OpenRouter's endpoint, and

the second witness informs the list without ever redefining it.

At most eight lines per refresh, then one summary.

• Nothing depends on Requesty. A failed fetch leaves the last

view standing; with the witness absent the app behaves exactly as

the single-witness app did.

By the shipped data: of the models Zero Data Retention serves, 74

have a twin the conservative matcher trusts, 43 agree, 31 differ —

so expect a first crop of difference lines on the first refresh.

That is the feature working: the retention-in-days figure is

exactly the food OpenRouter does not serve.

The relay closes

This is the fourth and final piece of the Voice Seat & Aggregator

Bench relay (v0.110.0 to v0.113.0). The full record: the ledger in

docs/BUILD-QUEUE.md §J and the OPEN FOR ANDRE block at the top of

UI Review/IMPLEMENTATION-LOG.md.

Two gateways many people already hold accounts with become one-press

provider setups, and the bench's open claims are pinned to what could

actually be verified.

What you will see

• Settings ▸ Keys & connections ▸ Add provider now quick-sets four

endpoints: Ollama and LM Studio as before, plus Hugging Face

(router.huggingface.co) and Requesty (router.requesty.ai).

One press fills the name and the URL; add your key and its models

join My Custom like any other row.

• Requesty's EU data-residency endpoint is one press away: choose

the Requesty preset and a line offers the swap to

router.eu.requesty.ai — requests route through their Frankfurt

gateway to EU-region deployments and, by their policy, nothing is

stored. Said the honest way: their claim, under their terms, and

the EU Only stance still reads provider headquarters. A gateway hop

that itself stays in the EU informs that stance; it never redefines

it.

What was verified, and what stays open

• Hugging Face's Inference Providers do serve Whisper-class

transcription (whisper-large-v3 across five providers), and their

terms speak plainly of production workloads with no markup on

provider prices. Whether their OpenAI-style transcription route

works in our dictation path needs a real HF token, which this

machine does not hold — the one-command probe is booked in the

bench file.

• Requesty's transcription claim (their blog says whisper-1 works

through the OpenAI SDK; their models list carries no audio model)

likewise awaits a real key. Nothing in the app claims either

gateway dictates; the Voice seat's rows are exactly v0.110.0's.

The bench record: Sovereignty Audit/05-AGGREGATORS.md.

The two questions the Voice seat's new door left open are answered, one

by a stopwatch and one by a rule.

The measurement (the default follows it)

Twelve interleaved dictation round-trips through the app's own path,

same spoken clip, same machine, order alternated each round:

• Groq direct: median 2.25 s, spread 2.08–2.50 s.
• Via OpenRouter: median 4.23 s, spread 2.88–9.32 s.

Groq direct wins, decisively — two seconds faster at the median, and a

half-second spread against a six-second one, which is what a live

microphone actually feels. The Groq row stays the default. The

numbers live in the plan (docs/kickoffs/VS-2-PLAN.md) and in the

curated defaults' own reasoning.

One key, everything works

• **If the only key you add is OpenRouter, the Voice seat sorts itself

out**: the shipped Groq default (which would be a dead door without

a Groq key) moves to the OpenRouter Whisper row, silently and

visibly — no dialog, and one plain line in the watcher's log saying

what moved and why. A row you picked yourself is never touched, and

adding a Groq key later moves nothing back.

• The Set-up-AI banner and Settings ▸ Voice now say it plainly:

one OpenRouter key covers writing and dictation.

Fixed on the way

• The Voice door on the right rail now notices the world changing: a

key landing, the stance switching or the one-key rule firing wakes

it immediately. It used to watch only the Groq key, so an OpenRouter

key added in Keys & connections left it dim until a restart.

• The watcher's log gained the moved for you event kind, and the

event list is now one runtime source shared with the type, so a

future kind cannot silently vanish from the log the way this one

briefly did during the build.

Dictation is no longer welded to one vendor. The Voice seat now resolves

like every seat in the app: switchable rows, governed by your privacy

stance, watched by the sovereignty watcher, and priced honestly in the

usage meter.

What you will see

• Settings ▸ Voice lists every transcriber your stance serves, as

rows: Groq's two Whispers on your own Groq key, the same Whispers

via OpenRouter at roughly a quarter of the direct price, and

Mistral's Voxtral Mini Transcribe (France). Each row says plainly

where your audio travels and about what an hour of it costs. Picking

a row is the same choice as picking it in Seats. Local Whisper, on

this machine, is listed as a later update, visibly not built.

• Dictation now works under the locked cloud stances. The

transcription endpoint honours no routing controls, so a row is

offered under a locked stance only when every endpoint serving it

satisfies the stance by OpenRouter's own published data: under

Zero Data Retention and No Training the OpenRouter Whisper

rows qualify (every serving endpoint is on the published

zero-retention list); under EU Only the Voxtral row qualifies

(every serving endpoint is Mistral, headquartered in France).

Totally Local still stands the door down with the house sentence:

no silent leak, exactly as ruled.

• A missing key is a door, not a dead end. If the row your stance

names has no key yet, the Voice panel says which provider needs one

and the button opens the place that key lives.

• Dictation lands in the usage meter with a real cost, whichever

row runs: OpenRouter reports the exact charge back per request; the

direct rows are metered on the audio's measured seconds at the

provider's published price. The old zero-cost marker is gone.

• The chip beside Record names the transcriber that will actually run,

language fork included: on a Whisper row, a non-English document

still gets the full Large v3; Voxtral is one multilingual model and

simply hears the hint.

Under the bonnet

• The served-list collector learned OpenRouter's separate

audio→transcription modality (nineteen models that never appear in

the standard list), persists it as a sixth snapshot source, sweeps

its endpoints, and feeds it to the watcher: a vanished, expiring or

dark transcription model is watched like any other row.

• A Mistral direct provider row is seeded beside Groq for anyone who

wants their own Mistral key (a My Custom row, like every direct key).

• The curated defaults grid gained three Voice rows (migration v21,

never overwriting a choice you have already made), and the legacy

Groq-only model setting is retired: the seat is the one answer.

• Audio rows carry no per-token price in the catalogue: their prices

are per hour of audio, published, and verified by hand.

A prompt can now produce a whole file, not just an answer. You say

so in the prompt's own properties, before it is ever run: what a run

produces, and which kind of file it writes. Run it while you are

standing in a project, and a new document appears on your board.

The mechanics are the point. The model never touches your disk. It

returns the contents; Markelangelo writes the file, into your

project folder, never over anything already there, and the new card

says plainly that AI made it.

• Declared, never guessed. A new row in a prompt's properties,

"What a run produces": an answer in the panel, comments in the

margin, or a file in the project. Choose the file, and a second row

asks which kind: .md, .mmd, .csv, .svg or .html. Until you

answer it, the prompt keeps producing an ordinary answer, and the

panel says so. Pictures are not on the list, because an image prompt

already writes into your assets folder.

• It never overwrites. A name already taken comes back numbered,

the way ＋ Add a deliverable has always worked: run the same prompt

twice and you get competitor-teardown.md and

competitor-teardown 2.md, with the first one untouched. The toast

names what was written, and offers to show you its card.

• The card is honest about where it came from. It lands on the

Default Ladder in Draft wearing a small gold "made by AI" mark, and

opening it shows a quiet block: which prompt wrote it, which model,

which privacy route and seat that model was resolved on, and when.

That block is written into your project file, so it still answers

the question a year later.

• A file with no Room opens outside Markelangelo. An .html or an

.svg says so on its own card and hands off to whatever your

computer uses for it. There is no in-app preview and no in-app

editing of them, deliberately: this is a writing suite, not a

browser with an IDE in it.

• No project, no offer. A file-landing prompt needs somewhere to

land, so it simply is not offered outside a project: not in the

launcher, not on the quick bar. Press it from the library, which

shows everything on purpose, and it tells you in one sentence what

would wake it. Nothing is sent.

• New File now offers to start from the Project Room. Beneath the

document cards, a row that says "start here when you are assembling

a body of work", with the two doors that matter: open or promote a

folder you already have, or make a new project. The menu keeps

saying New File.

• The manual now has a Project Room chapter. Help ▸ User Guide, chapter

2a: the whole room end to end, from promoting a folder you already have to

the prompt that lands a file, in the same words the app uses.

• A landed file's stamp now says the date the British way, "26 August 2026

at 10:41" rather than "8/26/2026, 10:41:07 AM". It follows the language the

app is set to, like every other date it shows you.

• The room's words were swept, every one of them, against the house

vocabulary. Four small wrongs are fixed: a card's list of reference material

called itself the briefcase, which is a different thing; two sentences wrote

the Project Room's name in lower case; and one setting carried a dash the

house style does not use.

• One page shows you all twenty rulings.

docs/kickoffs/PROJECT-ROOM-ACCEPTANCE.md lists each ruling the brief

settled, where to press it in the built app, which release put it there, and

the picture that shows it, including the two that are honestly not built

(the argument wall, and the Slides end of the pipeline).

• The whole walk is now guarded by a fixture. Your own use case, promote a

folder, brain-dump the deliverables, shelve them, write with the shelf in

the briefcase, ask it, summon the watch, resolve a finding, land a file, and

be planned with on a second folder, runs end to end against the built app on

every check, and photographs each step.

The Project Room is complete as designed

Six releases, one room:

• 0.104.0, a project is a folder. Promote what you already have; one small

readable file holds the outcome and the board.

• 0.105.0, the board. Shelves as columns with objectives on their spines,

cards walking Draft to Locked, and ＋ Add a deliverable writing a real empty

document into your folder.

• 0.106.0, the briefcase. A chip that says what this document argues from,

and an answer that declares its footing part by part.

• 0.107.0, the coverage watch. The shelf reading your draft back to you,

when you ask it to and never before, as ordinary comments in the margin.

• 0.108.0, Plan it with me. A conversation that proposes a whole board in

dashes, where nothing exists until you accept it.

• 0.109.0, the Prototype Prompt. A prompt that produces a file, written by

the app, stamped with where it came from, and New File offering to start

from the Project Room.

What is deliberately not here, and is not an oversight: the argument wall,

which waits for the Cartographer, and the Slides end of the Shelf ▸ Document ▸

Slides pipeline, which waits for a Slides Room. The room's own names, the

Project Room, the Default Ladder, the shelf, the briefcase, are working names

until the naming session, and they all live in one file, so renaming them is

one edit rather than a sweep.

A project room can now plan itself with you. Press Plan it with me

on the masthead, talk for a minute about what you are actually trying

to achieve, and a proposed board appears over the one you have: shelves

with objectives, empty documents standing on them, and every shelf

carrying a one-line why in your own words.

Nothing is created. Not a folder, not a file, not a line in the

project. The proposal is dashed and gold, standing beside your real

columns, and it stays that way until you say otherwise.

• Two doors, one conversation. On an empty folder the plan comes

out of the conversation alone. On a folder with thirty files dropped

in it, the same door sends what you already have into the

conversation: it reads the ladder, shelves the files you own, and

proposes empty documents only for the things that are missing. One

door, two behaviours, decided by what is actually in the folder.

• Accept, adjust or dismiss, one at a time or all at once. Every

proposed document carries its own three words. Accept creates a

real empty file of that kind in your folder, on that shelf, through

exactly the same door as ＋ Add a deliverable. Adjust lets you

change the name and the room first. ✕ takes it out of the plan.

A proposed claim of a file you already own says Claim it or

Leave it instead, because there is nothing to create.

• Dismiss costs nothing at all. Take the whole proposal down and

your project file is byte for byte what it was. So is a crash: the

ghosts live only on screen, and a relaunch in the middle of a

proposal loses the proposal and nothing else. The conversation is

kept, so it can propose again.

• It cannot invent a file. A claim may only ever name a file the

app actually listed. Anything else is said out loud under the

banner — "never-here.pdf is not in this folder" — rather than drawn

as a card pointing at nothing. The same goes the other way: it never

proposes creating something the folder already holds.

• "Why these shelves?" Once a plan has been accepted, a quiet door

appears on the masthead. It opens the conversation the board came

from, months later: what you agreed, who interviewed, who wrote it,

under which privacy stance.

The interview is Conversational Mode, unchanged: your own model, your

own machine if you want it, the Brief you can correct by hand at any

point, and the writer who receives the agreed Brief and never the

chatter.

The shelf you argue from can now read your draft back to you. Press

one button and it says what you never addressed, what you claim

without citing a source you already own, and what the CFO would ask.

Every finding arrives as an ordinary comment in the margin, and you

resolve them like any other.

It only ever runs when you ask. There is no timer, no check on save

and no nagging while you type: the writing room stays quiet.

• Check it against this shelf. The same words on three doors, all

doing the same thing: on a card in the Project Room, in the

briefcase chip's popover while you write, and in the command

palette. It reads the document in front of you against the shelf

that document has adopted.

• Three kinds of finding. A gap is something a document on

your shelf raises that your draft never answers. An **uncited

claim** is a sentence of yours that a source on your own shelf

could ground, sitting there with nothing attached. A lens note

is a stakeholder you told the shelf about, asking for what they

care about.

• They land as comments, because that is what they are. Each one

is anchored to the sentence it is about, shows as a bubble in the

margin, opens as a thread you can argue with, and clears when you

resolve it. On a Word document it is also a real Word comment, so

somebody who never opens Markelangelo reads the same remark.

Findings about the draft as a whole sit at the top and say so,

rather than being pinned to whatever sentence was nearest.

• A line above the margin says what was checked. "Checked against

the Research shelf · summoned just now · 2 sources · 1 gap ·

1 uncited claim · 1 lens note · lands as comments, resolve them

like any other." Check again and the counts are the new check's,

not yesterday's added to today's.

• Lenses ride the shelf. The shelf menu gains Lenses…: short

notes about the people who will read this work — "the CFO cares

about cash exposure, and how long the runway is". A lens can borrow

a voice from your persona library, read fresh every time, so

editing the persona changes every lens wearing it. Its findings

wear its own colour in the margin and name it in the panel.

• It never invents coverage. A shelf that holds only pictures,

PDFs and workbooks stands the check down and says why, instead of

spending a run that could only make something up. Grounding that is

asleep does the same. And if a check comes back in a shape

Markelangelo cannot vouch for, it lands nothing at all and tells

you — a check that guesses would be worse than no check.

Nothing here touches your text. The draft is read, never rewritten;

what changes is only what is in your margin, and you decide what to do

with it. Under Totally Local with a local embeddings model, no part of

it leaves the building.

The shelves you built last release can now be argued from. While you

write inside a project, a chip beside the model chip names the

briefcase this document carries: one shelf, or the whole project. Ask

a question and the answer comes back from those documents, with every

part of it saying where it stands.

• A chip that says what this document argues from. It sits beside

the model chip, gild-bordered, and it reads "Briefcase: Research ·

5 sources". Click it to swap to another shelf or to the whole

project. The choice is remembered on that card's own row, so each

document keeps its own briefcase. A document outside a project has

no chip at all.

• Ask your shelf, in the panel you already use. Chat with Notes

becomes the briefcase's door when the document in front of you is

in a project. Same composer, a scoped question.

• Every part of the answer declares its footing. A paragraph that

stands on your shelf wears FROM YOUR SHELF and carries a thread to

the exact source, section and all; click it and that document opens

at the passage. A paragraph that came from the model's general

knowledge says so, in those words. If an answer will not say where

it stands, the whole of it is marked as unverified rather than

dressed up as a citation.

• **The same question against two shelves gives two different

answers**, because it really is reading different documents. That

is the point of the shelf.

• The chip counts honestly. Its popover splits your files into

what can be read and what can only be held: a PDF, a picture or a

workbook stands in the project but never grounds an answer. A shelf

of five pictures says "nothing to read" rather than promising five

sources.

• Grounding that cannot run says so. With no embeddings model in

your stance, the chip states plainly that grounding is asleep, what

would wake it, and a button to go and set it. Answers still come,

and they are honest about being general knowledge. Nothing pretends.

• Ordinary prompt runs get the shelf too. Run a saved prompt on a

project document and the shelf's material goes in with it; the

result panel closes by naming the shelf it argued from and the

sources it reached. Nothing lands in your document unreviewed: the

same diff, the same apply, exactly as before.

Underneath, the knowledge index learned scope. Your notes folder and

each project are indexed separately and searched separately, so a

question put to a five-file shelf reads that shelf rather than

guessing from everything you own. Changing your notes folder no longer

touches a project, and a project never touches your notes.

One thing to expect on first launch: the index rebuilds itself once,

because the vectors are stored in a new shape. Your notes folder

re-indexes the next time you ask it to; nothing else is affected.

Everything is still your folder, on your machine. Under Totally Local

with a local embeddings model, no part of asking a shelf leaves the

building.

The project you promoted last release now opens as a board. The

Default Ladder is still there on the left, showing every file you

have. Beside it are shelves: columns that carry an objective on their

spine, cards that walk from Draft to Locked, and the reference

material each shelf leans on.

It is built around the way you actually plan: go down the left column

adding everything that has to exist, then move right and start

detailing.

• Add a deliverable, and get a real file. ＋ Add a deliverable

sits on the ladder and on every shelf. Name it, choose its room

(Words, Rich Words, Numbers or Map) and an empty document of that

kind is written into your folder there and then. The card is the

unwritten document, so your plan can never drift away from what is

actually on disk.

• A shelf is a column, and its objective lives on its spine.

＋ New shelf makes one; type its name and the sentence that says

what it is for, straight into the column. Columns reorder by

dragging the grip, or from the shelf menu, so the board reads in

the order the work happens.

• Drag a card on to a shelf to claim it — and everything drag

does, a click does too. The card sheet can move a card between

shelves and back to the ladder, and the shelf menu can reorder the

columns. Nothing on this board needs a mouse.

• Open a card and it knows where it stands. It shows the

objective of the shelf it lives on, rather than making you retype

it; you walk it Draft ▸ Editing ▸ Done ▸ Locked by clicking a

rung; and one big button carries it to the room it belongs in.

• Reference material stands on as many shelves as it grounds.

Tick a file from the project and it joins that shelf's bay. Open it

anywhere and it says which other shelves it is on, so nothing is

quietly duplicated.

• Lock a card when it is finished. It becomes reference: material

rather than work in hand. The button changes to "Unlock to edit",

which is one click back. This is the board's own discipline, not a

lock on the file: it still opens from the Library, and the room

says so.

• Removing a shelf loses you nothing, and says so first. The

confirmation states exactly what happens: no file is touched, the

deliverables come back to the ladder unclaimed and the references

are detached. Then that is precisely what it does.

Everything is still just your folder and one small readable file in

it. Nothing here uploads, moves or rewrites a document.

Deliberately not on this board, and not by accident: no work-in-

progress limits, no assignees, no due dates. Columns, cards, four

statuses, objectives. Coverage checking against a shelf, and the

conversation that proposes a whole board for you, are the pieces that

follow.

Markelangelo now has a place for a whole piece of work, not just a

document. Point it at any folder you already have and that folder

becomes a project: your outcome at the top, every file in it listed

honestly underneath. Nothing is moved, nothing is renamed and nothing

you wrote is touched.

• Promote the folder you already have. Ctrl+Shift+P ▸ "Open or

promote a project folder", or right-click a folder in the Library and

choose "Open as a project". One small readable file appears in it

(markelangelo.project.json) and holds the board. That is the

only thing that changes on disk.

• One line at the top says what you are actually after. Type it

straight into the banner; it saves itself into the project file as

you type.

• Every file, always. The Default Ladder lists the whole folder,

grouped by Draft, Editing, Done and Locked, with references in

their own group. Markdown, Word and spreadsheet files start as

things you are making, and open in their own room with a click.

Everything else, a PDF, a picture, a zip, stands as a locked

reference and opens with whatever your computer uses for it. The

card says which of the two it is before you press it.

• Rename a file in Explorer and the room does not break. The card

says the file is missing and asks whether the file that just

appeared is the same one. One click re-points it; saying no leaves

it alone. It never guesses on your behalf.

• The room comes back when you do. Quit, reopen, and the project

is still there, still right, exactly like a document.

• Your Projects folder is yours. Settings ▸ Projects says where

new projects are made and lets you move it. Any folder anywhere can

still be promoted where it stands.

• New project makes a folder under that root, promotes it and

opens it, and that is the whole ceremony. No wizard.

Everything stays on this machine. The project file is written inside

your own folder, and it is plain readable JSON you can open, diff,

sync or delete.

This is the first piece of the Project Room. Shelves as columns,

cards you drag between the statuses, and making a blank document

straight from the board are the pieces that follow.

Charts from your workbooks, in your documents. A chart living in a

workbook — made in Markelangelo's Numbers Room or arriving in an

.xlsx from Excel — now inserts into a document by the same grammar

as a range.

• Two doors, two modes. Insert ▸ From Sheet… lists the open

workbook's charts beside its ranges; copy with a chart selected

and Paste Special offers the chart itself. Land it as an Image

(a one-time snapshot) or a Live Link (the same picture,

refreshing). A chart is never offered a Table mode, because a

chart cannot become one.

• The picture is the workbook's own drawing — the chart exactly

as the grid draws it, with its title and legend, saved into the

document's assets folder like any pasted picture.

• **A live chart keeps up while its workbook is open in

Markelangelo, and says so plainly when it is not.** Edit the

numbers and the linked picture redraws. Close the workbook and the

chart's chip states the ceiling in one sentence and offers to open

the workbook in one click; the picture you have is left exactly as

it is, never regenerated in silence. Detach turns a linked chart

into a plain picture, and says what that means.

• Charts print where they sit. In a document, on the page the

preview shows; in a workbook, at the cell they are anchored to

(and a chart made this session now prints too, which it quietly

did not before). If you can see it, it prints.

• In a Word document a chart is a picture. There is no live

binding for a picture on that surface, so the chooser says so

before you click, and tells you where a Live Link lives.

With this piece the relay's promise is whole: make a chart, put it

in your report, watch it follow the numbers, and print the report

with the chart exactly where you saw it.

The Look a document wears now reaches its diagrams. A Mermaid diagram

in your document stops rendering in the engine's stock lilac and

dresses itself in the document's Look: its boxes take the Look's

fill and outline, its arrows the Look's line, its labels the Look's

ink and type, its notes the Look's note colours.

• Everywhere the diagram appears, it appears the same: the

editor, the paged preview, the printed page, the PDF, the exported

HTML and the Word file (still a true vector there). One mapping,

proven in the accepted Looks prototypes, drives all of them.

• Themes and Looks compose. Switch the app theme and a

token-built Look re-dresses the diagram to match; a brand-committed

Look applies its stated dark-theme rule. Diagrams now also follow a

theme change immediately, which fixes a small standing fault:

before this release a theme flip left diagrams in the old theme's

colours until you next edited them.

• The Studio shows the diagram face of a Look. The proof wall

gained a small diagram exemplar, so while you author a Look you

can watch its boxes and arrows in all three themes live.

• A document with no Look draws exactly what it drew before.

Guarded by fixture, not by intention.

This is deliberately not a diagram editor; that room is a later

piece. It is the "one producer, many hosts" decision paying out: the

pictures the product already draws now wear the identity the

document chose.

Looks stopped being three fixed choices. The Style Studio is the

authoring room for the visual identity your work wears: browse the

shipped Looks, duplicate one, and make it yours.

• Open it from where you pick a Look (Properties ▸ Page & Style,

the ribbon's Page tab, or the command palette). The Studio opens as

a tab, like everything else, and comes back after a restart with

your work in progress.

• Three panes. The shelf lists the shipped Looks (duplicate is

their verb; they cannot be broken) and your own (rename, delete).

The editor offers the fifteen values as guarded controls: pick a

theme colour by name and swatch, or type a colour of your own,

which only lands once it is a real colour. Each value can carry its

own dark-theme override. The forbidden list is shown, read only.

• The proof wall shows all three themes at once, compiled by the

same code that dresses the editor and every export, so what the

wall shows is what a document gets. Edits save as you make them.

• Apply names the document it will dress and explains itself when

the active tab cannot wear a Look. Applying is one step, and one

step back.

• Your Looks follow you everywhere a shipped one does: the

editor, the paged preview, HTML and PDF export and print all

resolve them from the same library, and a document keeps wearing

yours after the app restarts. Deleting a Look never edits a

document; a document naming a missing Look simply renders plain

and says so where you would look.

The User Guide gained a section on Looks and the Studio (Help ▸ User

Guide, section 4a) covering this release and the last.

The work starts wearing one visual identity. A Look is a small,

shareable object — about fifteen values: what the ink is, what a box

is filled with, how heavy a line is, how round a corner is, what a

note wears — plus a short list of what it forbids and one honest rule

for dark themes. It was settled and accepted as a prototype set on

23 August; this release makes it real inside the product.

• Pick a Look where you pick a style. Properties ▸ Page & Style

(and the ribbon's Page tab) now carries a Look chooser beside the

style chooser. Three ship: Athenaeum (the house Look, built

from the theme's own tokens so it follows every theme for free),

Blueprint (technical and outlined, dashed rules, monospace) and

Poster (bold and filled, for reading from across a room).

• One coherent choice, not two fighting systems. Each Look names

a companion style set (Athenaeum pairs with Article, Blueprint with

Technical, Poster with Report), and picking a Look applies both in

one step. Your document's frontmatter stays readable: look: and

style:, side by side, and any editor that knows nothing of Looks

still honours the typography.

• The whole pipeline follows. The editor, the paged preview,

HTML and PDF export and print all read the same Look from the same

place. Callouts wear the Look's note colours; the horizontal rule

wears its line weight and dash rule. A document that never chose a

Look renders exactly as it did before.

• A Look is data, never code. Colours are either named theme

tokens or literal colour values, validated before they touch a

stylesheet — the same security posture as style sets, and what will

make Looks safe to share as packs later.

This is the foundation piece: the same Look object will drive themed

diagrams (next piece), chart chrome, and later the Diagram and Slides

Rooms — one producer, many hosts, per the accepted design.

Also in this release, two standing riders land: the app's main

process now ships minified (it carried its comments and prompt

text in plain sight until today), and one stale test fixture was

brought up to date with the Properties toggle behaviour.

And one long-standing defect is fixed at the root. Typing into a Word

document in the first moments after opening it (most easily right

after Rich Switch) could silently lose those keystrokes: the file

watcher's late echo of the document's own creation reloaded the pane

from disk over the top of the edit. Word tabs now record the file

time their bytes were read at, so that echo is recognised for what it

is and ignored — a real outside change still reloads as before. This

was almost certainly the intermittent test failure previously logged

as the "rich-journey load flake".

The second structural door, and the quiet one: tier gating becomes **one

seam, built once**, so the paid edition (Markelangelo Sistine, a design

on paper until now) can arrive later as data and policy rather than

surgery. Deliberately, almost nothing is visible:

• Help ▸ About now states the edition, under the version:

"Markelangelo · all features enabled". That sentence is the truth of

every installation today, and it is now read from the entitlement

service rather than assumed.

• Everything else behaves exactly as before. Every feature the

Sistine design earmarks (the Rich surface switches, page styles, the

page view and paged preview, AI on the Map, Conversational runs) now

asks "am I enabled?" through one door — and the answer is yes,

everywhere, because the default entitlement is everything on. There

is no account, no server, no purchase flow, and none is coming

uninvited: the seam ships dormant by design.

Under the bonnet: the licence file format is settled now so it never

changes shape — a signed document (the same signature scheme that

guards language packs) carrying the edition, the named capabilities,

the dates and the licensee. A tampered, mis-signed or expired licence

is refused outright and the app simply remains fully enabled. The

grep-only SISTINE GATE markers became real checks at their doors,

each still naming its capability for the map.

Piece W2, closing docs/kickoffs/STRUCTURAL-DOORS-RELAY.md: with the

world registry (0.98.0), every later world and every later tier now

lands as a row, not a grep.

The first of the two foundations the v1 running order builds before any

new world arrives: every world is now a row in one typed table

rather than a scatter of hand-written forks. What you can see of it:

• File ▸ New ▸ Mind Map. The New-document chooser now offers a

Mind Map beside Words, Rich Words and Numbers: choosing it starts a

fresh unsaved Words document with an empty map already in it and

lands straight on the map, ready to think in. The document behind it

is still the truth — the writing and the map stay together. "New

Mind Map" is in the command palette too, and the User Guide's Map

chapter now names both doors (New for a fresh map, Insert for a map

in the document you are in). This closes the finding "there is no

obvious way to create a Map".

• The New-document cards now wear their world's colour — the same

small dot the Tabs list uses, from the same single source.

• The chooser now follows a language switch like the rest of the

app, instead of keeping the words it booted with.

• The Comments panel stands down on a flow tab with an honest

sentence, as it already did on Numbers and on a Map — found by the

registry work; a flow has no passage of text to anchor a comment to.

Everything else is deliberately unchanged: same tints, same menus, same

doors, held by the full fixture suite. Under the bonnet, the editor

host, the tab strip, the extension families and the New-document

chooser all read the one registry, so the Diagram Editor, the

Cartographer and Slides each arrive as a data row rather than a hunt

through the code.

Piece W1 of docs/kickoffs/STRUCTURAL-DOORS-RELAY.md; W2 (the

entitlement seam and the licence format) follows.

The arrival moment, and the close of the Localisation architecture

relay.

• The first-run language offer. On a fresh install whose computer

speaks Español, Français, Deutsch, Nederlands, Polski, Italiano or

Português, Markelangelo offers that language once: one honest card

with three choices — use it for the interface and new documents,

keep the interface in English and write documents in it, or stay in

English entirely. The pack size and the single anonymous download

are named; the OS language is read on this machine and nothing about

you is sent anywhere. Nothing is ever switched silently, and

everything on the card lives in Settings ▸ Languages afterwards.

• The interface chip is honest about today: interface translations

arrive with each language's pack in the next relay, and until then

the chip says so rather than promising them.

• The User Guide gains a Languages chapter — the interface

language, the document language and its door, packs, the offer and

dictation, all in one place (Help ▸ User Guide).

With this, the architecture relay is complete: the catalogue and its

build-failing guard (0.94.0), the document language and the tools that

follow it (0.95.0), the signed pack machinery (0.96.0), and the arrival

moment (0.97.0). The languages themselves — translated interfaces and

the published pack store — are Relay B, which inherits a written

handover.

Piece A5, closing docs/kickoffs/LOCALISATION-A-RELAY.md.

The packs the language door has been promising are now real machinery.

• A pack manager in Settings ▸ Languages. Each of the eight product

languages is a row: what its pack covers (spelling, proofread,

thesaurus — read from the store's own manifest, never assumed), how

big it is, and one Install button. Install is the only moment

anything is fetched; downloads are anonymous, resume after a broken

connection, and are verified against a signed manifest before a

single file is unpacked. Remove undoes it entirely.

• The door changes the moment a pack lands. Install Español and

the document-language door's proofread row flips from "needs a

language pack" to a tick on the spot; the whole-document proofread

and the thesaurus wake in that language. Remove the pack and the

door stands down again, honestly.

• A signed store. The pack list is signed; a tampered or unsigned

manifest is refused outright and the app simply reports the store as

unreachable. Installed packs keep working offline.

• Two languages wait for counsel. German and Italian dictionaries

are only available under licences whose position we are having

confirmed; their packs are built but not offered, with one honest

sentence in the manager.

• The pipeline behind it builds every pack from pinned, audited

sources, converts them to one encoding, ships every licence text

inside the pack, and benches each language on real prose in its own

process before the manifest is allowed to claim proofread works.

All eight passed under the real Hunspell engine.

The store itself is not yet populated: packs appear in the manager the

moment the pipeline is published to the store, with no app update

needed.

Piece A4 of the Localisation architecture relay

(docs/kickoffs/LOCALISATION-A-RELAY.md).

Documents now carry their own language, and the tools follow the

document, not the app.

• One language door in the status bar. Where the spelling-languages

item used to sit, there is now a single door that names the language

the document in front of you speaks. Open it and it tells you, row by

honest row, what the tools can do for that language today: spelling

as you type, a whole-document proofread, the thesaurus, and the

language the AI will reply in. A document with no language mark is

read as the app default, and the door says so rather than pretending.

• The mark lives in the document. A markdown file keeps it in its

frontmatter (lang: es); a Word file keeps it in its own language

setting, written by an ordinary save. Change it in the door and the

file itself changes; nothing is stored on the side.

• Detection is an offer, never a change. A document of forty words

or more with no mark, written in one of the product languages, gets a

quiet "Looks like Español. Set it?" inside the door. One click sets

it; "Not now" is remembered.

• A real Hunspell engine. The whole-document proofread now runs the

same Hunspell engine as the word processors, on its own thread so a

long document never freezes the app. Where it has no dictionary for

your document's language it stands down and says so by name; the

language packs that wake it arrive in a later release.

• Sovereign dictionaries. Inline spelling dictionaries are fetched

from markelangelo.me, never from Google's servers. Languages not yet

hosted simply stay asleep, honestly reported in the door.

• AI replies follow the document everywhere. Word documents and the

conversational Writing Desk delivery now carry the document's

language into every run, exactly as markdown already did.

Piece A3 of the Localisation architecture relay

(docs/kickoffs/LOCALISATION-A-RELAY.md).

Invisible on the surface, and the point of the whole piece: nothing a

user sees has changed, in any theme, by a single character. Underneath,

every word Markelangelo speaks has moved into one catalogue.

• Around 3,500 strings extracted. The shell, the tabs, the status

bar, the palette, Settings whole (including every ⓘ entry and the

privacy copy, moved byte for byte), every AI door, the editor, the

Map, printing, images, both vendored-editor hosts' own chrome, the

native menus and the file dialogs now read from the EN-GB catalogue.

English output is character-identical to 0.93.0, with one deliberate

exception recorded in the release ledger: a flattened Map's image

alt text now reads "Map: name" rather than using a dash.

• A pseudo-locale proves completeness. Launched with a test flag,

the whole app renders in bracketed, accented text; any plain English

on screen is a missed string. The journey smoke can run under it.

• A hard-coded sentence now fails the build. A static lint scans

the chrome for user-facing literals that bypass the catalogue; every

feature built after this piece is born localised, because the build

says so.

• English remains the only populated language. The languages themselves

arrive by pack in Relay B; this piece is the machinery that makes

each of them a data file rather than a programme.

Piece A2 of the Localisation architecture relay

(docs/kickoffs/LOCALISATION-A-RELAY.md).

The localisation architecture's foundation: Markelangelo now has a

language engine, an interface-language setting, and an AI that answers

in the document's language.

• Settings ▸ Languages. A new section beside Privacy & Sovereignty

with two choices: the interface language (eight languages offered)

and the language for new documents ("Same as the interface" by

default). The section says plainly what switches today and what

arrives with the language packs.

• The Word editor already speaks nineteen languages, and now it

follows your choice: pick Español and its ribbon, menus and dialogs

switch immediately. Markelangelo's own chrome stays English until its

language packs arrive, and says so.

• AI replies follow the document, not the app. A document that

declares its language (frontmatter lang: es) gets its AI replies in

that language, on whatever model your stance serves: the instruction

changes, the model never does. The Assembled panel shows the

directive, because it shows what the model actually receives. English

documents are untouched, byte for byte.

• Under the surface: a tiny plural-aware i18n engine (EN-GB is the

source; anything untranslated falls back to English rather than

breaking) now serves both the app and the native menus, which rebuild

through it. This is the machinery every later language rides in on.

A user who never opens the new section notices nothing: English (UK)

remains exactly as it was, everywhere.

Piece A1 of the Localisation architecture relay

(docs/kickoffs/LOCALISATION-A-RELAY.md).

Voice dictation now speaks the Language System's law before the rest of

the app does: it follows the document.

• A language selector on the dictation panel. It defaults to

"Follow the document", so a document whose frontmatter says

lang: es is dictated in Spanish with no extra click. Pick a

language yourself and that choice is remembered for that document,

including across a restart.

• A spoken-language default in Settings ▸ Voice. Auto-detect by

default, exactly as before; set it once if you always dictate in one

language.

• The right Whisper for the language. English and auto-detect keep

the fast Turbo model; any other language is transcribed on the full

Whisper Large v3, which holds its accuracy exactly where Turbo loses

it. The model chip beside Record names the model that will really

run.

• Honest coverage, per language. One plain line under the selector

says what to expect: good coverage, usable with editing, or untested

with our best endeavours. Around one hundred languages are listed,

including Kiswahili, Yoruba, Hausa, Somali, Amharic, Shona, Lingala,

Malagasy and Afrikaans.

• Nothing changes for anyone who never touches the selector: same

model, same request, same panel.

Dictation remains a Markelangelo Labs feature: your audio goes to Groq

to be transcribed, under Groq's own policies, and the Voice settings

say so plainly.

This is the first piece of the Localisation architecture relay

(docs/kickoffs/LOCALISATION-A-RELAY.md).

The last of the six sovereignty releases. The programme that began at

0.86.0 closes here: one list, one resolver, one sentence, everywhere.

• A green test now means the key works. Test & refresh asks

OpenRouter about the key itself before saying Connected; a bad key

reads "OpenRouter refused this key." in red, not "Connected, 421

models visible". Other endpoints get one tiny authenticated call, or

say honestly "Address reachable, key not verified." A remote endpoint

no longer claims "No key needed": only a server on this machine does.

• Every stance arrives ready. Choosing EU Only, Zero Data Retention,

No Training or My Custom now fills each job with a curated model,

proven served and capable against the live list, and clears the

2024-era recommendations an old install may still carry. A job the

stance cannot serve says so plainly. Nothing is marked "tested" yet:

the acceptance sheet (Sovereignty Audit/05-DEFAULTS-ACCEPTANCE.md)

is yours to sign, one row per stance per job.

• The Voice seat stays honestly empty under locked stances: dictation

talks to a transcription endpoint and does not yet consult the seat,

so filling it would promise what the Record button cannot deliver.

Logged as the one open finding (SV-028) with the decision yours.

• The words got a pass. The command palette says "Keys &

Connections…"; error messages point at the doors that exist today;

absolute privacy claims are gone ("requested and enforced via

OpenRouter", "EU-based providers", your deliberate choice and our

best endeavours); the em-dashes left the copy, with a test to keep

them out.

• The User Guide teaches the new world: the five stances, Model

Management, the one model selector, the model chip, the stopped door

and the watcher, in plain words; the web manual's privacy pages are

rewritten with fresh pictures.

• The books are closed. All 28 audit findings carry a status (27

closed by construction and under test; SV-028 open, carried); your

findings AF-014, AF-017 and AF-018 are ticked with evidence.

The sovereignty remediation is complete: six staged releases, 0.86.0 to

0.91.0, none promoted. What needs you: sign the defaults sheet, and the

open decisions 7 to 13 at the top of the implementation log.

The fifth of six sovereignty releases. The model world changes weekly;

Markelangelo now watches it for you and says so in plain sentences.

• What changed since you last looked. On every refresh the app

compares the served list with the last view and writes what moved:

a new model your stance can serve (offered, never switched on for

you), a model that vanished, an end date that appeared or came close,

a provider that stopped answering, a model whose home or policies

changed, and your own switches when the world touched them (your

choice is re-asked, never carried silently).

• Never a silent substitution. A vanished or expired model you rely

on is switched off, the jobs that used it are marked "needs a choice",

and the alarm names every prompt, Leader, Flow step and Brief still

pointing at it, leaving them exactly as you wrote them. The run door

stops there in the same words. The stance card counts what needs you;

the "What changed" bar puts alarms first, in whole sentences.

• A newer model in the family. When a newer sibling of a model you

pinned arrives, served under your stance and able to do everything

the old one could, one line appears where the model is chosen:

"Claude Opus 6 has arrived in this family, served under your stance.

Try it · Switch · Not now." Nothing moves unless you say so.

• Switch everywhere. Switch shows every place the old model is

chosen, each tickable, and moves the ticked ones in one go, so nobody

ends up half-upgraded. What moved is recorded in the log.

• The family is read conservatively: when the app is not sure two ids

are the same line, it offers nothing. A "fast" or "pro" line is never

offered as an upgrade to the plain model.

Still coming: the honest provider test and the copy and guide sweep

(0.91.0), the last of the six.

The fourth of six sovereignty releases. The lock now reaches every door,

and follow-ups inherit the model that wrote what they follow.

• A comment conversation stays on its model. The small chip beside

"Discuss this with the AI" and beside Draft revision names the model

that wrote the comment, and the follow-up runs on it. If your stance

no longer serves that model, a small door appears right under the box:

what stopped, that nothing was sent, and the ways out (pick a served

model for this turn, switch stance, not now). Your choice runs that

one turn; the comment's record is never rewritten.

• Flows stop before they start. When you open Run flow, every step

is checked against your stance. A step that cannot run shows the

sentence in its own row and the Run button says which step is stopped.

No flow starts and then dies halfway.

• The model is named where you press. Run prompt, Ask AI, Translate,

Tidy and Concise, Record, Create image, Expand with AI, Suggest links,

Try on selection, Build index, Related notes: each control carries the

small chip naming the model and where your text goes, resolved exactly

as the run will be.

• Dictation joins the house rules. Groq is now a visible provider

("Direct to Groq") like every other direct key. Under a locked stance

that serves no dictation model, Record stands down with the sentence;

under My Custom it works as before, attributed.

• Pictures too. Suggest image prompt and Describe image now run

through the same engine as everything else: your stance's routing, the

usage meter and the stopped door all apply.

• Related notes go quiet, not wrong. With no served knowledge model,

the panel says so with a door to Privacy & Sovereignty; nothing is

sent and nothing toasts.

• Behind the scenes: the last two consent-era helpers are deleted; what

the resolver decided is recorded on comment threads, kept map nodes

and the Brief's seats, so tomorrow's doors can inherit it too.

Still coming: the watcher (0.90.0), the honest provider test and the

copy and guide sweep (0.91.0).

The third of six sovereignty releases. Wherever you choose a model, you

now get the same picker, and it only ever shows what your stance serves.

• One model selector, everywhere. The Run Prompt override, a prompt's

own model and its interviewer and writer, a Leader's model, a Flow

step's model, Retry with another model, Write it again, the stance

page's seat defaults, the stopped door's "pick a served model" and the

image model all open the same popover.

• The lock bar says what the list is. Under a locked stance: "EU Only ·

showing the 37 models served by EU-based providers that writing can

use. Nothing else is offered." Under My Custom: "21 models on your

list · every row shows where your text goes."

• Filters that narrow, never widen. Only the filters that apply to the

list are shown (tested, structured, vision, cheap, fast, big context,

image out, voice in, EU-based, zero retention, no-training, direct,

local), and each one can only make the list shorter.

• Rich rows. Every row carries the model's name and id, price per

million, context, where your text goes (provider and country, or direct

to the vendor), health, the tested mark and what it can do. Type to

search; arrows, Enter and Escape work.

• Honest empties. A seat the stance cannot serve says "nothing served

by EU-based providers can do this job" rather than "0 models"; prices

round to three figures.

• The image chips tell the truth. The picture dialog and the right-click

Image group now name the image seat's resolved model, not a setting.

• Gone: the old "outside your privacy stance" groups and the three helpers

behind them.

Still coming: every door naming its model beside the control and follow-ups

inheriting the model that wrote them (0.89.0), the watcher (0.90.0), the

honest provider test and the copy and guide sweep (0.91.0).

The second of six sovereignty releases. The place you choose your stance

now looks and behaves like the accepted design, and the models

environment has a home of its own.

• Privacy & Sovereignty, rebuilt. Five stance cards in a row: Totally

Local, EU Only, Zero Data Retention and No Training each wear a lock

and say how many models and providers they serve today; My Custom sits

beside them, dashed, yours. The active card glows and says "switch on

and go" when every job already has a served model, or how many still

need a choice. Beneath it, the active stance's page: the six jobs

(writing, the interviewer, reading pictures, making pictures, the

knowledge index, dictation) with the model each uses, where its text

goes and whether it has been tested; a job the stance cannot serve

says so plainly and offers nothing; any change you have not looked at

is one line with a Review door. Keys and connections sit at the bottom,

demoted: your OpenRouter key's state, your direct keys marked "kept,

not offered" under a locked stance, your local endpoints with their

model counts.

• Model Management. A new Settings section, right after Privacy &

Sovereignty: every model Markelangelo can reach, with what it is, where

your text would go, what it can do, its price, context, health and

lifecycle. Filters that narrow (where the text goes, what it can do,

tested, cheap, fast, on only). Under My Custom, templates you can switch

on in one click (Best available, EU balanced, Zero retention, Direct

keys), a switch on every row, and your own switches marked "yours".

Under a locked stance the page is read-only: the list is the data's.

"What changed since you last looked" lists what needs you.

• My Custom opens with "Best available" on. A fresh My Custom is our

recommended set, switched on, and anything you already relied on

(a prompt's pinned model, a Leader's, a Flow node's, a default) is

carried onto your list so nothing you had stops working.

• Keys & connections. Models & Providers is now keys, connections,

Test & refresh and local endpoints only; the catalogue editor for your

own endpoints lives under Model Management. A stray duplicate "Default"

provider row pointing at OpenRouter is removed.

Still coming: one model selector at every seat (0.88.0), every door naming

its model beside the control and follow-ups inheriting the model that

wrote them (0.89.0), the watcher (0.90.0), the honest provider test and

the copy and guide sweep (0.91.0).

The first of six releases that make the Privacy & Sovereignty stance a

single choice after which every AI door is already right. This one lays

the foundation: one served list, one resolver, and the run engine as the

second lock.

• Five stances, four of them locked. Totally Local, EU Only, Zero Data

Retention and No Training now each carry a list of served models, drawn

from OpenRouter's live lists (models, embedding models, providers and

their headquarters, the zero-retention endpoints) plus your local

endpoints, and narrowed per job (writing, the interviewer, reading

pictures, making pictures, the knowledge index, dictation). Under a

locked stance nothing outside that list is offered anywhere. **Frontier

is now My Custom**: everything, including your direct keys and the Max

subscription, each model wearing where your text goes.

• Nothing runs outside your stance, full stop. The run engine itself

now refuses a model the stance does not serve, before any text leaves,

for every door: prompts, quick actions, comments, Flows, the

Conversational seats, the Map, chat with notes, the knowledge index,

images and alt text. The old "This run leaves your privacy stance / Run

anyway" dialog and its "don't ask again" memory are gone; there is no

out-of-stance run under a locked stance. The only way out is to choose

My Custom, deliberately.

• One sentence when it stops, and a repair. "Under your EU Only

stance, Claude Sonnet 4.6 is not served for writing. Nothing was sent."

with Pick a served model, Switch stance, or Not now. OpenRouter's own

routing refusals now speak the same sentence.

• The model chip. Beside the Run Prompt picker and on every AI Results

row, the model and its attribute: "Mistral Large · EU-based · Mistral

(FR)", "Claude Opus 5 · Direct to Anthropic". It never says "in stance"

by construction.

• Defaults per stance per job. Each stance keeps its own default for

each job; a default a stance cannot serve is stopped and marked "needs

a choice", never silently replaced. The interviewer seat now only offers

models that can give structured answers.

• A shipped snapshot. The live lists as of 23 August 2026 ship inside

the app, so a first run without network still shows an honest list; the

app refreshes from OpenRouter at start and daily while open.

What is still coming in this series: the rebuilt Privacy & Sovereignty

home and Model Management (0.87.0), one model selector at every seat

(0.88.0), every door naming its model beside the control and follow-ups

inheriting the model that wrote them (0.89.0), the watcher that tells you

when a model is new, gone, expiring or dark (0.90.0), and the honest

provider test with the copy and guide sweep (0.91.0).

• Diagrams reach Word as drawings. A Mermaid diagram exported to a Word

document is now a real vector picture (it stays crisp at any zoom), with

a bitmap behind it for Word versions older than 2019.

• Open and close branches on a map. A map's Home ribbon gains a

Branches group: Open branch, Close branch, Open all, Close all; the same

four on the right-click menu, and the little fold circle on a node now

says what it does. Named Open and Close on purpose: Expand is still the

AI's word on the same ribbon.

• "Leave them alone, apply the rest" now lands the rest. In Talk after,

when the AI hands a table back mangled and you choose to hold the table

still, the changes to the paragraphs either side of it now land (they

used to be dropped with a notice). The same fix reaches Apply to

selection, flows and comment-thread replaces, because they share the

one mechanism.

• Every kind of AI deletion is visible and rejectable. An AI pass that deletes a heading, a list item, a code block, a quotation, a picture, an equation or a table now shows every one struck through (pictures and equations in a dashed frame, like a table) and every one can be rejected or accepted. A deleted or inserted equation used to be visible on the page but invisible to Accept, Reject and the Review count.
• The Map's ribbon folds like every other band at every supported

width (walked and measured, no change needed).

The same release as 0.84.0 (Print works everywhere; a workbook reaches

paper), rebuilt to include one file the 0.84.0 tag missed: the native File

menu's Print item, which is now its own door and live on a workbook rather

than tucked inside the Export submenu. Install this one.

One Print door, one dialogue, every world. File ▸ Print (the menu, the

File pill, the palette) now opens the same dialogue on a Words document,

a Word document and a workbook: real pages on the left with the page

count stated, the settings on the right, Cancel · Save as PDF · Print at

the foot. Escape closes it, Enter prints.

A workbook prints. The spreadsheet's print engine existed all along

and had nowhere to send its pages; now it does. Open a workbook, File ▸

Print: the sheet is laid out as real pages honouring its own page setup

(paper, orientation, margins, scaling, print area, repeated heading rows,

gridlines, headers and footers), the count is stated, and Print or Save

as PDF produce exactly the pages you were shown. Charts and pictures

print where they sit. A sheet wider than the paper says so and offers

Fit to width before anything prints. Settings saved in the file (or set

in Excel) are read and honoured, and reading them does not mark the

workbook as edited.

Words and Word documents gain the preview. A markdown document shows

its pages in the dialogue (the same pages the printer receives), with

paper, margins and orientation pre-filled from the document's own front

matter. A Word document shows its page count and a read-only summary of

each section's paper, and the print dialogue is now handed the

document's own paper size rather than the printer's default.

Stated, not hidden. Anything still being built is said in the

dialogue, where it applies: whole-workbook printing, page numbers in a

sheet's own header or footer, fit to height, manual page breaks, the

50,000-cell limit. On a markdown document, the printed page's number

comes from the printer's own numbering rather than the document's own

wording; the PDF carries the document's wording. These are temporary

states, listed as open in the completion contract.

A flow now opens as a tab. Until now the Flows designer took over the

whole window: a full-screen canvas with its own Close button, outside the

tab strip, outside Ctrl+S, forgotten on relaunch. It was the one shipped

surface that still broke the house rule that every surface lives in a tab.

Now: open the AI Library, Flows, press New, and a plain, colour-free tab

called "Untitled flow" appears in the strip beside your documents, with

the canvas in it. The flow's details (name, description, what it reads

and where its answer goes) sit in a slim strip above the canvas, and a

Flow ribbon above that carries Save, Add step, Tidy and Delete.

What that means day to day:

• Rename the flow and the tab renames with it. Change anything and the

tab shows the unsaved dot, like a document. Ctrl+S (or the ribbon's

Save) writes it back to your library and the list updates at once.

• Close it with unsaved work and it asks, the way a prompt tab does:

Save writes it back; Don't Save discards the draft and your library

keeps the version it already had.

• Ask for the same flow twice and you land back on the tab you already

have. A flow tab never splits, and says why. Quit and relaunch: a saved

flow tab is still there, read back from your library.

• Closing the tab is closing the flow. There is no Close button and no

full-screen takeover anywhere in the app now.

• Run has not moved: it stays on the Flows list, because running a flow

needs a document in front of you.

The spreadsheet's Styles trio is proven, against the file. Format as

Table, Cell Styles and a Conditional Formatting rule each apply, save, and

are still there when the workbook is opened again and saved again. This

closes the last open line of the F6 completion contract that was still

owned here. Nothing in the product had to change: the three controls

worked all along; the test that said otherwise had been clicking a hidden

copy of a folded ribbon group and pressing a shortcut that a test harness

cannot press. Two status-bar lines on a spreadsheet now speak plainly

("Cell style applied. Save with Ctrl+S.").

Every AI door that reads your document and writes back into it now

follows the same three rules, the ones Andre set for the conversational

refine loop in 0.79.0: rewrite the prose, read but leave what it

cannot rewrite (a table, a picture, a chart, an equation, an embedded

object) so what it writes agrees with what is there, and remark on

anything it would have changed and cannot, as a note against that object.

Before this release only "Talk after" did that; a quick action over a

table, or a flow that replaces the document, could still strike the table

and put prose in its place.

What that means, door by door:

• Apply to selection (quick actions, Run Prompt results): select

across a table in a Word document and press Improve; the prose changes

as a tracked change, the table stays, and the toast says so in measured

words ("Applied to selection. A table left as it is."). If the AI wanted

to change the table it leaves a note.

• Flows that replace the document or selection: pictures and tables

survive; only the paragraphs that changed are marked. The old warning

that the whole document had been rewritten is gone because it no longer

is.

• Comment threads whose passage runs through a table: applying the

proposed revision rewrites the prose and never enters the table.

• Combine: the combined file now tells you, per Word source, what

could not come across (a comment, a flattened block, tracked changes

accepted), in the same words MD Switch uses.

• Numbers: apply an AI rewrite to a range that holds a formula and the

formula cell is left exactly as it was; the landing says "4 formula

cells were left as they are". The AI is shown the formula, not just its

value, and told it is not its to rewrite.

A note on a Word document now exists in both systems. When the AI

leaves a note against an object it could not rewrite, it is Markelangelo's

comment (in the Comments panel, painted, taken back by Revert) AND a real

Word comment, author "Markelangelo AI", that anyone opening the file in

Word will see. Revert all removes both.

Also in this release:

• A paragraph that holds a picture, an equation or an embedded object is

treated as something to read and leave, so an AI pass cannot lose the

picture by rewriting the sentence round it.

• When the AI breaks the markers round a protected object, the app asks

you once whether to apply the pass while holding those objects still,

and writes nothing until you answer. Same dialog on every door.

• One set of rules teaches the AI this grammar, and it is sent only when

the document or selection it is shown actually contains such an object.

• On a spreadsheet, every message used to appear twice (the grid brought

its own message host along). It now appears once, where every other

message in the app lives.

None of these was big. Together they were the moments where you pressed

something and the app did the wrong thing, or nothing, and you wondered

whether it was you. Each one is fixed where it was wrong, with a test that

was red before the fix and is green after it.

In the Words editor

• A Divider is the same divider from the Insert ribbon and from the

slash menu: one rule, placed after the paragraph you are in, nothing

else added. Before, the ribbon put it above you and left an empty line

behind.

• A task checkbox can be ticked from the keyboard: Ctrl+Enter ticks

or unticks the task your caret is in, and the box itself is a real

control you can tab to and press Space on. The chord is in the command

palette ("Tick or Untick Task") and the guide's shortcut table.

• The slash menu says when nothing matches ("No matching block: …")

instead of silently vanishing.

• Backspace at the start of a heading gives you a paragraph, once,

with your words kept. It used to step the heading down a level at a

time: six presses to get out of a Heading 6.

• Regenerating the table of contents replaces the old one instead of

adding a second copy. The list is fenced by two small markers that the

editor and every other tool ignore.

• (Choosing Quote by keyboard leaving "/Quote" behind did not happen on

this build; the test that watches for it is now live.)

On the Page tab

• At a normal window width with a Desk panel open, the Page tab showed

one "More" chip and nothing else, because its first group was wider

than the room. Paper, Margins and Orientation are now icon buttons with

their names in the tooltip, so the tab shows its controls. The Manual

style set numbers headings as it always did; it simply could not be

chosen.

• The command palette names the counterpart door the way the surface you

are on does: "Open the Markdown Counterpart" on a Word document, "Open

the Word Counterpart" on markdown.

• The paged preview follows a theme change at once, not at the next

keystroke.

In prompt authoring

• A prompt's Properties save as you change them, like Settings: pick a

model and the next run uses it. The body still saves with Save Prompt,

which cuts a version, and that button now sits in the Properties panel

header and on the prompt's band, with the state spelled out: "Saved" or

"Unsaved (Save cuts version n+1)".

• The pen opens Properties on the Desk. Close it deliberately while on

a prompt and it stays closed next time; open it by hand and it comes

back.

In the status bar

• The word count no longer lags a delivery or a fast typist. A

streaming arrival used to leave it a hundred words behind until the

text stopped; it now agrees within a tenth of a second while the text

is still arriving.

Until now, on a Word document, everything that read "the whole document"

was reading the file as it was opened, not the page in front of you.

Type a paragraph, press MD Switch, and your paragraph was not in the

markdown. Run a whole-document prompt and the AI never saw your new

words. Combine two documents and the unsaved edits stayed behind. The

snapshot history kept the stale text too. The workaround was "save

first", and nothing told you that.

Fixed at the root. A Word tab's projection is now built from the document

on screen, through the same markdown writer as before, so every door that

reads a document sees what you see: **AI runs, MD Switch, Combine, the

snapshot history, drafts, chat context and HTML export.** Type a

sentence, press MD Switch, read your sentence in the markdown.

Tracked changes read as accepted: a pending insertion is included, a

struck-through deletion is left out. That is what the document means,

and it is what the file-based projection already did; struck-through

text never reaches a converted document or an AI prompt. (An interim

ruling, recorded for Andre.)

It costs nothing you will notice: the projection is rebuilt only when

the document changes, never when you switch tabs, and a hundred-page

document rebuilds in about thirty milliseconds.

Under the hood: a new inverse serialiser (pm-to-blocks) turns the live

editor document back into the parsed block model, composed from the

vendored editor's own pieces; no vendored file was patched. A 28-document

parity corpus proves the live projection equals the old one byte for

byte at open, carries typed edits and nothing else, and honours tracked

changes; the witness test that was waiting for this fix now passes with

its marker deleted.

When you steer a Word document in conversation, the AI can now see

the tables, pictures and charts in it, so the prose it writes agrees

with your figures, while it still cannot rewrite them. A pass that

rewrites the opening paragraph leaves the costs table beneath it

exactly as it was, structure and all, and only the paragraphs that

actually changed are marked. If the AI would have changed one of those

objects but cannot, it leaves a note against it in Comments, like a

post-it on a draft, saying what it would have done and why. Notes arrive

with the pass and leave with Revert all. If you ask for a table to go,

it goes as a tracked deletion you can reject.

Also in this release:

• A resumed conversation remembers to open with a recap, even if you

quit the app in between.

• The interviewer can mark a short but important sentence as one the

writer must see, so "budget is 900 euros a month" is never lost.

• Every privacy stance now names a quick model for interviewing, so the

interview is fast and cheap by default. Totally Local is left to your

own choice.

• A struck-through table or picture is now visibly marked in the

document; before, a correct tracked deletion of a whole block showed

no sign at all.

The Brief saved with a document is now something you can act on, not

just read.

Resume the conversation picks the interview up where it ended, and

opens by recapping where things stand, so you are not left guessing what

was already agreed. It works whether you parked the conversation or

delivered from it.

Write it again from this Brief is the same agreed intent in a

different hand: choose a different writer model, a different voice, or

both, and the second draft arrives beside the one you already have,

as marked changes on a Words document and as tracked changes on a Word

one. Nothing is taken away until you press a door, so comparing two

voices against the same brief is something you can actually see.

Prompt Smith can now write conversational prompts. Describe a prompt

whose quality depends on facts only you hold, and it will mark the

prompt Conversational and draft the interview domains to go with it.

Also in this release: the User Guide gains three sections on talking a

prompt through, and the welcome tour introduces it. Small fixes: a

map's Brief no longer repeats its own name in the header, and the

ghosts status line uses house punctuation.

Conversational Mode now delivers in every world's own language.

On a Word document, what the writer delivers arrives as tracked

changes, exactly like any other AI edit there: the panel says so and

offers the Review tab one click away. Steering a draft (Talk after)

works too; each pass lands tracked, Keep the changes hands you to

Word's own accept and reject, and Reject the AI's changes takes back

precisely what the pass proposed and nothing else.

On a Numbers workbook, press Build it and the layout arrives

under the full spreadsheet contract: a ghost preview before anything is

written, a refusal to overwrite occupied cells (with "Put it below" and

the new "Land on a new sheet", a real sheet created and filled as

one undo step), and, new in this release, **the calculation engine

checks every proposed formula before Apply is offered**. A broken

formula is refused by name: which cell, which error, and what the check

ran against. Anything computed is a real formula, never a baked number.

On a Map, press Map it and the ideas arrive as Ghosts: dashed

suggestions on the canvas that are not part of your document until you

press Keep, one undo step when you do, and free to discard.

Also in this release: an AI delivery on a Word document now scrolls

itself into view instead of landing silently at the foot of the

document.

One honest note: this release's own testing measured a defect older

than it, on Word documents only: the app's internal markdown snapshot

of a Word document updates on load, not as you type, so switching to

markdown or running whole-document AI immediately after unsaved edits

can miss them. The conversational refine loop reads the live document

and is not affected. The root fix has its own prepared session; until

then, saving first is the reliable workaround.

A delivered draft is now the start of the conversation, not the end.

Press Keep steering on a delivered Brief, or run "Talk after: refine

this document" from the AI tab, the palette or the right-click menu on

any Words document, and talk at the draft: "tighter intro", "drop the

references line", "make the closing ask one sentence". Each pass

previews in the document itself as marked changes: deletions struck

through, additions in gold, and nothing actually written. A delta line

states what the pass did, counted by the app from the real diff rather

than claimed by the model. Deliver this version commits the whole

revision as one undo step; Revert all takes it down and costs

nothing.

• Works with or without a prior interview: any Words document can be

steered.

• Refine passes run on the Writer model and are metered separately as

"Conversational refine".

• Also fixed, found by this wave's own tests: an AI delivery immediately

after your own typing could merge with it into a single undo step, so

one Ctrl+Z took both. Every AI landing in the markdown editor is now

its own undo event, so "one step restores" is exactly true. The same

guarantee now covers comment edits, linked-range refreshes and every

map write.

Pick a prompt and, instead of firing it, talk it through. A quick

interviewer asks one thing at a time: who this is for, what it must

achieve, the tone, the scope, the facts only you know. Its understanding

fills a Brief on the Desk as you answer, and any line you correct

yourself is kept verbatim: the model can never overwrite your words.

When you are satisfied (you decide, never the model), press Write it

and a stronger writer delivers the draft into your document as one undo

step. The Brief is saved with the document as its receipt: what was

agreed, who interviewed, who wrote, under which privacy stance, what it

cost, and a Resume the conversation door.

• The new Business proposal prompt ships conversational by default.

Run is always still one click.

• Any prompt can be talked through: from its row in the AI Library or

the launcher, the editor right-click menu, or the Run Prompt dialog.

• Two model seats, Interviewer and Writer, follow your privacy

stance and are yours to override, per prompt or in Settings.

• The interview and the delivery are metered separately in the usage

meter, so you can see what a conversation costs (interviews are

pennies).

• The View ribbon, the right rail and a status-bar pill all reach the

Brief; an unsaved document's Brief follows it when you first save.

Also in this release: prompt, leader and flow names no longer truncate

in the AI Library when the row's hover verbs appear, and a prompt opened

for editing from the Run list is titled by its name rather than

"New prompt".

The Mind Map's fifth staged release closes the programme: a map can

now arrive from anywhere your thinking already lives, and leave again

through a named door.

Where a map comes from

Insert ▸ Mind Map is now a split button. The face inserts a blank

map; the arrow offers four more answers:

• From this document's outline. A chooser lists the whole document

and every heading; headings become nodes, your prose does not travel

and is not touched. The same door sits at the foot of the Outline

panel, where you are already looking at your document's shape.

• From a markdown outline, pasted or picked from a file.
• From an XMind file. Open one, drop one, or pick one: both XMind

formats read, structure and labelled relationships travel, and the

arrival note says plainly what does not (styles and markers). This

is the migration path for anyone arriving from the tool this

feature's own designer used for years.

• Map Switch ⇄, the direction back out: the map becomes a heading

and nested outline in the document, losses named before anything

happens, one Ctrl+Z restoring the map exactly.

Every map that arrives generated, switched or imported comes collapsed

beyond depth two, so a big structure arrives calm rather than as a

wall.

The Guide now teaches it

Help ▸ User Guide gains the Map chapter: the fence and the truth

sentence, both switch directions with their named losses, the Node

panel, hand-drawn links, find, navigation, attachments, export, and

the Ghosts contract — including the trick that is not discoverable

from any button: name a node as a question, and Expand answers it.

Proven as a journey

The Journey Suite gains the Map's own walk: write an outline, switch

it to a map, draw a labelled link by hand, ask the AI to expand a

question-shaped node, keep the answers, attach a file, export the lot

to Word, and reopen. Twelve journeys now walk on every smoke run; the

Map's found nothing.

The same run surfaced four pre-existing faults on the Page tab and one

greyed palette row, none of them the Map's; they were each verified

against a build without the Map's changes and are recorded in the

journey ledger for their own session.

Also in this release

• The release gate itself caught a rare fold fault on the Word surface:

after a slow cold start the AI band could fold every group into More

and never come back. Fixed at the root for every band in the app; the

gate that found it now passes.

For the record

• Map Switch back to an outline and the earlier "Flatten" were one

act wearing two names; they are now one door named Map Switch, per

the one-answer-per-question rule.

• Reading an XMind file added the app's single

read-arbitrary-bytes-from-disk channel, deliberately narrowed to

that one extension; a general file-reading channel was rejected.

• The feature ships ungated, with the commercial gate points marked

in the source for a later decision.

The Mind Map's fourth staged release, and the one the feature was built

for: an assistant that extends your map without ever touching it.

Expand

Select a node and press ✨ Expand. Up to seven suggested children

stream onto the canvas as ghosts: dashed, dimmed, marked with a spark,

hanging off the node you asked from. They are not in your document.

Nothing is, until you press Keep.

One trick worth knowing: a question-shaped node steers the answer.

Name a node "What does wintering in Spain need?" and every suggestion

arrives as an answer to that question.

Suggest Links

The differentiated one. Press Suggest Links and the AI proposes up

to five labelled arrows between nodes your map already has, drawn

dashed until you decide. It can only propose connections between what

exists: it cannot invent nodes, rename yours, or move anything.

The Ghosts contract

• Keep lands every surviving suggestion in one go, and one Ctrl+Z

removes the lot.

• Discard costs nothing and leaves your file untouched, verified

to the byte.

• The hover ✕ removes any single suggestion before you decide.
• Retry asks again from the same place.
• Suggestions never touch your existing nodes, never reach the disk,

and do not survive closing the map. A crash loses only ghosts.

It is the same idea as tracked changes on the Word surface: the AI

proposes, you dispose.

On your own machine

A map run takes the same road as every AI feature: your provider, your

keys or your keyless local model, the Privacy and Sovereignty stances,

and the usage meter. The streaming pill and the status bar say plainly

where the run went and what it cost, "Run cost: $0.00 · Local"

included. Local mind mapping with local AI is a sentence no

competitor's product can say.

Three doors, one grammar

Expand and Suggest Links live on the Map ribbon's AI group, on the AI

ribbon tab (which arrives now the capability does), and on the canvas

right-click menu, which is now Markelangelo's own on the map, exactly

as it is everywhere else. The command palette knows both by name.

For the record

• No new AI plumbing was added. The map's runs travel the existing

engine end to end, which is why every stance and every meter works

on day one.

• The end-to-end tests drive a real streaming provider through the

app's own admin, so the whole road is walked, including the pause

mid-stream that the evidence pictures show.

• The two prompts are first drafts, tuned against scripted runs. A

session with real models is on the list for Andre.

The Mind Map's third staged release. Until now a map stopped at the

edge of its own tab. Now it travels: into pictures, into print, into

Word, and back into plain text when you want it gone.

Export the map itself

The Map ribbon gains Export picture: the button writes an SVG, a

real drawing that stays sharp at any size, with the text selectable

and searchable; the arrow beside it offers a PNG drawn at double

resolution. The picture is the map as it stands on screen, so a folded

branch stays folded in the picture.

The map rides along in every export

Export a document that contains a map and the drawn map is in it, on

every route. HTML carries the drawing inline. PDF and print draw it as

true vector, and the paged preview shows it sitting in the page

between your paragraphs. This closes the temporary state declared in

the last two releases: what you see now prints.

Word deserves its own sentence. A .docx export carries the map as a

genuine vector picture, the same technology Word uses for its own

icons, with an ordinary image behind it so an older Word still shows

the map. Your text arrives at exactly the width it was drawn at, so a

reader's different fonts can never overflow a node.

Flatten, when the map has done its job

Flatten to outline… replaces the map with its readable outline as

ordinary markdown, optionally keeping a picture in the document's

assets/ folder. The dialog names the losses before doing anything:

links, styles and attachments leave the document; the outline and the

picture stay. One Ctrl+Z puts the map back exactly as it was.

Also in this release

• Split buttons and dropdown menus inside a folded ribbon's "More"

overflow now work. Before, at narrow widths, their menus opened and

every entry silently did nothing, on every surface. Found by

pressing the new Export button at a narrow width; fixed at the root

for the whole app.

• A map that cannot be drawn for any reason still exports as its

readable outline, never as an error.

For the record

• The vector painter is vendored from mind-elixir v5 (MIT, recorded),

with its topic walker rewritten against the current library's

canvas, because v6 removed vector export. It paints what this

product added too: node shapes, branch colours, and the attachment

count pill.

• Colours are written into the picture in plain rgb because Word's

SVG renderer does not understand the modern colour notation the app

uses internally. Measured, not assumed.

• The exported .docx has been verified structurally, down to the

vector part inside the file. A human eye on Word 365 itself is the

one confirmation still owed, and it is on the list for Andre.

The Mind Map's second staged release. The Map stops being a picture you

look at and becomes a surface you work: style it, link it by hand, find

your way around it, and hang real files on it.

The Node panel

Select any node and a Node panel appears on the Desk and follows

your selection. Four shapes (Rounded, Pill, Sharp, Bare), six branch

colours drawn from the theme's own accents, text size and weight, and

a list of every link leaving the node with Edit label and Remove beside

it. Nothing about appearance is ever stored as styling: the fence

records a word like "pill", and the look is repainted from your theme

every time.

Links, drawn by hand

Select a node and a small dot appears on it. Drag from the dot, and a

line follows your pointer; let go on another node and the link is made

with its name box already open, so a link is born labelled. Prefer not

to drag? The ribbon's Link button does the same in two clicks, with

the status bar talking you through it.

Finding and moving

Ctrl+F finds a node by name, even inside a folded branch: the branch

opens, the node is centred, and the counter says which match of how

many. A hand control beside the zoom lets you drag the canvas around,

holding space does the same briefly, and Ctrl+plus, Ctrl+minus and

Ctrl+0 zoom the canvas, with Ctrl+0 fitting the whole map on screen.

Attachments

Drop any file onto a node. It is copied into the document's own

assets/ folder at that moment, and the node grows a small count pill.

The pill is a door: click it for the list, with Open and Reveal beside

each file. A file that has gone missing says so honestly and offers

Relocate… instead of a dead link. The Node panel carries the same

list, plus two more doors: Attach a file, and **Create and

attach…**, which makes a real markdown note in your workspace and

points the node at it. Wiki-links typed into a node's own words work

exactly as they do in prose, and the Backlinks panel now shows when

a note is referenced from a Map, marked with a small Map chip.

Honest limits, stated

• Attaching needs a saved document, because attachments live beside it

in its assets/ folder. On an unsaved draft every attach door says

so plainly and offers Save As.

• Removing an attachment takes it off the node and never deletes the

file; the tooltip says so.

• Exporting a document that contains a map still carries the map's

readable outline. The drawn map joins every export route in the next

staged release.

For the record

• Every act on this surface, a shape, a colour, a link, an attachment,

lands in the document as exactly one change and undoes with one

Ctrl+Z.

• Ten links on a 300-node map cost nothing measurable: the whole-map

redraw stays under a tenth of a second.

• The attachment doors are the only places in the app that hand a

document-supplied path to the operating system, so they refuse any

path that would leave the document's own folder.

The first staged release of the Mind Map. A map now lives inside an

ordinary markdown document and opens as its own tab, and both of those

sentences mean exactly what they say.

A map in your document

Press Insert ▸ Mind Map on a Words document. A starter map drops in

at your caret, centred on the document's own name, and opens straight

away as a tab beside it. The tab is filled in Words orange with a ◉

glyph and reads "Camper Tour · Map", because a Map is a second view of

the same document, not a second document. There is nothing new to save:

the map lives in the markdown as a fenced block, the document is the

only file, and Ctrl+S on either tab saves it.

In the document, the fence does not read as a wall of code. It shows a

card: a small sketch of the map, its name, "5 nodes · 0 links", and an

Open as Map button. The card tells you plainly that the markdown is

the truth, and opening the block in any other editor shows a readable

outline, not coordinates.

One undo stack, on purpose

Everything you do on the canvas is written straight into the document,

one action at a time. Ctrl+Z on the map undoes exactly one map action,

in the document's own undo history, and the canvas repaints to match.

Close the document and its Map closes with it; relaunch, and both come

back together.

In your colours

The canvas speaks the theme you write in. Node cards are the theme's

cards, the six branch colours come from the same accent set the comment

lenses use, and the root wears the gold ring the app gives to the thing

that is live. All three themes, no exceptions.

Honest limits, stated

• Exporting a document that contains a map currently carries the map's

readable outline, not a picture. The drawn map joins every export

route (HTML, PDF, Word, and print) in a coming release; this note is

the temporary state the design standard requires us to declare.

• The map's style panel, drag-to-link, find, attachments, AI and Map

Switch are the next staged releases. What shipped here is the

foundation: the fence, the tab, the theming, and the guards that keep

a map from ever damaging your prose.

For the record

• The fence round trip is guarded byte for byte: a prose edit leaves

the fence byte-identical, a map edit leaves the prose byte-identical,

and a fence the app cannot parse is never "fixed", because an editor

that rewrites what it cannot read destroys data.

• Performance is a budget, not a hope: a permanent fixture measures

paint, redraw, reparent and real drag frame timing at 300 and 600

visible nodes, and fails the build if the library's next version

regresses.

• mind-elixir is pinned exactly (npm's latest tag is a prerelease), MIT

verified against the shipped package, and its four unlicensed

companion packages are never installed.

The last of the four pieces of the Settings rethink. The libraries left

Settings, Settings became a page, a prompt became a document you write.

This one closes it: you can now fire the prompt you are looking at, at

the document you were just in, without saving anything first.

Test run

Open a prompt, change a line, and press Test Run on the AI tab of the

ribbon. The prompt runs exactly as it stands on screen, unsaved edits

included, against the document you were last in, and the result arrives

in AI Results like any other run.

Underneath the result there is one sentence, and it is the point of the

whole feature:

> The draft was used as it stands; the prompt was not saved · run on

> chapter · length: medium.

It tells you what was used, which document it borrowed, which variables

it filled from their defaults, and which went in empty. Nothing about the

prompt is written: no version is cut, your library is untouched. The run

itself is recorded in the usage meter, because it is a real call that

really costs money and pretending otherwise would be the more expensive

kind of lie.

A test run takes the same road a saved prompt takes, which is why it is

worth having. The draft travels as a draft, so variables still expand,

your persona still speaks, your global message still arrives last. What

you try is what you would get.

What printing means now

Every export route used to be offered on every tab, including the ones

with no document behind them. "Export as PDF" on the Settings page opened

a page-setup dialog for a thing that has no pages.

Now the export routes need a document. Print is the exception, because it

is the one that makes sense on a prompt: what is on screen is the whole

of it, so Print gives you the prompt as you see it, with the app around

it stripped away. A password field never prints, masked or otherwise.

The rest

• Settings deep links are under test end to end. Every old door into

Settings, from the status bar to the setup banner to a stale keyboard

shortcut, is proved twice over: once against the source, so no door can

quietly point at nothing, and once in the running app, so it lands where

the table says it lands.

• A new journey. The suite now walks the whole prompt life in one go:

find a prompt by something it says, open it, mend a sentence, try it,

keep it, use it.

• The manual's pictures were retaken, and the prompt-editor picture is

now a picture of the prompt rather than of the rails either side of it.

• The smallest window still works. At 720 by 480, Settings and a

prompt both hold, with nothing pushed off the side.

The programme, closed

Four phases:

1. The libraries left Settings for the AI Library on the rail.

2. Settings became one hue-free tab holding one page.

3. A prompt opened where you write, with its variables as chips.

4. Test run, the door contract under test, and the polish.

Everything the rethink promised is in the app and photographed in all

three themes under Future Features/Settings Rethink (Evaluation)/evidence/.

The third of four pieces of the Settings rethink. Phase one took the

libraries out of Settings. Phase two dealt with Settings itself. This one

deals with the thing you actually do in a prompt library, which is

write.

A prompt is a document now

Open a prompt from the AI Library and it arrives as a tab, on the same

writing surface as your chapters. Not a form with a text box in it: the

editor. Spellcheck, the thesaurus, find, quick actions, undo, the slash

menu, right-click, all of it, because it is not a copy of the editor, it

is the editor.

The list stays open on the rail beside it. You can leave a prompt open

for a week the way you leave a chapter open, switch to a document and

back, and it keeps its place and its unsaved dot.

Like Settings, the tab is colourless: a coloured tab means a

document, and a prompt is not one. Unlike Settings, it can be

unsaved, because there is something to save. So:

• One tab per prompt. Ask for the same one twice and you come back to

the draft you already have.

• Ctrl+S writes it to your library, and the library decides whether

that cuts a version.

• It cannot split. Right-click and the entry is there, greyed, saying

why.

• It comes back next launch. Settings does not, because you do not

resume adjusting preferences. A half-written prompt is work.

Your variables are chips

{{length}} is drawn as a small rounded chip saying length, with the

braces out of sight. The three the app fills for you, {{selection}},

{{document}} and {{title}}, read as quieter chips, because they are

not yours to configure.

Click one and it opens: rename it, say how it should be asked for, choose

between free text and a fixed set of choices, give it a default. A rename

changes every place it appears in the body, in one step you can undo.

The important part is what did not happen. The chip is painted on top

of ordinary text; the braces are still there in the document, exactly as

you typed them. That means a prompt comes back out of the editor

character for character, which is the whole reason it was built this way.

Every one of the twenty prompts shipped with the app is now checked

against that on every build.

Type / for the variables

The editor's own slash menu works in a prompt body, with a Variables

group at the top: the ones this prompt already has, the three reserved

ones, and New variable…, which drops a fresh chip and opens it so you can

name it on the spot.

The ribbon's AI tab grows a This prompt group offering the same list

under the same names, plus Save Version and the three panels below. Two

doors, one list, because a door that teaches a different word for the

same thing is a door that teaches you wrong.

Three panels on the Desk

Properties holds everything about a prompt that is not its words:

name, nickname, description, category, tags, which worlds it applies to,

its persona, its model, the global message, whether it shows on the Quick

actions bar, and each variable's settings. Beside the body rather than in

front of it.

Assembled shows what the model actually receives, live as you type:

the persona, then your prompt, then the global message, which always has

the last word. It is deliberately honest about two different kinds of

gap. A variable with a default is shown filled in and greyed, because

that is what will be sent unless you change it. A value that can only be

known when the run starts is marked as unknown in gold, rather than

quietly rendered as nothing.

Versions lists every saved snapshot, and says the rule that surprises

people: a version is cut when the body or the variables change. A

rename or a category move does not cut one, because nothing about the

words changed, and a history full of versions that changed nothing is a

history you cannot use. Restoring snapshots your current body first, so

restoring never costs you anything.

These three are the only panels in the app that are simply not there

when they do not apply, rather than greyed. Every other door keeps its

place and explains itself, because muscle memory matters. These have no

place to keep: they arrive with a prompt and leave with it, and three

permanently dead doors on every writer's Desk would be noise.

What went away

The temporary editor Phase 1 put in place is gone, on schedule, along

with the old three-column prompt workbench it was holding. Personas open

the same way. The global message opens as its own tab. Prompt categories

stayed a dialog on purpose: renaming a folder is filing, not writing, and

it belongs beside the list it files.

Five faults worth naming

Every shipped prompt gained a blank line. Writing a paragraph

straight onto a list is legal markdown, and the editor's canonical form

puts a blank line between them. Left alone, opening any prompt and

pressing Ctrl+S would have cut a version whose only change was invisible.

The twenty prompts are now stored in the form the editor writes, and a

prompt written by an older version is quietly re-based when you open it,

so it never opens already dirty either.

One prompt was rewritten for a different reason. "Draft from a brief"

asked for [placeholders] in square brackets, which markdown escapes.

The words a model receives had a backslash in them that nobody put there.

It now asks for a placeholder in capitals.

The slash menu's Variables group was missing your own variables. Only

on its first open, and only until you typed a letter, which is exactly

the sort of fault a green suite is happy to hide. The editor's menu

builds its list once, when the editor is created, and caches it; at that

moment the document has not been put in yet, so it asked an empty page

what variables it had. It reads the prompt itself now, which knows before

the editor is even built.

The tab was called "New prompt" for a prompt that had a name. Opening

Summarise gave you a card saying New prompt, and a window title to match.

The list knew the name all along and simply was not passing it.

The status bar called a prompt a draft. It said "Draft, Ctrl+S to

save it to a file", and a prompt has no file. It reads Saved or Unsaved

now, which is the truth, and the world name beside it stands down for the

same reason it does beside Settings.

Still to come

Phase 4 adds Test run (run the draft you are looking at, unsaved

changes and all, and see the result), walks every old door under test,

and brings the manual up to date.

The gate

Types clean on both processes, 2,720 unit tests, and the end-to-end

suite.

Thirteen new checks cover this phase, and the sharpest of them are about

{{name}}: the chips are drawn, the braces are not, and a prompt saved

and reopened comes back exactly as it went in.

The full end-to-end sweep owed from 0.67.0 also ran, on a quiet machine.

It found two more checks still written against the Settings overlay that

0.67.0 replaced, and both are re-pointed rather than relaxed.

Evidence, all three themes, beside the accepted prototype:

Future Features/Settings Rethink (Evaluation)/evidence/phase-3/.

The second of four pieces of the Settings rethink. Phase one took the

libraries out. This one deals with what was left, which was your own

observation: Settings did not feel like part of the same app.

It opens as a tab now

Press Ctrl+comma and Settings arrives in the tab strip beside your

document, instead of a full screen dropping over the top of it. Your

document keeps its place, and you can see it is still there.

The tab is deliberately colourless. In this app a tab's colour tells

you which world a document belongs to: orange for Words, blue for Rich

Words, green for Numbers. Settings is not a document, so it wears no

world colour and takes the plain highlight instead. That is not an

exception to the rule, it is what makes the rule readable: a coloured tab

now means one thing only.

Because it is furniture rather than a document, it behaves like

furniture:

• There is only ever one. Press Ctrl+comma again, or take any of the

thirty-odd doors that lead here, and it focuses the tab you already

have. Two would be two scroll positions and two answers.

• It can never be unsaved. There is nothing to save; every control

saves as you touch it.

• It cannot be split. Right-click the tab and the Split entry is

there, greyed, saying why: Settings is furniture. A control that simply

vanishes teaches nothing.

• It does not come back next launch. Your documents return, because

you resume writing. You do not resume adjusting preferences.

One page instead of twelve tabs

Ten sections, one scroll, in the order you would read them: General,

Appearance, Language, Quick actions, Markelangelo Labs, Voice, Privacy &

Sovereignty, Models & Providers, Knowledge, AI Images. An index on the

right says where you are and takes you anywhere.

Nothing has moved out of reach. Every old door still lands where it

always did, and several now land better: a door that names a control

scrolls to that control and puts the cursor in it, rather than dropping

you at the top of a long page to go hunting.

Every section says what it is, and what it costs you

Beside each heading is a small i. It answers the same four questions

every time:

• Overview. What this is.
• Relevance. Why it would matter to you.
• Use case. What you would actually do with it.
• Privacy considerations. What travels, where it goes, and under

whose terms.

The fourth one is why this exists. Privacy answers were scattered across

release notes and a manual nobody has open at the moment they are

deciding whether to switch something on. Now the answer is beside the

switch, and it never says a comfortable nothing: where the honest answer

is "your speech goes to the transcription provider under their policy",

that is what it says.

Voice says it is an experiment

Dictation now wears a Labs mark on its own heading, not only in a

release note. Its information panel spells out where speech travels and

why it stays experimental until a local option exists.

And the button that said "Set up in Labs" now says Set up Voice,

because there is no Labs page holding Voice; there is a Voice section,

which is where the button was going all along.

The status bar stopped describing a document that was not there

With Settings in front, the bar was still saying "Draft" and naming a

world. There was no document. Both now stand down, because chrome that

describes something you are not looking at is worse than chrome that says

nothing.

Two faults worth naming

The whole app failed to start, once. The Settings page reads the

feature register to find its sections, and the register loads the tabs

feature, which loads the thing that draws the page. Each waiting on the

other, and nothing to show for it but a blank window with no error at

all. The page is now loaded at the moment it is first needed, which

breaks the circle.

Deep links were landing near the right place rather than on it.

Sections above the target were still filling in (provider lists, key

states, model catalogues), and each one that grew pushed the target

further down after the scroll had already been aimed. It lands again once

the page stops moving.

Still to come

Phase 3 opens a prompt as a real tab in the real editor, with

variables as chips and a proper save that cuts a version, and deletes the

temporary editor Phase 1 put in place. Phase 4 adds Test run, walks

every old door under test, and brings the manual up to date.

Seven checks re-pointed, and one made honest

Seven existing end-to-end checks walked to Settings by clicking a rail of

tabs inside an overlay, which is exactly what this release removed. Each

now asks the question the new shape answers: not "is that rail button

lit" but "is that section at the top of the page".

One of them was quietly wrong in a way worth naming. Three checks

asserted that a library door does not open Settings by looking for a

dialog that no longer exists, so they were passing for the wrong reason.

They now look for the page itself, and the two where the test had already

opened Settings for other reasons no longer make a claim they cannot

honestly make.

And one found a real difference. The old overlay was rebuilt every time

it opened, so anything that checked the outside world (is a key set, is a

provider reachable) re-checked on every open. A tab stays put, so it

checks once. For anything you change inside Settings this makes no

difference, because the control updates as you use it. The check that

noticed had been setting a key behind the app's back and relying on the

rebuild; it now types the key in and presses Save, like a person.

The gate

Types clean on both processes, 2,672 unit tests, and the end-to-end

suite. Eight new checks cover this phase, and most of them are negative:

Settings must not duplicate, must not split, must not go dirty, must not

return on relaunch. Those are all things a tab normally does, and each

would look like a feature rather than a fault if it started happening.

Evidence, all three themes, beside the accepted prototypes:

Future Features/Settings Rethink (Evaluation)/evidence/phase-2/.

This is the first of four pieces of the Settings rethink. It answers one

question: why did tending your own prompt library mean covering up the

document you were writing?

Prompts and personas live on the rail now

Open the AI Library on the left rail. It always held Prompts,

Leaders and Flows. It now holds Personas too, and the Prompts room

has grown a second verb.

Run is the list you want with a document under your hands: click a

prompt, it runs. Manage is the list you want when the library itself

is the work: search, category chips, and a right-click menu on every

prompt with Open, Run on selection, Duplicate, Version history, Move to

category and Delete.

Same prompts, one address, one switch between them. The old Manage

button that closed the room and opened Settings on top of your document

is gone, because there is nowhere left for it to go.

The search reads what you wrote

Before this, searching the library looked only at names, nicknames,

descriptions and tags. So if you remembered writing a phrase inside a

prompt, and not what you had called it, the library had no way to find

it. Which is the wrong way round: the words you wrote are the ones you

remember.

The search now reads prompt bodies as well, and when a prompt matches on

its body alone, the row shows you the matching words in context so you

can see why it came up.

Duplicate

Right-click any prompt and copy it: same instructions, new identity, no

inherited history. The safe way to try a variation on something that

works, without risking the thing that works.

Leaving a half-written prompt now asks first

The old Settings surface closed on Escape without a word, and whatever

you had typed went with it. It asks now.

Personas are a room, not a page

A persona is a delivery voice you keep and reuse, exactly as a prompt

is. It had been marooned in Settings, so the only way to look at your own

voices was to cover your document with a settings screen. It has a room

now, beside the prompts it attaches to.

Every old door still works

There are thirty-odd places in the app that used to say "open Settings at

the prompt library": the palette, the ribbon, the welcome tour, toast

buttons, the message you get when a prompt does not apply to the document

in front of you. None of them were rewritten. One table now decides where

a settings id belongs, and it sends the library ones to the rail and

everything else to Settings, exactly as before.

Two of those doors got better rather than merely surviving.

The message about a prompt not applying here has an Open the library

button, and it now selects the prompt it was talking about rather than

dropping you in a list of thirty and leaving you to find it.

And Edit Global Message… and Prompt Categories… open the global

message and the category manager. A door that names a thing should open

that thing; landing you on a list with the thing somewhere in it is the

promise redirected to a search.

Settings said so, once

On first launch after updating, a bar explains where your prompts went,

with a Show me that takes you there. It speaks once and then never

again, and the record is kept in your settings rather than in the window,

so closing the app is not a way of being told twice.

If you waved it away too quickly: Help ▸ What changed in Settings?

Settings is ten pages now

General, Appearance, Language, Quick Actions, Markelangelo Labs, Voice,

Privacy & Sovereignty, Models & Providers, Knowledge, AI Images.

Quick actions stay here on purpose. A quick-action chip is a shortcut

that points at a prompt, not a prompt itself, so it belongs with your

preferences. The prompt it points at lives in the library.

Two things found while looking at something else

A stray file called 15 had been committed by accident, ten bytes of

nothing from a mistyped command. And two source files carried an invisible

control character inside a text string, one of them a leftover from a

shell quoting accident and harmless, the other deliberate but unreadable

in the source. Both are now written so a human can see them. Neither

changed how anything behaves; both were the kind of thing that becomes a

baffling bug six months later.

Three smaller things, each found by using it

Leaving a prompt list that has changed shows the change. Rename a

prompt in the editor, come back, and the list behind it was still showing

the old name until it happened to reload.

One press of Escape peels one layer. Closing the category manager

was also closing the editor behind it.

Four doors, one row, no scrolling. The room's fourth tab was

scrolling off the end at the rail's default width, which is precisely the

fault the AI Library was built to fix, and a prompt's world label spelled

out in words was eating half the row and truncating the prompt's own name

away. Both were found by looking at the screenshots, not by a failing

test. The pictures are part of the work for exactly this reason.

Still to come

This phase deliberately did not build the eventual prompt editor. Opening

a prompt takes you to today's workbench in a plain full-height surface

with a way back, and that surface is scaffolding with a stated death

date: Phase 3 opens a prompt as a real tab in the real editor.

Phase 2 turns Settings itself into one scrolling page in a tab.

The gate

Types clean on both processes, 2,669 unit tests, and the full end-to-end

sweep. Ten new end-to-end checks cover this phase, the sharpest being a

negative one: Manage must not open Settings. That is exactly the sort of

regression a green suite would hide, because everything would still

appear to work.

Four existing checks were re-pointed rather than relaxed. They walked to

the prompt editor, the AI builder, a chrome text field and the deep-link

landings by way of Settings, which is precisely the route this release

removed. Each now walks the route a person walks, and the deep-link check

asserts the new thing worth asserting: that a library door does NOT open

Settings.

A fifth was given a bigger stopwatch, which needs saying plainly because

it looks like the thing you are not supposed to do. The check that

keyboard shortcuts still open panels on a Word page had one minute to run,

and the Word page it opens can take most of a minute to paginate under a

full suite. It could only ever pass on an idle machine. Nothing about

what it checks was weakened; it was given a budget its subject can

actually meet.

Evidence, all three themes, beside the accepted prototype:

Future Features/Settings Rethink (Evaluation)/evidence/phase-1/.

Everything in this release was found by one instruction from Andre:

make a spreadsheet outside the app, with charts in it, and open that.

It took about a minute to find the first fault, and the afternoon to

find that there were three.

Charts from anyone else's spreadsheet were the size of a stamp

Open a workbook carrying three ordinary charts, made anywhere but here,

and all three arrived squashed into a single cell. About a centimetre

wide. Not missing, not failed, just drawn far too small to read, which

is worse, because nothing looked broken enough to report.

A spreadsheet can pin a chart to the page two ways. One says "from this

cell to that cell", and the distance between them is the size. The other

says "start here, and be this big", stating its size outright and naming

no end cell. We only ever handled the first. The second came out as a

size of zero.

Excel normally writes the first kind. A great many other things write

the second: other spreadsheet apps' exports, and effectively anything

generated by a script. **Every test file this project owned was made by

this project**, so the second kind had never once been opened here.

It affects pictures too, not only charts.

A chart in one of those files could not be deleted

Select it, press its ✕, and the app said "Visual deleted, save with

Ctrl+S". Save, and the chart was still there. The document stayed dirty

for ever, and the only clue was an error message blaming the file.

Two separate faults, and it took a matched pair of test files to find

both. Two workbooks identical in every way except one small spelling

choice inside them were put through the same steps, and they **failed

differently**. The first could not find the chart at all. Once that was

fixed, both then failed at the next step, on something with nothing to

do with the first. Had the first fix been declared a success without

re-running both halves, the second would still be there.

The paste offer no longer expires while your back is turned

Copy a range in the spreadsheet, get pulled into something else for a

quarter of an hour, come back and paste into a document, and the richer

paste options had silently expired. Flat text, no explanation.

There was a ten-minute clock behind that, and it was never what made the

feature safe: a separate check that the clipboard still holds what was

copied was doing that work all along. The clock only added a way to fail

quietly. It is gone.

Two records corrected

A note beside one of Andre's older findings still said half of it was

outstanding. It had been finished on 17 August and the prose beside the

ledger was never revisited. Worth knowing where staleness hides: not in

the tables, which get reconciled, but in the sentences next to them.

The action-surface line now records Andre's ruling that pressing every

control moves into his own per-surface deep testing, with his reasoning

rather than just the outcome, and stays marked open because deferred is

not done.

And the one I tried to leave in writing

A workbook with one damaged chart reference opened, showed none of

its charts rather than just the broken one, and then ignored every

keystroke without saying a word. I wrote it up carefully as a deferred

item, with a recipe, and moved on.

Andre's answer was to ask why anything known and unfixed was being left

at all. He was right, and it was fixed the same afternoon.

The cause was a single character: one unreadable part reported its

failure upward and aborted the whole workbook read, which is what

everything else was waiting on. Two lines above it, the code already knew

how to skip a visual it could not resolve. It simply was not doing it

consistently. Now a part that cannot be read costs that part, and nothing

else: the grid, the numbers, the other charts and your ability to type

are never in the blast radius.

And it speaks now. The file says, once, and you can send it away:

> One chart or picture in this workbook could not be read, so it is not

> shown. Everything else opened normally, and saving will not remove it

> from the file.

That last sentence is the one that matters. The first thing anyone thinks

on reading such a warning is whether saving will finish the job. It will

not.

A workbook that quietly showed two of its three charts would only have

been a slower version of the same bug.

The gate

Types clean on both processes, 2,656 unit tests, and the full

end-to-end sweep at 248 passed, nothing failed, in forty minutes.

The two skipped are the pair that were deliberately marked

known-unfinished in 0.64.0, and they still say so.

Three tests failed on the sweep before this one and were fixed at their

causes rather than retried. Two of them turned out not to be timing at

all: one was looking for a confirmation message and finding two, and one

was reading the menu bar before the app had finished rebuilding it. The

third measured a ribbon on a stopwatch instead of waiting for it. None of

the checks were weakened; only the moment they are taken changed, and it

is now decided by the app rather than by a guess.

Three more lines of the completion contract closed, which takes it from

52 to 55 of 61. Only three are left, and one of those is the big

press-every-control sweep.

The ribbon no longer crushes itself in a narrow window

Open the app at its smallest supported size, with the left rail up and a

panel open on the right, and the writing pane gets about 284 pixels for

its ribbon. Six tab names plus the File button already need more than

that, so the quick actions on the right were being squeezed off the edge:

Prompts cut mid-word, the Add button unreachable, the privacy badge gone

entirely.

Now the tabs get out of the way instead. They fold whole into a small

chevron, exactly as the buttons below them already fold into "More", and

the chevron keeps the gold underline so you can still see which tab you

are on. Click it and every tab is there. Widen the window and they come

back one at a time.

Two things only measuring could have told me. There is **no floor of one

tab**: even a single tab beside the chevron ate into the quick actions,

so all six fold together at the narrowest size. And the chevron's own

label is a step on the same ladder: it shows the active tab's name when

there is room and drops to the bare arrow when there is not.

The test that guards this used to close the right-hand panel before

checking the narrow width, which is exactly why the fault went recorded

instead of caught. It now opens a panel, proves it is open, and fails if

it is not.

Three shelved spreadsheet controls now have their reasons written down

When the spreadsheet ribbon was cleaned up, forty dead controls came out.

Three of them were worth coming back to, and until today the only record

of that was inside an audit document. Each now has its own place in the

Future Features catalogue, and the seeds argue rather than just list:

Breaks and Page Layout cannot start until printing works, because a

page break has nothing to say until a workbook has printed pages. It is

blocked by design, not by cost.

Create from Selection turns headings into names, so a formula reads

=SUM(Q1_Revenue) instead of =SUM(B2:B13) and survives an inserted

row. The seed makes the case that this is a product idea rather than a

spreadsheet one: it is the Framework thought one layer down, and it

compounds with the spreadsheet AI, the linked ranges and Form Mode.

Protect Workbook has a first deliverable that is a sentence, not a

dialog. Office protection stops an accident, not a person, and this

product cannot ship a padlock that implies otherwise.

The vendored spreadsheet's own record also gained a corrected count, a

note that some leftover styling is dead rather than load-bearing, and a

pointer to where every removal's reason lives, with a warning: several of

those controls had no machinery behind them at all, so putting the button

back would recreate the dishonesty that removing it fixed.

One page now answers "does it all still look like one product?"

There is a new document beside the design standard that says, dimension

by dimension and world by world, whether the rules are actually kept:

type, icons, shape, spacing, motion, feedback, themes, across all three

worlds, with the evidence named in every cell.

It has four verdicts rather than a tick or a cross, and one of them is

"ceiling", because writing "held" over something a screenshot cannot

prove is how a table like this turns into decoration. On its first pass

motion was a ceiling in all three worlds, and going to find out why is

the next section.

It is gated so it cannot rot. Signing it is now a step in the release

runbook, and any new surface has to fill in all seven dimensions before

it ships.

It earned its keep within the hour

Filling in the motion row honestly meant going to look for the evidence,

and looking for the evidence found a real fault.

Windows lets you say "stop moving things", and plenty of people need

that: migraine, motion sickness, vestibular trouble, or simply not

liking it. Our own design standard has said since it was written that

reduced motion gets no animation. **Both of the borrowed worlds honoured

it. Ours honoured it nowhere.** Every dialog, menu, panel and toast

still slid and faded at somebody who had asked their machine not to.

It is fixed, and the fix has a detail worth knowing. The rule slows

animation to a hundredth of a millisecond rather than switching it off,

because the menus wait for an animation to FINISH before they disappear,

and an animation that never runs never finishes. Switching it off would

have left dialogs stranded on screen. So the test checks both halves:

nothing moves, and the dialog still closes.

Measured, not asserted: the longest animation on screen goes from 0.200

seconds to 0.000.

Nobody had caught this because the standard says the rule, so reading

the standard makes it look kept. The table is the first thing that ever

asked whether the app actually does it.

Started, and honestly not finished

The last two spreadsheet checks are still open, and one of them now has a

half-built test with a note on it rather than nothing at all.

The shape of the proof is right: it checks the saved FILE rather than the

screen, states what the workbook looked like before, and proves the work

survived by opening the file again and saving it a second time, so

anything our reader did not understand would be gone. What it cannot do

yet is reach the controls: those three buttons are invisible covers

inside the borrowed spreadsheet's ribbon, and the whole group folds away

at the width the tests run at. Opening the fold first and forcing the

click both failed.

It is marked as known-unfinished rather than quietly deleted or

weakened until it passed. Solve the reach and the checking is already

written.

Also in this release

A test that had been failing about one run in three was fixed at its

cause: on a cold first launch the Word surface parses the document before

its AI tab can say which buttons are live, and the check was giving it

five seconds. It gets thirty now, the same as the wait just above it.

Both of your rulings from this morning, plus the oldest untouched finding in

the log, plus a sweep of the documents that had drifted out of date.

"AI is switched off" now waits until it knows

You said the sentence is not strictly accurate for someone running on a Claude

subscription, and that it should stay for anyone who genuinely has no AI at all.

That was already the intended rule, and it was already written down. Two things

made the app say it anyway.

It asked at the wrong moment: the banner only re-checked whether your

subscription was connected when the setting changed. Connecting is not a

setting change, so if you reconnected while the switch was already on, the app

went on telling you your AI was off until you restarted it.

And it answered before it had asked: the check is a round trip, and the

banner drew itself before the answer came back, so it could flash "AI is

switched off" at a connected subscriber on every launch.

One place now answers the question, the banner waits for that answer before it

says anything, and it re-asks whenever the connection actually changes. Where

there is genuinely no key, no local model and no subscription, the banner

stands exactly as it did.

The loading dialog stays dismissible

You confirmed the call taken in your absence: the point is telling you

something is happening, and you can wave it away and keep working. No change,

now recorded as your ruling rather than as an open question.

A divider no longer vanishes on the way into a Word document

This was the oldest untouched item in the findings log. Put a horizontal line

in a markdown document, cross it over with Rich Switch, and the line was simply

gone: nothing said, nothing to undo.

It turned out to be two separate holes with the same cause, a belief that Word

had no way of drawing a rule. It has: an empty paragraph with a line under it,

which is exactly what Word itself writes when you type three dashes. So the

line now survives all four ways it can travel: Rich Switch, an AI answer, a

pasted snippet, and the Word export. It also comes home again, as a proper

---, when you switch a Word document back to markdown.

Worth saying plainly, because it changes how much to trust the old note: the

converter that the finding blamed was only half the story. The route you

actually used, Rich Switch, goes somewhere else entirely, and the tool it uses

throws horizontal rules away without a word. That was found by testing the real

journey rather than by reading the code, which is the only reason the fix is

whole.

The manual's pictures were quietly broken

Eleven of the screenshots the online manual is built from were failing to

capture. Three of them did not exist on disk at all, so the published manual

had broken images; the rest were between three days and six weeks old.

Four causes, all found by running the thing rather than reading it. The harness

opened the command palette with a keyboard shortcut that belongs to the native

menu, which the test driver cannot press, so the palette never opened and the

command name was typed into the document instead. Two features had moved rooms

and it was still knocking on their old doors. It left a full-screen canvas open,

which a screenshot passes through but a click does not, so everything after it

quietly failed. And the picture captioned "Voice" was in fact a photograph of

the Settings page.

Two are left, and both now fail at the last step rather than the first: the

slash menu will not hold still long enough to be photographed, and the

right-click menu does not appear for the harness. Nine of the eleven are fixed

and every other picture in the manual is taken from today's build.

One section was describing a band that no longer exists, so it was rewritten:

the manual now describes the ribbon and its six tabs, which is what you actually

see above a document.

One view of the truth

Chasing your dashboard question turned up a set of documents disagreeing with

each other, so they were reconciled rather than patched:

• The roadmap said 32 of 59 lines closed. It is 52 of 61, and the figure

had been stale for five releases. The roadmap no longer keeps its own copy of

the number, it points at the one ledger that owns it.

• Your dashboard read one line ahead of the truth, because the printing

line's status began with the word "UNBLOCKED" and anything scanning for

keywords reads that as done. It means the work is now allowed. The contract

now says what each status word means, and the printing line says plainly that

nothing has been built.

• The handoff note guessed at the broken screenshots ("about eight"). It is

eleven, measured, and named.

• A new short table says where each kind of truth lives: progress,

schedule, your findings, known faults, so the next person does not restate a

number from memory.

Three pieces of work: your ruling on the cold-model wait, the public site

finally admitting the app opens Word documents and spreadsheets, and the

residual verification slice, which found a real defect within minutes.

The thing you asked for

**A model loading on your own machine now says so, in a dialog that clears

itself.**

You asked for exactly this after the 43-second measurement. It is built on

fact rather than a stopwatch: both local servers we support (LM Studio and

Ollama) will say outright which models are loaded, so the app asks, and states

what it was told. If the server cannot answer, and the run has produced nothing

after four seconds, the dialog appears anyway with softer wording. Silence was

the original defect, so "we could not tell" never means saying nothing.

It names the model, says nothing is being sent anywhere, and counts the seconds,

because a wait with no moving part is indistinguishable from a freeze. It

vanishes the instant the first word arrives, with nothing pressed.

One judgement made in your absence, flagged for you. The dialog can be

dismissed ("Carry on working", or Escape) and the run continues underneath.

Having just told somebody their wait might last forty seconds, holding their

document hostage for all of it seemed a worse bargain than the shimmer it

replaced. Say the word if you would rather it blocked.

It only ever appears for models on your own machine. A hosted provider has no

weights to load, and telling you a cloud model was "loading" would be an

invention. There is a test that proves it never claims it.

The website was describing a different product

The public manual and the landing page did not mention the Word world or the

spreadsheet world anywhere. Not "used the wrong name": did not mention them

at all. Anyone reading markelangelo.me learned about a markdown editor.

Now there is a Three worlds, one workshop section, placed first under

Writing, with real screenshots of a Word document and a spreadsheet open in the

app, and it leads with the thing that actually sells them: every prompt and

persona you build works in all three, arriving as a tracked change in Word and

as cells in a spreadsheet. The landing page gets a feature card saying the same

in one breath, and the introduction now says it in its opening line.

The checks, and what they caught

Diagrams were disappearing from Word exports. A Mermaid diagram exported

fine to HTML and PDF, and to Word it exported as nothing at all: no picture,

and not even the source text left behind. The reader just lost it. Worse, the

code carried a confident comment claiming Word handled it natively, and nobody

had ever opened one of the files to check. Fixed: Word exports now carry the

diagram as a real picture, verified by opening the .docx and finding it.

Zoom is now per document on markdown, matching Word documents and

spreadsheets, which already worked that way. Zoom a contract to read the small

print and your notes in the next tab stay exactly as they were. Settings still

holds your default: a document you have never zoomed follows it, and one you

have zoomed keeps what you chose.

Also walked, in the built app, and all correct: Zen mode in all three worlds

with Escape to leave; select-then-do with the same verbs on the ribbon and on

right-click; Paste as Plain Text in a Word document. The idle tab colours were

re-measured across all three worlds and all three themes, which had never been

done since the spreadsheet world arrived.

Still open, and honest about it

Two of the nine checks are not done: the spreadsheet Styles trio and the

chart-fallback grey. Both are inside the vendored spreadsheet, and the second

needs a workbook with a real chart in it, which does not exist yet as a test

fixture. They are named in the contract as open rather than quietly ticked.

The numbering-collision offer was closed after this note was first drafted: it

is walked both ways now, including the check that refusing it writes nothing.

One clause of the Zen check is also not claimed: reduced motion needs a

recording or measured timings, and a still cannot prove motion.

Read this line first: almost nothing in this release changes what you see.

It is the machinery that stops future releases shipping broken chrome. Two

things it found along the way are real fixes, and they are at the top.

What it found, and fixed

Three ribbon buttons had no name. Insert ▸ Picture, Insert ▸ Callout and

View ▸ Split are split buttons: an icon you press for the usual thing, and a

caret beside it for the rest. The label sits on the caret, so the half that

does the work announced nothing at all to a screen reader. Both halves are

named now.

"Sync scrolling" did nothing. It sat live on the View tab whether or not

the window was split, and pressing it with no split simply returned. It is now

greyed with the reason, and the fix is at the root rather than on that one

button: any ribbon button wired to a command now takes its greyed state from

the command itself, and shows the reason the command already carries. No future

button has to remember.

"Chat with Notes…" lost its full stops. The three dots promise a dialog and

it opens a panel, so the palette was offering the same door spelled two ways.

The guards themselves

Nothing on screen can be a dead end. A new check walks the ribbon, the

status bar, both side rails, the tab menu, the File menu, the native menus and

the palette, in all three worlds, and fails the build if a control that looks

live points at something that cannot run, or if it has no name. It proves

itself by planting both kinds of broken button and confirming it catches them.

How much of the app that covers is written down honestly in a new document,

docs/ACTION-SURFACE-MATRIX.md: fifteen surfaces, each with who checks it and

at what depth. One of three passes is done. The big one, actually pressing

every button and checking what happened, is not started and says so.

Names are checked on the screen, not in the code. The old check read source

files, which can only see a word someone typed as a literal. The new one reads

the app's own rendered chrome and asks two questions of every string: is it a

banned synonym, and is it a near miss of a name the app already spells

elsewhere (right words, wrong capitals, missing full stops). That is how the

"Chat with Notes…" drift above was found.

Saving is now proved by reopening. The three "make a document, type, save"

tests checked that a file appeared and was over a kilobyte. That would have

passed on a save that wrote a perfectly valid empty document. Each now closes

the app, opens the saved file fresh, and reads the sentence back.

Real timings, from a real model. Release evidence now records how long

exports actually take on a small document and on a picture-heavy one, and how

long the AI takes to say its first word, measured against a real model running

on this machine. The provider, model and document are recorded beside the

number, because the number means nothing without them. Exports land between a

tenth and two thirds of a second; the AI's first word arrives in **about six

tenths of a second** once the model is loaded.

That last phrase is doing real work, and it turned into the finding below.

One thing found, and deliberately not fixed here

A cold local model can make Markelangelo look like it has hung.

The same measurement, run twice on the same machine with the same model and the

same document, read one second once and forty-three seconds the next.

Nothing in the app changed between them. The difference was whether LM Studio

already had the model loaded: a cold one reads nine gigabytes off the disk

before it can answer a single word.

For all forty-three seconds the app shows one shimmering "Thinking…". That is

honest at one second and looks like a crash at forty.

It is written down rather than fixed, because the fix is a design decision and

not a guard, and it is your call:

• The app knows whether it is waiting on a model loading or a model

thinking, and those deserve different words.

• A wait past a few seconds probably wants a clock, or a way out.

It only affects models running on your own machine, which is the keyless,

nothing-leaves-the-laptop path. A hosted provider has no weights to load. The

numbers and the reasoning are in docs/measurements/README.md.

Held back

The check that every claim in the in-app user guide is true is **held with the

guide itself**, which you paused while features are still moving. Asserting a

document that is deliberately going stale would have an expiry date on it. It

is a condition of the first promotion rather than a dropped line: the guide

ships inside the app, and a wrong guide is worse than no guide.

One change, and it is the one that makes knowing a command's name worth

something.

What was wrong

The command palette listed only the commands that could run on the document in

front of you. That sounds sensible and it is not: a command that did not apply

was not demoted, it was absent. Open a spreadsheet, type "Insert Table of

Contents", and the palette said no such command exists. It does exist. It has

existed all along. You were simply in the wrong room and the palette would not

say so.

That is exactly backwards for a palette, whose whole job is: I know what this

is called, take me to it.

What it does now

The palette ranks by where you are, and withholds nothing.

Type anything and results come back in three bands, in this order:

• Here — what runs on the document in front of you, right now.
• Always — the short list that is present in every world: Save, Undo, Redo,

Find, Zoom, Settings, and the AI Results, Usage and History panels. (This is

the "declared global set" you signed off in the rails-and-panels sheet.)

• Elsewhere — everything that cannot run here, demoted rather than deleted.

An empty query paints what applies here plus what you last ran, so the list

opens on your own habits rather than on the alphabet. The app now remembers the

last eight commands you ran, from any door: the ribbon, a menu, a shortcut or

the palette itself.

Typing the name always wins

If you type a command's exact name it jumps to the very top under **Exactly

that**, above all three bands, whether or not it can run here. That is the

promise that makes demotion safe: you can never lose something by knowing what

it is called.

A demoted row is a door, or it tells you why

Every row in the Elsewhere band does one of exactly two things, and never a

third:

• It is a door. "Insert Table of Contents · Go to Report · Words" — it says

where you will land before you press it, and pressing it takes you there.

Doors appear when a document of the right kind is already open.

• It is greyed and says why. "Reopen Closed Tab · You have not closed a

document in this session yet." Nothing to go to, so it explains instead.

Neither is a silent refusal, which the app's own rules have banned since the

first audit. The reason is written into the row itself rather than hidden in a

tooltip, so a keyboard or screen-reader user reads it as part of the row.

The guard behind it

Every command that can say "not here" now has to carry the sentence that

explains it, written next to the rule itself so the two cannot drift apart.

Where a sentence already existed for the File menu, the palette reads that one

rather than inventing a second.

Three checks run on every build and one runs the app for real:

• from each of the three worlds, every registered command is typed by its

exact name and must come back first;

• a command that says no without saying why fails the run;
• the bands must paint in order, and every demoted row must be a door or carry

a reason;

• and the cap on how many rows show is applied per band, so a broad query

can never quietly hide a whole band. That one was found by measurement, not

by reasoning: typing "s" in a workbook painted one band and the fix followed.

Two things, both about shortcuts.

Every panel has a shortcut, and it works everywhere

Twelve panels, one scheme you can guess: **Ctrl+Alt and the panel's own

initial**. Outline is Ctrl+Alt+O, Comments is Ctrl+Alt+M, History is

Ctrl+Alt+H, AI Results is Ctrl+Alt+A, the Thesaurus is Ctrl+Alt+T. Press it

again and the panel goes away, so the way in is also the way back.

The part that took the care is everywhere. Markelangelo hosts two borrowed

editors, and they bring their own keyboard handling: anything the app does not

claim first, they swallow. That is not theoretical, it is exactly what the

first audit measured, with Ctrl+comma dying the moment your cursor was in a

spreadsheet cell.

So the app now claims its own shortcuts before any editor sees the key. The

test proves it the only way that means anything: it puts the cursor genuinely

inside each editor first, a caret in the prose, a real selected cell, the

caret on a Word page, and only then presses.

A shortcut for a panel that cannot work where you are does nothing at all,

rather than opening a pane that would immediately stand down.

One place now owns every shortcut in the app

This is invisible, and it is the reason the first half is trustworthy.

Shortcuts used to be declared wherever they were needed: the native menu had

one, the command had another, the ribbon button a third. **Eighty-six

declarations for fifty-five shortcuts**, in up to three places each, with

nothing checking they agreed. That is how the command palette came to advertise

formatting shortcuts that were bound to nothing at all, which you found in

August.

There is now one table, read by both halves of the app, and every one of those

eighty-six declarations asks it. Four checks run on each build:

• no two commands may claim the same keys where both can be present;
• the clash detector proves itself by planting a clash and confirming it is

caught, and by planting a legitimate one (two different worlds, same keys)

and confirming it is not;

• a shortcut typed as a literal anywhere outside the table fails the build;
• any panel shortcut not claimed ahead of the borrowed editors fails too.

Plus a fifth on the panels themselves: every shortcut lands on a panel that

really exists, no two claim the same one, and no panel is left unreachable from

the keyboard.

Also in this release

The ruling you gave on dimmed doors is in. A panel for a feature you have not

set up yet now shows a dim door rather than nothing, and, going one step

past the ruling, the dim door still works: press it and it takes you to the

setup. That keeps it on the right side of the app's own rule that an indicator

is either useful or absent. Dictation is the case you will see it on.

A door dimmed because you are simply in the wrong world stays unpressable, as

before, since there is nothing there to fix.

Until now a Desk panel was a light switch. You turned the Outline on, jumped to

a heading, and the Outline was still there, taking a fifth of the window, until

you remembered to turn it off. Nine doors, nine switches, and the writer doing

the tidying.

And when you crossed from a document to a spreadsheet, several of those doors

simply vanished. Nothing said why. The rail got shorter, the icons all

moved, and the door you had used a minute ago was gone.

Both are fixed, to the design you signed off.

A panel opens when you need it and folds back after the act

Open the Outline, click a heading, and the Outline gets out of the way. You

asked for the heading, you are at the heading, the panel's job is done. The

same for Backlinks once you open the note, History once you restore a version,

the Thesaurus once you replace the word, and Voice once your words are in the

document.

What is not an act: typing, selecting, scrolling, or thinking. A panel

never disappears because you moved the mouse. It goes only when the one thing

it exists for is finished.

And several panels never fold themselves at all, because they are places

you work rather than steps you finish: Properties is a form and a form you are

half-way through must not vanish; Comments is the task, not a step in one; AI

Results holds a run you have not dealt with yet; Chat is a conversation; the

Paged Preview and Usage are things you came to read.

A pin makes it stay

Every panel has the same pin in the same corner. Press it and that panel has

residence: it stays until you close it, through its act and everything after.

Three start pinned, because they are almost always the second kind: the Paged

Preview, Comments and AI Results. Pinned does not mean open. A fresh window

still shows your document and nothing else; pinning only decides what happens

once you do open it.

A door that cannot work stays put and says why

Open a spreadsheet and the Properties door is still exactly where it was, just

dimmed. Hover it and it tells you: "Properties edit a Words document's own

front matter."

The rail keeps its shape, so your hand keeps working. And you learn the rule

once instead of wondering where a button went.

Every dimmed door says something true and specific: headings live in documents,

snapshots are kept for documents rather than workbooks, wiki-links join Words

documents to each other, dictation needs a voice key and points you at

Settings.

Each world remembers its own desk

Pin the Paged Preview while writing a report and it is there the next time you

open a report, and not when you open a spreadsheet. Words, Rich Words and

Numbers each keep their own arrangement, and each survives a restart.

And a tab can no longer be lost

You reported the same day that with enough documents open, some sit off the

edge of the tab strip with no way to see or reach them: "there would be

nothing worse than a user having to close tabs to make room to find what they

know is there somewhere."

Two doors now, both standard everywhere else:

• Tabs, on the left beside Files and Recents. Every open document as a

list, each row wearing its world's colour (orange for Words, blue for Rich

Words, green for Numbers) and its unsaved dot. Click to bring it to the

front; middle-click, or the hover cross, to close it.

• Chevrons at each end of the strip that scroll it, and which are simply

not there when nothing is hidden.

It went on the left because that is where the rules already put finding and

opening things, which is exactly what you asked for.

The test opens twenty-two documents, checks the strip really is overflowing so

it cannot pass by accident, then reaches the furthest one both ways and

confirms the tab count never drops. Nothing is ever closed to get anywhere.

Small things that came with it

• A panel that opens now announces itself. Focus moves to its heading, so a

screen reader says which panel arrived instead of leaving you to find a new

region by accident.

• Closing a panel no longer quietly forgets that you pinned it. Residence is a

standing decision about the panel, not about this one opening of it.

Under the bonnet

• The state machine is unit-tested (stores/residence.test.ts): folds only an

unpinned panel, only the one you are looking at, and keeps each world's

arrangement apart.

• A structural guard (features/actions/panel-residence.test.ts) proves that

every panel declaring "I fold after this act" actually folds somewhere in its

own code, that no fold is wired to a keystroke, selection or scroll, and that

the shipped default arrangement is the one on the accepted sheet.

• Walked in the built app end to end (tests/e2e/residence.spec.ts and

residence-families.spec.ts), including a real restart, all four Desk

families, and the dimmed door's reason.

• One genuine bug found while building it: a markdown tab carries no world tag

at all (plain markdown is the absence of one), so the Desk could get stuck

describing the last spreadsheet you had open. Caught by the walk, not by a

green fixture.

The little pictures on the buttons had stopped meaning anything.

The first full audit counted it: one glyph carried ten different meanings

(the four-pointed Sparkles stood for Ask AI, Run Prompt, the AI Results panel,

Suggest an Image, Make it Rich, the setup banner, an available update, the

welcome tour and more), and **twenty-one ideas each wore a different face

depending on which door you came through** — the Prompt Library had three, the

Thesaurus two, Zen mode three.

The worst of it was two doors side by side on the same rail, Comments and Chat

with Notes, drawn with the identical speech bubbles. Nothing told you which was

which except reading the tooltip every single time.

This release closes all of it.

What changes when you open it

Every meaning now has one picture, and every picture means one thing.

• Ask AI keeps the sparkles. It is the act everything else descends from,

so it keeps them, and nothing else does. Run Prompt is a play button now,

because running something you already saved is not composing something new.

AI Results is the little robot. They sit on the same ribbon tab and you

can finally tell them apart at a glance.

• Comments and Chat with Notes are two clearly different bubbles.
• The Prompt Library wears the same notebook everywhere: ribbon, sidebar,

settings, palette.

• **The Divider, the callout, the page view, the paper size, orientation,

tracked changes, backlinks, a live link from a spreadsheet** and two dozen

others each got a picture that actually describes them. Word's tracked

changes are no longer drawn as a Git pull request.

Tooltips are one thing now, not two. About thirty controls used the

browser's own title popup: unstyled, two seconds late, invisible to anyone

using a keyboard, and always a slightly different shape from the app's real

tooltips right next to them. They all use the app's tooltip now, with the same

delay, the same look, and the same words the screen reader hears. The plain

title survives in exactly one job: revealing the full text of something that

had to be truncated, like a file path in a narrow panel.

And the house rule on dashes is applied. Forty-one files of user-facing

copy had long dashes in them, against the standing instruction. They are commas,

colons and full stops now. Source comments were left alone; they are not copy.

Why it will stay fixed

The reason this drifted in the first place is that each door chose its own

picture, forty separate places making forty separate decisions.

So the fix is not forty corrections. It is **one file that names every meaning

once** (features/actions/icon-lexicon.ts), which every door now asks. A

hundred and eighty-odd doors read from it. Four checks run on every build:

• no two meanings may share a picture;
• a picture that legitimately serves several objects of ONE act (the cross that

closes things; the circular arrow that does things again) must be declared

with its reasoning in writing, and that reasoning is read by the test;

• no door may reach past the lexicon for a picture the lexicon owns, so

writing Sparkles at a new door fails the build until you say which meaning

you mean;

• the retired pictures stay retired.

A fifth check does the same for the browser's title: every file still using

one is named with the reason, and a new one fails until it is either migrated

or argued for on the record.

And a sixth runs in the built app rather than in the source: it reads the

actual drawn shapes off the real ribbon and the real rail, proves no two doors

share one, hovers a panel door in all three themes and checks the tooltip

that opens says the same thing the screen reader is told.

Under the bonnet

• src/renderer/src/features/actions/icon-lexicon.ts — the meanings, with the

reasoning for every decision the census forced, and the intentionally-shared

register.

• icon-lexicon.test.ts — the four structural guards.
• lexicon-harvest.test.ts — the native-title register replaces the old bare

count, which was scaffolding with no migration behind it.

• tests/e2e/icon-lexicon.spec.ts — the running-app walk, three themes.
• Button and Toggle grew a hint prop that carries the shared tooltip and

doubles as the accessible name; components/shared/Hint.tsx does the same

for the handful of controls that need their own geometry.

Andre asked it for "a simple household finance tracker" and got a markdown

table in the results panel with a Copy button. That was the whole story: the

Numbers AI could work on a spreadsheet you already had, but it could not

make one.

It can now.

Describe it, and it gets built

Right-click a range ▸ AI on this range ▸ Build sheet, say what you want in

plain English, and the layout arrives in the grid: a title row, column headers,

a few realistic example rows clearly labelled as examples, and **every worked-out

number as a real formula**.

That last part is the point. A total is =SUM(...), not a number the model

typed in that stops being true the moment you change a row. Ask for a household

tracker and the "Total outgoings" cell really adds up the outgoings, and the

"Left over" cell really subtracts. Change a figure and the sheet follows, because

it is a spreadsheet rather than a picture of one.

The formulas are deliberately plain ones you can read and change: SUM, AVERAGE,

IF, COUNT, MIN, MAX and ordinary arithmetic. No array formulas, no macros, no

pivot machinery. One workbook, one sheet.

It arrives the same way every other Numbers suggestion does: **ghost cells on

the grid showing exactly what Apply will write, and one undo step** if you

change your mind.

It will not write over your work

This is the part that mattered most to get right. A formula suggestion filling

three empty cells beside a range you picked can hardly hurt you. A whole

generated spreadsheet dropped on a workbook you have been working in can, and

"there's always undo" is a thin thing to rest that on.

So the app checks rather than trusting the model's manners. Before Apply, the

proposed cells are measured against what the sheet actually holds. If they

overlap, Apply stands down and says which cells, in plain words: "This would

write over A1, A2 and 11 other cells that already have something in them, so it

is not applied."

And it offers the way out, never a bare no: Put it below what is there, which

moves the whole layout beneath your existing content. **The formulas move with

their rows**, so the totals still add up the things they were meant to add up

rather than pointing at whatever now sits where they used to.

What this is not

The scope is deliberate: one workbook, one sheet, formulas a person can read.

It is a fast start on a spreadsheet, not a modelling tool.

The model's arithmetic is not checked before it lands. What is checked is

where it lands, which is the part that can cost you something. If a formula

comes out wrong you can see it in the ghost preview before applying, and undo

in one step after.

Under the bonnet

• The generative prompt ships as an ordinary library prompt, seeded under its

own marker so it reaches installs that already have the three transformation

ones, and it is editable and deletable like any other.

• The landing guard is pure and unit-tested, including the formula-shifting: an

absolute $5 row stays pinned because its author pinned it, and a reference

to another sheet is left alone.

• Walked end to end in the built app against a scripted local model

(tests/e2e/build-spreadsheet.spec.ts): the prompt on the menu, the ghost

layout, the landing, the calc engine actually evaluating the formulas that

arrived, the refusal to overwrite, and the shifted second landing still

totalling correctly.

Three things Andre found in his own testing, fixed at the root. The big one

turned out to be much bigger than it looked.

You can get out of a Quote now, and out of everything else

Andre wrote a quote, then tried to go back to plain text and could not. The

slash menu would not do it, the ribbon buttons would not do it.

Rather than patch the one case, the whole matrix was walked in the built app:

every block type into every other block type, by every route — ribbon

click, slash menu, typed markdown, and keyboard. It found **62 of 144 switches

never arrived**, all of them one fault wearing different clothes.

A Quote, a bullet list, a numbered list and a task list are **wrappers around a

paragraph**, not kinds of paragraph. So "turn into text" set the paragraph to a

paragraph, which it already was, and left the wrapper standing. Nothing in the

app could take a wrapper off. From inside a list it was worse: only "Paragraph"

did anything, and what it did was nothing.

The rule now is the same everywhere: **come out first, then become the new

thing.** Every switch lifts you out of whatever you are inside and flattens you

to plain text, then builds what you asked for. The matrix is now 144 of 144,

by every route.

Alongside it:

• Quote, the three list kinds and code blocks toggle. Press the same button

or key again and you are back in plain text.

• Backspace at the very start of a quote or a list lifts you out of it, the

other escape a keyboard writer reaches for. At the start of a later line it

still joins with the line above, as it should.

• Task lists were unreachable from any route. Wrapping twice nests one list

inside another instead of ticking the item.

Keyboard shortcuts for every block

Never leave the keys:

| | |

|---|---|

| Ctrl+1 … Ctrl+6 | Heading 1 to 6 |

| Ctrl+Alt+0 | Plain paragraph |

| Ctrl+Shift+Q | Quote (toggles) |

| Ctrl+Shift+8 / 9 / 7 | Bullet, numbered, task list (all toggle) |

| Ctrl+Alt+C | Code block (toggles) |

Two of these depart from the Typora set Andre asked for, and both for the same

honest reason: Ctrl+0 is already Reset Zoom and **Ctrl+Shift+K is already

Comment on Selection**. Those are native menu shortcuts, so they fire before the

editor ever sees the key; a clash would simply have done nothing.

Every chord is printed on its own button in the Home ribbon, and in the

command palette, so you never have to look one up.

That fixed something else on the way: the command palette had been advertising

**Ctrl+Alt+1, Ctrl+Alt+2 and friends for block styles while nothing at all was

bound to them**. There is now one table the keymap, the ribbon and the palette

all read, so a shortcut cannot be advertised without existing.

The Divider is a line you can actually see

It was drawn in the faintest colour the theme owns, with 80% transparency put

on top of that. Measured against the page it came out at 1.06 to 1 — near

enough invisible, exactly as Andre said.

A divider is a mark the reader is meant to see, so it is now drawn from the

ink. The strength is measured rather than chosen: 3.71 to 1 in Athenaeum,

4.59 to 1 in Midnight and 3.24 to 1 in Scriptorium, all clearing the

3:1 floor for a mark that is not text.

The exports had the same fault (1.26 to 1) and are fixed with them: 3.16 to

1 in the light export, 3.81 to 1 in the dark. A test reads those numbers back

out of a real rendered export rather than trusting the arithmetic.

An unsaved workbook is an offer, not a dead end

Copy a range from a workbook you have not saved yet, paste it into a document,

and nothing happened except plain text. Every way of pasting reads the range

out of the workbook file, so the file really was the obstacle, but nothing said

so.

The chooser now opens anyway and tells you: **"X has not been saved yet. A

pasted range is read from the workbook file, so save it once and all three ways

of pasting become available." There is a Save the workbook** button beside

it that saves and brings the three choices alive on the spot, and the three

choices are shown greyed meanwhile so you can see what saving buys you.

Found on the way, logged rather than quietly absorbed

• A Divider disappears when a document crosses to Rich Words. The converter

has no spelling for a horizontal rule and drops it.

• Thirty-eight strings of the app's own copy still use em-dashes, against

the house rule. Fixed in the Paste Special dialog; the rest is a language

sweep that belongs beside the icons work.

Still needing Andre

The third door for the shortcuts was to be the native Format menu, and the

app has no Format menu to put them in. Adding one changes the shape of the

app's chrome, which is a design call rather than a bug fix.

Copy a range in Numbers, paste it into a Word document, and you now get the

same choice you get in a markdown one: Live Link, Table or Image. Take

the Live Link and what lands is a real Word table wearing the range's own

look, still following the workbook.

This closes the line Andre ruled from his own testing (L-057): the answer on

the Rich Words surface is an offer, not a stand-down.

The chooser arrives on Word documents

Pasting a copied range into a .docx used to drop plain text. It now opens

Paste from Sheet, exactly as it does on a markdown document, with the

three modes and the same words.

Two doors, both live here now: the paste itself, and Insert ▸ From Sheet…

from the command palette.

A Live Link is a styled Word table

Not a stripped grid of numbers. The header fill, the font, the font colour,

the alignment and the borders you gave the range in the sheet all cross into

the document, and merged cells arrive as real Word merges rather than being

flattened. Values keep their number formats, so £1,200.00 in the sheet is

£1,200.00 in the report. Hidden rows stay hidden.

A range with no styling of its own gets Word's ordinary gridlines, because an

invisible table is not what anyone means by "paste this range".

It behaves exactly like a linked range on the markdown side

The same contract, on a different material:

• A chip above the table names the range and its workbook, and carries

Refresh and Detach.

• The table is read-only while it is linked. Typing in it does nothing

and says why, with Detach offered in the message.

• Refresh redraws it from the workbook, styling and all — on demand, when

the workbook changes on disk, and when the document opens.

• Detach keeps the table and ends the link, naming the workbook it no

longer follows. After that it is an ordinary Word table you own.

The link is stored the way Word stores this sort of thing, as a content

control around the table, so it survives saving, closing and reopening — and

Word itself, or anyone else opening the file, sees a perfectly ordinary

table.

The bug that was hiding the whole feature

Walking this end to end found why Andre's own testing saw "only plain text"

where the chooser should have been, on both surfaces: the app was

listening for the browser's copy event to remember where a copy came from,

and the spreadsheet engine never raises one — it writes the clipboard a

different way. So the copy was never remembered, and Paste Special had

nothing to offer.

It now listens to the sheet engine's own copy command, which is where every

route to copying — the keyboard, the ribbon button, the menu — actually ends.

**Paste Special works from a real copy for the first time, in Words as well

as Rich Words.**

One stated ceiling

On a Word document, the automatic refresh decides "did anything change?" by

comparing the cell values. A workbook edit that changes only a colour waits

for the next value change, or for pressing Refresh, which always redraws.

Values are what a refresh is for, and rewriting the table on every open would

mark every document unsaved for no reason.

Under the bonnet

• The binding lives in a Word content control (w:sdt) and is re-emitted

whenever the table is rebuilt — the one mistake that would silently drop it

is pinned as its own failing test.

• Detach is watertight: the link is part of the table's change signature,

so detaching forces the table to be rewritten without the control rather

than quietly saving the old bytes back.

• Walked in the built app end to end (tests/e2e/linked-range-rich.spec.ts):

copy in Numbers, chooser, styled table, refusal to type, refresh from a

changed workbook, the control in the saved file, Detach, and the control

gone from the file afterwards.

Work on the styled, live-linked paste into Rich Words (L-057) began by

mapping what it must join, and that mapping found something that could not

wait: **the linked-range contract was only a third built, and the missing

two thirds cost people work.**

Linked ranges keep the promise now

When you paste a range from Numbers into a document as a Live Link, the

rule (ruled last August) was always: it is visibly linked, it is read-only,

and Detach is the one door to editing it. Only the "visibly linked" part

had been built. Nothing stopped you typing into a linked table, and the next

refresh quietly replaced whatever you had typed.

• A linked table is read-only now. Typing inside it does nothing, and it

says why: "This table is linked to costs.xlsx — linked ranges stay as the

workbook has them. Detach it to edit it here", with Detach offered

right there in the message. You can still select and copy from it.

• Detach is a real door, on the linked-range chip beside Refresh. It

keeps the table exactly as it stands and stops it following the workbook,

saying which workbook it just left. From then on it is an ordinary table

you own.

• A refresh can no longer destroy an edit, because an edit cannot happen

while the range is linked. That was the invariant the original ruling

called non-negotiable.

Groundwork for the styled paste into Rich Words

Two pieces of the bigger feature landed, and both are visible in the code

rather than promised:

• A range's look now travels. The workbook reader already parsed fills,

fonts, borders and alignment out of your .xlsx and threw all but the number

format away, because a markdown table cannot show any of it. It is carried

now, so the surfaces that CAN show it will. Markdown still ignores it, and

still says so.

• The binding carrier is settled and proven. A Word content control can

hold the link to the workbook and survive saving, closing and reopening the

file, including when a refresh changes the table's shape. That is pinned by

a test — along with the one mistake that would silently drop the link.

The rest of that feature (the chooser on Rich Words, the styled Word table,

the bound region and its refresh) is not in this release. See the handoff

note in docs/HANDOFF.md for exactly where it stands.

Under the hood

• region-plugin.ts gained a filterTransaction gate; the refresh service's

own writes pass it by meta flag, so regeneration is unaffected.

• detachSheetRegion() in links.ts; a second chip door in the same tokens.
• src/shared/sheet-style.ts — a host-owned CellStyle, mapped from the

vendored reader's shape at the main-process boundary, unit-tested.

• New fixtures: tests/e2e/linked-range.spec.ts (the whole D-2 walk in the

built app) and sdt-table-binding.test.ts (the binding spike).

The fifth execution slice of the F6 v2 Completion Contract (SLICE S5). The

app's voice: errors that say what happened and what to do, one sentence for

one moment, saves that confirm where you made them, and the last "state

pretending to be a toast" retired.

The on-disk conflict is a banner, not a toast

• When a document you have unsaved edits in changes on disk, the choice now

arrives as a banner above that document, naming it, with **Reload from

disk and Keep mine**. It stays until you decide, and it cannot cover

the AI panel's buttons the way the old permanent toast could.

• A clean document that reloads from disk says so, and the notice carries

Restore my version so the text you had is one click away.

• Renaming a file you have unsaved edits in no longer tells you to go and

reopen it: the notice carries a Reopen button that does it (asking

about your unsaved changes first, as always).

Errors in writer's English

Every censused error now leads with a plain title naming the object, keeps

the technical reason as detail, and ends with a next step. Examples:

• "This editor has no image node to insert into" is gone; a picture that

cannot land says so and says where it can.

• "It works" / "Test failed" became "Your Claude subscription answered" /

"…did not answer", each with what to do next.

• "Could not convert" now names the document: "Could not make the Word copy

of 'Report'", and tells you the original is unchanged.

• Nine toasts that led with a raw internal message (model renames, provider

toggles, key clears, snapshot restores, history clears, voice passes) now

lead with what failed and what it means for your work.

• "The editor is not ready" / "The document is still opening" now name the

document and say what to do.

One moment, one sentence

The four different ways the app used to say "no model is configured" are one

sentence with one destination now: "Choose a default AI model first",

with the same Open AI settings button, on every door — AI menu, prompts,

comments, Voice, the builders, the image tools. The one that pointed at a

settings tab that does not exist is fixed.

Saves you can see, and silence where it belongs

• Flipping a model default, or editing a model's label or pricing,

now shows a quiet "Saved" beside the control you used, the same way the

monthly budget already did.

• The remaining "look what I did" toasts are gone: dictation landing in your

document, and inserting a table of contents, no longer announce themselves.

The text appearing is the feedback.

Under the hood

• The locality rule is written into docs/DESIGN-STANDARD.md (§10a) and the

new-feature checklist: results and errors appear where the action happened;

a state is a banner, an event is a toast that carries its action; a visible

change needs no announcement.

• A conflict is now tab state (TabDoc.conflict) rendered by

ConflictBanner, not a duration: Infinity toast.

• Shared SavedFlash component + toastChooseModel() helper, so neither the

confirmation nor the stand-down can drift again.

• New fixture tests/e2e/feedback.spec.ts provokes all four moments in the

built app (banner with both doors, the restore door, the one sentence on

four doors, the saved states).

The fourth execution slice of the F6 v2 Completion Contract (SLICE S4) — the

programme's felt centrepiece, built to the accepted P9 prototype. Every prompt

now knows where it applies, every AI door filters by that one rule, and

Numbers gets real AI of its own: the range goes in, results land in cells,

one undo away.

Applies to — every prompt knows its worlds

• Every prompt carries Applies to: Words, Rich Words, Numbers, or Any

document. The prompt editor gains the row, with the world-coloured chips.

• Leave it alone and Markelangelo infers it from the template — dashed

chips and the reason, shown in the editor, live until you touch it. A

prose consumer ({{selection}}, {{document}}) reads as Words + Rich

Words together; click a chip and your choice wins, with a one-click way

back to inferred. Existing prompts all start inferred — no work for you,

and prose prompts leave the grid immediately.

One rule, every door

• The six AI door kinds — quick-action chips, right-click collections, the

✨ launcher, the Run Prompt dialog, the Desk panels and the native AI menu —

all project the same eligibility from the action contract. A prose prompt

cannot leak onto a workbook through one forgotten menu, and a Numbers

prompt never clutters an essay.

• The Run Prompt dialog is the one teaching point: it counts what stood

down ("3 more prompts stand down here (2 Words, 1 Rich Words)") with a door

to the library; every other surface simply offers what applies. Each row

wears its worlds as coloured swatches.

• The "arrives with the affinity wave" greys are gone — replaced by the real

offers below, or by teaching reasons that name them.

Numbers AI — the range in, the cells out

• On a workbook the AI receives the range you selected — real

coordinates, headers and values — never a fabricated whole-document

projection.

• Answers arrive in the AI Results panel (now at home on every world);

nothing rewrites your sheet behind your back. A formula suggestion carries

Apply: the target cells preview as ghost cells on the grid, and

applying writes them as one undo step — Ctrl+Z restores.

• The cell right-click menu gains AI on this range, and three

Numbers-native prompts ship in the library, editable and deletable like any

other: Explain this range, Suggest a formula, **Summarise this

table. Ask AI about Range** (Ctrl+J) asks a one-off question about the

selection.

Repairs in passing

• Saving a prompt from the editor silently dropped its comment-mode and pill

colour (the IPC validator stripped fields it did not know); both now

persist, and prompt-library import carries them (and Applies to) too.

• The ✦ Prompts button no longer renders where Run Prompt is not offered.
• A Document Leader whose engine prompt does not apply on the active world

now stands down aloud instead of running a prose pipeline on a grid.

Under the hood

• Schema migration v11 (prompts.applies_to, NULL = inferred); the shared

inference lives in src/shared/applies-to.ts, unit-tested.

• The sheet seam gains two verbs (applyCells — one-undo batched writes —

and previewCells — float-DOM ghosts) and range selection; recorded in

UPSTREAM-SHEETS.md as App.tsx patch 7.

• New fixtures: the L-018 matrix (four prompt classes × six doors × three

worlds), the L-017 admin walk, and the L-019/L-020 walk driven against a

scripted local model endpoint (affinity*.spec.ts); the action-contract

fixture updated to the new Numbers truth.

The third execution slice of the F6 v2 Completion Contract (SLICE S3): eight

small honesty and naming repairs, each one closed with evidence in the built

app.

The doors

• The Numbers chip answers a click. The status-bar kind chip on a workbook

("Numbers") now opens its honest explanation on click or keyboard, not only

on hover: a real .xlsx you own, with no counterpart world to switch to.

• The Git door says Git. The Review tab's workspace door was an unlabelled

icon; it now carries the word.

• Check Spelling stands down on a workbook. Pressing it on Numbers used to

toast "Nothing to check yet" at a sheet full of words. The door is now absent

there (native Edit menu and palette both), until a real sheet spell pass

exists.

• Voice waits to be invited. With no Groq key set, the Dictate button and

the Voice desk door no longer occupy chrome; the palette's Voice Dictation

door leads straight to its setup in Settings ▸ Voice. Add a key and the doors

appear.

• AI Builders live where you build. The standalone Settings tab is gone;

each ✨ Build with AI dialog now carries its own "Builder brief (advanced)"

editor, so the brief is edited where its behaviour is felt.

The words

• Privacy & Sovereignty is now the Settings tab's actual name, matching

every door that points at it.

• One split family. "Swap Panes" and "Remove Split" everywhere: native

menu, palette, ribbon, tab menu and the split header. "Close Split" and

"Swap Split Panes" are gone.

• One name for the quick-actions manager: Quick Action Prompts, on the

ribbon, the palette and the chip overflow.

• The cell menu speaks the band's words. Freeze Panes ▸ At Selection / Top

Row / First Column / Unfreeze Panes; Paste Special now offers all five of the

band's options, including All Except Borders.

• Host-platform keys in the Word world. The vendored context menu's

hard-coded ⌘ chords now render as Ctrl on Windows, like every tooltip

already did; Ctrl+E for inline code is advertised on the ribbon door too,

and the Home band's two-item group is captioned "Undo & Redo".

• Ellipsis grammar: the Switch doors carry their "…" on every route; Check

Spelling (which acts at once) carries none, anywhere.

Under the hood

• Ribbon items can declare when() visibility (how Voice gates its chrome).
• The Usage desk panel declares its when: () => true like its siblings.
• The user guide and website manual follow every rename.

The second slice of the F6 v2 Completion Contract: at any window width, on

any world, the bands and rows fold — they never scroll, never clip a

control, and never let the seam vanish.

The Rich Words band folds like its siblings

The Word-side ribbon used to overflow into a hidden horizontal scroll: at

common widths live controls were simply cut off (the Insert tab lost 391

pixels even on a 1600 pixel window). It now folds whole groups into a

labelled "⌄ More (n)" door, exactly as the Words and Numbers bands do —

open it and the folded groups are there, captions and all, fully usable.

The Numbers row protects its seam

At narrow widths the Numbers tab row used to crush its right end: the

✦ Prompts chip clipped mid-word and the privacy pill disappeared, while

the save and undo buttons squeezed into slivers. The row now folds

trailing tabs into a small ⌄ menu (a folded tab activates from there, and

the chevron tints when the active tab lives inside it), the toolbar

buttons keep their size, and at the very narrowest the AutoSave toggle

drops its label before anything else gives. ✦ Prompts, Add… and the

privacy pill are present and usable at every supported width.

The Styles trio comes home

On a wide window the Numbers Home band was folding Conditional

Formatting, Format as Table and Cell Styles behind "More (3)" — the

accepted design keeps them inline. The cause was a hidden group being

charged a guessed width; fixed, the trio sits inline in full ink with

"More (2)", matching the accepted mock in all three themes.

Under the hood

One fold grammar now runs all three bands, and all three learned the same

honest last resort: a pane too narrow for even one group folds everything

behind the More door rather than clip. A new width-contract fixture

(three themes × every ribbon tab × three widths, including the harshest

rail-and-panel state) guards all of it.

The first execution slice of the F6 v2 Completion Contract: every door

the app shows now tells the truth about what it can do, starting where

it was least honest.

The AI menu knows which world it is in

The native AI menu is now projected from the same action contract as

the File menu, so it changes with the document in front of you. On a

Numbers workbook it offers exactly what works there today: Chat with

Notes. The five doors that only apply to text documents (Ask AI about

Selection, Run Prompt, Comment on Selection, Summarise Document,

Generate Outline) no longer appear on a workbook, and the command

palette agrees. Previously, Summarise Document on a workbook was a

click that did nothing at all; that class of silent click is gone, and

a guard at the single place every AI run starts now speaks up if any

stray route ever reaches it on a workbook.

Print on a workbook

Printing a spreadsheet is on the roadmap as a real feature. Until it

arrives, the native File menu on a Numbers tab no longer lists Print

(a native menu cannot explain a greyed entry), while the File pill

keeps the greyed door with its reason, so the plan is visible where it

can be spoken.

The Rich Words View tab

Three controls on the Word-side View tab rendered enabled but did

nothing in Markelangelo: AI Panel, New Tab and Switch Tabs. All three

are removed. Everything that remains on that tab has been pressed and

does what it says: layout modes, the zoom family, Dark Mode, Ruler,

Gridlines, Navigation Pane, Split Window, Page Preview and Read Mode.

Straighter words in Settings

The Settings footer no longer claims "your files never leave this

machine" as an absolute. It now reads: "Local-first · files stay on

this machine · AI sends only content you choose, under your selected

stance · no telemetry".

The Numbers repair. Make a new workbook and look at it: the grid is

there, the band finally wears the house clothes, and saving works from

the first keystroke.

The grid is back

A new workbook (and any opened one) had collapsed into a thin strip over

a white void — a layout fault left behind by an earlier repair. The

workbook now owns its pane again. And a brand-new workbook is a real

file from birth: it opens on a live engine session, and the first save

asks where its home should be — previously a blank workbook could never

be saved at all.

The band, cut to the cloth

The Numbers band now matches the accepted design and the Word band it

sits beside, figure for figure: bordered dropdown chips, quiet 11px

labels under 22px icons, 13px letterform toggles, colour wells drawn as

a letter with its colour bar (not raw colour squares), painted group

separators, captions with room to breathe, and the Styles trio in full

ink — live controls no longer dressed as dead ones. Every ribbon tab was

photographed and checked by eye in all three themes, at wide and narrow

widths; at narrow widths whole groups fold into the labelled "⌄ More"

door and nothing clips. After-shots sit beside the accepted mock in the

project's F6 Sweep folder.

Why it looked broken (the honest note)

The vendored spreadsheet's own styling is deliberately quarantined below

Markelangelo's, and the app's base styles were silently stripping its

borders, fonts and hidden inputs. The band's look is now stated

explicitly in Markelangelo's own stylesheet, in house tokens, so themes

flip it and nothing underneath can undress it again.

Guard rails

A new cold-path test walks all three worlds the way a person does —

launch, new document, type, save — and the Numbers check asserts the

grid actually PAINTS (pixels, not page structure). A second new test

pins the band's computed anatomy: borders present, separators painted,

colour inputs hidden, house type sizes. The phantom "Start recording"

overlay was confirmed to belong to an external desktop utility, not

Markelangelo — nothing in the app renders it.

The world names, and a first second with a face. This closes the F6

remediation programme: seven staged releases, every finding of the

15 August sweep answered at root cause.

Words · Rich Words · Numbers

The three worlds now speak their decided names everywhere, in one

release: the document-kind chip in the status bar (with the file truth in

its tooltip: Words is .md, Rich Words is .docx, Numbers is .xlsx), the

New Document dialog's three cards, the palette's New entries, the Combine

dialog's kind chips, the welcome tour and the User Guide. Rich Switch and

MD Switch keep their names; they are mechanisms, and the doors now say

the worlds. Brand-free, format-honest — Framework's own convention.

One ask travels with the rename (recorded from the decision sheet): a

first-guess comprehension check with a fresh pair of eyes, since

"Numbers" is also Apple's spreadsheet. Only a failed check reopens the

decision.

The first second, faced

Launching used to show a white void until the interface arrived. The

window now paints the Markelangelo wordmark on the app's own ground

before any code runs, in light or dark to match your system, and the

real chrome replaces it the moment it is ready. Cold-open measurements

continue to be recorded per release in docs/measurements/.

The programme, closed

0.40.0 truth in first contact · 0.41.0 the guard · 0.42.0 the

severity-1 repairs · 0.43.0 the action and band/seam contracts ·

0.44.0 the one-answer batch · 0.45.0 export truth · 0.46.0 the world

names. What remains open for Andre is listed in the implementation log

(I-057): the Draw-tab observation, the Rich Words band's fold, the

stance-routing determinism fix, and the recorded P-010/P-011 remainder.

Export truth. Your diagrams now leave the app as diagrams.

Mermaid exports as pictures, everywhere

A Mermaid fence has always previewed as a live diagram in the editor and

then exported as its source code, which is not what anyone handing over a

document wants. Every export route now carries the rendered diagram

itself: HTML and PDF draw it as crisp inline SVG, printing prints it,

Copy as HTML carries it, and a Word export embeds it as a native vector

image (with an automatic bitmap fallback for older Word).

The Word route uses a dedicated render with plain text labels, because

Word cannot draw HTML-styled labels even inside a vector image; screen

routes keep the richer render. If a diagram cannot be rendered at export

time, that fence stays as readable source code and one quiet line tells

you so; nothing fails silently.

Under the hood this is deliberately built as the ONE picture-into-export

mechanism, the same primitive the coming Mind Map and Numbers chart

embeds will feed, so the next diagram-shaped feature ships without

inventing a sibling pipeline.

The one-answer batch. Five questions that had two or three answers each now

have one, and the AI things you keep finally have a front door.

The AI Library

The Library rail has a fifth door: AI Library, one room with three tabs

for your Prompts, Document Leaders and Flows. These rooms used to live

behind ribbon and palette deep links only, with no door in the rail that

hosted them; the shipped guide could not even describe the model. Ruled by

Andre as D-8: the things you keep get a place you can find them. The ribbon

and palette doors now deep-link into the room, and the User Guide teaches

the new door.

One answer each

• Zoom is one door shape on all three worlds: the status-bar - value +

control now serves Words (the prose zoom), Rich Words and Numbers (their

canvases, through their host seams). The View-tab groups remain as

secondary routes. The Words 100% control stops wearing a magnifier.

• Usage is one room. The duplicate Settings Usage tab is gone; the

Usage panel behind the status bar's cost figure is the reporting home.

The monthly budget gains its first real editor, on the Privacy tab

beside the model defaults, with a visible Saved state. The settings

surface drops the working title "Settings Shop" and is simply Settings.

• Paste as Plain Text is one name in one family: offered on both text

surfaces' right-click at the insertion point, and the native Edit menu's

"Paste and Match Style" now uses the same words. Paste as Markdown keeps

its distinct name where parsing genuinely happens.

• Theme and focus changes stop announcing themselves. The screen

already said it.

Numbered twice? One offer

A numbered style set over hand-numbered headings used to render "1.1 1.

Before you start". When Markelangelo detects that collision it now makes

one local, reversible offer in a banner: turn off the style set's numbering

for this document. Nothing is rewritten silently, and the offer can be

waved away (some headings legitimately start with numbers).

Recorded, riding the next batch

The remaining feedback-copy repairs (raw error toasts, the one stand-down

sentence, the conflict chooser's banner) and the icon/tooltip

normalisation are recorded in the implementation log (I-056) with their

census targets; a source-level ratchet already stops the tooltip count

growing while they wait.

The systemic spine. One declared contract now sits behind every document

action, and one seam contract behind every band. This is the release where

the same act starts meaning the same thing on every surface.

The action contract

Every File-family action is declared once: its canonical name, its

ellipsis, its accelerator, which worlds it applies to, and what a door does

where it cannot apply. The native File menu, the File pill, the tab

right-click menu and the palette are all projections of that one table.

What you will notice:

• The two File menus finally agree, entry for entry, per world.
• A spreadsheet tab's right-click has nothing to say about Word. The

Rich Switch and Counterpart entries are simply absent there.

• Print is honest on Numbers. It used to sit un-greyed and do nothing

when clicked (found by Andre after the sweep, filed as A-001); it is now

greyed with the reason, as are the export entries, until spreadsheet

printing and export arrive as real features.

• The document-kind chip means one thing everywhere (ruling D-1). On

Words and Rich Words it is the switch it always was; on Numbers it names

the kind and explains there is no counterpart world, instead of secretly

opening Explorer. Where your file lives belongs to the path crumb, which

answers on every world.

• Table of Contents is no longer dressed as AI. The deterministic

builder lives in Insert and the palette's Document group; the AI menu

stops advertising it.

The band and seam contract

• One seam on every world. The quick-access chips and the privacy pill

now sit at the end of the ribbon tab row on Words, Rich Words and

Numbers alike; Words was missing the pill entirely.

• The Words band folds like the Numbers band. Groups that do not fit

fold whole into a labelled "More (n)" overflow; nothing clips, nothing

scrolls, nothing vanishes. (The Rich Words band's fold is a recorded

follow-up; it keeps its quiet scroll for now.)

• Ctrl+, works everywhere now - including with your cursor in a

spreadsheet cell, where the sweep measured it dying.

• Keyboard hints speak your platform. The spreadsheet band's tooltips

no longer teach Mac chords on Windows.

The guards that keep it true

New fixtures pin all of it: the two File menus and the palette asserted in

agreement on all three worlds, Print pressed on each, the chords pressed

with focus in the grid, a source-level ban on the retired wordings, a

ratchet on native tooltips, and a guide-parity check that the doors the

User Guide names exist as it names them.

The severity-1 repairs. The three findings the F6 Sweep ranked worst after

the file-writing leak are closed at root cause: the Desk answers for the

document you are on, a cell's right-click is cell-shaped, and the Numbers

band reads as finished chrome.

The Desk answers for the active document

Switching to a spreadsheet used to leave the Outline showing the PREVIOUS

document's headings; the panel went on answering for a tab you had left.

The root cause is fixed: a sheet now clears the shared editor state the

text worlds publish, and every Desk panel declares where it applies.

Outline, Comments, History, AI Results and Voice stand down on Numbers

(each for a stated reason); Chat with Notes and the Thesaurus, which are

workspace tools, remain everywhere. Leave the spreadsheet and the panel

stands back up, answering for the document you returned to.

A cell's menu speaks spreadsheet

The grid's right-click no longer carries a "Word" section, prose prompt

collections, Document Leaders or the prose quick actions. Cell verbs,

clipboard, Paste Special and synonyms remain. Numbers-minded AI arrives

with surface affinity (already designed, P8); until then the menu offers

only what a cell can honestly receive. On Word documents, "New Word

comment" is now "Comment on selection", the same name the action has

everywhere else.

The Numbers band, rebuilt

• Every "Not available yet" door is gone - all forty of them. A

control returns when its feature does; greyed now always means "not

now, for this stated reason", never "someday".

• The band folds instead of scrolling or clipping. Groups that do not

fit fold whole into a labelled "More (n)" overflow, exactly as the

accepted prototype drew it. Nothing clips; nothing vanishes.

• The stuck "Streaming... rows available." pill is dead. It was being

written as the FINAL state of a finished load. Loading messages now end

when loading ends, and while work runs they live in the status bar,

never over the band's chips.

• One name-box row. The duplicate bar above the grid is gone; the

grid's own header carries the name box and the formula bar.

The guard release. The F6 Sweep's worst finding is dead: a spreadsheet can

no longer be "converted to Word".

A workbook is safe from Rich Switch

The sweep proved that right-clicking a Sheet tab offered Rich Switch, and

that clicking it wrote a meaningless .docx beside your workbook while a

toast talked about "the markdown". The eligibility rule always knew a

spreadsheet has no Word counterpart; one door bypassed it.

The conversion engine itself now refuses: whatever door asks, a sheet gets

a plain explanation and nothing is written to disk. A regression test pins

the contract, committed failing against the old build and passing against

this one. The menu entry itself disappears in an upcoming release, when

every document action moves onto one declared contract.

The app now measures itself

pnpm measure drives the built app through a standard walk: cold open to

editable on two fixture classes, warm switches between all three worlds,

palette, Desk panel, Settings and save latencies. The numbers land in

docs/measurements/<version>.json as release evidence, trended before any

threshold is set. The 0.40.0 baseline is recorded, taken before any of the

remediation's performance-affecting work.

Truth in first contact. The F6 Sweep's first finding was that a handful of

sentences promise things the app does not do; this release corrects every

one of them, ahead of everything else in the remediation programme.

The Welcome promise is now exact

Welcome used to say the only network traffic is the AI calls you invoke.

That was not quite true: a few seconds after launch, Markelangelo also

checks whether a newer version exists. The sentence now says so, plainly.

Your files still never leave this machine, and Help ▸ Check for Updates

remains the manual door.

Doors say what they do

• Rich Switch and MD Switch teach with the lexicon's words. The menu

entries now read "Rich Switch (make a Word copy)" and "MD Switch (make a

Markdown copy)": what you get is a copy beside the original, never a

conversion of the file you are looking at.

• New Document knows it offers three worlds. The dialog's caption

named two documents while showing three choices. It now explains that

Markdown and Word can switch to each other, and that a Sheet stays a

spreadsheet.

• Print no longer claims Ctrl+P. That chord opens Go to File (the

editor idiom) and always did; the File pill and command palette stop

advertising it for Print.

• Review ▸ "Commit & push" is now "Git". The button opens the Git

panel; it never committed anything itself. A door is named as a door.

The Numbers surface, made properly native — the band and the right-click,

both re-cut to the designs in P8 (reviewed before building).

The band reads like the other two

The Numbers band now shows its group captions — Clipboard · Font ·

Alignment · Number · Styles · Cells — in the same recipe the Words and Rich

Words bands use, with the overflow scrollbar riding below them rather than

across them.

And the grey trio is grey no more: **Conditional Formatting, Format as

Table and Cell Styles were live, working features all along**, dressed in a

disabled colour by a styling fault. They now carry full ink, and each was

driven in the built app to prove it: Format as Table produced a real styled

table with filter headers; Conditional Formatting opened its rules panel;

Cell Styles applies its fourteen presets.

One right-click menu, thoughtfully merged

The grid's right-click now holds BOTH vocabularies in one designed menu:

the spreadsheet's own verbs first — Cut/Copy/Paste (full fidelity, through

the engine), Paste Special (values, formulas, formats, column widths),

Insert/Delete Row and Column, Clear, Sort, Freeze, Add Note — and

Markelangelo's layer with them: synonyms, the AI actions, your prompts and

Document Leaders. Nothing the engine's menu offered is lost; nothing of

Markelangelo's is missing. Insert Row was machine-verified moving real

cells.

Next (already designed, P8): surface-tagged prompts so only Numbers-minded

AI verbs appear here, the Numbers starter set, and the world names — Words,

Rich Words, Numbers — across the chrome.

The spreadsheet joins the family properly: Markelangelo's own functions now

work on cells. This closes the finding that the Sheet surface had been "put

in wholesale" — a spreadsheet in Markelangelo rather than a Markelangelo

surface.

Select a range, then do — on the grid

The sheet surface now implements the same editor interface the markdown and

Word surfaces implement, over the spreadsheet engine's own command system.

What that means in practice:

• Right-click is Markelangelo's menu, the same one as everywhere else:

Cut/Copy/Paste, the AI actions (Improve, Humanise, Shorten, Expand, Fix

grammar, Tone, Ask AI, Translate), your prompt library and Document

Leaders, and **the thesaurus — synonyms looked up for a cell's word and

written back into the cell**, undoable. The engine's own menu stands down;

every grid operation it carried lives on the band above.

• The AI tab joins the sheet band — the same tab as the other two

surfaces (Prompts, This document, Companions, Sovereignty), plus one

surface note that is also a door: results land in cells. A result that is

a table fills cells from the selection; anything else lands in the anchor

cell. Undo reverses it.

• The File pill now leads the sheet band's tab row, and the quick-action

chips and privacy badge sit at its end — the same furniture, all three

bands.

Under it: one system, not a bolt-on

A selected range reads as a table, an AI result lands as cells, and every

write rides the engine's own undo and save journal. Doors whose concept has

no cell meaning yet (comment anchors, image nodes, block formatting) stand

down honestly instead of failing after the click.

Also in this release: the sheet grid's right-click Copy no longer needs a

permission it was never granted (0.37.3's fix, carried forward).

Three fixes found by Andre in the running app, each closed at root cause, and

the ribbon-architecture recommendation that came out of them.

Vendored styles can no longer leave their surface

The Word app and the Sheets app come from the same upstream and use the same

class names (.ribbon, .app-shell, …). Opening a spreadsheet loaded the

sheet skin globally, and every property the Word stylesheet did not set

leaked onto the Word ribbon: wrapped tabs, a clipped Styles gallery, a stray

scrollbar. A new build-time transform (build/vendor-css-scope.ts) now

rewrites every vendored stylesheet so its selectors can only match inside the

surface that owns it. This also confined Univer's global scrollbar reset,

which had been quietly overriding the app's themed scrollbars everywhere.

Your zoom is yours again

Switching away from a Word tab converted your zoom into "fit width" — coming

back landed on 149% instead of the zoom you chose. The hidden pane's resize

observer was reacting to the 0-width moment of being hidden. It now ignores

it. This predated the Sheets work; the slow first sheet mount just made it

visible.

Copy works from the sheet's right-click menu

Univer's context-menu Copy uses the browser clipboard API, which the app

never granted — it failed with a "Permission Denied" toast. The app's own

session is now allowed clipboard access (it runs only local code), so

right-click Copy/Paste in the grid behaves.

The recommendation

Andre's finding was bigger than the bugs: three ribbon systems from three

codebases, and a sheet surface that Markelangelo's own functions (AI,

prompts, spelling, the thesaurus, our context menu) cannot reach.

UI Review/12-RIBBON-ARCHITECTURE-RECOMMENDATION.md proposes the single

primary architecture and the three unifications that bring the sheet surface

into the fold. It awaits Andre's acceptance; nothing of it ships here.

Andre installed 0.37.0, and within three minutes found what a green test

suite had not: the markdown ribbon's styles gallery broken app-wide, the

window clamped to a fixed minimum width, a sheet returning from a tab switch

with a third of its grid, a second new sheet with no grid at all, and a slow,

heavy app. This release closes every one at root, and changes how releases

are verified so the class of miss cannot recur.

The fixes

• The markdown surface is untouched by the sheet surface, provably. The

vendored spreadsheet stylesheets are written for a window they own — bare

button and body rules included — and were silently overriding

Markelangelo's own chrome everywhere. They now load demoted beneath every

app style, and only when a sheet actually opens: a session that never

touches a sheet never loads a byte of them.

• A sheet you return to paints whole. The grid re-measures the moment its

tab comes back; no more half-painted or blank canvases after switching.

• The grid fills the pane. The stood-down AI side panel no longer leaves

its empty 360px column behind.

• Every new sheet gets its own grid. Opening several sheets (or two new

blank ones in a row) no longer sends the second one's grid into the first

one's pane.

• The installer sheds another ~70 MB, and first launch its minutes. The

release pipeline had been packing the spreadsheet engine's build

intermediates — 345 MB of them — into the app archive, on top of 0.37.0's

double-shipped libraries. Packaging is now an explicit allow-list of what

the app actually loads; the archive's contents are audited as part of the

release.

The practice change

Every release now ends with the consistency lens and chaos walk over the

built app, a hand-driven mixed session reviewed by eye, and an audit of the

shipped installer's actual contents. Green unit and e2e suites are necessary;

they are no longer treated as sufficient.

0.37.0's installer came out 255 MB against 0.36.0's 140 MB, and the sheet

surface only honestly accounts for a fraction of that. The rest was

double-shipping: the sheet surface's UI stack (the Univer engine and its

ribbon's icon set) is compiled into the app's own code at build time, yet the

raw library folders were being packed into the installer as well —

@fluentui/react-icons alone is 290 MB of icon files on disk, of which the

app uses a few dozen, already baked in. Nothing at runtime ever opened those

folders.

This release excludes them from packaging. Same app, same features, same

sheet engine (the 7.7 MB calculation sidecar stays, because that one really

is loaded from disk) — a much smaller download and install.

Also in this release: the calc corpus's Markelangelo-side fixtures now run

in CI (a wiring omission in 0.37.0; the corpus itself was already green

locally and the vendored suites were already in CI).

Markelangelo gains a third document world. A Sheet is a real .xlsx

workbook you own — it opens in Excel too, because Excel compatibility is the

storage format, not an export feature — edited in a proper spreadsheet surface

with formulas, number formats, filters, conditional formatting and charts.

The reason it exists is the report with a cost table that adds up. Until now

that meant a trip to Excel and a dead screenshot on the way back. Now the

table lives, and the document follows it.

The Sheet surface

• Open any .xlsx — from the workspace, the open dialog, recents or

Windows itself — and it lands in the Sheet editor. File ▸ New Document…

offers Sheet beside Markdown and Word; a new sheet is unsaved until Save

As gives it a home, exactly like a new Word document.

• The sheet world is green. The live tab fills in the sheet green the way

a markdown tab is orange and a Word tab document-blue; idle sheet tabs carry

the green wash and glyph. The status bar's doc-kind door reads Sheet —

click it to see the workbook file beside its neighbours (it is a real file;

that is the point), or to Save As while it is still a draft.

• Formulas recalculate as you edit (an embedded calculation engine), and

saving writes a faithful .xlsx: untouched parts of the file are copied

byte-for-byte, so nothing Excel wrote is quietly lost. If the file changed

on disk underneath your unsaved edits — perhaps in Excel — saving refuses

and says so rather than overwriting either side.

• Right-click speaks Markelangelo's menu, the environment's chrome is the

environment's, and sheets keep warm across tab switches from day one — no

ten-second rebuilds.

Paste Special — the three modes

Copy a range in the sheet, paste it into a markdown document, and the paste

asks how it should live there:

• Paste as Live Link — a Linked range: an ordinary table between two

invisible markers that keeps following the workbook. It refreshes when

the document opens, when the workbook changes on disk — **Excel edits

count** — and on demand (Refresh Linked Ranges). Every refresh states what

changed; nothing updates silently.

• Paste as Table — a one-time copy. Yours from here on.
• Paste as Image — a snapshot picture, saved beside the document.

Insert ▸ From Sheet… is the same choice from the document's side: pick a

workbook (open tabs offered first), a named range or a cell range, and a

mode. Named ranges are the sturdy anchor — they follow row and column

inserts; a plain A1:D12 link is honest but positional, and its refreshes

carry a may-have-shifted note. Currency and number formats travel: £1,234.50

in the sheet is £1,234.50 in the report.

Your document never stops being markdown: a Linked range exports and prints

as the table it currently shows, and deleting the markers leaves you a plain

table.

Under the bonnet, honestly stated

• The xlsx engine is a small native helper built in CI and shipped inside

the installer. If it is ever missing, opening a sheet says so plainly

instead of hanging.

• Word documents cannot hold Live Links yet — pasting a range there lands as

a real Word table through Word's own paste, which is the right static

answer; the live kind is markdown-only for now. The sheet surface's own

PDF export and print are also still to come, as is sheet content in

workspace search and Chat with Notes. Each of these is work with an owner,

not a ceiling.

• The vendored spreadsheet stack (GenOffice Sheets on Univer, Apache-2.0) is

mirrored and patched under the same discipline as the Word surface —

vendor/genoffice/UPSTREAM-SHEETS.md is the ledger, and a calc corpus

(cost tables through the real engine, 1,000+ assertions) now gates every

change the way the pagination corpus gates Word.

The first full Journey Suite sweep walked 35 user journeys through the built

app and filed 32 findings. This release answers every one of them: each was

verified against the source before anything was fixed, five turned out to be

faults in the test harness rather than the product, and the rest are closed

here, root cause first, never symptom first.

Nothing collides, nothing camps

• The ribbon folds instead of colliding. With several quick actions and a

narrow window, the tab row used to draw tabs and chips on top of each other,

and the "Add…" chip could not be pressed. The quick-action slot now measures

the room it actually has and folds what does not fit into its overflow menu.

Worst case is a clipped chip, never ink on ink.

• Crash recovery is a banner, not a toast. The "unsaved work from last

time" offer used to sit permanently over the AI Results action bar, blocking

Apply and Insert. It now lives in a quiet strip under the ribbon with two

honest doors: Open the copy, Discard the copy. Several documents share one

row. Persistent toasts have moved to the bottom-left corner, clear of the

desk. A recovered copy also keeps its pictures now.

• Quitting with unsaved work asks first. Closing the window with dirty

tabs used to discard them without a word. The close now walks every unsaved

document through the familiar Save, Don't Save, Cancel funnel, and Cancel

keeps the window open.

The editor keeps its promises

• A callout is a box you write in. Insert a callout and the caret lands

inside it, ready to type, from the ribbon and the slash menu alike. On disk

it is written exactly as GitHub defines an alert (the marker on its own

line, unescaped), so every other markdown tool reads it as a callout too.

• A Desk press keeps your caret. Opening a panel from the right rail

mid-sentence no longer swallows the rest of the sentence.

• Escape leaves Zen. The key everyone presses to get out of things now

works, politely: the find bar, dialogs and menus keep their own Escape.

Sovereignty without interrogation

• A stance decision is made once, on the record. With a cloud stance and

Anthropic Max, every single run used to stop on the same consent dialog.

The dialog now says the route honestly ("Direct to Anthropic, your Max

subscription") and offers "Don't ask again for this model while my stance

is X". Every remembered consent is listed in Privacy & Sovereignty, one

click to revoke. When your default model is outside your stance, one quiet

line in AI Results points at the room where that is fixed.

Search tells the whole truth

• Folder search reads Word documents. A search across your workspace now

looks inside .docx files as well as notes, with its own time budget and an

honest count on the rare occasion it runs out. "No matches" over a folder

of Word documents no longer means "did not look".

The rest of the list

• History rows carry their own Restore on hover, so the way back is one

visible click. The confirm stays.

• The Properties panel no longer shows the Page & Style keys twice; the

labelled controls are the only controls.

• A document that numbers its own headings can turn the style set's counters

off with numbering: false in its frontmatter, or from the new "Number

headings" switch in Page & Style. Depth can be overridden with

numbering: 2. Editor, page view and every export agree.

• A whole-document spell check no longer pays the expensive suggestion lookup

for every unknown word on every pass; suggestions are cached and bounded.

• The Word ribbon's glyph buttons carry real accessible names, so a screen

reader hears "Bold", not "B". Done from our side of the seam, with the

vendored tree untouched.

• One name per thing: Toggle Comments, Toggle Outline and Toggle Properties

(the rooms' own names), and the tab menu says Close others and Close to the

right in sentence case.

• Ribbon tabs and captions sit on the standard type scale; the tabs keep

their deliberate Word-style square corners, now on the record.

For the record

Five sweep findings were retired as harness artefacts after source

verification, among them "proofread finds nothing on Word documents", which

works and was mismeasured. The remediation also surfaced and closed a gap no

finding had named: the missing quit guard. The full audit trail, finding by

finding, lives in the repository's Journey Suite ledger.

Orange for markdown, blue for Word. One glance at the tab strip now answers

both questions a writer asks of it: which document am I in, and **which

editor is that**.

The live tab wears its world's colour

The document you are working on is a solid card in the colour of its world —

the mark's orange for markdown, document-blue for Word — with light text, a

little taller than its neighbours and room for a longer title. Nothing else on

the strip competes with it.

Everything at rest is quiet paper: plain cards with a hairline edge and

full-strength titles, so a tab reads as a tab whether or not you are on it. A

Word document you are not in still says so, carrying a soft blue tint and a

blue document glyph, so you can see at a glance which of your open files are

Word ones.

The gold that used to mark the current tab has retired from the strip — gold on

orange simply disappears, and the colour is now the marker. Gold keeps every

other job it has in the app: the unsaved dot on a resting tab, lit toggles, AI

presence.

Under it, a colour rule that keeps every theme honest

The two new colours are proper design tokens with per-theme values, so

Athenaeum, Midnight Oracle and Scriptorium each get a version tuned for their

own paper. Each one was checked in the running app rather than by eye: the text

on a live tab clears the accessibility contrast bar on all three themes (one

was 4.35 and got deepened until it did).

The same pass fixed a subtler thing across the whole app. Blending two colours

can be done two ways, and one of them travels the long way round the colour

wheel — which is how a blue tint can come out green. Twenty-three places were

quietly doing it the wrong way; they now do it the right way, and a standing

test measures the blue to make sure it stays blue.

Four things Andre found in 0.33.0. Three were the same kind of fault: work

being thrown away and done again.

Switching tabs is instant again

A Word document you had already opened was being **rebuilt from scratch every

time you came back to its tab** — the file re-read, re-parsed and re-paginated

from the beginning. On a manual full of screenshots that measured ten seconds

a switch, every switch, and with a dozen files open the whole app felt stuck.

Recently used Word documents now stay warm, the way markdown documents

already did, so returning to one is simply a matter of showing it. Measured on

an 84 MB document with twenty-five pictures: 9.6 seconds down to 0.35.

Markdown switching got faster with it. The first time you open a document

still takes as long as reading it takes; you now pay that once.

Keeping documents warm costs memory, so there is a ceiling on it: enough for

several ordinary Word documents or a couple of picture-heavy manuals, after

which the least recently used one is let go rather than the app growing without

limit. A document you are looking at, or one with unsaved changes, is never let

go.

A picture you put in a document is a real file

Dropping or pasting a picture into the markdown editor was quietly creating a

temporary in-memory link instead of saving the file. Three consequences,

all of them things you saw:

• the paragraph you dropped it into was cut in half, mid-word;
• the saved document pointed at a picture that no longer existed once the app

closed;

• Rich Switch produced a Word document with no pictures in it, because

there was no file to carry across.

Every route now saves the picture into the document's assets folder — drop,

paste, and the editor's own Upload button — and lands it cleanly between

paragraphs instead of splitting one. Wrapping it, and deleting it, leave your

prose exactly as it was.

One thing this cannot fix: a document that already contains one of those

temporary links has nothing to recover, because the picture was never written

anywhere. Drop it in again and it will stick this time.

The two ribbons really do match now

The sizes, weights and icons were already coming from one source. The colours

were not: the Word ribbon left every tab at full strength and highlighted the

live one in gold, while the markdown ribbon keeps its tabs quiet and darkens

the one you are on. Same letters, heavier-looking band — which is exactly what

Andre's eye caught. Both rows now behave the same way: quiet at rest, dark

when live, gold underneath.

The findings pass on 0.32.0: consistency between the two editors, and the

Image Studio made to work everywhere it is offered.

One look across both editors

The Word ribbon now takes its **typeface sizes, weights and icon weight from

the markdown ribbon's own recipes** — the lighter look, from a single

source. Tabs, buttons, captions, dropdowns and icons all read as one family;

a standing test measures the two ribbons identical.

One name for one function

Where the same function exists on both editors it now carries one name:

Picture is Image, Show Comments is Comments, New Comment is

Comment on selection, Insert Footnote is Footnote, and our own

Contents became Table of Contents. Their window-splitting Split is now

Split Window, so one word no longer means two things. Two dead buttons

that could never work in Markelangelo (the bundled editor's own AI spelling

and translate) are gone — Check Spelling and AI ▸ Translate serve

both editors. The full map, including what deliberately keeps Word's own

words, is docs/PARITY-MAP.md.

The Image Studio, everywhere

It now works on every document kind: saved markdown, unsaved drafts, and

Word documents — where pictures gained the toolbar, the double-click and a

working Done. When something cannot be edited, the Studio now says exactly

why in plain English instead of one unhelpful sentence: an unsaved

document's relative link, a picture with no data, a web-linked image (now

fetched properly). Pictures anchored inside a Word paragraph are declined

up front with an honest explanation rather than failing at the end.

Seven days of work aimed at one sentence: *you never get a second chance to

make a first impression.* Everything on the agreed list

(docs/FIRST-IMPRESSION.md) except the branded installer, which is parked

with code signing by choice.

The Image Studio

The whole PowerPoint round trip, retired. Double-click any picture (or

press Edit on its toolbar) and finish it without leaving the app: crop,

arrows, boxes, ellipses, highlights, blur for hiding anything sensitive,

a border or shadow, width presets, a caption, a credit line and

alt text with a one-click AI draft. It works on both editors, and it is

non-destructive: the original is kept, and double-clicking a finished figure

reopens the edit exactly where you left it. Captioned pictures export as

auto-numbered figures that renumber themselves when you move them.

Combine

Several open documents become one new unsaved document, in the order you

choose. File ▸ Combine Documents… shows every open document as a card — drag

to reorder, untick to leave out, press Combine. Your original files are never

touched. By default each document's title becomes a chapter heading and its

own headings step down one level, so five ideas become five chapters;

pictures come along; Markdown and Word combine together, and the result can

be either kind.

Nothing is ever lost

Crash insurance, everywhere. Unsaved edits to a saved file — either kind —

now survive a crash or a forced restart, and are offered back the next

time you open Markelangelo. A brand-new, never-saved **Word document now

comes back as a Word document** with everything you typed. Recovered copies

are always offered, never silently applied. (Also fixed on the way: an

unsaved Word document used to pop a Save dialog on its own thirty seconds

after your first word.)

Landscape pages, drawn true

A document that turns landscape mid-way now **draws each page at its own

width while you edit** — portrait pages portrait, landscape pages landscape,

all centred like Word. The file, preview and PDF were already right; now the

canvas tells the same truth.

Drop a file, it opens

Drag a markdown or Word file from Explorer onto the window and it opens.

Dropping an image into the editor still inserts it as a picture, as before.

Honest AI signals

When a review lens reads a passage, the passage now shimmers quietly

until the comment arrives, and a toast says what is happening. And an AI

comment's highlight is now a dotted hairline — an annotation can no longer be

mistaken for a tracked edit.

Your first pass over 0.30.0 found two things, and both are fixed here: the

ribbon had drifted from the design it was built to, and the doors into the Word

editor were harder to find than they should be.

The ribbon looks like its design again

Three faults, all of them visible the moment you looked:

• Labels were cut off. "Cont…", "Wiki-l…", "Run P…", "Docu…", "Make…". Big

buttons had been given a fixed width and told to truncate. They size to their

label now and nothing is clipped, on any of the six tabs.

• The styles gallery had lost its boxes. Paragraph, Heading 1, Quote and the

rest are bordered specimen tiles again, each showing the mark it applies —

¶, H1, H2, H3, ❝, <> — with the current one filled in gold. Marks are

letterforms too: B, I, ~~S~~.

• Group captions sat at different heights. The band now holds a minimum

height, so every caption across every tab lines up on one baseline.

The tabs, the File pill and the style-set gallery on the Page tab all match the

accepted design as well. The Word ribbon's AI tab is drawn by the very same

component as the markdown one, so the two cannot drift apart again.

A Word document you can just start

File ▸ New Document now asks which kind — Markdown or Word — and

opens an unsaved document of that kind. Nothing is written to disk until you

save it, exactly as a new document should behave.

Until now the only way into the Word editor was to make a markdown document,

save it, and convert — three steps, and the middle one was never mentioned.

The File menu tells the truth

Rich Switch did nothing on a document that had not been saved, and gave no

hint why. That is why it appeared broken on the What's New document, which lives

in memory and has no file.

Two fixes:

• Rich Switch works on an unsaved document. It converts in memory and hands

you an unsaved Word document. Neither one needs a home until you give it one.

• The File menu only offers what applies. A markdown document is offered

Rich Switch; a Word document is offered MD Switch. No more entries that look

live and quietly do nothing.

One File menu, on both editors

The Word editor had its own File button with three items — Open, Save, Save As.

Markelangelo's has those and eleven more, in the app's own words. Theirs now

stands down and ours takes its place, which means **MD Switch and Open the

Markdown Counterpart are visible entries** on a Word document rather than

something you had to know was hiding in the status bar.

And going back is a return, not a conversion: if the markdown you came from is

still open, MD Switch simply goes to it, instead of asking a four-way question

about a file you did not know you were creating.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

The last of three releases that make the whole environment speak one language.

0.28.0 gave every control the same parts, 0.29.0 gave both editors the same

ribbon, and this one sorts out where things live and what they are called.

Two rails that mean something

The window now reads left to right as files → text → actions → document.

• Left is the Library: things you keep. Files, Recents, Search, Git. It has

a one-word identity at last.

• Right is the Desk: this document, right now — and it names its families

instead of offering eleven unlabelled icons. Inspect (Outline, Properties,

Backlinks, Paged preview) · Record (Comments, History) · AI Desk (AI

Results, Chat with Notes, Voice) · Tools (Thesaurus). Expand the rail and

you see the names; collapsed, thin separators keep them apart.

Your prompt, Leader and Flow libraries moved off the left rail to the ribbon's

AI tab. The panels are unchanged and still open with the same commands: they are

actions, and actions belong in hands rather than drawers.

Usage left the rail too. It is your spend across the app, not a fact about

the document in front of you, so it opens from the cost figure in the status bar

or from AI ▸ Usage & Costs.

AI Results

The right-hand AI panel is now called AI Results, which is what it is:

the place a run's answer arrives to be applied, inserted, copied or discarded.

The old name collided with the entire AI family and told you nothing.

One list, wherever you meet it

Prompts, Document Leaders and Flows are three collections of the same shape, and

every place that showed one used to draw its own rows — different order,

different affordances — so the same five prompts read as three different

features depending on where you found them. There is one row now, everywhere.

Two things it says that nothing said before:

• Which verb a click performs. A ▶ appears on the row on hover, and a ✎

beside it for editing. Clicking a row runs it; that was always true and now it

looks true.

• Where the answer will arrive. A prompt that answers you and a lens

that leaves comments on the passage used to look identical. They do not now:

the row carries a small mark, and the right-click menu names the outcome —

Ask about this and Comment on this → Comments — rather than the category.

That last one is a fix for a real confusion: choosing a lens made the text go

gold with no panel and nothing to undo, and nothing had told you that was what

would happen.

Words that stay put

A concept now has exactly one name, and it is the same name in the ribbon, the

menus, the palette, the panels, tooltips, the status bar and this guide. The

drift that existed is gone: "Open the Markdown/Rich Counterpart" is **Open the

Word Counterpart, and the "Quick Action Bar" is simply Quick actions**,

since the bar it was named after no longer exists.

Two documents now ship with the app's source to keep it that way: a design

standard and a vocabulary. New features sign both before they are written.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

The second of three releases that make the whole environment speak one language.

0.28.0 gave every control the same parts. This one gives both editors the same

band across the top.

A ribbon on the markdown side

Six tabs: Home (writing), Insert (things that land in the page),

AI, Page (paper, margins, style sets), Review (spelling, comments,

history) and View (panels, appearance, zoom, split). A gold File pill at

the left that says exactly what the File menu says.

It is not a bigger toolbar, it is a legible one:

• Every group names itself underneath. Word hides its group captions; we

show ours, so nothing has to be memorised.

• Toggles light in gold when they are on. Put your caret in bold text and

B lights. The old toolbar never did this, which meant the only way to know

what formatting you were in was to look at the words.

• Things that cannot act are greyed, not hidden. With nothing selected,

Ask AI is visibly unavailable rather than mysteriously inert.

• The Page tab tells the truth on a plain document. It leads with **Make it

Rich**, and everything downstream stands down until the document actually has

page setup to edit.

Ctrl+F1, or a double-click on the active tab, folds the body away. Collapsed,

there is less chrome above your page than before the ribbon existed: one tab

row and then the document.

An AI tab in the Word ribbon

A Word document keeps every one of Word's own tabs and gains ours, in the same

place, with the same buttons as the markdown side. It also carries the one thing

that is genuinely different here: AI edits arrive tracked, said plainly, and

clicking it takes you to Review to accept or reject them.

Quick actions that say what they are

Your own actions used to be a row of bare icons in a band you could toggle

away, so "one click" depended on whether the band was open, and telling two

custom icons apart meant hovering to read a tooltip.

They are now permanent chips on the ribbon's tab row, **on every tab and both

editors: icon, accent colour and the nickname visible. ✦ Prompts** leads

the row and is always there. Right-click a chip to manage it. Beyond four they

fold into a ⌄ menu, still labelled.

Three bands become one

The formatting toolbar, the RichMD strip and the Word-document strip are gone,

and so is the icon cluster on the tab strip. Nothing they held was lost:

• Formatting → Home. Page setup and style sets → Page. The View popover

→ View. Quick actions → the tab row. MD Switch and the counterpart → the

File menu and the status bar's document button, which was always the

one-click switch.

• The tracked-changes count moved to the tab row, and is still a door to

Review.

• The picture controls moved to the picture. Select a screenshot and a small

toolbar appears just above it: wrap None / Left / Right, and the width. The

same control in the same place on both editors, which is where a control that

belongs to one picture should always have been.

Also fixed, while proving the above

Selecting text on a markdown document never told the rest of the app it had

happened. Nothing loud broke — the AI reads the editor directly — but the status

bar's "12 words selected" has quietly never worked. It does now.

What is next

0.30.0 does the rails, the lists and the words: named families on both

rails, one list component wherever prompts appear, and a wording sweep so a

concept has one name everywhere.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Markelangelo had grown two design grammars: the calm, icon-only markdown side,

and the labelled, grouped Word ribbon. They met in one window and the seams

showed. This is the first of three releases that make the whole environment

speak one language.

This one is foundations. Almost nothing moves; almost everything is drawn from

the same set of parts for the first time.

Buttons, rings and icons

Six independent button recipes had grown up across the chrome, none of them

sharing code: the markdown toolbar, both rails, the tab strip, both document

strips and the status bar each had their own. There is now one, in four sizes.

One focus ring instead of three. Two radii instead of three. One icon size

ladder instead of two idioms plus an 18px outlier that appeared nowhere else.

You will notice this as things simply lining up: the same button feels the same

wherever you press it.

Tooltips that behave the same everywhere

Hints used to appear after 300ms in one place, 350ms in another and 450ms in a

third, and some controls had no tooltip at all, just the operating system's own

grey box. There is one tooltip now, one delay, and shortcuts sit in their own

slot beside the label rather than being written into it.

Colours you choose survive the theme you choose

Quick-action icons used to take a free colour. Picked against Athenaeum, that

colour followed you into Midnight Oracle where it could land anywhere from

invisible to shouting. Colours are now eight named accents, Gold, Ink, Rust,

Amber, Leaf, Sea, Iris and Rose, that re-tune themselves per theme.

Your existing colours are migrated to the nearest one automatically, so nothing

needs re-picking. The original value is kept in the file, so nothing is lost.

The Word surface joins the room

Three things had never quite crossed the seam:

• Dark themes reached the ribbon. The vendored editor keys its dark palette

off a signal nothing was sending, so in Midnight Oracle it stayed light

underneath and only survived on the colours we had already bridged.

• The ruler, tooltips, preview backdrop, chips and focus rings were Office

grey and Office blue in every theme. They are Markelangelo colours now. The

page itself stays white, deliberately: paper is paper, in every theme, because

it is what your reader will see.

• There is one status bar. The vendored one had been kept alive, half

hidden, for its zoom control. Zoom is now an item on Markelangelo's own bar

on Word tabs, with minus, plus, a level menu, Fit width and Fit page, and

theirs is gone.

Under the floor

The two rails were byte-identical copies of each other and are now one

component. Two dock panels shared an ordering number, so their sequence rested

on a coincidence. Some comments described a toolbar that stopped existing

several releases ago.

What is next

0.29.0 brings the ribbon: six tabs on the markdown surface, an AI tab on the

Word one, and the retirement of the bands they replace. 0.30.0 does the

rails, the lists and the words.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

The Word editor exists so you can finish a piece of work without leaving. This

release closes the gaps that made you leave anyway — and removes the last places

where the app pointed at Word and told you to go there.

Footnotes are footnotes

A footnote written in markdown as [^1] used to arrive in a Word document as a

heading called "Footnotes" and a list at the very end. It is now a **real Word

footnote**: at the foot of the page it is referenced on, numbered by Word, and

renumbered as you edit. It shows there in the editor too.

"Page 3 of 12" can be written

A footer of {page} of {pages} gave you a bare page number, because nothing

supplied the total. It now counts the pages for real, and keeps counting as the

document grows.

A landscape page no longer stops a PDF

A document that turns landscape for a wide table or a full-width screenshot

could not be exported to PDF at all — the app said so, and pointed at Word.

It exports to one PDF now, each page on the paper it was written for.

Spelling, on both editors

Proofread — the whole-document pass with the green suggestion pills — works

on a Word document. Press F7, go through the lot, accept them one by one or all

at once. It was markdown-only for no better reason than that it had not been

built here yet.

Pictures you can place

Select a screenshot in a Word document and a Wrap control appears on the

strip above it: None, Left or Right. You can say which side the text runs down

without leaving the page.

Right-click gives you everything again

The Word actions are back alongside the AI ones, in a menu that now has both:

Font, Paragraph, Hyperlink, New Word comment, Update fields, and Restart or

Continue numbering when you are in a list — plus Paste as plain text. Getting to

one menu had quietly cost three of those, and numbering restart is not a small

thing in a long manual.

Web artefacts from a Word document

Export as HTML and Copy as HTML work on a Word document, and the

pictures come with them — inlined, so what you paste or publish still shows its

screenshots wherever it lands.

What is left

A document that mixes portrait and landscape still draws every page at the

width of the section your cursor is in. The file, the paged preview and the PDF

are all correct, so your landscape pages are landscape everywhere it counts —

it is the editing canvas that has not caught up, and it is next.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

The journey this app is actually for — notes in markdown, worked over with AI,

then switched to finish as a manual with screenshots, tables and a running

header — had never once been run end to end. It has now, and it found things.

Text next to a picture is on the page again

If you put a screenshot in a Word document and let the text wrap around it, that

text was not shown. Word showed it, the file contained it, Markelangelo drew

the picture and dropped the words. In a user manual that is every second page.

The paragraph now appears, and it is editable — click into it and type, just

like any other. The picture still floats exactly where Word floats it, left or

right as the document says. The words were never lost from the file at any

point; the torture document we test against went from 697 to 831 words the

moment this was fixed, which is the size of what had been invisible.

The same paragraph was also missing from the AI's view of your document, from

the word count, and from MD Switch — so a markdown copy silently lost it.

All three now have it.

A prompt with nothing to work on

Run one of the review prompts — Clarity, Evidence check, Devil's advocate — from

the sparkle menu and the AI would answer "No text was provided to review"

about the document right in front of you.

Those prompts are written as plain instructions, with no {{selection}} or

{{document}} marker in them, because the comment route hands them your text

another way. Run them any other way and your text simply was not in the message.

Any prompt you write yourself had the same trap, with nothing to warn you.

Now a prompt that names no place for your text still gets it, attached the way a

one-off instruction's is. A prompt that does place it keeps full control.

Callouts and wiki-links stop printing as source

A > [!NOTE] block arrived in an exported or converted document with the literal

[!NOTE] at the top of an ordinary quote, and [[a wiki link]] kept its

brackets. Both now come across properly: callouts as titled, tinted boxes in

their five kinds, wiki-links as the words you wrote.

These have been wrong in "Export as Word" for a long time. They only became

serious when that same pipeline became the way into the Word editor.

Smaller things

• A markdown and a Word document with the same name in the same folder showed

identical tab titles. The extension comes back when it is the only thing that

tells them apart.

• Two Word documents open at once behave: the ribbon, the AI and the status bar

all act on the one you are looking at, and a document you have been editing

stays live in the background rather than being thrown away.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

0.27.0 brought a second editor: a Word-grade surface for

real .docx, with the whole AI layer working on it. Five minutes of real use

found two faults that should never have shipped, so the whole thing has been

gone over one user story at a time — every door, every panel, every icon, on

both editors. Install this one.

Rich Switch is where you can see it

Look at the bottom-left of the window. Every document now says which world it is

in, Markdown or Word, and that label is the switch: one click makes the

other version and opens it. It is also in the File menu and on a tab's

right-click menu.

Before, the only button lived on the strip above a document that already had

page setup, which meant an ordinary markdown document had no button at all. That

was the wrong home for it. Rich Switch is not a property of rich markdown, it is

a property of being a document.

If you have already made the counterpart, you are now offered it rather than a

second copy of it.

Insert at top no longer flattens a Word document

"Insert at top" read the whole document and wrote it back with the new text on

the front. On a Word document that meant replacing it with its own plain-text

version: pictures gone, six pages down to three. It is now a real insert, on

both editors, and on a Word document it arrives as a tracked change like every

other AI edit, so one undo or one reject puts it back.

The same fault could have reached two other places. A flow that rewrites the

whole document now lands as a tracked change and says out loud what markdown

cannot carry, and a test now watches for anyone reaching for that shortcut

again.

Pictures the AI makes actually arrive

Markdown links its pictures; Word embeds them. Generating an image on a Word

document used to produce nothing at all: no picture, no placeholder, no error.

Generated images, images from disk and images fetched from a URL are all

embedded properly now.

PDF and Print work on a Word document

0.27.1 removed export from Word documents because export renders markdown, which

would have given you the wrong document. Correct, but it left a word processor

with no way to make a PDF. File ▸ Export as PDF and Print now produce

the pages you are looking at, laid out exactly as they are. HTML and Word export

remain markdown routes and stay absent; MD Switch gets you to them.

A document mixing more than one paper size cannot be gathered into one PDF yet,

and says so rather than failing quietly.

The ribbon

Three things were wrong with the band at the top of a Word document, and the

first was the worst: its tab row came from an app where it doubled as the

window's drag handle, so clicking Review or View moved the window

instead of changing tabs. It also reserved space for buttons that are not there,

and clipped at "R…" when a side panel was open, putting the last tabs out of

reach entirely. The row now wraps, stays clickable, and the controls below it

show a scrollbar when there are more of them than fit.

Right-click now gives you the AI, on both editors

Right-clicking inside a Word document used to open two menus at once — the

vendored editor's on top, Markelangelo's underneath in a cut-down form you never

saw. So the menu you got was the wrong one: it offered Mac keyboard shortcuts on

Windows, two entries wired to an assistant that is not part of Markelangelo, and

none of your AI actions, prompts, document leaders, thesaurus or spelling

corrections. All of those were a right-click away on a markdown document and

nowhere on a Word one.

Now there is one menu, and it is Markelangelo's, on both editors. Font,

Paragraph, Hyperlink, New Comment and the table and picture tools are on the

ribbon just above, where Word puts them too. Bullet and numbered lists work from

the menu on a Word document; the few entries that have no Word equivalent

(inline code, quote, task list, code block) are simply not offered there.

Smaller things, all of them the same idea

• The tracked-changes count above a Word document is now a button that takes

you to the Review tab, and it counts changes the way Word does, rather than

counting one per fragment.

• Opening a .docx through File ▸ Open lands in the Word editor. It used to

show the file's raw compressed bytes as text.

• Word tabs show the document's name, like markdown tabs do, with a small mark

to say which editor they open in.

• Properties, Backlinks and Paged Preview are markdown features and are no

longer offered on a Word document, where they would have done nothing — or

worse, in the paged preview's case, shown you a preview of a different

document. The ribbon's Layout, Design and References tabs do those jobs.

• Insert Table of Contents is markdown-only; Word's own References tab builds a

real one with page numbers.

The rule behind all of it: **anything that reports a state should be a door to

that state, and anything that cannot do its job should not be on screen.**

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

A follow-up to 0.27.0, which introduced the rich Word

editor. Install this one rather than 0.27.0.

Export no longer offers to export the wrong thing

File ▸ Export renders markdown. On a Word document the only markdown available

is the plain-text version of it, so exporting one would have quietly produced a

re-rendered approximation instead of the document you were looking at — the

wrong pages, the wrong layout, and no sign anything had been lost.

Those entries (Export as PDF, HTML and Word, Print, and Copy as HTML) are now

simply absent on a Word document. If you do want the markdown route, **MD

Switch** makes a markdown copy and everything works on that as usual.

*(From 0.27.2 onwards, Export as PDF and Print came back on Word documents and

produce the pages you are looking at. This note is kept as it shipped.)*

Nothing else has changed from 0.27.0. If you have not read what that release

brought — a second, Word-grade editor, Rich Switch and MD Switch, and your whole

AI layer working on .docx with its edits arriving as tracked changes — it is

worth a look.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Markelangelo has a second editor.

Keep writing in markdown the way you always have. When a document needs to

become a document — the one you send, print or hand to a client — press

Rich Switch. It converts to a real .docx and opens it in a proper

word processor: ribbon, ruler, actual pages, comments, tracked changes.

And MD Switch brings it back to markdown whenever you want. Neither

direction destroys anything: you get a new file beside the old one, and both

stay open.

Two editors, one app

Open any .docx — from the file tree, the open dialog, or straight from

Explorer — and it opens in the rich editor. Everything you expect is there:

• a ribbon with Home, Insert, Draw, Design, Layout, References, Review

and View

• real pagination — pages, page breaks, running headers and footers, page

numbers, all matching what Word shows

• tables with merged cells, images you can resize, equations,

footnotes, a table of contents with real page numbers

• comments and tracked changes, with accept and reject
• even ink: pen annotations that save as pictures Word can read, and stay

editable when you reopen them here

Saving edits only the paragraphs you actually changed, so everything else in

the file comes back exactly as it was. A document that has been through

Markelangelo still opens cleanly in Word.

Your AI works on Word documents too

This is the part that matters. Every AI feature you already use — quick

actions, your prompt library, personas, flows, chat with your notes — works on

a .docx exactly as it does on markdown.

With one improvement: an AI edit arrives as a tracked change. It appears in

the review pane attributed to "Markelangelo AI", and you accept or reject it,

here or later in Word. Nothing is silently rewritten.

The outline panel, word count, find and replace, snapshot history and your

quick actions all follow you across too.

Rich Switch

On any markdown document with page setup, there is now a Rich Switch button

on the rich strip; it is also in the command palette and the File menu. It

takes your page size, margins, running header and footer and style set with it,

so the Word document arrives looking like the document you set up.

MD Switch

From a Word document, MD Switch writes a markdown copy beside it. Headings,

bold and italic, links, lists, tables, footnotes, equations and images all come

across, page setup lands in the frontmatter, and pictures are extracted into an

assets folder.

Some things cannot survive the trip, and Markelangelo tells you which rather

than quietly dropping them: Word comments are not carried over, tracked changes

are accepted first, and anything with no markdown equivalent is flattened with

a note where it was. The Word document itself is never touched.

Two things to know

Two rough edges we have inherited and are working on. Neither loses any of your

work — both are only about what the editing canvas draws:

• A document that mixes portrait and landscape sections shows every section at

the width of whichever section your cursor is in. The saved file, and the

page preview, are both correct.

• Pictures set to wrap text are drawn as a close approximation rather than

exactly as Word draws them, and a picture placed behind the text shows

faded instead. Again, the file itself is exact.

Also for now: one rich document at a time in split view, and Proofread stays a

markdown feature.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Image wrap arrived in 0.26.0 with some rough edges. This is the pass that

takes them off.

The size control now actually resizes

Setting a width resized the box the picture sat in, while the picture itself

stayed its own size, overflowed and got clipped. That also pushed the image's

own handles out of view. Pictures now scale to the width you choose, keeping

their proportions.

You can also set a size without wrapping, which was oddly not allowed

before, and there is an Original option to take the size back off. Widths

run from 25% to 100%.

Code blocks no longer draw over your pictures

Text flows around a wrapped image, but a code block, a table or a callout is a

solid box: it kept its full width and slid underneath, drawing straight over

the picture. Those now start a fresh band of the page instead, in the editor,

the paged preview and the exported file alike.

No more leftover markers

Deleting, cutting or dragging away a wrapped picture used to leave its

<!--mk:img--> setting behind in the document, where it turned up as visible

text. The setting now goes with the picture, and one undo brings both back

together. A marker you wrote by hand is never touched.

Settings that stick

Three timing faults are fixed: two Page & Style changes made in quick

succession could lose one; a page-setup change made just after typing a

property could be overwritten by it; and the wrap control could act on a stale

copy of its own last change, quietly undoing it.

Also: a document whose frontmatter cannot be read is now left strictly alone

rather than looking merely empty, so nothing can silently replace YAML the app

could not parse.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

The last piece of RichMD.

Image wrap

Click a picture in a rich document and the strip above the editor offers

wrap and width. Choose Wrap right at 40% and the text runs up the

left of it, instead of stopping dead above and starting again below.

It works in the editor, in the PDF, in the Word file and in the HTML export,

from one source, so they all agree.

Still just markdown

The setting is written as an ordinary HTML comment on the line before the

image:

```markdown

<!--mk:img wrap=right width=40%-->

!A diagram

```

Every markdown renderer in the world ignores that line silently. Nothing about

your image changes. Open the file in any other editor and it is the document

you wrote, with one invisible comment in it — and choosing No wrap takes even

that away.

That is why it is a comment and not the fashionable {.wrap-right width=40%}

attribute syntax: attributes show up as literal visible text in editors that do

not support them, which would break the promise the whole feature rests on.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

The second half of RichMD: the part you can see.

Style sets, not thirty-six knobs

Six heading levels times six properties is a settings page nobody enjoys, and

it is not where Word's power actually comes from. The power is *applying a

consistent set*. So a document picks one:

```yaml

style: manual

```

Five ship with the app:

• Plain — the Markelangelo look. Nothing added, and the default.
• Report — numbered sections, sans-serif headings. Business documents.
• Manual — deeply numbered, ruled headings. Guides and handbooks.
• Article — editorial serif, generous spacing, no numbering.
• Technical — dense, numbered all the way down. Specifications.

Numbered sets number themselves: 1, 1.1, 1.1.1, renumbering as sections move.

That is presentation only. Your markdown still says ## Heading, and always

will.

One source drives the editor and the export, so what you see while writing

is what lands in the PDF or the Word file.

Sets are structured data, never raw CSS. That is deliberate: style packs are

meant to travel, and arbitrary CSS can reach out for remote fonts and images.

Ours cannot.

A page-like writing column

Turn on Page view and the writing column takes the real proportions and

margins of your chosen paper, with the running header and footer shown in

bands. It looks like the thing it is going to become.

It is page-like, deliberately: it does not break your document into pages

while you are typing in it. That is what the next one is for.

Real pages, one click away

The Paged Preview shows the document as actual sheets, with real headers,

footers and page numbers, beside the editor while you write.

It is not an imitation of the export. It is the export renderer, shown in a

pane instead of written to a file.

The Rich strip

Rich documents get a thin strip above the editor: the style picker, page view,

paged preview, and the paper you are set to. Plain documents get no new chrome

at all.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Stop re-picking A4 on every single export

Paper size, margins, orientation, a running header and footer, and page

numbering now belong to the document, not to the export dialog you fill in

again every time.

Open Properties ▸ Page & Style and press Make it Rich. The settings are

written into your document's own YAML frontmatter, exactly the sort of thing

Pandoc already understands:

```yaml

title: Field Manual

papersize: a4

geometry: margin=1.5cm

header: Field Manual

footer: Page {page} of {pages}

pagenumbers: true

```

Export to PDF or Word and the dialog arrives already filled in from that. Change

something there and it applies to that one export only, without touching your

file.

Headers and footers that actually print

Your header and footer text now reaches PDF, Word and the printer. Four

placeholders are understood:

• {page} and {pages} — the page number and the total
• {title} — the document's title
• {date} — today's date

Rich is something a document is, not a mode you switch on

There is no stored flag anywhere. A document that arrives carrying those

keys — from a colleague, a git pull, a template — is rich the moment you open

it, with nobody pressing anything. A status-bar badge reads Rich · A4 and

takes you straight to the settings.

And Make it plain again strips every one of those keys, cleanly. That is the

promise: your file is yours, and you can always get back to ordinary markdown.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

A more obvious home for Git

The Git panel has moved from the right-hand dock to the left sidebar,

where it sits alongside Files, Recents and Search.

That is where it belongs: the left sidebar is about your folder, while the

right-hand dock is about the document you are in. Git is a folder thing. It

is also where every other editor keeps source control, so it is simply where

your hand already goes.

Nothing else changed. Click Git in the left sidebar, or the branch name in

the status bar, and you are straight into commit and push.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

GitHub, without the web editor

If the markdown you care about lives in a git repository, you can now edit it in

Markelangelo and send it straight back, instead of hand-editing in a browser

textarea or copying and pasting.

• Clone a repository from the command palette (**Clone Repository from

GitHub…**), or straight from the Git panel. Paste the address, pick a folder,

and the clone opens as your workspace.

• Already cloned? Open that folder as your workspace and the new Git

panel notices by itself.

• Commit and push in one click. The Git panel lists everything that has

changed, you tick what you want, write a message, and press Commit & Push.

• Pull brings down anything new before you start.
• The status bar shows your branch, how many files have changed, and any

commits waiting to go up or come down. It stays completely hidden unless the

folder you have open is a repository.

You don't need to save first. Committing saves any open files from that

repository automatically, and tells you it did.

And your sign-in is the one you already have. Markelangelo uses the Git

already installed on your machine, so private repositories work exactly as they

do in your terminal. The app never asks for, sees or stores a password, token or

key of any kind, there is no account to create and no permissions to grant.

Find it in the left sidebar ▸ Git, or search the command palette for "Git".

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Authoring

• Bigger personas. The persona instruction limit is now **50,000

characters** (up from 20,000), so a richly detailed voice fits comfortably

with room to spare. Prompt templates remain generous at 100,000 characters.

Nothing else to do, update from Help ▸ Check for Updates, or just wait: the

app updates itself.

Export

• Export to Word (.docx). File ▸ Export as Word… turns the current

document into an editable Word file, with the same options you already know:

title, styled or bare, syntax highlighting, light or dark theme, typeface and

size, page size, margins and landscape. Your headings, lists, tables, links,

block quotes and images all come across, images embedded in the file so it

travels on its own.

• Word joins HTML, PDF, Print and Copy as HTML (which puts the

formatted document on the clipboard, ready to paste straight into Word or an

email).

A note on fidelity: because Word export runs through the same renderer as HTML

and PDF, callouts arrive as plain block quotes and code blocks keep their

text but not their syntax colours. Everything else lands as you would expect.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Appearance

• A proper palette. The surface colour picker now offers a named set to

choose from: Signal blue, Ember, Slate teal, Iris, Moss,

Solar orange and Magenta, alongside Theme default and Neutral.

Each swatch shows the colour at full character, while your workspace takes a

gentle wash of it, turn up Tint strength if you want more.

• Every colour works on the light and dark themes alike, and your text contrast

and the gold accent never move.

Find them in Settings ▸ Appearance ▸ Colour.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Appearance

• Choose your own surface colour. Markelangelo's warm ivory is no longer

fixed. In Settings ▸ Appearance ▸ Colour, pick a preset, Neutral, **Cool

slate, Sage, Rose or Sky, or dial your own hue and tint

strength**, and the whole app re-colours together: background, cards, sidebar,

panels and borders.

• Nothing gets harder to read. Every surface keeps its own lightness, so your

text contrast is exactly what it always was, whichever colour you choose. The

gold accent stays gold too, so Markelangelo still looks like Markelangelo.

• Works on all three themes, so you can have a sage Athenaeum, a slate Midnight

or a neutral-grey Scriptorium. Set the strength to zero for a completely

neutral, colourless workspace.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

✨ Build with AI

Stuck on how to word a prompt? Now the app writes it for you.

• On the prompt editor, click Build with AI, describe what you want in

plain English ("turn rough notes into a decisions list with an Action / Owner /

Due table"), and the AI writes the whole prompt: name, description, the template

body, and any variables, understanding {{selection}} and {{document}}. No

more copy-pasting to another chatbot to come up with one.

• Refine it in place ("make it stricter about output-only") and **Try it on

your selection** to watch it work before you save.

• The same ✨ builds more. A persona voice from "a wry, concise LinkedIn

ghostwriter"; a quick-action instruction; the global message. Each editor has

its own Build-with-AI button (and reads "Improve with AI" when there's already

something to work from).

• You own the recipe. The system prompts that drive each builder live in

Settings ▸ AI Builders, seeded with a strong default and yours to edit.

Everything runs on your own model and honours your privacy stance, and shows up

in Usage as "Prompt Smith" so you always know the cost.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

A documentation and website pass, so the newest features are easy to find and

easy to learn.

In the app

• The User Guide now covers the lot. New sections walk through Flows (the

visual pipeline builder), Voice dictation, Document Leaders, and the

Markelangelo Labs programme, including running Claude on your own

subscription. Open it from Help ▸ User Guide.

On the website

• Flows, Voice and Labs, front and centre. The landing page now leads with

Flows (build a pipeline once, run it on any idea), gives Voice its own feature

panel, and reframes Labs as the experimental wing it has become. Real

screenshots from the current build throughout.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Costs & usage

• Anthropic Max, shown for what it is. When a run uses your Anthropic Max

subscription, its cost is covered by your plan, not billed. The Usage meter now

shows those amounts struck through in red with a "Max" pill, keeps the big

headline number to what you actually owe, and adds a line telling you how

much Max covered. Your real spend, front and centre.

• Keep your costs forever. A new Export button in the Usage panel opens a

granular Markdown report of the current range, totals, by model, by feature,

and every event, as an ordinary document you can save wherever you like. (We eat

our own cooking.)

• Flows show up in your usage. Each step a flow runs is now itemised as

"Flow: <name>" in the Usage meter and the export, so you can see exactly

what your pipelines cost.

Flows

• Per-step model. A step on the canvas can now pick its own model,

overriding the prompt or Leader default, for when one stage wants a bigger (or

cheaper) model than the rest.

Voice

• The recording cue sits right. The microphone watermark is now perfectly

centred, soft green when armed and a centred orange pulse while recording.

• Copy in a click. Both the raw transcript and the tidied result have a

Copy button, so Voice doubles as "dictate here, paste into Word or email".

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Flows

A big polish pass on Flows from your first day with it.

• A proper canvas, not a cramped box. The flow designer now opens as a

full-size working surface with room to think. Give a flow a **name and a

description, choose its default source** (the selected text or the whole

document) and destination (insert below under headings, replace the source,

or open the results in a new document), then build.

• A run that shows its working. Running a flow now opens a considered dialog

that tells you exactly what's about to happen: the flow's name and description,

an itemised list of every step and the model it uses, and any privacy

warning. You can override the source and destination just for this run.

Then, as it runs, each step ticks off with the tokens it used, with a

running total, so a pipeline that takes a minute never leaves you wondering.

• Tokens, in the open. Per-step and total token counts are shown as the flow

runs.

• Duplicate and iterate. Copy a flow from the sidebar to build a variation

without starting over, and each flow now shows a short description line so

your library is easy to read at a glance.

• The cursor lands where you'd expect — just below freshly inserted results.

Create one from Flows ▸ New in the sidebar.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Voice

• You can see when the mic is live. The Voice panel now carries a large

microphone watermark behind it: a soft green when it's armed and ready,

turning a soft orange with a gentle pulse while it's actually recording.

A calm, always-there cue that your microphone is (or could be) listening, so

it's never a surprise.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Flows

Chain your prompts into a pipeline, then run the whole thing on one idea.

Flows is a visual builder: drag prompt and Document Leader steps onto a canvas,

connect them so each step feeds the next, and run the pipeline over your

selection. Branches that don't depend on each other run in parallel, so a

fan-out finishes in the time of its slowest path, not the sum.

The classic shape: select an idea, and one flow turns it into a full-length

article, then fans that article out into a LinkedIn post, an X post, a meta

description and a French translation, all at once. Every result lands in your

document under its own heading, in one undo-able edit.

• A real canvas. Built on React Flow: drag to arrange, connect handles to

pipe output into input, zoom and pan, snap to grid, minimap, and a one-click

Tidy that lays the whole pipeline out left to right for you.

• Steps are things you already trust. Each step runs one of your saved

prompts or a Document Leader, so a flow inherits your voices, models and

privacy stance. Nothing new to learn.

• Select, then run. Open the Flows panel in the sidebar, select an idea

in your document, and click a flow. It shows you exactly what it's about to do

first: how many AI calls, across which providers, and a clear warning if any

step would step outside your privacy stance. One confirm, then it runs.

• Parallel where it can be. Independent steps run together, so more steps

doesn't have to mean more waiting.

Create your first from Flows ▸ New in the sidebar, or the command palette

(New Flow).

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Small, thoughtful additions to Voice dictation (Labs).

Voice

• It stops itself. Recording now ends automatically when you run Tidy or

Concise (you're done talking), after a quiet spell (90 seconds by

default), or when a session hits a maximum length (15 minutes by default).

So a forgotten microphone never keeps listening. Both timers are adjustable in

Settings ▸ Voice, or switched off entirely.

• Groq's policies, in the open. The Voice settings now link Groq's Privacy

policy, Data handling & retention, Acceptable Use & Responsible AI policy, and

Trust Center (security & compliance), each with the full URL and a copy button.

Because even when you choose a third-party engine, you should be able to read

exactly how your audio is handled first. Transparency, not fine print.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Speak your first draft. Voice dictation joins Markelangelo Labs: record, watch

the transcript build, and turn it into clean prose or a faithful overview, all in

place.

New: Voice (Labs)

• Record and see it transcribed. Open the Voice panel (right-edge rail),

press Record, and speak. The transcript builds phrase by phrase as you pause,

powered by Groq Whisper on your own free Groq API key.

• Tidy or Concise, one tap. Tidy rewrites the dictation as clean prose

with the fillers and false starts removed, keeping every detail. Concise

turns it into a faithful overview. Both use admin-editable prompts you can tune

in settings.

• Drop it in your way. Insert the result at the cursor or replace your

selection, exactly like the other AI actions.

• Honest about it. Voice is experimental and sends your audio to Groq to be

transcribed, under Groq's terms, not ours. A status-bar indicator shows

whenever the mic is live, and nothing is recorded to disk: the audio is

transcribed and discarded.

Set it up under Settings ▸ Voice (add your Groq key from console.groq.com).

Windows first; macOS to follow.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Model names are chosen by the AI providers, not by us, and they change over time.

This release adds a quiet reminder so your list never drifts out of date without

you noticing.

New

• "Your model list is N days old." On Models & Providers, each provider now

shows how long since its model list was last refreshed. Once it has been a

while, a gentle gold prompt suggests a Test & refresh to pick up the

provider's latest names, making the choice yours, and never pretending the app

controls naming it doesn't own.

This pairs with the sovereignty promise: you decide when to reach out to a

provider, and the app is honest that model catalogues live with the providers,

not here.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

A thorough audit of every settings screen and admin flow, and the polish it

turned up. Nothing here changes what the app does, it just reads and behaves that

bit more cleanly.

Fixes

• Cleaner copy throughout. Roughly two hundred em-dashes have been swept out

of the app's text in favour of plainer punctuation, across the settings, the

privacy stances, prompts, personas and more.

• No more chasing tabs that don't exist. Two settings hints pointed at a

"Defaults tab" and an "AI defaults" tab that were renamed long ago; they now

name the right place (the Global message entry, and the Privacy tab).

• Consistent "are you sure?". Removing an AI provider now uses the same red

confirmation button as every other destructive action.

The settings screens were otherwise found to be in good shape: every serious

delete asks first, empty and error states are handled, and the copy is

consistent UK English.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

An end-to-end UX audit of the primary writing journey turned up a handful of

snags. This release fixes them. No new big features, just a smoother, more

honest interface.

Fixes

• Insert a link the obvious way. There's now a **link button in the

formatting toolbar and a Ctrl+K** shortcut (with an Edit ▸ Insert or Edit

Link menu item). Linking was previously reachable only through the command

palette.

• Ctrl+P no longer lies. It opens Go-to-File (as it always did); the Print

menu item no longer advertises Ctrl+P as its shortcut. Print is still one click

away under File ▸ Export.

• Recent files show their dates everywhere. The Recents sidebar now shows

when you last opened each file, matching the welcome screen.

• A tidier command palette. "Chat with Notes…" no longer appears twice, the

"Ask AI about Selection" command is named consistently between the menu and the

palette, and selection-only actions no longer show up when nothing is selected.

• Small copy fix in the Properties panel.

The full audit (inventory, user stories, findings and the repeatable Playwright

harness) lives in the repository under ux-audit/.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Split view, tightened up from real use, plus Recent files that actually keep up

with you.

Split view fixes

• The pane's ✕ now closes that pane. Clicking the ✕ on the split pane closes

the split and keeps your other document, every time, whichever pane you were

in. (Previously it could keep the wrong one.)

• Tabs open in the pane you're working in. Switch or open a document while

the split pane is focused and it lands there, instead of always replacing

the primary pane.

• You can tell the panes apart at a glance. The inactive pane is now clearly

dimmed, and the gold "this one's live" line sits at the top of the focused

document in both panes, consistently.

Recent files

• Files you reopen from your last session now appear in Recent (they were

being missed), and re-opening a file bumps it back to the top.

• File ▸ Open Recent puts your recent files one click away while you work,

not only on the welcome screen.

• The welcome screen's recent list now shows when you last opened each file.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

No new buttons this time. This release is a full adversarial review of the

entire codebase, and everything it caught, fixed. The complete findings live in

the repo as the Code and Solution Review; here is what you'll actually feel.

Sturdier

• Your privacy stance now guards every door. The out-of-stance warning

used to cover the main AI runs; now comment lenses, thread replies, revision

drafts and chat-with-notes all pass through the same gate. Nothing leaves

your machine on an out-of-stance model without a yes.

• Comment lenses honour their pinned model and persona, exactly like a

normal prompt run.

• A frontmatter edit can no longer land in the wrong document when you

switch tabs quickly (a genuine, silent data bug, now gone, with the pending

edit flushed safely to the document it belongs to).

• Two Windows-specific security holes closed in the comments plumbing

(a path escape in promoted note names, and over-permissive draft ids).

• Unsaved drafts no longer lose their last second of typing if you quit

immediately; failed saves no longer leave temp files beside your documents;

settings can no longer be corrupted by a malformed update.

Faster

• The whole app stays responsive during a big proofread pass (the spell

check now yields as it works) and folder search can no longer freeze the app

on a huge workspace.

• Comment re-anchoring after heavy edits is dramatically faster, removing

a rare but real "app hangs for minutes" scenario.

• Ctrl+Scroll zoom is smoother (dozens of disk writes a second became one),

and the file tree stops re-rendering on unrelated UI changes.

Lighter

• The installer sheds roughly 150 MB of dead weight. Renderer libraries

were shipping twice, once bundled and once raw; production dependencies went

from 48 packages to 22. Same app, same features, much less disk.

• A few hundred lines of dead code, unused settings and a debugging test file

are gone.

Also

• The website and manual now cover split view and Markelangelo Labs, with

fresh screenshots throughout.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Two documents at once. Split view puts a second, fully live editor beside

(or below) the one you're in, so writing with your notes open, comparing drafts

or lifting material between pieces stops meaning tab-hopping.

Highlights

• Split Right / Split Down. Right-click any tab and send it to a second

pane. Both panes are real editors: type in either, and every AI tool, panel

and shortcut works in whichever pane you're focused on.

• Always know which pane is "live". The focused pane carries a fine gold

hairline and the other dims slightly. The outline, properties, statusbar,

menus and all AI actions follow the focused pane.

• Synchronised scrolling. One click in the split pane's title bar locks the

two documents together in proportion. Made for comparing two drafts of the

same piece.

• Shaped to your hand. Drag the divider to resize (double-click to

re-centre), flip between side-by-side and stacked, swap the panes, or close

the split from the title bar, the tab's right-click menu or the View menu.

• One key. Ctrl+Alt+S splits against your most recent other tab; press it

again to remove the split.

• Restored next launch. The whole layout, which documents, which way round

and the divider position, comes back with your session.

Also in this release

• The split document's tab wears a small split badge so you can spot it in the

strip.

• The "AI is switched off" banner copy was tidied.

Update from Help ▸ Check for Updates, or just wait: the app updates itself.

Introducing Markelangelo Labs: an opt-in home for experimental features that

lean on third-party tools. Its first inhabitant lets you run Claude on your own

subscription.

Highlights

• Claude on your Pro or Max subscription. Run Claude text features using your

own Claude subscription instead of a pay-as-you-go API key. Open File ▸ Settings

▸ Markelangelo Labs, download the Claude runtime once, sign in with your plan,

and turn it on. A small Max badge shows in the status bar while it is

active. Embeddings and image generation still use an API key.

• Sign in through Anthropic's own tool. Click Sign in, approve in your

browser, and paste the token it gives you. We do it this assisted way on

purpose: it rides entirely on Anthropic's own sign-in, so it keeps working even

if they change how it behaves. Once you connect, it turns itself on and runs a

quick test so you can see it working.

• Downloaded on demand, not bundled. The Claude runtime is a large tool, so

it is fetched only if you ask for it and verified by checksum before it

installs. If you never use Labs, it costs you nothing in download size.

Honest by design

• A run on your subscription goes directly to Anthropic, with none of the

OpenRouter routing controls in play. Under a protective privacy stance,

Markelangelo flags it and asks you to confirm first, just like any other

direct-to-provider route.

• This is a "while it lasts" benefit. How a subscription is authorised and billed

is Anthropic's to decide and may change; we offer this on our best endeavours.

An API key remains fully supported and unaffected.

Under the hood

• The downloaded runtime is checksum-verified twice (the npm package signature and

the binary's own SHA-256) before it is ever run.

• Subscription runs scrub API-key environment variables, so a run can never

quietly fall back to billing an API key.

• Your Claude subscription login stays isolated from any Claude Code you use

elsewhere on your machine.

Pasting markdown that you copied from an email, a chat, or an AI reply now keeps

its formatting instead of arriving as plain text.

Highlights

• Markdown paste just works. When you copy markdown out of Gmail, Slack, an

LLM chat and so on, it comes with a hidden HTML version that is really just the

raw #, * and - characters dressed up as text. Markelangelo now spots that

and parses the markdown, so headings, bold, lists and rules render properly on

paste. Genuinely rich content (from Word, Google Docs, a web page) still pastes

with its formatting exactly as before.

• Paste as Markdown, on demand. A new command — Paste as Markdown

(Ctrl+Alt+V, also in the command palette) — always treats whatever is on the

clipboard as markdown. Handy for the cases the automatic detection

deliberately leaves alone.

Under the hood

• The automatic path only steps in when the clipboard's plain text looks like

markdown and its HTML is just trivial wrappers, so ordinary rich pastes are

never disturbed.

A focused follow-up to the privacy release: the privacy signal now reaches every individual choice, not just the surface it sits on.

A privacy indicator on every option

In 0.12.0 each run surface showed one badge for its default. But a single prompt or Document Leader can pin its own model, so the risky one could hide in a list. Now, wherever you pick from a list of things that use a model, every option carries its own little indicator:

• the right-click menu's prompts, Document Leaders, comment lenses and the Image entry,
• the Run Prompt library list,
• the Comments "New comment" lens menu,
• and the Prompts sidebar.

A faint shield means that option honours your active stance; an amber mark means that particular option's model would step outside it. Hover for the exact zone. You see the consequence of each choice before you make it, so nothing is left to guesswork. The Image entry reflects your image generator's own provider, which is separate from the text stances.

A big privacy release: your Privacy & Sovereignty stance is now the primary player, every AI run tells you where it will actually travel, and all settings live on one surface.

Each privacy stance owns its models

Privacy & Sovereignty stops being a preset and becomes the organising layer. Expand any stance card (Totally Local, EU Only, Zero Data Retention, No Training, Frontier) to choose the model each feature uses under that stance, embeddings included. The pickers only offer models that honour the stance, switching stances swaps the whole set in one click, and switching back restores your previous picks. Nothing is ever silently overwritten.

Under Zero Data Retention the picker is filtered against OpenRouter's own list of zero-retention endpoints (refreshed daily, and honest about it when the list is unavailable). As ever: the routing controls are sent on every request, and the guarantees are OpenRouter's and its providers' to enforce, not ours.

The privacy badge

Every run surface now carries a small badge naming the zone that run will actually travel through: Local, EU Only, Zero Data Retention, No Training, Frontier, or "Direct to <provider>". It shows the resolved truth, never just the setting. If a prompt or Document Leader pins a model outside your stance, the badge turns amber with a warning triangle, and the run asks first: Run anyway, or don't. Writing something personal? One glance tells you where it would go.

Model pickers across the app (Run Prompt, the prompt editor, the Document Leader editor) group compliant models first, with anything outside your stance clearly labelled.

One Settings surface

The old Settings dialog and the Settings Shop have merged: the Shop is now simply Settings (Ctrl+,), with everything on one rail — General, Appearance, Language, Prompts, Quick Actions, Privacy, Models & Providers, Personas, Knowledge, AI Images and Usage. Every old deep link (the setup banner, status bar chips, palette commands) lands on the right tab. The Global message now lives as a pinned entry at the foot of the Prompts list, and categories are managed from the folder icon beside the category filter.

A calmer right-click in settings fields

Right-clicking a text field outside the editor (a prompt you're editing, a search box) now shows a minimal menu: spelling suggestions, synonyms for a selected word, cut/copy/paste. The AI actions and formatting entries — which act on the document, not the field — no longer appear where they could do the wrong thing.

Under the bonnet

• Per-stance defaults are a proper schema migration; existing picks are carried into your active stance and Frontier.
• Chat-with-notes and the semantic index resolve their models through the active stance too, closing a gap where indexing was outside the stance switch.
• "Local" detection now genuinely requires a local address — a remote OpenAI-compatible endpoint no longer counts.

Two small refinements following the 0.11.0 interface wave.

The right-click menu's right column is left-aligned

The new AI actions column was centred, which read a little oddly next to the left column. It is now left-aligned, so both columns line up cleanly.

The floating selection toolbar has retired

The little toolbar that popped up above a selection has been retired. Everything it did now lives in the two places you already reach for: the right-click menu (Improve, Humanise, Shorten, Expand, Fix grammar, Tone, Translate, Ask AI, and your prompts, Document Leaders and images), and the formatting bar along the top of the editor. One selection, one place to act on it.

A wave of interface polish across the top toolbar, the right-click menu and the two icon rails.

A formatting toolbar up top

The strip below the tab strip is no longer empty. It now carries a persistent, centred formatting bar: Bold, Italic, Strikethrough and Inline code, then a divider, then the block types (Paragraph, Heading 1 to 3, Quote, and bullet, numbered and task lists, and Code block). Every button applies to your current selection with one click. When your bespoke quick action bar is open, its icons follow after a divider, keeping everything in one tidy centred row.

The right-click menu, refined

• A titled right column. The "AI actions" header now lines up with the first row of the left column and has its own divider beneath it, so the two columns read as one balanced panel. The action list is centred.
• Actions that know when they make sense. You cannot really shorten a single word, so the selection actions now grey out until the selection is long enough. Each has its own sensible minimum: Fix grammar from two words, Improve, Humanise and Expand from three, and Shorten and Tone from five. Hover a greyed action to see why. Ask AI and Translate are always available, whatever the length. Every threshold is adjustable in Settings, under Quick Actions.

Rails that pop out to labels

Both the left activity rail and the right dock rail now have a chevron that expands them to show text names beside each icon, for when the glyphs alone are not enough. A pin beside the chevron keeps a rail expanded across restarts.

Small things

• The active tab has a slightly heavier border, so it stands out more clearly from the rest.
• The divider under the workspace folder header now aligns exactly with the toolbar divider, so it reads as a single line across the whole window.

The right-click menu is now a two-column command centre.

Selection actions moved into the menu

Select some text and right-click, and the menu now has two columns. The left column is exactly as before (formatting, synonyms, comments, prompts, Document Leaders, images). The new right column carries the quick actions that used to live only in the floating toolbar:

• Improve, Humanise, Shorten, Expand, Fix grammar: one click each.
• Tone: a small submenu of tones to rewrite in.
• Translate: opens the translate picker.
• Ask AI: opens a modal where you type an instruction for the selection.

The right column only appears when you have text selected. The floating toolbar is unchanged for now, so nothing you already use has gone away; this simply makes the menu a fuller home for everything you can do to a selection.

A fix for the inline Ask AI box.

The Ask AI input no longer closes as you type

When you typed a longer instruction into the floating "Ask AI…" box, it would close the moment your text reached the edge of the box. The box scrolls sideways at that point, and that scroll was being mistaken for the page scrolling, which dismisses the bar. It now ignores its own scrolling, so you can type as long an instruction as you like.

Verified with an automated test that types a long instruction into the box and confirms it stays open.

A fix for Proofread mode.

Suggestion pills are visible again

The green suggestion pills were rendering transparent, so they only appeared when you rolled the mouse over them. They now show as solid green pills straight away, with the suggested word in white. Nothing else about the flow changed: click a pill to replace, click × to keep, or use "Correct all remaining".

This one slipped through because the automated checks were not exercising the rendered editor. There is now an end-to-end test that opens a document, runs a proofread pass, and confirms the pills are actually visible and clickable, so this cannot happen again unnoticed.

Three fixes to Proofread mode from the first round of use.

• Shortcut: Proofread is now F7 (the usual spell-check key). Ctrl+Shift+P stays with the command palette.
• The floating bar works: it was sitting inside the title bar, which quietly swallowed clicks, so "Correct all remaining" did nothing. It now sits just below the title bar and responds properly.
• Clearer suggestions: each suggestion is now a solid green pill with light text, rather than green text on a faint background.

Fix a whole document's spelling in one pass, without right-clicking every word.

Proofread mode

Press Ctrl+Shift+P (or Edit then Check Spelling) and Markelangelo checks the whole document at once. Every misspelling is marked in red, with up to three suggested corrections shown as green pills right beside it. Then:

• Click a green pill to replace the word.
• Click the × pill to keep the word as written.
• Correct all remaining from the floating bar at the top applies the best suggestion to every word you have not already handled.

The red marks and pills clear as you go, and a counter shows how many are left. It is designed to make proofreading fast and low-effort, especially if spelling is not your strong suit.

The check runs entirely on your machine using a local dictionary, and it respects the words you have added to your personal dictionary. The live as-you-type spellcheck is unchanged. Bulk proofreading currently covers English; more languages can follow.

The final piece of the images work.

Relative image links now display in the editor

When a document's images were re-homed into an assets/ folder beside it (as of 0.9.5), the links became relative and portable, which is exactly right for the file on disk. But the editor was showing the raw link, and a relative path like assets/picture.png was being looked up in the wrong place, so the images appeared blank even though the files were sitting right there.

The editor now resolves image links against the document's own folder for display, so both relative links and images stored elsewhere show correctly. The saved markdown is untouched: it stays relative and portable, and travels with the document.

Your documents keep their images with them.

Images move in beside the document on save

When you add an image to a new, unsaved document, it is stored in the app's data folder. Until now that meant the saved .md pointed at a file elsewhere on your machine, so moving or sharing the document left the images behind.

Now, when you save such a document, its images are copied into an assets/ folder next to the file and the links are rewritten to point there. The document becomes self-contained: move it, back it up or share the folder, and the images travel with it. This runs quietly on save and never gets in the way; images you deliberately linked from elsewhere are left alone.

Together with the export fix, images now appear both in your saved documents and in exported or printed PDFs.

The 0.9.3 image-embedding did not cover images stored with a full Windows path (which is how images added to an unsaved draft are recorded). The document's export sanitiser was discarding those paths before the image could be embedded. This release embeds them properly, so images now appear in exported and printed PDFs regardless of where they are stored.

Two follow-ups to the export work.

Images now appear in exports and prints

Local images are embedded directly into the exported document, so they show up in PDF, HTML, Print and Copy as HTML. Previously the rendered file lived in a temporary folder, so image links pointed nowhere and the pictures went missing. Now the document is self-contained, which also means it keeps its images when you move it or email it. Remote images (linked by URL) are left as links.

Choose the typeface and size

The export dialog now has a Typeface control (Serif or Sans-serif) and a Font size control, applied to both the body and the headings. The default size is also a touch smaller than before.

The export fix from 0.9.1 did not fully land. This completes it.

Export, print and copy really work now

The "empty preset" error when exporting (HTML or PDF), printing, or copying as HTML is now fixed for good. The 0.9.1 fix unwrapped the mis-loaded plugin one level, but the packaged build wrapped it twice, so the error remained. This release unwraps it fully.

A fix for exporting and printing.

Export, print and copy now work again

Exporting a document (HTML or PDF), printing, and Copy as HTML could fail with an "empty preset" error in the installed app. The markdown-to-HTML renderer was mis-loading one of its plugins in the packaged build. That is fixed, so all four paths render correctly again.

More ways to get your document out of the editor and onto the page.

Print

A new Print command (Ctrl+P, or File then Print) renders the current document and opens your operating system's print dialog, so you can send it straight to a printer. It uses the same polished rendering as PDF export.

PDF page options

Exporting a PDF is no longer fixed to A4. The export dialog now lets you choose the page size (A4, Letter or Legal), switch to landscape, set the margins (normal, narrow or none), and add an optional page-number footer.

Copy as HTML

File then Copy as HTML copies the rendered document to the clipboard as rich HTML. Paste it into Word, an email or another document and it arrives formatted, with headings, lists, links and emphasis intact.

Two quality fixes on top of the AI images release.

A shorter right-click menu

The editor's right-click menu had grown long enough to push the spelling suggestions off the top of the screen. The Prompts, Document Leaders and Image groups now collapse into tidy sections, closed by default and opening one at a time, each showing how many items it holds. Everything is still one click away, and the top of the menu is always in reach.

Faster tab switching

Switching tabs could lag by a second or two once a lot of tabs were open. Markelangelo now caps how many editors it keeps live at once: the tab you are in, any tab with unsaved changes, and your most recently viewed tabs. Switching no longer slows down as the number of open tabs grows. Nothing with unsaved changes is ever set aside, so no edits are lost, and a tab you return to after a while simply reloads from disk.

Generate images from your writing and drop them straight into the document, three ways.

Generate an image from a selection

Select a passage, then pick Generate image from selection from the right-click menu or the floating bar's Image control. Markelangelo turns the selection into an image on your own OpenAI key (gpt-image-1), saves it into the document's assets folder, and drops it in below the selection. A house style (set in Settings) is applied so your images share a look.

Suggest a prompt, edit, then create

Prefer to see the prompt first? Choose Suggest an image for selection. Markelangelo writes an image prompt that suits the passage, shows it in an editable field with a style picker, and generates only when you press Create. Edit the wording, swap the style, or resuggest until it is right.

Insert an image from disk or a URL

No AI needed. Insert image from file opens a picker, and Insert image from URL fetches a picture and saves a local copy into the document's assets, so nothing hotlinks and the image travels with the document.

A style library

Settings has a new AI Images section: choose the model, default size and quality, and build a library of named styles (editorial photo, flat vector, watercolour, line art, isometric, or your own). The active style is applied when you generate directly from a selection.

Image generation is cloud-based for now and uses your OpenAI key, so the prompt is sent to OpenAI. A fully local option can follow.

More ways to turn a selection into finished writing, and a faster path to every prompt you own.

A generic article engine for Document Leaders

Document Leaders now ship with a second engine alongside the LinkedIn one: a destination-neutral Generic Article Engine Core for blog posts, web commentary, general articles and rewrites. It reads your idea and sizes the piece itself, with a lighter deliverables package (title, standfirst, body and one image prompt).

It comes with its own seven voices, Article: Wry, Critical cynic, Pragmatist, Storyteller, Builder, Educator and Contrarian, paired into seven ready Leaders on Claude Opus 4.8. They appear in the Document Leaders sidebar tab under their own engine group, so you can pick "an idea in this voice, for a blog" as easily as "for LinkedIn".

Humanise

A new Humanise action rewrites existing text so it reads as though a person wrote it, stripping the tells of AI prose (tired vocabulary, "not just X, but Y" parallelism, forced triplets, stage directions like "here is the thing", and filler) while keeping your meaning, facts and formatting.

It is one click on the floating selection bar, right next to Improve, and it is also a full prompt in your library, so you can run it from the right-click menu or edit exactly how it works. Like the other quick actions, its instructions are yours to tune in Settings.

A Prompts sidebar tab

Your whole prompt library is now a tab in the sidebar, grouped by category. Select some text, click a prompt, done. With nothing selected, whole-document prompts run on the document. A filter box keeps things quick as your library grows. It is the same "select what you want to do something to, then do it" idea, now one click from the sidebar too.

Pick an idea, pick a voice, get a finished article.

Document Leaders

A Document Leader is a named pairing of an engine (what to write) and a persona (the voice), run in one click on a selected idea. The article streams into the run panel and drops in below your idea, ready to edit, comment on, or refine like anything else.

• Browse them in the new Document Leaders sidebar tab, grouped by engine, or reach them from the right-click menu on a selection.
• Ships ready to use: a LinkedIn article engine with strict humanisation rules, plus seven voices, Wry, Critical cynic, Pragmatist, Storyteller, Builder, Educator and Contrarian, paired into seven Leaders on Claude Opus 4.8.
• Build your own in seconds: name it, pick an engine prompt, pick a persona, pick a model. Swap the persona and the same engine becomes a whole new flavour, no duplication. Because engines are just prompts and voices are just personas, a blog or short-post engine is simply another prompt you pair up.

The philosophy holds: an engine carries the structure, a persona carries the voice, and a Leader is the named marriage of the two.

A fix for the image and diagram zoom viewer introduced in 0.5.1.

• Zooming a large image or diagram no longer blanks the app. The viewer now scales through the page layout rather than a single graphics-card texture, so it stays stable however far you zoom.
• Drag to pan in every direction — it now reaches the left and right edges of a zoomed image, not just up and down.
• Controls are a simple Reset and Close (Esc still closes).

Three small comforts.

• Ctrl+A now selects just the document. It used to grab the file panel and menus too; now it selects the whole document text, ready to copy or replace, without dragging top to bottom.
• Zoom the document with Ctrl+Scroll, like a web page — handy for peering at a Mermaid diagram or a wide table.
• Double-click any image or diagram to open it in a viewer you can pan and zoom around: wheel to zoom, drag to move, double-click to reset.

AI comments used to live in a panel of their own. Now they're just part of how you already work: select something, then do something to it.

Comment from anywhere, in one click

A comment is now simply a prompt that "responds as a comment." So the AI's review lands as an anchored note beside your text, and you start it from wherever your hand already is:

• Select a passage → right-click and pick a lens from the new Comment section.
• Use the floating bar's Comment menu, a quick button, or AI ▸ Comment on Selection (Ctrl+Shift+K).
• Or the New comment button at the top of the Comments panel.