@canonical/pragma-cli 0.33.0 → 0.34.0

package/src/testing/helpers/fixtureGraph.ts

@@ -1,6 +1,6 @@
 /**
  * Test helper: boot a store-backed {@link PragmaRuntime} at a REAL `cwd` whose
- * `pragma.lock.json` points at a built fixture pack.
+ * active-pack pointer names a built fixture pack.
  *
  * This is distinct from (and complements) `packRuntime.ts#buildFixtureRuntime`:
  * that helper hands back an in-process runtime wired to a custom `LazyStore`,
@@ -8,14 +8,18 @@
  * generalizes the `runtimeFor` + `buildUpdateTask` pattern proven in
  * `capabilities/sources/sources.test.ts`: it writes an actual
  * `pragma.config.ts` + package directory, runs the REAL `sources update` Task
- * (resolve → build → lock), and returns a `cwd`. Because the lock is a real
- * file, EVERY independent runtime construction that resolves config from that
+ * (resolve → build → point), and returns a `cwd`. Because the pointer is a
+ * real file, EVERY independent runtime construction that resolves config from that
  * `cwd` — `bootRuntime(flags, cwd)` (CLI dispatch), `projectMcp(modules, cwd)`
  * (MCP), and `runCli(args, { cwd })` (spawn) — boots the SAME cached pack. That
  * is the property PR4's cross-surface parity tests need and PR3's single-surface
  * parity tests did not: proof that CLI-json and MCP-json agree over a graph
  * built the same way `sources update` builds one for a real project.
  *
+ * A fixture package may also ship `stories/*.json` (the `stories` option), which
+ * `sources update` carries into the built pack — that is the package tier a
+ * third-party noun arrives through.
+ *
  * Hermetic: the pack cache lives under the isolated `$XDG_CACHE_HOME`
  * `setupXdgIsolation` installs; `dispose()` removes the temp directories (the
  * shared content-addressed pack cache itself is left for reuse/cleanup by the
@@ -30,7 +34,7 @@ import { buildUpdateTask } from "../../capabilities/sources/runUpdate.js";
 import { VERSION } from "../../constants.js";
 import type {
   ConfigLayers,
-  PackageEntry,
+  PackDeclaration,
   PragmaConfig,
 } from "../../kernel/config/types.js";
 import { bootRuntime } from "../../kernel/runtime/boot.js";
@@ -52,34 +56,39 @@ export interface FixtureGraphOptions {
   readonly ttl: string;
   /**
    * Config fields to bake into the written `pragma.config.ts`, e.g.
-   * `{ tier: "apps/lxd", channel: "prerelease" }`. `packages` is always set by
+   * `{ tier: "apps/lxd", channel: "prerelease" }`. `packs` is always set by
    * this helper (to the fixture package) — do not override it here.
    */
-  readonly config?: Omit<Partial<PragmaConfig>, "packages">;
+  readonly config?: Omit<Partial<PragmaConfig>, "packs">;
+  /**
+   * `stories/*.json` the fixture PACKAGE ships, as raw text keyed by file name
+   * — deliberately raw, so a test can ship malformed or schema-invalid content
+   * and assert that it is dropped rather than fatal.
+   */
+  readonly stories?: Readonly<Record<string, string>>;
 }
 
 /** A booted fixture runtime plus its `cwd` (usable by any surface) and disposal. */
 export interface FixtureGraph {
   /** A REAL `bootRuntime` at {@link cwd} — the same one CLI dispatch uses. */
   readonly runtime: PragmaRuntime;
-  /** The project directory whose `pragma.lock.json`/`pragma.config.ts` were written. */
+  /** The project directory whose `pragma.config.ts` + active-pack pointer were written. */
   readonly cwd: string;
   /** Remove the temp directories and dispose the store session, if booted. */
   dispose(): Promise<void>;
 }
 
 /** A synthetic runtime with an IN-MEMORY config — used only to drive the build Task. */
-function builderRuntime(cwd: string, packages: PackageEntry[]): PragmaRuntime {
+function builderRuntime(cwd: string, packs: PackDeclaration[]): PragmaRuntime {
   const layers: ConfigLayers = {
-    config: { channel: "normal", packages },
+    config: { channel: "normal", packs },
     origins: {
       tier: "default",
       channel: "default",
       detail: "default",
-      packages: "project",
+      packs: "project",
       stories: "default",
       prefixes: "default",
-      prompts: "default",
     },
     global: { path: "/nonexistent", exists: false },
     project: { exists: false },
@@ -102,8 +111,9 @@ function configField(key: string, value: unknown): string {
 }
 
 /**
- * Build a store-backed runtime whose `cwd` carries a real lock file — the ONE
- * shared store-backed fixture path for cross-surface (CLI/MCP/spawn) tests.
+ * Build a store-backed runtime whose `cwd` is pointed at a real built pack —
+ * the ONE shared store-backed fixture path for cross-surface (CLI/MCP/spawn)
+ * tests.
  *
  * @param options - The fixture graph TTL and any config overrides.
  * @returns The runtime, its cwd, and a disposer.
@@ -116,11 +126,18 @@ export async function bootFixtureRuntime(
   const pkgDir = mkdtempSync(join(tmpdir(), "pragma-fixture-pkg-"));
   mkdirSync(join(pkgDir, "definitions"), { recursive: true });
   writeFileSync(join(pkgDir, "definitions", "fixture.ttl"), options.ttl);
+  const stories = Object.entries(options.stories ?? {});
+  if (stories.length > 0) {
+    mkdirSync(join(pkgDir, "stories"), { recursive: true });
+    for (const [file, content] of stories) {
+      writeFileSync(join(pkgDir, "stories", file), content);
+    }
+  }
 
-  const packages: PackageEntry[] = [
+  const packs: PackDeclaration[] = [
     { name: "fixture", source: `file://${pkgDir}` },
   ];
-  const fields = [configField("packages", packages)];
+  const fields = [configField("packs", packs)];
   for (const [key, value] of Object.entries(options.config ?? {})) {
     fields.push(configField(key, value));
   }
@@ -129,7 +146,7 @@ export async function bootFixtureRuntime(
     `export default {\n${fields.join("\n")}\n};\n`,
   );
 
-  await runTask(await buildUpdateTask(builderRuntime(cwd, packages), false));
+  await runTask(await buildUpdateTask(builderRuntime(cwd, packs)));
 
   const runtime = bootRuntime(FIXTURE_FLAGS, cwd);
 

package/src/testing/helpers/packRuntime.ts

@@ -36,7 +36,7 @@ export interface FixtureRuntimeOptions {
   /** Explicit `--detail` level for this invocation. */
   readonly detail?: DetailLevel;
   /** Config `detail` value and its origin (drives {@link resolvePackDetail}). */
-  readonly configDetail?: string;
+  readonly configDetail?: DetailLevel;
   /** Origin of the config `detail` (default `"default"`). */
   readonly detailOrigin?: ConfigOrigin;
 }
@@ -93,10 +93,9 @@ export async function buildFixtureRuntime(
       tier: "default",
       channel: "default",
       detail: options.detailOrigin ?? "default",
-      packages: "default",
+      packs: "default",
       stories: "default",
       prefixes: "default",
-      prompts: "default",
     },
     global: { path: "", exists: false },
     project: { exists: false },

package/src/testing/helpers/projectCli.ts

@@ -7,6 +7,7 @@
  */
 
 import type { Command } from "commander";
+import { BIN_NAME } from "../../constants.js";
 import { buildProgram } from "../../kernel/project/cli/buildProgram.js";
 import type { GlobalFlags } from "../../kernel/runtime/types.js";
 import type { CapabilityModule, VerbSpec } from "../../kernel/spec/types.js";
@@ -31,5 +32,5 @@ export function projectCli(
   globalFlags: GlobalFlags = TEST_FLAGS,
 ): Command {
   const verbs: VerbSpec[] = modules.flatMap((module) => [...module.verbs]);
-  return buildProgram(verbs, { globalFlags, programName: "pragma" });
+  return buildProgram(verbs, { globalFlags, programName: BIN_NAME });
 }

package/src/testing/helpers/projectMcp.ts

@@ -42,6 +42,8 @@ export interface McpHarness {
   completeResource(partial: string): Promise<string[]>;
   /** The server capabilities negotiated at initialize (tools/resources/prompts). */
   serverCapabilities(): ServerCapabilities | undefined;
+  /** The `serverInfo` the server introduced itself with at initialize. */
+  serverInfo(): { name: string; version: string } | undefined;
   /** The server `instructions` string sent at initialize. */
   instructions(): string | undefined;
   /** List the native MCP prompts (`prompts/list`). */
@@ -120,6 +122,10 @@ export async function projectMcp(
     serverCapabilities() {
       return client.getServerCapabilities();
     },
+    serverInfo() {
+      const info = client.getServerVersion();
+      return info ? { name: info.name, version: info.version } : undefined;
+    },
     instructions() {
       return client.getInstructions();
     },

package/src/testing/perf/budgets.test.ts

@@ -96,6 +96,10 @@ describe("perf budgets (PROTECTED)", () => {
     // __store-probe boots the embedded pack from its n-quads cache and queries
     // it — the full store-backed verb cost in the compiled binary. The first
     // spawn materializes the pack; warmups absorb it, then it is a cache hit.
+    // Note that with 9 kept samples a nearest-rank p95 IS the maximum (see
+    // BUDGETS.md's p95-stabilization section) — deliberately kept, because the
+    // honest statistic here is the one that catches real cost, and the ceiling
+    // is sized with a 1.25× margin over a projected p95 to absorb it.
     const result = measureCommand(BINARY, ["__store-probe"], {
       runs: 12,
       warmups: 3,

package/src/testing/perf/budgets.ts

@@ -4,9 +4,12 @@
  * The ceilings the protected budget tests assert against. The surface
  * covenant's designed target for `--help`/`__complete` is 50 ms; the day-1 perf
  * spike (commit 6) found that unrealistic on the build hardware (cold Bun
- * process start alone is ~45 ms here), so — per the plan — each ceiling is set
- * to roughly 2× the measured median rather than silently weakening the target.
- * Measured numbers and environment are recorded in BUDGETS.md.
+ * process start alone is ~45 ms here), so — per the plan — those ceilings are
+ * set to roughly 2× the measured median rather than silently weakening the
+ * target. {@link BUDGET_WARM_STORE_MS} is derived differently (from a projected
+ * p95, and it lands TIGHTER than 2× its median); its arithmetic is written out
+ * in full in BUDGETS.md, as are the measurements and environment for all of
+ * them.
  */
 
 /** `pragma --help` ceiling (ms). Designed 50; measured median ~61 → 2×. */
@@ -20,11 +23,23 @@ export const BUDGET_PROJECT_CONFIG_MS = 10;
 
 /**
  * Warm store-backed verb ceiling (ms) — a store boot from the cached n-quads
- * dump plus a query, in the compiled binary. The designed 300 ms holds: the
- * measured median (`__store-probe`) is ~150 ms here, so 300 is already ~2× the
- * measured median and needs no relaxation (see BUDGETS.md).
+ * dump plus a query, in the compiled binary.
+ *
+ * Re-derived when the embed became the distribution's real 8 479-triple graph
+ * instead of a 23-triple sample. Netted against a `--version` control from the
+ * SAME binary in the SAME run (this box's process start swings 60–287 ms with
+ * page-cache state alone), the real pack's store work is 2.83× the sample's —
+ * the median of five repetitions across two protocols. Projected onto the
+ * reference box, whose own toy store work is 147 − 45.5 = 101.5 ms: 45.5 +
+ * 101.5 × 2.83 ≈ 333 ms median, and 333 × (176/147) ≈ 398 ms p95 using the
+ * reference box's own dispersion for this command. `ceil(398 × 1.25 / 50) × 50`
+ * = 500 — which is 1.6× the projected median, i.e. tighter than the
+ * 2×-of-median rule the ceilings above use. Every input, every step, and the
+ * raw measurements are in BUDGETS.md; the designed `<300ms` target stays in the
+ * surface covenant, exactly as the 50 ms `help` target survived its 130 ms
+ * ceiling.
  */
-export const BUDGET_WARM_STORE_MS = 300;
+export const BUDGET_WARM_STORE_MS = 500;
 
 /**
  * Warm in-process MCP tool-call ceiling (ms) — PR7 graduates this from seeded to

package/src/testing/perf/globalSetup.ts

@@ -1,24 +1,139 @@
 /**
  * Vitest global setup: build the compiled `dist/pragma` once, before the suite,
- * if it is missing.
+ * if it is missing OR older than the sources it was built from.
  *
  * Shared by both configs, because two suites spawn the binary: the perf budgets
  * (src/testing/perf/**, `test:perf`) and the storeless-guarantee guards in
  * src/kernel/completion/safety.test.ts (the main `test:vitest` pass). Wiring it
  * into both means `bun run test` on a clean checkout provisions the binary with
  * no manual build step — neither suite may assume it is pre-built.
+ *
+ * STALENESS, not mere existence. `existsSync` alone meant every spawned-binary
+ * guard ran against whatever binary happened to be on disk: a mutation to
+ * `bin.ts` making the storeless `__complete` path write to `$HOME` and boot the
+ * store — precisely what `safety.test.ts` is PROTECTED to forbid — was live
+ * when run from source and invisible through the gate. The guard whose own
+ * docblock warns that an unreachable bundle "would leave the whole suite green"
+ * was itself green against a binary that predated the change under test.
+ *
+ * STALENESS INCLUDES THE EMBEDDED WORKSPACE DEPS. The binary bundles every
+ * `@canonical/*` workspace package it (transitively) imports — task, summon-*,
+ * ke, … — so an edit to `packages/runtime/task` is a change to what
+ * `dist/pragma` runs, yet this package's own `src` never moves. The gate
+ * therefore also watches each workspace-linked dependency (found by following
+ * the `node_modules/<name>` symlinks, transitively) — its `src` (the authored
+ * source), `dist` (what the bundler actually embeds, per the dep's export map)
+ * and `package.json`. Registry deps resolve into a `node_modules` store path
+ * and are skipped: their content only changes with a lockfile change, which
+ * `bun install` surfaces as a fresh symlink mtime anyway. Content hashing of
+ * the build inputs was considered and DECLINED (PR7 ruling R5): an mtime
+ * comparison is a handful of stats, needs no state file to compare against,
+ * and the failure mode of a false "stale" is one redundant 10 s build — while
+ * hashing every input on every suite start costs more than the rebuild it
+ * avoids. CI is fresh-checkout either way; this gate exists for developer
+ * boxes that have built before.
  */
 
 import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { lstatSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { join, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
+/** Everything the compiled binary is built FROM, relative to the package root. */
+const INPUTS = ["src", "scripts", "pragma.conf.ts", "package.json"];
+
+/**
+ * What feeds the binary inside one workspace dependency: its authored source,
+ * the compiled output the bundler embeds, and its manifest. Deliberately NOT
+ * the whole package dir — that would watch `coverage/` and `node_modules/`,
+ * whose mtimes move on every test run and would force a rebuild loop.
+ */
+const DEP_INPUTS = ["src", "dist", "package.json"];
+
+/**
+ * The newest modification time under `path`, or 0 when it does not exist.
+ * A nested `node_modules` is never descended into (a dep's own deps are
+ * enumerated as roots of their own by {@link workspaceDepRoots}).
+ *
+ * @param path - A file or directory.
+ * @returns Epoch milliseconds of the newest entry beneath it.
+ * @note Impure — stats the source tree.
+ */
+function newestMtime(path: string): number {
+  let stats: ReturnType<typeof statSync>;
+  try {
+    stats = statSync(path);
+  } catch {
+    return 0;
+  }
+  if (!stats.isDirectory()) return stats.mtimeMs;
+  let newest = stats.mtimeMs;
+  for (const entry of readdirSync(path)) {
+    if (entry === "node_modules") continue;
+    newest = Math.max(newest, newestMtime(join(path, entry)));
+  }
+  return newest;
+}
+
+/**
+ * Every workspace package the binary can embed, transitively: follow each
+ * `node_modules/<name>` symlink whose target lives OUTSIDE any `node_modules`
+ * store (that is what distinguishes a workspace link from a registry install),
+ * then repeat from the target's own `node_modules`. Cycles are cut by the
+ * visited set.
+ *
+ * @param pkgRoot - This package's root directory.
+ * @returns Absolute real paths of the linked workspace dependency roots.
+ * @note Impure — reads `node_modules` link farms.
+ */
+function workspaceDepRoots(pkgRoot: string): string[] {
+  const visited = new Set<string>([realpathSync(pkgRoot)]);
+  const queue = [realpathSync(pkgRoot)];
+  while (queue.length > 0) {
+    const dir = queue.pop() as string;
+    const nm = join(dir, "node_modules");
+    let entries: string[];
+    try {
+      entries = readdirSync(nm);
+    } catch {
+      continue;
+    }
+    const links = entries.flatMap((entry) => {
+      if (!entry.startsWith("@")) return [join(nm, entry)];
+      try {
+        return readdirSync(join(nm, entry)).map((e) => join(nm, entry, e));
+      } catch {
+        return [];
+      }
+    });
+    for (const link of links) {
+      let real: string;
+      try {
+        if (!lstatSync(link).isSymbolicLink()) continue;
+        real = realpathSync(link);
+      } catch {
+        continue;
+      }
+      if (real.split(sep).includes("node_modules")) continue;
+      if (visited.has(real)) continue;
+      visited.add(real);
+      queue.push(real);
+    }
+  }
+  const root = realpathSync(pkgRoot);
+  return [...visited].filter((dir) => dir !== root);
+}
+
 export default function setup(): void {
   const root = fileURLToPath(new URL("../../../", import.meta.url));
-  const binary = fileURLToPath(
-    new URL("../../../dist/pragma", import.meta.url),
-  );
-  if (existsSync(binary)) return;
+  const built = newestMtime(join(root, "dist", "pragma"));
+  const fresh =
+    built > 0 &&
+    INPUTS.every((input) => newestMtime(join(root, input)) < built) &&
+    workspaceDepRoots(root).every((dep) =>
+      DEP_INPUTS.every((input) => newestMtime(join(dep, input)) < built),
+    );
+  if (fresh) return;
 
   const result = spawnSync("bun", ["run", "scripts/build.ts"], {
     cwd: root,

package/src/types.ts

@@ -12,8 +12,8 @@ export type { DetailLevel, OutputFormat } from "./constants.js";
 // — Config authoring ————————————————————————————————————————————————————————
 export type {
   Channel,
-  PackageDeclaration,
-  PackageEntry,
+  PackDeclaration,
+  PackSource,
   PragmaConfig,
 } from "./kernel/config/types.js";
 // — Error model —————————————————————————————————————————————————————————————

package/src/capabilities/block/blockList.test.ts

@@ -1,79 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { verbKey } from "../../kernel/packs/uniqueness.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-import type { VerbSpec } from "../../kernel/spec/types.js";
-import { OWL_EXPORT_TTL } from "../../testing/fixtures/graph/owlExport.js";
-import { bootFixtureRuntime } from "../../testing/helpers/fixtureGraph.js";
-import type { BlockRow } from "./blockList.verb.js";
-import { blockModule } from "./index.js";
-
-const listVerb = blockModule.verbs.find(
-  (verb) => verbKey(verb.path) === "block list",
-) as VerbSpec;
-
-const names = (rows: BlockRow[]): string[] =>
-  rows.map((row) => row.name).sort();
-
-/**
- * The OWL-export fixture ships an UNTIERED `ds:Component` (`ds:datePicker`, no
- * `ds:tier`) beside a tiered one (`ds:button`). The pre-fix `block list` gated
- * on a REQUIRED `ds:tier` triple pattern, so `--all-tiers` — which drops the
- * FILTER but not the pattern — still hid the untiered block, contradicting the
- * flag's promise to show every block (A2). A tier-scoped view legitimately
- * omits an untiered block (it joins the list through its tier); `--all-tiers`
- * is the escape that reveals it.
- */
-describe("block list — untiered blocks under --all-tiers (A2)", () => {
-  describe("no tier configured", () => {
-    let runtime: PragmaRuntime;
-    let dispose: () => Promise<void>;
-
-    beforeAll(async () => {
-      const fixture = await bootFixtureRuntime({ ttl: OWL_EXPORT_TTL });
-      runtime = fixture.runtime;
-      dispose = fixture.dispose;
-    });
-    afterAll(() => dispose());
-
-    it("the default view still omits the untiered block", async () => {
-      const rows = (await listVerb.run({}, runtime)) as BlockRow[];
-      expect(names(rows)).toEqual(["Button"]);
-    });
-
-    it("--all-tiers reveals the untiered block", async () => {
-      const rows = (await listVerb.run(
-        { allTiers: true },
-        runtime,
-      )) as BlockRow[];
-      expect(names(rows)).toEqual(["Button", "Date Picker"]);
-    });
-  });
-
-  describe("a tier IS configured", () => {
-    let runtime: PragmaRuntime;
-    let dispose: () => Promise<void>;
-
-    beforeAll(async () => {
-      const fixture = await bootFixtureRuntime({
-        ttl: OWL_EXPORT_TTL,
-        config: { tier: "global", channel: "normal" },
-      });
-      runtime = fixture.runtime;
-      dispose = fixture.dispose;
-    });
-    afterAll(() => dispose());
-
-    it("a scoped tier lists its tiered block, not the untiered one", async () => {
-      const rows = (await listVerb.run({}, runtime)) as BlockRow[];
-      expect(names(rows)).toEqual(["Button"]);
-    });
-
-    it("--all-tiers overrides the scope and reveals the untiered block", async () => {
-      const rows = (await listVerb.run(
-        { allTiers: true },
-        runtime,
-      )) as BlockRow[];
-      expect(names(rows)).toContain("Date Picker");
-    });
-  });
-});

package/src/capabilities/block/blockList.verb.ts

@@ -1,163 +0,0 @@
-/**
- * `block list` — the ONE hand-written read (Risk5).
- *
- * A block list is config-filtered in ways packs cannot express declaratively:
- * the tier CHAIN (a tier makes its whole parent chain visible), the channel
- * (release-level visibility), and the `--all-tiers` escape. Everything else in
- * PR3 is a declarative pack; this verb ports that behaviour directly. It reads
- * the effective tier/channel from config and runs one generated SELECT (no user
- * input in the query — the tier is config, the channel a closed enum).
- */
-
-import { runSelect } from "../../kernel/packs/sparql/runSelect.js";
-import type {
-  ColumnDef,
-  RenderListOptions,
-} from "../../kernel/render/contracts.js";
-import { DEFAULT_PREFIX_MAP } from "../../kernel/render/prefixes.js";
-import {
-  renderListLlm,
-  renderListPlain,
-} from "../../kernel/render/renderers.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { Formatters, VerbSpec } from "../../kernel/spec/types.js";
-import { buildChannelFilter, buildTierFilter } from "./tierChain.js";
-
-/** One block summary row. */
-export interface BlockRow {
-  readonly uri: string;
-  readonly name: string;
-  readonly type: string;
-  readonly tier: string;
-  readonly modifiers: string;
-}
-
-/** Local name of an IRI (`…/global` → `global`; `…#Thing` → `Thing`). */
-function localName(uri: string): string {
-  const hash = uri.lastIndexOf("#");
-  if (hash !== -1) return uri.slice(hash + 1);
-  const slash = uri.lastIndexOf("/");
-  return slash !== -1 ? uri.slice(slash + 1) : uri;
-}
-
-/** Normalize a block's rdf:type to one of the four block kinds. */
-function normalizeType(typeUri: string | undefined): BlockRow["type"] {
-  const local = localName(typeUri ?? "").toLowerCase();
-  return local === "pattern" || local === "layout" || local === "subcomponent"
-    ? local
-    : "component";
-}
-
-const listColumns: ColumnDef<BlockRow>[] = [
-  { key: "name", label: "Name" },
-  { key: "type", label: "Type" },
-  { key: "tier", label: "Tier" },
-  { key: "modifiers", label: "Modifiers", showWhenEmpty: false },
-  { key: "uri", label: "IRI" },
-];
-
-const listOptions: RenderListOptions<BlockRow> = {
-  heading: "Blocks",
-  columns: listColumns,
-  prefixes: DEFAULT_PREFIX_MAP,
-  // Zero blocks is a calm success (exit 0), not an error — the list is scoped by
-  // the active tier chain and channel, so the message names that scope and the
-  // hint offers the escape hatches (a cold store fails earlier with
-  // STORE_UNAVAILABLE, so reaching here means the store is built).
-  emptyMessage: "No blocks found under the current tier and channel.",
-  emptyHint:
-    "Use --all-tiers to ignore the tier filter, or run `pragma sources update` if the store is empty.",
-};
-
-const listFormatters: Formatters<BlockRow[]> = {
-  plain: (rows) => renderListPlain(rows, listOptions),
-  llm: (rows) => renderListLlm(rows, listOptions),
-  json: (rows) => JSON.stringify(rows, null, 2),
-};
-
-/** Build the config-filtered block SELECT for the resolved tier/channel. */
-function buildQuery(
-  tier: string | undefined,
-  channel: import("../../kernel/config/types.js").Channel,
-  allTiers: boolean,
-): string {
-  const tierFilter = allTiers ? "" : buildTierFilter(tier);
-  const channelFilter = buildChannelFilter(channel);
-  // Under --all-tiers, `ds:name`/`ds:tier` become OPTIONAL so a real block that
-  // ships without either is no longer hidden — the flag promises "all blocks",
-  // yet the pre-fix query gated on those as REQUIRED patterns, dropping the
-  // FILTER but not the pattern (A2). In the scoped/default view they stay
-  // required: a block joins the list through its tier, so an untiered block is
-  // intentionally out of a tier-scoped view (and --all-tiers is the escape).
-  const nameTierPatterns = allTiers
-    ? [
-        "  OPTIONAL { ?component ds:name ?name }",
-        "  OPTIONAL { ?component ds:tier ?tier }",
-      ]
-    : ["  ?component ds:name ?name ; ds:tier ?tier ."];
-  return [
-    "SELECT ?component ?type ?name ?tier",
-    '       (GROUP_CONCAT(DISTINCT ?modName; separator=", ") AS ?modifiers)',
-    "WHERE {",
-    "  VALUES ?type { ds:Component ds:Pattern ds:Layout ds:Subcomponent }",
-    "  ?component a ?type .",
-    ...nameTierPatterns,
-    tierFilter ? `  ${tierFilter}` : "",
-    `  ${channelFilter}`,
-    "  OPTIONAL { ?component ds:hasModifierFamily ?mod . ?mod ds:name ?modName }",
-    "}",
-    "GROUP BY ?component ?type ?name ?tier",
-    "ORDER BY ?name",
-  ]
-    .filter((line) => line !== "")
-    .join("\n");
-}
-
-const listVerb: VerbSpec<Record<string, unknown>, BlockRow[]> = {
-  path: ["block", "list"],
-  summary: "List blocks visible under the current tier and channel.",
-  doc: "List design system blocks visible under the active tier chain and channel. Optionally list across every tier, ignoring the tier filter.",
-  params: [
-    {
-      kind: "boolean",
-      name: "allTiers",
-      doc: "Show blocks from all tiers, ignoring the tier filter.",
-    },
-  ],
-  output: { formatters: listFormatters },
-  examples: [
-    { cmd: "pragma block list" },
-    { cmd: "pragma block list --all-tiers" },
-    { cmd: "pragma block list --format llm" },
-  ],
-  capability: {
-    needsStore: true,
-    mutates: false,
-    mcp: {
-      expose: true,
-      annotations: { readOnlyHint: true, openWorldHint: false },
-    },
-  },
-  run: async (params: Record<string, unknown>, rt: PragmaRuntime) => {
-    const layers = await rt.loadConfig();
-    const query = buildQuery(
-      layers.config.tier,
-      layers.config.channel,
-      params.allTiers === true,
-    );
-    const rows = await runSelect(rt, query, "block");
-    return rows.map((row) => ({
-      uri: row.component ?? "",
-      // An unnamed block still needs a token to show — fall back to its IRI's
-      // local name rather than rendering a blank row (A2).
-      name: row.name ?? localName(row.component ?? ""),
-      type: normalizeType(row.type),
-      tier: localName(row.tier ?? ""),
-      modifiers: row.modifiers ?? "",
-    }));
-  },
-};
-
-/** The hand-written `block list` verb. */
-export const blockListVerb = asVerb(listVerb);

package/src/capabilities/block/index.ts

@@ -1,25 +0,0 @@
-/**
- * The `block` capability module — a COMPOSITE: the hand-written `block list`
- * (tier chain + channel + --all-tiers) plus the bundled pack's GraphQL `lookup`.
- *
- * This is the one noun where a declarative pack and a hand-written verb share a
- * module; the pack ships lookup-only, so there is no `(noun, verb)` collision.
- */
-
-import { compilePack } from "../../kernel/packs/compile.js";
-import { DEFAULT_PREFIX_MAP } from "../../kernel/render/prefixes.js";
-import type { CapabilityModule } from "../../kernel/spec/types.js";
-import { blockListVerb } from "./blockList.verb.js";
-import { blockPack } from "./pack.js";
-
-/** The `block` capability module (`list` hand-written, `lookup` from the pack). */
-export const blockModule: CapabilityModule = {
-  name: "block",
-  verbs: [
-    blockListVerb,
-    ...compilePack(blockPack, "bundled:block", DEFAULT_PREFIX_MAP),
-  ],
-  // The bundled design-system domain colophon (authored on the flagship UI-block
-  // noun), surfaced by `pragma colophon` after pragma's own.
-  colophon: blockPack.colophon,
-};