@canonical/pragma-cli 0.35.0 → 0.36.0

package/src/testing/eval/cases/readNouns.ts

@@ -86,6 +86,181 @@ export const readNounEvalCases: readonly EvalCase[] = [
       });
     },
   },
+  {
+    // The journey the reported failure actually walked: browse a category, take
+    // a published `name` VERBATIM, and ask for its content. Every row `list`
+    // publishes must be addressable by `lookup` — otherwise the two-step
+    // grammar the whole read surface is built on has a hole in it, and an agent
+    // that follows the tools' own output gets ENTITY_NOT_FOUND with empty
+    // suggestions and a recovery pointing back at the list it just read.
+    id: "tool-standard-list-names-are-addressable-by-lookup",
+    kind: "tool",
+    input:
+      "every name standard_list {category:react} publishes resolves through standard_lookup {name:[…], detail:detailed}, dos/donts included.",
+    async expect() {
+      await withCanonicalFixture(CANONICAL_CONFIG, async (mcp) => {
+        const list = await mcp.callTool("standard_list", { category: "react" });
+        assert.equal(list.ok, true);
+        const names = (list.data as { name: string }[]).map((row) => row.name);
+        assert.ok(names.length > 0, "expected standard_list to publish rows");
+        let withExamples = 0;
+        for (const name of names) {
+          const result = await mcp.callTool("standard_lookup", {
+            name: [name],
+            detail: "detailed",
+          });
+          assert.equal(
+            result.ok,
+            true,
+            `standard_lookup rejected the name standard_list published: ${name}`,
+          );
+          const entity = (result.data as { results: Record<string, unknown>[] })
+            .results[0];
+          assert.equal(entity?.name, name);
+          if (
+            (entity?.dos as unknown[] | undefined)?.length &&
+            (entity?.donts as unknown[] | undefined)?.length
+          ) {
+            withExamples += 1;
+          }
+        }
+        assert.ok(
+          withExamples > 0,
+          "expected at least one resolved standard to carry both dos and donts",
+        );
+      });
+    },
+  },
+  {
+    // The glob the lookup tool's own description advertises. It matched nothing
+    // on the shipped graph, because the candidate pool was the `cs:name`
+    // population and no asserted name contains a slash.
+    id: "tool-standard-lookup-advertised-glob-matches",
+    kind: "tool",
+    input:
+      'standard_lookup {name:["react/component/*"]} — the glob the tool description advertises — resolves at least one standard.',
+    async expect() {
+      await withCanonicalFixture(CANONICAL_CONFIG, async (mcp) => {
+        const result = await mcp.callTool("standard_lookup", {
+          name: ["react/component/*"],
+        });
+        assert.equal(result.ok, true);
+        const results = (result.data as { results: unknown[] }).results;
+        assert.ok(
+          results.length > 0,
+          "the advertised glob must match at least one standard",
+        );
+      });
+    },
+  },
+  {
+    // The MIRROR of the addressability case above, and the reason the IRI-name
+    // fallback is DECLARED per story rather than inferred from a class
+    // constraint. `token list` requires `ds:tokenId`, so a `ds:Token` without
+    // one is a row it never publishes — and it must therefore be reachable by
+    // no name at all, and drawn by no sample. Inferring the fallback from the
+    // presence of `type: ds:Token` made it addressable and sampleable under an
+    // IRI-derived name the list never handed out: the same list/lookup
+    // disagreement as the standards defect, pointing the other way.
+    id: "tool-token-lookup-addresses-only-what-list-publishes",
+    kind: "tool",
+    input:
+      "a ds:Token carrying no ds:tokenId appears in no token_list row, resolves through no token_lookup name, and is drawn by no token_sample.",
+    async expect() {
+      await withCanonicalFixture(ALL_VISIBLE_CONFIG, async (mcp) => {
+        const list = await mcp.callTool("token_list");
+        assert.equal(list.ok, true);
+        const published = new Set(
+          (list.data as { name: string }[]).map((row) => row.name),
+        );
+        assert.ok(published.size > 0, "expected token_list to publish rows");
+        // The IRI-derived spellings the fallback would have minted for
+        // `ds:token.legacy.borderRadius` (local name, dots as slashes).
+        for (const derived of [
+          "token.legacy.borderRadius",
+          "token/legacy/borderRadius",
+        ]) {
+          assert.ok(
+            !published.has(derived),
+            `token_list must not publish ${derived}`,
+          );
+          const result = await mcp.callTool("token_lookup", {
+            name: [derived],
+          });
+          assert.equal(
+            result.ok,
+            false,
+            `token_lookup addressed ${derived}, a name token_list never published`,
+          );
+          assert.equal(
+            (result.error as { code: string }).code,
+            "ENTITY_NOT_FOUND",
+          );
+        }
+        // `sample`'s draw pool is the same population, so its reported total is
+        // the published population — not one entity wider.
+        const sample = await mcp.callTool("token_sample", {});
+        assert.equal(sample.ok, true);
+        assert.equal(
+          (sample.data as { totalCount: number }).totalCount,
+          published.size,
+        );
+      });
+    },
+  },
+  {
+    // A slug the graph declares with no standards filed under it. `standard
+    // categories` lists it at count 0 and the tool descriptions document a
+    // filtered list as a plain list, so asking for it is a calm empty answer —
+    // an INVALID_INPUT here tells an agent its own valid slug was a typo.
+    // Validity read off the RETURNED ROWS produced exactly that, because a
+    // category with no standards appears in no row.
+    id: "tool-standard-list-empty-category-is-a-calm-empty-list",
+    kind: "tool",
+    input:
+      "standard_list {category} for a real slug that no standard uses is ok:true with an empty list, not INVALID_INPUT.",
+    async expect() {
+      await withCanonicalFixture(CANONICAL_CONFIG, async (mcp) => {
+        const categories = await mcp.callTool("standard_categories");
+        assert.equal(categories.ok, true);
+        const empty = (categories.data as { name: string; count: string }[])
+          .filter((row) => Number(row.count) === 0)
+          .map((row) => row.name);
+        assert.ok(
+          empty.length > 0,
+          "expected standard_categories to report a zero-count category",
+        );
+        for (const slug of empty) {
+          const result = await mcp.callTool("standard_list", {
+            category: slug,
+          });
+          assert.equal(
+            result.ok,
+            true,
+            `standard_list rejected ${slug}, a slug standard_categories publishes`,
+          );
+          assert.deepEqual(result.data, []);
+        }
+        // The rejection itself still works, and still names the graph's whole
+        // vocabulary — including the categories no standard uses.
+        const rejected = await mcp.callTool("standard_list", {
+          category: "zzz-not-a-slug",
+        });
+        assert.equal(rejected.ok, false);
+        const error = rejected.error as {
+          code: string;
+          validOptions: string[];
+        };
+        assert.equal(error.code, "INVALID_INPUT");
+        for (const slug of empty) {
+          assert.ok(
+            error.validOptions.includes(slug),
+            `validOptions omitted the declared category ${slug}`,
+          );
+        }
+      });
+    },
+  },
   {
     id: "content-canonical-graph-has-4-components",
     kind: "content",
@@ -146,24 +321,85 @@ export const readNounEvalCases: readonly EvalCase[] = [
     },
   },
   {
-    id: "content-standard-list-length-equals-category-count-sum",
+    // The cross-surface count-parity invariant, stated for a HIERARCHY. Summing
+    // the category counts stopped being the right arithmetic the moment a
+    // parent counted its branch (a standard under `testing-unit` is counted by
+    // both `testing-unit` and `testing`); what must hold — and what actually
+    // catches the reported defect — is that each category's count and the rows
+    // `--category` returns for it are the same set. Before the roll-up,
+    // `testing` reported 1 and `standard list --category testing` returned 1 of
+    // the 8 standards in the branch: a silently wrong answer, exit 0.
+    id: "content-standard-category-counts-match-filtered-list",
     kind: "content",
     input:
-      "standard_list length equals the sum of standard_categories counts (the cross-surface count-parity invariant).",
+      "every standard_categories count equals the length of standard_list {category: <slug>}, and a parent category answers for its whole branch.",
     async expect() {
       await withCanonicalFixture(CANONICAL_CONFIG, async (mcp) => {
         const list = await mcp.callTool("standard_list");
         const categories = await mcp.callTool("standard_categories");
-        const listLength = (list.data as unknown[]).length;
-        const categorySum = (categories.data as { count: string }[]).reduce(
-          (sum, row) => sum + Number(row.count),
-          0,
+        const rows = categories.data as { name: string; count: string }[];
+        assert.ok(
+          (list.data as unknown[]).length > 0 && rows.length > 0,
+          "both surfaces must be non-empty for the parity invariant to bite",
+        );
+        let rolledUp = 0;
+        for (const row of rows) {
+          const filtered = await mcp.callTool("standard_list", {
+            category: row.name,
+          });
+          assert.equal(
+            (filtered.data as unknown[]).length,
+            Number(row.count),
+            `standard_list --category ${row.name} disagrees with its count`,
+          );
+          // A parent whose branch is bigger than its own direct membership:
+          // the roll-up is doing something, so this case cannot pass vacuously.
+          const direct = (list.data as { category?: string }[]).filter(
+            (r) => r.category === row.name,
+          ).length;
+          if (Number(row.count) > direct) rolledUp += 1;
+        }
+        assert.ok(
+          rolledUp > 0,
+          "expected at least one parent category to answer for its descendants",
+        );
+      });
+    },
+  },
+  {
+    // The reflexive half of `skos:broader*`. `broader+` looks equivalent and
+    // silently drops every standard filed DIRECTLY on the category asked for —
+    // one of the 8 under `testing` in the shipped graph.
+    id: "content-standard-category-rollup-keeps-the-direct-member",
+    kind: "content",
+    input:
+      "standard_list {category: <parent>} includes both the standard filed directly on the parent and those filed on its child.",
+    async expect() {
+      await withCanonicalFixture(CANONICAL_CONFIG, async (mcp) => {
+        const parent = await mcp.callTool("standard_list", {
+          category: "testing",
+        });
+        const child = await mcp.callTool("standard_list", {
+          category: "testing-unit",
+        });
+        const parentRows = parent.data as { name: string; category: string }[];
+        const childNames = new Set(
+          (child.data as { name: string }[]).map((r) => r.name),
+        );
+        assert.ok(
+          childNames.size > 0,
+          "expected the child category to be used",
         );
+        for (const name of childNames) {
+          assert.ok(
+            parentRows.some((r) => r.name === name),
+            `the parent category dropped its descendant ${name}`,
+          );
+        }
         assert.ok(
-          listLength > 0,
-          "standard_list must be non-empty for the count-parity invariant to be meaningful",
+          parentRows.some((r) => r.category === "testing"),
+          "the parent category dropped the standard filed directly on it",
         );
-        assert.equal(listLength, categorySum);
       });
     },
   },

package/src/testing/fixtures/blockGraph.ts

@@ -4,13 +4,26 @@
  *
  * Models the live ontology's shape faithfully but compactly: a `ds:UIBlock`
  * interface with `Component`/`Pattern`/`Subcomponent` subclasses, the block
- * detail properties (summary, whenToUse/whenNotToUse, guidelines, anatomy,
- * figmaLink), modifier families with values asserted ONLY in the reverse
+ * detail properties (summary, usage, guidelines, anatomy, figmaLink),
+ * modifier families with values asserted ONLY in the reverse
  * `ds:modifierFamily` direction (so the compiled inverse-union resolver is
  * exercised), block properties, and `ds:hasSubcomponent` scoped to `ds:Component`
  * (reached via a subtype-scoped fragment). Two blocks — Button and Modal —
- * carry the full spec so block content-parity asserts on a graph that DECLARES
- * whenToUse/whenNotToUse (which the live graph superseded with ds:usage).
+ * carry the full spec so block content-parity asserts on a graph shaped like
+ * the live one.
+ *
+ * The usage narrative is modelled as the live graph models it: ONE `ds:usage`
+ * literal per block, free-text Markdown carrying its own `### When to use` /
+ * `### When not to use` sub-sections. It used to declare the retired
+ * `ds:whenToUse`/`ds:whenNotToUse` pair instead, which is why the block parity
+ * suite went on asserting a "### When to use" heading that no real install had
+ * rendered since the ontology conflated the two into `ds:usage`.
+ *
+ * Both shapes the live pack has are here on purpose: Button carries a
+ * non-empty literal (126 of the 264 live blocks) and Modal an EMPTY one (the
+ * other 138), so the fixture proves the renderer both nests a body's own
+ * headings under the section heading AND prints no heading at all for an empty
+ * literal. A fixture that only ever carried prose could not tell those apart.
  */
 
 /** The prefixes the fixture store is built and queried with. */
@@ -56,8 +69,7 @@ ds:name a owl:DatatypeProperty ;
 ds:tier a owl:ObjectProperty, owl:FunctionalProperty ;
   rdfs:domain ds:UIBlock ; rdfs:range ds:Tier .
 ds:summary a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
-ds:whenToUse a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
-ds:whenNotToUse a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
+ds:usage a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
 ds:guidelines a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
 ds:anatomyDsl a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
 ds:anatomyClassic a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
@@ -82,8 +94,7 @@ ds:button a ds:Component ;
   ds:name "Button" ;
   ds:tier ds:global ;
   ds:summary "Primary action trigger with optional icon and label." ;
-  ds:whenToUse "Use for the primary action on a view." ;
-  ds:whenNotToUse "Do not use for navigation between pages." ;
+  ds:usage "Buttons trigger actions; links go places.\\n\\n### When to use\\n\\n- For the primary action on a view.\\n\\n### When not to use\\n\\n- For navigation between pages." ;
   ds:guidelines "Keep labels short and action-oriented." ;
   ds:anatomyDsl "root: button; children: label, icon" ;
   ds:anatomyClassic "Button > Label, Icon" ;
@@ -96,8 +107,7 @@ ds:modal a ds:Component ;
   ds:name "Modal" ;
   ds:tier ds:global ;
   ds:summary "Focused overlay dialog for a single task." ;
-  ds:whenToUse "Use to interrupt for a critical confirmation." ;
-  ds:whenNotToUse "Do not use for non-blocking notifications." ;
+  ds:usage "" ;
   ds:guidelines "Always provide an explicit close affordance." ;
   ds:anatomyDsl "root: dialog; children: header, body, footer" ;
   ds:hasModifierFamily ds:family.size ;
@@ -168,9 +178,14 @@ ${ROSTER_MEMBERS}
  *
  * It models the three shapes the addressing path gets wrong: two components
  * sharing one `ds:name` (declared zeta-first so the store's enumeration order
- * and IRI order DISAGREE — an unordered `LIMIT 1` picks the zeta one), and a
- * component carrying no `ds:name` at all (reachable only by IRI, the way 131 of
- * the 144 live code standards are).
+ * and IRI order DISAGREE), and a component carrying no `ds:name` at all
+ * (reachable only by IRI, the way 131 of the 144 live code standards are).
+ *
+ * The shared name is a SHAPE probe, not the live ambiguity: neither chip's tier
+ * outranks the other, so this fixture can only prove that both are returned in a
+ * total order — never which of them a reader means. Deciding that is a judgement
+ * about real tiers, and it is asserted where the real tiers are, against the
+ * shipped pack (`capabilities/block.tierRank.exec.test.ts`).
  */
 export const AMBIGUOUS_TTL = `
 ds:apps a ds:Tier ; ds:name "apps" .

package/src/testing/fixtures/graph/canonical.ts

@@ -26,6 +26,16 @@
  * ours to pin): 4 `ds:Component` (Button, Modal, LXD Panel, Beta Widget),
  * `importance` family with value `primary`, code standard
  * `code/function/purity`.
+ *
+ * Two of those anchors exist to pin an ABSENCE, and are load-bearing for the
+ * "declared, not inferred" halves of the read grammar:
+ * - `ds:token.legacy.borderRadius` — a `ds:Token` with no `ds:tokenId`, which
+ *   `token list` therefore never publishes and `token lookup`/`token sample`
+ *   must never reach (`PackLookup.nameFallback` is declared by `standard`
+ *   alone).
+ * - `cs:archive` — a `cs:Category` with no standards, which `standard
+ *   categories` reports at count 0 and `standard list --category archive` must
+ *   answer with a calm empty list rather than INVALID_INPUT.
  */
 
 import { BLOCK_PREFIXES, BLOCK_TTL } from "../blockGraph.js";
@@ -76,13 +86,46 @@ ds:token.spacing.medium a ds:Token ;
   ds:tokenType ds:type.spacing ;
   ds:valueLight "16px" ;
   ds:valueDark "16px" .
+
+# A ds:Token carrying NO ds:tokenId — the entity "token list" does not publish,
+# because its query REQUIRES the id. It is here to pin what a lookup may NOT
+# reach: "token lookup" addresses by ds:tokenId, and a story whose list requires
+# its "by" property must not become addressable (or sampleable) under a name
+# derived from its IRI. See PackLookup.nameFallback, declared by the "standard"
+# story alone — the one story whose list DOES publish such a name.
+ds:token.legacy.borderRadius a ds:Token ;
+  ds:tokenType ds:type.spacing ;
+  ds:valueLight "4px" ;
+  ds:valueDark "4px" .
 `;
 
-/** The `cs:` (code standards) section — reused verbatim from `standard/parity.test.ts`'s
- * fixture shape so `code/function/purity`/`react/component/*` are stable, shared
- * anchor names rather than a second invented set. */
+/**
+ * The `cs:` (code standards) section — shaped like the SHIPPED code-standards
+ * graph, not like a convenience fixture.
+ *
+ * Two facts about the real data are reproduced here on purpose, because the
+ * eval harness was blind to both while every fixture standard carried a
+ * `cs:name`:
+ *
+ * 1. **Most standards carry NO `cs:name`.** The shipped graph asserts it on 22
+ *    of 156 (~13%); one of the eight standards below carries one (~13%). The
+ *    ontology says so deliberately — `cs:name` is "an optional human-readable
+ *    display title" that "never participates in identity", the canonical
+ *    identifier being the compact IRI. So the name `standard list` publishes for
+ *    the other seven is SYNTHESIZED from the IRI local name
+ *    (`cs:react.component.props` → `react/component/props`), and a lookup that
+ *    cannot resolve a synthesized name cannot resolve the graph.
+ * 2. **Categories are a two-level SKOS tree.** `cs:testing.unit skos:broader
+ *    cs:testing`, exactly as the shipped graph declares for `testing.*` and
+ *    `ui_blocks.nojs`, and one standard sits DIRECTLY on the parent — the case a
+ *    non-reflexive roll-up (`skos:broader+`) silently drops.
+ *
+ * Anchor names (`code/function/purity`, `react/component/*`) are unchanged; they
+ * are simply reached the way the real graph reaches them.
+ */
 const CS_TTL = `
 @prefix cs: <http://pragma.canonical.com/codestandards#> .
+@prefix skos: <http://www.w3.org/2004/02/skos/core#> .
 
 cs:CodeStandard a owl:Class .
 cs:Category a owl:Class .
@@ -97,27 +140,66 @@ cs:dont a owl:ObjectProperty ; rdfs:domain cs:CodeStandard ; rdfs:range cs:Examp
 cs:language a owl:DatatypeProperty ; rdfs:domain cs:Example ; rdfs:range xsd:string .
 cs:code a owl:DatatypeProperty ; rdfs:domain cs:Example ; rdfs:range xsd:string .
 
-cs:cat.react a cs:Category ; cs:slug "react" .
-cs:cat.code a cs:Category ; cs:slug "code" .
-
+# ---- Categories: flat roots, plus one two-level branch (testing) ----
+cs:react a cs:Category ; rdfs:label "React" ; cs:slug "react" .
+cs:code a cs:Category ; rdfs:label "Code" ; cs:slug "code" .
+cs:turtle a cs:Category ; rdfs:label "Turtle" ; cs:slug "turtle" .
+cs:testing a cs:Category ; rdfs:label "Testing" ; cs:slug "testing" .
+cs:testing.unit a cs:Category ;
+  rdfs:label "Unit testing" ;
+  cs:slug "testing-unit" ;
+  skos:broader cs:testing .
+
+# A category the graph DECLARES with no standards filed under it. The
+# "standard categories" verb lists it with count 0, so
+# "standard list --category archive" must be the documented calm empty list — a
+# real slug, an empty answer. Validity read off the returned ROWS instead of the
+# graph called it INVALID_INPUT.
+cs:archive a cs:Category ;
+  rdfs:label "Archive" ;
+  cs:slug "archive" .
+
+# ---- Standards. Seven of eight carry NO cs:name (the shipped ~13% split). ----
 cs:react.component.props a cs:CodeStandard ;
-  cs:name "react/component/props" ;
   cs:description "Type component props explicitly." ;
-  cs:hasCategory cs:cat.react ;
+  cs:hasCategory cs:react ;
   cs:do [ a cs:Example ; cs:description "Do type props" ; cs:language "tsx" ; cs:code "interface P {}" ] ;
   cs:dont [ a cs:Example ; cs:description "Avoid any" ; cs:language "tsx" ; cs:code "props: any" ] .
 
 cs:react.component.structure a cs:CodeStandard ;
-  cs:name "react/component/structure" ;
   cs:description "Keep folder structure flat." ;
-  cs:hasCategory cs:cat.react ;
+  cs:hasCategory cs:react ;
   cs:extends cs:react.component.props ;
   cs:do [ a cs:Example ; cs:description "Do flatten" ; cs:language "text" ; cs:code "src/Button.tsx" ] .
 
 cs:code.function.purity a cs:CodeStandard ;
-  cs:name "code/function/purity" ;
   cs:description "Prefer pure functions." ;
-  cs:hasCategory cs:cat.code .
+  cs:hasCategory cs:code .
+
+# The standard sitting DIRECTLY on the parent category: a skos:broader+
+# roll-up loses it, a reflexive skos:broader* keeps it.
+cs:testing.smoke a cs:CodeStandard ;
+  cs:description "Keep one end-to-end smoke path green." ;
+  cs:hasCategory cs:testing .
+
+cs:testing.unit.isolation a cs:CodeStandard ;
+  cs:description "Isolate the unit under test." ;
+  cs:hasCategory cs:testing.unit .
+
+cs:testing.unit.naming a cs:CodeStandard ;
+  cs:description "Name a unit test for the behaviour it pins." ;
+  cs:hasCategory cs:testing.unit ;
+  cs:do [ a cs:Example ; cs:description "Do name the behaviour" ; cs:language "ts" ; cs:code "it(\\"rejects an empty batch\\")" ] .
+
+cs:testing.unit.fixtures a cs:CodeStandard ;
+  cs:description "Share one fixture per behavioural claim." ;
+  cs:hasCategory cs:testing.unit .
+
+# The ~13%: a display title that adds something the IRI does not.
+cs:turtle.naming.local_name_casing a cs:CodeStandard ;
+  cs:name "Turtle local-name casing" ;
+  cs:description "Use snake_case for multi-word local-name segments." ;
+  cs:hasCategory cs:turtle .
 `;
 
 /** The `ds:Prompt` workflow templates — the ONE source both the `prompt_list`/
@@ -255,6 +337,7 @@ ds:implementation.svelte-ds-global.button a ds:ImplementationObject ;
 export const CANONICAL_PREFIXES: Readonly<Record<string, string>> = {
   ...BLOCK_PREFIXES,
   cs: "http://pragma.canonical.com/codestandards#",
+  skos: "http://www.w3.org/2004/02/skos/core#",
 };
 
 /** The full canonical Turtle: PR3's `BLOCK_TTL` verbatim, plus the sections above. */

package/dist/src/capabilities/shared/bands.js

@@ -1,16 +0,0 @@
-/**
- * User-facing labels for the two config bands, shared by the setup recap
- * ({@link ../setup/setup.render}) and the doctor report
- * ({@link ../doctor/doctor.render}) so ONE consistent vocabulary appears across
- * both. The pair matches the CLI grammar users already meet elsewhere: the
- * `--global`/`--local` flags, the `--scope project|global|both` enum, config
- * show's `[global]`/`[project]` origin markers, and the `setup` manifest's
- * `[global]`/`[project]` lines. (Earlier these two surfaces said MACHINE/PROJECT
- * — a third term for the same bands; this is the single source that unifies it.)
- */
-/** The user-facing display label for each of the two config bands. */
-export const BAND_LABELS = {
-    global: "Global",
-    project: "Project",
-};
-//# sourceMappingURL=bands.js.map

package/dist/src/capabilities/shared/bands.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bands.js","sourceRoot":"","sources":["../../../../src/capabilities/shared/bands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,sEAAsE;AACtE,MAAM,CAAC,MAAM,WAAW,GAAyC;IAC/D,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;CACnB,CAAC"}

package/src/capabilities/shared/bands.ts

@@ -1,16 +0,0 @@
-/**
- * User-facing labels for the two config bands, shared by the setup recap
- * ({@link ../setup/setup.render}) and the doctor report
- * ({@link ../doctor/doctor.render}) so ONE consistent vocabulary appears across
- * both. The pair matches the CLI grammar users already meet elsewhere: the
- * `--global`/`--local` flags, the `--scope project|global|both` enum, config
- * show's `[global]`/`[project]` origin markers, and the `setup` manifest's
- * `[global]`/`[project]` lines. (Earlier these two surfaces said MACHINE/PROJECT
- * — a third term for the same bands; this is the single source that unifies it.)
- */
-
-/** The user-facing display label for each of the two config bands. */
-export const BAND_LABELS: Record<"project" | "global", string> = {
-  global: "Global",
-  project: "Project",
-};