@canonical/pragma-cli 0.33.0 → 0.34.0

package/src/testing/behavioral/journeys.packageStories.test.ts

@@ -0,0 +1,188 @@
+/**
+ * The package tier, end to end: a noun the binary never shipped.
+ *
+ * A package that ships `stories/*.json` and is declared as a `file:` pack
+ * contributes a working command to a project that declares it — resolved by
+ * `sources update`, hashed into the pack, written into the pack directory, read
+ * back storelessly at dispatch, and answered from the fixture graph. Proven both
+ * in-process and through the COMPILED binary in a real subprocess.
+ *
+ * The same package also ships a malformed story and a schema-invalid one. Those
+ * must be DROPPED, not fatal: package stories reach dispatch before the command
+ * tree exists, so a throw there fails every command — including `sources update`
+ * and `doctor`, the only two that can recover from it. Both of those are run
+ * here after the bad stories are in the pack.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { runTask } from "@canonical/task/node";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { runChecks } from "../../capabilities/doctor/runChecks.js";
+import { capabilities } from "../../capabilities/index.js";
+import { buildUpdateTask } from "../../capabilities/sources/runUpdate.js";
+import { loadEffectiveModules } from "../../kernel/packs/collect.js";
+import { packDir, readActivePack } from "../../kernel/runtime/paths.js";
+import type { VerbSpec } from "../../kernel/spec/types.js";
+import {
+  bootFixtureRuntime,
+  type FixtureGraph,
+} from "../helpers/fixtureGraph.js";
+import { runCli } from "../helpers/runCli.js";
+
+const TTL = `
+@prefix ex: <https://example.org/kitchen#> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+ex:Recipe a owl:Class .
+ex:name a owl:DatatypeProperty ; rdfs:domain ex:Recipe ; rdfs:range xsd:string .
+
+ex:soup a ex:Recipe ; ex:name "Soup" .
+ex:stew a ex:Recipe ; ex:name "Stew" .
+`;
+
+/** A valid read story — the noun the binary never shipped. */
+const RECIPE_STORY = JSON.stringify({
+  noun: "recipe",
+  description: "List recipes.",
+  colophon: "Recipes are modelled as ex:Recipe individuals.",
+  list: {
+    query:
+      "SELECT ?uri ?name WHERE { ?uri a ex:Recipe ; ex:name ?name } ORDER BY ?name",
+    columns: [{ field: "uri" }, { field: "name" }],
+  },
+});
+
+/** Schema-invalid: a well-formed JSON document the pack grammar rejects. */
+const INVALID_STORY = JSON.stringify({ noun: "Bad Noun", list: {} });
+
+let graph: FixtureGraph;
+beforeAll(async () => {
+  graph = await bootFixtureRuntime({
+    ttl: TTL,
+    stories: {
+      "recipe.json": RECIPE_STORY,
+      // Not JSON at all.
+      "broken.json": "{ this is not json",
+      "invalid.json": INVALID_STORY,
+    },
+  });
+}, 60_000);
+afterAll(async () => {
+  await graph.dispose();
+});
+
+describe("a package's stories reach the pack", () => {
+  it("sources update carries all three story files into the pack, verbatim", () => {
+    const hash = readActivePack(graph.cwd);
+    expect(hash).toBeDefined();
+    const carried = JSON.parse(
+      readFileSync(join(packDir(hash as string), "stories.json"), "utf-8"),
+    ) as { source: string; content: string }[];
+    expect(carried.map((record) => record.source)).toEqual([
+      "fixture/stories/broken.json",
+      "fixture/stories/invalid.json",
+      "fixture/stories/recipe.json",
+    ]);
+    expect(
+      carried.find((r) => r.source === "fixture/stories/recipe.json")?.content,
+    ).toBe(RECIPE_STORY);
+  });
+});
+
+describe("a package-declared noun answers reads (in-process)", () => {
+  it("recipe list returns rows from the package's own graph", async () => {
+    const { modules } = await loadEffectiveModules(capabilities, graph.cwd);
+    const recipe = modules.find((module) => module.name === "recipe");
+    expect(recipe?.story).toBe(true);
+    expect(recipe?.colophon).toBe(
+      "Recipes are modelled as ex:Recipe individuals.",
+    );
+    const list = recipe?.verbs.find(
+      (verb) => verb.path.join(" ") === "recipe list",
+    ) as VerbSpec;
+    const rows = (await list.run({}, graph.runtime)) as { name: string }[];
+    expect(rows.map((row) => row.name)).toEqual(["Soup", "Stew"]);
+  });
+
+  it("names the unusable stories without failing the load", async () => {
+    const { problems } = await loadEffectiveModules(capabilities, graph.cwd);
+    expect(problems.map((problem) => problem.source).sort()).toEqual([
+      "fixture/stories/broken.json",
+      "fixture/stories/invalid.json",
+    ]);
+    // Each says WHY, not just that something was wrong.
+    const invalid = problems.find((p) => p.source.endsWith("invalid.json"));
+    expect(invalid?.message).toMatch(/Invalid story/);
+  });
+});
+
+describe("the two recoveries still run with bad stories in the pack", () => {
+  it("sources update re-resolves and reports the carried story count", async () => {
+    const result = await runTask(await buildUpdateTask(graph.runtime));
+    expect(result.packs).toEqual([
+      {
+        name: "fixture",
+        resolved: expect.any(String),
+        sourceCount: 1,
+        storyCount: 3,
+      },
+    ]);
+  });
+
+  it("doctor passes `pack refs` and lists each ignored story as a failing item", async () => {
+    const data = await runChecks(graph.runtime);
+    const check = data.checks.find((entry) => entry.name === "pack refs");
+    // The pack DOES answer reads, so the check passes…
+    expect(check?.status).toBe("pass");
+    expect(check?.detail).toContain("2 stories ignored");
+    // …with the unusable stories named underneath it.
+    expect(check?.items?.map((item) => item.label).sort()).toEqual([
+      "fixture/stories/broken.json",
+      "fixture/stories/invalid.json",
+    ]);
+    for (const item of check?.items ?? []) expect(item.status).toBe("fail");
+  });
+});
+
+describe("the compiled binary answers the package's noun (subprocess)", () => {
+  it("pragma recipe list --format json returns the package's rows", () => {
+    const result = runCli(["recipe", "list", "--format", "json"], {
+      cwd: graph.cwd,
+    });
+    expect(result.exitCode).toBe(0);
+    const rows = (JSON.parse(result.stdout) as { data: { name: string }[] })
+      .data;
+    expect(rows.map((row) => row.name)).toEqual(["Soup", "Stew"]);
+    // The bad stories are named on stderr, never on stdout — `--format json`
+    // stays machine-readable.
+    expect(result.stderr).toContain("fixture/stories/broken.json");
+    expect(result.stderr).toContain("fixture/stories/invalid.json");
+  });
+
+  it("pragma capabilities lists the package's tools — the surface agents read", () => {
+    // The MCP server registers its tools from the effective modules, so a
+    // catalog built from the STATIC registry would omit exactly the nouns
+    // `tools/list` advertises. `config show` points agents here for the verbs a
+    // story produces; that pointer has to be true.
+    const result = runCli(["capabilities", "--format", "json"], {
+      cwd: graph.cwd,
+    });
+    expect(result.exitCode).toBe(0);
+    const { data } = JSON.parse(result.stdout) as {
+      data: { tools: { name: string }[] };
+    };
+    expect(data.tools.map((tool) => tool.name)).toContain("recipe_list");
+  });
+
+  it("pragma --help does NOT list recipe — the documented fast-path limit", () => {
+    // `--help` reads the STATIC capability set (no config, no pack read), which
+    // is what keeps its budget. A package-declared noun is dispatch-only.
+    const help = runCli(["--help"], { cwd: graph.cwd });
+    expect(help.exitCode).toBe(0);
+    expect(help.stdout).not.toContain("recipe");
+    // …and the command it does not advertise still runs (asserted above).
+  });
+});

package/src/testing/behavioral/liveReadSurface.ts

@@ -61,9 +61,10 @@ export const liveVerbs: readonly LiveVerb[] = buildLiveVerbs();
 /**
  * Read nouns' `lookup` verbs, MCP-exposed, store-backed — restricted to the
  * PACK-lookup contract (a variadic `<name...>` positional), which the B-tier
- * list→lookup→batch suites drive uniformly. Bespoke single-name lookups
- * (`tier_lookup`, `prompt_lookup`) have their own tests, so they are excluded
- * here structurally (by param shape, not by naming the noun — R2).
+ * list→lookup→batch suites drive uniformly. The one bespoke single-name lookup
+ * left (`prompt_lookup`) has its own tests, so it is excluded here structurally
+ * (by param shape, not by naming the noun — R2). `tier_lookup` joined the pack
+ * contract in L-OPEN-9, so it is swept here like every other declared lookup.
  */
 export const lookupVerbs: readonly LiveVerb[] = liveVerbs.filter(
   (v) =>

package/src/testing/behavioral/mcpSurface.test.ts

@@ -21,6 +21,8 @@
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { capabilities } from "../../capabilities/index.js";
 import { readPackIndex } from "../../kernel/completion/entitySource.js";
+import type { PackIndex } from "../../kernel/runtime/graphpack/types.js";
+import { resolveSources } from "../../kernel/runtime/resolveSources.js";
 import {
   ALL_VISIBLE_CONFIG,
   CANONICAL_TTL,
@@ -41,6 +43,8 @@ let mcp: Awaited<ReturnType<typeof projectMcp>>;
 let firstNameByNoun: Map<string, string>;
 /** The registered tool list, fetched once (annotations are call-invariant). */
 let registeredTools: Awaited<ReturnType<typeof mcp.listTools>>;
+/** The index of the pack the fixture's boot decision names. */
+let activeIndex: PackIndex | undefined;
 
 beforeAll(async () => {
   fixture = await bootFixtureRuntime({
@@ -49,6 +53,9 @@ beforeAll(async () => {
   });
   mcp = await projectMcp(capabilities, fixture.cwd);
   registeredTools = await mcp.listTools();
+  activeIndex = readPackIndex(
+    resolveSources(await fixture.runtime.loadConfig(), fixture.cwd),
+  );
 
   firstNameByNoun = new Map();
   for (const v of listVerbs) {
@@ -81,15 +88,13 @@ function representativeValue(
   param: LiveVerb["spec"]["params"][number],
 ): unknown {
   if (param.name === "prefix") {
-    const prefix = Object.keys(readPackIndex(fixture.cwd)?.prefixes ?? {}).find(
+    const prefix = Object.keys(activeIndex?.prefixes ?? {}).find(
       (p) => p !== "owl" && p !== "rdfs" && p !== "rdf" && p !== "xsd",
     );
     return prefix ?? "ds";
   }
   if (param.name === "uri") {
-    const entity = readPackIndex(fixture.cwd)?.entities.find(
-      (e) => e.box === "abox",
-    );
+    const entity = activeIndex?.entities.find((e) => e.box === "abox");
     return entity?.prefixed ?? entity?.name ?? "";
   }
   // An enum positional (e.g. `config set <key>`) must

package/src/testing/behavioral/staleCommands.test.ts

@@ -51,6 +51,16 @@ const BANNED: readonly BannedPattern[] = [
     reason:
       "retired `--llm` flag (now the `--format llm` form, auto-detected when piped)",
   },
+  {
+    pattern: /--all-tiers\b/,
+    reason:
+      "retired `--all-tiers` flag (L-OPEN-9: `block list` is the declared, unfiltered story — there is no tier filter to escape)",
+  },
+  {
+    pattern: /\btoken[ _]add-config\b/,
+    reason:
+      "removed `token add-config` command / `token_add-config` tool (L-OPEN-9: a mutation the declared read grammar has no verb for)",
+  },
 ];
 
 // Every shipped doc must be free of retired vocabulary: the README plus every

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

@@ -170,18 +170,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 +194,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/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`

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

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