@metabase/rde 0.1.18 → 0.5.1

package/README.md

@@ -1,6 +1,6 @@
 # @metabase/rde
 
-`rde` prepares a Mac or Linux machine for data-engineering work with Metabase and coding agents. One command, `rde init`, sets up everything a working setup needs: the `mb` CLI, the `rde` skill for your coding agents, a running Metabase Enterprise instance (in Docker, or a jar run with the machine's Java), an admin user, an API key wired into `mb`, transforms switched on, your license, a database of your own for transforms to write to, and a git repository connected through Metabase's remote sync. It decides what it can on its own and asks only for what it cannot know: your license token, a connection string for your own database (`init` goes no further without one), and with a license, where the git repository lives. Every step checks whether it is already done, so the wizard can be interrupted at any prompt and picked up again with the same command.
+`rde` prepares a Mac or Linux machine for data-engineering work with Metabase and coding agents. One command, `rde init`, sets up everything a working setup needs: the `mb` CLI, the `metabase-rde` skill for your coding agents, a running Metabase Enterprise instance (in Docker, or a jar run with the machine's Java), an admin user, an API key wired into `mb`, transforms switched on, your license, a database of your own for transforms to write to, and a git repository connected through Metabase's remote sync. It decides what it can on its own and asks only for what it cannot know: your license token, a connection string for your own database (`init` goes no further without one), and with a license, where the git repository lives. Every step checks whether it is already done, so the wizard can be interrupted at any prompt and picked up again with the same command.
 
 After `init`, the rest is lifecycle: `rde start`, `rde stop`, `rde status`, `rde logs`, `rde open`, and `rde db add` when another database comes along. The instance lives under `~/.rde`, listens on `127.0.0.1` only, and is used through `mb` and through the agent skill.
 
@@ -60,13 +60,13 @@ The git step reads `–` until a license with remote sync is active; it is check
 | Install the Metabase CLI | `@metabase/cli` (`mb`) at the `latest` dist-tag, with the package manager that installed `rde`; an installed `mb` older than what the dist-tag names now is updated. `rde status` and `rde doctor` check only what is installed and ask no registry |
 | Install Metabase | **Docker** when it is available: pulls the major line of the newest Metabase Enterprise release, such as `metabase/metabase-enterprise:v1.65.x` (or `--image`), and creates the container. **Jar** otherwise, or with `--runtime jar`: downloads the newest enterprise release (or the tag or `.jar` path given as `--jar`) into `~/.rde/jars/` and runs it with your Java. [Metabase versions](#metabase-versions) says how the release is found. Either way on port 23000, or the first free port above it that nothing else claims, or `--port` |
 | Start Metabase | Starts the container or the jar and waits for `/api/health`, showing Metabase's own progress |
-| Install the rde and data-app skills | The data-app skills (`metabase-data-app-setup`, `-routing`, `-actions`, `-semantic-layer`, `-migrate`) from the release branch of the Metabase the instance runs (`metabase/metabase/skills#release-x.65.x` for Metabase 65, `release-x.66.x` for 66, and so on; 65 is the first with them), then the `rde` and `rde-data-apps` skills from the `main` branch of `metabase/agent-skills` (the rde skill hands an explicit app request to `rde-data-apps`, which hands the build to the data-app skills), for the coding agents you pick at a terminal, from the ones found on this machine (Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Windsurf). When none is found, the step is skipped and says how to add the skills once an agent is installed; `rde` installs no agent. Without a terminal, or with `--yes`, every agent found gets the skills; `--agents` picks a set ahead of time (the skills are installed for them whether or not they are on the machine yet), `--skip-agents` none; `RDE_SKILL_SOURCE` installs the two rde skills from another URL or a local checkout of `metabase/agent-skills`. Installed skills whose directory changed on its branch since are installed again, without a question when every detected agent already has them all. The skills are installed globally, not per instance, so every instance on the machine shares one set: instances on different Metabase majors share the data-app branch the last `init` (or `rde upgrade` to another major) installed |
+| Install the rde and data-app skills | The `metabase-data-apps` skill, one skill with a guide per data-app task (setup, routing, actions, semantic layer, migrate), from the `skills/metabase-data-apps/v1` folder of the `main` branch of `metabase/agent-skills`, then the `metabase-rde` skill from the `skills/metabase-rde/v1` folder of the same branch (its data-app reference settles what an app needs on an rde machine and hands the build to `metabase-data-apps`), for the coding agents you pick at a terminal, from the ones found on this machine (OpenCode, Claude Code, Codex, Cursor, Gemini CLI, Windsurf). When none is found, the step is skipped and says how to add the skills once an agent is installed; `rde` installs no agent. Without a terminal, or with `--yes`, every agent found gets the skills; `--agents` picks a set ahead of time (the skills are installed for them whether or not they are on the machine yet), `--skip-agents` none; `RDE_SKILL_SOURCE` installs both from another branch URL or a local checkout of `metabase/agent-skills`. The `v1` folder of `metabase-data-apps` is the data-app contract version Metabase serves, the same whatever Metabase version the instance runs; a breaking contract change gets a folder of its own (`v2`, …), and the guide for migrating an app Metabase marks Outdated moves it to the newer one. Installed skills whose directory changed on its branch since are installed again, without a question when every detected agent already has them all, and copies of the earlier per-task data-app skills (`metabase-data-app-setup`, `-routing`, `-actions`, `-semantic-layer`, `-migrate`) that the skills lock attributes to `metabase/metabase`, whoever installed them, are removed once `metabase-data-apps` is in, so the two never compete; a copy also installed for an agent that has no `metabase-data-apps` after the run stays, with a warning naming those agents and the `rde init --only agents-skills --agents <…>` command that replaces it. Copies of `rde` and `rde-data-apps`, the two skills an earlier rde installed in place of `metabase-rde`, are removed the same way once `metabase-rde` is in, wherever they came from. The skills are installed globally, not per instance, so every instance on the machine shares one set |
 | Create the admin user | `admin@metabase.local` with a generated password that `rde credentials` shows, or your own with `--admin prompted`, see [Credentials](#credentials) |
 | Connect the Metabase CLI | Creates an API key named `rde` and logs `mb` in with it under the profile `default`, so plain `mb` uses the instance; when `default` already points at another Metabase it asks first, see [The `mb` profile](#the-mb-profile); a key Metabase rejects is replaced |
 | Enable transforms | Turns transforms on, unless someone already set them either way: turned off in the admin settings, they stay off on every later `rde init`, and the admin settings turn them back on |
 | Activate your license | Optional. Paste a token, or press Enter to skip. The token unlocks remote sync (the `remote-sync` feature, which the git step needs), data apps (`data-apps`), and transform tests (`transforms-testing`); skipping the license goes without all three, and an activated token that lacks some is named with the ones it lacks. A token Metabase refuses is asked for again at a terminal |
 | Connect a git repository | Only with a license. Initializes or reuses a repository and points Metabase's remote sync at it, with transforms included in the sync (the Transforms row under Collections to sync), and imports the content it already holds |
-| Choose what syncs to git | Only once a repository is connected. Creates the Library (when the license has the `library` feature) and an `Analytics` collection, unless the repository already brought synced top-level collections in, and marks them for sync. Before it changes anything it asks whether to push them to the branch (default yes); without the push, or when the branch has commits Metabase has not imported, it prints the export to run instead |
+| Choose what syncs to git | Only once a repository is connected, and only when the license has the `library` feature. Creates the Library unless the repository already brought one in, and marks it for sync; nothing else is created or marked. When the Library was not synced yet, it asks before it changes anything whether to push it to the branch (default yes); without the push, or when the branch has commits Metabase has not imported, it prints the export to run instead |
 | Connect your databases | Required: `init` goes no further until a database of your own is connected, as a user that can create the tables transforms write. At a terminal: pick the databases the imported content uses from a checklist, or, with none, paste a connection string (Enter goes to the engine list); review, test, add; repeat. `--database` names them ahead of time; with `--yes` or without a terminal and none named, the step fails naming `--database` and the answers file. `rde db add` starts from the same checklist, then the engine list, where the fields can also be filled one by one |
 | Summary | URL, login email, the `mb` command for the instance, databases, repository, the export still to run when Metabase has unexported changes, and the command that opens each detected agent |
 
@@ -95,7 +95,7 @@ The second run on the same machine detects every step as done and prints the sum
 │  Databases:                                                            │
 │    warehouse (postgres, syncing; `rde status` shows when it finishes)  │
 │  Remote sync: not configured (no license)                              │
-│  rde skill: installed for Claude Code                                  │
+│  metabase-rde skill: installed for Claude Code                         │
 │  Start working:                                                        │
 │    claude  (Claude Code)                                               │
 │  Lifecycle: rde status (--json for scripts), rde stop, rde start       │
@@ -152,7 +152,7 @@ Docker is used whenever it is available: the image is self-contained, and the co
 
 rde runs Metabase Enterprise 65 or newer. Once Metabase is up, `rde init`, `rde start`, and `rde upgrade` read the version it reports and refuse the OSS edition (a `v0.…` version, which `metabase/metabase` runs), a release before 65, and a build of master (a `-SNAPSHOT` version, which `metabase/metabase-enterprise-head` runs), with exit code 2 and the way to another: `rde upgrade --to <image or release tag>` for this instance, or `rde uninstall`, then `rde init --image <image>` or `rde init --jar <release tag>`, for a new one. The refused instance is left running as it is. `--jar` refuses a `v0.…` tag before anything is downloaded. With `RDE_DEV=1`, for working on rde and Metabase themselves, every version runs.
 
-A new instance runs the newest release that Metabase's release feed (`https://static.metabase.com/version-info-ee.json`) lists of Enterprise 65 or newer, betas and release candidates left out. The feed's own `latest`, like the Docker `:latest` tag, moves to a new major only weeks after its release, so rde reads neither. Docker gets the major line of that release, `metabase/metabase-enterprise:v1.<major>.x`, a tag Metabase moves to every build of the major: the state file records the line, and each pull of it brings the newest build. The jar gets the release itself. While the feed lists no release of 65 or newer, `init` stops with exit code 2 before it pulls or downloads anything, and names the ways out: `--image <image>`, `--jar <release tag>`, or `RDE_DEV=1` for the development build. When the feed cannot be read, `init` stops the same way, with the cause and `--image <image>` or `--jar <release tag>` as the way past it. In development mode the image is `metabase/metabase-enterprise-head:latest`, and the jar's `latest` is the feed's own `latest`.
+A new instance runs the newest release that Metabase's release feed (`https://static.metabase.com/version-info-ee.json`) lists of Enterprise 65 or newer, a beta included: a major's betas are its `.0` builds and its first final release is `.1`, so a beta runs only until that final is out. The feed's own `latest`, like the Docker `:latest` tag, moves to a new major only weeks after its release, so rde reads neither. Docker gets the major line of that release, `metabase/metabase-enterprise:v1.<major>.x`, a tag Metabase moves to every build of the major: the state file records the line, and each pull of it brings the newest build. The jar gets the release itself. While the feed lists no release of 65 or newer, `init` stops with exit code 2 before it pulls or downloads anything, and names the ways out: `--image <image>`, `--jar <release tag>`, or `RDE_DEV=1` for the development build. When the feed cannot be read, `init` stops the same way, with the cause and `--image <image>` or `--jar <release tag>` as the way past it. In development mode the image is `metabase/metabase-enterprise-head:latest`, and the jar's `latest` is the feed's own `latest`.
 
 ## Everyday commands
 
@@ -195,9 +195,9 @@ With a license that includes remote sync, the step after the license connects a
 
 A fresh repository gets a first commit with a `README.md` and a `.gitignore` that keeps out what a data app built in it must not push: `.env`, `.env.local`, `.env.*.local`, `node_modules/`, `.vite/`, the rde skill's `.scratch/`, and `.DS_Store` (a data app's built `dist/` stays tracked, since that bundle is what Metabase serves); a `.gitignore` already there keeps its lines and gets the missing ones, and a repository that already has commits is left as it is. A repository that already holds Metabase content is imported on the spot; each database it names that this instance lacks becomes a stub, which the databases step offers to connect.
 
-Remote sync carries only what is marked for it, so the step after the repository decides what that is: the Library (published tables with their measures and segments in Data, metrics in Metrics), and one top-level collection for dashboards, questions, models, and documents; transforms already sync through the repository step. The collection is `Analytics`, created for the purpose (beside any `Analytics` of the user's, which stays out of git), unless the import brought top-level collections the repository already syncs, in which case those are used and nothing is created; the Library is created only when the import did not bring one, since a second Library would conflict with the repository's on the next import. Anything filed outside these collections stays on this instance. The step refuses to run after an import that did not finish cleanly, and names the import to run first. While remote sync is read-only, the repository decides what syncs: `rde init` skips the step, and `rde init --only sync-scope` stops and asks for read-write in Admin. `rde init --only sync-scope` runs it again; it creates nothing that is already there.
+Remote sync carries only what is marked for it, so the step after the repository decides what that is: the Library, where everything for consumption goes (published tables with their measures and segments in Data, metrics in Metrics, official dashboards in Dashboards). Transforms already sync through the repository step, by setting rather than by collection, and data apps sync their own collections. The step never creates or marks any other collection; top-level collections the repository already syncs come in marked with the import and are left as they are. The Library is created only when the import did not bring one, since a second Library would conflict with the repository's on the next import, and when the import brought it already synced, the normal case for an instance cloned from a production repository, the step changes nothing and asks nothing. Anything filed outside the synced collections stays on this instance. The step refuses to run after an import that did not finish cleanly, and names the import to run first. While remote sync is read-only, the repository decides what syncs: `rde init` skips the step, and `rde init --only sync-scope` stops and asks for read-write in Admin. `rde init --only sync-scope` runs it again; it creates nothing that is already there. An instance set up by an earlier `rde` may have an `Analytics` collection that step created; it stays as it is, synced or not, and `rde` no longer tracks it.
 
-Marking the scope is itself a change Metabase has not exported, and until it is exported a plain `mb git-sync import` refuses ("There are unsaved changes in the Remote Sync collection"). So the step asks, before it creates or marks anything, whether to push the scope to the branch, and on yes runs `mb git-sync export` and checks that Metabase is in sync afterwards. It asks because the branch may be one others share. On no, or when the push fails, it prints `mb git-sync export -b <branch>` and the summary repeats it while Metabase has unexported changes. When the branch has commits Metabase has not imported, it asks nothing and pushes nothing: a plain export would end in a conflict, which counts the remote commit as synced, so it names `mb git-sync export-preflight` and `mb git-sync export -b <branch> --merge` instead. Afterwards:
+Marking the Library is itself a change Metabase has not exported, and until it is exported a plain `mb git-sync import` refuses ("There are unsaved changes in the Remote Sync collection"). So when the Library is not synced yet, as with a fresh repository, the step asks, before it creates or marks anything, whether to push it to the branch, and on yes runs `mb git-sync export` and checks that Metabase is in sync afterwards. It asks because the branch may be one others share. On no, or when the push fails, it prints `mb git-sync export -b <branch>` and the summary repeats it while Metabase has unexported changes. When the branch has commits Metabase has not imported, it asks nothing and pushes nothing: a plain export would end in a conflict, which counts the remote commit as synced, so it names `mb git-sync export-preflight` and `mb git-sync export -b <branch> --merge` instead. Afterwards:
 
 ```sh
 cd <your working directory>
@@ -208,7 +208,7 @@ git pull   # after an export, to see the YAML files
 
 ## Running `init` without a terminal
 
-Every prompt can be answered ahead of time, by a flag or by a JSON answers file, so an agent or a CI job can run `rde init` unattended. The choices `init` makes on its own need no answer, so a run without a terminal only has to cover the license, the databases, the git repository, and whether to push the sync scope. When stdin is not a terminal, the first prompt nothing answers fails with exit code 2 and a message naming the step, the prompt, and the flag or answers key that would have answered it; nothing hangs. A text prompt with a default (a display name) takes its default, as Enter would.
+Every prompt can be answered ahead of time, by a flag or by a JSON answers file, so an agent or a CI job can run `rde init` unattended. The choices `init` makes on its own need no answer, so a run without a terminal only has to cover the license, the databases, the git repository, and whether to push the Library. When stdin is not a terminal, the first prompt nothing answers fails with exit code 2 and a message naming the step, the prompt, and the flag or answers key that would have answered it; nothing hangs. A text prompt with a default (a display name) takes its default, as Enter would.
 
 ### Flags
 
@@ -220,11 +220,12 @@ rde init --skip-license \
 
 | Flag | Answers |
 | --- | --- |
-| `--agents claude-code,codex` / `--skip-agents` | Which agents get the skill, instead of asking at a terminal or taking the ones found on the machine |
+| `--agents opencode,claude-code` / `--skip-agents` | Which agents get the skill, instead of asking at a terminal or taking the ones found on the machine |
 | `--runtime docker\|jar`, `--image`, `--jar`, `--port` | How Metabase runs, the Docker image or the jar (`latest`, an enterprise release tag, or a `.jar` path), and the host port, instead of Docker when available, the major line of the newest release, the newest release, and the first free port from 23000 that nothing else claims; `--image` implies `docker` and `--jar` implies `jar` |
 | `--admin generated\|prompted`, `--admin-email`, `--admin-password` | The admin user, `generated` unless given; an email or password implies `prompted` |
 | `--license-token` / `--skip-license` | The license |
 | `--database <connection string>` (repeatable) | Your own databases, the engine read from the string; `<engine>=<connection string>` names it when the string fits several (`druid=jdbc:avatica:…`). Without a terminal, one of them or the answers file's `databases` section is required unless the instance already has a database |
+| `--database-name <name>` (repeatable) | Display name of the `--database` in the same position. A name the repository's content already uses (the production Metabase's name) connects the placeholder a remote-sync import left for it instead of adding a second database |
 | `--git-dir`, `--git-remote local\|hosted`, `--git-url`, `--git-token` / `--skip-git` | The content repository; a remote or URL without `--git-dir` means the current directory |
 | `--mb-profile default\|rde` | The `mb` profile when `default` already points at another Metabase; `default` (replace it) unless given |
 | `--yes` | Every confirmation, and the recommended choice of a question (replacing `default`); your own database then comes from `--database` or the answers file, as without a terminal. A driver's toggle (SSL, an SSH tunnel) is a setting, not a confirmation, and keeps the driver's default |
@@ -255,7 +256,7 @@ rde init --license-token '$RDE_LICENSE_TOKEN' …
 }
 ```
 
-`"runtime"` takes `"kind": "docker"` or `"jar"`, which `"image"` and `"jar"` imply on their own (`"runtime": { "jar": "latest" }` runs the newest release with Java). `"license": { "token": null }` skips the license and `"git-sync": { "location": "skip" }` leaves the repository for later. `"sync-scope": { "export": false }` leaves the first export of the sync scope to you. `"databases"` lists at least one database: an empty list is refused, since `init` needs one; leave the section out to be asked at a terminal. A database is pasted as a `uri` or entered with `fields`, keyed by the driver's field names as the admin form shows them; a file field takes a path. Anything a `fields` entry leaves out is asked in the terminal, or named in the error without one. A field that engine does not ask with the others given, such as one behind the admin form's advanced options, is named in a warning and ignored.
+`"runtime"` takes `"kind": "docker"` or `"jar"`, which `"image"` and `"jar"` imply on their own (`"runtime": { "jar": "latest" }` runs the newest release with Java). `"license": { "token": null }` skips the license and `"git-sync": { "location": "skip" }` leaves the repository for later. `"sync-scope": { "export": false }` leaves the first export of the Library to you. `"databases"` lists at least one database: an empty list is refused, since `init` needs one; leave the section out to be asked at a terminal. A database is pasted as a `uri` or entered with `fields`, keyed by the driver's field names as the admin form shows them; a file field takes a path. Anything a `fields` entry leaves out is asked in the terminal, or named in the error without one. A field that engine does not ask with the others given, such as one behind the admin form's advanced options, is named in a warning and ignored.
 
 ### Recording a run
 
@@ -265,7 +266,7 @@ rde init --license-token '$RDE_LICENSE_TOKEN' …
 
 `rde upgrade` moves the instance to a newer Metabase without losing its application database. It makes sure the instance is running and reads the version it is on, fetches the target, and stops there with `Already on …` when the target is what the instance already runs. Otherwise it shows the running version, the target, and the backup path, asks once (`--yes` skips the question; without a terminal `--yes` is required), and then stops Metabase, copies the whole `data/` directory to `~/.rde/instances/default/backups/<timestamp>/`, switches the instance to the target, starts it, waits for health, and records the new version. Metabase migrates its application database forward on that first start.
 
-A move to another major version (65 to 66, say) is named before the backup with `This moves Metabase from 65 to 66`, ahead of the same question. A target that names no release shows its version only once it runs, and the plan says so: a major line (`:v1.66.x`) still names its major, so the move is named before the backup all the same, while `:latest` or a jar path names nothing, so the line comes after the start instead. Either way, once the new major runs, `rde upgrade` runs the skills step, because the data-app skills come from the release branch of the Metabase the instance runs; at a terminal it asks which agents get them like `rde init` does, and with `--yes` every agent found gets them.
+A move to another major version (65 to 66, say) is named before the backup with `This moves Metabase from 65 to 66`, ahead of the same question. A target that names no release shows its version only once it runs, and the plan says so: a major line (`:v1.66.x`) still names its major, so the move is named before the backup all the same, while `:latest` or a jar path names nothing, so the line comes after the start instead. Either way, once the new major runs, `rde upgrade` runs the skills step, which installs again every skill whose folder changed on its branch; at a terminal it asks which agents get them like `rde init` does, and with `--yes` every agent found gets them.
 
 For a Docker instance the target is an image ref (`--to <image ref>`; by default, for an image of `metabase/metabase-enterprise`, `metabase/metabase-enterprise-head`, or `metabase/metabase`, the major line of the newest release, found the way `init` finds it, whatever tag the instance ran before: `:latest`, an older major line, or the same line), the pulled image is compared by id with the one the container runs, and the container is removed and created again from the target with the same port and mount and the environment rde sets now. An image from any other repository (a registry of your own, an image you built) is pulled again under its own ref, and the plan says so. The default target follows the feed rules of [Metabase versions](#metabase-versions): a feed that lists no release of 65 or newer, or cannot be read, stops the upgrade before it starts Metabase or pulls anything. With `RDE_DEV=1` the default target is the instance's own image. When the target is the image already running, a container created under another ref of it (`:latest` that names the same image as the line, say) or one that keeps variables rde sets otherwise now (the staging store of development mode, say) is still created again from that image under the target's ref, with no backup since nothing migrates; `rde doctor` names a container with such variables, with `rde upgrade` as the fix. A build of master (`metabase/metabase-enterprise-head:latest`, the development image) reports a major ahead of every release, so `rde upgrade` refuses it as a downgrade; `rde doctor` names one outside development mode, and the way onto a release is `rde uninstall`, then `rde init`, while `RDE_DEV=1` keeps running it. For a jar instance the target is `latest` (the default, the newest release), a release tag, or a `.jar` path; a release is downloaded into `~/.rde/jars/` before the question, and the instance's `runtime.source` is switched to it.
 
@@ -294,7 +295,7 @@ With the local `content.git` remote, that repository lives in the instance direc
 ```sh
 rde uninstall                  # container or process, mb profile, ~/.rde/instances/default
 rde uninstall --keep-data      # container or process and profile only; the data and secrets.json stay, and `rde init` reinstalls from them
-rde uninstall --remove-skill   # also the rde and rde-data-apps skills from your coding agents
+rde uninstall --remove-skill   # also the metabase-rde and metabase-data-apps skills (and the older rde and rde-data-apps) from your coding agents
 rde uninstall --remove-image   # also the Docker images or the downloaded jar (otherwise they stay for the next init)
 rde uninstall --yes --force    # also deletes commits in content.git that your working directory has not pulled
 ```
@@ -308,7 +309,7 @@ Running it twice is a no-op. It also works with no `~/.rde` at all, so a leftove
 | Variable | What it does |
 | --- | --- |
 | `RDE_HOME` | Where rde keeps its state instead of `~/.rde`; a relative path is resolved against the working directory |
-| `RDE_SKILL_SOURCE` | Development only: where the `rde` and `rde-data-apps` skills are installed from instead of `metabase/agent-skills`, such as a local checkout, so they can be tried before they are pushed |
+| `RDE_SKILL_SOURCE` | Development only: the `metabase/agent-skills` branch or checkout the `metabase-rde` and `metabase-data-apps` skills are installed from (from its `skills/metabase-rde/v1` and `skills/metabase-data-apps/v1` folders) instead of the `main` branch: a GitHub URL that names a branch (`…/tree/<branch>`) or the root of a local checkout, so they can be tried before they are pushed |
 | `RDE_DEV` | Development only: `1` runs instances on the enterprise build of master and checks license tokens against the staging store; `bin/rde-dev` sets it |
 
 An empty value counts as unset.
@@ -372,9 +373,9 @@ Start Docker (or `colima start`), or install Java, and run `rde init` again. `rd
                    plain `mb` uses prod (MB_PROFILE): prod.acme.example
 ```
 
-**The agent follows an old copy of the skill.** The `rde skill copies` row lists every copy of the skill the `skills` CLI knows, global and in the current directory's project, with where it came from, and fails when one did not come from rde's source (the branch is read from the `skills` lock file; against a local `RDE_SKILL_SOURCE` the copy's `SKILL.md` is compared with the checkout's `skills/rde/SKILL.md`). With several copies it says which one Claude Code started in that directory loads (a personal skill wins over a project one). `rde init --only agents-skills` reinstalls the global copy; restart the agent session afterwards.
+**The agent follows an old copy of the skill.** The `metabase-rde skill copies` row lists every copy of the skill the `skills` CLI knows, global and in the current directory's project, with where it came from, and fails when one did not come from rde's source (the branch is read from the `skills` lock file; against a local `RDE_SKILL_SOURCE` the copy's `SKILL.md` is compared with the checkout's `skills/metabase-rde/v1/SKILL.md`), and also fails while a global copy of `rde` or `rde-data-apps`, which `metabase-rde` replaces, is still there. With several copies it says which one Claude Code started in that directory loads (a personal skill wins over a project one). `rde init --only agents-skills` reinstalls the global copy and removes the replaced ones; restart the agent session afterwards.
 
-**The data-app skills are for another Metabase version.** The `data-app skills` row names the branch of `metabase/metabase` the instance's Metabase version takes them from (`release-x.65.x` for 65, and so on) and fails when a data-app skill is missing or its copy came from another branch, or when `rde-data-apps` did not come from rde's source. The skills are global, so it happens when an instance on another major installed them last, or when the skills step was left out after `rde upgrade` moved to another major. `rde init --only agents-skills` (or `rde doctor --fix`) installs them for this instance's version; restart the agent session afterwards.
+**The agent follows the wrong data-app skill.** The `data-app skills` row fails when `metabase-data-apps` is missing or its copy did not come from rde's source (against a local `RDE_SKILL_SOURCE`, the checkout's `skills/metabase-data-apps/v1/SKILL.md`), or when a copy of an earlier per-task data-app skill (`metabase-data-app-setup` and the like) that the skills lock attributes to `metabase/metabase` is still there, whoever installed it. `rde init --only agents-skills` (or `rde doctor --fix`) installs the skills and removes the copies `metabase-data-apps` replaces; a copy also installed for an agent that has no `metabase-data-apps` after the run stays, and the run names the `--agents` that let it go. Restart the agent session afterwards.
 
 **The license token is rejected.** Metabase checks the token with `token-check.metabase.com` before it saves it. `The license token was refused: <reason>` means the store turned the token down: check that you pasted the whole token and that its subscription is active. `The instance could not reach token-check.metabase.com to check the license token` means the check never got an answer: the container (or the jar) needs outbound network access to that host. At a terminal the step asks for the token again, and Enter skips the license and carries on without remote sync, data apps, and transform tests; without a terminal the run stops, and `rde init --from license` tries again.
 

package/dist/cli.mjs

@@ -369,7 +369,7 @@ const StepRecord = z.object({
 	completedAt: z.string()
 });
 const InstanceState = z.object({
-	schemaVersion: z.literal(7),
+	schemaVersion: z.literal(8),
 	name: z.string(),
 	runtime: RuntimeState.nullable(),
 	url: z.string().nullable(),
@@ -380,7 +380,6 @@ const InstanceState = z.object({
 	databases: z.array(DatabaseRecord),
 	gitRemote: GitRemoteState.nullable(),
 	movedFrom: z.string().nullable(),
-	syncRoot: z.int().nullable(),
 	steps: z.partialRecord(StepId, StepRecord)
 });
 function configuredRuntime(state) {
@@ -410,7 +409,7 @@ function mbCommand(profile) {
 }
 function emptyInstanceState(name) {
 	return {
-		schemaVersion: 7,
+		schemaVersion: 8,
 		name,
 		runtime: null,
 		url: null,
@@ -421,7 +420,6 @@ function emptyInstanceState(name) {
 		databases: [],
 		gitRemote: null,
 		movedFrom: null,
-		syncRoot: null,
 		steps: {}
 	};
 }
@@ -434,6 +432,7 @@ const V3 = 3;
 const V4 = 4;
 const V5 = 5;
 const V6 = 6;
+const V7 = 7;
 const StateV1 = z.object({ schemaVersion: z.literal(V1) }).loose();
 const StateV2 = z.object({ schemaVersion: z.literal(V2) }).loose();
 const AdminV3 = z.discriminatedUnion("kind", [z.object({
@@ -450,6 +449,7 @@ const StateV5 = z.object({
 	steps: z.record(z.string(), z.unknown())
 }).loose();
 const StateV6 = z.object({ schemaVersion: z.literal(V6) }).loose();
+const StateV7 = z.object({ schemaVersion: z.literal(V7) }).loose();
 const StateV3 = z.object({
 	schemaVersion: z.literal(V3),
 	admin: AdminV3.nullable(),
@@ -487,8 +487,14 @@ function liftV5(raw) {
 function liftV6(raw) {
 	return {
 		...StateV6.parse(raw),
-		schemaVersion: 7,
-		syncRoot: null
+		schemaVersion: V7
+	};
+}
+function liftV7(raw) {
+	const { syncRoot: _syncRoot, ...state } = StateV7.parse(raw);
+	return {
+		...state,
+		schemaVersion: 8
 	};
 }
 function adminV4(admin) {
@@ -530,15 +536,16 @@ function migrateInstanceState(raw) {
 		case V3: return liftV3(raw);
 		case V4: return migrateInstanceState(liftV4(raw));
 		case V5: return migrateInstanceState(liftV5(raw));
-		case V6: return {
-			state: InstanceState.parse(liftV6(raw)),
+		case V6: return migrateInstanceState(liftV6(raw));
+		case V7: return {
+			state: InstanceState.parse(liftV7(raw)),
 			movedSecrets: null
 		};
-		case 7: return {
+		case 8: return {
 			state: InstanceState.parse(raw),
 			movedSecrets: null
 		};
-		default: throw new ConfigError(`state schemaVersion ${schemaVersion} is not supported by this build (expected 7)`);
+		default: throw new ConfigError(`state schemaVersion ${schemaVersion} is not supported by this build (expected 8)`);
 	}
 }
 //#endregion
@@ -714,6 +721,7 @@ async function requireInstanceState(name) {
 }
 const LOCK_SUFFIX = ".lock";
 const STALE_SUFFIX = ".stale";
+const PENDING_SUFFIX = ".pending";
 const LOCK_RETRY_MS = 25;
 const LOCK_WAIT_MS = 3e4;
 function lockToken() {
@@ -731,6 +739,15 @@ function isRunning(pid) {
 		return !hasCode(error, "ESRCH");
 	}
 }
+async function createLock(path, token) {
+	const pending = `${path}${PENDING_SUFFIX}.${token.replaceAll(" ", "-")}`;
+	await promises.writeFile(pending, token, { mode: 384 });
+	try {
+		await promises.link(pending, path);
+	} finally {
+		await promises.rm(pending, { force: true });
+	}
+}
 async function takeOverDeadLock(path, held) {
 	const aside = `${path}${STALE_SUFFIX}.${held.replaceAll(" ", "-")}`;
 	try {
@@ -755,10 +772,7 @@ async function acquireLock(name, signal) {
 	const deadline = Date.now() + LOCK_WAIT_MS;
 	for (;;) {
 		try {
-			await promises.writeFile(path, token, {
-				flag: "wx",
-				mode: 384
-			});
+			await createLock(path, token);
 			return token;
 		} catch (error) {
 			if (isFileNotFound$1(error)) await requireInstanceState(name);
@@ -2116,14 +2130,23 @@ async function whichCommand(name) {
 //#endregion
 //#region src/tools/agents.ts
 const AgentId = z.enum([
+	"opencode",
 	"claude-code",
 	"codex",
 	"cursor",
 	"gemini-cli",
-	"opencode",
 	"windsurf"
 ]);
 const AGENTS = [
+	{
+		id: "opencode",
+		displayName: "OpenCode",
+		skillsCliName: "opencode",
+		command: "opencode",
+		launch: "opencode",
+		readsSharedSkills: true,
+		configDir: (_home, configHome) => join(configHome, "opencode")
+	},
 	{
 		id: "claude-code",
 		displayName: "Claude Code",
@@ -2160,15 +2183,6 @@ const AGENTS = [
 		readsSharedSkills: true,
 		configDir: (home) => join(home, ".gemini")
 	},
-	{
-		id: "opencode",
-		displayName: "OpenCode",
-		skillsCliName: "opencode",
-		command: "opencode",
-		launch: "opencode",
-		readsSharedSkills: true,
-		configDir: (_home, configHome) => join(configHome, "opencode")
-	},
 	{
 		id: "windsurf",
 		displayName: "Windsurf",
@@ -2229,7 +2243,6 @@ const VERSION_INFO_PATH = "/version-info-ee.json";
 const JAR_FILE = "metabase.jar";
 const RELEASE_TAG$1 = /^v(?<edition>[01])\.(?<major>\d+)\.\d+(?:\.\d+)?(?:-[\w.]+)?$/;
 const MAJOR_LINE_TAG = /^v(?<edition>[01])\.(?<major>\d+)\.x$/;
-const FINAL_ENTERPRISE_RELEASE = /^v1\.\d+\.\d+(?:\.\d+)?$/;
 const ENTERPRISE_EDITION = "1";
 const OPEN_SOURCE_EDITION = "0";
 const SNAPSHOT_SUFFIX = "-SNAPSHOT";
@@ -2268,11 +2281,13 @@ function compareReleases(left, right) {
 	return 0;
 }
 function supportedRelease(version) {
-	if (!FINAL_ENTERPRISE_RELEASE.test(version)) return null;
-	const major = releaseMajor(version);
-	return major !== null && major >= 65 ? {
+	const groups = RELEASE_TAG$1.exec(version)?.groups;
+	const major = groups?.["major"];
+	if (groups?.["edition"] !== ENTERPRISE_EDITION || major === void 0) return null;
+	const number = Number.parseInt(major, 10);
+	return number >= 65 ? {
 		version,
-		major
+		major: number
 	} : null;
 }
 function newestSupportedRelease(versions) {
@@ -5722,6 +5737,14 @@ function gitTool(runner) {
 			"HEAD"
 		], { cwd: dir })).exitCode === 0;
 	}
+	async function gitPath(dir, name) {
+		const result = await git([
+			"rev-parse",
+			"--git-path",
+			name
+		], { cwd: dir });
+		return resolve(dir, result.stdout.trim());
+	}
 	async function hasIdentity(dir) {
 		const result = await runner.run(GIT, [
 			"config",
@@ -5839,6 +5862,7 @@ function gitTool(runner) {
 		initBare,
 		init,
 		hasCommits,
+		gitPath,
 		commitPaths,
 		addRemote,
 		clone,
@@ -6056,6 +6080,7 @@ const README_NAME = "README.md";
 const README_CONTENT = "# Metabase content\n\nMetabase content synced by rde.\n";
 const INITIAL_COMMIT_MESSAGE = "Initial commit";
 const GITIGNORE_NAME = ".gitignore";
+const EXCLUDE_GIT_PATH = "info/exclude";
 const IGNORED_PATHS = [
 	".env",
 	".env.local",
@@ -6076,10 +6101,7 @@ const TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set([
 	"timed-out",
 	"conflict"
 ]);
-const SYNC_MODE_SETTINGS = {
-	"remote-sync-type": "read-write",
-	"remote-sync-transforms": true
-};
+const SYNC_MODE_SETTINGS = { "remote-sync-type": "read-write" };
 function hostDeps$11(ctx) {
 	return {
 		runner: processRunner(ctx.signal),
@@ -6318,20 +6340,21 @@ function hostedScreen(run) {
 		}
 	};
 }
-async function ignoreDataAppFiles(workdir) {
-	const path = join(workdir, GITIGNORE_NAME);
+async function ignoreDataAppFiles(path) {
 	const existing = await readTextFile(path);
 	const present = new Set(existing === null ? [] : existing.split("\n").map((line) => line.trim()));
 	const missing = IGNORED_PATHS.filter((entry) => !present.has(entry));
 	if (missing.length === 0) return;
 	const separator = existing === null || existing.endsWith("\n") ? "" : "\n";
+	await promises.mkdir(dirname(path), { recursive: true });
 	await promises.appendFile(path, `${separator}${missing.join("\n")}\n`);
 }
 async function prepareWorkdir(run, workdir) {
 	if (!await run.git.isRepo(workdir)) await run.git.init(workdir, { branch: DEFAULT_BRANCH });
-	if (!await run.git.hasCommits(workdir)) {
+	if (await run.git.hasCommits(workdir)) await ignoreDataAppFiles(await run.git.gitPath(workdir, EXCLUDE_GIT_PATH));
+	else {
 		await promises.writeFile(join(workdir, README_NAME), README_CONTENT);
-		await ignoreDataAppFiles(workdir);
+		await ignoreDataAppFiles(join(workdir, GITIGNORE_NAME));
 		await run.git.commitPaths(workdir, [README_NAME, GITIGNORE_NAME], INITIAL_COMMIT_MESSAGE);
 	}
 	return {
@@ -6385,12 +6408,9 @@ async function cloneHosted(run, workdir, credentials) {
 		throw error;
 	}
 	spinner.stop(`Cloned into ${workdir}`);
-	if (await run.git.hasCommits(workdir)) return {
-		workdir,
-		branch: await run.git.currentBranch(workdir)
-	};
+	const hadCommits = await run.git.hasCommits(workdir);
 	const prepared = await prepareWorkdir(run, workdir);
-	await run.git.push(workdir, ORIGIN, prepared.branch, credentials);
+	if (!hadCommits) await run.git.push(workdir, ORIGIN, prepared.branch, credentials);
 	return prepared;
 }
 async function adoptRepository(run, workdir, url) {
@@ -6469,7 +6489,8 @@ function unfinishedImport(outcome) {
 }
 async function importExistingContent(run, gitRemote) {
 	if (!await remoteHasContent(run, gitRemote)) {
-		run.ctx.ui.info(`The repository holds no Metabase content yet; the first \`${exportCommand(run.ctx.state.mbProfile, gitRemote.branch)}\` populates it`);
+		await run.client.remoteSync.syncTransforms();
+		run.ctx.ui.info(`Nothing to import from the repository; \`${exportCommand(run.ctx.state.mbProfile, gitRemote.branch)}\` publishes this Metabase's content to it`);
 		return;
 	}
 	const spinner = run.ctx.ui.spinner("Importing the repository's content into Metabase…");
@@ -6607,16 +6628,18 @@ function githubContents(signal, options = {}) {
 //#region src/tools/skills-cli.ts
 const NPX = "npx";
 const SKILLS_PACKAGE = "skills@latest";
-const RDE_DATA_APPS_SKILL_NAME = "rde-data-apps";
-const RDE_SOURCE_SKILL_NAMES = ["rde", RDE_DATA_APPS_SKILL_NAME];
-const DATA_APP_REPOSITORY = "metabase/metabase";
-const DATA_APP_SKILL_NAMES = [
-	"metabase-data-app-setup",
-	"metabase-data-app-routing",
-	"metabase-data-app-actions",
-	"metabase-data-app-semantic-layer",
-	"metabase-data-app-migrate"
-];
+const LIST_INTERNAL_SKILLS = { INSTALL_INTERNAL_SKILLS: "1" };
+const DEFAULT_RDE_SKILL_SOURCE = "https://github.com/metabase/agent-skills/tree/main";
+const RDE_SKILL_NAME = "metabase-rde";
+const DATA_APPS_SKILL_NAME = "metabase-data-apps";
+const RDE_INSTALLED_SKILL_NAMES = [DATA_APPS_SKILL_NAME, RDE_SKILL_NAME];
+const REPLACED_RDE_SKILL_NAMES = ["rde", "rde-data-apps"];
+const RDE_OWNED_SKILL_NAMES = [...RDE_INSTALLED_SKILL_NAMES, ...REPLACED_RDE_SKILL_NAMES];
+const SKILL_VERSIONS = {
+	[DATA_APPS_SKILL_NAME]: 1,
+	[RDE_SKILL_NAME]: 1
+};
+const SOURCE_SKILLS_DIR = "skills";
 function rdeSkillSource() {
 	return readSetEnv("RDE_SKILL_SOURCE") ?? "https://github.com/metabase/agent-skills/tree/main";
 }
@@ -6656,16 +6679,6 @@ const hostSkillFiles = {
 	readJson: readJsonFile,
 	readText: readTextFile
 };
-function dataAppSkillsSource(ref) {
-	return `${DATA_APP_REPOSITORY}/skills#${ref}`;
-}
-function dataAppSkillsOrigin(ref) {
-	return {
-		kind: "github",
-		repository: DATA_APP_REPOSITORY,
-		ref
-	};
-}
 const GITHUB_URL = /^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/tree\/([^/]+)(?:\/.*)?)?\/?$/;
 function skillOrigin(source, cwd) {
 	const github = GITHUB_URL.exec(source);
@@ -6686,6 +6699,23 @@ function skillOrigin(source, cwd) {
 		source
 	};
 }
+function sourceSkillDirectory(skill) {
+	return posix.join(SOURCE_SKILLS_DIR, skill, `v${SKILL_VERSIONS[skill]}`);
+}
+function skillSource(rdeSource, skill, cwd) {
+	const directory = sourceSkillDirectory(skill);
+	const origin = skillOrigin(rdeSource, cwd);
+	switch (origin.kind) {
+		case "github":
+			if (origin.ref === null) throw new ConfigError(`RDE_SKILL_SOURCE must name a branch: https://github.com/${origin.repository}/tree/<branch>`);
+			return `https://github.com/${origin.repository}/tree/${origin.ref}/${directory}`;
+		case "local": return join(origin.path, directory);
+		case "other": {
+			const [path, ref] = origin.source.split("#", 2);
+			return ref === void 0 ? `${path}/${directory}` : `${path}/${directory}#${ref}`;
+		}
+	}
+}
 function skillsCli(runner) {
 	async function add(options) {
 		const argv = [
@@ -6719,7 +6749,10 @@ function skillsCli(runner) {
 			"-g",
 			"--json"
 		];
-		const result = await runner.run(NPX, argv, { stdoutToFile: true });
+		const result = await runner.run(NPX, argv, {
+			stdoutToFile: true,
+			addedEnv: LIST_INTERNAL_SKILLS
+		});
 		if (result.exitCode !== 0) throw toolFailure(NPX, argv, result);
 		return parseJsonOutput(NPX, argv, result.stdout, InstalledSkillList);
 	}
@@ -6732,7 +6765,8 @@ function skillsCli(runner) {
 		];
 		const result = await runner.run(NPX, argv, {
 			cwd,
-			stdoutToFile: true
+			stdoutToFile: true,
+			addedEnv: LIST_INTERNAL_SKILLS
 		});
 		if (result.exitCode !== 0) throw toolFailure(NPX, argv, result);
 		return parseJsonOutput(NPX, argv, result.stdout, InstalledSkillList);
@@ -6749,7 +6783,23 @@ function skillsCli(runner) {
 const STEP_ID$5 = "agents-skills";
 const AGENTS_SKILLS_KEYS = { agents: `${STEP_ID$5}.agents` };
 const MECHANICS_NOTE = "The rde skill's mechanics come from `mb skills get <name>` at runtime, so nothing else needs installing.";
-const REQUIRED_SKILL_NAMES = [...DATA_APP_SKILL_NAMES, ...RDE_SOURCE_SKILL_NAMES];
+const REQUIRED_SKILL_NAMES = RDE_INSTALLED_SKILL_NAMES;
+const LEGACY_DATA_APP_REPOSITORY = "metabase/metabase";
+const LEGACY_DATA_APP_SKILL_NAMES = [
+	"metabase-data-app-setup",
+	"metabase-data-app-routing",
+	"metabase-data-app-actions",
+	"metabase-data-app-semantic-layer",
+	"metabase-data-app-migrate"
+];
+const REPLACED_RDE_NAMES = REPLACED_RDE_SKILL_NAMES;
+const REPLACEMENTS = [{
+	by: DATA_APPS_SKILL_NAME,
+	names: LEGACY_DATA_APP_SKILL_NAMES
+}, {
+	by: RDE_SKILL_NAME,
+	names: REPLACED_RDE_NAMES
+}];
 const DETECT_AGENTS = { kind: "detected" };
 const ASK_AGENTS = { kind: "ask" };
 function hostDeps$10(ctx) {
@@ -6792,34 +6842,17 @@ function coveredAgentNames(entry, agents) {
 function installedLines(entries, agents) {
 	return entries.map((entry) => `${entry.name} (${coveredAgentNames(entry, agents).join(", ")}): ${entry.path}`).join("\n");
 }
-const DEVELOPMENT_BRANCH = "master";
-function releaseBranch(major) {
-	return `release-x.${major}.x`;
-}
-function dataAppSkillsRef(metabaseVersion, development) {
-	if (metabaseVersion === null) return releaseBranch(65);
-	if (development && isMasterBuild(metabaseVersion)) return DEVELOPMENT_BRANCH;
-	const major = releaseMajor(metabaseVersion) ?? 65;
-	return releaseBranch(Math.max(major, 65));
-}
-function wantedDataAppRef(metabaseVersion) {
-	return dataAppSkillsRef(metabaseVersion, developmentMode());
-}
-function skillSets(deps, metabaseVersion) {
-	const dataAppRef = wantedDataAppRef(metabaseVersion);
-	return [{
-		label: "data-app",
-		source: dataAppSkillsSource(dataAppRef),
-		sourceNote: ` from ${dataAppRef}`,
-		origin: dataAppSkillsOrigin(dataAppRef),
-		skills: DATA_APP_SKILL_NAMES
-	}, {
-		label: "rde",
-		source: deps.skillSource,
-		sourceNote: deps.skillSource === "https://github.com/metabase/agent-skills/tree/main" ? "" : ` from ${deps.skillSource}`,
-		origin: skillOrigin(deps.skillSource, deps.cwd),
-		skills: RDE_SOURCE_SKILL_NAMES
-	}];
+function skillInstalls(deps) {
+	const defaultSource = deps.skillSource === DEFAULT_RDE_SKILL_SOURCE;
+	return RDE_INSTALLED_SKILL_NAMES.map((skill) => {
+		const source = skillSource(deps.skillSource, skill, deps.cwd);
+		return {
+			skill,
+			source,
+			sourceNote: ` from ${defaultSource ? sourceSkillDirectory(skill) : source}`,
+			origin: skillOrigin(source, deps.cwd)
+		};
+	});
 }
 function hashLookup(github) {
 	const asked = /* @__PURE__ */ new Map();
@@ -6844,7 +6877,8 @@ async function readLockedSkills(deps) {
 	const lockPath = globalSkillLockPath(deps.probe.home, deps.stateHome);
 	try {
 		const lock = await deps.files.readJson(lockPath);
-		return new Map(REQUIRED_SKILL_NAMES.map((name) => [name, lockedSkill(lockPath, lock, name)]));
+		const names = [...REQUIRED_SKILL_NAMES, ...LEGACY_DATA_APP_SKILL_NAMES];
+		return new Map(names.map((name) => [name, lockedSkill(lockPath, lock, name)]));
 	} catch (error) {
 		if (error instanceof ConfigError) return null;
 		throw error;
@@ -6864,25 +6898,54 @@ function lockedCopy(locked, origin) {
 		hash: locked.skillFolderHash
 	};
 }
-async function setBehind(set, check) {
-	const { origin } = set;
+async function installBehind(install, check) {
+	const { origin } = install;
 	if (origin.kind !== "github" || check.locked === null) return true;
-	const copies = [];
-	for (const skill of set.skills) {
-		const copy = lockedCopy(check.locked.get(skill) ?? null, origin);
-		if (copy === null) return true;
-		copies.push(copy);
-	}
+	const copy = lockedCopy(check.locked.get(install.skill) ?? null, origin);
+	if (copy === null) return true;
 	if (check.updates === "installed") return false;
-	for (const copy of copies) {
-		const current = await check.hashes(origin.repository, copy.ref, copy.directory);
-		if (current !== null && current.get(copy.folder) !== copy.hash) return true;
+	const current = await check.hashes(origin.repository, copy.ref, copy.directory);
+	return current !== null && current.get(copy.folder) !== copy.hash;
+}
+function isLegacyDataAppCopy(name, source) {
+	return LEGACY_DATA_APP_SKILL_NAMES.includes(name) && source === LEGACY_DATA_APP_REPOSITORY;
+}
+function isReplacedRdeCopy(name) {
+	return REPLACED_RDE_NAMES.includes(name);
+}
+function replacedCopies(installed, locked) {
+	const found = /* @__PURE__ */ new Map();
+	for (const { by, names } of REPLACEMENTS) {
+		const present = names.filter((name) => by === "metabase-data-apps" ? isLegacyDataAppCopy(name, locked?.get(name)?.source) : installed.some((entry) => entry.name === name));
+		if (present.length > 0) found.set(by, present);
 	}
-	return false;
+	return found;
 }
 function hasSkill(installed, skill, agent) {
 	return installed.some((entry) => entry.name === skill && skillCoversAgent(entry, agent));
 }
+function splitReplaced(by, replaced, installed, all) {
+	const split = {
+		removable: [],
+		kept: [],
+		uncovered: []
+	};
+	for (const name of replaced) {
+		const copies = installed.filter((entry) => entry.name === name);
+		const uncovered = all.filter((agent) => copies.some((entry) => skillCoversAgent(entry, agent)) && !hasSkill(installed, by, agent));
+		if (uncovered.length === 0) {
+			split.removable.push(name);
+			continue;
+		}
+		split.kept.push(name);
+		for (const agent of uncovered) if (!split.uncovered.includes(agent)) split.uncovered.push(agent);
+	}
+	return split;
+}
+function keptReplacedLine(by, split) {
+	const ids = split.uncovered.map((agent) => agent.id).join(",");
+	return `${by} is not installed for ${displayNames(split.uncovered)}, so rde keeps ${split.kept.join(", ")}; \`rde init --only ${STEP_ID$5} --agents ${ids}\` installs it there and removes what it replaces`;
+}
 function coversAll(installed, skills, agents) {
 	return agents.every((agent) => skills.every((skill) => hasSkill(installed, skill, agent)));
 }
@@ -6948,7 +7011,7 @@ function skipLine(all, source) {
 }
 function agentsSkillsStep(options, updates, deps = hostDeps$10) {
 	let hashes = null;
-	async function setCheck(resolved) {
+	async function installCheck(resolved) {
 		hashes ??= hashLookup(resolved.github);
 		return {
 			updates,
@@ -6964,9 +7027,11 @@ function agentsSkillsStep(options, updates, deps = hostDeps$10) {
 			const resolved = deps(ctx);
 			const detected = detectedOnly(await detectAgents(resolved.probe));
 			if (detected.length === 0) return ctx.state.steps[STEP_ID$5]?.status === "skipped" ? "not-applicable" : "todo";
-			if (missingSkills(await skillsCli(resolved.runner).list(), detected).length > 0) return "todo";
-			const check = await setCheck(resolved);
-			for (const set of skillSets(resolved, ctx.state.version)) if (await setBehind(set, check)) return "outdated";
+			const installed = await skillsCli(resolved.runner).list();
+			if (missingSkills(installed, detected).length > 0) return "todo";
+			const check = await installCheck(resolved);
+			if (replacedCopies(installed, check.locked).size > 0) return "outdated";
+			for (const install of skillInstalls(resolved)) if (await installBehind(install, check)) return "outdated";
 			return "done";
 		},
 		async run(ctx) {
@@ -6981,28 +7046,37 @@ function agentsSkillsStep(options, updates, deps = hostDeps$10) {
 				return { outcome: "skipped" };
 			}
 			const before = await installedNow();
-			const check = await setCheck(resolved);
+			const check = await installCheck(resolved);
 			const pending = [];
-			for (const set of skillSets(resolved, ctx.state.version)) if (!coversAll(before, set.skills, selection.agents) || await setBehind(set, check)) pending.push(set);
+			for (const install of skillInstalls(resolved)) if (!coversAll(before, [install.skill], selection.agents) || await installBehind(install, check)) pending.push(install);
+			const replaced = replacedCopies(before, check.locked);
 			const names = displayNames(selection.agents);
-			if (pending.length === 0) {
+			if (pending.length === 0 && replaced.size === 0) {
 				ctx.ui.success(`The rde and data-app skills are current for ${names}`);
 				return { outcome: "completed" };
 			}
 			const agents = selection.agents.map((agent) => agent.skillsCliName);
 			const forWhom = `for ${names} (${SOURCE_NOTES[selection.source]})`;
-			for (const set of pending) {
-				ctx.ui.info(`Installing the ${set.label} skills ${forWhom}${set.sourceNote}`);
+			for (const install of pending) {
+				ctx.ui.info(`Installing ${install.skill} ${forWhom}${install.sourceNote}`);
 				await skills.add({
-					source: set.source,
-					skills: set.skills,
+					source: install.source,
+					skills: [install.skill],
 					agents,
 					output: ctx.ui.childOutput
 				});
 			}
-			const installed = await skills.list();
+			const installed = pending.length === 0 ? before : await skills.list();
 			const missing = unlistedSkills(installed);
 			if (missing.length > 0) throw new ConfigError(`the skills installer finished but \`skills list\` does not show ${missing.join(", ")}`);
+			for (const [by, old] of replaced) {
+				const split = splitReplaced(by, old, installed, all);
+				if (split.removable.length > 0) {
+					ctx.ui.info(`Removing ${split.removable.join(", ")}, which ${by} replaces`);
+					await skills.remove(split.removable, ctx.ui.childOutput);
+				}
+				if (split.kept.length > 0) ctx.ui.warn(keptReplacedLine(by, split));
+			}
 			ctx.ui.note(installedLines(requiredEntries(installed), selection.agents), "Skills installed");
 			ctx.ui.info(MECHANICS_NOTE);
 			return { outcome: "completed" };
@@ -7190,7 +7264,7 @@ function npmRegistry(signal, options = {}) {
 //#endregion
 //#region src/steps/install-mb.ts
 const STEP_ID$4 = "install-mb";
-const MIN_MB_VERSION = "0.3.0";
+const MIN_MB_VERSION = "0.5.1";
 const MB_RANGE = `>=${MIN_MB_VERSION}`;
 function installedWith(scriptPath) {
 	return scriptPath === void 0 ? "npm" : packageManagerFor(scriptPath);
@@ -7918,10 +7992,8 @@ function startMetabaseStep(deps = hostDeps$5, accepted = "supported") {
 //#region src/steps/sync-scope.ts
 const STEP_ID$2 = "sync-scope";
 const SYNC_SCOPE_KEYS = { export: `${STEP_ID$2}.export` };
-const AGENT_COLLECTION_NAME = "Analytics";
 const LIBRARY_NAME = "Library";
 const ROOT_COLLECTION_NAME = "Our analytics";
-const AGENT_COLLECTION_DESCRIPTION = "Dashboards, questions, models, and documents that reach git on export.";
 function hostDeps$4(ctx) {
 	return {
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
@@ -7932,22 +8004,11 @@ function hostDeps$4(ctx) {
 function isCollection(entry) {
 	return typeof entry.id === "number";
 }
-function isOrdinary(collection) {
-	return collection.type === null && collection.namespace === null && collection.personal_owner_id === null;
-}
-function readScope(list, syncRoot) {
-	const topLevel = list.filter(isCollection).filter((collection) => collection.location === "/");
-	const ordinary = topLevel.filter(isOrdinary);
-	const unsynced = ordinary.filter((collection) => !collection.is_remote_synced);
-	return {
-		library: topLevel.find((collection) => collection.type === "library") ?? null,
-		syncedRoots: ordinary.filter((collection) => collection.is_remote_synced),
-		unsyncedRecordedRoot: unsynced.find((collection) => collection.id === syncRoot) ?? null,
-		foreignNamesake: unsynced.some((collection) => collection.id !== syncRoot && collection.name === "Analytics")
-	};
+function findLibrary(list) {
+	return list.filter(isCollection).find((collection) => collection.location === "/" && collection.type === "library") ?? null;
 }
-function isComplete(scope, libraryLicensed) {
-	return (!libraryLicensed || scope.library !== null && scope.library.is_remote_synced) && scope.syncedRoots.length > 0;
+function isComplete(library, libraryLicensed) {
+	return !libraryLicensed || library !== null && library.is_remote_synced;
 }
 function isNotAnsweringYet(error) {
 	return error instanceof MetabaseUnreachableError || error instanceof MetabaseInitializingError || isRejectedCredential(error);
@@ -7976,34 +8037,8 @@ async function isReadOnly(client) {
 async function requireReadWrite(client) {
 	if (await isReadOnly(client)) throw new ConfigError(`remote sync is read-only; the repository decides what syncs. Switch it to read-write in Admin, then \`rde init --only ${STEP_ID$2}\``);
 }
-async function ensureLibrary(client, scope, libraryLicensed) {
-	if (!libraryLicensed) return null;
-	return scope.library ?? client.collection.createLibrary();
-}
-async function ensureRoots(ctx, client, scope) {
-	if (scope.syncedRoots.length > 0) return {
-		roots: scope.syncedRoots,
-		created: false,
-		besideNamesake: false
-	};
-	if (scope.unsyncedRecordedRoot !== null) return {
-		roots: [scope.unsyncedRecordedRoot],
-		created: false,
-		besideNamesake: false
-	};
-	const created = await client.collection.create({
-		name: AGENT_COLLECTION_NAME,
-		description: AGENT_COLLECTION_DESCRIPTION
-	});
-	await ctx.saveState({
-		...ctx.state,
-		syncRoot: created.id
-	});
-	return {
-		roots: [created],
-		created: true,
-		besideNamesake: scope.foreignNamesake
-	};
+async function ensureLibrary(client, library) {
+	return library ?? client.collection.createLibrary();
 }
 function itemLabel(item) {
 	return item.name === null ? `${item.model} ${item.id}` : `${item.model} ${item.id} "${item.name}"`;
@@ -8040,21 +8075,12 @@ function explainRefusal(error) {
 	if (!refusal.success) return error;
 	return new ConfigError([...refusal.data.errors.required.flatMap(requiredSyncLines), `After the fix, run \`rde init --only ${STEP_ID$2}\`.`].join("\n"));
 }
-function plannedNames(scope, libraryLicensed) {
-	const library = libraryLicensed ? [scope.library?.name ?? LIBRARY_NAME] : [];
-	if (scope.syncedRoots.length > 0) return [...library, ...scope.syncedRoots.map((collection) => collection.name)];
-	return [...library, scope.unsyncedRecordedRoot?.name ?? "Analytics"];
-}
-function nameList(names) {
-	if (names.length <= 2) return names.join(" and ");
-	return `${names.slice(0, -1).join(", ")}, and ${names.at(-1)}`;
-}
 function exportAdvice(profile, branch, changes) {
 	const command = exportCommand(profile, branch);
 	if (!remoteMoved(changes)) return `\`${command}\``;
 	return `the branch has commits Metabase has not imported; \`${mbCommand(profile)} git-sync export-preflight\`, then \`${command} --merge\``;
 }
-async function planExport(ctx, runner, instance, names) {
+async function planExport(ctx, runner, instance, name) {
 	const changes = await mbTool(runner).gitSyncHasRemoteChanges(instance);
 	if (remoteMoved(changes)) return {
 		changes,
@@ -8064,7 +8090,7 @@ async function planExport(ctx, runner, instance, names) {
 		changes,
 		push: await ctx.prompts.confirm({
 			key: SYNC_SCOPE_KEYS.export,
-			message: `Push ${nameList(names)} to ${requireGitRemote(ctx).branch} now?`,
+			message: `Push ${name} to ${requireGitRemote(ctx).branch} now?`,
 			initialValue: true
 		})
 	};
@@ -8079,7 +8105,7 @@ function reportPending(run) {
 }
 async function exportScope(run, runner) {
 	const mb = mbTool(runner);
-	const label = nameList(run.names);
+	const label = run.name;
 	const spinner = run.ctx.ui.spinner(`Pushing ${label} to ${run.gitRemote.branch}…`);
 	try {
 		const final = (await mb.gitSyncExport(run.instance, {
@@ -8100,9 +8126,6 @@ async function exportScope(run, runner) {
 		reportPending(run);
 	}
 }
-function scopeLabel(synced) {
-	return `Synced to git: ${synced.map((collection) => collection.name).join(", ")}`;
-}
 function syncScopeStep(deps = hostDeps$4) {
 	return {
 		id: STEP_ID$2,
@@ -8118,7 +8141,7 @@ function syncScopeStep(deps = hostDeps$4) {
 				key: ctx.secrets.apiKey
 			});
 			try {
-				if (isComplete(readScope(await client.collection.list(), ctx.state.syncRoot), hasLibrary(ctx.state.license))) return "done";
+				if (isComplete(findLibrary(await client.collection.list()), hasLibrary(ctx.state.license))) return "done";
 				return await isReadOnly(client) ? "not-applicable" : "todo";
 			} catch (error) {
 				if (isNotAnsweringYet(error)) return "todo";
@@ -8137,30 +8160,27 @@ function syncScopeStep(deps = hostDeps$4) {
 			await requireReadWrite(client);
 			await requireSettledImport(ctx, client, gitRemote);
 			const libraryLicensed = hasLibrary(ctx.state.license);
-			const scope = readScope(await client.collection.list(), ctx.state.syncRoot);
-			const names = plannedNames(scope, libraryLicensed);
-			const plan = isComplete(scope, libraryLicensed) ? null : await planExport(ctx, resolved.runner, instance, names);
+			const found = findLibrary(await client.collection.list());
+			if (isComplete(found, libraryLicensed)) {
+				ctx.ui.info(libraryLicensed ? `Synced to git: ${found?.name ?? LIBRARY_NAME}` : "The license has no Library, so there is nothing to mark for sync");
+				return { outcome: "completed" };
+			}
+			const name = found?.name ?? LIBRARY_NAME;
+			const plan = await planExport(ctx, resolved.runner, instance, name);
 			const spinner = ctx.ui.spinner("Choosing what syncs to git…");
-			let synced;
-			let chosen;
 			try {
-				const library = await ensureLibrary(client, scope, libraryLicensed);
-				chosen = await ensureRoots(ctx, client, scope);
-				synced = library === null ? chosen.roots : [library, ...chosen.roots];
-				await client.remoteSync.updateScope({ collections: Object.fromEntries(synced.map((collection) => [collection.id, true])) });
+				const library = await ensureLibrary(client, found);
+				await client.remoteSync.updateScope({ collections: { [library.id]: true } });
 			} catch (error) {
 				spinner.fail("Could not choose what syncs to git");
 				throw explainRefusal(error);
 			}
-			spinner.stop(scopeLabel(synced));
-			if (chosen.created) ctx.ui.info(`Created the ${AGENT_COLLECTION_NAME} collection: dashboards, questions, models, and documents filed under it reach git on the next export`);
-			if (chosen.besideNamesake) ctx.ui.info(`Another collection is also named ${AGENT_COLLECTION_NAME}; rde did not create it, so it stays out of git`);
-			if (plan === null) return { outcome: "completed" };
+			spinner.stop(`Synced to git: ${name}`);
 			const exportRun = {
 				ctx,
 				instance,
 				gitRemote,
-				names,
+				name,
 				changes: plan.changes
 			};
 			if (plan.push) await exportScope(exportRun, resolved.runner);
@@ -8247,10 +8267,11 @@ async function pendingExportLines(state, secrets, runner) {
 		throw error;
 	}
 }
-function skillLine(entries, detected) {
+function skillLine(entries, detected, skipped) {
 	const agents = [...new Set(entries.flatMap((entry) => coveredAgentNames(entry, detected)))];
-	if (agents.length === 0) return `rde skill: not installed; \`rde init --only agents-skills\``;
-	return `rde skill: installed for ${agents.join(", ")}`;
+	if (agents.length === 0) return `${RDE_SKILL_NAME} skill: not installed; \`rde init --only agents-skills\``;
+	if (skipped) return `${RDE_SKILL_NAME} skill: skipped by this run; an earlier install covers ${agents.join(", ")}`;
+	return `${RDE_SKILL_NAME} skill: installed for ${agents.join(", ")}`;
 }
 function launchLines(agents, workdir) {
 	const detected = agents.filter((agent) => agent.detected);
@@ -8270,7 +8291,7 @@ async function summaryLines(state, secrets, deps) {
 	const installed = await skillsCli(deps.runner).list();
 	const agents = await detectAgents(deps.probe);
 	const detected = agents.filter((agent) => agent.detected);
-	lines.push(skillLine(installed.filter((entry) => entry.name === "rde"), detected));
+	lines.push(skillLine(installed.filter((entry) => entry.name === RDE_SKILL_NAME), detected, state.steps["agents-skills"]?.status === "skipped"));
 	lines.push(...launchLines(agents, state.gitRemote?.workdir ?? null));
 	lines.push("Lifecycle: rde status (--json for scripts), rde stop, rde start");
 	return lines;
@@ -8714,6 +8735,18 @@ function parseDatabase(spec) {
 		uri
 	};
 }
+function databasesSection(flags) {
+	if (flags.databaseName.length > flags.database.length) throw new ConfigError("--database-name names a --database; give one --database for each name");
+	if (flags.database.length === 0) return;
+	return flags.database.map((spec, index) => {
+		const name = flags.databaseName[index];
+		if (name !== void 0 && name.trim().length === 0) throw new ConfigError("--database-name needs a display name");
+		return {
+			...parseDatabase(spec),
+			...name !== void 0 && { name }
+		};
+	});
+}
 function adminSection(flags, secrets) {
 	const prompted = flags.adminEmail !== void 0 || secrets.has("--admin-password");
 	if (flags.admin === void 0 && !prompted) return;
@@ -8851,7 +8884,7 @@ async function answersFromFlags(flags, readStdin) {
 		runtime: runtimeSection(flags),
 		"admin-user": adminSection(flags, secrets),
 		license: licenseSection(flags, secrets),
-		databases: flags.database.length > 0 ? flags.database.map(parseDatabase) : void 0,
+		databases: databasesSection(flags),
 		"git-sync": gitSection(flags, secrets),
 		"agents-skills": agentsSection(flags),
 		"api-key": flags.mbProfile === void 0 ? void 0 : { profile: flags.mbProfile }
@@ -8908,6 +8941,11 @@ function givenFlags(flags) {
 			flag: "--database",
 			given: flags.database.length > 0
 		},
+		{
+			step: "databases",
+			flag: "--database-name",
+			given: flags.databaseName.length > 0
+		},
 		{
 			step: "git-sync",
 			flag: "--git-dir",
@@ -9336,7 +9374,7 @@ const db = defineCommand({
 //#endregion
 //#region package.json
 var name = "@metabase/rde";
-var version = "0.1.18";
+var version = "0.5.1";
 var description = "Prepares a local machine for data-engineering work with Metabase and coding agents";
 //#endregion
 //#region src/version.ts
@@ -10050,8 +10088,8 @@ async function gitSyncRow(state, instance, deps) {
 const SKILL_STEP = "agents-skills";
 const GLOBAL_SCOPE = "global";
 const SKILL_FILE = "SKILL.md";
-const SOURCE_SKILLS_DIR = "skills";
 const CLAUDE_CODE = "Claude Code";
+const COPIES_LABEL = `${RDE_SKILL_NAME} skill copies`;
 const CLAUDE_CODE_SKILL_RULE = "a personal skill wins over a project one: https://code.claude.com/docs/en/skills";
 function skillRowId(agent) {
 	return `skill.${agent.id}`;
@@ -10063,12 +10101,12 @@ async function copyRef(entry, deps) {
 	const path = entry.scope === GLOBAL_SCOPE ? globalSkillLockPath(deps.probe.home, deps.skills.stateHome) : projectSkillLockPath(deps.skills.cwd);
 	return lockedSkill(path, await deps.skills.files.readJson(path), entry.name)?.ref ?? null;
 }
-async function judgeCopy(entry, origin, deps) {
+async function judgeCopy(skill, entry, origin, deps) {
 	const where = `${entry.scope} ${entry.path}`;
 	switch (origin.kind) {
 		case "local": {
 			const installed = await deps.skills.files.readText(join(entry.path, SKILL_FILE));
-			const wanted = await deps.skills.files.readText(join(origin.path, SOURCE_SKILLS_DIR, entry.name, SKILL_FILE));
+			const wanted = await deps.skills.files.readText(join(origin.path, sourceSkillDirectory(skill), SKILL_FILE));
 			const current = installed !== null && installed === wanted;
 			return {
 				entry,
@@ -10109,80 +10147,80 @@ function loadedCopyLine(entries, cwd) {
 	if (loaded === void 0) return count;
 	return `${count}; ${CLAUDE_CODE} started in ${cwd} loads ${loaded.path} (${CLAUDE_CODE_SKILL_RULE})`;
 }
-function staleCopiesRow(stale, detail, deps) {
+function staleCopiesRow(stale, replaced, detail, deps) {
 	const globalStale = stale.some((copy) => copy.entry.scope === GLOBAL_SCOPE);
 	const projectStale = stale.some((copy) => copy.entry.scope !== GLOBAL_SCOPE);
 	const repairs = [];
-	if (globalStale) repairs.push(`\`rde init --only ${SKILL_STEP}\` reinstalls the global copy from ${deps.skills.source}`);
-	if (projectStale) repairs.push(`remove the project copy with \`npx -y skills@latest remove rde -y\` in ${deps.skills.cwd}`);
-	return failed("skill-copies", "rde skill copies", {
+	const stepFixes = [];
+	if (globalStale) stepFixes.push(`reinstalls the global copy from ${deps.skills.source}`);
+	if (replaced) stepFixes.push(`removes the copies ${RDE_SKILL_NAME} replaces`);
+	if (stepFixes.length > 0) repairs.push(`\`rde init --only ${SKILL_STEP}\` ${stepFixes.join(" and ")}`);
+	if (projectStale) repairs.push(`remove the project copy with \`npx -y skills@latest remove ${RDE_SKILL_NAME} -y\` in ${deps.skills.cwd}`);
+	return failed("skill-copies", COPIES_LABEL, {
 		detail,
 		hint: `${repairs.join("; ")}; then restart the agent session`,
-		step: globalStale ? SKILL_STEP : null
+		step: stepFixes.length > 0 ? SKILL_STEP : null
 	});
 }
-async function skillCopiesRow(globalEntries, deps) {
+async function skillCopiesRow(globalEntries, replaced, deps) {
 	const id = "skill-copies";
-	const label = "rde skill copies";
+	const label = COPIES_LABEL;
 	const cwd = deps.skills.cwd;
-	const projectEntries = cwd === deps.probe.home ? [] : (await skillsCli(deps.runner).listProject(cwd)).filter((entry) => entry.name === "rde");
+	const projectEntries = cwd === deps.probe.home ? [] : (await skillsCli(deps.runner).listProject(cwd)).filter((entry) => entry.name === RDE_SKILL_NAME);
 	const entries = [...globalEntries, ...projectEntries];
-	if (entries.length === 0) return skipped(id, label, "no copy installed");
+	if (entries.length === 0 && replaced.length === 0) return skipped(id, label, "no copy installed");
 	const origin = skillOrigin(deps.skills.source, cwd);
 	const judged = [];
-	for (const entry of entries) judged.push(await judgeCopy(entry, origin, deps));
+	for (const entry of entries) judged.push(await judgeCopy(RDE_SKILL_NAME, entry, origin, deps));
 	const loaded = loadedCopyLine(entries, cwd);
-	const lines = judged.map((copy) => copy.line);
+	const lines = [...judged.map((copy) => copy.line), ...replaced.map((entry) => `${entry.scope} ${entry.path}: replaced by ${RDE_SKILL_NAME}`)];
 	const detail = (loaded === null ? lines : [...lines, loaded]).join("\n");
 	const stale = judged.filter((copy) => !copy.current);
-	return stale.length === 0 ? ok(id, label, detail) : staleCopiesRow(stale, detail, deps);
+	if (stale.length === 0 && replaced.length === 0) return ok(id, label, detail);
+	return staleCopiesRow(stale, replaced.length > 0, detail, deps);
 }
-function dataAppBranchLine(version, origin) {
-	const wanted = withRef(origin.repository, origin.ref);
-	return version === null ? `Metabase has not reported its version yet; rde installs them from ${wanted}` : `Metabase ${version} takes them from ${wanted}`;
+function dataAppSkillsFix({ current, legacy }) {
+	const command = `\`rde init --only ${SKILL_STEP}\``;
+	const removal = `the copies ${DATA_APPS_SKILL_NAME} replaces`;
+	if (!legacy) return `${command} installs it`;
+	return current ? `${command} removes ${removal}` : `${command} installs it and removes ${removal}`;
 }
-async function dataAppSkillsRow(state, installed, deps) {
+async function dataAppSkillsRow(installed, deps) {
 	const id = "data-app-skills";
 	const label = "data-app skills";
-	const branch = dataAppSkillsOrigin(wantedDataAppRef(state.version));
-	const wanted = [...DATA_APP_SKILL_NAMES.map((name) => ({
-		name,
-		origin: branch
-	})), {
-		name: RDE_DATA_APPS_SKILL_NAME,
-		origin: skillOrigin(deps.skills.source, deps.skills.cwd)
-	}];
-	const lines = [dataAppBranchLine(state.version, branch)];
-	let current = true;
-	for (const skill of wanted) {
-		const entry = installed.find((candidate) => candidate.name === skill.name);
-		if (entry === void 0) {
-			lines.push(`${skill.name}: not installed`);
-			current = false;
-			continue;
-		}
-		const judged = await judgeCopy(entry, skill.origin, deps);
+	const origin = skillOrigin(deps.skills.source, deps.skills.cwd);
+	const lines = [];
+	const copy = installed.find((candidate) => candidate.name === DATA_APPS_SKILL_NAME);
+	let current = false;
+	if (copy === void 0) lines.push(`${DATA_APPS_SKILL_NAME}: not installed`);
+	else {
+		const judged = await judgeCopy(DATA_APPS_SKILL_NAME, copy, origin, deps);
 		lines.push(judged.line);
-		current &&= judged.current;
+		current = judged.current;
 	}
+	const legacy = installed.filter((entry) => isLegacyDataAppCopy(entry.name, entry.source));
+	for (const entry of legacy) lines.push(`${entry.scope} ${entry.path}: replaced by ${DATA_APPS_SKILL_NAME}`);
 	const detail = lines.join("\n");
-	if (current) return ok(id, label, detail);
+	if (current && legacy.length === 0) return ok(id, label, detail);
 	return failed(id, label, {
 		detail,
-		hint: `\`rde init --only ${SKILL_STEP}\` installs them; then restart the agent session`,
+		hint: `${dataAppSkillsFix({
+			current,
+			legacy: legacy.length > 0
+		})}; then restart the agent session`,
 		step: SKILL_STEP
 	});
 }
 async function skillRows(state, deps) {
-	const label = "rde skill";
+	const label = `${RDE_SKILL_NAME} skill`;
 	if (state === null) return [skipped("skill", label, NO_INSTANCE_REASON)];
 	if (state.steps[SKILL_STEP]?.status === "skipped") return [skipped("skill", label, `skipped during init; \`rde init --only ${SKILL_STEP}\``)];
 	const detected = (await detectAgents(deps.probe)).filter((agent) => agent.detected);
 	if (detected.length === 0) return [skipped("skill", label, "no coding agents detected")];
 	const installed = await skillsCli(deps.runner).list();
-	const entries = installed.filter((entry) => entry.name === "rde");
-	const copies = await skillCopiesRow(entries, deps);
-	const dataApps = await dataAppSkillsRow(state, installed, deps);
+	const entries = installed.filter((entry) => entry.name === RDE_SKILL_NAME);
+	const copies = await skillCopiesRow(entries, installed.filter((entry) => isReplacedRdeCopy(entry.name)), deps);
+	const dataApps = await dataAppSkillsRow(installed, deps);
 	if (detected.filter((agent) => entries.some((entry) => skillCoversAgent(entry, agent))).length === 0) return [
 		failed("skill", label, {
 			detail: `not installed for ${detected.map((agent) => agent.displayName).join(", ")}`,
@@ -10642,6 +10680,10 @@ const init = defineRdeCommand({
 			type: "string",
 			description: "Database to connect, a connection string or <engine>=<connection string> when it fits several engines; repeatable. init needs one, and asks for it only at a terminal"
 		},
+		"database-name": {
+			type: "string",
+			description: "Display name of the --database in the same position, such as the name the production Metabase uses; repeatable"
+		},
 		"git-dir": {
 			type: "string",
 			description: "Directory for the content repository"
@@ -10699,6 +10741,7 @@ const init = defineRdeCommand({
 				licenseToken: args["license-token"],
 				skipLicense: args["skip-license"],
 				database: repeatedValues(rawArgs, "--database"),
+				databaseName: repeatedValues(rawArgs, "--database-name"),
 				gitDir: args["git-dir"],
 				gitRemote: args["git-remote"],
 				gitUrl: args["git-url"],
@@ -11264,17 +11307,22 @@ async function findMbProfiles(candidates, urls, runner) {
 	}
 	return found;
 }
+function spokenList(items) {
+	const last = items.at(-1);
+	if (last === void 0 || items.length <= 2) return items.join(" and ");
+	return `${items.slice(0, -1).join(", ")}, and ${last}`;
+}
 function skillLabel(names, entries) {
 	const agents = [...new Set(entries.flatMap((entry) => entry.agents))];
 	const noun = names.length === 1 ? "skill" : "skills";
-	return `${names.join(" and ")} ${noun} for ${agents.join(", ")}`;
+	return `${spokenList(names)} ${noun} for ${agents.join(", ")}`;
 }
+const OWNED_SKILL_NAMES = RDE_OWNED_SKILL_NAMES;
 async function findSkill(runner, childOutput) {
 	const skills = skillsCli(runner);
-	const owned = RDE_SOURCE_SKILL_NAMES;
-	const entries = (await skills.list()).filter((entry) => owned.includes(entry.name));
+	const entries = (await skills.list()).filter((entry) => OWNED_SKILL_NAMES.includes(entry.name));
 	if (entries.length === 0) return null;
-	const names = [...new Set(entries.map((entry) => entry.name))];
+	const names = OWNED_SKILL_NAMES.filter((name) => entries.some((entry) => entry.name === name));
 	return {
 		label: skillLabel(names, entries),
 		remove: () => skills.remove(names, childOutput)
@@ -11376,7 +11424,7 @@ function keptOnDisk(options, state, dirPresent) {
 	const kept = [];
 	if (options.keepData && dirPresent) kept.push(`Instance directory ${instanceDir(options.instance)} (--keep-data); \`rde init\` reinstalls from it`);
 	if (state?.gitRemote !== null && state?.gitRemote !== void 0) kept.push(`Working directory ${state.gitRemote.workdir} and its git history`);
-	if (!options.removeSkill) kept.push(`The ${RDE_SOURCE_SKILL_NAMES.join(" and ")} skills for your agents; pass --remove-skill to remove them`);
+	if (!options.removeSkill) kept.push(`The ${spokenList(RDE_INSTALLED_SKILL_NAMES)} skills for your agents; pass --remove-skill to remove them`);
 	return kept;
 }
 async function planUninstall(options, deps) {
@@ -11535,7 +11583,7 @@ const uninstallCommand = defineRdeCommand({
 		},
 		"remove-skill": {
 			type: "boolean",
-			description: "Also remove the rde and rde-data-apps skills from your coding agents",
+			description: "Also remove the metabase-data-apps and metabase-rde skills, and the rde and rde-data-apps skills they replace, from your coding agents",
 			default: false
 		},
 		"remove-image": {
@@ -11857,7 +11905,7 @@ async function upgrade(ctx, options, deps = hostDeps) {
 	const backup = join(instanceBackupsDir(ctx.state.name), backupStamp(resolved.now()));
 	ctx.ui.note(planLines(configured, current, target, backup).join("\n"), "rde upgrade");
 	const announced = majorMove(current, target.releaseTag);
-	if (announced !== null) ctx.ui.warn(`This moves Metabase from ${announced.from} to ${announced.to}, a new major version; the data-app skills follow it after the upgrade`);
+	if (announced !== null) ctx.ui.warn(`This moves Metabase from ${announced.from} to ${announced.to}, a new major version; rde updates your coding agents' skills after the upgrade`);
 	if (!options.yes) {
 		if (!await ctx.prompts.confirm({
 			message: "Upgrade now?",
@@ -11880,7 +11928,7 @@ async function upgrade(ctx, options, deps = hostDeps) {
 	ctx.ui.success(`Upgraded Metabase from ${current} to ${to}; the backup at ${backup} can go once you are happy with it`);
 	const moved = majorMove(current, to);
 	if (moved !== null) {
-		if (announced === null) ctx.ui.warn(`This moved Metabase from ${moved.from} to ${moved.to}, a new major version; the data-app skills follow it`);
+		if (announced === null) ctx.ui.warn(`This moved Metabase from ${moved.from} to ${moved.to}, a new major version`);
 		await runWizard([resolved.skills(options.yes ? DETECT_AGENTS : ASK_AGENTS)], ctx);
 	}
 	return {

package/package.json

@@ -1,8 +1,17 @@
 {
   "name": "@metabase/rde",
-  "version": "0.1.18",
+  "version": "0.5.1",
   "description": "Prepares a local machine for data-engineering work with Metabase and coding agents",
+  "keywords": [
+    "analytics",
+    "claude-code",
+    "cli",
+    "coding-agents",
+    "data-engineering",
+    "metabase"
+  ],
   "license": "AGPL-3.0",
+  "author": "Metabase",
   "bin": {
     "rde": "dist/cli.mjs"
   },
@@ -31,7 +40,8 @@
     "test:e2e": "vitest run --project e2e --reporter=verbose tests/e2e/init.e2e.test.ts tests/e2e/mb-profiles.e2e.test.ts",
     "test:e2e:databases": "vitest run --project e2e --reporter=verbose tests/e2e/databases.e2e.test.ts",
     "check": "bun run typecheck && bun run lint && bun run format:check && bun run test",
-    "check:fix": "bun run lint:fix && bun run format"
+    "check:fix": "bun run lint:fix && bun run format",
+    "prepublishOnly": "bun run build"
   },
   "dependencies": {
     "@clack/prompts": "^0.8.2",