@canonical/pragma-cli 0.36.0 → 0.38.0

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

@@ -55,48 +55,52 @@ afterAll(async () => {
 });
 
 describe("agent session — list, pick, lookup (B1)", () => {
-  it.each(
-    browsableNouns,
-  )("%s: list -> pick first -> lookup resolves it", async (noun) => {
-    const list = await mcp.callTool(`${noun}_list`);
-    expect(list.ok).toBe(true);
-    const rows = list.data as { name: string }[];
-    expect(rows.length).toBeGreaterThan(0);
-    const first = rows[0] as { name: string };
+  it.each(browsableNouns)(
+    "%s: list -> pick first -> lookup resolves it",
+    async (noun) => {
+      const list = await mcp.callTool(`${noun}_list`);
+      expect(list.ok).toBe(true);
+      const rows = list.data as { name: string }[];
+      expect(rows.length).toBeGreaterThan(0);
+      const first = rows[0] as { name: string };
 
-    const lookup = await mcp.callTool(`${noun}_lookup`, { name: [first.name] });
-    expect(lookup.ok).toBe(true);
-    const data = lookup.data as {
-      results: { name: string }[];
-      errors: unknown[];
-    };
-    expect(data.errors).toEqual([]);
-    expect(data.results[0]?.name).toBe(first.name);
-  });
+      const lookup = await mcp.callTool(`${noun}_lookup`, {
+        name: [first.name],
+      });
+      expect(lookup.ok).toBe(true);
+      const data = lookup.data as {
+        results: { name: string }[];
+        errors: unknown[];
+      };
+      expect(data.errors).toEqual([]);
+      expect(data.results[0]?.name).toBe(first.name);
+    },
+  );
 
-  it.each(
-    browsableNouns,
-  )("%s: a BATCH lookup with one hit reports the miss without failing the call", async (noun) => {
-    // `makeLookupRun` (kernel/packs/runBodies.ts) throws on a TOTAL miss (see
-    // the errorMatrix.mcp.test.ts B3 suite) — a partial batch is the "miss
-    // reported, call not failed" shape (an ADAPTATION of the plan's B1/B3
-    // wording, which described a single-name miss; verified against the
-    // live behavior).
-    const list = await mcp.callTool(`${noun}_list`);
-    const rows = list.data as { name: string }[];
-    const known = (rows[0] as { name: string }).name;
+  it.each(browsableNouns)(
+    "%s: a BATCH lookup with one hit reports the miss without failing the call",
+    async (noun) => {
+      // `makeLookupRun` (kernel/packs/runBodies.ts) throws on a TOTAL miss (see
+      // the errorMatrix.mcp.test.ts B3 suite) — a partial batch is the "miss
+      // reported, call not failed" shape (an ADAPTATION of the plan's B1/B3
+      // wording, which described a single-name miss; verified against the
+      // live behavior).
+      const list = await mcp.callTool(`${noun}_list`);
+      const rows = list.data as { name: string }[];
+      const known = (rows[0] as { name: string }).name;
 
-    const result = await mcp.callTool(`${noun}_lookup`, {
-      name: [known, "zzz-definitely-not-a-real-entity"],
-    });
-    expect(result.ok).toBe(true);
-    const data = result.data as {
-      results: { name: string }[];
-      errors: { code: string }[];
-    };
-    expect(data.results[0]?.name).toBe(known);
-    expect(data.errors[0]?.code).toBe("ENTITY_NOT_FOUND");
-  });
+      const result = await mcp.callTool(`${noun}_lookup`, {
+        name: [known, "zzz-definitely-not-a-real-entity"],
+      });
+      expect(result.ok).toBe(true);
+      const data = result.data as {
+        results: { name: string }[];
+        errors: { code: string }[];
+      };
+      expect(data.results[0]?.name).toBe(known);
+      expect(data.errors[0]?.code).toBe("ENTITY_NOT_FOUND");
+    },
+  );
 });
 
 describe("agent session — the categories journey, if the live surface declares one (B1)", () => {

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

@@ -65,12 +65,13 @@ describe("verb-level candidates: the SET matches the live surface", () => {
     expect(multiVerbNouns.length).toBeGreaterThan(0);
   });
 
-  it.each(
-    multiVerbNouns,
-  )("%s: candidates == its live verb set", async (noun, verbs) => {
-    const candidates = await runComplete([noun, ""], capabilities);
-    expect([...candidates].sort()).toEqual([...verbs].sort());
-  });
+  it.each(multiVerbNouns)(
+    "%s: candidates == its live verb set",
+    async (noun, verbs) => {
+      const candidates = await runComplete([noun, ""], capabilities);
+      expect([...candidates].sort()).toEqual([...verbs].sort());
+    },
+  );
 });
 
 describe("flags are kebab-cased at emission (the live, testable guarantee)", () => {

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

@@ -69,47 +69,49 @@ describe("disclosure lookups declare the aligned canonical level set (B4)", () =
   // the full `[summary, standard, detailed]`, so a config `detail=standard` named
   // a level block never advertised. Every disclosure lookup now declares the same
   // canonical ladder; per-noun DEFAULTS may still differ (domain-tuned).
-  it.each(
-    disclosureLookupVerbs,
-  )("$noun: levels === the canonical ladder", (v) => {
-    expect(v.spec.disclosure?.levels).toEqual([...DETAIL_LEVELS]);
-  });
+  it.each(disclosureLookupVerbs)(
+    "$noun: levels === the canonical ladder",
+    (v) => {
+      expect(v.spec.disclosure?.levels).toEqual([...DETAIL_LEVELS]);
+    },
+  );
 });
 
 describe("detail:summary vs detail:detailed — key-set growth (B6)", () => {
-  it.each(
-    disclosureLookupVerbs,
-  )("%s_lookup: detailed carries every summary key plus at least one more", async (v) => {
-    const noun = v.noun;
-    const list = await mcp.callTool(`${noun}_list`);
-    const rows = list.data as { name: string }[];
-    const name = rows[0]?.name;
-    expect(name).toBeDefined();
-    if (!name) return;
+  it.each(disclosureLookupVerbs)(
+    "%s_lookup: detailed carries every summary key plus at least one more",
+    async (v) => {
+      const noun = v.noun;
+      const list = await mcp.callTool(`${noun}_list`);
+      const rows = list.data as { name: string }[];
+      const name = rows[0]?.name;
+      expect(name).toBeDefined();
+      if (!name) return;
 
-    const summary = await mcp.callTool(`${noun}_lookup`, {
-      name: [name],
-      detail: "summary",
-    });
-    const detailed = await mcp.callTool(`${noun}_lookup`, {
-      name: [name],
-      detail: "detailed",
-    });
-    expect(summary.ok).toBe(true);
-    expect(detailed.ok).toBe(true);
+      const summary = await mcp.callTool(`${noun}_lookup`, {
+        name: [name],
+        detail: "summary",
+      });
+      const detailed = await mcp.callTool(`${noun}_lookup`, {
+        name: [name],
+        detail: "detailed",
+      });
+      expect(summary.ok).toBe(true);
+      expect(detailed.ok).toBe(true);
 
-    const summaryEntity = (
-      summary.data as { results: Record<string, unknown>[] }
-    ).results[0] as Record<string, unknown>;
-    const detailedEntity = (
-      detailed.data as { results: Record<string, unknown>[] }
-    ).results[0] as Record<string, unknown>;
+      const summaryEntity = (
+        summary.data as { results: Record<string, unknown>[] }
+      ).results[0] as Record<string, unknown>;
+      const detailedEntity = (
+        detailed.data as { results: Record<string, unknown>[] }
+      ).results[0] as Record<string, unknown>;
 
-    const summaryKeys = new Set(Object.keys(summaryEntity));
-    const detailedKeys = new Set(Object.keys(detailedEntity));
-    for (const key of summaryKeys) {
-      expect(detailedKeys.has(key)).toBe(true);
-    }
-    expect(detailedKeys.size).toBeGreaterThan(summaryKeys.size);
-  });
+      const summaryKeys = new Set(Object.keys(summaryEntity));
+      const detailedKeys = new Set(Object.keys(detailedEntity));
+      for (const key of summaryKeys) {
+        expect(detailedKeys.has(key)).toBe(true);
+      }
+      expect(detailedKeys.size).toBeGreaterThan(summaryKeys.size);
+    },
+  );
 });

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

@@ -25,6 +25,7 @@
 
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { capabilities } from "../../capabilities/index.js";
+import { RESERVED_STORY_PARAMS } from "../../kernel/packs/types.js";
 import {
   ALL_VISIBLE_CONFIG,
   CANONICAL_TTL,
@@ -37,16 +38,25 @@ import { projectMcp } from "../helpers/projectMcp.js";
 import { listVerbs, lookupVerbs } from "./liveReadSurface.js";
 
 /**
- * List verbs with a STRING or ENUM (narrowable, non-boolean) flag — e.g.
- * `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.)
+ * List verbs with a STRING or ENUM (narrowable, non-boolean) flag the STORY
+ * itself declares — e.g. `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.)
+ *
+ * The kernel's own params are excluded by name, from the grammar's own list.
+ * Without that, every list verb qualified the day the kernel gave them all an
+ * `--after` cursor, and four unfiltered nouns were swept for a narrowing
+ * behaviour they do not have — the assertions failed on a param that is not a
+ * filter at all.
  */
 const filteredListVerbs = listVerbs
   .map((v) => {
     const flag = v.spec.params.find(
-      (p) => !p.positional && (p.kind === "string" || p.kind === "enum"),
+      (p) =>
+        !p.positional &&
+        (p.kind === "string" || p.kind === "enum") &&
+        !RESERVED_STORY_PARAMS.includes(p.name),
     );
     return flag
       ? { noun: v.noun, tool: v.tool as string, param: flag.name }
@@ -73,25 +83,27 @@ afterAll(async () => {
 });
 
 describe("lookup miss — total miss fails the call (B3, adapted)", () => {
-  it.each(
-    lookupVerbs.map((v) => v.noun),
-  )("%s_lookup: a single unknown name fails with ENTITY_NOT_FOUND", async (noun) => {
-    const result = await mcp.callTool(`${noun}_lookup`, {
-      name: ["zzz-definitely-not-a-real-entity"],
-    });
-    expect(result.ok).toBe(false);
-    expect((result.error as { code: string }).code).toBe("ENTITY_NOT_FOUND");
-  });
+  it.each(lookupVerbs.map((v) => v.noun))(
+    "%s_lookup: a single unknown name fails with ENTITY_NOT_FOUND",
+    async (noun) => {
+      const result = await mcp.callTool(`${noun}_lookup`, {
+        name: ["zzz-definitely-not-a-real-entity"],
+      });
+      expect(result.ok).toBe(false);
+      expect((result.error as { code: string }).code).toBe("ENTITY_NOT_FOUND");
+    },
+  );
 
-  it.each(
-    lookupVerbs.map((v) => v.noun),
-  )("%s_lookup: an all-unknown batch ALSO fails (not a partial report)", async (noun) => {
-    const result = await mcp.callTool(`${noun}_lookup`, {
-      name: ["zzz-nope-one", "zzz-nope-two"],
-    });
-    expect(result.ok).toBe(false);
-    expect((result.error as { code: string }).code).toBe("ENTITY_NOT_FOUND");
-  });
+  it.each(lookupVerbs.map((v) => v.noun))(
+    "%s_lookup: an all-unknown batch ALSO fails (not a partial report)",
+    async (noun) => {
+      const result = await mcp.callTool(`${noun}_lookup`, {
+        name: ["zzz-nope-one", "zzz-nope-two"],
+      });
+      expect(result.ok).toBe(false);
+      expect((result.error as { code: string }).code).toBe("ENTITY_NOT_FOUND");
+    },
+  );
 });
 
 /**
@@ -116,45 +128,43 @@ describe("list — a filter value the graph does not carry is INVALID_INPUT (B3,
     expect(filteredListVerbs.length).toBeGreaterThan(0);
   });
 
-  it.each(
-    filteredListVerbs,
-  )("$tool: an unobserved filter value is rejected, naming the observed ones", async ({
-    tool,
-    param,
-  }) => {
-    const result = await mcp.callTool(tool, {
-      [param]: "zzz-definitely-not-a-real-value",
-    });
-    expect(result.ok).toBe(false);
-    const error = result.error as { code: string; validOptions?: string[] };
-    expect(error.code).toBe("INVALID_INPUT");
-    expect(error.validOptions?.length).toBeGreaterThan(0);
-    expect(error.validOptions).not.toContain("zzz-definitely-not-a-real-value");
-  });
+  it.each(filteredListVerbs)(
+    "$tool: an unobserved filter value is rejected, naming the observed ones",
+    async ({ tool, param }) => {
+      const result = await mcp.callTool(tool, {
+        [param]: "zzz-definitely-not-a-real-value",
+      });
+      expect(result.ok).toBe(false);
+      const error = result.error as { code: string; validOptions?: string[] };
+      expect(error.code).toBe("INVALID_INPUT");
+      expect(error.validOptions?.length).toBeGreaterThan(0);
+      expect(error.validOptions).not.toContain(
+        "zzz-definitely-not-a-real-value",
+      );
+    },
+  );
 
-  it.each(
-    filteredListVerbs,
-  )("$tool: every value the graph DOES carry narrows to a calm list", async ({
-    tool,
-    param,
-  }) => {
-    const rejected = await mcp.callTool(tool, { [param]: "zzz-nope" });
-    const admissible = (rejected.error as { validOptions: string[] })
-      .validOptions;
-    expect(admissible.length).toBeGreaterThan(0);
-    // EVERY admissible value is accepted, and at least one is populated. Not
-    // "the first one returns rows": the vocabulary is the graph's, so it can
-    // legitimately contain a value no row carries (a category with zero
-    // standards) — that value is a calm empty list, not a rejection, and the
-    // sweep would otherwise read a real answer as a failure.
-    let populated = 0;
-    for (const value of admissible) {
-      const result = await mcp.callTool(tool, { [param]: value });
-      expect(result.ok).toBe(true);
-      if ((result.data as unknown[]).length > 0) populated += 1;
-    }
-    expect(populated).toBeGreaterThan(0);
-  });
+  it.each(filteredListVerbs)(
+    "$tool: every value the graph DOES carry narrows to a calm list",
+    async ({ tool, param }) => {
+      const rejected = await mcp.callTool(tool, { [param]: "zzz-nope" });
+      const admissible = (rejected.error as { validOptions: string[] })
+        .validOptions;
+      expect(admissible.length).toBeGreaterThan(0);
+      // EVERY admissible value is accepted, and at least one is populated. Not
+      // "the first one returns rows": the vocabulary is the graph's, so it can
+      // legitimately contain a value no row carries (a category with zero
+      // standards) — that value is a calm empty list, not a rejection, and the
+      // sweep would otherwise read a real answer as a failure.
+      let populated = 0;
+      for (const value of admissible) {
+        const result = await mcp.callTool(tool, { [param]: value });
+        expect(result.ok).toBe(true);
+        if ((result.data as unknown[]).length > 0) populated += 1;
+      }
+      expect(populated).toBeGreaterThan(0);
+    },
+  );
 
   it("standard_list: a declared category with NO standards is a calm empty list", async () => {
     // The case that separates "the graph is the vocabulary" from "the returned
@@ -202,14 +212,22 @@ describe("empty ≠ silence on the machine surfaces", () => {
     // an agent received `{"ok":true,"data":[],"meta":{}}` and nothing else. The
     // search path is the honest way to reach an empty list without a bad
     // argument.
+    //
+    // The guidance leads with the question that was actually answered — the
+    // SEARCH that matched nothing, in the caller's own spelling — and the
+    // story's `emptyRecovery` follows it, as it does on an unfiltered empty
+    // answer. Leading with the recovery instead was the defect: `sources
+    // update` told a reader with a populated store to rebuild it.
     const result = await mcp.callTool("standard_list", {
       search: "zzz-nothing-matches-this",
     });
     expect(result.ok).toBe(true);
     expect(result.data).toEqual([]);
     const notice = (result.meta as { notice?: string }).notice ?? "";
-    expect(notice).toContain("No standard entries found.");
-    expect(notice).toContain("pragma standard categories");
+    expect(notice).toContain(
+      "No standard matches `--search zzz-nothing-matches-this`.",
+    );
+    expect(notice).toContain("Category slugs come from the graph");
   });
 });
 

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

@@ -96,16 +96,17 @@ describe("error/recovery matrix — render shapes (A8, storeless)", () => {
     }
   });
 
-  it.each(MATRIX)("json renders the failure envelope for $label", ({
-    error,
-  }) => {
-    const envelope = JSON.parse(renderErrorJson(error)) as {
-      ok: boolean;
-      error: { code: string };
-    };
-    expect(envelope.ok).toBe(false);
-    expect(envelope.error.code).toBe(error.code);
-  });
+  it.each(MATRIX)(
+    "json renders the failure envelope for $label",
+    ({ error }) => {
+      const envelope = JSON.parse(renderErrorJson(error)) as {
+        ok: boolean;
+        error: { code: string };
+      };
+      expect(envelope.ok).toBe(false);
+      expect(envelope.error.code).toBe(error.code);
+    },
+  );
 });
 
 describe("error/recovery matrix — grounded in a real spawn (A8, e2e)", () => {

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

@@ -8,22 +8,29 @@
  * 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.
+ * CONTRACT CHANGE, TWICE, and this journey is where both are legible. It used
+ * to enumerate four answers — one per tier config, one per channel, one for
+ * `--all-tiers` — from hand-written filtering. That went, and the journey then
+ * pinned ONE answer under every config, because neither `config.tier` nor
+ * `config.channel` reached the query at all.
  *
- * 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`). Since L-OPEN-9 neither block
- * verb is tier-aware, so both halves of the noun now agree.
+ * The TIER SCOPE brings back exactly one of those two, in declared form: the
+ * `block` story declares the tier hierarchy, so `config.tier` and a per-call
+ * `--tier` decide which tiers the list answers from — unset is the top-level
+ * tiers, a tier is its own chain, `all` is the unfiltered list this journey used
+ * to pin. `config.channel` still reaches nothing, and the owner-signed
+ * consequence of that — experimental/alpha blocks are visible to everyone — is
+ * still asserted here rather than left to prose.
+ *
+ * So there are several answers again, and that is the improvement: each one
+ * states the scope it used, and one argument widens it.
+ *
+ * BOTH HALVES OF THE NOUN AGREE, as they have to: `block lookup` reads the same
+ * declared hierarchy, so the tier that decides which blocks this list shows is
+ * the tier that decides which Button a bare name means. The lookup's own half
+ * of that — it PREFERS the scope and falls back rather than refusing — is
+ * asserted in `kernel/packs/tierScope.test.ts` and, on the shipped pack's real
+ * tiers, in `capabilities/block.tierRank.exec.test.ts`.
  */
 
 import { afterAll, describe, expect, it } from "vitest";
@@ -70,6 +77,16 @@ const EVERY_BLOCK = [
   "Modal",
 ];
 
+/**
+ * What the DEFAULT tier scope answers with: the top-level tiers (`global` and
+ * `apps`), so `LXD Panel` — two levels down, in `apps/lxd` — is out.
+ *
+ * `Button Icon` is IN, and that is the half worth stating twice: it carries no
+ * tier, and an entity the scope cannot PLACE is not an entity the scope hides.
+ * The hand-written verb's required tier join is what used to hide it.
+ */
+const TOP_LEVEL_BLOCKS = ["Beta Widget", "Button", "Button Icon", "Modal"];
+
 const fixtures: FixtureGraph[] = [];
 afterAll(async () => {
   await Promise.all(fixtures.map((f) => f.dispose()));
@@ -84,10 +101,13 @@ async function bootWith(
   return fixture;
 }
 
-async function blockListNames(fixture: FixtureGraph): Promise<string[]> {
+async function blockListNames(
+  fixture: FixtureGraph,
+  params: Record<string, unknown> = {},
+): Promise<string[]> {
   const out = await executeVerb(
     listVerb,
-    {},
+    params,
     NO_MUTATION,
     bootRuntime(JSON_FLAGS, fixture.cwd),
   );
@@ -95,27 +115,43 @@ async function blockListNames(fixture: FixtureGraph): Promise<string[]> {
   return rows.map((r) => r.name).sort();
 }
 
-describe("block list — the declared, unfiltered list (B9, in-process CLI dispatch)", () => {
-  it("with no tier configured, lists every block in the store", async () => {
+describe("block list — the declared, tier-scoped list (B9, in-process CLI dispatch)", () => {
+  it("with no tier configured, answers from the top-level tiers", async () => {
     expect(await blockListNames(await bootWith(CANONICAL_CONFIG))).toEqual(
-      EVERY_BLOCK,
+      TOP_LEVEL_BLOCKS,
     );
   });
 
-  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.
+  it("a configured tier narrows the list to its own chain", async () => {
+    // `global` is the base and has nothing above it, so its chain is itself.
+    // The apps/lxd block is out — and the UNTIERED subcomponent is not.
     const fixture = await bootWith({ tier: "global", channel: "normal" });
-    expect(await blockListNames(fixture)).toEqual(EVERY_BLOCK);
+    expect(await blockListNames(fixture)).toEqual(TOP_LEVEL_BLOCKS);
+  });
+
+  it("the deepest tier in the chain sees MORE than the shallowest", async () => {
+    // Tier-chain inheritance was the point of the hand-written query, and it is
+    // the point again: `apps/lxd` -> [global, apps, apps/lxd], so the deepest
+    // tier answers with its own block AND everything it inherits. That is why
+    // the scope is the chain and not the single tier.
+    const names = await blockListNames(await bootWith(FILTERED_CONFIG));
+    expect(names).toEqual(EVERY_BLOCK);
+    expect(names).toContain("LXD Panel");
+  });
+
+  it("every tier on request is the unfiltered list this journey used to pin", async () => {
+    // The escape, and the proof that the scope removes nothing from the store:
+    // one argument, and every tier answers again.
+    const fixture = await bootWith(CANONICAL_CONFIG);
+    expect(await blockListNames(fixture, { tier: "all" })).toEqual(EVERY_BLOCK);
   });
 
-  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("a per-call tier replaces the configured one", async () => {
+    // Precedence, at the seam a reader meets it: the machine is set to the deep
+    // tier, the call asks for the base, and the call wins.
+    const fixture = await bootWith(FILTERED_CONFIG);
+    expect(await blockListNames(fixture, { tier: "global" })).toEqual(
+      TOP_LEVEL_BLOCKS,
     );
   });
 });
@@ -131,8 +167,11 @@ describe("block list — channel visibility is gone too (B9)", () => {
   });
 
   it("`prerelease` — once the only config that saw everything — is now unremarkable", async () => {
+    // Both configs set no tier, so both answer from the top-level tiers: the
+    // channel changes nothing, which is the claim. What narrows these rows is
+    // the tier scope, and it narrows them identically.
     expect(await blockListNames(await bootWith(ALL_VISIBLE_CONFIG))).toEqual(
-      EVERY_BLOCK,
+      TOP_LEVEL_BLOCKS,
     );
   });
 });

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

@@ -168,10 +168,12 @@ describe("default-pack journey — sources update, build, boot (E1)", () => {
       expect(outcome.exitCode).toBe(0);
       expect(readActivePack(cwd)).toMatch(/^[0-9a-f]{64}$/);
       // A SEPARATE, fresh runtime boots the just-built pack from the pointer and
-      // answers a read over it. Since L-OPEN-9 the list is unfiltered, so the
-      // cold-boot read returns the pack's WHOLE block set — the beta-gated Beta
-      // Badge and the untiered Orphan Widget included. That makes this the
-      // strictest form of the assert (an exact set, not a tolerant subset).
+      // answers a read over it. The cold-boot read returns the pack's WHOLE
+      // block set — the beta-gated Beta Badge (no channel filters) and the
+      // untiered Orphan Widget (no scope hides an entity it cannot place)
+      // included, and every tier this fixture declares is top-level, so the
+      // tier scope admits the rest. That makes this the strictest form of the
+      // assert (an exact set, not a tolerant subset).
       expect(await blockListNames(cwd)).toEqual([
         "Beta Badge",
         "Button",