@canonical/pragma-cli 0.29.0 → 0.31.0

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

@@ -9,6 +9,7 @@
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import type { PragmaRuntime } from "../../domains/shared/runtime.js";
+import { TOKEN_READ_SURFACE_ENABLED } from "../../domains/token/featureFlag.js";
 import createTestMcpClient from "../helpers/createTestMcpClient.js";
 import createTestRuntime from "../helpers/createTestRuntime.js";
 
@@ -55,7 +56,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(TOKEN_READ_SURFACE_ENABLED ? 34 : 31);
     expect(data.conventions).toBeDefined();
     expect(data.version).toBeDefined();
   });
@@ -190,7 +191,11 @@ describe("standard_lookup", () => {
       results: { name: string; extends?: string }[];
     };
     expect(data.results[0]?.name).toBe("react/component/props");
-    expect(data.results[0]?.extends).toBe("cs:react_folder");
+    // Pack entities keep cs:extends as the raw IRI in data (compaction is
+    // display-time only) — a pinned PARITY_GAP of the standard cutover.
+    expect(data.results[0]?.extends).toBe(
+      "http://pragma.canonical.com/codestandards#react_folder",
+    );
   });
 });
 
@@ -240,7 +245,7 @@ describe("modifier_lookup", () => {
 // Token
 // ---------------------------------------------------------------------------
 
-describe("token_list", () => {
+describe.skipIf(!TOKEN_READ_SURFACE_ENABLED)("token_list", () => {
   it("returns tokens", async () => {
     const res = await client.callTool({
       name: "token_list",
@@ -252,7 +257,7 @@ describe("token_list", () => {
   });
 });
 
-describe("token_lookup", () => {
+describe.skipIf(!TOKEN_READ_SURFACE_ENABLED)("token_lookup", () => {
   it("returns token with values", async () => {
     const res = await client.callTool({
       name: "token_lookup",
@@ -273,15 +278,16 @@ describe("token_lookup", () => {
 // ---------------------------------------------------------------------------
 
 describe("tier_list", () => {
-  it("returns tiers with hierarchy", async () => {
+  it("returns the tiers (bundled pack)", async () => {
     const res = await client.callTool({
       name: "tier_list",
       arguments: {},
     });
     const body = parseEnvelope(res);
     expect(body.ok).toBe(true);
-    const data = body.data as { path: string }[];
-    expect(data.some((t) => t.path === "global")).toBe(true);
+    // Bundled tier pack: uniform `{uri, name}` rows (no bespoke hierarchy).
+    const data = body.data as { name: string }[];
+    expect(data.some((t) => t.name === "global")).toBe(true);
   });
 });
 
@@ -480,15 +486,34 @@ describe("disclosure", () => {
     expect(meta.disclosure).toBe("digest");
   });
 
-  it("standard_list with detailed returns enriched data", async () => {
-    const res = await client.callTool({
-      name: "standard_list",
-      arguments: { detailed: true },
+  // `standard list --detailed` was retired with the standard cutover (a
+  // pinned PARITY_GAP: pack lists are single-level); per-entity disclosure
+  // now lives on the lookup's `detail` parameter and its legacy aliases.
+  it("standard_lookup honors the detail parameter", async () => {
+    const summary = await client.callTool({
+      name: "standard_lookup",
+      arguments: {
+        names: ["react/component/folder-structure"],
+        detail: "summary",
+      },
     });
-    const body = parseEnvelope(res);
-    expect(body.ok).toBe(true);
-    const meta = body.meta as { disclosure?: string };
-    expect(meta.disclosure).toBe("detailed");
+    const summaryData = parseEnvelope(summary).data as {
+      results: Record<string, unknown>[];
+    };
+    expect(summaryData.results[0]).not.toHaveProperty("dos");
+
+    const detailed = await client.callTool({
+      name: "standard_lookup",
+      arguments: {
+        names: ["react/component/folder-structure"],
+        detail: "detailed",
+      },
+    });
+    const detailedData = parseEnvelope(detailed).data as {
+      results: Record<string, unknown>[];
+    };
+    expect(detailedData.results[0]).toHaveProperty("dos");
+    expect(detailedData.results[0]).toHaveProperty("donts");
   });
 });
 

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 ----
@@ -41,20 +42,10 @@ import {
 } from "../../domains/ontology/operations/index.js";
 import { CHANNEL_RELEASES } from "../../domains/shared/filters/buildChannelFilter.js";
 import { resolveTierChain } from "../../domains/shared/filters/buildTierFilter.js";
+import { listTiers } from "../../domains/shared/listTiers.js";
 import type { PragmaRuntime } from "../../domains/shared/runtime.js";
-import {
-  type StandardListOutput,
-  categoriesFormatters as standardCatFmt,
-  listFormatters as standardListFmt,
-  lookupFormatters as standardLookupFmt,
-} from "../../domains/standard/formatters/index.js";
-import {
-  listCategories,
-  listStandards,
-  lookupStandard,
-} from "../../domains/standard/operations/index.js";
-import { listFormatters as tierListFmt } from "../../domains/tier/formatters/index.js";
-import { listTiers } from "../../domains/tier/operations/index.js";
+import { listDomainNames } from "../../domains/shared/suggestions/index.js";
+import { TOKEN_READ_SURFACE_ENABLED } from "../../domains/token/featureFlag.js";
 import {
   createLookupFormatters as createTokenLookupFmt,
   listFormatters as tokenListFmt,
@@ -175,58 +166,83 @@ describe("block parity", () => {
 // Standard parity
 // ---------------------------------------------------------------------------
 
-describe("standard parity", () => {
-  it("standard_list: count and names match", async () => {
-    const opResult = await listStandards(rt.store);
+// `standard *` is now served by the bundled `standard` story pack (the
+// hand-written domain was deleted). Pack rows/entities are uniform
+// `Record<string,string>` projections with expand arrays, and rendering is
+// the generic pack renderer — so these tests assert *semantic* parity
+// against the store (every standard reachable, by the same names, with the
+// same category/description/dos/donts values) rather than byte equality
+// with the removed bespoke formatters. See PARITY_GAPS in #testing for the
+// pinned, accepted divergences.
+describe("standard parity (bundled pack)", () => {
+  it("standard_list returns one {uri, name, category, description} row per standard", async () => {
+    const allNames = await listDomainNames(rt.store, "standard");
+    expect(allNames.length).toBeGreaterThan(0);
+
     const mcpRes = await client.callTool({
       name: "standard_list",
       arguments: {},
     });
-    assertParity(opResult, mcpRes);
+    const body = parseEnvelope(mcpRes);
+    expect(body.ok).toBe(true);
+    const rows = body.data as {
+      uri?: string;
+      name?: string;
+      category?: string;
+      description?: string;
+    }[];
+
+    // Same standards, same names — nothing dropped or invented.
+    const listed = new Set(rows.map((row) => row.name));
+    for (const name of allNames) {
+      expect(listed.has(name), `"${name}" missing from standard_list`).toBe(
+        true,
+      );
+    }
+    for (const row of rows) {
+      expect(row.uri).toBeTruthy();
+      expect(row.description).toBeTruthy();
+    }
   });
 
-  it("standard_list condensed: matches llm formatter", async () => {
-    const opResult = await listStandards(rt.store);
-    const output: StandardListOutput = {
-      items: opResult,
-      details: undefined,
-      disclosure: { level: "summary" },
-    };
-    const expectedText = standardListFmt.llm(output);
-
+  it("standard_list condensed lists every standard under the pack heading", async () => {
+    const allNames = await listDomainNames(rt.store, "standard");
     const mcpRes = await client.callTool({
       name: "standard_list",
       arguments: { condensed: true },
     });
     const body = parseCondensed(mcpRes);
-    expect(body.text).toBe(expectedText);
+    expect(body.text).toContain("## Standard");
+    for (const name of allNames) {
+      expect(body.text).toContain(name);
+    }
   });
 
-  it("standard_lookup: detailed fields match", async () => {
-    const opResult = await lookupStandard(
-      rt.store,
-      "react/component/folder-structure",
-    );
+  it("standard_lookup returns full detail by default (MCP full-data contract)", async () => {
     const mcpRes = await client.callTool({
       name: "standard_lookup",
       arguments: { names: ["react/component/folder-structure"] },
     });
     const body = parseEnvelope(mcpRes);
-    const data = body.data as { results: unknown[]; errors: unknown[] };
-    expect(data.results[0]).toEqual(opResult);
+    const data = body.data as {
+      results: {
+        name: string;
+        category: string;
+        dos: { code?: string; language?: string }[];
+        donts: { code?: string }[];
+      }[];
+      errors: unknown[];
+    };
     expect(data.errors).toEqual([]);
+    const entity = data.results[0];
+    expect(entity?.name).toBe("react/component/folder-structure");
+    expect(entity?.category).toBe("react");
+    expect(entity?.dos.length).toBeGreaterThan(0);
+    expect(entity?.dos.every((example) => example.code)).toBe(true);
+    expect(entity?.donts.length).toBeGreaterThan(0);
   });
 
-  it("standard_lookup condensed: matches llm formatter", async () => {
-    const opResult = await lookupStandard(
-      rt.store,
-      "react/component/folder-structure",
-    );
-    const expectedText = standardLookupFmt.llm({
-      standard: opResult,
-      detailed: true,
-    });
-
+  it("standard_lookup condensed renders the entity with its code examples", async () => {
     const mcpRes = await client.callTool({
       name: "standard_lookup",
       arguments: {
@@ -235,28 +251,37 @@ describe("standard parity", () => {
       },
     });
     const body = parseCondensed(mcpRes);
-    expect(body.text).toBe(expectedText);
+    expect(body.text).toContain("## react/component/folder-structure");
+    expect(body.text).toContain("Do");
+    expect(body.text).toContain("src/lib/Button/Button.tsx");
   });
 
-  it("standard_categories: data matches", async () => {
-    const opResult = await listCategories(rt.store);
-    const mcpRes = await client.callTool({
-      name: "standard_categories",
+  it("standard_categories counts agree with the standard list", async () => {
+    const listRes = await client.callTool({
+      name: "standard_list",
       arguments: {},
     });
-    assertParity(opResult, mcpRes);
-  });
-
-  it("standard_categories condensed: matches llm formatter", async () => {
-    const opResult = await listCategories(rt.store);
-    const expectedText = standardCatFmt.llm(opResult);
+    const rows = parseEnvelope(listRes).data as { category?: string }[];
+    const expected = new Map<string, number>();
+    for (const row of rows) {
+      if (row.category) {
+        expected.set(row.category, (expected.get(row.category) ?? 0) + 1);
+      }
+    }
 
     const mcpRes = await client.callTool({
       name: "standard_categories",
-      arguments: { condensed: true },
+      arguments: {},
     });
-    const body = parseCondensed(mcpRes);
-    expect(body.text).toBe(expectedText);
+    const body = parseEnvelope(mcpRes);
+    expect(body.ok).toBe(true);
+    const categories = body.data as { name: string; count: string }[];
+    expect(categories.length).toBeGreaterThan(0);
+    for (const [category, count] of expected) {
+      const row = categories.find((entry) => entry.name === category);
+      expect(row, `category "${category}" missing`).toBeDefined();
+      expect(Number(row?.count)).toBe(count);
+    }
   });
 });
 
@@ -264,26 +289,51 @@ describe("standard parity", () => {
 // Tier parity
 // ---------------------------------------------------------------------------
 
-describe("tier parity", () => {
-  it("tier_list: paths and depths match", async () => {
+// `tier list` / `tier_list` is now served by the bundled `tier` story pack
+// (the hand-written domain was deleted). Pack rows are `Record<string,string>`
+// projected from the SELECT, so the shape is intentionally uniform: `{uri,
+// name}` with no always-zero `depth` field, and the llm renderer is the
+// generic pack renderer. These tests assert *semantic* parity — every tier the
+// shared operation sees is present, by the same names — rather than byte
+// equality with the removed bespoke formatter.
+describe("tier parity (bundled pack)", () => {
+  it("tier_list returns one {uri, name} row per ontology tier", async () => {
     const opResult = await listTiers(rt.store);
-    const mcpRes = await client.callTool({
-      name: "tier_list",
-      arguments: {},
-    });
-    assertParity(opResult, mcpRes);
+    const mcpRes = await client.callTool({ name: "tier_list", arguments: {} });
+
+    const content = mcpRes.content as { type: string; text: string }[];
+    const envelope = JSON.parse(content[0].text) as {
+      ok: boolean;
+      data: Array<{ uri?: string; name?: string }>;
+    };
+    expect(envelope.ok).toBe(true);
+
+    // Same tiers, same names — no tier dropped or invented by the cutover.
+    // The shared op names the field `path`; the pack names it `name` (the
+    // honest `ds:name` mapping) — the values are identical.
+    expect(new Set(envelope.data.map((r) => r.name))).toEqual(
+      new Set(opResult.map((t) => t.path)),
+    );
+    // Uniform pack shape: uri + name, no bespoke `depth` field.
+    for (const row of envelope.data) {
+      expect(row.uri).toBeTruthy();
+      expect(row).not.toHaveProperty("depth");
+    }
   });
 
-  it("tier_list condensed: matches llm formatter", async () => {
+  it("tier_list condensed lists every tier under a markdown heading", async () => {
     const opResult = await listTiers(rt.store);
-    const expectedText = tierListFmt.llm(opResult);
-
     const mcpRes = await client.callTool({
       name: "tier_list",
       arguments: { condensed: true },
     });
     const body = parseCondensed(mcpRes);
-    expect(body.text).toBe(expectedText);
+
+    // The generic pack llm renderer headings by the capitalized noun: `## Tier`.
+    expect(body.text).toContain("## Tier");
+    for (const tier of opResult) {
+      expect(body.text).toContain(tier.path);
+    }
   });
 });
 
@@ -341,7 +391,7 @@ describe("modifier parity", () => {
 // Token parity
 // ---------------------------------------------------------------------------
 
-describe("token parity", () => {
+describe.skipIf(!TOKEN_READ_SURFACE_ENABLED)("token parity", () => {
   it("token_list: count matches", async () => {
     const opResult = await listTokens(rt.store);
     const mcpRes = await client.callTool({
@@ -440,14 +490,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 +519,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,26 @@
+/**
+ * Global test setup: isolate the XDG config and data layers.
+ *
+ * The layered config reader consults `$XDG_CONFIG_HOME/pragma/config.json`
+ * on every read, and global-first writes create it; the schema artifact
+ * writes to `$XDG_DATA_HOME/pragma/schema.graphql`. Point both at
+ * per-run temp directories so tests neither observe nor pollute the
+ * developer's real global state. Individual tests that exercise XDG
+ * behavior override these values themselves.
+ *
+ * The boot-time schema artifact emission is disabled globally: it would
+ * add a full ke-graphql compile to every test that drives the real CLI
+ * pipeline and print an "Updated ..." notice on first boot. Its behavior
+ * is covered directly by ensureSchemaArtifact.test.ts; tests exercising
+ * the boot hook re-enable it explicitly.
+ */
+
+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-"));
+process.env.XDG_DATA_HOME = mkdtempSync(
+  join(tmpdir(), "pragma-test-xdg-data-"),
+);
+process.env.PRAGMA_SCHEMA_ARTIFACT = "off";

package/src/testing/standardParityFixtures.ts

@@ -0,0 +1,35 @@
+/**
+ * Standard-noun cutover parity contract.
+ *
+ * The hand-written `standard` domain was deleted; the noun is served by
+ * the bundled pack-v1 definition (`pack/bundled/standardPack.ts`), and
+ * `standardParity.test.ts` asserts SEMANTIC parity against the real
+ * @canonical/code-standards graphs: same entities and values reachable,
+ * uniform pack row/entity shapes, generic renderers.
+ *
+ * {@link PARITY_GAPS} is the honest record of the differences that
+ * remain BY DESIGN after the cutover. Each entry names a concrete,
+ * accepted divergence from the deleted built-in — remove an entry only
+ * when the pack format gains the capability and the parity test asserts
+ * it.
+ */
+
+/**
+ * Accepted post-cutover divergences from the deleted built-in standard
+ * domain. These are doctrine (semantic parity, not byte parity) plus the
+ * capabilities pack v1 deliberately does not carry.
+ */
+export const PARITY_GAPS: readonly string[] = [
+  "list disclosure: pack lists are single-level — the old `standard list --digest/--detailed` row enrichment (extends/example/dos/donts merged into every row, disclosure meta on the MCP envelope) is gone; the same data is reachable per-entity via `standard lookup --detail digest|detailed` and `standard sample`",
+  "list empty guard: the old list raised EMPTY_RESULTS with an install-hint recovery when no standards load or a --category matched nothing; the pack format has no emptyError hook, so an empty or fully-filtered list renders zero rows successfully",
+  "lookup digest rendering: the old list digest truncated the first do-example to 120 chars; the pack `digest` level fetches the full `dos` expand instead (richer, not byte-equal)",
+  "lookup data compaction: the old domain compacted cs:extends in resolved data (JSON showed `cs:ComponentFolderStructure`); pack entities keep the raw IRI in JSON — plain/llm output still compacts at display time",
+  "lookup recovery copy: cross-domain hints (detectCrossDomain) and the curated `List available standards.` message are not authorable; pack misses carry ranked suggestions with the generic `List available standard entries.` copy",
+  'typed shapes: pack rows/entities are all-string records — category counts are strings, and dos/donts entries are `{caption?, language?, code?}` string records rather than typed CodeBlock objects (no `language: "typescript"` default, absent captions are omitted)',
+  "render templates: plain/llm output uses the generic pack renderers (aligned columns, `## Standard (n)` headings, `- key: value` collection entries), not the old bespoke standard templates",
+  "sample count flag: the pack sample takes a positional count (`standard sample 3`) instead of the old `--count 3` flag",
+  "lookup IRI display: plain/llm lookup output does not print the entity IRI (the pack renderer titles by name and projects no uri field); the IRI stays reachable via the list's IRI column, `--format json`, and the non-condensed MCP envelope",
+  "categories JSON shape: the old CategorySummary carried a numeric `standardCount`; pack category rows carry the key `count` with a string value (all-string pack rows, until pack v2 typed columns)",
+  "sample population: totalCount counts name-addressable standards (the set the sampler can actually resolve) rather than all list rows; the old op counted every list row but failed outright when it drew a standard without cs:name",
+  "ink renderers: the pack format declares no renderInk TUI views",
+];

package/src/testing/store.ts

@@ -2,12 +2,12 @@
  * Test store bridge — createTestStore, PragmaTestStoreOptions.
  *
  * Wraps `@canonical/ke/testing` with pragma's default prefix map
- * pre-configured so test authors do not need to repeat PREFIX_MAP.
+ * pre-configured so test authors do not need to repeat DEFAULT_PREFIX_MAP.
  */
 
 import type { TestStoreOptions, TestStoreResult } from "@canonical/ke/testing";
 import { createTestStore as keCreateTestStore } from "@canonical/ke/testing";
-import { PREFIX_MAP } from "../domains/shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../domains/shared/prefixes.js";
 
 /** Options for creating a test store, with pragma prefixes pre-applied. */
 interface PragmaTestStoreOptions extends Omit<TestStoreOptions, "prefixes"> {
@@ -18,7 +18,7 @@ interface PragmaTestStoreOptions extends Omit<TestStoreOptions, "prefixes"> {
  * Create a test ke store with pragma's default prefix map.
  *
  * @param options - Optional overrides; additional prefixes are merged
- *   on top of the default PREFIX_MAP.
+ *   on top of the default DEFAULT_PREFIX_MAP.
  * @returns The test store result from ke/testing.
  *
  * @note Impure
@@ -29,7 +29,7 @@ async function createTestStore(
   return keCreateTestStore({
     ...options,
     prefixes: {
-      ...PREFIX_MAP,
+      ...DEFAULT_PREFIX_MAP,
       ...options.prefixes,
     },
   });

package/src/testing/storyFixtures.ts

@@ -0,0 +1,63 @@
+/**
+ * Story-pack test fixtures — a foreign (non-DS) recipe ontology plus a
+ * matching pack definition.
+ *
+ * The `ex:` namespace is deliberately outside PREFIX_MAP: tests register
+ * it via config `prefixes`, proving the DS-agnostic path end to end.
+ */
+
+import type { StoryPackDefinition } from "../domains/shared/stories/pack/types.js";
+
+/** Namespace of the foreign recipe ontology. */
+export const RECIPE_NAMESPACE = "http://example.org/recipes/";
+
+/** Prefix map entry tests merge into config `prefixes`. */
+export const RECIPE_PREFIXES = { ex: RECIPE_NAMESPACE } as const;
+
+/** A tiny foreign ontology with two recipe instances. */
+export const RECIPE_TTL = `
+@prefix ex: <${RECIPE_NAMESPACE}> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+
+ex:Recipe a rdfs:Class .
+
+ex:pancakes a ex:Recipe ;
+  ex:name "Pancakes" ;
+  ex:category "breakfast" ;
+  ex:instructions "Mix, fry, flip." .
+
+ex:gazpacho a ex:Recipe ;
+  ex:name "Gazpacho" ;
+  ex:category "soup" ;
+  ex:instructions "Blend everything cold." .
+`;
+
+/** A valid pack definition for the recipe ontology. */
+export const RECIPE_STORY: StoryPackDefinition = {
+  noun: "recipe",
+  description: "List recipes",
+  list: {
+    query:
+      "SELECT ?uri ?name ?category WHERE { ?uri a ex:Recipe ; ex:name ?name ; ex:category ?category } ORDER BY ?name",
+    columns: [
+      { field: "name" },
+      { field: "category" },
+      { field: "uri", label: "IRI" },
+    ],
+    filters: [
+      {
+        param: "category",
+        variable: "category",
+        values: ["breakfast", "soup"],
+      },
+    ],
+  },
+  lookup: {
+    type: "ex:Recipe",
+    by: "ex:name",
+    fields: [{ name: "category", property: "ex:category" }],
+    sections: [
+      { name: "instructions", property: "ex:instructions", kind: "field" },
+    ],
+  },
+};