superacli 1.0.1 → 1.1.2

package/__tests__/nullclaw-plugin.test.js

@@ -0,0 +1,157 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakeCurlBinary(dir) {
+  const bin = path.join(dir, "curl")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "const url = args[args.length - 1] || '';",
+    "if (args.includes('--version')) { console.log('curl 8.0.0-test'); process.exit(0); }",
+    "if (url.includes('/git/trees/main?recursive=1')) {",
+    "  console.log(JSON.stringify({ tree: [",
+    "    { type: 'blob', path: 'README.md' },",
+    "    { type: 'blob', path: 'AGENTS.md' },",
+    "    { type: 'blob', path: 'CLAUDE.md' },",
+    "    { type: 'blob', path: 'CONTRIBUTING.md' },",
+    "    { type: 'blob', path: 'docs/en/README.md' },",
+    "    { type: 'blob', path: 'docs/en/installation.md' },",
+    "    { type: 'blob', path: 'docs/en/configuration.md' },",
+    "    { type: 'blob', path: 'docs/en/commands.md' },",
+    "    { type: 'blob', path: 'docs/en/usage.md' },",
+    "    { type: 'blob', path: 'docs/en/architecture.md' },",
+    "    { type: 'blob', path: 'docs/en/security.md' },",
+    "    { type: 'blob', path: 'docs/en/gateway-api.md' },",
+    "    { type: 'blob', path: 'docs/en/development.md' }",
+    "  ] }));",
+    "  process.exit(0);",
+    "}",
+    "if (url.includes('raw.githubusercontent.com/nullclaw/nullclaw/main/')) {",
+    "  const docPath = url.split('/main/')[1] || 'README.md';",
+    "  console.log(`# ${docPath}\\n\\nTest markdown for ${docPath}.`);",
+    "  process.exit(0);",
+    "}",
+    "console.error(`unsupported url: ${url}`);",
+    "process.exit(22);"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+function writeFakeNullclawBinary(dir) {
+  const bin = path.join(dir, "nullclaw")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version' || args[0] === 'version') { console.log('nullclaw v2026.3.8-test'); process.exit(0); }",
+    "if (args[0] === 'status') { console.log('NullClaw status: healthy'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("nullclaw hybrid plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-nullclaw-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-nullclaw-"))
+  writeFakeCurlBinary(fakeDir)
+  writeFakeNullclawBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+  let removed = false
+
+  beforeAll(() => {
+    const install = runNoServer("plugins install ./plugins/nullclaw --on-conflict replace --json", { env })
+    expect(install.ok).toBe(true)
+  })
+
+  afterAll(() => {
+    if (!removed) runNoServer("plugins remove nullclaw --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("indexes nullclaw skills provider", () => {
+    const provider = runNoServer("skills providers show --name nullclaw --json", { env })
+    expect(provider.ok).toBe(true)
+    const providerData = JSON.parse(provider.output)
+    expect(providerData.provider.name).toBe("nullclaw")
+
+    const list = runNoServer("skills list --catalog --provider nullclaw --json", { env })
+    expect(list.ok).toBe(true)
+    const listData = JSON.parse(list.output)
+    expect(listData.skills.some(skill => skill.id === "nullclaw:root.agents")).toBe(true)
+  })
+
+  test("routes wrapped version command", () => {
+    const r = runNoServer("nullclaw cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("nullclaw.cli.version")
+    expect(data.data.raw).toBe("nullclaw v2026.3.8-test")
+  })
+
+  test("routes wrapped system status command", () => {
+    const r = runNoServer("nullclaw system status --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("nullclaw.system.status")
+    expect(data.data.raw).toBe("NullClaw status: healthy")
+  })
+
+  test("supports nullclaw namespace passthrough", () => {
+    const r = runNoServer("nullclaw models list --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("nullclaw.passthrough")
+    expect(data.data.args[0]).toBe("models")
+    expect(data.data.args[1]).toBe("list")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports curl and nullclaw dependencies as healthy", () => {
+    const r = runNoServer("plugins doctor nullclaw --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "curl" && c.ok === true)).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "nullclaw" && c.ok === true)).toBe(true)
+  })
+
+  test("removal cleans up the skills provider", () => {
+    const remove = runNoServer("plugins remove nullclaw --json", { env })
+    expect(remove.ok).toBe(true)
+    removed = true
+
+    const provider = runNoServer("skills providers show --name nullclaw --json", { env })
+    expect(provider.ok).toBe(false)
+
+    const list = runNoServer("skills list --catalog --provider nullclaw --json", { env })
+    expect(list.ok).toBe(true)
+    const listData = JSON.parse(list.output)
+    expect(listData.skills).toEqual([])
+  })
+})

package/__tests__/openapi-adapter.test.js

@@ -0,0 +1,199 @@
+describe("openapi adapter", () => {
+  const mockSpec = {
+    servers: [{ url: "https://api.test/v1" }],
+    paths: {
+      "/users/{id}": {
+        get: {
+          operationId: "getUser",
+          parameters: [
+            { name: "id", in: "path" },
+            { name: "q", in: "query" }
+          ]
+        }
+      },
+      "/users": {
+        post: {
+          operationId: "createUser"
+        }
+      }
+    }
+  }
+
+  let execute;
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.resetModules()
+    global.fetch = jest.fn()
+    execute = require("../cli/adapters/openapi").execute
+  })
+
+  test("throws if spec or operationId missing", async () => {
+    await expect(execute({ adapterConfig: {} }, {}, {})).rejects.toThrow(/requires 'spec' and 'operationId'/)
+  })
+
+  test("successfully executes GET operation with path and query params", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ 
+        ok: true,
+        json: () => Promise.resolve(mockSpec)
+      })
+      .mockResolvedValueOnce({ 
+        ok: true,
+        headers: { get: () => "application/json" },
+        json: () => Promise.resolve({ user: "alice" })
+      })
+
+    const context = {
+      config: {
+        specs: [{ name: "my-spec", url: "http://specs/my.json" }]
+      }
+    }
+
+    const result = await execute({
+      adapterConfig: { spec: "my-spec", operationId: "getUser" }
+    }, { id: "123", q: "query-val" }, context)
+
+    expect(global.fetch).toHaveBeenCalledWith("http://specs/my.json")
+    expect(global.fetch).toHaveBeenCalledWith(
+      "https://api.test/v1/users/123?q=query-val",
+      expect.objectContaining({ method: "GET" })
+    )
+    expect(result).toEqual({ user: "alice" })
+  })
+
+  test("successfully executes POST operation with body", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ 
+        ok: true,
+        json: () => Promise.resolve(mockSpec)
+      })
+      .mockResolvedValueOnce({ 
+        ok: true,
+        headers: { get: () => "text/plain" },
+        text: () => Promise.resolve("done")
+      })
+
+    const context = {
+      config: {
+        specs: [{ name: "my-spec", url: "u" }]
+      }
+    }
+
+    const result = await execute({
+      adapterConfig: { spec: "my-spec", operationId: "createUser" }
+    }, { name: "bob" }, context)
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      "https://api.test/v1/users",
+      expect.objectContaining({
+        method: "POST",
+        body: JSON.stringify({ name: "bob" })
+      })
+    )
+    expect(result).toEqual({ raw: "done" })
+  })
+
+  test("resolves spec from remote server if not in local config", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ 
+        ok: true,
+        json: () => Promise.resolve([{ name: "remote-spec", url: "http://remote/spec.json" }])
+      })
+      .mockResolvedValueOnce({ 
+        ok: true,
+        json: () => Promise.resolve(mockSpec)
+      })
+      .mockResolvedValueOnce({ 
+        ok: true,
+        headers: { get: () => "json" },
+        json: () => Promise.resolve({ ok: true })
+      })
+
+    const context = { server: "http://api.test", config: { specs: [] } }
+
+    await execute({
+      adapterConfig: { spec: "remote-spec", operationId: "getUser" }
+    }, { id: "1" }, context)
+
+    expect(global.fetch).toHaveBeenCalledWith("http://api.test/api/specs?format=json")
+    expect(global.fetch).toHaveBeenCalledWith("http://remote/spec.json")
+  })
+
+  test("throws if spec not found and no server", async () => {
+    const context = { config: { specs: [] } }
+    await expect(execute({
+      adapterConfig: { spec: "missing", operationId: "op" }
+    }, {}, context)).rejects.toThrow(/not found in local config/)
+  })
+
+  test("throws if remote spec list fetch fails", async () => {
+    global.fetch.mockResolvedValue({ ok: false, status: 500 })
+    const context = { server: "http://api.test", config: { specs: [] } }
+    await expect(execute({
+      adapterConfig: { spec: "any", operationId: "op" }
+    }, {}, context)).rejects.toThrow(/Failed to fetch specs list: 500/)
+  })
+
+  test("throws if remote spec not found in list", async () => {
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve([])
+    })
+    const context = { server: "http://api.test", config: { specs: [] } }
+    await expect(execute({
+      adapterConfig: { spec: "missing", operationId: "op" }
+    }, {}, context)).rejects.toThrow(/OpenAPI spec 'missing' not found/)
+  })
+
+  test("throws if actual spec fetch fails", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve([{ name: "s", url: "u" }]) })
+      .mockResolvedValueOnce({ ok: false, status: 404 })
+    const context = { server: "http://api.test", config: { specs: [] } }
+    await expect(execute({
+      adapterConfig: { spec: "s", operationId: "op" }
+    }, {}, context)).rejects.toThrow(/Failed to fetch OpenAPI spec from u: 404/)
+  })
+
+  test("throws if operationId not found in spec", async () => {
+    global.fetch.mockResolvedValue({ ok: true, json: () => Promise.resolve(mockSpec) })
+    const context = { config: { specs: [{ name: "s", url: "u" }] } }
+    await expect(execute({
+      adapterConfig: { spec: "s", operationId: "missingOp" }
+    }, {}, context)).rejects.toThrow(/Operation 'missingOp' not found in spec/)
+  })
+
+  test("handles API call failure (500)", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockSpec) })
+      .mockResolvedValueOnce({ 
+        ok: false, 
+        status: 500, 
+        statusText: "Err", 
+        text: () => Promise.resolve("body"),
+        headers: { get: () => "text/plain" }
+      })
+    
+    const context = { config: { specs: [{ name: "s", url: "u" }] } }
+    await expect(execute({
+      adapterConfig: { spec: "s", operationId: "getUser" }
+    }, { id: "1" }, context)).rejects.toMatchObject({ code: 105 })
+  })
+
+  test("uses spec cache", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockSpec) })
+      .mockResolvedValue({ ok: true, headers: { get: () => "json" }, json: () => Promise.resolve({}) })
+
+    const context = { config: { specs: [{ name: "cached", url: "u" }] } }
+    
+    // First call: spec fetch + API call
+    await execute({ adapterConfig: { spec: "cached", operationId: "getUser" } }, { id: "1" }, context)
+    // Second call: only API call (spec is cached)
+    await execute({ adapterConfig: { spec: "cached", operationId: "getUser" } }, { id: "2" }, context)
+
+    expect(global.fetch).toHaveBeenCalledWith("u")
+    expect(global.fetch).toHaveBeenCalledTimes(3) // 1 spec fetch + 2 API calls
+  })
+})

package/__tests__/plan-runtime.test.js

@@ -0,0 +1,43 @@
+const { buildLocalPlan, annotateServerPlan, outputHumanPlan } = require("../cli/plan-runtime")
+
+describe("plan-runtime", () => {
+  test("buildLocalPlan annotates local execution", () => {
+    const cmd = {
+      namespace: "ai",
+      resource: "text",
+      action: "summarize",
+      adapter: "mcp",
+      adapterConfig: { tool: "summarize" }
+    }
+
+    const plan = buildLocalPlan(cmd, { text: "hello" })
+
+    expect(plan.execution_mode).toBe("local")
+    expect(plan.persisted).toBe(false)
+    expect(plan.command).toBe("ai.text.summarize")
+  })
+
+  test("annotateServerPlan annotates persisted server plan", () => {
+    const plan = annotateServerPlan({ plan_id: "plan_1", command: "x.y.z", steps: [] })
+
+    expect(plan.execution_mode).toBe("server")
+    expect(plan.persisted).toBe(true)
+  })
+
+  test("outputHumanPlan prints execution hint", () => {
+    const spy = jest.spyOn(console, "log").mockImplementation(() => {})
+    outputHumanPlan({
+      plan_id: "plan_1",
+      command: "x.y.z",
+      risk_level: "safe",
+      side_effects: false,
+      persisted: false,
+      steps: [{ type: "resolve_command", description: "resolve" }]
+    })
+
+    const joined = spy.mock.calls.map(args => args.join(" ")).join("\n")
+    expect(joined).toContain("Execution Plan")
+    expect(joined).toContain("preview only")
+    spy.mockRestore()
+  })
+})

package/__tests__/planner.test.js

@@ -0,0 +1,47 @@
+const { createPlan } = require("../cli/planner")
+
+describe("planner", () => {
+  test("creates default http plan with expected steps", () => {
+    const cmd = {
+      namespace: "api",
+      resource: "users",
+      action: "list",
+      adapter: "http",
+      adapterConfig: { method: "GET", url: "https://example.com/users" }
+    }
+
+    const plan = createPlan(cmd, { limit: 10 })
+
+    expect(plan.command).toBe("api.users.list")
+    expect(plan.args).toEqual({ limit: 10 })
+    expect(plan.steps).toHaveLength(4)
+    expect(plan.steps[2]).toMatchObject({
+      type: "adapter_request",
+      adapter: "http",
+      method: "GET",
+      url: "https://example.com/users"
+    })
+    expect(plan.side_effects).toBe(false)
+    expect(plan.risk_level).toBe("safe")
+  })
+
+  test("marks mutation command as medium risk by default", () => {
+    const cmd = {
+      namespace: "api",
+      resource: "users",
+      action: "create",
+      adapter: "openapi",
+      mutation: true,
+      adapterConfig: { operationId: "createUser" }
+    }
+
+    const plan = createPlan(cmd, {})
+
+    expect(plan.side_effects).toBe(true)
+    expect(plan.risk_level).toBe("medium")
+    expect(plan.steps[2]).toMatchObject({
+      adapter: "openapi",
+      operationId: "createUser"
+    })
+  })
+})

package/__tests__/plugin-agency-agents.test.js

@@ -0,0 +1,62 @@
+const { spawnSync } = require("child_process")
+const { addProvider, syncCatalog } = require("../cli/skills-catalog")
+const {
+  run,
+  buildRemoteEntriesFromTree
+} = require("../plugins/agency-agents/scripts/post-install")
+
+jest.mock("child_process")
+jest.mock("../cli/skills-catalog")
+
+describe("plugin-agency-agents", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("buildRemoteEntriesFromTree filters only agent markdown files", () => {
+    const entries = buildRemoteEntriesFromTree({
+      tree: [
+        { type: "blob", path: "engineering/engineering-frontend-developer.md" },
+        { type: "blob", path: "strategy/QUICKSTART.md" },
+        { type: "blob", path: "design/README.md" },
+        { type: "blob", path: "marketing/marketing-growth-hacker.md" }
+      ]
+    })
+
+    expect(entries).toHaveLength(2)
+    expect(entries[0].id).toBe("engineering.engineering-frontend-developer")
+    expect(entries[1].id).toBe("marketing.marketing-growth-hacker")
+  })
+
+  test("run stores provider and syncs catalog", () => {
+    spawnSync.mockReturnValue({
+      status: 0,
+      stdout: JSON.stringify({
+        tree: [
+          { type: "blob", path: "engineering/engineering-frontend-developer.md" },
+          { type: "blob", path: "testing/testing-api-tester.md" }
+        ]
+      })
+    })
+    syncCatalog.mockReturnValue({ skills: [1, 2, 3] })
+
+    const result = run()
+
+    expect(addProvider).toHaveBeenCalledWith(expect.objectContaining({
+      name: "agency-agents",
+      type: "remote_static",
+      entries: expect.any(Array)
+    }))
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({
+      provider: "agency-agents",
+      entries: 2,
+      synced_skills: 3
+    })
+  })
+
+  test("run throws on curl failure", () => {
+    spawnSync.mockReturnValue({ status: 22, stderr: "404" })
+    expect(() => run()).toThrow(/Failed to fetch agency-agents metadata/)
+  })
+})

package/__tests__/plugin-nullclaw.test.js

@@ -0,0 +1,78 @@
+const { spawnSync } = require("child_process")
+const { addProvider, removeProvider, syncCatalog } = require("../cli/skills-catalog")
+const {
+  CATALOG_FILES,
+  run,
+  buildRemoteEntriesFromTree
+} = require("../plugins/nullclaw/scripts/post-install")
+const { run: runUninstall } = require("../plugins/nullclaw/scripts/post-uninstall")
+
+jest.mock("child_process")
+jest.mock("../cli/skills-catalog")
+
+describe("plugin-nullclaw", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("buildRemoteEntriesFromTree keeps only curated nullclaw docs", () => {
+    const entries = buildRemoteEntriesFromTree({
+      tree: [
+        { type: "blob", path: "README.md" },
+        { type: "blob", path: "AGENTS.md" },
+        { type: "blob", path: "docs/en/commands.md" },
+        { type: "blob", path: "docs/zh/commands.md" },
+        { type: "blob", path: "spec/webchannel_v1.json" }
+      ]
+    })
+
+    expect(entries.map(entry => entry.id)).toEqual([
+      "root.readme",
+      "root.agents",
+      "docs.en.commands"
+    ])
+    expect(entries.every(entry => entry.source_url.includes("raw.githubusercontent.com/nullclaw/nullclaw/main/"))).toBe(true)
+  })
+
+  test("run stores provider and syncs catalog", () => {
+    spawnSync.mockReturnValue({
+      status: 0,
+      stdout: JSON.stringify({
+        tree: CATALOG_FILES.map(file => ({ type: "blob", path: file.path }))
+      })
+    })
+    syncCatalog.mockReturnValue({ skills: [1, 2, 3, 4] })
+
+    const result = run()
+
+    expect(addProvider).toHaveBeenCalledWith(expect.objectContaining({
+      name: "nullclaw",
+      type: "remote_static",
+      entries: expect.arrayContaining([
+        expect.objectContaining({ id: "root.agents" }),
+        expect.objectContaining({ id: "docs.en.architecture" })
+      ])
+    }))
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({
+      provider: "nullclaw",
+      entries: CATALOG_FILES.length,
+      synced_skills: 4
+    })
+  })
+
+  test("run throws on curl failure", () => {
+    spawnSync.mockReturnValue({ status: 22, stderr: "404" })
+    expect(() => run()).toThrow(/Failed to fetch nullclaw metadata/)
+  })
+
+  test("post-uninstall removes provider and syncs catalog", () => {
+    removeProvider.mockReturnValue(true)
+    syncCatalog.mockReturnValue({ skills: [1] })
+    const result = runUninstall()
+    expect(removeProvider).toHaveBeenCalledWith("nullclaw")
+    expect(addProvider).not.toHaveBeenCalled()
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({ provider: "nullclaw", removed: true, synced_skills: 1 })
+  })
+})

package/__tests__/plugin-visual-explainer.test.js

@@ -0,0 +1,62 @@
+const { spawnSync } = require("child_process")
+const { addProvider, syncCatalog } = require("../cli/skills-catalog")
+const {
+  run,
+  buildRemoteEntriesFromTree
+} = require("../plugins/visual-explainer/scripts/post-install")
+
+jest.mock("child_process")
+jest.mock("../cli/skills-catalog")
+
+describe("plugin-visual-explainer", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("buildRemoteEntriesFromTree filters only normalized markdown skills", () => {
+    const entries = buildRemoteEntriesFromTree({
+      tree: [
+        { type: "blob", path: "plugins/visual-explainer-normalized/SKILL.md" },
+        { type: "blob", path: "plugins/visual-explainer-normalized/commands/diff-review.md" },
+        { type: "blob", path: "plugins/visual-explainer/commands/diff-review.md" },
+        { type: "blob", path: "plugins/visual-explainer-normalized/templates/architecture.html" }
+      ]
+    })
+
+    expect(entries).toHaveLength(2)
+    expect(entries[0].id).toBe("visual-explainer.commands.diff-review")
+    expect(entries[1].id).toBe("visual-explainer.skill")
+  })
+
+  test("run stores provider and syncs catalog", () => {
+    spawnSync.mockReturnValue({
+      status: 0,
+      stdout: JSON.stringify({
+        tree: [
+          { type: "blob", path: "plugins/visual-explainer-normalized/SKILL.md" },
+          { type: "blob", path: "plugins/visual-explainer-normalized/commands/generate-web-diagram.md" }
+        ]
+      })
+    })
+    syncCatalog.mockReturnValue({ skills: [1, 2, 3] })
+
+    const result = run()
+
+    expect(addProvider).toHaveBeenCalledWith(expect.objectContaining({
+      name: "visual-explainer",
+      type: "remote_static",
+      entries: expect.any(Array)
+    }))
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({
+      provider: "visual-explainer",
+      entries: 2,
+      synced_skills: 3
+    })
+  })
+
+  test("run throws on curl failure", () => {
+    spawnSync.mockReturnValue({ status: 22, stderr: "404" })
+    expect(() => run()).toThrow(/Failed to fetch visual-explainer metadata/)
+  })
+})