akm-cli 0.7.0 → 0.7.2

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

@@ -1,186 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-const CLI = path.join(__dirname, "..", "src", "cli.ts");
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-function writeFile(filePath, content) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content);
-}
-function writeConfig(configDir, config) {
-    const configPath = path.join(configDir, "akm", "config.json");
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
-}
-function runCli(stashDir, args, config) {
-    const xdgCache = makeTempDir("akm-agent-cache-");
-    const xdgConfig = makeTempDir("akm-agent-config-");
-    if (config)
-        writeConfig(xdgConfig, config);
-    const result = spawnSync("bun", [CLI, ...args], {
-        encoding: "utf8",
-        timeout: 30_000,
-        env: {
-            ...process.env,
-            AKM_STASH_DIR: stashDir,
-            XDG_CACHE_HOME: xdgCache,
-            XDG_CONFIG_HOME: xdgConfig,
-        },
-    });
-    if (result.status !== 0) {
-        throw new Error(`CLI exited ${result.status}:\n${result.stderr}`);
-    }
-    return result.stdout.trim();
-}
-afterEach(() => {
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-describe("--for-agent output mode", () => {
-    function makeStash() {
-        const stashDir = makeTempDir("akm-agent-stash-");
-        writeFile(path.join(stashDir, "agents", "architect.md"), "---\ndescription: System architecture agent\ntags: [arch, design]\n---\nYou are an architect.\n");
-        writeFile(path.join(stashDir, "scripts", "deploy.sh"), "#!/usr/bin/env bash\necho deploy\n");
-        writeFile(path.join(stashDir, "commands", "release.md"), "---\ndescription: Release process\n---\nRun release {{version}}\n");
-        return stashDir;
-    }
-    test("--for-agent search output has only: name, ref, type, description, action, score", () => {
-        const stashDir = makeStash();
-        const output = runCli(stashDir, ["search", "architect", "--format=json", "--for-agent"]);
-        const json = JSON.parse(output);
-        expect(json.hits.length).toBeGreaterThan(0);
-        const hit = json.hits[0];
-        const keys = Object.keys(hit);
-        // Must have these agent-essential fields (when present)
-        expect(keys).toContain("name");
-        expect(keys).toContain("type");
-        expect(keys).toContain("action");
-        // Only allowed keys (estimatedTokens is optional — present when fileSize is known)
-        const allowedKeys = new Set(["name", "ref", "type", "description", "action", "score", "estimatedTokens"]);
-        for (const key of keys) {
-            expect(allowedKeys.has(key)).toBe(true);
-        }
-    });
-    test("--for-agent search output does NOT have: schemaVersion, stashDir, path, whyMatched, origin, editable", () => {
-        const stashDir = makeStash();
-        const output = runCli(stashDir, ["search", "architect", "--format=json", "--for-agent"]);
-        const json = JSON.parse(output);
-        // Top-level envelope must not have these
-        expect(json).not.toHaveProperty("schemaVersion");
-        expect(json).not.toHaveProperty("stashDir");
-        expect(json).not.toHaveProperty("timing");
-        // Hits must not have these
-        const hits = json.hits;
-        for (const hit of hits) {
-            expect(hit).not.toHaveProperty("path");
-            expect(hit).not.toHaveProperty("whyMatched");
-            expect(hit).not.toHaveProperty("origin");
-            expect(hit).not.toHaveProperty("editable");
-            expect(hit).not.toHaveProperty("editHint");
-            expect(hit).not.toHaveProperty("tags");
-            expect(hit).not.toHaveProperty("size");
-        }
-    });
-    test("--for-agent show output strips non-essential fields", () => {
-        const stashDir = makeStash();
-        const output = runCli(stashDir, ["show", "command:release.md", "--format=json", "--for-agent"]);
-        const json = JSON.parse(output);
-        // Must have essential fields
-        expect(json).toHaveProperty("name");
-        expect(json).toHaveProperty("type");
-        // Must NOT have non-essential fields
-        expect(json).not.toHaveProperty("schemaVersion");
-        expect(json).not.toHaveProperty("path");
-        expect(json).not.toHaveProperty("origin");
-        expect(json).not.toHaveProperty("editable");
-        expect(json).not.toHaveProperty("editHint");
-    });
-    test("--for-agent show output keeps content/run/action", () => {
-        const stashDir = makeStash();
-        // Command has template content
-        const cmdOutput = runCli(stashDir, ["show", "command:release.md", "--format=json", "--for-agent"]);
-        const cmdJson = JSON.parse(cmdOutput);
-        expect(cmdJson).toHaveProperty("template");
-        expect(cmdJson).toHaveProperty("action");
-        // Script has run field
-        const scriptOutput = runCli(stashDir, ["show", "script:deploy.sh", "--format=json", "--for-agent"]);
-        const scriptJson = JSON.parse(scriptOutput);
-        expect(scriptJson).toHaveProperty("run");
-        expect(scriptJson).toHaveProperty("action");
-    });
-    test("standard output (without --for-agent) is unchanged", () => {
-        const stashDir = makeStash();
-        // Default brief search still has same shape
-        const searchOutput = runCli(stashDir, ["search", "architect", "--format=json"]);
-        const searchJson = JSON.parse(searchOutput);
-        // hits is always present; warnings may appear when semantic search is pending
-        expect(Object.keys(searchJson)).toContain("hits");
-        // Standard brief output includes at least name, type, action (may also include estimatedTokens etc.)
-        const hit = searchJson.hits[0] ?? {};
-        expect(hit).toHaveProperty("name");
-        expect(hit).toHaveProperty("type");
-        expect(hit).toHaveProperty("action");
-        // Default show still has origin
-        const showOutput = runCli(stashDir, ["show", "command:release.md", "--format=json"]);
-        const showJson = JSON.parse(showOutput);
-        expect(showJson).toHaveProperty("origin");
-    });
-});
-describe("--format jsonl", () => {
-    function makeStash() {
-        const stashDir = makeTempDir("akm-jsonl-stash-");
-        writeFile(path.join(stashDir, "agents", "architect.md"), "---\ndescription: System architecture agent\n---\nYou are an architect.\n");
-        writeFile(path.join(stashDir, "scripts", "deploy.sh"), "#!/usr/bin/env bash\necho deploy\n");
-        return stashDir;
-    }
-    test("JSONL format outputs one JSON object per line for search hits", () => {
-        const stashDir = makeStash();
-        // QA #14: empty query now rejects; use a real keyword that matches stash assets.
-        // Use "architect" since architect.md has that word in both name and content.
-        const output = runCli(stashDir, ["search", "architect", "--format=jsonl"]);
-        const lines = output.split("\n").filter((line) => line.trim().length > 0);
-        // Should have at least 1 hit
-        expect(lines.length).toBeGreaterThanOrEqual(1);
-        // Each line must be its own object, not wrapped in an envelope
-        for (const line of lines) {
-            const parsed = JSON.parse(line);
-            expect(typeof parsed).toBe("object");
-            expect(parsed).toHaveProperty("name");
-        }
-    });
-    test("each JSONL line is valid parseable JSON", () => {
-        const stashDir = makeStash();
-        const output = runCli(stashDir, ["search", "deploy", "--format=jsonl"]);
-        const lines = output.split("\n").filter((line) => line.trim().length > 0);
-        for (const line of lines) {
-            expect(() => JSON.parse(line)).not.toThrow();
-            const parsed = JSON.parse(line);
-            expect(typeof parsed).toBe("object");
-            expect(Array.isArray(parsed)).toBe(false);
-        }
-    });
-    test("JSONL combined with --for-agent uses agent shaping", () => {
-        const stashDir = makeStash();
-        const output = runCli(stashDir, ["search", "deploy", "--format=jsonl", "--for-agent"]);
-        const lines = output.split("\n").filter((line) => line.trim().length > 0);
-        for (const line of lines) {
-            const parsed = JSON.parse(line);
-            const allowedKeys = new Set(["name", "ref", "type", "description", "action", "score", "estimatedTokens"]);
-            for (const key of Object.keys(parsed)) {
-                expect(allowedKeys.has(key)).toBe(true);
-            }
-            // Must not have stripped fields
-            expect(parsed).not.toHaveProperty("path");
-            expect(parsed).not.toHaveProperty("origin");
-            expect(parsed).not.toHaveProperty("whyMatched");
-        }
-    });
-});

package/dist/tests/architecture/agent-no-llm-sdk-guard.test.js

@@ -1,103 +0,0 @@
-/**
- * Regression guard — `src/integrations/agent/**` does not import LLM SDKs.
- *
- * Locks v1 spec §9.7 (LLM/agent boundary) and §12 (CLI shell-out only).
- * Issue #222.
- *
- * **This test is defence-in-depth, not the primary enforcement.**
- *
- * The primary enforcement of the agent shell-out invariant is:
- *   1. The seam test in `agent-spawn-seam.test.ts`, which locks the
- *      `runAgent` interface.
- *   2. The TypeScript module graph — vendor SDKs are not in
- *      `package.json`, so an accidental import would fail to resolve at
- *      build time.
- *   3. Code review and the architectural boundary documented in
- *      `docs/technical/architecture.md`.
- *
- * The guard below scans file contents under `src/integrations/agent/`
- * for known LLM SDK package names. It exists to surface accidental
- * regressions in PRs (e.g. someone copies an example that pulls in a
- * vendor SDK before the type-check would catch it). The list is
- * intentionally narrow — it names specific vendor packages, not broad
- * patterns — so it does not flag legitimate code.
- *
- * Adding a new SDK package to the list (when a new vendor ships) is a
- * one-line change. Removing the test entirely is a contract violation:
- * agents are reachable only via the spawn wrapper.
- */
-import { describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import path from "node:path";
-const REPO_ROOT = path.resolve(import.meta.dir, "..", "..");
-const AGENT_DIR = path.join(REPO_ROOT, "src", "integrations", "agent");
-/**
- * Specific vendor SDK package names whose presence in the agent
- * integration tree would indicate the shell-out invariant has been
- * crossed. The names are matched as quoted-import strings, not as
- * arbitrary substrings, so unrelated mentions in comments do not
- * trip the guard.
- */
-const FORBIDDEN_LLM_SDK_PACKAGES = [
-    "@anthropic-ai/sdk",
-    "@anthropic-ai/bedrock-sdk",
-    "@anthropic-ai/vertex-sdk",
-    "openai",
-    "@google/generative-ai",
-    "@google/genai",
-    "@google-ai/generativelanguage",
-    "cohere-ai",
-    "@mistralai/mistralai",
-    "@huggingface/inference",
-    "groq-sdk",
-    "ollama",
-    "langchain",
-    "@langchain/core",
-    "@langchain/openai",
-    "@langchain/anthropic",
-    "ai",
-    "replicate",
-];
-function listAgentSourceFiles() {
-    const out = [];
-    function walk(dir) {
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const abs = path.join(dir, entry.name);
-            if (entry.isDirectory())
-                walk(abs);
-            else if (entry.isFile() && entry.name.endsWith(".ts"))
-                out.push(abs);
-        }
-    }
-    walk(AGENT_DIR);
-    return out.sort();
-}
-/**
- * Match `from "<pkg>"` and `from '<pkg>'` and the equivalent
- * `import("<pkg>")` / `require("<pkg>")` forms. This is deliberately
- * a quoted-import match, not a free-text substring match, so writing
- * about a vendor SDK in a comment ("never imports `openai`") does not
- * trip the guard.
- */
-function buildImportRegex(pkg) {
-    const escaped = pkg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return new RegExp(`${String.raw `(?:from|import\(|require\()\s*['"]` + escaped}(?:/[^'"]*)?['"]`);
-}
-describe("regression guard: src/integrations/agent/** never imports LLM SDKs", () => {
-    test("the agent integration tree exists", () => {
-        expect(fs.existsSync(AGENT_DIR)).toBe(true);
-        const files = listAgentSourceFiles();
-        expect(files.length).toBeGreaterThan(0);
-    });
-    test.each([...FORBIDDEN_LLM_SDK_PACKAGES])("no file imports %s", (pkg) => {
-        const re = buildImportRegex(pkg);
-        const offenders = [];
-        for (const file of listAgentSourceFiles()) {
-            const text = fs.readFileSync(file, "utf8");
-            if (re.test(text)) {
-                offenders.push(path.relative(REPO_ROOT, file));
-            }
-        }
-        expect(offenders).toEqual([]);
-    });
-});

package/dist/tests/architecture/agent-spawn-seam.test.js

@@ -1,193 +0,0 @@
-/**
- * Architecture seam test — `runAgent` is the single agent CLI entry point.
- *
- * Locks v1 spec §9.7 (LLM/agent boundary) and §12 (agent CLI integration).
- * Issue #222.
- *
- * The test exercises the documented `runAgent` interface without
- * spawning a real binary. Every agent-CLI integration in akm passes
- * through this seam; if the shape changes, callers break.
- *
- * Specifically locked:
- *   • `runAgent` is exported from `src/integrations/agent/spawn.ts`
- *     and re-exported from `src/integrations/agent/index.ts`.
- *   • `AgentRunResult` carries the documented envelope.
- *   • `AgentFailureReason` is the discriminated union
- *     `"timeout" | "spawn_failed" | "non_zero_exit" | "parse_error"`.
- *   • Captured stdio captures stdout/stderr; interactive stdio inherits
- *     the parent's streams (no captured strings).
- *   • A per-call `timeoutMs` override forces a `timeout` reason.
- */
-import { describe, expect, test } from "bun:test";
-import * as agentBarrel from "../../src/integrations/agent";
-import { runAgent } from "../../src/integrations/agent/spawn";
-const KNOWN_FAILURE_REASONS = new Set([
-    "timeout",
-    "spawn_failed",
-    "non_zero_exit",
-    "parse_error",
-]);
-function makeProfile(overrides = {}) {
-    return {
-        name: "seam-test-agent",
-        bin: "seam-test-agent",
-        args: [],
-        stdio: "captured",
-        envPassthrough: ["PATH"],
-        parseOutput: "text",
-        ...overrides,
-    };
-}
-function asReadableStream(text) {
-    const bytes = new TextEncoder().encode(text);
-    return new ReadableStream({
-        start(controller) {
-            controller.enqueue(bytes);
-            controller.close();
-        },
-    });
-}
-function fakeSpawn(stdout, stderr, exitCode) {
-    let calls = 0;
-    const spawn = () => {
-        calls++;
-        const proc = {
-            exitCode,
-            exited: Promise.resolve(exitCode),
-            stdout: asReadableStream(stdout),
-            stderr: asReadableStream(stderr),
-            stdin: null,
-            kill: () => undefined,
-        };
-        return proc;
-    };
-    return {
-        spawn,
-        get calls() {
-            return calls;
-        },
-    };
-}
-describe("`runAgent` seam (v1 spec §9.7, §12.2)", () => {
-    test("`runAgent` is exported from both the spawn module and the agent barrel", () => {
-        expect(typeof runAgent).toBe("function");
-        expect(agentBarrel.runAgent).toBe(runAgent);
-    });
-    test("captured-stdio success returns `ok: true` with stdout/stderr strings", async () => {
-        const fake = fakeSpawn("agent-output", "agent-stderr", 0);
-        const result = await runAgent(makeProfile(), "hello", { spawn: fake.spawn });
-        expect(result.ok).toBe(true);
-        expect(result.exitCode).toBe(0);
-        expect(result.stdout).toBe("agent-output");
-        expect(result.stderr).toBe("agent-stderr");
-        expect(result.reason).toBeUndefined();
-        expect(result.error).toBeUndefined();
-        expect(typeof result.durationMs).toBe("number");
-        expect(fake.calls).toBe(1);
-    });
-    test("interactive-stdio mode does not capture stdout/stderr into the result", async () => {
-        // Build a spawn that records the stdio options it was given. The
-        // contract: when stdio is "interactive", stdout/stderr default to
-        // "inherit", which the wrapper must not try to read from.
-        let observed;
-        const spawn = (_cmd, options) => {
-            observed = {
-                stdin: options.stdin,
-                stdout: options.stdout,
-                stderr: options.stderr,
-            };
-            return {
-                exitCode: 0,
-                exited: Promise.resolve(0),
-                stdout: null,
-                stderr: null,
-                stdin: null,
-                kill: () => undefined,
-            };
-        };
-        const result = await runAgent(makeProfile({ stdio: "interactive" }), "hi", { spawn });
-        expect(observed?.stdout).toBe("inherit");
-        expect(observed?.stderr).toBe("inherit");
-        expect(observed?.stdin).toBe("inherit");
-        expect(result.ok).toBe(true);
-        expect(result.stdout).toBe("");
-        expect(result.stderr).toBe("");
-    });
-    test("failure-reason discriminated union covers exactly the documented vocabulary", async () => {
-        // Synchronous spawn failure → `spawn_failed`.
-        const spawnFailedSpawn = () => {
-            throw new Error("boom");
-        };
-        const spawnFailed = await runAgent(makeProfile(), undefined, { spawn: spawnFailedSpawn });
-        expect(spawnFailed.ok).toBe(false);
-        expect(spawnFailed.reason).toBe("spawn_failed");
-        expect(KNOWN_FAILURE_REASONS.has(spawnFailed.reason)).toBe(true);
-        // Non-zero exit → `non_zero_exit`.
-        const nonZero = fakeSpawn("", "oops", 7);
-        const nonZeroResult = await runAgent(makeProfile(), undefined, { spawn: nonZero.spawn });
-        expect(nonZeroResult.ok).toBe(false);
-        expect(nonZeroResult.reason).toBe("non_zero_exit");
-        expect(nonZeroResult.exitCode).toBe(7);
-        // Malformed JSON when parseOutput is "json" → `parse_error`.
-        const badJson = fakeSpawn("not json", "", 0);
-        const parseResult = await runAgent(makeProfile({ parseOutput: "json" }), undefined, { spawn: badJson.spawn });
-        expect(parseResult.ok).toBe(false);
-        expect(parseResult.reason).toBe("parse_error");
-    });
-    test("timeout override produces `reason: 'timeout'` deterministically", async () => {
-        // A spawn that hangs until kill() is called. We drive the timer
-        // synchronously so the timeout fires immediately.
-        const hangingSpawn = () => {
-            const spawn = () => {
-                let resolve;
-                const exited = new Promise((r) => {
-                    resolve = r;
-                });
-                const proc = {
-                    exitCode: null,
-                    exited,
-                    stdout: asReadableStream(""),
-                    stderr: asReadableStream(""),
-                    stdin: null,
-                    kill: () => resolve?.(143),
-                };
-                return proc;
-            };
-            return { spawn };
-        };
-        const fakeTimers = [];
-        let nextId = 1;
-        const setTimeoutFn = ((cb) => {
-            const id = nextId++;
-            fakeTimers.push({ id, cb });
-            return id;
-        });
-        const clearTimeoutFn = ((id) => {
-            const idx = fakeTimers.findIndex((t) => t.id === id);
-            if (idx >= 0)
-                fakeTimers.splice(idx, 1);
-        });
-        const { spawn } = hangingSpawn();
-        const promise = runAgent(makeProfile(), undefined, {
-            spawn,
-            timeoutMs: 10,
-            setTimeoutFn,
-            clearTimeoutFn,
-        });
-        // Drive the timer synchronously.
-        expect(fakeTimers.length).toBe(1);
-        fakeTimers[0]?.cb();
-        const result = await promise;
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe("timeout");
-        expect(typeof result.error).toBe("string");
-    });
-    test("`AgentFailureReason` union from the barrel matches the documented vocabulary", () => {
-        // Compile-time + runtime: assigning each known reason string to the
-        // exported type pins the union shape. If the union narrows or
-        // widens, this block fails to compile (the runtime arm just
-        // mirrors the same set so the test reads end-to-end).
-        const reasons = ["timeout", "spawn_failed", "non_zero_exit", "parse_error"];
-        expect(new Set(reasons)).toEqual(KNOWN_FAILURE_REASONS);
-    });
-});

package/dist/tests/architecture/llm-stateless-seam.test.js

@@ -1,112 +0,0 @@
-/**
- * Architecture seam test — `src/llm/*` is bounded and stateless.
- *
- * Locks v1 spec §9.7 (LLM/agent boundary) and §14.4 (statelessness
- * invariant). Issue #222.
- *
- * The test inspects the **module shape** of each public LLM helper,
- * not the source text. The contract under test is:
- *
- *   1. Each module's runtime exports are functions (or values that
- *      describe pure data, e.g. a model-name constant). They are not
- *      instances of stateful clients.
- *   2. The only module-level singleton across `src/llm/*` is the local
- *      embedder pipeline in `src/llm/embedder.ts`, which is documented
- *      as a stateless model handle and exposes `resetLocalEmbedder()`
- *      so tests can construct a fresh pipeline.
- *   3. The transport-level helpers (`chatCompletion`, `enhanceMetadata`,
- *      `splitMemoryIntoAtomicFacts`, `resolveIndexPassLLM`) take the
- *      connection config as a parameter — they do not read it from
- *      module state.
- *
- * Together these properties keep every in-tree LLM call to a single
- * bounded request/response cycle. Crossing this seam (introducing a
- * conversation cache, a streaming session, or a hidden module-level
- * config) is a contract violation and should fail this test.
- */
-import { describe, expect, test } from "bun:test";
-import * as client from "../../src/llm/client";
-import * as embedder from "../../src/llm/embedder";
-import * as indexPasses from "../../src/llm/index-passes";
-import * as memoryInfer from "../../src/llm/memory-infer";
-import * as metadataEnhance from "../../src/llm/metadata-enhance";
-describe("src/llm/* is bounded and stateless (v1 spec §9.7, §14.4)", () => {
-    test("`client` exports are pure functions", () => {
-        expect(typeof client.chatCompletion).toBe("function");
-        expect(typeof client.stripJsonFences).toBe("function");
-        expect(typeof client.parseJsonResponse).toBe("function");
-        expect(typeof client.isLlmAvailable).toBe("function");
-        expect(typeof client.probeLlmCapabilities).toBe("function");
-    });
-    test("`client.chatCompletion` accepts the connection config as its first arg", () => {
-        // Length-on-function reflects declared (non-rest) parameter count.
-        // The contract is: the connection config is a parameter, not module
-        // state. Two declared params: (config, messages); options is
-        // optional and trailing.
-        expect(client.chatCompletion.length).toBeGreaterThanOrEqual(2);
-    });
-    test("`client` does not export any non-function runtime value (no module-level client instance)", () => {
-        for (const [name, value] of Object.entries(client)) {
-            if (value === undefined)
-                continue;
-            expect(typeof value).toBe("function");
-            // Eslint-style sanity: anything callable that exposes mutable
-            // state at module scope would surface here as a non-function
-            // export (an instance, a Map, etc).
-            void name;
-        }
-    });
-    test("`metadata-enhance` exports a single pure helper", () => {
-        expect(typeof metadataEnhance.enhanceMetadata).toBe("function");
-        expect(metadataEnhance.enhanceMetadata.length).toBeGreaterThanOrEqual(2);
-        const runtimeExports = Object.entries(metadataEnhance).filter(([, v]) => v !== undefined);
-        expect(runtimeExports.length).toBe(1);
-    });
-    test("`memory-infer` exports a single pure helper", () => {
-        expect(typeof memoryInfer.splitMemoryIntoAtomicFacts).toBe("function");
-        expect(memoryInfer.splitMemoryIntoAtomicFacts.length).toBeGreaterThanOrEqual(2);
-        const runtimeExports = Object.entries(memoryInfer).filter(([, v]) => v !== undefined);
-        expect(runtimeExports.length).toBe(1);
-    });
-    test("`index-passes` exports a single pure resolver", () => {
-        expect(typeof indexPasses.resolveIndexPassLLM).toBe("function");
-        expect(indexPasses.resolveIndexPassLLM.length).toBeGreaterThanOrEqual(2);
-        const runtimeExports = Object.entries(indexPasses).filter(([, v]) => v !== undefined);
-        expect(runtimeExports.length).toBe(1);
-    });
-    test("`embedder` only exports functions and pure data constants", () => {
-        // The embedder facade has more surface than the chat helpers because
-        // it owns the local-pipeline cache. Every export must still be a
-        // function or a pure data value (e.g. the default model name).
-        const allowedNonFunctionNames = new Set(["DEFAULT_LOCAL_MODEL"]);
-        for (const [name, value] of Object.entries(embedder)) {
-            if (value === undefined)
-                continue;
-            if (allowedNonFunctionNames.has(name)) {
-                // Pure-data constant. Must be a primitive (string/number/boolean).
-                expect(["string", "number", "boolean"]).toContain(typeof value);
-                continue;
-            }
-            expect(typeof value).toBe("function");
-        }
-    });
-    test("`embedder.resetLocalEmbedder` exists so tests can rebuild the cached pipeline", () => {
-        // The local embedder is a documented module-level singleton — it is
-        // a stateless model handle, not a session. The reset hook is part
-        // of the seam: it lets tests assert pipeline-construction logic
-        // without relying on module-load order.
-        expect(typeof embedder.resetLocalEmbedder).toBe("function");
-        // resetLocalEmbedder is a no-arg function.
-        expect(embedder.resetLocalEmbedder.length).toBe(0);
-    });
-    test("`stripJsonFences` and `parseJsonResponse` are referentially transparent", () => {
-        // Two calls with the same input produce the same output. These are
-        // pure, so this is not a deep test of statelessness — but it does
-        // pin the seam: response parsing is not allowed to learn from
-        // prior responses.
-        const fenced = '```json\n{"a":1}\n```';
-        expect(client.stripJsonFences(fenced)).toBe(client.stripJsonFences(fenced));
-        expect(client.parseJsonResponse(fenced)).toEqual({ a: 1 });
-        expect(client.parseJsonResponse(fenced)).toEqual({ a: 1 });
-    });
-});