wisp-agents 0.21.0 → 0.23.0

package/CHANGELOG.md

@@ -5,6 +5,35 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [0.23.0] - 2026-10-20
+
+### Changed
+
+- **Auto's Balanced goal runs frontier models.** When you have a frontier model installed and allowed (Opus, Codex's default, Gemini Argon, Grok 4.x), Balanced now picks it, at the harness's default or medium thinking, instead of Sonnet or Haiku. Best stays on frontier models at high or x-high, so the thinking level is what sets the two apart. Balanced steps down to an everyday model (Sonnet, never Haiku) only while every frontier model is at its limit, so the task still runs, or when you have none; small models' wins no longer pull Balanced to them after 20 outcomes. Cheap is unchanged. For models with the level in their name (Antigravity's `gemini-4-argon-low` / `-medium` / `-high`), the goal now picks the variant: Cheap low, Balanced medium, Best high, and the other variants count as the same model.
+- **Guides on the website for what people search for.** Six new pages under [trywisp.dev/guides](https://trywisp.dev/guides/): [run Claude Code and Codex in parallel](https://trywisp.dev/guides/run-claude-code-and-codex-in-parallel.html), [run multiple Claude Code agents in parallel](https://trywisp.dev/guides/run-multiple-claude-code-agents-in-parallel.html), [run coding agents on multiple machines](https://trywisp.dev/guides/run-coding-agents-on-multiple-machines.html), [multi-agent coding](https://trywisp.dev/guides/multi-agent-coding.html), [Claude Code vs Codex on your own repo](https://trywisp.dev/guides/claude-code-vs-codex.html) and [run coding agents in the background](https://trywisp.dev/guides/run-coding-agents-in-the-background.html). Each answers its question in the first paragraph, shows the manual way with `git worktree` and `ssh`, then how wisp does it, and ends with FAQs (with `FAQPage` structured data). `scripts/guides.mjs` holds them; `scripts/site.mjs` renders them into the sitemap. The landing page's title, description and structured data now say *in parallel* and *on your other machines*, its FAQ answers both questions, and Guides is in the nav and footer of every page. The npm description and keywords match.
+
+## [0.22.0] - 2026-10-20
+
+### Added
+
+- **Full transcript, when you want it.** Turn on Settings → General → **Full transcript** and every card shows its run as a timeline: the agent's messages in full, every step it took (commands, reads, edits, searches, questions), and at the end its presentation, rendered as blocks as usual. Click a step to see the whole command and what it printed, the diff that one edit made, or the full error. Long runs of steps fold their middle, and **Jump to the result** skips to the end. While a task runs, the timeline grows live above a one-line status bar with Stop. Any card can switch either way with its **Transcript** button or `V` (also in ⌘K), and keeps that choice. Off by default. Agent messages are now kept whole (they used to be cut at 600 characters), and so is the output of each command, search, web or MCP call, up to 2,000 characters (its start and end), from Claude Code, Codex, opencode, Cursor and Grok. Turns from before this change show their steps without output.
+- **Every project runs on every machine.** Projects are no longer tied to one computer. Pick any project, pick a machine under **Run on**, and launch: if the machine has no checkout of it yet, wisp finds one there (a project or a git repo in the usual folders with the same origin) or clones the repo's origin into the machine's clone folder, then remembers it. The launcher shows one row of projects for all the places you picked, the card says "Cloning … on devbox" while it does that, and the Projects dialog lists every project with the places it's checked out on. A folder you add on a machine that's the same repo as a project you already have joins that project instead of becoming a second one. Repos without a git remote can't be cloned this way; wisp says so.
+- **Move a task to another computer with a follow-up.** The composer has a new **Runs on** button (shown once you have a machine). Pick another computer and your next follow-up moves the task there: its branch, uncommitted and untracked changes travel as a git bundle and land in a worktree on the same branch, and the earlier turns come along as history, so the harness there is told what happened before it continues. The old session is archived with a "Continues on …" link; the new card shows "From …" and tags each earlier turn with where it ran. A running task has to stop or finish first. API: `"machine"` on `POST /sessions/:id/reply` (`""` for this computer).
+- **Rerun on another computer.** The rerun dialog has a **Run on** picker; the rerun uses that computer's checkout of the project, cloned there first if needed.
+- **`/btw` side questions.** Type `/btw did you update the docs too?` in a card's follow-up box to ask while the agent works, without interrupting it. A separate read-only run answers it, and the answer shows on the card under the turn you asked during. Claude Code, Codex and opencode answer on a copy (fork) of the agent's conversation, so they know what the run did and why; the task's own conversation never sees the question. Cursor, Antigravity and Grok, and CLIs too old to fork, get wisp's record of the task instead: requests, reports, actions so far and files changed. It also works when the task isn't running, and it adds no turn. Dismiss an answer with its ×; dismissing one that is still running stops it. Typing `/` in the box opens a small command menu (`/btw`, `/feedback`), and a working task shows a quiet **Tip: `/btw` asks without interrupting** next to Show all activity. Click it to start one in the box. It goes away after your first `/btw`, or when you hide it with its ×. CLI: `wisp btw <id> "question"` prints the answer, and `wisp reply <id> "/btw …"` works too, as does a `/btw` reply from Telegram. API: `POST /sessions/:id/btw`, `DELETE /sessions/:id/btw?item=<id>`. SDK: `wisp.btw(id, text)`.
+
+### Changed
+
+- **No folder is picked by default when wisp has no folders.** With no projects added, the launcher now starts on **No folder**, so a prompt runs right away in an empty scratch directory instead of opening the folder picker. Adding a folder picks it, as before.
+
+- **The website is now [trywisp.dev](https://trywisp.dev/), with more pages for search engines to find.** Canonical, Open Graph, structured-data, `robots.txt`, `llms.txt`, the install script and the npm and Homebrew `homepage` use the new domain. The site gained a page per harness ([Claude Code](https://trywisp.dev/agents/claude-code.html), Codex, Cursor CLI, opencode, Antigravity CLI, Grok Build) that shows how wisp runs that CLI: the flags behind each permission mode, how it asks you questions, `/btw` and the take-over command. An [agents overview](https://trywisp.dev/agents/) compares them, and the integrations guide and changelog are now [pages on the site](https://trywisp.dev/changelog.html) instead of GitHub links. `scripts/site.mjs` (`npm run site`) builds these pages, a `404.html` and a `sitemap.xml` with each page's last-commit date. The Pages workflow runs it before each deploy, redeploys when `CHANGELOG.md` or an adapter changes, and pings IndexNow (Bing and friends) afterwards. The harness logos on the landing page link to their pages.
+
+### Fixed
+
+- **The Auto-fix PR conflicts switch works on its own.** In Settings → General it only responded after you had clicked Worktree per task in the same visit.
+- **Chevrons inside Done cards point the right way.** Showing the Done list rotated every chevron in its cards too, so collapsed cards looked open.
+- **The rerun dialog's Rerun button no longer slides off the edge.** With the **Run on** picker added, the bar under the prompt (place, mode, harness) was wider than the dialog and pushed **Rerun** out of view. The dialog is a little wider, and when space runs short the harness name folds first (its logo stays), then the model; on narrow windows the place and mode buttons show only their icons.
+
 ## [0.21.0] - 2026-10-20
 
 ### Added
@@ -391,7 +420,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.21.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.23.0...HEAD
+[0.23.0]: https://github.com/M0xoo/wisp/compare/v0.22.0...v0.23.0
+[0.22.0]: https://github.com/M0xoo/wisp/compare/v0.21.0...v0.22.0
 [0.21.0]: https://github.com/M0xoo/wisp/compare/v0.20.0...v0.21.0
 [0.20.0]: https://github.com/M0xoo/wisp/compare/v0.19.0...v0.20.0
 [0.19.0]: https://github.com/M0xoo/wisp/compare/v0.18.1...v0.19.0

package/README.md

@@ -15,7 +15,7 @@ Launch coding agents in the background, skip the transcript, and read the presen
 [![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%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)
+[Website](https://trywisp.dev/) · [Quick start](#quick-start) · [Features](#features) · [CLI](#cli) · [Integrations](#integrations) · [Shortcuts](#keyboard-shortcuts) · [Architecture](#architecture) · [Adding a harness](#adding-a-harness) · [Roadmap](#roadmap)
 
 </div>
 
@@ -39,10 +39,11 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 |---|---|
 | 🚀 **Fire and forget** | Launch a task from the UI or from any folder with `wisp "…"`. Each folder becomes a project. |
 | 🎞️ **Presentations, not transcripts** | Agents end with structured blocks that render as an animated, skimmable report. |
+| 📜 **The full transcript, if you want it** | Off by default. Settings → General → *Full transcript*, or a card's **Transcript** button (`V`), shows the agent's messages and every step on a timeline. Click a step to see its output or diff. The presentation still renders as blocks at the end. |
 | ❓ **Live questions** | Agents get an `ask_user` tool, so they can pause mid-run. Your answer goes straight back to the running agent. |
 | 🧾 **Real diffs** | Edits come from the agent's own tool calls, so `diff` blocks show what actually changed. |
 | 📥 **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. |
+| 💬 **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. To ask without interrupting, start with `/btw` (`/btw did you update the docs too?`): a separate read-only run answers on a copy of the conversation, and the agent keeps working. |
 | 🔎 **Command palette** | `⌘K` / `Ctrl+K` fuzzy-searches sessions, projects, and actions. |
 | ✨ **Auto** | The default harness: wisp picks the harness, model and thinking level per task from what worked before, and learns from merges, 👍 / 👎 and follow-ups. See [Auto](#auto). |
 | 🤖 **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. |
@@ -55,7 +56,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.21.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.23.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, or start a task with `/new`. |
 | 🔐 **Permission modes** | Choose **Plan** (read-only), **Edits** (file edits auto-accepted), or **Full auto** (no permission prompts, the default) for each launch. `Shift+Tab` in the prompt cycles modes. In Edits mode, anything the permissions block comes to you: Claude Code waits for **Allow / Always / Deny**, and the other harnesses show an **Allow & retry** card. |
@@ -77,14 +78,14 @@ The first run downloads Electron for the desktop app; if that isn't possible, wi
 Or install it globally to get the `wisp` command everywhere. Pick one:
 
 ```sh
-curl -fsSL https://mokh.xyz/install.sh | bash   # macOS or Linux: checks Node 20+, then npm install -g wisp-agents
+curl -fsSL https://trywisp.dev/install.sh | bash   # macOS or Linux: checks Node 20+, then npm install -g wisp-agents
 npm install -g wisp-agents                      # any OS with Node 20+
 brew install m0xoo/tap/wisp-agents             # Homebrew: CLI and browser mode, no Electron desktop app
 
 wisp "fix the flaky auth test"
 ```
 
-The Homebrew formula lives in [M0xoo/homebrew-tap](https://github.com/M0xoo/homebrew-tap). `install.sh` honors `WISP_VERSION` to pin a release (`curl -fsSL https://mokh.xyz/install.sh | WISP_VERSION=0.21.0 bash`).
+The Homebrew formula lives in [M0xoo/homebrew-tap](https://github.com/M0xoo/homebrew-tap). `install.sh` honors `WISP_VERSION` to pin a release (`curl -fsSL https://trywisp.dev/install.sh | WISP_VERSION=0.23.0 bash`).
 
 From source:
 
@@ -130,10 +131,11 @@ 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; --mode, --agent, --model to switch)
+wisp btw <id> "did you do X?"     # ask on the side without interrupting the run; prints the answer
 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.21.0            # run a recipe; values fill its {params} (or version=0.21.0)
+wisp run release 0.23.0            # run a recipe; values fill its {params} (or version=0.23.0)
 wisp recipes                      # list recipes
 wisp usage [--days 7]             # spend and outcomes
 wisp mcp                          # MCP server for other agents and editors
@@ -200,6 +202,7 @@ console.log((await wisp.wait(s.id)).state, (await wisp.presentation(s.id)).markd
 | `M` | Rename |
 | `⌫` | Delete |
 | `R` | Replay the presentation |
+| `V` | Switch between the full transcript and the presentation |
 | `C` | Collapse all |
 | `U` | Back to top (also `Home`) |
 | `?` | Show all shortcuts |
@@ -301,7 +304,7 @@ If the harness has no system-prompt flag, prepend `systemPrompt` to the first pr
 
 ## Auto
 
-**Auto** is the default harness: wisp picks the harness, model and thinking level for each task. Its "model" is a goal: **Balanced** (best result per dollar), **Cheap** or **Best**. The goal also sets how hard the agent thinks: Cheap runs at low (or minimal), Balanced at the harness's default or medium, Best at high or x-high. A harness or model without levels runs at its default.
+**Auto** is the default harness: wisp picks the harness, model and thinking level for each task. Its "model" is a goal: **Balanced** (the default), **Cheap** or **Best**. Balanced and Best both run frontier models (Opus, not Sonnet or Haiku) when you have one installed and allowed; what sets them apart is how hard the agent thinks: Balanced runs at the harness's default or medium, Best at high or x-high. Cheap runs at low (or minimal) on whichever model does the job for least. A harness or model without levels runs at its default; for models with the level in their name (Antigravity's `gemini-4-argon-high`) the goal picks the variant the same way.
 
 How it picks: every harness · model · thinking level you have installed is an option (`claude:opus:high`). For the kind of task (bug, feature, UI, tests, refactor, docs, release, question) Auto keeps an estimate of how often each option does it well. The estimate starts from a small wisp-bench pilot that ships with wisp (`server/router-priors.json`), then counts your own outcomes: merged PR (best), closed PR, 👍 / 👎, rollback, then how the run ended, less a bit for each follow-up you needed. It draws from each estimate (Thompson sampling), so options with little data now and then get a turn, and takes the best value for the goal after expected cost and time. A launch with `important: true` (API, SDK) gets the best-known option, with no trying. Options that keep failing a kind of task are left out of it. Thinking harder starts out a little more likely to work and costs more, and then your outcomes decide. A model's record at one level counts half at its other levels.
 
@@ -316,7 +319,7 @@ After the run, Auto checks the work before it lands in your queue:
 3. **Repair**: new failures go back to the same agent (1 round by default, up to 2).
 4. **Hand over**: still failing, or the run errored, so the task runs again on a stronger tier (small → everyday → frontier) in its own worktree, next to the first run.
 
-A harness that says it's at its limit (session or usage limit, rate limit, no credit) isn't failing the task. Auto rests it until the limit resets, doesn't count the run against it, and moves the task to the best pick that can run now. Best always runs frontier models only (Opus, not Sonnet or Haiku); it falls back to the strongest you have only when no frontier model is installed. Until Auto has 20 of your own outcomes, Balanced picks only everyday and frontier models. The shipped estimates come from a small pilot, so they count for at most 4 tasks each.
+A harness that says it's at its limit (session or usage limit, rate limit, no credit) isn't failing the task. Auto rests it until the limit resets, doesn't count the run against it, and moves the task to the best pick that can run now. Best always runs frontier models only; it falls back to the strongest you have only when no frontier model is installed. Balanced runs on the strongest tier that can run now, whatever the record of the weaker models: frontier, or everyday (Sonnet, never Haiku) while every frontier model is at its limit or when you have none. The shipped estimates come from a small pilot, so they count for at most 4 tasks each.
 5. **Best of two** (goal Best, off by default): two picks work side by side; tests decide, then a cheap model reads both diffs, and the better run is marked **Pick**.
 
 Each step's outcome feeds the router: a test pass counts more than the agent's "done", needing a repair counts less, and losing a best-of-2 a little less again. Your own follow-up stops whatever Auto was about to do next. A launch on a machine is checked on that machine, where the files are. Settings → Auto turns each step on or off and sets the test command per project.
@@ -351,7 +354,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.21.0` fills the fields in order, `wisp run release version=0.21.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.23.0` fills the fields in order, `wisp run release version=0.23.0` by name.
 
 **Triggers** launch sessions on their own while wisp is open (⌘K → *Triggers*):
 
@@ -385,10 +388,12 @@ They receive titles, summaries and questions (with their context), never code or
 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.
+Every project runs on every machine. In the launcher, **Run on** (next to the harness) picks where the prompt goes: this computer, any machine, or several at once. A machine without a checkout of the project gets one first: wisp reuses a clone of the same repo it finds there, or clones the project's origin (repos without a remote can't be cloned; add their folder on the machine in Projects instead). Enter launches on every place 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. When the machine runs an older wisp than this computer, **Update to X** next to its version restarts it there as this version. 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.
 
+A task can change computers mid-way: the **Runs on** button next to the composer moves your next follow-up (and the task) to another computer. The task's branch and uncommitted work travel as a git bundle into a worktree there, on the same branch, and its earlier turns come along so the harness picks up where the other one stopped. The old session is archived and links to the new one. **Rerun** has the same picker.
+
 ## 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

@@ -4,7 +4,7 @@
 //   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 ls | show | wait | reply | btw | 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
@@ -26,6 +26,7 @@ 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  --mode plan|edits|auto
                                 --agent ID  --model ID  --effort LEVEL: switch harness / model from here on)
+  wisp btw <id> "question"      ask on the side without interrupting the run; prints the answer
   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
@@ -40,7 +41,7 @@ launch options: --mode plan|edits|auto  --agent claude|codex|opencode|cursor|ant
                 --cwd DIR  --also DIR (repeatable)  --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', 'ship', 'merge', 'run', 'recipes', 'usage']);
+const COMMANDS = new Set(['add', 'ls', 'list', 'show', 'wait', 'reply', 'btw', '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, also: [], json: false, wait: false, queue: undefined, state: null, limit: null, project: false, worktree: undefined, compare: null, draft: false, days: null };
 const words = [];
@@ -80,7 +81,7 @@ for (let i = 0; i < argv.length; i++) {
 // 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 FITS = { ship: (w) => SESSION_ID.test(w[1] || ''), merge: (w) => SESSION_ID.test(w[1] || ''), btw: (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) => {
@@ -108,6 +109,7 @@ async function scripted(cmd, args) {
   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 btw = (b) => out(b, b.status === 'done' ? b.answer : b.status === 'running' ? '  … still answering; it will show on the card' : `  ! ${b.error}`);
   const show = async (id, summary) => {
     const p = await wisp.presentation(id);
     const s = summary || (await wisp.sessions()).find((x) => x.id === id);
@@ -135,9 +137,14 @@ async function scripted(cmd, args) {
     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, mode: flags.mode || undefined, agent: flags.agent || undefined, model: flags.model ?? undefined, effort: flags.effort ?? undefined });
+      if (r.btw) return btw(await wisp.btwAnswer(id, r.btw.id)); // "/btw …": a side question
       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 'btw': {
+      const id = need(args[0], 'session id');
+      return btw(await wisp.btw(id, need(args.slice(1).join(' ').trim(), 'question')));
+    }
     case 'stop':
       return out(await wisp.stop(need(args[0], 'session id')), '  ✓ stopped');
     case 'ship': {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wisp-agents",
-  "version": "0.21.0",
-  "description": "Launch coding agents, skip the transcript, read the presentation.",
+  "version": "0.23.0",
+  "description": "Run Claude Code, Codex, Cursor and other coding agents in parallel, in the background, on any of your machines. Skip the transcript, read the report.",
   "type": "module",
   "bin": {
     "wisp": "bin/wisp.js",
@@ -20,7 +20,8 @@
     "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/machines.test.js test/feedback.test.js test/router.test.js test/routes.test.js test/adapters-exit.test.js test/web-pure.test.js test/install.test.js test/install-script.test.js test/mentions.test.js test/clone.test.js test/pipeline.test.js test/commands.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/feedback.test.js test/router.test.js test/routes.test.js test/adapters-exit.test.js test/web-pure.test.js test/install.test.js test/install-script.test.js test/mentions.test.js test/clone.test.js test/pipeline.test.js test/commands.test.js test/btw.test.js test/site.test.js",
+    "site": "node scripts/site.mjs",
     "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"
   },
@@ -30,7 +31,17 @@
   "keywords": [
     "claude",
     "claude-code",
+    "codex",
+    "openai-codex",
+    "cursor",
+    "opencode",
     "coding-agent",
+    "ai-agents",
+    "multi-agent",
+    "parallel",
+    "git-worktree",
+    "ssh",
+    "orchestration",
     "ai",
     "agents",
     "cli",
@@ -44,7 +55,7 @@
     "type": "git",
     "url": "git+https://github.com/M0xoo/wisp.git"
   },
-  "homepage": "https://mokh.xyz/",
+  "homepage": "https://trywisp.dev/",
   "bugs": {
     "url": "https://github.com/M0xoo/wisp/issues"
   },

package/server/adapters/claude.js

@@ -32,6 +32,7 @@ export default {
   name: 'Claude Code',
   // Asks wisp before a tool call its permission mode won't allow on its own (Edits mode).
   approveTool: 'mcp__wisp__approve',
+  fork: true, // run({ resumeId, fork }) answers on a copy of the conversation (/btw)
   models: [
     { id: '', label: 'Default', hint: 'Whatever Claude Code is set to' },
     { id: 'opus', label: 'Opus', hint: 'Most capable, for hard problems' },
@@ -57,7 +58,8 @@ export default {
   // Returns { stop(), done: Promise<void> }. Everything else is reported through onEvent.
   // grants: --allowedTools rules (Bash(npm publish)) for what the user allowed after a denial.
   // dirs: the task's other folders, which it may read and edit like cwd.
-  run({ prompt, attachments = [], cwd, dirs: extra = [], resumeId, mode, model, effort, systemPrompt, mcpServers = {}, delegating = false, grants = [], onEvent }) {
+  // fork: resume a throwaway copy of resumeId's conversation, leaving the original as it is.
+  run({ prompt, attachments = [], cwd, dirs: extra = [], resumeId, fork = false, mode, model, effort, systemPrompt, mcpServers = {}, delegating = false, grants = [], onEvent }) {
     const args = [
       '-p',
       '--output-format', 'stream-json',
@@ -68,6 +70,7 @@ export default {
     if (effort) args.push('--effort', effort);
     if (chromeEnabled()) args.push('--chrome');
     if (resumeId) args.push('--resume', resumeId);
+    if (resumeId && fork) args.push('--fork-session', '--no-session-persistence');
     if (Object.keys(mcpServers).length) args.push('--mcp-config', JSON.stringify({ mcpServers }));
     // In Edits mode, what would prompt goes to wisp's approve tool (the user decides) instead of being denied.
     if (mcpServers.wisp && mode === 'edits') args.push('--permission-prompt-tool', this.approveTool);
@@ -108,17 +111,18 @@ export default {
             onEvent({ type: 'thinking' });
           } else if (part.type === 'tool_use') {
             pendingTools.set(part.id, part.name);
-            onEvent({ type: 'tool', ...describeTool(part.name, part.input || {}, cwd) });
+            onEvent({ type: 'tool', id: part.id, ...describeTool(part.name, part.input || {}, cwd) });
             const change = captureChange(part.name, part.input || {}, cwd);
             if (change) onEvent({ type: 'change', ...change });
           }
         }
       } else if (msg.type === 'user') {
         for (const part of msg.message?.content || []) {
-          if (part.type === 'tool_result' && part.is_error) {
+          if (part.type !== 'tool_result') continue;
+          if (part.is_error) {
             const name = pendingTools.get(part.tool_use_id);
             onEvent({ type: 'tool_error', name, text: flatten(part.content).slice(0, 400) });
-          }
+          } else onEvent({ type: 'tool_output', id: part.tool_use_id, text: flatten(part.content) });
         }
       } else if (msg.type === 'system') {
         // background_tasks_changed carries the full list; task_started/task_notification are the

package/server/adapters/codex.js

@@ -1,7 +1,7 @@
 // Codex CLI adapter — drives `codex exec --json` (JSONL thread/turn/item events).
 
 import path from 'node:path';
-import { ASK_TIMEOUT_MS, attachmentNote, clip, detectVersion, exitText, fileTracker, rel, spawnJsonl, withProtocol } from './common.js';
+import { ASK_TIMEOUT_MS, attachmentNote, clip, detectVersion, exitText, fileTracker, flatten, rel, spawnJsonl, withProtocol } from './common.js';
 import { describeCommand } from './commands.js';
 
 const BIN = process.env.WISP_CODEX_BIN || 'codex';
@@ -21,6 +21,7 @@ export default {
   id: 'codex',
   name: 'Codex',
   askTool: 'mcp__wisp__ask_user',
+  fork: true, // run({ resumeId, fork }) answers on a copy of the conversation (/btw)
   models: [{ id: '', label: 'Default', hint: 'Whatever Codex is set to' }],
   efforts: ['minimal', 'low', 'medium', 'high', 'xhigh'],
 
@@ -33,7 +34,8 @@ export default {
   },
 
   // dirs: the task's other folders, writable like cwd.
-  run({ prompt, attachments = [], cwd, dirs: extra = [], resumeId, mode, model, effort, systemPrompt, mcpServers = {}, onEvent }) {
+  // fork: `exec fork` a copy of resumeId's conversation instead of resuming it (/btw).
+  run({ prompt, attachments = [], cwd, dirs: extra = [], resumeId, fork = false, mode, model, effort, systemPrompt, mcpServers = {}, onEvent }) {
     const args = ['exec', '--json', '--skip-git-repo-check'];
     // `resume` doesn't take --sandbox, so set it through config for both paths.
     if (mode === 'auto') args.push('--dangerously-bypass-approvals-and-sandbox');
@@ -54,7 +56,7 @@ export default {
       const dirs = [...new Set([...extra, ...attachments.map((a) => path.dirname(a.path))])];
       for (const d of dirs) args.push('--add-dir', d);
     }
-    if (resumeId) args.push('resume', resumeId);
+    if (resumeId) args.push(fork ? 'fork' : 'resume', resumeId);
     // No prompt argument: codex reads it from stdin.
 
     let input = withProtocol(prompt, systemPrompt, resumeId);
@@ -73,9 +75,9 @@ export default {
       const type = item.type || item.item_type;
       if (phase === 'started') {
         if (type === 'command_execution') {
-          onEvent({ type: 'tool', kind: 'run', label: describeCommand(unwrapShell(item.command), cwd), detail: item.command });
+          onEvent({ type: 'tool', id: item.id, kind: 'run', label: describeCommand(unwrapShell(item.command), cwd), detail: item.command });
         } else if (type === 'mcp_tool_call') {
-          onEvent({ type: 'tool', ...describeMcp(item) });
+          onEvent({ type: 'tool', id: item.id, ...describeMcp(item) });
         } else if (type === 'web_search') {
           onEvent({ type: 'tool', kind: 'web', label: item.query ? `Searching the web: ${clip(item.query, 50)}` : 'Searching the web' });
         }
@@ -103,7 +105,7 @@ export default {
         case 'command_execution':
           if (item.status === 'failed' || (item.exit_code != null && item.exit_code !== 0)) {
             onEvent({ type: 'tool_error', name: clip(unwrapShell(item.command), 40), text: clip(item.aggregated_output || `exit ${item.exit_code}`, 400) });
-          }
+          } else if (item.aggregated_output) onEvent({ type: 'tool_output', id: item.id, text: item.aggregated_output });
           break;
         case 'file_change':
           for (const c of item.changes || []) {
@@ -116,6 +118,7 @@ export default {
           break;
         case 'mcp_tool_call':
           if (item.status === 'failed') onEvent({ type: 'tool_error', name: `${item.server}.${item.tool}`, text: clip(item.error?.message || 'failed', 400) });
+          else if (item.result?.content) onEvent({ type: 'tool_output', id: item.id, text: flatten(item.result.content) });
           break;
         case 'todo_list': {
           const next = item.items?.find((t) => !t.completed);

package/server/adapters/cursor.js

@@ -67,7 +67,7 @@ export default {
             const args = body.args || {};
             if (msg.subtype === 'started') {
               if ((name === 'editToolCall' || name === 'deleteToolCall') && args.path) files.remember(args.path);
-              onEvent({ type: 'tool', ...describeTool(name, args, cwd) });
+              onEvent({ type: 'tool', id: msg.call_id, ...describeTool(name, args, cwd) });
             } else if (msg.subtype === 'completed') {
               const [outcome, value = {}] = resultOf(body.result);
               if (outcome && outcome !== 'success') {
@@ -77,6 +77,9 @@ export default {
               } else if (name === 'editToolCall' || name === 'deleteToolCall') {
                 const change = editChange(args.path || value.path, value, cwd, files);
                 if (change) onEvent({ type: 'change', ...change });
+              } else {
+                const output = [value.stdout, value.stderr].filter((x) => typeof x === 'string' && x).join('\n') || (typeof value.content === 'string' ? value.content : '');
+                if (output) onEvent({ type: 'tool_output', id: msg.call_id, text: output });
               }
             }
             break;

package/server/adapters/grok.js

@@ -108,7 +108,7 @@ export default {
                 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) });
+                onEvent({ type: 'tool', id: part.id, ...describeTool(part.name, input, cwd) });
               }
             }
             break;
@@ -122,6 +122,7 @@ export default {
               else {
                 const change = captureChange(call.name, call.input, cwd, files);
                 if (change) onEvent({ type: 'change', ...change });
+                else onEvent({ type: 'tool_output', id: part.tool_use_id, text: flatten(part.content) });
               }
             }
             break;

package/server/adapters/index.js

@@ -9,6 +9,8 @@
 //                                                  null = can't inject MCP, ask via a question block
 //     approveTool?: string                         its permission prompts go to wisp's `approve` MCP
 //                                                  tool (live approval); omit if it can't route them
+//     fork?: true                                  run({ resumeId, fork: true }) works on a copy of
+//                                                  that conversation, leaving it as it is (/btw)
 //     permission?(tool, input, cwd): { tool, action, detail, why? }   what a live approval is about
 //     detect(): Promise<{ available, version?, error?, models? }>   models overrides the static list
 //     resumeCommand({ resumeId, model, effort }): string[]   argv to continue the session interactively
@@ -19,9 +21,12 @@
 //
 // onEvent receives normalized events:
 //   { type: 'session', id }                         agent-side session id (used to resume follow-ups)
-//   { type: 'tool', kind, label, file?, detail? }   kind: read|edit|run|search|web|agent|plan|tool
+//   { type: 'tool', kind, label, file?, detail?, id?, output? }   kind: read|edit|run|search|web|agent|plan|tool
+//                                                  id: the harness's call id, for a later tool_output;
+//                                                  output: what it returned, if it reports calls once run
+//   { type: 'tool_output', id, text }               what a finished call returned (the transcript shows it)
 //   { type: 'tool_error', name, text }
-//   { type: 'text', text }                          intermediate assistant prose
+//   { type: 'text', text }                          assistant prose, the final answer included
 //   { type: 'thinking' }
 //   { type: 'change', file, op, edits: [{ before, after }] }
 //   { type: 'blocked', tool, detail, rule? }        a call its permissions refused; rule: what allows

package/server/adapters/opencode.js

@@ -27,6 +27,7 @@ export default {
   id: 'opencode',
   name: 'opencode',
   askTool: 'wisp_ask_user',
+  fork: true, // run({ resumeId, fork }) answers on a copy of the session (/btw)
   models: [{ id: '', label: 'Default', hint: 'Whatever opencode is set to' }],
 
   resumeCommand({ resumeId, model }) {
@@ -67,7 +68,8 @@ export default {
   },
 
   // grants: { permission, patterns } the user allowed after `run` rejected them, for this turn.
-  run({ prompt, attachments = [], cwd, resumeId, mode, model, effort, systemPrompt, mcpServers = {}, delegating = false, grants = [], onEvent }) {
+  // fork: continue a copy of resumeId's session instead of the session itself (/btw).
+  run({ prompt, attachments = [], cwd, resumeId, fork = false, mode, model, effort, systemPrompt, mcpServers = {}, delegating = false, grants = [], onEvent }) {
     // The prompt goes on stdin; `run` appends piped stdin to the (empty) message.
     // Errors to stderr: the only place a rate limit shows up (see RATE_LIMITED).
     const args = ['run', '--format', 'json', '--print-logs', '--log-level', 'ERROR'];
@@ -76,6 +78,7 @@ export default {
     if (model) args.push('--model', model);
     if (model && effort) args.push('--variant', effort);
     if (resumeId) args.push('--session', resumeId);
+    if (resumeId && fork) args.push('--fork');
     for (const a of attachments) args.push('--file', a.path);
 
     // Inject the ask_user server through inline config, merged over the user's own.
@@ -152,7 +155,7 @@ export default {
             // Emitted once the tool has finished, with its input and output.
             const state = part.state || {};
             const input = state.input || {};
-            onEvent({ type: 'tool', ...describeTool(part.tool, input, cwd) });
+            onEvent({ type: 'tool', ...describeTool(part.tool, input, cwd), ...(state.status !== 'error' && typeof state.output === 'string' && { output: state.output }) });
             if (state.status === 'error') onEvent({ type: 'tool_error', name: part.tool, text: clip(state.error || state.output, 400) });
             else {
               for (const change of captureChanges(part.tool, input, state.metadata || {}, cwd, files)) onEvent({ type: 'change', ...change });

package/server/btw.js

@@ -0,0 +1,76 @@
+// /btw: a side question about a task ("/btw did you also update the docs?"), answered while its
+// run carries on. The answer comes from a read-only run of its own: a fork of the agent's
+// conversation where the harness can fork one, so it knows everything the run did and why; else a
+// fresh run that gets wisp's record of the task. Nothing goes back into the task's conversation.
+
+import { turnText } from './handoff.js';
+import { textMentions } from './mentions.js';
+import { blocksToMarkdown } from './render.js';
+import { parsePresentation } from './protocol.js';
+import { clip, truncate } from './util.js';
+
+export const BTW_CMD = /^\/btw(?:\s+|$)/i;
+export const MAX_BTW = 3; // side questions running at once, per task
+export const BTW_TIMEOUT_MS = 5 * 60_000;
+const DIGEST_TURNS = 4; // earlier turns written out for a run that can't fork
+const LIVE_ACTS = 40; // the running turn's latest actions it gets to see
+
+// The question in "/btw did you …", or null when the text isn't a /btw.
+export function btwQuestion(text) {
+  const t = String(text || '').trim();
+  return BTW_CMD.test(t) ? t.replace(BTW_CMD, '').trim() : null;
+}
+
+// Marks the run as a side question (the system prompt, where the harness takes one).
+export const BTW_SYSTEM = '# wisp btw\n\nYou answer a side question about a coding task. You only read; you change nothing.';
+
+const rules = (forked) => `# wisp btw
+
+The user has a quick side question (/btw) about this task. ${forked ? 'This is a copy of the conversation so far: the original keeps working on the task in parallel, and it' : 'Another agent run is working on this task, and it'} does the work. This reply only answers the user.
+
+- Answer just the question, briefly: a few sentences or a short list, in plain markdown.
+- Change nothing: no edits, no file writes, no commits, no commands with side effects. Reading files, \`git diff\` and \`git status\` is fine when you need to check.
+- No wisp presentation block and no wisp tools (ask_user, delegate): this isn't a task result.
+- If you can't tell from what's here, say so instead of guessing.`;
+
+// What the task has been doing, for a run that can't fork the conversation: the earlier turns'
+// requests and reports, and the latest turn's actions so far.
+export function btwDigest(session, name = (t) => t.agent || session.agent) {
+  const turns = session.turns || [];
+  const parts = [];
+  const from = Math.max(0, turns.length - DIGEST_TURNS);
+  if (from) parts.push(`_${from} earlier turn${from > 1 ? 's' : ''} left out._`);
+  turns.slice(from).forEach((t, i) => {
+    const n = from + i + 1;
+    if (t.status !== 'running') return parts.push(turnText(t, n, name));
+    const acts = (t.activity || []).filter((a) => a.kind !== 'text').slice(-LIVE_ACTS);
+    const said = (t.activity || []).findLast((a) => a.kind === 'text')?.label;
+    const files = (t.changes || []).map((c) => `\`${c.file}\``);
+    parts.push(
+      [
+        `### Turn ${n} · ${name(t)} · still running (started ${Math.max(1, Math.round((Date.now() - t.startedAt) / 60_000))} min ago)`,
+        `**User:** ${textMentions(t.prompt)}`,
+        acts.length && `**What it has done so far (oldest first):**\n${acts.map((a) => `- ${clip(a.label, 160)}`).join('\n')}`,
+        files.length && `**Files it edited so far:** ${files.join(', ')}`,
+        said && `**Its latest message:** ${truncate(said, 1200)}`,
+      ]
+        .filter(Boolean)
+        .join('\n\n'),
+    );
+  });
+  return parts.join('\n\n');
+}
+
+// forked: the run resumes a copy of the conversation, so it already knows the task.
+export function btwPrompt(session, question, { forked, name } = {}) {
+  const head = rules(forked);
+  if (forked) return `${head}\n\n## Side question\n\n${question}`;
+  return `${head}\n\n## The task so far\n\n${btwDigest(session, name)}\n\n---\n\n## Side question\n\n${question}`;
+}
+
+// The reply as markdown. An agent that ended with a wisp block anyway gets it rendered.
+export function btwAnswer(text) {
+  const p = parsePresentation(String(text || ''));
+  const md = p.fallback ? String(text || '').trim() : [p.notes, blocksToMarkdown(p.blocks)].filter(Boolean).join('\n\n');
+  return md || '_No answer._';
+}

package/server/client.js

@@ -160,6 +160,25 @@ export class WispClient {
   // run it, and the follow-ups after it, on another harness, model or thinking level.
   reply = (id, text, { attachments, queue, mode, agent, model, effort } = {}) => this.request('POST', `/sessions/${id}/reply`, { text, attachments, queue, mode, agent, model, effort });
 
+  // A side question (/btw): a read-only run of its own answers it while the task's run carries on.
+  // Resolves with { id, question, status: done | error, answer | error } once it's answered
+  // (status stays running if timeoutMs runs out first), or right away with wait: false.
+  async btw(id, text, { attachments, wait = true, timeoutMs = 6 * 60_000 } = {}) {
+    const q = await this.request('POST', `/sessions/${id}/btw`, { text, attachments });
+    return wait ? this.btwAnswer(id, q.id, { timeoutMs }) : q;
+  }
+
+  async btwAnswer(id, btwId, { timeoutMs = 6 * 60_000 } = {}) {
+    const end = Date.now() + timeoutMs;
+    for (;;) {
+      const s = await this.request('GET', `/sessions/${id}`);
+      const b = s.turns.flatMap((t) => t.btw || []).find((x) => x.id === btwId);
+      if (!b) return { id: btwId, status: 'error', error: 'It was dismissed.' };
+      if (b.status !== 'running' || Date.now() > end) return b;
+      await new Promise((r) => setTimeout(r, 1500));
+    }
+  }
+
   // Upload a file (path, Buffer or Uint8Array) to attach to a launch or reply. Returns { id, … }.
   async upload(file, { name, type } = {}) {
     const data = typeof file === 'string' ? fs.readFileSync(file) : file;