@canonical/pragma-cli 0.36.0 → 0.38.0

package/src/capabilities/surface.test.ts

@@ -83,36 +83,66 @@ describe("surface conformance — capabilities ⊆ covenant (PROTECTED)", () =>
       "sample",
     ]);
     // `token` is purely declarative since L-OPEN-9 removed `add-config`: the
-    // three read verbs its story compiles, and no mutation.
+    // read verbs its story compiles, and no mutation. The two extra
+    // list-shaped verbs sit between `list` and `lookup` because that is the
+    // order the compiler emits them in — `list`, then each declared verb, then
+    // `lookup`, then `sample`.
     expect(emitted.nouns.token?.verbs.map((v) => v.v)).toEqual([
       "list",
+      "values",
+      "consumers",
       "lookup",
       "sample",
     ]);
-    // block list is the story's compiled, unfiltered list (L-OPEN-9): no
-    // flags — the `--all-tiers` escape died with the hand-written filtering.
+    // `variable` is the same shape over the platform stratum, with one extra
+    // verb rather than two.
+    expect(emitted.nouns.variable?.verbs.map((v) => v.v)).toEqual([
+      "list",
+      "chain",
+      "lookup",
+      "sample",
+    ]);
+    // block list declares no filters of its own, and the three flags it
+    // carries are all the KERNEL's: `--tier` because the block story declares
+    // a tier hierarchy (so every read of it is scoped), and the page's two,
+    // which every list-shaped verb gets whether its story declares anything or
+    // not. `--tier` leads them because params are emitted in `verb.params`
+    // order and the scope is resolved before the page is cut.
     expect(emitted.nouns.block?.verbs).toEqual([
       {
         v: "list",
+        flags: ["--tier", "--limit", "--after"],
         needsStore: true,
         mcp: "block_list",
       },
       {
         v: "lookup",
         args: ["<name...>"],
+        flags: ["--tier"],
         needsStore: true,
         mcp: "block_lookup",
       },
+      // `sample` carries NO `--tier`: a sample is a shape probe drawn at the
+      // highest level, and which tier a specimen sits in is not its shape.
       { v: "sample", needsStore: true, mcp: "block_sample" },
     ]);
     // The tier lookup is the story's compiled lookup (L-OPEN-9), so it emits
-    // the variadic `<name...>` positional every pack lookup emits.
+    // the variadic `<name...>` positional every pack lookup emits — and NO
+    // `--tier`, because a tier carries no tier of its own and this is the
+    // surface that publishes the names `--tier` accepts.
     expect(emitted.nouns.tier?.verbs).toContainEqual({
       v: "lookup",
       args: ["<name...>"],
       needsStore: true,
       mcp: "tier_lookup",
     });
+    // The scope reaches every tiered noun, not just the flagship one, and
+    // reaches it on both halves of the two-step grammar.
+    for (const noun of ["modifier", "concept"]) {
+      const verbs = emitted.nouns[noun]?.verbs ?? [];
+      expect(verbs.find((v) => v.v === "list")?.flags).toContain("--tier");
+      expect(verbs.find((v) => v.v === "lookup")?.flags).toEqual(["--tier"]);
+    }
   });
 
   it("emits the authored read nouns (ontology TBox, storeless skill, graph inspect)", () => {
@@ -133,8 +163,18 @@ describe("surface conformance — capabilities ⊆ covenant (PROTECTED)", () =>
       { v: "list", mcp: "skill_list" },
       { v: "lookup", args: ["<name>"], mcp: "skill_lookup" },
     ]);
-    // graph adds the SPARQL escape hatch (`query`) in PR6, alongside `inspect`.
+    // graph carries the three store-wide reads: one entity's neighbourhood
+    // (`inspect`), the SPARQL escape hatch (`query`, PR6), and the relation
+    // paths between two entities (`connect`) — a verb rather than a declared
+    // story because the pack grammar can mint only ONE required positional.
     expect(emitted.nouns.graph?.verbs).toEqual([
+      {
+        v: "connect",
+        args: ["<a>", "<b>"],
+        flags: ["--hops", "--paths"],
+        needsStore: true,
+        mcp: "graph_connect",
+      },
       {
         v: "inspect",
         args: ["<uri>"],
@@ -192,10 +232,18 @@ describe("surface conformance — capabilities ⊆ covenant (PROTECTED)", () =>
       {
         v: "application",
         args: ["[app-path]"],
-        // ssr/router are GONE: always-on facts, not prompts — the pair had no
-        // reachable explicit form (only `--no-` spellings the generator's own
-        // guard rejected), so the projection no longer carries them.
-        flags: ["--no-forms", "--intl", "--relay", "--no-run-install"],
+        // router is GONE: an always-on fact, not a prompt — it had no
+        // reachable explicit form (only a `--no-` spelling the generator's own
+        // guard rejected), so the projection no longer carries it. `rendering`
+        // is the SSR axis' replacement (L-CIS-3): a select, so it is spelled as
+        // a value and never as a negation.
+        flags: [
+          "--no-forms",
+          "--intl",
+          "--rendering",
+          "--relay",
+          "--no-run-install",
+        ],
         mutates: true,
         mcp: "create_application",
       },
@@ -330,14 +378,14 @@ describe("surface COMPLETE — emitted == covenant (PROTECTED)", () => {
   // The CLOSING direction: assertConforms already proves emitted ⊆ covenant;
   // this proves covenant ⊆ emitted, so together the tool sets are EQUAL — the
   // surface-complete milestone. After PR7, every covenant tool is realized.
-  it("emits every covenant tool (all 42) — set equality with the covenant", () => {
+  it("emits every covenant tool (all 49) — set equality with the covenant", () => {
     const emittedTools = new Set(emitted.mcpSurface.tools);
     const missing = golden.mcpSurface.tools.filter((t) => !emittedTools.has(t));
     expect(missing).toEqual([]);
     expect([...emitted.mcpSurface.tools].sort()).toEqual(
       [...golden.mcpSurface.tools].sort(),
     );
-    expect(emitted.mcpSurface.tools).toHaveLength(42);
+    expect(emitted.mcpSurface.tools).toHaveLength(49);
   });
 
   // The covenant edit: the non-tool MCP surface is frozen too.

package/src/capabilities/tier.parity.test.ts

@@ -14,7 +14,7 @@
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { compilePack } from "../kernel/packs/compile.js";
 import type { LookupOutput } from "../kernel/packs/resolveEntity.js";
-import type { PackRow } from "../kernel/packs/types.js";
+import type { PackPage } from "../kernel/packs/types.js";
 import { verbKey } from "../kernel/packs/uniqueness.js";
 import { DEFAULT_PREFIX_MAP } from "../kernel/render/prefixes.js";
 import type { PragmaRuntime } from "../kernel/runtime/types.js";
@@ -80,7 +80,7 @@ function blockNames(entity: Record<string, unknown>): string[] {
 
 describe("tier list parity", () => {
   it("lists every tier, name-ordered, with the uniform row shape", async () => {
-    const rows = (await verb("list").run({}, rt)) as PackRow[];
+    const rows = ((await verb("list").run({}, rt)) as PackPage).rows;
     expect(rows.map((r) => r.name)).toEqual(["apps", "apps/lxd", "global"]);
     for (const row of rows) {
       expect(row.uri).toBeTruthy();