wisp-agents 0.20.0 → 0.21.0

package/CHANGELOG.md

@@ -5,6 +5,16 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [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 +391,8 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 - Session queue with follow-ups, answers to agent questions, terminal takeover and mark-as-done.
 - Older turns are folded, with a floating collapse-all button and back-to-top.
 
-[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.20.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.21.0...HEAD
+[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

@@ -49,12 +49,13 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 | 🖥️ **Take over** | Opens your terminal with the harness's resume command (`claude --resume <id>`, `codex resume <id>`, …) in the project folder. Works with Terminal, iTerm, Ghostty, Warp, cmux, kitty, WezTerm, GNOME Terminal, Konsole, Alacritty, Windows Terminal, PowerShell, or a custom command. |
 | 📎 **Attachments** | Paste screenshots or drop images, video, logs, or PDFs into the launcher. |
 | 🧠 **Learns as you go** | After a session goes quiet, a background retro records your preferences and the agent's lessons (a mistake and the way that worked), globally and per project. Later runs get them in their prompt. See [Learning](#learning). |
+| 🗂️ **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.21.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. |
@@ -83,7 +84,7 @@ brew install m0xoo/tap/wisp-agents             # Homebrew: CLI and browser mode,
 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://mokh.xyz/install.sh | WISP_VERSION=0.21.0 bash`).
 
 From source:
 
@@ -132,7 +133,7 @@ wisp reply <id> "also do X"       # follow up (answers a pending question; --mod
 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.21.0            # run a recipe; values fill its {params} (or version=0.21.0)
 wisp recipes                      # list recipes
 wisp usage [--days 7]             # spend and outcomes
 wisp mcp                          # MCP server for other agents and editors
@@ -146,6 +147,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 |
@@ -329,6 +331,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 +351,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.21.0` fills the fields in order, `wisp run release version=0.21.0` by name.
 
 **Triggers** launch sessions on their own while wisp is open (⌘K → *Triggers*):
 

package/bin/wisp.js

@@ -37,12 +37,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 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 +57,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;
@@ -114,7 +115,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…`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wisp-agents",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Launch coding agents, skip the transcript, read the presentation.",
   "type": "module",
   "bin": {

package/server/adapters/claude.js

@@ -41,8 +41,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 +56,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.
-  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.
+  run({ prompt, attachments = [], cwd, dirs: extra = [], resumeId, mode, model, effort, systemPrompt, mcpServers = {}, delegating = false, grants = [], onEvent }) {
     const args = [
       '-p',
       '--output-format', 'stream-json',
@@ -74,7 +75,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');

package/server/adapters/codex.js

@@ -32,11 +32,14 @@ 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.
+  run({ prompt, attachments = [], cwd, dirs: extra = [], resumeId, 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,7 +51,7 @@ 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);

package/server/client.js

@@ -132,14 +132,15 @@ export class WispClient {
   // worktree: true/false overrides the default (on in git repos). compare: [{ agent, model, effort }]
   // runs the same task on more harnesses at once, each in its own worktree. subagents:
   // [{ name, agent, model, effort, use }] (or preset: a saved team's id) the lead can delegate to.
-  async launch({ prompt, cwd = process.cwd(), agent, mode, model, effort, attachments, worktree, compare, subagents, preset } = {}) {
+  // also: more folders the same task works in (each git repo gets its own worktree and PR).
+  async launch({ prompt, cwd = process.cwd(), also, agent, mode, model, effort, attachments, worktree, compare, subagents, preset } = {}) {
     if (!agent || !mode || model === undefined) {
       const { defaults = {} } = await this.config();
       agent ||= defaults.agent || 'auto';
       mode ||= defaults.mode || 'auto';
       model ??= defaults.models?.[agent] ?? (agent === defaults.agent ? defaults.model || '' : '');
     }
-    return this.request('POST', '/sessions', { prompt, cwd: path.resolve(cwd), agent, mode, model, effort, attachments, worktree, compare, subagents, preset });
+    return this.request('POST', '/sessions', { prompt, cwd: path.resolve(cwd), also: also?.length ? also.map((d) => path.resolve(d)) : undefined, agent, mode, model, effort, attachments, worktree, compare, subagents, preset });
   }
 
   // Ship it: commit the session's worktree, push its branch, open (or update) the PR.

package/server/mcp-wisp.js

@@ -23,6 +23,7 @@ const TOOLS = [
       properties: {
         prompt: { type: 'string', description: 'The task, written as you would brief a colleague: goal, constraints, how to verify.' },
         cwd: { type: 'string', description: 'Absolute path of the project folder. Default: this MCP server’s working directory.' },
+        also: { type: 'array', items: { type: 'string' }, description: 'Absolute paths of more folders the same agent works in (e.g. the API next to its web app). Git repos each get a worktree, and Ship it opens a PR in each.' },
         agent: { type: 'string', enum: AGENTS, description: 'Harness to run; auto lets wisp pick harness and model from what worked before. Default: the user’s last pick in wisp.' },
         mode: { type: 'string', enum: ['plan', 'edits', 'auto'], description: 'plan = read-only, edits = auto-accept file edits, auto = no permission prompts. Default: the user’s pick.' },
         model: { type: 'string', description: 'Model id for that harness. Default: the user’s pick.' },
@@ -116,7 +117,7 @@ async function callTool(name, a = {}) {
   switch (name) {
     case 'wisp_launch': {
       if (!a.prompt?.trim()) throw new Error('prompt is required');
-      const s = await c.launch({ prompt: a.prompt, cwd: a.cwd || process.cwd(), agent: a.agent, mode: a.mode, model: a.model, effort: a.effort, subagents: a.subagents, preset: a.preset });
+      const s = await c.launch({ prompt: a.prompt, cwd: a.cwd || process.cwd(), also: Array.isArray(a.also) ? a.also : undefined, agent: a.agent, mode: a.mode, model: a.model, effort: a.effort, subagents: a.subagents, preset: a.preset });
       if (a.wait) return waitFor(s.id);
       return `Launched session \`${s.id}\` (“${s.title}”) on ${s.agent} in ${s.cwd}, mode ${s.mode}. Call wisp_wait or wisp_get with this id for the result.`;
     }

package/server/openapi.js

@@ -304,6 +304,7 @@ export function openapi({ version, port }) {
           properties: {
             prompt: { type: 'string' },
             cwd: { type: 'string', description: 'Project folder (absolute; ~ allowed). Default: the server’s cwd' },
+            also: { type: 'array', maxItems: 8, items: { type: 'string' }, description: 'More folders the same task works in (absolute; ~ allowed). The agent gets each; git repos get their own worktree, and Ship it opens a PR in each' },
             scratch: { type: 'boolean', description: 'No project folder: run in an empty scratch directory (no worktree). Overrides cwd' },
             agent: { enum: ['auto', 'claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'], default: 'auto', description: 'auto: wisp picks the harness and model from what worked before; model is then the goal (cheap, balanced, best)' },
             important: { type: 'boolean', description: 'With agent auto: no exploring, take the pick with the best record' },

package/server/routes/sessions.js

@@ -10,7 +10,7 @@ import { execCommand } from '../proc.js';
 import { ensureWorktree, removeWorktree } from '../git.js';
 import { MIME } from '../http/static.js';
 import { blocksToMarkdown, sessionToMarkdown } from '../render.js';
-import { summarize, workdir } from '../runner.js';
+import { alsoDirs, summarize, workdir } from '../runner.js';
 import { normalizeTeam } from '../subagents.js';
 import { openInTerminal, shq } from '../terminal.js';
 import { bad, clip, expand, MODES } from '../util.js';
@@ -46,6 +46,10 @@ export function register(r, app) {
     }
     return { agent, ...(model !== undefined && { model: String(model || '') }), ...(effort !== undefined && { effort: String(effort || '') }) };
   };
+  // Archiving removes clean worktrees: the task's own and its other folders' come back before it runs again.
+  const ensureTrees = async (s) => {
+    for (const x of [s, ...(s.also || [])]) await ensureWorktree(x.worktree);
+  };
   const turnOf = (s, turnId) => (turnId ? s.turns.find((t) => t.id === turnId) : s.turns.at(-1));
 
   r.route('GET', '/sessions', async (c) => {
@@ -57,8 +61,10 @@ export function register(r, app) {
     let list = [...here, ...(await machines.sessions(q))].sort((a, b) => b.updatedAt - a.updatedAt);
     if (q.state) list = list.filter((x) => q.state.split(',').includes(x.state));
     if (q.agent) list = list.filter((x) => x.agent === q.agent);
-    if (q.project) list = list.filter((x) => x.projectId === q.project || x.project === q.project);
-    if (cwd) list = list.filter((x) => x.cwd === cwd || x.cwd?.startsWith(cwd + path.sep));
+    // A task in several folders (also) shows under each of their projects.
+    const dirs = (x) => [x.cwd, ...(x.also || []).map((a) => a.cwd)];
+    if (q.project) list = list.filter((x) => [x, ...(x.also || [])].some((p) => p.projectId === q.project || p.project === q.project));
+    if (cwd) list = list.filter((x) => dirs(x).some((d) => d === cwd || d?.startsWith(cwd + path.sep)));
     if (q.archived !== undefined) list = list.filter((x) => x.archived === (q.archived === 'true' || q.archived === '1'));
     if (Number(q.limit) > 0) list = list.slice(0, Number(q.limit));
     c.send(200, list);
@@ -100,7 +106,8 @@ export function register(r, app) {
       if (s.state === 'done' || s.archived) app.retro.schedule(s, 0); // finished with it: learn now
       // Archived: a clean worktree goes (its branch stays, a follow-up brings it back).
       // discardWorktree: a compare run you didn't keep; its changes go too.
-      if (s.worktree && !runner.live.has(s.id) && (s.archived || body.discardWorktree)) await removeWorktree(s.worktree, { force: !!body.discardWorktree, branch: !!body.discardWorktree && !s.pr && 'force' });
+      if (!runner.live.has(s.id) && (s.archived || body.discardWorktree))
+        for (const x of [s, ...(s.also || [])]) if (x.worktree) await removeWorktree(x.worktree, { force: !!body.discardWorktree, branch: !!body.discardWorktree && !x.pr && 'force' });
       app.sessionChanged(s);
       c.send(200, summarize(s, store));
     }),
@@ -117,7 +124,7 @@ export function register(r, app) {
         if (store.get(cid)) (store.delete(cid), app.broadcast('removed', { id: cid }));
       }
       // Its worktree goes with it; the branch only if it holds nothing beyond its base.
-      if (s.worktree) await removeWorktree(s.worktree, { force: true, branch: true }).catch(() => {});
+      for (const x of [s, ...(s.also || [])]) if (x.worktree) await removeWorktree(x.worktree, { force: true, branch: true }).catch(() => {});
       store.delete(s.id);
       app.broadcast('removed', { id: s.id });
       c.send(200, { ok: true });
@@ -213,7 +220,7 @@ export function register(r, app) {
     one(async (c, s) => {
       const { turnId, allow } = await c.body();
       notTour(s, 'approve');
-      await ensureWorktree(s.worktree);
+      await ensureTrees(s);
       c.send(200, runner.approveBlocked(s, { turnId, allow: allow !== false }));
     }),
   );
@@ -295,8 +302,8 @@ export function register(r, app) {
     one(async (c, s) => {
       const adapter = adapters[s.agent];
       if (!adapter?.resumeCommand || !s.agentSessionId) return c.send(400, { error: 'This session cannot be resumed in a terminal.' });
-      const argv = adapter.resumeCommand({ resumeId: s.agentSessionId, model: s.model, effort: s.effort });
-      await ensureWorktree(s.worktree);
+      const argv = adapter.resumeCommand({ resumeId: s.agentSessionId, model: s.model, effort: s.effort, dirs: alsoDirs(s) });
+      await ensureTrees(s);
       const command = `cd ${shq(workdir(s))} && ${argv.map(shq).join(' ')}`;
       await fn(s, argv);
       c.send(200, { command });

package/server/routes/ship.js

@@ -1,7 +1,9 @@
 // Ship it. GET: what would ship (branch, changes, draft message). POST { title, body, draft }:
-// commit, push, open or update the PR. Then follow it (pr) and squash-merge it (merge).
+// commit, push, open or update the PR. Then follow it (pr) and squash-merge it (merge). A task in
+// several repos (also) ships, follows and merges a PR in each (services/ship.js).
 
-import { ship, merge, worktreeStatus } from '../git.js';
+import { worktreeStatus } from '../git.js';
+import { reposOf } from '../services/ship.js';
 
 export function register(r, app) {
   const { store, runner, telemetry } = app;
@@ -11,46 +13,40 @@ export function register(r, app) {
     return fn(c, s);
   };
   const NO_TREE = 'Ship it works on worktree sessions: launch with a worktree to get one.';
+  const hasTrees = (s) => !!(s.worktree || s.also?.some((a) => a.worktree));
 
   r.route(
     'GET',
     '/sessions/:id/ship',
     one(async (c, s) => {
-      if (!s.worktree) return c.send(400, { error: NO_TREE });
+      if (!hasTrees(s)) return c.send(400, { error: NO_TREE });
       app.ship.recheck(s);
-      c.send(200, { branch: s.worktree.branch, base: s.worktree.base, remote: s.worktree.remote, ...(await worktreeStatus(s.worktree)), pr: s.pr || null, ...app.ship.draft(s) });
+      const repos = await Promise.all(reposOf(s, store).map(async (r) => ({ repo: r.name, branch: r.wt.branch, base: r.wt.base, remote: r.wt.remote, ...(await worktreeStatus(r.wt)), pr: r.at.pr || null })));
+      // The first repo's fields at the top level (as before one task could span repos), each in `repos`.
+      const sum = (k) => repos.reduce((n, r) => n + r[k], 0);
+      c.send(200, { ...repos[0], ...(repos.length > 1 && { dirty: sum('dirty'), ahead: sum('ahead'), repos }), ...app.ship.draft(s) });
     }),
   );
   r.route(
     'POST',
     '/sessions/:id/ship',
     one(async (c, s) => {
-      if (!s.worktree) return c.send(400, { error: NO_TREE });
+      if (!hasTrees(s)) return c.send(400, { error: NO_TREE });
       if (runner.live.has(s.id)) return c.send(409, { error: 'Still working: wait for it to finish, or stop it.' });
       if (s.shipping) return c.send(409, { error: 'Already shipping: wait for it to land.' });
       const body = await c.body();
       const draft = app.ship.draft(s);
-      // The card follows along: s.shipping names the stage running now, sent with each summary.
-      s.shipping = { step: 'start', update: s.pr?.state === 'OPEN', startedAt: Date.now() };
-      app.sessionChanged(s);
-      const onStep = (step) => ((s.shipping = { ...s.shipping, step }), app.sessionChanged(s));
-      try {
-        s.pr = await ship(s.worktree, { title: body.title ?? draft.title, body: body.body ?? draft.body, draft: !!body.draft, pr: s.pr, onStep });
-        s.pushedAt = Date.now(); // the PR is polled fast for a while, so its checks show up as they start
-      } finally {
-        delete s.shipping;
-        app.sessionChanged(s, { now: true });
-      }
-      telemetry.track('ship', { agent: s.agent, draft: !!body.draft });
-      app.ship.recheck(s);
-      c.send(200, s.pr);
+      // The card follows along: s.shipping names the stage (and repo) running now, sent with each summary.
+      const pr = await app.ship.shipAll(s, { title: body.title ?? draft.title, body: body.body ?? draft.body, draft: !!body.draft });
+      telemetry.track('ship', { agent: s.agent, draft: !!body.draft, ...(pr.prs && { repos: pr.prs.length }) });
+      c.send(200, pr);
     }),
   );
   r.route(
     'POST',
     '/sessions/:id/pr',
     one(async (c, s) => {
-      if (!s.pr) return c.send(404, { error: 'No pull request yet.' });
+      if (!s.pr && !s.also?.some((a) => a.pr)) return c.send(404, { error: 'No pull request yet.' });
       c.send(200, await app.ship.refreshPr(s));
     }),
   );
@@ -76,13 +72,12 @@ export function register(r, app) {
     'POST',
     '/sessions/:id/merge',
     one(async (c, s) => {
-      if (!s.pr || !s.worktree) return c.send(400, { error: 'No pull request to merge.' });
-      const { pr, sync } = await merge(s.worktree, s.pr.number);
-      s.pr = pr;
+      if (!reposOf(s, store).some((r) => r.at.pr)) return c.send(400, { error: 'No pull request to merge.' });
+      const out = await app.ship.mergeAll(s);
       app.launcher.markDone(s);
       telemetry.track('merge', { agent: s.agent });
       app.sessionChanged(s, { now: true });
-      c.send(200, { pr, sync });
+      c.send(200, out);
     }),
   );
 }

package/server/runner.js

@@ -46,11 +46,21 @@ export { newId };
 // Where the agent actually works: its own worktree when it has one, else the project folder.
 export const workdir = (s) => s.worktree?.cwd || s.cwd;
 
-// Worktree sessions get told where they are, so they don't go looking for the main checkout.
+// Where the agent works in the task's other folders (also): their worktrees, else the folders.
+export const alsoDirs = (s) => (s.also || []).map((a) => a.worktree?.cwd || a.cwd);
+
+// Worktree sessions get told where they are, so they don't go looking for the main checkout. A task
+// with other folders (also) gets their paths: that's where the work in them goes.
 function workspaceNote(s) {
   const wt = s.worktree;
-  if (!wt) return '';
-  return `\n\n## Workspace\n\nYou are in an isolated git worktree (${wt.path}) on branch \`${wt.branch}\`, created from \`${wt.baseRef}\` for this task only. Other agents may be working in the user's main checkout, so make every change here. Dependencies and build output (node_modules, virtualenvs, dist/) are not shared with the main checkout: install them if a command needs them. Leave your changes uncommitted unless the user asks you to commit; the user ships them from wisp (commit, push, pull request).`;
+  const also = s.also || [];
+  const out = [];
+  if (wt) out.push(`You are in an isolated git worktree (${wt.path}) on branch \`${wt.branch}\`, created from \`${wt.baseRef}\` for this task only. Other agents may be working in the user's main checkout, so make every change here. Dependencies and build output (node_modules, virtualenvs, dist/) are not shared with the main checkout: install them if a command needs them. Leave your changes uncommitted unless the user asks you to commit; the user ships them from wisp (commit, push, pull request).`);
+  if (also.length) {
+    const line = (a) => (a.worktree ? `- \`${a.worktree.cwd}\`: a worktree of \`${a.cwd}\` on branch \`${a.worktree.branch}\` (from \`${a.worktree.baseRef}\`). Work here, not in \`${a.cwd}\`.` : `- \`${a.cwd}\``);
+    out.push(`This task spans ${also.length + 1} folders. Besides your working directory (${workdir(s)}), you work in:\n${also.map(line).join('\n')}\n\nRead and change files in all of them as the task needs, using absolute paths outside your working directory. Run each folder's commands (tests, builds) from inside that folder.${also.some((a) => a.worktree) ? ' Leave the changes there uncommitted too; Ship it opens a pull request per repo.' : ''}`);
+  }
+  return out.length ? `\n\n## Workspace\n\n${out.join('\n\n')}` : '';
 }
 
 // A follow-up's { agent, model, effort }, or null when it's what the session already runs on.
@@ -102,6 +112,13 @@ export function summarize(s, store) {
     question: s.ask?.question || '',
     approval: !!s.ask?.permission, // the question is a live approval (Allow / Deny)
     branch: s.worktree?.branch || '',
+    // The task's other folders: their project, worktree branch and PR, for the card and the filter.
+    ...(s.also?.length && {
+      also: s.also.map((a) => {
+        const p = store?.projectFor(a.cwd);
+        return { cwd: a.cwd, project: p?.name || path.basename(a.cwd), projectId: p?.id || null, color: p?.color || 'slate', branch: a.worktree?.branch || '', pr: a.pr ? { number: a.pr.number, url: a.pr.url, state: a.pr.state, draft: a.pr.draft, review: a.pr.review, checks: a.pr.checks, conflict: !!a.pr.conflict } : null };
+      }),
+    }),
     toShip: s.toShip || null, // { dirty, ahead, unpushed } of the worktree, null until checked
     shipping: s.shipping || null, // { step: 'start' | 'commit' | 'push' | 'pr', update } while Ship it runs
     pr: s.pr ? { number: s.pr.number, url: s.pr.url, state: s.pr.state, draft: s.pr.draft, review: s.pr.review, checks: s.pr.checks, conflict: !!s.pr.conflict } : null,
@@ -165,7 +182,8 @@ export class Runner extends EventEmitter {
   }
 
   // subagents: the team a lead may delegate to. parentId/member: this session is one of them.
-  create({ id = newId(), prompt, cwd, agent = 'claude', mode = 'auto', model = '', effort = '', attachments = [], worktree = null, groupId = null, origin = null, subagents = [], parentId = null, member = '', route = null, auto = null, scout = null }) {
+  // also: the task's other folders, [{ cwd, worktree }] (services/launch.js).
+  create({ id = newId(), prompt, cwd, also = [], agent = 'claude', mode = 'auto', model = '', effort = '', attachments = [], worktree = null, groupId = null, origin = null, subagents = [], parentId = null, member = '', route = null, auto = null, scout = null }) {
     if (!adapters[agent]) throw new Error(`Unknown agent: ${agent}`);
     const now = Date.now();
     const session = {
@@ -186,6 +204,7 @@ export class Runner extends EventEmitter {
       queue: [],
       turns: [],
       ...(worktree && { worktree }),
+      ...(also.length && { also }),
       ...(groupId && { groupId }),
       ...(origin && { origin }),
       ...(subagents.length && { subagents, children: {} }),
@@ -195,7 +214,7 @@ export class Runner extends EventEmitter {
       ...(route && { route }), // how Auto picked agent, model and level (server/router.js)
     };
     this.store.put(session);
-    if (!parentId) this.store.touchProject(cwd); // a subagent's cwd may be the lead's worktree
+    if (!parentId) for (const dir of [...also.map((a) => a.cwd), cwd]) this.store.touchProject(dir); // a subagent's cwd may be the lead's worktree
     this.#startTurn(session, prompt, attachments);
     return session;
   }
@@ -541,6 +560,7 @@ export class Runner extends EventEmitter {
       prompt: handoff ? `${handoff}\n\n${text}` : text,
       attachments,
       cwd: workdir(session),
+      dirs: alsoDirs((session.parentId && this.store.get(session.parentId)) || session), // the task's other folders (a subagent's are its lead's)
       resumeId: session.agentSessionId,
       mode,
       grants,

package/server/services/auto.js

@@ -109,12 +109,20 @@ export function createAuto(app) {
     const first = s.turns[0];
     const id = newId();
     if (!s.groupId) s.groupId = newId();
-    const wt = s.worktree;
-    const worktree = wt ? await createWorktree({ cwd: s.cwd, home: store.home, id, title: first.prompt, source: { root: wt.root, base: { ref: wt.head || wt.baseRef, branch: wt.base, remote: wt.remote, sha: wt.head } } }).catch(() => null) : null;
+    const fresh = (wt, cwd) => (wt ? createWorktree({ cwd, home: store.home, id, title: first.prompt, source: { root: wt.root, base: { ref: wt.head || wt.baseRef, branch: wt.base, remote: wt.remote, sha: wt.head } } }).catch(() => null) : null);
+    const worktree = await fresh(s.worktree, s.cwd);
+    // The task's other folders too: fresh worktrees from the same bases.
+    const also = await Promise.all(
+      (s.also || []).map(async (a) => {
+        const tree = await fresh(a.worktree, a.cwd);
+        return tree ? { cwd: a.cwd, worktree: tree } : { cwd: a.cwd };
+      }),
+    );
     const sib = app.runner.create({
       id,
       prompt: first.prompt,
       cwd: s.cwd,
+      also,
       agent: pick.agent,
       model: pick.model,
       effort: pick.effort || '',

package/server/services/launch.js

@@ -2,6 +2,7 @@
 // runs), here or on a machine, plus the follow-ups and "done" that every surface shares.
 
 import fs from 'node:fs';
+import path from 'node:path';
 import { adapters } from '../adapters/index.js';
 import { createWorktree, worktreeSource, ensureWorktree, removeWorktree } from '../git.js';
 import { qualify } from '../machines.js';
@@ -11,11 +12,32 @@ import { normalizeTeam } from '../subagents.js';
 import { bad, expand, MODES, newId } from '../util.js';
 
 export const MAX_COMPARE = 4;
+export const MAX_ALSO = 8; // extra folders one task may work in
+
+// also: more folders the task works in besides cwd (a backend and its web app, say). Each must be
+// a directory; repeats, cwd itself and folders inside one already listed are dropped.
+export function alsoDirs(list, cwd) {
+  if (list === undefined || list === null) return [];
+  if (!Array.isArray(list)) throw bad('also must be a list of folders.');
+  const inside = (a, b) => a === b || a.startsWith(b.endsWith(path.sep) ? b : b + path.sep);
+  const out = [];
+  for (const x of list) {
+    const raw = typeof x === 'string' ? x : x?.cwd;
+    if (!String(raw || '').trim()) continue;
+    const dir = path.resolve(expand(String(raw).trim()));
+    if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) throw bad(`Not a directory: ${dir}`);
+    if (inside(dir, cwd) || out.some((d) => inside(dir, d))) continue;
+    for (let i = out.length - 1; i >= 0; i--) if (inside(out[i], dir)) out.splice(i, 1);
+    out.push(dir);
+  }
+  if (out.length > MAX_ALSO) throw bad(`A task can work in up to ${MAX_ALSO + 1} folders.`);
+  return out;
+}
 
 export function createLaunch(app) {
   const { store, runner, machines } = app;
 
-  // body: { prompt, cwd, scratch: true = no folder, agent, mode, model, effort, attachments: [uploadId], worktree, compare,
+  // body: { prompt, cwd, also: [folder], scratch: true = no folder, agent, mode, model, effort, attachments: [uploadId], worktree, compare,
   //         subagents: [{ name, agent, model, effort, use }] | preset: teamId }
   async function launch(body, origin = null) {
     if (!String(body.prompt || '').trim()) throw bad('prompt required');
@@ -23,6 +45,7 @@ export function createLaunch(app) {
     const scratch = body.scratch === true;
     const cwd = scratch ? store.scratchDir(newId()) : expand(body.cwd || process.cwd());
     if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) throw bad(`Not a directory: ${cwd}`);
+    const also = scratch ? [] : alsoDirs(body.also, cwd);
     const d = store.config.defaults;
     const preset = body.preset && store.config.teams.find((t) => t.id === body.preset);
     if (body.preset && !preset && !body.subagents) throw bad(`no such subagent preset: ${body.preset}`);
@@ -66,7 +89,16 @@ export function createLaunch(app) {
       }
       if (failed) console.warn(`wisp: no worktree for ${cwd}: ${failed.message}`);
     }
-    return runners.map((r, i) => runner.create({ id: ids[i], prompt: body.prompt, cwd, ...r, mode, attachments, worktree: trees[i], groupId, origin, subagents, ...(r.route && { auto: { strategy }, scout: resolved.scout || null }) }));
+    // The other folders: a worktree of their own per run where they're git repos (so parallel
+    // tasks don't collide there either), else the folder itself.
+    const extras = await Promise.all(
+      also.map(async (dir) => {
+        const source = wantTree && (await worktreeSource(dir).catch(() => null));
+        const made = await Promise.all(ids.map((id) => (source ? createWorktree({ cwd: dir, home: store.home, id, title: body.prompt, source }).catch((err) => console.warn(`wisp: no worktree for ${dir}: ${err.message}`)) : null)));
+        return made.map((worktree) => ({ cwd: dir, ...(worktree && { worktree }) }));
+      }),
+    );
+    return runners.map((r, i) => runner.create({ id: ids[i], prompt: body.prompt, cwd, also: extras.map((x) => x[i]), ...r, mode, attachments, worktree: trees[i], groupId, origin, subagents, ...(r.route && { auto: { strategy }, scout: resolved.scout || null }) }));
   }
 
   // Where a launch runs: body.machine, else a project folder that only exists on a machine
@@ -110,7 +142,7 @@ export function createLaunch(app) {
 
   // A follow-up from anywhere (UI, CLI, phone). An archived session may have lost its worktree.
   async function replyTo(s, text, attachments = [], queue, mode, run) {
-    await ensureWorktree(s.worktree);
+    for (const x of [s, ...(s.also || [])]) await ensureWorktree(x.worktree);
     return runner.reply(s, text, attachments, { queue: queue ?? store.config.defaults.followUp === 'queue', mode, run });
   }