@canonical/pragma-cli 0.32.0 → 0.34.0

package/src/kernel/packs/schema.ts

@@ -5,26 +5,38 @@
  * refinements that encode the source rule (§3): `type` XOR `types`, a
  * graphql-sourced lookup names its fragment target, SPARQL expands stay
  * single-hop, GraphQL fields reject property paths, and every disclosure `level`
- * names a declared canonical level.
+ * names a declared canonical level. Two more refinements make the definition
+ * COMPILABLE, not merely well-shaped: distinct compiled verb names and distinct
+ * filter params (see {@link refineVerbNames} / {@link refineFilterParams}).
  *
  * zod lives here and ONLY here in the pack layer, imported lazily (never on the
- * `--help`/`__complete` fast path). Bundled packs are authored in-repo and typed
- * by TypeScript, so `collect` skips validation for them (per-source skip); this
- * runs for config/package packs and in tests.
+ * `--help`/`__complete` fast path). The distribution's own stories are compiled
+ * statically by `capabilities/distribution.ts` and never revalidated at dispatch
+ * (`collect.projectStoryTiers`'s default-origin carve-out); this runs for config-
+ * and package-declared stories, and in `distribution.test.ts`'s round-trip.
  */
 
 import { z } from "zod";
-import { DETAIL_LEVELS } from "../../constants.js";
+import { DETAIL_LEVELS, RECOVERY_CLI_PREFIX } from "../../constants.js";
 import { PragmaError } from "../error/PragmaError.js";
 import type { PackDefinition } from "./types.js";
 
 const NOUN_PATTERN = /^[a-z][a-z0-9-]*$/;
+/** Message for {@link NOUN_PATTERN} — third-party authors never see the regex. */
+const NOUN_MESSAGE = 'must be lowercase kebab-case, e.g. "design-token"';
 const FILTER_PARAM_PATTERN = /^[a-z][a-z0-9]*$/;
 const FIELD_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const GRAPHQL_NAME_PATTERN = /^[_A-Za-z][_0-9A-Za-z]*$/;
-/** A prefixed name (`ds:Thing`), a property path of them, or an absolute IRI. */
+/**
+ * A prefixed name (`ds:Thing`), a property path of them, or an absolute IRI.
+ * Each path segment may carry the SPARQL inverse marker (`^ds:tier`) — the
+ * contract (`types.ts`) admits "prefixed name, IRI, or path", and an inverse
+ * step IS a property path, so rejecting it here was a schema bug, not a
+ * grammar decision (L-OPEN-9: the tier story's `blocks` expand reads
+ * `^ds:tier`).
+ */
 const TERM_PATTERN =
-  /^(?:[A-Za-z][A-Za-z0-9+.-]*:\/\/[^<>"\s]+|[A-Za-z][\w-]*:[^/<>"\s]+(?:\/[A-Za-z][\w-]*:[^/<>"\s]+)*)$/;
+  /^(?:[A-Za-z][A-Za-z0-9+.-]*:\/\/[^<>"\s]+|\^?[A-Za-z][\w-]*:[^/<>"\s]+(?:\/\^?[A-Za-z][\w-]*:[^/<>"\s]+)*)$/;
 
 /** Params a filter/verb may not claim (they are the shared read vocabulary). */
 const RESERVED_PARAMS = new Set(["search", "detail", "name", "count"]);
@@ -59,9 +71,18 @@ const searchSchema = z
 const emptyRecoverySchema = z
   .object({
     message: z.string().min(1),
+    // The command WITHOUT a binary name — the renderer prepends the CONSUMING
+    // distribution's. A story is portable only if it does not name a binary, so
+    // the old prefixed form is rejected rather than accepted and doubled. Named
+    // loudly, in the `packages` → `packs` tradition, because a third-party pack
+    // written against the old grammar is data, not a typo.
     cli: z
       .string()
-      .startsWith("pragma ", 'emptyRecovery.cli must be a "pragma " command')
+      .min(1)
+      .refine(
+        (value) => !value.startsWith(RECOVERY_CLI_PREFIX),
+        `emptyRecovery.cli is now the command WITHOUT the binary name — write "sources update", not "${RECOVERY_CLI_PREFIX}sources update"`,
+      )
       .optional(),
   })
   .strict();
@@ -78,7 +99,7 @@ const listSchema = z.object(listShape).strict();
 const verbSchema = z
   .object({
     ...listShape,
-    verb: z.string().regex(NOUN_PATTERN),
+    verb: z.string().regex(NOUN_PATTERN, NOUN_MESSAGE),
     description: z.string().optional(),
     toolDescription: z.string().optional(),
   })
@@ -168,6 +189,7 @@ const sampleSchema = z.union([
   z
     .object({
       count: z.number().int().min(1).max(5).optional(),
+      fixedCount: z.boolean().optional(),
       description: z.string().optional(),
       toolDescription: z.string().optional(),
     })
@@ -202,7 +224,7 @@ const lookupSchema = z
 
 const definitionSchema = z
   .object({
-    noun: z.string().regex(NOUN_PATTERN),
+    noun: z.string().regex(NOUN_PATTERN, NOUN_MESSAGE),
     description: z.string().optional(),
     toolDescription: z.string().optional(),
     list: listSchema.optional(),
@@ -228,9 +250,73 @@ const definitionSchema = z
         path: ["list", "query"],
       });
     }
+    refineVerbNames(def, ctx);
+    if (def.list) refineFilterParams(def.list.filters, ["list"], ctx);
+    for (const [index, verb] of (def.verbs ?? []).entries()) {
+      refineFilterParams(verb.filters, ["verbs", index], ctx);
+    }
     if (def.lookup) refineLookup(def.lookup, ctx);
   });
 
+/**
+ * The compiled `(noun, verb)` keys must be distinct.
+ *
+ * `compilePack` emits `list`, then each `verbs[].verb`, then `lookup` and
+ * `sample`. A repeat there survives the grammar into `assembleEffectiveModules`,
+ * where `assertUniqueVerbs` throws — and package stories reach dispatch before
+ * the command tree exists, so that throw would fail EVERY command, `doctor` and
+ * `sources update` included. The collision is a property of the definition, so
+ * the grammar is where it is caught.
+ */
+function refineVerbNames(
+  def: {
+    list?: unknown;
+    verbs?: readonly { verb: string }[];
+    lookup?: unknown;
+  },
+  ctx: z.RefinementCtx,
+): void {
+  const emitted = new Set<string>(def.list ? ["list"] : []);
+  if (def.lookup) {
+    emitted.add("lookup");
+    if ((def.lookup as { sample?: unknown }).sample) emitted.add("sample");
+  }
+  const seen = new Set<string>();
+  for (const [index, verb] of (def.verbs ?? []).entries()) {
+    if (emitted.has(verb.verb) || seen.has(verb.verb)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `verb "${verb.verb}" is already compiled by this pack — every verb must be distinct.`,
+        path: ["verbs", index, "verb"],
+      });
+    }
+    seen.add(verb.verb);
+  }
+}
+
+/**
+ * Filter params project to CLI options, so a repeat inside one list shape makes
+ * Commander refuse to register the second `--<param>` — outside every error
+ * envelope the CLI owns.
+ */
+function refineFilterParams(
+  filters: readonly { param: string }[] | undefined,
+  path: readonly (string | number)[],
+  ctx: z.RefinementCtx,
+): void {
+  const seen = new Set<string>();
+  for (const [index, filter] of (filters ?? []).entries()) {
+    if (seen.has(filter.param)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `filter param "${filter.param}" is declared twice.`,
+        path: [...path, "filters", index, "param"],
+      });
+    }
+    seen.add(filter.param);
+  }
+}
+
 /** Cross-field lookup rules — the source rule (§3, F8). */
 function refineLookup(
   lookup: z.infer<typeof lookupSchema>,

package/src/kernel/packs/sparql/runSelect.test.ts

@@ -1,18 +1,32 @@
 /**
  * `runSelect` — the single choke point for every TRUSTED, generated SPARQL read.
  *
- * Pins the unseeded-store remap: a generated pack query only references the
- * pack's own `ds:`/`cs:` prefixes, so a "Prefix not found" from the facade means
- * the store was never built — an actionable STORE_UNAVAILABLE, NOT a raw error
- * collapsing to INTERNAL_ERROR ("please report this issue"). The recovery carries
- * BOTH the CLI command (`pragma sources update`) and the MCP tool an agent calls
- * (`sources_update`), so either surface can recover.
+ * Pins the remap: a generated query is composed from declared and pack-authored
+ * terms, never from user input, so a "Prefix not found" from the facade means
+ * the store cannot answer this read — an actionable error, NOT a raw one
+ * collapsing to INTERNAL_ERROR ("please report this issue").
+ *
+ * WHICH actionable error is the story's provenance to decide, which is the
+ * second thing pinned here. A DISTRIBUTION story keeps STORE_UNAVAILABLE and its
+ * recovery, carrying BOTH the CLI command (`pragma sources update`) and the MCP
+ * tool an agent calls (`sources_update`), so either surface can recover. A
+ * CONFIG or PACKAGE story gets CONFIG_ERROR naming the story instead: its author
+ * named a prefix nothing binds, and `sources update` cannot conjure a term.
  */
 
 import { describe, expect, it } from "vitest";
 import type { PragmaRuntime } from "../../runtime/types.js";
+import { distributionSource, type StorySource } from "../types.js";
 import { runSelect } from "./runSelect.js";
 
+/** A story declared by a package (a third party's own file). */
+const PACKAGE: StorySource = {
+  label: "@acme/recipes/stories/recipe.json",
+  origin: "package",
+};
+/** A story declared in the user's config. */
+const CONFIG: StorySource = { label: "config", origin: "config" };
+
 /** A runtime whose query facade throws the given error for every SPARQL call. */
 function throwingRuntime(error: unknown): Pick<PragmaRuntime, "query"> {
   return {
@@ -35,14 +49,14 @@ function selectRuntime(
   };
 }
 
-describe("runSelect — unseeded-store remap (ROOT A)", () => {
+describe("runSelect — unanswerable-store remap (ROOT A)", () => {
   it("remaps a 'Prefix not found' to STORE_UNAVAILABLE with CLI + MCP recovery", async () => {
     let caught: unknown;
     try {
       await runSelect(
         throwingRuntime(new Error("Prefix not found: ds")),
         "SELECT ?x WHERE { ?x a ds:Thing }",
-        "block",
+        distributionSource("block"),
       );
     } catch (error) {
       caught = error;
@@ -50,6 +64,12 @@ describe("runSelect — unseeded-store remap (ROOT A)", () => {
 
     // The whole point: it is NOT an unclassified INTERNAL_ERROR.
     expect(caught).toMatchObject({ code: "STORE_UNAVAILABLE" });
+    // …and it claims only what it knows. The same failure reaches a store that
+    // IS built, from a pack whose vocabulary is simply different, so the
+    // message must not tell that user their store is unbuilt.
+    expect((caught as { message: string }).message).toContain(
+      "not built from a pack that defines every term",
+    );
     const recovery = (caught as { recovery?: Record<string, unknown> })
       .recovery;
     expect(recovery?.cli).toBe("pragma sources update");
@@ -61,7 +81,11 @@ describe("runSelect — unseeded-store remap (ROOT A)", () => {
     const boom = new Error("some other engine failure");
     let caught: unknown;
     try {
-      await runSelect(throwingRuntime(boom), "SELECT ?x WHERE {}", "block");
+      await runSelect(
+        throwingRuntime(boom),
+        "SELECT ?x WHERE {}",
+        distributionSource("block"),
+      );
     } catch (error) {
       caught = error;
     }
@@ -73,8 +97,78 @@ describe("runSelect — unseeded-store remap (ROOT A)", () => {
     const rows = await runSelect(
       selectRuntime([{ name: "Button" }, { name: "Card" }]),
       "SELECT ?name WHERE { ?x ds:name ?name }",
-      "block",
+      distributionSource("block"),
     );
     expect(rows).toEqual([{ name: "Button" }, { name: "Card" }]);
   });
 });
+
+describe("runSelect — an unbound prefix is diagnosed by PROVENANCE", () => {
+  const unbound = (): Error => new Error("Prefix not found: acme");
+
+  for (const source of [PACKAGE, CONFIG]) {
+    it(`a ${source.origin} story gets CONFIG_ERROR naming the story`, async () => {
+      // `sources update` cannot help an author who named a prefix nothing
+      // binds — no amount of building conjures a term. Telling them to run it
+      // (as this path used to) sends them round a loop that cannot terminate.
+      // `buildIndex` already treats the same condition as the ordinary
+      // third-party case; the query path used to escalate it.
+      let caught: unknown;
+      try {
+        await runSelect(
+          throwingRuntime(unbound()),
+          "SELECT ?x WHERE { ?x a acme:Thing }",
+          source,
+        );
+      } catch (error) {
+        caught = error;
+      }
+      expect(caught).toMatchObject({ code: "CONFIG_ERROR" });
+      const { message } = caught as { message: string };
+      // It names the story, so the author knows which file to fix.
+      expect(message).toContain(source.label);
+      expect(message).toContain("does not bind");
+      // And it does NOT send them to the lever that cannot help.
+      expect(message).not.toContain("sources update");
+      expect(
+        (caught as { recovery?: { cli?: string } }).recovery?.cli,
+      ).toBeUndefined();
+    });
+  }
+
+  it("the distribution's own story keeps STORE_UNAVAILABLE", async () => {
+    // Unchanged, and the reason is real: the distribution's stories ship with
+    // the packs that bind their terms, so an unbound prefix there means nothing
+    // is built yet — which `sources update` does fix.
+    let caught: unknown;
+    try {
+      await runSelect(
+        throwingRuntime(unbound()),
+        "SELECT ?x WHERE { ?x a ds:Thing }",
+        distributionSource("pragma.conf.ts"),
+      );
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).toMatchObject({ code: "STORE_UNAVAILABLE" });
+    expect((caught as { recovery?: { cli?: string } }).recovery?.cli).toBe(
+      "pragma sources update",
+    );
+  });
+
+  it("a non-SELECT still names the story on every origin", async () => {
+    const askRuntime = {
+      query: {
+        sparql: async () => ({ type: "ask", boolean: true }),
+      } as unknown as PragmaRuntime["query"],
+    };
+    for (const source of [PACKAGE, CONFIG, distributionSource("block")]) {
+      await expect(
+        runSelect(askRuntime, "ASK { ?x ?y ?z }", source),
+      ).rejects.toMatchObject({
+        code: "CONFIG_ERROR",
+        message: expect.stringContaining(source.label),
+      });
+    }
+  });
+});

package/src/kernel/packs/sparql/runSelect.ts

@@ -10,18 +10,28 @@
  * (`graph query`) goes through the facade directly and stays INVALID_INPUT.
  */
 
-import { RECOVERY_CLI_PREFIX } from "../../../constants.js";
 import { PragmaError } from "../../error/PragmaError.js";
 import { cliRecovery } from "../../error/recovery.js";
 import type { PragmaRuntime } from "../../runtime/types.js";
-import type { PackRow } from "../types.js";
+import type { PackRow, StorySource } from "../types.js";
 
 /**
  * True when a trusted, generated query failed because the store does not know a
- * prefix it used. A generated pack query only references the pack's own
- * ontology prefixes (`ds:`/`cs:`), so a "prefix not found" means the store is
- * unseeded — the fresh-install embedded fallback carries no design-system
- * ontology — rather than a query bug.
+ * prefix it used. Generated queries are composed from terms the distribution
+ * declares and from a pack's own story text, never from user input — so an
+ * unknown prefix is never a query bug. It means this store was not built from a
+ * pack that binds that term: most often nothing was built at all, and otherwise
+ * a store built from a pack whose vocabulary is simply different.
+ *
+ * For a DISTRIBUTION story both are answered by the same lever
+ * (`sources update`), so both are remapped to it; the message says which claim
+ * it is actually making, and does NOT assert the store is unbuilt. Widening the
+ * detection any further would start hiding query bugs, which is the failure this
+ * whole choke point exists to prevent.
+ *
+ * A story from a package or a user's config is a different diagnosis, which is
+ * why {@link runSelect} now takes the query's provenance: see
+ * {@link unboundPrefixError}.
  */
 function isUnseededStoreError(error: unknown): boolean {
   const message = error instanceof Error ? error.message : String(error);
@@ -29,33 +39,60 @@ function isUnseededStoreError(error: unknown): boolean {
 }
 
 /**
- * Run the facade query, remapping an unseeded-store failure. A generated pack
- * query hitting an unknown prefix means the store was never built for this
- * design system (the first thing a fresh install hits) — surface the actionable
- * STORE_UNAVAILABLE with the canonical `pragma sources update` recovery instead
- * of a raw SPARQL "Prefix not found" wrapped as INTERNAL_ERROR ("please report
- * this issue"). Returns the inferred facade result type, so this module stays
- * clear of a static `@canonical/ke` import (the lazy-dispatch guard).
+ * The error for a generated query naming a prefix the graph does not bind,
+ * diagnosed by WHO declared the story.
+ *
+ * A distribution story ships with the packs that bind its terms, so the honest
+ * reading is "nothing is built yet" (or "what is built came from a pack with a
+ * different vocabulary") — both fixed by `sources update`, so it keeps today's
+ * STORE_UNAVAILABLE and that recovery.
+ *
+ * A config or package story is the author's own: they named a prefix the graph
+ * does not bind, and `sources update` cannot help them — `buildIndex` already
+ * treats the same condition as the ordinary third-party case and degrades
+ * gracefully, while this path escalated it. It is a CONFIG_ERROR naming the
+ * story, which is the module's own precedent for a declaration that cannot be
+ * served (ruling R3).
+ */
+function unboundPrefixError(source: StorySource): PragmaError {
+  if (source.origin !== "distribution") {
+    return PragmaError.configError(
+      `Story query in ${source.label} uses a prefix the graph does not bind. ` +
+        `Declare it under \`prefixes\`, or use a term the configured packs define.`,
+    );
+  }
+  return PragmaError.storeUnavailable(
+    "The local store was not built from a pack that defines every term this read uses.",
+    {
+      recovery: cliRecovery(
+        "sources update",
+        "Build the local store from the configured packs.",
+        // An agent recovers by calling the tool, then retrying (PR9 C1 cold-
+        // store retry makes the post-update retry succeed).
+        { tool: "sources_update" },
+      ),
+    },
+  );
+}
+
+/**
+ * Run the facade query, remapping a store that cannot answer it. A generated
+ * query hitting an unknown prefix surfaces an actionable error — chosen by the
+ * story's provenance, see {@link unboundPrefixError} — instead of a raw SPARQL
+ * "Prefix not found" wrapped as INTERNAL_ERROR ("please report this issue").
+ * Returns the inferred facade result type, so this module stays clear of a
+ * static `@canonical/ke` import (the lazy-dispatch guard).
  */
-async function queryOrRemap(rt: Pick<PragmaRuntime, "query">, query: string) {
+async function queryOrRemap(
+  rt: Pick<PragmaRuntime, "query">,
+  query: string,
+  source: StorySource,
+) {
   try {
     return await rt.query.sparql(query);
   } catch (error) {
     if (error instanceof PragmaError) throw error;
-    if (isUnseededStoreError(error)) {
-      throw PragmaError.storeUnavailable(
-        "The store has not been built for this project yet.",
-        {
-          recovery: cliRecovery(
-            `${RECOVERY_CLI_PREFIX}sources update`,
-            "Build the local store from the configured design-system packages.",
-            // An agent recovers by calling the tool, then retrying (PR9 C1 cold-
-            // store retry makes the post-update retry succeed).
-            { tool: "sources_update" },
-          ),
-        },
-      );
-    }
+    if (isUnseededStoreError(error)) throw unboundPrefixError(source);
     throw error;
   }
 }
@@ -63,21 +100,23 @@ async function queryOrRemap(rt: Pick<PragmaRuntime, "query">, query: string) {
 /**
  * @param rt - The runtime (its query facade over the lazy store).
  * @param query - SPARQL SELECT text (prefixes auto-applied by the store).
- * @param source - The pack source, for error attribution.
+ * @param source - The story's provenance: its label for attribution, and the
+ *   layer that declared it, which decides how an unbound prefix is diagnosed.
  * @returns One record per row, keyed by SELECT variable name.
- * @throws PragmaError CONFIG_ERROR when the query is not a SELECT;
- *   STORE_UNAVAILABLE (exit 3) when the store is unseeded.
+ * @throws PragmaError CONFIG_ERROR when the query is not a SELECT, or when a
+ *   config/package story names a prefix the graph does not bind;
+ *   STORE_UNAVAILABLE (exit 3) when a distribution story finds one.
  * @note Impure — queries the store through the facade.
  */
 export async function runSelect(
   rt: Pick<PragmaRuntime, "query">,
   query: string,
-  source: string,
+  source: StorySource,
 ): Promise<PackRow[]> {
-  const result = await queryOrRemap(rt, query);
+  const result = await queryOrRemap(rt, query, source);
   if (result.type !== "select") {
     throw PragmaError.configError(
-      `Story query in ${source} must be a SELECT (got ${result.type}).`,
+      `Story query in ${source.label} must be a SELECT (got ${result.type}).`,
     );
   }
   return result.bindings as PackRow[];

package/src/kernel/packs/toolDescription.test.ts

@@ -13,12 +13,20 @@
  */
 
 import { describe, expect, it } from "vitest";
-import { standardModule } from "../../capabilities/standard/index.js";
-import { tokenModule } from "../../capabilities/token/index.js";
+import { storyModules } from "../../capabilities/distribution.js";
 import { projectMcp } from "../../testing/helpers/projectMcp.js";
 import { formatVerbHelp } from "../project/cli/verbHelp.js";
 import type { VerbSpec } from "../spec/types.js";
 
+const standardModule = storyModules.get("standard");
+if (!standardModule) {
+  throw new Error('pragma.conf.ts declares no story for "standard"');
+}
+const tokenModule = storyModules.get("token");
+if (!tokenModule) {
+  throw new Error('pragma.conf.ts declares no story for "token"');
+}
+
 const verb = (
   module: { verbs: readonly VerbSpec[] },
   label: string,

package/src/kernel/packs/types.ts

@@ -170,7 +170,11 @@ export interface PackSearch {
 export interface PackEmptyRecovery {
   /** Human-readable cause + fix (e.g. which packages provide the data). */
   readonly message: string;
-  /** Runnable pragma command fixing the emptiness (rendered on the CLI). */
+  /**
+   * The command that fixes the emptiness, WITHOUT the binary name
+   * (`sources update`). The consuming distribution's renderer prepends its own
+   * name, so a story stays portable across distributions.
+   */
   readonly cli?: string;
 }
 
@@ -312,8 +316,8 @@ export interface PackDefinition {
   /** MCP tool description (defaults to the CLI description). */
   readonly toolDescription?: string;
   /**
-   * The list story. Optional so a pack can serve only the lookup verb of a noun
-   * whose list stays hand-written (e.g. `block`). At least one of `list`/`lookup`
+   * The list story. Optional so a pack can serve a noun that is addressable but
+   * not enumerable — a lookup with no list. At least one of `list`/`lookup`
    * must be declared.
    */
   readonly list?: PackList;
@@ -331,7 +335,38 @@ export interface PackDefinition {
 
 /** A validated pack definition paired with where it was declared. */
 export interface PackEntry {
-  /** Where the definition was declared (config path, package file, or bundled). */
+  /** The package story file it came from, e.g. `@acme/recipes/stories/recipe.json`. */
   readonly source: string;
   readonly definition: PackDefinition;
 }
+
+/**
+ * Which layer declared a story. The label alone cannot answer this — a label is
+ * free text for a human — and the difference changes what a failure MEANS.
+ *
+ * A generated query that names a prefix the graph does not bind is, from a
+ * `distribution` story, almost always an unbuilt store: the distribution's own
+ * stories and its packs ship together, so the terms exist as soon as anything is
+ * built. From a `config` or `package` story it is the opposite: the author named
+ * a prefix nothing binds, and no amount of building will conjure it. One is
+ * STORE_UNAVAILABLE with a `sources update` recovery, the other a CONFIG_ERROR
+ * naming the story — and telling them apart needs this at the failure site.
+ */
+export type StoryOrigin = "distribution" | "config" | "package";
+
+/**
+ * A story's provenance, threaded from where it was declared down to the query
+ * that runs on its behalf.
+ */
+export interface StorySource {
+  /** Human-readable location, used verbatim in diagnostics. */
+  readonly label: string;
+  /** The layer that declared it. */
+  readonly origin: StoryOrigin;
+}
+
+/** A story the distribution itself declares (`pragma.conf.ts` and its kin). */
+export const distributionSource = (label: string): StorySource => ({
+  label,
+  origin: "distribution",
+});

package/src/kernel/packs/uniqueness.ts

@@ -2,10 +2,10 @@
  * Plain `(noun, verb)` uniqueness across compiled verbs.
  *
  * Replaces the old reserved-verb / derive-reserved machinery: every verb the
- * projectors see — authored, bundled-pack, or dynamic-pack — must own a distinct
- * `(noun, verb)` key. Precedence (config > package > bundled) is resolved by
- * NOUN before this runs, so a surviving collision here is a real conflict (a
- * dynamic pack claiming an authored noun's verb), reported with both sources.
+ * projectors see — authored, distribution-declared, or dynamic — must own a
+ * distinct `(noun, verb)` key. Precedence (config > package > distribution) is
+ * resolved by NOUN before this runs, so a surviving collision here is a real
+ * conflict, reported with both sources.
  */
 
 import type { VerbSpec } from "../spec/types.js";