@canonical/pragma-cli 0.32.0 → 0.34.0

package/src/capabilities/config/set.test.ts

@@ -1,12 +1,12 @@
 /**
- * `config set <key> <value>` — the additive one-command setter (PR9, COVENANT).
+ * `config set <key> <value>` — the one-command config setter (PR9, COVENANT).
  *
  * Pins the emitted covenant slice (`{ v:"set", args:["<key>","<value>"],
- * mutates:true, mcp:"config_set" }`), proves it shares the per-field write path
- * (set / reset-sentinel / enum-backstop), rejects an unknown key and an
- * out-of-set enum value with INVALID_INPUT, and holds MCP plan-first/confirm
- * parity. The frozen `config tier/channel/detail` verbs are UNTOUCHED — this is
- * purely additive.
+ * mutates:true, mcp:"config_set" }`), proves it drives the shared per-field
+ * write path (set / reset-sentinel / enum-backstop), rejects an unknown key and
+ * an out-of-set enum value with INVALID_INPUT, and holds MCP plan-first/confirm
+ * parity. Since AV-228 B3 retired `config tier/channel/detail`, `config set` is
+ * the sole config setter — `config set <field> <value>` is the migration path.
  */
 
 import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";

package/src/capabilities/config/set.verb.ts

@@ -1,11 +1,11 @@
 /**
  * `config set <key> <value>` — the one-command config setter (ADDITIVE).
  *
- * The user-facing primary form for writing config: `pragma config set tier
- * apps/lxd` instead of the per-field `pragma config tier apps/lxd`. It is purely
- * additive — the frozen `config tier`/`channel`/`detail` verbs stay — and shares
- * their exact write path (`runField` via `runSet`), so it inherits reset
- * sentinels, enum re-validation, and the global-layer-only write for free.
+ * The single form for writing config: `pragma config set tier apps/lxd`. Since
+ * AV-228 B3 retired the per-field `config tier`/`channel`/`detail` verbs, this
+ * is now the ONLY config setter. It drives the shared write path (`runField` via
+ * `runSet`), so it inherits reset sentinels, enum re-validation, and the
+ * global-layer-only write from the {@link CONFIG_FIELDS} table.
  *
  * Covenant shape: `<key>` is an ENUM over the field names (better completion +
  * validation; the token still emits as `<key>`), `<value>` a free string, so
@@ -14,6 +14,7 @@
  */
 
 import type { Task } from "@canonical/task";
+import { BIN_NAME } from "../../constants.js";
 import { asVerb } from "../../kernel/spec/asVerb.js";
 import type { VerbSpec } from "../../kernel/spec/types.js";
 import { configFieldFormatters } from "./field.render.js";
@@ -46,9 +47,12 @@ const setVerb: VerbSpec<Record<string, unknown>, ConfigFieldResult> = {
   ],
   output: { formatters: configFieldFormatters },
   examples: [
-    { cmd: "pragma config set tier apps/lxd", note: "scope reads to a tier" },
-    { cmd: "pragma config set channel experimental" },
-    { cmd: "pragma config set tier none", note: "clear the tier" },
+    {
+      cmd: `${BIN_NAME} config set tier apps/lxd`,
+      note: "scope reads to a tier",
+    },
+    { cmd: `${BIN_NAME} config set channel experimental` },
+    { cmd: `${BIN_NAME} config set tier none`, note: "clear the tier" },
   ],
   capability: {
     needsStore: false,

package/src/capabilities/config/show.render.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from "vitest";
+import { type RenderStyle, styleFor } from "../../kernel/render/style.js";
+import { emitReference } from "../../kernel/spec/emitReference.js";
+import { capabilities } from "../index.js";
+import { configShowFormatters, renderConfigShowPlain } from "./show.render.js";
+import type { ConfigShowData } from "./types.js";
+
+const DATA: ConfigShowData = {
+  config: {
+    tier: "apps/lxd",
+    channel: "normal",
+    detail: "standard",
+    packs: ["@canonical/ds"],
+  },
+  origins: {
+    tier: "project",
+    channel: "default",
+    detail: "default",
+    packs: "global",
+    stories: "default",
+    prefixes: "default",
+  },
+  globalConfigPath: "/home/u/.config/pragma/config.json",
+  projectConfigPath: "/repo/pragma.config.ts",
+  projectExists: true,
+  globalExists: true,
+};
+
+/** A sentinel styler — enabled, each color wrapped in a visible tag. */
+const TAGGED: RenderStyle = {
+  enabled: true,
+  bold: (t) => `<b>${t}</b>`,
+  dim: (t) => `<d>${t}</d>`,
+  cyan: (t) => `<c>${t}</c>`,
+  green: (t) => `<g>${t}</g>`,
+  yellow: (t) => `<y>${t}</y>`,
+};
+
+describe("renderConfigShowPlain", () => {
+  it("is byte-identical to the plain form when the styler is disabled", () => {
+    expect(renderConfigShowPlain(DATA, styleFor(false))).toBe(
+      [
+        "tier: apps/lxd [project]",
+        "channel: normal",
+        "detail: standard",
+        "packs: @canonical/ds [global]",
+        "global config: /home/u/.config/pragma/config.json",
+        "project config: /repo/pragma.config.ts",
+      ].join("\n"),
+    );
+  });
+
+  it("aligns the key column and colorizes values on a TTY", () => {
+    const out = renderConfigShowPlain(DATA, TAGGED);
+    const keyWidth = "project config:".length;
+    // Dim, padded key; cyan value; dim `[layer]` marker.
+    expect(out).toContain(
+      `<d>${"tier:".padEnd(keyWidth)}</d> <c>apps/lxd</c><d> [project]</d>`,
+    );
+    // A default-origin value carries no marker.
+    expect(out).toContain(
+      `<d>${"channel:".padEnd(keyWidth)}</d> <c>normal</c>`,
+    );
+    expect(out).not.toContain("<d> [default]</d>");
+  });
+
+  it("renders absent optional fields as (none)", () => {
+    const bare: ConfigShowData = {
+      config: { channel: "normal" },
+      origins: {
+        tier: "default",
+        channel: "default",
+        detail: "default",
+        packs: "default",
+        stories: "default",
+        prefixes: "default",
+      },
+      globalConfigPath: "/home/u/.config/pragma/config.json",
+      projectExists: false,
+      globalExists: false,
+    };
+
+    const out = renderConfigShowPlain(bare, styleFor(false));
+
+    expect(out).toContain("tier: (none)");
+    expect(out).toContain("packs: (none)");
+    expect(out).toContain("project config: (not found)");
+  });
+});
+
+describe("configShowFormatters.llm", () => {
+  it("renders the layered rows with origin markers", () => {
+    const out = configShowFormatters.llm(DATA);
+
+    expect(out).toContain("- **Tier:** apps/lxd [project]");
+    expect(out).toContain("- **Packs:** @canonical/ds [global]");
+  });
+
+  it("reports no identity row, in either form", () => {
+    // Identity is read statically from `pragma.conf.ts`; reporting a layer for
+    // it was reporting a provenance the kernel does not honour. Both renderers
+    // are asserted, because they list their rows independently.
+    for (const out of [
+      renderConfigShowPlain(DATA, styleFor(false)),
+      configShowFormatters.llm(DATA),
+    ]) {
+      for (const field of ["name", "help", "colophon", "issues"]) {
+        expect(out.toLowerCase()).not.toContain(`${field}:`);
+      }
+    }
+  });
+});
+
+describe("the generated configuration reference", () => {
+  it("names exactly the fields this renderer reports with a layer", () => {
+    // The page and the renderer are written independently — the page is kernel
+    // prose, the renderer a capability — and the page's account of the renderer
+    // was wrong in both directions: it claimed every field but `completion`
+    // carried a printed provenance, while `prefixes`, `stories` and the four
+    // distribution-only fields do not, and it claimed `completion` was not
+    // printed, while `--format json` carries it.
+    //
+    // DERIVED from the real formatter: the field rows are the ones before the
+    // two PATH rows, which are not fields at all. Adding a row here without
+    // saying so on the page, or naming a field there this renderer drops, fails.
+    const printed = renderConfigShowPlain(DATA, styleFor(false))
+      .split("\n")
+      .map((line) => line.slice(0, line.indexOf(":")));
+    const fields = printed.slice(0, printed.indexOf("global config"));
+    expect(fields.length).toBeGreaterThan(0);
+
+    const page = emitReference(capabilities).get("config.md") ?? "";
+    expect(page).toContain(
+      `${fields.map((field) => `\`${field}\``).join(", ")} — those and only those —`,
+    );
+  });
+});

package/src/capabilities/config/show.render.ts

@@ -7,6 +7,7 @@
  */
 
 import type { ConfigOrigin } from "../../kernel/config/types.js";
+import { defaultStyle, type RenderStyle } from "../../kernel/render/style.js";
 import type { Formatters } from "../../kernel/spec/types.js";
 import type { ConfigShowData } from "./types.js";
 
@@ -15,27 +16,67 @@ function originMarker(origin: ConfigOrigin): string {
   return origin === "default" ? "" : ` [${origin}]`;
 }
 
-/** Summarize the `packages` list as a comma-separated set of names. */
-function packageNames(data: ConfigShowData): string {
-  const packages = data.config.packages ?? [];
-  const names = packages.map((entry) =>
+/** Summarize a list of named entries as a comma-separated set of names. */
+function entryNames(entries: readonly (string | { name: string })[]): string {
+  const names = entries.map((entry) =>
     typeof entry === "string" ? entry : entry.name,
   );
   return names.length > 0 ? names.join(", ") : "(none)";
 }
 
+/** One resolved row: its label, value, and `[layer]` marker (blank for a default). */
+type ConfigRow = readonly [label: string, value: string, marker: string];
+
+/** The resolved rows, in display order, shared by the plain + beautified forms. */
+function configRows(data: ConfigShowData): readonly ConfigRow[] {
+  const { config, origins } = data;
+  return [
+    ["tier", config.tier ?? "(none)", originMarker(origins.tier)],
+    ["channel", config.channel, originMarker(origins.channel)],
+    ["detail", config.detail ?? "standard", originMarker(origins.detail)],
+    ["packs", entryNames(config.packs ?? []), originMarker(origins.packs)],
+    [
+      "global config",
+      `${data.globalConfigPath}${data.globalExists ? "" : " (not found)"}`,
+      "",
+    ],
+    ["project config", data.projectConfigPath ?? "(not found)", ""],
+  ];
+}
+
+/**
+ * Render `config show` as plain text.
+ *
+ * @param data - The resolved config-show payload.
+ * @param style - TTY styling; defaults to the process style. On a color-capable
+ *   terminal the `key:` column is aligned + dim, values cyan, and `[layer]`
+ *   markers dim; off a TTY the styler is inert, so the output is byte-identical
+ *   to the pre-beautify `key: value[marker]` form.
+ * @returns The formatted config block.
+ */
+export function renderConfigShowPlain(
+  data: ConfigShowData,
+  style: RenderStyle = defaultStyle(),
+): string {
+  const rows = configRows(data);
+  if (!style.enabled) {
+    return rows
+      .map(([label, value, marker]) => `${label}: ${value}${marker}`)
+      .join("\n");
+  }
+  const keyWidth = Math.max(...rows.map(([label]) => `${label}:`.length));
+  return rows
+    .map(([label, value, marker]) => {
+      const key = style.dim(`${label}:`.padEnd(keyWidth));
+      const tail = marker ? style.dim(marker) : "";
+      return `${key} ${style.cyan(value)}${tail}`;
+    })
+    .join("\n");
+}
+
 export const configShowFormatters: Formatters<ConfigShowData> = {
   plain(data) {
-    const { config, origins } = data;
-    const lines = [
-      `tier: ${config.tier ?? "(none — all tiers visible)"}${originMarker(origins.tier)}`,
-      `channel: ${config.channel}${originMarker(origins.channel)}`,
-      `detail: ${config.detail ?? "standard"}${originMarker(origins.detail)}`,
-      `packages: ${packageNames(data)}${originMarker(origins.packages)}`,
-      `global config: ${data.globalConfigPath}${data.globalExists ? "" : " (not found)"}`,
-      `project config: ${data.projectConfigPath ?? "(not found)"}`,
-    ];
-    return lines.join("\n");
+    return renderConfigShowPlain(data);
   },
 
   llm(data) {
@@ -43,10 +84,10 @@ export const configShowFormatters: Formatters<ConfigShowData> = {
     const lines = [
       "## Configuration",
       "",
-      `- **Tier:** ${config.tier ?? "none (all tiers)"}${originMarker(origins.tier)}`,
+      `- **Tier:** ${config.tier ?? "none"}${originMarker(origins.tier)}`,
       `- **Channel:** ${config.channel}${originMarker(origins.channel)}`,
       `- **Detail:** ${config.detail ?? "standard"}${originMarker(origins.detail)}`,
-      `- **Packages:** ${packageNames(data)}${originMarker(origins.packages)}`,
+      `- **Packs:** ${entryNames(config.packs ?? [])}${originMarker(origins.packs)}`,
       `- **Global config:** \`${data.globalConfigPath}\``,
     ];
     if (data.projectConfigPath) {

package/src/capabilities/config/show.verb.ts

@@ -5,9 +5,9 @@
  * later PR — this ships only the reader.
  */
 
+import { BIN_NAME, PROJECT_CONFIG_FILENAME } from "../../constants.js";
 import { asVerb } from "../../kernel/spec/asVerb.js";
 import type { CapabilityModule, VerbSpec } from "../../kernel/spec/types.js";
-import { configFieldVerbs } from "./fields.js";
 import { configSetVerb } from "./set.verb.js";
 import { configShowFormatters } from "./show.render.js";
 import type { ConfigShowData } from "./types.js";
@@ -15,12 +15,12 @@ import type { ConfigShowData } from "./types.js";
 const showVerb: VerbSpec<Record<string, unknown>, ConfigShowData> = {
   path: ["config", "show"],
   summary: "Show the resolved config and per-field provenance.",
-  doc: "Merges built-in defaults, the global XDG config, and the nearest pragma.config.ts, marking which layer supplied each value.",
+  doc: `Merges built-in defaults, the global XDG config, and the nearest ${PROJECT_CONFIG_FILENAME}, marking which layer supplied each value.`,
   params: [],
   output: { formatters: configShowFormatters },
   examples: [
-    { cmd: "pragma config show" },
-    { cmd: "pragma config show --format json" },
+    { cmd: `${BIN_NAME} config show` },
+    { cmd: `${BIN_NAME} config show --format json` },
   ],
   capability: {
     needsStore: false,
@@ -35,11 +35,12 @@ const showVerb: VerbSpec<Record<string, unknown>, ConfigShowData> = {
 };
 
 /**
- * The `config` capability module: the `show` reader (PR1), the storeless
- * `tier`/`channel`/`detail` setters (PR6), and the additive one-command `set`
- * verb (PR9), emitted in covenant order.
+ * The `config` capability module: the `show` reader (PR1) and the one-command
+ * `set <key> <value>` setter (PR9), emitted in covenant order. The per-field
+ * `tier`/`channel`/`detail` verbs were retired in favour of `config set`
+ * (AV-228 B3).
  */
 export const configModule: CapabilityModule = {
   name: "config",
-  verbs: [asVerb(showVerb), ...configFieldVerbs, configSetVerb],
+  verbs: [asVerb(showVerb), configSetVerb],
 };

package/src/capabilities/config/types.ts

@@ -6,6 +6,14 @@ import type { ConfigOrigins, PragmaConfig } from "../../kernel/config/types.js";
 
 /** The resolved configuration plus per-field provenance and layer locations. */
 export interface ConfigShowData {
+  /**
+   * The effective config, MINUS declared story bodies: `packs` entries carry
+   * `{ name, source }` only and the top-level `stories` array is omitted. The
+   * bodies are SPARQL, and MCP returns the JSON formatter's output verbatim, so
+   * carrying them would put ~2.7k tokens of query text in every `config_show`
+   * call. `origins` still reports where `packs`/`stories` came from, and
+   * `pragma capabilities` lists the verbs those stories produce.
+   */
   readonly config: PragmaConfig;
   readonly origins: ConfigOrigins;
   readonly projectConfigPath?: string;

package/src/capabilities/create/byteEquality.subprocess.test.ts

@@ -20,7 +20,7 @@ import { describe, expect, it } from "vitest";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(here, "../../../../../..");
-const pragmaBin = join(repoRoot, "packages/cli/next/src/bin.ts");
+const pragmaBin = join(repoRoot, "packages/cli/pragma/src/bin.ts");
 const summonCore = join(repoRoot, "packages/summon/core/dist/esm/index.js");
 const pickGen = join(here, "pickGenerator.ts");
 const freshCwd = (): string => mkdtempSync(join(tmpdir(), "pragma-xbin-"));

package/src/capabilities/create/byteEquality.test.ts

@@ -1,29 +1,42 @@
 /**
- * PROTECTED — the permanent seam contract: every `create` tree is produced TWO
- * ways and diffed byte-for-byte (path set + contents, incl. the "Generated by"
- * stamp): (1) `pragma create <verb> --yes` through the kernel dispatcher, and
- * (2) summon-core `execute` with `autoPrompt`, run through `runGeneratorTask` +
- * the shared stamp — the summon bin's path. They match because both derive the
- * StampConfig from `createGeneratorStamp` (displayName + version) and run the
- * SAME `generator.generate` with the SAME answers.
+ * PROTECTED — pragma's side of the byte-equality seam contract: every `create`
+ * tree is produced TWO ways and diffed byte-for-byte (path set + contents, incl.
+ * the "Generated by" stamp): (1) `pragma create <verb> --yes` through the kernel
+ * dispatcher, and (2) the REFERENCE — summon-core `execute` with `autoPrompt`,
+ * run through `runGeneratorTask` + the shared stamp. They match because both
+ * derive the StampConfig from `createGeneratorStamp` (displayName + version) and
+ * run the SAME `generator.generate` with the SAME answers.
+ *
+ * The reference producer, the tree snapshot/diff, and the answer sets are NOT
+ * defined here any more: they are `@canonical/summon-core/testing`, the named
+ * conformance suite both bins run (L-OPEN-10). This file supplies what only
+ * pragma can — its kernel dispatch path, and the mapping from a fixture's
+ * logical generator id to the bundled generator plus the CLI param names the
+ * `create` verbs take. No new package edge: pragma already depends on
+ * summon-core, and never on the summon bin.
  *
  * Five generators are covered: component × {react, svelte, lit}, package, and
  * application. A cross-binary subprocess guard lives in byteEquality.subprocess.test.ts.
  */
 
-import { mkdtempSync, readdirSync, readFileSync } from "node:fs";
+import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import {
+  CONFORMANCE_FIXTURES,
+  diffTrees,
+  formatTreeDiff,
+  isIdentical,
+  produceReference,
+  snapshotTree,
+  type TreeSnapshot,
+} from "@canonical/summon-core/testing";
 import { describe, expect, it } from "vitest";
 import { executeVerb } from "../../kernel/project/cli/dispatch.js";
 import { bootRuntime } from "../../kernel/runtime/boot.js";
 import type { GlobalFlags } from "../../kernel/runtime/types.js";
 import type { VerbSpec } from "../../kernel/spec/types.js";
-import {
-  createApplicationVerb,
-  createComponentVerb,
-  createPackageVerb,
-} from "./create.verb.js";
+import { createVerbs } from "./create.verb.js";
 import type { CreateKind } from "./types.js";
 
 const FLAGS: GlobalFlags = {
@@ -34,39 +47,17 @@ const FLAGS: GlobalFlags = {
 };
 const freshCwd = (): string => mkdtempSync(join(tmpdir(), "pragma-golden-"));
 
-/** Read a directory tree into a sorted map of relative path → contents. */
-function snapshot(dir: string): Map<string, string> {
-  const out = new Map<string, string>();
-  const walk = (d: string, base: string): void => {
-    for (const entry of readdirSync(d, { withFileTypes: true }).sort((a, b) =>
-      a.name.localeCompare(b.name),
-    )) {
-      const rel = base ? `${base}/${entry.name}` : entry.name;
-      if (entry.isDirectory()) walk(join(d, entry.name), rel);
-      else out.set(rel, readFileSync(join(d, entry.name), "utf-8"));
-    }
-  };
-  walk(dir, "");
-  return out;
-}
-
-const verbFor: Record<CreateKind, VerbSpec> = {
-  component: createComponentVerb as VerbSpec,
-  package: createPackageVerb as VerbSpec,
-  application: createApplicationVerb as VerbSpec,
-};
-
 /** Producer (1): the full pragma kernel path — dispatcher runs the create verb. */
 async function producePragma(
   kind: CreateKind,
   params: Record<string, unknown>,
-): Promise<Map<string, string>> {
+): Promise<TreeSnapshot> {
   const dir = freshCwd();
   const prev = process.cwd();
   process.chdir(dir);
   try {
     const outcome = await executeVerb(
-      verbFor[kind],
+      createVerbs[kind] as VerbSpec,
       params,
       { dryRun: false, undo: false, yes: true },
       bootRuntime(FLAGS, dir),
@@ -75,44 +66,38 @@ async function producePragma(
   } finally {
     process.chdir(prev);
   }
-  return snapshot(dir);
+  return snapshotTree(dir);
 }
 
-/** Producer (2): summon-core execute + autoPrompt + the shared stamp core. */
+/**
+ * Producer (2): the shared conformance REFERENCE, over pragma's own generator.
+ *
+ * The fixture names its generator logically; `pickGenerator` is what turns that
+ * into the bundled definition. The suite never imports a generator itself —
+ * summon-core sits below both bins.
+ */
 async function produceSummon(
   kind: CreateKind,
   framework: string,
-  answers: Record<string, unknown>,
-): Promise<Map<string, string>> {
+  answers: Readonly<Record<string, unknown>>,
+): Promise<TreeSnapshot> {
   const { pickGenerator } = await import("./pickGenerator.js");
-  const {
-    execute,
-    autoPrompt,
-    runGeneratorTask,
-    createGeneratorStamp,
-    createStampOnEffectStart,
-  } = await import("@canonical/summon-core");
-  const generator = pickGenerator(kind, { framework });
-  const dir = freshCwd();
-  await runGeneratorTask(
-    execute(generator, { prompt: autoPrompt(answers), params: answers }),
-    {
-      cwd: dir,
-      promptHandler: autoPrompt(answers),
-      onEffectStart: createStampOnEffectStart(createGeneratorStamp(generator)),
-      onLog: () => {},
-    },
-  );
-  return snapshot(dir);
+  return produceReference({
+    generator: pickGenerator(kind, { framework }),
+    answers,
+  });
 }
 
-/** One golden case: the create-verb params, and the equivalent summon answers. */
+/**
+ * One golden case: the shared fixture, plus what only pragma knows — which
+ * bundled generator the fixture's id names, and the CLI param names the create
+ * verb takes for the same answers.
+ */
 interface Case {
-  readonly name: string;
+  readonly fixture: string;
   readonly kind: CreateKind;
   readonly framework: string;
   readonly params: Record<string, unknown>;
-  readonly answers: Record<string, unknown>;
 }
 
 const componentAnswers = {
@@ -123,7 +108,7 @@ const componentAnswers = {
 
 const cases: Case[] = [
   {
-    name: "component/react",
+    fixture: "component/react",
     kind: "component",
     framework: "react",
     params: {
@@ -131,10 +116,9 @@ const cases: Case[] = [
       componentPath: "src/components/Button",
       ...componentAnswers,
     },
-    answers: { componentPath: "src/components/Button", ...componentAnswers },
   },
   {
-    name: "component/svelte",
+    fixture: "component/svelte",
     kind: "component",
     framework: "svelte",
     params: {
@@ -142,10 +126,9 @@ const cases: Case[] = [
       componentPath: "src/lib/Button",
       ...componentAnswers,
     },
-    answers: { componentPath: "src/lib/Button", ...componentAnswers },
   },
   {
-    name: "component/lit",
+    fixture: "component/lit",
     kind: "component",
     framework: "lit",
     params: {
@@ -153,10 +136,9 @@ const cases: Case[] = [
       componentPath: "src/lib/Button",
       ...componentAnswers,
     },
-    answers: { componentPath: "src/lib/Button", ...componentAnswers },
   },
   {
-    name: "package",
+    fixture: "package",
     kind: "package",
     framework: "",
     params: {
@@ -169,54 +151,53 @@ const cases: Case[] = [
       withPrTemplate: false,
       runInstall: false,
     },
-    answers: {
-      name: "@canonical/my-lib",
-      type: "library",
-      description: "A library.",
-      withReact: false,
-      withStorybook: false,
-      withCli: false,
-      withPrTemplate: false,
-      runInstall: false,
-    },
   },
   {
-    name: "application",
+    fixture: "application",
     kind: "application",
     framework: "",
+    // The pragma path receives the CLI `--with-X` params (AV-228 B8); the shared
+    // fixture carries the generator's bare prompt names. runCreate's boundary
+    // remap (`withSsr` -> `ssr`, ...) makes both produce the identical tree —
+    // which is exactly what this case exists to prove.
     params: {
       appPath: "my-app",
-      ssr: true,
-      router: true,
-      forms: true,
-      relay: false,
-      runInstall: false,
-    },
-    answers: {
-      appPath: "my-app",
-      ssr: true,
-      router: true,
-      forms: true,
-      relay: false,
+      withSsr: true,
+      withRouter: true,
+      withForms: true,
+      withRelay: false,
       runInstall: false,
     },
   },
 ];
 
-describe("byte-equality goldens — pragma create ≡ summon execute (PROTECTED)", () => {
+describe("byte-equality goldens — pragma create \u2261 the conformance reference (PROTECTED)", () => {
+  it("covers every shared conformance fixture", () => {
+    // The suite's fixture list is the contract; a fixture added there and not
+    // wired here would silently go unchecked on pragma's side.
+    expect(cases.map((entry) => entry.fixture)).toEqual(
+      CONFORMANCE_FIXTURES.map((entry) => entry.name),
+    );
+  });
+
   for (const testCase of cases) {
-    it(`${testCase.name}: both producers write byte-identical trees`, async () => {
+    it(`${testCase.fixture}: the kernel path matches the reference byte for byte`, async () => {
+      const shared = CONFORMANCE_FIXTURES.find(
+        (entry) => entry.name === testCase.fixture,
+      );
+      if (!shared) throw new Error(`no fixture "${testCase.fixture}"`);
       const pragma = await producePragma(testCase.kind, testCase.params);
-      const summon = await produceSummon(
+      const reference = await produceSummon(
         testCase.kind,
         testCase.framework,
-        testCase.answers,
+        shared.answers,
       );
       expect(pragma.size).toBeGreaterThan(0);
-      expect([...pragma.keys()].sort()).toEqual([...summon.keys()].sort());
-      for (const [path, content] of pragma) {
-        expect(summon.get(path), `content of ${path}`).toBe(content);
-      }
+      const diff = diffTrees(pragma, reference);
+      expect(
+        isIdentical(diff),
+        formatTreeDiff(diff, "pragma create", "the conformance reference"),
+      ).toBe(true);
     });
   }
 });