@canonical/pragma-cli 0.29.0 → 0.30.0

package/src/testing/integration/cross-binary-byte-equality.test.ts

@@ -0,0 +1,129 @@
+/**
+ * The P.05 byte-equality gate: `pragma create X` and `summon X` must write
+ * identical bytes for the same generator invocation.
+ *
+ * Both binaries reduce to compositions over the shared execution core:
+ * pragma's batch path is `executeGenerator` (which stamps via
+ * `createStampOnEffectStart`), and summon's Ink executor runs
+ * `runGeneratorTask` with the same stamp transform and the defaults prompt
+ * handler. This test runs both compositions over the real generators into
+ * separate directories and asserts the trees are byte-identical — stamps
+ * included.
+ */
+
+import {
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, relative } from "node:path";
+import {
+  answerPromptWithDefaults,
+  createGeneratorStamp,
+  createStampOnEffectStart,
+  executeGenerator,
+  runGeneratorTask,
+} from "@canonical/cli-core";
+import type { GeneratorDefinition } from "@canonical/summon-core";
+import { generators as packageGenerators } from "@canonical/summon-package";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { COMPONENT_GENERATORS } from "../../domains/create/generators.js";
+
+interface Case {
+  readonly name: string;
+  readonly gen: GeneratorDefinition;
+  readonly answers: Record<string, unknown>;
+}
+
+const cases: Case[] = [
+  {
+    name: "component/react",
+    gen: COMPONENT_GENERATORS.react as GeneratorDefinition,
+    answers: { componentPath: "src/components/Button" },
+  },
+  {
+    name: "package/library",
+    gen: packageGenerators.package as GeneratorDefinition,
+    answers: { name: "@canonical/example", type: "library" },
+  },
+];
+
+/** Collect every file under root as relative path → raw content bytes. */
+const readTree = (root: string, dir = root): Map<string, Buffer> => {
+  const files = new Map<string, Buffer>();
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      for (const [k, v] of readTree(root, full)) files.set(k, v);
+    } else {
+      files.set(relative(root, full), readFileSync(full));
+    }
+  }
+  return files;
+};
+
+describe("cross-binary byte equality — pragma create ≡ summon", () => {
+  let dir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+    dir = mkdtempSync(join(tmpdir(), "byte-equality-"));
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  for (const testCase of cases) {
+    it(`${testCase.name} — both binaries write identical bytes, stamps included`, async () => {
+      const pragmaDir = join(dir, "pragma");
+      const summonDir = join(dir, "summon");
+      mkdirSync(pragmaDir);
+      mkdirSync(summonDir);
+
+      // pragma path: the create command's batch execution (stamps by default).
+      const result = await executeGenerator(
+        testCase.gen,
+        { ...testCase.answers, yes: true },
+        {
+          cwd: pragmaDir,
+          globalFlags: { llm: false, format: "text", verbose: false },
+        },
+      );
+      expect(result.tag).toBe("output");
+
+      // summon path: the Ink executor's exact composition over the shared
+      // core. Both binaries fold prompt defaults into the answers before
+      // generating; do the same here.
+      const answers = { ...testCase.answers };
+      for (const prompt of testCase.gen.prompts) {
+        if (!(prompt.name in answers) && prompt.default !== undefined) {
+          answers[prompt.name] = prompt.default;
+        }
+      }
+      await runGeneratorTask(testCase.gen.generate(answers), {
+        cwd: summonDir,
+        promptHandler: answerPromptWithDefaults,
+        onEffectStart: createStampOnEffectStart(
+          createGeneratorStamp(testCase.gen),
+        ),
+      });
+
+      const pragmaTree = readTree(pragmaDir);
+      const summonTree = readTree(summonDir);
+
+      expect([...pragmaTree.keys()].sort()).toEqual(
+        [...summonTree.keys()].sort(),
+      );
+      for (const [path, content] of pragmaTree) {
+        expect(summonTree.get(path)?.equals(content), path).toBe(true);
+      }
+      expect(pragmaTree.size).toBeGreaterThan(0);
+    });
+  }
+});

package/src/testing/integration/executor-execution.test.ts

@@ -0,0 +1,101 @@
+/**
+ * End-to-end characterization of the real-execution path the executor merge
+ * (4a) rewired: every generator the CLI actually dispatches, and a real setup
+ * task, run through the shared UI-free core ({@link runGeneratorTask}) and
+ * produce their files on disk.
+ *
+ * The golden snapshots (executor-golden.test.ts) lock the *preview* modes
+ * (dry-run/json/llm), which never execute. This locks the *real* run: the
+ * merged core executes the genuine task trees — not test doubles — with the
+ * correct working-directory semantics.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runGeneratorTask } from "@canonical/cli-core";
+import { generators as packageGenerators } from "@canonical/summon-package";
+import type { Task } from "@canonical/task";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { COMPONENT_GENERATORS } from "../../domains/create/generators.js";
+import setupMcp from "../../domains/setup/operations/setupMcp.js";
+
+interface Case {
+  readonly name: string;
+  readonly build: () => Task<unknown>;
+}
+
+const componentParams = { componentPath: "src/components/Button" };
+const packageParams = { name: "@canonical/example", type: "library" };
+
+const cases: Case[] = [
+  {
+    name: "component/react",
+    build: () => COMPONENT_GENERATORS.react.generate(componentParams),
+  },
+  {
+    name: "component/svelte",
+    build: () => COMPONENT_GENERATORS.svelte.generate(componentParams),
+  },
+  {
+    name: "component/lit",
+    build: () => COMPONENT_GENERATORS.lit.generate(componentParams),
+  },
+  {
+    name: "package/library",
+    build: () => packageGenerators.package.generate(packageParams),
+  },
+];
+
+const countFiles = (root: string): number => {
+  let total = 0;
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    total += entry.isDirectory() ? countFiles(join(root, entry.name)) : 1;
+  }
+  return total;
+};
+
+describe("shared executor — real execution over the dispatched tasks", () => {
+  let dir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+    dir = mkdtempSync(join(tmpdir(), "executor-execution-"));
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  for (const testCase of cases) {
+    it(`${testCase.name} — executes for real in the target cwd`, async () => {
+      const targetDir = join(dir, "target");
+      mkdirSync(targetDir);
+
+      await runGeneratorTask(testCase.build(), { cwd: targetDir });
+
+      expect(countFiles(targetDir)).toBeGreaterThan(0);
+      expect(process.cwd()).toBe(originalCwd);
+    });
+  }
+
+  // A real setup task on the rewired production surface. setupMcp in force
+  // mode writes root-relative config (no prompts, no home-dir writes), so it
+  // is safe to execute in a sandbox.
+  it("setup/mcp (force) — writes the harness config for real", async () => {
+    const root = join(dir, "project");
+    mkdirSync(root);
+
+    await runGeneratorTask(setupMcp(root, "cursor"));
+
+    expect(existsSync(join(root, ".cursor", "mcp.json"))).toBe(true);
+  });
+});

package/src/testing/integration/executor-golden.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Characterization (golden) snapshots of the two current executors —
+ * `executeGenerator` (cli-core, drives `pragma create`) and `runSetupTask`
+ * (drives `pragma setup`) — across the real generators and setup tasks.
+ *
+ * These lock the *observable output* of each executor for representative,
+ * fully-answered inputs in every non-interactive mode. Both executors now run
+ * real execution through the shared UI-free core (`runGeneratorTask`), and the
+ * merged path must keep reproducing these byte-for-byte; the execution
+ * characterization test alongside asserts the real-run path. Interactive
+ * behavior is characterized separately, since it runs through the injected
+ * `promptHandler` seam.
+ */
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { CommandContext, CommandResult } from "@canonical/cli-core";
+import { executeGenerator } from "@canonical/cli-core";
+import { generators as packageGenerators } from "@canonical/summon-package";
+import { describe, expect, it } from "vitest";
+import { COMPONENT_GENERATORS } from "../../domains/create/generators.js";
+import runSetupTask from "../../domains/setup/helpers/runSetupTask.js";
+import setupCompletions from "../../domains/setup/operations/setupCompletions.js";
+import setupLsp from "../../domains/setup/operations/setupLsp.js";
+
+const ROOT = "/tmp/characterization-project";
+
+const ctx = (format: "text" | "json", llm = false): CommandContext => ({
+  cwd: ROOT,
+  globalFlags: { llm, format, verbose: false },
+});
+
+/**
+ * Render an executor result to the plain string a user would see, with
+ * environment-specific bytes normalised so a committed baseline compares
+ * equal on every machine and in CI: ANSI color codes are stripped (chalk
+ * enables them under nx's FORCE_COLOR in CI but not in a plain local run),
+ * then the repo checkout root (package-generator plans embed absolute
+ * template source paths) and the home directory (shell-completion install
+ * targets embed `$HOME`) become stable tokens. The repo root is replaced
+ * first — on a dev machine it usually lives under `$HOME`.
+ */
+const plain = (result: CommandResult): string => {
+  let text =
+    result.tag === "output"
+      ? result.render.plain(result.value)
+      : `[${result.tag}]`;
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: matching the ANSI escape byte is the point
+  text = text.replace(/\u001b\[[0-9;]*m/g, "");
+  const repoRoot = resolve(
+    dirname(fileURLToPath(import.meta.url)),
+    "../../../../../..",
+  );
+  text = text.split(repoRoot).join("<repo>");
+  const home = process.env.HOME ?? "";
+  return home === "" ? text : text.split(home).join("<home>");
+};
+
+// =============================================================================
+// create — executeGenerator across the real component + package generators
+// =============================================================================
+
+const componentParams = { componentPath: "src/components/Button" };
+const packageParams = { name: "@canonical/example", type: "library" };
+
+describe("golden: executeGenerator — components", () => {
+  for (const framework of ["react", "svelte", "lit"] as const) {
+    const gen = COMPONENT_GENERATORS[framework];
+
+    it(`${framework} — dry-run plan`, async () => {
+      const result = await executeGenerator(
+        gen,
+        { ...componentParams, dryRun: true },
+        ctx("text"),
+      );
+      expect(plain(result)).toMatchSnapshot();
+    });
+
+    it(`${framework} — json plan`, async () => {
+      const result = await executeGenerator(
+        gen,
+        { ...componentParams },
+        ctx("json"),
+      );
+      expect(plain(result)).toMatchSnapshot();
+    });
+
+    it(`${framework} — llm plan`, async () => {
+      const result = await executeGenerator(
+        gen,
+        { ...componentParams },
+        ctx("text", true),
+      );
+      expect(plain(result)).toMatchSnapshot();
+    });
+  }
+});
+
+describe("golden: executeGenerator — package", () => {
+  const gen = packageGenerators.package;
+
+  it("library — dry-run plan", async () => {
+    const result = await executeGenerator(
+      gen,
+      { ...packageParams, dryRun: true },
+      ctx("text"),
+    );
+    expect(plain(result)).toMatchSnapshot();
+  });
+
+  it("library — json plan", async () => {
+    const result = await executeGenerator(
+      gen,
+      { ...packageParams },
+      ctx("json"),
+    );
+    expect(plain(result)).toMatchSnapshot();
+  });
+});
+
+// =============================================================================
+// setup — runSetupTask across representative deterministic setup tasks
+// =============================================================================
+
+describe("golden: runSetupTask — setups", () => {
+  it("lsp — dry-run", async () => {
+    const result = await runSetupTask(setupLsp(ROOT), { dryRun: true });
+    expect(plain(result)).toMatchSnapshot();
+  });
+
+  it("completions (bash) — dry-run", async () => {
+    const result = await runSetupTask(setupCompletions("bash"), {
+      dryRun: true,
+    });
+    expect(plain(result)).toMatchSnapshot();
+  });
+
+  it("lsp — dry-run json", async () => {
+    const result = await runSetupTask(setupLsp(ROOT), {
+      dryRun: true,
+      format: "json",
+    });
+    expect(plain(result)).toMatchSnapshot();
+  });
+});

package/src/testing/integration/mcp-surface.test.ts

@@ -55,7 +55,7 @@ describe("capabilities", () => {
     expect(toolNames).toContain("block_list");
     expect(toolNames).toContain("capabilities");
     expect(data.tools.every((t) => t.use_when.length > 0)).toBe(true);
-    expect(data.counts.total).toBe(29);
+    expect(data.counts.total).toBe(30);
     expect(data.conventions).toBeDefined();
     expect(data.version).toBeDefined();
   });

package/src/testing/integration/parity.test.ts

@@ -10,6 +10,7 @@
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 // ---- Shared utilities ----
+import { readConfigLayers } from "#config";
 import { VERSION } from "#constants";
 import { detectInstallSource } from "#package-manager";
 // ---- Formatters ----
@@ -440,14 +441,25 @@ describe("ontology parity", () => {
 // ---------------------------------------------------------------------------
 
 describe("config parity", () => {
-  it("config_show: data matches resolveConfigShow", async () => {
+  // Both surfaces resolve from the filesystem via the shared config show
+  // story, so parity is asserted against the real config path/existence
+  // (the MCP tool previously hardcoded "pragma.config.json" / true).
+  function resolveExpectedConfigShow() {
+    const layers = readConfigLayers(rt.cwd);
     const install = detectInstallSource();
-    const opResult = resolveConfigShow(rt.config, {
+    return resolveConfigShow(layers.config, {
       packageManager: install.packageManager,
       installSource: install.label,
-      configFilePath: "pragma.config.json",
-      configFileExists: true,
+      configFilePath: layers.project.path,
+      configFileExists: layers.project.exists,
+      globalConfigPath: layers.global.path,
+      globalConfigExists: layers.global.exists,
+      origins: layers.origins,
     });
+  }
+
+  it("config_show: data matches resolveConfigShow", async () => {
+    const opResult = resolveExpectedConfigShow();
 
     const mcpRes = await client.callTool({
       name: "config_show",
@@ -458,14 +470,7 @@ describe("config parity", () => {
   });
 
   it("config_show condensed: matches llm formatter", async () => {
-    const install = detectInstallSource();
-    const opResult = resolveConfigShow(rt.config, {
-      packageManager: install.packageManager,
-      installSource: install.label,
-      configFilePath: "pragma.config.json",
-      configFileExists: true,
-    });
-    const expectedText = configShowFmt.llm(opResult);
+    const expectedText = configShowFmt.llm(resolveExpectedConfigShow());
 
     const mcpRes = await client.callTool({
       name: "config_show",

package/src/testing/regression/0001-skill-discovery-granularity.test.ts

@@ -0,0 +1,71 @@
+/**
+ * Regression: skill discovery returned zero skills on real installs.
+ *
+ * `readPackageDir` emits one `SkillEntry.dir` per skill folder
+ * (`<package>/skills/<name>`), but `discoverSkills` treated each source
+ * directory as a *parent* of skill folders and scanned it for
+ * subdirectories containing SKILL.md. Production sources therefore never
+ * matched — `pragma skill list` errored with "No SKILL.md files found"
+ * and MCP `skill_list` returned an empty list, despite `doctor` counting
+ * skills in the very same packages. This test pins the granularity
+ * contract between the loader and discovery using both real
+ * implementations end-to-end.
+ */
+
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import readPackageDir from "../../domains/shared/loaders/readPackageDir.js";
+import type { SemanticPackage } from "../../domains/shared/semanticPackage.js";
+import { resolveSkillSources } from "../../domains/skill/helpers/index.js";
+import discoverSkills from "../../domains/skill/operations/discover.js";
+
+const TMP_ROOT = join(tmpdir(), `pragma-regression-0001-${Date.now()}`);
+const PKG_DIR = join(TMP_ROOT, "node_modules/@canonical/design-system");
+
+beforeAll(() => {
+  const skillDir = join(PKG_DIR, "skills/design-auditor");
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(
+    join(PKG_DIR, "package.json"),
+    JSON.stringify({ name: "@canonical/design-system", version: "0.1.2" }),
+  );
+  writeFileSync(
+    join(skillDir, "SKILL.md"),
+    `---
+name: design-auditor
+description: Audit design system coverage, consistency, and quality
+---
+
+# Design Auditor
+`,
+  );
+});
+
+afterAll(() => {
+  rmSync(TMP_ROOT, { recursive: true, force: true });
+});
+
+describe("skill discovery granularity (loader -> discovery contract)", () => {
+  it("discovers skills from sources produced by readPackageDir", async () => {
+    const contents = readPackageDir(PKG_DIR);
+    expect(contents.skills).toHaveLength(1);
+
+    const pkg: SemanticPackage = {
+      name: "@canonical/design-system",
+      version: contents.version,
+      source: "local",
+      graphs: contents.graphs,
+      skills: contents.skills,
+    };
+
+    const sources = resolveSkillSources([pkg]);
+    const skills = await discoverSkills(TMP_ROOT, sources);
+
+    expect(skills).toHaveLength(1);
+    expect(skills.at(0)?.name).toBe("design-auditor");
+    expect(skills.at(0)?.folderName).toBe("design-auditor");
+    expect(skills.at(0)?.sourcePackage).toBe("@canonical/design-system");
+  });
+});

package/src/testing/setupXdgIsolation.ts

@@ -0,0 +1,15 @@
+/**
+ * Global test setup: isolate the XDG config layer.
+ *
+ * The layered config reader consults `$XDG_CONFIG_HOME/pragma/config.json`
+ * on every read, and global-first writes create it. Point XDG at a
+ * per-run temp directory so tests neither observe nor pollute the
+ * developer's real global configuration. Individual tests that exercise
+ * XDG behavior override this value themselves.
+ */
+
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+process.env.XDG_CONFIG_HOME = mkdtempSync(join(tmpdir(), "pragma-test-xdg-"));

package/src/testing/standardParityFixtures.ts

@@ -0,0 +1,92 @@
+/**
+ * Standard-noun parity pilot fixtures.
+ *
+ * The built-in `standard` list/lookup read stories re-expressed as a v0
+ * story-pack definition, plus the honest record of what v0 cannot yet
+ * reproduce. Together they form the pilot's contract: the definition is
+ * asserted byte-compatible with the built-in output where the format
+ * reaches (`standardParity.test.ts`), and every remaining divergence
+ * must appear in {@link PARITY_GAPS} rather than being papered over.
+ */
+
+import type { StoryPackDefinition } from "../domains/shared/stories/pack/types.js";
+
+/**
+ * The built-in `standard` stories as a declarative pack definition.
+ *
+ * The list SELECT mirrors the query `listStandards` sends the store,
+ * with variables renamed to the built-in's output fields (`?standard` →
+ * `?uri`, `?categoryName` → `?category`) so pack rows carry the same
+ * keys as the built-in summary items. The lookup mirrors the built-in
+ * title and inline fields as far as v0 reaches — {@link PARITY_GAPS}
+ * lists what it cannot express.
+ */
+export const STANDARD_PACK_STORY: StoryPackDefinition = {
+  noun: "standard",
+  description: "List all code standards",
+  list: {
+    query: [
+      "SELECT ?uri ?name ?category ?description",
+      "WHERE {",
+      "  ?uri a cs:CodeStandard ;",
+      "       cs:name ?name ;",
+      "       cs:description ?description .",
+      "  OPTIONAL {",
+      "    ?uri cs:hasCategory ?cat .",
+      "    ?cat cs:slug ?category .",
+      "  }",
+      "}",
+      "ORDER BY ?name",
+    ].join("\n"),
+    columns: [
+      { field: "uri", label: "IRI" },
+      { field: "name", label: "Name" },
+      { field: "category", label: "Category" },
+      { field: "description", label: "Description" },
+    ],
+  },
+  lookup: {
+    type: "cs:CodeStandard",
+    by: "cs:name",
+    fields: [
+      {
+        name: "category",
+        property: "cs:hasCategory/cs:slug",
+        label: "Category",
+      },
+      {
+        name: "description",
+        property: "cs:description",
+        label: "Description",
+      },
+      { name: "extends", property: "cs:extends", label: "Extends" },
+    ],
+  },
+};
+
+/**
+ * Every place the v0 pack format cannot reproduce the built-in standard
+ * stories — the pilot's primary output. Each entry names the concrete
+ * missing pack-format capability; remove an entry only when the format
+ * gains the capability and the parity test asserts it.
+ */
+export const PARITY_GAPS: readonly string[] = [
+  "list params: packs declare no story parameters, so the built-in --category and --search filters (and their MCP tool arguments) cannot be expressed",
+  "list disclosure: no digest/detailed progressive-disclosure levels — the built-in --digest/--detailed flags enrich rows with extends/example/dos/donts and add disclosure meta to the MCP envelope; pack lists always render summary rows",
+  "list empty guard: the built-in raises EMPTY_RESULTS with an install-hint recovery when no standards load; the pack format has no emptyError hook, so a pack list renders nothing",
+  "list plain template: packs render the shared aligned-column table; the built-in renders stacked `name [category]` blocks with an indented description — v0 columns carry no layout or template control",
+  "list llm template: pack headings are `## <Noun> (<count>)` with `` `iri` — **name** value | value `` items; the built-in emits `## Standards` with `- **name** [category]` plus an indented description line — heading text and item template are not authorable",
+  "lookup uri field: the entity IRI cannot be declared as an inline field — v0 fields are property-derived, and a field named `uri` generates a duplicate ?uri SELECT variable the store rejects; the built-in renders `URI: cs:...` as its first lookup field",
+  "lookup property paths: `category` needs the two-hop path cs:hasCategory/cs:slug; the documented v0 `property` contract is a single predicate, and the path only passes validation because the prefixed-name pattern rejects `/` in the first character alone — multi-hop fields need first-class support",
+  "lookup data compaction: the built-in compacts `extends` in resolved data (JSON shows `cs:ComponentFolderStructure`); pack rows keep the raw IRI, so lookup JSON diverges for standards with cs:extends (plain/llm still match because renderers compact at display time)",
+  "lookup sections: dos/donts (cs:do/cs:dont → Example nodes with description/language/code) cannot be declared — v0 sections are single-valued field/code kinds, and the generated single-row lookup query cannot collect arrays of structured code blocks",
+  "lookup detailed toggle: no detailedParam — the built-in CLI adds Do/Don't sections under --detailed and MCP defaults to detailed with a summary projection (project); a pack lookup has one fixed output shape",
+  "lookup empty placeholders: the built-in renders `Category: —` for a standard without a category; pack renderers skip empty fields — no fallback/placeholder declaration (every current standard has a category, so outputs match today)",
+  "lookup glob expansion: the built-in expands glob queries (e.g. `react/*`) via expandLookupQueries before resolving; pack lookups pass names through verbatim",
+  "lookup by IRI: the built-in resolves an IRI or prefixed name (e.g. `cs:ComponentProps`) as the query; a pack lookup only matches the `by` property's string value, and only case-insensitively — exact-match semantics are not selectable",
+  "lookup recovery copy: built-in not-found errors carry cross-domain hints and the recovery message `List available standards.`; pack errors generate `List available standard entries.` — recovery copy is not authorable",
+  "lookup descriptions and examples: the pack lookup CLI description, tool description, names description, and examples are generated from the noun; the built-in curates all of them (e.g. `Look up detailed information for a standard by name or IRI`)",
+  "ink renderers: the built-in stories declare renderInk TUI views; the pack format has none",
+  "extra verbs: the standard noun also ships `categories` and `sample` commands; v0 packs compile only list and lookup",
+  "noun cutover: a pack story cannot register the noun `standard` while the built-in exists (reserved-noun guard in collectPackStories), so cutover must remove the built-in stories in the same release",
+];