@canonical/pragma-cli 0.33.0 → 0.35.0

package/src/testing/eval/__snapshots__/eval.test.ts.snap

@@ -2,6 +2,11 @@
 
 exports[`eval harness — seed gate > runs the full seed (stable + read-noun) cases clean 1`] = `
 [
+  {
+    "id": "content-block-list-is-channel-independent",
+    "kind": "content",
+    "passed": true,
+  },
   {
     "id": "content-canonical-graph-has-4-components",
     "kind": "content",
@@ -57,11 +62,6 @@ exports[`eval harness — seed gate > runs the full seed (stable + read-noun) ca
     "kind": "content",
     "passed": true,
   },
-  {
-    "id": "content-normal-channel-drops-beta-only-block",
-    "kind": "content",
-    "passed": true,
-  },
   {
     "id": "content-standard-list-length-equals-category-count-sum",
     "kind": "content",
@@ -113,7 +113,7 @@ exports[`eval harness — seed gate > runs the full seed (stable + read-noun) ca
     "passed": true,
   },
   {
-    "id": "prompt-tokens-config-maps-to-token-add-config",
+    "id": "prompt-tokens-config-maps-to-nothing",
     "kind": "prompt",
     "passed": true,
   },
@@ -183,7 +183,7 @@ exports[`eval harness — seed gate > runs the full seed (stable + read-noun) ca
     "passed": true,
   },
   {
-    "id": "tool-token-add-config-is-plan-first",
+    "id": "tool-token-noun-is-read-only",
     "kind": "tool",
     "passed": true,
   },

package/src/testing/eval/cases/assembly.ts

@@ -171,15 +171,22 @@ export const assemblyEvalCases: readonly EvalCase[] = [
     },
   },
   {
-    id: "prompt-tokens-config-maps-to-token-add-config",
+    id: "prompt-tokens-config-maps-to-nothing",
     kind: "prompt",
     input:
-      '"Generate a terrazzo tokens config" should map to `token_add-config`.',
+      '"Generate a terrazzo tokens config" maps to NO tool — `token_add-config` was removed in L-OPEN-9, and the token noun is read-only.',
     async expect({ mcp }) {
-      assertIntentTool(
-        await mcp.listTools(),
-        "token_add-config",
-        /token|terrazzo/i,
+      // The inverse of an intent-mapping case, and the point of the ruling: an
+      // agent asked to write a tokens config finds nothing in the catalog that
+      // claims to do it, rather than a verb the declared grammar cannot express.
+      const tools = await mcp.listTools();
+      assert.ok(
+        !tools.some(
+          (tool) =>
+            tool.name === "token_add-config" ||
+            /terrazzo|tokens\.config/i.test(String(tool.description ?? "")),
+        ),
+        "no tool may still offer to write a tokens config",
       );
     },
   },

package/src/testing/eval/cases/effectful.ts

@@ -88,7 +88,7 @@ export const effectfulEvalCases: readonly EvalCase[] = [
     id: "tool-doctor-reports-check-tallies",
     kind: "tool",
     input:
-      "doctor returns a { checks, passed, failed, skipped } diagnostic report where the tallies sum to the checks.",
+      "doctor returns a { checks, passed, failed, available, skipped } diagnostic report where the tallies sum to the checks.",
     async expect({ mcp }) {
       const result = await mcp.callTool("doctor");
       assert.equal(result.ok, true);
@@ -96,11 +96,12 @@ export const effectfulEvalCases: readonly EvalCase[] = [
         checks: unknown[];
         passed: number;
         failed: number;
+        available: number;
         skipped: number;
       };
       assert.ok(Array.isArray(data.checks), "expected a checks array");
       assert.equal(
-        data.passed + data.failed + data.skipped,
+        data.passed + data.failed + data.available + data.skipped,
         data.checks.length,
       );
     },
@@ -170,18 +171,23 @@ export const effectfulEvalCases: readonly EvalCase[] = [
     },
   },
   {
-    id: "tool-token-add-config-is-plan-first",
+    id: "tool-token-noun-is-read-only",
     kind: "tool",
     input:
-      "token_add-config (needsStore mutation) without `confirm` returns a plan naming tokens.config.mjs and writes nothing.",
+      "the `token` noun exposes only reads — `token_add-config` (the tokens.config.mjs writer) was REMOVED in L-OPEN-9, not ported.",
     async expect() {
       await withCanonicalFixture(CANONICAL_CONFIG, async (mcp) => {
-        const result = await mcp.callTool("token_add-config");
-        assert.equal(result.ok, true);
-        const meta = result.meta as { planOnly?: boolean };
-        assert.equal(meta.planOnly, true);
-        const data = result.data as { plan: string[] };
-        assert.match(data.plan.join("\n"), /tokens\.config\.mjs/);
+        // This case used to pin `token_add-config`'s plan-first contract. The
+        // verb is gone, so it pins the ruling instead: the read surface is
+        // declared content and carries no mutation. (The plan-first MECHANIC is
+        // still covered by `tool-config-set-is-plan-first` and
+        // `tool-upgrade-is-plan-first`.)
+        const tools = (await mcp.listTools()).map((tool) => tool.name);
+        assert.ok(!tools.includes("token_add-config"));
+        assert.deepEqual(
+          tools.filter((name) => name.startsWith("token")).sort(),
+          ["token_list", "token_lookup", "token_sample"],
+        );
       });
     },
   },
@@ -189,14 +195,21 @@ export const effectfulEvalCases: readonly EvalCase[] = [
     id: "tool-tier-lookup-lists-scoped-blocks",
     kind: "tool",
     input:
-      "tier_lookup {name:apps/lxd} resolves the tier and lists the blocks scoped to it (LXD Panel).",
+      "tier_lookup {name:[apps/lxd]} resolves the tier and expands the blocks scoped to it (LXD Panel).",
     async expect() {
       await withCanonicalFixture(ALL_VISIBLE_CONFIG, async (mcp) => {
-        const result = await mcp.callTool("tier_lookup", { name: "apps/lxd" });
+        // The declared pack lookup (L-OPEN-9): variadic names in, the uniform
+        // `{ results, errors }` lookup envelope out, blocks as an expand.
+        const result = await mcp.callTool("tier_lookup", {
+          name: ["apps/lxd"],
+        });
         assert.equal(result.ok, true);
-        const data = result.data as { name: string; blocks: string[] };
-        assert.equal(data.name, "apps/lxd");
-        assert.ok(data.blocks.includes("LXD Panel"));
+        const data = result.data as {
+          results: { name: string; blocks: { name: string }[] }[];
+        };
+        const tier = data.results[0];
+        assert.equal(tier?.name, "apps/lxd");
+        assert.ok(tier?.blocks.some((block) => block.name === "LXD Panel"));
       });
     },
   },

package/src/testing/eval/cases/readNouns.ts

@@ -90,15 +90,15 @@ export const readNounEvalCases: readonly EvalCase[] = [
     id: "content-canonical-graph-has-4-components",
     kind: "content",
     input:
-      "the canonical fixture graph carries 4 ds:Component individuals (Button, Modal, LXD Panel, Beta Widget); block list --all-tiers also surfaces the untiered Button Icon subcomponent (A2).",
+      "the canonical fixture graph carries 4 ds:Component individuals (Button, Modal, LXD Panel, Beta Widget); block_list also surfaces the untiered Button Icon subcomponent (A2).",
     async expect() {
       await withCanonicalFixture(ALL_VISIBLE_CONFIG, async (mcp) => {
-        const result = await mcp.callTool("block_list", { allTiers: true });
+        const result = await mcp.callTool("block_list");
         const names = (result.data as { name: string }[])
           .map((r) => r.name)
           .sort();
-        // --all-tiers now reveals the untiered Button Icon subcomponent
-        // alongside the 4 tiered components (A2).
+        // The declared list takes no arguments and filters nothing: the 4 tiered
+        // components plus the untiered Button Icon subcomponent (A2).
         assert.deepEqual(names, [
           "Beta Widget",
           "Button",
@@ -168,25 +168,27 @@ export const readNounEvalCases: readonly EvalCase[] = [
     },
   },
   {
-    id: "content-normal-channel-drops-beta-only-block",
+    id: "content-block-list-is-channel-independent",
     kind: "content",
     input:
-      "the normal channel (CANONICAL_CONFIG) excludes the beta-only block; the prerelease channel (ALL_VISIBLE_CONFIG) includes it.",
+      "block_list returns the SAME rows on the normal channel (CANONICAL_CONFIG) and the prerelease one (ALL_VISIBLE_CONFIG) — including the beta-only block, which the normal channel used to hide (L-OPEN-9).",
     async expect() {
-      await withCanonicalFixture(CANONICAL_CONFIG, async (mcp) => {
-        const normal = await mcp.callTool("block_list", { allTiers: true });
-        const normalNames = (normal.data as { name: string }[]).map(
-          (r) => r.name,
-        );
-        assert.ok(!normalNames.includes("Beta Widget"));
-      });
-      await withCanonicalFixture(ALL_VISIBLE_CONFIG, async (mcp) => {
-        const prerelease = await mcp.callTool("block_list", { allTiers: true });
-        const prereleaseNames = (prerelease.data as { name: string }[]).map(
-          (r) => r.name,
-        );
-        assert.ok(prereleaseNames.includes("Beta Widget"));
-      });
+      const namesUnder = async (
+        config: typeof CANONICAL_CONFIG | typeof ALL_VISIBLE_CONFIG,
+      ): Promise<string[]> => {
+        let names: string[] = [];
+        await withCanonicalFixture(config, async (mcp) => {
+          const result = await mcp.callTool("block_list");
+          names = (result.data as { name: string }[]).map((r) => r.name).sort();
+        });
+        return names;
+      };
+      const normal = await namesUnder(CANONICAL_CONFIG);
+      const prerelease = await namesUnder(ALL_VISIBLE_CONFIG);
+      // The signed-off consequence: an experimental block is visible to
+      // everyone, on every channel, until filtering returns in declared form.
+      assert.ok(normal.includes("Beta Widget"));
+      assert.deepEqual(normal, prerelease);
     },
   },
   {

package/src/testing/eval/cases/stable.ts

@@ -110,7 +110,11 @@ export const stableEvalCases: readonly EvalCase[] = [
       try {
         const widgetModule: CapabilityModule = {
           name: "widget",
-          verbs: compilePack(WIDGET_PACK, "test:widget", WIDGET_PREFIXES),
+          verbs: compilePack(
+            WIDGET_PACK,
+            { label: "test:widget", origin: "package" },
+            WIDGET_PREFIXES,
+          ),
         };
         const mcp = await projectMcp([widgetModule], fixture.cwd);
         try {

package/src/testing/eval/eval.test.ts

@@ -70,5 +70,11 @@ describe("eval harness — seed gate", () => {
     expect(report.cases.length).toBeGreaterThanOrEqual(35);
     expect(report.cases.length).toBeLessThanOrEqual(60);
     expect(normalize(report.cases)).toMatchSnapshot();
-  });
+    // Explicit timeout, like the other suite-level gates: this drives every
+    // seed case through a real runtime AND a real MCP server, and since a
+    // preview now performs its reads for real rather than answering from a
+    // mock, the effectful cases pay genuine IO. Measured 3.7s before that
+    // change and 5.4s after, so the vitest 5s default fails it on cost the
+    // PR intends to pay — not on a defect. 60s leaves room for CI contention.
+  }, 60_000);
 });

package/src/testing/fixtures/blockGraph.ts

@@ -21,6 +21,18 @@ export const BLOCK_PREFIXES: Readonly<Record<string, string>> = {
   xsd: "http://www.w3.org/2001/XMLSchema#",
 };
 
+/**
+ * A membership roster deep enough to cross the entity read's fan-in threshold,
+ * so the fixture exercises the SAMPLED branch and not only the listed one.
+ * Generated rather than written out: the count is the whole point of the case,
+ * and 22 hand-copied lines invite someone to "tidy" one away.
+ */
+const ROSTER_MEMBER_COUNT = 22;
+const ROSTER_MEMBERS = Array.from(
+  { length: ROSTER_MEMBER_COUNT },
+  (_, index) => `ds:probe.member${index} a ds:Probe ; ds:tier ds:rosterHub .`,
+).join("\n");
+
 /** The fixture ontology + individuals as Turtle. */
 export const BLOCK_TTL = `
 @prefix ds: <https://ds.canonical.com/> .
@@ -109,4 +121,71 @@ ds:mod.importance.secondary a ds:Modifier ; ds:name "secondary" ; ds:modifierFam
 ds:mod.density.compact a ds:Modifier ; ds:name "compact" ; ds:modifierFamily ds:family.density .
 ds:mod.size.small a ds:Modifier ; ds:name "small" ; ds:modifierFamily ds:family.size .
 ds:mod.size.large a ds:Modifier ; ds:name "large" ; ds:modifierFamily ds:family.size .
+
+# ---- Neighbourhood-read probes ----
+# Typed \`ds:Probe\`, which is deliberately NOT declared as an owl:Class and is
+# outside the block VALUES set, so these individuals reach the entity reader
+# without entering any block list or the ontology class listing.
+#
+# literalTrap holds a STRING that begins with the ds: namespace. Read through
+# the lossy string view it was indistinguishable from an IRI and got compacted
+# into something that read back as one; the term view is what tells them apart.
+ds:literalTrap a ds:Probe ;
+  ds:name "literal trap" ;
+  ds:figmaLink "https://ds.canonical.com/not-an-iri" .
+
+# blankHolder carries blank-node objects — store-local handles that re-mint on
+# every load — so the read must inline them as records AND order those records
+# by content rather than by the label that grouped them.
+ds:blankHolder a ds:Probe ;
+  ds:name "blank holder" ;
+  ds:changeLog [ a ds:ChangeLogEntry ; ds:changeType "decision" ; ds:change "Split the button." ] ;
+  ds:changeLog [ a ds:ChangeLogEntry ; ds:changeType "revision" ; ds:change "Renamed the slot." ] .
+
+# One blank node reached by TWO predicates — keyed by node alone, the second
+# edge silently vanished.
+ds:doubleLinked a ds:Probe ;
+  ds:name "double linked" ;
+  ds:changeLog [ a ds:ChangeLogEntry ; ds:changeType "decision" ] ;
+  ds:usageNote [ a ds:ChangeLogEntry ; ds:changeType "note" ] .
+
+# An RDF 1.2 directional literal — dropped, it reads as a plain @ar literal.
+ds:directional a ds:Probe ;
+  ds:name "\u0645\u0631\u062D\u0628\u0627"@ar--rtl .
+
+# The roster hub also carries ONE edge under a different predicate, so a read
+# can prove that a 22-deep neighbour does not evict its quieter sibling.
+ds:rosterHub a ds:Probe ; ds:name "roster hub" .
+ds:probe.quiet a ds:Probe ; ds:hasSubcomponent ds:rosterHub .
+${ROSTER_MEMBERS}
+`;
+
+/**
+ * An OPT-IN overlay for the lookup-addressing suite, appended to
+ * {@link BLOCK_TTL} by the tests that need it and by nothing else — the block
+ * parity, ontology and GraphQL-engine suites assert over the base graph and
+ * must keep seeing exactly two components.
+ *
+ * It models the three shapes the addressing path gets wrong: two components
+ * sharing one `ds:name` (declared zeta-first so the store's enumeration order
+ * and IRI order DISAGREE — an unordered `LIMIT 1` picks the zeta one), and a
+ * component carrying no `ds:name` at all (reachable only by IRI, the way 131 of
+ * the 144 live code standards are).
+ */
+export const AMBIGUOUS_TTL = `
+ds:apps a ds:Tier ; ds:name "apps" .
+
+ds:zeta.chip a ds:Component ;
+  ds:name "Chip" ;
+  ds:tier ds:global ;
+  ds:summary "The zeta chip — declared first, sorts last." .
+
+ds:alpha.chip a ds:Component ;
+  ds:name "Chip" ;
+  ds:tier ds:apps ;
+  ds:summary "The alpha chip — declared last, sorts first." .
+
+ds:nameless.widget a ds:Component ;
+  ds:tier ds:global ;
+  ds:summary "Carries no ds:name; addressable only by IRI." .
 `;

package/src/testing/fixtures/fixtureCapability.ts

@@ -7,7 +7,7 @@
 
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { $, gen, succeed, writeFile } from "@canonical/task";
+import { $, gen, readFile, succeed, writeFile } from "@canonical/task";
 import type { CapabilityModule } from "../../kernel/spec/types.js";
 
 /** A synthetic module: noun `widget`, three verbs (one hidden). */
@@ -174,6 +174,50 @@ export const fixtureEffectsModule: CapabilityModule = {
   ],
 };
 
+/**
+ * A synthetic module for the HONEST-preview guards (PR7). `probe graft` READS a
+ * file before writing beside it, so a run whose source is missing dies on its
+ * first effect. The mock previewer answered that read with a placeholder string
+ * and reported a confident plan with exit 0 — the structural false positive
+ * PRA-104 indicts. Under `runPreview` the read is real, so `--dry-run` (and the
+ * MCP plan-first twin) fail exactly where and how the run would. Test-only (D8)
+ * — never listed in `capabilities/index.ts`.
+ */
+export const fixturePreviewModule: CapabilityModule = {
+  name: "fixture-preview",
+  verbs: [
+    {
+      path: ["probe", "graft"],
+      summary: "Copy a file's content into a sibling.",
+      params: [
+        {
+          kind: "string",
+          name: "source",
+          doc: "The file to read.",
+          positional: true,
+          required: true,
+        },
+      ],
+      output: { formatters: passthroughFormatters },
+      capability: {
+        needsStore: false,
+        mutates: true,
+        mcp: {
+          expose: true,
+          annotations: { readOnlyHint: false, openWorldHint: false },
+        },
+      },
+      run: (p) =>
+        gen(function* () {
+          const { source } = p as { source: string };
+          const content = yield* $(readFile(source));
+          yield* $(writeFile(`${source}.grafted`, content));
+          return { grafted: source };
+        }),
+    },
+  ],
+};
+
 /**
  * A synthetic module that exercises every RENDER path of `emitReference` (D8 —
  * never listed in `src/capabilities/index.ts`). Distinct from `fixtureModule`,

package/src/testing/fixtures/graph/canonical.ts

@@ -6,9 +6,12 @@
  * `block` content-parity + `ontology`/`graph inspect` tests are protected
  * against) byte-for-byte and EXTENDS it with the entities the other bundled
  * read nouns (`standard`, `modifier`, `token`, `tier`) need, plus two more
- * blocks that exercise tier-chain inheritance and channel visibility (PR3's
- * hand-written `block list`, Risk5). Because `BLOCK_TTL` is reused verbatim,
- * Button/Modal content can never drift between PR3's fixture and this one.
+ * blocks that used to exercise tier-chain inheritance and channel visibility
+ * (PR3's hand-written `block list`, Risk5). Those two now serve the opposite
+ * purpose: L-OPEN-9 removed the filtering, so a tier-scoped and a
+ * channel-gated block are what prove the declared list hides NEITHER. Because
+ * `BLOCK_TTL` is reused verbatim, Button/Modal content can never drift between
+ * PR3's fixture and this one.
  *
  * Composed as one Turtle document, so ONE store answers every read noun:
  * `block`/`ontology`/`graph inspect` were already provable on `BLOCK_TTL`
@@ -157,11 +160,97 @@ ds:prompt.configure a ds:Prompt ;
 ds:prompt.scaffold-component a ds:Prompt ;
   rdfs:label "scaffold-component" ;
   rdfs:comment "Scaffold a new component and align it to the standards." ;
-  ds:promptBody "Scaffold the {{componentName}} component in {{framework}}. Use create_component with the component path and --framework {{framework}}, then review the generated files against the react/component standards via standard_lookup." ;
+  ds:promptBody "Scaffold the {{componentName}} component in {{framework}}. Use create_component with framework {{framework}} and the component path, then review the generated files against the react/component standards via standard_lookup." ;
   ds:promptArgument [ ds:argName "componentName" ; rdfs:comment "Component name/path (e.g. Button)." ; ds:argRequired true ] ;
   ds:promptArgument [ ds:argName "framework" ; rdfs:comment "react | svelte | lit." ; ds:argRequired false ] .
 `;
 
+/** The `ds:Concept` section — long-form documentation entries the `concept`
+ * story reads. Mirrors the real design-system data shape (canonical/design-system#64):
+ * `ds:name`/`ds:summary`/`ds:tier` base, the Markdown body in `ds:content`
+ * (standard disclosure), `ds:knownEdgeCases` (detailed), and `ds:conceptType`
+ * → a named `ds:ConceptType` individual carrying its own `ds:name`. */
+const CONCEPT_TTL = `
+ds:Concept a owl:Class .
+ds:ConceptType a owl:Class .
+ds:content a owl:DatatypeProperty ; rdfs:domain ds:Concept ; rdfs:range xsd:string .
+ds:knownEdgeCases a owl:DatatypeProperty ; rdfs:domain ds:Concept ; rdfs:range xsd:string .
+ds:conceptType a owl:ObjectProperty ; rdfs:domain ds:Concept ; rdfs:range ds:ConceptType .
+
+ds:concepttype.Explanation a ds:ConceptType ;
+  ds:name "Explanation" ;
+  ds:summary "Concept documentation that deepens understanding of a topic." .
+
+ds:concepttype.How-to-guide a ds:ConceptType ;
+  ds:name "How-to guide" ;
+  ds:summary "Concept documentation that walks through solving a problem." .
+
+ds:concept.Foundations-Grid a ds:Concept ;
+  ds:name "Foundations: Grid" ;
+  ds:summary "How the grid system underpins every layout." ;
+  ds:tier ds:global ;
+  ds:conceptType ds:concepttype.Explanation ;
+  ds:content "The grid is the shared spatial contract every block lays out against." ;
+  ds:knownEdgeCases "Nested grids inherit the outer gutter unless re-declared." .
+
+ds:concept.Question-mark-vs-information-icon a ds:Concept ;
+  ds:name "Question mark vs information icon" ;
+  ds:summary "Deciding between the information icon and the question mark icon." ;
+  ds:tier ds:global ;
+  ds:conceptType ds:concepttype.How-to-guide ;
+  ds:content "The information icon offers context proactively; the question mark answers a question the user already has." ;
+  ds:knownEdgeCases "Icon interpretation depends on the user's prior conventions." .
+`;
+
+/**
+ * The implementation graph: two libraries whose `ds:implementsBlock` edges point
+ * at `BLOCK_TTL`'s own Button/Modal IRIs, so a test can prove the cross-pack
+ * join (an implementation collected from source resolving to a block declared by
+ * the design system) rather than just the shape of a row. Button is implemented
+ * TWICE, on two platforms — the case `--platform` has to separate.
+ */
+const IMPLEMENTATION_TTL = `
+ds:ImplementationLibrary a owl:Class .
+ds:ImplementationObject a owl:Class .
+ds:hasImplementation a owl:ObjectProperty ; rdfs:domain ds:ImplementationLibrary ; rdfs:range ds:ImplementationObject .
+ds:implementsBlock a owl:ObjectProperty ; rdfs:domain ds:ImplementationObject ; rdfs:range ds:UIBlock .
+ds:libraryName a owl:DatatypeProperty ; rdfs:domain ds:ImplementationLibrary ; rdfs:range xsd:string .
+ds:platform a owl:DatatypeProperty ; rdfs:domain ds:ImplementationLibrary ; rdfs:range xsd:string .
+ds:libraryTier a owl:ObjectProperty ; rdfs:domain ds:ImplementationLibrary ; rdfs:range ds:Tier .
+ds:implementationCount a owl:DatatypeProperty ; rdfs:domain ds:ImplementationLibrary ; rdfs:range xsd:integer .
+ds:headLink a owl:DatatypeProperty ; rdfs:domain ds:ImplementationObject ; rdfs:range xsd:string .
+ds:versionedLink a owl:DatatypeProperty ; rdfs:domain ds:ImplementationObject ; rdfs:range xsd:string .
+
+ds:implementation.library.react-ds-global a ds:ImplementationLibrary ;
+  ds:libraryName "@canonical/react-ds-global" ;
+  ds:platform "react" ;
+  ds:libraryTier ds:global ;
+  ds:version "0.34.0" ;
+  ds:implementationCount 2 ;
+  ds:hasImplementation ds:implementation.react-ds-global.button,
+                       ds:implementation.react-ds-global.modal .
+
+ds:implementation.react-ds-global.button a ds:ImplementationObject ;
+  ds:implementsBlock ds:button ;
+  ds:headLink "https://example.test/react/Button.tsx" .
+
+ds:implementation.react-ds-global.modal a ds:ImplementationObject ;
+  ds:implementsBlock ds:modal ;
+  ds:headLink "https://example.test/react/Modal.tsx" .
+
+ds:implementation.library.svelte-ds-global a ds:ImplementationLibrary ;
+  ds:libraryName "@canonical/svelte-ds-global" ;
+  ds:platform "svelte" ;
+  ds:libraryTier ds:global ;
+  ds:version "0.34.0" ;
+  ds:implementationCount 1 ;
+  ds:hasImplementation ds:implementation.svelte-ds-global.button .
+
+ds:implementation.svelte-ds-global.button a ds:ImplementationObject ;
+  ds:implementsBlock ds:button ;
+  ds:headLink "https://example.test/svelte/Button.svelte" .
+`;
+
 /** The prefixes the canonical store is built and queried with. */
 export const CANONICAL_PREFIXES: Readonly<Record<string, string>> = {
   ...BLOCK_PREFIXES,
@@ -169,7 +258,7 @@ export const CANONICAL_PREFIXES: Readonly<Record<string, string>> = {
 };
 
 /** The full canonical Turtle: PR3's `BLOCK_TTL` verbatim, plus the sections above. */
-export const CANONICAL_TTL = `${BLOCK_TTL}\n${DS_EXTRA_TTL}\n${CS_TTL}\n${PROMPT_TTL}`;
+export const CANONICAL_TTL = `${BLOCK_TTL}\n${DS_EXTRA_TTL}\n${CS_TTL}\n${PROMPT_TTL}\n${CONCEPT_TTL}\n${IMPLEMENTATION_TTL}`;
 
 /** Default viewing config: no tier set, `normal` channel — drops the beta-only block. */
 export const CANONICAL_CONFIG = { channel: "normal" as const };

package/src/testing/fixtures/graph/defaultPack.ts

@@ -19,17 +19,18 @@
  *  2. Two+ domain classes (`ds:Component` and `ds:Pattern`) so a read that keys
  *     off the primary domain type is exercised across more than one class.
  *  3. An UNTIERED block (`ds:orphanWidget` — a `ds:Component` with a `ds:name`
- *     but NO `ds:tier`). `block list`'s SELECT inner-joins `?c ds:tier ?t`, so an
- *     untiered block is silently dropped from every listing (A2), even though
- *     `graph query` finds it — the fixture pins both halves of that divergence.
+ *     but NO `ds:tier`). `block list`'s SELECT once inner-joined `?c ds:tier ?t`,
+ *     silently dropping an untiered block from every listing (A2) even though
+ *     `graph query` found it; the declared story's OPTIONAL tier join is what
+ *     the fixture now holds honest.
  *  4. A multilingual `rdfs:label "Button"@en, "Bouton"@fr` — two same-predicate
  *     labels whose winner in the single-valued index is store-order-arbitrary
  *     (A7), a shape a bare-string fixture can never produce.
  *
  * The vocabulary is the live `ds:` design-system namespace (same as
  * `blockGraph.ts`/`canonical.ts`), so `block list`, `ontology list/show`, and
- * `graph query` all run against real terms — the hand-written `block list` verb
- * hard-codes `ds:Component`/`ds:name`/`ds:tier`/`ds:release`.
+ * `graph query` all run against real terms — the `block` story's declared SELECT
+ * names `ds:Component`/`ds:Pattern`/`ds:name`/`ds:tier` directly.
  *
  * Stable anchors this fixture guarantees (pinned by the journey suite):
  *  - Exactly 4 blocks in the graph: Button (`ds:Component`, global), Card
@@ -170,7 +171,7 @@ ex:beta ex:name "Beta" .
 /**
  * A malformed Turtle source — a subject/predicate with no object — drives the
  * `sources update` data-error classification path (a NAMED `CONFIG_ERROR`, not
- * an INTERNAL "please report this issue").
+ * an INTERNAL "report this issue").
  */
 export const MALFORMED_TTL = `@prefix ex: <https://ex.test/#> .
 ex:One a ex:Widget .

package/src/testing/fixtures/graph/owlExport.ts

@@ -1,17 +1,19 @@
 /**
  * A realistic multi-typed OWL / Protégé-export fixture graph.
  *
- * The embedded `sample.ttl` (Button/Card/Dialog, each typed by exactly ONE
- * domain class, every block tiered, every label untagged) is a TOY: it never
- * exercises the counters/classifiers the way a real vocabulary does. This graph
- * deliberately carries the shapes that only bite real packs (audit backlog A):
+ * The other fixture graphs (`canonical.ts`, `defaultPack.ts` — Button/Card/
+ * Dialog, each typed by exactly ONE domain class, every block tiered, every
+ * label untagged) are TOYS: they never exercise the counters/classifiers the way
+ * a real vocabulary does. This graph deliberately carries the shapes that only
+ * bite real packs (audit backlog A):
  *
  * - Protégé DUAL-typing: an individual asserted as its domain class AND
  *   `owl:NamedIndividual` — the multiset that made `entityTotal` run ~2× (A1).
  * - A MULTI-DOMAIN individual (`ex:toggle`: two domain classes) — so the
  *   primary-type tie-break must be deterministic, not store-order (A3).
  * - An UNTIERED block (`ds:datePicker`: a `ds:Component` with no `ds:tier`) —
- *   which `block list --all-tiers` must surface, not hide (A2).
+ *   which `block list` must surface, not hide (A2; the tier join is OPTIONAL,
+ *   and since L-OPEN-9 there is no tier filter at all).
  * - A blank-node `rdf:type` (`ex:field`'s anonymous SHACL-style class) — which
  *   must NOT become a `type:"_:b0"` primary key (A6).
  * - An OWL-PUNNED subject (`ex:Slider`: a class that is ALSO a metaclass

package/src/testing/helpers/blankCanonicalRanges.ts

@@ -0,0 +1,36 @@
+/**
+ * Blank the @canonical/* dependency ranges inside a scaffolded application's
+ * `my-app/package.json` — identically on every snapshot — before a byte
+ * comparison. The application generator resolves its range through each
+ * producer's OWN `npm view` call (no timeout, no shared cache), so an
+ * asymmetric registry outcome (one producer reaches npm and another does
+ * not, or a @canonical/* release lands between the calls) would turn
+ * `^0.34.0` vs `^0.33.0` across all 11 ranges into a red that says nothing
+ * about the code under test. The networked cases prove the TEMPLATE surface;
+ * range truth belongs to the offline cells, where the outcome is forced
+ * (`capabilities/create/shippedCreate.subprocess.test.ts`).
+ *
+ * The regex preserves the dependency KEY (`$1`), so a key-set or
+ * non-@canonical divergence still fails; only the range value collapses.
+ * Deliberately import-free — a pure string transform no module-graph guard
+ * can ever see.
+ *
+ * @param tree - A tree snapshot (relative path → contents).
+ * @param manifestPath - The scaffolded manifest's path within the tree.
+ * @returns A NEW map with the manifest's @canonical/* ranges blanked; the
+ *   input is untouched. A tree without the manifest comes back copied as-is.
+ */
+export function blankCanonicalRanges(
+  tree: ReadonlyMap<string, string>,
+  manifestPath = "my-app/package.json",
+): Map<string, string> {
+  const out = new Map(tree);
+  const manifest = out.get(manifestPath);
+  if (manifest !== undefined) {
+    out.set(
+      manifestPath,
+      manifest.replaceAll(/("@canonical\/[^"]+": )"[^"]+"/g, '$1"<range>"'),
+    );
+  }
+  return out;
+}