@malloy-publisher/server 0.0.235 → 0.0.237

package/src/mcp/query_envelope.ts

@@ -1,240 +0,0 @@
-import type * as Malloy from "@malloydata/malloy-interfaces";
-import { bigIntReplacer } from "../json_utils";
-import type { QueryRowLimitSource } from "../service/model_limits";
-
-/**
- * The agent-facing shape for a query result, matched to what Credible's
- * `execute_query` returns.
- *
- * Matching matters for a specific workflow: a data app is authored locally
- * against Publisher and then served through Credible. An agent that sees one
- * response shape while developing and a different one in production has to
- * learn both, and a shared skill cannot describe either without forking. So the
- * field names here are Credible's, deliberately, including the leading
- * underscores and the mixed casing of `renderLogErrors`.
- *
- * Also following Credible: the truncation fields appear only when truncation
- * happened, rather than always carrying `false`.
- *
- * The two `_limit_...` fields are new to both products. Three separate things
- * can shorten a result and only one of them was ever reported:
- *
- *   1. The query row cap, pushed into the SQL. A query with no `limit:` of its
- *      own gets DEFAULT_QUERY_ROW_LIMIT (1000) rows, which is far under
- *      PUBLISHER_MAX_QUERY_ROWS, so nothing raises and nothing warns. An agent
- *      reports statistics on a silent sample. This is why `_limit_hit` exists,
- *      and unlike the others it is not derivable by a client: the cap depends on
- *      server config and on the query's own LIMIT.
- *   2. The hard ceiling (maxRows / maxBytes), which throws 413 and is loud.
- *   3. The payload cap below, which degrades to a truncated result plus a
- *      warning instead of overflowing the client's per-result limit.
- *
- * `_limit_hit` is a bound, not a total. The server cannot know the true row
- * count, because the database applied the cap. Landing exactly on the limit is
- * the only evidence available that rows were left behind.
- *
- * It is reported only when the cap was the server default, which `_limit_source`
- * names. `resolveModelQueryRowLimit` folds the query's own `limit:`/`top:` into
- * the same number, so equality also holds every time an author limited the query
- * on purpose: three of the eight views in the bundled storefront example use
- * `top:`, and each would otherwise report its complete answer as cut off. The
- * silent sample this exists to catch only ever happens under the default.
- */
-export interface QueryEnvelope {
-   rows: unknown;
-   /** Malloy metadata the flat rows drop: field types, render tags, timezone. */
-   _meta: {
-      schema: Malloy.Schema;
-      annotations: Malloy.Annotation[];
-      connection_name: string;
-      model_annotations?: Malloy.Annotation[];
-      query_timezone?: string;
-      source_annotations?: Malloy.Annotation[];
-   };
-   /** The cap pushed into the SQL: the query's own LIMIT, else the server default. */
-   _query_row_limit: number;
-   /** Which of those two the cap came from. */
-   _limit_source: QueryRowLimitSource;
-   /**
-    * Row count equals the cap AND the cap was the server default, so rows were
-    * almost certainly left behind. A deliberate `limit:`/`top:` that returns
-    * exactly what it asked for is a complete answer and does not set this.
-    */
-   _limit_hit: boolean;
-   /** Present only when the payload cap dropped rows. */
-   _rows_truncated?: boolean;
-   _total_rows?: number;
-   _returned_rows?: number;
-   /**
-    * The `query_id` property attached to this query's statements: the join key
-    * into the backend's own query record (`QUERY_HISTORY`, `JOBS.labels`, the
-    * statement text). Publisher-side and new to both products, like the two
-    * `_limit_...` fields. Absent when nothing was attached, which is every query
-    * on a deployment that has not enabled query metadata.
-    */
-   _query_id?: string;
-   warning?: string;
-   renderLogErrors?: string[];
-}
-
-/**
- * Cap on the serialized envelope, in characters. Same value Credible uses.
- *
- * Host-loop MCP clients enforce a per-tool-result ceiling of roughly 25k tokens;
- * past it the result is spilled to disk or rejected outright, and the model then
- * struggles to recover it. Chars stand in for tokens at about 4:1, with headroom
- * for the envelope itself.
- */
-export const MAX_RESULT_CHARS = 90_000;
-
-function serialize(envelope: QueryEnvelope): string {
-   return JSON.stringify(envelope, bigIntReplacer, 2);
-}
-
-/**
- * Build the envelope, applying the payload cap.
- *
- * @param rows      compactResult: flat row objects, straight from the driver.
- * @param rowLimit  the cap pushed into the SQL.
- * @param result    the full Malloy result, read only for its metadata.
- */
-export function buildQueryEnvelope(
-   rows: unknown,
-   rowLimit: number,
-   result: Malloy.Result,
-   renderLogErrors: string[] = [],
-   limit = MAX_RESULT_CHARS,
-   rowLimitSource: QueryRowLimitSource = "server_default",
-   queryCorrelationId: string | null = null,
-): QueryEnvelope {
-   const rowCount = Array.isArray(rows) ? rows.length : 0;
-   // Equality, not >=: the cap is pushed into the SQL, so the database cannot
-   // return more than it. Landing exactly on it is the signal.
-   //
-   // Restricted to the server default on purpose. resolveModelQueryRowLimit
-   // folds the query's own limit:/top: into the same cap, so equality also holds
-   // every time an author deliberately limited the query: a modelled `top: 10`
-   // view returning its 10 rows would otherwise be reported as cut off, and the
-   // Contract rule would tell an agent that a top-N is "not the answer". Only
-   // the silently-applied default is evidence that rows were left behind.
-   const limitHit =
-      rowLimitSource === "server_default" &&
-      rowLimit > 0 &&
-      rowCount === rowLimit;
-
-   const envelope: QueryEnvelope = {
-      rows,
-      _meta: {
-         schema: result.schema,
-         annotations: result.annotations ?? [],
-         connection_name: result.connection_name,
-         ...(result.model_annotations !== undefined && {
-            model_annotations: result.model_annotations,
-         }),
-         ...(result.query_timezone !== undefined && {
-            query_timezone: result.query_timezone,
-         }),
-         ...(result.source_annotations !== undefined && {
-            source_annotations: result.source_annotations,
-         }),
-      },
-      _query_row_limit: rowLimit,
-      _limit_source: rowLimitSource,
-      _limit_hit: limitHit,
-      ...(queryCorrelationId !== null && { _query_id: queryCorrelationId }),
-      ...(renderLogErrors.length > 0 && { renderLogErrors }),
-   };
-
-   if (limitHit) {
-      envelope.warning =
-         `Returned exactly ${rowLimit} rows, the row limit applied to this query, so there are probably more. ` +
-         `This is not a complete result: add an explicit limit, aggregate, or filter rather than reporting these rows as the whole set.`;
-   }
-
-   return fitToBudget(envelope, limit);
-}
-
-/**
- * Drop rows until the serialized envelope fits, by binary search on the row
- * count.
- *
- * The marker fields are set BEFORE the search, so their serialized size counts
- * against the limit. Adding them afterwards pushes the payload back over the cap
- * the truncation existed to respect. `_returned_rows` is measured at `total`
- * first, whose digit width is at least that of any value it ends up holding, so
- * the finished payload stays under the limit. Credible's `_truncate_rows` does
- * the same thing for the same reason.
- *
- * The search can land on zero rows, which needs its own wording rather than
- * "Showing 0 of N rows": that reads as an empty result set, and an agent will
- * report "no rows matched" for what is really one row too large to send. It is
- * reachable, because the hard ceiling upstream is maxBytes (50MB by default), so
- * a single row carrying a large text or JSON column passes
- * assertWithinModelResponseLimits and arrives here. Both wordings are measured,
- * and the search uses whichever is longer, so swapping one for the other after
- * the fact cannot push the payload back over the cap.
- *
- * One case cannot be fixed by dropping rows: when the envelope minus its rows
- * already exceeds the limit (a very wide schema in `_meta`). The result is then
- * returned over-limit rather than emptied further, and the warning says so.
- */
-function fitToBudget(envelope: QueryEnvelope, limit: number): QueryEnvelope {
-   if (serialize(envelope).length <= limit) return envelope;
-
-   const rows = envelope.rows;
-   if (!Array.isArray(rows) || rows.length === 0) return envelope;
-   const total = rows.length;
-
-   const truncating: QueryEnvelope = {
-      ...envelope,
-      _rows_truncated: true,
-      _total_rows: total,
-      _returned_rows: total,
-   };
-   // The size warning joins any limit warning already present, and is included
-   // in the measurement for the same reason as the counts.
-   const sizeWarning = (kept: number) =>
-      `Showing ${kept} of ${total} rows; the rest were dropped to fit the result size limit. Narrow the query rather than paging through it.`;
-   const noneFitWarning =
-      `No rows fit the result size limit: the first of ${total} rows is too large to send on its own. ` +
-      `This is NOT an empty result and does not mean nothing matched. Select fewer columns, or truncate the oversized field, then run it again.`;
-   // Measure with whichever wording is longer, so the one actually returned is
-   // never bigger than the one the search sized the payload against.
-   const measured =
-      noneFitWarning.length > sizeWarning(total).length
-         ? noneFitWarning
-         : sizeWarning(total);
-   truncating.warning = [envelope.warning, measured].filter(Boolean).join(" ");
-
-   let low = 0;
-   let high = total;
-   let best = 0;
-   while (low <= high) {
-      const mid = Math.floor((low + high) / 2);
-      if (
-         serialize({ ...truncating, rows: rows.slice(0, mid) }).length <= limit
-      ) {
-         best = mid;
-         low = mid + 1;
-      } else {
-         high = mid - 1;
-      }
-   }
-
-   return {
-      ...truncating,
-      rows: rows.slice(0, best),
-      _returned_rows: best,
-      warning: [
-         envelope.warning,
-         best === 0 ? noneFitWarning : sizeWarning(best),
-      ]
-         .filter(Boolean)
-         .join(" "),
-   };
-}
-
-/** Serialize an envelope for transport, BigInt-safe. */
-export function serializeEnvelope(envelope: QueryEnvelope): string {
-   return serialize(envelope);
-}

package/src/mcp/server.protocol.spec.ts

@@ -1,250 +0,0 @@
-import { beforeAll, describe, expect, it } from "bun:test";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { initializeMcpServer } from "./server";
-import { RELOAD_FAILURE_IS_SAFE } from "./tools/reload_package_tool";
-import type { EnvironmentStore } from "../service/environment_store";
-
-/**
- * End-to-end coverage of the unified MCP server over the real MCP protocol,
- * using the SDK's in-memory transport (no HTTP, no network, no DuckDB).
- * Exercises tool registration (including the agent retrieval tools that now
- * live on the same server), the dual-channel skill prompts, a real tool call
- * (searchDocs over the bundled index), and the getContext error path.
- */
-describe("MCP server over the MCP protocol (in-memory)", () => {
-   let client: Client;
-
-   beforeAll(async () => {
-      // searchDocs does not touch the store, and the tools' error paths only
-      // need getEnvironment to reject. The one exception is `compiles-badly`,
-      // which resolves to a compileSource returning an error diagnostic: that
-      // is malloy_compile's own isError path (a bad Malloy snippet rather than
-      // a thrown error), and it is only reachable with an environment that
-      // exists.
-      const stubStore = {
-         getEnvironment: async (name: string) => {
-            if (name === "compiles-badly") {
-               return {
-                  compileSource: async () => ({
-                     problems: [
-                        {
-                           severity: "error",
-                           message: "'nope' is not defined",
-                           code: "field-not-found",
-                           at: {
-                              range: {
-                                 start: { line: 2, character: 3 },
-                                 end: { line: 2, character: 7 },
-                              },
-                           },
-                        },
-                     ],
-                  }),
-               };
-            }
-            throw new Error(`Environment not found: ${name}`);
-         },
-      } as unknown as EnvironmentStore;
-
-      const server = initializeMcpServer(stubStore);
-      const [clientTransport, serverTransport] =
-         InMemoryTransport.createLinkedPair();
-      await server.connect(serverTransport);
-      client = new Client({ name: "mcp-protocol-test", version: "0.0.0" });
-      await client.connect(clientTransport);
-   });
-
-   it("exposes the agent retrieval tools alongside the core tools", async () => {
-      const { tools } = await client.listTools();
-      const names = new Set(tools.map((t) => t.name));
-      expect(names.has("malloy_getContext")).toBe(true);
-      expect(names.has("malloy_searchDocs")).toBe(true);
-      expect(names.has("malloy_executeQuery")).toBe(true);
-      expect(names.has("malloy_compile")).toBe(true);
-      expect(names.has("malloy_reloadPackage")).toBe(true);
-   });
-
-   /**
-    * Tool descriptions are truncated by some clients. `malloy_getContext`'s was
-    * observed arriving cut off mid-sentence at 2271 characters, and what a tail
-    * cut removes is whatever the description put last.
-    *
-    * Two defenses, and the ordering one matters more. No single number is
-    * portable, since the cap belongs to the client and is not published; this
-    * budget only stops silent regrowth past the one length we have watched fail.
-    * The real rule is that contract rules come BEFORE the reference material, so
-    * a cut costs an agent the worked example rather than the invariants it
-    * cannot self-correct without. See docs/agent-skills/tool-description-template.md.
-    */
-   it("keeps every tool description under the truncation budget", async () => {
-      const BUDGET = 2000;
-      const { tools } = await client.listTools();
-      const oversized = tools
-         .filter((t) => (t.description ?? "").length > BUDGET)
-         .map((t) => `${t.name} (${t.description?.length})`);
-      expect(oversized).toEqual([]);
-   });
-
-   it("puts contract rules ahead of the reference sections", async () => {
-      // The section a tail-truncating client drops must never be the invariants.
-      const { tools } = await client.listTools();
-      for (const tool of tools) {
-         const description = tool.description ?? "";
-         const contract = description.indexOf("## Contract rules");
-         if (contract === -1) continue;
-         for (const later of ["## Response", "## Worked example"]) {
-            const index = description.indexOf(later);
-            if (index !== -1) {
-               expect(contract).toBeLessThan(index);
-            }
-         }
-      }
-   });
-
-   it("exposes the skill set as dual-channel prompts", async () => {
-      const { prompts } = await client.listPrompts();
-      expect(prompts.length).toBeGreaterThanOrEqual(24);
-      expect(prompts.some((p) => p.name === "malloy-analysis")).toBe(true);
-   });
-
-   it("delivers orientation instructions to the connecting client", () => {
-      const instructions = client.getInstructions();
-      expect(instructions).toBeDefined();
-      expect(instructions).toContain("malloy_getContext");
-      // Pin the shared fragment, not just that instructions exist. The whole
-      // point of exporting it is that this surface and the tool description
-      // cannot drift, and they have drifted twice. Without this, deleting the
-      // interpolation leaves the suite green and the drift comes back.
-      expect(instructions).toContain(RELOAD_FAILURE_IS_SAFE);
-   });
-
-   it("malloy_searchDocs returns relevant docs over the protocol", async () => {
-      const res = await client.callTool({
-         name: "malloy_searchDocs",
-         arguments: { query: "window functions" },
-      });
-      const content = res.content as Array<{ resource?: { text?: string } }>;
-      const results = JSON.parse(
-         content?.[0]?.resource?.text ?? "[]",
-      ) as Array<{
-         url: string;
-      }>;
-      expect(results.length).toBeGreaterThan(0);
-      expect(results[0].url.length).toBeGreaterThan(0);
-   });
-
-   /**
-    * Assert the tool's OWN error payload, not just isError. The SDK sets
-    * isError for any uncaught throw, so `expect(res.isError).toBe(true)` passes
-    * even with the tool's catch deleted entirely. Only these tools emit a
-    * resource block carrying structured JSON; a raw throw yields the SDK's text
-    * content instead, so this shape is what actually pins the catch.
-    */
-   function expectToolErrorPayload(result: unknown): {
-      error: string;
-      suggestions: string[];
-   } {
-      const res = result as {
-         isError?: boolean;
-         content?: Array<{
-            type?: string;
-            text?: string;
-            resource?: { text?: string; mimeType?: string };
-         }>;
-      };
-      expect(res.isError).toBe(true);
-      expect(res.content?.[0]?.type).toBe("resource");
-      expect(res.content?.[0]?.resource?.mimeType).toBe("application/json");
-      const payload = JSON.parse(res.content?.[0]?.resource?.text ?? "{}");
-      expect(typeof payload.error).toBe("string");
-      expect(Array.isArray(payload.suggestions)).toBe(true);
-
-      // The structured payload alone is invisible to a client that renders
-      // only text blocks on an error, which is how a real diagnostic ends up
-      // reported as a bare "Unknown error". Every error must also say it in
-      // plain text.
-      const textBlock = res.content?.find((b) => b.type === "text");
-      expect(textBlock?.text).toContain(payload.error);
-
-      return payload;
-   }
-
-   it("malloy_getContext returns its own error payload over the protocol", async () => {
-      const res = await client.callTool({
-         name: "malloy_getContext",
-         arguments: {
-            environmentName: "nope",
-            packageName: "nope",
-            query: "x",
-         },
-      });
-      expect(expectToolErrorPayload(res).error).toContain("nope");
-      // getContext answers with `results` at every tier, so an error keeps the
-      // key rather than making callers branch on success first.
-      const payload = JSON.parse(
-         (res.content as Array<{ resource?: { text?: string } }>)[0]?.resource
-            ?.text ?? "{}",
-      );
-      expect(payload.results).toEqual([]);
-   });
-
-   it("malloy_compile returns its own error payload over the protocol", async () => {
-      const res = await client.callTool({
-         name: "malloy_compile",
-         arguments: {
-            environmentName: "nope",
-            packageName: "nope",
-            modelPath: "x.malloy",
-            source: "run: x -> { aggregate: c is count() }",
-         },
-      });
-      expect(expectToolErrorPayload(res).error).toContain("nope");
-   });
-
-   it("malloy_compile states a compile diagnostic in text over the protocol", async () => {
-      // The diagnostics path keeps its {status, diagnostics} payload rather
-      // than the {error, suggestions} of the thrown-error path, so it cannot go
-      // through expectToolErrorPayload. What it shares is the invariant that
-      // matters: an isError result is never resource-only. Asserted over the
-      // real transport because a client that renders only text is exactly the
-      // one this was invisible to.
-      const res = await client.callTool({
-         name: "malloy_compile",
-         arguments: {
-            environmentName: "compiles-badly",
-            packageName: "p",
-            modelPath: "m.malloy",
-            source: "run: nope -> { aggregate: c is count() }",
-         },
-      });
-      const content = res.content as Array<{
-         type?: string;
-         text?: string;
-         resource?: { text?: string; mimeType?: string };
-      }>;
-      expect(res.isError).toBe(true);
-      expect(content[0]?.type).toBe("resource");
-      expect(content[0]?.resource?.mimeType).toBe("application/json");
-      expect(JSON.parse(content[0]?.resource?.text ?? "{}").status).toBe(
-         "error",
-      );
-      const textBlock = content.find((b) => b.type === "text");
-      expect(textBlock?.text).toContain("'nope' is not defined");
-      expect(textBlock?.text).toContain("field-not-found");
-   });
-
-   it("malloy_reloadPackage returns its own error payload over the protocol", async () => {
-      const res = await client.callTool({
-         name: "malloy_reloadPackage",
-         arguments: { environmentName: "nope", packageName: "nope" },
-      });
-      expect(expectToolErrorPayload(res).error).toContain("nope");
-   });
-
-   it("a skill prompt returns its body", async () => {
-      const res = await client.getPrompt({ name: "malloy-analysis" });
-      const content = res.messages[0].content as { text?: string };
-      expect((content.text ?? "").length).toBeGreaterThan(200);
-   });
-});

package/src/mcp/server.ts

@@ -1,87 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { EnvironmentStore } from "../service/environment_store";
-
-import { formatDuration, logger } from "../logger";
-import { registerCompileTool } from "./tools/compile_tool";
-import { registerDocsSearchTool } from "./tools/docs_search_tool";
-import { registerExecuteQueryTool } from "./tools/execute_query_tool";
-import { registerGetContextTool } from "./tools/get_context_tool";
-import {
-   registerReloadPackageTool,
-   RELOAD_FAILURE_IS_SAFE,
-} from "./tools/reload_package_tool";
-import skillsBundle from "./skills/skills_bundle.json";
-
-export const testServerInfo = {
-   name: "malloy-publisher-mcp-server",
-   version: "0.0.1",
-   displayName: "Malloy Publisher MCP Server",
-   description: "Provides access to Malloy models and query execution via MCP.",
-};
-
-// Build-time bundle of the agent skills (see skills/build_skills_bundle.ts),
-// exposed as MCP prompts for the dual-channel delivery below.
-const AGENT_SKILLS = (
-   skillsBundle as {
-      skills: { name: string; description: string; body: string }[];
-   }
-).skills;
-
-// Orientation delivered to any connecting MCP client via the initialize
-// response (the on-the-wire analog of AGENTS.md), so an agent that reached the
-// server over npx without cloning the repo still knows how to work. Kept
-// workflow-focused rather than a tool catalog, which the client already gets
-// from listTools, so it does not drift as the tool set changes.
-// SECURITY: this is delivered pre-authorization to any connecting client, so it
-// must stay STATIC. It may interpolate module-scope string LITERALS (see
-// RELOAD_FAILURE_IS_SAFE, shared with the tool description so the two cannot
-// drift). Not "constants": `const x = process.env.FOO` is a module-scope
-// constant and would put deployment config into an unauthenticated string. It
-// must never interpolate environment, package, connection, or request data.
-const MCP_INSTRUCTIONS = `Malloy Publisher serves one or more Malloy semantic-model packages, so you can discover what data exists and answer questions against it, grounded in the names the model actually defines.
-
-Start with malloy_getContext. Call it with no arguments to list the environments (each with its packages), with an environment to list its packages, with a package to list its sources, and with a package plus a plain-English question to get the sources, views, and fields most relevant to it. Use the names it returns verbatim and do not guess. Then run a query with malloy_executeQuery. To change a model: validate the edit with malloy_compile, save it, then call malloy_reloadPackage so the new sources and views become queryable by name without restarting the server. ${RELOAD_FAILURE_IS_SAFE}
-
-Task-specific guidance is served as prompts you can fetch by name: malloy-getting-started to begin, malloy-modeling to build or change a model, malloy-analysis to explore and answer questions, and malloy-review to check correctness.
-
-Results and any charts render in the Publisher web UI on the REST port (4000 by default).`;
-
-export function initializeMcpServer(
-   environmentStore: EnvironmentStore,
-): McpServer {
-   logger.info("[MCP Init] Starting initializeMcpServer...");
-   const startTime = performance.now();
-
-   const mcpServer = new McpServer(testServerInfo, {
-      instructions: MCP_INSTRUCTIONS,
-   });
-
-   registerExecuteQueryTool(mcpServer, environmentStore);
-   registerGetContextTool(mcpServer, environmentStore);
-   registerDocsSearchTool(mcpServer, environmentStore);
-   registerCompileTool(mcpServer, environmentStore);
-   registerReloadPackageTool(mcpServer, environmentStore);
-
-   // Dual-channel: also expose each skill as an MCP prompt, so hosts that ingest
-   // MCP but do not load skill files (e.g. Codex, ChatGPT, Cursor) can pull the
-   // same guidance. Skill-aware hosts (Claude Code/Desktop) use the native skill
-   // files. Note: MCP prompts are on-demand, so always-on "prevention" skills
-   // become on-demand here; see docs/agent-skills/design-principles.md.
-   for (const skill of AGENT_SKILLS) {
-      mcpServer.prompt(skill.name, skill.description, () => ({
-         messages: [
-            {
-               role: "user" as const,
-               content: { type: "text" as const, text: skill.body },
-            },
-         ],
-      }));
-   }
-
-   const endTime = performance.now();
-   logger.info(`[MCP Init] Finished initializeMcpServer`, {
-      duration: formatDuration(endTime - startTime),
-   });
-
-   return mcpServer;
-}

package/src/mcp/skills/build_skills_bundle.spec.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { parseSkill, unquote } from "./build_skills_bundle";
-
-describe("build_skills_bundle parseSkill", () => {
-   it("parses name, description, and body from frontmatter", () => {
-      const md =
-         "---\nname: malloy-queries\ndescription: Query patterns.\n---\n# Body\n\nText.";
-      const s = parseSkill(md, "dir");
-      expect(s.name).toBe("malloy-queries");
-      expect(s.description).toBe("Query patterns.");
-      expect(s.body).toBe("# Body\n\nText.");
-   });
-
-   it("keeps colons in the description (line-based, not split on colon)", () => {
-      const md =
-         "---\nname: x\ndescription: Use when: a thing happens.\n---\nbody";
-      expect(parseSkill(md, "dir").description).toBe(
-         "Use when: a thing happens.",
-      );
-   });
-
-   it("tolerates CRLF line endings", () => {
-      const md = "---\r\nname: x\r\ndescription: d\r\n---\r\nbody line";
-      const s = parseSkill(md, "dir");
-      expect(s.name).toBe("x");
-      expect(s.description).toBe("d");
-      expect(s.body).toBe("body line");
-   });
-
-   it("falls back to the dir name and empty description when frontmatter is missing", () => {
-      const s = parseSkill("# Just a body, no frontmatter", "fallback-name");
-      expect(s.name).toBe("fallback-name");
-      expect(s.description).toBe("");
-      expect(s.body).toBe("# Just a body, no frontmatter");
-   });
-
-   it("strips surrounding quotes from values", () => {
-      const md = "---\nname: \"quoted-name\"\ndescription: 'q'\n---\nb";
-      const s = parseSkill(md, "dir");
-      expect(s.name).toBe("quoted-name");
-      expect(s.description).toBe("q");
-   });
-});
-
-describe("build_skills_bundle unquote", () => {
-   it("removes a single layer of surrounding quotes", () => {
-      expect(unquote('"hi"')).toBe("hi");
-      expect(unquote("'hi'")).toBe("hi");
-      expect(unquote("plain")).toBe("plain");
-   });
-});