@metabase/cli 0.3.1-alpha.versioning.9ac5f50 → 0.3.2-alpha.fix-transform-test-ee-path.041c793

package/dist/{upgrade-CD1xtsIv.mjs → upgrade-EwL6wPSY.mjs}

@@ -1,7 +1,7 @@
-import { I as outputFlags, M as version, Q as UnknownError, W as AbortError, Y as NetworkError, Z as TimeoutError, a as renderItem, et as errorMessage, g as promptConfirm, j as name, t as interruptSignal, u as writeText } from "./cli.mjs";
-import { L as HttpError, O as USER_AGENT, V as parseJson, t as defineMetabaseCommand } from "./runtime-BQiGgbgZ.mjs";
-import { n as throwIfAborted, t as combineAborts } from "./signal-GhGmuHfx.mjs";
-import { n as streamProcess } from "./process-CcQM4qPv.mjs";
+import { H as outputFlags, L as name, R as version, X as AbortError, h as writeText, it as UnknownError, ot as errorMessage, rt as TimeoutError, t as interruptSignal, tt as NetworkError, u as renderItem, x as promptConfirm } from "./cli.mjs";
+import { L as HttpError, O as USER_AGENT, V as parseJson, t as defineMetabaseCommand } from "./runtime-arKqJqIT.mjs";
+import { n as throwIfAborted, t as combineAborts } from "./signal-k7cm5N6h.mjs";
+import { n as streamProcess } from "./process-CTrfxxaC.mjs";
 import { z } from "zod";
 import { realpathSync } from "node:fs";
 import { compare, valid } from "semver";

package/dist/upload-BZshRJIM.mjs

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

package/dist/{upload-akKFxpVA.mjs → upload-D0KaTqUE.mjs}

@@ -1,7 +1,7 @@
-import { I as outputFlags, L as profileFlag, N as connectionFlags, c as renderSummary } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-BQiGgbgZ.mjs";
+import { H as outputFlags, U as profileFlag, p as renderSummary, z as connectionFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-arKqJqIT.mjs";
 import { t as ContentTranslationUploadResult } from "./content-translation-BrHOrmj9.mjs";
-import { n as requireUploadFilePath, t as readCsvFile } from "./upload-BUd3MG90.mjs";
+import { n as requireUploadFilePath, t as readCsvFile } from "./upload-Do2PBSeH.mjs";
 //#region src/output/views/content-translation.ts
 const contentTranslationUploadView = {
 	compactPick: ContentTranslationUploadResult,

package/dist/{upload-BUd3MG90.mjs → upload-Do2PBSeH.mjs}

@@ -1,5 +1,5 @@
-import { K as ConfigError, tt as isFileNotFoundError } from "./cli.mjs";
-import { n as fileNotFoundError } from "./input-DFZ_qGW_.mjs";
+import { Q as ConfigError, st as isFileNotFoundError } from "./cli.mjs";
+import { n as fileNotFoundError } from "./input-DEvkIjGr.mjs";
 import { basename } from "node:path";
 import { readFile } from "node:fs/promises";
 //#region src/runtime/upload.ts

package/dist/{uuid-oVdJ62eA.mjs → uuid-DjKLDIVE.mjs}

@@ -1,5 +1,5 @@
-import { I as outputFlags, K as ConfigError, l as writeJson, u as writeText } from "./cli.mjs";
-import { nt as parseInteger, t as defineMetabaseCommand } from "./runtime-BQiGgbgZ.mjs";
+import { H as outputFlags, Q as ConfigError, h as writeText, m as writeJson } from "./cli.mjs";
+import { rt as parseInteger, t as defineMetabaseCommand } from "./runtime-arKqJqIT.mjs";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
 //#region src/commands/uuid.ts
@@ -10,10 +10,13 @@ var uuid_default = defineMetabaseCommand({
 		name: "uuid",
 		description: "Mint random UUID v4 strings"
 	},
-	details: "For MBQL `lib/uuid` slots, native template-tag ids, and other UUID fields. Mint fresh values here rather than authoring them by hand — the MBQL 5 schema rejects placeholder strings.",
+	details: "For the values that must be a UUID: the `lib/uuid` of an aggregation an MBQL aggregation ref points at, and a document node's `_id`.",
 	skills: [{
 		skill: "mbql",
-		purpose: "where lib/uuid values are used"
+		purpose: "aggregation refs"
+	}, {
+		skill: "document",
+		purpose: "document node ids"
 	}],
 	requires: null,
 	args: {
@@ -28,7 +31,8 @@ var uuid_default = defineMetabaseCommand({
 	examples: [
 		"mb uuid",
 		"mb uuid --count 5",
-		"mb uuid --count 5 --json"
+		"mb uuid --count 5 --json",
+		"U=$(mb uuid --format text)"
 	],
 	run({ args, ctx }) {
 		const count = parseInteger(args.count, {

package/dist/{validate-query-Boi8-cAP.mjs → validate-query-D6_ad-Gi.mjs}

@@ -1,5 +1,5 @@
-import { K as ConfigError, l as writeJson } from "./cli.mjs";
-import { i as validateQuery, r as isMbql5Query, t as assertNotLegacyEnvelopeWrappingMbql5 } from "./validate-CWd6l6KZ.mjs";
+import { Q as ConfigError, m as writeJson } from "./cli.mjs";
+import { a as validateQuery, i as isMbql5Query, n as assertNotLegacyEnvelopeWrappingMbql5 } from "./validate-xR_MHBNR.mjs";
 //#region src/commands/validate-query.ts
 const skipValidateFlag = { "skip-validate": {
 	type: "boolean",
@@ -28,7 +28,7 @@ function preflightMbql5Query(query, labels, options) {
 	const outcome = validateQuery(query);
 	if (outcome.ok) return;
 	writeJson(outcome);
-	throw new ConfigError(`${labels.contextLabel}: ${outcome.errors.length} error(s) — pass valid MBQL 5 or use the legacy format`);
+	throw new ConfigError(`${labels.contextLabel}: ${outcome.errors.length} error(s) — fix them, or pass --skip-validate to send anyway`);
 }
 //#endregion
 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/{validate-CWd6l6KZ.mjs → validate-xR_MHBNR.mjs}

@@ -1,4 +1,4 @@
-import { K as ConfigError, gt as escapeJsonPointerSegment, h as isPlainObject } from "./cli.mjs";
+import { Q as ConfigError, b as isPlainObject, lt as escapeJsonPointerSegment } from "./cli.mjs";
 import { z } from "zod";
 import Ajv2020 from "ajv/dist/2020.js";
 import addFormats from "ajv-formats";
@@ -1308,7 +1308,7 @@ const ValidationIssue = z.object({
 	path: z.string(),
 	message: z.string()
 });
-z.object({
+const ValidationOutcome = z.object({
 	ok: z.boolean(),
 	errors: z.array(ValidationIssue)
 });
@@ -1327,6 +1327,58 @@ const idSchema = {
 		field_id: POSITIVE_INTEGER
 	}
 };
+function definitionRef(tag) {
+	return {
+		description: `[${tag}, options, id]`,
+		type: "array",
+		prefixItems: [
+			{ const: tag },
+			{ $ref: "query.yaml#/$defs/options" },
+			POSITIVE_INTEGER
+		],
+		minItems: 3,
+		maxItems: 3
+	};
+}
+const refSchemaWithIds = {
+	...ref_default,
+	$defs: {
+		...ref_default.$defs,
+		metric_ref: definitionRef("metric"),
+		measure_ref: definitionRef("measure"),
+		segment_ref: definitionRef("segment")
+	}
+};
+const templateTag = query_default.$defs.template_tag;
+const nativeStage = query_default.$defs.native_stage;
+const TEMPLATE_TAG_REF = { $ref: "#/$defs/template_tag" };
+const querySchemaForApi = {
+	...query_default,
+	$defs: {
+		...query_default.$defs,
+		native_stage: {
+			...nativeStage,
+			properties: {
+				...nativeStage.properties,
+				"template-tags": {
+					type: ["object", "array"],
+					additionalProperties: TEMPLATE_TAG_REF,
+					items: TEMPLATE_TAG_REF
+				}
+			}
+		},
+		template_tag: {
+			...templateTag,
+			properties: {
+				...templateTag.properties,
+				id: {
+					type: "string",
+					minLength: 1
+				}
+			}
+		}
+	}
+};
 let validator = null;
 function getValidator() {
 	if (validator !== null) return validator;
@@ -1338,18 +1390,18 @@ function getValidator() {
 	addFormats(ajv);
 	ajv.addSchema(idSchema, "id.yaml");
 	ajv.addSchema(parameter_default, "parameter.yaml");
-	ajv.addSchema(ref_default, "ref.yaml");
+	ajv.addSchema(refSchemaWithIds, "ref.yaml");
 	ajv.addSchema(temporal_bucketing_default, "temporal_bucketing.yaml");
-	ajv.addSchema(query_default, "query.yaml");
+	ajv.addSchema(querySchemaForApi, "query.yaml");
 	const compiled = ajv.getSchema("query.yaml");
 	if (compiled === void 0) throw new Error("internal: query.yaml validator not registered");
 	validator = compiled;
 	return validator;
 }
-const UUID_HINT_MESSAGE = "must be a UUID v4 (RFC 4122) — run `mb uuid` (or `mb uuid --count N`) to mint one. The MBQL 5 schema rejects placeholder strings (`a1`, `uuid-1`, etc.); agents must call the CLI for UUIDs rather than authoring them.";
-const FIELD_SLOT1_HINT_MESSAGE = "must be the field options object — MBQL 5 field refs are [\"field\", {options}, fieldId]; the legacy MBQL 4 shape [\"field\", id, opts] is not accepted here. (Tip: `mb uuid` mints `lib/uuid` strings if you need them.)";
-function clauseSlot1HintMessage(operator, slot1) {
-	return `must be the clause options object — every MBQL 5 clause is ["${operator}", {options}, ...args]; got ${describeJsonValue(slot1)} at index 1`;
+const UUID_HINT_MESSAGE = "must be a UUID from `mb uuid`";
+const FIELD_SLOT1_HINT_MESSAGE = "must be the options object: [\"field\", {}, <field id>]";
+function clauseSlot1HintMessage(operator) {
+	return `must be the options object: ["${operator}", {}, ...args]`;
 }
 const FormatErrorParams = z.object({ format: z.string() });
 function isUuidFormatIssue(issue) {
@@ -1365,7 +1417,7 @@ function runValidator(validatorFn, value) {
 	const overrides = collectMessageOverrides(value);
 	return {
 		ok: false,
-		errors: (validatorFn.errors ?? []).map((issue) => {
+		errors: (validatorFn.errors ?? []).filter((issue) => issue.keyword !== IF_KEYWORD).map((issue) => {
 			if (issue.message === void 0) throw new Error(`Ajv issue at ${issue.instancePath} has no message`);
 			const path = issue.instancePath === "" ? "/" : issue.instancePath;
 			if (isUuidFormatIssue(issue)) return {
@@ -1379,6 +1431,7 @@ function runValidator(validatorFn, value) {
 		})
 	};
 }
+const IF_KEYWORD = "if";
 function collectMessageOverrides(root) {
 	const overrides = /* @__PURE__ */ new Map();
 	visit(root, "");
@@ -1403,7 +1456,7 @@ function clauseSlot1Message(clause) {
 	const slot1 = clause[1];
 	if (isPlainObject(slot1)) return null;
 	if (operator === "field") return FIELD_SLOT1_HINT_MESSAGE;
-	return clauseSlot1HintMessage(operator, slot1);
+	return clauseSlot1HintMessage(operator);
 }
 function refSlot2Message(clause) {
 	if (clause.length !== 3) return null;
@@ -1414,18 +1467,11 @@ function refSlot2Message(clause) {
 }
 function refHintForKind(kind) {
 	switch (kind) {
-		case "aggregation": return "must be the target aggregation's lib/uuid (string), not a numeric position";
-		case "expression": return "must be the target expression's name (string), not a numeric position";
+		case "aggregation": return "must be the lib/uuid of an aggregation in this stage";
+		case "expression": return "must be the name of an expression in this stage";
 		default: return null;
 	}
 }
-function describeJsonValue(value) {
-	if (value === null) return "null";
-	if (Array.isArray(value)) return "array";
-	if (typeof value === "string") return `string ${JSON.stringify(value)}`;
-	if (typeof value === "number" || typeof value === "boolean") return `${typeof value} ${String(value)}`;
-	return typeof value;
-}
 function validateQuery(value) {
 	return runValidator(getValidator(), value);
 }
@@ -1443,7 +1489,7 @@ function isLegacyEnvelopeWrappingMbql5(value) {
 }
 function assertNotLegacyEnvelopeWrappingMbql5(value, options) {
 	if (!isLegacyEnvelopeWrappingMbql5(value)) return;
-	throw new ConfigError(`${options.contextLabel}: MBQL 5 query nested inside a legacy {type:"query", query:…} envelope. For MBQL 5, ${options.bodyNoun} is the mbql/query value itself: {"lib/type":"mbql/query", database:N, stages:[…]}.`);
+	throw new ConfigError(`${options.contextLabel}: ${options.bodyNoun} is the query itself: {"lib/type": "mbql/query", "database": N, "stages": […]}.`);
 }
 z.object({
 	schema: z.unknown(),
@@ -1456,14 +1502,14 @@ z.object({
 });
 function getQuerySchemaBundle() {
 	return {
-		schema: query_default,
+		schema: querySchemaForApi,
 		defs: {
 			"id.yaml": idSchema,
 			"parameter.yaml": parameter_default,
-			"ref.yaml": ref_default,
+			"ref.yaml": refSchemaWithIds,
 			"temporal_bucketing.yaml": temporal_bucketing_default
 		}
 	};
 }
 //#endregion
-export { validateQuery as i, getQuerySchemaBundle as n, isMbql5Query as r, assertNotLegacyEnvelopeWrappingMbql5 as t };
+export { validateQuery as a, isMbql5Query as i, assertNotLegacyEnvelopeWrappingMbql5 as n, getQuerySchemaBundle as r, ValidationOutcome as t };

package/dist/{values-DLwZl-P8.mjs → values-Dc9612_L.mjs}

@@ -1,8 +1,8 @@
-import { I as outputFlags, L as profileFlag, N as connectionFlags, c as renderSummary, f as formatScalar } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-BQiGgbgZ.mjs";
-import { t as parseId } from "./parse-id-DR8aUSdL.mjs";
-import { s as FieldValues } from "./field-Cr2DPUG9.mjs";
-import { n as fieldValuesView } from "./field-BPsNa-TO.mjs";
+import { H as outputFlags, U as profileFlag, _ as formatScalar, p as renderSummary, z as connectionFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-arKqJqIT.mjs";
+import { t as parseId } from "./parse-id-DmFJgpY6.mjs";
+import { l as FieldValues } from "./field-CcN4oZy6.mjs";
+import { n as fieldValuesView } from "./field-fDtIrY6D.mjs";
 //#region src/commands/field/values.ts
 var values_default = defineMetabaseCommand({
 	meta: {

package/dist/{verify-CH9Tw8yv.mjs → verify-DVN1eqXZ.mjs}

@@ -1,6 +1,6 @@
-import { n as createClient } from "./client-Bv7Iwdvh.mjs";
-import { J as MetabaseError, Y as NetworkError, Z as TimeoutError, et as errorMessage } from "./cli.mjs";
-import { $ as probeServer, L as HttpError, O as USER_AGENT } from "./runtime-BQiGgbgZ.mjs";
+import { n as createClient } from "./client-cJ7aw0Gt.mjs";
+import { et as MetabaseError, ot as errorMessage, rt as TimeoutError, tt as NetworkError } from "./cli.mjs";
+import { L as HttpError, O as USER_AGENT, et as probeServer } from "./runtime-arKqJqIT.mjs";
 //#region src/core/auth/verify.ts
 const VERIFY_TIMEOUT_MS = 15e3;
 async function verifyAndProbe(url, credential, options = {}) {

package/dist/{wait-rfTdQWdi.mjs → wait-C-ovOTAZ.mjs}

@@ -1,9 +1,9 @@
-import { I as outputFlags, L as profileFlag, N as connectionFlags, c as renderSummary } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-BQiGgbgZ.mjs";
-import { n as DEFAULT_TIMEOUT_MS, t as DEFAULT_INTERVAL_MS } from "./poll-By46YQ5J.mjs";
-import { r as parseWaitSchedule } from "./wait-flags-DiQ_kRjZ.mjs";
-import { c as syncTaskView } from "./git-sync-DxD_ng48.mjs";
-import { a as throwIfFailedTask, i as taskPollOptions, n as formatSyncTask, r as syncTaskIdleView, t as SyncTaskOrIdle } from "./sync-task-BACcrs0i.mjs";
+import { H as outputFlags, U as profileFlag, p as renderSummary, z as connectionFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-arKqJqIT.mjs";
+import { n as DEFAULT_TIMEOUT_MS, t as DEFAULT_INTERVAL_MS } from "./poll-CZeXepUQ.mjs";
+import { r as parseWaitSchedule } from "./wait-flags-BQNmuvIj.mjs";
+import { c as syncTaskView } from "./git-sync-TjX1r_wF.mjs";
+import { a as throwIfFailedTask, i as taskPollOptions, n as formatSyncTask, r as syncTaskIdleView, t as SyncTaskOrIdle } from "./sync-task-BXeWuARG.mjs";
 //#region src/commands/git-sync/wait.ts
 const WaitResult = SyncTaskOrIdle;
 var wait_default = defineMetabaseCommand({

package/dist/{wait-flags-DiQ_kRjZ.mjs → wait-flags-BQNmuvIj.mjs}

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

package/dist/{window-BkvrP0gB.mjs → window-DSb1tqSe.mjs}

@@ -1,4 +1,4 @@
-import { m as projectForList } from "./cli.mjs";
+import { y 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.3.1-alpha.versioning.9ac5f50",
+  "version": "0.3.2-alpha.fix-transform-test-ee-path.041c793",
   "description": "Metabase CLI",
   "license": "AGPL-3.0",
   "repository": {

package/skill-data/core/SKILL.md

@@ -6,17 +6,17 @@ allowed-tools: Read, Write, Edit, Bash, AskUserQuestion
 
 # metabase-cli (core)
 
-The official Metabase CLI (`mb`) drives a Metabase instance over its REST API: auth, list/get/create/update/delete on every resource, query and transform execution, content search, git-sync (representations ↔ instance), and entity-id translation.
+`mb` drives a Metabase instance over its REST API: CRUD on every resource, query and transform execution, search, git-sync (representations ↔ instance), and entity-id translation.
 
 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 | timeline | timeline-event | transform | transform-job | transform-tag | alert | subscription | setting
+document | timeline | timeline-event | transform | transform-job | transform-tag | transform-test | alert | subscription | setting
 search | git-sync | setup | eid | uuid | upgrade | skills
 ```
 
-The conventions below — auth, flags, output, body input — hold across **every** group. Per-command flags and examples live in each command's `--help`; add `--json` for the machine-readable form with the output JSON Schema. A few flows have their own skills (see "Specialized skills"). When a card needs a query, prefer MBQL over native SQL (portable, pre-flight-validated — load `mbql`); fall back to native SQL when MBQL can't express it.
+The conventions below — auth, flags, output, body input — hold across **every** group. When a card needs a query, prefer MBQL over native SQL (portable, pre-flight-validated — load `mbql`); fall back to native SQL when MBQL can't express it.
 
 ## Auth & profiles
 
@@ -28,7 +28,7 @@ mb auth status --json                    # → {profile, present, url} for the d
 mb auth status --profile <name> --json   # health probe for one profile
 ```
 
-`auth list` is the primary enumeration path — one call returns every profile with sanitized URL, an `authenticated` flag, and a probe `status` (`ok` / `auth-failed` / `network-error` / `server-error` / `not-probed`). Use it before asking which profile to pick.
+`auth list` is the primary enumeration path — one call returns every profile with sanitized URL, an `authenticated` flag, and a probe `status` (`ok` / `auth-failed` / `network-error` / `server-error` / `not-probed`).
 
 - One profile and intent doesn't disambiguate → use it.
 - Several → ask via `AskUserQuestion`, presenting the names from `auth list`.
@@ -60,7 +60,7 @@ Every list/get verb supports the same output flags:
 - `--json` — emit the full JSON envelope, safe for `jq`. Default is human-readable text.
 - `--full` — include every field (the compact projection is the default, and is the agent-facing contract).
 - `--fields a,b.c.d` — project specific dot-paths. Mutually exclusive with `--full`. **Paths are relative to each `data[]` item on list verbs, and to the root on single-item verbs.** So it's `--fields id,name` on `… list` / `database schema-tables` (`data.id` and `data[].id` both fail with `unknown field path: "data.id"`), and `--fields id,name,display` on `card get`, `--fields data.rows` on `mb query` (whose `data` is an object).
-- `--max-bytes <n>` — cap output size. Default 24576 (sized to fit under agent-harness tool-output limits); `0` disables. On a list it drops trailing items and sets `truncated` (see below). Single-item commands (`get`) never truncate — over the cap they throw a `ConfigError` (exit 2: "output is N bytes, over the M-byte --max-bytes cap; …") whose tail names the remedy: on schema-shaped commands it is the exact narrower command to run instead — follow it rather than raising the cap.
+- `--max-bytes <n>` — cap output size. Default 24576; `0` disables. On a list it drops trailing items and sets `truncated` (see below). Single-item commands (`get`) never truncate — over the cap they throw a `ConfigError` (exit 2: "output is N bytes, over the M-byte --max-bytes cap; …") whose tail names the remedy: on schema-shaped commands it is the exact narrower command to run instead — follow it rather than raising the cap.
 - JSON output is a single line when stdout is piped (pretty-printed only at a TTY) — always parse it, never scrape by line position.
 
 ## List windows and resumption
@@ -69,10 +69,10 @@ Every list verb takes `--limit <n>` (items this call returns) and `--offset <n>`
 
 - **`has_more` decides whether to keep going — never compare counts.** `total` is the server's count on endpoints that report one and `null` on those that don't, so arithmetic over it is not a termination condition.
 - **To continue, pass `next_offset` back as `--offset`.** When `has_more` is true `next_offset` is past the offset you sent, so the loop advances; when false the walk is over and `next_offset` is `null`.
-- **`truncated` means the byte cap cut the output, not that the data ran out.** `has_more`/`next_offset` are recomputed to the cut point, so a capped list resumes like any window. Its `bytes` is what the untruncated answer would have measured, so it sizes the work left rather than the reply you hold. Narrow rows with `--fields` rather than raising `--max-bytes` — a bigger cap spends context on fields you didn't ask for, and the cap counts only what you asked for, so `--fields` buys rows directly. A capped list always returns at least one row; when not even one fits it exits 2 with "the smallest response this list can produce is N bytes, over the M-byte --max-bytes cap; …".
+- **`truncated` means the byte cap cut the output, not that the data ran out.** `has_more`/`next_offset` are recomputed to the cut point, so a capped list resumes like any window. Its `bytes` is what the untruncated answer would have measured, so it sizes the work left rather than the reply you hold. Narrow rows with `--fields` rather than raising `--max-bytes` — the cap counts only what you asked for, so `--fields` buys rows directly. A capped list always returns at least one row; when not even one fits it exits 2 with "the smallest response this list can produce is N bytes, over the M-byte --max-bytes cap; …".
 - `limit` is echoed only when you passed `--limit` — except `mb search`, which defaults to `--limit 20` (an unbounded search is expensive server-side) and so always reports one. On nouns the server doesn't page, one large `--limit` with narrow `--fields` is a single request; many small `--offset` hops are one request each.
 
-The whole walk, literally:
+The whole walk:
 
 ```bash
 offset=0
@@ -104,7 +104,7 @@ mb <noun> create --file ./.scratch/body.json --profile <n> --json
 
 Single-quoted `'EOF'` stops the shell interpolating `$vars` inside the JSON.
 
-Write working files to **`./.scratch`** in the current directory (`mkdir -p ./.scratch` first), never `/tmp` — better permissions, they persist across the session, and the user can review them.
+Write working files to **`./.scratch`** in the current directory (`mkdir -p ./.scratch` first), never `/tmp` — they persist across the session and the user can review them.
 
 ## Discovering commands and schemas
 
@@ -123,7 +123,7 @@ mb transform --help --json | jq -r '.commands[].command'  # verbs under "transfo
 
 ## Resource quirks worth memorizing
 
-Routine verb shapes (list / get / create / update), every flag, and output schemas live in each command's `--help` (add `--json` for output schemas). Below is only what help does _not_ tell you: footguns and non-obvious behaviors.
+Only what `--help` does _not_ tell you: footguns and non-obvious behaviors.
 
 - **db traversal: the hydration ladder.** Start with `database get <db-id> --include tables` — the compact table map (id, name, schema, description per table), one call that fits most databases. Pick the relevant tables, then `table fields <table-id>` per table (bounded: fields are per-table). `--include tables.fields` is the full rollup — small databases only. Hundreds of tables? Traverse by schema (`database schemas <db-id>` → `database schema-tables <db-id> <schema>`) or look tables up by name (`search <term> --models table --db-id <db-id> --limit 10`). `sync-schema` / `rescan-values` queue async work and return `{status:"ok"}` immediately; `sync-schema --wait` blocks until `initial_sync_status: complete`.
 - **table fields.** `table get` never returns fields on its own — pass `--include fields` (compact; the underlying query_metadata response also carries FK targets and dimensions, visible under `--full`) or use `table fields <id>` (list envelope). `table update` patches table-level metadata only; physical columns aren't editable.
@@ -132,8 +132,8 @@ Routine verb shapes (list / get / create / update), every flag, and output schem
 <!-- requires: contentTranslation -->
 - **content-translation.** Admin-only, and separate from Remote Sync. `content-translation download > translations.csv` streams the complete active dictionary; `content-translation upload --file translations.csv` replaces every active translation with the file's contents. Always upload the canonical complete CSV, never a partial patch. An empty dictionary downloads as Metabase's four-row sample dictionary — don't re-upload it as real translations. Metabase limits dictionaries to 1.5 MiB.
 <!-- /requires -->
-- **card.** `dataset_query` is the **flat** `mbql/query` value, not a legacy `{type:"query",query:…}` envelope (→ `mbql`). `--export-format csv|xlsx` streams the raw export (pipe to a file), bypassing the JSON envelope. `archive` is the only delete; unarchive with `update --body '{"archived":false}'`. `visualization_settings` keys are scoped by `display` and aren't pre-flighted — see `visualization`.
-- **dashboard.** Dashcards round-trip through `PUT /api/dashboard/:id` (no per-dashcard endpoint): `update-dashcard <dash-id> <dashcard-id>` patches one safely; `update --body '{"dashcards":[…]}'` replaces the whole set (omitted ids are deleted server-side; negative ids for new cards). Every dashcard must include `card_id`, including existing rows; use `card_id:null` plus a `visualization_settings.virtual_card` block (`{display:"text"|"heading"|"link"|…}`) for non-question cards. `create` accepts the **same** `dashcards` array in its initial body, so lay out the whole dashboard in one call. `create`/`update` pre-flight every positive `card_id` and exit **2** with `{ok:false,errors:[…]}` on a bad ref (non-bypassable). `dashboard get <id>` (or `--full`) hydrates dashcards/tabs; `list` omits them. **The grid is 24 columns wide:** each dashcard's `{col, row, size_x, size_y}` is in grid units — **full-width is `size_x: 24`** (`size_x: 12` is half a row, the usual cause of a card filling only half the width). Keep `col + size_x ≤ 24`, start a full-width stack's `col` at 0, and don't overlap (the server stores collisions as sent — no auto-fix). Layout patterns and per-chart default sizes → the `dashboard` skill; load it before composing any `dashcards` array.
+- **card.** `dataset_query` is the `mbql/query` object itself (→ `mbql`). `--export-format csv|xlsx` streams the raw export (pipe to a file), bypassing the JSON envelope. `archive` is the only delete; unarchive with `update --body '{"archived":false}'`. `visualization_settings` keys are scoped by `display` and aren't pre-flighted — see `visualization`.
+- **dashboard.** Dashcards round-trip through `PUT /api/dashboard/:id` (no per-dashcard endpoint): `update-dashcard <dash-id> <dashcard-id>` patches one safely; `update --body '{"dashcards":[…]}'` replaces the whole set (omitted ids are deleted server-side; negative ids for new cards). Every dashcard must include `card_id`, including existing rows; use `card_id:null` plus a `visualization_settings.virtual_card` block (`{display:"text"|"heading"|"link"|…}`) for non-question cards. `create` accepts the **same** `dashcards` array in its initial body, so lay out the whole dashboard in one call. `create`/`update` pre-flight every positive `card_id` and exit **2** with `{ok:false,errors:[…]}` on a bad ref (non-bypassable). `dashboard get <id>` (or `--full`) hydrates dashcards/tabs; `list` omits them. **The grid is 24 columns wide:** each dashcard's `{col, row, size_x, size_y}` is in grid units — **full-width is `size_x: 24`**. Keep `col + size_x ≤ 24`, start a full-width stack's `col` at 0, and don't overlap (the server stores collisions as sent — no auto-fix). Layout patterns and per-chart default sizes → the `dashboard` skill; load it before composing any `dashcards` array.
 - **dashboard parameters (filters).** A dashboard's `parameters` array holds its filter widgets; they're part of the dashboard record, so read them with `dashboard get <id> --fields parameters --json` (no separate verb). **Editing replaces the _whole_ array** (like dashcards), so it's a read-modify-write loop and omitting a parameter deletes it. A parameter only filters a card once it is **mapped** onto that dashcard's `parameter_mappings` — an unmapped parameter is an inert widget. `type` is a **closed enum**; an unlisted value is a hard parse error that echoes the full allowed set back to you. `dashboard parameter-values <id> <parameter-id> [--query <substr>]` fetches a widget's selectable values (`{values, has_more_values}`; `--query` is a case-insensitive substring search). Parameter types, ids, mapping targets, and value sources → the `dashboard` skill; load it before authoring a `parameters` array.
 - **alert / subscription are two unrelated systems.** `alert` watches one **card** and fires on a send condition (`/api/notification`: a cron string, `channel/email`-prefixed handlers, typed recipients); `subscription` delivers one **dashboard** on a schedule (`/api/pulse`: structured `schedule_type` + hour/day/frame, bare `email` channels, `{id}|{email}` recipients). The bodies are not interchangeable. Both silently deliver nowhere if the server has no SMTP / Slack app — check `mb setting get 'email-configured?'` (quote it; the `?` is a shell glob) before creating either. Their list-valued fields (`handlers`/`subscriptions`, `channels`/`cards`) **replace wholesale** on update, so adding one recipient is a read-modify-write. `mb card alerts <id>` and `mb dashboard subscriptions <id>` list what's already attached to a card/dashboard; `archive` deactivates rather than deletes. Load the `notification` skill before authoring either body.
 - **snippet `--archived` is a swap, not a union** — list returns _either_ active _or_ archived rows, never both. (Same for `--filter archived` on dashboard/collection.)
@@ -144,13 +144,16 @@ Routine verb shapes (list / get / create / update), every flag, and output schem
 - **search vs. list.** For plain enumeration of cards/dashboards/collections use the dedicated `… list` verbs; reach for `search --models <kind>` only for ranking against a query string or a cross-resource lookup.
 <!-- 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 — no real table is read — and exits non-zero 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).
 <!-- requires: library -->
-- **library.** The Library is a curated subtree (`library-data` "Data" + `library-metrics` "Metrics" under a `library` root): tables published to **Data** appear first in data pickers and rank up in search; metrics saved to **Metrics** are prioritized in nav, search, and the query builder — it's how you tell people (and agents) "start from these, they're trusted." `library get` shows the Library and its Data/Metrics collection ids; `library create` provisions it (idempotent). `library publish --table-ids/--db-ids/--schemas` publishes tables into Data — it **resolves the Data collection itself and creates the Library if absent** (no collection id to find); each `--schemas` entry is `<db-id>:<schema>` (e.g. `1:public`), not a bare name. `publish` cascades to upstream FK dependencies, `unpublish` to downstream dependents; both need **admin or data-analyst** (Curate alone won't publish) and exit **403** without write **and** query permission on every affected table. Publish status shows on the table: `table get`/`table list` carry `is_published` (`collection_id` under `--full`). Good candidates are finished, analysis-ready tables — clean/combine via transforms first, then publish the polished result. Publishing does not put the Data collection in the git-sync scope: on a remote-sync instance, `mb git-sync add-collection <data-collection-id>` is what makes exports carry the published tables' metadata (see the `git-sync` skill).
+- **library.** The Library is a curated subtree (`library-data` "Data" + `library-metrics` "Metrics" under a `library` root): tables published to **Data** appear first in data pickers and rank up in search; metrics saved to **Metrics** are prioritized in nav, search, and the query builder. `library get` shows the Library and its Data/Metrics collection ids; `library create` provisions it (idempotent). `library publish --table-ids/--db-ids/--schemas` publishes tables into Data — it **resolves the Data collection itself and creates the Library if absent**; each `--schemas` entry is `<db-id>:<schema>` (e.g. `1:public`), not a bare name. `publish` cascades to upstream FK dependencies, `unpublish` to downstream dependents; both need **admin or data-analyst** (Curate alone won't publish) and exit **403** without write **and** query permission on every affected table. Publish status shows on the table: `table get`/`table list` carry `is_published` (`collection_id` under `--full`). Publishing does not put the Data collection in the git-sync scope: on a remote-sync instance, `mb git-sync add-collection <data-collection-id>` is what makes exports carry the published tables' metadata (see the `git-sync` skill).
 <!-- /requires -->
-- **query / uuid.** `mb query` is the ad-hoc MBQL surface (`--print-schema` → `--dry-run` → run); `mb uuid --count <n>` mints the `lib/uuid` values MBQL clauses need. Both live in `mbql`.
+- **query / uuid.** `mb query` runs MBQL (`--dry-run` → run; `mbql`). `mb uuid --count <n>` mints an aggregation's `lib/uuid` (`mbql`) and document node `_id`s (`document`).
 
 ## Specialized skills (load on demand)
 
@@ -164,6 +167,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 -->
@@ -171,7 +177,7 @@ This file is enough for any single-command task. For anything deeper, load the r
 <!-- /requires -->
 - **`data-workflow`** — the guided, end-to-end data workflow: investigate raw data, build clean analysis-ready tables, define reusable segments/measures/metrics, answer questions, build dashboards. **Start here when the user states a goal rather than a single verb** — "make sense of my data", "build a data model", "go from raw data to a dashboard", "be my data analyst", "set up analytics for X". It detects where the data is and routes to the right stage.
 
-If a task spans more than one, load each. `mb skills list` enumerates the skills the profile's server can use, and `mb skills get` prints a skill with the sections that server cannot use left out; `--all` shows everything.
+If a task spans more than one, load each. `mb skills list` enumerates the skills the profile's server can use, and `mb skills get` prints a skill with the sections that server cannot use left out; `--unfiltered` shows everything.
 
 ## Don't
 

package/skill-data/dashboard/SKILL.md

@@ -47,7 +47,7 @@ A dashboard filter is one entry in the dashboard's `parameters` array **plus** a
   "target": ["dimension", ["field", 1779, null]] }
 ```
 
-**`id` is a slug-like string you pick** (e.g. `order_status`), unique within the dashboard — Metabase stores any non-blank string verbatim, so reuse the `slug` rather than guessing an opaque value. If you genuinely need an opaque id, mint one with `mb uuid`; never fabricate one.
+**`id` is a slug-like string you pick** (e.g. `order_status`), unique within the dashboard — Metabase stores any non-blank string verbatim, so reuse the `slug` rather than guessing an opaque value.
 
 **`type` is a closed enum** — an unlisted value is a hard parse error that echoes the allowed set back: string ops `string/=` `string/!=` `string/contains` `string/does-not-contain` `string/starts-with` `string/ends-with`; number ops `number/=` `number/!=` `number/between` `number/>=` `number/<=`; date `date/single` `date/range` `date/relative` `date/month-year` `date/quarter-year` `date/all-options`; location `location/city` `location/state` `location/zip_code` `location/country`; plus `category`, `id`, `boolean/=`, `temporal-unit`, and bare `number`/`text`/`date`/`boolean`.