@metabase/cli 0.1.15 → 0.1.17

package/dist/field-B-UcqFzm.mjs

@@ -1,18 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/field/index.ts
-var field_default = defineCommand({
-	meta: {
-		name: "field",
-		description: "Manage Metabase fields"
-	},
-	subCommands: {
-		get: () => import("./get-RQFSmnpY.mjs").then((m) => m.default),
-		values: () => import("./values-DMYpkoEH.mjs").then((m) => m.default),
-		summary: () => import("./summary-RgLcBcEh.mjs").then((m) => m.default),
-		update: () => import("./update-DoQpy9SA.mjs").then((m) => m.default)
-	}
-});
-
-//#endregion
-export { field_default as default };

package/dist/git-sync-CwOvcUI2.mjs

@@ -1,28 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/git-sync/index.ts
-var git_sync_default = defineCommand({
-	meta: {
-		name: "git-sync",
-		description: "Sync Metabase content with a git remote"
-	},
-	subCommands: {
-		status: () => import("./status-BKF9rRnk.mjs").then((mod) => mod.default),
-		"is-dirty": () => import("./is-dirty-MT0BT4CS.mjs").then((mod) => mod.default),
-		"has-remote-changes": () => import("./has-remote-changes-B6YEMC90.mjs").then((mod) => mod.default),
-		dirty: () => import("./dirty-DoEZRSGB.mjs").then((mod) => mod.default),
-		"current-task": () => import("./current-task-rW54KJax.mjs").then((mod) => mod.default),
-		"cancel-task": () => import("./cancel-task-BHnzRQKL.mjs").then((mod) => mod.default),
-		wait: () => import("./wait-BzIAj8lJ.mjs").then((mod) => mod.default),
-		import: () => import("./import-Bl2Wj9Xf.mjs").then((mod) => mod.default),
-		export: () => import("./export-Bgv5B4_F.mjs").then((mod) => mod.default),
-		stash: () => import("./stash-BV4sEp73.mjs").then((mod) => mod.default),
-		branches: () => import("./branches-Ct3PK5U3.mjs").then((mod) => mod.default),
-		"create-branch": () => import("./create-branch-jPE7nW-E.mjs").then((mod) => mod.default),
-		"add-collection": () => import("./add-collection-Bnuh0d4j.mjs").then((mod) => mod.default),
-		"remove-collection": () => import("./remove-collection-BwcFi8Fs.mjs").then((mod) => mod.default)
-	}
-});
-
-//#endregion
-export { git_sync_default as default };

package/dist/is-dirty-MT0BT4CS.mjs

@@ -1,9 +0,0 @@
-import "./command-augment-CAur0XOQ.mjs";
-import "./error-D5bZ5BUX.mjs";
-import "./runtime-C1QgWHM7.mjs";
-import "./capabilities-BX1rnVuH.mjs";
-import "./poll-CYkX02Bm.mjs";
-import "./poll-task-oXpl3wzp.mjs";
-import { IsDirtyResult, is_dirty_default } from "./is-dirty-D9MoFj0T.mjs";
-
-export { is_dirty_default as default };

package/dist/list-Cx8JxS2C.mjs

@@ -1,42 +0,0 @@
-import "./command-augment-CAur0XOQ.mjs";
-import { listEnvelopeSchema, outputFlags, wrapList } from "./error-D5bZ5BUX.mjs";
-import { defineMetabaseCommand } from "./runtime-C1QgWHM7.mjs";
-import { renderList } from "./capabilities-BX1rnVuH.mjs";
-import { loadVisibleSkills } from "./skills-CJ8g8fhQ.mjs";
-import { z } from "zod";
-
-//#region src/commands/skills/list.ts
-const SkillSummary = z.object({
-	name: z.string(),
-	description: z.string()
-});
-const SkillListEnvelope = listEnvelopeSchema(SkillSummary);
-const skillSummaryView = {
-	compactPick: SkillSummary,
-	tableColumns: [{
-		key: "name",
-		label: "Name"
-	}, {
-		key: "description",
-		label: "Description"
-	}]
-};
-var list_default = defineMetabaseCommand({
-	meta: {
-		name: "list",
-		description: "List CLI-bundled skills — always consult the matching skill before acting on a task; they are the source of truth for every workflow."
-	},
-	args: { ...outputFlags },
-	outputSchema: SkillListEnvelope,
-	examples: ["mb skills list", "mb skills list --json"],
-	run({ ctx }) {
-		const items = loadVisibleSkills().map((s) => ({
-			name: s.name,
-			description: s.description
-		}));
-		renderList(wrapList(items), skillSummaryView, ctx);
-	}
-});
-
-//#endregion
-export { list_default as default };

package/dist/measure-BIAoqgcS.mjs

@@ -1,19 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/measure/index.ts
-var measure_default = defineCommand({
-	meta: {
-		name: "measure",
-		description: "Manage Metabase measures"
-	},
-	subCommands: {
-		list: () => import("./list-DfoNv0gb.mjs").then((mod) => mod.default),
-		get: () => import("./get-DLRBq8kR.mjs").then((mod) => mod.default),
-		create: () => import("./create-D3cVDtxM.mjs").then((mod) => mod.default),
-		update: () => import("./update-BXZBEeUp.mjs").then((mod) => mod.default),
-		archive: () => import("./archive-Drt-rWvU.mjs").then((mod) => mod.default)
-	}
-});
-
-//#endregion
-export { measure_default as default };

package/dist/publish-CGUkIqSm.mjs

@@ -1,70 +0,0 @@
-import { ConfigError } from "./command-augment-CAur0XOQ.mjs";
-import { connectionFlags, outputFlags, profileFlag } from "./error-D5bZ5BUX.mjs";
-import { defineMetabaseCommand } from "./runtime-C1QgWHM7.mjs";
-import { renderSummary } from "./capabilities-BX1rnVuH.mjs";
-import { parseId } from "./parse-id-DNPeV0Iu.mjs";
-import { Collection, CollectionCompact } from "./collection-Deiziuu2.mjs";
-import { parseTableSelectors, tableSelectorFlags } from "./selectors-DPc2ZDdd.mjs";
-import { z } from "zod";
-
-//#region src/commands/table/publish.ts
-const TablePublishResult = z.object({ target_collection: Collection.nullable() });
-const TablePublishResultCompact = z.object({ target_collection: CollectionCompact.nullable() });
-const tablePublishResultView = {
-	compactPick: TablePublishResultCompact,
-	tableColumns: [{
-		key: "target_collection",
-		label: "Target collection"
-	}]
-};
-var publish_default = defineMetabaseCommand({
-	meta: {
-		name: "publish",
-		description: "Publish tables (and their upstream dependencies) to a library collection"
-	},
-	details: "Sets the collection for each selected table and recursively for every upstream table it depends on, surfacing them as trusted data sources in the library. Select tables with --table-ids, whole databases with --db-ids, or schemas with --schemas (each schema id is \"<db-id>:<schema>\", e.g. 1:public); the filters are combined. The target must be a `library-data` collection.",
-	capabilities: {
-		minVersion: 59,
-		tokenFeature: "library"
-	},
-	args: {
-		...outputFlags,
-		...profileFlag,
-		...connectionFlags,
-		"collection-id": {
-			type: "string",
-			description: "Target library collection id"
-		},
-		...tableSelectorFlags
-	},
-	outputSchema: TablePublishResult,
-	examples: [
-		"mb table publish --collection-id 12 --table-ids 1,2,3",
-		"mb table publish --collection-id 12 --db-ids 1 --json",
-		"mb table publish --collection-id 12 --schemas 1:public,1:analytics"
-	],
-	async run({ args, ctx, getClient }) {
-		const collectionRaw = args["collection-id"];
-		if (collectionRaw === void 0 || collectionRaw === "") throw new ConfigError("provide a target library collection with --collection-id <id>");
-		const collectionId = parseId(collectionRaw, "collection id");
-		const selectors = parseTableSelectors(args);
-		const body = {
-			collection_id: collectionId,
-			...selectors
-		};
-		const client = await getClient();
-		const result = await client.requestParsed(TablePublishResult, "/api/ee/data-studio/table/publish-tables", {
-			method: "POST",
-			body
-		});
-		renderSummary(result, tablePublishResultView, summaryLine(result), ctx);
-	}
-});
-function summaryLine(result) {
-	const collection = result.target_collection;
-	if (collection === null) return "Published tables to the library.";
-	return `Published tables to collection ${collection.id} "${collection.name}".`;
-}
-
-//#endregion
-export { publish_default as default };

package/dist/segment-BN8sFunv.mjs

@@ -1,19 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/segment/index.ts
-var segment_default = defineCommand({
-	meta: {
-		name: "segment",
-		description: "Manage Metabase segments"
-	},
-	subCommands: {
-		list: () => import("./list-DcjenlTM.mjs").then((mod) => mod.default),
-		get: () => import("./get-CqnCaosn.mjs").then((mod) => mod.default),
-		create: () => import("./create-fIDFkdox.mjs").then((mod) => mod.default),
-		update: () => import("./update-DR4WkAET.mjs").then((mod) => mod.default),
-		archive: () => import("./archive-Blc1dz8Z.mjs").then((mod) => mod.default)
-	}
-});
-
-//#endregion
-export { segment_default as default };

package/dist/setting-zZjcOPyE.mjs

@@ -1,17 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/setting/index.ts
-var setting_default = defineCommand({
-	meta: {
-		name: "setting",
-		description: "Inspect and update Metabase settings"
-	},
-	subCommands: {
-		list: () => import("./list-CoRX8Ruc.mjs").then((m) => m.default),
-		get: () => import("./get-D9o38nK5.mjs").then((m) => m.default),
-		set: () => import("./set-X2N6x7pe.mjs").then((m) => m.default)
-	}
-});
-
-//#endregion
-export { setting_default as default };

package/dist/snippet-DK0ZA8m5.mjs

@@ -1,19 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/snippet/index.ts
-var snippet_default = defineCommand({
-	meta: {
-		name: "snippet",
-		description: "Manage Metabase native query snippets"
-	},
-	subCommands: {
-		list: () => import("./list-cnqPlJgC.mjs").then((mod) => mod.default),
-		get: () => import("./get-B8etVxWD.mjs").then((mod) => mod.default),
-		create: () => import("./create-BDWthCYq.mjs").then((mod) => mod.default),
-		update: () => import("./update-BuypOaXq.mjs").then((mod) => mod.default),
-		archive: () => import("./archive-D-Ovk0-E.mjs").then((mod) => mod.default)
-	}
-});
-
-//#endregion
-export { snippet_default as default };

package/dist/table-COAKXNuj.mjs

@@ -1,21 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/table/index.ts
-var table_default = defineCommand({
-	meta: {
-		name: "table",
-		description: "Manage Metabase tables"
-	},
-	subCommands: {
-		list: () => import("./list-DtrfE0sF.mjs").then((m) => m.default),
-		get: () => import("./get-eUYDNALt.mjs").then((m) => m.default),
-		metadata: () => import("./metadata-DHODjg1d.mjs").then((m) => m.default),
-		fields: () => import("./fields-VA7tXHJz.mjs").then((m) => m.default),
-		update: () => import("./update-DQPg0_-d.mjs").then((m) => m.default),
-		publish: () => import("./publish-CGUkIqSm.mjs").then((m) => m.default),
-		unpublish: () => import("./unpublish-CmaRNjK3.mjs").then((m) => m.default)
-	}
-});
-
-//#endregion
-export { table_default as default };

package/dist/transform-Bto4U82j.mjs

@@ -1,25 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/transform/index.ts
-var transform_default = defineCommand({
-	meta: {
-		name: "transform",
-		description: "Manage Metabase transforms"
-	},
-	subCommands: {
-		list: () => import("./list-DMik04Dh.mjs").then((mod) => mod.default),
-		get: () => import("./get-BgIE_YEg.mjs").then((mod) => mod.default),
-		dependencies: () => import("./dependencies-D2N9eqm1.mjs").then((mod) => mod.default),
-		create: () => import("./create-DxDD6n1d.mjs").then((mod) => mod.default),
-		update: () => import("./update-nwXgVNQa.mjs").then((mod) => mod.default),
-		delete: () => import("./delete-BWO6uB4P.mjs").then((mod) => mod.default),
-		"delete-table": () => import("./delete-table-BXzvDEPG.mjs").then((mod) => mod.default),
-		run: () => import("./run-3eFtdI2Z.mjs").then((mod) => mod.default),
-		cancel: () => import("./cancel-tST8Bh0w.mjs").then((mod) => mod.default),
-		"get-run": () => import("./get-run-CATz-XMS.mjs").then((mod) => mod.default),
-		runs: () => import("./runs-CpRTkn1W.mjs").then((mod) => mod.default)
-	}
-});
-
-//#endregion
-export { transform_default as default };

package/dist/transform-job-_fW1y2tg.mjs

@@ -1,22 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/transform-job/index.ts
-var transform_job_default = defineCommand({
-	meta: {
-		name: "transform-job",
-		description: "Manage Metabase transform jobs"
-	},
-	subCommands: {
-		list: () => import("./list-B5Q7E2Km.mjs").then((mod) => mod.default),
-		get: () => import("./get-DvQoDU2m.mjs").then((mod) => mod.default),
-		create: () => import("./create-DGxZmbxh.mjs").then((mod) => mod.default),
-		update: () => import("./update-B59h7KmS.mjs").then((mod) => mod.default),
-		delete: () => import("./delete-CeigtfRI.mjs").then((mod) => mod.default),
-		run: () => import("./run-C-vftXCu.mjs").then((mod) => mod.default),
-		transforms: () => import("./transforms-BOQ9CG0l.mjs").then((mod) => mod.default),
-		"set-active": () => import("./set-active-BoBa3pOw.mjs").then((mod) => mod.default)
-	}
-});
-
-//#endregion
-export { transform_job_default as default };

package/dist/transform-tag-C8n1oTr1.mjs

@@ -1,18 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/transform-tag/index.ts
-var transform_tag_default = defineCommand({
-	meta: {
-		name: "transform-tag",
-		description: "Manage Metabase transform tags"
-	},
-	subCommands: {
-		list: () => import("./list-DaJk60dd.mjs").then((mod) => mod.default),
-		create: () => import("./create-HZ-9GMLx.mjs").then((mod) => mod.default),
-		update: () => import("./update-Kz4kyqY_.mjs").then((mod) => mod.default),
-		delete: () => import("./delete-CBwztF6P.mjs").then((mod) => mod.default)
-	}
-});
-
-//#endregion
-export { transform_tag_default as default };

package/skill-data/robot-data-engineer/SKILL.md

@@ -1,142 +0,0 @@
----
-name: robot-data-engineer
-description: The front door for turning a database into something a non-technical person can use - clean tables, reusable definitions, dashboards, and answers - all through the `mb` CLI. A light router - it works out where the user is (raw data? clean tables? ready to chart? just need a question answered?), sets up auth and how hands-on they want to be, then loads the right specialized skill. Load when someone wants to "make sense of my data", "build a data model", "go from raw data to a dashboard", "answer questions about my data", "report on who registered / signed up / responded", "analyze X", "be my data analyst / data engineer", "set up analytics for X", or asks for the whole journey rather than one step.
-allowed-tools: Read, Write, Edit, Bash, AskUserQuestion
----
-
-# Robot Data Engineer
-
-You're the front door, not the worker. Point the user at the right tools and get out of the way. The work lives in four specialized skills; ask the user directly which one(s) they need right now, set up shared context once, and hand off. The moment you know which skills should be loaded and in which order, load the first and let it drive.
-
-The three stages:
-
-1. **Raw data → clean tables** — `data-transformation`. Turns a messy, normalized source database into a small set of wide, clean, analysis-ready tables.
-2. **Clean tables → reusable definitions** — `semantic-layer`. Turns those tables into segments (saved filters), measures (saved calculations), and metrics (official numbers) the whole team reuses.
-3. **Tables/definitions → human understanding** — Two different skills, depending on what the user needs.
-   A. Charts and dashboards? `visualization`. Builds the questions and dashboards people look at.
-   B. Plain-language analysis? `data-analysis`. Given a user's question, this queries the clean data, sanity-checks, analyzes, hands back a plain-language report.
-
-Stages 3A and 3B are not sequential, but options: answering-in-prose and charting are two different things you can do with clean data; route to whichever the goal calls for. Users describe a goal, not a stage. Map the goal to a stage, confirm, and route.
-
-In some cases, the user will want to do all of 1-3 sequentially; in other cases, just one or two of the stages.
-
----
-
-## Setup — do this once, up front
-
-Settle two things before routing so the child skills don't re-ask:
-
-1. **Auth.** Pick the profile per `core`'s **Auth & profiles** section — `mb auth list --json`; one → use it, several → ask which, none → ask the user to `mb auth login` — then carry `--profile <name>` into everything. (Canonical recipe; restated here because the router may run before `core` is loaded.)
-
-2. **How hands-on they want to be** (the autonomy slider). Ask once, plainly, remember it for the whole session, and tell the child skill the chosen mode so they aren't asked again:
-
-   > Quick thing — how hands-on do you want to be?
-   > • **Check with me on everything** — I'll run each step past you first.
-   > • **Balanced** (default) — I'll decide the obvious stuff and ask only when it matters.
-   > • **Just go** — I'll do what makes sense and show you the result.
-
-Two things you always own, regardless of mode and regardless of which child ran:
-
-- **When genuinely unsure, ask — never assume.** Pass this expectation down.
-- **The final hard stop.** Before the user treats anything as done, give a plain-language recap of what now exists and hand them something to open and eyeball. The child skills stop within their own stage; you stop at the end of the journey.
-
----
-
-## Shared Contract
-
-This is the single source for the rules every child skill follows. Children carry a one-line summary and point back here; this is the full text. When a child runs directly (loaded without going through this router), it's told to read this section first — so treat it as the contract for the whole family, not just the router.
-
-**Who you're talking to.** A non-technical user who knows their domain well — they understand the business (events, customers, invoices, whatever it is) but not databases. Talk in their terms.
-
-**Jargon.** Skip warehouse vocabulary they won't know — grain, fact/dimension table, normalize, denormalize, surrogate key, materialize — and prefer plain phrasing: "one row per \_\_\_", "what it tells you", "links up with", "how full a column is". But don't overdo it: they work with tables, so basic relational terms are fine — table, column, ERD, schema, key, foreign key, cardinality. **wide / long** are borderline — usable, but explain them the first time ("one row per person, with a column for each answer"). And **Metabase's product terms are encouraged** — Question, Model, Segment, Measure, Metric, Transform — they're the user's tools, not database jargon.
-
-**PII.** Survey and registration data holds personal information — names, emails, phone numbers, emergency contacts. Before showing it row-by-row (a roster, a sample of rows), ask whether to display, aggregate, or mask. Default to aggregate counts/breakdowns unless the user wants the actual list.
-
-**Capability limits — know what you can't do.** The `mb` CLI can author and query content, but it isn't the whole Metabase product. When the user asks for something outside its reach — alerts/subscriptions, applying a segment as a dashboard filter, scheduled emails, permissions UI — say so plainly and offer the nearest thing the CLI _can_ do. Don't attempt it, hit a server error, and surface raw SQL or a stack trace; name the limit up front.
-
-**Permission denied — stop, diagnose, offer a way back.** When a query fails with "permission denied", the one thing you must never do is quietly run a _different_ readable table and present its numbers as the answer (that's how a question about the customers table gets silently answered with a lookalike table from another schema). Instead, in order:
-
-1. **Stop.** Don't substitute another table and pass it off as the answer.
-2. **Surface and diagnose in plain, friendly terms.** Name what was denied and the likely reason. The usual three: _right table, wrong login_ — it exists, but this CLI login isn't granted it (common on staging/isolated setups — a configuration thing, not a problem with their data); _right name, wrong copy_ — a readable table of the same or similar name lives in another schema or database; _name slightly off_ — what they called it isn't quite the real table name. For example: "I can't read `analytics.account` — this login doesn't have access to it. That's usually a staging-permissions thing, not a problem with your data."
-3. **Offer to search — don't auto-crawl.** Ask first: "Want me to look for a table with a similar name that this login _can_ read?" Only on yes, run `mb search <name>` / `mb table list`, and surface any match as a **confirm question**, never as a substituted answer: "There's `dbt_models.account` I can read — did you mean that one?"
-4. **Hand control back.** Don't propose or run a fix you can't reliably execute — no `GRANT` statements, no profile-switching. The recovery is the user's call.
-
-**Scratch files.** Working files — transform/query/patch JSON bodies, notes — go in `./.scratch` in the current working directory, **never `/tmp`**. Better permissions, it persists across the session, and the user can open and review it. `mkdir -p ./.scratch` if it isn't there yet.
-
-**Talking to the user.** Habits that are easy to slip on (see also "Questions must carry their own context" below):
-
-- **Don't reference things they never saw.** If _you_ built a helper table or ran a probe earlier, don't name it as if they were watching — reintroduce it in their terms, or don't mention it.
-- **Assume they read only the last ~30 lines.** Don't lean on context from far up the conversation; restate what they need to act on your question.
-- **Plain permission requests.** Don't paste a wall of SQL or JSON and ask "run this?". Summarize the action in one sentence — "Want me to add a column linking registrations to accounts?" — and offer to show the details if they ask.
-
-**Autonomy slider.** Ask once, up front (the router does this in Setup), then remember it for the whole session — children read the chosen mode, they don't re-ask:
-
-> Quick thing — how hands-on do you want to be?
-> • **Check with me on everything** — I'll run each step past you first.
-> • **Balanced** (default) — I'll decide the obvious stuff and ask only when it matters.
-> • **Just go** — I'll do what makes sense and show you the result.
-
-**When genuinely unsure, ask — never assume.**
-
-**Questions must carry their own context.** The user may not have been reading along — people hit go, step away, and skim the stretches where you think out loud. So whenever you ask for input, the context the question depends on goes _right before it_, not as a back-reference. "Given the mismatch I found earlier, what would you like to do?" forces a scroll-back; lead with a short recap instead:
-
-> I have a question for you — quick recap so it makes sense:
->
-> - I found a mismatch in ...
-> - This matters because ...
-> - Here's what I was thinking, but I need to check ...
->
-> The question.
-
-Recap only the few points the question turns on — enough to answer cold, not a replay of everything you did.
-
-**The final hard stop.** Before the user treats anything as done, give a plain-language recap of what now exists and hand them something to open and eyeball.
-
----
-
-## Work out where they are, then route
-
-Don't make the user name a _stage_ — but do find out _where their data lives_ before you go looking for it.
-
-**Ask before you crawl.** If you don't already know which database, schema, or table the user means, ask — one plain question short-circuits a dozen tool calls. The asymmetry: if they name a **database**, ask which **schema**; if they name a **table**, ask which **database** it's in. "If you don't know, no problem — I'll look" is the fallback, not the opening move. Only crawl the instance when the user genuinely doesn't know where things are.
-
-**When you do crawl — the efficient ladder** (cheap, narrowest-first; never pull whole-warehouse rollups):
-
-- Walk down: `mb db list` → `mb db schemas <id>` → `mb db schema-tables <id> <schema>` → `mb table list [--db-id]` → `mb table fields <id>` / `mb table metadata <id>`.
-- Have a _name_ to look for rather than a tree to walk? Use `mb search <query> [--models] [--db-id]` instead of crawling.
-- Need to know what's actually in a column? `mb field summary <id>` (row/distinct counts) and `mb field values <id>` (sample values).
-- **If a database looks freshly connected, or a table the user expects isn't showing up, offer to sync** — `mb db sync-schema <id> --wait` — before concluding the table doesn't exist.
-
-**Then read the shape to pick a stage.** Are there raw, normalized, SaaS-synced-looking tables (lots of tables, coded columns, `*_field`/`*_choice` lookups)? Or already wide, clean, human-readable ones? Any segments/measures/metrics (`mb segment list`, `mb measure list`, `mb card list`) or dashboards (`mb dashboard list`)?
-
-**Map goal + state to a skill:**
-
-| What the user wants / what's there                                                                                                                             | Load                                                                       |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
-| "Clean up / flatten / make sense of" raw, normalized data; no clean tables yet                                                                                 | `data-transformation`                                                      |
-| Clean tables exist; "make this reusable", "define active customers / revenue / MRR officially", "so everyone uses the same definition"                         | `semantic-layer`                                                           |
-| Tables (and maybe definitions) exist; "chart this", "build a dashboard", "show me X over time"                                                                 | `visualization`                                                            |
-| Clean tables exist; "answer this question", "who registered", "what did people say", "analyze / report on / summarize X" (wants a written answer, not a chart) | `data-analysis`                                                            |
-| "Do the whole thing" / "set up analytics for X" from raw data                                                                                                  | start at `data-transformation`, then continue down the journey (see below) |
-
-Load a skill with `mb skills get <name>`. Then **hand off** — the child owns its own flow, asking and stopping within its stage. Don't narrate the child's work or duplicate its steps.
-
-**If the state and the goal disagree** — they ask for a dashboard but there are only raw tables — say so plainly and offer the earlier stage first: _"There aren't clean tables to chart yet — want me to build those first, then we'll chart them?"_ Don't silently build on raw data.
-
----
-
-## The whole journey
-
-For the full arc (raw → dashboard), run the stages in order, handing off to each child in turn. Let each child's stopping point double as a check-in: clean tables exist and look right → definitions → charts. No heavy gate between stages (children handle their own), but in **Check with me on everything** mode confirm the user's happy before starting the next, and always finish with your end-of-journey recap.
-
-A user can drop in at any stage — that's the point of detecting state. Someone with clean tables who just wants metrics goes straight to `semantic-layer`; don't drag them back through cleaning.
-
----
-
-## Don't
-
-- **Hand the work to the child skill — don't do it yourself.** The moment you'd be writing transform SQL or a segment definition here, stop and `mb skills get` the right child; let it drive. You route and set up context; the child does the work.
-- **Don't re-ask the autonomy question** once it's set; pass it down.
-- **Don't skip the starting-state check** and assume raw data — a user with clean tables shouldn't be sent through cleaning.
-- **Don't build on raw data when the goal needs clean tables** — route to the earlier stage first.
-- **Don't drop the final recap** — you own the end-of-journey hard stop even though each child stops within its own stage.