akm-cli 0.7.0-rc1 → 0.7.0

package/dist/tests/bench/workflow-trace.js

@@ -30,6 +30,27 @@
  *
  * NOT in scope: live tailing, persistence, evaluation. Those belong to #256.
  */
+/** Runtime set of all valid workflow trace event names. Single source of truth. */
+export const WORKFLOW_TRACE_EVENT_NAMES = new Set([
+    "agent_started",
+    "akm_search",
+    "akm_show",
+    "akm_feedback",
+    "akm_reflect",
+    "akm_distill",
+    "akm_propose",
+    "akm_proposal_accept",
+    "akm_workflow_start",
+    "akm_workflow_next",
+    "akm_workflow_complete",
+    "akm_workflow_finish",
+    "workspace_read",
+    "workspace_write",
+    "first_workspace_write",
+    "test_run",
+    "verifier_run",
+    "agent_finished",
+]);
 /* ─── Caps (documented contract) ──────────────────────────────────────────── */
 /** Hard cap on total events per trace. Prevents a noisy run from OOM-ing the harness. */
 export const MAX_EVENT_COUNT = 4096;
@@ -182,6 +203,9 @@ const AKM_EVENT_TYPE_MAP = {
     distill_invoked: "akm_distill",
     propose_invoked: "akm_propose",
     promoted: "akm_proposal_accept",
+    workflow_started: "akm_workflow_start",
+    workflow_step_completed: "akm_workflow_complete",
+    workflow_finished: "akm_workflow_finish",
 };
 function fromAkmEvent(ev, run, options, originalIndex) {
     if (!ev || typeof ev !== "object")
@@ -354,6 +378,16 @@ function classifyArgs(command, argv) {
             return { type: "akm_distill", command, args: argv };
         case "propose":
             return { type: "akm_propose", command, args: argv };
+        case "workflow": {
+            const sub = rest[0];
+            if (sub === "start")
+                return { type: "akm_workflow_start", command, args: argv, assetRef: rest[1] };
+            if (sub === "next")
+                return { type: "akm_workflow_next", command, args: argv, assetRef: rest[1] };
+            if (sub === "complete")
+                return { type: "akm_workflow_complete", command, args: argv };
+            return null;
+        }
         default:
             return null;
     }

package/dist/tests/cli-errors.test.js

@@ -59,6 +59,7 @@ describe("CLI error handling", () => {
         const parsed = JSON.parse(stderr.trim());
         expect(parsed.ok).toBe(false);
         expect(typeof parsed.error).toBe("string");
+        expect(parsed.code).toBe("INVALID_FLAG_VALUE");
     });
     test("search --source invalid prints hint about source", () => {
         const { stderr, status } = runCli("search", "test", "--source", "invalid");

package/dist/tests/commands/history.test.js

@@ -5,6 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import { akmHistory } from "../../src/commands/history";
 import { saveConfig } from "../../src/core/config";
+import { appendEvent } from "../../src/core/events";
 import { getDbPath } from "../../src/core/paths";
 import { closeDatabase, openDatabase } from "../../src/indexer/db";
 import { akmIndex } from "../../src/indexer/indexer";
@@ -221,3 +222,197 @@ describe("akm history CLI", () => {
         expect(typeof parsed.error).toBe("string");
     });
 });
+describe("akmHistory --include-proposals", () => {
+    test("sources field is ['usage_events'] by default", async () => {
+        const db = openDatabase(":memory:");
+        try {
+            ensureUsageEventsSchema(db);
+            const result = await akmHistory({ db });
+            expect(result.sources).toEqual(["usage_events"]);
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("sources field includes events.jsonl when includeProposals is true", async () => {
+        const eventsFile = path.join(makeTempDir("akm-history-events-"), "events.jsonl");
+        const db = openDatabase(":memory:");
+        try {
+            ensureUsageEventsSchema(db);
+            const result = await akmHistory({
+                db,
+                includeProposals: true,
+                eventsCtx: { filePath: eventsFile },
+            });
+            expect(result.sources).toEqual(["usage_events", "events.jsonl"]);
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("proposal accept event (promoted) appears in history with --include-proposals", async () => {
+        const eventsFile = path.join(makeTempDir("akm-history-proposal-"), "events.jsonl");
+        const db = openDatabase(":memory:");
+        try {
+            ensureUsageEventsSchema(db);
+            // Simulate `akm proposal accept` emitting a promoted event.
+            appendEvent({
+                eventType: "promoted",
+                ref: "skill:deploy",
+                metadata: { proposalId: "prop-001", source: "reflect", assetPath: "/stash/skills/deploy.md" },
+            }, { filePath: eventsFile });
+            const result = await akmHistory({
+                db,
+                includeProposals: true,
+                eventsCtx: { filePath: eventsFile },
+            });
+            expect(result.totalCount).toBe(1);
+            const promoted = result.entries.find((e) => e.eventType === "promoted");
+            expect(promoted).toBeDefined();
+            expect(promoted?.ref).toBe("skill:deploy");
+            expect(promoted?.eventType).toBe("promoted");
+            // Metadata from the proposal should be accessible.
+            expect(promoted?.metadata?.proposalId).toBe("prop-001");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("proposal reject event (rejected) appears in history with --include-proposals", async () => {
+        const eventsFile = path.join(makeTempDir("akm-history-reject-"), "events.jsonl");
+        const db = openDatabase(":memory:");
+        try {
+            ensureUsageEventsSchema(db);
+            appendEvent({
+                eventType: "rejected",
+                ref: "memory:old-draft",
+                metadata: { proposalId: "prop-002", source: "reflect", reason: "outdated" },
+            }, { filePath: eventsFile });
+            const result = await akmHistory({
+                db,
+                includeProposals: true,
+                eventsCtx: { filePath: eventsFile },
+            });
+            expect(result.totalCount).toBe(1);
+            const rejected = result.entries.find((e) => e.eventType === "rejected");
+            expect(rejected).toBeDefined();
+            expect(rejected?.ref).toBe("memory:old-draft");
+            expect(rejected?.metadata?.reason).toBe("outdated");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("non-proposal events in events.jsonl are excluded even with --include-proposals", async () => {
+        const eventsFile = path.join(makeTempDir("akm-history-filter-"), "events.jsonl");
+        const db = openDatabase(":memory:");
+        try {
+            ensureUsageEventsSchema(db);
+            // These event types should NOT appear in history even with --include-proposals.
+            appendEvent({ eventType: "add", ref: "skill:deploy" }, { filePath: eventsFile });
+            appendEvent({ eventType: "reflect_invoked", ref: "memory:alpha" }, { filePath: eventsFile });
+            // Only this one should appear.
+            appendEvent({ eventType: "promoted", ref: "skill:deploy", metadata: { proposalId: "p1", source: "reflect" } }, { filePath: eventsFile });
+            const result = await akmHistory({
+                db,
+                includeProposals: true,
+                eventsCtx: { filePath: eventsFile },
+            });
+            expect(result.entries.every((e) => e.eventType === "promoted" || e.eventType === "rejected")).toBe(true);
+            expect(result.entries.length).toBe(1);
+            expect(result.entries[0]?.eventType).toBe("promoted");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("usage events and proposal events are merged chronologically", async () => {
+        const eventsFile = path.join(makeTempDir("akm-history-merge-"), "events.jsonl");
+        const db = openDatabase(":memory:");
+        try {
+            ensureUsageEventsSchema(db);
+            // Insert usage events with explicit timestamps (early, then late).
+            db.prepare("INSERT INTO usage_events (event_type, entry_ref, entry_id, created_at) VALUES (?, ?, ?, ?)").run("show", "skill:deploy", 1, "2026-01-01 10:00:00");
+            db.prepare("INSERT INTO usage_events (event_type, entry_ref, entry_id, created_at) VALUES (?, ?, ?, ?)").run("feedback", "skill:deploy", 1, "2026-01-03 12:00:00");
+            // Append a proposal event between the two usage events.
+            appendEvent({ eventType: "promoted", ref: "skill:deploy", metadata: { proposalId: "p3", source: "reflect" } }, {
+                filePath: eventsFile,
+                now: () => new Date("2026-01-02T09:00:00Z").getTime(),
+            });
+            const result = await akmHistory({
+                db,
+                includeProposals: true,
+                eventsCtx: { filePath: eventsFile },
+            });
+            expect(result.totalCount).toBe(3);
+            const types = result.entries.map((e) => e.eventType);
+            // Chronological: show (Jan 1), promoted (Jan 2), feedback (Jan 3)
+            expect(types).toEqual(["show", "promoted", "feedback"]);
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("--include-proposals ref filter shows only matching ref events", async () => {
+        const eventsFile = path.join(makeTempDir("akm-history-ref-filter-"), "events.jsonl");
+        const db = openDatabase(":memory:");
+        try {
+            ensureUsageEventsSchema(db);
+            // Two proposal events for different refs.
+            appendEvent({ eventType: "promoted", ref: "skill:deploy", metadata: { proposalId: "p1", source: "reflect" } }, { filePath: eventsFile });
+            appendEvent({ eventType: "rejected", ref: "memory:draft", metadata: { proposalId: "p2", source: "reflect" } }, { filePath: eventsFile });
+            const result = await akmHistory({
+                db,
+                ref: "skill:deploy",
+                includeProposals: true,
+                eventsCtx: { filePath: eventsFile },
+            });
+            // Only the promoted event for skill:deploy should appear.
+            expect(result.ref).toBe("skill:deploy");
+            expect(result.entries.every((e) => e.ref === "skill:deploy")).toBe(true);
+            const promoted = result.entries.find((e) => e.eventType === "promoted");
+            expect(promoted).toBeDefined();
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("akm history --include-proposals CLI flag surfaces proposal lifecycle events", async () => {
+        const stashDir = makeTempDir("akm-history-cli-proposals-");
+        process.env.AKM_STASH_DIR = stashDir;
+        const cacheDir = makeTempDir("akm-history-cli-cache-");
+        process.env.XDG_CACHE_HOME = cacheDir;
+        saveConfig({ semanticSearchMode: "off" });
+        writeFile(path.join(stashDir, "memories", "alpha.md"), "---\ndescription: alpha memory\n---\nAlpha.\n");
+        await akmIndex({ stashDir, full: true });
+        // We can't easily run a full accept without a real proposal, so instead
+        // write a promoted event directly to events.jsonl to verify the CLI flag.
+        const eventsFile = path.join(cacheDir, "akm", "events.jsonl");
+        fs.mkdirSync(path.dirname(eventsFile), { recursive: true });
+        const promoted = {
+            schemaVersion: 1,
+            ts: new Date().toISOString(),
+            eventType: "promoted",
+            ref: "memory:alpha",
+            metadata: { proposalId: "p-cli-test", source: "reflect", assetPath: "memories/alpha.md" },
+        };
+        fs.appendFileSync(eventsFile, `${JSON.stringify(promoted)}\n`);
+        const result = runCli(["history", "--include-proposals", "--ref", "memory:alpha", "--format=json"]);
+        expect(result.status).toBe(0);
+        const parsed = parseJsonOutput(result);
+        const entries = parsed.entries;
+        expect(Array.isArray(entries)).toBe(true);
+        // The promoted event should appear.
+        const promotedEntry = entries.find((e) => e.eventType === "promoted");
+        expect(promotedEntry).toBeDefined();
+        expect(promotedEntry?.ref).toBe("memory:alpha");
+        // Sources should include events.jsonl.
+        expect(Array.isArray(parsed.sources)).toBe(true);
+        expect(parsed.sources.includes("events.jsonl")).toBe(true);
+        // Verify text output also shows the proposal event.
+        const text = runCli(["history", "--include-proposals", "--ref", "memory:alpha", "--format=text"]);
+        expect(text.status).toBe(0);
+        expect(text.stdout).toContain("[promoted]");
+        expect(text.stdout).toContain("events.jsonl");
+    });
+});

package/dist/tests/config.test.js

@@ -267,6 +267,31 @@ describe("loadConfig", () => {
             expect(hint).toContain("akm remove");
         }
     });
+    test("throws ConfigError when config contains legacy stashes[]", () => {
+        writeRawConfig(getConfigPath(), JSON.stringify({
+            stashes: [{ type: "filesystem", path: "/legacy-stash" }],
+        }));
+        expect(() => loadConfig()).toThrow(ConfigError);
+        expect(() => loadConfig()).toThrow("legacy `stashes[]` config key");
+    });
+    test("throws ConfigError when installed npm entry is marked writable", () => {
+        writeRawConfig(getConfigPath(), JSON.stringify({
+            installed: [
+                {
+                    id: "npm:left-pad",
+                    source: "npm",
+                    ref: "npm:left-pad",
+                    artifactUrl: "https://registry.npmjs.org/left-pad/-/left-pad-1.3.0.tgz",
+                    stashRoot: "/tmp/left-pad",
+                    cacheDir: "/tmp/cache",
+                    installedAt: "2026-05-01T00:00:00.000Z",
+                    writable: true,
+                },
+            ],
+        }));
+        expect(() => loadConfig()).toThrow(ConfigError);
+        expect(() => loadConfig()).toThrow("writable: true is only supported on filesystem and git sources");
+    });
     test("recomputes merged config when cwd changes", () => {
         const firstProject = makeTmpDir();
         const secondProject = makeTmpDir();

package/dist/tests/e2e.test.js

@@ -500,8 +500,28 @@ describe("Scenario: CLI subprocess execution", () => {
         expect(json.hits.length).toBeGreaterThan(0);
         expect(json.hits.every((h) => h.type === "knowledge")).toBe(true);
     });
+    // Issue 9: empty query must list all assets rather than throwing UsageError.
+    // The CLI contract (--help text) promises omitting the query returns all
+    // indexed assets. The akmSearch function handles empty queries end-to-end
+    // via getAllEntries (DB path) and the substring-fallback's query-less branch.
+    test("cli: akm search with no query lists all assets (empty-query listing)", async () => {
+        const result = runCli("search");
+        expect(result.exitCode).toBe(0);
+        const json = parseJson(result.stdout);
+        expect(json.hits).toBeInstanceOf(Array);
+        expect(json.hits.length).toBeGreaterThan(0);
+        // Brief output: ref is NOT present (only full/agent levels include ref)
+        expect(json.hits.every((h) => h.type !== undefined)).toBe(true);
+        expect(json.hits.every((h) => h.name !== undefined)).toBe(true);
+    });
+    test("cli: akm search with no query and --type filters by type", async () => {
+        const result = runCli("search", "--type", "skill");
+        expect(result.exitCode).toBe(0);
+        const json = parseJson(result.stdout);
+        expect(json.hits).toBeInstanceOf(Array);
+        expect(json.hits.every((h) => h.type === "skill")).toBe(true);
+    });
     test("cli: akm search --limit 2 respects limit", async () => {
-        // QA #14: empty query now throws UsageError (exit 2); use a real query
         const result = runCli("search", "docker", "--limit", "2");
         expect(result.exitCode).toBe(0);
         const json = parseJson(result.stdout);
@@ -513,7 +533,8 @@ describe("Scenario: CLI subprocess execution", () => {
         const json = parseJson(result.stdout);
         expect(json.source).toBeUndefined();
         expect(json.timing).toBeUndefined();
-        expect(json.hits.every((h) => h.ref === undefined)).toBe(true);
+        // REC-03: ref is now included at brief detail so agents can run `akm show <ref>`
+        expect(json.hits.every((h) => h.ref !== undefined)).toBe(true);
         expect(json.hits.every((h) => h.type !== undefined)).toBe(true);
         expect(json.hits.every((h) => h.name !== undefined)).toBe(true);
         expect(json.hits.every((h) => h.action !== undefined)).toBe(true);

package/dist/tests/fixtures/stashes/load.js

@@ -120,7 +120,7 @@ export function loadFixtureStash(name, options = {}) {
             process.env.AKM_STASH_DIR = priorAkmStashDir;
         fs.rmSync(tmpRoot, { recursive: true, force: true });
     };
-    return { stashDir, cleanup, contentHash };
+    return { stashDir, cleanup, contentHash, ...(!options.skipIndex ? { indexCacheHome: cacheHome } : {}) };
 }
 // ── Internals ───────────────────────────────────────────────────────────────
 function fixtureSourceDir(name) {

package/dist/tests/fixtures/stashes/load.test.js

@@ -81,8 +81,17 @@ describe("fixtureContentHash", () => {
     });
 });
 describe("listFixtures", () => {
-    test("returns all six shipped fixtures, sorted", () => {
+    test("returns all shipped fixtures, sorted", () => {
         const names = listFixtures();
-        expect(names).toEqual(["az-cli", "docker-homelab", "minimal", "multi-domain", "noisy", "ranking-baseline"]);
+        expect(names).toEqual([
+            "az-cli",
+            "docker-homelab",
+            "drillbit",
+            "inkwell",
+            "minimal",
+            "multi-domain",
+            "noisy",
+            "ranking-baseline",
+        ]);
     });
 });

package/dist/tests/indexer.test.js

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, expect, mock, spyOn, test } from "bun:test";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { saveConfig } from "../src/core/config";
 import { getDbPath } from "../src/core/paths";
 import { closeDatabase, DB_VERSION, getAllEntries, getEmbeddingCount, getMeta, openDatabase } from "../src/indexer/db";
 import { akmIndex, buildFileBasenameMap, matchEntryToFile } from "../src/indexer/indexer";
@@ -13,7 +14,7 @@ let embedBatchImpl;
 const actualEmbedBatch = embedderModule.embedBatch;
 const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
 const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
-mock.module("../src/embedder.js", () => ({
+mock.module("../src/llm/embedder.js", () => ({
     ...embedderModule,
     embedBatch: (texts, embeddingConfig) => embedBatchImpl ? embedBatchImpl(texts, embeddingConfig) : actualEmbedBatch(texts, embeddingConfig),
 }));
@@ -138,6 +139,15 @@ test("akmIndex handles markdown assets", async () => {
     const result = await akmIndex({ stashDir });
     expect(result.totalEntries).toBe(2);
 });
+test("akmIndex classifies flat markdown files under skills/ as skill assets", async () => {
+    const stashDir = tmpStash();
+    writeFile(path.join(stashDir, "skills", "deploy.md"), "---\ndescription: Deploy skill\n---\n# Deploy\n");
+    await akmIndex({ stashDir, full: true });
+    const db = openDatabase();
+    const skillEntry = getAllEntries(db).find((row) => row.entry.type === "skill" && row.entry.name === "deploy");
+    expect(skillEntry).toBeDefined();
+    closeDatabase(db);
+});
 test("akmIndex includes wiki raw files but excludes infrastructure files from the primary stash index", async () => {
     const stashDir = tmpStash();
     writeFile(path.join(stashDir, "wikis", "research", "schema.md"), "---\ndescription: Schema\n---\n# Schema\n");
@@ -511,6 +521,7 @@ test("usage_events are re-linked after full reindex", async () => {
 test("incremental reindex clears embeddings when provider fingerprint changes", async () => {
     const stashDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-fp-"));
     process.env.AKM_STASH_DIR = stashDir;
+    saveConfig({ semanticSearchMode: "auto" });
     embedBatchImpl = async (texts) => texts.map((_text, index) => {
         const embedding = new Float32Array(384);
         embedding[0] = index + 1;

package/dist/tests/output-baseline.test.js

@@ -83,7 +83,8 @@ describe("output baseline", () => {
         const json = JSON.parse(output);
         // hits is always present; warnings may appear when semantic search is pending
         expect(Object.keys(json)).toContain("hits");
-        expect(Object.keys(json.hits[0] ?? {}).sort()).toEqual(["action", "estimatedTokens", "name", "type"]);
+        // REC-03: ref is now included at brief detail so agents can run `akm show <ref>`
+        expect(Object.keys(json.hits[0] ?? {}).sort()).toEqual(["action", "estimatedTokens", "name", "ref", "type"]);
     });
     test("search normal detail includes description capped at 250 characters", () => {
         const stashDir = makeTempDir("akm-output-stash-");

package/dist/tests/output-shapes-unit.test.js

@@ -69,10 +69,12 @@ describe("shapeSearchHit — local stash hits", () => {
         tags: ["ops"],
         whyMatched: "name match",
     };
-    test("brief keeps only type/name/action/estimatedTokens", () => {
+    test("brief keeps only type/name/ref/action/estimatedTokens", () => {
+        // REC-03: ref is now included at brief so agents can run `akm show <ref>`
         expect(shapeSearchHit(fullHit, "brief")).toEqual({
             type: "skill",
             name: "deploy",
+            ref: "skill:deploy",
             action: "akm show skill:deploy",
             estimatedTokens: 120,
         });

package/dist/tests/registry-build-index.test.js

@@ -3,7 +3,7 @@ import { spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { buildRegistryIndex } from "../src/registry/build-index";
+import { buildRegistryIndex, writeRegistryIndex } from "../src/registry/build-index";
 const CLI = path.join(import.meta.dir, "..", "src", "cli.ts");
 const tempDirs = [];
 const servers = [];
@@ -105,6 +105,22 @@ afterAll(() => {
     }
 });
 describe("buildRegistryIndex", () => {
+    test("writeRegistryIndex defaults under the cache registry-build directory", () => {
+        const cacheHome = makeTempDir("akm-registry-cache-");
+        const originalCacheHome = process.env.XDG_CACHE_HOME;
+        process.env.XDG_CACHE_HOME = cacheHome;
+        try {
+            const outPath = writeRegistryIndex({ version: 3, updatedAt: "2026-05-01T00:00:00.000Z", stashes: [] });
+            expect(outPath).toBe(path.join(cacheHome, "akm", "registry-build", "index.json"));
+            expect(fs.existsSync(outPath)).toBe(true);
+        }
+        finally {
+            if (originalCacheHome === undefined)
+                delete process.env.XDG_CACHE_HOME;
+            else
+                process.env.XDG_CACHE_HOME = originalCacheHome;
+        }
+    });
     test("builds a v2 index from discovery and manual entries", async () => {
         const fixtureRoot = makeTempDir("akm-registry-build-fixture-");
         const npmPackageDir = path.join(fixtureRoot, "package");

package/dist/tests/registry-providers/static-index.test.js

@@ -201,4 +201,38 @@ describe("StaticIndexProvider", () => {
             expect(hit?.installRef).toBe("github:vercel-labs/agent-skills");
         });
     });
+    describe("registry version contract", () => {
+        test("version 3 index parses without warnings (canonical format)", async () => {
+            const srv = serveJson(FIXTURE_INDEX); // FIXTURE_INDEX has version: 3
+            const provider = makeProvider(srv.url);
+            const result = await provider.search({ query: "agent", limit: 10 });
+            expect(result.warnings ?? []).toHaveLength(0);
+            expect(result.hits.length).toBeGreaterThan(0);
+        });
+        test("version 2 index parses without warnings (live official registry format)", async () => {
+            const v2Index = { ...FIXTURE_INDEX, version: 2 };
+            const srv = serveJson(v2Index);
+            const provider = makeProvider(srv.url);
+            const result = await provider.search({ query: "agent", limit: 10 });
+            expect(result.warnings ?? []).toHaveLength(0);
+            expect(result.hits.length).toBeGreaterThan(0);
+        });
+        test("version 2 index returns correct kit hits", async () => {
+            const v2Index = { ...FIXTURE_INDEX, version: 2 };
+            const srv = serveJson(v2Index);
+            const provider = makeProvider(srv.url);
+            const kits = await provider.searchKits({ text: "agent", limit: 10 });
+            expect(kits.length).toBeGreaterThan(0);
+            expect(kits.some((k) => k.id === "github:vercel-labs/agent-skills")).toBe(true);
+        });
+        test("version 1 index returns null (unsupported)", async () => {
+            // version 1 is explicitly unsupported per schema comment
+            const v1Index = { ...FIXTURE_INDEX, version: 1 };
+            const srv = serveJson(v1Index);
+            const provider = makeProvider(srv.url);
+            const result = await provider.search({ query: "agent", limit: 10 });
+            // No hits because the parser returns null for unsupported versions
+            expect(result.hits).toHaveLength(0);
+        });
+    });
 });