Changelog

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.