wisp-agents 0.20.0 → 0.22.0

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/routes/uploads.js

@@ -16,4 +16,6 @@ export function register(r, app) {
     c.res.writeHead(200, { 'content-type': u.mime, 'content-length': fs.statSync(u.path).size });
     fs.createReadStream(u.path).pipe(c.res);
   });
+  // A moved task's bundle, once the other place has it (services/move.js).
+  r.route('DELETE', '/uploads/:id', (c) => c.send(200, { ok: uploads.remove(c.params.id) }), { doc: false });
 }

package/server/runner.js

@@ -12,9 +12,14 @@ import { captureCheckpoint, freshCheckpoint, readGitFile } from './checkpoint.js
 import { teamNote, copies, SUBAGENT_ASK } from './subagents.js';
 import { handoffNote } from './handoff.js';
 import { agentPrompt, plainMentions } from './mentions.js';
-import { bad, MODES, newId } from './util.js';
+import { BTW_SYSTEM, BTW_TIMEOUT_MS, MAX_BTW, btwAnswer, btwPrompt } from './btw.js';
+import { bad, clip, MODES, newId } from './util.js';
 
 const MAX_ACTIVITY = 400;
+const MAX_TEXT = 20_000; // an agent message, kept whole for the transcript up to this
+const MAX_OUTPUT = 2_000; // what a tool call returned: its start and end past this
+// The calls whose output the transcript shows. A read returns the file and an edit a confirmation.
+const OUTPUT_KINDS = new Set(['run', 'search', 'web', 'tool', 'agent']);
 const LINGER_MS = 3000; // how long a CLI may keep running after it reported its result
 const BACKGROUND_MAX_MS = 60 * 60_000; // how long a turn may wait on its background tasks
 const ASK_SERVER = path.join(path.dirname(fileURLToPath(import.meta.url)), 'mcp-ask.js');
@@ -43,14 +48,38 @@ function retryPrompt(items, scoped) {
 
 export { newId };
 
+// A tool call's output for the transcript: whole when short, else its first and last lines (the
+// end of a test run or a build is what tells how it went).
+export function clipOutput(text) {
+  const out = String(text ?? '').replace(/\s+$/, '');
+  if (out.length <= MAX_OUTPUT) return out;
+  let head = out.slice(0, 600);
+  let tail = out.slice(-1300);
+  if (head.includes('\n')) head = head.slice(0, head.lastIndexOf('\n'));
+  if (tail.includes('\n')) tail = tail.slice(tail.indexOf('\n') + 1);
+  const cut = out.slice(head.length, out.length - tail.length);
+  const lines = cut.split('\n').length - 1;
+  return `${head}\n… ${lines > 1 ? `${lines} lines` : `${cut.length} characters`} cut …\n${tail}`;
+}
+
 // 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 +131,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,
@@ -109,6 +145,8 @@ export function summarize(s, store) {
     conflictFix: s.conflictFix ? { step: s.conflictFix.step, why: s.conflictFix.why || '' } : null,
     groupId: s.groupId || null,
     origin: s.origin || null, // { kind: 'recipe' | 'trigger' | 'telegram', id, name }
+    moved: s.moved || null, // { from }: carried on here from another place (services/move.js)
+    movedTo: s.movedTo || null, // { id, place }: this one carried on there, and was archived
     // The roster, for the stacked logos on the card: used = delegated to at least once, busy = working now.
     team: (s.subagents || []).flatMap((m) =>
       copies(m).map((name) => {
@@ -147,6 +185,7 @@ export class Runner extends EventEmitter {
     this.stopping = new Set();
     this.interrupting = new Set();
     this.answers = new Map(); // askId -> answer, until the MCP server picks it up
+    this.sides = new Map(); // /btw id -> { sessionId, handle }: side questions being answered
     this.promptExtra = () => ''; // (session) => text appended to the system prompt (learned preferences)
     this.routeAuto = null; // (prompt, { cwd }) => { agent, model, route } for subagents set to Auto
     this.pipeline = null; // Auto's check / repair / hand-over steps (server/pipeline.js)
@@ -161,17 +200,22 @@ export class Runner extends EventEmitter {
         s.state = 'review';
         store.save(s);
       }
+      const asked = s.turns.flatMap((x) => x.btw || []).filter((b) => b.status === 'running');
+      for (const b of asked) Object.assign(b, { status: 'error', error: 'wisp was restarted before this was answered.' });
+      if (asked.length) store.save(s);
     }
   }
 
   // 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).
+  // history / title / moved: a task moved here from another place, with the turns it had there.
+  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, history = [], title = '', moved = null }) {
     if (!adapters[agent]) throw new Error(`Unknown agent: ${agent}`);
     const now = Date.now();
     const session = {
       id,
-      title: autoTitle(prompt),
-      titleAuto: true,
+      title: title || autoTitle(prompt),
+      titleAuto: !title,
       agent,
       cwd,
       mode,
@@ -184,8 +228,10 @@ export class Runner extends EventEmitter {
       agentSessionId: null,
       agentSessions: {}, // harness -> its own conversation id, so switching back resumes it
       queue: [],
-      turns: [],
+      turns: [...history],
+      ...(moved && { moved }),
       ...(worktree && { worktree }),
+      ...(also.length && { also }),
       ...(groupId && { groupId }),
       ...(origin && { origin }),
       ...(subagents.length && { subagents, children: {} }),
@@ -195,7 +241,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;
   }
@@ -289,6 +335,99 @@ export class Runner extends EventEmitter {
     return true;
   }
 
+  // /btw: a side question, answered by a read-only run of its own while the task's run carries on
+  // (server/btw.js). It lands on the latest turn and never reaches the task's conversation.
+  btw(session, question, attachments = []) {
+    const turn = session.turns.at(-1);
+    if (!turn) throw bad('Nothing to ask about yet.', 409);
+    if ([...this.sides.values()].filter((x) => x.sessionId === session.id).length >= MAX_BTW) throw bad(`${MAX_BTW} side questions are still being answered. Ask again once one is in.`, 429);
+    const entry = {
+      id: newId(),
+      question,
+      status: 'running',
+      askedAt: Date.now(),
+      agent: session.agent,
+      model: session.model || '',
+      ...(attachments.length && { attachments: attachments.map(({ id, name, mime, size }) => ({ id, name, mime, size })) }),
+    };
+    (turn.btw ||= []).push(entry);
+    this.#sideRun(session, turn, entry, attachments, !!adapters[session.agent]?.fork && !!session.agentSessionId);
+    this.#btwChanged(session, turn);
+    return entry;
+  }
+
+  // forked: on a copy of the agent's conversation, so it knows what the run did and why. A fork
+  // that fails (a CLI too old to fork) asks again with wisp's record of the task instead.
+  #sideRun(session, turn, entry, attachments, forked) {
+    const adapter = adapters[entry.agent];
+    const name = (t) => adapters[t.agent || session.agent]?.name || t.agent || session.agent;
+    const question = agentPrompt(entry.question, this.store, { tool: null, self: session.id });
+    entry.forked = forked;
+    let reply = null;
+    let handle;
+    try {
+      handle = adapter.run({
+        prompt: btwPrompt(session, question, { forked, name }),
+        attachments,
+        cwd: workdir(session),
+        dirs: alsoDirs(session),
+        resumeId: forked ? session.agentSessionId : null,
+        fork: forked,
+        mode: 'plan',
+        model: entry.model,
+        effort: session.effort || '',
+        systemPrompt: BTW_SYSTEM,
+        onEvent: (ev) => {
+          if (ev.type === 'result') reply = ev;
+        },
+      });
+    } catch (err) {
+      reply = { isError: true, text: err.message };
+      handle = { done: Promise.resolve(), stop() {} };
+    }
+    const side = { sessionId: session.id, handle, timedOut: false };
+    this.sides.set(entry.id, side);
+    const timer = setTimeout(() => ((side.timedOut = true), handle.stop()), BTW_TIMEOUT_MS);
+    handle.done.then(() => {
+      clearTimeout(timer);
+      if (this.sides.get(entry.id) !== side) return; // dismissed, or the task was deleted
+      this.sides.delete(entry.id);
+      const ok = reply && !reply.isError && !reply.stopped;
+      if (!ok && forked && !side.timedOut) return this.#sideRun(session, turn, entry, attachments, false);
+      if (ok) Object.assign(entry, { status: 'done', answer: btwAnswer(reply.text), ...(reply.stats?.costUsd && { costUsd: reply.stats.costUsd }) });
+      else Object.assign(entry, { status: 'error', error: side.timedOut ? `No answer after ${BTW_TIMEOUT_MS / 60_000} minutes.` : clip(reply?.text || 'The side run ended without an answer.', 400) });
+      entry.answeredAt = Date.now();
+      this.#btwChanged(session, turn);
+    });
+  }
+
+  // Dismiss a side question, stopping its run if it's still going.
+  dropBtw(session, id) {
+    const turn = session.turns.find((t) => t.btw?.some((b) => b.id === id));
+    if (!turn) return false;
+    turn.btw = turn.btw.filter((b) => b.id !== id);
+    if (!turn.btw.length) delete turn.btw;
+    this.sides.get(id)?.handle.stop();
+    this.sides.delete(id);
+    this.#btwChanged(session, turn);
+    return true;
+  }
+
+  // The task is going away: its side questions stop too.
+  stopSides(session) {
+    for (const [id, side] of this.sides) {
+      if (side.sessionId !== session.id) continue;
+      this.sides.delete(id);
+      side.handle.stop();
+    }
+  }
+
+  // A side question changed: the card repaints it in place. The task's own state is untouched.
+  #btwChanged(session, turn) {
+    this.store.save(session);
+    this.emit('turn', { sessionId: session.id, turnId: turn.id });
+  }
+
   // ask_user: the agent is blocked inside a tool call until answer() is called.
   // permission: set for a live approval ({ tool, action, detail }), see requestApproval().
   ask(session, { question, context, options, permission }) {
@@ -519,6 +658,14 @@ export class Runner extends EventEmitter {
     const mode = MODES.has(once) ? once : session.mode;
     const turn = this.#newTurn(session, prompt, attachments, mode);
     if (by === 'wisp') turn.by = 'wisp'; // sent by wisp (Auto's repair round), not by you
+    // Side questions still being answered move to the new turn: the old one folds away on the card.
+    const prev = session.turns.at(-1);
+    const open = prev?.btw?.filter((b) => b.status === 'running') || [];
+    if (open.length) {
+      prev.btw = prev.btw.filter((b) => !open.includes(b));
+      if (!prev.btw.length) delete prev.btw;
+      turn.btw = open;
+    }
     session.turns.push(turn);
     session.state = 'running';
     session.unread = false;
@@ -541,6 +688,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,
@@ -596,15 +744,29 @@ export class Runner extends EventEmitter {
       case 'tool_error':
       case 'text': {
         const item = { t: Date.now(), kind: ev.type === 'tool' ? ev.kind : ev.type === 'text' ? 'text' : 'error' };
-        if (ev.type === 'tool') Object.assign(item, { label: ev.label, file: ev.file, detail: ev.detail });
-        else if (ev.type === 'text') item.label = ev.text.slice(0, 600);
+        if (ev.type === 'tool') {
+          Object.assign(item, { label: ev.label, file: ev.file, detail: ev.detail });
+          if (ev.id) item.call = String(ev.id); // a tool_output later finds its call by this
+          if (ev.output && OUTPUT_KINDS.has(item.kind)) item.output = clipOutput(ev.output);
+        } else if (ev.type === 'text') item.label = ev.text.slice(0, MAX_TEXT);
         else item.label = `${ev.name || 'Tool'} failed: ${ev.text}`;
         turn.activity.push(item);
-        if (turn.activity.length > MAX_ACTIVITY) turn.activity.splice(0, turn.activity.length - MAX_ACTIVITY);
+        // The transcript says how many of the oldest steps it no longer has.
+        if (turn.activity.length > MAX_ACTIVITY) turn.trimmed = (turn.trimmed || 0) + turn.activity.splice(0, turn.activity.length - MAX_ACTIVITY).length;
         this.emit('activity', { sessionId: session.id, turnId: turn.id, item });
         this.#touch(session, { quiet: ev.type === 'text' });
         return;
       }
+      case 'tool_output': {
+        // What a call returned, for the transcript: matched to the call by the harness's id.
+        const item = ev.id && turn.activity.findLast((a) => a.call === String(ev.id));
+        const output = clipOutput(ev.text);
+        if (!item || !OUTPUT_KINDS.has(item.kind) || !output.trim()) return;
+        item.output = output;
+        this.emit('activity', { sessionId: session.id, turnId: turn.id, item, update: true });
+        this.store.save(session);
+        return;
+      }
       case 'change': {
         let entry = turn.changes.find((c) => c.file === ev.file);
         if (!entry) {
@@ -618,7 +780,11 @@ export class Runner extends EventEmitter {
         }
         if (ev.op === 'create' && entry.edits.length === 0) entry.op = 'create';
         delete entry.reverted;
+        const from = entry.edits.length;
         entry.edits.push(...ev.edits);
+        // The transcript shows each edit under the call that made it: [from, to) in entry.edits.
+        const call = !ev.by && turn.activity.findLast((a) => a.kind === 'edit' && a.file === ev.file);
+        if (call) call.edits = [call.edits?.[0] ?? from, entry.edits.length];
         if (ev.by && !entry.by?.includes(ev.by)) (entry.by ||= []).push(ev.by);
         this.store.save(session);
         // A subagent's edits are the lead's too: they show up in its files, diffs and Ship it.

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,7 +2,9 @@
 // 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 { btwQuestion } from '../btw.js';
 import { createWorktree, worktreeSource, ensureWorktree, removeWorktree } from '../git.js';
 import { qualify } from '../machines.js';
 import { fill, positional } from '../recipes.js';
@@ -11,18 +13,40 @@ 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,
-  //         subagents: [{ name, agent, model, effort, use }] | preset: teamId }
+  // 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, moved: { from, title, turns, packs } }
   async function launch(body, origin = null) {
     if (!String(body.prompt || '').trim()) throw bad('prompt required');
     // scratch: no project folder (general questions); the task gets an empty directory of its own.
     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}`);
@@ -49,6 +73,16 @@ export function createLaunch(app) {
     const attachments = app.uploads.resolve(body.attachments);
     const ids = runners.map(() => newId());
     let trees = ids.map(() => null);
+    // A task moved here from another place (services/move.js): its work comes in its bundles.
+    const moved = body.moved && typeof body.moved === 'object' && !comparing ? body.moved : null;
+    if (moved) {
+      const made = await app.mover.unpack([cwd, ...also], moved.packs, { id: ids[0], title: moved.title || body.prompt });
+      trees = [made[0]];
+      const extras = also.map((dir, i) => ({ cwd: dir, ...(made[i + 1] && { worktree: made[i + 1] }) }));
+      const history = Array.isArray(moved.turns) ? moved.turns.filter((t) => t && typeof t === 'object' && typeof t.prompt === 'string') : [];
+      const r = runners[0];
+      return [runner.create({ id: ids[0], prompt: body.prompt, cwd, also: extras, ...r, mode, attachments, worktree: trees[0], groupId, origin: origin || moved.origin || null, subagents, history, title: moved.title, moved: { from: String(moved.from || ''), at: Date.now() } })];
+    }
     if (wantTree) {
       const must = body.worktree === true || (comparing && mode !== 'plan');
       // One fetch for the whole launch, then the checkouts side by side: compare runs used to
@@ -66,12 +100,22 @@ 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
-  // (recipes and schedules keep just the path). null = here.
+  // Where a launch runs: body.machine ('' = here), else a project folder that only exists on a
+  // machine (recipes and schedules keep just the path). null = here.
   function machineFor(body) {
+    if (typeof body.machine === 'string') return body.machine ? machines.get(body.machine).id : null; // '' = this computer
     if (body.machine) return machines.get(String(body.machine)).id;
     const cwd = String(body.cwd || '');
     if (!cwd || fs.existsSync(expand(cwd))) return null;
@@ -88,6 +132,8 @@ export function createLaunch(app) {
   // launch(), here or on a machine. Resolves with summaries (a compare launch has several).
   async function launchAny(body, origin = null) {
     const mid = machineFor(body);
+    // Every project runs anywhere: its folders become the ones on that place, cloned there first if need be.
+    body = await app.places.placeBody(body, mid);
     if (!mid) return (await launch(body, origin)).map((x) => summarize(x, store));
     // Auto for a machine: routed here, with the harnesses that machine has; its outcomes come
     // back through the summaries it streams (auto.signals), so one router learns from every place.
@@ -109,11 +155,25 @@ export function createLaunch(app) {
   }
 
   // A follow-up from anywhere (UI, CLI, phone). An archived session may have lost its worktree.
+  // One that starts with /btw is a side question instead: the run carries on (see askBtw).
   async function replyTo(s, text, attachments = [], queue, mode, run) {
-    await ensureWorktree(s.worktree);
+    const question = btwQuestion(text);
+    if (question !== null) return { btw: await askBtw(s, question, attachments) };
+    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 });
   }
 
+  // /btw: answered by a read-only run of its own, next to the task's run (server/btw.js).
+  async function askBtw(s, question, attachments = []) {
+    question = String(question || '').trim();
+    if (!question) throw bad('Type your question after /btw.');
+    if (s.agent === 'wisp') throw bad('This is the tour — launch a real wisp to ask it things.');
+    for (const x of [s, ...(s.also || [])]) await ensureWorktree(x.worktree);
+    const entry = runner.btw(s, question, attachments);
+    app.telemetry?.track('btw', { agent: s.agent, forked: entry.forked, running: runner.live.has(s.id) });
+    return entry;
+  }
+
   function markDone(s) {
     if (s.state === 'running' || s.state === 'waiting') return false;
     s.state = 'done';
@@ -132,5 +192,5 @@ export function createLaunch(app) {
     return s;
   }
 
-  return { launch, launchAny, machineFor, pushUploads, replyTo, markDone, runRecipe };
+  return { launch, launchAny, machineFor, pushUploads, replyTo, askBtw, markDone, runRecipe };
 }