@canonical/pragma-cli 0.36.0 → 0.38.0

package/src/capabilities/capabilities/hints.ts

@@ -71,6 +71,11 @@ export const TOOL_HINTS: Record<string, ToolHint> = {
     use_when:
       "Checking the active configuration (tier, channel, detail) and which layer set each field",
   },
+  graph_connect: {
+    category: "read",
+    use_when:
+      "Deciding whether two entities are related at all — the shortest relation paths between them, or which kind of nothing there is",
+  },
   graph_inspect: {
     category: "read",
     use_when:
@@ -168,7 +173,7 @@ export const TOOL_HINTS: Record<string, ToolHint> = {
   },
   tier_list: {
     category: "read",
-    use_when: "Understanding the tier hierarchy before setting a tier filter",
+    use_when: "Picking the tier to scope a read to (the `tier` parameter)",
   },
   tier_lookup: {
     category: "read",
@@ -177,17 +182,47 @@ export const TOOL_HINTS: Record<string, ToolHint> = {
   token_list: {
     category: "read",
     use_when:
-      "Browsing design tokens, optionally filtered by category (color, spacing, etc.)",
+      "Browsing which token SYMBOLS exist (the logical dotted names), optionally by type or by the symbol a channel provisions",
   },
   token_lookup: {
     category: "read",
     use_when:
-      "Need theme values and resolution details for specific tokens by name or IRI",
+      "Need one symbol in full — its definitions, the families that may rebind it, and what it resolves to at each position",
+  },
+  token_values: {
+    category: "read",
+    use_when:
+      "Need the value a symbol resolves to at a position, with the chain that produced it or the symbol it derives from",
+  },
+  token_consumers: {
+    category: "read",
+    use_when:
+      "Need which blocks consume a symbol, at which style key, state and rank",
   },
   token_sample: {
     category: "read",
     use_when:
-      "See actual token data shapes (with theme values) before querying — returns random instances each call",
+      "See actual token symbol data shapes before querying — returns random instances each call",
+  },
+  variable_list: {
+    category: "read",
+    use_when:
+      "Browsing the platform names a stylesheet declares, by platform, symbol, tier, visibility or coordinate — including the 236 that stand for no symbol",
+  },
+  variable_lookup: {
+    category: "read",
+    use_when:
+      "Need one platform variable in full — its symbol, tier, visibility, and every selector and at-rule it is declared under",
+  },
+  variable_chain: {
+    category: "read",
+    use_when:
+      "Need what a variable finally means: the transitive walk to every symbol it reaches",
+  },
+  variable_sample: {
+    category: "read",
+    use_when:
+      "See actual platform variable data shapes before querying — returns random instances each call",
   },
 
   // — Write ——————————————————————————————————————————————————————————————————
@@ -213,7 +248,7 @@ export const TOOL_HINTS: Record<string, ToolHint> = {
   create_application: {
     category: "write",
     use_when:
-      "Scaffolding a new React application with SSR, routing, and optional Relay",
+      "Scaffolding a new React application with routing, optional Relay, and either server-side rendering or a client-only SPA",
   },
   setup: {
     category: "write",

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

@@ -36,6 +36,7 @@ describe("config show payload", () => {
     ).toEqual([
       "@canonical/design-system",
       "@canonical/anatomy-dsl",
+      "@canonical/token-ontology",
       "@canonical/code-standards",
       "@canonical/ds-implementations",
     ]);

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

@@ -108,36 +108,35 @@ describe("config set — the reserved clear-markers are refused, naming unset",
   // Clearing a field is a command, so no value may quietly mean "remove me":
   // the three strings that used to are rejected, and the rejection names the
   // command that owns the job. `tier` keeps whatever it held.
-  it.each([
-    "none",
-    "default",
-    "-",
-  ])("set tier %s is INVALID_INPUT that recovers with config unset tier", async (reserved) => {
-    const cwd = tmp("pragma-proj-");
-    await executeVerb(
-      setVerb,
-      { key: "tier", value: "apps/lxd" },
-      REAL,
-      bootRuntime(FLAGS, cwd),
-    );
-    let caught: unknown;
-    try {
+  it.each(["none", "default", "-"])(
+    "set tier %s is INVALID_INPUT that recovers with config unset tier",
+    async (reserved) => {
+      const cwd = tmp("pragma-proj-");
       await executeVerb(
         setVerb,
-        { key: "tier", value: reserved },
+        { key: "tier", value: "apps/lxd" },
         REAL,
         bootRuntime(FLAGS, cwd),
       );
-    } catch (error) {
-      caught = error;
-    }
-    expect(caught).toBeInstanceOf(PragmaError);
-    expect((caught as PragmaError).code).toBe("INVALID_INPUT");
-    expect(JSON.stringify((caught as PragmaError).recovery)).toContain(
-      "config unset tier",
-    );
-    expect(readGlobal().tier).toBe("apps/lxd");
-  });
+      let caught: unknown;
+      try {
+        await executeVerb(
+          setVerb,
+          { key: "tier", value: reserved },
+          REAL,
+          bootRuntime(FLAGS, cwd),
+        );
+      } catch (error) {
+        caught = error;
+      }
+      expect(caught).toBeInstanceOf(PragmaError);
+      expect((caught as PragmaError).code).toBe("INVALID_INPUT");
+      expect(JSON.stringify((caught as PragmaError).recovery)).toContain(
+        "config unset tier",
+      );
+      expect(readGlobal().tier).toBe("apps/lxd");
+    },
+  );
 
   it("a reserved marker is only reserved for a free-string field", () => {
     // `channel`/`detail` are closed enums: their rejection is the enum

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

@@ -40,7 +40,9 @@ 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]",
+        // The value AND the scope it puts every tiered read under: `tier`
+        // decides a scope now, so the line that reports it says which.
+        "tier: apps/lxd — apps/lxd and its ancestors [project]",
         "channel: normal",
         "detail: standard",
         "packs: @canonical/ds [global]",
@@ -55,7 +57,7 @@ describe("renderConfigShowPlain", () => {
     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>`,
+      `<d>${"tier:".padEnd(keyWidth)}</d> <c>apps/lxd — apps/lxd and its ancestors</c><d> [project]</d>`,
     );
     // A default-origin value carries no marker.
     expect(out).toContain(
@@ -82,7 +84,8 @@ describe("renderConfigShowPlain", () => {
 
     const out = renderConfigShowPlain(bare, styleFor(false));
 
-    expect(out).toContain("tier: (none)");
+    // Unset is not "no scope": it is the default scope, and the line says so.
+    expect(out).toContain("tier: (none) — the top-level tiers");
     expect(out).toContain("packs: (none)");
     expect(out).toContain("project config: (not found)");
   });
@@ -92,7 +95,9 @@ 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(
+      "- **Tier:** apps/lxd — apps/lxd and its ancestors [project]",
+    );
     expect(out).toContain("- **Packs:** @canonical/ds [global]");
   });
 

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

@@ -7,6 +7,7 @@
  */
 
 import type { ConfigOrigin } from "../../kernel/config/types.js";
+import { EVERY_TIER } from "../../kernel/packs/types.js";
 import { defaultStyle, type RenderStyle } from "../../kernel/render/style.js";
 import type { Formatters } from "../../kernel/spec/index.js";
 import type { ConfigShowData } from "./types.js";
@@ -16,6 +17,29 @@ function originMarker(origin: ConfigOrigin): string {
   return origin === "default" ? "" : ` [${origin}]`;
 }
 
+/**
+ * The `tier` value with the SCOPE it puts every tiered read under.
+ *
+ * The value alone is not the answer to "what am I reading". `tier` used to be
+ * accepted and read by nothing, and `config show` reported it as a setting in
+ * force while `block list` answered from all fifteen tiers; now it decides a
+ * scope, so this line has to say which. The three cases are the whole rule:
+ * unset is the top-level tiers, a tier is that tier and its ancestors, and
+ * `all` turns the scope off.
+ *
+ * It names the RULE and not the tiers, deliberately: `config show` is storeless
+ * (`capability.needsStore: false`) and naming the five top-level tiers means
+ * booting the pack to read them. The tiers themselves are one command away
+ * (`tier list`), and every scoped answer states its own scope in its heading —
+ * so the reading a store could add here is already available where it matters.
+ */
+function tierScope(tier: string | undefined): string {
+  if (tier === undefined) return "the top-level tiers";
+  return tier.trim().toLowerCase() === EVERY_TIER
+    ? "every tier"
+    : `${tier} and its ancestors`;
+}
+
 /** 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) =>
@@ -31,7 +55,11 @@ type ConfigRow = readonly [label: string, value: string, marker: string];
 function configRows(data: ConfigShowData): readonly ConfigRow[] {
   const { config, origins } = data;
   return [
-    ["tier", config.tier ?? "(none)", originMarker(origins.tier)],
+    [
+      "tier",
+      `${config.tier ?? "(none)"} — ${tierScope(config.tier)}`,
+      originMarker(origins.tier),
+    ],
     ["channel", config.channel, originMarker(origins.channel)],
     ["detail", config.detail ?? "standard", originMarker(origins.detail)],
     ["packs", entryNames(config.packs ?? []), originMarker(origins.packs)],
@@ -84,7 +112,7 @@ export const configShowFormatters: Formatters<ConfigShowData> = {
     const lines = [
       "## Configuration",
       "",
-      `- **Tier:** ${config.tier ?? "none"}${originMarker(origins.tier)}`,
+      `- **Tier:** ${config.tier ?? "none"} — ${tierScope(config.tier)}${originMarker(origins.tier)}`,
       `- **Channel:** ${config.channel}${originMarker(origins.channel)}`,
       `- **Detail:** ${config.detail ?? "standard"}${originMarker(origins.detail)}`,
       `- **Packs:** ${entryNames(config.packs ?? [])}${originMarker(origins.packs)}`,

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

@@ -15,7 +15,8 @@
  * `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
+ * Five generators are covered across seven fixtures: component × {react, svelte, lit},
+ * package, and
  * application. A cross-binary subprocess guard lives in byteEquality.subprocess.test.ts.
  */
 
@@ -175,6 +176,32 @@ const cases: Case[] = [
       runInstall: false,
     },
   },
+  {
+    fixture: "application-spa",
+    kind: "application",
+    framework: "",
+    params: {
+      appPath: "my-app",
+      forms: true,
+      intl: false,
+      relay: false,
+      rendering: "spa",
+      runInstall: false,
+    },
+  },
+  {
+    fixture: "application-spa-all",
+    kind: "application",
+    framework: "",
+    params: {
+      appPath: "my-app",
+      forms: true,
+      intl: true,
+      relay: true,
+      rendering: "spa",
+      runInstall: false,
+    },
+  },
 ];
 
 describe("byte-equality goldens — pragma create \u2261 the conformance reference (PROTECTED)", () => {

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

@@ -688,6 +688,7 @@ describe("projection fidelity — the committed surface IS the live generators (
       "appPath",
       "forms",
       "intl",
+      "rendering",
       "relay",
       "runInstall",
     ]);

package/src/capabilities/create/create.verb.ts

@@ -523,11 +523,12 @@ export const createVerbs: Record<
   ),
   application: createVerb(
     "application",
-    "Scaffold a full React application with SSR and routing.",
+    "Scaffold a full React application with routing, and either server-side rendering or a client-only SPA.",
     applicationParams,
     [
       { cmd: `${BIN_NAME} create application react my-app` },
       { cmd: `${BIN_NAME} create application react my-app --relay` },
+      { cmd: `${BIN_NAME} create application react my-app --rendering spa` },
     ],
   ),
 };

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

@@ -655,7 +655,10 @@ describe("the mounted create grammar (subprocess)", () => {
       "--type": "library",
       "--description": "A replied library.",
     },
-    "application/react": { "--app-path": "replied-app" },
+    "application/react": {
+      "--app-path": "replied-app",
+      "--rendering": "spa",
+    },
   };
   for (const [commandPath, surface] of Object.entries(CREATE_SURFACE)) {
     it(`${commandPath}: the refusal's own instruction WORKS — its Missing tokens supplied back (+ --dry-run) preview, exit 0`, () => {

package/src/capabilities/create/createSurface.generated.ts

@@ -17,7 +17,7 @@ export const CREATE_SURFACE: Readonly<Record<string, SurfaceCommand>> = {
       "application",
       "react"
     ],
-    "description": "Scaffold a complete React application with SSR and routing",
+    "description": "Scaffold a complete React application with routing, and either server-side rendering or a client-only SPA",
     "prompts": [
       {
         "name": "appPath",
@@ -41,6 +41,23 @@ export const CREATE_SURFACE: Readonly<Record<string, SurfaceCommand>> = {
         "default": false,
         "group": "Application"
       },
+      {
+        "name": "rendering",
+        "type": "select",
+        "message": "Rendering — ssr keeps the server layer (SSR servers and sitemap), spa is client-only",
+        "default": "ssr",
+        "choices": [
+          {
+            "label": "ssr - server-side rendering (Express + Bun servers, sitemap)",
+            "value": "ssr"
+          },
+          {
+            "label": "spa - client-only single-page app (no server layer)",
+            "value": "spa"
+          }
+        ],
+        "group": "Application"
+      },
       {
         "name": "relay",
         "type": "confirm",
@@ -278,6 +295,11 @@ export const CREATE_CLI_SYNTAX: Readonly<
       "takesValue": false,
       "kebabName": "intl"
     },
+    "rendering": {
+      "flag": "--rendering",
+      "takesValue": true,
+      "kebabName": "rendering"
+    },
     "relay": {
       "flag": "--relay",
       "takesValue": false,

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

@@ -258,9 +258,16 @@ describe("cross-CLI conformance matrix (PROTECTED)", () => {
   // here, which is the point).
   it("every declared generator binding path is driven by a conformance fixture", () => {
     expect(
-      [...CONFORMANCE_FIXTURES]
-        .map((fixture) => commandPathOf(fixture.generator))
-        .sort(),
+      // Deduplicated: the assertion is that every declared path is COVERED, and
+      // one path may carry several fixtures — application/react is driven by
+      // both the SSR arm and the SPA arm.
+      [
+        ...new Set(
+          CONFORMANCE_FIXTURES.map((fixture) =>
+            commandPathOf(fixture.generator),
+          ),
+        ),
+      ].sort(),
     ).toEqual(
       Object.values(CREATE_GENERATORS)
         .flatMap((binding) => binding.paths as readonly string[])

package/src/capabilities/distribution.parity.test.ts

@@ -13,7 +13,7 @@ import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { compilePack } from "../kernel/packs/compile.js";
 import type { LookupOutput } from "../kernel/packs/resolveEntity.js";
 import { parsePackDefinition } from "../kernel/packs/schema.js";
-import type { PackRow } from "../kernel/packs/types.js";
+import type { PackPage } from "../kernel/packs/types.js";
 import { distributionSource } from "../kernel/packs/types.js";
 import { verbKey } from "../kernel/packs/uniqueness.js";
 import { DEFAULT_PREFIX_MAP } from "../kernel/render/prefixes.js";
@@ -122,7 +122,7 @@ describe("standard story definition (PROTECTED)", () => {
 
 describe("standard list parity", () => {
   it("lists every standard with the uniform row shape", async () => {
-    const rows = (await verb("list").run({}, rt)) as PackRow[];
+    const rows = ((await verb("list").run({}, rt)) as PackPage).rows;
     expect(rows.map((r) => r.name)).toEqual([
       "code/function/purity",
       "react/component/props",
@@ -135,25 +135,26 @@ describe("standard list parity", () => {
   });
 
   it("filters by category and searches, conjunctively", async () => {
-    const react = (await verb("list").run(
-      { category: "react" },
-      rt,
-    )) as PackRow[];
+    const react = (
+      (await verb("list").run({ category: "react" }, rt)) as PackPage
+    ).rows;
     expect(react.map((r) => r.name).sort()).toEqual([
       "react/component/props",
       "react/component/structure",
     ]);
-    const searched = (await verb("list").run(
-      { category: "react", search: "structure" },
-      rt,
-    )) as PackRow[];
+    const searched = (
+      (await verb("list").run(
+        { category: "react", search: "structure" },
+        rt,
+      )) as PackPage
+    ).rows;
     expect(searched.map((r) => r.name)).toEqual(["react/component/structure"]);
   });
 });
 
 describe("standard categories parity", () => {
   it("lists categories with their standard counts", async () => {
-    const rows = (await verb("categories").run({}, rt)) as PackRow[];
+    const rows = ((await verb("categories").run({}, rt)) as PackPage).rows;
     const counts = new Map(rows.map((r) => [r.name, Number(r.count)]));
     expect(counts.get("react")).toBe(2);
     expect(counts.get("code")).toBe(1);

package/src/capabilities/distribution.test.ts

@@ -14,6 +14,7 @@
 import { describe, expect, it } from "vitest";
 import { compilePack } from "../kernel/packs/compile.js";
 import { parsePackDefinition } from "../kernel/packs/schema.js";
+import { storyIssues } from "../kernel/packs/storyRules.js";
 import { DEFAULT_PREFIX_MAP } from "../kernel/render/prefixes.js";
 import type { VerbSpec } from "../kernel/spec/types.js";
 import { VOCABULARY } from "../kernel/vocabulary.js";
@@ -45,16 +46,85 @@ describe("the distribution's declared stories (PROTECTED)", () => {
       "standard",
       "tier",
       "token",
+      "variable",
     ]);
   });
 
-  it.each([
-    ...declaredStories.keys(),
-  ])("the %s story validates against the pack grammar, unchanged", (noun) => {
-    const story = declaredStories.get(noun);
-    expect(
-      parsePackDefinition(JSON.parse(JSON.stringify(story)), "pragma.conf.ts"),
-    ).toEqual(story);
+  it.each([...declaredStories.keys()])(
+    "the %s story validates against the pack grammar, unchanged",
+    (noun) => {
+      const story = declaredStories.get(noun);
+      expect(
+        parsePackDefinition(
+          JSON.parse(JSON.stringify(story)),
+          "pragma.conf.ts",
+        ),
+      ).toEqual(story);
+    },
+  );
+
+  it('every declared filter names "values" or a "vocabulary"', () => {
+    // The rule the round-trip above already enforces, said OUT LOUD. It was
+    // only implied there — a story satisfies the whole grammar or it does not,
+    // and a reader looking for this particular property found no assertion
+    // claiming it. It is the property that separates a refusal (INVALID_INPUT
+    // naming the admissible values) from a calm empty page, so it is worth a
+    // test that fails with the rule's own name on it.
+    const filters = [...declaredStories].flatMap(([noun, story]) => [
+      ...(story.list?.filters ?? []).map(
+        (filter) => [`${noun} list --${filter.param}`, filter] as const,
+      ),
+      ...(story.verbs ?? []).flatMap((verb) =>
+        (verb.filters ?? []).map(
+          (filter) =>
+            [`${noun} ${verb.verb} --${filter.param}`, filter] as const,
+        ),
+      ),
+    ]);
+    // A guard, not a no-op: an empty derivation would make this vacuous.
+    expect(filters.map(([label]) => label).sort()).toEqual([
+      "concept list --type",
+      "implementation list --library",
+      "implementation list --platform",
+      "standard list --category",
+      "token consumers --key",
+      "token consumers --state",
+      "token consumers --symbol",
+      "token consumers --variable",
+      "token list --channelOf",
+      "token list --type",
+      "token values --position",
+      "token values --symbol",
+      "variable chain --symbol",
+      "variable chain --variable",
+      "variable list --coordinate",
+      "variable list --platform",
+      "variable list --symbol",
+      "variable list --tier",
+      "variable list --visibility",
+    ]);
+    for (const [label, filter] of filters) {
+      expect(
+        filter.values !== undefined || filter.vocabulary !== undefined,
+        `${label} declares neither "values" nor a "vocabulary"`,
+      ).toBe(true);
+      // And never both — a declared set IS the vocabulary.
+      expect(
+        filter.values !== undefined && filter.vocabulary !== undefined,
+        `${label} declares both`,
+      ).toBe(false);
+    }
+  });
+
+  it("every declared story satisfies the compilability rules", () => {
+    // These rules are checked in `compileStoryModule`, which is what makes them
+    // reach the distribution's own stories rather than only the ones zod sees.
+    // Asserted here as a property of the CONFIG so a violation is a red test
+    // and not an import-time throw in every command.
+    for (const [noun, story] of declaredStories) {
+      const issues = storyIssues(story);
+      expect(issues, `${noun} has compilability issues`).toEqual([]);
+    }
   });
 
   it("every declared noun reaches the registry as an overridable module", () => {

package/src/capabilities/doctor/checks/checkNodeVersion.test.ts

@@ -0,0 +1,49 @@
+/**
+ * Covers the two things `checkNodeVersion` owns beyond the range comparison:
+ * the shape of the CheckResult, and that the failure path quotes the declared
+ * range rather than a number of its own. The range logic itself is pinned in
+ * `isSupportedNodeVersion.test.ts`.
+ */
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { SUPPORTED_NODE_RANGE } from "../../../constants.js";
+import { checkNodeVersion } from "./checkNodeVersion.js";
+
+/** Swap `process.versions.node`, which is read-only in the normal way. */
+function withNodeVersion(version: string) {
+  vi.spyOn(process, "versions", "get").mockReturnValue({
+    ...process.versions,
+    node: version,
+  });
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("checkNodeVersion — reports against the declared range", () => {
+  it("passes on a supported version and reports it", async () => {
+    withNodeVersion("24.18.1");
+    const result = await checkNodeVersion();
+    expect(result).toEqual({
+      name: "Node version",
+      status: "pass",
+      detail: "v24.18.1",
+    });
+  });
+
+  it("fails on an unsupported version and quotes the declared range", async () => {
+    withNodeVersion("20.19.0");
+    const result = await checkNodeVersion();
+    expect(result.status).toBe("fail");
+    expect(result.detail).toContain("v20.19.0");
+    // The range must come from the manifest, never from a literal in the check.
+    expect(result.detail).toContain(SUPPORTED_NODE_RANGE);
+    expect(result.remedy).toContain(SUPPORTED_NODE_RANGE);
+  });
+
+  it("fails inside the 23.0-23.5 window the range excludes", async () => {
+    withNodeVersion("23.2.0");
+    expect((await checkNodeVersion()).status).toBe("fail");
+  });
+});

package/src/capabilities/doctor/checks/checkNodeVersion.ts

@@ -1,25 +1,29 @@
+import { SUPPORTED_NODE_RANGE } from "../../../constants.js";
 import type { CheckResult } from "../types.js";
-
-const MIN_NODE_MAJOR = 20;
+import { isSupportedNodeVersion } from "./isSupportedNodeVersion.js";
 
 /**
- * Check that the Node.js major version is at least {@link MIN_NODE_MAJOR}.
+ * Check that the running Node.js version satisfies this package's declared
+ * `engines.node` range.
+ *
+ * The floor is a property of the manifest, not of this file: a check that
+ * hardcodes its own number can disagree with the range the package publishes,
+ * and a consumer then passes a check the install contract would have failed.
  *
  * @returns A CheckResult with the current version and pass/fail status.
  * @note Impure — reads `process.versions`.
  */
 export async function checkNodeVersion(): Promise<CheckResult> {
   const version = process.versions.node;
-  const major = Number.parseInt(version.split(".")[0] ?? "0", 10);
 
-  if (major >= MIN_NODE_MAJOR) {
+  if (isSupportedNodeVersion(version)) {
     return { name: "Node version", status: "pass", detail: `v${version}` };
   }
 
   return {
     name: "Node version",
     status: "fail",
-    detail: `v${version} (requires >= ${MIN_NODE_MAJOR})`,
-    remedy: `Install Node.js >= ${MIN_NODE_MAJOR}`,
+    detail: `v${version} (requires ${SUPPORTED_NODE_RANGE})`,
+    remedy: `Install Node.js ${SUPPORTED_NODE_RANGE}`,
   };
 }