@canonical/pragma-cli 0.33.0 → 0.35.0

package/src/capabilities/standard/pack.ts

@@ -1,128 +0,0 @@
-/**
- * The bundled `standard` pack — code standards as data.
- *
- * `standard list|lookup|categories|sample` compile from this definition through
- * the one pack kernel. Normalized for v2: the old `digest` level is renamed to
- * the canonical `standard`, so disclosure gates by the canonical index; the
- * default is `summary` (base fields by name), `--detail standard` adds the `dos`
- * examples, `--detail detailed` adds `donts`. `cs:extends` stays the raw IRI in
- * JSON (renderers compact it at display time).
- */
-
-import type { PackDefinition } from "../../kernel/packs/types.js";
-
-export const standardPack: PackDefinition = {
-  noun: "standard",
-  description: "List all code standards.",
-  toolDescription:
-    "List code standards. Optionally filter by category or search term.",
-  list: {
-    query: [
-      "SELECT ?uri ?name ?category ?description",
-      "WHERE {",
-      "  ?uri a cs:CodeStandard ;",
-      "       cs:description ?description .",
-      "  OPTIONAL { ?uri cs:name ?n . }",
-      '  BIND(COALESCE(?n, REPLACE(STRAFTER(STR(?uri), "#"), "\\\\.", "/")) AS ?name)',
-      "  OPTIONAL {",
-      "    ?uri cs:hasCategory ?cat .",
-      "    ?cat cs:slug ?category .",
-      "  }",
-      "}",
-      "ORDER BY ?name",
-    ].join("\n"),
-    columns: [
-      { field: "uri", label: "IRI" },
-      { field: "name", label: "Name" },
-      { field: "category", label: "Category" },
-      { field: "description", label: "Description" },
-    ],
-    filters: [
-      {
-        param: "category",
-        variable: "category",
-        description: "Filter by category name.",
-      },
-    ],
-    search: {
-      variables: ["name", "description"],
-      description: "Search in name and description.",
-    },
-  },
-  verbs: [
-    {
-      verb: "categories",
-      description: "List all standard categories with counts.",
-      toolDescription: "List all code standard categories.",
-      query: [
-        "SELECT ?name (COUNT(?standard) AS ?count)",
-        "WHERE {",
-        "  ?cat a cs:Category ;",
-        "       cs:slug ?name .",
-        "  OPTIONAL {",
-        "    ?standard a cs:CodeStandard ;",
-        "              cs:hasCategory ?cat .",
-        "  }",
-        "}",
-        "GROUP BY ?name",
-        "ORDER BY ?name",
-      ].join("\n"),
-      columns: [
-        { field: "name", label: "Category" },
-        { field: "count", label: "Standards" },
-      ],
-    },
-  ],
-  lookup: {
-    source: "sparql",
-    by: "cs:name",
-    type: "cs:CodeStandard",
-    description:
-      "Look up detailed information for a standard by name, IRI, or glob.",
-    toolDescription:
-      "Get detailed information about one or more code standards including dos and donts with code examples. Address standards by name, prefixed name (cs:…), absolute IRI, or glob pattern (react/component/*).",
-    fields: [
-      {
-        name: "category",
-        property: "cs:hasCategory/cs:slug",
-        label: "Category",
-      },
-      { name: "description", property: "cs:description", label: "Description" },
-      { name: "extends", property: "cs:extends", label: "Extends" },
-    ],
-    expand: [
-      {
-        name: "dos",
-        heading: "Do",
-        relation: "cs:do",
-        select: [
-          { name: "caption", property: "cs:description" },
-          { name: "language", property: "cs:language" },
-          { name: "code", property: "cs:code" },
-        ],
-        level: "standard",
-      },
-      {
-        name: "donts",
-        heading: "Don't",
-        relation: "cs:dont",
-        select: [
-          { name: "caption", property: "cs:description" },
-          { name: "language", property: "cs:language" },
-          { name: "code", property: "cs:code" },
-        ],
-        level: "detailed",
-      },
-    ],
-    disclosure: {
-      levels: ["summary", "standard", "detailed"],
-      default: "summary",
-    },
-    sample: {
-      description:
-        "Return randomly selected complete standard instances as exemplars for shape discovery.",
-      toolDescription:
-        "Return 1–5 randomly selected complete code standard instances as exemplars. Use BEFORE writing queries to see actual data shapes, property names, and value formats. Each call returns different instances.",
-    },
-  },
-};

package/src/capabilities/tier/index.ts

@@ -1,19 +0,0 @@
-/**
- * The `tier` capability module — the bundled flat-list pack compiled to `list`.
- */
-
-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 { tierLookupVerb } from "./lookup.verb.js";
-import { tierPack } from "./pack.js";
-
-/** The `tier` capability module — the bundled flat-list pack plus the bespoke
- * single-name `lookup` (a pack lookup would emit the variadic `<name...>`). */
-export const tierModule: CapabilityModule = {
-  name: "tier",
-  verbs: [
-    ...compilePack(tierPack, "bundled:tier", DEFAULT_PREFIX_MAP),
-    tierLookupVerb,
-  ],
-};

package/src/capabilities/tier/lookup.render.test.ts

@@ -1,72 +0,0 @@
-import chalk from "chalk";
-import { afterEach, describe, expect, it } from "vitest";
-import { type TierLookupData, tierLookupFormatters } from "./lookup.render.js";
-
-const TIER: TierLookupData = {
-  uri: "cs:apps/lxd-panel",
-  name: "apps/lxd-panel",
-  blocks: ["LXD Panel", "Status Bar"],
-};
-
-/** Run `body` with stdout's `isTTY` forced to `value`, then restore it. */
-function withStdoutTty(value: boolean | undefined, body: () => void): void {
-  const stream = process.stdout as { isTTY?: boolean };
-  const saved = stream.isTTY;
-  stream.isTTY = value;
-  try {
-    body();
-  } finally {
-    stream.isTTY = saved;
-  }
-}
-
-describe("tierLookupFormatters", () => {
-  it("underlines the plain title with an ═ rule (B7)", () => {
-    const [title, rule, blank, blocks] = tierLookupFormatters
-      .plain(TIER)
-      .split("\n");
-    expect(title).toBe("apps/lxd-panel (cs:apps/lxd-panel)");
-    expect(rule).toBe("═".repeat(Math.max((title as string).length, 24)));
-    expect(blank).toBe("");
-    expect(blocks).toBe("  blocks: LXD Panel, Status Bar");
-  });
-
-  it("floors the plain rule at 24 columns for a short title", () => {
-    const out = tierLookupFormatters.plain({ ...TIER, uri: "x", name: "a" });
-    expect(out.split("\n").at(1)).toBe("═".repeat(24));
-  });
-
-  it("heads the llm entity read at H2, never H1 (B2)", () => {
-    const out = tierLookupFormatters.llm(TIER);
-    expect(out.startsWith("## apps/lxd-panel\n")).toBe(true);
-    expect(out).not.toMatch(/^# /m);
-  });
-});
-
-describe("tierLookupFormatters — shared style seam (B7)", () => {
-  const prevLevel = chalk.level;
-  afterEach(() => {
-    chalk.level = prevLevel;
-  });
-
-  it("styles the plain title on a color-capable TTY (single-sourced frame)", () => {
-    chalk.level = 1;
-    withStdoutTty(true, () => {
-      // Delegating to `renderLookupPlain` now carries the same TTY tint block and
-      // skill lookups get — previously the tier title stayed unstyled.
-      // biome-ignore lint/suspicious/noControlCharactersInRegex: asserting the ESC byte is the point
-      expect(tierLookupFormatters.plain(TIER)).toMatch(/\x1b\[/);
-    });
-  });
-
-  it("keeps piped plain output byte-stable off a TTY", () => {
-    chalk.level = 3;
-    withStdoutTty(undefined, () => {
-      const out = tierLookupFormatters.plain(TIER);
-      // biome-ignore lint/suspicious/noControlCharactersInRegex: asserting NO ESC byte survives
-      expect(out).not.toMatch(/\x1b\[/);
-      expect(out.split("\n").at(0)).toBe("apps/lxd-panel (cs:apps/lxd-panel)");
-      expect(out.split("\n").at(3)).toBe("  blocks: LXD Panel, Status Bar");
-    });
-  });
-});

package/src/capabilities/tier/lookup.render.ts

@@ -1,59 +0,0 @@
-/**
- * Formatters + data shape for `tier lookup <name>`.
- */
-
-import type { RenderLookupOptions } from "../../kernel/render/contracts.js";
-import { renderLookupPlain } from "../../kernel/render/renderers.js";
-import type { Formatters } from "../../kernel/spec/types.js";
-
-/** The looked-up tier: its IRI, name, and the blocks scoped directly to it. */
-export interface TierLookupData {
-  readonly uri: string;
-  readonly name: string;
-  readonly blocks: readonly string[];
-}
-
-/**
- * The shared plain-lookup layout for a tier: a `name (uri)` title over an ═ rule,
- * then the directly-scoped blocks as one inline field. Delegating to
- * {@link renderLookupPlain} single-sources the frame AND the TTY styling (bold
- * title, dim rule, cyan label) that block/skill lookups already earn — so a tier
- * title no longer stays unstyled on a terminal while theirs are bold (B7).
- */
-const tierPlainOptions: RenderLookupOptions<TierLookupData> = {
-  title: (tier) => `${tier.name} (${tier.uri})`,
-  fields: [
-    {
-      label: "blocks",
-      // Pre-joined so the empty case still renders (the shared field renderer
-      // skips an empty array). Blocks are `ds:name` display strings, never IRIs,
-      // so the shared renderer's URI compaction is a no-op here — byte-stable.
-      value: (tier) =>
-        tier.blocks.length > 0
-          ? tier.blocks.join(", ")
-          : "(none scoped directly to this tier)",
-    },
-  ],
-  sections: [],
-};
-
-export const tierLookupFormatters: Formatters<TierLookupData> = {
-  plain(data) {
-    return renderLookupPlain(data, tierPlainOptions);
-  },
-  llm(data) {
-    // A byte-frozen agent contract that DIVERGES from the generic
-    // `renderLookupLlm`: an H2 `name` title (not `name (uri)`) with the IRI and
-    // blocks backtick-wrapped (`\`cs:…\``) — a shape the shared renderer does not
-    // emit. The llm path is never styled, so it has no TTY drift to single-source;
-    // kept inline so the frozen bytes hold (B2).
-    const lines = [`## ${data.name}`, `- IRI: \`${data.uri}\``];
-    if (data.blocks.length > 0) {
-      lines.push(`- Blocks: ${data.blocks.map((b) => `\`${b}\``).join(", ")}`);
-    }
-    return lines.join("\n");
-  },
-  json(data) {
-    return JSON.stringify(data);
-  },
-};

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

@@ -1,83 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-import { CANONICAL_TTL } from "../../testing/fixtures/graph/canonical.js";
-import {
-  bootFixtureRuntime,
-  type FixtureGraph,
-} from "../../testing/helpers/fixtureGraph.js";
-import type { McpHarness } from "../../testing/helpers/projectMcp.js";
-import { projectMcp } from "../../testing/helpers/projectMcp.js";
-import { capabilities } from "../index.js";
-import { runTierLookup } from "./runLookup.js";
-
-let fixture: FixtureGraph;
-let mcp: McpHarness;
-
-beforeAll(async () => {
-  fixture = await bootFixtureRuntime({ ttl: CANONICAL_TTL });
-  mcp = await projectMcp(capabilities, fixture.cwd);
-});
-
-afterAll(async () => {
-  await mcp.cleanup();
-  await fixture.dispose();
-});
-
-describe("tier_lookup — bespoke single-name lookup (PROTECTED)", () => {
-  it("resolves a tier and the blocks scoped directly to it", async () => {
-    const result = await mcp.callTool("tier_lookup", { name: "apps/lxd" });
-    expect(result.ok).toBe(true);
-    const data = result.data as { name: string; blocks: string[] };
-    expect(data.name).toBe("apps/lxd");
-    // The canonical fixture scopes "LXD Panel" to apps/lxd.
-    expect(data.blocks).toContain("LXD Panel");
-  });
-
-  it("errors on an unknown tier name with a tier_list recovery", async () => {
-    const result = await mcp.callTool("tier_lookup", { name: "not-a-tier" });
-    expect(result.ok).toBe(false);
-    const error = result.error as { code: string };
-    expect(error.code).toBe("ENTITY_NOT_FOUND");
-  });
-
-  it("suggests a near-miss tier name from the full list (did-you-mean parity)", async () => {
-    // B6: tier lookup was the only entity lookup that omitted suggestions,
-    // though — like the others — it can read the full tier list on a miss.
-    let caught: unknown;
-    try {
-      await runTierLookup(fixture.runtime, "apps/lxdd");
-    } catch (error) {
-      caught = error;
-    }
-    expect(caught).toMatchObject({ code: "ENTITY_NOT_FOUND" });
-    expect((caught as { suggestions: string[] }).suggestions).toContain(
-      "apps/lxd",
-    );
-  });
-});
-
-describe("tier_lookup — cold/unseeded store (ROOT A)", () => {
-  it("remaps a 'Prefix not found' to STORE_UNAVAILABLE, not INTERNAL_ERROR", async () => {
-    // The bespoke lookup used to call `rt.query.sparql` directly, bypassing the
-    // `runSelect` remap — so a cold store's raw "Prefix not found" collapsed to
-    // INTERNAL_ERROR. It now routes through `runSelect`, inheriting the remap.
-    const coldRuntime = {
-      query: {
-        sparql: async () => {
-          throw new Error("Prefix not found: ds");
-        },
-      },
-    } as unknown as PragmaRuntime;
-
-    let caught: unknown;
-    try {
-      await runTierLookup(coldRuntime, "apps/lxd");
-    } catch (error) {
-      caught = error;
-    }
-    expect(caught).toMatchObject({ code: "STORE_UNAVAILABLE" });
-    expect(
-      (caught as { recovery?: { mcp?: { tool: string } } }).recovery?.mcp,
-    ).toMatchObject({ tool: "sources_update" });
-  });
-});

package/src/capabilities/tier/lookup.verb.ts

@@ -1,44 +0,0 @@
-/**
- * `tier lookup <name>` — the covenant `tier_lookup` tool.
- *
- * Bespoke store-backed lookup with a SINGLE `<name>` positional (a pack lookup
- * would emit the variadic `<name...>`), so it emits
- * `{ v: "lookup", args: ["<name>"], needsStore: true, mcp: "tier_lookup" }`.
- */
-
-import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { VerbSpec } from "../../kernel/spec/types.js";
-import { type TierLookupData, tierLookupFormatters } from "./lookup.render.js";
-
-const tierLookupSpec: VerbSpec<Record<string, unknown>, TierLookupData> = {
-  path: ["tier", "lookup"],
-  summary: "Show one tier by name, with the blocks scoped to it.",
-  doc: "Look up a single tier by its name (e.g. apps/lxd) and list the blocks scoped directly to it.",
-  params: [
-    {
-      kind: "string",
-      name: "name",
-      doc: "The tier name (e.g. apps/lxd).",
-      positional: true,
-      required: true,
-      complete: { kind: "names", source: { from: "tiers" } },
-    },
-  ],
-  output: { formatters: tierLookupFormatters },
-  examples: [{ cmd: "pragma tier lookup apps/lxd" }],
-  capability: {
-    needsStore: true,
-    mutates: false,
-    mcp: {
-      expose: true,
-      annotations: { readOnlyHint: true, openWorldHint: false },
-    },
-  },
-  run: (params, rt) =>
-    import("./runLookup.js").then((m) =>
-      m.runTierLookup(rt, String(params.name)),
-    ),
-};
-
-/** The `tier lookup` verb, widened for registry composition. */
-export const tierLookupVerb = asVerb(tierLookupSpec);

package/src/capabilities/tier/pack.ts

@@ -1,28 +0,0 @@
-/**
- * The bundled `tier` pack — a flat, name-ordered list story.
- *
- * Tier hierarchy is encoded in the slash-separated path string (`apps/lxd`), not
- * in graph edges, so `tier list` is a flat list; the ordered-inheritance logic
- * lives in the block list's tier chain. SPARQL-sourced (a flat-ordered list).
- */
-
-import type { PackDefinition } from "../../kernel/packs/types.js";
-
-export const tierPack: PackDefinition = {
-  noun: "tier",
-  description: "List all tiers in the design system ontology.",
-  toolDescription:
-    "List all tiers in the design-system ontology. Use when understanding the tier hierarchy before setting a tier filter. Example: tier_list {}.",
-  list: {
-    query: [
-      "SELECT ?uri ?name WHERE {",
-      "  ?uri a ds:Tier ;",
-      "       ds:name ?name .",
-      "} ORDER BY ?name",
-    ].join("\n"),
-    columns: [
-      { field: "uri", label: "IRI" },
-      { field: "name", label: "Name" },
-    ],
-  },
-};

package/src/capabilities/tier/runLookup.ts

@@ -1,87 +0,0 @@
-/**
- * The `tier lookup` run body (lazily imported, off the fast path).
- *
- * Bespoke (not a pack lookup): the covenant freezes `tier_lookup` with a SINGLE
- * `<name>` positional, whereas a pack lookup emits the variadic `<name...>`.
- * Resolves the tier by its `ds:name` and returns the blocks scoped directly to
- * it (a joined OPTIONAL, so a tier with no direct members still resolves).
- */
-
-import { PragmaError } from "../../kernel/error/PragmaError.js";
-import { runSelect } from "../../kernel/packs/sparql/runSelect.js";
-import { suggestNames } from "../../kernel/project/cli/suggestNames.js";
-import { compactUri } from "../../kernel/render/compactUri.js";
-import { DEFAULT_PREFIX_MAP } from "../../kernel/render/prefixes.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-import type { TierLookupData } from "./lookup.render.js";
-
-/**
- * Read every tier name in the store (its `ds:name`), ordered.
- *
- * The bespoke lookup already holds the machinery to reach the store, so a
- * name-not-found can rank "did you mean?" candidates the same way every other
- * entity lookup does — the tier list is a single cheap SELECT away.
- *
- * @param rt - The runtime (its store is booted by the projector for needsStore).
- * @returns The tier names, ordered.
- * @note Impure — queries the store through `runSelect`.
- */
-async function selectTierNames(rt: PragmaRuntime): Promise<string[]> {
-  const rows = await runSelect(
-    rt,
-    "SELECT ?name WHERE { ?tier a ds:Tier ; ds:name ?name } ORDER BY ?name",
-    "tier",
-  );
-  return rows
-    .map((row) => row.name as string | undefined)
-    .filter((name): name is string => Boolean(name));
-}
-
-/**
- * Look up one tier by name.
- *
- * @param rt - The runtime (its store is booted by the projector for needsStore).
- * @param name - The tier name (its `ds:name`, e.g. `apps/lxd`).
- * @returns The tier's IRI, name, and directly-scoped block names.
- * @throws PragmaError ENTITY_NOT_FOUND when no tier has that name;
- *   STORE_UNAVAILABLE (exit 3) when the store is unseeded for this project.
- */
-export async function runTierLookup(
-  rt: PragmaRuntime,
-  name: string,
-): Promise<TierLookupData> {
-  const query = [
-    "SELECT ?uri ?blockName WHERE {",
-    "  ?uri a ds:Tier ; ds:name ?tierName .",
-    `  FILTER(STR(?tierName) = ${JSON.stringify(name)})`,
-    "  OPTIONAL { ?block ds:tier ?uri ; ds:name ?blockName }",
-    "}",
-    "ORDER BY ?blockName",
-  ].join("\n");
-
-  // Route through `runSelect` (not `rt.query.sparql` directly) so a cold/unseeded
-  // store — a generated `ds:` query hitting an unknown prefix — is remapped to an
-  // actionable STORE_UNAVAILABLE with `pragma sources update` recovery, instead of
-  // a raw "Prefix not found" collapsing to INTERNAL_ERROR at the boundary.
-  const rows = await runSelect(rt, query, "tier");
-  const uri = rows[0]?.uri;
-  if (!uri) {
-    // Rank "did you mean?" candidates from the full tier list — the only entity
-    // lookup that used to omit suggestions, though (like the others) it has the
-    // names in hand. The suggestion query runs only on this cold, not-found path.
-    const suggestions = suggestNames(name, await selectTierNames(rt));
-    throw PragmaError.notFound("tier", name, {
-      suggestions,
-      recovery: {
-        message: "List available tiers.",
-        cli: "pragma tier list",
-        mcp: { tool: "tier_list" },
-      },
-    });
-  }
-  const blocks = rows
-    // `blockName` rides an OPTIONAL, so the key is absent for a memberless tier.
-    .map((row) => row.blockName as string | undefined)
-    .filter((block): block is string => Boolean(block));
-  return { uri: compactUri(uri, DEFAULT_PREFIX_MAP), name, blocks };
-}

package/src/capabilities/token/addConfig.render.ts

@@ -1,27 +0,0 @@
-/**
- * Formatters for `token add-config` — plain, llm, json.
- */
-
-import type { Formatters } from "../../kernel/spec/types.js";
-import type { AddConfigResult } from "./runAddConfig.js";
-
-export const addConfigFormatters: Formatters<AddConfigResult> = {
-  plain(data) {
-    const lines = [
-      `${data.alreadyExisted ? "Updated" : "Wrote"} ${data.path}`,
-      `  ${data.tokenCount} token${data.tokenCount === 1 ? "" : "s"} in the active graph`,
-      `  sources: ${data.sources.join(", ")}`,
-    ];
-    return lines.join("\n");
-  },
-  llm(data) {
-    return [
-      `${data.alreadyExisted ? "Updated" : "Wrote"} \`${data.path}\` for the terrazzo token pipeline.`,
-      `- ${data.tokenCount} token(s) in the active graph`,
-      `- sources: ${data.sources.map((source) => `\`${source}\``).join(", ")}`,
-    ].join("\n");
-  },
-  json(data) {
-    return JSON.stringify(data);
-  },
-};

package/src/capabilities/token/addConfig.test.ts

@@ -1,62 +0,0 @@
-import { existsSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
-import { CANONICAL_TTL } from "../../testing/fixtures/graph/canonical.js";
-import {
-  bootFixtureRuntime,
-  type FixtureGraph,
-} from "../../testing/helpers/fixtureGraph.js";
-import type { McpHarness } from "../../testing/helpers/projectMcp.js";
-import { projectMcp } from "../../testing/helpers/projectMcp.js";
-import { capabilities } from "../index.js";
-
-let fixture: FixtureGraph;
-let mcp: McpHarness;
-let configPath: string;
-
-beforeAll(async () => {
-  fixture = await bootFixtureRuntime({ ttl: CANONICAL_TTL });
-  mcp = await projectMcp(capabilities, fixture.cwd);
-  configPath = join(fixture.cwd, "tokens.config.mjs");
-});
-
-afterAll(async () => {
-  await mcp.cleanup();
-  await fixture.dispose();
-});
-
-beforeEach(() => {
-  rmSync(configPath, { force: true });
-});
-
-describe("token_add-config — plan-first mutation (PROTECTED)", () => {
-  it("without confirm, returns a plan and writes NOTHING", async () => {
-    const result = await mcp.callTool("token_add-config");
-    expect(result.ok).toBe(true);
-    const meta = result.meta as {
-      planOnly?: boolean;
-      confirmRequired?: boolean;
-    };
-    expect(meta.planOnly).toBe(true);
-    expect(meta.confirmRequired).toBe(true);
-    const data = result.data as { plan: string[] };
-    expect(data.plan.join("\n")).toMatch(/tokens\.config\.mjs/);
-    expect(existsSync(configPath)).toBe(false);
-  });
-
-  it("with confirm, writes a terrazzo config reflecting the store token count", async () => {
-    const result = await mcp.callTool("token_add-config", { confirm: true });
-    expect(result.ok).toBe(true);
-    const data = result.data as {
-      path: string;
-      tokenCount: number;
-      sources: string[];
-    };
-    expect(existsSync(configPath)).toBe(true);
-    // The canonical fixture holds 2 ds:Token entities.
-    expect(data.tokenCount).toBe(2);
-    const written = readFileSync(configPath, "utf-8");
-    expect(written).toContain("defineConfig");
-    expect(written).toContain("@canonical/terrazzo");
-  });
-});

package/src/capabilities/token/addConfig.verb.ts

@@ -1,40 +0,0 @@
-/**
- * `token add-config` — generate a terrazzo `tokens.config.mjs` (the one `token`
- * mutation). Store-backed (needsStore, per covenant) so it can report the token
- * count; plan-first through the uniform mutation seam (a tool call without
- * `confirm` returns the write plan; `--dry-run`/`--yes` on the CLI). No params —
- * the covenant emits `{ v: "add-config", mutates: true, needsStore: true }`.
- */
-
-import type { Task } from "@canonical/task";
-import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { VerbSpec } from "../../kernel/spec/types.js";
-import { addConfigFormatters } from "./addConfig.render.js";
-import type { AddConfigResult } from "./runAddConfig.js";
-
-const addConfigVerb: VerbSpec<Record<string, unknown>, AddConfigResult> = {
-  path: ["token", "add-config"],
-  summary: "Generate a tokens.config.mjs for the terrazzo token pipeline.",
-  doc: "Writes a terrazzo `defineConfig` at the project root, sourcing token JSON from the configured design-system packages. Store-backed so it reports how many tokens the active graph holds. Plan-first: returns the write plan until you confirm.",
-  params: [],
-  output: { formatters: addConfigFormatters },
-  examples: [
-    { cmd: "pragma token add-config --dry-run", note: "preview the write" },
-    { cmd: "pragma token add-config --yes", note: "write the config" },
-  ],
-  capability: {
-    needsStore: true,
-    mutates: true,
-    mcp: {
-      expose: true,
-      annotations: { readOnlyHint: false, openWorldHint: false },
-    },
-  },
-  run: (_params, rt) =>
-    import("./runAddConfig.js").then((m) =>
-      m.runAddConfig(rt),
-    ) as unknown as Task<AddConfigResult>,
-};
-
-/** The `token add-config` verb, widened for registry composition. */
-export const tokenAddConfigVerb = asVerb(addConfigVerb);

package/src/capabilities/token/index.ts

@@ -1,19 +0,0 @@
-/**
- * The `token` capability module — the bundled SPARQL pack compiled to verbs.
- */
-
-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 { tokenAddConfigVerb } from "./addConfig.verb.js";
-import { tokenPack } from "./pack.js";
-
-/** The `token` capability module — the bundled read pack plus the `add-config`
- * mutation (hand-written; the pack compiler emits reads only). */
-export const tokenModule: CapabilityModule = {
-  name: "token",
-  verbs: [
-    ...compilePack(tokenPack, "bundled:token", DEFAULT_PREFIX_MAP),
-    tokenAddConfigVerb,
-  ],
-};