wisp-agents 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -5,6 +5,42 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-10-17
+
+### Added
+
+- Subagents: give the lead agent a team on other harnesses, e.g. a Claude Code run that hands tests to Codex and research to opencode. The launcher's **Subagents** button opens an editor: up to 6 members, each with its own harness, model and thinking level, a name, a **Use for** note ("image and UI work", "research") that tells the lead when to pick it, and a **×N** copies stepper: `Codex ×3` gives the lead three identical Codex agents (`codex#1`…`codex#3`, 12 agents in all). Several tasks sent to `codex` in one call go to free copies and run side by side; naming a copy continues its conversation. **Save as preset** stores the team; **Presets** loads or deletes one. The lead gets a `delegate` tool on wisp's injected MCP server (Claude Code, Codex, opencode; Cursor and Antigravity can be subagents but not leads). Tasks in one call run in parallel in the lead's folder, and delegating to the same member again resumes its conversation. Feed cards show the lead's logo with its subagents' logos stacked behind it (they fan out on hover and pulse while working). A running card lists each subagent's live status, and a finished turn shows one report card per delegated task that opens into that subagent's own presentation. Subagent edits count as the lead's, so they appear in its files, diffs, rollback and Ship it. API: `subagents` / `preset` on `POST /sessions`, `/teams` for presets, `PATCH /sessions/:id { subagents }`; `wisp_launch` takes them too.
+- Actionable presentation blocks: a new `actions` block (`items: [{label, command, detail, confirm} | {label, reply}]`) renders 1-click command buttons that run in the session's project folder (`POST /api/sessions/:id/exec`), show live exit code, duration and output inline, and offer a **Send failure to agent** follow-up button when a command fails. `terminal` and `tests` blocks with a `command` now have a **Run / Re-run** button, and `diff` and `files` blocks have a per-file **Revert / Re-apply** button (`POST /api/sessions/:id/revert`).
+- Session checkpoints & one-click rollback: before each turn starts, wisp snapshots the git working tree (`git stash create || git rev-parse --verify HEAD`, pinned at `refs/wisp/checkpoints/<session>/<turn>`) along with pre-turn untracked files and per-file before snapshots. Each turn's trail bar, session menu, and command palette include **Restore to before this turn** (and **Re-apply turn** / Undo) via `POST /api/sessions/:id/rollback`.
+- Worktree per task: in a git repo, each launch runs in its own git worktree on a `wisp/<task>-<id>` branch made from `origin/main` (freshly fetched), under `~/.wisp/worktrees/`. Parallel agents never edit the same checkout, and the agent is told where it is. On by default; toggle **Worktree / In place** in the launcher, Settings → *Worktree per task*, `--no-worktree` on the CLI or `worktree: false` in the API. Plan mode and folders that aren't repos run in place. Archiving removes a clean worktree (the branch stays, a follow-up brings it back); deleting the session removes it, and its branch unless it has commits.
+- Ship it (`S`, the card's **Ship it** button, or `wisp ship <id>`): commits the worktree with a conventional message drafted from the presentation, pushes the branch and opens a PR with `gh pr create` (optionally as a draft). The card then shows the PR: CI checks, review state and merges, polled every minute; it comes back to *Needs you* when checks finish, a review lands, or it merges. **Merge** (`wisp merge <id>`) marks a draft ready, squash-merges with `--match-head-commit`, fast-forwards your local base branch and removes the worktree.
+- Compare: the **vs** button in the launcher (or `--compare codex,opencode:model` on the CLI, `compare: [...]` in the API) runs the same task on a second harness, each in its own worktree. **Compare** opens the runs side by side: time, cost, files and lines changed, tests, questions, and each presentation. **Keep this** archives the others and deletes their worktrees.
+- Recipes: saved prompts where `{name}` becomes a field to fill in, e.g. `Prepare release {version}…`. Create them from ⌘K → *Recipes* or *Save as recipe…* on any card; run them from ⌘K → *Run: …*, or `wisp run release 0.8.0` / `wisp recipes`. A recipe can pin a project, harness, model and mode.
+- Triggers start sessions without you, while wisp is open: a cron **schedule** (local time), **CI failed** (a GitHub Actions run fails; polled with `gh run list`), or **issue labelled** (polled with `gh issue list`). Each runs a prompt or a recipe, with the run's or issue's details filled in. The first check only records what already exists. Issue triggers default to Plan mode, since issue text is untrusted. ⌘K → *Triggers*.
+- Usage view (⌘K → *Usage*, Settings → *Usage*): spend per day, and spend, turns, success rate, questions and average time by project and by harness · model, over 7, 30 or 90 days. Harnesses that don't report cost are counted but not priced. `wisp usage`, `GET /api/usage`.
+- Phone (Settings → *Phone*): questions and finished tasks go to [ntfy](https://ntfy.sh) and/or a Telegram bot. Tap an option to answer; on Telegram, reply to a message to answer in your own words or follow up, and tap *Mark done*. wisp polls both, so nothing has to reach your machine. ntfy answers are HMAC-signed; Telegram is linked to one chat with a one-time code.
+- API: `POST /sessions` takes `worktree` and `compare`; new `/sessions/:id/ship`, `/pr`, `/merge`, `/recipes`, `/triggers`, `/remote`, `/usage` (all in `GET /api/openapi.json`). SDK: `ship`, `merge`, `recipes`, `saveRecipe`, `runRecipe`, `triggers`, `usage`. Summaries carry `branch`, `pr`, `groupId` and `origin`.
+- A `graph` presentation block for explaining merges and conflicts: a PR card with the branches as coloured lanes (newest commit first), the merge target on top (conflicts / ready / merged), branch tags on each tip, and the base commits that conflict highlighted and numbered. Under it: each conflict with file, `ours` vs `theirs` and how it was resolved (hover one to light up the commit it came from), checks as chips, and an optional action button (e.g. **Resolve conflicts**) that replies to the agent. Plain-markdown rendering for the CLI, MCP and chat apps too.
+- Back to top from the keyboard: `U` (or `Home`) scrolls the feed to the top. The back-to-top button that appears once you scroll shows the `U` key next to its arrow, and the shortcut is listed under `?`.
+
+### Changed
+
+- The bar under an open task's title only says how the run was set up: the mode when it's Plan or Full auto, the branch, and what launched it. Agent, model and path, which the card header already shows, moved into its tooltip. Compare stays in the task header and Done next to the composer; Take over is an icon. **Ship it** now also sits next to *Mark done* under the composer, so you can ship right after reading the result.
+- Memory, Automations, Usage and Phone open inside Settings when you reach them from there: they take the main area next to the sidebar, with a **Back** button (or Esc) that returns to the section you came from. Only the X closes Settings. From the top bar or ⌘K they still open on their own.
+- Settings is a sidebar and a pane instead of one long list: **General** (editor, terminal, worktree per task), **Notifications** (desktop, phone), **Agents** (each harness with version or error; a red dot in the sidebar when one is missing), **Memory**, **Automations** (recipes and triggers, each with **Manage**), **Usage** (last 7 days at a glance) and **Privacy**. It reopens on the last section; ↑/↓ move between sections. Phones get the sections as a scrolling tab strip.
+- Recipes and triggers are out in the open instead of only behind Settings and ⌘K: an **Automations** button in the top bar (badge = triggers on, tooltip = what fires next), and a **Recipes** row under the launcher with one-click chips for the picked project's recipes (and those tied to none), **Save as recipe** for whatever is in the box, and **Manage**. Each recipe in Automations has a **Schedule** button that starts a schedule trigger running it.
+- The launcher stays reachable while you scroll: once it passes under the top bar it docks there as a one-line bar (project chip + draft). Click it, or press `⌘L` / `N`, and the full launcher opens in place over the feed, without scrolling you back to the top. `Esc` or clicking away folds it again. Cards selected with `J` / `K` or opened scroll into view below it.
+- The launcher's **vs** (compare) control is part of the harness pill instead of a separate button. Turned on, the second harness joins the same pill (`Claude Code ⌄ vs opencode ⌄`); hover **vs** for × to stop comparing. The bar no longer wraps onto a second line: on narrow widths model names, then labels, fold away and the logos stay.
+- A compare launch is one task in the feed instead of a card per harness: the prompt on top, a row per run (harness, model, live status; each expands in place), and **Compare** for the side-by-side view. The task sits in *Needs you* while any run asks, *Working* while any runs, and *Done* once all are; ✓ marks every finished run done. Compare runs keep the prompt as their title. **Keep this** turns the kept run back into an ordinary card. See [docs/feed.md](docs/feed.md#compare-tasks).
+
+### Fixed
+
+- Clicking a recipe no longer runs it straight away when it has no fields to fill in. Its dialog now always stays open until you press **Run** (the button has focus, so Enter works too).
+- `flow` blocks that don't fit across the card wrap onto rows that alternate direction (left to right, then right to left), joined by a short line, instead of squeezing every step into a narrow column. Loop-back lines go around the cards instead of crossing them. Phone width still stacks the steps.
+- The launcher no longer flashes its focus ring when you open the harness pickers or switch between them (e.g. opencode, then Claude Code in a compare). The ring stays on while a picker or the mode menu is open; the rerun dialog behaves the same way.
+- Launching a compare no longer freezes wisp for a few seconds. The runs share one `git fetch` and their worktrees are checked out in parallel. A fresh worktree's first checkpoint is its base commit, so it no longer runs blocking `git` calls that stalled the server and the live feed. With fake harnesses, a 2-way launch went from 1.5 s to 0.7 s and a 3-way launch from 2.3 s to 0.9 s. The send button shows a spinner while the launch sets up. If one worktree fails, the ones already created are removed.
+- Scrolling in the feed stays put. When a card changes section in the background (a task finishes, asks or is removed), the card you're reading no longer jumps; one whose edge just peeks onto the screen no longer drags the view with it. Mark done, Archive and Delete put the next card where the old one was and focus it, so E / A / j triage continues from the same spot. j / k show the header of tall cards, switching project filters returns to the top of the feed, and a task launched from the box scrolls into view when its card lands off-screen. The rules are written down in [docs/feed.md](docs/feed.md).
+
 ## [0.7.0] - 2026-10-17
 
 ### Added
@@ -122,7 +158,8 @@ 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.7.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.8.0...HEAD
+[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
 [0.5.0]: https://github.com/M0xoo/wisp/compare/v0.4.0...v0.5.0

package/README.md

@@ -48,6 +48,14 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 | 🖥️ **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). |
+| 🌿 **A worktree per task** | In a git repo each task gets its own worktree and branch from `origin/main`, so parallel agents never collide. |
+| 🚢 **Ship it** | One click commits, pushes and opens the PR. The card follows CI and reviews; **Merge** squash-merges and syncs your local main. |
+| 🤝 **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. |
+| 📊 **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. |
 | 🔌 **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. |
@@ -115,6 +123,11 @@ 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 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 recipes                      # list recipes
+wisp usage [--days 7]             # spend and outcomes
 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)
 ```
@@ -127,6 +140,8 @@ wisp skill install                # install the wisp skill for Claude Code (--ag
 | `--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 |
+| `--no-worktree` | Edit the folder in place instead of a fresh worktree (default in git repos: a worktree) |
+| `--compare a[:model],…` | Also run the task on these harnesses, each in its own worktree |
 | `--json` | Machine-readable output |
 | `--browser`, `-b` | Use the browser instead of the desktop app |
 | `--no-open` | Just run the server; open nothing |
@@ -169,12 +184,15 @@ console.log((await wisp.wait(s.id)).state, (await wisp.presentation(s.id)).markd
 | `/` | Reply to the focused session |
 | `1`–`9` | Pick an option in a pending question |
 | `T` | Take over in your terminal |
+| `S` | Ship it: commit, push and open a PR (worktree tasks) |
+| `⇧ R` | Rerun with another harness, model or thinking level |
 | `E` | Mark done and jump to the next session that needs you |
 | `A` | Archive / unarchive |
 | `M` | Rename |
 | `⌫` | Delete |
 | `R` | Replay the presentation |
 | `C` | Collapse all |
+| `U` | Back to top (also `Home`) |
 | `?` | Show all shortcuts |
 | `Esc` | Close, blur, or collapse |
 
@@ -202,9 +220,15 @@ wisp/
 │   ├── mcp-wisp.js        # `wisp mcp`: wisp as tools for other agents
 │   ├── render.js          # presentation → markdown
 │   ├── runner.js          # session lifecycle, follow-ups, event normalization
+│   ├── checkpoint.js      # per-turn git checkpoints, file revert, rollback, action exec
 │   ├── protocol.js        # system prompt + ```wisp block parser (markdown fallback)
 │   ├── mcp-ask.js         # ask_user MCP server
 │   ├── store.js           # JSON-file persistence in ~/.wisp
+│   ├── git.js             # worktrees, Ship it, PR status and merge (git + gh)
+│   ├── recipes.js         # saved prompts with {params}
+│   ├── triggers.js        # cron schedules and GitHub watchers
+│   ├── remote.js          # phone: ntfy and Telegram, out and back
+│   ├── usage.js           # spend and outcomes
 │   ├── terminal.js        # "take over" in your terminal
 │   ├── welcome.js         # the gallery session
 │   └── adapters/
@@ -231,7 +255,7 @@ wisp/
 
 ### Presentation blocks
 
-`hero` · `markdown` · `steps` · `stats` · `files` · `tree` · `diff` · `code` · `tests` · `commits` · `terminal` · `compare` · `flow` · `chart` · `checklist` · `callout` · `image` · `question` · `next`
+`hero` · `markdown` · `steps` · `stats` · `files` · `tree` · `diff` · `code` · `tests` · `commits` · `graph` · `terminal` · `compare` · `flow` · `chart` · `checklist` · `callout` · `image` · `question` · `actions` · `next`
 
 ## Adding a harness
 
@@ -251,6 +275,57 @@ If the harness has no system-prompt flag, prepend `systemPrompt` to the first pr
 - [x] Cursor CLI adapter
 - [x] Antigravity CLI adapter
 
+## Worktrees and shipping
+
+In a git repo, every launch (except Plan mode) runs in its own [git worktree](https://git-scm.com/docs/git-worktree) under `~/.wisp/worktrees/`, on a branch named `wisp/<task>-<id>` made from the remote's default branch (`origin/main`, fetched first; `HEAD` when there is no remote). Uncommitted changes in your own checkout are not carried over, and dependencies aren't shared: the agent is told to install what it needs. The card shows the branch, and **Take over** opens the worktree.
+
+**Ship it** (`S`) commits whatever is uncommitted (the message is drafted from the presentation as a conventional commit; edit it before shipping), pushes the branch and runs `gh pr create`. You need the [GitHub CLI](https://cli.github.com) signed in. From then on the card follows the PR every minute: checks (✓ / running / failing), the review decision, merged or closed. **Merge** runs `gh pr ready` for drafts and `gh pr merge --squash --match-head-commit <sha>`, so a branch that moved since you looked is never merged, then fast-forwards your local base branch (`git merge --ff-only`, or a ref update when it isn't checked out) and removes the worktree and branch. If a ruleset requires a review, Merge waits for the approval like `gh` does.
+
+**Compare** (the **vs** button next to the harness picker) launches the same task on a second harness. Both get their own worktree and show up as one task in the feed, with a row per run; **Compare** on the task shows them side by side, and **Keep this** archives the others and deletes their worktrees.
+
+Turn worktrees off in Settings → *Worktree per task*, with the launcher's **Worktree / In place** toggle, or per launch (`--no-worktree`, `"worktree": false`).
+
+## 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`.
+
+## Checkpoints and rollback
+
+Before each turn, wisp snapshots the git working tree (pinned at `refs/wisp/checkpoints/<session>/<turn>`). **Restore to before this turn** (turn bar, session menu or ⌘K) rolls back; **Re-apply turn** undoes that. `diff` and `files` blocks have a per-file **Revert / Re-apply**, and `actions`, `terminal` and `tests` blocks run their command in the project folder with one click.
+
+## Automations
+
+**Recipes** are prompts you send again and again. `{name}` in a recipe becomes a field you fill in when it runs:
+
+```text
+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.
+
+**Triggers** launch sessions on their own while wisp is open (⌘K → *Triggers*):
+
+| Kind | Fires when | Prompt fields |
+|---|---|---|
+| Schedule | a cron expression matches (local time), e.g. `0 9 * * 1-5` | your recipe's fields |
+| CI failed | a GitHub Actions run fails (optionally on one branch) | `{name} {branch} {url} {id} {sha}` |
+| Issue labelled | an open issue carries a label | `{number} {title} {body} {url} {author}` |
+
+GitHub triggers poll with your `gh` login (every 2–60 minutes), so nothing has to reach your machine; the first check only records what already exists. Issue triggers start in Plan mode: issue text comes from whoever can open issues, so think twice before giving it Full auto.
+
+## 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`.
+
+## Phone
+
+Settings → *Phone* sends questions and finished tasks to your phone and takes the answers back. wisp polls both services, so it works from anywhere without opening a port.
+
+- **[ntfy](https://ntfy.sh)**: subscribe to the topic in the ntfy app. Notifications carry up to three buttons (the question's options, or *Mark done*); a tap sends a signed answer back. Use a long random topic (wisp suggests one): anyone who knows it can read the notifications, but only wisp can make answers that count.
+- **Telegram**: create a bot with @BotFather, paste its token, then send `/link <code>` to the bot. Tap a button to answer, or reply to a message to answer in your own words or send a follow-up.
+
+They receive titles, summaries and questions (with their context), never code or diffs.
+
 ## 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

@@ -5,6 +5,7 @@
 //   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 run <recipe> [values…]             run a saved recipe
 //   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
 
@@ -25,17 +26,22 @@ const HELP = `usage:
   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 ship <id>                commit, push and open a PR for a worktree session   (--draft)
+  wisp merge <id>               squash-merge its PR and sync your local base branch
+  wisp run <recipe> [values…]   run a saved recipe; values fill its {params} in order, or key=value
+  wisp recipes                  list recipes
+  wisp usage                    spend and outcomes   (--days 7|30|90)
   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
+                --cwd DIR  --wait  --json  --no-worktree  --compare agent[:model],…
 options:        --port N  --browser  --no-open  --json  --version`;
 
-const COMMANDS = new Set(['add', 'ls', 'list', 'show', 'wait', 'reply', 'stop', 'mcp', 'skill']);
+const COMMANDS = new Set(['add', 'ls', 'list', 'show', 'wait', 'reply', 'stop', 'mcp', 'skill', 'ship', 'merge', 'run', 'recipes', 'usage']);
 const argv = process.argv.slice(2);
-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 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, worktree: undefined, compare: null, draft: false, days: null };
 const words = [];
 let literal = false;
 for (let i = 0; i < argv.length; i++) {
@@ -56,6 +62,11 @@ for (let i = 0; i < argv.length; i++) {
   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 === '--no-worktree') flags.worktree = false;
+  else if (a === '--worktree') flags.worktree = true;
+  else if (a === '--compare') flags.compare = argv[++i].split(',').filter(Boolean).map((x) => ({ agent: x.split(':')[0], model: x.split(':').slice(1).join(':') || undefined }));
+  else if (a === '--draft') flags.draft = true;
+  else if (a === '--days') flags.days = Number(argv[++i]);
   else if (a === '--version' || a === '-v') {
     console.log(JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url))).version);
     process.exit(0);
@@ -64,7 +75,11 @@ for (let i = 0; i < argv.length; i++) {
     process.exit(0);
   } else words.push(a);
 }
-const command = literal !== 'task' && COMMANDS.has(words[0]) ? words[0] : null;
+// Newer commands are also common first words of a task ("ship the docs", "usage of X"), so they
+// only count when the rest fits; `wisp run` falls back to a task when no recipe has that name.
+const SESSION_ID = /^[a-f0-9]{12}$/;
+const FITS = { ship: (w) => SESSION_ID.test(w[1] || ''), merge: (w) => SESSION_ID.test(w[1] || ''), usage: (w) => w.length === 1, recipes: (w) => w.length === 1, run: (w) => w.length > 1 };
+const command = literal !== 'task' && COMMANDS.has(words[0]) && (FITS[words[0]]?.(words) ?? true) ? words[0] : null;
 const cwd = flags.cwd || process.cwd();
 const die = (msg) => {
   console.error(`  ✗ ${msg}`);
@@ -98,7 +113,8 @@ async function scripted(cmd, args) {
   };
   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 });
+      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, worktree: flags.worktree, compare: flags.compare || undefined });
+      if (s.group && !flags.wait) return out(s, s.group.map((x) => `  ◌ launched on ${x.agent}: ${x.title}  (${x.id})`).join('\n'));
       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));
@@ -122,6 +138,37 @@ async function scripted(cmd, args) {
     }
     case 'stop':
       return out(await wisp.stop(need(args[0], 'session id')), '  ✓ stopped');
+    case 'ship': {
+      const pr = await wisp.ship(need(args[0], 'session id'), { draft: flags.draft });
+      return out(pr, `  ✓ PR #${pr.number}${pr.draft ? ' (draft)' : ''}: ${pr.url}`);
+    }
+    case 'merge': {
+      const r = await wisp.merge(need(args[0], 'session id'));
+      return out(r, `  ✓ merged PR #${r.pr.number}\n  ${r.sync.ok ? '✓' : '!'} ${r.sync.text}`);
+    }
+    case 'recipes': {
+      const list = await wisp.recipes();
+      return out(list, list.map((r) => `${r.name.padEnd(24)}  ${r.params.map((p) => `{${p}}`).join(' ').padEnd(20)}  ${r.prompt.replace(/\s+/g, ' ').slice(0, 60)}`).join('\n') || 'No recipes yet. Save one from wisp (⌘K → Recipes).');
+    }
+    case 'run': {
+      const key = need(args[0], 'recipe name');
+      const kv = Object.fromEntries(args.slice(1).filter((a) => /^[a-zA-Z][\w-]*=/.test(a)).map((a) => [a.slice(0, a.indexOf('=')), a.slice(a.indexOf('=') + 1)]));
+      const words = args.slice(1).filter((a) => !/^[a-zA-Z][\w-]*=/.test(a));
+      const s = await wisp.runRecipe(key, { params: kv, words, cwd, agent: flags.agent || undefined, model: flags.model ?? undefined, effort: flags.effort ?? undefined, mode: flags.mode || undefined }).catch((err) => {
+        if (err.status !== 404) throw err;
+        return wisp.launch({ prompt: ['run', ...args].join(' '), cwd, agent: flags.agent || undefined, mode: flags.mode || undefined, model: flags.model ?? undefined, effort: flags.effort ?? undefined, worktree: flags.worktree });
+      });
+      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 'usage': {
+      const u = await wisp.usage({ days: flags.days || 30 });
+      const money = (v) => `$${v.toFixed(2)}`;
+      const pct = (v) => (v === null ? '—' : `${Math.round(v * 100)}%`);
+      const rows = (list, label) => list.map((x) => `  ${label(x).padEnd(32).slice(0, 32)}  ${money(x.cost).padStart(8)}  ${String(x.turns).padStart(5)} turns  ${pct(x.successRate).padStart(4)} ok`).join('\n');
+      return out(u, `Last ${u.days} days: ${money(u.total.cost)} · ${u.total.turns} turns in ${u.total.sessions} sessions · ${pct(u.total.successRate)} worked · ${u.total.questions} questions\n\nBy project\n${rows(u.projects, (x) => x.name)}\n\nBy harness · model\n${rows(u.runners, (x) => `${x.agent} · ${x.model || 'default'}`)}`);
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wisp-agents",
-  "version": "0.7.0",
+  "version": "0.8.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": "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: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

@@ -182,6 +182,10 @@ function describeTool(name, input, cwd) {
     }
     case 'mcp__wisp__ask_user':
       return { kind: 'wait', label: 'Waiting for your answer' };
+    case 'mcp__wisp__delegate':
+      return { kind: 'agent', label: `Delegating to ${clip([...new Set((input.tasks || []).map((t) => t.subagent))].join(', ') || 'subagents', 60)}` };
+    case 'mcp__wisp__subagent_results':
+      return { kind: 'agent', label: 'Waiting on subagents' };
     default:
       return { kind: 'tool', label: name.startsWith('mcp__') ? `Using ${name.split('__').slice(1).join(' · ')}` : `Using ${name}` };
   }

package/server/adapters/codex.js

@@ -186,5 +186,6 @@ export function unwrapShell(cmd) {
 
 function describeMcp(item) {
   if (item.server === 'wisp' && item.tool === 'ask_user') return { kind: 'wait', label: 'Waiting for your answer' };
+  if (item.server === 'wisp' && (item.tool === 'delegate' || item.tool === 'subagent_results')) return { kind: 'agent', label: 'Waiting on subagents' };
   return { kind: 'tool', label: `Using ${item.server} · ${item.tool}` };
 }

package/server/adapters/common.js

@@ -169,7 +169,7 @@ export function fileTracker(cwd) {
       known.set(r, after);
       announced.delete(r);
       if (before === after) return null;
-      return { file: r, op: before === null ? 'create' : 'write', edits: [{ before: before ?? '', after: after ?? '' }] };
+      return { file: r, op: before === null ? 'create' : 'write', beforeFile: before, edits: [{ before: before ?? '', after: after ?? '' }] };
     },
   };
 }

package/server/adapters/index.js

@@ -41,7 +41,8 @@ export async function listAgents() {
       const found = await detected.get(a.id);
       // Only a hit is cached: a CLI installed while wisp is running shows up on the next call.
       if (!found.available) detected.delete(a.id);
-      return { id: a.id, name: a.name, models: a.models, efforts: a.efforts || [], ...found };
+      // delegates: can lead a team of subagents (needs wisp's MCP server injected).
+      return { id: a.id, name: a.name, models: a.models, efforts: a.efforts || [], delegates: a.askTool !== null, ...found };
     }),
   );
 }

package/server/adapters/opencode.js

@@ -169,6 +169,10 @@ function describeTool(name, input, cwd) {
     }
     case 'wisp_ask_user':
       return { kind: 'wait', label: 'Waiting for your answer' };
+    case 'wisp_delegate':
+      return { kind: 'agent', label: `Delegated to ${clip([...new Set((input.tasks || []).map((t) => t.subagent))].join(', ') || 'subagents', 60)}` };
+    case 'wisp_subagent_results':
+      return { kind: 'agent', label: 'Collected subagent reports' };
     default:
       return { kind: 'tool', label: `Using ${name.replace(/_/g, ' ')}` };
   }