akm-cli 0.7.0 → 0.7.1

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 });
-    });
-});

package/dist/tests/asset-ref.test.js

@@ -1,192 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { makeAssetRef, parseAssetRef } from "../src/core/asset-ref";
-// ── makeAssetRef ────────────────────────────────────────────────────────────
-describe("makeAssetRef", () => {
-    test("script ref", () => {
-        expect(makeAssetRef("script", "deploy.sh")).toBe("script:deploy.sh");
-    });
-    test("skill ref", () => {
-        expect(makeAssetRef("skill", "code-review")).toBe("skill:code-review");
-    });
-    test("nested path — slashes stay literal", () => {
-        expect(makeAssetRef("script", "azure/container-apps/scale.sh")).toBe("script:azure/container-apps/scale.sh");
-    });
-    test("name with spaces — no encoding", () => {
-        expect(makeAssetRef("script", "my script.sh")).toBe("script:my script.sh");
-    });
-    test("with local origin", () => {
-        expect(makeAssetRef("script", "deploy.sh", "local")).toBe("local//script:deploy.sh");
-    });
-    test("with npm origin — colons and @ stay literal", () => {
-        expect(makeAssetRef("script", "deploy.sh", "npm:@itlackey/openkit")).toBe("npm:@itlackey/openkit//script:deploy.sh");
-    });
-    test("with github shorthand origin", () => {
-        expect(makeAssetRef("skill", "code-review", "itlackey/dimm-city-stash")).toBe("itlackey/dimm-city-stash//skill:code-review");
-    });
-    test("with github prefixed origin", () => {
-        expect(makeAssetRef("script", "lint.sh", "github:owner/repo#v1.2")).toBe("github:owner/repo#v1.2//script:lint.sh");
-    });
-    test("nested name with origin", () => {
-        expect(makeAssetRef("script", "db/migrate/run.sh", "npm:@corp/db-tools")).toBe("npm:@corp/db-tools//script:db/migrate/run.sh");
-    });
-    test("normalizes backslashes", () => {
-        expect(makeAssetRef("script", "dir\\file.sh")).toBe("script:dir/file.sh");
-    });
-    test("no origin produces plain ref", () => {
-        expect(makeAssetRef("agent", "architect.md")).toBe("agent:architect.md");
-        expect(makeAssetRef("agent", "architect.md", undefined)).toBe("agent:architect.md");
-    });
-    test("rejects empty name", () => {
-        expect(() => makeAssetRef("script", "")).toThrow("Empty asset name");
-    });
-    test("rejects null byte", () => {
-        expect(() => makeAssetRef("script", "foo\0bar")).toThrow("Null byte");
-    });
-    test("rejects absolute path", () => {
-        expect(() => makeAssetRef("script", "/etc/passwd")).toThrow("Absolute path");
-    });
-    test("rejects path traversal", () => {
-        expect(() => makeAssetRef("script", "../outside.sh")).toThrow("Path traversal");
-    });
-    test("rejects Windows drive path", () => {
-        expect(() => makeAssetRef("script", "C:\\foo")).toThrow("Windows drive");
-    });
-});
-// ── parseAssetRef ───────────────────────────────────────────────────────────
-describe("parseAssetRef", () => {
-    test("simple script ref", () => {
-        const ref = parseAssetRef("script:deploy.sh");
-        expect(ref.type).toBe("script");
-        expect(ref.name).toBe("deploy.sh");
-        expect(ref.origin).toBeUndefined();
-    });
-    test("nested path stays literal", () => {
-        const ref = parseAssetRef("script:azure/container-apps/scale.sh");
-        expect(ref.name).toBe("azure/container-apps/scale.sh");
-    });
-    test("name with spaces", () => {
-        const ref = parseAssetRef("script:my script.sh");
-        expect(ref.name).toBe("my script.sh");
-    });
-    test("local origin", () => {
-        const ref = parseAssetRef("local//script:deploy.sh");
-        expect(ref.origin).toBe("local");
-        expect(ref.type).toBe("script");
-        expect(ref.name).toBe("deploy.sh");
-    });
-    test("npm origin with scope", () => {
-        const ref = parseAssetRef("npm:@itlackey/openkit//script:deploy.sh");
-        expect(ref.origin).toBe("npm:@itlackey/openkit");
-        expect(ref.type).toBe("script");
-        expect(ref.name).toBe("deploy.sh");
-    });
-    test("github shorthand origin", () => {
-        const ref = parseAssetRef("itlackey/dimm-city-stash//skill:code-review");
-        expect(ref.origin).toBe("itlackey/dimm-city-stash");
-        expect(ref.type).toBe("skill");
-        expect(ref.name).toBe("code-review");
-    });
-    test("github origin with tag", () => {
-        const ref = parseAssetRef("github:owner/repo#v1.2//script:lint.sh");
-        expect(ref.origin).toBe("github:owner/repo#v1.2");
-        expect(ref.type).toBe("script");
-        expect(ref.name).toBe("lint.sh");
-    });
-    test("nested name with origin", () => {
-        const ref = parseAssetRef("npm:@corp/db-tools//script:db/migrate/run.sh");
-        expect(ref.origin).toBe("npm:@corp/db-tools");
-        expect(ref.name).toBe("db/migrate/run.sh");
-    });
-    test("path-based origin", () => {
-        const ref = parseAssetRef("/mnt/shared-stash//skill:code-review");
-        expect(ref.origin).toBe("/mnt/shared-stash");
-        expect(ref.type).toBe("skill");
-        expect(ref.name).toBe("code-review");
-    });
-    test("all asset types parse", () => {
-        for (const type of ["skill", "command", "agent", "knowledge", "script"]) {
-            const ref = parseAssetRef(`${type}:test`);
-            expect(ref.type).toBe(type);
-        }
-    });
-    test("normalizes backslashes in name", () => {
-        const ref = parseAssetRef("script:dir\\file.sh");
-        expect(ref.name).toBe("dir/file.sh");
-    });
-    test("throws for invalid type", () => {
-        expect(() => parseAssetRef("widget:foo")).toThrow("Invalid asset type");
-    });
-    test("throws for removed tool type", () => {
-        expect(() => parseAssetRef("tool:deploy.sh")).toThrow("Invalid asset type");
-    });
-    test("throws for missing colon", () => {
-        expect(() => parseAssetRef("scriptname")).toThrow("Invalid ref");
-    });
-    test("throws for empty origin", () => {
-        expect(() => parseAssetRef("//script:deploy.sh")).toThrow("Empty origin");
-    });
-    test("throws for empty name", () => {
-        expect(() => parseAssetRef("script:")).toThrow("Empty asset name");
-    });
-    test("throws for path traversal in name", () => {
-        expect(() => parseAssetRef("script:../outside.sh")).toThrow("Path traversal");
-    });
-    test("throws for absolute name", () => {
-        expect(() => parseAssetRef("script:/etc/passwd")).toThrow("Absolute path");
-    });
-    test("throws for null byte in name", () => {
-        expect(() => parseAssetRef("script:foo\0bar")).toThrow("Null byte");
-    });
-    test("throws for Windows drive in name", () => {
-        expect(() => parseAssetRef("script:C:\\foo")).toThrow("Windows drive");
-    });
-    test("throws for empty string", () => {
-        expect(() => parseAssetRef("")).toThrow("Empty ref");
-    });
-    test("throws for whitespace-only string", () => {
-        expect(() => parseAssetRef("   ")).toThrow("Empty ref");
-    });
-});
-// ── Round-trips ─────────────────────────────────────────────────────────────
-describe("round-trip", () => {
-    test("script round-trips", () => {
-        const str = makeAssetRef("script", "deploy.sh");
-        expect(str).toBe("script:deploy.sh");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "script", name: "deploy.sh", origin: undefined });
-    });
-    test("with npm origin", () => {
-        const str = makeAssetRef("script", "deploy.sh", "npm:@scope/pkg");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "script", name: "deploy.sh", origin: "npm:@scope/pkg" });
-    });
-    test("nested path with origin", () => {
-        const str = makeAssetRef("script", "db/migrate/run.sh", "npm:@corp/tools");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "script", name: "db/migrate/run.sh", origin: "npm:@corp/tools" });
-    });
-    test("local origin", () => {
-        const str = makeAssetRef("skill", "review", "local");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "skill", name: "review", origin: "local" });
-    });
-    test("github origin with tag", () => {
-        const str = makeAssetRef("script", "lint.sh", "github:owner/repo#v2.0");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "script", name: "lint.sh", origin: "github:owner/repo#v2.0" });
-    });
-    test("name with spaces", () => {
-        const str = makeAssetRef("command", "my command.md");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "command", name: "my command.md", origin: undefined });
-    });
-    test("every asset type round-trips", () => {
-        for (const type of ["skill", "command", "agent", "knowledge", "script"]) {
-            const str = makeAssetRef(type, "test-asset", "owner/repo");
-            const parsed = parseAssetRef(str);
-            expect(parsed.type).toBe(type);
-            expect(parsed.name).toBe("test-asset");
-            expect(parsed.origin).toBe("owner/repo");
-        }
-    });
-});

package/dist/tests/asset-registry.test.js

@@ -1,103 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import path from "node:path";
-import { ACTION_BUILDERS, TYPE_TO_RENDERER } from "../src/core/asset-registry";
-import { deregisterAssetType, registerAssetType } from "../src/core/asset-spec";
-// ── Test helpers ────────────────────────────────────────────────────────────
-const TEST_TYPE = "registry-test-widget";
-function makeWidgetSpec(overrides = {}) {
-    return {
-        stashDir: "widgets",
-        isRelevantFile: (f) => f.endsWith(".widget"),
-        toCanonicalName: (_root, fp) => path.basename(fp, ".widget"),
-        toAssetPath: (root, name) => path.join(root, `${name}.widget`),
-        ...overrides,
-    };
-}
-// ── Tests ───────────────────────────────────────────────────────────────────
-describe("asset-registry singleton", () => {
-    afterEach(() => {
-        // Clean up the test type to avoid polluting other tests
-        deregisterAssetType(TEST_TYPE);
-        delete TYPE_TO_RENDERER[TEST_TYPE];
-        delete ACTION_BUILDERS[TEST_TYPE];
-    });
-    test("registerAssetType populates TYPE_TO_RENDERER when rendererName is set", () => {
-        registerAssetType(TEST_TYPE, makeWidgetSpec({ rendererName: "widget-md" }));
-        expect(TYPE_TO_RENDERER[TEST_TYPE]).toBe("widget-md");
-    });
-    test("registerAssetType populates ACTION_BUILDERS when actionBuilder is set", () => {
-        const builder = (ref) => `akm show ${ref} -> use widget`;
-        registerAssetType(TEST_TYPE, makeWidgetSpec({ actionBuilder: builder }));
-        expect(ACTION_BUILDERS[TEST_TYPE]).toBe(builder);
-        expect(ACTION_BUILDERS[TEST_TYPE]("widget:foo")).toBe("akm show widget:foo -> use widget");
-    });
-    test("registration works regardless of import order (no deferred hooks needed)", () => {
-        // The key property: TYPE_TO_RENDERER and ACTION_BUILDERS are populated
-        // directly, not through deferred hooks. Importing asset-registry.ts
-        // before or after asset-spec.ts doesn't matter because they share the
-        // same singleton maps.
-        const builder = (ref) => `akm show ${ref} -> render widget`;
-        registerAssetType(TEST_TYPE, makeWidgetSpec({
-            rendererName: "widget-md",
-            actionBuilder: builder,
-        }));
-        // Both maps should be populated after a single registerAssetType call
-        expect(TYPE_TO_RENDERER[TEST_TYPE]).toBe("widget-md");
-        expect(ACTION_BUILDERS[TEST_TYPE]).toBe(builder);
-    });
-    test("multiple registrations don't clobber each other", () => {
-        const type1 = `${TEST_TYPE}-1`;
-        const type2 = `${TEST_TYPE}-2`;
-        try {
-            registerAssetType(type1, makeWidgetSpec({
-                stashDir: "widgets1",
-                rendererName: "widget1-md",
-                actionBuilder: (ref) => `action1 ${ref}`,
-            }));
-            registerAssetType(type2, makeWidgetSpec({
-                stashDir: "widgets2",
-                rendererName: "widget2-md",
-                actionBuilder: (ref) => `action2 ${ref}`,
-            }));
-            expect(TYPE_TO_RENDERER[type1]).toBe("widget1-md");
-            expect(TYPE_TO_RENDERER[type2]).toBe("widget2-md");
-            expect(ACTION_BUILDERS[type1]("r")).toBe("action1 r");
-            expect(ACTION_BUILDERS[type2]("r")).toBe("action2 r");
-        }
-        finally {
-            for (const t of [type1, type2]) {
-                deregisterAssetType(t);
-                delete TYPE_TO_RENDERER[t];
-                delete ACTION_BUILDERS[t];
-            }
-        }
-    });
-    test("_setAssetTypeHooks no longer exists in asset-spec", async () => {
-        const assetSpec = await import("../src/core/asset-spec");
-        expect("_setAssetTypeHooks" in assetSpec).toBe(false);
-    });
-    test("TYPE_TO_RENDERER contains built-in types", () => {
-        expect(TYPE_TO_RENDERER.script).toBe("script-source");
-        expect(TYPE_TO_RENDERER.skill).toBe("skill-md");
-        expect(TYPE_TO_RENDERER.command).toBe("command-md");
-        expect(TYPE_TO_RENDERER.agent).toBe("agent-md");
-        expect(TYPE_TO_RENDERER.knowledge).toBe("knowledge-md");
-        expect(TYPE_TO_RENDERER.memory).toBe("memory-md");
-    });
-    test("ACTION_BUILDERS contains built-in types", () => {
-        expect(typeof ACTION_BUILDERS.script).toBe("function");
-        expect(typeof ACTION_BUILDERS.skill).toBe("function");
-        expect(typeof ACTION_BUILDERS.command).toBe("function");
-        expect(typeof ACTION_BUILDERS.agent).toBe("function");
-        expect(typeof ACTION_BUILDERS.knowledge).toBe("function");
-        expect(typeof ACTION_BUILDERS.memory).toBe("function");
-    });
-    test("spec without rendererName leaves TYPE_TO_RENDERER unchanged for that type", () => {
-        registerAssetType(TEST_TYPE, makeWidgetSpec());
-        expect(TYPE_TO_RENDERER[TEST_TYPE]).toBeUndefined();
-    });
-    test("spec without actionBuilder leaves ACTION_BUILDERS unchanged for that type", () => {
-        registerAssetType(TEST_TYPE, makeWidgetSpec());
-        expect(ACTION_BUILDERS[TEST_TYPE]).toBeUndefined();
-    });
-});