@diviops/mcp-server 1.5.10 → 1.5.11

package/README.md

@@ -80,6 +80,27 @@ The server exposes **73 tools** across the categories below. Each category links
 
 See [server-reference.md](../docs/server-reference.md) for per-tool descriptions.
 
+## Bundled CLI — `diviops-preset`
+
+The package also ships a standalone command-line preset emitter, `diviops-preset`,
+that produces byte-canonical Divi 5.5.x preset JSON gated by the verified-attrs
+registry (`data/verified-attrs.json`). It is independent of the MCP stdio server —
+run it directly:
+
+```bash
+diviops-preset button --name "Primary" --bg-color gcid-primary-color \
+  --bg-color-hover gcid-secondary-color --radius 8px \
+  --font-family Inter --font-weight 600 --font-color gcid-body-color
+```
+
+`--dry-run` (the default) composes and prints the canonical JSON with no
+credentials and no network. `--apply` posts to the existing `/preset/create`
+REST route, reusing the same `WP_URL` / `WP_USER` / `WP_APP_PASSWORD` env vars.
+The current scope is one emitter — `divi/button` group presets. See the
+[preset-cli reference](https://github.com/oaris-dev/diviops/blob/main/diviops-server/src/preset-cli/README.md)
+for the full command reference (the `src/` tree is not part of the published
+npm package — this link resolves on the repository).
+
 ## Response contract
 
 Tools return a standardized envelope. The shape lets clients branch on `ok` and machine-readable `error.code` without parsing freeform messages.

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 {};

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

@@ -0,0 +1,134 @@
+/**
+ * Registry-gating coverage: the min() rule, missing-applicability → 0,
+ * and threshold refusal with attr + level + source in the error.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { loadRegistry, resolveEvidence, gateWriteAttr, EvidenceGateError, writeThresholdNumber, } from "../registry.js";
+/** A minimal synthetic registry exercising every branch of the min() rule. */
+function syntheticRegistry() {
+    return {
+        evidence_level_ordering: {
+            UNVERIFIED: 0,
+            SCHEMA_OBSERVED: 1,
+            RUNTIME_VERIFIED: 2,
+            VB_ROUNDTRIP_VERIFIED: 3,
+            VB_PRESET_STORAGE_VERIFIED: 4,
+            CROSS_VERSION_STABLE: 5,
+        },
+        tier2: [
+            {
+                // pattern 4, cell 4 -> effective 4 (clears threshold)
+                pattern_family: "synthetic/clears",
+                pattern_evidence_level: "VB_PRESET_STORAGE_VERIFIED",
+                pattern_evidence_source: "docs/synthetic/clears.json",
+                applicability: {
+                    "divi/widget": {
+                        cell_evidence_level: "VB_PRESET_STORAGE_VERIFIED",
+                        source: "docs/synthetic/clears-cell.json",
+                    },
+                },
+            },
+            {
+                // pattern 4, cell 1 -> effective 1 (min picks the cell, below threshold)
+                pattern_family: "synthetic/cell-low",
+                pattern_evidence_level: "VB_PRESET_STORAGE_VERIFIED",
+                pattern_evidence_source: "docs/synthetic/cell-low-pattern.json",
+                applicability: {
+                    "divi/widget": {
+                        cell_evidence_level: "SCHEMA_OBSERVED",
+                        source: "docs/synthetic/cell-low-cell.json",
+                    },
+                },
+            },
+            {
+                // pattern 1, cell 4 -> effective 1 (min picks the pattern, below threshold)
+                pattern_family: "synthetic/pattern-low",
+                pattern_evidence_level: "SCHEMA_OBSERVED",
+                pattern_evidence_source: "docs/synthetic/pattern-low-pattern.json",
+                applicability: {
+                    "divi/widget": {
+                        cell_evidence_level: "VB_PRESET_STORAGE_VERIFIED",
+                        source: "docs/synthetic/pattern-low-cell.json",
+                    },
+                },
+            },
+            {
+                // pattern 4, NO applicability cell for divi/widget -> effective 0
+                pattern_family: "synthetic/no-cell",
+                pattern_evidence_level: "VB_PRESET_STORAGE_VERIFIED",
+                pattern_evidence_source: "docs/synthetic/no-cell.json",
+                applicability: {
+                    "divi/other": {
+                        cell_evidence_level: "VB_PRESET_STORAGE_VERIFIED",
+                        source: "docs/synthetic/no-cell-other.json",
+                    },
+                },
+            },
+        ],
+    };
+}
+test("min() rule picks the smaller of pattern and cell", () => {
+    const reg = syntheticRegistry();
+    const clears = resolveEvidence(reg, "divi/widget", "synthetic/clears");
+    assert.equal(clears.effectiveLevel, 4);
+    assert.equal(clears.effectiveLevelName, "VB_PRESET_STORAGE_VERIFIED");
+    const cellLow = resolveEvidence(reg, "divi/widget", "synthetic/cell-low");
+    assert.equal(cellLow.patternLevel, 4);
+    assert.equal(cellLow.cellLevel, 1);
+    assert.equal(cellLow.effectiveLevel, 1, "min picks the cell level");
+    const patternLow = resolveEvidence(reg, "divi/widget", "synthetic/pattern-low");
+    assert.equal(patternLow.patternLevel, 1);
+    assert.equal(patternLow.cellLevel, 4);
+    assert.equal(patternLow.effectiveLevel, 1, "min picks the pattern level");
+});
+test("missing applicability[<module>] resolves to UNVERIFIED (0)", () => {
+    const reg = syntheticRegistry();
+    const r = resolveEvidence(reg, "divi/widget", "synthetic/no-cell");
+    assert.equal(r.applicabilityMissing, true);
+    assert.equal(r.cellLevel, 0, "no invisible inheritance from the pattern");
+    assert.equal(r.effectiveLevel, 0);
+    assert.equal(r.effectiveLevelName, "UNVERIFIED");
+});
+test("gateWriteAttr passes when effective evidence clears the threshold", () => {
+    const reg = syntheticRegistry();
+    const r = gateWriteAttr(reg, "divi/widget", "synthetic/clears");
+    assert.equal(r.effectiveLevel, 4);
+});
+test("gateWriteAttr refuses below threshold, naming attr + level + source", () => {
+    const reg = syntheticRegistry();
+    assert.throws(() => gateWriteAttr(reg, "divi/widget", "synthetic/cell-low"), (err) => {
+        assert.ok(err instanceof EvidenceGateError);
+        assert.match(err.message, /synthetic\/cell-low/, "names the attr family");
+        assert.match(err.message, /SCHEMA_OBSERVED/, "names the effective level");
+        assert.match(err.message, /docs\/synthetic\/cell-low-cell\.json/, "names the registry source");
+        return true;
+    });
+});
+test("gateWriteAttr refusal on missing applicability cites UNVERIFIED + absent cell", () => {
+    const reg = syntheticRegistry();
+    assert.throws(() => gateWriteAttr(reg, "divi/widget", "synthetic/no-cell"), (err) => {
+        assert.ok(err instanceof EvidenceGateError);
+        assert.match(err.message, /UNVERIFIED \(0\)/);
+        assert.match(err.message, /absent from the registry entry/);
+        return true;
+    });
+});
+test("resolveEvidence throws for an entirely-absent pattern family", () => {
+    const reg = syntheticRegistry();
+    assert.throws(() => resolveEvidence(reg, "divi/widget", "synthetic/does-not-exist"), /absent from verified-attrs\.json/);
+});
+test("real registry: divi/button styling families clear the write threshold", () => {
+    const reg = loadRegistry();
+    assert.equal(writeThresholdNumber(reg), 4);
+    for (const fam of [
+        "divi/button.background",
+        "divi/button.border",
+        "divi/button.font",
+    ]) {
+        const r = resolveEvidence(reg, "divi/button", fam);
+        assert.equal(r.effectiveLevel, 4, `${fam} must be at effective level 4 (VB_PRESET_STORAGE_VERIFIED)`);
+        // gateWriteAttr must not throw.
+        gateWriteAttr(reg, "divi/button", fam);
+    }
+});

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

@@ -0,0 +1,8 @@
+/**
+ * Apply-mode coverage — mocked only (no live substrate write, per #725 AC #8).
+ *
+ * Asserts: the capability gate (storage_multipath_probe_v1 present → proceed,
+ * absent → fail fast), the POST route + request body, and credential
+ * handling. The HTTP client is a stub; nothing touches the network.
+ */
+export {};