Changelog

1.14.0

• **Your AI knows about FeatherDB even when the app is closed.** An AI tool that starts before FeatherDB used to see a broken connection and nothing else — so it never thought of FeatherDB and sent you to copy production by hand on the server. It now receives the full description of what FeatherDB offers, and every call it makes while the app is closed answers with one thing: open FeatherDB and try again. No restart of the AI tool needed, before or after.
• **Clearer guidance on when to use it.** The AI is told plainly which jobs belong here — a copy of production data, a migration rehearsal, inspecting a production database — and never a shell on the server, which would skip the masking, the snapshot and the record.
• **Bringing a database in, and running your app against a sandbox, are spelled out.** The AI learns how to hand you a ready-made connection for a database it can see in your deploy files, and that a sandbox is a database your own dev build or migration tool can connect to, with the Live feed showing what it ran.
• **"Is it connected?" now means right now.** When your AI asks about a connection it filled in, the answer reflects the live state — exposed to it, connected but not shared with AI, or not open at the moment — with the exact switch or screen to use, instead of remembering a Connect click from an earlier session.
• **Sandboxes keep what a rehearsal needs.** Inside document columns, masked identifiers used to collapse into one placeholder and every masked number became zero — so a migration rehearsed on a sandbox grouped differently and summed to nothing. Masked values now stay consistent: equal stays equal, distinct stays distinct, and counts, amounts and deltas are kept. Personal data still never crosses. Your AI is told the rule on every sandbox.
• **Fewer false alarms from the mask check.** A document whose masked fields were already masked was counted as a leak; it no longer is.
• **Your AI can attach a sandbox to your project without ever seeing its address.** Instead of copying the sandbox address from the Sandbox tab into a chat, the AI asks FeatherDB to write it into an env file of the project; you see the path and click Write once. The address, with its password, never enters the conversation. A file git would commit, or a path outside a git project, is refused before you are asked.

1.13.1

• **Controls you can read in light mode.** The database picker above every workspace tab, the refresh button and links were drawn in the pale brand green and nearly vanished on a light background. They now use a darker green that stays readable.
• **Clearer status colours.** Match checks on references, warnings in Checkup and Proposals, the trial reminder, and the SAFE / WARN / DANGER labels on migration steps use the same readable greens, ambers and reds in light and dark.

1.13.0

• **Text you can read in both modes.** Light mode has a cleaner palette, and every status message, link and warning now keeps its contrast in light and dark — green, amber and red text no longer fades into a pale background.
• **New type.** Headings, text and code each get their own face. Code shows exactly what you typed: != stays two characters, never a drawn symbol.
• **Losing work now asks first.** Deleting a connection (and its saved secrets), discarding a sandbox, clearing its journal, deleting a mark or a snapshot, and removing your licence from this Mac each confirm before they happen. Closing the connection form with unsaved changes — Cancel or Esc — asks too.
• **The workspace tabs moved to the toolbar.** Browse, Sandbox, Snapshots, Checkup and Proposals sit in the window's toolbar, with ⌘1–⌘5 in the View menu.
• **What needs you is at the top.** Requests waiting for your approval and the AI gateway's status now sit at the top of the sidebar, where a window dragged low cannot hide them.
• **FeatherDB follows your Mac's Light/Dark setting.** The separate appearance setting is gone.

1.12.9

• **A new look.** FeatherDB now wears a calm green and slate-blue palette, with a new feather icon in the Dock. Light and dark mode both follow it.
• **Easier-to-read SQL and JSON.** Keywords, JSON keys and placeholders are recoloured to match, and keep their contrast in both modes.

1.12.8

• **Connect to a database running in a container on your server — by name, not by address.** Choose "A container on the server", click Find, and pick your stack from the list (it reads like "shop · production"). FeatherDB finds the container's current address each time you connect, so a redeploy that moves it no longer breaks the connection. Nothing needs publishing. The form says exactly what FeatherDB looks up on your server, and it only does so for connections where you chose it.
• **Your AI can file that kind of connection too.** It names the database's service from your deploy file instead of an address; you pick the stack and type the password.
• **A connection that stops answering after a redeploy says why.** When FeatherDB reaches your server but not the database, and the database's address is one on the server's private network — a container's — the error now says the address may have moved when the container was redeployed, and how to look up the new one.

1.12.7

• **One place for everything your AI is waiting on.** Questions to run, changes to confirm, snapshots to take and connections to add now gather under "waiting for you" at the foot of the sidebar, from every database at once — click one and FeatherDB opens it where it is answered. The Dock icon shows how many are waiting, and if FeatherDB is in the background when a new one arrives, macOS tells you.
• **Your AI keeps changes on the reviewed road.** Every live database now tells your AI, each time it looks, that a change goes through a proposal you confirm — even right after a dropped connection — instead of commands run directly on your server.

1.12.6

• **A decided proposal opens when you click anywhere on its row.** Only the small chevron used to open it, so a rationale shortened to two lines read as cut off. The row itself is the button now, on the Proposals tab and in "On the record".
• **Your AI can file a connection that goes through a server you already use, by name.** Instead of spelling out the SSH machine and your key's location, it says "same as Acme production" and FeatherDB fills that step from the connection you saved. The card shows which one it borrowed, and the host counts as one you already trust.
• **When your AI's own app blocks a FeatherDB tool, it tells you how to allow it first.** One click in AI Tools → Claude Code, then retry; typing things in by hand comes last, only if you would rather not allow it.

1.12.5

• **A proposal tells you what it did, statement by statement.** A script that ran several statements used to report only the last one's count — "0 row(s) affected" after a change that had touched thousands of rows. The outcome now lists every statement with its count, and a check the proposal's author put at the end (a SELECT) shows its actual rows, so you read the verdict instead of trusting a summary.
• **While it runs, the card says what is running** — taking the snapshot, then running the SQL — instead of a bare "Running".
• **Nothing is cut off any more.** A decided proposal opens to its full reason, the SQL and the whole outcome; the record below does the same.

1.12.4

• **A read no longer fails because the database went idle.** Over a tunnel, the first call after a quiet stretch used to come back "connection dropped, retry" — and the AI's immediate retry hit the same wall while FeatherDB was still reconnecting. Now the app reconnects and the read runs on the new connection before anyone is told anything. If a reconnect really cannot finish in a few seconds, the AI is told to wait before one retry, not to retry at once.
• **Your AI is told where things run.** Every filed item names its tab — a change proposal waits under Proposals and runs only when you confirm there — so you are never asked to paste SQL into a terminal. And when the AI tool's own permission check refuses a door that reads nothing, the AI knows to point you at Allow safe tools instead of working around it.

1.12.3

• **A connection that finishes opening no longer steals the screen.** If you were reading one database while a second one was still connecting, the app used to jump to the second the moment it came up. Now the database you are looking at stays; the new one is a click away in the picker. The very first connection still opens where it always did.

1.12.2

• **Claude Code stops asking about the doors that read nothing.** Its auto mode checks every tool it has not been told to trust, and it was refusing even "file a question for you to run" as if it read your data. One click on the AI Tools screen now tells Claude Code which doors are safe to skip the question for: listing databases, reading a schema, filing a question, a snapshot request, a change proposal or a connection, and reading what became of them. Reading your rows or changing anything still asks.
• **Every door says what it does not read.** The first words of each tool's description now state whether it reads your data at all, so any AI tool can tell a question from a query before deciding.
• **The Integrations page explains the same thing** for anyone setting up Claude Code by hand.
• **A filled-in connection now separates what your AI read from what it guessed.** When it is unsure of a value — a port it inferred, say — the card shows that doubt as its own warning line, so you check that one thing first instead of reading a paragraph.
• **A filled-in connection is checked before you type a password.** For a server you have connected to before, FeatherDB reaches it and knocks on the database port by itself, using no secret, and the card says what it found: the server answered, the port answers and only the password is missing — or nothing is listening there. A server you have never connected to is checked only when you click Check.
• **Your AI can read that check too.** It learns whether you connected, dismissed, or what the check found, so it fixes the cause — a database that is not published on the server, say — instead of asking you to try again.

1.12.0

• **Your AI can fill in a connection for you.** When it already knows where a database lives — from your deploy files, say — it hands you a ready-made connection on the Connections screen: host, port, database, user and the SSH machine in front of it, all filled in. You type the password and click Connect. Nothing connects until you do.
• **It never carries a password.** A request that tries to include one, a private key, or a connection string with a password in it is refused outright. The secret is typed by you, in the app, and stays in the macOS Keychain like every other one.
• **A host you have never connected to is flagged.** Before you type anything, the card says whether one of your saved connections already reaches this machine — so a wrong or planted address is caught at a glance.

1.11.1

• **Staging and the live feed have their own place now.** The Sandbox tab gained a Live section — one click, not a long scroll past the mask report: who is attached to this sandbox, and a feed of every statement its server runs.
• **The feed shows your traffic, not the app's.** It used to fill with FeatherDB reading your own schema; now it shows what your backend, your AI, and your own editor run, and a long statement wraps so a glance finds the table and the verb.
• **The mask check stops crying wolf on document columns.** A sandbox whose document (JSON) columns held only operational data — amounts, dates, statuses — used to turn red, warning of values that had not actually leaked. The check now weighs only what it should hide, so a red state again means something real crossed. What gets masked did not change.

1.11.0

• **Your dev build can use the sandbox as its staging database.** On a connection you reach over SSH, the Sandbox tab gains "Expose to your server": FeatherDB opens a path from that server back to the sandbox on this Mac and shows the connection address your deployment should use — valid on the server, one Copy button. Your backend then reads and writes production-shaped, masked data while production stays untouched. The path lives as long as FeatherDB runs; Stop or Discard closes it.
• **Attached apps.** Each database now lists who is connected to it right now, as the server reports it — "shopio 1.2 · 2 sessions", "FeatherDB", "FeatherDB AI (claude-code)" — live and sandbox side by side, so you can see that v1.2 landed on staging and v1.1 stayed on production. A client that appears on both sides is flagged. Your AI sees the same list and is told what an attached backend means before it suggests a discard or a promote.
• **Live feed on the sandbox.** Every statement that runs on a Docker sandbox now appears on the Sandbox tab as it happens — time, which client ran it, how long it took, the statement — whether it came from your backend, from you, or from your AI. Backends that annotate their queries with sqlcommenter show the route beside each line. The built-in sandbox has no feed and says so.

1.10.6

• The gateway line in the sidebar shows its state in colour as well as words: green while running, grey when stopped, orange when a sandbox is unreachable.

1.10.5

• **The sidebar's client count no longer goes stale.** "Gateway running · … · N clients" stays current for as long as the gateway is up, on every screen. It used to be refreshed only while the AI Tools screen was open, so a client that connected while you were elsewhere still read "no client yet" until you opened that screen.

1.10.4

• **The trial clock is where you look, not two menus deep.** From a week before the trial ends, the sidebar's bottom line reads "Trial · 6 days left" (orange from three days), with Buy and Enter key… beside it. When the trial has ended, the same line says so and names what is locked — sandbox, snapshots, AI gateway — while browsing, SQL and schema diff keep working, as before.
• **A trial that ends while the app is open now ends on time.** The clock used to be read only at launch, so an app left open across day 14 kept every feature until its next relaunch, then locked without warning. It is now re-read when the app comes to the front and before each licensed action.
• **Your AI tool is told why the gateway is gone.** After the trial, Claude Desktop, Cursor or Codex used to receive "cannot reach FeatherDB", which reads as a connection problem. The gateway now answers that the trial has ended and how to buy or enter a key, so the assistant can relay the real reason.
• The sandbox mask legend now says what an emptied column holds: a negative row number.
• **The sidebar's bottom line says whether the AI gateway is running.** "Gateway running · port 8477 · 2 clients", or "Gateway stopped" with a Start button right there — the state every "cannot reach FeatherDB" in an AI tool has come down to, previously visible only on the AI Tools screen. A sandbox that has become unreachable (Docker not running) is named on the same line.
• **A locked control is disabled, not silently dead.** After the trial, "Start MCP server" and the exposure switches on AI Tools used to look live but do nothing when clicked. They are now greyed out with the reason beside them.

1.10.3

• **A sandbox now proves its mask held.** After every clone, FeatherDB reads back each masked column from the sandbox and compares it with the sampled source values. The Sandbox screen states the result as counts — "Verified in this sandbox: 0 of 1,203 masked values still equal a source value, across 14 masked columns" — and turns red, naming the column, if anything survived. The check covers exactly the rows that were copied, never the live database, and no source value leaves the source connection. AI tools see the same counts in the database list, so "masked" is a checked claim rather than a label.
• **Fixed, found by that check: a refused number could equal a real one.** When the mask rules refuse a numeric column, the placeholder written to the sandbox could coincide with a real id on a table whose ids are small. Placeholders are now unmistakably not data — negative, still unique per row — so they can never equal a value from your database.

1.10.2

• **The update line now also shows downloads that happened automatically.** If you chose "download and install updates automatically", FeatherDB used to fetch the new version in the background and say nothing until you quit — then, once the Mac went idle, pop a "ready to install" dialog. The sidebar now reads "1.10.2 downloaded · installs when you quit", with an Install now… button, and no dialog opens on its own in either mode.

1.10.1

• **Five workspace tabs instead of seven.** Checkup now holds both reports on a database — Schema, and Slow queries where the engine records them — and Proposals holds everything your AI asked for: Questions to run and Changes to confirm, with one count. The database name in the bar no longer gets cut off. Every old link still lands on the right place.

1.10.0

• **Your AI can now propose a change to your live database — and you confirm it in one click.** A new Proposals tab in the workspace lists what the AI filed: the reason it gave, the SQL it wants to run, or — after rehearsing on the sandbox — the migration plan from sandbox to live with each step's risk. You take a snapshot and confirm, or reject with a reason the AI reads back. Nothing runs without your click; the AI only ever polls the outcome.
• **Checkup findings come with a fix request.** One button copies the exact ask for your AI: fix these in the sandbox, then propose the change.
• **Migrations carry column defaults.** Promoting a new column that has a default (a flag defaulting to false, a tier defaulting to "basic") used to fail on any table with rows; the plan now includes the default, and such a column is a warning, not a dangerous step.
• **Fixed: dropping a constraint in a migration never actually ran.** It does now, and the constraint is verifiably gone afterwards.
• **Sandboxes keep every UNIQUE constraint.** Masked text used to be the same placeholder on every row, so a unique column could not be recreated on the clone and the diff later offered to drop that constraint on live. Masked values now read "***MASKED*** #12" — distinct per row.
• **Updates stop interrupting.** A scheduled update check no longer opens a dialog. When a new version exists, a line appears at the bottom of the sidebar — "1.10.0 available · Install…" — and in Settings › License, and you install when you choose. Check for Updates… in the app menu still shows the full release notes right away, because you asked.
• **Settings › License shows the version and when it was last checked**, in plain words: "Up to date · checked 5 min ago".

1.9.7

• **The "Updated" line no longer ticks.** It reads "Updated just now", then "5 min ago", then the clock time — the granularity macOS uses — instead of a seconds counter, and the resting state has no green check: the words are the confirmation.

1.9.6

• **Refresh now says what it did.** Under the table list: "Updated 2 minutes ago · 12 tables" after a load, a spinner while it runs, and the reason when it fails. Before, a refresh on a schema that had not changed looked like a button that did nothing.

1.9.5

• **Guessed references now show their evidence.** Where a schema declares no foreign keys (document-style tables with a JSON column, or apps that dropped their constraints) FeatherDB guesses relationships from names and asks you to confirm them. Opening a table now also samples up to 1,000 of its rows and checks how many of the referenced values really exist on the guessed table — "298/298 match · 300 sampled" next to the guess, or "8 of 200 unmatched" when they don't. Only the counts are read; no row values leave your database, and nothing runs until you open the table.
• **Document-style tables show what is inside them.** A table shaped id + data jsonb used to read as two columns and nothing more. The table view now lists the top-level keys found in a small sample of its rows — key names only, never values — and AI tools get the same list from list_tables, so a schema-less app is no longer a blank to them.
• **One References section for every kind of relationship.** Declared foreign keys, guesses and the ones you confirmed now share one list with the same row shape and a declared / guess / confirmed badge, instead of foreign keys hiding as raw constraint text below.
• **The table view is tidier.** Each guess now has two controls, Confirm and Correct…, with "Not a reference" at the bottom of the Correct… menu; badges share one style across the screen; Refresh is a glyph beside the list title (⌘R) and the system-schema switch sits under the list it filters.
• **Fixed: a database with a single document-style table repeated its guessed references.** Each sampled row re-reported the same key, and every repeat became another identical guess.

1.9.4

• **The AI exposure table stays readable as you connect more databases.** Each capability — sandbox read/write, live read-only, whether the AI may create a sandbox, whether it may read rows — is now named once in a header row instead of repeated beside every switch. With several databases connected you can scan a column to see what the AI can reach.
• **Confirmations appear where you clicked.** Connecting an AI tool used to put its "Installed" message at the top of the screen, a full scroll from the button you pressed and often out of sight, so the button looked like it had done nothing. It now shows directly under the button.
• **The Codex option names the app it is for.** It reads "OpenAI Codex (ChatGPT app)", since Codex is the mode inside the ChatGPT desktop app as well as its own command line and IDE extension.

1.9.3

• **One-click connect for OpenAI Codex — and the ChatGPT desktop app.** AI Tools now has an "Add to OpenAI Codex" button that adds FeatherDB to your Codex config (your other settings kept, a backup written first). Codex shares one config across its command line, its IDE extension, and the Codex feature inside the ChatGPT desktop app, so a single click connects all three — locally, with no tunnel. (ChatGPT's own cloud connectors still need a public URL; that path is unchanged.)

1.9.2

• **FeatherDB offers to move itself into Applications on first launch.** An app run straight from Downloads or a disk image can't update itself — macOS locks it to a read-only copy. Now, if you open FeatherDB from anywhere but your Applications folder, it offers to move there and relaunch, so updates just work from then on. The download disk image also carries an Applications shortcut to drag onto.

1.9.1

• **The connection list no longer breaks when you widen the sidebar.** Dragging the navigation sidebar very wide used to squeeze the panel beside it until its text wrapped one letter per line. The sidebar now stops at a sensible width, the way every Mac app's navigator does.

1.9.0

• **Checkup — a database review a DBA would give you, in one tab.** FeatherDB reads the schema you're connected to and flags what an expert would: tables with no primary key, foreign keys with no covering index (Postgres — MySQL and MariaDB index these for you), tables holding personal data, and a connection running as a superuser or root. Each finding says what it means and what to do. It runs on the schema plus one privilege check — no query against your data, nothing changed, nothing to install — and it's free, on every engine.
• **Your AI can run Checkup too.** The same review is now a gateway tool, so an assistant connected to FeatherDB can ask "is this database healthy?" and get exactly what the app shows you — the same findings, read-only.

1.8.2

• **Buying is easier to find.** When the trial is running low, or a licensed feature is locked, the app now shows a Buy button right where you are — on the Snapshots, Sandbox and AI Tools screens, and in Settings → License — instead of only a buried link. If you are already licensed, nothing changes.

1.8.1

• **A dropped connection heals itself instead of failing your query.** When an idle SSH tunnel or a timed-out session dies, FeatherDB used to keep saying "Connected" and fail the next query with "connection closed". Now the connection is reconnected in place — your query just runs — and the Connections row shows "Connection dropped" with a Reconnect button if it can't. Your AI is told a dropped connection is transient and to retry, not that something is broken.

1.8.0

• **Your AI's sandbox work is on the record.** Every statement it executes on a sandbox is journaled automatically — what ran, when, by which AI, how many rows — shown on the Sandbox tab and copyable as SQL. The Diff screen notes when a plan's sandbox carries a session journal.
• **Let your AI start its own sandbox — if you say so, once.** A new per-connection switch (off by default) lets the AI create the same masked, version-true sandbox the button makes, so a coding session doesn't wait for a click. One per connection; without the switch it is refused and told to ask you.
• **Sandboxes survive quitting the app.** A Docker sandbox now waits for you across restarts: reopen FeatherDB, reconnect, and it is back — same data, same mask report, your AI's journal intact. Discard still deletes it for real.
• **The AI can see version-truth at a glance**: every database it is offered now names its version series, so a sandbox visibly matches your production server before it writes a line.

1.7.0

• **Undo for your database.** Applying a migration now takes a whole-database snapshot first (on by default — and if the snapshot fails, the migration does not run). Every snapshot lists WHY it was taken, and restoring is deliberate: the app names exactly what will be lost, asks you to type the database's name, and takes one more snapshot right before — so even the undo can be undone. On MySQL and MariaDB this is the only undo that exists for schema changes: no transaction there can roll back a DROP TABLE. Snapshot, drop a table, restore — it is back with its rows.
• **Look at yesterday's database next to today's.** A snapshot opens into its own disposable container for inspection — browse it like any database, compare, then discard it. It holds your REAL data, so unlike a sandbox it is never, under any setting, visible to an AI.
• **Your AI can ask for an undo point — and only ask.** Before handing you a risky change, it can file a snapshot request with its reason; the request waits on the Snapshots screen and nothing happens until you click. Snapshots it asked for are labelled with its name.
• **The SQL editor guards live the same way.** Running a write on a live database offers "Snapshot first" — on by default, and if the snapshot fails the statement does not run.
• **Snapshots stay on your Mac** — a folder you can see, sizes shown, deletion is yours. Nothing is uploaded anywhere, and nothing to install: snapshots are taken at your server's version through the same Docker path sandboxes use.

1.6.1

• **Hit the two-Mac limit? Fix it on the spot.** Activating a third Mac now shows the two Macs holding your seats, and one click retires the one you chose and licenses this Mac in the same step — same email code, no support ticket, no second code to type.

1.6.0

• **FeatherDB now connects to MySQL and MariaDB.** Pick the engine when you add a connection, or just paste a mysql:// or mariadb:// URI — the scheme sets everything up. Browse tables, stream big results, read the full schema with its keys and relationships, save marks and answer lookups, exactly as with Postgres. Tested against MySQL 8.0 and 8.4 and MariaDB 10.11 and 11.4 — other versions will usually connect, but those four are the ones we run the whole suite against before every release.
• **Your AI knows which dialect to write.** Every database it can see now names its engine, so it writes MySQL when it is talking to MySQL — backticks, LIMIT syntax and all — instead of assuming Postgres and failing on the first query.
• **Live MySQL databases are read-only for AI, enforced by the server itself.** Not a promise in a prompt: we verified on real MySQL 8.0 and 8.4 and MariaDB 10.11 and 11.4 servers that INSERT, UPDATE, CREATE TABLE and DROP are all refused before anything runs.
• **The editor reads MySQL, too.** Backticked names, # comments and MySQL keywords all colour correctly in the SQL editor and everywhere a query is shown.
• **Sandboxes now run in Docker — for every engine, at your server's exact version.** Cloning proposes a container matched to your production (PostgreSQL 14 or 18, MySQL 8.4, MariaDB 11.4 — whatever it really runs), and nothing is created until you approve it. The container is visible in Docker Desktop, and discarding the sandbox deletes it. No Docker? Postgres still clones instantly with the built-in engine, exactly as before — and the screen tells MySQL/MariaDB users what to install instead of guessing.
• **A finished clone takes you straight to your new sandbox** — the data grid opens on it, instead of leaving you on the screen you clicked from.
• **If Docker stops underneath a running sandbox, FeatherDB notices.** The sandbox's row says it is unreachable and how to get going again, and your AI is told the same thing once, in words — the dead sandbox leaves its list instead of erroring forever.
• **Every saved connection now shows its engine** — PostgreSQL, MySQL or MariaDB — next to its name, so two similarly named rows can never be confused.
• **"Connection refused" now reads like a sentence.** A database that is not running gets you "nothing is listening at 127.0.0.1:53306 — is the database server running?" instead of a stack of driver wrappers around an OS error code.
• **The mask report tells the truth about generated columns**: they are recomputed by the sandbox from their own expression, and the report now says RECOMPUTED instead of mislabelling them as nulled.
• **Slow queries and "Why is this slow?" show only where they work today** — Postgres. For MySQL and MariaDB they arrive in coming releases rather than sitting there broken.

1.5.1

• **Run it again and you can share the new rows.** After sharing a result, re-running kept the old "Shared with AI" line and hid the Share button — so if you added a row and ran the query again, there was no way to send the fresh answer, and your AI kept reading the first snapshot. Every run now starts clean.
• **A lookup's id is a name, not a number.** Ids now look like lk-7f3, minted the way mark ids always have been. The old numbering restarted at lk-1 once you had deleted every lookup, which meant a brand-new question could inherit a name your AI was still holding — and it would read that name expecting the earlier question. Ids from before this update keep working exactly as they did.
• **The relationship map opens around the table you were reading**, not the first one in the alphabet.

1.5.0

• **Your AI can hand you a question instead of reading your data.** When the answer lives in rows it should not see, it files a lookup: you find it under Database → Lookups, read the one-sentence reason above the query, and run it yourself. The rows stay with you.
• **And when you want its help reading them, you decide what it sees.** Press Share with AI on a result and sensitive values cross as stable aliases instead of the real thing — so it can still tell you "these three rows hold the same token, and it has not changed in 40 days" without ever seeing the token. Every column says how it crossed: as-is, aliased, redacted, or withheld.
• **A question your AI filed is still there tomorrow.** Lookups now survive quitting the app. What is kept is the question itself; a result you shared is never written to disk, so sharing stays a decision about this session and nothing more.
• **Sharing shows you exactly what will cross — before it does.** Press Share and you get a column-by-column account first: aliased, redacted, or as-is. Nothing moves until you confirm, and column names that name something sensitive are now caught in the plural too (tokens, not just token).
• **You can expose a database without letting the AI read it.** A new switch beside Live · read-only: with it off, the AI sees the schema and files lookups for you to run, and its own queries against your rows are refused — by FeatherDB, not by asking it nicely. This update starts every live database with the switch OFF, including ones you had already exposed: letting an AI read your rows is a decision worth making on purpose, and the AI Tools screen tells you it was switched off and why.
• **Your credentials are never sent to an AI — at any setting.** Columns that name a token, key, password, hash or secret are removed from every result before it leaves your Mac, and so are the same keys nested inside JSON documents. The AI is told which columns were removed and that it should hand you a lookup instead, so you read the value here, where it stays. Recognition is by name, so if a credential of yours lives in a column that does not say so, add the word to "Always mask" beside the switch — your words now apply to everything an AI can read, not just to sandboxes.
• **Lookups are yours to manage.** Open one again after you have run it, take back a result you shared, or delete the question for good. And a lookup your AI files while you are looking at the tab now appears there by itself, badge and all.
• **SQL is highlighted wherever you read it** — a lookup's question, a slow query, a migration step, and the screen where you approve a write your AI proposed.
• **The editor says what it measured, and stops guessing what it means.** Run becomes Re-run once rows are on screen, the result says when it was fetched, and "Why is this slow?" now reports Postgres's own numbers — planning plus execution, and that the measurement itself inflates them — instead of telling you whether that is good. Reading the plan is your call, with your AI: you can send it one deliberately, and it arrives labelled a measurement, so a plan can never be mistaken for the answer to the question you asked.

1.4.0

Sandboxes for every Mac, and a place for everything.

• **Intel Macs get version-matched sandboxes too.** Sandbox runtimes now come in a build for your machine — Apple Silicon or Intel — and FeatherDB fetches the right one. On 1.3.0 an Intel Mac was offered a runtime it could not run; that is fixed.
• **The sidebar holds what the app does; the Database tab holds what a database does.** Sandbox and Slow queries now live inside Database, under a bar that names the database they act on — with two connections open, nothing is ambiguous about which one you are looking at. Existing links and shortcuts still land where they always did. Connections shows a Sandbox badge so you can still see at a glance which databases have one running. Picking which database (and Live vs Sandbox) now happens once, in that bar, instead of separately on each screen.
• **A way forward when a database refuses the connection.** Adding a connection now links the recipes for databases that live inside Docker, Kubernetes or a PaaS — the cases where the fix is on your server, not in this form.
• **Tidier disk.** Runtime downloads clean up their temporary files, on success and on failure alike.

1.3.0

The sandbox now speaks your production's PostgreSQL version.

• **Version-matched sandboxes.** If your database runs PostgreSQL 14, 15, or 16, FeatherDB offers a small one-time download (~8 MB) of that exact version and clones into it — the migrations you rehearse are rehearsed on the real thing, not a lookalike. PostgreSQL 17 stays built in and works with zero downloads, as before.
• **The choice comes first.** The version question is asked before your first clone, not after: download the matching version, or clone with the built-in engine — one click either way. A version-matched sandbox confirms itself in green; a mismatched one keeps the orange warning and carries the fix right next to it.
• **No busywork.** After a runtime download finishes, the sandbox re-clones itself.
• **Sturdier sandboxes.** Version-matched sandboxes run separately from the app: a sandbox crash cannot take FeatherDB down with it, and they accept parallel connections.
• **pgvector included.** Every downloadable runtime ships with the vector extension — CREATE EXTENSION vector works in your sandbox.
• **Cleaner exits.** Sandbox servers left behind by a crashed session are shut down and cleaned up the next time FeatherDB starts.
• **A fresh coat.** The accent palette across the app now matches the FeatherDB feather — the lighter violet it always meant to wear.

1.2.0

• **Connecting to a remote database is seconds now, not minutes.** Reading a schema over a real SSH tunnel to a faraway server used to take minutes — long enough that a connected AI's schema request could time out entirely. It now takes seconds, however many tables you have.
• **Your connections come back too.** Whatever was connected when you quit reconnects on launch — tunnels, databases, the databases the AI sees filling in as each one opens. Disconnecting still means stay closed.
• **What you exposed to the AI stays exposed.** The databases you chose in AI Tools now survive quitting the app: reconnect and they are back on the gateway without re-toggling. Un-exposing, disconnecting, or deleting a connection still clears its exposure — quitting is the one thing that no longer does.
• **The AI gateway comes back with the app.** If the MCP server was running when you quit, relaunching FeatherDB starts it again — your connected AI keeps its tools instead of silently losing them until someone remembers the Start button. Pressing Stop still means stop, across relaunches too.
• **A guessed relationship now takes your verdict.** Each guess on a table's detail asks: Confirm, Correct (pick the real target), or Not a reference — and your answer beats the guess everywhere at once: the map draws it solid, the AI is told "confirmed by the user" instead of "verify", and a wrong guess stays gone. Your verdicts live with the connection and survive relaunches.
• **The relationship map now sees joins nobody declared.** Document-store schemas (one data JSON column per table) and FK-less relational apps never declare foreign keys, so their maps used to say every table "stands alone". FeatherDB now infers relationships from column and document-key naming — userId inside billing_events reaching for users — and shows them as dashed lines that say why they exist. A guess stays labelled a guess everywhere it travels: the map, the AI context, and what your connected AI reads. Ambiguous names infer nothing.

1.1.0

• **Your AI can now work with your databases — safely.** FeatherDB runs a local MCP server you can connect Claude Desktop, Claude Code or Cursor to. You choose which databases it sees; a sandbox is fully writable (it is a masked, disposable clone — that is what it is for), the live database is read-only, enforced by Postgres itself. When the AI is refused something, the refusal tells it what to ask you — no silent dead ends.
• **Marks — hand your AI exactly the schema you mean.** Save any table plus the related tables you pick as a mark (an id like mark-7f3), and say that id in your AI chat: the AI pulls the same DDL and masked sample rows you previewed, with a picture of the relationships. Links like featherdb://mark-7f3 open the mark right back in FeatherDB — and the AI can open it for you on request.
• **See a table's relationships as a map.** A button on every table draws the tables it references and the tables that reference it — in plain words ("each order belongs to one customer"), with link tables marked, cascade deletes in red, drag to rearrange and zoom to fit.
• **The AI knows what FeatherDB offers.** On connecting, your AI tool is told what it can do here and when to suggest it — including what is new in the version you are running — so features reach you in the middle of real work, not from a manual.
• **Copy AI context moved to where the data is.** The button now sits on the Data screen of the table you are viewing; the preview still shows exactly what leaves the machine before anything is copied.
• **"Why is this slow?" answers the question.** The verdict says whether the run was actually slow — not just how long it took — asks before measuring an unbounded query on a live database, and the copied prompt now carries the schema and indexes the plan is about.
• **The SQL editor colours your query**, and a connection with no saved password says so in plain words before dialing.

1.0.3

• **Slow queries** — a new section listing what has actually been slow on the database you are connected to, worst average first, read from Postgres's own record. Each entry opens in the SQL editor, or asks "Why is this slow?" directly.
• **"Why is this slow?" now sits beside Run** in the SQL editor. It shows the query plan in the same result area every query uses and puts an optimization prompt — your query and its plan — on the clipboard for your AI chat. A query Postgres recorded with placeholder values gets an estimated plan, and the app tells you that is what you are looking at.
• **Two databases, at the same time.** Connecting one no longer makes you wait for it: a slow remote database and a local one open side by side, and only the row actually doing the work says it is working.
• **The sandbox screen names its database.** Each open connection gets its own row with its own clone, browse, compare and discard. With two connections the second sandbox used to be invisible while it was still running.
• **Every data screen says which database it is showing** — and whether that is the LIVE one or a sandbox — with the same source picker on all of them.
• **A comment above a statement no longer hides what it does.** A statement that would change or drop data is still flagged before you (or an AI proposal) run it, even with a -- comment line above it.

1.0.2

• The Licence pane reads properly again: its fields are fields, not sentences wedged into a label, and they stop growing sideways while you type.
• Closing Settings clears anything half-typed. Reopen it and you get a clean pane — not last time's draft, and never a licence key left revealed on screen.
• The AI command approval sheet has a way out. It could be opened with no button to dismiss it and no key that closed it; now Done and Escape both do.

1.0.1

• Activate with your purchase email — buy, open FeatherDB, enter the email from your receipt and the 6-digit code it sends you. Done. No key to copy out of an email, no account created; after activation everything verifies on your Mac, offline, exactly as before.
• Licence keys still work and always will — pasting a key remains the offline path for air-gapped machines.

1.0.0

First public release.

• Native macOS Postgres client: saved connections over SSH or direct TLS, a data grid for browsing and editing rows, a SQL query editor, schema diff and migration planning.
• Local sandboxes: clone a database's real schema into an embedded Postgres on your Mac, with personal data masked before it lands — a safe place for an AI agent to work.
• One MCP gateway for AI tools (Claude Code, Claude Desktop, Cursor, Codex CLI, and anything else that speaks MCP): live databases are read-only, enforced by the database server; sandboxes get full read and write.
• Signed, notarized, and self-updating — the in-app updater checks this same feed for new versions.

0.9.2

• The app icon now keeps its transparent margin, so it no longer shows a white frame on dark backgrounds or in the update dialog.

0.9.1

First build carrying self-updates. Earlier versions were never distributed, so there is nothing to update from.