@canonical/pragma-cli 0.33.0 → 0.35.0

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

@@ -1,6 +1,8 @@
 import { describe, expect, it } from "vitest";
 import { type RenderStyle, styleFor } from "../../kernel/render/style.js";
-import { renderConfigShowPlain } from "./show.render.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 = {
@@ -8,16 +10,15 @@ const DATA: ConfigShowData = {
     tier: "apps/lxd",
     channel: "normal",
     detail: "standard",
-    packages: ["@canonical/ds"],
+    packs: ["@canonical/ds"],
   },
   origins: {
     tier: "project",
     channel: "default",
     detail: "default",
-    packages: "global",
+    packs: "global",
     stories: "default",
     prefixes: "default",
-    prompts: "default",
   },
   globalConfigPath: "/home/u/.config/pragma/config.json",
   projectConfigPath: "/repo/pragma.config.ts",
@@ -42,7 +43,7 @@ describe("renderConfigShowPlain", () => {
         "tier: apps/lxd [project]",
         "channel: normal",
         "detail: standard",
-        "packages: @canonical/ds [global]",
+        "packs: @canonical/ds [global]",
         "global config: /home/u/.config/pragma/config.json",
         "project config: /repo/pragma.config.ts",
       ].join("\n"),
@@ -62,4 +63,75 @@ describe("renderConfigShowPlain", () => {
     );
     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

@@ -8,7 +8,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 { Formatters } from "../../kernel/spec/index.js";
 import type { ConfigShowData } from "./types.js";
 
 /** A `[layer]` marker for values a config file supplied (blank for defaults). */
@@ -16,10 +16,9 @@ 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)";
@@ -32,14 +31,10 @@ type ConfigRow = readonly [label: string, value: string, marker: string];
 function configRows(data: ConfigShowData): readonly ConfigRow[] {
   const { config, origins } = data;
   return [
-    [
-      "tier",
-      config.tier ?? "(none — all tiers visible)",
-      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}${data.globalExists ? "" : " (not found)"}`,
@@ -89,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,21 +5,24 @@
  * 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 type { CapabilityModule, VerbSpec } from "../../kernel/spec/index.js";
+import { configGetVerb } from "./get.verb.js";
 import { configSetVerb } from "./set.verb.js";
 import { configShowFormatters } from "./show.render.js";
 import type { ConfigShowData } from "./types.js";
+import { configUnsetVerb } from "./unset.verb.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,
@@ -34,12 +37,13 @@ const showVerb: VerbSpec<Record<string, unknown>, ConfigShowData> = {
 };
 
 /**
- * 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).
+ * The `config` capability module, emitted in covenant order: the `show`
+ * reader, the `get <key>` single-value reader, the `set <key> <value>`
+ * writer, and the `unset <key>` clearer. The per-field `tier`/`channel`/
+ * `detail` verbs were retired in favour of `config set` (AV-228 B3);
+ * clearing moved from a magic `set` value to its own verb.
  */
 export const configModule: CapabilityModule = {
   name: "config",
-  verbs: [asVerb(showVerb), configSetVerb],
+  verbs: [asVerb(showVerb), configGetVerb, configSetVerb, configUnsetVerb],
 };

package/src/capabilities/config/types.ts

@@ -2,10 +2,22 @@
  * Data shapes for `pragma config show`.
  */
 
-import type { ConfigOrigins, PragmaConfig } from "../../kernel/config/types.js";
+import type {
+  ConfigOrigin,
+  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;
@@ -14,14 +26,24 @@ export interface ConfigShowData {
   readonly globalExists: boolean;
 }
 
-/** The outcome of a `config <field>` setter (set, or reset via sentinel). */
+/** The outcome of a config write (`set` writes a value, `unset` clears one). */
 export interface ConfigFieldResult {
   /** The config field written (`tier` / `channel` / `detail`). */
   readonly field: string;
-  /** The value written, or absent when the field was reset (removed). */
+  /** The value written, or absent when the field was cleared (removed). */
   readonly value?: string;
   /** The global config file the write landed in. */
   readonly path: string;
-  /** True when a reset sentinel removed the field rather than setting a value. */
+  /** True when `unset` removed the field rather than setting a value. */
   readonly reset: boolean;
 }
+
+/** The payload of `config get <key>` — one resolved value with provenance. */
+export interface ConfigGetData {
+  /** The config field read (`tier` / `channel` / `detail`). */
+  readonly field: string;
+  /** The effective value after layering, absent when the field is unset. */
+  readonly value?: unknown;
+  /** The layer that supplied the value (`default` / `global` / `project`). */
+  readonly source: ConfigOrigin;
+}

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

@@ -0,0 +1,58 @@
+/**
+ * `config unset <key>` — clear one config field.
+ *
+ * Clearing is a COMMAND, not a magic value: `config set` refuses the values
+ * that used to double as clear-markers, and this verb owns the job. Removes
+ * the field from the global layer so the built-in default (or a project
+ * config) applies again; project configs are authored by hand and never
+ * written here.
+ */
+
+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/index.js";
+import { configFieldFormatters } from "./field.render.js";
+import { CONFIG_FIELDS } from "./fields.js";
+import type { ConfigFieldResult } from "./types.js";
+
+/** The clearable field names — the `<key>` enum, in covenant order. */
+const CONFIG_KEYS = CONFIG_FIELDS.map((field) => field.field);
+
+const unsetVerb: VerbSpec<Record<string, unknown>, ConfigFieldResult> = {
+  path: ["config", "unset"],
+  summary: "Clear a config field by name.",
+  doc: "Removes a field from the global config so the built-in default (or a project config) applies again. The counterpart of `config set` — setting writes a value, unsetting removes one; no value doubles as a remove-marker.",
+  params: [
+    {
+      kind: "enum",
+      name: "key",
+      doc: "The config field to clear.",
+      values: CONFIG_KEYS,
+      required: true,
+      positional: true,
+    },
+  ],
+  output: { formatters: configFieldFormatters },
+  examples: [
+    { cmd: `${BIN_NAME} config unset tier`, note: "read the full graph again" },
+    { cmd: `${BIN_NAME} config unset channel` },
+  ],
+  capability: {
+    needsStore: false,
+    mutates: true,
+    mcp: {
+      expose: true,
+      annotations: { readOnlyHint: false, openWorldHint: false },
+    },
+  },
+  // Lazily import the write body (off the fast path); the `Task` arm is the
+  // same honest cast `config set` uses.
+  run: (params) =>
+    import("./runSet.js").then((m) =>
+      m.runUnset(params),
+    ) as unknown as Task<ConfigFieldResult>,
+};
+
+/** The `config unset` verb. */
+export const configUnsetVerb = asVerb(unsetVerb);

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

@@ -48,9 +48,8 @@ describe("cross-binary byte-equality (PROTECTED)", () => {
         pragmaBin,
         "create",
         "component",
-        "src/components/Button",
-        "--framework",
         "react",
+        "src/components/Button",
         "--yes",
       ],
       { cwd: pragmaDir, stdio: "pipe" },
@@ -66,7 +65,7 @@ import { pickGenerator } from ${JSON.stringify(`file://${pickGen}`)};
 import { execute, autoPrompt, runGeneratorTask, createGeneratorStamp, createStampOnEffectStart } from ${JSON.stringify(`file://${summonCore}`)};
 const dir = process.argv[2];
 const answers = { componentPath: "src/components/Button", withStyles: true, withStories: true, withSsrTests: true };
-const gen = pickGenerator("component", { framework: "react" });
+const gen = pickGenerator("component/react");
 await runGeneratorTask(execute(gen, { prompt: autoPrompt(answers), params: answers }), {
   cwd: dir,
   promptHandler: autoPrompt(answers),

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

@@ -1,29 +1,43 @@
 /**
- * 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 { blankCanonicalRanges } from "../../testing/helpers/blankCanonicalRanges.js";
+import { createVerbs } from "./create.verb.js";
 import type { CreateKind } from "./types.js";
 
 const FLAGS: GlobalFlags = {
@@ -34,39 +48,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 +67,46 @@ 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);
+  // pickGenerator is keyed by FULL COMMAND PATH now; this surface still
+  // thinks in kind+framework, so map first (exactly as runCreate does).
+  const commandPath =
+    kind === "component"
+      ? `component/${framework}`
+      : kind === "package"
+        ? "package"
+        : "application/react";
+  return produceReference({
+    generator: pickGenerator(commandPath),
+    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 +117,7 @@ const componentAnswers = {
 
 const cases: Case[] = [
   {
-    name: "component/react",
+    fixture: "component/react",
     kind: "component",
     framework: "react",
     params: {
@@ -131,10 +125,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 +135,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 +145,9 @@ const cases: Case[] = [
       componentPath: "src/lib/Button",
       ...componentAnswers,
     },
-    answers: { componentPath: "src/lib/Button", ...componentAnswers },
   },
   {
-    name: "package",
+    fixture: "package",
     kind: "package",
     framework: "",
     params: {
@@ -169,36 +160,16 @@ 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 summon
-    // path receives the generator's bare prompt names. runCreate's boundary remap
-    // (`withSsr` -> `ssr`, ...) makes both produce the byte-identical tree.
+    // The prompt names ARE the param names now (the B8 alias seam is gone):
+    // the pragma path takes the generator's own `forms`/`relay` (ssr/router
+    // are always-on facts, no longer prompts).
     params: {
       appPath: "my-app",
-      withSsr: true,
-      withRouter: true,
-      withForms: true,
-      withRelay: false,
-      runInstall: false,
-    },
-    answers: {
-      appPath: "my-app",
-      ssr: true,
-      router: true,
       forms: true,
       relay: false,
       runInstall: false,
@@ -206,20 +177,41 @@ const cases: Case[] = [
   },
 ];
 
-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 () => {
-      const pragma = await producePragma(testCase.kind, testCase.params);
-      const summon = await produceSummon(
+    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}"`);
+      let pragma = await producePragma(testCase.kind, testCase.params);
+      let 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);
+      // Two independent `npm view` resolutions feed the application tree
+      // (one per producer); blank the @canonical/* ranges identically so an
+      // asymmetric registry outcome cannot red this template-surface cell —
+      // range truth lives in the offline subprocess cells.
+      if (testCase.kind === "application") {
+        pragma = blankCanonicalRanges(pragma);
+        reference = blankCanonicalRanges(reference);
       }
+      expect(pragma.size).toBeGreaterThan(0);
+      const diff = diffTrees(pragma, reference);
+      expect(
+        isIdentical(diff),
+        formatTreeDiff(diff, "pragma create", "the conformance reference"),
+      ).toBe(true);
     });
   }
 });