wisp-agents 0.5.0 → 0.7.0

package/CHANGELOG.md

@@ -5,6 +5,39 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-10-17
+
+### Added
+
+- Update button next to Search when a newer `wisp-agents` is on npm (checked at start, then once a day while wisp stays open — survives sleep, and the UI re-asks on focus). One click runs `npm install -g wisp-agents@latest` (or relaunches through `npx …@latest`) and restarts wisp; it asks first if agents are running. Git checkouts just get the `git pull` hint. Opt out with `WISP_UPDATE_CHECK=0`.
+- Rerun a task: right-click a card → **Rerun…** (or `⇧R`, or ⌘K → Rerun). A dialog opens with the original prompt (editable), attachments and mode, plus the harness / model / thinking-level picker. You can pick a different setup without changing the launcher's defaults. Rerunning starts a new session in the same folder and keeps the original.
+- Learning from sessions: after a session goes quiet (90 s, or right away when marked done or archived), a background retro (same harness, read-only, no tools; Haiku on Claude Code) records your preferences and the agent's lessons (a mistake and the way that worked), globally and per project. Later turns get them in their system prompt. Stored in `~/.wisp/preferences.json`; API `GET/PUT /api/preferences`. See [Learning](README.md#learning).
+- Memory view (Settings → *Memory* → Open, or ⌘K → Memory): a tab per scope with preferences and lessons, the session that taught each item, a token estimate, and inline edit / add / forget. The *Retros* tab is a timeline of every retro run (last 30), including *nothing new* and failures with the reason, plus a live entry while one runs. Switching Memory off stops both learning and applying.
+
+### Fixed
+
+- The card you were reading stays in view after collapsing a section, and the open card is followed when it moves to another section.
+
+## [0.6.0] - 2026-10-17
+
+### Added
+
+- Antigravity CLI adapter (`agy --input-format stream-json --output-format stream-json`). Plan → `--mode plan`, Edits → `--mode accept-edits`, Full auto → `--dangerously-skip-permissions`; models from `agy models`, `--effort low|medium|high`, follow-ups via `--conversation`. Like Cursor it has no flag to inject MCP servers, so Antigravity agents ask with a `question` block. Override the binary with `WISP_ANTIGRAVITY_BIN`.
+- Integrations: wisp can now be driven by other agents, editors and scripts. Reference: [docs/integrations.md](docs/integrations.md).
+- `wisp mcp`: a stdio MCP server with `wisp_launch`, `wisp_wait`, `wisp_get`, `wisp_reply`, `wisp_list`, `wisp_stop` and `wisp_agents`, so Claude Code, Codex, opencode, Cursor or Claude Desktop can hand tasks to wisp and read the results.
+- Agent skill (`skills/wisp/SKILL.md`), installed with `wisp skill install [--agent claude|codex|opencode|all] [--project]`.
+- Scripting CLI: `wisp ls`, `show`, `wait`, `reply`, `stop`, plus `--json`, `--wait`, `--cwd`, `--model` and `--effort` on launches. Use `wisp -- …` for a task whose first word is a command name.
+- JS SDK: `import { WispClient } from 'wisp-agents'`. It connects to the running wisp (or starts a headless one) and covers launch, wait, reply, presentation, uploads and the event stream. `wisp-agents/render`, `/protocol` and `/server` are exported too.
+- HTTP API: `GET /api/health`, `GET /api/openapi.json` (OpenAPI 3.1), `GET /api/sessions/:id/wait` (long-poll until it finishes or asks), `GET /api/sessions/:id/presentation` (blocks + markdown, `?format=markdown`), and `state`/`agent`/`project`/`cwd`/`archived`/`limit` filters on `GET /api/sessions`.
+- `~/.wisp/server.json` advertises the running server's URL, port and pid.
+- Webhooks (`PATCH /api/config {"webhooks": [...]}`): POST `session.finished` / `session.waiting` with the presentation as markdown.
+
+### Fixed
+
+- Clicking a harness in the harness · model picker (or Enter on it) switches to it with the model and thinking level shown, instead of only previewing its models.
+- Antigravity models are listed with newer `agy` builds that print tab-separated `agy models` output.
+- A harness CLI installed while wisp is running is detected without restarting wisp.
+
 ## [0.5.0] - 2026-10-17
 
 ### Added
@@ -89,7 +122,9 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 - Session queue with follow-ups, answers to agent questions, terminal takeover and mark-as-done.
 - Older turns are folded, with a floating collapse-all button and back-to-top.
 
-[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.5.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/M0xoo/wisp/compare/v0.6.0...v0.7.0
+[0.6.0]: https://github.com/M0xoo/wisp/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/M0xoo/wisp/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/M0xoo/wisp/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/M0xoo/wisp/compare/v0.2.2...v0.3.0

package/README.md

@@ -13,9 +13,9 @@ Launch coding agents in the background, skip the transcript, and read the presen
 [![Node](https://img.shields.io/badge/node-%3E%3D20-339933?logo=node.js&logoColor=white)](https://nodejs.org)
 [![Electron](https://img.shields.io/badge/desktop-Electron-47848f?logo=electron&logoColor=white)](https://www.electronjs.org)
 [![Zero runtime deps](https://img.shields.io/badge/runtime%20deps-0-brightgreen)](package.json)
-[![Harnesses](https://img.shields.io/badge/harness-Claude%20Code%20·%20Codex%20·%20opencode%20·%20Cursor-d97757)](#adding-a-harness)
+[![Harnesses](https://img.shields.io/badge/harness-Claude%20Code%20·%20Codex%20·%20opencode%20·%20Cursor%20·%20Antigravity-d97757)](#adding-a-harness)
 
-[Quick start](#quick-start) · [Features](#features) · [CLI](#cli) · [Shortcuts](#keyboard-shortcuts) · [Architecture](#architecture) · [Adding a harness](#adding-a-harness) · [Roadmap](#roadmap)
+[Quick start](#quick-start) · [Features](#features) · [CLI](#cli) · [Integrations](#integrations) · [Shortcuts](#keyboard-shortcuts) · [Architecture](#architecture) · [Adding a harness](#adding-a-harness) · [Roadmap](#roadmap)
 
 </div>
 
@@ -23,7 +23,7 @@ Launch coding agents in the background, skip the transcript, and read the presen
 
 ## Why wisp?
 
-Agent transcripts are long, and you rarely need them. wisp runs agent harnesses (Claude Code, Codex, opencode, and Cursor) on your projects in the background. When an agent finishes, it hands you a short, animated **presentation**: diffs, test results, commits, flows, and decisions. The session then waits in your queue.
+Agent transcripts are long, and you rarely need them. wisp runs agent harnesses (Claude Code, Codex, opencode, Cursor, and Antigravity) on your projects in the background. When an agent finishes, it hands you a short, animated **presentation**: diffs, test results, commits, flows, and decisions. The session then waits in your queue.
 
 From there you can **follow up**, **answer its questions**, **take it over** in your terminal, or **mark it done**.
 
@@ -44,15 +44,17 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 | 📥 **A queue** | Sessions sort into *Needs you*, *Working* (with a live one-line status), and *Done*. Archive what you don't need to see. |
 | 💬 **Follow-ups that interrupt** | A follow-up sent mid-run interrupts the agent and resumes it with your message. Turn on **Queue** to wait for the run to finish instead; queued messages can be cancelled. |
 | 🔎 **Command palette** | `⌘K` / `Ctrl+K` fuzzy-searches sessions, projects, and actions. |
-| 🤖 **Any harness** | Claude Code, Codex, opencode, or Cursor CLI. Pick the harness, model and thinking level together in the launcher; both are remembered per harness. Each card shows the harness it ran on. |
+| 🤖 **Any harness** | Claude Code, Codex, opencode, Cursor CLI, or Antigravity CLI. Pick the harness, model and thinking level together in the launcher; both are remembered per harness. Each card shows the harness it ran on. |
 | 🖥️ **Take over** | Opens your terminal with the harness's resume command (`claude --resume <id>`, `codex resume <id>`, …) in the project folder. Works with Terminal, iTerm, Ghostty, Warp, cmux, kitty, WezTerm, GNOME Terminal, Konsole, Alacritty, Windows Terminal, PowerShell, or a custom command. |
 | 📎 **Attachments** | Paste screenshots or drop images, video, logs, or PDFs into the launcher. |
+| 🧠 **Learns as you go** | After a session goes quiet, a background retro records your preferences and the agent's lessons (a mistake and the way that worked), globally and per project. Later runs get them in their prompt. See [Learning](#learning). |
 | 🔐 **Permission modes** | Choose **Plan** (read-only), **Edits** (file edits auto-accepted), or **Full auto** for each launch. `Shift+Tab` in the prompt cycles modes. |
+| 🔌 **Integrations** | An MCP server (`wisp mcp`), an agent skill, a scriptable CLI, a JS SDK, an OpenAPI-described HTTP API, and webhooks. Hand tasks to wisp from Claude Code, Codex, opencode, Cursor, scripts or CI. |
 | 🪶 **No runtime dependencies** | The server uses only Node built-ins. Electron is needed only for the desktop app. |
 
 ## Quick start
 
-> **Requirements:** macOS, Linux, or Windows; Node.js ≥ 20; and at least one harness installed and signed in: [Claude Code](https://claude.com/claude-code) (`claude`), [Codex](https://github.com/openai/codex) (`codex`), [opencode](https://opencode.ai) (`opencode`), or [Cursor CLI](https://cursor.com/cli) (`cursor-agent`). Override a binary path with `WISP_CLAUDE_BIN`, `WISP_CODEX_BIN`, `WISP_OPENCODE_BIN`, or `WISP_CURSOR_BIN`.
+> **Requirements:** macOS, Linux, or Windows; Node.js ≥ 20; and at least one harness installed and signed in: [Claude Code](https://claude.com/claude-code) (`claude`), [Codex](https://github.com/openai/codex) (`codex`), [opencode](https://opencode.ai) (`opencode`), [Cursor CLI](https://cursor.com/cli) (`cursor-agent`), or [Antigravity CLI](https://antigravity.google/docs/cli/headless/) (`agy`). Override a binary path with `WISP_CLAUDE_BIN`, `WISP_CODEX_BIN`, `WISP_OPENCODE_BIN`, `WISP_CURSOR_BIN`, or `WISP_ANTIGRAVITY_BIN`.
 
 ```sh
 npx wisp-agents                          # open the wisp desktop app
@@ -101,20 +103,59 @@ wisp                              # open wisp (or focus the running one)
 wisp "fix the flaky auth test"    # launch a task in this folder (it becomes a project)
 wisp add [path]                   # add a folder as a project (default: cwd)
 wisp --mode plan "audit deps"     # permission mode: plan | edits | auto
-wisp --agent codex "add a test"   # harness: claude | codex | opencode | cursor
+wisp --agent codex "add a test"   # harness: claude | codex | opencode | cursor | antigravity
+```
+
+Scripting (every command takes `--json`):
+
+```sh
+wisp "add a test" --wait          # block until it finishes, print the presentation as markdown
+wisp ls --state running,waiting   # list sessions
+wisp show <id>                    # state + latest presentation
+wisp wait <id>                    # until it finishes or asks you something
+wisp reply <id> "also do X"       # follow up (answers a pending question)
+wisp stop <id>
+wisp mcp                          # MCP server for other agents and editors
+wisp skill install                # install the wisp skill for Claude Code (--agent all for Codex/opencode too)
 ```
 
 | Option | Description |
 |---|---|
 | `--port`, `-p N` | Port to use (default `4477`, or `WISP_PORT`) |
 | `--mode`, `-m` | `plan` · `edits` · `auto` |
-| `--agent`, `-a` | `claude` · `codex` · `opencode` · `cursor` (default: the agent last picked in the launcher) |
+| `--agent`, `-a` | `claude` · `codex` · `opencode` · `cursor` · `antigravity` (default: the agent last picked in the launcher) |
+| `--model` · `--effort` | Model id and thinking level for the launch |
+| `--cwd`, `-C DIR` | Project folder (default: the current one) |
+| `--wait`, `-w` | Wait for the run to finish or ask, then print the presentation |
+| `--json` | Machine-readable output |
 | `--browser`, `-b` | Use the browser instead of the desktop app |
 | `--no-open` | Just run the server; open nothing |
 | `--version`, `-v` | Print the version |
 
 > `npm install -g wisp-agents` (or `npm link` from a clone) puts `wisp` on your `PATH`. Without installing, use `npx wisp-agents …` with the same arguments.
 
+## Integrations
+
+wisp is a local server, and the app is just one client of it. Other agents, editors and scripts can launch tasks into the same queue and read the presentations back. Full reference: [docs/integrations.md](docs/integrations.md).
+
+```sh
+claude mcp add wisp -- npx -y wisp-agents mcp   # Claude Code can now delegate with wisp_launch / wisp_wait / wisp_reply
+wisp skill install --agent all                  # teach Claude Code, Codex and opencode when and how to use wisp
+```
+
+```js
+import { WispClient } from 'wisp-agents';
+const wisp = await WispClient.connect();
+const s = await wisp.launch({ prompt: 'fix the flaky auth test', cwd: '/path/to/repo' });
+console.log((await wisp.wait(s.id)).state, (await wisp.presentation(s.id)).markdown);
+```
+
+- **MCP** (`wisp mcp`): `wisp_launch`, `wisp_wait`, `wisp_get`, `wisp_reply`, `wisp_list`, `wisp_stop`, `wisp_agents`. Config snippets for Claude Code, Codex, opencode, Cursor and Claude Desktop are in the docs.
+- **Skill** ([`skills/wisp/SKILL.md`](skills/wisp/SKILL.md)): when to delegate, how to brief, and to pass a waiting agent's question on to you instead of answering it.
+- **HTTP API**: `GET /api/openapi.json`. The new routes are `/api/health`, `/api/sessions/:id/wait` (long-poll), `/api/sessions/:id/presentation` (blocks + markdown), and filters on `/api/sessions`.
+- **Discovery**: the running server writes `~/.wisp/server.json` (`url`, `port`, `pid`, `version`).
+- **Webhooks**: `PATCH /api/config {"webhooks":[…]}`. wisp POSTs `session.finished` and `session.waiting` with the presentation as markdown.
+
 ## Keyboard shortcuts
 
 | Key | Action |
@@ -146,6 +187,7 @@ web/ (UI) ⇄ HTTP + SSE ⇄ server/ ── adapters/claude.js   ── claude -
                                  ├─ adapters/codex.js    ── codex exec --json
                                  ├─ adapters/opencode.js ── opencode run --format json
                                  ├─ adapters/cursor.js   ── cursor-agent -p --output-format stream-json
+                                 ├─ adapters/antigravity.js ── agy --output-format stream-json
                                  └─ mcp-ask.js  (ask_user MCP tool, injected per run)
 ```
 
@@ -155,6 +197,10 @@ wisp/
 │   └── wisp.js            # CLI: starts the server or talks to the running one
 ├── server/
 │   ├── index.js           # HTTP API, SSE stream, static UI, uploads
+│   ├── openapi.js         # OpenAPI document for the public API
+│   ├── client.js          # JS SDK (wisp-agents/client), used by the CLI and MCP server
+│   ├── mcp-wisp.js        # `wisp mcp`: wisp as tools for other agents
+│   ├── render.js          # presentation → markdown
 │   ├── runner.js          # session lifecycle, follow-ups, event normalization
 │   ├── protocol.js        # system prompt + ```wisp block parser (markdown fallback)
 │   ├── mcp-ask.js         # ask_user MCP server
@@ -167,7 +213,9 @@ wisp/
 │       ├── claude.js      # Claude Code adapter
 │       ├── codex.js       # Codex CLI adapter
 │       ├── opencode.js    # opencode adapter
-│       └── cursor.js      # Cursor CLI adapter
+│       ├── cursor.js      # Cursor CLI adapter
+│       └── antigravity.js # Antigravity CLI adapter
+├── skills/wisp/SKILL.md   # agent skill: how other agents use wisp
 ├── web/                   # vanilla JS UI, no build step
 │   ├── index.html
 │   ├── css/app.css
@@ -201,6 +249,20 @@ If the harness has no system-prompt flag, prepend `systemPrompt` to the first pr
 - [x] Codex adapter
 - [x] opencode adapter
 - [x] Cursor CLI adapter
+- [x] Antigravity CLI adapter
+
+## Learning
+
+After a session has been quiet for 90 seconds (or right away when you mark it done or archive it), wisp runs a short **retro**: the same harness, read-only and without tools (Claude Code runs it on Haiku), reads a digest of the turns it hasn't seen yet. The digest holds your requests and follow-ups, questions and answers, failed tool calls and the commands run around them, and how each run ended. The retro then updates four small lists:
+
+| | Everywhere | This project |
+|---|---|---|
+| **Preferences**: how you like agents to work | report style, git habits, "never …" | tooling, conventions, areas to leave alone |
+| **Lessons**: a mistake and the way that worked | "use `python3`, not `python`" | "run tests with `node --test`; `npm test -- x` runs everything" |
+
+The retro gets the current lists along with the digest, so when you change your mind it rewrites or drops the old item instead of adding a contradicting one. Each list holds at most 10 items of 180 characters or less, and the digest is capped at 10k characters, so the prompt block stays small. Every later turn gets the lists in its system prompt, and the current request always wins over them.
+
+**Memory** (Settings → *Memory*, or `⌘K` → *Memory*) has a tab for each scope (Everywhere, then each project) with its preferences and lessons, the retro that taught each one, and an estimate of the tokens it adds to the prompt. You can edit, add or forget any item. The *Retros* tab is a timeline of every run: what it added or removed, *nothing new*, or why it failed. Switching Memory off stops both learning and applying. The data lives in `~/.wisp/preferences.json`, and the API is `GET/PUT /api/preferences`.
 
 ## Telemetry
 
@@ -228,7 +290,7 @@ npm test         # adapters, process launching, terminals, and the full ask_user
 npm run test:real  # smoke test against the real CLIs installed on this machine
 ```
 
-`npm test` needs no network or accounts. A fake CLI (`test/fixtures/fake-agent.mjs`) speaks each harness's real output format, edits files, and calls `ask_user` through the real MCP bridge. On Windows the fakes are installed as npm-style `.cmd` shims, which is how npm installs the real CLIs. CI (`.github/workflows/test.yml`) runs the suite on Linux, macOS, and Windows with Node 20 and 22, then runs `test:real` against freshly installed Claude Code, Codex, opencode, and Cursor CLIs.
+`npm test` needs no network or accounts. A fake CLI (`test/fixtures/fake-agent.mjs`) speaks each harness's real output format, edits files, and calls `ask_user` through the real MCP bridge. On Windows the fakes are installed as npm-style `.cmd` shims, which is how npm installs the real CLIs. CI (`.github/workflows/test.yml`) runs the suite on Linux, macOS, and Windows with Node 20 and 22, then runs `test:real` against freshly installed Claude Code, Codex, opencode, Cursor, and Antigravity CLIs.
 
 ## License
 

package/bin/wisp.js

@@ -1,100 +1,213 @@
 #!/usr/bin/env node
 // wisp — launcher + queue for coding agents.
 //
-//   wisp                   open the wisp desktop app (or focus the running one)
-//   wisp "fix the tests"   launch a wisp in the current folder
-//   wisp add [path]        add a folder as a project (default: current folder)
-//   --port N               port (default 4477, or WISP_PORT)
-//   --mode plan|edits|auto permission mode for a launch
-//   --agent ID             claude, codex, opencode or cursor (default: the launcher's pick)
-//   --browser              use the browser instead of the desktop app
-//   --no-open              just run the server, open nothing
+//   wisp                       open the wisp desktop app (or focus the running one)
+//   wisp "fix the tests"       launch a wisp in the current folder
+//   wisp add [path]            add a folder as a project (default: current folder)
+//   wisp ls | show | wait | reply | stop    script sessions (see --help)
+//   wisp mcp                   stdio MCP server, so other agents and editors can use wisp
+//   wisp skill [install]       the agent skill that teaches other agents to use wisp
 
 import { exec, spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import fs, { existsSync } from 'node:fs';
+import os from 'node:os';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { wispAppBinary } from './mac-app.js';
 
+const HELP = `usage:
+  wisp                          open wisp
+  wisp "task"                   launch a task in this folder
+  wisp add [path]               add a project
+  wisp ls                       list sessions        (--state running,waiting  --limit N)
+  wisp show <id>                state + latest presentation as markdown
+  wisp wait <id>                block until it finishes or asks you something
+  wisp reply <id> "text"        follow up (answers a pending question)   (--queue)
+  wisp stop <id>                stop a run
+  wisp mcp                      run the MCP server (stdio) for other agents and editors
+  wisp skill [install]          print / install the wisp agent skill   (--agent claude|codex|opencode|all  --project)
+  wisp -- "ls the repo"         a task that starts with a command name
+
+launch options: --mode plan|edits|auto  --agent claude|codex|opencode|cursor|antigravity  --model ID  --effort LEVEL
+                --cwd DIR  --wait  --json
+options:        --port N  --browser  --no-open  --json  --version`;
+
+const COMMANDS = new Set(['add', 'ls', 'list', 'show', 'wait', 'reply', 'stop', 'mcp', 'skill']);
 const argv = process.argv.slice(2);
-const flags = { open: true, browser: false, port: Number(process.env.WISP_PORT) || 4477, mode: null, agent: null };
+const flags = { open: true, browser: false, port: Number(process.env.WISP_PORT) || 4477, mode: null, agent: null, model: null, effort: null, cwd: null, json: false, wait: false, queue: undefined, state: null, limit: null, project: false };
 const words = [];
+let literal = false;
 for (let i = 0; i < argv.length; i++) {
   const a = argv[i];
-  if (a === '--no-open') flags.open = false;
+  if (literal) words.push(a);
+  else if (a === '--') literal = words.length === 0 ? 'task' : true;
+  else if (a === '--no-open') flags.open = false;
   else if (a === '--browser' || a === '-b') flags.browser = true;
   else if (a === '--port' || a === '-p') flags.port = Number(argv[++i]);
   else if (a === '--mode' || a === '-m') flags.mode = argv[++i];
   else if (a === '--agent' || a === '-a') flags.agent = argv[++i];
+  else if (a === '--model') flags.model = argv[++i];
+  else if (a === '--effort') flags.effort = argv[++i];
+  else if (a === '--cwd' || a === '-C') flags.cwd = path.resolve(argv[++i].replace(/^~(?=$|[\\/])/, os.homedir()));
+  else if (a === '--state') flags.state = argv[++i];
+  else if (a === '--limit') flags.limit = Number(argv[++i]);
+  else if (a === '--json') flags.json = true;
+  else if (a === '--wait' || a === '-w') flags.wait = true;
+  else if (a === '--queue') flags.queue = true;
+  else if (a === '--project') flags.project = true;
   else if (a === '--version' || a === '-v') {
-    const { readFileSync } = await import('node:fs');
-    console.log(JSON.parse(readFileSync(new URL('../package.json', import.meta.url))).version);
+    console.log(JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url))).version);
     process.exit(0);
   } else if (a === '--help' || a === '-h') {
-    console.log('usage:\n  wisp                    open wisp\n  wisp "task"             launch a task in this folder\n  wisp add [path]         add a project\n\noptions: --port N  --mode plan|edits|auto  --agent claude|codex|opencode|cursor  --browser  --no-open  --version');
+    console.log(HELP);
     process.exit(0);
   } else words.push(a);
 }
+const command = literal !== 'task' && COMMANDS.has(words[0]) ? words[0] : null;
+const cwd = flags.cwd || process.cwd();
+const die = (msg) => {
+  console.error(`  ✗ ${msg}`);
+  process.exit(1);
+};
 
-const base = `http://localhost:${flags.port}`;
-const api = (p, body) =>
-  fetch(`${base}/api${p}`, {
-    method: body ? 'POST' : 'GET',
-    headers: { 'content-type': 'application/json' },
-    body: body ? JSON.stringify(body) : undefined,
-  }).then(async (r) => {
-    const j = await r.json();
-    if (!r.ok) throw new Error(j.error || r.statusText);
-    return j;
-  });
-
-let running = false;
-try {
-  await api('/config');
-  running = true;
-} catch {}
-
-// The desktop app (Electron is an optional dependency) runs the server in its own process, so
-// it outlives this terminal. Without Electron, or with --browser/--no-open, serve from here.
-// A task or `add` sent to an already-running wisp just goes over the API, no window.
-const electron = flags.open && !flags.browser && (!running || !words.length) ? electronBinary() : null;
-if (electron) {
-  const child = spawn(electron, [fileURLToPath(new URL('..', import.meta.url))], {
-    detached: true,
-    stdio: 'ignore',
-    env: { ...process.env, WISP_PORT: String(flags.port) },
-  });
-  child.unref();
-  if (!running) await waitForServer();
-  console.log(`\n  ◌ wisp is open\n`);
-} else if (!running) {
-  const { startServer } = await import('../server/index.js');
-  await startServer({ port: flags.port });
-  console.log(`\n  ◌ wisp is floating at ${base}\n`);
+// --- commands that only talk to the API (and start a headless wisp if none is running) ---
+
+if (command === 'mcp') {
+  const { serveMcp } = await import('../server/mcp-wisp.js');
+  serveMcp(); // stdout belongs to the MCP protocol from here on
+} else if (command === 'skill') {
+  skill(words[1]);
+} else if (command && command !== 'add') {
+  await scripted(command, words.slice(1)).catch((e) => die(e.message));
+} else if (!command && words.length && (flags.json || flags.wait)) {
+  await scripted('launch', words).catch((e) => die(e.message));
+} else {
+  await interactive();
 }
 
-let openPath = '/';
-if (words[0] === 'add') {
-  const dir = path.resolve(words[1] || process.cwd());
-  const p = await api('/projects', { path: dir }).catch((e) => console.error(`  ✗ ${e.message}`));
-  if (p) console.log(`  ✓ project added: ${p.name}  (${p.path})`);
-  if (running || electron) process.exit(0);
-} else if (words.length) {
-  const cfg = await api('/config');
-  const agent = flags.agent || cfg.defaults.agent;
-  // Models are remembered per agent (ids aren't portable between harnesses).
-  const model = cfg.defaults.models?.[agent] ?? (agent === cfg.defaults.agent ? cfg.defaults.model : '');
-  const s = await api('/sessions', { prompt: words.join(' '), cwd: process.cwd(), agent, mode: flags.mode || cfg.defaults.mode, model });
-  console.log(`  ◌ launched: ${s.title}`);
-  openPath = `/#/s/${s.id}`;
-  if (running || electron) process.exit(0); // the running wisp will show it in the queue
+async function scripted(cmd, args) {
+  const { WispClient } = await import('../server/client.js');
+  const wisp = await WispClient.connect({ port: argv.some((a) => a === '--port' || a === '-p') ? flags.port : undefined });
+  const out = (v, text) => console.log(flags.json ? JSON.stringify(v, null, 2) : text);
+  const need = (v, what) => v || die(`${what} required — see wisp --help`);
+  const show = async (id, summary) => {
+    const p = await wisp.presentation(id);
+    const s = summary || (await wisp.sessions()).find((x) => x.id === id);
+    out({ ...s, presentation: p }, `◌ ${s?.title}  [${s?.state}${summary?.timedOut ? ', still running' : ''}]  ${id}\n\n${p.markdown}`);
+  };
+  switch (cmd) {
+    case 'launch': {
+      const s = await wisp.launch({ prompt: args.join(' '), cwd, agent: flags.agent || undefined, mode: flags.mode || undefined, model: flags.model ?? undefined, effort: flags.effort ?? undefined });
+      if (!flags.wait) return out(s, `  ◌ launched: ${s.title}  (${s.id})`);
+      if (!flags.json) console.error(`  ◌ launched: ${s.title}  (${s.id}) — waiting…`);
+      return show(s.id, await wisp.wait(s.id));
+    }
+    case 'ls':
+    case 'list': {
+      const list = await wisp.sessions({ state: flags.state, limit: flags.limit, cwd: flags.cwd || undefined, archived: flags.state ? undefined : false });
+      return out(list, list.map((s) => `${s.id}  ${s.state.padEnd(7)}  ${s.agent.padEnd(8)}  ${s.project.padEnd(16).slice(0, 16)}  ${s.title}${s.question ? `  — asks: ${s.question}` : ''}`).join('\n') || 'No sessions.');
+    }
+    case 'show':
+      return show(need(args[0], 'session id'));
+    case 'wait': {
+      const id = need(args[0], 'session id');
+      return show(id, await wisp.wait(id));
+    }
+    case 'reply': {
+      const id = need(args[0], 'session id');
+      const r = await wisp.reply(id, need(args.slice(1).join(' ').trim(), 'text'), { queue: flags.queue });
+      if (!flags.wait) return out(r, r.answered ? '  ✓ answered' : r.interrupted ? '  ✓ interrupted; resuming with your message' : r.queued ? '  ✓ queued' : '  ✓ sent');
+      return show(id, await wisp.wait(id));
+    }
+    case 'stop':
+      return out(await wisp.stop(need(args[0], 'session id')), '  ✓ stopped');
+  }
 }
 
-if (electron) process.exit(0);
-if (flags.open) {
-  const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start ""' : 'xdg-open';
-  exec(`${cmd} "${base}${openPath}"`);
+// Installs skills/wisp/SKILL.md where each harness looks for skills.
+function skill(sub) {
+  const src = fileURLToPath(new URL('../skills/wisp/SKILL.md', import.meta.url));
+  if (sub !== 'install') return process.stdout.write(fs.readFileSync(src, 'utf8'));
+  const home = os.homedir();
+  const base = flags.project ? cwd : null;
+  const targets = {
+    claude: base ? path.join(base, '.claude', 'skills') : path.join(home, '.claude', 'skills'),
+    codex: base ? path.join(base, '.codex', 'skills') : path.join(process.env.CODEX_HOME || path.join(home, '.codex'), 'skills'),
+    opencode: base ? path.join(base, '.opencode', 'skill') : path.join(process.env.XDG_CONFIG_HOME || path.join(home, '.config'), 'opencode', 'skill'),
+  };
+  const which = !flags.agent ? ['claude'] : flags.agent === 'all' ? Object.keys(targets) : [flags.agent];
+  for (const a of which) {
+    if (!targets[a]) die(`no skill location for ${a} (try claude, codex, opencode or all)`);
+    const dir = path.join(targets[a], 'wisp');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.copyFileSync(src, path.join(dir, 'SKILL.md'));
+    console.log(`  ✓ ${a}: ${path.join(dir, 'SKILL.md')}`);
+  }
+}
+
+// --- the original flow: open the app, launch from the terminal, add projects ---
+
+async function interactive() {
+  const base = `http://localhost:${flags.port}`;
+  const api = (p, body) =>
+    fetch(`${base}/api${p}`, {
+      method: body ? 'POST' : 'GET',
+      headers: { 'content-type': 'application/json' },
+      body: body ? JSON.stringify(body) : undefined,
+    }).then(async (r) => {
+      const j = await r.json();
+      if (!r.ok) throw new Error(j.error || r.statusText);
+      return j;
+    });
+
+  let running = false;
+  try {
+    await api('/config');
+    running = true;
+  } catch {}
+
+  // The desktop app (Electron is an optional dependency) runs the server in its own process, so
+  // it outlives this terminal. Without Electron, or with --browser/--no-open, serve from here.
+  // A task or `add` sent to an already-running wisp just goes over the API, no window.
+  const electron = flags.open && !flags.browser && (!running || !words.length) ? electronBinary() : null;
+  if (electron) {
+    const child = spawn(electron, [fileURLToPath(new URL('..', import.meta.url))], {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...process.env, WISP_PORT: String(flags.port) },
+    });
+    child.unref();
+    if (!running) await waitForServer(api);
+    console.log(`\n  ◌ wisp is open\n`);
+  } else if (!running) {
+    const { startServer } = await import('../server/index.js');
+    await startServer({ port: flags.port });
+    console.log(`\n  ◌ wisp is floating at ${base}\n`);
+  }
+
+  let openPath = '/';
+  if (command === 'add') {
+    const dir = path.resolve(words[1] || process.cwd());
+    const p = await api('/projects', { path: dir }).catch((e) => console.error(`  ✗ ${e.message}`));
+    if (p) console.log(`  ✓ project added: ${p.name}  (${p.path})`);
+    if (running || electron) process.exit(0);
+  } else if (words.length) {
+    const cfg = await api('/config');
+    const agent = flags.agent || cfg.defaults.agent;
+    // Models are remembered per agent (ids aren't portable between harnesses).
+    const model = flags.model ?? cfg.defaults.models?.[agent] ?? (agent === cfg.defaults.agent ? cfg.defaults.model : '');
+    const s = await api('/sessions', { prompt: words.join(' '), cwd, agent, mode: flags.mode || cfg.defaults.mode, model, effort: flags.effort || '' });
+    console.log(`  ◌ launched: ${s.title}`);
+    openPath = `/#/s/${s.id}`;
+    if (running || electron) process.exit(0); // the running wisp will show it in the queue
+  }
+
+  if (electron) process.exit(0);
+  if (flags.open) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start ""' : 'xdg-open';
+    exec(`${cmd} "${base}${openPath}"`);
+  }
 }
 
 function electronBinary() {
@@ -107,7 +220,7 @@ function electronBinary() {
   }
 }
 
-async function waitForServer() {
+async function waitForServer(api) {
   for (let i = 0; i < 150; i++) {
     try {
       return await api('/config');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wisp-agents",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Launch coding agents, skip the transcript, read the presentation.",
   "type": "module",
   "bin": {
@@ -12,6 +12,7 @@
     "CHANGELOG.md",
     "electron/",
     "server/",
+    "skills/",
     "web/"
   ],
   "scripts": {
@@ -19,9 +20,9 @@
     "app": "node bin/wisp.js",
     "dev": "WISP_DEV=1 node bin/wisp.js",
     "dev:web": "node --watch-path=server bin/wisp.js --no-open",
-    "test": "node --test test/proc.test.js test/terminal.test.js test/adapters.test.js test/e2e.test.js test/fuzzy.test.js",
+    "test": "node --test test/proc.test.js test/terminal.test.js test/adapters.test.js test/e2e.test.js test/fuzzy.test.js test/integrations.test.js test/update.test.js test/learn.test.js",
     "test:real": "node test/real-clis.mjs",
-    "prepublishOnly": "node --check bin/wisp.js && node --check bin/mac-app.js && node -e \"import('./server/index.js')\" && node --check electron/main.js"
+    "prepublishOnly": "node --check bin/wisp.js && node --check bin/mac-app.js && node -e \"import('./server/index.js').then(() => import('./server/mcp-wisp.js'))\" && node --check electron/main.js"
   },
   "engines": {
     "node": ">=20"
@@ -33,7 +34,9 @@
     "ai",
     "agents",
     "cli",
-    "launcher"
+    "launcher",
+    "mcp",
+    "sdk"
   ],
   "author": "M0xoo",
   "license": "MIT",
@@ -46,6 +49,14 @@
     "url": "https://github.com/M0xoo/wisp/issues"
   },
   "main": "electron/main.js",
+  "exports": {
+    ".": "./server/client.js",
+    "./client": "./server/client.js",
+    "./server": "./server/index.js",
+    "./protocol": "./server/protocol.js",
+    "./render": "./server/render.js",
+    "./package.json": "./package.json"
+  },
   "optionalDependencies": {
     "electron": "^44.8.0"
   }