@canonical/pragma-cli 0.29.0 → 0.31.0

package/src/domains/doctor/operations/checks/checkMcpCommands.ts

@@ -0,0 +1,133 @@
+import { existsSync } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+import type { DetectedHarness } from "@canonical/harnesses";
+import { detectHarnesses, readMcpConfig } from "@canonical/harnesses";
+import { runTask } from "@canonical/task/node";
+import type { CheckContext, CheckItem, CheckResult } from "../types.js";
+
+const NAME = "MCP commands";
+
+/**
+ * Extract the stdio command from an MCP server config entry, if any.
+ * HTTP/SSE entries (e.g. `{ "type": "http", "url": ... }`) have no command
+ * and are not checked.
+ *
+ * @param entry - Raw server entry from a harness MCP config.
+ * @returns The command string, or `undefined` when the entry is not
+ *   command-based.
+ */
+function commandOf(entry: unknown): string | undefined {
+  if (typeof entry !== "object" || entry === null) return undefined;
+  const command = (entry as { command?: unknown }).command;
+  return typeof command === "string" && command.length > 0
+    ? command
+    : undefined;
+}
+
+/**
+ * Resolve a command the way a shell would: entries containing a path
+ * separator are checked as file paths (relative to the project root),
+ * bare names are searched across `PATH`.
+ *
+ * @param command - Command string from an MCP server entry.
+ * @param cwd - Project root for resolving relative paths.
+ * @returns Whether the command resolves to an existing file.
+ * @note Impure — reads `process.env.PATH` and the filesystem.
+ */
+function commandResolves(command: string, cwd: string): boolean {
+  if (command.includes("/") || command.includes("\\")) {
+    return existsSync(isAbsolute(command) ? command : join(cwd, command));
+  }
+
+  return (process.env.PATH ?? "")
+    .split(delimiter)
+    .filter((dir) => dir.length > 0)
+    .some((dir) => existsSync(join(dir, command)));
+}
+
+/**
+ * Check that every command-based MCP server entry in detected harness
+ * configs resolves to an executable. A dead entry (e.g. a leftover server
+ * whose binary was never installed) makes every agent session try and fail
+ * to boot it, so it is flagged with the offending config path.
+ *
+ * @param ctx - Check context with the working directory.
+ * @returns A CheckResult: pass when all commands resolve, fail listing the
+ *   broken entries, or skip when there is nothing to check.
+ * @note Impure
+ */
+export default async function checkMcpCommands(
+  ctx: CheckContext,
+): Promise<CheckResult> {
+  let detected: DetectedHarness[];
+  try {
+    detected = await runTask(detectHarnesses(ctx.cwd));
+  } catch {
+    return {
+      name: NAME,
+      status: "skip",
+      detail: "harness detection failed",
+    };
+  }
+
+  const withConfig = detected.filter((d) => d.configExists);
+  if (withConfig.length === 0) {
+    return {
+      name: NAME,
+      status: "skip",
+      detail: "no MCP configs found",
+    };
+  }
+
+  const broken: CheckItem[] = [];
+  let checked = 0;
+
+  for (const d of withConfig) {
+    let servers: Record<string, unknown>;
+    try {
+      servers = await runTask(readMcpConfig(d.harness, ctx.cwd));
+    } catch {
+      // Config unreadable — the "MCP configured" check reports on this.
+      continue;
+    }
+
+    for (const [serverName, entry] of Object.entries(servers)) {
+      const command = commandOf(entry);
+      if (!command) continue;
+
+      checked += 1;
+      if (!commandResolves(command, ctx.cwd)) {
+        broken.push({
+          label: `"${serverName}"`,
+          status: "fail",
+          detail: `"${command}" not found · ${d.configPath}`,
+        });
+      }
+    }
+  }
+
+  if (checked === 0) {
+    return {
+      name: NAME,
+      status: "skip",
+      detail: "no command-based MCP servers configured",
+    };
+  }
+
+  if (broken.length === 0) {
+    return {
+      name: NAME,
+      status: "pass",
+      detail: `${checked} command${checked === 1 ? "" : "s"} resolve on PATH`,
+    };
+  }
+
+  return {
+    name: NAME,
+    status: "fail",
+    detail: `${broken.length} of ${checked} unresolvable`,
+    items: broken,
+    remedy:
+      "Install the missing command or remove the entry from the MCP config — every agent session tries and fails to boot it.",
+  };
+}

package/src/domains/doctor/operations/checks/checkMcpConfigured.ts

@@ -1,6 +1,6 @@
 import type { DetectedHarness } from "@canonical/harnesses";
 import { detectHarnesses, readMcpConfig } from "@canonical/harnesses";
-import { runTask } from "@canonical/task";
+import { runTask } from "@canonical/task/node";
 import type { CheckContext, CheckResult } from "../types.js";
 
 /**

package/src/domains/doctor/operations/checks/checkPackageRefs.ts

@@ -6,32 +6,25 @@
  */
 
 import { readConfig } from "#config";
-import { parsePackageEntry } from "../../../refs/operations/parseRef.js";
-import readGlobalRefs from "../../../refs/operations/readGlobalRefs.js";
 import {
   createBundledLoader,
   createGitLoader,
   createLocalLoader,
 } from "../../../shared/loaders/index.js";
-import { DEFAULT_PACKAGES } from "../../../shared/packages.js";
+import { mergeAndParseRefs } from "../../../shared/mergeAndParseRefs.js";
 import { resolveSemanticPackages } from "../../../shared/semanticPackage.js";
-import type { CheckContext, CheckResult } from "../types.js";
+import type { CheckContext, CheckItem, CheckResult } from "../types.js";
+
+/** Pluralize a count, e.g. `1 graph` / `2 graphs`. */
+function count(n: number, unit: string): string {
+  return `${n} ${unit}${n === 1 ? "" : "s"}`;
+}
 
 export default async function checkPackageRefs(
   ctx: CheckContext,
 ): Promise<CheckResult> {
   const config = readConfig(ctx.cwd);
-  const globalEntries = readGlobalRefs();
-
-  const hasProjectRefs = config.packages && config.packages.length > 0;
-
-  const rawEntries = hasProjectRefs
-    ? config.packages!
-    : globalEntries.length > 0
-      ? globalEntries
-      : DEFAULT_PACKAGES;
-
-  const refs = [...rawEntries].map(parsePackageEntry);
+  const refs = mergeAndParseRefs(config.packages);
   const loaders = [
     createLocalLoader(),
     createGitLoader(),
@@ -39,32 +32,45 @@ export default async function checkPackageRefs(
   ];
   const packages = await resolveSemanticPackages(refs, loaders);
 
-  const details: string[] = [];
-  let hasIssue = false;
+  const items: CheckItem[] = [];
+  let unresolved = 0;
 
   for (const ref of refs) {
     const resolved = packages.find((p) => p.name === ref.pkg);
 
     if (resolved) {
-      details.push(
-        `${ref.pkg}: ${resolved.source} v${resolved.version} (${resolved.graphs.length} graphs, ${resolved.skills.length} skills)`,
-      );
+      items.push({
+        label: ref.pkg,
+        status: "pass",
+        detail: `${resolved.source} v${resolved.version} · ${count(resolved.graphs.length, "graph")}, ${count(resolved.skills.length, "skill")}`,
+      });
     } else {
       // Check if covered by bundled fallback
       const bundled = packages.find((p) => p.name === "(bundled)");
       if (bundled) {
-        details.push(`${ref.pkg}: bundled v${bundled.version}`);
+        items.push({
+          label: ref.pkg,
+          status: "pass",
+          detail: `bundled fallback v${bundled.version}`,
+        });
       } else {
-        details.push(`${ref.pkg}: NOT RESOLVED`);
-        hasIssue = true;
+        items.push({ label: ref.pkg, status: "fail", detail: "not resolved" });
+        unresolved += 1;
       }
     }
   }
 
+  const total = refs.length;
+  const detail =
+    unresolved > 0
+      ? `${unresolved} of ${count(total, "package")} not resolved`
+      : `${count(total, "package")} resolved`;
+
   return {
     name: "package refs",
-    status: hasIssue ? "fail" : "pass",
-    detail: details.join("; "),
-    ...(hasIssue ? { remedy: "pragma update-refs" } : {}),
+    status: unresolved > 0 ? "fail" : "pass",
+    detail,
+    items,
+    ...(unresolved > 0 ? { remedy: "pragma update-refs" } : {}),
   };
 }

package/src/domains/doctor/operations/checks/checkSkillsSymlinked.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import type { DetectedHarness } from "@canonical/harnesses";
 import { detectHarnesses } from "@canonical/harnesses";
-import { runTask } from "@canonical/task";
+import { runTask } from "@canonical/task/node";
 import type { CheckContext, CheckResult } from "../types.js";
 
 /**

package/src/domains/doctor/operations/checks/index.ts

@@ -1,6 +1,7 @@
 /** @module Individual environment health checks invoked by runChecks. */
 export { default as checkConfigFile } from "./checkConfigFile.js";
 export { default as checkKeStore } from "./checkKeStore.js";
+export { default as checkMcpCommands } from "./checkMcpCommands.js";
 export { default as checkMcpConfigured } from "./checkMcpConfigured.js";
 export { default as checkNodeVersion } from "./checkNodeVersion.js";
 export { default as checkPackageRefs } from "./checkPackageRefs.js";

package/src/domains/doctor/operations/checks.test.ts

@@ -1,8 +1,12 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 vi.mock("#config", async (importOriginal) => ({
   ...(await importOriginal<typeof import("#config")>()),
   configExists: vi.fn(),
+  readConfigLayers: vi.fn(),
 }));
 vi.mock("../../shared/bootStore.js", () => ({
   bootStore: vi.fn(),
@@ -14,17 +18,18 @@ vi.mock("@canonical/harnesses", () => ({
   detectHarnesses: vi.fn(),
   readMcpConfig: vi.fn(),
 }));
-vi.mock("@canonical/task", () => ({
+vi.mock("@canonical/task/node", () => ({
   runTask: vi.fn((task: unknown) => task),
 }));
 
 import { detectHarnesses, readMcpConfig } from "@canonical/harnesses";
-import { configExists } from "#config";
+import { configExists, readConfigLayers } from "#config";
 import { collectStoreSummary } from "../../info/operations/index.js";
 import { bootStore } from "../../shared/bootStore.js";
 import {
   checkConfigFile,
   checkKeStore,
+  checkMcpCommands,
   checkMcpConfigured,
   checkNodeVersion,
   checkPragmaVersion,
@@ -55,14 +60,55 @@ describe("checkPragmaVersion", () => {
 });
 
 describe("checkConfigFile", () => {
-  it("passes when config exists", async () => {
-    vi.mocked(configExists).mockReturnValue(true);
+  it("passes when a project config exists", async () => {
+    vi.mocked(readConfigLayers).mockReturnValue({
+      config: { tier: undefined, channel: "normal" },
+      origins: {
+        tier: "default",
+        channel: "default",
+        packages: "default",
+        trace: "default",
+        framework: "default",
+      },
+      global: { path: "/home/u/.config/pragma/config.json", exists: false },
+      project: { path: "/repo/pragma.config.json", exists: true },
+    });
+    const result = await checkConfigFile(ctx);
+    expect(result.status).toBe("pass");
+    expect(result.detail).toContain("/repo/pragma.config.json");
+  });
+
+  it("passes when only the global config exists", async () => {
+    vi.mocked(readConfigLayers).mockReturnValue({
+      config: { tier: undefined, channel: "normal" },
+      origins: {
+        tier: "default",
+        channel: "default",
+        packages: "default",
+        trace: "default",
+        framework: "default",
+      },
+      global: { path: "/home/u/.config/pragma/config.json", exists: true },
+      project: { path: "/repo/pragma.config.json", exists: false },
+    });
     const result = await checkConfigFile(ctx);
     expect(result.status).toBe("pass");
+    expect(result.detail).toContain("global config active");
   });
 
-  it("fails with remedy when config missing", async () => {
-    vi.mocked(configExists).mockReturnValue(false);
+  it("fails with remedy when neither layer exists", async () => {
+    vi.mocked(readConfigLayers).mockReturnValue({
+      config: { tier: undefined, channel: "normal" },
+      origins: {
+        tier: "default",
+        channel: "default",
+        packages: "default",
+        trace: "default",
+        framework: "default",
+      },
+      global: { path: "/home/u/.config/pragma/config.json", exists: false },
+      project: { path: "/repo/pragma.config.json", exists: false },
+    });
     const result = await checkConfigFile(ctx);
     expect(result.status).toBe("fail");
     expect(result.remedy).toBeDefined();
@@ -145,6 +191,113 @@ describe("checkMcpConfigured", () => {
   });
 });
 
+describe("checkMcpCommands", () => {
+  const harness = {
+    id: "claude-code",
+    name: "Claude Code",
+    configPath: () => "/test/.mcp.json",
+    skillsPath: () => "/test/.claude/skills",
+    detect: [],
+    version: "*",
+    configFormat: "json" as const,
+    mcpKey: "mcpServers",
+  };
+  const detected = {
+    harness,
+    confidence: "high" as const,
+    configExists: true,
+    configPath: "/test/.mcp.json",
+  };
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("skips when no harnesses detected", async () => {
+    vi.mocked(detectHarnesses).mockReturnValue(Promise.resolve([]) as never);
+    const result = await checkMcpCommands(ctx);
+    expect(result.status).toBe("skip");
+  });
+
+  it("skips when only URL-based servers are configured", async () => {
+    vi.mocked(detectHarnesses).mockReturnValue(
+      Promise.resolve([detected]) as never,
+    );
+    vi.mocked(readMcpConfig).mockReturnValue(
+      Promise.resolve({
+        figma: { type: "http", url: "https://mcp.figma.com/mcp" },
+      }) as never,
+    );
+
+    const result = await checkMcpCommands(ctx);
+    expect(result.status).toBe("skip");
+    expect(result.detail).toContain("no command-based");
+  });
+
+  it("passes when every configured command resolves on PATH", async () => {
+    const binDir = mkdtempSync(join(tmpdir(), "pragma-doctor-"));
+    writeFileSync(join(binDir, "pragma"), "#!/bin/sh\n", { mode: 0o755 });
+    vi.stubEnv("PATH", binDir);
+
+    vi.mocked(detectHarnesses).mockReturnValue(
+      Promise.resolve([detected]) as never,
+    );
+    vi.mocked(readMcpConfig).mockReturnValue(
+      Promise.resolve({
+        pragma: { command: "pragma", args: ["mcp"] },
+      }) as never,
+    );
+
+    const result = await checkMcpCommands(ctx);
+    expect(result.status).toBe("pass");
+    expect(result.detail).toContain("1 command");
+  });
+
+  it("fails and names the entry whose command does not resolve", async () => {
+    const emptyDir = mkdtempSync(join(tmpdir(), "pragma-doctor-empty-"));
+    vi.stubEnv("PATH", emptyDir);
+
+    vi.mocked(detectHarnesses).mockReturnValue(
+      Promise.resolve([detected]) as never,
+    );
+    vi.mocked(readMcpConfig).mockReturnValue(
+      Promise.resolve({
+        sem: { command: "sem", args: ["mcp"] },
+      }) as never,
+    );
+
+    const result = await checkMcpCommands(ctx);
+    expect(result.status).toBe("fail");
+    const semItem = result.items?.find((i) => i.label === '"sem"');
+    expect(semItem).toBeDefined();
+    expect(semItem?.detail).toContain("/test/.mcp.json");
+    expect(result.remedy).toBeDefined();
+  });
+
+  it("flags only the broken entry among several", async () => {
+    const binDir = mkdtempSync(join(tmpdir(), "pragma-doctor-mixed-"));
+    writeFileSync(join(binDir, "pragma"), "#!/bin/sh\n", { mode: 0o755 });
+    vi.stubEnv("PATH", binDir);
+
+    vi.mocked(detectHarnesses).mockReturnValue(
+      Promise.resolve([detected]) as never,
+    );
+    vi.mocked(readMcpConfig).mockReturnValue(
+      Promise.resolve({
+        pragma: { command: "pragma", args: ["mcp"] },
+        sem: { command: "sem", args: ["mcp"] },
+        figma: { type: "http", url: "https://mcp.figma.com/mcp" },
+      }) as never,
+    );
+
+    const result = await checkMcpCommands(ctx);
+    expect(result.status).toBe("fail");
+    const labels = (result.items ?? []).map((i) => i.label);
+    expect(labels).toContain('"sem"');
+    expect(labels).not.toContain('"pragma"');
+  });
+});
+
 describe("checkSkillsSymlinked", () => {
   it("skips when no harnesses detected", async () => {
     vi.mocked(detectHarnesses).mockReturnValue(Promise.resolve([]) as never);

package/src/domains/doctor/operations/runChecks.test.ts

@@ -8,12 +8,14 @@ vi.mock("./checks/index.js", () => ({
   checkKeStore: vi.fn(),
   checkShellCompletions: vi.fn(),
   checkMcpConfigured: vi.fn(),
+  checkMcpCommands: vi.fn(),
   checkSkillsSymlinked: vi.fn(),
 }));
 
 import {
   checkConfigFile,
   checkKeStore,
+  checkMcpCommands,
   checkMcpConfigured,
   checkNodeVersion,
   checkPackageRefs,
@@ -50,13 +52,14 @@ describe("runChecks", () => {
     vi.mocked(checkKeStore).mockResolvedValue(pass("store"));
     vi.mocked(checkShellCompletions).mockResolvedValue(pass("completions"));
     vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
     vi.mocked(checkSkillsSymlinked).mockResolvedValue(pass("skills"));
 
     const data = await runChecks({ cwd: "/test" });
-    expect(data.passed).toBe(8);
+    expect(data.passed).toBe(9);
     expect(data.failed).toBe(0);
     expect(data.skipped).toBe(0);
-    expect(data.checks).toHaveLength(8);
+    expect(data.checks).toHaveLength(9);
   });
 
   it("counts failures and skips correctly", async () => {
@@ -67,10 +70,11 @@ describe("runChecks", () => {
     vi.mocked(checkKeStore).mockResolvedValue(fail("store"));
     vi.mocked(checkShellCompletions).mockResolvedValue(fail("completions"));
     vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
     vi.mocked(checkSkillsSymlinked).mockResolvedValue(skip("skills"));
 
     const data = await runChecks({ cwd: "/test" });
-    expect(data.passed).toBe(4);
+    expect(data.passed).toBe(5);
     expect(data.failed).toBe(3);
     expect(data.skipped).toBe(1);
   });
@@ -83,6 +87,7 @@ describe("runChecks", () => {
     vi.mocked(checkKeStore).mockResolvedValue(pass("store"));
     vi.mocked(checkShellCompletions).mockResolvedValue(pass("completions"));
     vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
     vi.mocked(checkSkillsSymlinked).mockResolvedValue(pass("skills"));
 
     const data = await runChecks({ cwd: "/test" });
@@ -91,7 +96,7 @@ describe("runChecks", () => {
     expect(data.checks[2].name).toBe("config");
     expect(data.checks[3].name).toBe("refs");
     expect(data.checks[4].name).toBe("store");
-    expect(data.checks[7].name).toBe("skills");
+    expect(data.checks[8].name).toBe("skills");
   });
 
   it("preserves order even when checks resolve out of order", async () => {
@@ -109,6 +114,7 @@ describe("runChecks", () => {
     vi.mocked(checkKeStore).mockResolvedValue(pass("store"));
     vi.mocked(checkShellCompletions).mockResolvedValue(pass("completions"));
     vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
     vi.mocked(checkSkillsSymlinked).mockReturnValue(delayed(pass("skills"), 0));
 
     const data = await runChecks({ cwd: "/test" });
@@ -120,6 +126,7 @@ describe("runChecks", () => {
       "store",
       "completions",
       "mcp",
+      "mcp commands",
       "skills",
     ]);
   });
@@ -132,13 +139,14 @@ describe("runChecks", () => {
     vi.mocked(checkKeStore).mockResolvedValue(pass("store"));
     vi.mocked(checkShellCompletions).mockResolvedValue(pass("completions"));
     vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
     vi.mocked(checkSkillsSymlinked).mockResolvedValue(pass("skills"));
 
     const data = await runChecks({ cwd: "/test" });
 
     // The whole run still completes; the thrown check becomes a fail in place.
-    expect(data.checks).toHaveLength(8);
-    expect(data.passed).toBe(7);
+    expect(data.checks).toHaveLength(9);
+    expect(data.passed).toBe(8);
     expect(data.failed).toBe(1);
     const failed = data.checks[2];
     expect(failed.status).toBe("fail");
@@ -157,6 +165,7 @@ describe("runChecks", () => {
     vi.mocked(checkKeStore).mockRejectedValue("string failure");
     vi.mocked(checkShellCompletions).mockResolvedValue(pass("completions"));
     vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
     vi.mocked(checkSkillsSymlinked).mockResolvedValue(pass("skills"));
 
     const data = await runChecks({ cwd: "/test" });

package/src/domains/doctor/operations/runChecks.ts

@@ -1,6 +1,7 @@
 import {
   checkConfigFile,
   checkKeStore,
+  checkMcpCommands,
   checkMcpConfigured,
   checkNodeVersion,
   checkPackageRefs,
@@ -28,6 +29,7 @@ function buildChecks(
     ["ke store", checkKeStore(ctx)],
     ["Shell completions", checkShellCompletions()],
     ["MCP configured", checkMcpConfigured(ctx)],
+    ["MCP commands", checkMcpCommands(ctx)],
     ["Skills symlinked", checkSkillsSymlinked(ctx)],
   ];
 }

package/src/domains/doctor/operations/types.ts

@@ -1,8 +1,30 @@
+/** Status of a doctor check or one of its sub-items. */
+export type CheckStatus = "pass" | "fail" | "skip";
+
+/**
+ * A structured sub-item under a check — e.g. one resolved package under
+ * `package refs`, or one unresolvable server under `MCP commands`. Lets the
+ * formatter render an indented, aligned breakdown instead of cramming
+ * everything into a single `detail` string.
+ */
+export interface CheckItem {
+  /** Left-column label (e.g. the package or server name). */
+  readonly label: string;
+  /** Right-column detail (e.g. `git v0.1.2 · 362 graphs`). */
+  readonly detail?: string;
+  /** Optional per-item status, rendered as its own icon. */
+  readonly status?: CheckStatus;
+}
+
 /** Result of a single doctor check. */
 export interface CheckResult {
   readonly name: string;
-  readonly status: "pass" | "fail" | "skip";
+  readonly status: CheckStatus;
+  /** One-line headline shown next to the check name. */
   readonly detail: string;
+  /** Optional structured breakdown, rendered as indented sub-items. */
+  readonly items?: readonly CheckItem[];
+  /** Remedial instruction shown inline under a failing check. */
   readonly remedy?: string;
 }
 

package/src/domains/graph/commands/inspect.test.ts

@@ -2,7 +2,7 @@ import type { CommandDefinition } from "@canonical/cli-core";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import createTestRuntime from "../../../testing/helpers/createTestRuntime.js";
 import type { PragmaContext } from "../../shared/context.js";
-import { PREFIX_MAP } from "../../shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
 import type { PragmaRuntime } from "../../shared/runtime.js";
 import type { InspectResult } from "../../shared/types/index.js";
 import buildInspectCommand from "./inspect.js";
@@ -37,7 +37,7 @@ async function executeOutput(
 }
 
 describe("graph inspect command", () => {
-  const uri = `${PREFIX_MAP.ds}global.component.button`;
+  const uri = `${DEFAULT_PREFIX_MAP.ds}global.component.button`;
 
   it("returns inspect results", async () => {
     const ctx = makeCtx();

package/src/domains/graph/commands/query.test.ts

@@ -58,15 +58,17 @@ describe("graph query command", () => {
     expect(text).toContain("n");
   });
 
-  it("renders llm output", async () => {
+  it("renders llm output as a Markdown table for SELECT", async () => {
     const ctx = makeCtx({
       globalFlags: { llm: true, format: "text" as const, verbose: false },
     });
     const cmd = buildQueryCommand(ctx);
     const { text } = await executeOutput(cmd, { sparql }, ctx);
 
-    const parsed = JSON.parse(text) as QueryResult;
-    expect(parsed.type).toBe("select");
+    // Condensed Markdown, not a raw JSON dump.
+    expect(text).toContain("| n |");
+    expect(text).toContain("| --- |");
+    expect(() => JSON.parse(text)).toThrow();
   });
 
   it("renders json output", async () => {