@canonical/pragma-cli 0.32.0 → 0.34.0

package/src/kernel/config/defaults.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+import defaults from "./defaults.js";
+
+describe("defaults — the validated distribution config (pragma.conf.ts)", () => {
+  it("ships the distribution identity", () => {
+    expect(defaults.name).toBe("pragma");
+    expect(defaults.help).toBe("Explore the design system");
+    expect(defaults.issuesUrl).toBe(
+      "https://github.com/canonical/pragma/issues",
+    );
+  });
+
+  it("declares the toolchain colophon as content (markdown body + summary)", () => {
+    // The narrative is a DECLARATION the `colophon` verb renders, not code:
+    // `collectColophon` reads exactly this object. Pin the shape and the two
+    // stable fragments — the story's own subject and the maker line the old
+    // one-line `colophon` string carried (folded in when the field went live).
+    expect(defaults.colophon?.markdown).toContain("domain-based toolchain");
+    expect(defaults.colophon?.markdown).toContain(
+      "Made by the Canonical Webteam — https://canonical.com.",
+    );
+    expect(defaults.colophon?.summary).toContain("domain-based toolchain");
+    // Bodies, not documents: the renderer supplies the H1 from the name.
+    expect(defaults.colophon?.markdown.startsWith("#")).toBe(false);
+    expect(defaults.colophon?.summary?.startsWith("#")).toBe(false);
+  });
+
+  it("ships the three canonical default packs (git+https sources)", () => {
+    expect(
+      defaults.packs?.map((pack) =>
+        typeof pack === "string"
+          ? pack
+          : { name: pack.name, source: pack.source },
+      ),
+    ).toEqual([
+      {
+        name: "@canonical/design-system",
+        source: "git+https://github.com/canonical/design-system.git#main",
+      },
+      {
+        name: "@canonical/anatomy-dsl",
+        source: "git+https://github.com/canonical/anatomy-dsl.git#main",
+      },
+      {
+        name: "@canonical/code-standards",
+        source: "git+https://github.com/canonical/web-code-standards.git#main",
+      },
+    ]);
+  });
+
+  it("carries the declared read stories through validation, on their packs", () => {
+    // The zod layer must not strip `stories` (unknown keys ARE stripped for
+    // forward compatibility). Content is owned by `capabilities/distribution.test.ts`;
+    // this pins only that the field survives `parseRawConfig` on the right pack.
+    const storyCounts = defaults.packs?.map((pack) =>
+      typeof pack === "string" ? 0 : (pack.stories?.length ?? 0),
+    );
+    expect(storyCounts).toEqual([4, 0, 1]);
+  });
+
+  it("declares no removed field — the validator would refuse to load one", () => {
+    // `generators` was deleted (L-OPEN-1 ruling): validated, layered, and read
+    // by nothing. The distribution config goes through the same strict
+    // `parseRawConfig` as every layer, so a `generators:` reintroduced here
+    // would fail the eager validation at import — this pins the honest state.
+    expect(defaults).not.toHaveProperty("generators");
+  });
+
+  it("declares the domain namespaces the store is built with and the CLI resolves", () => {
+    // Two consumers, one declaration. (1) The config layer wins every prefix
+    // harvest, so this is what keeps `ds:` entity names stable when the design
+    // system declares `ds:` with two IRIs. (2) It is the domain half of
+    // `DEFAULT_PREFIX_MAP`, so it also decides which prefixed names a lookup
+    // can expand — `cs:` is here for that reader.
+    expect(defaults.prefixes).toEqual({
+      ds: "https://ds.canonical.com/",
+      cs: "http://pragma.canonical.com/codestandards#",
+    });
+  });
+
+  it("ships the normal channel and standard detail level", () => {
+    expect(defaults.channel).toBe("normal");
+    expect(defaults.detail).toBe("standard");
+  });
+});

package/src/kernel/config/defaults.ts

@@ -1,28 +1,17 @@
 /**
- * Built-in configuration defaults (D6 — TS, not JSON).
+ * Built-in configuration defaults — the validated distribution config.
  *
- * The lowest config layer. Authored as a typed module so an invalid edit fails
- * at type-check rather than at runtime, and so the default `packages` sources
- * live in one place. Sources verified against the v1 `config/defaults.json`.
+ * The lowest config layer is the distribution's own `pragma.conf.ts` (package
+ * root), STATICALLY imported so `bun build --compile` inlines it (no fs read —
+ * `evaluateProjectConfig` stats/imports from disk, impossible inside the
+ * compiled binary) and validated through the same `parseRawConfig` as every
+ * other layer. Statically imported by `readConfig` (itself dynamic-imported,
+ * off the `--help`/`__complete` fast path) and by its own test, so the eager
+ * validation and the zod import here add nothing to the storeless surfaces —
+ * the lazy.test.ts module-graph probe covers that boundary.
  */
 
-import type { PragmaConfig } from "./types.js";
+import rawConfig from "../../../pragma.conf.js";
+import { parseRawConfig } from "./schema.js";
 
-export default {
-  channel: "normal",
-  detail: "standard",
-  packages: [
-    {
-      name: "@canonical/design-system",
-      source: "git+https://github.com/canonical/design-system.git#main",
-    },
-    {
-      name: "@canonical/anatomy-dsl",
-      source: "git+https://github.com/canonical/anatomy-dsl.git#main",
-    },
-    {
-      name: "@canonical/code-standards",
-      source: "git+https://github.com/canonical/web-code-standards.git#main",
-    },
-  ],
-} satisfies PragmaConfig;
+export default parseRawConfig(rawConfig, "pragma.conf.ts");

package/src/kernel/config/evaluateProjectConfig.ts

@@ -33,7 +33,7 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { VERSION } from "../../constants.js";
+import { PROJECT_CONFIG_FILENAME, VERSION } from "../../constants.js";
 import { PragmaError } from "../error/PragmaError.js";
 import { configCacheDir } from "./paths.js";
 import { parseRawConfig } from "./schema.js";
@@ -107,8 +107,7 @@ export async function evaluateProjectConfig(path: string): Promise<RawConfig> {
       `Could not load project config ${path}: ${reason}`,
       {
         recovery: {
-          message:
-            "Fix the error in your pragma.config.ts (it must evaluate to a default export), then try again.",
+          message: `Fix the error in your ${PROJECT_CONFIG_FILENAME} (it must evaluate to a default export), then try again.`,
         },
       },
     );

package/src/kernel/config/findProjectConfig.ts

@@ -1,8 +1,8 @@
 /**
  * Locate the nearest project config by walking up from `cwd`.
  *
- * Looks for `pragma.config.ts` (or, as a compiled-binary fallback,
- * `pragma.config.js`) at or above `cwd`. The walk is bounded: it stops after
+ * Looks for `<bin>.config.ts` (or, as a compiled-binary fallback,
+ * `<bin>.config.js`) at or above `cwd`. The walk is bounded: it stops after
  * the first directory containing `.git` (the repo root), after the home
  * directory, and at the filesystem root — a config outside the repo or home
  * never leaks in. Ported from the v1 `findProjectConfigPath`.
@@ -11,9 +11,10 @@
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { BIN_NAME, PROJECT_CONFIG_FILENAME } from "../../constants.js";
 
 /** Candidate project-config filenames, in preference order. */
-const CANDIDATES = ["pragma.config.ts", "pragma.config.js"] as const;
+const CANDIDATES = [PROJECT_CONFIG_FILENAME, `${BIN_NAME}.config.js`] as const;
 
 /**
  * Find the nearest project config file at or above `cwd`.

package/src/kernel/config/firstRun.ts

@@ -21,6 +21,11 @@ import {
   writeFile,
 } from "@canonical/task";
 import { runTask } from "@canonical/task/node";
+import {
+  BIN_NAME,
+  ISSUES_URL,
+  PROJECT_CONFIG_FILENAME,
+} from "../../constants.js";
 import { globalConfigPath } from "./paths.js";
 
 /** Seed content: an empty object, so nothing is pinned the user did not choose. */
@@ -29,10 +34,10 @@ const SEED_CONFIG = "{}\n";
 /** Build the welcome note; the resolved path is shown so it is copyable. */
 function welcomeLines(path: string): string[] {
   return [
-    "Hello! Thanks for taking the time to try the pre-release pragma CLI.",
-    "Please file issues and feedback at https://github.com/canonical/pragma/issues.",
-    `Pragma stores its configuration in ${path} (just created with defaults).`,
-    "A `pragma.config.ts` in this directory or above it overrides it per project.",
+    `Hello! Thanks for taking the time to try the pre-release ${BIN_NAME} CLI.`,
+    `Please file issues and feedback at ${ISSUES_URL}.`,
+    `${BIN_NAME} stores its configuration in ${path} (just created with defaults).`,
+    `A \`${PROJECT_CONFIG_FILENAME}\` in this directory or above it overrides it per project.`,
     "",
   ];
 }
@@ -86,6 +91,8 @@ export async function ensureFirstRun(
     });
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
-    write(`Warning: could not create the global pragma config — ${reason}`);
+    write(
+      `Warning: could not create the global ${BIN_NAME} config — ${reason}`,
+    );
   }
 }

package/src/kernel/config/globalConfig.ts

@@ -1,8 +1,8 @@
 /**
  * Read the global machine config: `$XDG_CONFIG_HOME/pragma/config.json`.
  *
- * The global layer holds cross-project machine state (channel, detail, tier,
- * prompts). A missing or empty file contributes no values — the layer simply
+ * The global layer holds cross-project machine state (channel, detail, tier).
+ * A missing or empty file contributes no values — the layer simply
  * does not participate in the merge. A *malformed* file (a torn write) must
  * never brick every command (the old loud `CONFIG_ERROR` throw) nor be silently
  * discarded (writeConfigField's old reset-to-`{}`): it is backed up to a

package/src/kernel/config/index.ts

@@ -3,17 +3,16 @@
  *
  * `schema.ts` (zod) is intentionally not re-exported here: it is imported
  * directly and lazily by the readers, keeping this barrel — and any storeless
- * consumer — off the zod fast path.
+ * consumer — off the zod fast path. `defaults` is likewise not re-exported:
+ * it statically imports the distribution config and the validating schema.
  */
 
-export { default as defaults } from "./defaults.js";
 export { evaluateProjectConfig } from "./evaluateProjectConfig.js";
 export { findProjectConfig } from "./findProjectConfig.js";
 export { ensureFirstRun, firstRunTask } from "./firstRun.js";
 export type { GlobalConfigRead } from "./globalConfig.js";
 export { readGlobalConfig } from "./globalConfig.js";
 export {
-  cacheDir,
   configCacheDir,
   configDir,
   globalConfigPath,
@@ -26,8 +25,8 @@ export type {
   ConfigLayers,
   ConfigOrigin,
   ConfigOrigins,
-  PackageDeclaration,
-  PackageEntry,
+  PackDeclaration,
+  PackSource,
   PragmaConfig,
   RawConfig,
 } from "./types.js";

package/src/kernel/config/paths.ts

@@ -1,39 +1,39 @@
 /**
- * XDG base-directory resolution for config, cache, and state.
+ * XDG base-directory resolution for config and state.
  *
- * Config (the global JSON) lives under `$XDG_CONFIG_HOME/pragma`; the evaluated
- * project-config cache lives under `$XDG_STATE_HOME/pragma/config-cache`. Tests
- * point these env vars at per-run temp directories (see setupXdgIsolation) so
- * they never touch the developer's real state.
+ * Every directory is namespaced by the distribution's own {@link BIN_NAME}, so a
+ * fork stores its state beside this one instead of colliding in it — the
+ * greeting that quotes the resolved path then names one program, not two. Config
+ * (the global JSON) lives under `$XDG_CONFIG_HOME/<bin>`; the evaluated
+ * project-config cache lives under `$XDG_STATE_HOME/<bin>/config-cache`. The
+ * store layer's cache root (`$XDG_CACHE_HOME/<bin>`) is resolved by
+ * `kernel/runtime/paths.ts` instead — it must stay leaf-clean for the storeless
+ * fast path. Tests point these env vars at per-run temp directories (see
+ * setupXdgIsolation) so they never touch the developer's real state.
  */
 
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { BIN_NAME } from "../../constants.js";
 
-/** `$XDG_CONFIG_HOME/pragma` (default `~/.config/pragma`). */
+/** `$XDG_CONFIG_HOME/<bin>` (default `~/.config/<bin>`). */
 export function configDir(): string {
   const base = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
-  return join(base, "pragma");
+  return join(base, BIN_NAME);
 }
 
-/** `$XDG_CACHE_HOME/pragma` (default `~/.cache/pragma`). */
-export function cacheDir(): string {
-  const base = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
-  return join(base, "pragma");
-}
-
-/** `$XDG_STATE_HOME/pragma` (default `~/.local/state/pragma`). */
+/** `$XDG_STATE_HOME/<bin>` (default `~/.local/state/<bin>`). */
 export function stateDir(): string {
   const base = process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state");
-  return join(base, "pragma");
+  return join(base, BIN_NAME);
 }
 
-/** The global config file: `$XDG_CONFIG_HOME/pragma/config.json`. */
+/** The global config file: `$XDG_CONFIG_HOME/<bin>/config.json`. */
 export function globalConfigPath(): string {
   return join(configDir(), "config.json");
 }
 
-/** The evaluated-project-config cache dir: `$XDG_STATE_HOME/pragma/config-cache`. */
+/** The evaluated-project-config cache dir: `$XDG_STATE_HOME/<bin>/config-cache`. */
 export function configCacheDir(): string {
   return join(stateDir(), "config-cache");
 }

package/src/kernel/config/readConfig.test.ts

@@ -10,6 +10,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { runTask } from "@canonical/task/node";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { BIN_NAME, PROGRAM_DESCRIPTION } from "../../constants.js";
 import { evaluateProjectConfig } from "./evaluateProjectConfig.js";
 import { findProjectConfig } from "./findProjectConfig.js";
 import { readGlobalConfig } from "./globalConfig.js";
@@ -58,13 +59,13 @@ describe("readConfig — layering + provenance", () => {
     expect(config.tier).toBe("core");
     expect(config.channel).toBe("experimental");
     expect(config.detail).toBe("detailed");
-    expect(config.packages).toHaveLength(3); // from defaults
+    expect(config.packs).toHaveLength(3); // from defaults
 
     expect(origins).toMatchObject({
       tier: "project",
       channel: "global",
       detail: "project", // project wins over global
-      packages: "default",
+      packs: "default",
     });
     expect(project.exists).toBe(true);
     expect(global.exists).toBe(true);
@@ -81,14 +82,43 @@ describe("readConfig — layering + provenance", () => {
     expect(project.exists).toBe(false);
   });
 
-  it("replaces packages wholesale from the project layer", async () => {
+  it("replaces packs wholesale from the project layer", async () => {
     freshXdg();
-    const dir = projectWith('export default { packages: ["@acme/only"] };');
+    const dir = projectWith('export default { packs: ["@acme/only"] };');
+
+    const { config, origins } = await readConfig(dir);
+
+    expect(config.packs).toEqual(["@acme/only"]);
+    expect(origins.packs).toBe("project");
+  });
+
+  it("accepts a layer's identity fields and gives them NO effect", async () => {
+    // Identity is read from `pragma.conf.ts` by `src/constants.ts` at module
+    // load, so a layer declaring it can only ever be silent. The validator
+    // still accepts the keys (the distribution config shares the schema), and
+    // the merged config now carries neither the value nor a provenance for it
+    // — which is what `config show` used to report and did not honour.
+    freshXdg();
+    writeGlobal('{"help":"Global help"}');
+    const dir = projectWith(
+      'export default { name: "acme", colophon: { markdown: "By Acme." }, issuesUrl: "https://acme.test/issues", tier: "core" };',
+    );
 
     const { config, origins } = await readConfig(dir);
 
-    expect(config.packages).toEqual(["@acme/only"]);
-    expect(origins.packages).toBe("project");
+    expect(config).not.toHaveProperty("name");
+    expect(config).not.toHaveProperty("help");
+    expect(config).not.toHaveProperty("colophon");
+    expect(config).not.toHaveProperty("issuesUrl");
+    expect(origins).not.toHaveProperty("name");
+    // The positive control, from the SAME project file: a layerable field
+    // declared beside them IS merged and reported, so the assertions above
+    // cannot pass by the project layer having failed to load at all.
+    expect(config.tier).toBe("core");
+    expect(origins.tier).toBe("project");
+    // And the projected identity is unmoved by any of it.
+    expect(BIN_NAME).toBe("pragma");
+    expect(PROGRAM_DESCRIPTION).not.toBe("Global help");
   });
 
   it("merges the completion policy into the effective config", async () => {
@@ -106,6 +136,212 @@ describe("readConfig — layering + provenance", () => {
   });
 });
 
+describe("`detail` — a closed enum at load", () => {
+  it("a project config declaring an unknown level throws CONFIG_ERROR naming the file and the three levels", async () => {
+    freshXdg();
+    // Before the enum, `detail: "banana"` passed validation, was reported as
+    // `[project]` by `config show`, and silently rendered at `standard`.
+    const dir = projectWith('export default { detail: "banana" };');
+    const path = join(dir, "pragma.config.ts");
+
+    let caught: unknown;
+    try {
+      await evaluateProjectConfig(path);
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toMatchObject({ code: "CONFIG_ERROR" });
+    const message = (caught as { message: string }).message;
+    expect(message).toContain(path);
+    expect(message).toContain("detail");
+    for (const level of ["summary", "standard", "detailed"]) {
+      expect(message).toContain(level);
+    }
+  });
+
+  it("a global JSON declaring an unknown level throws the same loud error", () => {
+    freshXdg();
+    writeGlobal('{"detail": "digest"}');
+
+    let caught: unknown;
+    try {
+      readGlobalConfig();
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toMatchObject({ code: "CONFIG_ERROR" });
+    const message = (caught as { message: string }).message;
+    expect(message).toContain(globalConfigPath());
+    for (const level of ["summary", "standard", "detailed"]) {
+      expect(message).toContain(level);
+    }
+  });
+});
+
+describe("legacy config shapes — loud rename/removal errors", () => {
+  it("a project config declaring `packages` throws CONFIG_ERROR naming the rename", async () => {
+    freshXdg();
+    // Unknown keys are stripped by the schema, so the legacy key must be
+    // DETECTED — a silent ignore would boot the default packs while the user
+    // believes their own list is in force.
+    const dir = projectWith('export default { packages: ["@acme/only"] };');
+    const path = join(dir, "pragma.config.ts");
+
+    let caught: unknown;
+    try {
+      await evaluateProjectConfig(path);
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toMatchObject({ code: "CONFIG_ERROR" });
+    expect((caught as { message: string }).message).toContain(
+      `Invalid config in ${path}: the "packages" field was renamed to "packs". The entry shape is unchanged.`,
+    );
+    // The recovery carries the path; the message drops the instruction.
+    expect(
+      (caught as { recovery?: { message: string } }).recovery?.message,
+    ).toBe(`In ${path}, rename "packages:" to "packs".`);
+  });
+
+  it("a legacy global JSON declaring `packages` throws the same rename error", () => {
+    freshXdg();
+    writeGlobal('{"packages": []}');
+
+    let caught: unknown;
+    try {
+      readGlobalConfig();
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toMatchObject({ code: "CONFIG_ERROR" });
+    expect((caught as { message: string }).message).toContain(
+      'the "packages" field was renamed to "packs". The entry shape is unchanged.',
+    );
+  });
+
+  it("a removed `generators` field throws CONFIG_ERROR naming the field", async () => {
+    freshXdg();
+    // Ruled dead (L-OPEN-1): `resolveSources` never read it, `create` resolves
+    // its generators statically, and its only consumers were the merge and
+    // `config show`'s name display. A config still declaring it must fail
+    // naming the file — the schema's unknown-key stripping would otherwise
+    // swallow the deletion in silence.
+    const dir = projectWith(
+      'export default { generators: [{ name: "@acme/gen", source: "npm:@acme/gen@^1.0.0" }] };',
+    );
+    const path = join(dir, "pragma.config.ts");
+
+    let caught: unknown;
+    try {
+      await evaluateProjectConfig(path);
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toMatchObject({ code: "CONFIG_ERROR" });
+    const message = (caught as { message: string }).message;
+    expect(message).toContain(path);
+    expect(message).toContain('"generators"');
+    expect(message).toContain("removed");
+    expect(
+      (caught as { recovery?: { message: string } }).recovery?.message,
+    ).toBe(`In ${path}, delete the "generators" field.`);
+  });
+
+  it("a global JSON still declaring generators throws the same removal error", () => {
+    freshXdg();
+    writeGlobal('{"generators": []}');
+
+    let caught: unknown;
+    try {
+      readGlobalConfig();
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toMatchObject({ code: "CONFIG_ERROR" });
+    expect((caught as { message: string }).message).toContain('"generators"');
+  });
+
+  it("a removed `completion.caseSensitive` throws CONFIG_ERROR naming the field", async () => {
+    freshXdg();
+    // The field was validated and read by NOTHING. Removing it silently would
+    // leave a config author believing case-sensitivity is in force; the schema
+    // strips unknown keys, so the removal must be DETECTED before validation.
+    const dir = projectWith(
+      "export default { completion: { minChars: 3, caseSensitive: true } };",
+    );
+    const path = join(dir, "pragma.config.ts");
+
+    let caught: unknown;
+    try {
+      await evaluateProjectConfig(path);
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toMatchObject({ code: "CONFIG_ERROR" });
+    const message = (caught as { message: string }).message;
+    expect(message).toContain(path);
+    expect(message).toContain('"completion.caseSensitive"');
+    expect(message).toContain("removed");
+    expect(
+      (caught as { recovery?: { message: string } }).recovery?.message,
+    ).toBe(`In ${path}, delete "caseSensitive" from "completion".`);
+  });
+
+  it("a global JSON still setting completion.caseSensitive throws the same removal error", () => {
+    freshXdg();
+    writeGlobal('{"completion": {"caseSensitive": false}}');
+
+    let caught: unknown;
+    try {
+      readGlobalConfig();
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toMatchObject({ code: "CONFIG_ERROR" });
+    expect((caught as { message: string }).message).toContain(
+      '"completion.caseSensitive"',
+    );
+  });
+
+  it("a TOP-LEVEL `caseSensitive` key is an ordinary unknown key, not the removed field", async () => {
+    freshXdg();
+    // The detection reads exactly `completion.caseSensitive` — a stray
+    // top-level key keeps the forward-compatible unknown-key stripping.
+    const dir = projectWith(
+      "export default { caseSensitive: true, tier: 'core' };",
+    );
+    const path = join(dir, "pragma.config.ts");
+
+    await expect(evaluateProjectConfig(path)).resolves.toEqual({
+      tier: "core",
+    });
+  });
+
+  it("a `packages` key NESTED under another field does NOT trip the detection", async () => {
+    freshXdg();
+    // The rename detection is deliberately SHALLOW (top-level keys only): a
+    // `packages` key inside `prefixes` is a namespace prefix named `packages`,
+    // not the legacy field. Pin that against a future "helpful" deep check,
+    // which would false-positive here.
+    const dir = projectWith(
+      'export default { prefixes: { packages: "https://example.com/packages/" } };',
+    );
+    const path = join(dir, "pragma.config.ts");
+
+    await expect(evaluateProjectConfig(path)).resolves.toEqual({
+      prefixes: { packages: "https://example.com/packages/" },
+    });
+  });
+});
+
 describe("global config — corrupt-file recovery", () => {
   /** Backup siblings the recovery created next to the config file. */
   function corruptBackups(): string[] {

package/src/kernel/config/readConfig.ts

@@ -3,7 +3,7 @@
  *
  * Layer order, least to most specific: the built-in {@link defaults}, the
  * global XDG JSON, and the nearest evaluated `pragma.config.ts`. Merging is
- * per field — a more specific layer wins wholesale (so `packages` *replaces*,
+ * per field — a more specific layer wins wholesale (so `packs` *replaces*,
  * preserving the "project pins exactly" semantics) — and each field records
  * the layer that supplied it. Async because the project layer is evaluated
  * (and content-hash cached).
@@ -37,7 +37,7 @@ export async function readConfig(
   const project: RawConfig = projectPath
     ? await evaluateProjectConfig(projectPath)
     : {};
-  const defaultValues = defaults as RawConfig;
+  const defaultValues = defaults;
 
   const pick = <K extends keyof RawConfig>(
     field: K,
@@ -51,13 +51,15 @@ export async function readConfig(
     return { value: defaultValues[field], origin: "default" };
   };
 
+  // `name`/`help`/`colophon`/`issuesUrl` are DELIBERATELY not picked: identity
+  // is read from `pragma.conf.ts` statically (`src/constants.ts`), so merging a
+  // layer's value here would report a provenance nothing honours.
   const tier = pick("tier");
   const channel = pick("channel");
   const detail = pick("detail");
-  const packages = pick("packages");
+  const packs = pick("packs");
   const stories = pick("stories");
   const prefixes = pick("prefixes");
-  const prompts = pick("prompts");
   // `completion` is read at `setup completions` emit time (not on any fast
   // path) and carries no `config show` provenance, so it merges into the
   // effective config but is deliberately absent from ConfigOrigins.
@@ -67,10 +69,9 @@ export async function readConfig(
     channel: (channel.value ?? defaults.channel) as Channel,
     ...(tier.value !== undefined ? { tier: tier.value } : {}),
     ...(detail.value !== undefined ? { detail: detail.value } : {}),
-    ...(packages.value !== undefined ? { packages: packages.value } : {}),
+    ...(packs.value !== undefined ? { packs: packs.value } : {}),
     ...(stories.value !== undefined ? { stories: stories.value } : {}),
     ...(prefixes.value !== undefined ? { prefixes: prefixes.value } : {}),
-    ...(prompts.value !== undefined ? { prompts: prompts.value } : {}),
     ...(completion.value !== undefined ? { completion: completion.value } : {}),
   };
 
@@ -80,10 +81,9 @@ export async function readConfig(
       tier: tier.origin,
       channel: channel.origin,
       detail: detail.origin,
-      packages: packages.origin,
+      packs: packs.origin,
       stories: stories.origin,
       prefixes: prefixes.origin,
-      prompts: prompts.origin,
     },
     global: { path: global.path, exists: global.exists },
     project: {