@canonical/pragma-cli 0.33.0 → 0.34.0

package/src/kernel/vocabulary.ts

@@ -0,0 +1,146 @@
+/**
+ * The domain vocabulary this distribution declares, validated once at load.
+ *
+ * The kernel reads a graph whose vocabulary it must not name. Two of its reads
+ * need domain terms: the pack index projects an alternative-name property into
+ * `altNames` (what a family is addressed by, hence what completes and what a
+ * lookup resolves), and the MCP prompt surface materializes prompt entities
+ * with a generated SELECT. Both take their terms from here, and the bundled
+ * capability packs that query the same terms read the same declaration — so
+ * complete and resolve cannot drift apart.
+ *
+ * A DISTRIBUTION DECLARATION, not a config layer field, and deliberately so.
+ * Both readers sit where the config layer is unreachable: the storeless
+ * `__complete` fast path builds a completion ref at module load, and the index
+ * is built inside the pack builder. Made layerable, a user setting it in their
+ * project config would change nothing anywhere — silence, which is the exact
+ * failure a dead config field is. A fork ships its own binary: it edits the
+ * declaration and rebuilds.
+ *
+ * Terms must be PREFIXED NAMES whose prefix the distribution BINDS, and
+ * {@link parseVocabulary} rejects anything else by name. They are interpolated
+ * into SPARQL, where an absolute IRI written bare is a parse error and an
+ * unbound prefix is either a parse error or a silently empty result — and a
+ * failed read is indistinguishable from an empty graph, which is how a
+ * malformed declaration would otherwise surface as "this distribution has no
+ * prompts". Both halves matter: rejecting the shape alone still lets a
+ * one-character typo (`ds:name` → `dss:name`) pass startup and then drop every
+ * `altNames` from the index while reporting a built store as unbuilt. Failing
+ * at module load is correct for a compiled-in build defect: the distribution
+ * config's own layer validation (`config/defaults.ts`) already throws the same
+ * way.
+ *
+ * Standard vocabulary (`rdfs:label`, `rdfs:comment`) is deliberately absent —
+ * it is the same in every graph, and the index already treats it as universal.
+ */
+
+import conf, { vocabulary } from "../../pragma.conf.js";
+import { PragmaError } from "./error/PragmaError.js";
+
+/** The domain terms the kernel reads a distribution's graph with. */
+export interface DeclaredVocabulary {
+  /**
+   * The property an entity family is addressed by, beside `rdfs:label` — the
+   * tokens the index offers as candidates and a bespoke lookup matches on.
+   */
+  readonly altName: string;
+  /** The prompt entity shape the MCP prompt surface reads. */
+  readonly prompt: {
+    /** The class every prompt entity carries. */
+    readonly type: string;
+    /** The template body, with `{{arg}}` placeholders. */
+    readonly body: string;
+    /** Links a prompt to one of its declared arguments. */
+    readonly argument: string;
+    /** An argument's name. */
+    readonly argName: string;
+    /** Whether an argument is required. */
+    readonly argRequired: string;
+  };
+}
+
+/** A prefixed name — `prefix:local`, the only form a generated query can read. */
+const PREFIXED_NAME = /^[A-Za-z][A-Za-z0-9_-]*:[A-Za-z_][A-Za-z0-9_.-]*$/;
+
+/**
+ * The distribution config file, quoted in the diagnostics.
+ *
+ * The literal, not `${BIN_NAME}.conf.ts`: the import above names this file, and
+ * so do four other modules, so a fork CANNOT rename it — deriving the name from
+ * the fork's would send its maintainer to a path that is not on disk.
+ * `config/defaults.ts` names the same file for the same reason.
+ */
+const CONF_FILE = "pragma.conf.ts";
+
+/**
+ * Hold one declared term to a form a generated query can actually read: the
+ * `prefix:local` shape, AND a prefix the distribution binds.
+ *
+ * @param field - The term's path in the declaration, for the message.
+ * @param term - The declared value.
+ * @param prefixes - The distribution's declared namespace bindings.
+ * @param source - The file the declaration was read from.
+ * @throws PragmaError CONFIG_ERROR when the term is not `prefix:local`, or
+ *   names a prefix `prefixes` does not bind.
+ */
+function assertReadableTerm(
+  field: string,
+  term: string,
+  prefixes: Readonly<Record<string, string>>,
+  source: string,
+): void {
+  const reject = (problem: string, fix: string): never => {
+    throw PragmaError.configError(
+      `Invalid vocabulary in ${source}: \`${field}\` ${problem}, not ${JSON.stringify(term)}.`,
+      { recovery: { message: `In ${source}, ${fix}` } },
+    );
+  };
+  if (!PREFIXED_NAME.test(term)) {
+    reject(
+      "must be a prefixed name like `ex:thing`",
+      `write \`${field}\` as \`<prefix>:<local>\`. These terms are interpolated into queries, which cannot read an absolute IRI here.`,
+    );
+  }
+  const prefix = term.slice(0, term.indexOf(":"));
+  if (!Object.hasOwn(prefixes, prefix)) {
+    reject(
+      `must use a prefix \`prefixes\` binds, and nothing binds \`${prefix}:\``,
+      `either bind \`${prefix}\` under \`prefixes\` or write \`${field}\` with a prefix that is bound. An unbound prefix makes the generated query fail, which a read cannot tell apart from an empty graph.`,
+    );
+  }
+}
+
+/**
+ * Validate a declared vocabulary.
+ *
+ * @param raw - A distribution's `vocabulary` export.
+ * @param prefixes - That distribution's `prefixes`, which must bind every
+ *   prefix the terms use.
+ * @param source - The file it was declared in, quoted in errors.
+ * @returns The same declaration, once every term is readable.
+ * @throws PragmaError CONFIG_ERROR naming the offending field and its value.
+ */
+export function parseVocabulary(
+  raw: DeclaredVocabulary,
+  prefixes: Readonly<Record<string, string>>,
+  source: string,
+): DeclaredVocabulary {
+  assertReadableTerm("altName", raw.altName, prefixes, source);
+  for (const [term, value] of Object.entries(raw.prompt)) {
+    assertReadableTerm(`prompt.${term}`, value, prefixes, source);
+  }
+  return raw;
+}
+
+/**
+ * This distribution's validated vocabulary.
+ *
+ * The declaration is type-checked at this call — a fork that drops or mistypes
+ * a term fails `tsc`, and one that writes an unreadable term fails here at
+ * startup rather than at the read that would have swallowed it.
+ */
+export const VOCABULARY = parseVocabulary(
+  vocabulary,
+  conf.prefixes ?? {},
+  CONF_FILE,
+);

package/src/testing/PARITY_GAPS.ts

@@ -78,13 +78,19 @@ export const PARITY_GAPS: readonly ParityGapEntry[] = [
     id: "generic-renderers-not-bespoke-templates",
     area: "render",
     description:
-      "Every noun's plain/llm output — including the one hand-written verb, `block list` — renders through the SAME generic list/lookup renderer (`kernel/render/renderers.ts`), driven by declarative column/field/section metadata. There are no per-noun hand-authored render templates left to keep in parity.",
+      "Every noun's plain/llm output renders through the SAME generic list/lookup renderer (`kernel/render/renderers.ts`), driven by declarative column/field/section metadata. There are no per-noun hand-authored render templates left to keep in parity (the last hand-written verb, `block list`, became declared content in L-OPEN-9).",
   },
   {
     id: "block-lookup-not-tier-scoped",
     area: "block",
     description:
-      "`block lookup` resolves by `ds:name` GLOBALLY, with no tier or channel filtering — only the hand-written `block list` is tier/channel-aware (PR3 Risk5, `capabilities/block/tierChain.ts`). A same-named block declared at two tiers cannot be disambiguated by `block lookup` alone (the old shell's tier-scoped lookup disambiguation has no v2 equivalent).",
+      "`block lookup` resolves by `ds:name` GLOBALLY, with no tier or channel filtering. A same-named block declared at two tiers cannot be disambiguated by plain name (the old shell's tier-scoped lookup disambiguation has no v2 equivalent) — address it by prefixed IRI instead. Since L-OPEN-9 NOTHING is tier/channel-aware: the hand-written, tier-chain-filtered `block list` was removed with its `tierChain.ts`.",
+  },
+  {
+    id: "block-list-unfiltered",
+    area: "block",
+    description:
+      "L-OPEN-9 (owner-signed): `block list` is the block story's compiled, UNFILTERED list — it shows every block, including experimental/alpha ones, for everyone, until filtering returns in declared form. The old tier-chain inheritance, channel visibility, and `--all-tiers` escape were hand-written filtering the pack grammar has no term for, and the ruling removed them rather than growing the grammar to keep them. `config.tier` consequently scopes nothing (reported by `config show`/`info` only); `config.channel` keeps only its npm dist-tag role for `upgrade`/`info`.",
   },
   {
     id: "graph-query-deferred",

package/src/testing/behavioral/README.md

@@ -40,7 +40,7 @@ the emitted set legitimately grows PR-by-PR.
 | `agentSession.mcp.test.ts` | A multi-step agent MCP session (list → pick → lookup) + the SPARQL escape hatch. |
 | `mcpSurface.test.ts` | Every MCP tool the live catalog exposes is callable and well-formed — the "surface ⊆ covenant, exercised" proof. |
 | `disclosure.test.ts` | The cross-noun disclosure sweep (mechanism itself is PR3's/kernel's protected unit test — this only sweeps the noun SET). |
-| `journeys.cli.test.ts` | The `block list` tier-chain/channel journey (the one hand-written verb). |
+| `journeys.cli.test.ts` | The `block list` journey — since L-OPEN-9 it pins that the declared list is UNFILTERED: four tier/channel configs, one answer. |
 | `completion.test.ts` | The THIN main-line `__complete` candidate contract (§6 — see "Completion" below). |
 
 Plus `testing/eval/` (the eval harness + seed cases) and `testing/PARITY_GAPS.ts`
@@ -71,7 +71,7 @@ import { CANONICAL_TTL, CANONICAL_CONFIG } from "../fixtures/graph/canonical.js"
 
 const fixture = await bootFixtureRuntime({ ttl: CANONICAL_TTL, config: CANONICAL_CONFIG });
 try {
-  // fixture.cwd carries a REAL pragma.lock.json — bootRuntime(flags, fixture.cwd),
+  // fixture.cwd is pointed at a REAL built pack — bootRuntime(flags, fixture.cwd),
   // executeVerb(...), projectMcp(modules, fixture.cwd), and (if you must)
   // runCli(args, { cwd: fixture.cwd }) all resolve the SAME cached pack.
 } finally {
@@ -80,7 +80,7 @@ try {
 ```
 
 Use `packRuntime.ts#buildFixtureRuntime` (PR3's helper) instead when you only
-need ONE surface (a direct `verb.run()` call) — it's cheaper (no lock file).
+need ONE surface (a direct `verb.run()` call) — it's cheaper (no real build).
 Reach for `bootFixtureRuntime` specifically when you need CLI and MCP (or a
 spawn) to agree on the same store.
 

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

@@ -4,7 +4,7 @@
  * The full completion engine (`kernel/completion`: parse → resolve → rank, the
  * spec-derived model, the entity seam) owns the unit-level guarantees; this
  * pins the behaviour end-to-end against the LIVE capabilities and — for the
- * entity tier — against a REAL built pack index on disk (the locked-pack branch
+ * entity tier — against a REAL built pack index on disk (the built-pack branch
  * of the storeless reader, which the engine's own tests exercise only via the
  * embedded fallback). Parameterized over the live read surface so noun/verb
  * renames never churn it.
@@ -89,21 +89,34 @@ describe("flags are kebab-cased at emission (the live, testable guarantee)", ()
   });
 });
 
-describe("entity params resolve from a real built pack index (B10)", () => {
-  it("a lookup's entity positional completes from the built pack index", async () => {
+describe("entity params resolve from the project's built pack, not the embedded snapshot (B10)", () => {
+  it("a lookup's entity positional offers the built pack's subjects and none of the snapshot's", async () => {
     const fixture = await bootFixtureRuntime({
       ttl: CANONICAL_TTL,
       config: ALL_VISIBLE_CONFIG,
     });
     try {
-      // The locked-pack branch of the storeless reader: a real index.json on
+      // The built-pack branch of the storeless reader: a real index.json on
       // disk under the fixture cwd, read without booting the store.
       const all = await runComplete(
         ["block", "lookup", ""],
         capabilities,
         indexCompletionEnv(fixture.cwd),
       );
-      expect(all.length).toBeGreaterThan(0);
+      // The four `ds:Component` subjects the canonical fixture declares
+      // (`blockGraph.ts`'s Button/Modal plus `canonical.ts`'s LXD Panel and
+      // Beta Widget) — the fixture's own data, not a recomputation. Stating
+      // the SET is what makes the distribution's own snapshot names provably
+      // absent: a pointer read that regressed to the embedded fallback would
+      // complete another graph's names while every read answered correctly,
+      // and the old `narrowed.length < all.length` heuristic only noticed by
+      // the accident that no snapshot name contains `ds:b`.
+      expect([...all].sort()).toEqual([
+        "ds:betaWidget",
+        "ds:button",
+        "ds:lxdPanel",
+        "ds:modal",
+      ]);
 
       const narrowed = await runComplete(
         ["block", "lookup", "ds:b"],
@@ -111,7 +124,7 @@ describe("entity params resolve from a real built pack index (B10)", () => {
         indexCompletionEnv(fixture.cwd),
       );
       // Every ranked candidate carries the partial (case-insensitive), and the
-      // filter is strictly narrowing — the index tier really ran.
+      // filter is strictly narrowing — the ranker really ran over this index.
       expect(
         narrowed.every((name) => name.toLowerCase().includes("ds:b")),
       ).toBe(true);

package/src/testing/behavioral/errorMatrix.mcp.test.ts

@@ -32,9 +32,10 @@ import { listVerbs, lookupVerbs } from "./liveReadSurface.js";
 
 /**
  * List verbs with a STRING or ENUM (narrowable, non-boolean) flag — e.g.
- * `standard_list --category`. Excludes boolean escape hatches like `block
- * list --all-tiers`, which reject a string value at the schema layer rather
- * than narrowing to an empty result.
+ * `standard_list --category`. Boolean flags are excluded: they reject a string
+ * value at the schema layer rather than narrowing to an empty result. (`block
+ * list --all-tiers` used to be the example; it retired with the hand-written
+ * filtering in L-OPEN-9.)
  */
 const filteredListVerbs = listVerbs
   .map((v) => {

package/src/testing/behavioral/errorMatrix.storeless.test.ts

@@ -61,7 +61,7 @@ const MATRIX: readonly {
   },
   {
     label: "recovery (mcp-only, no cli)",
-    error: PragmaError.storeUnavailable("no lock", {
+    error: PragmaError.storeUnavailable("the store has not been built", {
       recovery: { message: "Please report this issue." },
     }),
   },

package/src/testing/behavioral/exitCodes.e2e.test.ts

@@ -37,14 +37,15 @@ describe("exit-code covenant, spawn-observed (A4, e2e)", () => {
     expect(result.stderr).toContain('Invalid format "yaml"');
   });
 
-  it("3 — store unavailable (configured packages, never built)", () => {
+  it("3 — store unavailable (configured packs, never built)", () => {
     const cwd = mkdtempSync(join(tmpdir(), "pragma-exit3-"));
-    // A pragma.config.ts with custom `packages` flips `origins.packages` to
-    // "project" — with no `pragma.lock.json`, resolveSources refuses to boot
-    // (no network probing) rather than fall back to the embedded pack.
+    // A pragma.config.ts with custom `packs` flips `origins.packs` to
+    // "project" — with nothing built for this project, resolveSources refuses
+    // to boot (no network probing) rather than serve the embedded pack, which
+    // is a DIFFERENT graph from the one this project asked for.
     writeFileSync(
       join(cwd, "pragma.config.ts"),
-      'export default { packages: [{ name: "never-built", source: "file:///nonexistent" }] };\n',
+      'export default { packs: [{ name: "never-built", source: "file:///nonexistent" }] };\n',
     );
     const result = runCli(["block", "list"], { cwd });
     expect(result.exitCode).toBe(3);

package/src/testing/behavioral/harness.foundation.test.ts

@@ -2,8 +2,8 @@
  * Harness-foundation smoke tests (commit 1).
  *
  * Validates the framework pieces PR4 adds — NOT per-noun behavior (that's
- * commits 2/4's job). Proves: (1) `bootFixtureRuntime` boots a real,
- * lock-backed store that BOTH the CLI and MCP surfaces resolve identically
+ * commits 2/4's job). Proves: (1) `bootFixtureRuntime` boots a real, built-pack
+ * store that BOTH the CLI and MCP surfaces resolve identically
  * (via the shared canonical graph, one real lookup); (2) the compiler/runtime
  * is ontology-agnostic — a pack over the foreign `ex:` recipe namespace
  * registers its 2 tools and resolves on both surfaces; (3) `runCli` can spawn
@@ -12,7 +12,7 @@
 
 import { homedir, tmpdir } from "node:os";
 import { describe, expect, it } from "vitest";
-import { blockModule } from "../../capabilities/block/index.js";
+import { storyModules } from "../../capabilities/distribution.js";
 import { VERSION } from "../../constants.js";
 import { compilePack } from "../../kernel/packs/compile.js";
 import { verbKey } from "../../kernel/packs/uniqueness.js";
@@ -31,8 +31,13 @@ import { plain } from "../helpers/golden.js";
 import { assertCliMcpParity } from "../helpers/parity.js";
 import { runCli } from "../helpers/runCli.js";
 
+const blockModule = storyModules.get("block");
+if (!blockModule) {
+  throw new Error('pragma.conf.ts declares no story for "block"');
+}
+
 describe("bootFixtureRuntime — the shared canonical graph (commit-1 smoke)", () => {
-  it("boots a lock-backed store both CLI and MCP resolve identically", async () => {
+  it("boots a built-pack store both CLI and MCP resolve identically", async () => {
     const fixture = await bootFixtureRuntime({
       ttl: CANONICAL_TTL,
       config: CANONICAL_CONFIG,
@@ -68,7 +73,11 @@ describe("foreign-namespace generic-pack proof (compiler is DS-agnostic)", () =>
     try {
       const recipeModule: CapabilityModule = {
         name: "recipe",
-        verbs: compilePack(recipePack, "test:recipe", RECIPE_PREFIXES),
+        verbs: compilePack(
+          recipePack,
+          { label: "test:recipe", origin: "package" },
+          RECIPE_PREFIXES,
+        ),
       };
       expect(recipeModule.verbs.map((v) => verbKey(v.path)).sort()).toEqual([
         "recipe list",

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

@@ -1,6 +1,5 @@
 /**
- * B9 — the tier-chain / channel CLI journey (PR3 Risk5's ONE hand-written
- * verb, `block list`).
+ * B9 — the `block list` CLI journey, re-pinned on the DECLARED contract.
  *
  * BACKING ADAPTATION: the plan lists this as "fixture + spawn"; the PR4 quality
  * bar (R7 — keep the spawn-e2e layer to exactly A1-A4/A7) overrides that, so
@@ -9,42 +8,86 @@
  * against the fixture, rather than spawning. It still exercises the true CLI
  * seam (typed params -> dispatch -> render), just without forking a process.
  *
+ * CONTRACT CHANGE (L-OPEN-9): this journey used to enumerate four different
+ * answers — one per tier config, one per channel, one for `--all-tiers`. That
+ * hand-written filtering is gone; `block list` is the block story's compiled,
+ * UNFILTERED list. So the journey pins the honest NEW behaviour, which is a
+ * STRONGER claim than the old one: the SAME graph under FOUR different configs
+ * gives ONE answer, containing every block in the store. `config.tier` and
+ * `config.channel` no longer reach the query at all, and the owner-signed
+ * consequence — experimental/alpha blocks are visible to everyone — is asserted
+ * here rather than left to prose.
+ *
  * CONTENT ADAPTATION (R2 — verified against the live `block lookup`, not
  * assumed): the plan's wording describes an unscoped `block lookup` returning
  * multiple tier-disambiguated matches — that mechanism doesn't exist in v2
  * (`block lookup` resolves by name GLOBALLY with no tier awareness at all;
- * PARITY_GAPS `block-lookup-not-tier-scoped`). Only `block list` is
- * tier/channel-aware, so this journey is entirely about `block list` under
- * different tier configs on the SAME canonical graph.
+ * PARITY_GAPS `block-lookup-not-tier-scoped`). Since L-OPEN-9 neither block
+ * verb is tier-aware, so both halves of the noun now agree.
  */
 
 import { afterAll, describe, expect, it } from "vitest";
-import { blockModule } from "../../capabilities/block/index.js";
+import { storyModules } from "../../capabilities/distribution.js";
 import { verbKey } from "../../kernel/packs/uniqueness.js";
 import { executeVerb } from "../../kernel/project/cli/dispatch.js";
 import { bootRuntime } from "../../kernel/runtime/boot.js";
 import type { VerbSpec } from "../../kernel/spec/types.js";
 import {
+  ALL_VISIBLE_CONFIG,
   CANONICAL_CONFIG,
   CANONICAL_TTL,
+  FILTERED_CONFIG,
 } from "../fixtures/graph/canonical.js";
 import {
   bootFixtureRuntime,
   type FixtureGraph,
+  type FixtureGraphOptions,
 } from "../helpers/fixtureGraph.js";
 import { JSON_FLAGS, NO_MUTATION } from "../helpers/parity.js";
 
+const blockModule = storyModules.get("block");
+if (!blockModule) {
+  throw new Error('pragma.conf.ts declares no story for "block"');
+}
+
 const listVerb = blockModule.verbs.find(
   (v) => verbKey(v.path) === "block list",
 ) as VerbSpec;
 
-async function blockListNames(
-  fixture: FixtureGraph,
-  allTiers = false,
-): Promise<string[]> {
+/**
+ * Every block the canonical fixture carries: two global components, one scoped
+ * to `apps/lxd`, one gated to the `beta` release channel, and one UNTIERED
+ * subcomponent. Under the hand-written verb NO single invocation returned all
+ * five — the tier chain hid `LXD Panel`, the channel hid `Beta Widget`, and only
+ * `--all-tiers` revealed `Button Icon`. The declared list returns all five, and
+ * returns them whatever the config says.
+ */
+const EVERY_BLOCK = [
+  "Beta Widget",
+  "Button",
+  "Button Icon",
+  "LXD Panel",
+  "Modal",
+];
+
+const fixtures: FixtureGraph[] = [];
+afterAll(async () => {
+  await Promise.all(fixtures.map((f) => f.dispose()));
+});
+
+/** Boot a tracked canonical fixture under `config`, for auto-disposal. */
+async function bootWith(
+  config: FixtureGraphOptions["config"],
+): Promise<FixtureGraph> {
+  const fixture = await bootFixtureRuntime({ ttl: CANONICAL_TTL, config });
+  fixtures.push(fixture);
+  return fixture;
+}
+
+async function blockListNames(fixture: FixtureGraph): Promise<string[]> {
   const out = await executeVerb(
     listVerb,
-    { allTiers },
+    {},
     NO_MUTATION,
     bootRuntime(JSON_FLAGS, fixture.cwd),
   );
@@ -52,80 +95,78 @@ async function blockListNames(
   return rows.map((r) => r.name).sort();
 }
 
-const fixtures: FixtureGraph[] = [];
-afterAll(async () => {
-  await Promise.all(fixtures.map((f) => f.dispose()));
-});
+describe("block list — the declared, unfiltered list (B9, in-process CLI dispatch)", () => {
+  it("with no tier configured, lists every block in the store", async () => {
+    expect(await blockListNames(await bootWith(CANONICAL_CONFIG))).toEqual(
+      EVERY_BLOCK,
+    );
+  });
 
-describe("block list — tier-chain inheritance (B9, in-process CLI dispatch)", () => {
-  it("unscoped (no tier configured) sees every tier", async () => {
-    const fixture = await bootFixtureRuntime({
-      ttl: CANONICAL_TTL,
-      config: CANONICAL_CONFIG, // channel: normal, no tier set
-    });
-    fixtures.push(fixture);
-    // normal channel drops the beta-only block; no tier set -> every tier.
-    expect(await blockListNames(fixture)).toEqual([
-      "Button",
-      "LXD Panel",
-      "Modal",
-    ]);
+  it("a configured tier does NOT narrow the list — tier scopes nothing", async () => {
+    // The old verb answered ["Button", "Modal"] here: `global` excluded the
+    // apps/lxd block, and the required `ds:tier` join hid the untiered
+    // subcomponent. Nothing filters now, so the tier config is inert.
+    const fixture = await bootWith({ tier: "global", channel: "normal" });
+    expect(await blockListNames(fixture)).toEqual(EVERY_BLOCK);
   });
 
-  it("scoped to the global tier excludes the apps/lxd-only block", async () => {
-    const fixture = await bootFixtureRuntime({
-      ttl: CANONICAL_TTL,
-      config: { tier: "global", channel: "normal" },
-    });
-    fixtures.push(fixture);
-    expect(await blockListNames(fixture)).toEqual(["Button", "Modal"]);
+  it("the deepest tier in the chain gets the same answer as the shallowest", async () => {
+    // Tier-chain inheritance was the point of the hand-written query
+    // (`apps/lxd` -> [global, apps, apps/lxd]). With no filtering there is no
+    // chain to walk, so `apps/lxd` and `global` are indistinguishable.
+    expect(await blockListNames(await bootWith(FILTERED_CONFIG))).toEqual(
+      EVERY_BLOCK,
+    );
   });
+});
 
-  it("scoped to apps/lxd includes its OWN block plus the inherited chain", async () => {
-    const fixture = await bootFixtureRuntime({
-      ttl: CANONICAL_TTL,
-      config: { tier: "apps/lxd", channel: "normal" },
-    });
-    fixtures.push(fixture);
-    // resolveTierChain("apps/lxd") = [global, apps, apps/lxd] — Button/Modal
-    // (global) are inherited; LXD Panel is the tier's own block.
-    expect(await blockListNames(fixture)).toEqual([
-      "Button",
-      "LXD Panel",
-      "Modal",
-    ]);
+describe("block list — channel visibility is gone too (B9)", () => {
+  it("the `normal` channel shows the beta-gated block — the signed-off consequence", async () => {
+    // `ds:betaWidget` carries `ds:release ds:beta`. The hand-written verb hid it
+    // from every channel but `prerelease`; the declared list shows it to
+    // everyone. This is the owner-signed visible consequence of L-OPEN-9,
+    // pinned so it stays a decision on record rather than a silent regression.
+    const names = await blockListNames(await bootWith(CANONICAL_CONFIG));
+    expect(names).toContain("Beta Widget");
   });
 
-  it("--all-tiers ignores a configured tier scope", async () => {
-    const fixture = await bootFixtureRuntime({
-      ttl: CANONICAL_TTL,
-      config: { tier: "global", channel: "normal" },
-    });
-    fixtures.push(fixture);
-    // Scoped (no flag) excludes LXD Panel; --all-tiers restores it AND reveals
-    // the untiered Button Icon subcomponent the scoped view omits (A2).
-    expect(await blockListNames(fixture, false)).toEqual(["Button", "Modal"]);
-    expect(await blockListNames(fixture, true)).toEqual([
-      "Button",
-      "Button Icon",
-      "LXD Panel",
-      "Modal",
-    ]);
+  it("`prerelease` — once the only config that saw everything — is now unremarkable", async () => {
+    expect(await blockListNames(await bootWith(ALL_VISIBLE_CONFIG))).toEqual(
+      EVERY_BLOCK,
+    );
   });
 });
 
-describe("block list — channel visibility (B9)", () => {
-  it("prerelease channel is the one config where all 4 components list", async () => {
-    const fixture = await bootFixtureRuntime({
-      ttl: CANONICAL_TTL,
-      config: { channel: "prerelease" },
-    });
-    fixtures.push(fixture);
-    expect(await blockListNames(fixture)).toEqual([
-      "Beta Widget",
-      "Button",
-      "LXD Panel",
-      "Modal",
+describe("block list — the row shape the declared columns emit (B9)", () => {
+  it("derives name/type/tier in SPARQL, and leaves an untiered block's tier unset", async () => {
+    const fixture = await bootWith(CANONICAL_CONFIG);
+    const out = await executeVerb(
+      listVerb,
+      {},
+      NO_MUTATION,
+      bootRuntime(JSON_FLAGS, fixture.cwd),
+    );
+    const rows = JSON.parse(out.stdout as string).data as {
+      name: string;
+      type?: string;
+      tier?: string;
+      uri: string;
+      modifiers?: string;
+    }[];
+    const byName = new Map(rows.map((row) => [row.name, row]));
+
+    // `type` is the LOWERCASED local name of the matched class — the BIND that
+    // replaced the hand-written `normalizeType`.
+    expect(byName.get("Button")?.type).toBe("component");
+    expect(byName.get("Button Icon")?.type).toBe("subcomponent");
+    // `tier` is the tier IRI's local name; an untiered block simply has none.
+    expect(byName.get("Button")?.tier).toBe("global");
+    expect(byName.get("Button Icon")?.tier).toBeUndefined();
+    expect(byName.get("Button")?.uri).toBe("https://ds.canonical.com/button");
+    // GROUP_CONCAT of the modifier family names (order-independent).
+    expect(byName.get("Button")?.modifiers?.split(", ").sort()).toEqual([
+      "density",
+      "importance",
     ]);
   });
 });