superacli 1.1.6 → 1.1.7

package/README.md

@@ -1,6 +1,11 @@
-# supercli — Universal Skill Router for AI Agents
+# supercli — Universal Capability Router for AI Agents
 
-Discover and execute skills across CLIs, APIs, MCP servers, workflows, and custom automations through a single agent-friendly interface.
+Discover and execute capabilities across CLIs, APIs, MCP servers, workflows, and custom automations through a single agent-friendly interface.
+
+## Terminology
+
+- **Capability**: Any executable unit exposed by Supercli (command, OpenAPI operation, MCP tool binding, HTTP integration, workflow step).
+- **Skill document**: Agent-facing guidance in `SKILL.md` format, indexed by the `skills` catalog commands.
 
 ## BIN Aliases
 
@@ -10,44 +15,44 @@ Discover and execute skills across CLIs, APIs, MCP servers, workflows, and custo
 - superacli (What was available) (Super Agent/ic CLI)
 - sc (For lazy people)
 
-## What Is a Skill Layer?
+## What Is a Capability Layer?
 
-Everything the system exposes becomes a **skill**:
+Everything the system exposes becomes a **capability**:
 
 | Source | Turns into |
 | --- | --- |
-| CLI command | Skill |
-| OpenAPI endpoint | Skill |
-| MCP tool | Skill |
-| HTTP request | Skill |
-| Workflow / plan step | Skill |
+| CLI command | Capability |
+| OpenAPI endpoint | Capability |
+| MCP tool | Capability |
+| HTTP request | Capability |
+| Workflow / plan step | Capability |
 
-Agents query the skill layer once, and supercli handles discovery, routing, and execution across every connected ecosystem. Skills are addressable (e.g., `beads.issue.list` or `docker.container.ps`), searchable, and consistently described so agents never need bespoke integrations per tool.
+Agents query the capability layer once, and supercli handles discovery, routing, and execution across every connected ecosystem. Capabilities are addressable (e.g., `beads.issue.list` or `docker.container.ps`), searchable, and consistently described so agents never need bespoke integrations per tool.
 
 ### Core Responsibilities
 
-1. **Discovery** – build a real-time catalog of skills across bundled harnesses, adapters, and plugins.
-2. **Routing** – resolve the right execution adapter (CLI, HTTP, MCP, custom runtime) from an incoming skill ID.
+1. **Discovery** – build a real-time catalog of capabilities across bundled harnesses, adapters, and plugins.
+2. **Routing** – resolve the right execution adapter (CLI, HTTP, MCP, custom runtime) from an incoming capability ID.
 3. **Execution** – normalize inputs/outputs, enforce envelopes, and surface deterministic status codes.
-4. **Extension** – let teams add new skills by dropping in manifests, OpenAPI specs, or plugin harnesses.
+4. **Extension** – let teams add new capabilities by dropping in manifests, OpenAPI specs, or plugin harnesses.
 
-Example skill executions:
+Example capability executions:
 
 ```bash
-supercli beads issue list              # Calls beads skill adapter
+supercli beads issue list              # Calls beads capability adapter
 supercli gwc drive files list          # Calls Google Workspace adapter
 supercli docker container ps           # Calls Docker plugin (when installed)
 ```
 
-## Skill Sources
+## Capability Sources
 
-supercli generates skills from six primary channels:
+supercli generates capabilities from six primary channels:
 
 - **Bundled Harnesses** – beads (tasks/issues), gwc (Google Workspace), commiat (commit automation)
 - **Built-in Adapters** – OpenAPI specs, raw HTTP integrations, MCP (Model Context Protocol) servers
 - **Plugin Harnesses** – community or internal CLIs installed via `supercli plugins install`
-- **AI & Plans** – natural-language `ask` commands create execution DAGs composed of skills
-- **Workflows** – repeatable plans and stored executions referenced as skills
+- **AI & Plans** – natural-language `ask` commands create execution DAGs composed of capabilities
+- **Workflows** – repeatable plans and stored executions referenced as capabilities
 - **Future Extensions** – popular CLIs such as gh, aws, docker, kubectl, terraform, etc.
 
 ## Architecture
@@ -57,9 +62,9 @@ supercli generates skills from six primary channels:
                   │
             supercli runtime
                   │
-            Skill Discovery Layer
+          Capability Discovery Layer
                   │
-             Skill Router Core
+           Capability Router Core
                   │
    ┌──────────────┼──────────────┬───────────────┐
    │              │              │               │
@@ -67,61 +72,67 @@ supercli generates skills from six primary channels:
 ```
 
 The router intelligently:
-- **Discovers** available skills from every adapter and caches metadata for fast lookup
+- **Discovers** available capabilities from every adapter and caches metadata for fast lookup
 - **Routes** commands to the correct harness based on namespace and capability metadata
 - **Executes** with unified error handling, envelopes, and output formatting
-- **Surfaces** machine-readable descriptions so agents can plan against the skill graph
+- **Surfaces** machine-readable descriptions so agents can plan against the capability graph
 
-## Why Skills Matter
+## Why Capabilities Matter
 
-Traditional CLIs force agents to learn tool-specific syntax. supercli replaces that effort with a discoverable skill graph so agents can:
+Traditional CLIs force agents to learn tool-specific syntax. supercli replaces that effort with a discoverable capability graph so agents can:
 
 - Search (`supercli skills search "database"`) to find relevant capabilities instantly
 - Inspect (`supercli skills get beads.issue.create`) to pull schema-rich metadata
-- Compose (`supercli plan …`) to build DAGs out of skills without writing glue code
+- Compose (`supercli plan …`) to build DAGs out of capabilities without writing glue code
 - Delegate execution to the same router regardless of whether the source is a CLI, API, or MCP tool
 
-## Skill Mesh Vision
+## Capability Mesh Vision
 
-supercli is steadily evolving toward a broader **skill mesh** that provides discovery, routing, execution, composition, and governance across every tool in the stack. Near-term focus areas include:
+supercli is steadily evolving toward a broader **capability mesh** that provides discovery, routing, execution, composition, and governance across every tool in the stack. Near-term focus areas include:
 
-- **Deeper skill registry** with richer metadata, tagging, and policy controls
-- **Graph-native discovery** so agents can traverse related skills and capability clusters
-- **Execution DAG observability** for multi-skill plans with retries and status streaming
+- **Deeper capability registry** with richer metadata, tagging, and policy controls
+- **Graph-native discovery** so agents can traverse related capabilities and capability clusters
+- **Execution DAG observability** for multi-capability plans with retries and status streaming
 - **Agent endpoints** that expose the router over HTTP/webhooks for direct agent access beyond the CLI
 
 These directional goals keep the README aligned with the system’s trajectory without overpromising unshipped features.
 
+## Operating Modes
+
+Supercli supports two runtime modes:
+
+| Mode | What it means | Best for |
+| --- | --- | --- |
+| Local-only (default) | CLI runs directly from local config/cache and installed plugins. No Supercli server required. | Personal workflows, offline/local development, quick setup |
+| Server mode | A Supercli server hosts shared config/plugins via API; clients connect with `SUPERCLI_SERVER` and run `supercli sync`. | Team-shared capabilities/plugins, centralized governance, multi-client consistency |
+
+Notes:
+- `supercli sync` is only relevant when `SUPERCLI_SERVER` is configured.
+- Local plugins still take precedence over server-synced plugins when names collide.
+- Server plugin behavior and policies are documented in [docs/features/server-plugins.md](docs/features/server-plugins.md).
+
 ## Quick Start
 
 ```bash
-# Quick usage (no install, local-only by default)
+# Path A: Local-only mode (default, no server required)
 npx supercli help                      # List available harnesses
 npx supercli skills teach
 
 # Install
 npm install
 
-# Configure (copy and edit)
+# Optional local config
 cp .env.example .env
 
-# Start server (defaults to local JSON files, no MongoDB required!)
-npm start
-# Or alternatively, start via CLI:
-# supercli --server
-
-# Open Web UI
-open http://localhost:3000
-
-# CLI usage - Multi-harness routing
+# Local CLI usage - Multi-harness routing
 supercli help                          # List all harnesses
-supercli beads                         # List beads skills
-supercli gwc                           # List Google Workspace skills
+supercli beads                         # List beads capabilities
+supercli gwc                           # List Google Workspace capabilities
 supercli beads issue list              # Execute beads command
 supercli gwc drive files list          # Execute Google Workspace command
 
-# Skills discovery across harnesses
-supercli skills list                   # All skills from all harnesses
+# Capabilities discovery across harnesses
+supercli skills list                   # Capability docs from all harnesses
 supercli skills search "database"      # Full-text search across harnesses
 
 # AI-driven multi-harness execution
@@ -131,6 +142,19 @@ supercli ask "show my tasks and recent commits"
 supercli plugins list
 supercli plugins explore               # Browse available plugins
 supercli plugins install commiat       # Install community plugin
+
+# Path B: Server mode (optional, shared backend)
+# Start server (local JSON storage by default; MongoDB optional)
+npm start
+# Or alternatively, start via CLI:
+# supercli --server
+
+# Point CLI clients to the server, then sync shared config/plugins
+export SUPERCLI_SERVER=http://localhost:3000
+supercli sync
+
+# Open Web UI
+open http://localhost:3000
 ```
 
 ## CLI Usage
@@ -139,8 +163,8 @@ supercli plugins install commiat       # Install community plugin
 
 ```bash
 # Basic harness routing
-supercli <harness>                          # List skills in harness
-supercli <harness> <skill-group> <action>   # Execute skill
+supercli <harness>                          # List capabilities in harness
+supercli <harness> <capability-group> <action>   # Execute capability
 
 # Examples across different harnesses
 supercli beads issue create --title "Fix bug"
@@ -150,13 +174,13 @@ supercli commiat validate --commit-msg "my message"
 
 # Discovery
 supercli help                              # List all harnesses
-supercli skills list                       # List all skills from all harnesses
+supercli skills list                       # List capability docs from all harnesses
 supercli skills search --harness beads     # Search within harness
 supercli skills search "database"          # Full-text search across harnesses
 
 # Inspection
 supercli inspect beads issue create        # Command details + schema
-supercli skills get beads.issue.create     # Get skill metadata
+supercli skills get beads.issue.create     # Get capability documentation
 
 # Execution
 supercli beads issue create --title "New task"      # Standard execution
@@ -172,9 +196,9 @@ export OPENAI_BASE_URL=https://api.openai.com/v1   # Enable AI resolution
 supercli ask "list my tasks and summarize them"     # Execute across harnesses
 
 # Config & Server
-supercli sync                              # Sync local cache from server
+supercli sync                              # Server mode only: sync cache from SUPERCLI_SERVER
 supercli config show                       # Show cache info
-supercli --server                          # Start backend server
+supercli --server                          # Start backend server (server mode)
 
 # Plugin Harness Management
 supercli plugins list                      # List installed harnesses
@@ -221,7 +245,7 @@ supercli --help-json                       # Machine-readable capabilities
 A **plugin harness** bridges dcli to an external CLI tool. Each plugin:
 - Defines a manifest (`plugin.json`) with available commands
 - Maps CLI arguments to dcli's command structure
-- Supports command wrapping, passthrough, remote skills catalogs, or any combination of those patterns
+- Supports command wrapping, passthrough, remote skill-document catalogs, or any combination of those patterns
 - Includes dependency checks and installation guidance
 
 ### Currently Supported Harnesses

package/__tests__/azd-plugin.test.js

@@ -0,0 +1,109 @@
+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 writeFakeAzdBinary(dir) {
+  const bin = path.join(dir, "azd")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === 'version') { console.log('azd version 1.17.0-test'); process.exit(0); }",
+    "if (args[0] === 'auth' && args[1] === 'login' && args.includes('--check-status')) {",
+    "  console.log('Logged in as test-user');",
+    "  process.exit(0);",
+    "}",
+    "if (args[0] === 'deploy' && args[1] === '--all') {",
+    "  const envIndex = args.indexOf('--environment');",
+    "  const environment = envIndex >= 0 ? args[envIndex + 1] : null;",
+    "  console.log(JSON.stringify({ mode: 'deploy-all', environment, args }));",
+    "  process.exit(0);",
+    "}",
+    "if (args[0] === 'env' && args[1] === 'list') {",
+    "  console.log(JSON.stringify({ environments: ['dev', 'prod'] }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("azd plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-azd-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-azd-"))
+  writeFakeAzdBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    const install = runNoServer("plugins install ./plugins/azd --on-conflict replace --json", { env })
+    expect(install.ok).toBe(true)
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove azd --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes wrapped commands and passthrough", () => {
+    const version = runNoServer("azd cli version --json", { env })
+    expect(version.ok).toBe(true)
+    expect(JSON.parse(version.output).data.raw).toBe("azd version 1.17.0-test")
+
+    const status = runNoServer("azd auth status --json", { env })
+    expect(status.ok).toBe(true)
+    expect(JSON.parse(status.output).data.raw).toContain("Logged in")
+
+    const deploy = runNoServer("azd deploy all --environment dev --json", { env })
+    expect(deploy.ok).toBe(true)
+    const deployPayload = JSON.parse(JSON.parse(deploy.output).data.raw)
+    expect(deployPayload.mode).toBe("deploy-all")
+    expect(deployPayload.environment).toBe("dev")
+    expect(deployPayload.args).toContain("--no-prompt")
+
+    const passthrough = runNoServer("azd env list --json", { env })
+    expect(passthrough.ok).toBe(true)
+    expect(JSON.parse(passthrough.output).command).toBe("azd.passthrough")
+  })
+
+  test("exposes learn content and healthy dependency checks", () => {
+    const learn = runNoServer("plugins learn azd --json", { env })
+    expect(learn.ok).toBe(true)
+    const learnPayload = JSON.parse(learn.output)
+    expect(learnPayload.plugin).toBe("azd")
+    expect(learnPayload.learn_markdown).toContain("azd Quickstart")
+
+    const explore = runNoServer("plugins explore --name azd --json", { env })
+    expect(explore.ok).toBe(true)
+    const plugin = JSON.parse(explore.output).plugins.find(p => p.name === "azd")
+    expect(plugin).toBeDefined()
+    expect(plugin.has_learn).toBe(true)
+
+    const doctor = runNoServer("plugins doctor azd --json", { env })
+    expect(doctor.ok).toBe(true)
+    expect(JSON.parse(doctor.output).checks.some(c => c.type === "binary" && c.binary === "azd" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/config.test.js

@@ -17,7 +17,7 @@ const {
   upsertCommand,
   removeCommandsByNamespace
 } = require("../cli/config")
-const { getInstalledPluginCommands, listInstalledPlugins } = require("../cli/plugins-store")
+const { getEffectivePluginCommands, listInstalledPlugins, readServerPluginsLock } = require("../cli/plugins-store")
 
 global.fetch = jest.fn()
 
@@ -29,8 +29,9 @@ describe("config", () => {
   beforeEach(() => {
     jest.clearAllMocks()
     os.homedir.mockReturnValue(mockHomedir)
-    getInstalledPluginCommands.mockReturnValue([])
+    getEffectivePluginCommands.mockReturnValue([])
     listInstalledPlugins.mockReturnValue([])
+    readServerPluginsLock.mockReturnValue({ installed: {} })
     jest.spyOn(Date, "now").mockReturnValue(1000000)
   })
 
@@ -52,7 +53,7 @@ describe("config", () => {
         version: "2",
         commands: [{ id: "base" }]
       }))
-      getInstalledPluginCommands.mockReturnValue([{ id: "plugin" }])
+      getEffectivePluginCommands.mockReturnValue([{ id: "plugin" }])
 
       const config = await loadConfig()
       expect(config.version).toBe("2")

package/__tests__/discover.test.js

@@ -0,0 +1,59 @@
+const { tokenizeIntent, discoverPluginsByIntent } = require("../cli/discover")
+const { listRegistryPlugins } = require("../cli/plugins-registry")
+const { listInstalledPlugins, getPluginInstallGuidance } = require("../cli/plugins-manager")
+
+jest.mock("../cli/plugins-registry")
+jest.mock("../cli/plugins-manager")
+
+describe("discover", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("tokenizeIntent strips stopwords and expands synonyms", () => {
+    const tokens = tokenizeIntent("Please send mail with gmail")
+    expect(tokens).toEqual(expect.arrayContaining(["email", "gmail", "mail"]))
+    expect(tokens).not.toContain("please")
+    expect(tokens).not.toContain("with")
+  })
+
+  test("discoverPluginsByIntent ranks plugins deterministically", () => {
+    listRegistryPlugins.mockReturnValue([
+      {
+        name: "resend",
+        description: "Resend email API",
+        tags: ["email", "api"],
+        has_learn: true,
+        source: { type: "bundled" },
+      },
+      {
+        name: "browser-use",
+        description: "Browser automation over MCP",
+        tags: ["browser", "mcp"],
+        has_learn: true,
+        source: { type: "bundled" },
+      },
+    ])
+    listInstalledPlugins.mockReturnValue([{ name: "resend" }])
+    getPluginInstallGuidance.mockReturnValue({
+      install_steps: ["supercli plugins install resend", "supercli resend cli setup"],
+    })
+
+    const out = discoverPluginsByIntent("send email", { limit: 5 })
+    expect(out.no_llm).toBe(true)
+    expect(out.plugins[0].name).toBe("resend")
+    expect(out.plugins[0].installed).toBe(true)
+    expect(out.plugins[0].matched_tokens).toContain("email")
+    expect(out.plugins[0].next_steps).toEqual(expect.arrayContaining(["supercli plugins learn resend --json"]))
+  })
+
+  test("discoverPluginsByIntent validates empty intent", () => {
+    expect(() => discoverPluginsByIntent("   ")).toThrow(/Missing --intent text/)
+  })
+
+  test("discoverPluginsByIntent validates limit", () => {
+    listRegistryPlugins.mockReturnValue([])
+    listInstalledPlugins.mockReturnValue([])
+    expect(() => discoverPluginsByIntent("email", { limit: 0 })).toThrow(/Invalid --limit/)
+  })
+})

package/__tests__/goose-plugin.test.js

@@ -0,0 +1,149 @@
+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 || {}) },
+      cwd: options.cwd || undefined
+    })
+    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 writeFakeGooseBinary(dir) {
+  const bin = path.join(dir, "goose")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('goose 1.27.2-test'); process.exit(0); }",
+    "if (args[0] === 'run' && args.includes('--output-format') && args.includes('stream-json')) {",
+    "  console.log(JSON.stringify({ type: 'message', content: 'planning' }));",
+    "  console.log(JSON.stringify({ type: 'result', ok: true }));",
+    "  process.exit(0);",
+    "}",
+    "if (args[0] === 'run' && args.includes('--output-format') && args.includes('json')) {",
+    "  if (args.includes('--text') && args[args.indexOf('--text') + 1] === 'Needs provider') {",
+    "    console.error(JSON.stringify({ error: { message: \"No provider configured. Run 'goose configure' first\" } }));",
+    "    process.exit(1);",
+    "  }",
+    "  const i = args.indexOf('--text');",
+    "  console.log(JSON.stringify({ ok: true, mode: 'json', text: i >= 0 ? args[i + 1] : null, args, cwd: process.cwd() }));",
+    "  process.exit(0);",
+    "}",
+    "if (args[0] === 'run' && args.includes('--instructions')) {",
+    "  const i = args.indexOf('--instructions');",
+    "  console.log(`file:${args[i + 1] || ''}`);",
+    "  process.exit(0);",
+    "}",
+    "if (args[0] === 'run' && args.includes('--text')) {",
+    "  const i = args.indexOf('--text');",
+    "  console.log(`text:${args[i + 1] || ''}`);",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("goose plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-goose-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-goose-"))
+  writeFakeGooseBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    const install = runNoServer("plugins install ./plugins/goose --on-conflict replace --json", { env })
+    expect(install.ok).toBe(true)
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove goose --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes wrapped commands and passthrough", () => {
+    const version = runNoServer("goose cli version --json", { env })
+    expect(version.ok).toBe(true)
+    expect(JSON.parse(version.output).data.raw).toBe("goose 1.27.2-test")
+
+    const text = runNoServer("goose task text --text \"Summarize this repo\" --json", { env })
+    expect(text.ok).toBe(true)
+    expect(JSON.parse(text.output).data.raw).toBe("text:Summarize this repo")
+
+    const json = runNoServer("goose task json --text \"Return JSON\" --json", { env })
+    expect(json.ok).toBe(true)
+    const jsonPayload = JSON.parse(json.output).data
+    expect(jsonPayload.mode).toBe("json")
+    expect(jsonPayload.text).toBe("Return JSON")
+    expect(jsonPayload.args).toContain("--no-session")
+
+    const file = runNoServer("goose task file --instructions ./task.txt --json", { env })
+    expect(file.ok).toBe(true)
+    expect(JSON.parse(file.output).data.raw).toBe("file:./task.txt")
+
+    const passthrough = runNoServer("goose run --text \"raw mode\" --json", { env })
+    expect(passthrough.ok).toBe(true)
+    expect(JSON.parse(passthrough.output).command).toBe("goose.passthrough")
+  })
+
+  test("streams jsonl events and exposes learn content", () => {
+    const stream = runNoServer("goose task stream --text \"Plan work\" --json", { env })
+    expect(stream.ok).toBe(true)
+    const lines = stream.output.split("\n").filter(Boolean).map(line => JSON.parse(line))
+    expect(lines[0].command).toBe("goose.task.stream")
+    expect(lines[0].data.type).toBe("message")
+    expect(lines[1].data.type).toBe("result")
+    expect(lines[2].data.streamed).toBe(true)
+    expect(lines[2].data.event_count).toBe(2)
+
+    const learn = runNoServer("plugins learn goose --json", { env })
+    expect(learn.ok).toBe(true)
+    expect(JSON.parse(learn.output).learn_markdown).toContain("Goose Quickstart")
+
+    const doctor = runNoServer("plugins doctor goose --json", { env })
+    expect(doctor.ok).toBe(true)
+    expect(JSON.parse(doctor.output).checks.some(c => c.type === "binary" && c.binary === "goose" && c.ok === true)).toBe(true)
+  })
+
+  test("returns friendly escalation guidance when goose is unconfigured", () => {
+    const result = runNoServer("goose task json --text \"Needs provider\" --json", { env })
+    expect(result.ok).toBe(false)
+    const payload = JSON.parse(result.stderr || result.output)
+    expect(payload.error.message).toContain("not configured with a provider yet")
+    expect(payload.error.suggestions[0]).toContain("goose configure")
+    expect(payload.error.recoverable).toBe(true)
+  })
+
+  test("runs Goose task commands from the caller cwd", () => {
+    const invokeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-goose-invoke-"))
+    try {
+      const result = runNoServer("goose task json --text \"Check cwd\" --json", {
+        env,
+        cwd: invokeDir
+      })
+      expect(result.ok).toBe(true)
+      const payload = JSON.parse(result.output).data
+      expect(payload.cwd).toBe(invokeDir)
+    } finally {
+      fs.rmSync(invokeDir, { recursive: true, force: true })
+    }
+  })
+})

package/__tests__/help-json.test.js

@@ -4,11 +4,13 @@ describe("help-json", () => {
   test("includes plugins and hides sync when no server", () => {
     const data = buildCapabilities({ commands: [] }, false)
 
+    expect(data.commands.discover).toBeDefined()
     expect(data.commands.plugins).toBeDefined()
     expect(data.commands.plugins.subcommands).toEqual(expect.arrayContaining(["learn"]))
     expect(data.commands.mcp.subcommands).toEqual(expect.arrayContaining(["tools", "call", "bind", "doctor"]))
     expect(data.commands.sync).toBeUndefined()
     expect(data.flags["--help-json"]).toBeDefined()
+    expect(data.agent_onboarding.no_llm_discovery).toBe(true)
   })
 
   test("includes sync when server is available", () => {