Changelog

1.21.0: THE THINGS THAT LOOKED FINE

Everything below was green somewhere before this release. A test passed, a screen rendered, a tool appeared in the list. Each one was still broken.

• Nobody else can pair to your Mori. The phone link ran on a channel anyone who knew your account id could join, and it accepted a pairing handshake from anything that sent one, with no code and no signature. Driven end to end: an anonymous client became the paired phone, survived a restart, and its next message arrived with owner permissions. A pairing is now only accepted as the answer to one you asked for, and it expires. Your phone needs no update.
• Her memory works again. Recall was calling for a model it never had, so every "what do you remember about" came back empty while the Brain page reported READY, and the failure itself was being read to her as though it were a memory. Both halves are fixed, and a failed lookup can never again be presented as something she recalls.
• Seven listed tools could not run. Both video tools answered "Unknown action" on every call, and all five Skills Hub tools reported the hub unavailable. They are wired to code that was already written and already tested, and the bench now refuses to let a tool be listed without a path that runs it.
• The first-run terms describe this app. They named no company, and said your chats sync to a database you configure and that we never receive your data, neither of which was true once plans and sync existed. Rewritten to match the privacy policy, which was already correct. You will be asked to accept them once.
• The cost estimate is right. It quoted three times too much for Opus 5 and three times too little for Fable 5, off a price table a generation out of date. Every model is now priced against the live catalog.
• A free account is no longer told it has a subscription, and the plan chip reads from what you actually pay for rather than a server setting.

Underneath: the managed proxy can no longer be talked into serving a model your plan does not include, usage is recorded against the model that really answered, and the publish step refuses to ship a build it cannot prove was notarized.

1.20.2: THE OTHER HALF OF THE SAME FIX

1.20.1 stopped the argument of every typing hand reaching the durable record. It missed that the result is a record too, and on some paths the result handed the value straight back. This closes that, on both platforms.

• What she types no longer comes back in the answer. A typing hand's result used to read "Typed: <the thing you typed>". The argument had just been withheld from the log, and then the result printed it anyway, to the model and into the activity view. Every typing path on both Windows and macOS now reports a character count instead. Proven by typing into a real application and reading the log file back afterwards.
• Reading the clipboard is now treated like writing it. Putting a password on the clipboard was already withheld; reading it straight back wrote it to disk in full. A clipboard is where a password manager puts things.
• Crash reports from the main process are covered too. The fix in 1.20.1 reached the window but not the process where the work actually happens.
• Tools from your own connected servers are covered. A list of names can never include a tool someone else supplies, so what gets withheld is decided by the shape of the request rather than by a name we knew in advance.
• The character count now describes what you typed, rather than the length of the notice replacing it. A number that is wrong reads like evidence.

1.20.1: WHAT SHE TYPES INTO A PAGE STAYS BETWEEN YOU

A security and honesty release. Nothing here is a new feature; all of it is Mori keeping promises the last version only appeared to keep.

• Nothing you type into a page is written down any more. Her tool results already hid password fields from the model, and the durable record beside them held the password in plain text, appended to the activity file in your application data and printed on the Home page and in Settings, in the very same row that said the field was hidden. Every hand that can put a value on a page or in an app now withholds it and writes the character count in its place.
• Crash reports no longer carry your session. Console output was attached to every error report and uploaded, and this app narrates what it is doing constantly. Those breadcrumbs are dropped before they can leave the machine.
• Research from GitHub is treated as a stranger's writing. Issue bodies and code comments are text anyone can author and get indexed, and reading one issue pulls its whole comment thread. That content now crosses the same untrusted boundary as a web page.
• "Close that tab" works. She refused to close any tab she had not opened herself, which is every tab you opened. She now closes a tab you name and tells you which one went, and still will not tidy your browser on her own initiative.
• She stops at the payment step without lying about the form. She used to list fields as filled that the browser had refused outright. She reads the form back now before handing you the final button.

1.20.0: SHE STOPS TELLING YOU THINGS SHE HAS NOT CHECKED

Nineteen capability gaps closed, and then a night of driving the real app on a real machine, which is where the interesting part happened. Five bugs came out of that session. Every one was a green light that promised more than the code had measured.

• A verification badge that could not lie. "Verified: 1/1 change confirmed on disk" only ever checked that files she wrote exist. It now says what it did.
• Tool parity across Mac and Windows, with the gaps named rather than quietly missing.
• Her own benchmark refuses to publish on stale proof — a claim with no fresh evidence behind it does not make the page.

1.19.0: WORKFLOWS LIVE, AGENTS YOURS, ROUTINES ON HOME

• Real workflows. Multi-step work runs as a visible plan with live boxes you can watch, not a wall of tool calls.
• Agents you define. Roles with their own tools and instructions, saved and reusable.
• Routines on Home. Schedule the things you ask for every day, and see them where you start.

1.18.2: SHE KNOWS WHAT YOU PAY FOR

A money and entitlements release. Nothing here changes how she works. It changes whether the app agrees with your account about what you bought.

• An unreachable server no longer means Free. Signing in fired one 8 second call to ask what plan you are on, and every failure of that call became the answer "free" for the rest of the session. If you paid, you spent that session on free limits, with the app telling you to upgrade to a tier below the one you already owned. It knows the difference between being told Free and not being told now, retries, and falls back to the last plan the server actually gave you.
• The server stopped inventing an answer. The endpoint behind that call returned a cheerful "free" whenever its own database query failed. It says it could not answer instead.
• Free managed mode actually works. Leaving the model chip on Auto in Managed mode was refused for anyone on Free, because the request was classified as a premium model before the code that resolves Auto to the free model ever ran.
• A declining card no longer strips your plan. Stripe marks a subscription past due the moment one payment attempt fails and then retries for days. The app kept your tier through that window and the database disagreed. They agree now.
• The App Store and the web can no longer both bill you. Subscribing on iPhone and then buying again on the site would have opened a second paid plan against the same account.

Every fix here was found by an adversarial audit of the money path rather than by a bug report.

1.18.1: STOP ACTUALLY STOPS

A fix release. If you were on 1.18.0, the Stop button in that build could not reach a running command.

• Stop kills what it started. Two bugs sat on top of each other. Nothing tagged a spawned process with the run that owned it, so the scoped kill matched nothing every time. It read as "Stop works sometimes", because cancelling a model call always worked and the moment a shell command was running Stop did nothing. Fixing that exposed the second: a persistent terminal session lived where Stop never looked, and it is the path she prefers for long work.
• Stop tells you the truth. The toast said "Stopped." whether or not anything was reached. It still answers instantly, and now corrects itself if the kill came back empty.
• The model chip named your pick, not what ran. Sitting on Opus, a request could still go out as Haiku. It shows both now.
• Forge, Trance and Swarm were partly decoration. The frontier gears bought effort and depth and then let the classifier swap the model out from under them. They refuse the downgrade now.
• Commands stopped appearing in the chat body. A command she ran belongs in the activity log and the card, not a third time in the sentence.
• Asking what she is no longer goes to the web. She knows her own name, version and platform, and answers instantly.
• Deep Research remembers being on. It was missing from the defaults, so every launch painted the toggle off.

1.18.0: PORCELAIN, AND A LIGHT SHE CAN LIVE IN

The app now wears the same system as this site.

• Light blue, not pure white. The site's near white read flat on a dense app screen, so the app's grounds carry a blue cast. Self hosted type, titles in the sans, and a serif kept for real italics.
• Night mode is one press. The title bar and Settings both return the original dark Mori look, and it survives a restart.
• Custom themes are parked, never destroyed. So is any preset you picked on purpose, so someone on Midnight lands back on Midnight.
• The sign in page matches the site. Same account, same look, across the desktop app, Mori Link on iPhone, and Mori Chrome.
• Floating panels got an opaque face. A translucent popover reads solid on dark and invisible on light, which is how the overflow menu vanished.

1.17.0: WATCH HER WORK

You can watch the work now, from the first thought to the proof.

• The right rail. Plan, activity, files, and preview sit beside the chat instead of scrolling it away. The conversation and the work stay visible at once.
• Live phase boxes. Plans render as numbered boxes with honest counts, each one pending, in progress, or done as she moves.
• Thinking that types. Reasoning streams in word by word and holds until the last word lands. The pace is capped for reading, and the words are real.
• The workflow card. Deep research runs on an inline card in the chat: waves, sources, and the trail that produced the answer.
• The composer queue. Send while she works and the message queues, then folds into the run in order.
• The CLI auto-demo. A build that ships a command line tool ends with a live demo run in a real terminal.

Shipped for macOS and Windows.

1.16.0: EVERY CHAT IS ITS OWN

The deepest change under the hood since Mori shipped: each conversation now runs on its own engine.

• Chats can't bleed into each other anymore. Another chat's plan, steps, or receipts can no longer show up in the wrong conversation, each one carries only its own work.
• Stop any task from the background panel. Hover a running task, hit Stop, and exactly that one stops while everything else keeps building. The tray Stop now honestly stops everything, in every chat.
• The status pill answers for the whole app: whichever chat is actually working is what you see, and one chat finishing no longer blanks a busy machine.
• Ollama models on tap. Ask for local AI and Mori pulls the model you need (with your OK, they're big), then verifies it's really there before continuing.

1.15.0: SHE SETS UP THE MACHINE

The first slice of Mori Infinite: any task, gated by your credit, never by the app or a missing runtime.

• A build never dies on "command not found." Mori checks what your machine has, node, npm, python, git, ollama, and installs what a task needs through your own package manager (Homebrew on Mac, winget on Windows), asking you first. No package manager? She hands you the official download instead of piping remote scripts into a shell, that line does not get crossed.
• Credits are checked before the build starts. An empty OpenRouter balance gets a clear "top up first" before any work begins, never again a half-finished build dying at a 402 five minutes in. A low balance gets a heads-up and keeps going.
• Plus everything in 1.14.2, for anyone catching up.

1.14.2: SHE KNOWS WHAT SHE'S CLICKING

A safety hardening and the two most-reported paper cuts.

• Stricter stop-at-pay. Mori never clicks the final pay button, that was already the rule. Now she also refuses to click anything she can't identify: if the page changed since she read it, she reads it again instead of clicking blind. And with several chats using your Chrome at once, each task keeps its own approval and its own view of the page, one chat's "yes" no longer covers another's.
• Mori's mark on the Mori panel. The panel header and its composer button wear her icon instead of the same sparkle the Skills button wears.
• Small windows behave. Opening a side panel in a small window used to crush the chat into an unusable sliver. The panel now measures the space it actually has and always leaves the chat room to breathe.

1.14.1: STOP MEANS STOP

Two fixes on top of 1.14.0, both reported after install.

• Stop actually stops. It only ever worked if it caught a network request in mid-air, which is why it looked random: pressed between steps, inside a running command, during a sub-agent, or while Mori was driving your browser, it did nothing at all. The stop signal was being erased one line after it was set, by the very call meant to enforce it. It now holds until the work has genuinely wound down, on every one of those paths.
• Mori's face is back on the pill. The always-on status pill and the app's own window icon were falling back to a plain dot, so the pill read as an older, different one. The logo was being packaged into the wrong folder, a bug that is invisible when running from source and only appears in an installed build. Fixed on Mac and Windows, with a check that now compares the packaging config against the code that reads it.

1.14.0: SHE TELLS YOU FIRST

Mori answers before she builds, says what she understood and how she'll do it, and names the point where she'll need you, before she gets there, not after.

• Answer first. A question gets an answer, not a build. Ask "should I move this to a framework?" and she reads the actual files, then gives you a recommendation and the one trade-off that matters. Ask a question *and* give an order in the same message and she does both, in that order. A plain build order still goes straight to work, it just tells you the plan first.
• She says what she is about to do. Every task now opens with her reading of the ask, the approach and why, and anything she decided for you, before the first tool call, not buried in the summary at the end. This applies to everything, not just building. It stays in the chat too, so stepping away to another conversation mid-build and coming back no longer leaves you looking at tool activity with no idea what she set out to do.
• She tells you where she will need you. A job needing a Supabase project, Stripe keys, a deploy under your hosting account or an App Store submission is flagged in the *first* reply, with what she needs and why. She builds everything she can, gets right up to the wall, and stops there with the exact ask, instead of inventing a placeholder key and handing you something that looks finished and works nowhere.
• Visible plans. Work with three or more real steps shows a live plan with done / in-progress / remaining, updated as she goes.
• The Mori panel got honest. Ask it mid-build and it answers from live state instead of last turn's: the files it just wrote, the actual error text of anything that failed, and where it really is. Typing an instruction into it now reaches the build, before, an instruction containing a word like "progress" or "status" was silently answered as a question and thrown away.

Fixes. A terminal line ending in an erase sequence no longer swallows the whole message. A failed review whose finding began with "None" no longer renders as nothing at all. Every CLI tool failure is now recognised as a failure, so the repeat-failure guard actually fires. An ordinary commit can no longer be mistaken for passing test evidence. A message queued in one chat can no longer be delivered into another. A piece of work handed to a sub-agent can no longer land in a previous project's folder: ask for a site at one path right after building one at a similar path, and the files go where you asked. Deep research stays attached to the chat that started it. A dead shell no longer bricks its terminal session, and terminal output can no longer grow without limit. And when the provider says you can afford a smaller reply, Mori retries at that size instead of failing the turn and telling you to top up.

1.7.0: THE CLAUDE-GRADE MIND

Memory grew up, vague references resolve, and every past conversation is searchable word for word.

• Memory rewrite. Every fact is now its own markdown file with a findable one-line description, a tiny always-loaded index, enforced update-not-duplicate, first-class delete with tombstones, and [[links]] between memories. "The demo is Friday" is stored with the actual date. One-time migration from the old store, with a .bak backup.
• The entity resolver. "The guy from the demo", "that site", "my resume", a universal registry maps slight terms to the real person, file, URL, build, app, or past chat, and asks one short question instead of guessing.
• Total recall. Full-text search over every past conversation's raw transcript, /sessions <query> or just ask. Export any chat as Markdown or a styled HTML page with automatic secret-scrubbing (/export, --redact for more).
• Real schedules. A main-process cron service: 5-field cron expressions, at: one-shots, every:N intervals, running with the window closed, missed runs fired once on wake, never replayed. Heartbeat checklists that stay silent unless something's wrong, and an off-by-default localhost webhook to poke her from scripts.
• The Brain works out of the box. No Ollama? A built-in local embedder keeps the knowledge graph alive at $0, honestly labeled as lexical-grade, sticky per brain, never silently switched.
• Nothing durable is lost. Facts are flushed to memory right before a long conversation compacts, and bot replies are recorded before sending, recovered exactly once after a crash.
• New Memory page. Browse, edit, and delete everything Mori knows; inspect the entity registry; read the nightly dream-consolidation reports.
• `/retry` and `/branch` are real, and cold start measured at 0.7s.

The deep dives live in Memory and Automation & schedules.

1.6.2: MEMORY FIX, POLISHED

Small release, real fixes.

• "Open the game you built" actually opens it: a fresh chat asking to open/run/launch a past project reliably enters the tool path and opens the real thing.
• Cleaner recent-builds list. Saving a loose file to Desktop or Downloads no longer mistakes the whole folder for a project.
• "Open Terminal / Notes / Music" launches the real app again, even with a same-named folder around, and project paths with parentheses are handled correctly.

1.6.1: MEMORY 1:1 + HONEST USAGE

Cross-chat build memory and a plan meter that tells the truth.

• Open what you built, from any chat. A durable index of every project Mori builds, so a brand-new conversation can "open the game you just made" and land on the exact folder.
• The plan meter is honest. On your own API key it says so ("on your own key") instead of showing a stuck 0%, with one tap to switch to your Mori plan. Keyless subscribers default to their plan automatically.
• All 154 tools verified wired end-to-end: nothing declared that can't actually run, and dead code removed with no behavior lost.

1.6.0: THE BRAIN + TRUE AGENT

A real memory Brain, terminal sovereignty, and the autonomy ladder.

• The Brain. A private, on-device knowledge graph that remembers people, projects, and files across every conversation and answers "what were we working on?" with cited sources and honest gaps. Runs fully local on Ollama, with its own Brain page.
• Never loses the thread: the active task always comes first, so an old project can't hijack a session just because it looks similar.
• Named terminal sessions that stay alive across turns, local, Docker, or SSH, and you can type into the same shell Mori is driving.
• Autonomy ladder (Guided / Trusted / Commander) with time-boxed grants and a Stop that really stops; computer use shows a floating pill with a Stop button even when the app is minimized.
• Mori for Traders: market research, backtests, and paper trading, never real money, plus local Ollama models for internal chores.

See The brain, Terminal sessions, and the Autonomy ladder.

1.5.0: COMMAND DECK

Mori stopped being one conversation.

• Multi-pane chat. Run two, three, or four live sessions side by side, Single, 1+1, or 2×2: each with its own conversation, model, and composer. Cmd+1-4 jumps between panes.
• Broadcast. Type once and send to every pane at once, compare the answers side by side, then Promote the winner. The losing panes are archived in both stores, never deleted.
• Truly concurrent. Panes run at the same time without stepping on each other.
• Settings by chat. Tell Mori "switch to the Terminal theme and Forge stage" and it happens through configure_app: but sensitive settings (autonomy, API keys, billing) can never be changed by chat, only in Settings.
• Session-scoped engine. Under the hood the whole chat engine now keys off a session id, so steering, Stop, the usage meter, and verification are all per-pane.

The deep dive lives in Command Deck.

1.4.0: SOVEREIGN II

The reskin, the migration path, and skills that version themselves.

• Theme Studio. Six shipped looks, including a full Terminal skin, a live token editor, and import/export of your own theme.
• Import from other agents. One click pulls your skills and memories in from Hermes, Claude Code, or OpenClaw. Everything lands pending your approval; nothing is trusted on arrival.
• Skills 3.0. The open SKILL.md standard, semantic-version history with rollback, an in-place editor, and an approve/reject flow that covers both Mori's own drafts and imported skills.
• `/learn`. Teach Mori a new skill from a folder, a link, or "what we just did."
• Mid-run learning. A failing step becomes a lesson the very next step can use.
• Kanban, for real. Rename, add, and reorder columns, set WIP limits, and switch between Board and List views, while workers still only pick up what you stage as Ready.
• Always-on plan meter. Every signed-in user watches their usage fill up right in the composer, with reset times on hover.

See Theme Studio, Import from other agents, Skills, and Context & usage.

1.3.0: SOVEREIGN

Persistent shells, a real autonomy model, and the slash layer.

• Named terminal sessions. Mori keeps real shells alive across turns, local, docker, or ssh: and you can type into the same session she is driving.
• Autonomy ladder. Guided / Trusted / Commander, with time-boxed grants, a live countdown, and an append-only action ledger. The hard safety floor can never be bypassed, on any rung.
• Context transparency. Click the usage chip for a full token breakdown, a next-turn cost estimate, and one-click Compress.
• Slash commands. Type / in the composer, /usage, /compress, /clear, /model, /autonomy, and more.
• Artifact cards. Files Mori makes for you now show as rich cards with Open, Reveal, and Preview.
• Better bot replies. Discord DMs get real file attachments, and long replies chunk cleanly without breaking code blocks.
• What Mori knows about you. View and edit your profile right in Settings.
• Ollama support. Run local models, with an automatic one-hop fallback if your primary provider fails.

See Terminal sessions, the Autonomy ladder, Slash commands, and Context & usage.