@canonical/pragma-cli 0.32.0 → 0.33.0

package/src/capabilities/colophon/markdownTerminal.ts

@@ -7,11 +7,14 @@
  *
  * Single consumer today (`pragma colophon`); a promotion candidate to
  * `kernel/render/` if another verb ever wants the same helper. Determinism note:
- * styling routes entirely through `chalk`, so a test forcing `chalk.level = 0`
- * gets a stable, color-free snapshot of the structural transforms.
+ * styling routes through the shared {@link RenderStyle} seam (color only on a
+ * color-capable TTY), so piped / redirected / CI output — where `supports-color`
+ * can report a level with no TTY — stays byte-for-byte the color-free structural
+ * transform, and a test can force either mode by passing an explicit style.
  */
 
 import chalk from "chalk";
+import { defaultStyle, type RenderStyle } from "../../kernel/render/style.js";
 
 /** Full ANSI escape sequences (`ESC [ … final-letter`) — colour/cursor codes. */
 // biome-ignore lint/suspicious/noControlCharactersInRegex: deliberate control-char scrub
@@ -33,25 +36,35 @@ function stripControl(line: string): string {
   return line.replace(ANSI_ESCAPE, "").replace(C0_CONTROLS, "");
 }
 
-/** Style inline `**bold**` and `` `code` `` spans within one line. */
-function styleInline(text: string): string {
+/**
+ * Style inline `**bold**` and `` `code` `` spans within one line. The `**` / `` ` ``
+ * markers are ALWAYS consumed; off a TTY the styler is inert, so the markers drop
+ * with no color (byte-identical to the pre-seam `chalk.level = 0` behavior).
+ */
+function styleInline(text: string, style: RenderStyle): string {
   return text
-    .replace(/\*\*([^*]+)\*\*/g, (_match, inner: string) => chalk.bold(inner))
-    .replace(/`([^`]+)`/g, (_match, inner: string) => chalk.cyan(inner));
+    .replace(/\*\*([^*]+)\*\*/g, (_match, inner: string) => style.bold(inner))
+    .replace(/`([^`]+)`/g, (_match, inner: string) => style.cyan(inner));
 }
 
 /**
  * Render a Markdown string to styled terminal text.
  *
  * @param markdown - The authored Markdown body.
- * @returns The chalk-styled terminal string (no trailing newline).
+ * @param style - The TTY styler; defaults to the process style. On a color-capable
+ *   terminal headings/bullets/inline spans are tinted; off a TTY the styler is
+ *   inert, so the output is byte-identical to the color-free structural form.
+ * @returns The styled terminal string (no trailing newline).
  */
-export function renderMarkdownToTerminal(markdown: string): string {
+export function renderMarkdownToTerminal(
+  markdown: string,
+  style: RenderStyle = defaultStyle(),
+): string {
   const lines: string[] = [];
   let inFence = false;
 
   for (const rawLine of markdown.split("\n")) {
-    // Scrub pack-authored terminal control codes BEFORE our own chalk styling
+    // Scrub pack-authored terminal control codes BEFORE our own styling
     // (colophon bodies are domain-as-data — never a channel for raw ANSI).
     const raw = stripControl(rawLine);
     // A fence toggles code mode; the ``` markers themselves are dropped.
@@ -60,25 +73,31 @@ export function renderMarkdownToTerminal(markdown: string): string {
       continue;
     }
     if (inFence) {
-      lines.push(chalk.dim(`  ${raw}`));
+      lines.push(style.dim(`  ${raw}`));
       continue;
     }
 
     const heading = /^(#{1,6})\s+(.+)$/.exec(raw);
     if (heading) {
       const level = heading[1]?.length ?? 1;
-      const text = styleInline(heading[2] ?? "");
-      lines.push(level === 1 ? chalk.bold.underline(text) : chalk.bold(text));
+      const text = styleInline(heading[2] ?? "", style);
+      // H1 earns bold+underline on a TTY; underline is outside the RenderStyle
+      // seam, so reach for chalk only when the styler is enabled.
+      lines.push(
+        level === 1 && style.enabled
+          ? chalk.bold.underline(text)
+          : style.bold(text),
+      );
       continue;
     }
 
     const bullet = /^\s*[-*]\s+(.+)$/.exec(raw);
     if (bullet) {
-      lines.push(`  ${chalk.cyan("•")} ${styleInline(bullet[1] ?? "")}`);
+      lines.push(`  ${style.cyan("•")} ${styleInline(bullet[1] ?? "", style)}`);
       continue;
     }
 
-    lines.push(styleInline(raw));
+    lines.push(styleInline(raw, style));
   }
 
   return lines.join("\n");

package/src/capabilities/colophon/pragmaColophon.ts

@@ -4,7 +4,7 @@
  * colophon` as the first section, before any active pack's domain colophon.
  *
  * `PRAGMA_COLOPHON` is the full narrative for humans; `PRAGMA_COLOPHON_SUMMARY`
- * is the condensed form `--llm` emits (Markdown IS the agent-optimal shape).
+ * is the condensed form `--format llm` emits (Markdown IS the agent-optimal shape).
  * Both are BODIES with no leading H1 — the renderer supplies the "pragma"
  * heading, so the section is never double-titled.
  */
@@ -32,7 +32,7 @@ source of truth a test asserts the live grammar still emits, tool for tool.
 ## LLM-optimized output
 
 Each verb renders three ways — \`plain\` for a terminal, \`json\` for the machine
-envelope, and \`llm\` for condensed Markdown. \`--llm\` (or a non-interactive
+envelope, and \`llm\` for condensed Markdown. \`--format llm\` (or a non-interactive
 stdout) selects the agent form: the same data, shaped for a model to read. This
 colophon is itself a showcase of that render model.
 
@@ -56,11 +56,11 @@ queries) compiled into verbs, backed by a content-addressed graphpack that
 \`sources update\` builds once. Swap the pack and the same pragma serves a
 different domain — including the domain colophon printed below this one.`;
 
-/** The condensed colophon for `--llm` (Markdown body, no leading H1). */
+/** The condensed colophon for `--format llm` (Markdown body, no leading H1). */
 export const PRAGMA_COLOPHON_SUMMARY = `pragma is a domain-based toolchain: one CLI + MCP server projected from a single \`VerbSpec\` grammar.
 
 - **Effect monad** (\`@canonical/task\`): reads are async; a mutation returns an interpreted \`Task\`, so \`--dry-run\` and \`--undo\` are free. The dispatcher branches on \`capability.mutates\`.
 - **One grammar, many projections**: CLI, MCP tools, completion, and docs all project one \`VerbSpec\`; the emitted surface is frozen in a covenant so the projections never drift.
-- **LLM-optimized output**: every verb renders \`plain\` / \`json\` / \`llm\`; \`--llm\` emits condensed Markdown for agents.
+- **LLM-optimized output**: every verb renders \`plain\` / \`json\` / \`llm\`; \`--format llm\` (or a piped stdout) emits condensed Markdown for agents.
 - **Modular + storeless**: capability modules; the triple store boots only for \`needsStore\` verbs.
 - **Domain as data**: a pack is a declarative \`PackDefinition\` compiled to verbs over a content-addressed graph built by \`sources update\`.`;

package/src/capabilities/colophon/types.ts

@@ -17,7 +17,7 @@ export interface ColophonSection {
    * heading from {@link title}, so a section is never double-titled).
    */
   readonly markdown: string;
-  /** Optional condensed body for `--llm` (pragma supplies one). */
+  /** Optional condensed body for `--format llm` (pragma supplies one). */
   readonly summary?: string;
   /** Provenance: `"built-in"`, or `"pack:<name>"`. */
   readonly source?: string;

package/src/capabilities/config/fields.ts

@@ -1,28 +1,19 @@
 /**
- * The config field table — one declarative row per writable field drives all
- * three setters (`tier` / `channel` / `detail`), the way the pack grammar
- * compiles read verbs from a table.
- *
- * Covenant-exact emission is the hard gate (surfaceConformance): each verb must
- * `emitVerb` to `{ v:<field>, args:["<positional>"], mutates:true,
- * mcp:"config_<field>" }` — one REQUIRED positional, NO flags, NO needsStore
- * (config setters are storeless; the old store-backed `validateTier` is dropped
- * — PARITY_GAP `config-tier-no-ontology-validation`). The factory produces
- * exactly that shape; the `field.test.ts` deep-equals the golden slice.
+ * The config field table — one declarative row per writable field. Since AV-228
+ * B3 retired the per-field `config tier`/`channel`/`detail` verbs, this table no
+ * longer emits verbs of its own: it is the shared source of truth that drives
+ * `config set <key> <value>` (via `runSet` → `runField`), giving `set` its
+ * `<key>` enum, per-field reset sentinels, enum validation, and positional
+ * shaping for free.
  */
 
-import type { Task } from "@canonical/task";
 import { DETAIL_LEVELS } from "../../constants.js";
 import type { RawConfig } from "../../kernel/config/types.js";
 import { CHANNELS } from "../../kernel/config/types.js";
-import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { ParamSpec, VerbSpec } from "../../kernel/spec/types.js";
-import { configFieldFormatters } from "./field.render.js";
-import type { ConfigFieldResult } from "./types.js";
 
 /** One writable config field and how its single positional is shaped/validated. */
 export interface ConfigFieldSpec {
-  /** The `RawConfig` key written (also the verb label + `config_<field>` tool). */
+  /** The `RawConfig` key written (also the `config set` `<key>` enum member). */
   readonly field: keyof RawConfig & ("tier" | "channel" | "detail");
   /** The positional param NAME — its usage token is `<positional>` (covenant). */
   readonly positional: string;
@@ -30,24 +21,22 @@ export interface ConfigFieldSpec {
   readonly kind: "string" | "enum";
   /** The allowed values for an enum field. */
   readonly values?: readonly string[];
-  /** One-line verb summary. */
+  /** One-line field summary. */
   readonly summary: string;
   /** Extended help doc. */
   readonly doc: string;
   /** Reserved values that REMOVE the field instead of setting it. */
   readonly resetSentinel?: readonly string[];
-  /** Verb help examples. */
+  /** Field help examples. */
   readonly examples: readonly { cmd: string; note?: string }[];
 }
 
 /**
  * The three writable fields. Only `tier` (a free string with a meaningful
  * "no value") carries reset sentinels; `channel`/`detail` reset by setting
- * their default (`normal`/`standard`) — no `--reset` flag exists, because a
- * flag would emit `flags:[...]` and break the covenant (PARITY_GAP
- * `config-field-reset-sentinel`). Query is `config show` — the covenant gives
- * each setter exactly ONE required positional, so a no-arg "print current" mode
- * is impossible here (PARITY_GAP `config-field-query-via-show`).
+ * their default (`normal`/`standard`). The migration path for the retired
+ * field-verbs is `config set <field> <value>` (e.g. `config set tier apps/lxd`,
+ * `config set tier none` to clear it).
  */
 export const CONFIG_FIELDS: readonly ConfigFieldSpec[] = [
   {
@@ -58,8 +47,11 @@ export const CONFIG_FIELDS: readonly ConfigFieldSpec[] = [
     summary: "Set the active design-system tier.",
     doc: "Writes the `tier` field to the global config. Pass `none`, `default`, or `-` to clear it. Written to the global layer only — project configs are authored by hand.",
     examples: [
-      { cmd: "pragma config tier apps/lxd", note: "scope reads to a tier" },
-      { cmd: "pragma config tier none", note: "clear the tier" },
+      {
+        cmd: "pragma config set tier apps/lxd",
+        note: "scope reads to a tier",
+      },
+      { cmd: "pragma config set tier none", note: "clear the tier" },
     ],
   },
   {
@@ -70,8 +62,8 @@ export const CONFIG_FIELDS: readonly ConfigFieldSpec[] = [
     summary: "Set the release channel controlling component visibility.",
     doc: "Writes the `channel` field to the global config. Reset by setting the default, `normal`.",
     examples: [
-      { cmd: "pragma config channel experimental" },
-      { cmd: "pragma config channel normal", note: "back to the default" },
+      { cmd: "pragma config set channel experimental" },
+      { cmd: "pragma config set channel normal", note: "back to the default" },
     ],
   },
   {
@@ -82,71 +74,8 @@ export const CONFIG_FIELDS: readonly ConfigFieldSpec[] = [
     summary: "Set the default progressive-disclosure level.",
     doc: "Writes the `detail` field to the global config. Reset by setting the default, `standard`.",
     examples: [
-      { cmd: "pragma config detail detailed" },
-      { cmd: "pragma config detail standard", note: "back to the default" },
+      { cmd: "pragma config set detail detailed" },
+      { cmd: "pragma config set detail standard", note: "back to the default" },
     ],
   },
 ];
-
-/** The single required positional for a field, shaped per its `kind`. */
-function fieldPositional(spec: ConfigFieldSpec): ParamSpec {
-  // Name the positional by its usage token (`<path>`/`<name>`/`<level>`) so the
-  // doc and the token agree (was "The tier value to write." for a `<path>`).
-  const doc = `The ${spec.field} ${spec.positional} to write.`;
-  if (spec.kind === "enum") {
-    return {
-      kind: "enum",
-      name: spec.positional,
-      doc,
-      values: spec.values ?? [],
-      required: true,
-      positional: true,
-    };
-  }
-  return {
-    kind: "string",
-    name: spec.positional,
-    doc,
-    required: true,
-    positional: true,
-  };
-}
-
-/**
- * Build one storeless, mutating config setter from a field spec.
- *
- * `run` lazily imports the write body and presents `Promise<Task<R>>` through
- * the `Task<R>` arm by the honest cast (the same seam `sources update` uses) —
- * a literal `Promise<Task>` union arm would poison async read-verb inference.
- *
- * @param spec - The field-table row.
- * @returns The verb spec for `config <field>`.
- */
-export function fieldVerb(
-  spec: ConfigFieldSpec,
-): VerbSpec<Record<string, unknown>, ConfigFieldResult> {
-  return {
-    path: ["config", spec.field],
-    summary: spec.summary,
-    doc: spec.doc,
-    params: [fieldPositional(spec)],
-    output: { formatters: configFieldFormatters },
-    examples: [...spec.examples],
-    capability: {
-      needsStore: false,
-      mutates: true,
-      mcp: {
-        expose: true,
-        annotations: { readOnlyHint: false, openWorldHint: false },
-      },
-    },
-    run: (params) =>
-      import("./runField.js").then((m) =>
-        m.runField(spec, params),
-      ) as unknown as Task<ConfigFieldResult>,
-  };
-}
-
-/** The three config setters, in covenant order (tier, channel, detail). */
-export const configFieldVerbs: VerbSpec[] =
-  CONFIG_FIELDS.map(fieldVerb).map(asVerb);

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

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

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { type RenderStyle, styleFor } from "../../kernel/render/style.js";
+import { renderConfigShowPlain } from "./show.render.js";
+import type { ConfigShowData } from "./types.js";
+
+const DATA: ConfigShowData = {
+  config: {
+    tier: "apps/lxd",
+    channel: "normal",
+    detail: "standard",
+    packages: ["@canonical/ds"],
+  },
+  origins: {
+    tier: "project",
+    channel: "default",
+    detail: "default",
+    packages: "global",
+    stories: "default",
+    prefixes: "default",
+    prompts: "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",
+        "packages: @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>");
+  });
+});

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";
 
@@ -24,18 +25,63 @@ function packageNames(data: ConfigShowData): string {
   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 — 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)", ""],
+  ];
+}
+
+/**
+ * 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) {

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

@@ -7,7 +7,6 @@
 
 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";
@@ -35,11 +34,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/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

@@ -184,12 +184,15 @@ const cases: Case[] = [
     name: "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.
     params: {
       appPath: "my-app",
-      ssr: true,
-      router: true,
-      forms: true,
-      relay: false,
+      withSsr: true,
+      withRouter: true,
+      withForms: true,
+      withRelay: false,
       runInstall: false,
     },
     answers: {

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

@@ -28,7 +28,7 @@ import { beforeAll, describe, expect, it } from "vitest";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(here, "../../../../../..");
-const cliNextDir = join(repoRoot, "packages/cli/next");
+const cliNextDir = join(repoRoot, "packages/cli/pragma");
 const pragmaBin = join(cliNextDir, "src/bin.ts");
 const compiledBin = join(cliNextDir, "dist/pragma");
 const freshCwd = (): string => mkdtempSync(join(tmpdir(), "pragma-compiled-"));

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

@@ -29,6 +29,7 @@ import {
   createApplicationVerb,
   createComponentVerb,
   createPackageVerb,
+  INCLUDE_FLAG_ALIASES,
   isModuleNotFound,
 } from "./create.verb.js";
 import { generatorToParams } from "./generatorToVerbSpec.js";
@@ -350,6 +351,18 @@ describe("generator→grammar adapter parity (PROTECTED)", () => {
     });
   });
 
+  /** Map a mirror's CLI `--with-X` include-flag names back to the generator
+   * prompt names (AV-228 B8) so the parity comparison still checks kinds and
+   * defaults against the real generator despite the deliberate flag rename. */
+  const toGeneratorNames = (
+    kind: "application",
+    params: readonly ParamSpec[],
+  ): ParamSpec[] =>
+    params.map((p) => {
+      const generatorName = INCLUDE_FLAG_ALIASES[kind][p.name];
+      return generatorName ? ({ ...p, name: generatorName } as ParamSpec) : p;
+    });
+
   it("application: mirror matches the application/react generator (defaults)", async () => {
     const { generators } = await import("@canonical/summon-application");
     const real = generatorToParams(
@@ -357,9 +370,25 @@ describe("generator→grammar adapter parity (PROTECTED)", () => {
         "application/react"
       ].prompts as never,
     );
-    expect(behavioural(createApplicationVerb.params)).toEqual(
-      behavioural(applyRunInstallOverride(real)),
-    );
+    // Bridge the B8 include-flag rename before comparing: the CLI grammar
+    // exposes `withSsr`/`withRouter`/`withForms`, which map back to the
+    // generator's `ssr`/`router`/`forms`.
+    expect(
+      behavioural(
+        toGeneratorNames("application", createApplicationVerb.params),
+      ),
+    ).toEqual(behavioural(applyRunInstallOverride(real)));
+
+    // Guard the B8 rename itself: ALL application include-flags ARE on the
+    // `--with-X` convention (params `withSsr`/`withRouter`/`withForms`/
+    // `withRelay`), not the bare `ssr`/`router`/`forms`/`relay` booleans.
+    const names = createApplicationVerb.params.map((p) => p.name);
+    expect(names).toContain("withSsr");
+    expect(names).toContain("withRouter");
+    expect(names).toContain("withForms");
+    expect(names).toContain("withRelay");
+    expect(names).not.toContain("ssr");
+    expect(names).not.toContain("relay");
 
     const realRunInstall = real.find((p) => p.name === "runInstall") as
       | Record<string, unknown>