@canonical/pragma-cli 0.34.0 → 0.36.0

package/src/capabilities/graph/inspect.verb.ts

@@ -8,19 +8,23 @@
  * name or absolute IRI addresses the subject exactly.
  */
 
-import { BIN_NAME } from "../../constants.js";
+import {
+  BIN_NAME,
+  DEFAULT_DETAIL_LEVEL,
+  DETAIL_LEVELS,
+} from "../../constants.js";
+import type { PragmaRuntime } from "../../kernel/runtime/index.js";
 import type { InspectResult } from "../../kernel/runtime/readEntity.js";
 import { readEntity } from "../../kernel/runtime/readEntity.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
 import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { VerbSpec } from "../../kernel/spec/types.js";
+import type { VerbSpec } from "../../kernel/spec/index.js";
 import { inspectFormatters } from "./inspect.render.js";
 
 const inspectVerb: VerbSpec<Record<string, unknown>, InspectResult> = {
   path: ["graph", "inspect"],
   summary:
     "Show every triple where a URI is the subject, grouped by predicate.",
-  doc: "Inspect one entity: all predicate/object pairs asserted on the subject. Address it by prefixed name (ds:button) or absolute IRI.",
+  doc: "Inspect one entity: all predicate/object pairs asserted on the subject. Address it by prefixed name (ds:global.component.button) or absolute IRI.",
   params: [
     {
       kind: "string",
@@ -32,9 +36,17 @@ const inspectVerb: VerbSpec<Record<string, unknown>, InspectResult> = {
     },
   ],
   output: { formatters: inspectFormatters },
+  // The read is BOUNDED by disclosure — inbound exemplars and literal previews
+  // both widen with the level — so the verb must declare the ladder it honours.
+  // Without this the CLI `--detail` flag has nothing to validate against and the
+  // MCP projector injects no `detail` argument at all, so the documented knob
+  // was one an agent could not actually reach.
+  disclosure: { levels: [...DETAIL_LEVELS], default: DEFAULT_DETAIL_LEVEL },
   examples: [
-    { cmd: `${BIN_NAME} graph inspect ds:button` },
-    { cmd: `${BIN_NAME} graph inspect https://ds.canonical.com/button` },
+    { cmd: `${BIN_NAME} graph inspect ds:global.component.button` },
+    {
+      cmd: `${BIN_NAME} graph inspect https://ds.canonical.com/global.component.button`,
+    },
   ],
   capability: {
     needsStore: true,

package/src/capabilities/graph/query.render.ts

@@ -9,7 +9,7 @@
  * - json: the serialized {@link QueryResult}.
  */
 
-import type { Formatters } from "../../kernel/spec/types.js";
+import type { Formatters } from "../../kernel/spec/index.js";
 
 // Inline `import("…")` type (no `from`) — keeps the ke types off the static
 // import graph the lazy-dispatch probe walks (see query.verb.ts).
@@ -36,9 +36,21 @@ function formatTriples(
 }
 
 export const queryFormatters: Formatters<QueryResult> = {
+  // Zero rows/triples: plain stdout stays empty — the notice is
+  // `notice`, routed to stderr (exit 0) by the dispatcher so a pipe
+  // reads no prose. ASK always has a result and never goes empty.
+  notice(result) {
+    if (result.type === "select" && result.bindings.length === 0) {
+      return "No results.";
+    }
+    if (result.type === "construct" && result.triples.length === 0) {
+      return "No triples.";
+    }
+    return undefined;
+  },
   plain(result) {
     if (result.type === "select") {
-      if (result.bindings.length === 0) return "No results.";
+      if (result.bindings.length === 0) return "";
       const cols = Object.keys(result.bindings[0] ?? {});
       const rows = result.bindings.map((b) =>
         cols.map((c) => b[c] ?? "").join("\t"),
@@ -48,7 +60,7 @@ export const queryFormatters: Formatters<QueryResult> = {
     if (result.type === "ask") {
       return `ASK: ${String(result.result)}`;
     }
-    return formatTriples(result.triples);
+    return result.triples.length === 0 ? "" : formatTriples(result.triples);
   },
 
   llm(result) {

package/src/capabilities/graph/query.verb.ts

@@ -10,9 +10,9 @@
  */
 
 import { BIN_NAME } from "../../constants.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
+import type { PragmaRuntime } from "../../kernel/runtime/index.js";
 import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { VerbSpec } from "../../kernel/spec/types.js";
+import type { VerbSpec } from "../../kernel/spec/index.js";
 import { queryFormatters } from "./query.render.js";
 
 // Inline `import("…")` type (no `from`) so the ke types stay OFF the static
@@ -40,7 +40,7 @@ const queryVerb: VerbSpec<Record<string, unknown>, QueryResult> = {
       note: "list every component subject",
     },
     {
-      cmd: `${BIN_NAME} graph query "ASK { ds:button a ds:Component }" --format json`,
+      cmd: `${BIN_NAME} graph query "ASK { <https://ds.canonical.com/global.component.button> a ds:Component }" --format json`,
     },
   ],
   capability: {

package/src/capabilities/graph/runQuery.ts

@@ -10,9 +10,8 @@
  */
 
 import type { QueryResult } from "@canonical/ke";
-import { PragmaError } from "../../kernel/error/PragmaError.js";
-import { cliRecovery } from "../../kernel/error/recovery.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
+import { cliRecovery, PragmaError } from "../../kernel/error/index.js";
+import type { PragmaRuntime } from "../../kernel/runtime/index.js";
 
 /**
  * Execute a raw SPARQL query against the booted store.

package/src/capabilities/index.ts

@@ -14,7 +14,7 @@
  * `--help`/`__complete` fast paths stay free of the config reader and zod.
  */
 
-import type { CapabilityModule } from "../kernel/spec/types.js";
+import type { CapabilityModule } from "../kernel/spec/index.js";
 import { capabilitiesModule } from "./capabilities/index.js";
 import { colophonModule } from "./colophon/index.js";
 import { configModule } from "./config/index.js";
@@ -30,10 +30,12 @@ import { setupModule } from "./setup/index.js";
 import { skillModule } from "./skill/index.js";
 import { sourcesModule } from "./sources/index.js";
 import { upgradeModule } from "./upgrade/index.js";
+import { versionModule } from "./version/index.js";
 
 /** The modules with hand-written code, in authoring order. */
 const authored: readonly CapabilityModule[] = [
   infoModule,
+  versionModule,
   configModule,
   createModule,
   sourcesModule,

package/src/capabilities/info/collectInfo.ts

@@ -18,14 +18,16 @@ import {
   entityTotal,
   readPackIndex,
 } from "../../kernel/completion/entitySource.js";
-import { readConfig } from "../../kernel/config/readConfig.js";
+import { readConfig } from "../../kernel/config/index.js";
+import type { PragmaRuntime } from "../../kernel/runtime/index.js";
 import { resolveSources } from "../../kernel/runtime/resolveSources.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
 import {
+  checkRegistryVersion,
   detectInstallSource,
+  PRAGMA_PACKAGE,
   pmUpdateCommand,
-} from "../shared/packageManager.js";
-import { checkRegistryVersion, PRAGMA_PACKAGE } from "../shared/registry.js";
+  updateGuidance,
+} from "../shared/index.js";
 import type { InfoData, InfoUpdate } from "./types.js";
 
 /**
@@ -43,12 +45,17 @@ export async function collectInfo(runtime: PragmaRuntime): Promise<InfoData> {
 
   // Update-check: unconditional (no flag exists), 3s timeout, silent-fail.
   const registry = await checkRegistryVersion(PRAGMA_PACKAGE, config.channel);
+  // Only a GLOBAL install gets a command; every other state gets the honest
+  // guidance sentence — a confidently wrong `npm i -g` against a linked
+  // checkout would overwrite the development link.
   const update: InfoUpdate | undefined =
     registry && registry.latest !== runtime.version
       ? {
           current: runtime.version,
           latest: registry.latest,
-          command: pmUpdateCommand(install.pm, PRAGMA_PACKAGE),
+          ...(install.kind === "global"
+            ? { command: pmUpdateCommand(install, PRAGMA_PACKAGE) }
+            : { guidance: updateGuidance(install) }),
         }
       : undefined;
   const updateSkipped = registry === undefined;
@@ -61,6 +68,7 @@ export async function collectInfo(runtime: PragmaRuntime): Promise<InfoData> {
   return {
     version: runtime.version,
     installSource: install.label,
+    installKind: install.kind,
     ...(update ? { update } : {}),
     updateSkipped,
     ...(entities !== undefined ? { entities } : {}),

package/src/capabilities/info/info.render.ts

@@ -4,7 +4,7 @@
 
 import { BIN_NAME } from "../../constants.js";
 import type { ConfigOrigin } from "../../kernel/config/types.js";
-import type { Formatters } from "../../kernel/spec/types.js";
+import type { Formatters } from "../../kernel/spec/index.js";
 import type { InfoData } from "./types.js";
 
 /** A `[layer]` marker for values a config file supplied (blank for defaults). */
@@ -37,7 +37,9 @@ export const infoFormatters: Formatters<InfoData> = {
       lines.push(
         "",
         `Update available: ${data.update.current} → ${data.update.latest}`,
-        `  Run: ${data.update.command}`,
+        data.update.command
+          ? `  Run: ${data.update.command}`
+          : `  ${data.update.guidance}`,
       );
     }
     return lines.join("\n");
@@ -61,7 +63,9 @@ export const infoFormatters: Formatters<InfoData> = {
     }
     if (data.update) {
       lines.push(
-        `- Update available: ${data.update.current} → ${data.update.latest} (\`${data.update.command}\`)`,
+        data.update.command
+          ? `- Update available: ${data.update.current} → ${data.update.latest} (\`${data.update.command}\`)`
+          : `- Update available: ${data.update.current} → ${data.update.latest} — ${data.update.guidance}`,
       );
     }
     return lines.join("\n");

package/src/capabilities/info/info.test.ts

@@ -17,9 +17,26 @@ import { bootRuntime } from "../../kernel/runtime/boot.js";
 import type { GlobalFlags, PragmaRuntime } from "../../kernel/runtime/types.js";
 import type { VerbSpec } from "../../kernel/spec/types.js";
 import { projectMcp } from "../../testing/helpers/projectMcp.js";
+import type { InstallSource } from "../shared/index.js";
 import { infoModule } from "./index.js";
 import type { InfoData } from "./types.js";
 
+// Pin the install-source detection: the real detector reads THIS process
+// (whose entry is a source checkout — an honest `unknown`), and these tests
+// are about the enrichment around it, not the detection itself (covered by
+// `shared/packageManager.test.ts`). The holder lets a case retarget it.
+const detection = vi.hoisted(() => ({ install: undefined as unknown }));
+vi.mock("../shared/index.js", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  detectInstallSource: () => detection.install,
+}));
+
+const GLOBAL_NPM: InstallSource = {
+  kind: "global",
+  pm: "npm",
+  label: "npm (global)",
+};
+
 const infoVerb = infoModule.verbs[0] as VerbSpec;
 const FLAGS_JSON: GlobalFlags = {
   llm: false,
@@ -54,6 +71,7 @@ let prevXdg: string | undefined;
 beforeEach(() => {
   prevXdg = process.env.XDG_CONFIG_HOME;
   process.env.XDG_CONFIG_HOME = tmpCwd();
+  detection.install = GLOBAL_NPM;
 });
 afterEach(() => {
   process.env.XDG_CONFIG_HOME = prevXdg;
@@ -74,12 +92,30 @@ describe("info — update-check enrichment", () => {
     const data = await collect(rt);
 
     expect(data.update).toMatchObject({ current: VERSION, latest: "99.0.0" });
-    expect(data.update?.command).toContain("@canonical/pragma-cli");
+    expect(data.update?.command).toBe("npm i -g @canonical/pragma-cli");
+    expect(data.installSource).toBe("npm (global)");
+    expect(data.installKind).toBe("global");
     expect(data.updateSkipped).toBe(false);
     // The storeless invariant: the enrichment must NOT boot the store.
     expect(rt.store.booted).toBe(false);
   });
 
+  it("a LINKED install gets guidance, never a command (would clobber the link)", async () => {
+    detection.install = {
+      kind: "linked",
+      pm: "npm",
+      target: "/home/u/code/pragma/packages/cli/pragma",
+      label: "npm link (development checkout)",
+    } satisfies InstallSource;
+    stubRegistry("99.0.0");
+    const data = await collect(bootRuntime(FLAGS_JSON, tmpCwd()));
+
+    expect(data.installKind).toBe("linked");
+    expect(data.installSource).toBe("npm link (development checkout)");
+    expect(data.update?.command).toBeUndefined();
+    expect(data.update?.guidance).toMatch(/development checkout/i);
+  });
+
   it("marks `updateSkipped` when the registry is unreachable", async () => {
     stubRegistry("offline");
     const data = await collect(bootRuntime(FLAGS_JSON, tmpCwd()));

package/src/capabilities/info/info.verb.ts

@@ -8,7 +8,7 @@
 
 import { BIN_NAME } from "../../constants.js";
 import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { CapabilityModule, VerbSpec } from "../../kernel/spec/types.js";
+import type { CapabilityModule, VerbSpec } from "../../kernel/spec/index.js";
 import { infoFormatters } from "./info.render.js";
 import type { InfoData } from "./types.js";
 

package/src/capabilities/info/types.ts

@@ -3,6 +3,7 @@
  */
 
 import type { ConfigOrigins } from "../../kernel/config/types.js";
+import type { InstallKind } from "../../kernel/render/vocabulary.js";
 
 /** The config summary `info` reports — resolved values plus provenance. */
 export interface InfoConfig {
@@ -20,8 +21,12 @@ export interface InfoConfig {
 export interface InfoUpdate {
   readonly current: string;
   readonly latest: string;
-  /** The package-manager command that would apply the update. */
-  readonly command: string;
+  /** The package-manager command that would apply the update — only for a
+   * GLOBAL install; every other state carries {@link guidance} instead. */
+  readonly command?: string;
+  /** The honest sentence for an install with no sanctioned update command
+   * (linked / ephemeral / workspace / unknown). */
+  readonly guidance?: string;
 }
 
 /**
@@ -31,7 +36,10 @@ export interface InfoUpdate {
  */
 export interface InfoData {
   readonly version: string;
+  /** The install-source display label (e.g. `npm (global)`). */
   readonly installSource: string;
+  /** The install-source state the label renders. */
+  readonly installKind: InstallKind;
   /** Set when a newer CLI release is available on the active channel. */
   readonly update?: InfoUpdate;
   /** True when the registry could not be reached (the update-check was skipped). */

package/src/capabilities/lazy.test.ts

@@ -140,6 +140,38 @@ describe("lazy dispatch — module-graph probe (PROTECTED)", () => {
     }
   });
 
+  // The create surface's registration machinery — summon-core's projection
+  // helpers, its Commander adapter, and Commander itself — must stay behind
+  // the mount's dynamic import: `--help` and `__complete` both import this
+  // barrel and neither registers a single create command, so an eager edge
+  // here taxes every fast-path spawn for work only a dispatched `create`
+  // invocation performs. The registered flag/positional spellings the fast
+  // paths DO need (completion tokens, reference syntax) are baked into
+  // `createSurface.generated.ts` at build time, so nothing on this graph has
+  // to call the projection to learn them. Type-only imports are allowed —
+  // they are erased — which is why this walks import STATEMENTS rather than
+  // grepping for the specifier.
+  it("capabilities/index pulls no summon-core projection, adapter, or commander value import (PROTECTED)", () => {
+    const banned = [/^@canonical\/summon-core\/projection/, /^commander$/];
+    const graph = staticImportGraph(resolve(here, "index.ts"));
+    const pkgRoot = resolve(here, "..", "..");
+    // Anchored to line start so the word "import" inside a docblock cannot
+    // open a match that swallows prose down to the next real specifier.
+    const importRe = /^import\s+([^;]*?)from\s*["']([^"']+)["']/gm;
+    const offenders: string[] = [];
+    for (const file of graph) {
+      const source = readFileSync(file, "utf-8");
+      for (const match of source.matchAll(importRe)) {
+        const clause = match[1] as string;
+        const specifier = match[2] as string;
+        if (!banned.some((re) => re.test(specifier))) continue;
+        if (/^type\s/.test(clause.trim())) continue;
+        offenders.push(`${relative(pkgRoot, file)} → ${specifier}`);
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+
   it("NO module on that graph statically imports zod (PROTECTED)", () => {
     // This used to pin an exact set of one — `graphpack/types.ts`, reached via
     // `resolveSources` → `packIsComplete` → `readManifest` → `manifestSchema

package/src/capabilities/meta/complete.verb.ts

@@ -10,7 +10,7 @@
  * Storeless: the entity tier reads the index off disk, never booting the store.
  */
 
-import type { VerbSpec } from "../../kernel/spec/types.js";
+import type { VerbSpec } from "../../kernel/spec/index.js";
 
 /** The `__complete` verb spec. */
 export const completeVerb: VerbSpec<Record<string, unknown>, string[]> = {

package/src/capabilities/meta/index.ts

@@ -4,7 +4,7 @@
  */
 
 import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { CapabilityModule } from "../../kernel/spec/types.js";
+import type { CapabilityModule } from "../../kernel/spec/index.js";
 import { completeVerb } from "./complete.verb.js";
 import { mcpVerb } from "./mcp.verb.js";
 

package/src/capabilities/meta/mcp.verb.ts

@@ -1,19 +1,21 @@
 /**
- * The hidden `mcp` verb — the MCP server entry point.
+ * `mcp serve` — the MCP server entry point.
  *
- * The server is not an agent tool, so it is withheld from MCP with a reason and
- * `hidden` from the CLI surface/help. The bin special-cases `pragma mcp` to
- * serve over stdio (D9); this spec's lazy `run` is the same serve, reachable if
- * a future tier dispatches it.
+ * The server is not an agent tool, so it is withheld from MCP with a reason —
+ * but it IS a command, and it is spelled like one: a noun and a verb, the same
+ * shape as every other pair in the grammar, so it completes, appears in help,
+ * and answers `--help` without a special case. The bin still short-circuits
+ * the exact `pragma mcp serve` invocation before flag parsing and first-run,
+ * because the server's stdout carries JSON-RPC and nothing else may reach it;
+ * this spec's lazy `run` is that same serve, for any tier that dispatches it.
  */
 
-import type { VerbSpec } from "../../kernel/spec/types.js";
+import type { VerbSpec } from "../../kernel/spec/index.js";
 
 /** The `mcp` verb spec. */
 export const mcpVerb: VerbSpec<Record<string, unknown>, void> = {
-  path: ["mcp"],
+  path: ["mcp", "serve"],
   summary: "Start the MCP server over stdio.",
-  hidden: true,
   params: [],
   output: {
     formatters: {

package/src/capabilities/ontology/index.ts

@@ -2,18 +2,22 @@
  * The `ontology` capability module — schema (TBox) inspection.
  */
 
-import type { CapabilityModule } from "../../kernel/spec/types.js";
-import {
-  ontologyListVerb,
-  ontologyLookupVerb,
-  ontologyShowVerb,
-} from "./verbs.js";
+import type { CapabilityModule } from "../../kernel/spec/index.js";
+import { ontologyListVerb, ontologyLookupVerb } from "./verbs.js";
 
-/**
- * The `ontology` capability module (`list`, `lookup`, and the deprecated `show`
- * alias — AV-228 B1).
- */
+/** The `ontology` capability module (`list` and the `lookup` by-name read). */
 export const ontologyModule: CapabilityModule = {
   name: "ontology",
-  verbs: [ontologyListVerb, ontologyLookupVerb, ontologyShowVerb],
+  verbs: [ontologyListVerb, ontologyLookupVerb],
+  /**
+   * The ONE hand-declared listing in the distribution. Every other module is
+   * story-compiled and has its slice DERIVED from the types its lookup already
+   * names; this noun addresses the schema itself, which no `type` filter
+   * expresses — the whole TBox is the answer, so it is stated once, here.
+   *
+   * `0.5` puts the schema below the story collections (weight 1) it explains
+   * and above nothing else: an agent orienting itself wants the collections
+   * first, then the vocabulary they are described in.
+   */
+  mcpListable: { sources: [{ box: "tbox", as: "entities", weight: 0.5 }] },
 };

package/src/capabilities/ontology/ontology.test.ts

@@ -1,5 +1,5 @@
 /**
- * Ontology inspection (list + show) over the block fixture graph.
+ * Ontology inspection (list + lookup) over the block fixture graph.
  *
  * Asserts the TBox exception: namespaces are grouped with class/property counts,
  * a namespace's class hierarchy carries per-class instance counts from the pack
@@ -32,10 +32,6 @@ const listVerb = ontologyModule.verbs.find(
 const lookupVerb = ontologyModule.verbs.find(
   (v) => verbKey(v.path) === "ontology lookup",
 ) as VerbSpec;
-const showVerb = ontologyModule.verbs.find(
-  (v) => verbKey(v.path) === "ontology show",
-) as VerbSpec;
-
 let rt: PragmaRuntime;
 beforeAll(async () => {
   ({ rt } = await buildFixtureRuntime({
@@ -132,36 +128,11 @@ describe("ontology lookup (primary by-name read)", () => {
   });
 });
 
-describe("ontology show — deprecated alias of lookup (AV-228 B1)", () => {
-  it("is marked deprecated in its summary and steers callers to `ontology lookup`", () => {
-    expect(showVerb.summary.toLowerCase()).toContain("deprecated");
-    expect(showVerb.summary).toContain("ontology lookup");
-  });
-
-  it("shares the lookup handler — same payload for the same input", async () => {
-    const viaLookup = (await lookupVerb.run(
-      { prefix: "ds", properties: true },
-      rt,
-    )) as OntologyShowData;
-    const viaShow = (await showVerb.run(
-      { prefix: "ds", properties: true },
-      rt,
-    )) as OntologyShowData;
-    expect(viaShow).toEqual(viaLookup);
-  });
-
-  it("still rejects an unknown prefix (the alias is a full, callable verb)", async () => {
-    await expect(showVerb.run({ prefix: "nope" }, rt)).rejects.toThrow(
-      /prefix/i,
-    );
-  });
-});
-
-describe("ontology_show honours detail over MCP (B5)", () => {
-  // The CLI B5 cases above seed `globalFlags.detail` and call `showVerb.run`
+describe("ontology_lookup honours detail over MCP (B5)", () => {
+  // The CLI B5 cases above seed `globalFlags.detail` and call `lookupVerb.run`
   // directly. Over MCP there are NO global flags — the ONLY detail channel is
   // the per-tool `detail` param the projector injects from the VerbSpec
-  // disclosure. Under an AMBIENT config `detail: standard`, an `ontology_show`
+  // disclosure. Under an AMBIENT config `detail: standard`, a by-name read
   // with no declared disclosure would force the properties section with no
   // per-call escape (the AV-228 MCP-opt-out asymmetry `block`/`standard` lack);
   // declaring disclosure lights the param up, so an agent can ask for
@@ -184,15 +155,6 @@ describe("ontology_show honours detail over MCP (B5)", () => {
     await fixture.dispose();
   });
 
-  it("injects a detail param onto the ontology_show tool (symmetric with block/standard)", async () => {
-    const tools = await mcp.listTools();
-    const show = tools.find((t) => t.name === "ontology_show");
-    const schema = show?.inputSchema as {
-      properties?: Record<string, unknown>;
-    };
-    expect(schema.properties?.detail).toBeDefined();
-  });
-
   it("exposes the primary ontology_lookup tool with the same injected detail param (AV-228 B1)", async () => {
     const tools = await mcp.listTools();
     const lookup = tools.find((t) => t.name === "ontology_lookup");
@@ -217,25 +179,14 @@ describe("ontology_show honours detail over MCP (B5)", () => {
   it("honours the ambient detail=standard config when no per-call detail is set", async () => {
     // Proves the ambient level really is standard, so the summary case below is
     // a genuine per-call override rather than merely the spec default.
-    const result = await mcp.callTool("ontology_show", { prefix: "ds" });
+    const result = await mcp.callTool("ontology_lookup", { prefix: "ds" });
     expect(result.ok).toBe(true);
     const data = result.data as { properties: unknown[] };
     expect(data.properties.length).toBeGreaterThan(0);
   });
 
-  it("a per-call detail=summary returns classes-only despite the ambient standard", async () => {
-    const result = await mcp.callTool("ontology_show", {
-      prefix: "ds",
-      detail: "summary",
-    });
-    expect(result.ok).toBe(true);
-    const data = result.data as { classes: unknown[]; properties: unknown[] };
-    expect(data.classes.length).toBeGreaterThan(0);
-    expect(data.properties).toEqual([]);
-  });
-
   it("an explicit detail=detailed overrides upward to include properties", async () => {
-    const result = await mcp.callTool("ontology_show", {
+    const result = await mcp.callTool("ontology_lookup", {
       prefix: "ds",
       detail: "detailed",
     });

package/src/capabilities/ontology/queries.ts

@@ -7,7 +7,7 @@
  * result never depends on which vocabulary prefixes the store injected.
  */
 
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
+import type { PragmaRuntime } from "../../kernel/runtime/index.js";
 
 const OWL = "http://www.w3.org/2002/07/owl#";
 const RDFS = "http://www.w3.org/2000/01/rdf-schema#";
@@ -40,7 +40,7 @@ export interface OntologyProperty {
   readonly type: "object" | "datatype";
 }
 
-/** The `ontology show` payload — the detailed view plus render options. */
+/** The `ontology lookup` payload — the detailed view plus render options. */
 export interface OntologyShowData {
   readonly prefix: string;
   readonly namespace: string;

package/src/capabilities/ontology/render.ts

@@ -1,10 +1,9 @@
 /**
- * Formatters for `ontology list` and `ontology show`.
+ * Formatters for `ontology list` and `ontology lookup`.
  */
 
-import { compactUri } from "../../kernel/render/compactUri.js";
-import { DEFAULT_PREFIX_MAP } from "../../kernel/render/prefixes.js";
-import type { Formatters } from "../../kernel/spec/types.js";
+import { compactUri, DEFAULT_PREFIX_MAP } from "../../kernel/render/index.js";
+import type { Formatters } from "../../kernel/spec/index.js";
 import type {
   OntologyClass,
   OntologyProperty,