@canonical/pragma-cli 0.29.0 → 0.31.0

package/src/domains/shared/emptyErrorRecovery.test.ts

@@ -4,8 +4,7 @@ import blockSpecs from "../block/mcp/specs.js";
 import blockEmptyError from "../block/orchestration/blockEmptyError.js";
 import modifierSpecs from "../modifier/mcp/specs.js";
 import modifierEmptyError from "../modifier/orchestration/modifierEmptyError.js";
-import standardSpecs from "../standard/mcp/specs.js";
-import standardEmptyError from "../standard/orchestration/standardEmptyError.js";
+import { TOKEN_READ_SURFACE_ENABLED } from "../token/featureFlag.js";
 import tokenSpecs from "../token/mcp/specs.js";
 import tokenEmptyError from "../token/orchestration/tokenEmptyError.js";
 import type { FilterConfig } from "./types/index.js";
@@ -40,36 +39,34 @@ const cases: ReadonlyArray<{
     toolNames: new Set(blockSpecs.map((s) => s.name)),
     storeEmpty: false,
   },
-  {
-    domain: "token (category active)",
-    error: tokenEmptyError("color"),
-    toolNames: new Set(tokenSpecs.map((s) => s.name)),
-    storeEmpty: false,
-  },
-  {
-    domain: "token (store-empty)",
-    error: tokenEmptyError(),
-    toolNames: new Set(tokenSpecs.map((s) => s.name)),
-    storeEmpty: true,
-  },
+  // The token read surface (and with it the paths that raise
+  // tokenEmptyError) is gated behind the token feature flag; its recovery
+  // hints can only point at registered tools while the surface is live.
+  ...(TOKEN_READ_SURFACE_ENABLED
+    ? [
+        {
+          domain: "token (category active)",
+          error: tokenEmptyError("color"),
+          toolNames: new Set(tokenSpecs.map((s) => s.name)),
+          storeEmpty: false,
+        },
+        {
+          domain: "token (store-empty)",
+          error: tokenEmptyError(),
+          toolNames: new Set(tokenSpecs.map((s) => s.name)),
+          storeEmpty: true,
+        },
+      ]
+    : []),
   {
     domain: "modifier (store-empty)",
     error: modifierEmptyError(),
     toolNames: new Set(modifierSpecs.map((s) => s.name)),
     storeEmpty: true,
   },
-  {
-    domain: "standard (filter active)",
-    error: standardEmptyError({ category: "react" }),
-    toolNames: new Set(standardSpecs.map((s) => s.name)),
-    storeEmpty: false,
-  },
-  {
-    domain: "standard (store-empty)",
-    error: standardEmptyError({}),
-    toolNames: new Set(standardSpecs.map((s) => s.name)),
-    storeEmpty: true,
-  },
+  // `standard` left this contract with its domain: the bundled pack has no
+  // emptyError hook (a pinned PARITY_GAP), so an empty standard list renders
+  // zero rows instead of an EMPTY_RESULTS recovery.
 ];
 
 describe("empty-error recovery contract (cross-domain)", () => {

package/src/domains/shared/extractLocalName.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import extractLocalName from "./extractLocalName.js";
-import { PREFIX_MAP } from "./prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "./prefixes.js";
 
 describe("extractLocalName", () => {
   it("extracts after hash", () => {
@@ -8,7 +8,7 @@ describe("extractLocalName", () => {
   });
 
   it("extracts after last slash", () => {
-    expect(extractLocalName(`${PREFIX_MAP.ds}global`)).toBe("global");
+    expect(extractLocalName(`${DEFAULT_PREFIX_MAP.ds}global`)).toBe("global");
   });
 
   it("returns full string when no separator", () => {
@@ -16,6 +16,6 @@ describe("extractLocalName", () => {
   });
 
   it("handles nested path", () => {
-    expect(extractLocalName(`${PREFIX_MAP.ds}apps/lxd`)).toBe("lxd");
+    expect(extractLocalName(`${DEFAULT_PREFIX_MAP.ds}apps/lxd`)).toBe("lxd");
   });
 });

package/src/domains/shared/formatters.ts

@@ -70,13 +70,34 @@ export function renderLookupResults<TResult, TInput>(
 
   const parts = result.results.map((item) => formatOne(mapResult(item)));
   if (result.errors.length > 0) {
+    const heading = ctx.globalFlags.llm ? "**Errors:**" : "Errors:";
     parts.push(
       [
-        "Errors:",
-        ...result.errors.map((error) => `- ${error.query}: ${error.message}`),
+        heading,
+        ...result.errors.flatMap((error) => formatErrorLines(error)),
       ].join("\n"),
     );
   }
 
   return parts.join("\n\n");
 }
+
+/**
+ * Render one lookup error as display lines: the query and message, plus any
+ * fuzzy-match suggestions carried on the error (which the JSON mode surfaces
+ * but the text modes previously dropped).
+ *
+ * @param error - A single lookup error entry.
+ * @returns One or more display lines for this error.
+ */
+function formatErrorLines(error: {
+  query: string;
+  message: string;
+  suggestions?: readonly string[];
+}): string[] {
+  const lines = [`- ${error.query}: ${error.message}`];
+  if (error.suggestions && error.suggestions.length > 0) {
+    lines.push(`  Did you mean: ${error.suggestions.join(", ")}?`);
+  }
+  return lines;
+}

package/src/domains/shared/listTiers.ts

@@ -0,0 +1,40 @@
+/**
+ * List the tiers defined in the loaded ontology, ordered by name.
+ *
+ * Shared operation: the `tier list` CLI/MCP surface is served by the bundled
+ * `tier` story pack, but `config tier` validation still needs the tier set
+ * programmatically, and this stays part of the package's public API. Kept in
+ * the shared layer so it has no dependency on any DS-specific domain module.
+ *
+ * @param store - ke store to query.
+ * @returns Array of tier entries, empty when none exist.
+ * @note Impure — queries the ke store.
+ */
+
+import type { Store, URI } from "@canonical/ke";
+import { buildQuery } from "./buildQuery.js";
+import { P } from "./prefixes.js";
+import type { TierEntry } from "./types/index.js";
+
+export async function listTiers(store: Store): Promise<TierEntry[]> {
+  const result = await store.query(
+    buildQuery(`
+      SELECT ?tier ?name
+      WHERE {
+        ?tier a ${P.ds}Tier ;
+              ${P.ds}name ?name .
+      }
+      ORDER BY ?name
+    `),
+  );
+
+  if (result.type !== "select") return [];
+
+  return result.bindings.map((b) => ({
+    uri: (b.tier ?? "") as URI,
+    path: b.name ?? "",
+    depth: 0,
+  }));
+}
+
+export default listTiers;

package/src/domains/shared/loaders/bundledLoader.test.ts

@@ -0,0 +1,248 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { PackageRef } from "../../refs/operations/parseRef.js";
+import createBundledLoader, {
+  resetBundledLoaderCache,
+} from "./bundledLoader.js";
+
+const ref: PackageRef = { kind: "npm", pkg: "@canonical/design-system" };
+
+/** Minimal stand-in for a Bun embedded-file blob. */
+interface FakeBlob {
+  readonly name: string;
+  text(): Promise<string>;
+}
+
+const blob = (name: string, content: string): FakeBlob => ({
+  name,
+  text: async () => content,
+});
+
+const corruptBlob = (name: string): FakeBlob => ({
+  name,
+  text: async () => {
+    throw new Error("embedded blob unreadable");
+  },
+});
+
+const TTL = "@prefix ds: <https://example.test/ds#> .";
+
+function stubEmbeddedFiles(blobs: readonly FakeBlob[]): void {
+  (globalThis as { Bun?: unknown }).Bun = { embeddedFiles: blobs };
+}
+
+const hadBun = typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
+const originalBun = (globalThis as { Bun?: unknown }).Bun;
+
+let stderrSpy: ReturnType<typeof vi.spyOn>;
+
+beforeEach(() => {
+  resetBundledLoaderCache();
+  stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+});
+
+afterEach(() => {
+  resetBundledLoaderCache();
+  if (hadBun) {
+    (globalThis as { Bun?: unknown }).Bun = originalBun;
+  } else {
+    delete (globalThis as { Bun?: unknown }).Bun;
+  }
+  stderrSpy.mockRestore();
+});
+
+const stderrText = (): string =>
+  stderrSpy.mock.calls.map((call) => String(call[0])).join("");
+
+describe("createBundledLoader", () => {
+  it("returns undefined outside a compiled Bun binary", async () => {
+    if (!hadBun) {
+      delete (globalThis as { Bun?: unknown }).Bun;
+      const resolved = await createBundledLoader().resolve(ref);
+      expect(resolved).toBeUndefined();
+    }
+  });
+
+  it("bundles all embedded TTL and reads the manifest version", async () => {
+    stubEmbeddedFiles([
+      blob("button-a1b2c3d4.ttl", TTL),
+      blob("package-a1b2c3d4.json", JSON.stringify({ version: "1.2.3" })),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+
+    expect(resolved).toBeDefined();
+    expect(resolved?.source).toBe("bundled");
+    expect(resolved?.version).toBe("1.2.3");
+    expect(resolved?.graphs).toEqual([
+      {
+        path: "(bundled)/button-a1b2c3d4.ttl",
+        content: TTL,
+        format: "turtle",
+      },
+    ]);
+  });
+
+  it("accepts a plain package.json basename", async () => {
+    stubEmbeddedFiles([
+      blob("button.ttl", TTL),
+      blob("package.json", JSON.stringify({ version: "2.0.0" })),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+    expect(resolved?.version).toBe("2.0.0");
+  });
+
+  it("warns and skips a corrupt TTL blob instead of silently dropping it", async () => {
+    stubEmbeddedFiles([
+      blob("good-a1b2c3d4.ttl", TTL),
+      corruptBlob("bad-a1b2c3d4.ttl"),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+
+    expect(resolved?.graphs).toHaveLength(1);
+    expect(stderrText()).toContain("bad-a1b2c3d4.ttl");
+    expect(stderrText()).toContain("embedded blob unreadable");
+  });
+
+  it("serves embedded story JSON as story-file entries", async () => {
+    stubEmbeddedFiles([
+      blob("button-a1b2c3d4.ttl", TTL),
+      blob("package-a1b2c3d4.json", JSON.stringify({ version: "1.2.3" })),
+      blob("colors-fyskc7pf.json", JSON.stringify({ noun: "color" })),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+
+    expect(resolved?.stories).toEqual([
+      {
+        path: "(bundled)/colors-fyskc7pf.json",
+        definition: { noun: "color" },
+      },
+    ]);
+    expect(resolved?.version).toBe("1.2.3");
+  });
+
+  it("does not serve package manifests as stories", async () => {
+    stubEmbeddedFiles([
+      blob("button.ttl", TTL),
+      blob("package.json", JSON.stringify({ version: "2.0.0" })),
+      blob("package-deadbeef.json", JSON.stringify({ version: "3.0.0" })),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+
+    expect(resolved?.stories).toEqual([]);
+  });
+
+  it("warns and skips a story blob with invalid JSON instead of crashing", async () => {
+    stubEmbeddedFiles([
+      blob("button.ttl", TTL),
+      blob("good-a1b2c3d4.json", JSON.stringify({ noun: "color" })),
+      blob("broken-a1b2c3d4.json", "{ not json"),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+
+    expect(resolved?.stories).toHaveLength(1);
+    expect(resolved?.stories.at(0)?.definition).toEqual({ noun: "color" });
+    expect(stderrText()).toContain("broken-a1b2c3d4.json");
+  });
+
+  it("warns and skips an unreadable story blob", async () => {
+    stubEmbeddedFiles([
+      blob("button.ttl", TTL),
+      corruptBlob("story-a1b2c3d4.json"),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+
+    expect(resolved?.stories).toEqual([]);
+    expect(stderrText()).toContain("story-a1b2c3d4.json");
+    expect(stderrText()).toContain("embedded blob unreadable");
+  });
+
+  it("resolves a stories-only bundle with no TTL graphs", async () => {
+    stubEmbeddedFiles([
+      blob("colors-fyskc7pf.json", JSON.stringify({ noun: "color" })),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+
+    expect(resolved).toBeDefined();
+    expect(resolved?.graphs).toEqual([]);
+    expect(resolved?.stories).toHaveLength(1);
+  });
+
+  it("returns undefined when no TTL or story content is embedded", async () => {
+    stubEmbeddedFiles([
+      blob("template-a1b2c3d4.ejs", "<%= name %>"),
+      blob("skill-a1b2c3d4.md", "# Skill"),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+
+    expect(resolved).toBeUndefined();
+  });
+
+  it("warns on a corrupt package manifest and falls back to 0.0.0", async () => {
+    stubEmbeddedFiles([
+      blob("button.ttl", TTL),
+      blob("package-deadbeef.json", "{ not json"),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+
+    expect(resolved?.version).toBe("0.0.0");
+    expect(stderrText()).toContain("package-deadbeef.json");
+  });
+
+  it("rejects JSON blobs whose basename is not a package manifest", async () => {
+    stubEmbeddedFiles([
+      blob("button.ttl", TTL),
+      blob("mypackage.json", JSON.stringify({ version: "9.9.9" })),
+      blob("package-lock.json", JSON.stringify({ version: "8.8.8" })),
+      blob("packages.json", JSON.stringify({ version: "7.7.7" })),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+    expect(resolved?.version).toBe("0.0.0");
+  });
+
+  it("warns on an invalid semver version and keeps looking", async () => {
+    stubEmbeddedFiles([
+      blob("button.ttl", TTL),
+      blob("package-aaaaaaaa.json", JSON.stringify({ version: "not-semver" })),
+      blob("package-bbbbbbbb.json", JSON.stringify({ version: "3.4.5" })),
+    ]);
+
+    const resolved = await createBundledLoader().resolve(ref);
+
+    expect(resolved?.version).toBe("3.4.5");
+    expect(stderrText()).toContain('invalid semver "not-semver"');
+  });
+
+  it("caches the resolved package until the cache is reset", async () => {
+    stubEmbeddedFiles([
+      blob("button.ttl", TTL),
+      blob("package.json", JSON.stringify({ version: "1.0.0" })),
+    ]);
+
+    const first = await createBundledLoader().resolve(ref);
+    expect(first?.version).toBe("1.0.0");
+
+    // New fixture without reset — cached result still returned.
+    stubEmbeddedFiles([
+      blob("other.ttl", TTL),
+      blob("package.json", JSON.stringify({ version: "5.0.0" })),
+    ]);
+    const second = await createBundledLoader().resolve(ref);
+    expect(second).toBe(first);
+
+    // After reset the loader re-reads the embedded files.
+    resetBundledLoaderCache();
+    const third = await createBundledLoader().resolve(ref);
+    expect(third?.version).toBe("5.0.0");
+    expect(third).not.toBe(first);
+  });
+});

package/src/domains/shared/loaders/bundledLoader.ts

@@ -1,23 +1,32 @@
 /**
  * Bundled package loader for compiled binaries.
  *
- * Resolves semantic content from `Bun.embeddedFiles` — TTL and skill
- * files embedded into the compiled binary via the build command.
+ * Resolves semantic content from `Bun.embeddedFiles` — the TTL graphs
+ * and story-pack JSON embedded into the compiled binary via the build
+ * command. Skills are not embedded; this loader reports `skills: []`.
  *
  * Blob names are hashed by bun (e.g. `button-a1b2c3d4.ttl`), losing
  * directory and package association. The loader therefore returns a
- * single SemanticPackage containing ALL embedded TTL content. RDF
- * stores deduplicate triples, so this is safe when combined with
- * higher-precedence loaders that resolve individual packages.
+ * single SemanticPackage containing ALL embedded TTL and story content,
+ * and the same cached package is returned for every ref this loader
+ * resolves.
+ * Note that repeated loads are NOT fully deduplicated by the store:
+ * Oxigraph applies set semantics to ground triples, but blank nodes are
+ * re-minted on every parse, so content loaded both here and by a
+ * higher-precedence loader can produce duplicated blank-node subgraphs.
+ * The orchestrator's first-loader-wins precedence (local > git >
+ * bundled) is what keeps individual packages from double-loading.
  *
  * @note Impure — reads embedded blobs.
  */
 
+import { basename } from "node:path";
 import type { PackageRef } from "../../refs/operations/parseRef.js";
 import type {
   GraphContent,
   PackageLoader,
   SemanticPackage,
+  StoryFileEntry,
 } from "../semanticPackage.js";
 
 // ---------------------------------------------------------------------------
@@ -27,6 +36,45 @@ import type {
 /** Cached result — embedded content is immutable, no need to re-read. */
 let cached: SemanticPackage | undefined;
 
+/**
+ * Reset the module-level cache. Test-only: lets suites exercise the loader
+ * against different `Bun.embeddedFiles` fixtures without module isolation.
+ */
+export function resetBundledLoaderCache(): void {
+  cached = undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+/**
+ * Embedded package manifest basename: exactly `package.json`, or
+ * `package-<hash>.json` where `<hash>` is bun's content hash suffix.
+ */
+const PACKAGE_MANIFEST_PATTERN = /^package(?:-[0-9a-f]{6,64})?\.json$/i;
+
+/**
+ * Semver 2.0.0 validation (semver.org's suggested pattern).
+ */
+const SEMVER_PATTERN =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+/**
+ * Whether a blob name is an embedded package manifest — strict basename
+ * match, so unrelated JSON blobs (e.g. `mypackage.json`) are not misread.
+ */
+function isPackageManifest(name: string): boolean {
+  return PACKAGE_MANIFEST_PATTERN.test(basename(name));
+}
+
+/**
+ * Emit a loader warning on stderr (safe for both CLI and MCP stdio use).
+ */
+function warn(message: string): void {
+  process.stderr.write(`Warning: bundled loader: ${message}\n`);
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -44,16 +92,20 @@ export default function createBundledLoader(): PackageLoader {
       if (!blobs?.length) return undefined;
 
       const graphs = await readEmbeddedGraphs(blobs);
-      if (graphs.length === 0) return undefined;
+      const stories = await readEmbeddedStories(blobs);
+      if (graphs.length === 0 && stories.length === 0) return undefined;
 
       const version = await readEmbeddedVersion(blobs);
+      const prefixes = await readEmbeddedPrefixes(blobs);
 
       cached = {
         name: "(bundled)",
         version,
         source: "bundled",
         graphs,
+        ...(prefixes ? { prefixes } : {}),
         skills: [],
+        stories,
       };
 
       return cached;
@@ -80,28 +132,122 @@ async function readEmbeddedGraphs(
         content,
         format: "turtle",
       });
-    } catch {}
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      warn(`skipping unreadable embedded graph "${blob.name}": ${reason}`);
+    }
   }
 
   return graphs;
 }
 
+// ---------------------------------------------------------------------------
+// Story reading
+// ---------------------------------------------------------------------------
+
+/**
+ * Read story-pack definitions from embedded `.json` blobs.
+ *
+ * The build's story-assets plugin makes `stories/*.json` the only JSON
+ * embedded as file assets (see storyAssetsPlugin.ts), so every `.json`
+ * blob not named like a package manifest is a story file. Mirrors the
+ * local loader: a blob that cannot be read or parsed warns on stderr
+ * and is skipped — one bad file cannot break boot. Definitions are
+ * shape-validated later by the story-pack compiler.
+ */
+async function readEmbeddedStories(
+  blobs: ReadonlyArray<Blob & { name: string }>,
+): Promise<StoryFileEntry[]> {
+  const stories: StoryFileEntry[] = [];
+
+  for (const blob of blobs) {
+    if (!blob.name.endsWith(".json") || isPackageManifest(blob.name)) continue;
+
+    try {
+      stories.push({
+        path: `(bundled)/${blob.name}`,
+        definition: JSON.parse(await blob.text()),
+      });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      warn(`skipping invalid embedded story "${blob.name}": ${reason}`);
+    }
+  }
+
+  return stories;
+}
+
 // ---------------------------------------------------------------------------
 // Version reading
 // ---------------------------------------------------------------------------
 
+/**
+ * Aggregate `pragma.prefixes` declared across embedded package manifests.
+ *
+ * The bundled loader collapses every embedded package into one aggregate
+ * SemanticPackage, so their prefix declarations are merged here (later
+ * manifests win on key collisions). Only string→string entries are kept;
+ * malformed shapes are ignored so one bad manifest cannot break boot.
+ *
+ * @returns The merged prefix map, or `undefined` when none is declared.
+ */
+async function readEmbeddedPrefixes(
+  blobs: ReadonlyArray<Blob & { name: string }>,
+): Promise<Readonly<Record<string, string>> | undefined> {
+  const prefixes: Record<string, string> = {};
+
+  for (const blob of blobs) {
+    if (!isPackageManifest(blob.name)) continue;
+
+    try {
+      const parsed = JSON.parse(await blob.text()) as { pragma?: unknown };
+      const pragma = parsed.pragma;
+      if (typeof pragma !== "object" || pragma === null) continue;
+      const raw = (pragma as { prefixes?: unknown }).prefixes;
+      if (typeof raw !== "object" || raw === null) continue;
+      for (const [name, namespace] of Object.entries(raw)) {
+        if (typeof namespace !== "string") continue;
+        // These collapse into one aggregate package, so a cross-manifest
+        // collision would never reach resolvePrefixes' warning — surface it
+        // here, naming the manifest, instead of silently last-winning.
+        if (name in prefixes && prefixes[name] !== namespace) {
+          warn(
+            `embedded manifest "${blob.name}" overrides prefix "${name}" ` +
+              `(was <${prefixes[name]}>, now <${namespace}>)`,
+          );
+        }
+        prefixes[name] = namespace;
+      }
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      warn(`skipping prefixes in embedded manifest "${blob.name}": ${reason}`);
+    }
+  }
+
+  return Object.keys(prefixes).length > 0 ? prefixes : undefined;
+}
+
 async function readEmbeddedVersion(
   blobs: ReadonlyArray<Blob & { name: string }>,
 ): Promise<string> {
   for (const blob of blobs) {
-    if (!blob.name.includes("package") || !blob.name.endsWith(".json"))
-      continue;
+    if (!isPackageManifest(blob.name)) continue;
 
     try {
       const text = await blob.text();
-      const parsed = JSON.parse(text) as { version?: string };
-      if (parsed.version) return parsed.version;
-    } catch {}
+      const parsed = JSON.parse(text) as { version?: unknown };
+      if (typeof parsed.version !== "string") continue;
+      if (!SEMVER_PATTERN.test(parsed.version)) {
+        warn(
+          `ignoring invalid semver "${parsed.version}" in embedded manifest "${blob.name}"`,
+        );
+        continue;
+      }
+      return parsed.version;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      warn(`skipping corrupt embedded manifest "${blob.name}": ${reason}`);
+    }
   }
 
   return "0.0.0";

package/src/domains/shared/loaders/gitLoader.ts

@@ -24,8 +24,7 @@ export default function createGitLoader(): PackageLoader {
       const dir = gitCacheDir(ref.pkg, ref.ref);
       if (!existsSync(dir)) return undefined;
 
-      const { version, graphs, skills } = readPackageDir(dir);
-      return { name: ref.pkg, version, source: "git", graphs, skills };
+      return { name: ref.pkg, source: "git", ...readPackageDir(dir) };
     },
   };
 }

package/src/domains/shared/loaders/index.ts

@@ -1,6 +1,9 @@
 /** @module Semantic package loaders — local, git, and bundled resolution. */
 
-export { default as createBundledLoader } from "./bundledLoader.js";
+export {
+  default as createBundledLoader,
+  resetBundledLoaderCache,
+} from "./bundledLoader.js";
 export { default as createGitLoader } from "./gitLoader.js";
 export { default as createLocalLoader } from "./localLoader.js";
 export { default as readPackageDir } from "./readPackageDir.js";