wisp-agents 0.20.0 → 0.22.0

package/CHANGELOG.md

@@ -5,6 +5,38 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [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
+
+- **One task across several folders.** A task can now work in more than one project at a time, for example an API and the web app that uses it. In the launcher, ⌘-click (Ctrl- or Shift-click) a second project chip, or click the **+** on its corner or next to it in the project list. One agent starts in the first folder and can read and edit the others: Claude Code and Codex get them as `--add-dir`, and every harness is told the paths. Each git repo gets its own worktree. The card reads `api + web` and shows up under either project's filter. **Ship it** opens a pull request in each repo that has changes, and **Merge all** merges them together and syncs each local base branch. CLI: `wisp "…" --also ~/code/web` (repeatable). API: `"also": [folders]` on `POST /sessions`. MCP: `also` on `wisp_launch`.
+
+### Fixed
+
+- **The launcher's project row no longer throws while it isn't laid out.** Refitting the chips of a launcher that had just been painted over (or folded into the dock) read the position of a chip that wasn't there.
+
 ## [0.20.0] - 2026-10-19
 
 ### Added
@@ -381,7 +413,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.20.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.22.0...HEAD
+[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
 [0.18.1]: https://github.com/M0xoo/wisp/compare/v0.18.0...v0.18.1

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,22 +39,24 @@ 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. |
 | 🖥️ **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). |
+| 🗂️ **One task, several folders** | ⌘-click a second project in the launcher (or its **+**) and one agent works in both, e.g. the API and the web app that uses it. Each git repo gets its own worktree, and **Ship it** opens a PR in each. |
 | 🌿 **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.20.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.22.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. |
@@ -76,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.20.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.22.0 bash`).
 
 From source:
 
@@ -129,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.20.0            # run a recipe; values fill its {params} (or version=0.20.0)
+wisp run release 0.22.0            # run a recipe; values fill its {params} (or version=0.22.0)
 wisp recipes                      # list recipes
 wisp usage [--days 7]             # spend and outcomes
 wisp mcp                          # MCP server for other agents and editors
@@ -146,6 +149,7 @@ wisp skill install                # install the wisp skill for Claude Code (--ag
 | `--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) |
+| `--also DIR` | Another folder the same task works in; repeat for more (each git repo gets its own worktree and PR) |
 | `--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 |
@@ -198,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 |
@@ -329,6 +334,8 @@ In a git repo, every launch (except Plan mode) runs in its own [git worktree](ht
 
 **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.
 
+**Several folders.** A task can span projects: ⌘/Ctrl-click (or Shift-click) another project chip in the launcher, or use the **+** on its corner or in the project list. The agent starts in the first folder and gets the others as extra working directories (`--add-dir` for Claude Code and Codex; the rest are told the paths). Each git repo gets its own worktree on the task's branch name, the card reads `api + web` and lists under either project's filter, and **Ship it** commits, pushes and opens a PR per repo with changes, each noting the others. **Merge all** squash-merges them in order and syncs each local base branch. From the CLI or API: `wisp "…" --also ~/code/web`, `"also": ["~/code/web"]` on `POST /sessions`, or `also` on the `wisp_launch` MCP tool. wisp fixes merge conflicts only on the first repo's PR, and checkpoints and rollback cover the first folder.
+
 Turn worktrees off in Settings → *Worktree per task*, with the launcher's **Worktree / In place** toggle, or per launch (`--no-worktree`, `"worktree": false`).
 
 ## Subagents
@@ -347,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.20.0` fills the fields in order, `wisp run release version=0.20.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.22.0` fills the fields in order, `wisp run release version=0.22.0` by name.
 
 **Triggers** launch sessions on their own while wisp is open (⌘K → *Triggers*):
 
@@ -381,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
@@ -37,12 +38,12 @@ const HELP = `usage:
   wisp -- "ls the repo"         a task that starts with a command name
 
 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],…
+                --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, json: false, wait: false, queue: undefined, state: null, limit: null, project: false, worktree: undefined, compare: null, draft: false, days: null };
+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 = [];
 let literal = false;
 for (let i = 0; i < argv.length; i++) {
@@ -57,6 +58,7 @@ for (let i = 0; i < argv.length; i++) {
   else if (a === '--model') flags.model = argv[++i];
   else if (a === '--effort') flags.effort = argv[++i];
   else if (a === '--cwd' || a === '-C') flags.cwd = path.resolve(argv[++i].replace(/^~(?=$|[\\/])/, os.homedir()));
+  else if (a === '--also') flags.also.push(path.resolve(argv[++i].replace(/^~(?=$|[\\/])/, os.homedir())));
   else if (a === '--state') flags.state = argv[++i];
   else if (a === '--limit') flags.limit = Number(argv[++i]);
   else if (a === '--json') flags.json = true;
@@ -79,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) => {
@@ -107,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);
@@ -114,7 +117,7 @@ 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, worktree: flags.worktree, compare: flags.compare || undefined });
+      const s = await wisp.launch({ prompt: args.join(' '), cwd, also: flags.also, 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…`);
@@ -134,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,6 +1,6 @@
 {
   "name": "wisp-agents",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Launch coding agents, skip the transcript, read the presentation.",
   "type": "module",
   "bin": {
@@ -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"
   },
@@ -44,7 +45,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' },
@@ -41,8 +42,8 @@ export default {
   efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
 
   // Interactive command to take over a session in a terminal.
-  resumeCommand({ resumeId, model, effort }) {
-    return [BIN, ...(resumeId ? ['--resume', resumeId] : []), ...(model ? ['--model', model] : []), ...(effort ? ['--effort', effort] : [])];
+  resumeCommand({ resumeId, model, effort, dirs = [] }) {
+    return [BIN, ...(resumeId ? ['--resume', resumeId] : []), ...(model ? ['--model', model] : []), ...(effort ? ['--effort', effort] : []), ...dirs.flatMap((d) => ['--add-dir', d])];
   },
 
   detect() {
@@ -56,7 +57,9 @@ 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.
-  run({ prompt, attachments = [], cwd, resumeId, mode, model, effort, systemPrompt, mcpServers = {}, delegating = false, grants = [], onEvent }) {
+  // dirs: the task's other folders, which it may read and edit like cwd.
+  // 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',
@@ -67,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);
@@ -74,7 +78,7 @@ export default {
     if (allowed.length) args.push('--allowedTools', ...allowed);
     // 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)))];
+    const dirs = [...new Set([...extra, ...attachments.map((a) => path.dirname(a.path))])];
     if (dirs.length) args.push('--add-dir', ...dirs);
     args.push('--verbose'); // terminates the variadic flags above
     prompt += attachmentNote(attachments, 'Read images and PDFs with the Read tool');
@@ -107,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'],
 
@@ -32,11 +33,15 @@ export default {
     return detectVersion(BIN);
   },
 
-  run({ prompt, attachments = [], cwd, resumeId, mode, model, effort, systemPrompt, mcpServers = {}, onEvent }) {
+  // dirs: the task's other folders, writable like cwd.
+  // 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');
     else args.push('-c', `sandbox_mode=${toml(SANDBOX[mode] || 'workspace-write')}`);
+    // `resume` doesn't take --add-dir either: the other folders are writable roots through config.
+    if (extra.length && mode !== 'auto') args.push('-c', `sandbox_workspace_write.writable_roots=${toml(extra)}`);
     if (model) args.push('-m', model);
     if (effort) args.push('-c', `model_reasoning_effort=${toml(effort)}`);
     for (const [name, srv] of Object.entries(mcpServers)) {
@@ -48,10 +53,10 @@ export default {
     const images = attachments.filter((a) => IMAGE.test(a.mime));
     for (const img of images) args.push('-i', img.path);
     if (!resumeId) {
-      const dirs = [...new Set(attachments.map((a) => path.dirname(a.path)))];
+      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);
@@ -70,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' });
         }
@@ -100,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 || []) {
@@ -113,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._';
+}