@metabase/rde 0.1.12 → 0.1.14

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import { defineCommand, renderUsage, runMain } from "citty";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { createWriteStream, promises } from "node:fs";
-import { delimiter, dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { delimiter, dirname, isAbsolute, join, posix, resolve, sep } from "node:path";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { ZodError, z } from "zod";
 import { homedir, tmpdir, userInfo } from "node:os";
@@ -71,12 +71,14 @@ var MetabaseApiError = class extends Error {
 	status;
 	path;
 	errors;
+	reason;
 	constructor(failure) {
 		super(`Metabase ${failure.status} on ${failure.path}: ${failure.message}`);
 		this.name = "MetabaseApiError";
 		this.status = failure.status;
 		this.path = failure.path;
 		this.errors = failure.errors;
+		this.reason = failure.message;
 	}
 };
 const UNAUTHORIZED_STATUS = 401;
@@ -93,10 +95,12 @@ var MetabaseInitializingError = class extends Error {
 };
 var MetabaseUnreachableError = class extends Error {
 	url;
+	reason;
 	constructor(url, reason) {
 		super(`Metabase at ${url} is unreachable: ${reason}`);
 		this.name = "MetabaseUnreachableError";
 		this.url = url;
+		this.reason = reason;
 	}
 };
 var DownloadError = class extends Error {
@@ -240,10 +244,11 @@ const StepId = z.enum([
 	"start-metabase",
 	"admin-user",
 	"api-key",
+	"transforms",
 	"sample-database",
 	"license",
-	"databases",
 	"git-sync",
+	"databases",
 	"summary"
 ]);
 const GlobalConfig = z.object({
@@ -891,6 +896,11 @@ function describeCause(error) {
 	if (error instanceof Error && error.cause instanceof Error) return error.cause.message;
 	return error instanceof Error ? error.message : String(error);
 }
+function lookupFailure(error) {
+	if (error instanceof MetabaseUnreachableError) return `${error.url} is unreachable: ${error.reason}`;
+	if (error instanceof MetabaseApiError) return `HTTP ${error.status} on ${error.path}: ${error.reason}`;
+	return null;
+}
 function createHttp(options) {
 	const fetchImpl = options.fetchImpl ?? fetch;
 	const baseUrl = options.baseUrl.replace(/\/+$/, "");
@@ -910,7 +920,11 @@ function createHttp(options) {
 			init.body = JSON.stringify(body);
 		}
 		try {
-			return await fetchImpl(url, init);
+			const response = await fetchImpl(url, init);
+			return {
+				ok: response.ok,
+				body: parseBody(response.status, await response.text())
+			};
 		} catch (error) {
 			if (options.signal.aborted) throw new AbortError();
 			if (isTimeout(error)) throw new MetabaseUnreachableError(url, `no response within ${REQUEST_TIMEOUT_MS}ms`);
@@ -918,10 +932,9 @@ function createHttp(options) {
 		}
 	}
 	async function requestBody(method, path, body) {
-		const response = await send(method, path, body);
-		const parsed = parseBody(response.status, await response.text());
-		if (!response.ok) throw failureFor(path, parsed);
-		return parsed;
+		const received = await send(method, path, body);
+		if (!received.ok) throw failureFor(path, received.body);
+		return received.body;
 	}
 	return {
 		async requestJson(method, path, request) {
@@ -1037,8 +1050,12 @@ const Database = z.object({
 	id: z.int(),
 	name: z.string(),
 	engine: z.string(),
-	initial_sync_status: InitialSyncStatus
+	initial_sync_status: InitialSyncStatus,
+	is_stub: z.boolean().optional()
 }).loose();
+function isStub(database) {
+	return database.is_stub === true;
+}
 const DatabaseList = z.object({
 	data: z.array(Database),
 	total: z.int()
@@ -1072,6 +1089,17 @@ function databaseResource(http) {
 	async function list() {
 		return http.requestJson("GET", "/api/database", { schema: DatabaseList });
 	}
+	/** GET /api/database?include_stubs=true */
+	async function listWithStubs() {
+		return http.requestJson("GET", "/api/database?include_stubs=true", { schema: DatabaseList });
+	}
+	/** PUT /api/database/:id — on a stub, new connection details make it a real database */
+	async function connect(id, connection) {
+		return http.requestJson("PUT", `/api/database/${id}`, {
+			body: connection,
+			schema: Database
+		});
+	}
 	/** GET /api/database/:id */
 	async function get(id) {
 		return http.requestJson("GET", `/api/database/${id}`, { schema: Database });
@@ -1080,6 +1108,8 @@ function databaseResource(http) {
 		validate,
 		create,
 		list,
+		listWithStubs,
+		connect,
 		get
 	};
 }
@@ -1132,6 +1162,13 @@ function remoteSyncResource(http) {
 			schema: RemoteSyncSettingsResult
 		});
 	}
+	/** PUT /api/ee/remote-sync/settings with only `remote-sync-transforms`, which skips the repository check. */
+	async function syncTransforms() {
+		return http.requestJson("PUT", "/api/ee/remote-sync/settings", {
+			body: { "remote-sync-transforms": true },
+			schema: RemoteSyncSettingsResult
+		});
+	}
 	/** POST /api/ee/remote-sync/test-connection; an empty body tests the saved url and token. */
 	async function testConnection(connection = {}) {
 		return http.requestJson("POST", "/api/ee/remote-sync/test-connection", {
@@ -1145,6 +1182,7 @@ function remoteSyncResource(http) {
 	}
 	return {
 		updateSettings,
+		syncTransforms,
 		testConnection,
 		currentTask
 	};
@@ -1154,6 +1192,33 @@ function remoteSyncResource(http) {
 const Session = z.object({ id: z.string() }).loose();
 //#endregion
 //#region src/metabase/domain/session-properties.ts
+const SessionProperties = z.object({
+	"setup-token": z.string().nullable(),
+	"has-user-setup": z.boolean(),
+	version: z.object({ tag: z.string() }).loose(),
+	"token-features": z.record(z.string(), z.boolean())
+}).loose();
+//#endregion
+//#region src/metabase/resources/session.ts
+function sessionResource(http) {
+	/** GET /api/session/properties */
+	async function properties() {
+		return http.requestJson("GET", "/api/session/properties", { schema: SessionProperties });
+	}
+	/** POST /api/session */
+	async function create(credentials) {
+		return http.requestJson("POST", "/api/session", {
+			body: credentials,
+			schema: Session
+		});
+	}
+	return {
+		properties,
+		create
+	};
+}
+//#endregion
+//#region src/metabase/domain/engine.ts
 const EngineFieldOption = z.object({
 	name: z.string(),
 	value: z.unknown()
@@ -1179,36 +1244,16 @@ const Engine = z.object({
 	"superseded-by": z.string().nullable(),
 	"creatable?": z.boolean().optional()
 }).loose();
-const SessionProperties = z.object({
-	"setup-token": z.string().nullable(),
-	"has-user-setup": z.boolean(),
-	version: z.object({ tag: z.string() }).loose(),
-	"token-features": z.record(z.string(), z.boolean()),
-	engines: z.record(z.string(), Engine)
-}).loose();
+const Engines = z.record(z.string(), Engine);
 //#endregion
-//#region src/metabase/resources/session.ts
-function sessionResource(http) {
-	/** GET /api/session/properties */
-	async function properties() {
-		return http.requestJson("GET", "/api/session/properties", { schema: SessionProperties });
-	}
-	/** POST /api/session */
-	async function create(credentials) {
-		return http.requestJson("POST", "/api/session", {
-			body: credentials,
-			schema: Session
-		});
-	}
-	return {
-		properties,
-		create
-	};
-}
+//#region src/metabase/domain/setting.ts
+const BooleanSetting = z.boolean();
 //#endregion
 //#region src/metabase/resources/setting.ts
 const PREMIUM_EMBEDDING_TOKEN_SETTING = "premium-embedding-token";
+const ENGINES_SETTING = "engines";
 const TRANSFORMS_ENABLED_SETTING = "transforms-enabled";
+const TRANSFORMS_SETUP_COMPLETE_SETTING = "transforms-setup-complete";
 function settingResource(http) {
 	/** PUT /api/setting/premium-embedding-token */
 	async function setPremiumEmbeddingToken(value) {
@@ -1218,9 +1263,19 @@ function settingResource(http) {
 	async function enableTransforms() {
 		await http.requestNoContent("PUT", `/api/setting/${TRANSFORMS_ENABLED_SETTING}`, { body: { value: true } });
 	}
+	/** GET /api/setting/transforms-setup-complete */
+	async function transformsDecided() {
+		return http.requestJson("GET", `/api/setting/${TRANSFORMS_SETUP_COMPLETE_SETTING}`, { schema: BooleanSetting });
+	}
+	/** GET /api/setting/engines; admins only, which the API key's user is. */
+	async function engines() {
+		return http.requestJson("GET", `/api/setting/${ENGINES_SETTING}`, { schema: Engines });
+	}
 	return {
 		setPremiumEmbeddingToken,
-		enableTransforms
+		enableTransforms,
+		transformsDecided,
+		engines
 	};
 }
 //#endregion
@@ -2443,13 +2498,6 @@ const PLUGINS_DIR = "plugins";
 const METABASE_STOP_GRACE_MS = 3e4;
 const DB_DIR = "metabase.db";
 const DB_FILE = "metabase.db";
-const STAGING_STORE_ENV = {
-	MB_RUN_MODE: "e2e",
-	MB_STORE_USE_STAGING: "true"
-};
-const ALLOW_LOCAL_WAREHOUSES_ENV = { MB_WAREHOUSE_ALLOWED_NETWORKS: "allow-all" };
-const NO_H2_SAMPLE_ENV = { MB_LOAD_SAMPLE_CONTENT: "false" };
-const NO_AUDIT_DB_ENV = { MB_INSTALL_ANALYTICS_DATABASE: "false" };
 function instanceUrl(port) {
 	return `http://localhost:${port}`;
 }
@@ -2458,10 +2506,11 @@ function serverEnv(options) {
 		MB_DB_FILE: options.dbFile,
 		MB_PLUGINS_DIR: options.pluginsDir,
 		MB_SITE_URL: instanceUrl(options.port),
-		...STAGING_STORE_ENV,
-		...ALLOW_LOCAL_WAREHOUSES_ENV,
-		...NO_H2_SAMPLE_ENV,
-		...NO_AUDIT_DB_ENV
+		MB_RUN_MODE: "e2e",
+		MB_STORE_USE_STAGING: "true",
+		MB_WAREHOUSE_ALLOWED_NETWORKS: "allow-all",
+		MB_LOAD_SAMPLE_CONTENT: "false",
+		MB_INSTALL_ANALYTICS_DATABASE: "false"
 	};
 }
 function jettyEnv(port) {
@@ -3018,12 +3067,12 @@ async function portClaims(state, runtime) {
 }
 //#endregion
 //#region src/steps/admin-user.ts
-const STEP_ID$9 = "admin-user";
+const STEP_ID$10 = "admin-user";
 const ADMIN_USER_KEYS = {
-	email: `${STEP_ID$9}.email`,
-	password: `${STEP_ID$9}.password`,
-	firstName: `${STEP_ID$9}.first-name`,
-	lastName: `${STEP_ID$9}.last-name`
+	email: `${STEP_ID$10}.email`,
+	password: `${STEP_ID$10}.password`,
+	firstName: `${STEP_ID$10}.first-name`,
+	lastName: `${STEP_ID$10}.last-name`
 };
 const GENERATED_ADMIN_EMAIL = "admin@metabase.local";
 const GENERATED_PASSWORD_BYTES = 24;
@@ -3038,7 +3087,7 @@ function generatePassword(random) {
 		if (DIGIT.test(candidate)) return candidate;
 	}
 }
-function hostDeps$13(ctx) {
+function hostDeps$14(ctx) {
 	return {
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
 		instanceRunning: () => isInstanceRunning(ctx.state, hostRuntimeDeps(ctx.state.name, ctx.signal)),
@@ -3176,9 +3225,9 @@ async function recordExistingAdmin(ctx, variant, client, url) {
 	ctx.ui.success(`Admin user ${email} recorded`);
 	return "completed";
 }
-function adminUserStep(options, deps = hostDeps$13) {
+function adminUserStep(options, deps = hostDeps$14) {
 	return {
-		id: STEP_ID$9,
+		id: STEP_ID$10,
 		title: "Create the admin user",
 		redoHint: "An instance keeps the admin it was set up with; `rde credentials` shows it.",
 		async detect(ctx) {
@@ -3247,7 +3296,9 @@ function adminUserStep(options, deps = hostDeps$13) {
 //#endregion
 //#region src/tools/mb.ts
 const MB = "mb";
-const MB_INSTALL_SPEC = `@metabase/cli@alpha-release-65-integration-branch`;
+const MB_PACKAGE = "@metabase/cli";
+const MB_DIST_TAG = "alpha-release-65-integration-branch";
+const MB_INSTALL_SPEC = `${MB_PACKAGE}@${MB_DIST_TAG}`;
 const GLOBAL_INSTALL = {
 	npm: {
 		command: "npm",
@@ -3421,7 +3472,6 @@ const AuthProfileStatus = z.enum([
 const AuthProfile = z.object({
 	profile: z.string(),
 	url: z.string(),
-	authenticated: z.boolean(),
 	status: AuthProfileStatus,
 	user: ProbedUser.nullable()
 }).loose();
@@ -3503,7 +3553,14 @@ function mbTool(runner) {
 		], LogoutResult);
 	}
 	async function authList() {
-		return (await mbJson(["auth", "list"], AuthList)).data;
+		return (await mbJson([
+			"auth",
+			"list",
+			"--fields",
+			"profile,url,status,user",
+			"--max-bytes",
+			"0"
+		], AuthList)).data;
 	}
 	async function gitSyncStatus(profile) {
 		return mbJson([
@@ -3559,14 +3616,14 @@ function mbTool(runner) {
 }
 //#endregion
 //#region src/steps/api-key.ts
-const STEP_ID$8 = "api-key";
+const STEP_ID$9 = "api-key";
 const API_KEY_KEYS = {
-	email: `${STEP_ID$8}.email`,
-	password: `${STEP_ID$8}.password`,
-	profile: `${STEP_ID$8}.profile`
+	email: `${STEP_ID$9}.email`,
+	password: `${STEP_ID$9}.password`,
+	profile: `${STEP_ID$9}.profile`
 };
 const ADMINISTRATORS_GROUP_NAME = "Administrators";
-function hostDeps$12(ctx) {
+function hostDeps$13(ctx) {
 	return {
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
 		runner: processRunner(ctx.signal)
@@ -3685,9 +3742,9 @@ function usageNote(profile) {
 	if (profile === "default") return `${mbCommand(profile)} <command> uses this instance`;
 	return `${mbCommand(profile)} <command>\nMB_PROFILE=${profile} for agents and scripts`;
 }
-function apiKeyStep(deps = hostDeps$12) {
+function apiKeyStep(deps = hostDeps$13) {
 	return {
-		id: STEP_ID$8,
+		id: STEP_ID$9,
 		title: "Connect the Metabase CLI",
 		redoHint: "`rde status` shows the mb profile it uses.",
 		async detect(ctx) {
@@ -4646,20 +4703,29 @@ function syncWithHint(database) {
 function existingDatabaseLines(databases) {
 	return databases.map((db) => `${db.name} (${db.engine}, ${syncWithHint(db)})`);
 }
+function unconnectedStubsLine(stubs) {
+	return `Not connected yet, used by your content: ${stubs.map((stub) => stub.name).join(", ")}; \`rde db add\` connects one`;
+}
+function listingStatus(entry) {
+	if (entry.stub) return "not connected, your content uses it; `rde db add` connects it";
+	return entry.initialSyncStatus === null ? "missing on the server" : syncLabel(entry.initialSyncStatus);
+}
 function databaseListingLines(listing) {
 	if (listing.length === 0) return ["No databases connected yet; run `rde db add`"];
 	return listing.map((entry) => {
-		const sync = entry.initialSyncStatus === null ? "missing on the server" : syncLabel(entry.initialSyncStatus);
-		return `${entry.name}  ${entry.engine}  id ${entry.id}  ${sync}`;
+		const engine = entry.stub ? "?" : entry.engine;
+		return `${entry.name}  ${engine}  id ${entry.id}  ${listingStatus(entry)}`;
 	});
 }
 //#endregion
 //#region src/steps/databases/flow.ts
 const DATABASE_KEYS = {
 	connection: "databases.connection",
-	skip: "databases.skip"
+	skip: "databases.skip",
+	stubs: "databases.stubs"
 };
 const DATABASE_KEY_NAMES = {
+	connection: "connection",
 	detectedEngine: "detected-engine",
 	engine: "engine",
 	mode: "mode",
@@ -4703,11 +4769,13 @@ const RSA_KEY_UNAVAILABLE_ERROR = "RSA public key is not available";
 const KEY_RETRIEVAL_NOTE = "allowPublicKeyRetrieval=true is added: MySQL 8 needs it to log in to a local server without SSL; to leave it out, paste a connection string with allowPublicKeyRetrieval=false instead";
 const KEY_RETRIEVAL_HINT = "MySQL 8 without SSL needs allowPublicKeyRetrieval=true: go back and add ?allowPublicKeyRetrieval=true to the connection string, or turn on SSL";
 const CONNECTION_PLACEHOLDER = "leave empty to skip";
+const STUB_CONNECTION_PLACEHOLDER = "leave empty to pick the engine";
 const START_SCREEN = {
 	engine: "pick-engine",
 	"connection-string": "connection-string"
 };
 const FRESH$1 = {
+	target: null,
 	engine: null,
 	uri: null,
 	pasted: null,
@@ -4717,6 +4785,35 @@ const FRESH$1 = {
 	name: null,
 	fieldErrors: null
 };
+function targeting(stub) {
+	return {
+		...FRESH$1,
+		target: stub,
+		name: stub.name
+	};
+}
+function restart(model) {
+	return model.target === null ? FRESH$1 : targeting(model.target);
+}
+function nextStub(run, model) {
+	const stub = run.queue.shift();
+	if (stub !== void 0) return {
+		type: "next",
+		to: "connection-string",
+		model: targeting(stub)
+	};
+	return run.created.length > 0 ? {
+		type: "next",
+		to: "another",
+		model
+	} : {
+		type: "done",
+		model
+	};
+}
+function stubNamed(run, name) {
+	return run.stubs.find((stub) => stub.name === name) ?? null;
+}
 function ordinalOf(run) {
 	return run.created.length + 1;
 }
@@ -4786,20 +4883,60 @@ async function pickDetectedEngine(run, candidates) {
 	if (entry === void 0) throw new Error(`engine ${picked} was not offered`);
 	return entry;
 }
+function pickStubsScreen(run) {
+	return async (model) => {
+		const picked = await run.deps.prompts.multiselect({
+			key: DATABASE_KEYS.stubs,
+			message: "Your content uses these databases, not connected yet. Pick the ones to connect now (space picks, Enter goes on; the rest wait for `rde db add`)",
+			choices: run.stubs.map((stub) => ({
+				value: stub.id,
+				label: stub.name
+			})),
+			required: false
+		});
+		if (picked.length > 0) {
+			run.queue = run.stubs.filter((stub) => picked.includes(stub.id));
+			return nextStub(run, model);
+		}
+		if (run.deps.start === "connection-string" && run.created.length === 0) return {
+			type: "done",
+			model
+		};
+		return {
+			type: "next",
+			to: "pick-engine",
+			model: FRESH$1
+		};
+	};
+}
+function connectionQuestion(run, target) {
+	if (target === null) return {
+		key: DATABASE_KEYS.connection,
+		message: "Connection string of your database (Enter to skip; `rde db add` connects one later)",
+		placeholder: CONNECTION_PLACEHOLDER
+	};
+	return {
+		key: databaseKey(ordinalOf(run), "connection"),
+		message: `Connection string of ${target.name} (Enter to pick its engine instead)`,
+		placeholder: STUB_CONNECTION_PLACEHOLDER
+	};
+}
 function connectionStringScreen(run) {
 	return async (model) => {
 		let draft = model.uri;
 		for (;;) {
 			const uri = (await run.deps.prompts.text({
-				key: DATABASE_KEYS.connection,
-				message: "Connection string of your database (Enter to skip; `rde db add` connects one later)",
-				placeholder: CONNECTION_PLACEHOLDER,
+				...connectionQuestion(run, model.target),
 				...draft !== null && { initialValue: draft }
 			})).trim();
 			draft = uri;
-			if (uri.length === 0) return {
+			if (uri.length === 0) return model.target === null ? {
 				type: "done",
 				model
+			} : {
+				type: "next",
+				to: "pick-engine",
+				model: restart(model)
 			};
 			const candidates = detectEngine(uri).map((key) => run.deps.catalog.entry(key)).filter(isCreatableEntry);
 			const [first, ...others] = candidates;
@@ -4808,7 +4945,7 @@ function connectionStringScreen(run) {
 				return {
 					type: "next",
 					to: "pick-engine",
-					model: FRESH$1
+					model: restart(model)
 				};
 			}
 			const engine = others.length === 0 ? first : await pickDetectedEngine(run, candidates);
@@ -4822,7 +4959,7 @@ function connectionStringScreen(run) {
 				return {
 					type: "next",
 					to: "pick-engine",
-					model: FRESH$1
+					model: restart(model)
 				};
 			}
 			return toReview(run, model, {
@@ -4832,12 +4969,16 @@ function connectionStringScreen(run) {
 		}
 	};
 }
+function finishLabel(run, model) {
+	if (model.target !== null) return `Leave ${model.target.name} unconnected`;
+	return run.deps.existingCount + run.created.length > 0 ? "Finish" : "Skip for now";
+}
 function pickEngineScreen(run) {
 	return async (model) => {
 		const total = run.deps.existingCount + run.created.length;
 		const finishChoice = {
 			value: FINISH,
-			label: total > 0 ? "Finish" : "Skip for now"
+			label: finishLabel(run, model)
 		};
 		for (;;) {
 			const picked = await run.deps.prompts.select({
@@ -4846,6 +4987,7 @@ function pickEngineScreen(run) {
 				choices: [...run.deps.catalog.list().map(engineChoice), finishChoice],
 				...model.engine !== null && { initialValue: model.engine.key }
 			});
+			if (picked === "finish" && model.target !== null) return nextStub(run, model);
 			if (picked === "finish") {
 				if (total > 0 || await confirmSkip(run)) return {
 					type: "done",
@@ -4863,7 +5005,7 @@ function pickEngineScreen(run) {
 				type: "next",
 				to: "paste-uri",
 				model: model.engine?.key === entry.key ? model : {
-					...FRESH$1,
+					...restart(model),
 					engine: entry
 				}
 			};
@@ -4894,6 +5036,10 @@ async function chooseAfterParseError(run, engine, uri, error) {
 	if (entry === void 0) throw new Error(`engine ${picked} was not offered`);
 	return entry;
 }
+function reviewName(model, sameString) {
+	if (model.target !== null) return model.target.name;
+	return sameString ? model.name : null;
+}
 function toReview(run, model, connection) {
 	const mapped = mapDatabaseValues(connection.parsed);
 	const sameString = model.uri === connection.parsed.uri;
@@ -4901,13 +5047,14 @@ function toReview(run, model, connection) {
 		type: "next",
 		to: "review",
 		model: {
+			target: model.target,
 			engine: connection.engine,
 			uri: connection.parsed.uri,
 			pasted: mapped.details,
 			details: mapped.details,
 			failure: null,
 			suggestedName: defaultDisplayName(mapped, connection.parsed, connection.engine),
-			name: sameString ? model.name : null,
+			name: reviewName(model, sameString),
 			fieldErrors: null
 		}
 	};
@@ -5050,6 +5197,33 @@ async function fixReportedFields(run, fields, details, errors) {
 	}
 	return current;
 }
+function reviewQuestion(target, name) {
+	const edit = {
+		value: "edit",
+		label: "Edit a field"
+	};
+	if (target !== null) return {
+		message: `Connect ${name}?`,
+		choices: [{
+			value: "test",
+			label: "Test and connect"
+		}, edit]
+	};
+	return {
+		message: `Add ${name}?`,
+		choices: [
+			{
+				value: "test",
+				label: "Test and add"
+			},
+			edit,
+			{
+				value: "rename",
+				label: "Change the display name"
+			}
+		]
+	};
+}
 function reviewScreen(run) {
 	const review = reviewAttempt(run);
 	return (model) => model.failure === null ? review(model) : orFailure(model.failure, () => review({
@@ -5075,21 +5249,7 @@ function reviewAttempt(run) {
 			if (name === null) name = await promptName(run, current, chosen.engine);
 			const action = await run.deps.prompts.selectOrBack({
 				key: databaseKey(ordinalOf(run), "action"),
-				message: `Add ${name}?`,
-				choices: [
-					{
-						value: "test",
-						label: "Test and add"
-					},
-					{
-						value: "edit",
-						label: "Edit a field"
-					},
-					{
-						value: "rename",
-						label: "Change the display name"
-					}
-				]
+				...reviewQuestion(model.target, name)
 			});
 			if (action === BACK) return { type: "back" };
 			if (action === "edit") {
@@ -5168,26 +5328,44 @@ function testScreen(run) {
 function isRejectedDetails(error) {
 	return error instanceof MetabaseApiError && error.status === BAD_REQUEST_STATUS$1;
 }
+function commitFor(run, stub) {
+	if (stub === null) return {
+		verb: "add",
+		progress: "Adding",
+		past: "Added",
+		send: (request) => run.deps.database.create(request)
+	};
+	return {
+		verb: "connect",
+		progress: "Connecting",
+		past: "Connected",
+		send: ({ engine, details }) => run.deps.database.connect(stub.id, {
+			engine,
+			details
+		})
+	};
+}
 function createScreen(run) {
 	return async (model) => {
 		const chosen = requireEngine(run, model);
 		if (model.name === null) throw new Error("no display name before create");
-		const spinner = run.deps.ui.spinner(`Adding ${model.name}…`);
+		const commit = commitFor(run, model.target ?? stubNamed(run, model.name));
+		const spinner = run.deps.ui.spinner(`${commit.progress} ${model.name}…`);
 		let database;
 		try {
-			database = await run.deps.database.create({
+			database = await commit.send({
 				name: model.name,
 				engine: chosen.engine.key,
 				details: sentDetails(run, chosen, model.details).details
 			});
 		} catch (error) {
 			if (!isRejectedDetails(error)) {
-				spinner.fail(`Could not add ${model.name}`);
+				spinner.fail(`Could not ${commit.verb} ${model.name}`);
 				throw error;
 			}
 			spinner.fail(error.message);
 			keyRetrievalHint(run, chosen, error.message);
-			const failure = `Metabase could not add ${model.name}: ${error.message}`;
+			const failure = `Metabase could not ${commit.verb} ${model.name}: ${error.message}`;
 			return {
 				type: "next",
 				to: "review",
@@ -5199,14 +5377,15 @@ function createScreen(run) {
 			};
 		}
 		run.created.push(database);
-		spinner.stop(`Added ${database.name}. Initial sync is running in the background; \`rde status\` shows progress.`);
+		run.stubs = run.stubs.filter((candidate) => candidate.id !== database.id);
+		spinner.stop(`${commit.past} ${database.name}. Initial sync is running in the background; \`rde status\` shows progress.`);
 		run.added.push(addedDatabase(chosen, model, model.name));
 		await run.deps.onCreated(database);
-		return {
+		return model.target === null ? {
 			type: "next",
 			to: "another",
 			model
-		};
+		} : nextStub(run, model);
 	};
 }
 function anotherScreen(run) {
@@ -5227,18 +5406,24 @@ function anotherScreen(run) {
 		};
 		return {
 			type: "next",
-			to: "pick-engine",
+			to: offersStubs(run) ? "pick-stubs" : "pick-engine",
 			model: FRESH$1
 		};
 	};
 }
+function offersStubs(run) {
+	return run.deps.offerStubs && run.stubs.length > 0;
+}
 async function runDatabaseFlow(deps) {
 	const run = {
 		deps,
 		created: [],
-		added: []
+		added: [],
+		stubs: [...deps.stubs],
+		queue: []
 	};
 	await runFlow({
+		"pick-stubs": pickStubsScreen(run),
 		"connection-string": connectionStringScreen(run),
 		"pick-engine": pickEngineScreen(run),
 		"paste-uri": pasteUriScreen(run),
@@ -5246,10 +5431,11 @@ async function runDatabaseFlow(deps) {
 		test: testScreen(run),
 		create: createScreen(run),
 		another: anotherScreen(run)
-	}, START_SCREEN[deps.start], FRESH$1);
+	}, offersStubs(run) ? "pick-stubs" : START_SCREEN[deps.start], FRESH$1);
 	return {
 		created: run.created,
-		added: run.added
+		added: run.added,
+		stubsLeft: run.stubs
 	};
 }
 //#endregion
@@ -5305,8 +5491,9 @@ function gitTool(runner) {
 	}
 	async function isRepo(dir) {
 		if (!await directoryExists(dir)) return false;
-		const result = await runner.run(GIT, ["rev-parse", "--is-inside-work-tree"], { cwd: dir });
-		return result.exitCode === 0 && result.stdout.trim() === "true";
+		const result = await runner.run(GIT, ["rev-parse", "--show-toplevel"], { cwd: dir });
+		if (result.exitCode !== 0) return false;
+		return result.stdout.trim() === await promises.realpath(dir);
 	}
 	async function initBare(path, options) {
 		await git([
@@ -5419,13 +5606,13 @@ function gitTool(runner) {
 }
 //#endregion
 //#region src/steps/git-sync.ts
-const STEP_ID$7 = "git-sync";
+const STEP_ID$8 = "git-sync";
 const GIT_SYNC_KEYS = {
-	location: `${STEP_ID$7}.location`,
-	path: `${STEP_ID$7}.path`,
-	remote: `${STEP_ID$7}.remote`,
-	url: `${STEP_ID$7}.url`,
-	token: `${STEP_ID$7}.token`
+	location: `${STEP_ID$8}.location`,
+	path: `${STEP_ID$8}.path`,
+	remote: `${STEP_ID$8}.remote`,
+	url: `${STEP_ID$8}.url`,
+	token: `${STEP_ID$8}.token`
 };
 const BARE_REPO_NAME = "content.git";
 const DEFAULT_BRANCH = "main";
@@ -5455,7 +5642,11 @@ const TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set([
 	"timed-out",
 	"conflict"
 ]);
-function hostDeps$11(ctx) {
+const SYNC_MODE_SETTINGS = {
+	"remote-sync-type": "read-write",
+	"remote-sync-transforms": true
+};
+function hostDeps$12(ctx) {
 	return {
 		runner: processRunner(ctx.signal),
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
@@ -5746,7 +5937,7 @@ async function configureLocalBare(run, runtime, workdir) {
 		},
 		settings: {
 			"remote-sync-url": bareUrlFor(runtime, barePath),
-			"remote-sync-type": "read-write",
+			...SYNC_MODE_SETTINGS,
 			"remote-sync-branch": prepared.branch
 		}
 	};
@@ -5789,7 +5980,7 @@ async function configureHosted(run, workdir, url) {
 		settings: {
 			"remote-sync-url": url,
 			"remote-sync-token": token,
-			"remote-sync-type": "read-write",
+			...SYNC_MODE_SETTINGS,
 			"remote-sync-branch": prepared.branch
 		}
 	};
@@ -5862,6 +6053,7 @@ async function importExistingContent(run, gitRemote) {
 	}
 	spinner.stop("Import finished");
 	reportImport(run, outcome);
+	await run.client.remoteSync.syncTransforms();
 }
 const SHELL_SAFE = /^[\w./-]+$/;
 function shellWord(value) {
@@ -5922,15 +6114,15 @@ async function runGitSync(ctx, deps) {
 	ctx.ui.note(usageLines$1(ctx.state, remote.gitRemote).join("\n"), "Working with the repository");
 	return "completed";
 }
-function gitSyncStep(deps = hostDeps$11) {
+function gitSyncStep(deps = hostDeps$12) {
 	return {
-		id: STEP_ID$7,
+		id: STEP_ID$8,
 		title: "Connect a git repository",
 		redoHint: "`rde init --only git-sync` with it points Metabase's remote sync at that repository instead.",
 		async detect(ctx) {
 			if (!hasRemoteSync(ctx.state.license)) return "not-applicable";
-			if (ctx.state.steps[STEP_ID$7]?.status === "skipped") return "not-applicable";
-			if (ctx.state.gitRemote === null || ctx.state.steps[STEP_ID$7]?.status !== "done") return "todo";
+			if (ctx.state.steps[STEP_ID$8]?.status === "skipped") return "not-applicable";
+			if (ctx.state.gitRemote === null || ctx.state.steps[STEP_ID$8]?.status !== "done") return "todo";
 			try {
 				return (await mbTool(deps(ctx).runner).gitSyncStatus(ctx.state.mbProfile)).branch === null ? "todo" : "done";
 			} catch (error) {
@@ -5944,17 +6136,45 @@ function gitSyncStep(deps = hostDeps$11) {
 	};
 }
 //#endregion
+//#region src/metabase/domain/github-content.ts
+const GitHubContentEntry = z.object({
+	name: z.string(),
+	type: z.string(),
+	sha: z.string()
+}).loose();
+const GitHubDirectory = z.array(GitHubContentEntry);
+//#endregion
+//#region src/metabase/github.ts
+const GITHUB_API = "https://api.github.com";
+const DIRECTORY_TYPE = "dir";
+function githubContents(signal, options = {}) {
+	const http = createHttp({
+		baseUrl: GITHUB_API,
+		auth: NO_AUTH,
+		signal,
+		...options
+	});
+	return { async subdirectoryHashes(repository, ref, directory) {
+		const path = `/repos/${repository}/contents/${directory}${ref === null ? "" : `?ref=${encodeURIComponent(ref)}`}`;
+		const entries = await http.requestJson("GET", path, { schema: GitHubDirectory });
+		return new Map(entries.filter((entry) => entry.type === DIRECTORY_TYPE).map((entry) => [entry.name, entry.sha]));
+	} };
+}
+//#endregion
 //#region src/tools/skills-cli.ts
 const NPX = "npx";
 const SKILLS_PACKAGE = "skills@latest";
 const DEFAULT_RDE_SKILL_SOURCE = "https://github.com/metabase/agent-skills/tree/main";
 const RDE_SOURCE_SKILL_NAMES = ["rde", "rde-data-apps"];
-const DATA_APP_SKILLS_SOURCE = "metabase/metabase/skills#master";
+const DATA_APP_REPOSITORY = "metabase/metabase";
+const DATA_APP_BRANCH = "master";
+const DATA_APP_SKILLS_SOURCE = `${DATA_APP_REPOSITORY}/skills#${DATA_APP_BRANCH}`;
 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-semantic-layer",
+	"metabase-data-app-migrate"
 ];
 function rdeSkillSource() {
 	const override = readEnv(ENV_RDE_SKILL_SOURCE);
@@ -5968,7 +6188,13 @@ const InstalledSkill = z.object({
 	source: z.string().nullable()
 }).loose();
 const InstalledSkillList = z.array(InstalledSkill);
-const SkillLock = z.object({ skills: z.record(z.string(), z.object({ ref: z.string().nullish() }).loose()) }).loose();
+const LockedSkill = z.object({
+	source: z.string().nullish(),
+	ref: z.string().nullish(),
+	skillPath: z.string().nullish(),
+	skillFolderHash: z.string().nullish()
+}).loose();
+const SkillLock = z.object({ skills: z.record(z.string(), LockedSkill) }).loose();
 const GLOBAL_LOCK_FILE = ".skill-lock.json";
 const PROJECT_LOCK_FILE = "skills-lock.json";
 function globalSkillLockPath(home, stateHome) {
@@ -5981,16 +6207,21 @@ function xdgStateHome() {
 	const value = readEnv(ENV_XDG_STATE_HOME);
 	return value === void 0 || value.length === 0 ? null : value;
 }
-function lockedRef(path, raw, skill) {
+function lockedSkill(path, raw, skill) {
 	if (raw === null) return null;
 	const parsed = SkillLock.safeParse(raw);
 	if (!parsed.success) throw new ConfigError(`${path} is not a skills lock file: ${parsed.error.message}`);
-	return parsed.data.skills[skill]?.ref ?? null;
+	return parsed.data.skills[skill] ?? null;
 }
 const hostSkillFiles = {
 	readJson: readJsonFile,
 	readText: readTextFile
 };
+const DATA_APP_SKILLS_ORIGIN = {
+	kind: "github",
+	repository: DATA_APP_REPOSITORY,
+	ref: DATA_APP_BRANCH
+};
 const GITHUB_URL = /^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/tree\/([^/]+)(?:\/.*)?)?\/?$/;
 function skillOrigin(source, cwd) {
 	const github = GITHUB_URL.exec(source);
@@ -6071,16 +6302,20 @@ function skillsCli(runner) {
 }
 //#endregion
 //#region src/steps/agents-skills.ts
-const STEP_ID$6 = "agents-skills";
-const AGENTS_SKILLS_KEYS = { agents: `${STEP_ID$6}.agents` };
+const STEP_ID$7 = "agents-skills";
+const AGENTS_SKILLS_KEYS = { agents: `${STEP_ID$7}.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 DETECT_AGENTS = { kind: "detected" };
-function hostDeps$10(ctx) {
+function hostDeps$11(ctx) {
 	return {
 		runner: processRunner(ctx.signal),
 		probe: hostAgentProbe(),
-		skillSource: rdeSkillSource()
+		skillSource: rdeSkillSource(),
+		stateHome: xdgStateHome(),
+		files: hostSkillFiles,
+		github: githubContents(ctx.signal),
+		cwd: process.cwd()
 	};
 }
 function detectedOnly(agents) {
@@ -6115,10 +6350,91 @@ function coveredAgentNames(entry, agents) {
 function installedLines(entries, agents) {
 	return entries.map((entry) => `${entry.name} (${coveredAgentNames(entry, agents).join(", ")}): ${entry.path}`).join("\n");
 }
+function skillSets(deps) {
+	return [{
+		label: "data-app",
+		source: DATA_APP_SKILLS_SOURCE,
+		sourceNote: "",
+		origin: DATA_APP_SKILLS_ORIGIN,
+		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 hashLookup(github) {
+	const asked = /* @__PURE__ */ new Map();
+	return (repository, ref, directory) => {
+		const key = JSON.stringify([
+			repository,
+			ref,
+			directory
+		]);
+		let hashes = asked.get(key);
+		if (hashes === void 0) {
+			hashes = github.subdirectoryHashes(repository, ref, directory).catch((error) => {
+				if (lookupFailure(error) === null) throw error;
+				return null;
+			});
+			asked.set(key, hashes);
+		}
+		return hashes;
+	};
+}
+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)]));
+	} catch (error) {
+		if (error instanceof ConfigError) return null;
+		throw error;
+	}
+}
+function lockedCopy(locked, origin) {
+	if (locked === null || locked.source !== origin.repository) return null;
+	const ref = locked.ref ?? null;
+	if (origin.ref !== null && ref !== origin.ref) return null;
+	if (locked.skillPath === null || locked.skillPath === void 0) return null;
+	if (locked.skillFolderHash === null || locked.skillFolderHash === void 0) return null;
+	const folder = posix.dirname(locked.skillPath);
+	return {
+		ref,
+		directory: posix.dirname(folder),
+		folder: posix.basename(folder),
+		hash: locked.skillFolderHash
+	};
+}
+async function setBehind(set, check) {
+	const { origin } = set;
+	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);
+	}
+	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;
+	}
+	return false;
+}
+function hasSkill(installed, skill, agent) {
+	return installed.some((entry) => entry.name === skill && skillCoversAgent(entry, agent));
+}
+function coversAll(installed, skills, agents) {
+	return agents.every((agent) => skills.every((skill) => hasSkill(installed, skill, agent)));
+}
 const SOURCE_NOTES = {
 	override: "from --agents",
 	detected: "detected on this machine",
-	chosen: "as chosen"
+	chosen: "as chosen",
+	installed: "updating the installed copies"
 };
 function agentChoice(agent) {
 	return {
@@ -6136,7 +6452,7 @@ async function askAgents(ctx, detected) {
 	});
 	return detected.filter((agent) => picked.includes(agent.id));
 }
-async function selectAgents(ctx, all, options) {
+async function selectAgents(ctx, all, options, installedNow) {
 	switch (options.kind) {
 		case "detected": return {
 			agents: detectedOnly(all),
@@ -6155,6 +6471,10 @@ async function selectAgents(ctx, all, options) {
 				agents: [],
 				source: "detected"
 			};
+			if (coversAll(await installedNow(), REQUIRED_SKILL_NAMES, detected)) return {
+				agents: detected,
+				source: "installed"
+			};
 			return {
 				agents: await askAgents(ctx, detected),
 				source: "chosen"
@@ -6165,47 +6485,65 @@ async function selectAgents(ctx, all, options) {
 function skipLine(all, source) {
 	switch (source) {
 		case "override":
-		case "chosen": return `Skipping the skills; run \`rde init --only ${STEP_ID$6}\` to install it later`;
-		case "detected": return `No coding agent found (${displayNames(all)}); run \`rde init --only ${STEP_ID$6} --agents <name>\` once one is installed`;
+		case "chosen":
+		case "installed": return `Skipping the skills; run \`rde init --only ${STEP_ID$7}\` to install it later`;
+		case "detected": return `No coding agent found (${displayNames(all)}); run \`rde init --only ${STEP_ID$7} --agents <name>\` once one is installed`;
 	}
 }
-function agentsSkillsStep(options, deps = hostDeps$10) {
+function agentsSkillsStep(options, updates, deps = hostDeps$11) {
+	let hashes = null;
+	async function setCheck(resolved) {
+		hashes ??= hashLookup(resolved.github);
+		return {
+			updates,
+			locked: await readLockedSkills(resolved),
+			hashes
+		};
+	}
 	return {
-		id: STEP_ID$6,
+		id: STEP_ID$7,
 		title: "Install the rde and data-app skills for your coding agents",
 		redoHint: "`rde init --only agents-skills` with it installs the skills for those agents.",
 		async detect(ctx) {
 			const resolved = deps(ctx);
 			const detected = detectedOnly(await detectAgents(resolved.probe));
-			if (detected.length === 0) return ctx.state.steps[STEP_ID$6]?.status === "skipped" ? "not-applicable" : "todo";
-			return missingSkills(await skillsCli(resolved.runner).list(), detected).length === 0 ? "done" : "todo";
+			if (detected.length === 0) return ctx.state.steps[STEP_ID$7]?.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)) if (await setBehind(set, check)) return "outdated";
+			return "done";
 		},
 		async run(ctx) {
 			const resolved = deps(ctx);
+			const skills = skillsCli(resolved.runner);
 			const all = await detectAgents(resolved.probe);
-			const selection = await selectAgents(ctx, all, options);
+			let listing = null;
+			const installedNow = () => listing ??= skills.list();
+			const selection = await selectAgents(ctx, all, options, installedNow);
 			if (selection.agents.length === 0) {
 				ctx.ui.info(skipLine(all, selection.source));
 				return { outcome: "skipped" };
 			}
-			const skills = skillsCli(resolved.runner);
+			const before = await installedNow();
+			const check = await setCheck(resolved);
+			const pending = [];
+			for (const set of skillSets(resolved)) if (!coversAll(before, set.skills, selection.agents) || await setBehind(set, check)) pending.push(set);
+			const names = displayNames(selection.agents);
+			if (pending.length === 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 ${displayNames(selection.agents)} (${SOURCE_NOTES[selection.source]})`;
-			ctx.ui.info(`Installing the data-app skills ${forWhom}`);
-			await skills.add({
-				source: DATA_APP_SKILLS_SOURCE,
-				skills: DATA_APP_SKILL_NAMES,
-				agents,
-				output: ctx.ui.childOutput
-			});
-			const from = resolved.skillSource === "https://github.com/metabase/agent-skills/tree/main" ? "" : ` from ${resolved.skillSource}`;
-			ctx.ui.info(`Installing the rde skills ${forWhom}${from}`);
-			await skills.add({
-				source: resolved.skillSource,
-				skills: RDE_SOURCE_SKILL_NAMES,
-				agents,
-				output: ctx.ui.childOutput
-			});
+			const forWhom = `for ${names} (${SOURCE_NOTES[selection.source]})`;
+			for (const set of pending) {
+				ctx.ui.info(`Installing the ${set.label} skills ${forWhom}${set.sourceNote}`);
+				await skills.add({
+					source: set.source,
+					skills: set.skills,
+					agents,
+					output: ctx.ui.childOutput
+				});
+			}
 			const installed = 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(", ")}`);
@@ -6217,7 +6555,7 @@ function agentsSkillsStep(options, deps = hostDeps$10) {
 }
 //#endregion
 //#region src/steps/databases.ts
-const STEP_ID$5 = "databases";
+const STEP_ID$6 = "databases";
 const SAMPLE_STANDS_IN = { request: "sample-stands-in" };
 function hostDatabasesDeps(signal) {
 	return {
@@ -6226,7 +6564,7 @@ function hostDatabasesDeps(signal) {
 		now: () => /* @__PURE__ */ new Date()
 	};
 }
-function isNotServingYet$1(error) {
+function isNotServingYet$2(error) {
 	return error instanceof MetabaseUnreachableError || error instanceof MetabaseInitializingError;
 }
 function requireApiKey$2(state, apiKey) {
@@ -6255,14 +6593,15 @@ function authenticatedClient(state, apiKey, deps) {
 	});
 }
 async function listDatabases(state, apiKey, deps) {
-	const listed = await authenticatedClient(state, apiKey, deps).database.list();
+	const listed = await authenticatedClient(state, apiKey, deps).database.listWithStubs();
 	const records = new Map(state.databases.map((record) => [record.id, record]));
 	const onServer = listed.data.map((database) => ({
 		id: database.id,
 		name: database.name,
 		engine: database.engine,
 		initialSyncStatus: database.initial_sync_status,
-		createdAt: records.get(database.id)?.createdAt ?? null
+		createdAt: records.get(database.id)?.createdAt ?? null,
+		stub: isStub(database)
 	}));
 	const serverIds = new Set(listed.data.map((database) => database.id));
 	const missing = state.databases.filter((record) => !serverIds.has(record.id)).map((record) => ({
@@ -6270,24 +6609,27 @@ async function listDatabases(state, apiKey, deps) {
 		name: record.name,
 		engine: record.engine,
 		initialSyncStatus: null,
-		createdAt: record.createdAt
+		createdAt: record.createdAt,
+		stub: false
 	}));
 	return [...onServer, ...missing];
 }
-async function connectDatabases(ctx, deps, start) {
+async function connectDatabases(ctx, deps, opening) {
 	const configured = requireConfiguredRuntime(ctx.state);
 	const client = authenticatedClient(ctx.state, ctx.secrets.apiKey, deps);
-	const properties = await client.session.properties();
-	const existing = await client.database.list();
-	if (existing.data.length > 0) ctx.ui.note(existingDatabaseLines(existing.data).join("\n"), "Connected databases");
+	const engines = await client.setting.engines();
+	const listed = await client.database.listWithStubs();
+	const existing = listed.data.filter((database) => !isStub(database));
+	if (existing.length > 0) ctx.ui.note(existingDatabaseLines(existing).join("\n"), "Connected databases");
 	const result = await runDatabaseFlow({
-		start,
+		...opening,
+		stubs: listed.data.filter(isStub),
 		prompts: ctx.prompts,
 		ui: ctx.ui,
-		catalog: engineCatalog(properties.engines),
+		catalog: engineCatalog(engines),
 		hostAlias: hostAliasOf(configured.runtime),
 		database: client.database,
-		existingCount: existing.data.length,
+		existingCount: existing.length,
 		readTextFile: deps.readTextFile,
 		onCreated: async (database) => {
 			const record = toRecord$1(database, deps.now().toISOString());
@@ -6297,27 +6639,34 @@ async function connectDatabases(ctx, deps, start) {
 			});
 		}
 	});
+	if (result.stubsLeft.length > 0) ctx.ui.info(unconnectedStubsLine(result.stubsLeft));
 	return {
-		existing: existing.data.length,
+		existing: existing.length,
 		created: result.created.length,
 		added: result.added
 	};
 }
-async function addDatabases(ctx, deps) {
-	const connected = await connectDatabases(ctx, deps, "engine");
+async function addDatabases(ctx, deps, options) {
+	const connected = await connectDatabases(ctx, deps, {
+		start: "engine",
+		...options
+	});
 	return {
 		outcome: connected.existing + connected.created > 0 ? "completed" : "skipped",
 		result: { addedDatabases: connected.added }
 	};
 }
 async function askForOwnDatabase(ctx, deps) {
-	const connected = await connectDatabases(ctx, deps, "connection-string");
+	const connected = await connectDatabases(ctx, deps, {
+		start: "connection-string",
+		offerStubs: true
+	});
 	return {
 		outcome: connected.created > 0 ? "completed" : "skipped",
 		result: { addedDatabases: connected.added }
 	};
 }
-function hostDeps$9(ctx) {
+function hostDeps$10(ctx) {
 	return {
 		...hostDatabasesDeps(ctx.signal),
 		instanceRunning: () => isInstanceRunning(ctx.state, hostRuntimeDeps(ctx.state.name, ctx.signal))
@@ -6327,15 +6676,15 @@ function sampleDatabaseId(state) {
 	return state.sampleDatabase === null ? null : state.sampleDatabase.databaseId;
 }
 function skippedBefore(state) {
-	return state.steps[STEP_ID$5]?.status === "skipped";
+	return state.steps[STEP_ID$6]?.status === "skipped";
 }
 function ownDatabaseIds(state) {
 	const sampleId = sampleDatabaseId(state);
 	return new Set(state.databases.filter((record) => record.id !== sampleId).map((record) => record.id));
 }
-function databasesStep(options, deps = hostDeps$9) {
+function databasesStep(options, deps = hostDeps$10) {
 	return {
-		id: STEP_ID$5,
+		id: STEP_ID$6,
 		title: "Connect your databases",
 		redoHint: "Connect another with `rde db add --url <connection string>`.",
 		async detect(ctx) {
@@ -6358,22 +6707,40 @@ function databasesStep(options, deps = hostDeps$9) {
 			try {
 				return (await client.database.list()).data.some((database) => isOwn(database.id)) ? "done" : "todo";
 			} catch (error) {
-				if (isNotServingYet$1(error) || isRejectedCredential(error)) return "todo";
+				if (isNotServingYet$2(error) || isRejectedCredential(error)) return "todo";
 				throw error;
 			}
 		},
 		async run(ctx) {
 			switch (options.request) {
 				case "ask-once": return askForOwnDatabase(ctx, deps(ctx));
-				case "named": return addDatabases(ctx, deps(ctx));
+				case "named": return addDatabases(ctx, deps(ctx), { offerStubs: false });
 				case "sample-stands-in": return { outcome: "skipped" };
 			}
 		}
 	};
 }
 //#endregion
+//#region src/metabase/domain/npm-package.ts
+const NpmVersionManifest = z.object({ version: z.string() }).loose();
+//#endregion
+//#region src/metabase/npm-registry.ts
+const NPM_REGISTRY = "https://registry.npmjs.org";
+function npmRegistry(signal, options = {}) {
+	const http = createHttp({
+		baseUrl: NPM_REGISTRY,
+		auth: NO_AUTH,
+		signal,
+		...options
+	});
+	return { async distTagVersion(packageName, tag) {
+		const path = `/${encodeURIComponent(packageName)}/${encodeURIComponent(tag)}`;
+		return (await http.requestJson("GET", path, { schema: NpmVersionManifest })).version;
+	} };
+}
+//#endregion
 //#region src/steps/install-mb.ts
-const STEP_ID$4 = "install-mb";
+const STEP_ID$5 = "install-mb";
 const MIN_MB_VERSION = "0.3.0";
 const MB_RANGE = `>=${MIN_MB_VERSION}`;
 function installedWith(scriptPath) {
@@ -6382,11 +6749,12 @@ function installedWith(scriptPath) {
 function rdeInstalledWith() {
 	return installedWith(process.argv[1]);
 }
-function hostDeps$8(ctx) {
+function hostDeps$9(ctx) {
 	return {
 		runner: processRunner(ctx.signal),
 		installedWith: rdeInstalledWith(),
-		locate: locateMbOnPath
+		locate: locateMbOnPath,
+		publishedVersion: () => npmRegistry(ctx.signal).distTagVersion(MB_PACKAGE, MB_DIST_TAG)
 	};
 }
 async function inspectMb(runner) {
@@ -6400,6 +6768,38 @@ async function inspectMb(runner) {
 		satisfies: semver.satisfies(version, MB_RANGE, { includePrerelease: true })
 	};
 }
+const UNCHECKED = { kind: "unchecked" };
+async function publishedMb(deps) {
+	let raw;
+	try {
+		raw = await deps.publishedVersion();
+	} catch (error) {
+		const reason = lookupFailure(error);
+		if (reason === null) throw error;
+		return {
+			kind: "unknown",
+			reason
+		};
+	}
+	const version = semver.valid(raw);
+	if (version === null) return {
+		kind: "unknown",
+		reason: `the registry names "${raw}" for ${MB_DIST_TAG}, which is not a version`
+	};
+	return {
+		kind: "published",
+		version
+	};
+}
+function coreOf(version) {
+	return `${semver.major(version)}.${semver.minor(version)}.${semver.patch(version)}`;
+}
+function updateTo(release, installed) {
+	if (release.kind !== "published" || release.version === installed) return null;
+	const order = semver.compare(coreOf(installed), coreOf(release.version));
+	if (order === 0) return semver.prerelease(installed) === null ? null : release.version;
+	return order < 0 ? release.version : null;
+}
 function displayCommand(install) {
 	return [install.command, ...install.args].join(" ");
 }
@@ -6498,27 +6898,66 @@ async function stillWrong(install, after, deps) {
 		`${stillWrongAdvice(diagnosis)}.`
 	].join(" "));
 }
-function installMbStep(deps = hostDeps$8) {
+async function shadowedWarning(lead, deps) {
+	const found = await inspectMbOnPath(deps.runner, deps.locate);
+	const diagnosis = diagnoseMb(found, deps.installedWith);
+	const advice = diagnosis.kind === "shadowed" ? ` ${shadowedHint(diagnosis)}.` : "";
+	return `${lead} Every mb on PATH, in order: ${mbPathLines(found).join("; ")}.${advice}`;
+}
+async function updateFor(release, installed, deps) {
+	const version = updateTo(release, installed);
+	if (version === null) return { kind: "current" };
+	return (await inspectMbOnPath(deps.runner, deps.locate)).some((entry) => entry.version === version) ? {
+		kind: "shadowed",
+		version
+	} : {
+		kind: "update",
+		version
+	};
+}
+function installMbStep(updates, deps = hostDeps$9) {
+	let published = null;
+	function release(resolved) {
+		if (updates === "installed") return Promise.resolve(UNCHECKED);
+		published ??= publishedMb(resolved);
+		return published;
+	}
 	return {
-		id: STEP_ID$4,
+		id: STEP_ID$5,
 		title: "Install the Metabase CLI",
 		async detect(ctx) {
-			const found = await inspectMb(deps(ctx).runner);
-			return found.installed && found.satisfies ? "done" : "todo";
+			const resolved = deps(ctx);
+			const found = await inspectMb(resolved.runner);
+			if (!found.installed || !found.satisfies) return "todo";
+			return (await updateFor(await release(resolved), found.version, resolved)).kind === "update" ? "outdated" : "done";
 		},
 		async run(ctx) {
 			const resolved = deps(ctx);
 			const before = await inspectMb(resolved.runner);
+			const target = await release(resolved);
 			if (before.installed && before.satisfies) {
-				ctx.ui.success(`mb ${before.version} is installed`);
-				return { outcome: "completed" };
-			}
-			if (before.installed) ctx.ui.warn(`mb ${before.version} is installed; ${MIN_MB_VERSION} or newer is required`);
+				if (target.kind === "unknown") ctx.ui.warn(`Could not check for a newer mb: ${target.reason}`);
+				const update = await updateFor(target, before.version, resolved);
+				if (update.kind === "shadowed") {
+					const lead = `mb ${before.version} runs first; ${update.version} is installed later on PATH.`;
+					ctx.ui.warn(await shadowedWarning(lead, resolved));
+				}
+				if (update.kind !== "update") {
+					ctx.ui.success(`mb ${before.version} is installed`);
+					return { outcome: "completed" };
+				}
+				ctx.ui.info(`mb ${before.version} is installed; updating to ${update.version}`);
+			} else if (before.installed) ctx.ui.warn(`mb ${before.version} is installed; ${MIN_MB_VERSION} or newer is required`);
 			const install = mbInstallCommand(resolved.installedWith);
 			ctx.ui.info(`Running ${displayCommand(install)}`);
 			await runShown(resolved.runner, ctx.ui.childOutput, install.command, install.args);
 			const after = await inspectMb(resolved.runner);
 			if (!after.installed || !after.satisfies) throw await stillWrong(install, after, resolved);
+			const stillNewer = updateTo(target, after.version);
+			if (stillNewer !== null) {
+				const lead = `mb ${after.version} still runs first, not the ${stillNewer} just installed.`;
+				ctx.ui.warn(await shadowedWarning(lead, resolved));
+			}
 			ctx.ui.success(`mb ${after.version} is installed`);
 			return { outcome: "completed" };
 		}
@@ -6526,11 +6965,11 @@ function installMbStep(deps = hostDeps$8) {
 }
 //#endregion
 //#region src/steps/license.ts
-const STEP_ID$3 = "license";
-const LICENSE_KEYS = { token: `${STEP_ID$3}.token` };
+const STEP_ID$4 = "license";
+const LICENSE_KEYS = { token: `${STEP_ID$4}.token` };
 const TOKEN_PATTERN = /^[0-9a-f]{64}$/i;
 const NOT_FOUND_STATUS$2 = 404;
-function hostDeps$7(ctx) {
+function hostDeps$8(ctx) {
 	return {
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
 		runner: processRunner(ctx.signal),
@@ -6553,13 +6992,13 @@ function activeLabel(status) {
 	const plan = status["plan-alias"];
 	return plan === void 0 ? "License active" : `License active (plan ${plan})`;
 }
-function licenseStep(deps = hostDeps$7) {
+function licenseStep(deps = hostDeps$8) {
 	return {
-		id: STEP_ID$3,
+		id: STEP_ID$4,
 		title: "Activate your license",
 		redoHint: "`rde init --from license` with it activates the license and runs the steps after it again.",
 		async detect(ctx) {
-			if (ctx.state.steps[STEP_ID$3]?.status === "skipped") return "not-applicable";
+			if (ctx.state.steps[STEP_ID$4]?.status === "skipped") return "not-applicable";
 			const configured = configuredRuntime(ctx.state);
 			if (configured === null || ctx.secrets.apiKey === null) return "todo";
 			const resolved = deps(ctx);
@@ -6650,7 +7089,7 @@ const PLATFORMS = {
 		javaHint: `Install Java 21 or newer with your distribution's package manager (openjdk-21-jre) or from https://adoptium.net`
 	}
 };
-function hostDeps$6(ctx) {
+function hostDeps$7(ctx) {
 	const runner = processRunner(ctx.signal);
 	return {
 		platform: process.platform,
@@ -6772,7 +7211,7 @@ function checkLine(check) {
 function checkLines(checks) {
 	return checks.map(checkLine);
 }
-function preflightStep(deps = hostDeps$6) {
+function preflightStep(deps = hostDeps$7) {
 	return {
 		id: "preflight",
 		title: "Check this machine",
@@ -6791,7 +7230,7 @@ function preflightStep(deps = hostDeps$6) {
 }
 //#endregion
 //#region src/steps/runtime.ts
-const STEP_ID$2 = "runtime";
+const STEP_ID$3 = "runtime";
 const MIN_PORT = 1;
 const MAX_PORT = 65535;
 const PORT_PATTERN = /^\d+$/;
@@ -6805,7 +7244,7 @@ const NO_RUNTIME_FLAGS = {
 	jar: null,
 	port: null
 };
-function hostDeps$5(ctx) {
+function hostDeps$6(ctx) {
 	return {
 		runtime: hostRuntimeDeps(ctx.state.name, ctx.signal),
 		releases: releaseLookup(ctx.signal)
@@ -6934,9 +7373,9 @@ async function persistedRuntime(ctx, options, deps) {
 	});
 	return chosen;
 }
-function runtimeStep(options, deps = hostDeps$5) {
+function runtimeStep(options, deps = hostDeps$6) {
 	return {
-		id: STEP_ID$2,
+		id: STEP_ID$3,
 		title: "Install Metabase",
 		redoHint: "Move it with `rde start --port`, or change its Metabase with `rde upgrade --to`.",
 		async detect(ctx) {
@@ -6962,11 +7401,11 @@ function runtimeStep(options, deps = hostDeps$5) {
 }
 //#endregion
 //#region src/steps/sample-database.ts
-const STEP_ID$1 = "sample-database";
+const STEP_ID$2 = "sample-database";
 const SAMPLE_DATABASE_DISPLAY_NAME = "Sample Database";
 const POSTGRES_ENGINE = "postgres";
 const NOT_FOUND_STATUS$1 = 404;
-function hostDeps$4(ctx) {
+function hostDeps$5(ctx) {
 	return {
 		runtime: hostRuntimeDeps(ctx.state.name, ctx.signal),
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
@@ -6974,7 +7413,7 @@ function hostDeps$4(ctx) {
 		now: () => /* @__PURE__ */ new Date()
 	};
 }
-function isNotServingYet(error) {
+function isNotServingYet$1(error) {
 	return error instanceof MetabaseUnreachableError || error instanceof MetabaseInitializingError;
 }
 function isNotFound$2(error) {
@@ -7117,11 +7556,11 @@ async function connectDatabase(ctx, choice, configured, client, deps) {
 	return database;
 }
 function usageLines(record) {
-	return [`psql "${sampleDatabaseUrl(record.port)}"`, "Transforms are enabled; this database is where they can write."].join("\n");
+	return [`psql "${sampleDatabaseUrl(record.port)}"`, "Transforms can write to this database."].join("\n");
 }
-function sampleDatabaseStep(deps = hostDeps$4) {
+function sampleDatabaseStep(deps = hostDeps$5) {
 	return {
-		id: STEP_ID$1,
+		id: STEP_ID$2,
 		title: "Connect a sample database",
 		async detect(ctx) {
 			const resolved = deps(ctx);
@@ -7137,7 +7576,7 @@ function sampleDatabaseStep(deps = hostDeps$4) {
 			try {
 				return await recordedDatabase(record, client) === null ? "todo" : "done";
 			} catch (error) {
-				if (isNotServingYet(error) || isRejectedCredential(error)) return "todo";
+				if (isNotServingYet$1(error) || isRejectedCredential(error)) return "todo";
 				throw error;
 			}
 		},
@@ -7149,16 +7588,13 @@ function sampleDatabaseStep(deps = hostDeps$4) {
 			if (!docker.available) throw new ConfigError(`the sample database runs in Docker, which is not available: ${docker.reason}`);
 			const persisted = await persistedRecord(ctx, resolved);
 			const record = await installAndStart(ctx, sampleDatabaseContainer(persisted.record, resolved.runtime.docker, resolved.runtime.rdeHome), persisted.record, resolved);
-			const choice = {
+			await connectDatabase(ctx, {
 				...persisted,
 				record
-			};
-			const client = resolved.client(configured.url, {
+			}, configured, resolved.client(configured.url, {
 				kind: "api-key",
 				key: apiKey
-			});
-			await connectDatabase(ctx, choice, configured, client, resolved);
-			await client.setting.enableTransforms();
+			}), resolved);
 			ctx.ui.note(usageLines(record), "Sample database");
 			return { outcome: "completed" };
 		}
@@ -7169,7 +7605,7 @@ const DEFAULT_HEALTH_TIMING = { timeoutMs: 3e5 };
 //#region src/steps/start-metabase.ts
 const LOG_TAIL_ON_TIMEOUT = 30;
 const PERCENT = 100;
-function hostDeps$3(ctx) {
+function hostDeps$4(ctx) {
 	return {
 		runtime: hostRuntimeDeps(ctx.state.name, ctx.signal),
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
@@ -7213,7 +7649,7 @@ async function startRuntime(ctx, runtime, deps) {
 		throw error;
 	}
 }
-function startMetabaseStep(deps = hostDeps$3) {
+function startMetabaseStep(deps = hostDeps$4) {
 	return {
 		id: "start-metabase",
 		title: "Start Metabase",
@@ -7273,9 +7709,9 @@ function startMetabaseStep(deps = hostDeps$3) {
 }
 //#endregion
 //#region src/steps/summary.ts
-const STEP_ID = "summary";
+const STEP_ID$1 = "summary";
 const GIT_SYNC_STEP_ID = "git-sync";
-function hostDeps$2(ctx) {
+function hostDeps$3(ctx) {
 	return {
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
 		runner: processRunner(ctx.signal),
@@ -7299,14 +7735,21 @@ async function databaseLines$1(state, apiKey, deps) {
 		databases = (await deps.client(state.url, {
 			kind: "api-key",
 			key: apiKey
-		}).database.list()).data;
+		}).database.listWithStubs()).data;
 	} catch (error) {
 		if (isNotServing$1(error)) return ["Databases: Metabase is not running; `rde start`"];
 		if (isRejectedCredential(error)) return ["Databases: Metabase rejects the stored API key; `rde init --only api-key`"];
 		throw error;
 	}
-	if (databases.length === 0) return ["Databases: none connected yet; `rde db add`"];
-	return ["Databases:", ...existingDatabaseLines(databases).map((line) => `  ${line}`)];
+	const connected = databases.filter((database) => !isStub(database));
+	const stubs = databases.filter(isStub);
+	const stubLines = stubs.length === 0 ? [] : [unconnectedStubsLine(stubs)];
+	if (connected.length === 0) return ["Databases: none connected yet; `rde db add`", ...stubLines];
+	return [
+		"Databases:",
+		...existingDatabaseLines(connected).map((line) => `  ${line}`),
+		...stubLines
+	];
 }
 function remoteLine(remote) {
 	switch (remote.kind) {
@@ -7353,9 +7796,9 @@ async function summaryLines(state, apiKey, deps) {
 	lines.push("Lifecycle: rde status (--json for scripts), rde stop, rde start");
 	return lines;
 }
-function summaryStep(deps = hostDeps$2) {
+function summaryStep(deps = hostDeps$3) {
 	return {
-		id: STEP_ID,
+		id: STEP_ID$1,
 		title: "Summary",
 		async detect() {
 			return "todo";
@@ -7368,21 +7811,76 @@ function summaryStep(deps = hostDeps$2) {
 	};
 }
 //#endregion
+//#region src/steps/transforms.ts
+const STEP_ID = "transforms";
+function hostDeps$2(ctx) {
+	return {
+		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
+		instanceRunning: () => isInstanceRunning(ctx.state, hostRuntimeDeps(ctx.state.name, ctx.signal))
+	};
+}
+function isNotServingYet(error) {
+	return error instanceof MetabaseUnreachableError || error instanceof MetabaseInitializingError;
+}
+function transformsStep(deps = hostDeps$2) {
+	return {
+		id: STEP_ID,
+		title: "Enable transforms",
+		async detect(ctx) {
+			const configured = configuredRuntime(ctx.state);
+			if (configured === null || ctx.secrets.apiKey === null) return "todo";
+			const resolved = deps(ctx);
+			if (!await resolved.instanceRunning()) return "todo";
+			const client = resolved.client(configured.url, {
+				kind: "api-key",
+				key: ctx.secrets.apiKey
+			});
+			try {
+				return await client.setting.transformsDecided() ? "done" : "todo";
+			} catch (error) {
+				if (isNotServingYet(error) || isRejectedCredential(error)) return "todo";
+				throw error;
+			}
+		},
+		async run(ctx) {
+			const configured = requireConfiguredRuntime(ctx.state);
+			if (ctx.secrets.apiKey === null) throw new ConfigError("no API key yet; the api-key step comes first");
+			const client = deps(ctx).client(configured.url, {
+				kind: "api-key",
+				key: ctx.secrets.apiKey
+			});
+			if (await client.setting.transformsDecided()) {
+				ctx.ui.info("Transforms are already set in Metabase; leaving them as they are");
+				return { outcome: "completed" };
+			}
+			await client.setting.enableTransforms();
+			ctx.ui.success("Transforms enabled");
+			return { outcome: "completed" };
+		}
+	};
+}
+//#endregion
 //#region src/steps/index.ts
 const DEFAULT_STEP_OPTIONS = {
 	runtime: NO_RUNTIME_FLAGS,
 	agents: DETECT_AGENTS,
 	admin: DEFAULT_ADMIN,
-	databases: SAMPLE_STANDS_IN
+	databases: SAMPLE_STANDS_IN,
+	updates: "published"
+};
+const LOCAL_STEP_OPTIONS = {
+	...DEFAULT_STEP_OPTIONS,
+	updates: "installed"
 };
 const STEP_BY_ID = {
 	preflight: () => preflightStep(),
-	"install-mb": () => installMbStep(),
-	"agents-skills": (options) => agentsSkillsStep(options.agents),
+	"install-mb": (options) => installMbStep(options.updates),
+	"agents-skills": (options) => agentsSkillsStep(options.agents, options.updates),
 	runtime: (options) => runtimeStep(options.runtime),
 	"start-metabase": () => startMetabaseStep(),
 	"admin-user": (options) => adminUserStep(options.admin),
 	"api-key": () => apiKeyStep(),
+	transforms: () => transformsStep(),
 	"sample-database": () => sampleDatabaseStep(),
 	license: () => licenseStep(),
 	databases: (options) => databasesStep(options.databases),
@@ -7555,7 +8053,8 @@ function stepOptionsFrom(answers, run) {
 		},
 		agents: agentsOption(agents, run),
 		admin: admin === void 0 ? DEFAULT_STEP_OPTIONS.admin : { variant: admin.variant },
-		databases: { request: databasesRequest(databases, run) }
+		databases: { request: databasesRequest(databases, run) },
+		updates: DEFAULT_STEP_OPTIONS.updates
 	};
 }
 function keyedAnswers(answers) {
@@ -8161,6 +8660,7 @@ var SessionCache = class {
 const CHECKLIST_MARK = {
 	done: "✓",
 	todo: "○",
+	outdated: "↑",
 	"not-applicable": "–"
 };
 const SPINNER_FAILURE_CODE = 1;
@@ -8318,7 +8818,7 @@ const dbAdd = defineRdeCommand({
 		await addDatabases(await createWizardContext(name, {
 			signal: interruptSignal,
 			prompts
-		}), hostDatabasesDeps(interruptSignal));
+		}), hostDatabasesDeps(interruptSignal), { offerStubs: args.url === void 0 });
 	}
 });
 //#endregion
@@ -8401,7 +8901,7 @@ async function turnOf(entry, ctx, options) {
 	if (options.only !== void 0) return "not-selected";
 	if (entry.status === "done") return "done";
 	const status = await entry.step.detect(ctx);
-	return status === "todo" ? "run" : status;
+	return status === "todo" || status === "outdated" ? "run" : status;
 }
 function unusedMessage(step, turn, given) {
 	const hint = step.redoHint === void 0 ? "" : ` ${step.redoHint}`;
@@ -9049,7 +9549,7 @@ function withRef(source, ref) {
 }
 async function copyRef(entry, deps) {
 	const path = entry.scope === GLOBAL_SCOPE ? globalSkillLockPath(deps.probe.home, deps.skills.stateHome) : projectSkillLockPath(deps.skills.cwd);
-	return lockedRef(path, await deps.skills.files.readJson(path), entry.name);
+	return lockedSkill(path, await deps.skills.files.readJson(path), entry.name)?.ref ?? null;
 }
 async function judgeCopy(entry, origin, deps) {
 	const where = `${entry.scope} ${entry.path}`;
@@ -9311,7 +9811,7 @@ const doctor = defineRdeCommand({
 				signal: interruptSignal,
 				prompts
 			});
-			if (await fixDoctor(report, initSteps(DEFAULT_STEP_OPTIONS), ctx, { yes: args.yes })) report = await collectDoctor(name, ctx.state, ctx.secrets, deps);
+			if (await fixDoctor(report, initSteps(LOCAL_STEP_OPTIONS), ctx, { yes: args.yes })) report = await collectDoctor(name, ctx.state, ctx.secrets, deps);
 		}
 		print(report, args.json);
 		if (report.failed > 0) throw new Error(doctorSummary(report));
@@ -9360,7 +9860,8 @@ function applyDatabaseRecord(draft, record) {
 	const value = stringOf(record.answer);
 	const skippedConnection = record.key === DATABASE_KEYS.connection && value?.trim() === "";
 	const finished = parseDatabaseKey(record.key)?.name === "engine" && value === "finish";
-	if (skippedConnection || finished) draft.databasesFinished = true;
+	const pickedNoStub = record.key === DATABASE_KEYS.stubs && record.answer.kind === "multiselect" && record.answer.values.length === 0;
+	if (skippedConnection || finished || pickedNoStub) draft.databasesFinished = true;
 }
 function applyAdminRecord(draft, key, value) {
 	if (key === ADMIN_USER_KEYS.email && value !== null) admin(draft).email = value;
@@ -9812,7 +10313,7 @@ const start = defineRdeCommand({
 const SUMMARY_STEP_ID = "summary";
 function hostStatusDeps(instanceName, signal) {
 	return {
-		steps: initSteps(DEFAULT_STEP_OPTIONS),
+		steps: initSteps(LOCAL_STEP_OPTIONS),
 		runtime: hostRuntimeDeps(instanceName, signal),
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, signal),
 		runner: processRunner(signal)
@@ -10737,7 +11238,7 @@ const upgradeCommand = defineRdeCommand({
 const main = defineCommand({
 	meta: {
 		name: "rde",
-		version: "0.1.12",
+		version: "0.1.14",
 		description: "Prepares a local machine for data-engineering work with Metabase and coding agents"
 	},
 	subCommands: {