@canonical/pragma-cli 0.32.0 → 0.33.0

package/src/capabilities/doctor/doctor.render.ts

@@ -1,35 +1,74 @@
 /**
- * Formatters for `pragma doctor` — plain (chalk), llm (Markdown), json.
+ * Formatters for `pragma doctor` — plain (chalk on a TTY), llm (Markdown), json.
  *
  * Ported from the old shell's `doctor/formatters/doctor.ts`, retargeted at the
- * kernel `Formatters` contract.
+ * kernel `Formatters` contract. The plain path is colored ONLY on a color-capable
+ * TTY: it consults the shared {@link defaultStyle} seam (stdout `isTTY` AND a
+ * non-zero chalk level), so a piped / redirected / CI run — where `supports-color`
+ * can report a level with no TTY (`GITHUB_ACTIONS`, `FORCE_COLOR`) — renders the
+ * plain form byte-for-byte instead of leaking ANSI into `doctor --format plain`.
+ * Glyphs are plain constants tinted at render time; nothing is baked at load.
  */
 
 import chalk from "chalk";
+import { defaultStyle, type RenderStyle } from "../../kernel/render/style.js";
 import type { Formatters } from "../../kernel/spec/types.js";
+import { BAND_LABELS } from "../shared/bands.js";
 import type { CheckResult, CheckStatus, DoctorData } from "./types.js";
 
-/** Status icons for pass/fail/skip results (checks and sub-items). */
-const STATUS_ICONS: Record<CheckStatus, string> = {
-  pass: chalk.green("✓"),
-  fail: chalk.red("✗"),
-  skip: chalk.yellow("○"),
+/** Uncolored status glyphs — tinted at render time (never baked at module load). */
+const STATUS_GLYPHS: Record<CheckStatus, string> = {
+  pass: "✓",
+  fail: "✗",
+  skip: "○",
 };
 
-const SUB_BULLET = chalk.dim("·");
-const FIX_ARROW = chalk.cyan("↳");
+const SUB_BULLET = "·";
+const FIX_ARROW = "↳";
 const INDENT = "     "; // aligns sub-lines under the check name
 
+/** The TTY styler plus `red` — the one tint {@link RenderStyle} does not carry. */
+interface DoctorStyle extends RenderStyle {
+  red(text: string): string;
+}
+
+/**
+ * Build the doctor styler for this process's stdout: the shared TTY seam, plus a
+ * `red` gated on the SAME decision, so a fail tint appears only on a color TTY.
+ *
+ * @returns A colorizing styler on a color-capable TTY, else the identity styler.
+ * @note Impure — {@link defaultStyle} reads `process.stdout.isTTY` + chalk level.
+ */
+function doctorStyle(): DoctorStyle {
+  const style = defaultStyle();
+  return {
+    ...style,
+    red: style.enabled ? (text) => chalk.red(text) : (text) => text,
+  };
+}
+
+/** Tint a status glyph by meaning — green pass, red fail, yellow skip. */
+function paintGlyph(status: CheckStatus, style: DoctorStyle): string {
+  const glyph = STATUS_GLYPHS[status];
+  if (status === "pass") return style.green(glyph);
+  if (status === "fail") return style.red(glyph);
+  return style.yellow(glyph);
+}
+
 /**
  * Render one check as terminal lines: a headline row (icon, aligned name,
  * detail), an optional indented breakdown of sub-items, and — for failures — an
  * inline remedial instruction.
  */
-function formatCheckPlain(check: CheckResult, nameWidth: number): string[] {
+function formatCheckPlain(
+  check: CheckResult,
+  nameWidth: number,
+  style: DoctorStyle,
+): string[] {
   const name = check.name.padEnd(nameWidth);
-  const label = check.status === "fail" ? chalk.red(name) : chalk.bold(name);
+  const label = check.status === "fail" ? style.red(name) : style.bold(name);
   const lines = [
-    `  ${STATUS_ICONS[check.status]}  ${label}  ${chalk.dim(check.detail)}`,
+    `  ${paintGlyph(check.status, style)}  ${label}  ${style.dim(check.detail)}`,
   ];
 
   if (check.items && check.items.length > 0) {
@@ -38,55 +77,86 @@ function formatCheckPlain(check: CheckResult, nameWidth: number): string[] {
     for (const item of check.items) {
       const icon = anyStatus
         ? item.status
-          ? `${STATUS_ICONS[item.status]} `
+          ? `${paintGlyph(item.status, style)} `
           : "  "
         : "";
       const itemLabel = item.detail ? item.label.padEnd(itemWidth) : item.label;
-      const detail = item.detail ? `  ${chalk.dim(item.detail)}` : "";
-      lines.push(`${INDENT}${SUB_BULLET} ${icon}${itemLabel}${detail}`);
+      const detail = item.detail ? `  ${style.dim(item.detail)}` : "";
+      lines.push(
+        `${INDENT}${style.dim(SUB_BULLET)} ${icon}${itemLabel}${detail}`,
+      );
     }
   }
 
   if (check.status === "fail" && check.remedy) {
-    lines.push(`${INDENT}${FIX_ARROW} ${chalk.cyan("fix:")} ${check.remedy}`);
+    lines.push(
+      `${INDENT}${style.cyan(FIX_ARROW)} ${style.cyan("fix:")} ${check.remedy}`,
+    );
   }
 
   return lines;
 }
 
 /** Render the pass/fail/skip tally, coloring non-zero fail/skip. */
-function formatSummary(data: DoctorData): string {
-  const parts = [chalk.green(`${data.passed} passed`)];
+function formatSummary(data: DoctorData, style: DoctorStyle): string {
+  const parts = [style.green(`${data.passed} passed`)];
   parts.push(
     data.failed > 0
-      ? chalk.red(`${data.failed} failed`)
-      : chalk.dim(`${data.failed} failed`),
+      ? style.red(`${data.failed} failed`)
+      : style.dim(`${data.failed} failed`),
   );
   parts.push(
     data.skipped > 0
-      ? chalk.yellow(`${data.skipped} skipped`)
-      : chalk.dim(`${data.skipped} skipped`),
+      ? style.yellow(`${data.skipped} skipped`)
+      : style.dim(`${data.skipped} skipped`),
   );
-  return `  ${parts.join(chalk.dim(" · "))}`;
+  return `  ${parts.join(style.dim(" · "))}`;
+}
+
+/**
+ * Partition checks into ordered bands: environment (no band), then the global
+ * and project bands. Declaration order is preserved within each band, so the
+ * report stays deterministic.
+ */
+function partitionByBand(checks: readonly CheckResult[]): {
+  environment: CheckResult[];
+  machine: CheckResult[];
+  project: CheckResult[];
+} {
+  return {
+    environment: checks.filter((c) => c.band === undefined),
+    machine: checks.filter((c) => c.band === "global"),
+    project: checks.filter((c) => c.band === "project"),
+  };
 }
 
 export const doctorFormatters: Formatters<DoctorData> = {
   plain(data) {
+    const style = doctorStyle();
     const nameWidth = Math.max(...data.checks.map((c) => c.name.length), 0);
-    const lines: string[] = [chalk.bold("pragma doctor"), ""];
-    for (const check of data.checks) {
-      lines.push(...formatCheckPlain(check, nameWidth));
-    }
-    lines.push("", formatSummary(data));
+    const lines: string[] = [style.bold("pragma doctor"), ""];
+    const { environment, machine, project } = partitionByBand(data.checks);
+    const section = (heading: string, checks: CheckResult[]): void => {
+      if (checks.length === 0) return;
+      if (heading) lines.push(style.bold(heading));
+      for (const check of checks)
+        lines.push(...formatCheckPlain(check, nameWidth, style));
+      lines.push("");
+    };
+    // Environment checks lead (no header); the global then project bands are the
+    // two banded sections before the tally.
+    section("", environment);
+    section(BAND_LABELS.global, machine);
+    section(BAND_LABELS.project, project);
+    lines.push(formatSummary(data, style));
     return lines.join("\n");
   },
 
   llm(data) {
-    const lines: string[] = ["## Doctor", ""];
-    for (const check of data.checks) {
+    const renderCheck = (check: CheckResult): string[] => {
       const icon =
         check.status === "pass" ? "✓" : check.status === "fail" ? "✗" : "○";
-      lines.push(`- ${icon} **${check.name}**: ${check.detail}`);
+      const out = [`- ${icon} **${check.name}**: ${check.detail}`];
       for (const item of check.items ?? []) {
         const itemIcon =
           item.status === "pass"
@@ -97,12 +167,24 @@ export const doctorFormatters: Formatters<DoctorData> = {
                 ? "○ "
                 : "";
         const detail = item.detail ? `: ${item.detail}` : "";
-        lines.push(`  - ${itemIcon}${item.label}${detail}`);
+        out.push(`  - ${itemIcon}${item.label}${detail}`);
       }
       if (check.status === "fail" && check.remedy) {
-        lines.push(`  - _fix:_ \`${check.remedy}\``);
+        out.push(`  - _fix:_ \`${check.remedy}\``);
       }
-    }
+      return out;
+    };
+
+    const lines: string[] = ["## Doctor", ""];
+    const { environment, machine, project } = partitionByBand(data.checks);
+    const section = (heading: string, checks: CheckResult[]): void => {
+      if (checks.length === 0) return;
+      if (heading) lines.push(`### ${heading}`, "");
+      for (const check of checks) lines.push(...renderCheck(check));
+    };
+    section("", environment);
+    section(BAND_LABELS.global, machine);
+    section(BAND_LABELS.project, project);
     lines.push(
       "",
       `_${data.passed} passed, ${data.failed} failed, ${data.skipped} skipped_`,

package/src/capabilities/doctor/doctor.test.ts

@@ -8,7 +8,7 @@
  * the MCP read-only envelope.
  */
 
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
@@ -28,6 +28,7 @@ import {
 } from "../../testing/fixtures/graph/canonical.js";
 import { bootFixtureRuntime } from "../../testing/helpers/fixtureGraph.js";
 import { projectMcp } from "../../testing/helpers/projectMcp.js";
+import { checkMcpConfigured } from "./checks/checkMcpConfigured.js";
 import { doctorModule } from "./index.js";
 import { runChecks } from "./runChecks.js";
 import type { DoctorData } from "./types.js";
@@ -50,17 +51,24 @@ const tmp = (prefix: string): string => {
 
 let prevHome: string | undefined;
 let prevXdg: string | undefined;
+let prevPath: string | undefined;
 beforeEach(() => {
   prevHome = process.env.HOME;
   prevXdg = process.env.XDG_CONFIG_HOME;
+  prevPath = process.env.PATH;
   // Empty HOME/XDG so `~`-based harness signals, rc files, and the global config
   // are all absent — the harness/config/completion checks become deterministic.
   process.env.HOME = tmp("pragma-doctor-home-");
   process.env.XDG_CONFIG_HOME = tmp("pragma-doctor-xdg-");
+  // Point PATH at an empty dir so no harness `process` signal fires off the
+  // ambient PATH (e.g. a `claude`/`codex` binary on the CI/dev host) — keeping
+  // "no harnesses detected" deterministic regardless of what is installed.
+  process.env.PATH = tmp("pragma-doctor-path-");
 });
 afterEach(() => {
   process.env.HOME = prevHome;
   process.env.XDG_CONFIG_HOME = prevXdg;
+  process.env.PATH = prevPath;
   for (const dir of roots) rmSync(dir, { recursive: true, force: true });
   roots.length = 0;
 });
@@ -177,3 +185,25 @@ describe("doctor — dispatch & MCP", () => {
     expect((envelope.data as DoctorData).checks).toHaveLength(9);
   });
 });
+
+describe("doctor — MCP checks band by detected harness scope, not check name", () => {
+  it("bands a configured GLOBAL-scope harness (Windsurf) as global", async () => {
+    // Windsurf is a global-only harness whose MCP config lives in the home band.
+    // The old static map tagged every "MCP configured" result PROJECT; the fix
+    // derives the band from the harness's real scope, so this reports `global`.
+    const cwd = tmp("pragma-doctor-proj-");
+    mkdirSync(join(cwd, ".windsurf"), { recursive: true }); // ⇒ Windsurf detected
+    const home = process.env.HOME ?? "";
+    const wsDir = join(home, ".codeium", "windsurf");
+    mkdirSync(wsDir, { recursive: true });
+    writeFileSync(
+      join(wsDir, "mcp_config.json"),
+      JSON.stringify({ mcpServers: { pragma: { command: "pragma" } } }),
+    );
+
+    const check = await checkMcpConfigured(cwd);
+    expect(check.status).toBe("pass");
+    expect(check.detail).toContain("Windsurf");
+    expect(check.band).toBe("global"); // NOT the old static "project"
+  });
+});

package/src/capabilities/doctor/runChecks.ts

@@ -18,7 +18,31 @@ import { checkPackageRefs } from "./checks/checkPackageRefs.js";
 import { checkPragmaVersion } from "./checks/checkPragmaVersion.js";
 import { checkShellCompletions } from "./checks/checkShellCompletions.js";
 import { checkSkillsSymlinked } from "./checks/checkSkillsSymlinked.js";
-import type { CheckResult, DoctorData } from "./types.js";
+import type { CheckResult, DoctorData, ScopeBand } from "./types.js";
+
+/**
+ * The band a check statically concerns, by name — for checks whose band is
+ * fixed by construction: skills always symlink into the per-repo project dir
+ * (`skillsPath` is project-rooted), and completions install into the user/home
+ * shell dir. The MCP checks are NOT here: they detect harnesses across BOTH
+ * bands, so each derives its own band from what it found (see `deriveBand`) and
+ * sets it on its own result — {@link attachBand} preserves that.
+ */
+const CHECK_BANDS: Record<string, ScopeBand> = {
+  "Skills symlinked": "project",
+  "Shell completions": "global",
+};
+
+/**
+ * Attach a band tag to a check result. A check that already set its own band
+ * (the harness-derived MCP checks) keeps it; otherwise the static
+ * {@link CHECK_BANDS} map fills one in by name, if defined.
+ */
+function attachBand(result: CheckResult): CheckResult {
+  if (result.band !== undefined) return result;
+  const band = CHECK_BANDS[result.name];
+  return band ? { ...result, band } : result;
+}
 
 /**
  * Each check paired with the display name used if it rejects. The fallback name
@@ -53,16 +77,16 @@ export async function runChecks(rt: PragmaRuntime): Promise<DoctorData> {
   const checks: CheckResult[] = await Promise.all(
     buildChecks(rt).map(async ([name, promise]): Promise<CheckResult> => {
       try {
-        return await promise;
+        return attachBand(await promise);
       } catch (error) {
         const reason = error instanceof Error ? error.message : String(error);
-        return {
+        return attachBand({
           name,
           status: "fail",
           detail: `Check threw an unexpected error: ${reason}`,
           remedy:
             "Re-run `pragma doctor`; if it persists, report this as a bug.",
-        };
+        });
       }
     }),
   );

package/src/capabilities/doctor/types.ts

@@ -2,6 +2,13 @@
  * Data shapes for `pragma doctor` (ported verbatim from the old shell).
  */
 
+/**
+ * One of the two config bands a check can concern. Mirrors the harnesses
+ * `ScopeBand` structurally but is redeclared here so this statically-reachable
+ * type module never pulls the harnesses runtime into the fast-path module graph.
+ */
+export type ScopeBand = "project" | "global";
+
 /** Status of a doctor check or one of its sub-items. */
 export type CheckStatus = "pass" | "fail" | "skip";
 
@@ -30,6 +37,14 @@ export interface CheckResult {
   readonly items?: readonly CheckItem[];
   /** Remedial instruction shown inline under a failing check. */
   readonly remedy?: string;
+  /**
+   * Which config band the check concerns, if any: `global` for the user/home
+   * level (shell completions), `project` for per-repo config (skills). The MCP
+   * checks derive their band from the harnesses they found. The renderer groups
+   * banded checks into Global/Project sections; environment checks (Node,
+   * versions, store) carry no band.
+   */
+  readonly band?: ScopeBand;
 }
 
 /** Aggregated results from all doctor checks. */

package/src/capabilities/ontology/index.ts

@@ -3,10 +3,17 @@
  */
 
 import type { CapabilityModule } from "../../kernel/spec/types.js";
-import { ontologyListVerb, ontologyShowVerb } from "./verbs.js";
+import {
+  ontologyListVerb,
+  ontologyLookupVerb,
+  ontologyShowVerb,
+} from "./verbs.js";
 
-/** The `ontology` capability module (`list`, `show`). */
+/**
+ * The `ontology` capability module (`list`, `lookup`, and the deprecated `show`
+ * alias — AV-228 B1).
+ */
 export const ontologyModule: CapabilityModule = {
   name: "ontology",
-  verbs: [ontologyListVerb, ontologyShowVerb],
+  verbs: [ontologyListVerb, ontologyLookupVerb, ontologyShowVerb],
 };

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

@@ -15,13 +15,23 @@ import {
   BLOCK_PREFIXES,
   BLOCK_TTL,
 } from "../../testing/fixtures/blockGraph.js";
+import { CANONICAL_TTL } from "../../testing/fixtures/graph/canonical.js";
+import {
+  bootFixtureRuntime,
+  type FixtureGraph,
+} from "../../testing/helpers/fixtureGraph.js";
 import { buildFixtureRuntime } from "../../testing/helpers/packRuntime.js";
+import { projectMcp } from "../../testing/helpers/projectMcp.js";
+import { capabilities } from "../index.js";
 import { ontologyModule } from "./index.js";
 import type { OntologyShowData, OntologySummary } from "./queries.js";
 
 const listVerb = ontologyModule.verbs.find(
   (v) => verbKey(v.path) === "ontology list",
 ) as VerbSpec;
+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;
@@ -48,9 +58,12 @@ describe("ontology list", () => {
   });
 });
 
-describe("ontology show", () => {
+describe("ontology lookup (primary by-name read)", () => {
   it("renders the class hierarchy with per-class instance counts from the index", async () => {
-    const data = (await showVerb.run({ prefix: "ds" }, rt)) as OntologyShowData;
+    const data = (await lookupVerb.run(
+      { prefix: "ds" },
+      rt,
+    )) as OntologyShowData;
     const component = data.classes.find((c) => c.uri.endsWith("Component"));
     expect(component?.superclass).toBe("https://ds.canonical.com/UIBlock");
     // Two Component individuals (Button, Modal) in the fixture.
@@ -58,8 +71,34 @@ describe("ontology show", () => {
     expect(data.properties).toEqual([]);
   });
 
+  it("--detail detailed folds onto disclosure and includes properties (B5)", async () => {
+    // Ontology honours the canonical `--detail` instead of only its bespoke
+    // `--properties`: standard/detailed add the properties section.
+    const detailed = {
+      ...rt,
+      globalFlags: { ...rt.globalFlags, detail: "detailed" as const },
+    };
+    const data = (await lookupVerb.run(
+      { prefix: "ds" },
+      detailed,
+    )) as OntologyShowData;
+    expect(data.properties.length).toBeGreaterThan(0);
+  });
+
+  it("--detail summary keeps classes only (no properties)", async () => {
+    const summary = {
+      ...rt,
+      globalFlags: { ...rt.globalFlags, detail: "summary" as const },
+    };
+    const data = (await lookupVerb.run(
+      { prefix: "ds" },
+      summary,
+    )) as OntologyShowData;
+    expect(data.properties).toEqual([]);
+  });
+
   it("--class focuses on one class and its properties", async () => {
-    const data = (await showVerb.run(
+    const data = (await lookupVerb.run(
       { prefix: "ds", class: "BlockProperty" },
       rt,
     )) as OntologyShowData;
@@ -77,18 +116,131 @@ describe("ontology show", () => {
   });
 
   it("--full-uris flag rides on the payload for the renderer", async () => {
-    const data = (await showVerb.run(
+    const data = (await lookupVerb.run(
       { prefix: "ds", fullUris: true },
       rt,
     )) as OntologyShowData;
     expect(data.fullUris).toBe(true);
-    const llm = showVerb.output.formatters.llm(data);
+    const llm = lookupVerb.output.formatters.llm(data);
     expect(llm).toContain("https://ds.canonical.com/Component");
   });
 
   it("rejects an unknown prefix with recovery", async () => {
+    await expect(lookupVerb.run({ prefix: "nope" }, rt)).rejects.toThrow(
+      /prefix/i,
+    );
+  });
+});
+
+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`
+  // 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`
+  // 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
+  // classes-only per call and can equally override upward.
+  let fixture: FixtureGraph;
+  let mcp: Awaited<ReturnType<typeof projectMcp>>;
+
+  beforeAll(async () => {
+    // Ambient config detail=standard → origins.detail === "project", so it
+    // outranks the verb's `summary` default inside resolvePackDetail.
+    fixture = await bootFixtureRuntime({
+      ttl: CANONICAL_TTL,
+      config: { detail: "standard" },
+    });
+    mcp = await projectMcp(capabilities, fixture.cwd);
+  });
+
+  afterAll(async () => {
+    await mcp.cleanup();
+    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");
+    expect(lookup).toBeDefined();
+    const schema = lookup?.inputSchema as {
+      properties?: Record<string, unknown>;
+    };
+    expect(schema.properties?.detail).toBeDefined();
+  });
+
+  it("ontology_lookup honours a per-call detail=summary despite the ambient standard", async () => {
+    const result = await mcp.callTool("ontology_lookup", {
+      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("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" });
+    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", {
+      prefix: "ds",
+      detail: "detailed",
+    });
+    expect(result.ok).toBe(true);
+    const data = result.data as { properties: unknown[] };
+    expect(data.properties.length).toBeGreaterThan(0);
+  });
+});