@metabase/cli 0.4.0-alpha.release-65-integration-branch.31ca6bb → 0.4.1-alpha.fix-transform-test-ee-path.b41b46c

package/dist/{update-DKDQTlnV.mjs → update-Duxk_-dC.mjs}

@@ -1,10 +1,10 @@
-import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
-import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
-import { t as readBody } from "./body-CB2eDFFb.mjs";
+import { J as outputFlags, U as connectionFlags, Y as profileFlag, p as renderSummary } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-C3AL15Dp.mjs";
+import { t as parseId } from "./parse-id-aMXePsUP.mjs";
+import { t as readBody } from "./body-CT1cQrhp.mjs";
 import { t as bodyInputFlags } from "./body-flags-AqKpN01Y.mjs";
 import { i as MeasureUpdateInput, t as Measure } from "./measure-CtfjqJFP.mjs";
-import { o as preflightMbql5Query, r as MEASURE_DEFINITION_LABELS, s as skipValidateFlag } from "./validate-query-BzbZmenf.mjs";
+import { a as preflightMbql5Query, n as MEASURE_DEFINITION_LABELS, o as skipValidateFlag } from "./validate-query-BEYjmSv2.mjs";
 import { t as measureView } from "./measure-4P0bOlZ3.mjs";
 //#region src/commands/measure/update.ts
 var update_default = defineMetabaseCommand({

package/dist/{update-hvO4VpfZ.mjs → update-EpHReUGk.mjs}

@@ -1,11 +1,11 @@
-import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
-import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
-import { t as readBody } from "./body-CB2eDFFb.mjs";
+import { J as outputFlags, U as connectionFlags, Y as profileFlag, p as renderSummary } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-C3AL15Dp.mjs";
+import { t as parseId } from "./parse-id-aMXePsUP.mjs";
+import { t as readBody } from "./body-CT1cQrhp.mjs";
 import { t as bodyInputFlags } from "./body-flags-AqKpN01Y.mjs";
-import { c as CardUpdateInput, t as Card } from "./card-P5mBknsl.mjs";
-import { n as cardView } from "./card-CQNUT9pm.mjs";
-import { o as preflightMbql5Query, s as skipValidateFlag, t as CARD_DATASET_QUERY_LABELS } from "./validate-query-BzbZmenf.mjs";
+import { c as CardUpdateInput, t as Card } from "./card-Bv4ZN0oV.mjs";
+import { n as cardView } from "./card-DSrgU7lT.mjs";
+import { a as preflightMbql5Query, o as skipValidateFlag, t as CARD_DATASET_QUERY_LABELS } from "./validate-query-BEYjmSv2.mjs";
 //#region src/commands/card/update.ts
 var update_default = defineMetabaseCommand({
 	meta: {

package/dist/{update-tltXCUwR.mjs → update-IEVAFvpi.mjs}

@@ -1,7 +1,7 @@
-import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
-import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
-import { t as readBody } from "./body-CB2eDFFb.mjs";
+import { J as outputFlags, U as connectionFlags, Y as profileFlag, p as renderSummary } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-C3AL15Dp.mjs";
+import { t as parseId } from "./parse-id-aMXePsUP.mjs";
+import { t as readBody } from "./body-CT1cQrhp.mjs";
 import { t as bodyInputFlags } from "./body-flags-AqKpN01Y.mjs";
 import { i as TransformTagUpdateInput, t as TransformTag } from "./transform-tag-CcElGp3C.mjs";
 import { t as transformTagView } from "./transform-tag-Dmb4u3-Q.mjs";

package/dist/{update-dashcard-DuTjOh14.mjs → update-dashcard-C4ZndfvP.mjs}

@@ -1,7 +1,7 @@
-import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
-import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
-import { t as readBody } from "./body-CB2eDFFb.mjs";
+import { J as outputFlags, U as connectionFlags, Y as profileFlag, p as renderSummary } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-C3AL15Dp.mjs";
+import { t as parseId } from "./parse-id-aMXePsUP.mjs";
+import { t as readBody } from "./body-CT1cQrhp.mjs";
 import { t as bodyInputFlags } from "./body-flags-AqKpN01Y.mjs";
 import { d as DashcardPatchInput, l as Dashcard } from "./dashboard-Phz3XpRM.mjs";
 import { r as dashcardView } from "./dashboard-XSTr9QCr.mjs";

package/dist/{upgrade-Ca-Ss5jb.mjs → upgrade-o2DpB66j.mjs}

@@ -1,7 +1,7 @@
-import { B as name, V as version, ct as NetworkError, dt as UnknownError, g as writeText, pt as errorMessage, q as outputFlags, rt as AbortError, t as interruptSignal, u as renderItem, ut as TimeoutError, w as promptConfirm } from "./cli.mjs";
-import { P as HttpError, R as parseJson, T as USER_AGENT, t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
-import { n as throwIfAborted, t as combineAborts } from "./signal-CxWeLszu.mjs";
-import { n as streamProcess } from "./process-D0HdqZ3r.mjs";
+import { H as version, J as outputFlags, T as promptConfirm, V as name, _ as writeText, ft as TimeoutError, ht as errorMessage, it as AbortError, pt as UnknownError, t as interruptSignal, u as renderItem, ut as NetworkError } from "./cli.mjs";
+import { P as HttpError, R as parseJson, T as USER_AGENT, t as defineMetabaseCommand } from "./runtime-C3AL15Dp.mjs";
+import { n as throwIfAborted, t as combineAborts } from "./signal-0Yt8JTMn.mjs";
+import { n as streamProcess } from "./process-B3Di_HtV.mjs";
 import { z } from "zod";
 import { realpathSync } from "node:fs";
 import { compare, valid } from "semver";

package/dist/upload-BqNErDXE.mjs

@@ -0,0 +1,13 @@
+import { t as defineCommandGroup } from "./group-D4w87fXL.mjs";
+//#region src/commands/upload/index.ts
+var upload_default = defineCommandGroup({
+	name: "upload",
+	description: "Upload CSV files into Metabase",
+	subCommands: {
+		csv: () => import("./csv-CX1wws5-.mjs").then((m) => m.default),
+		append: () => import("./append-DUFn3_Og.mjs").then((m) => m.default),
+		replace: () => import("./replace-COC3ggyx.mjs").then((m) => m.default)
+	}
+});
+//#endregion
+export { upload_default as default };

package/dist/{upload-t6dkccqn.mjs → upload-CEtKrueq.mjs}

@@ -1,7 +1,7 @@
-import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { J as outputFlags, U as connectionFlags, Y as profileFlag, p as renderSummary } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-C3AL15Dp.mjs";
 import { t as ContentTranslationUploadResult } from "./content-translation-BrHOrmj9.mjs";
-import { n as requireUploadFilePath, t as readCsvFile } from "./upload-C2fhpKkP.mjs";
+import { n as requireUploadFilePath, t as readCsvFile } from "./upload-DJB7DMA1.mjs";
 //#region src/output/views/content-translation.ts
 const contentTranslationUploadView = {
 	compactPick: ContentTranslationUploadResult,

package/dist/{upload-C2fhpKkP.mjs → upload-DJB7DMA1.mjs}

@@ -1,5 +1,5 @@
-import { at as ConfigError, ht as isFileNotFoundError } from "./cli.mjs";
-import { n as fileNotFoundError } from "./input-D8qW-KtR.mjs";
+import { _t as isFileNotFoundError, ot as ConfigError } from "./cli.mjs";
+import { n as fileNotFoundError } from "./input-DjHsV-kD.mjs";
 import { basename } from "node:path";
 import { readFile } from "node:fs/promises";
 //#region src/runtime/upload.ts

package/dist/{uuid-BMlJZT8z.mjs → uuid-D9oozo8p.mjs}

@@ -1,5 +1,5 @@
-import { at as ConfigError, g as writeText, h as writeJson, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand, tt as parseInteger } from "./runtime-B8RtMb4B.mjs";
+import { J as outputFlags, _ as writeText, g as writeJson, ot as ConfigError } from "./cli.mjs";
+import { t as defineMetabaseCommand, tt as parseInteger } from "./runtime-C3AL15Dp.mjs";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
 //#region src/commands/uuid.ts

package/dist/{validate-D7e110oU.mjs → validate-D_iikPkc.mjs}

@@ -1,4 +1,4 @@
-import { C as isPlainObject, _t as escapeJsonPointerSegment, at as ConfigError } from "./cli.mjs";
+import { ot as ConfigError, w as isPlainObject, yt as escapeJsonPointerSegment } from "./cli.mjs";
 import { z } from "zod";
 import Ajv2020 from "ajv/dist/2020.js";
 import addFormats from "ajv-formats";

package/dist/{validate-query-BzbZmenf.mjs → validate-query-BEYjmSv2.mjs}

@@ -1,5 +1,5 @@
-import { at as ConfigError, h as writeJson } from "./cli.mjs";
-import { a as validateQuery, i as isMbql5Query, n as assertNotLegacyEnvelopeWrappingMbql5 } from "./validate-D7e110oU.mjs";
+import { g as writeJson, ot as ConfigError } from "./cli.mjs";
+import { a as validateQuery, i as isMbql5Query, n as assertNotLegacyEnvelopeWrappingMbql5 } from "./validate-D_iikPkc.mjs";
 //#region src/commands/validate-query.ts
 const skipValidateFlag = { "skip-validate": {
 	type: "boolean",
@@ -9,10 +9,6 @@ const CARD_DATASET_QUERY_LABELS = {
 	contextLabel: "card.dataset_query validation failed",
 	bodyNoun: "dataset_query"
 };
-const DATA_ACTION_DATASET_QUERY_LABELS = {
-	contextLabel: "dataAction.dataset_query validation failed",
-	bodyNoun: "dataset_query"
-};
 const TRANSFORM_SOURCE_QUERY_LABELS = {
 	contextLabel: "transform.source.query validation failed",
 	bodyNoun: "source.query"
@@ -35,4 +31,4 @@ function preflightMbql5Query(query, labels, options) {
 	throw new ConfigError(`${labels.contextLabel}: ${outcome.errors.length} error(s) — fix them, or pass --skip-validate to send anyway`);
 }
 //#endregion
-export { TRANSFORM_SOURCE_QUERY_LABELS as a, SEGMENT_DEFINITION_LABELS as i, DATA_ACTION_DATASET_QUERY_LABELS as n, preflightMbql5Query as o, MEASURE_DEFINITION_LABELS as r, skipValidateFlag as s, CARD_DATASET_QUERY_LABELS as t };
+export { preflightMbql5Query as a, TRANSFORM_SOURCE_QUERY_LABELS as i, MEASURE_DEFINITION_LABELS as n, skipValidateFlag as o, SEGMENT_DEFINITION_LABELS as r, CARD_DATASET_QUERY_LABELS as t };

package/dist/{values-CXN4xTTh.mjs → values-De8aGDiJ.mjs}

@@ -1,6 +1,6 @@
-import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags, v as formatScalar } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
-import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
+import { J as outputFlags, U as connectionFlags, Y as profileFlag, p as renderSummary, y as formatScalar } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-C3AL15Dp.mjs";
+import { t as parseId } from "./parse-id-aMXePsUP.mjs";
 import { u as FieldValues } from "./field-5nivEfd6.mjs";
 import { s as fieldValuesView } from "./field-wmN6raOG.mjs";
 //#region src/commands/field/values.ts

package/dist/{verify-k-JB-k3D.mjs → verify-DKmz4xJs.mjs}

@@ -1,6 +1,6 @@
-import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
-import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
+import { J as outputFlags, U as connectionFlags, Y as profileFlag, p as renderSummary } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-C3AL15Dp.mjs";
+import { t as parseId } from "./parse-id-aMXePsUP.mjs";
 import { t as ModerationReview } from "./moderation-review-BdqEH6N1.mjs";
 import { i as moderationReviewView, n as verifyFlags, r as describeReview, t as reviewInput } from "./verify-flags-CMpRkMPa.mjs";
 //#region src/commands/dashboard/verify.ts

package/dist/{verify-CPVfwKSu.mjs → verify-DVjaammv.mjs}

@@ -1,6 +1,6 @@
-import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
-import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
+import { J as outputFlags, U as connectionFlags, Y as profileFlag, p as renderSummary } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-C3AL15Dp.mjs";
+import { t as parseId } from "./parse-id-aMXePsUP.mjs";
 import { t as ModerationReview } from "./moderation-review-BdqEH6N1.mjs";
 import { i as moderationReviewView, n as verifyFlags, r as describeReview, t as reviewInput } from "./verify-flags-CMpRkMPa.mjs";
 //#region src/commands/card/verify.ts

package/dist/{verify-t-CEmvoG.mjs → verify-ob8JSLxv.mjs}

@@ -1,6 +1,6 @@
-import { n as createClient } from "./client-BHIFvEg2.mjs";
-import { ct as NetworkError, pt as errorMessage, st as MetabaseError, ut as TimeoutError } from "./cli.mjs";
-import { P as HttpError, Q as probeServer, T as USER_AGENT } from "./runtime-B8RtMb4B.mjs";
+import { n as createClient } from "./client-5y-BaV3d.mjs";
+import { ft as TimeoutError, ht as errorMessage, lt as MetabaseError, ut as NetworkError } from "./cli.mjs";
+import { P as HttpError, Q as probeServer, T as USER_AGENT } from "./runtime-C3AL15Dp.mjs";
 //#region src/core/auth/verify.ts
 const VERIFY_TIMEOUT_MS = 15e3;
 async function verifyAndProbe(url, credential, options = {}) {

package/dist/{wait-KSkq7kKW.mjs → wait-BN_MzTng.mjs}

@@ -1,9 +1,9 @@
-import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
-import { n as DEFAULT_TIMEOUT_MS, t as DEFAULT_INTERVAL_MS } from "./poll-Dz4tUm2f.mjs";
-import { r as parseWaitSchedule } from "./wait-flags-KX7NHdj4.mjs";
+import { J as outputFlags, U as connectionFlags, Y as profileFlag, p as renderSummary } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-C3AL15Dp.mjs";
+import { n as DEFAULT_TIMEOUT_MS, t as DEFAULT_INTERVAL_MS } from "./poll-DFZRtTA_.mjs";
+import { r as parseWaitSchedule } from "./wait-flags-DQlX2yM_.mjs";
 import { u as syncTaskView } from "./git-sync-DspFahwV.mjs";
-import { a as throwIfFailedTask, i as taskPollOptions, n as formatSyncTask, r as syncTaskIdleView, t as SyncTaskOrIdle } from "./sync-task-CXFoqlpF.mjs";
+import { a as throwIfFailedTask, i as taskPollOptions, n as formatSyncTask, r as syncTaskIdleView, t as SyncTaskOrIdle } from "./sync-task-BAMOf6_t.mjs";
 //#region src/commands/git-sync/wait.ts
 const WaitResult = SyncTaskOrIdle;
 var wait_default = defineMetabaseCommand({

package/dist/{wait-flags-KX7NHdj4.mjs → wait-flags-DQlX2yM_.mjs}

@@ -1,6 +1,6 @@
 import { t as interruptSignal } from "./cli.mjs";
-import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
-import { n as DEFAULT_TIMEOUT_MS, t as DEFAULT_INTERVAL_MS } from "./poll-Dz4tUm2f.mjs";
+import { t as parseId } from "./parse-id-aMXePsUP.mjs";
+import { n as DEFAULT_TIMEOUT_MS, t as DEFAULT_INTERVAL_MS } from "./poll-DFZRtTA_.mjs";
 //#region src/commands/wait-flags.ts
 const waitScheduleFlags = {
 	timeout: {

package/dist/{window-CI_QD04s.mjs → window-2ybHqui2.mjs}

@@ -1,4 +1,4 @@
-import { b as projectForList } from "./cli.mjs";
+import { x as projectForList } from "./cli.mjs";
 //#region src/output/window.ts
 const MAX_REQUEST_PAGE_SIZE = 200;
 function windowList(items, range, serverTotal) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metabase/cli",
-  "version": "0.4.0-alpha.release-65-integration-branch.31ca6bb",
+  "version": "0.4.1-alpha.fix-transform-test-ee-path.b41b46c",
   "description": "Metabase CLI",
   "license": "AGPL-3.0",
   "repository": {

package/skill-data/core/SKILL.md

@@ -12,7 +12,7 @@ Top-level command groups (run `mb <group> --help` to discover verbs):
 
 ```
 auth | db | table | field | upload | content-translation | query | card | dashboard | snippet | segment | measure | collection | library
-document | glossary | timeline | timeline-event | transform | transform-job | transform-tag | alert | subscription | setting
+document | glossary | timeline | timeline-event | transform | transform-job | transform-tag | transform-test | alert | subscription | setting
 search | dependency | git-sync | setup | eid | uuid | upgrade | skills
 ```
 
@@ -148,6 +148,9 @@ Routine verb shapes (list / get / create / update), every flag, and output schem
 - **search vs. list.** Enumerate with `… list` verbs; `search` ranks a query or spans resources. `--search-native-query` matches native query text and keeps only query-bearing models; dashboard questions need `--include-dashboard-questions`.
 <!-- requires: transforms -->
 - **transform.** Iterate with `transform update <id>`, never `delete` + `create` (keeps the row, `entity_id`, materialized table, and YAML filename — avoids `_2` suffixes and noisy git history). `transform run` needs `--wait` (or `--sync`, which also waits for the output table to register and returns `target_table_id`) or you get only `{run_id, final:null}`. (→ `transform`.)
+  <!-- /requires -->
+  <!-- requires: transformTests -->
+- **transform-test.** `transform-test run <id>` checks a transform against fixtures in temp tables — only a `format: "sql"` input reads the source database — and exits 1 unless it passes. (→ `transform`.)
 <!-- /requires -->
 - **setup is one-shot.** `mb setup` walks `/api/setup` for a **fresh** instance only — errors against an already-configured one. Mostly for bootstrapping local / e2e instances.
 - **eid** translates a string entity id → numeric id: `mb eid --model <model> <eid1,eid2> --json`. Entity ids are NanoIDs that can start with `-`, which the positional form misreads as a flag (shell quotes don't help) — for those, use `--body '{"entity_ids":{"card":["-…"]}}'` (the id is a JSON string value, immune to flag parsing).
@@ -171,6 +174,9 @@ This file is enough for any single-command task. For anything deeper, load the r
 - **`notification`** — scheduled delivery: question alerts (`mb alert`) and dashboard subscriptions (`mb subscription`). Choosing between them, the two schedule/recipient contracts, channel prerequisites, testing a send.
 <!-- requires: transforms -->
 - **`transform`** — transform body JSON, create + run-with-wait, run inspection, tags, jobs.
+  <!-- /requires -->
+  <!-- requires: transformTests -->
+- **`transform-test-plan`** — deciding _what_ to test in a transform: the fixture cast, the expectations, the coverage matrix. (`transform` has the `mb transform-test` shapes.)
 <!-- /requires -->
 - **`document`** — Metabase documents (TipTap body, embedding cards).
 <!-- requires: remoteSync -->

package/skill-data/native-sql/SKILL.md

@@ -112,6 +112,6 @@ mb card query 12 --parameters '[{"type":"string/=","target":["dimension",["templ
 
 - Don't wrap a field filter in an operator (`WHERE col = {{ff}}`) — write it bare (`WHERE {{ff}}`).
 - Don't author the flat `{type:"native", …}` form — send the native stage above.
-- Don't use native SQL for DDL or multiple statements — the editor is read-only, single-statement; `CREATE`/`UPDATE`/`;`-chained SQL is unsupported. To materialize a table, use a `transform`; to write rows (`INSERT`/`UPDATE`/`DELETE`), use a data action (`data-action`).
+- Don't use native SQL for DDL or multiple statements — the editor is read-only, single-statement; `CREATE`/`UPDATE`/`;`-chained SQL is unsupported. To materialize a table, use a `transform`.
 - Don't expect `[[ ]]` to save you from a case/type mismatch — `WHERE plan = {{p}}` returns zero rows on a case-sensitive engine if the value's case is off; that's a value problem, not syntax.
 - Don't reach for native when a structured query fits — you lose the engine-independence and readability of an `mbql.stage/mbql` stage.

package/skill-data/transform/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: transform
-description: Author and run Metabase transforms via `mb` — body shape (native SQL or structured MBQL), create + run-with-wait, run inspection, dependencies, cancel, the `update`-vs-recreate iteration rule, the writable-keys-only PATCH contract, plus transform tags and tag-driven transform-job schedules. Load when the user touches transforms — "create a transform", "run a transform", "fix a failing transform", "list transform runs", "cancel a running transform", "manage transform tags", "run a transform job", or anything `mb transform …` / `mb transform-job …` / `mb transform-tag …`.
+description: Author and run Metabase transforms via `mb` — body shape (native SQL or structured MBQL), create + run-with-wait, run inspection, dependencies, cancel, the `update`-vs-recreate iteration rule, the writable-keys-only PATCH contract, transform tests (fixtures and expectations run against temp tables), plus transform tags and tag-driven transform-job schedules. Load when the user touches transforms — "create a transform", "run a transform", "fix a failing transform", "test a transform", "list transform runs", "cancel a running transform", "manage transform tags", "run a transform job", or anything `mb transform …` / `mb transform-job …` / `mb transform-tag …` / `mb transform-test …`.
 allowed-tools: Read, Write, Edit, Bash, AskUserQuestion
 requires: [transforms]
 ---
@@ -173,6 +173,68 @@ mb transform run "$ID" --wait --profile <n> --json     # → succeeded
 
 If you really must `create + delete` instead, do the `delete` **before** the first `git-sync export` so the failed entity never lands in git history — an export of a soft-failed state is noise that needs a follow-up cleanup commit. See `git-sync`, "Read state before mutating", for the ordering rule.
 
+<!-- requires: transformTests -->
+
+## Transform tests
+
+A transform test replaces every table the transform reads with a fixture, runs it into a temp table, and checks that output. The transform and the expectations read only the run's temp tables; a `format: "sql"` input runs verbatim against the transform's source database, so it may read real tables. Only query transforms (native SQL or MBQL) can be tested, and only on Postgres, MySQL, H2, ClickHouse, Redshift or SQL Server; otherwise `create`/`update`/`run` refuse with `transform-test.unsupported-transform` / `unsupported-driver` (422).
+
+```bash
+mb transform-test list --transform-id <id> --profile <n> --json  # --transform-id is optional
+mb transform-test get <id> --full --profile <n> --json        # --full for inputs/expectations
+mb transform-test create --file ./.scratch/test.json --profile <n> --json
+mb transform-test update <id> --file ./.scratch/patch.json --profile <n> --json
+mb transform-test delete <id> --yes --profile <n>
+mb transform-test run <id> --profile <n> --json               # exits 1 unless it passes
+```
+
+**`inputs`** — one per table the transform reads, each naming a `table` plus either `format: "sql"` with `sql`, or `format: "rows"` with `columns` (each a `name` and a `cast_type`) and `rows`.
+
+**`cast_type` is a `CAST` target, not a column type**, and the two vocabularies differ per warehouse: MySQL casts to `SIGNED` and reports `BIGINT`; ClickHouse takes `Nullable(Int32)` for a column that is `Int64`. So a body is warehouse-specific — don't copy a `database_type` out of a run result into a `cast_type`, and don't expect one body to run everywhere.
+
+**`expectations`** — `type: "empty"` with the `sql` that must return no rows, or `type: "equals"` with `format: "rows"` and the `columns` and `rows` the output must hold exactly. `equals` compares the rows as a multiset over the declared columns only, so an output column it does not declare is never checked. An `equals` without a `format` is refused, and one with `format: "sql"` is saved but reports `error` on every run, so its test can never pass.
+
+**Expectation SQL may only name the transform's target table and its declared input tables.** Those are rewritten to the run's temp tables; any other table is refused with `transform-test.unremapped-reference` (400), at `create`/`update` as well as `run`. A column qualified by its table name (`people.id`) is refused the same way, in expectation SQL and in the transform's own SQL alike: qualify by an alias (`FROM people p … p.id`) or leave the column bare — for the transform's SQL that means editing the transform. Expectation names are unique within a test (refused with "expectation names must be unique within a test"), and every `rows` row carries exactly its declared columns (refused naming the missing or undeclared columns).
+
+```json
+{
+  "transform_id": 1,
+  "name": "adults only",
+  "inputs": [
+    {
+      "table": { "schema": "public", "name": "people" },
+      "format": "rows",
+      "columns": [
+        { "name": "id", "cast_type": "INTEGER" },
+        { "name": "age", "cast_type": "INTEGER" }
+      ],
+      "rows": [
+        { "id": 1, "age": 30 },
+        { "id": 2, "age": 12 }
+      ]
+    }
+  ],
+  "expectations": [
+    {
+      "type": "equals",
+      "name": "exactly one row, id 1",
+      "format": "rows",
+      "columns": [{ "name": "id", "cast_type": "INTEGER" }],
+      "rows": [{ "id": 1 }]
+    },
+    {
+      "type": "empty",
+      "name": "no null ids",
+      "sql": "SELECT * FROM public.adults WHERE id IS NULL"
+    }
+  ]
+}
+```
+
+Create and update bodies are closed at every level (the top level is checked before sending; a stray nested key is a 400) — strip `id`, `entity_id`, `creator_id`, `created_at` and `updated_at` from a `get --full` body before sending it back.
+
+<!-- /requires -->
+
 ## Drop the materialized table (keep the transform)
 
 ```bash

package/skill-data/transform-test-plan/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: transform-test-plan
+description: Derive a comprehensive test plan for a transform — the fixture cast, the expectations, hand-derived expected rows, and a coverage matrix — from the model's declared design. Covers input partitioning (zero-case, multiplicity, dirty rows), grain / conservation / recomputation / conformance checks, and known-quirk conventions. Load when the user wants tests planned or written for transforms — "write tests for my transforms", "is my model right", "test plan for this pipeline", "add data quality checks" — whether the model is mid-build or already deployed. The `mb transform-test` command and body shapes live in the `transform` skill; this one decides what to test.
+allowed-tools: Read, Write, Edit, Bash, AskUserQuestion
+requires: [transformTests]
+---
+
+# Planning transform tests
+
+Turn a transform into a fixture cast that proves the logic on small known rows, expectations that state the model's invariants, and a coverage matrix showing what's checked and what's deliberately not. Mechanics — the `inputs`/`expectations` body shape and every `mb transform-test` verb — live in the `transform` skill (`mb skills get transform`); load it before authoring, and never restate it here. The two references this skill routes through, `references/checklist.md` and `references/checks.md`, come with `mb skills get transform-test-plan --full`, or read them from `mb skills path transform-test-plan`.
+
+Every check derives from what the model **declares** — detected from its SQL, confirmed with its owner — never from conformance to a modeling doctrine. One plan serves two moments: while the model is **built**, checks pin each design decision; once **deployed**, the same SQL screens production tables for anomalies.
+
+## Operating rules
+
+- **Detect, then derive.** Classify what the transform is and which conventions it uses (the checklist); derive checks only from that. Star, one-big-table, partial denormalization — all fine; never flag a style.
+- **Judgment calls go through the checklist.** The session's autonomy setting governs which answers you supply yourself and which you bring to the user — it never makes the checklist a formality. Every answer you supply yourself is recorded in the plan as a stated assumption, paired with the named expectation that enforces it — reversing the decision then breaks a test, not a paragraph. And regardless of setting, when genuinely unsure, ask — a wrong-but-confident grain poisons every downstream check.
+- **Expected rows are derived by hand** from the fixture story and business meaning — never captured from the transform's output, which asserts only that the transform equals itself.
+- **Batteries stay off until declared structure switches them on.** No snapshot-density checks without a snapshot, no version-history checks without effective/end/current columns. An empty section beats a speculative one.
+
+## The procedure
+
+1. **Profile the real inputs**: per table, row count; per column, min/max/distinct-count/null incidence; orphan counts across declared links (`mb field summary`, `mb query`). Profiling feeds domains, bounds, null partitions, and key candidates — and every fixture edge cites the real-data condition that warrants it, with its count ("the warehouse has 67 ship-before-order rows").
+2. **Detect.** Read the transform's SQL (`mb transform get <id> --full --json`) for: grain candidates (`GROUP BY` keys, the joins' driving table), join types (orphan handling), correlated aggregates (stored aggregates), `<entity>_<attr>` naming (copies), effective/end/current columns (version history), `now()`/`current_date` (volatile columns). A transform whose grain you cannot state in one phrase is itself a finding — raise it before writing any test.
+3. **Confirm.** Walk [references/checklist.md](references/checklist.md). Three stages: classify the model, per-table declarations, per-column declarations. Each question carries its detection hint; answer autonomously where the hint resolves, ask where it doesn't. In build-along mode these are design questions — treat an undecided answer as a decision to make together, not a blocker.
+4. **Derive.** Route every output column through [references/checks.md](references/checks.md) — declared property → expectation shape, fixture implication, expected-row convention. Read it in full once per plan; it is the plan's content.
+5. **Design the fixture cast**: one small cast per transform (≈5–10 rows per table), human-named rows ("Alice Premium"), every row a named edge — zero-case entities for every outer join and aggregation, ≥2-member groups for every grouping and join, one dirty row per screenable defect, boundary dates. Document it as a table (row → attributes → purpose) in the plan.
+
+   Express the cast as literal rows rather than as a query, so the story stays legible in the test itself; a query is worth it only when the rows are mechanical to generate. A cast is written against one warehouse and does not carry to another.
+
+6. **Hand-derive the expected rows**, arithmetic recorded in the plan (premium: 3 orders / 350.50 / 3.0). Every fixture row's fate appears in some expected cell. Pin NULL-vs-0-vs-empty for every zero-case row — that cell is the null policy's only enforcement.
+7. **Author the test.** One test per transform, per coherent story: an `equals` pinning the output, declaring every output column, since `equals` compares only the columns it declares, and `empty` expectations stating the invariants that survive a change to the cast.
+
+   Give each expectation a name that states the invariant, because the name is what a failure leads with ("revenue never negative", not "check 3"), and open each `empty` expectation's SQL with a `--` contract comment: the invariant, and the failure modes it catches ("catches both dropped orders and join fan-out").
+
+   Where one invariant applies to several transforms, duplicate the SQL. Nothing is shared between tests, so give each copy its own name and comment rather than one that only makes sense next to its twin.
+
+8. **Emit the coverage matrix** in the plan: rows = output columns with the table's grain; columns = check classes (grain, conservation, recomputation, conformance, domains, referential integrity, temporal, screens); cells name the covering expectation or expected-row cell, or state `gap: <reason>`. Scan shared-attribute columns across transforms for cross-table agreement obligations. Empty cells are honest; silent gaps are not.
+9. **Prove the tests have teeth.** Once per test: corrupt one expected cell, `run`, confirm `cell-mismatches` names exactly that column; revert. Then perturb one input cell and confirm exactly the declared output cells move. An `empty` expectation that only selects output rows passes against an empty output, so a green test can still be vacuous.
+
+## Severity: error, or the tolerated oddity
+
+Every expectation is pass or fail, and one failure fails the run. **error** = forbidden, and it becomes an `empty` expectation. There is no warn severity, so **never author an expectation you expect to fire**: a permanently red test trains everyone to ignore the result, and a red run gates everyone else's work.
+
+A tolerated-but-surfaced oddity — one the owner lives with, like orphan rows or ship-before-order dates — gets encoded the two ways that hold: **pin it in the `equals` rows** (an orphan passing through with NULLs is a cell in the expected output, so reversing the tolerance breaks the test), and **record it in the plan's known-quirks list** with its real-data count, so the tolerance stays a conscious choice.
+
+Under budget pressure cut business-rule checks first, then cross-table structure checks; never single-column screens (domains, ranges, nulls) — cheapest, and the last line.
+
+## When a check exposes a live bug
+
+Non-negotiable: **never soften the test to green** — expected values state correct behavior; matching them to buggy output documents the bug as intended — and **surface the finding with its blast radius at both scales**, fixture ("1530.24 of 1600.74 fixture dollars survive") and warehouse ("908 of 2,050 orders dropped"). What happens next follows the session's terms, not a fixed protocol: propose and apply the fix now (when the user wants it or the autonomy setting covers it), or — when the fix must wait — hold the correct expectation and record the red in the plan with the minimal fix body. A stored test has no red-by-design state, so a deferred fix must be visible in the plan or the test reads as broken. Either way, once green the test stays as the regression guard.
+
+## When the doctrine doesn't apply
+
+The vocabulary follows Kimball's dimensional modeling (grain, additivity, conformed attributes, slowly changing dimensions) — precise, widely understood terms. Real models are Kimball-inspired at most; no check may score adherence:
+
+- Full calendar date dimensions are rare. Never demand one; test date _semantics_ — ranges, orderings, volatile derivations.
+- Surrogate keys are doctrine, natural-key joins are practice. Test whichever key the model declares; never flag natural-key joins.
+- "No NULL FKs / no NULL attributes" is doctrine routinely dropped. Null policy is three independent declarations — measures, attributes, FKs — each detected and confirmed, never presumed.
+- One-big-table is legitimate: it still has a grain, its copies still need agreement checks, its functional dependencies still hold.
+- A transform-level `ORDER BY` has no testable effect — output tables carry no row order and the `equals` comparison is a multiset. Flag it as probable dead weight (clustering hints aside); never write an ordering expectation.
+
+## One transform at a time
+
+Each test covers one transform. When the transform under test reads another transform's output, that target table is an input like any other: declare it and fake it. Derive those rows from the base transform's own expected output, so the two tests tell one story, and note the coupling in both plans — changing the base's expected rows means changing this test's input.
+
+## Worked example, condensed
+
+`orders` + `customers` → _enriched_orders_ (order grain; LEFT JOIN attaches `customer_name`, `tier`).
+
+Cast, 7 orders: two tiers; Alice and Carol with 2 orders each (multiplicity); two never shipped (zero-case for the shipping join); order 106 shipped before ordered (real oddity, count cited); order 107's customer_id matches no customer (orphan). Two `rows` inputs, one per source table.
+
+Derived, per catalog: grain uniqueness on `order_id`; row and amount conservation from input to output, as scalar subqueries over the target and the seeded input; `tier` domain ⊆ {standard, premium}; orphan = keep-with-NULLs → an expected row pinning the NULL pass-through; ship-before-order tolerated → the plan's known-quirks list with the warehouse count. The whole output, every column, pinned in one `equals`, hand-computed, arithmetic in the plan. The inner-vs-LEFT-join bug this cast catches — unshipped orders silently dropped from revenue — is what the zero-case rows exist for.
+
+## Don't
+
+- Don't author expectations before loading the `transform` skill — the body shape, the closed create/update contract, and the verb flags live there.
+- Don't capture expected rows from the transform's own output — hand-derive them or they assert nothing.
+- Don't emit checks for structure the model doesn't declare (snapshot density, version history, bridge weights) — an inapplicable battery buries real findings.
+- Don't let a fixture cast go all-clean — no zero-case, no orphan, no dirty row proves the happy path and nothing else; the bugs live in the edges.
+- Don't write an expectation you expect to fail.
+- Don't surface bare check-ids ("per C3…") to the user — name the check in plain words; the ids are for your cross-referencing, not their reading.

package/skill-data/transform-test-plan/references/checklist.md

@@ -0,0 +1,32 @@
+# Confirmation checklist
+
+The judgment calls a plan depends on, in derivation order. Each question carries a **detect** hint — how to answer it from the SQL, the metadata, or profiling. Answer autonomously where the hint resolves cleanly; ask where it doesn't. Every answer you supply yourself goes into the emitted plan as a stated assumption, phrased so the owner can falsify it at a glance ("Assuming `discount` can never be negative — correct?").
+
+In build-along mode these are design questions: the owner is deciding, not recalling. An undecided answer is a decision to make together — surface the options and the check each implies (the `checks.md` entry named in parentheses).
+
+## Stage 1 — classify the model (per transform)
+
+1. **Grain: one row per what?** (G1, G2) Detect: `GROUP BY` keys; otherwise the driving table of the joins. Confirm whenever detection and any written description disagree — that disagreement is itself a finding.
+2. **Fact-table type — and if periodic snapshot, dense or sparse?** (F2) Detect: event-grain with a single event date → transaction; entity×period grain → periodic snapshot (density is the one yes/no that flips its whole invariant set — always confirm); one row per pipeline occurrence with milestone-date columns → accumulating snapshot.
+
+## Stage 2 — per-table declarations
+
+3. **Conservation ties: output rows/sums tie to which input, with which declared exclusions?** (A2) Detect: `WHERE` clauses and join types name the exclusions (filtered rows, dropped duplicates). Exclusions must be declared, or conservation appears to fail.
+4. **Zero-group policy: does a group with no contributing rows appear (with zeros) or stay absent?** (A5) Detect: driving table of the rollup — grouping the detail can't produce empty groups; joining a dimension first can.
+5. **Orphan handling per join: drop / keep-with-NULLs / default row — and is an orphan tolerated or forbidden?** (C3, I5) Detect: join type. INNER = drop, LEFT = keep-with-NULLs, COALESCE to a sentinel = default row. Tolerated-vs-forbidden is the owner's call — profiling says whether orphans exist today, not whether they're acceptable. Forbidden becomes an `empty` expectation; tolerated is pinned in the expected rows and recorded in the known-quirks list.
+6. **Version history: effective/end/current columns anywhere? If not, confirm overwrite-everywhere.** (T1) Detect: column names. Absence means history is silently rewritten in rollups — state that consequence when confirming, not just the mechanism.
+7. **Does this transform read another transform's output?** (A5) Detect: another transform's target table in this one's SQL. It becomes a declared input like any other, faked from that transform's own expected output — confirm which rows, and record the coupling in both plans.
+
+## Stage 3 — per-column declarations
+
+8. **Each measure: additive, semi-additive, or non-additive?** (A1) Detect: sums and counts are additive; balances and levels are semi-additive; ratios, rates, and unit prices are non-additive. Confirm the ambiguous ones (a "score"? a "quantity on hand"?).
+9. **Legal bounds per measure?** (Q1) Detect: profiling min/max suggests, business meaning decides — can `discount` be negative? can `quantity` be zero? Derived bounds are free (a sum of non-negatives is non-negative).
+10. **Each derived measure: the exact recomputation rule?** (A3) Detect: the SELECT expression is the rule — but rounding, business-day adjustments, and NULL handling are conventions to confirm, not read.
+11. **Which columns are stored aggregates, over which detail and filter?** (A4) Detect: correlated subqueries / joined-aggregate CTEs in the SQL.
+12. **Which categorical columns have closed domains — enumerate; is NULL a member?** (C2) Detect: profiling distinct values gives today's set; the owner confirms it's closed rather than merely small so far.
+13. **Which columns are denormalized copies, of which owning attribute?** (C1) Detect: `<entity>_<attr>` naming; any column functionally dependent on a non-grain key. Every hit must be classified: copy (C1), stored aggregate (A4), or smuggled coarser-grain fact — a finding.
+14. **Which many-to-one edges hold within one output table?** (C4) Detect: hierarchy-shaped column pairs (product/category, zip/state). Applies where no owning table is in scope; otherwise C1 covers it.
+15. **Which date orderings are business-guaranteed vs. known-violated and tolerated (with real-data counts)?** (T2) Detect: profiling counts the violations that exist; the owner decides tolerated vs. bug.
+16. **Null policy per column — measures, attributes, FKs separately.** (Q2) Detect: the SQL shows what's produced (COALESCE, CASE); the owner confirms intent — "count of nothing": 0 or NULL? empty date: NULL or sentinel?
+17. **Which columns are volatile across runs?** (T3) Detect: `now()` / `current_date` / run-metadata expressions in the SQL. A volatile column is left out of the `equals` columns; its form can still be asserted with an `empty`.
+18. **Per tolerated oddity: does it stay tolerated, and what is its current count?** (Q3) Detect: can't — this is the conscious-choice question, and the plan's known-quirks list is where it survives.