@canonical/pragma-cli 0.32.0 → 0.34.0

package/src/capabilities/block/tierChain.ts

@@ -1,78 +0,0 @@
-/**
- * Tier-chain inheritance + channel visibility for the hand-written `block list`.
- *
- * Ported from the v1 filters. Setting a tier activates a parent-chain filter
- * (`apps/lxd` → visible tiers `global`, `apps`, `apps/lxd`); the channel maps to
- * the set of visible release levels. Both are generated SPARQL clauses composed
- * only from validated pack terms — no user input reaches the query text (the
- * tier value comes from config, the channel from a closed enum).
- */
-
-import type { Channel } from "../../kernel/config/types.js";
-
-/** The `ds:` prefix — the store injects its PREFIX declaration. */
-const DS = "ds:";
-
-/** Release levels visible per channel setting. */
-export const CHANNEL_RELEASES: Record<Channel, readonly string[]> = {
-  normal: ["stable"],
-  experimental: ["stable", "experimental"],
-  prerelease: ["stable", "experimental", "alpha", "beta"],
-};
-
-/**
- * The parent chain for a tier path.
- *
- * `apps/lxd` → `["global", "apps", "apps/lxd"]`; `undefined` → `[]` (all tiers).
- */
-export function resolveTierChain(tierPath: string | undefined): string[] {
-  if (tierPath === undefined) return [];
-  const normalized = tierPath.trim().toLowerCase();
-  const chain: string[] = ["global"];
-  const segments = normalized.split("/");
-  for (let i = 0; i < segments.length; i++) {
-    const path = segments.slice(0, i + 1).join("/");
-    if (path !== "global") chain.push(path);
-  }
-  return chain;
-}
-
-/** A tier path's URI local name (slashes → underscores: `apps/lxd` → `apps_lxd`). */
-export function tierPathToLocal(tierPath: string): string {
-  return tierPath.trim().toLowerCase().replace(/\//g, "_");
-}
-
-/**
- * A SPARQL FILTER clause for tier visibility, or empty when no tier is set.
- *
- * @param tierPath - The configured tier path (e.g. `apps/lxd`) or `undefined`.
- * @param varName - The SPARQL variable to filter (default `tier`).
- */
-export function buildTierFilter(
-  tierPath: string | undefined,
-  varName = "tier",
-): string {
-  if (tierPath === undefined) return "";
-  const uriList = resolveTierChain(tierPath)
-    .map((t) => `${DS}${tierPathToLocal(t)}`)
-    .join(", ");
-  return `FILTER(?${varName} IN (${uriList}))`;
-}
-
-/**
- * SPARQL clauses for channel visibility: bind `?release` if present, then filter
- * to allowed levels OR unbound (unannotated blocks are treated as stable).
- *
- * @param channel - The configured channel.
- * @param varName - The SPARQL variable to bind/filter (default `release`).
- */
-export function buildChannelFilter(
-  channel: Channel,
-  varName = "release",
-): string {
-  const uriList = CHANNEL_RELEASES[channel].map((r) => `${DS}${r}`).join(", ");
-  return [
-    `OPTIONAL { ?component ${DS}release ?${varName} }`,
-    `FILTER(!BOUND(?${varName}) || ?${varName} IN (${uriList}))`,
-  ].join("\n    ");
-}

package/src/capabilities/colophon/pragmaColophon.ts

@@ -1,66 +0,0 @@
-/**
- * The built-in pragma colophon — how the toolchain itself is made. Authored
- * Markdown grounded in this tree's real architecture; surfaced by `pragma
- * colophon` as the first section, before any active pack's domain colophon.
- *
- * `PRAGMA_COLOPHON` is the full narrative for humans; `PRAGMA_COLOPHON_SUMMARY`
- * is the condensed form `--llm` emits (Markdown IS the agent-optimal shape).
- * Both are BODIES with no leading H1 — the renderer supplies the "pragma"
- * heading, so the section is never double-titled.
- */
-
-/** The full built-in colophon (Markdown body). */
-export const PRAGMA_COLOPHON = `pragma is a **domain-based toolchain**: one CLI and one MCP server projected
-from a single grammar, serving a knowledge-graph domain that reads as data.
-
-## The effect monad
-
-Reads are plain \`async\` functions; a mutation instead *describes* its effects
-as a \`Task\` (\`@canonical/task\`) that is interpreted — under the real node
-interpreter, a \`--dry-run\` planner, or an \`--undo\` reverser. Describe-then-
-interpret means dry-run and undo come for free, and the dispatcher tells the two
-worlds apart on one bit: \`capability.mutates\`.
-
-## One grammar, many projections
-
-Every capability is a \`VerbSpec\` — a noun, its params, its effect profile, its
-formatters. The CLI commands, the MCP tools, shell completion, and the
-surface/docs are all *projections* of that one shape, so they cannot drift. The
-projected surface is frozen in a covenant (\`surface/surface.v2.json\`): a single
-source of truth a test asserts the live grammar still emits, tool for tool.
-
-## LLM-optimized output
-
-Each verb renders three ways — \`plain\` for a terminal, \`json\` for the machine
-envelope, and \`llm\` for condensed Markdown. \`--llm\` (or a non-interactive
-stdout) selects the agent form: the same data, shaped for a model to read. This
-colophon is itself a showcase of that render model.
-
-## Modular, storeless by construction
-
-Capabilities ship as **modules** — named bundles of verbs with optional
-boot / resource / prompt hooks. A verb declares whether it \`needsStore\`, and
-the dispatcher boots the triple store *only* for those; a storeless verb
-(\`info\`, \`config\`, \`capabilities\`, \`colophon\`) never pays for the graph.
-
-## Scaffolding
-
-\`pragma create\` scaffolds components, packages, and applications through the
-\`@canonical/summon-*\` generators, reusing summon's rich Ink wizard when it runs
-interactively.
-
-## The domain reads as data
-
-A domain is a **pack**: a declarative \`PackDefinition\` (its list / lookup
-queries) compiled into verbs, backed by a content-addressed graphpack that
-\`sources update\` builds once. Swap the pack and the same pragma serves a
-different domain — including the domain colophon printed below this one.`;
-
-/** The condensed colophon for `--llm` (Markdown body, no leading H1). */
-export const PRAGMA_COLOPHON_SUMMARY = `pragma is a domain-based toolchain: one CLI + MCP server projected from a single \`VerbSpec\` grammar.
-
-- **Effect monad** (\`@canonical/task\`): reads are async; a mutation returns an interpreted \`Task\`, so \`--dry-run\` and \`--undo\` are free. The dispatcher branches on \`capability.mutates\`.
-- **One grammar, many projections**: CLI, MCP tools, completion, and docs all project one \`VerbSpec\`; the emitted surface is frozen in a covenant so the projections never drift.
-- **LLM-optimized output**: every verb renders \`plain\` / \`json\` / \`llm\`; \`--llm\` emits condensed Markdown for agents.
-- **Modular + storeless**: capability modules; the triple store boots only for \`needsStore\` verbs.
-- **Domain as data**: a pack is a declarative \`PackDefinition\` compiled to verbs over a content-addressed graph built by \`sources update\`.`;

package/src/capabilities/config/field.test.ts

@@ -1,188 +0,0 @@
-/**
- * `config tier` / `channel` / `detail` — storeless, covenant-exact setters.
- *
- * Pins the emitted shape against the golden slice, exercises set / reset-sentinel
- * / enum-reject / `--dry-run` plan / MCP plan-first-vs-confirm, and holds the
- * storeless invariant (a config write never boots the store).
- */
-
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { globalConfigPath } from "../../kernel/config/paths.js";
-import { CHANNELS } from "../../kernel/config/types.js";
-import { PragmaError } from "../../kernel/error/PragmaError.js";
-import {
-  executeVerb,
-  extractParams,
-} from "../../kernel/project/cli/dispatch.js";
-import { bootRuntime } from "../../kernel/runtime/boot.js";
-import type { GlobalFlags, PragmaRuntime } from "../../kernel/runtime/types.js";
-import { emitVerb } from "../../kernel/spec/emitSurface.js";
-import type { VerbSpec } from "../../kernel/spec/types.js";
-import { projectMcp } from "../../testing/helpers/projectMcp.js";
-import { CONFIG_FIELDS } from "./fields.js";
-import { configModule } from "./index.js";
-import { runField } from "./runField.js";
-
-const FLAGS: GlobalFlags = {
-  llm: false,
-  autoLlm: false,
-  format: "plain",
-  verbose: false,
-};
-const REAL = { dryRun: false, undo: false, yes: false };
-const DRY = { dryRun: true, undo: false, yes: false };
-
-const verbOf = (field: string): VerbSpec =>
-  configModule.verbs.find((v) => v.path[1] === field) as VerbSpec;
-const tierVerb = verbOf("tier");
-const channelVerb = verbOf("channel");
-const detailVerb = verbOf("detail");
-
-let prevXdg: string | undefined;
-const roots: string[] = [];
-const tmp = (prefix: string): string => {
-  const dir = mkdtempSync(join(tmpdir(), prefix));
-  roots.push(dir);
-  return dir;
-};
-
-beforeEach(() => {
-  prevXdg = process.env.XDG_CONFIG_HOME;
-  process.env.XDG_CONFIG_HOME = tmp("pragma-cfgfield-xdg-");
-});
-afterEach(() => {
-  process.env.XDG_CONFIG_HOME = prevXdg;
-  for (const dir of roots) rmSync(dir, { recursive: true, force: true });
-  roots.length = 0;
-});
-
-function readGlobal(): Record<string, unknown> {
-  return JSON.parse(readFileSync(globalConfigPath(), "utf-8"));
-}
-
-describe("config setters — covenant-exact emission (PROTECTED)", () => {
-  it("emits the golden slice for each field", () => {
-    expect(emitVerb(tierVerb)).toEqual({
-      v: "tier",
-      args: ["<path>"],
-      mutates: true,
-      mcp: "config_tier",
-    });
-    expect(emitVerb(channelVerb)).toEqual({
-      v: "channel",
-      args: ["<name>"],
-      mutates: true,
-      mcp: "config_channel",
-    });
-    expect(emitVerb(detailVerb)).toEqual({
-      v: "detail",
-      args: ["<level>"],
-      mutates: true,
-      mcp: "config_detail",
-    });
-  });
-});
-
-describe("config setters — write & reset", () => {
-  it("set writes the field to the GLOBAL config and never boots the store", async () => {
-    const rt: PragmaRuntime = bootRuntime(FLAGS, tmp("pragma-proj-"));
-    const outcome = await executeVerb(tierVerb, { path: "apps/lxd" }, REAL, rt);
-
-    expect(outcome.exitCode).toBe(0);
-    expect(outcome.stdout).toContain("Set tier = apps/lxd");
-    expect(readGlobal().tier).toBe("apps/lxd");
-    // Storeless invariant: a config write never touches the store factory.
-    expect(rt.store.booted).toBe(false);
-  });
-
-  it("channel/detail write their enum value", async () => {
-    const rt = bootRuntime(FLAGS, tmp("pragma-proj-"));
-    await executeVerb(channelVerb, { name: "experimental" }, REAL, rt);
-    await executeVerb(detailVerb, { level: "detailed" }, REAL, rt);
-    const written = readGlobal();
-    expect(written.channel).toBe("experimental");
-    expect(written.detail).toBe("detailed");
-  });
-
-  it("a reset sentinel removes the tier field", async () => {
-    const cwd = tmp("pragma-proj-");
-    await executeVerb(
-      tierVerb,
-      { path: "apps/lxd" },
-      REAL,
-      bootRuntime(FLAGS, cwd),
-    );
-    expect(readGlobal().tier).toBe("apps/lxd");
-
-    const outcome = await executeVerb(
-      tierVerb,
-      { path: "none" },
-      REAL,
-      bootRuntime(FLAGS, cwd),
-    );
-    expect(outcome.stdout).toContain("Reset tier");
-    expect("tier" in readGlobal()).toBe(false);
-  });
-});
-
-describe("config setters — enum rejection", () => {
-  it("the CLI coerce layer rejects a non-member with INVALID_INPUT + validOptions", () => {
-    let caught: unknown;
-    try {
-      extractParams(channelVerb.params, ["bogus"], {});
-    } catch (error) {
-      caught = error;
-    }
-    expect(caught).toBeInstanceOf(PragmaError);
-    expect((caught as PragmaError).code).toBe("INVALID_INPUT");
-    expect((caught as PragmaError).validOptions).toEqual([...CHANNELS]);
-  });
-
-  it("runField backstops a bad enum value before it reaches disk", () => {
-    const channelSpec = CONFIG_FIELDS.find((s) => s.field === "channel");
-    expect(() =>
-      runField(channelSpec as (typeof CONFIG_FIELDS)[number], {
-        name: "bogus",
-      }),
-    ).toThrow(/Invalid channel/);
-  });
-});
-
-describe("config setters — dry-run plan", () => {
-  it("--dry-run shows the WriteFile plan and writes nothing", async () => {
-    const rt = bootRuntime(FLAGS, tmp("pragma-proj-"));
-    const outcome = await executeVerb(tierVerb, { path: "apps/lxd" }, DRY, rt);
-
-    expect(outcome.exitCode).toBe(0);
-    expect(outcome.stdout).toContain("Write file");
-    expect(outcome.stdout).toContain(globalConfigPath());
-    expect(existsSync(globalConfigPath())).toBe(false);
-  });
-});
-
-describe("config setters — MCP plan-first / confirm parity", () => {
-  it("config_tier returns a plan without confirm, writes with confirm:true", async () => {
-    const cwd = tmp("pragma-proj-");
-    const mcp = await projectMcp([configModule], cwd);
-
-    const plan = await mcp.callTool("config_tier", { path: "apps/lxd" });
-    expect(plan.ok).toBe(true);
-    expect(plan.meta).toMatchObject({ planOnly: true, confirmRequired: true });
-    const planLines = (plan.data as { plan: string[] }).plan;
-    expect(planLines.some((line) => line.includes("Write file"))).toBe(true);
-    expect(existsSync(globalConfigPath())).toBe(false);
-
-    const done = await mcp.callTool("config_tier", {
-      path: "apps/lxd",
-      confirm: true,
-    });
-    await mcp.cleanup();
-
-    expect(done.ok).toBe(true);
-    expect(done.data).toMatchObject({ field: "tier", value: "apps/lxd" });
-    expect(readGlobal().tier).toBe("apps/lxd");
-  });
-});

package/src/capabilities/modifier/index.ts

@@ -1,15 +0,0 @@
-/**
- * The `modifier` capability module — the bundled pack (SPARQL list, GraphQL
- * lookup) 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 { modifierPack } from "./pack.js";
-
-/** The `modifier` capability module (`list`, `lookup`). */
-export const modifierModule: CapabilityModule = {
-  name: "modifier",
-  verbs: compilePack(modifierPack, "bundled:modifier", DEFAULT_PREFIX_MAP),
-};

package/src/capabilities/modifier/pack.ts

@@ -1,64 +0,0 @@
-/**
- * The bundled `modifier` pack — modifier families as data.
- *
- * `modifier list` is SPARQL (an alternation path collects values asserted in
- * either direction); `modifier lookup` is GRAPHQL, where the compiled
- * `ModifierFamily.modifiers` field is the declared-inverse union and resolves
- * both directions in ONE generated document — exactly the case the GraphQL fetch
- * path exists for.
- */
-
-import type { PackDefinition } from "../../kernel/packs/types.js";
-
-export const modifierPack: PackDefinition = {
-  noun: "modifier",
-  description: "List all modifier families.",
-  toolDescription:
-    "List all modifier families with their values. Use when browsing which modifier families exist and the values each allows. Example: modifier_list {}.",
-  list: {
-    query: [
-      "SELECT ?uri ?name",
-      '       (GROUP_CONCAT(DISTINCT ?valueName; separator=", ") AS ?values)',
-      "WHERE {",
-      "  ?uri a ds:ModifierFamily ;",
-      "       ds:name ?name .",
-      "  OPTIONAL {",
-      "    ?uri (ds:hasModifier|^ds:modifierFamily) ?value .",
-      "    ?value ds:name ?valueName .",
-      "  }",
-      "}",
-      "GROUP BY ?uri ?name",
-      "ORDER BY ?name",
-    ].join("\n"),
-    columns: [
-      { field: "uri", label: "IRI" },
-      { field: "name", label: "Name" },
-      { field: "values", label: "Values" },
-    ],
-    emptyRecovery: {
-      message:
-        "No modifier families in the store. Build it from the configured design-system packages.",
-      cli: "pragma sources update",
-    },
-  },
-  lookup: {
-    source: "graphql",
-    by: "ds:name",
-    type: "ds:ModifierFamily",
-    toolDescription:
-      'Get values and usage details for one or more modifier families by name. Use when you need the allowed values of specific families. Example: modifier_lookup { names: ["importance"] }.',
-    expand: [
-      {
-        name: "values",
-        heading: "Values",
-        relation: "ds:hasModifier",
-        select: [{ name: "name", property: "ds:name" }],
-      },
-    ],
-    sample: {
-      fixedCount: true,
-      toolDescription:
-        "Return randomly selected complete modifier families (with value lists) as exemplars. Use BEFORE writing queries to see actual data shapes.",
-    },
-  },
-};

package/src/capabilities/standard/index.ts

@@ -1,18 +0,0 @@
-/**
- * The `standard` capability module — the bundled pack compiled to verbs.
- *
- * Compiled at import (fast-path safe: compilePack is pure/zod-free) so the module
- * is surface-deterministic. A config/package story for `standard` overrides it at
- * dispatch (see kernel/packs/collect).
- */
-
-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 { standardPack } from "./pack.js";
-
-/** The `standard` capability module (list, categories, lookup, sample). */
-export const standardModule: CapabilityModule = {
-  name: "standard",
-  verbs: compilePack(standardPack, "bundled:standard", DEFAULT_PREFIX_MAP),
-};

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.ts

@@ -1,34 +0,0 @@
-/**
- * Formatters + data shape for `tier lookup <name>`.
- */
-
-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[];
-}
-
-export const tierLookupFormatters: Formatters<TierLookupData> = {
-  plain(data) {
-    const lines = [`${data.name} (${data.uri})`];
-    lines.push(
-      data.blocks.length > 0
-        ? `  blocks: ${data.blocks.join(", ")}`
-        : "  blocks: (none scoped directly to this tier)",
-    );
-    return lines.join("\n");
-  },
-  llm(data) {
-    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,68 +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");
-  });
-});
-
-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" });
-  });
-});