wisp-agents 0.8.0 → 0.10.0

package/CHANGELOG.md

@@ -5,6 +5,38 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-10-18
+
+### Added
+
+- Machines finds hosts for you. **Found on this computer** lists the hosts this computer already reaches: `Host` entries in `~/.ssh/config`, your Tailscale peers (`tailscale status --json`, with an online dot; phones and tablets are skipped) and hosts in `~/.ssh/known_hosts` (code hosts such as github.com, hashed entries and non-default ports are skipped). Hosts you've already added aren't listed. Click one to fill in the form, then press Connect. The SSH host field suggests the same hosts. API: `GET /api/machines/discover`.
+
+### Changed
+
+- Ship it only shows when there is something to ship. It used to sit on every finished worktree task, even one that changed nothing or whose work was already on its PR. Now it appears (on the card bar, next to the composer, in the right-click menu, in ⌘K and on `S`) only if the worktree has uncommitted changes or commits its PR doesn't have yet. **Push to PR #N** shows only when there are new changes to push. wisp checks the worktree when a turn ends, after Ship it, a revert, a rollback or an action command, and at startup. Summaries carry it as `toShip: { dirty, ahead, unpushed }`.
+
+### Fixed
+
+- Updating from the top-bar Update button now restarts wisp on the port it was running on. Before, a wisp started with `--port` came back on 4477 and the open tab said "wisp did not come back".
+
+## [0.9.0] - 2026-10-18
+
+### Added
+
+- Machines: run agents on your other computers (a dev box, a GPU server, a cloud VM) over SSH. **Machines** in the top bar (also Settings → *Machines*, ⌘K) takes an SSH host (suggested from `~/.ssh/config`) and connects: wisp signs in with your keys, finds Node.js there, starts `npx -y wisp-agents@<this version>` detached (or reuses the wisp already running), and opens an `ssh -L` tunnel back. Each step shows live, and a failure says what to run (`ssh-copy-id`, install Node, restart an older wisp). Then pick projects on the machine (its git repos are listed, folders autocomplete). The launcher's **Run on** button (next to the harness) picks where a prompt goes: this computer, a machine, or several at once. Each place gets its own row of project chips, and one Enter launches on all of them in parallel, as one task card with a row per machine (its own project, badge and status) and a single "ready on 3 machines" toast. A machine picked while disconnected connects. Each run executes the agent on its machine, with worktrees, diffs, rollback, `ask_user`, subagents, compare and Ship it working as usual. Its sessions join your feed with a machine badge, answer questions from your phone like any other, open in VS Code / Cursor / Windsurf over Remote - SSH, and **Take over** opens `ssh -t` in your terminal. Nothing new listens on the network: wisp over there stays on its own loopback, keeps running (agents too) when this computer sleeps, and wisp reconnects when it wakes. API: `/api/machines`, `machine` and `groupId` (to group runs launched in several places) on `POST /sessions`, `machine` on `/projects`; remote sessions are `<id>@<machine>` everywhere (CLI, SDK, MCP).
+- Grok Build harness (`grok`, `--agent grok`). wisp runs `grok --output-format streaming-messages-json` headless. It lists the models from `grok models` with each model's thinking levels (Low to X-High), maps Plan / Edits / Full auto to grok's permission modes, and resumes follow-ups with `--resume`. Grok can lead a team of subagents, and it asks you questions through wisp's `ask_user`. The tool reaches grok through a throwaway `--agent` definition that keeps grok's stock prompt. Diffs come from `search_replace` and `write`. Cost shows in Usage when grok reports it.
+
+### Changed
+
+- The launcher's Recipes row no longer has a Manage link. Recipes are still one click away from the Automations button in the top bar.
+- Every text field, textarea, select and checkbox now shares one look from a small form kit in `web/css/app.css` (`.input`, `.textarea`, `.field`, `.check`, plus `.mono` / `.sm` / `.lg`): the same border, radius, height, placeholder colour, hover and focus ring across Settings, Phone, Automations, Ship it, Run recipe, Projects, the model picker search, the Subagents editor and question cards. Checkboxes use the accent colour.
+
+### Fixed
+
+- A lead with subagents now uses them instead of its harness's built-in subagents. Claude Code leads run with `Task`, `Agent` and `Workflow` disallowed, opencode leads with `permission.task: "deny"`, and every lead is told to use `delegate` in place of its own subagent tool. Without a team, nothing changes.
+- The selects in the recipe and trigger forms and in the Ship it / Run dialogs had lost their dropdown chevron.
+- Settings and Phone text fields, and every select, showed no focus state.
+
 ## [0.8.0] - 2026-10-17
 
 ### Added
@@ -158,7 +190,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.8.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.10.0...HEAD
+[0.10.0]: https://github.com/M0xoo/wisp/compare/v0.9.0...v0.10.0
+[0.9.0]: https://github.com/M0xoo/wisp/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/M0xoo/wisp/compare/v0.7.0...v0.8.0
 [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

package/README.md

@@ -13,7 +13,7 @@ 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%20·%20Antigravity-d97757)](#adding-a-harness)
+[![Harnesses](https://img.shields.io/badge/harness-Claude%20Code%20·%20Codex%20·%20opencode%20·%20Cursor%20·%20Antigravity%20·%20Grok-d97757)](#adding-a-harness)
 
 [Quick start](#quick-start) · [Features](#features) · [CLI](#cli) · [Integrations](#integrations) · [Shortcuts](#keyboard-shortcuts) · [Architecture](#architecture) · [Adding a harness](#adding-a-harness) · [Roadmap](#roadmap)
 
@@ -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, 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.
+Agent transcripts are long, and you rarely need them. wisp runs agent harnesses (Claude Code, Codex, opencode, Cursor, Antigravity, and Grok) 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,7 +44,7 @@ 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, 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. |
+| 🤖 **Any harness** | Claude Code, Codex, opencode, Cursor CLI, Antigravity CLI, or Grok Build. 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). |
@@ -53,7 +53,7 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 | 🤝 **Subagents** | Give the lead agent a team on other harnesses (e.g. Claude Code hands tests to Codex ×3). It delegates through a `delegate` tool; their edits land in its worktree. See [Subagents](#subagents). |
 | ⏪ **Checkpoints & rollback** | Every turn is snapshotted first. Restore to before any turn, revert a single file, or re-run a command block from the presentation. |
 | ⚖️ **Compare** | Run one task on two harnesses side by side, and keep the better run. |
-| 🧾 **Recipes & triggers** | Saved prompts with `{params}` (`wisp run release 0.8.0`), run by hand, on a schedule, when CI fails, or when an issue is labelled. |
+| 🧾 **Recipes & triggers** | Saved prompts with `{params}` (`wisp run release 0.10.0`), run by hand, on a schedule, when CI fails, or when an issue is labelled. |
 | 📊 **Usage** | Spend, success rate and questions per project and per harness · model. |
 | 📱 **Phone** | Questions and finished tasks on ntfy or Telegram; answer from there. |
 | 🔐 **Permission modes** | Choose **Plan** (read-only), **Edits** (file edits auto-accepted), or **Full auto** for each launch. `Shift+Tab` in the prompt cycles modes. |
@@ -62,7 +62,7 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 
 ## 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`), [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`.
+> **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`), [Antigravity CLI](https://antigravity.google/docs/cli/headless/) (`agy`), or [Grok Build](https://x.ai/cli) (`grok`). 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
@@ -111,7 +111,7 @@ 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 | antigravity
+wisp --agent codex "add a test"   # harness: claude | codex | opencode | cursor | antigravity | grok
 ```
 
 Scripting (every command takes `--json`):
@@ -125,7 +125,7 @@ wisp reply <id> "also do X"       # follow up (answers a pending question)
 wisp stop <id>
 wisp ship <id> [--draft]          # commit, push and open a PR for a worktree task
 wisp merge <id>                   # squash-merge its PR, fast-forward your local main
-wisp run release 0.8.0            # run a recipe; values fill its {params} (or version=0.8.0)
+wisp run release 0.10.0            # run a recipe; values fill its {params} (or version=0.10.0)
 wisp recipes                      # list recipes
 wisp usage [--days 7]             # spend and outcomes
 wisp mcp                          # MCP server for other agents and editors
@@ -136,7 +136,7 @@ wisp skill install                # install the wisp skill for Claude Code (--ag
 |---|---|
 | `--port`, `-p N` | Port to use (default `4477`, or `WISP_PORT`) |
 | `--mode`, `-m` | `plan` · `edits` · `auto` |
-| `--agent`, `-a` | `claude` · `codex` · `opencode` · `cursor` · `antigravity` (default: the agent last picked in the launcher) |
+| `--agent`, `-a` | `claude` · `codex` · `opencode` · `cursor` · `antigravity` · `grok` (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 |
@@ -206,6 +206,7 @@ web/ (UI) ⇄ HTTP + SSE ⇄ server/ ── adapters/claude.js   ── claude -
                                  ├─ 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
+                                 ├─ adapters/grok.js     ── grok --output-format streaming-messages-json
                                  └─ mcp-ask.js  (ask_user MCP tool, injected per run)
 ```
 
@@ -228,6 +229,7 @@ wisp/
 │   ├── recipes.js         # saved prompts with {params}
 │   ├── triggers.js        # cron schedules and GitHub watchers
 │   ├── remote.js          # phone: ntfy and Telegram, out and back
+│   ├── machines.js        # other computers: SSH, a tunnel to wisp there, relayed sessions
 │   ├── usage.js           # spend and outcomes
 │   ├── terminal.js        # "take over" in your terminal
 │   ├── welcome.js         # the gallery session
@@ -238,7 +240,8 @@ wisp/
 │       ├── codex.js       # Codex CLI adapter
 │       ├── opencode.js    # opencode adapter
 │       ├── cursor.js      # Cursor CLI adapter
-│       └── antigravity.js # Antigravity CLI adapter
+│       ├── antigravity.js # Antigravity CLI adapter
+│       └── grok.js        # Grok Build adapter
 ├── skills/wisp/SKILL.md   # agent skill: how other agents use wisp
 ├── web/                   # vanilla JS UI, no build step
 │   ├── index.html
@@ -274,6 +277,7 @@ If the harness has no system-prompt flag, prepend `systemPrompt` to the first pr
 - [x] opencode adapter
 - [x] Cursor CLI adapter
 - [x] Antigravity CLI adapter
+- [x] Grok Build adapter
 
 ## Worktrees and shipping
 
@@ -287,7 +291,7 @@ Turn worktrees off in Settings → *Worktree per task*, with the launcher's **Wo
 
 ## Subagents
 
-The launcher's **Subagents** button gives the lead agent a team: up to 6 members, each with its own harness, model, thinking level, name, a **Use for** note that tells the lead when to pick it, and a **×N** copies count (`Codex ×3` → `codex#1`…`codex#3`). The lead gets a `delegate` tool on wisp's MCP server; tasks sent in one call run in parallel in the lead's folder, and delegating to the same member again resumes its conversation. Claude Code, Codex and opencode can lead; Cursor and Antigravity can be members. **Save as preset** stores a team for later. Subagent edits count as the lead's, so they show up in its diffs, rollback and Ship it. API: `subagents` / `preset` on `POST /sessions`, `/teams`.
+The launcher's **Subagents** button gives the lead agent a team: up to 6 members, each with its own harness, model, thinking level, name, a **Use for** note that tells the lead when to pick it, and a **×N** copies count (`Codex ×3` → `codex#1`…`codex#3`). The lead gets a `delegate` tool on wisp's MCP server; tasks sent in one call run in parallel in the lead's folder, and delegating to the same member again resumes its conversation. Claude Code, Codex, opencode and Grok can lead; Cursor and Antigravity can be members. **Save as preset** stores a team for later. Subagent edits count as the lead's, so they show up in its diffs, rollback and Ship it. API: `subagents` / `preset` on `POST /sessions`, `/teams`.
 
 ## Checkpoints and rollback
 
@@ -301,7 +305,7 @@ Before each turn, wisp snapshots the git working tree (pinned at `refs/wisp/chec
 Prepare release {version}: update CHANGELOG, README and docs/, bump package.json, tag v{version}.
 ```
 
-Make one from ⌘K → *Recipes*, or *Save as recipe…* on any card. A recipe may pin a project, harness, model and mode. Run it from ⌘K (*Run: Release*), from the Recipes view, or from a terminal: `wisp run release 0.8.0` fills the fields in order, `wisp run release version=0.8.0` by name.
+Make one from ⌘K → *Recipes*, or *Save as recipe…* on any card. A recipe may pin a project, harness, model and mode. Run it from ⌘K (*Run: Release*), from the Recipes view, or from a terminal: `wisp run release 0.10.0` fills the fields in order, `wisp run release version=0.10.0` by name.
 
 **Triggers** launch sessions on their own while wisp is open (⌘K → *Triggers*):
 
@@ -315,7 +319,7 @@ GitHub triggers poll with your `gh` login (every 2–60 minutes), so nothing has
 
 ## Usage
 
-⌘K → *Usage* shows spend per day and, per project and per harness · model: spend, turns, how often the run worked (finished, not partial or blocked), how often the agent had to ask you, and the average time. Claude Code and opencode report cost; Codex, Cursor and Antigravity only report tokens, so their turns are counted but not priced. Also `wisp usage` and `GET /api/usage?days=30`.
+⌘K → *Usage* shows spend per day and, per project and per harness · model: spend, turns, how often the run worked (finished, not partial or blocked), how often the agent had to ask you, and the average time. Claude Code, opencode and Grok report cost (Grok only when its plan does); Codex, Cursor and Antigravity only report tokens, so their turns are counted but not priced. Also `wisp usage` and `GET /api/usage?days=30`.
 
 ## Phone
 
@@ -326,6 +330,18 @@ Settings → *Phone* sends questions and finished tasks to your phone and takes
 
 They receive titles, summaries and questions (with their context), never code or diffs.
 
+## Machines
+
+**Machines** (top bar, Settings → *Machines*, or ⌘K) runs agents on your other computers over SSH. Give it `user@host` or a `Host` from `~/.ssh/config` and press **Connect**:
+
+1. wisp signs in with `ssh` using your keys, agent and config (never a password; `BatchMode=yes`, new host keys are trusted on first use).
+2. On the machine it finds Node.js 20+ and starts `npx -y wisp-agents@<this version> --no-open` detached, or reuses the wisp already answering on its port (4477 by default).
+3. It forwards a free local port to that wisp with `ssh -L` and relays its event stream.
+
+Then **Pick projects on it**: the machine's git repos are listed, and folders autocomplete. In the launcher, **Run on** (next to the harness) picks where the prompt goes: this computer, any machine, or several at once. Each place shows its own project chips; Enter launches on all of them in parallel, and the runs land as one task with a row per machine. Each run executes on its machine, with worktrees, diffs, rollback, `ask_user`, subagents, compare and Ship it all working on that machine. Its sessions join your feed with a badge, answer from your phone like any other, open in VS Code, Cursor or Windsurf through Remote - SSH, and **Take over** opens `ssh -t <host>` resuming the agent in your terminal.
+
+Nothing new listens on the network: wisp on the machine stays on its own `127.0.0.1`, and it keeps running (agents too) when this computer sleeps or disconnects; wisp reconnects on its own. **Stop wisp there** (the machine's ⋯ menu) stops it. The machine needs Node.js 20+ and the harness CLIs, signed in. Sessions there are `<id>@<machine>` in the API, CLI, SDK and MCP; recipes and schedules work with machine projects, while CI and issue triggers, usage and memory stay per machine.
+
 ## 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:

package/bin/wisp.js

@@ -35,7 +35,7 @@ const HELP = `usage:
   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
+launch options: --mode plan|edits|auto  --agent claude|codex|opencode|cursor|antigravity|grok  --model ID  --effort LEVEL
                 --cwd DIR  --wait  --json  --no-worktree  --compare agent[:model],…
 options:        --port N  --browser  --no-open  --json  --version`;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wisp-agents",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Launch coding agents, skip the transcript, read the presentation.",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "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/integrations.test.js test/update.test.js test/learn.test.js test/ship.test.js test/subagents.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/ship.test.js test/subagents.test.js test/machines.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').then(() => import('./server/mcp-wisp.js'))\" && node --check electron/main.js"
   },

package/server/adapters/claude.js

@@ -35,7 +35,7 @@ export default {
   },
 
   // Returns { stop(), done: Promise<void> }. Everything else is reported through onEvent.
-  run({ prompt, attachments = [], cwd, resumeId, mode, model, effort, systemPrompt, mcpServers = {}, onEvent }) {
+  run({ prompt, attachments = [], cwd, resumeId, mode, model, effort, systemPrompt, mcpServers = {}, delegating = false, onEvent }) {
     const args = [
       '-p',
       '--output-format', 'stream-json',
@@ -49,6 +49,8 @@ export default {
       args.push('--mcp-config', JSON.stringify({ mcpServers }));
       args.push('--allowedTools', ...Object.keys(mcpServers).map((n) => `mcp__${n}`));
     }
+    // Its built-in subagents (Task, or Agent in newer versions) would bypass the user's team.
+    if (delegating) args.push('--disallowedTools', 'Task', 'Agent', 'Workflow');
     const dirs = [...new Set(attachments.map((a) => path.dirname(a.path)))];
     if (dirs.length) args.push('--add-dir', ...dirs);
     args.push('--verbose'); // terminates the variadic flags above

package/server/adapters/grok.js

@@ -0,0 +1,251 @@
+// Grok Build adapter — drives `grok --prompt-file … --output-format streaming-messages-json`
+// (Claude Code's stream-json shape, with grok's own tool names).
+//
+// grok has no flag for an extra MCP server (and its GROK_CONFIG overlay can't add one), but an
+// agent definition passed with `--agent <file>` can declare `mcpServers`. So each turn writes a
+// throwaway agent file that inherits the full stock prompt and only adds wisp's server; the model
+// reaches it through grok's `use_tool` as `wisp__ask_user`. The protocol goes in with `--rules`.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { ASK_TIMEOUT_MS, attachmentNote, clip, detectVersion, fileTracker, flatten, quietOutput, rel, spawnJsonl } from './common.js';
+
+const BIN = process.env.WISP_GROK_BIN || 'grok';
+
+const PERMISSION_MODES = {
+  plan: 'plan',
+  edits: 'acceptEdits',
+  auto: 'bypassPermissions',
+};
+const EFFORT_ORDER = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+
+export default {
+  id: 'grok',
+  name: 'Grok',
+  askTool: 'wisp__ask_user',
+  models: [{ id: '', label: 'Default', hint: 'Whatever Grok is set to' }],
+  efforts: ['low', 'medium', 'high', 'xhigh'],
+
+  resumeCommand({ resumeId, model, effort }) {
+    return [BIN, ...(resumeId ? ['--resume', resumeId] : []), ...(model ? ['--model', model] : []), ...(effort ? ['--reasoning-effort', effort] : [])];
+  },
+
+  async detect() {
+    const found = await detectVersion(BIN);
+    if (!found.available) return found;
+    // `grok models` prints "  * grok-4.7 (default)" / "  - grok-4.6" lines.
+    const ids = [...(await quietOutput(BIN, ['models'])).matchAll(/^\s+[*-]\s+([\w.\-/:]+)/gm)].map((m) => m[1]);
+    if (!ids.length) return found;
+    const meta = cachedModels();
+    const models = ids.map((id) => {
+      const info = meta[id]?.info || {};
+      const efforts = info.supports_reasoning_effort === false ? [] : effortsOf(info.reasoning_efforts);
+      return { id, label: info.name || id, hint: clip(info.description || id, 60), ...(efforts && { efforts }) };
+    });
+    return { ...found, models: [this.models[0], ...models] };
+  },
+
+  run({ prompt, attachments = [], cwd, resumeId, mode, model, effort, systemPrompt, mcpServers = {}, onEvent }) {
+    // grok -p doesn't read stdin, and a prompt in argv is capped on Windows: hand it over as a file.
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'wisp-grok-'));
+    const promptFile = path.join(tmp, 'prompt.md');
+    fs.writeFileSync(promptFile, prompt + attachmentNote(attachments));
+
+    const args = [
+      '--prompt-file', promptFile,
+      '--output-format', 'streaming-messages-json',
+      '--permission-mode', PERMISSION_MODES[mode] || 'acceptEdits',
+      '--rules', systemPrompt,
+      // A headless run can't answer grok's own question tool; wisp's ask_user (or a question block) replaces it.
+      '--disallowed-tools', 'ask_user_question',
+      '--no-auto-update',
+    ];
+    if (model) args.push('--model', model);
+    if (effort) args.push('--reasoning-effort', effort);
+    if (resumeId) args.push('--resume', resumeId);
+    if (Object.keys(mcpServers).length) {
+      const agentFile = path.join(tmp, 'wisp.md');
+      fs.writeFileSync(agentFile, agentDefinition(mcpServers));
+      args.push('--agent', agentFile);
+    }
+
+    const files = fileTracker(cwd);
+    const pending = new Map(); // tool_use_id -> { name, input }
+    let session = null;
+    let sawResult = false;
+    let error = null;
+
+    const handle = spawnJsonl({
+      bin: BIN,
+      args,
+      cwd,
+      env: { ...process.env, GROK_DISABLE_AUTOUPDATER: '1' },
+      onEvent,
+      onJson(msg) {
+        if (msg.session_id && msg.session_id !== session) onEvent({ type: 'session', id: (session = msg.session_id) });
+        // Subagent traffic carries its parent's tool id; only the main conversation is shown.
+        if (msg.parent_tool_use_id) return;
+        switch (msg.type) {
+          case 'assistant':
+            for (const part of msg.message?.content || []) {
+              if (part.type === 'text' && part.text?.trim()) onEvent({ type: 'text', text: part.text });
+              else if (part.type === 'thinking') onEvent({ type: 'thinking' });
+              else if (part.type === 'server_tool_use') onEvent({ type: 'tool', kind: 'web', label: `Searching the web: ${clip(part.input?.query, 50)}` });
+              else if (part.type === 'tool_use') {
+                const input = part.input || {};
+                pending.set(part.id, { name: part.name, input });
+                if (part.name === 'write' && input.file_path) files.remember(input.file_path);
+                // Streamed once answered, so "waiting" would land after "You answered"; the trail has both.
+                if (part.name === 'use_tool' && input.tool_name === 'wisp__ask_user') continue;
+                onEvent({ type: 'tool', ...describeTool(part.name, input, cwd) });
+              }
+            }
+            break;
+          case 'user':
+            for (const part of msg.message?.content || []) {
+              if (part.type !== 'tool_result') continue;
+              const call = pending.get(part.tool_use_id);
+              pending.delete(part.tool_use_id);
+              if (!call) continue;
+              if (part.is_error) onEvent({ type: 'tool_error', name: call.name, text: clip(flatten(part.content), 400) });
+              else {
+                const change = captureChange(call.name, call.input, cwd, files);
+                if (change) onEvent({ type: 'change', ...change });
+              }
+            }
+            break;
+          case 'result':
+            sawResult = true;
+            onEvent({
+              type: 'result',
+              text: msg.is_error ? (msg.errors || []).join('\n') || msg.result || `grok stopped: ${msg.subtype}` : msg.result ?? '',
+              isError: !!msg.is_error || (msg.subtype && msg.subtype !== 'success'),
+              stats: {
+                costUsd: msg.total_cost_usd || undefined, // 0 means "not reported", never free
+                durationMs: msg.duration_ms,
+                turns: msg.num_turns,
+                inputTokens: msg.usage?.input_tokens,
+                outputTokens: msg.usage?.output_tokens,
+              },
+            });
+            break;
+          case 'error':
+            error = msg.message || 'grok reported an error.';
+            break;
+        }
+      },
+      onClose({ code, signal, stderr, stopped }) {
+        if (sawResult) return;
+        onEvent({ type: 'result', isError: true, stopped, text: error || stderr || `grok exited with ${signal || `code ${code}`}` });
+      },
+    });
+    handle.done.finally(() => fs.rmSync(tmp, { recursive: true, force: true }));
+    return handle;
+  },
+};
+
+// `prompt_mode: full` keeps grok's stock system prompt; the body adds nothing.
+function agentDefinition(mcpServers) {
+  const servers = Object.entries(mcpServers).map(([name, srv]) => ({
+    name,
+    command: srv.command,
+    args: srv.args || [],
+    env: srv.env || {},
+    tool_timeout_sec: ASK_TIMEOUT_MS / 1000,
+    startup_timeout_sec: 60,
+  }));
+  // YAML is a superset of JSON, so JSON values need no escaping of their own.
+  return `---\nname: wisp\ndescription: A task launched by wisp\nprompt_mode: full\nagents_md: true\nmcpServers: ${JSON.stringify(servers)}\n---\n`;
+}
+
+// grok caches the model catalog, with each model's reasoning levels, in $GROK_HOME.
+function cachedModels() {
+  try {
+    const home = process.env.GROK_HOME || path.join(os.homedir(), '.grok');
+    return JSON.parse(fs.readFileSync(path.join(home, 'models_cache.json'), 'utf8')).models || {};
+  } catch {
+    return {};
+  }
+}
+
+function effortsOf(list) {
+  if (!Array.isArray(list)) return undefined;
+  const rank = (id) => (EFFORT_ORDER.includes(id) ? EFFORT_ORDER.indexOf(id) : EFFORT_ORDER.length);
+  return list.map((e) => e.id).filter(Boolean).sort((a, b) => rank(a) - rank(b));
+}
+
+function describeTool(name, input, cwd) {
+  const f = rel(input.target_file || input.file_path || input.path || input.target_directory, cwd);
+  switch (name) {
+    case 'read_file':
+      return { kind: 'read', label: `Reading ${f}`, file: f };
+    case 'search_replace':
+      return { kind: 'edit', label: `Editing ${f}`, file: f };
+    case 'write':
+      return { kind: 'edit', label: `Writing ${f}`, file: f };
+    case 'run_terminal_command':
+    case 'run_terminal_cmd':
+      return { kind: 'run', label: input.description ? clip(input.description) : `Running ${clip(input.command, 60)}`, detail: input.command };
+    case 'grep':
+      return { kind: 'search', label: `Searching for “${clip(input.pattern, 40)}”` };
+    case 'list_dir':
+      return { kind: 'search', label: `Listing ${isDir(input.target_directory, cwd) ? '.' : f || '.'}` };
+    case 'web_search':
+      return { kind: 'web', label: `Searching the web: ${clip(input.query, 50)}` };
+    case 'web_fetch':
+      return { kind: 'web', label: `Reading ${clip(input.url, 60)}` };
+    case 'spawn_subagent':
+    case 'task':
+      return { kind: 'agent', label: `Delegating: ${clip(input.description || input.prompt, 60)}` };
+    case 'todo_write': {
+      const active = input.todos?.find((t) => t.status === 'in_progress' && t.content);
+      return { kind: 'plan', label: active ? clip(active.content) : 'Planning' };
+    }
+    case 'enter_plan_mode':
+    case 'exit_plan_mode':
+      return { kind: 'plan', label: 'Planning' };
+    case 'search_tool':
+      return { kind: 'search', label: `Looking up tools: ${clip(input.query, 50)}` };
+    case 'use_tool':
+      return describeMcp(String(input.tool_name || ''), input.tool_input || {});
+    default:
+      return { kind: 'tool', label: `Using ${name.replace(/_/g, ' ')}` };
+  }
+}
+
+// grok passes absolute paths, also for the project root itself (which rel() leaves as is).
+function isDir(dir, cwd) {
+  try {
+    return !!dir && fs.realpathSync(path.resolve(cwd, dir)) === fs.realpathSync(cwd);
+  } catch {
+    return false;
+  }
+}
+
+// MCP tools are called through `use_tool` with a `server__tool` name.
+function describeMcp(tool, input) {
+  switch (tool) {
+    case 'wisp__ask_user':
+      return { kind: 'wait', label: 'Waiting for your answer' };
+    case 'wisp__delegate':
+      return { kind: 'agent', label: `Delegating to ${clip([...new Set((input.tasks || []).map((t) => t.subagent))].join(', ') || 'subagents', 60)}` };
+    case 'wisp__subagent_results':
+      return { kind: 'agent', label: 'Waiting on subagents' };
+    default:
+      return { kind: 'tool', label: `Using ${tool.split('__').join(' · ') || 'an integration'}` };
+  }
+}
+
+// Called once a tool succeeded. grok may stream a batch of tool calls after running them, so the
+// "before" side of a write can't come from disk at tool_use time: the tracker supplies it.
+function captureChange(name, input, cwd, files) {
+  const file = input.file_path;
+  if (!file) return null;
+  if (name === 'search_replace' && typeof input.old_string === 'string' && input.old_string) {
+    files.change(file); // keep the tracker's snapshot current for later writes
+    return { file: rel(file, cwd), op: 'edit', edits: [{ before: input.old_string, after: input.new_string ?? '' }] };
+  }
+  if (name === 'search_replace' || name === 'write') return files.change(file);
+  return null;
+}

package/server/adapters/index.js

@@ -29,8 +29,9 @@ import codex from './codex.js';
 import opencode from './opencode.js';
 import cursor from './cursor.js';
 import antigravity from './antigravity.js';
+import grok from './grok.js';
 
-export const adapters = Object.fromEntries([claude, codex, opencode, cursor, antigravity].map((a) => [a.id, a]));
+export const adapters = Object.fromEntries([claude, codex, opencode, cursor, antigravity, grok].map((a) => [a.id, a]));
 
 const detected = new Map();
 

package/server/adapters/opencode.js

@@ -38,7 +38,7 @@ export default {
     return { ...found, models: [this.models[0], ...models] };
   },
 
-  run({ prompt, attachments = [], cwd, resumeId, mode, model, effort, systemPrompt, mcpServers = {}, onEvent }) {
+  run({ prompt, attachments = [], cwd, resumeId, mode, model, effort, systemPrompt, mcpServers = {}, delegating = false, onEvent }) {
     // The prompt goes on stdin; `run` appends piped stdin to the (empty) message.
     const args = ['run', '--format', 'json'];
     if (mode === 'plan') args.push('--agent', 'plan');
@@ -60,6 +60,8 @@ export default {
         ...inline,
         mcp: { ...inline.mcp, ...mcp },
         experimental: { ...inline.experimental, mcp_timeout: ASK_TIMEOUT_MS },
+        // Its built-in `task` subagents would bypass the user's team.
+        ...(delegating && { permission: { ...(typeof inline.permission === 'object' ? inline.permission : inline.permission && { '*': inline.permission }), task: 'deny' } }),
       });
     }
 

package/server/git.js

@@ -93,12 +93,15 @@ export async function ensureWorktree(wt) {
   await git(wt.root, ['worktree', 'add', '--quiet', wt.path, wt.branch]);
 }
 
-// { dirty: changed paths, ahead: commits past the base, exists }
+// { dirty: changed paths, ahead: commits past the base, unpushed: commits not on the remote branch, exists }
 export async function worktreeStatus(wt) {
-  if (!wt || !fs.existsSync(wt.path)) return { exists: false, dirty: 0, ahead: 0 };
+  if (!wt || !fs.existsSync(wt.path)) return { exists: false, dirty: 0, ahead: 0, unpushed: 0 };
   const porcelain = await quiet(git(wt.path, ['status', '--porcelain']));
   const ahead = Number(await quiet(git(wt.path, ['rev-list', '--count', `${wt.baseRef}..HEAD`]))) || 0;
-  return { exists: true, dirty: porcelain ? porcelain.split('\n').length : 0, ahead };
+  const pushed = wt.remote && `refs/remotes/${wt.remote}/${wt.branch}`;
+  const tracked = pushed && (await quiet(git(wt.path, ['rev-parse', '--verify', '--quiet', pushed])));
+  const unpushed = tracked ? Number(await quiet(git(wt.path, ['rev-list', '--count', `${pushed}..HEAD`]))) || 0 : ahead;
+  return { exists: true, dirty: porcelain ? porcelain.split('\n').length : 0, ahead, unpushed };
 }
 
 // force: drop uncommitted work too. The branch goes only when nothing would be lost with it.