@diviops/mcp-server 1.5.9 → 1.5.11

package/dist/index.js

@@ -316,7 +316,7 @@ registerPluginTool("diviops_schema_get_settings", {
     };
 });
 registerPluginTool("diviops_global_color_list", {
-    description: "Get the global color palette defined in Divi. Returns all global colors that can be referenced by modules. Returns the standardized envelope { ok, data?, error: { code, message, hint? } }.",
+    description: "Get the global color palette defined in Divi. Returns `{ colors, customizer }` — `colors` is the user-defined palette stored under `et_divi.et_global_data.global_colors` (read via the #719 priority-ordered probe); `customizer` surfaces the five WP-customizer-bound defaults (gcid-primary-color / gcid-secondary-color / gcid-heading-color / gcid-body-color / gcid-link-color) sourced from `\\ET\\Builder\\Packages\\GlobalData\\GlobalData::$customizer_colors`. Top-level `_meta.source_path` + `_meta.probed_paths` document which storage path yielded the user palette; `_meta.customizer_source` describes the customizer-bound default surface. Returns the standardized envelope { ok, data?, error: { code, message, hint? } }.",
     annotations: { idempotentHint: true },
     _meta: { idempotent: "true" },
 }, async () => {
@@ -327,6 +327,18 @@ registerPluginTool("diviops_global_color_list", {
         ],
     };
 });
+registerPluginTool("diviops_global_color_audit_storage", {
+    description: "Audit the global_colors STORAGE LOCATION landscape (#719 contract). Aggregates entries across all candidate paths for the global_colors surface with per-entry provenance via `_meta.entry_sources = { <id>: { path, provenance } }`. Provenance vocabulary: `et_divi_nested` (canonical 5.x — `et_divi.et_global_data.global_colors`), `top_level` (hypothetical standalone option, not observed on tested 5.5.x substrates), `wp_customizer` (the five WP-customizer-bound defaults — gcid-primary-color / gcid-secondary-color / gcid-heading-color / gcid-body-color / gcid-link-color, sourced from GlobalData::$customizer_colors). Warnings: `id_collision` (same id across two paths). The user palette overrides customizer defaults when both present (matches Divi's render-side behavior at GlobalData::get_global_colors). Returns the standardized envelope { ok, data?, error: { code, message, hint? } }.",
+    annotations: { idempotentHint: true },
+    _meta: { idempotent: "true" },
+}, async () => {
+    const result = await wp.requestEnveloped("/global-color/audit-storage");
+    return {
+        content: [
+            { type: "text", text: serializeEnvelope(result, "diviops_global_color_audit_storage") },
+        ],
+    };
+});
 registerPluginTool("diviops_global_color_create", {
     description: "Add a new global color to Divi's palette. The plugin mints a fresh `gcid-<uuid>` ID (the server forwards the color entry without an id and the WP-side handler generates one) and writes to the et_global_data option in the canonical Divi shape `{color, folder, label, lastUpdated, status, usedInPosts}`. The color appears in the VB color picker after save and can be referenced via `$variable({type:color,value:{name:gcid-...}})$` tokens. Note: Divi's AI Agent bundle has a Zod schema gap that drops `label` on its own writes — our PHP path goes around that bug by writing directly to the option. CONCURRENCY: this is a read-modify-write on a single WP option with no conflict detection. If a Visual Builder session holds stale global data, its next save can clobber colors written here in the interim. Coordinate writes when VB sessions are active, or have the user reload VB after MCP color writes. Returns the standardized envelope { ok, data?, error: { code, message, hint? } }; input-shape rejections (non-CSS color value, missing required `color` for a new entry) return code 'invalid_input' with `error.data` documenting the failed field." +
         DRY_RUN_DESC_SUFFIX,
@@ -443,7 +455,7 @@ registerPluginTool("diviops_global_color_delete", {
     return { content: [{ type: "text", text: serializeEnvelope(result, "diviops_global_color_delete") }] };
 });
 registerPluginTool("diviops_global_font_list", {
-    description: "List the DiviOps-managed global fonts registered under `et_global_data.global_fonts`. ALWAYS returns the normalized shape `{ count: number, fonts: { <gfid>: <record>, ... } }` — even on empty substrates (count:0, fonts:{}), never bare `false`. Distinct from the variable-manager font tokens (`gvid-*` under `et_global_data.global_variables.fonts`, surfaced via `diviops_variable_list({type:\"fonts\"})`) — `global_font_*` is the DiviOps-controlled font catalog presets bind to via canonical `gfid-` slugs. Returns the standardized envelope { ok, data?, error: { code, message, hint? } }.",
+    description: "List the DiviOps-managed global fonts registered under `et_divi.et_global_data.global_fonts` (gfid-* Google catalog) AND the local-hosted Pattern B fonts registered under `et_uploaded_fonts` (per #719 AC #9). Returns `{ count, fonts, uploaded_count, uploaded_fonts }` — both maps always emitted as JSON objects (consistent shape across empty/populated substrates). Top-level `_meta.sources` discriminates the two surfaces with `provenance: \"gfid_catalog\"` vs `provenance: \"uploaded_local\"`. Distinct from the variable-manager font tokens (`gvid-*` under `et_global_data.global_variables.fonts`, surfaced via `diviops_variable_list({type:\"fonts\"})`) — `global_font_*` is the DiviOps-controlled font catalog presets bind to via canonical `gfid-` slugs. Returns the standardized envelope { ok, data?, error: { code, message, hint? } }.",
     annotations: { idempotentHint: true },
     _meta: { idempotent: "true" },
 }, async () => {
@@ -454,6 +466,18 @@ registerPluginTool("diviops_global_font_list", {
         ],
     };
 });
+registerPluginTool("diviops_global_font_audit_storage", {
+    description: "Audit the global_fonts STORAGE LOCATION landscape (#719 contract). Aggregates entries across the gfid-* catalog (`et_divi.et_global_data.global_fonts`) AND the local-hosted `et_uploaded_fonts` Pattern B surface with per-entry provenance via `_meta.entry_sources = { <id>: { path, provenance } }`. Provenance vocabulary: `gfid_catalog` (Google CDN canonical), `uploaded_local` (file-uploaded local-hosted fonts per `reference_local_hosted_fonts_eu_pattern`). Warnings: `id_collision` (same id in both — upstream contract violation since the two surfaces are key-namespace-disjoint by convention). Returns the standardized envelope { ok, data?, error: { code, message, hint? } }.",
+    annotations: { idempotentHint: true },
+    _meta: { idempotent: "true" },
+}, async () => {
+    const result = await wp.requestEnveloped("/global-font/audit-storage");
+    return {
+        content: [
+            { type: "text", text: serializeEnvelope(result, "diviops_global_font_audit_storage") },
+        ],
+    };
+});
 registerPluginTool("diviops_global_font_create", {
     description: "Create a new global font in DiviOps's registry under `et_global_data.global_fonts`. Mints a fresh `gfid-<uuid>` if `id` is omitted; otherwise uses the supplied id (must match `gfid-[0-9a-z-]{1,80}`; auto-prefixes `gfid-` if missing). Strict create — collision on existing id returns `conflict` (HTTP 409) with `error.data = { id, existing }`; use diviops_global_font_update to modify an existing record. Stored shape: `{ family, source, weights[], subsets[], label, fallback, status, lastUpdated }`. Required: `family` (CSS family name, e.g. \"Sora\") + `source` (one of `google`/`system`/`custom`). Distinct from `diviops_variable_create({type:\"fonts\"})` which writes `gvid-*` font tokens to the variable manager — `global_font_*` is the DiviOps catalog presets bind via `gfid-` slugs. Returns the standardized envelope { ok, data?, error: { code, message, hint? } }; input-shape rejections (malformed id, invalid source enum, non-array weights/subsets, missing required `family`/`source` for a new entry) collapse onto `invalid_input` with structured `error.data`." +
         DRY_RUN_DESC_SUFFIX,
@@ -1244,6 +1268,18 @@ registerPluginTool("diviops_preset_audit", {
         ],
     };
 });
+registerPluginTool("diviops_preset_audit_storage", {
+    description: "Audit the D5 preset STORAGE LOCATION landscape (#719 contract). Distinct from `diviops_preset_audit` (which audits preset CONTENT — usage refs, orphans, defaults). Aggregates entries across the canonical top-level `et_divi_builder_global_presets_d5` and the legacy nested `et_divi.builder_global_presets_d5` scratchpad on upgraded substrates, with per-entry provenance via `_meta.entry_sources = { <id>: { path, provenance } }`. Provenance vocabulary: `d5_top_level` (canonical), `d5_nested_scratchpad` (upgrade artifact), `legacy_d4_ng` (D4-era `et_divi_builder_global_presets_ng` store — OUT-OF-BAND per the banner, surfaced via entry_sources only, NEVER merged into the D5 aggregate). Warnings: `id_collision` (same id across D5 paths, same top-level shape), `shape_inconsistency` (same id, divergent top-level keys), `ng_non_empty` (legacy D4 store contains content; surface for inventory). Use this to diagnose substrate state before/after upgrades — agents do NOT auto-migrate; surfacing state is the contract. Returns the standardized envelope { ok, data?, error: { code, message, hint? } }; the routing-provenance fields sit on top-level `_meta`.",
+    annotations: { idempotentHint: true },
+    _meta: { idempotent: "true" },
+}, async () => {
+    const result = await wp.requestEnveloped("/preset/audit-storage");
+    return {
+        content: [
+            { type: "text", text: serializeEnvelope(result, "diviops_preset_audit_storage") },
+        ],
+    };
+});
 registerPluginTool("diviops_preset_cleanup", {
     description: 'Clean up presets. Default: remove spam presets. Optional: dedup=true to also remove duplicates, action="rename_strip_prefix" with prefix to strip a name prefix, or action="remove_orphans" with scope="spam"|"all" to remove unreferenced presets. Use dry_run: true (default) to preview. Returns the standardized envelope { ok, data?, error: { code, message, hint? } }. Note: dry_run currently returns the route-specific summary shape rather than the standardized `data.plan = { summary, changes[] }` shape used by tools introduced after the dry_run convention was generalized; plan-shape standardization is tracked separately for the pre-existing dry_run wave.',
     inputSchema: {

package/dist/preset-cli/__tests__/button-emitter.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `divi/button` emitter shape coverage:
+ *  - fixture-based shape assertion against round-3-button-canonical-complete.json
+ *  - emit-on-specification discriminator (with vs without font.weight)
+ *  - hover shape (NO `value` wrapper), radius vocabulary, variable tokens,
+ *    the do-not-emit list, and the opt-in bypass corner.
+ */
+export {};

package/dist/preset-cli/__tests__/button-emitter.test.js

@@ -0,0 +1,188 @@
+/**
+ * `divi/button` emitter shape coverage:
+ *  - fixture-based shape assertion against round-3-button-canonical-complete.json
+ *  - emit-on-specification discriminator (with vs without font.weight)
+ *  - hover shape (NO `value` wrapper), radius vocabulary, variable tokens,
+ *    the do-not-emit list, and the opt-in bypass corner.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { emitButtonGroupPreset, composeButtonAttrs, buildPresetCreateBody, } from "../button-emitter.js";
+import { loadRegistry } from "../registry.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(__dirname, "..", "..", "..", "..");
+const FIXTURE = join(REPO_ROOT, "docs/verification/evidence/canonical-shape-dumps-2026-05-18/round-3-button-canonical-complete.json");
+const registry = loadRegistry();
+test("emitter byte-matches the round-3 canonical button fixture attrs", () => {
+    const fixture = JSON.parse(readFileSync(FIXTURE, "utf8"));
+    const canonicalAttrs = fixture.canonical_button_primary_preset.attrs;
+    const entry = emitButtonGroupPreset({
+        name: "canonical-button-primary-vb-2026-05-18",
+        bg_color: "gcid-primary-color",
+        bg_color_hover: "gcid-secondary-color",
+        radius: {
+            topLeft: "8px",
+            topRight: "8px",
+            bottomLeft: "8px",
+            bottomRight: "8px",
+        },
+        font: {
+            family: "Inter",
+            weight: "600",
+            color: "gcid-body-color",
+        },
+    }, registry);
+    assert.deepEqual(entry.attrs, canonicalAttrs, "emitted attrs must byte-match the canonical capture");
+    assert.equal(entry.type, "group");
+    assert.equal(entry.group_name, "divi/button");
+    assert.equal(entry.group_id, "button");
+    assert.equal(entry.module_name, "divi/button");
+});
+test("hover bg color emits at desktop.hover.color with NO value wrapper", () => {
+    const attrs = composeButtonAttrs({
+        name: "hover-only",
+        bg_color: "#111111",
+        bg_color_hover: "#222222",
+    });
+    const bg = attrs.button.decoration.background;
+    assert.equal(bg.desktop.value.color, "#111111", "desktop is 3-level (value.color)");
+    assert.equal(bg.desktop.hover.color, "#222222", "hover is 2-level (hover.color)");
+    assert.equal("value" in bg.desktop.hover, false, "hover must NOT carry a `value` wrapper");
+});
+test("emit-on-specification discriminator: font.weight present vs absent", () => {
+    const withWeight = composeButtonAttrs({
+        name: "with-weight",
+        font: { family: "Inter", weight: "600" },
+    });
+    const withoutWeight = composeButtonAttrs({
+        name: "without-weight",
+        font: { family: "Inter" },
+    });
+    const wv = withWeight.button.decoration.font.font.desktop.value;
+    const wov = withoutWeight.button.decoration.font.font.desktop.value;
+    assert.equal(wv.weight, "600", "weight emitted when specified");
+    assert.equal("weight" in wv, true);
+    assert.equal("weight" in wov, false, "weight absent when not specified");
+    assert.deepEqual(Object.keys(wov), ["family"], "ONLY the touched key emitted");
+});
+test("radius vocabulary is {topLeft,topRight,bottomLeft,bottomRight,sync}", () => {
+    const attrs = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px", topRight: "8px", bottomLeft: "8px", bottomRight: "8px" },
+    });
+    const radius = attrs.button.decoration.border.desktop.value.radius;
+    assert.deepEqual(Object.keys(radius).sort(), [
+        "bottomLeft",
+        "bottomRight",
+        "sync",
+        "topLeft",
+        "topRight",
+    ]);
+    assert.equal(radius.sync, "on", "equal corners derive sync=on");
+});
+test("radius sync derives off when corners differ; partial corners stay absent", () => {
+    const attrs = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px", bottomRight: "4px" },
+    });
+    const radius = attrs.button.decoration.border.desktop.value.radius;
+    assert.equal(radius.sync, "off");
+    assert.equal("topRight" in radius, false, "untouched corner absent");
+    assert.equal("bottomLeft" in radius, false, "untouched corner absent");
+});
+test("radius sync derives off for a single specified corner (Rule 1a)", () => {
+    // Per Rule 1a in canonical-preset-shapes: a partial corner set must derive
+    // sync="off". A 1-element corner array is trivially "all equal" — auto-
+    // deriving "on" is only correct when all 4 corners are present and identical.
+    const attrs = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px" },
+    });
+    const radius = attrs.button.decoration.border.desktop.value.radius;
+    assert.equal(radius.sync, "off", "single corner must NOT derive sync=on");
+    assert.equal("topRight" in radius, false, "untouched corner absent");
+});
+test("radius sync stays off for 3 identical corners; on only with all 4", () => {
+    const three = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px", topRight: "8px", bottomLeft: "8px" },
+    });
+    assert.equal(three.button.decoration.border.desktop.value.radius.sync, "off", "3 identical corners is still a partial set — sync=off");
+    const all = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px", topRight: "8px", bottomLeft: "8px", bottomRight: "8px" },
+    });
+    assert.equal(all.button.decoration.border.desktop.value.radius.sync, "on", "all 4 identical corners derive sync=on");
+});
+test("explicit radius.sync wins over derivation", () => {
+    const attrs = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px", sync: "on" },
+    });
+    assert.equal(attrs.button.decoration.border.desktop.value.radius.sync, "on", "an explicitly-passed sync flag is honored regardless of corner count");
+});
+test("variable tokens get the {name,settings} object shape + trailing )$", () => {
+    const attrs = composeButtonAttrs({
+        name: "v",
+        bg_color: "gcid-primary-color",
+    });
+    const color = attrs.button.decoration.background.desktop.value.color;
+    assert.ok(color.endsWith(")$"), "token must end with )$");
+    assert.match(color, /^\$variable\(/);
+    const payload = JSON.parse(color.slice("$variable(".length, -2));
+    assert.deepEqual(payload, {
+        type: "color",
+        value: { name: "gcid-primary-color", settings: {} },
+    });
+});
+test("literal hex color is emitted verbatim, not wrapped", () => {
+    const attrs = composeButtonAttrs({ name: "h", bg_color: "#2563eb" });
+    assert.equal(attrs.button.decoration.background.desktop.value.color, "#2563eb");
+});
+test("do-not-emit list: no attrs.font/spacing top-level, no renderAttrs, no button slot", () => {
+    const entry = emitButtonGroupPreset({
+        name: "clean",
+        bg_color: "#111",
+        font: { family: "Inter" },
+    }, registry);
+    assert.equal("font" in entry.attrs, false, "no top-level attrs.font");
+    assert.equal("spacing" in entry.attrs, false, "no top-level attrs.spacing");
+    assert.equal("renderAttrs" in entry, false, "no renderAttrs");
+    const decoration = entry.attrs.button.decoration;
+    assert.equal("button" in decoration, false, "no button.decoration.button slot by default");
+});
+test("bypass_hover_padding_gate emits ONLY the padding.top corner", () => {
+    const attrs = composeButtonAttrs({
+        name: "bypass",
+        bg_color: "#111",
+        bypass_hover_padding_gate: true,
+    });
+    const buttonSlot = attrs.button.decoration.button;
+    assert.deepEqual(buttonSlot, {
+        desktop: { value: { padding: { top: "0px" } } },
+    });
+});
+test("emitter rejects an empty preset (no styling specified)", () => {
+    assert.throws(() => emitButtonGroupPreset({ name: "empty" }, registry), /empty preset/);
+});
+test("emitter rejects a missing name", () => {
+    assert.throws(() => emitButtonGroupPreset({ name: "" }, registry), /requires a non-empty `name`/);
+});
+test("buildPresetCreateBody mirrors the diviops_preset_create body shape", () => {
+    const entry = emitButtonGroupPreset({ name: "Primary", bg_color: "#111" }, registry);
+    const body = buildPresetCreateBody(entry, { dry_run: true });
+    assert.deepEqual(body, {
+        module_name: "divi/button",
+        name: "Primary",
+        attrs: entry.attrs,
+        type: "group",
+        group_name: "divi/button",
+        group_id: "button",
+        dry_run: true,
+    });
+    const noDry = buildPresetCreateBody(entry);
+    assert.equal("dry_run" in noDry, false, "dry_run omitted when not requested");
+});

package/dist/preset-cli/__tests__/cli.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CLI integration coverage: --help, arg parsing, structured exit codes,
+ * dry-run output, evidence-gate exit, capability-missing exit.
+ *
+ * Apply-mode here is exercised through the credential-missing path only
+ * (no live write — #725 AC #8). The mocked write-path proper lives in
+ * write-path.test.ts.
+ */
+export {};

package/dist/preset-cli/__tests__/cli.test.js

@@ -0,0 +1,149 @@
+/**
+ * CLI integration coverage: --help, arg parsing, structured exit codes,
+ * dry-run output, evidence-gate exit, capability-missing exit.
+ *
+ * Apply-mode here is exercised through the credential-missing path only
+ * (no live write — #725 AC #8). The mocked write-path proper lives in
+ * write-path.test.ts.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { run, parseArgs, buildButtonInput, EXIT, UsageError } from "../cli.js";
+/** Capture CLI output without touching real stdio. */
+function capture() {
+    const stdout = [];
+    const stderr = [];
+    return {
+        stdout,
+        stderr,
+        out: (t) => stdout.push(t),
+        err: (t) => stderr.push(t),
+    };
+}
+test("--help prints usage and exits 0", async () => {
+    const io = capture();
+    const code = await run(["--help"], io);
+    assert.equal(code, EXIT.OK);
+    assert.match(io.stdout.join("\n"), /diviops-preset/);
+    assert.match(io.stdout.join("\n"), /EXIT CODES/);
+});
+test("no args prints help and exits 0", async () => {
+    const io = capture();
+    const code = await run([], io);
+    assert.equal(code, EXIT.OK);
+    assert.match(io.stdout.join("\n"), /USAGE/);
+});
+test("unknown command exits 1 (invalid input)", async () => {
+    const io = capture();
+    const code = await run(["section", "--name", "X"], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /Unknown command/);
+});
+test("unknown flag exits 1 (invalid input)", async () => {
+    const io = capture();
+    const code = await run(["button", "--name", "X", "--bogus", "y"], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /Unknown flag/);
+});
+test("button without --name exits 1", async () => {
+    const io = capture();
+    const code = await run(["button", "--bg-color", "#111"], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /requires --name/);
+});
+test("dry-run is the default and prints canonical JSON, exit 0", async () => {
+    const io = capture();
+    const code = await run(["button", "--name", "Primary", "--bg-color", "gcid-primary-color"], io);
+    assert.equal(code, EXIT.OK);
+    const parsed = JSON.parse(io.stdout.join("\n"));
+    assert.equal(parsed.type, "group");
+    assert.equal(parsed.dry_run, true);
+    assert.equal(parsed.module_name, "divi/button");
+    assert.equal(parsed.attrs.button.decoration.background.desktop.value.color, '$variable({"type":"color","value":{"name":"gcid-primary-color","settings":{}}})$');
+});
+test("explicit --dry-run behaves the same as the default", async () => {
+    const io = capture();
+    const code = await run(["button", "--name", "P", "--bg-color", "#111", "--dry-run"], io);
+    assert.equal(code, EXIT.OK);
+    assert.equal(JSON.parse(io.stdout.join("\n")).dry_run, true);
+});
+test("dry-run requires no credentials and no network", async () => {
+    // No WP_* env vars set in this assertion's expectation: a clean dry-run
+    // run must not throw a CredentialsMissingError.
+    const io = capture();
+    const code = await run(["button", "--name", "P", "--bg-color", "#111"], io);
+    assert.equal(code, EXIT.OK);
+    assert.equal(io.stderr.length, 0, "no error output on a credential-free dry-run");
+});
+test("--apply without credentials exits 1 with a credentials hint", async () => {
+    const saved = {
+        WP_URL: process.env.WP_URL,
+        WP_USER: process.env.WP_USER,
+        WP_APP_PASSWORD: process.env.WP_APP_PASSWORD,
+    };
+    delete process.env.WP_URL;
+    delete process.env.WP_USER;
+    delete process.env.WP_APP_PASSWORD;
+    try {
+        const io = capture();
+        const code = await run(["button", "--name", "P", "--bg-color", "#111", "--apply"], io);
+        assert.equal(code, EXIT.INVALID_INPUT);
+        assert.match(io.stderr.join("\n"), /requires WordPress credentials/);
+    }
+    finally {
+        if (saved.WP_URL !== undefined)
+            process.env.WP_URL = saved.WP_URL;
+        if (saved.WP_USER !== undefined)
+            process.env.WP_USER = saved.WP_USER;
+        if (saved.WP_APP_PASSWORD !== undefined)
+            process.env.WP_APP_PASSWORD = saved.WP_APP_PASSWORD;
+    }
+});
+test("--apply and --dry-run together exit 1 (mutually exclusive)", async () => {
+    const io = capture();
+    const code = await run(["button", "--name", "P", "--apply", "--dry-run"], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /mutually exclusive/);
+});
+test("parseArgs: --radius shorthand and per-corner overrides", () => {
+    const parsed = parseArgs([
+        "button",
+        "--name",
+        "P",
+        "--radius",
+        "8px",
+        "--radius-top-left",
+        "12px",
+    ]);
+    const input = buildButtonInput(parsed);
+    assert.deepEqual(input.radius, {
+        topLeft: "12px",
+        topRight: "8px",
+        bottomLeft: "8px",
+        bottomRight: "8px",
+    });
+});
+test("parseArgs: --bypass-hover-padding-gate sets the opt-in flag", () => {
+    const parsed = parseArgs(["button", "--name", "P", "--bypass-hover-padding-gate"]);
+    const input = buildButtonInput(parsed);
+    assert.equal(input.bypass_hover_padding_gate, true);
+});
+test("parseArgs: value flag without a value throws UsageError", () => {
+    assert.throws(() => parseArgs(["button", "--name"]), (err) => {
+        assert.ok(err instanceof UsageError);
+        return true;
+    });
+});
+test("parseArgs: --radius-sync rejects values outside on|off", () => {
+    const parsed = parseArgs(["button", "--name", "P", "--radius-sync", "maybe"]);
+    assert.throws(() => buildButtonInput(parsed), /radius-sync must be/);
+});
+test("dry-run output includes the bypass corner when requested", async () => {
+    const io = capture();
+    const code = await run(["button", "--name", "P", "--bg-color", "#111", "--bypass-hover-padding-gate"], io);
+    assert.equal(code, EXIT.OK);
+    const parsed = JSON.parse(io.stdout.join("\n"));
+    assert.deepEqual(parsed.attrs.button.decoration.button, {
+        desktop: { value: { padding: { top: "0px" } } },
+    });
+});

package/dist/preset-cli/__tests__/preset-create-unchanged.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AC #9 — `diviops_preset_create` MCP tool behavior is unchanged.
+ *
+ * Track 4 adds a standalone CLI; it must NOT modify the existing MCP tool.
+ * This test pins two contracts:
+ *  1. The CLI posts to the SAME route the MCP tool uses (`/preset/create`)
+ *     with a body whose keys are a subset of the MCP tool's body keys —
+ *     i.e. the CLI is a peer consumer of the existing route, not a fork.
+ *  2. The `diviops_preset_create` registration block in `src/index.ts` is
+ *     byte-identical to the committed baseline on `main` (a guard against
+ *     an accidental edit landing in this PR).
+ */
+export {};

package/dist/preset-cli/__tests__/preset-create-unchanged.test.js

@@ -0,0 +1,64 @@
+/**
+ * AC #9 — `diviops_preset_create` MCP tool behavior is unchanged.
+ *
+ * Track 4 adds a standalone CLI; it must NOT modify the existing MCP tool.
+ * This test pins two contracts:
+ *  1. The CLI posts to the SAME route the MCP tool uses (`/preset/create`)
+ *     with a body whose keys are a subset of the MCP tool's body keys —
+ *     i.e. the CLI is a peer consumer of the existing route, not a fork.
+ *  2. The `diviops_preset_create` registration block in `src/index.ts` is
+ *     byte-identical to the committed baseline on `main` (a guard against
+ *     an accidental edit landing in this PR).
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { PRESET_CREATE_ROUTE } from "../write-path.js";
+import { buildPresetCreateBody, emitButtonGroupPreset } from "../button-emitter.js";
+import { loadRegistry } from "../registry.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SERVER_ROOT = join(__dirname, "..", "..", "..");
+test("CLI posts to the same /preset/create route as diviops_preset_create", () => {
+    assert.equal(PRESET_CREATE_ROUTE, "/preset/create");
+});
+test("CLI write body keys are a subset of the diviops_preset_create contract", () => {
+    // diviops_preset_create accepts: module_name, name, attrs, type,
+    // group_name, group_id, primary_attr_name, make_default, priority, dry_run.
+    const allowed = new Set([
+        "module_name",
+        "name",
+        "attrs",
+        "type",
+        "group_name",
+        "group_id",
+        "primary_attr_name",
+        "make_default",
+        "priority",
+        "dry_run",
+    ]);
+    const entry = emitButtonGroupPreset({ name: "P", bg_color: "#111" }, loadRegistry());
+    const body = buildPresetCreateBody(entry, { dry_run: true });
+    for (const key of Object.keys(body)) {
+        assert.ok(allowed.has(key), `CLI body key "${key}" is not part of the diviops_preset_create contract`);
+    }
+});
+test("diviops_preset_create registration in src/index.ts is unchanged vs main", () => {
+    // Diff src/index.ts against main; the preset_create handler region must
+    // not appear in the diff. If `main` is unavailable (detached CI checkout)
+    // the test is skipped rather than failing spuriously.
+    let diff = "";
+    try {
+        diff = execFileSync("git", ["diff", "main", "--", "src/index.ts"], { cwd: SERVER_ROOT, encoding: "utf8" });
+    }
+    catch {
+        // git/main not resolvable in this environment — fall back to a
+        // presence check that the tool is still registered.
+        const src = readFileSync(join(SERVER_ROOT, "src", "index.ts"), "utf8");
+        assert.match(src, /"diviops_preset_create"/);
+        return;
+    }
+    assert.equal(diff.includes("diviops_preset_create"), false, "src/index.ts diff vs main must not touch the diviops_preset_create tool");
+});

package/dist/preset-cli/__tests__/registry.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Registry-gating coverage: the min() rule, missing-applicability → 0,
+ * and threshold refusal with attr + level + source in the error.
+ */
+export {};