wisp-agents 0.20.0 → 0.22.0

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

package/server/git.js

@@ -4,6 +4,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
 import { execFile } from './proc.js';
 import { bad } from './util.js';
 
@@ -12,9 +13,9 @@ const GH = () => process.env.WISP_GH_BIN || 'gh';
 // Never wait on a credential or confirmation prompt nobody can see.
 const QUIET_ENV = { GIT_TERMINAL_PROMPT: '0', GH_PROMPT_DISABLED: '1', GH_NO_UPDATE_NOTIFIER: '1', GIT_EDITOR: 'true' };
 
-export function run(bin, args, { cwd, timeout = 60_000 } = {}) {
+export function run(bin, args, { cwd, timeout = 60_000, env } = {}) {
   return new Promise((resolve, reject) => {
-    execFile(bin, args, { cwd, timeout, maxBuffer: 16 * 1024 * 1024, env: { ...process.env, ...QUIET_ENV } }, (err, stdout, stderr) => {
+    execFile(bin, args, { cwd, timeout, maxBuffer: 16 * 1024 * 1024, env: { ...process.env, ...QUIET_ENV, ...env } }, (err, stdout, stderr) => {
       if (!err) return resolve(String(stdout).trim());
       // git and gh lead with "fatal:" / "error:"; otherwise the tail is the useful part.
       const lines = String(stderr || '').trim().split('\n').filter(Boolean);
@@ -279,10 +280,13 @@ export function parseRepo(input, { shorthand = false } = {}) {
   return null;
 }
 
+// parseRepo, plus a plain path to a repo on disk (an origin can be one).
+export const repoOf = (u) => parseRepo(u) || (path.isAbsolute(String(u || '')) ? parseRepo(pathToFileURL(String(u)).href) : null);
+
 // The same repo, however it was spelled (https vs ssh, .git or not, case of the host).
-const sameRepo = (a, b) => {
+export const sameRepo = (a, b) => {
   const key = (u) => {
-    const r = parseRepo(u);
+    const r = repoOf(u);
     return r && (r.gh ? `github.com/${r.gh.toLowerCase()}` : `${r.host}/${r.path}`);
   };
   return !!key(a) && key(a) === key(b);
@@ -317,3 +321,75 @@ export async function cloneRepo(repo, parent, { timeout = 10 * 60_000 } = {}) {
     throw bad(`Couldn’t clone ${what}: it doesn’t exist, or this login can’t see it.${repo.gh ? ' Private repo? Check `gh auth status`.' : ''}`);
   throw bad(`Couldn’t clone ${what}: ${last.message}`);
 }
+
+// --- moving a task to another place: its work travels as a git bundle ---
+
+// Who the snapshot commit is by, so packing works where git has no user.name.
+const MOVER = { GIT_AUTHOR_NAME: 'wisp', GIT_AUTHOR_EMAIL: 'wisp@localhost', GIT_COMMITTER_NAME: 'wisp', GIT_COMMITTER_EMAIL: 'wisp@localhost' };
+
+// Pack the work in `dir` into `file`: the branch's commits plus one snapshot commit on top that
+// holds what isn't committed (untracked files too, ignored ones not). The user's index and
+// working tree are only read. Commits the remote already has (from wt.head down) stay out.
+// Resolves the pack's description for unpackWork(), or null outside a repo with commits.
+export async function packWork(dir, wt, file) {
+  const root = await repoRoot(dir);
+  const head = root && (await quiet(git(root, ['rev-parse', '--verify', '--quiet', 'HEAD^{commit}'])));
+  if (!head) return null;
+  const index = `${file}.index`;
+  const env = { ...MOVER, GIT_INDEX_FILE: index };
+  const ref = `refs/wisp/move/${path.basename(file).replace(/\W+/g, '-')}`;
+  try {
+    await git(root, ['read-tree', 'HEAD'], { env });
+    await git(root, ['add', '-A'], { env, timeout: 120_000 });
+    const tree = await git(root, ['write-tree'], { env });
+    const snap = await git(root, ['commit-tree', tree, '-p', head, '-m', 'wisp: work in progress, moved'], { env });
+    await git(root, ['update-ref', ref, snap]);
+    const published = wt?.head && (await quiet(git(root, ['branch', '-r', '--contains', wt.head])));
+    await git(root, ['bundle', 'create', file, ref, ...(published ? [`^${wt.head}`] : [])], { timeout: 300_000 });
+    const branch = wt?.branch || '';
+    return { ref, branch, base: wt?.base || '', baseRef: wt?.baseRef || '', head: wt?.head || null, remote: wt?.remote ?? null, prereq: !!published };
+  } finally {
+    fs.rmSync(index, { force: true });
+    await quiet(git(root, ['update-ref', '-d', ref]));
+  }
+}
+
+// Unpack a packWork() bundle into a new worktree of the repo at `cwd`, on the same branch name
+// when it's free: its commits as commits, the snapshot as uncommitted changes again.
+export async function unpackWork({ cwd, home, id, title, pack, file }) {
+  const root = await repoRoot(cwd);
+  if (!root) throw bad(`${cwd} isn’t a git repo here, so the work has nowhere to go.`);
+  if (pack.prereq) await quiet(git(root, ['fetch', '--quiet', 'origin'], { timeout: 60_000 })); // the commits the bundle leaves out
+  const local = `refs/wisp/moved/${id}`;
+  try {
+    await git(root, ['fetch', '--quiet', '--no-tags', file, `+${pack.ref}:${local}`], { timeout: 300_000 });
+  } catch (err) {
+    throw bad(`Couldn’t bring the work over: ${err.message}`);
+  }
+  const taken = async (b) => !!(await quiet(git(root, ['rev-parse', '--verify', '--quiet', `refs/heads/${b}`])));
+  let branch = /^[\w./-]{1,120}$/.test(pack.branch || '') && !(await taken(pack.branch)) ? pack.branch : `wisp/${slug(title) || 'task'}-${id.slice(0, 6)}`;
+  if (await taken(branch)) branch = `wisp/${slug(title) || 'task'}-${id}`;
+  const dir = path.join(home, 'worktrees', `${path.basename(root)}-${id}`);
+  fs.mkdirSync(path.dirname(dir), { recursive: true });
+  try {
+    await git(root, ['worktree', 'add', '--quiet', '--no-track', '-b', branch, dir, `${local}^`]);
+    await git(dir, ['read-tree', '-u', '--reset', local]);
+    await git(dir, ['reset', '--quiet']);
+  } finally {
+    await quiet(git(root, ['update-ref', '-d', local]));
+  }
+  // A task that ran in the folder itself (no worktree) branches from what's here.
+  const base = pack.baseRef ? null : await baseRef(root);
+  const sub = path.relative(realpath(root), realpath(cwd));
+  return {
+    path: dir,
+    cwd: sub && !sub.startsWith('..') ? path.join(dir, sub) : dir,
+    branch,
+    base: pack.base || base?.branch || '',
+    baseRef: pack.baseRef || base?.ref || '',
+    head: pack.head || (await quiet(git(dir, ['rev-parse', 'HEAD']))) || null,
+    remote: pack.baseRef ? pack.remote : base?.remote || null,
+    root,
+    createdAt: Date.now(),
+  };
+}

package/server/handoff.js

@@ -15,19 +15,22 @@ const KEEP = new Set(['hero', 'markdown', 'steps', 'stats', 'files', 'tests', 'c
 // The turns before the current one that `agent` hasn't seen: everything after the last turn it
 // ran, or all of them when it has no conversation of its own to resume (resumeId). Only a gap
 // that another harness filled counts: on its own, a harness has nothing to catch up on.
+// Turns that ran on another place before the task moved here (t.moved) count as unseen by every
+// harness: their conversations stayed there.
 export function missedTurns(session, agent, resumeId) {
   const prior = session.turns.slice(0, -1);
-  const missed = resumeId ? prior.slice(prior.findLastIndex((t) => (t.agent || agent) === agent) + 1) : prior;
-  return missed.some((t) => (t.agent || agent) !== agent) ? missed : [];
+  const missed = resumeId ? prior.slice(prior.findLastIndex((t) => !t.moved && (t.agent || agent) === agent) + 1) : prior;
+  return missed.some((t) => t.moved || (t.agent || agent) !== agent) ? missed : [];
 }
 
-function turnText(t, n, name) {
+// One earlier turn as markdown: the request, its report and the files it edited. /btw uses it too.
+export function turnText(t, n, name) {
   const blocks = (t.presentation?.blocks || []).filter((b) => KEEP.has(b?.type));
   const report = t.status === 'running' ? '' : blocksToMarkdown(blocks, t) || clip(t.raw, 1500);
   const files = (t.changes || []).filter((c) => !c.reverted).map((c) => `\`${c.file}\``);
   return truncate(
     [
-      `### Turn ${n} · ${name(t)}${t.model ? ` (${t.model})` : ''}${t.status === 'stopped' ? ' · stopped' : t.status === 'error' ? ' · failed' : ''}${t.rolledBackAt ? ' · rolled back, its edits were undone' : ''}`,
+      `### Turn ${n} · ${name(t)}${t.model ? ` (${t.model})` : ''}${t.moved ? ` · on ${t.moved}` : ''}${t.status === 'stopped' ? ' · stopped' : t.status === 'error' ? ' · failed' : ''}${t.rolledBackAt ? ' · rolled back, its edits were undone' : ''}`,
       `**User:** ${textMentions(t.prompt)}`,
       report && `**Report:**\n\n${report}`,
       files.length && `**Files it edited:** ${files.join(', ')}`,
@@ -55,9 +58,12 @@ export function handoffNote(session, agent, resumeId, name) {
   const dropped = missed.length - parts.length;
   const fresh = !resumeId;
   const others = [...new Set(missed.filter((t) => t.agent !== agent).map(name))].join(', ');
-  const intro = fresh
-    ? `You are taking over a task that another coding agent (${others}) has been working on. Its work is already in this folder. Below is what happened so far, oldest first; read the files and \`git diff\` for the details, then carry on with the follow-up.`
-    : `While you were away, this task continued on another coding agent (${others}). Its work is already in this folder. Below is what happened since your last turn, oldest first; check the files and \`git diff\` before you rely on what you remember.`;
+  const places = [...new Set(missed.map((t) => t.moved).filter(Boolean))].join(', ');
+  const intro = places
+    ? `You are taking over a task that ran on another computer (${places})${others ? `, on ${others}` : ''}, and was moved here. Its work so far is already in this folder: committed work as commits, the rest as uncommitted changes. Below is what happened so far, oldest first; read the files and \`git diff\` for the details, then carry on with the follow-up.`
+    : fresh
+      ? `You are taking over a task that another coding agent (${others}) has been working on. Its work is already in this folder. Below is what happened so far, oldest first; read the files and \`git diff\` for the details, then carry on with the follow-up.`
+      : `While you were away, this task continued on another coding agent (${others}). Its work is already in this folder. Below is what happened since your last turn, oldest first; check the files and \`git diff\` before you rely on what you remember.`;
   return [
     '## Earlier in this task',
     intro,

package/server/index.js

@@ -29,6 +29,8 @@ import { scoutNote } from './scout.js';
 import { createFeedback } from './services/feedback.js';
 import { createInstaller } from './services/install.js';
 import { createLaunch } from './services/launch.js';
+import { createMove } from './services/move.js';
+import { createPlaces } from './services/places.js';
 import { phoneActions } from './services/phone.js';
 import { createShip } from './services/ship.js';
 import { trackTurns } from './services/telemetry.js';
@@ -148,6 +150,8 @@ export async function startServer({ port = DEFAULT_PORT, host = '127.0.0.1', han
   });
   trackTurns(app);
 
+  app.places = createPlaces(app);
+  app.mover = createMove(app);
   app.launcher = createLaunch(app);
   app.sendFeedback = createFeedback(app);
   app.triggers = new Triggers({ store, launch: async (body, origin) => (await app.launcher.launchAny(body, origin))[0], onChange: () => app.broadcast('config', {}) });

package/server/machines.js

@@ -21,6 +21,7 @@ import { spawn, killTree } from './proc.js';
 import { newer } from './update.js';
 import { bootstrapScript } from './machines/bootstrap.js';
 import { sshHint, sshHosts, knownHosts, tailscalePeers, discoverHosts, TARGET } from './machines/hosts.js';
+import { HERE } from './store.js';
 import { bad, DEFAULT_PORT, shq } from './util.js';
 
 export { DEFAULT_PORT };
@@ -153,7 +154,17 @@ export class Machines extends EventEmitter {
     this.conns.delete(id);
     this.cache.delete(id);
     this.store.config.machines = this.list.filter((x) => x.id !== id);
-    this.store.config.projects = this.store.config.projects.filter((p) => p.machine !== id);
+    // Its checkouts go. A project added there lives on in a copy elsewhere, if it has one.
+    this.store.config.projects = this.store.config.projects.filter((p) => {
+      delete p.copies?.[id];
+      if (p.machine !== id) return true;
+      const [k, dir] = Object.entries(p.copies || {})[0] || [];
+      if (!k) return false;
+      delete p.copies[k];
+      delete p.machine;
+      Object.assign(p, { path: dir }, k !== HERE && { machine: k });
+      return true;
+    });
     this.store.saveConfig();
     this.onChange();
   }
@@ -175,7 +186,7 @@ export class Machines extends EventEmitter {
         remote: c?.remote || null,
         outdated: updateTo(this.version, c?.remote?.version, m.command),
         log: c?.log.slice(-30) || [],
-        projects: this.store.config.projects.filter((p) => p.machine === m.id).length,
+        projects: this.store.config.projects.filter((p) => this.store.pathAt(p, m.id)).length,
         working: cached.filter((s) => s.state === 'running').length,
       };
     });
@@ -577,10 +588,10 @@ export class Machines extends EventEmitter {
     return j;
   }
 
+  // A folder there that's a checkout of a repo already added elsewhere joins that project.
   async addProject(mid, dir, name) {
     const p = await this.json(mid, 'POST', '/projects', { path: dir }, { timeout: 10 * 60_000 }); // dir may be a repo URL to clone
-    const local = this.store.addProject(p.path, { name: name || p.name, machine: mid });
-    return local;
+    return this.store.addProject(p.path, { name: name || p.name, machine: mid, repo: p.origin || p.cloned?.url || undefined });
   }
 
   // A terminal on the machine running `command` (Take over), in the user's own interactive login

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

@@ -234,11 +234,20 @@ export function openapi({ version, port }) {
       '/sessions/{id}/reply': {
         parameters: [id],
         post: {
-          summary: 'Follow up (answers a pending ask_user question if there is one)',
+          summary: 'Follow up (answers a pending ask_user question if there is one). Text starting with /btw is a side question instead (see /btw)',
           requestBody: body({ type: 'object', required: ['text'], properties: { text: { type: 'string' }, attachments: { type: 'array', items: { type: 'string' } }, queue: { type: 'boolean', description: 'Wait for the current run instead of interrupting it' }, mode: { enum: ['plan', 'edits', 'auto'], description: 'Switch the session to this mode from this follow-up on' }, agent: { type: 'string', description: 'Switch to this harness from this follow-up on; it is handed the turns it has not seen' }, model: { type: 'string', description: 'Switch model (empty: the harness default)' }, effort: { type: 'string', description: 'Switch thinking level (empty: the default)' } } }),
-          responses: { 200: json({ type: 'object', properties: { answered: { type: 'boolean' }, queued: { type: 'boolean' }, interrupted: { type: 'boolean' }, ahead: { type: 'integer' } } }), 400: err[400] },
+          responses: { 200: json({ type: 'object', properties: { answered: { type: 'boolean' }, queued: { type: 'boolean' }, interrupted: { type: 'boolean' }, ahead: { type: 'integer' }, btw: ref('Btw') } }), 400: err[400] },
         },
       },
+      '/sessions/{id}/btw': {
+        parameters: [id],
+        post: {
+          summary: 'Ask a side question without interrupting: a read-only run of its own answers it (on a fork of the agent’s conversation where the harness can fork) and the answer lands on the latest turn’s btw list',
+          requestBody: body({ type: 'object', required: ['text'], properties: { text: { type: 'string', description: 'The question; a leading /btw is dropped' }, attachments: { type: 'array', items: { type: 'string' } } } }),
+          responses: { 200: json(ref('Btw')), 400: err[400], 404: err[404], 429: err[400] },
+        },
+        delete: { summary: 'Dismiss a side question (stops its run if it is still answering)', parameters: [{ name: 'item', in: 'query', required: true, schema: { type: 'string' } }], responses: { 200: ok, 404: err[404] } },
+      },
       '/sessions/{id}/answer': { parameters: [id], post: { summary: 'Answer the pending ask_user question (or approval: Allow, Always allow in this task, Deny, or what to do instead)', requestBody: body({ type: 'object', required: ['text'], properties: { text: { type: 'string' } } }), responses: { 200: ok } } },
       '/sessions/{id}/approve': { parameters: [id], post: { summary: 'Allow and retry (or deny) what a finished turn’s permissions blocked', requestBody: body({ type: 'object', properties: { turnId: { type: 'string' }, allow: { type: 'boolean', description: 'Default true' } } }), responses: { 200: ok } } },
       '/sessions/{id}/revert': {
@@ -304,6 +313,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' },
@@ -430,6 +440,22 @@ export function openapi({ version, port }) {
             stats: { type: ['object', 'null'] },
           },
         },
+        Btw: {
+          type: 'object',
+          description: 'A side question (/btw). It sits on turns[].btw of the turn it was asked during; GET the session or wait for its turn event to see the answer',
+          properties: {
+            id: { type: 'string' },
+            question: { type: 'string' },
+            status: { enum: ['running', 'done', 'error'] },
+            answer: { type: 'string', description: 'Markdown, once done' },
+            error: { type: 'string' },
+            forked: { type: 'boolean', description: 'Answered on a copy of the agent’s conversation (else from wisp’s record of the task)' },
+            agent: { type: 'string' },
+            model: { type: 'string' },
+            askedAt: { type: 'integer' },
+            answeredAt: { type: 'integer' },
+          },
+        },
       },
     },
   };

package/server/remote.js

@@ -25,7 +25,8 @@ export function findProject(projects, q) {
 export const mask = (t) => (t ? `••••${String(t).slice(-4)}` : '');
 
 export class Remote {
-  // act({ sessionId, kind: answer|reply|done|text, ref, index, text }) → a short result line.
+  // act({ sessionId, kind: answer|reply|done|text, ref, index, text, later? }) → a short result line;
+  // later(text) sends one more message afterwards (a /btw answer).
   // launch({ project, prompt }) → the new session's summary (a task started with /new).
   constructor({ store, act, launch = async () => null, onChange = () => {} }) {
     Object.assign(this, { store, act, launch, onChange });
@@ -253,7 +254,8 @@ export class Remote {
     const replyTo = m.reply_to_message?.message_id;
     const sessionId = replyTo && (this.store.all().find((x) => x.remote?.tg?.includes(replyTo))?.id || this.tgElsewhere.get(replyTo));
     if (!sessionId) return say(t.allowStart ? 'Reply to one of wisp’s messages to answer it or follow up, or send /new <task> to start one.' : 'Reply to one of wisp’s messages to answer it or send a follow-up.');
-    await say(await this.act({ sessionId, kind: 'text', text: m.text }), { reply_to_message_id: m.message_id });
+    const later = (text) => say(text, { reply_to_message_id: m.message_id }).catch(() => {});
+    await say(await this.act({ sessionId, kind: 'text', text: m.text, later }), { reply_to_message_id: m.message_id });
   }
 
   async #tgCommand(name, arg, m, say) {

package/server/routes/machines.js

@@ -36,7 +36,7 @@ export function register(r, app) {
     'GET',
     '/machines/:id/discover',
     known(async (c, id) => {
-      const have = new Set(store.config.projects.filter((p) => p.machine === id).map((p) => p.path));
+      const have = new Set(store.config.projects.map((p) => store.pathAt(p, id)).filter(Boolean));
       c.send(200, (await machines.json(id, 'GET', '/projects/discover')).filter((f) => !have.has(f.path)));
     }),
   );

package/server/routes/proxy.js

@@ -2,6 +2,7 @@
 // Registered before the session routes, so a qualified id never reaches them.
 
 import os from 'node:os';
+import { btwQuestion } from '../btw.js';
 import { pipeFrom } from '../http/respond.js';
 import { splitId, qualify } from '../machines.js';
 import { openInTerminal, shq } from '../terminal.js';
@@ -34,6 +35,11 @@ export function register(r, app) {
       return c.send(200, { command: argv.map(shq).join(' ') });
     }
     const body = m === 'GET' ? undefined : await c.body();
+    // A follow-up that moves the task here or to another machine (services/move.js).
+    if (action === 'reply' && typeof body?.machine === 'string') {
+      if (body.machine !== mid && btwQuestion(body.text) === null) return c.send(200, await app.mover.move(c.params.id, body.machine, { ...body, text: String(body.text || '').trim() }));
+      delete body.machine;
+    }
     if (action === 'reply' && body?.attachments?.length) body.attachments = await app.launcher.pushUploads(mid, body.attachments);
     const out = await machines.json(mid, m, sub, body, action === 'wait' ? { timeout: (MAX_WAIT_S + 30) * 1000 } : undefined);
     if (!action && m === 'GET') return c.send(200, machines.session(mid, out));

package/server/routes/sessions.js

@@ -1,16 +1,17 @@
 // Sessions: list and launch, one session (read, edit, delete), and what can be done to it:
-// wait, presentation, reply, queue, answer, revert, rollback, exec, takeover, stop, file.
+// wait, presentation, reply, btw, queue, answer, revert, rollback, exec, takeover, stop, file.
 // Ids of the form <id>@<machine> are passed through to that machine's wisp (proxy.js).
 
 import fs from 'node:fs';
 import path from 'node:path';
 import { adapters, listAgents } from '../adapters/index.js';
+import { btwQuestion } from '../btw.js';
 import { cleanupCheckpoints, revertFileChange, rollbackToTurn } from '../checkpoint.js';
 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 +47,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 +62,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);
@@ -90,6 +97,8 @@ export function register(r, app) {
       if (body.state === 'done' && s.state !== 'running') s.state = 'done';
       if (body.state === 'review' && s.state === 'done') s.state = 'review';
       if (typeof body.unread === 'boolean') s.unread = body.unread;
+      // Moved to another place by the wisp that shows it (services/move.js): where it went.
+      if (body.movedTo && typeof body.movedTo === 'object') s.movedTo = { id: String(body.movedTo.id || ''), place: String(body.movedTo.place || '') };
       // The team can change between turns; the next turn's lead sees the new roster.
       if (body.subagents !== undefined && !s.parentId) {
         s.subagents = normalizeTeam(body.subagents, adapters);
@@ -100,7 +109,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));
     }),
@@ -110,6 +120,7 @@ export function register(r, app) {
     '/sessions/:id',
     one(async (c, s) => {
       runner.stop(s);
+      runner.stopSides(s);
       await runner.live.get(s.id)?.done;
       cleanupCheckpoints(workdir(s), s.id);
       for (const cid of Object.values(s.children || {})) {
@@ -117,7 +128,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 });
@@ -177,16 +188,42 @@ export function register(r, app) {
     'POST',
     '/sessions/:id/reply',
     one(async (c, s) => {
-      const { text, attachments, queue, mode, agent, model, effort } = await c.body();
+      const { text, attachments, queue, mode, agent, model, effort, machine } = await c.body();
       if (!text?.trim()) return c.send(400, { error: 'text required' });
       notTour(s, 'follow up');
       if (mode !== undefined && !MODES.has(mode)) return c.send(400, { error: 'mode must be plan, edits or auto.' });
+      // machine: carry the task on on a machine instead (services/move.js). '' is here, where it is.
+      // A /btw side question never moves it.
+      if (typeof machine === 'string' && machine && btwQuestion(text) === null) return c.send(200, await app.mover.move(s.id, machine, { text: text.trim(), attachments, mode, agent, model, effort }));
       // agent / model / effort: run this follow-up (and the ones after it) on another harness or model.
       const run = agent !== undefined || model !== undefined || effort !== undefined ? await followUpRun(s, { agent, model, effort }) : undefined;
       c.send(200, await launcher.replyTo(s, text.trim(), app.uploads.resolve(attachments), queue, mode, run));
     }),
   );
 
+  // Pack the task's work to move it to another place (services/move.js): bundles, as uploads.
+  r.route(
+    'POST',
+    '/sessions/:id/pack',
+    one(async (c, s) => c.send(200, await app.mover.pack(s))),
+    { doc: false },
+  );
+
+  // A side question (/btw): answered next to the run, which carries on. text may keep its /btw.
+  r.route(
+    'POST',
+    '/sessions/:id/btw',
+    one(async (c, s) => {
+      const { text, attachments } = await c.body();
+      c.send(200, await launcher.askBtw(s, btwQuestion(text) ?? String(text || ''), app.uploads.resolve(attachments)));
+    }),
+  );
+  r.route(
+    'DELETE',
+    '/sessions/:id/btw',
+    one((c, s) => (runner.dropBtw(s, c.query.get('item') || '') ? c.send(200, { ok: true }) : c.send(404, { error: 'No such side question.' }))),
+  );
+
   r.route(
     'DELETE',
     '/sessions/:id/queue',
@@ -213,7 +250,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 +332,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/settings.js

@@ -10,20 +10,10 @@ import { envDisabled, feedbackAvailable } from '../telemetry.js';
 import { TERMINALS } from '../terminal.js';
 import { normalizeWebhooks } from '../services/webhooks.js';
 import { cloneRepo, gh, git, parseRepo } from '../git.js';
+import { checkout, cloneRoot, discoverRepos, originAt } from '../services/places.js';
 import { expand } from '../util.js';
 
-// Where people keep their repos, for one-click "add project".
-const REPO_ROOTS = ['code', 'Code', 'dev', 'Developer', 'projects', 'Projects', 'src', 'repos', 'work', 'git', 'GitHub', 'Documents', 'Downloads', 'Desktop'];
-
-// Where a pasted repo URL is cloned: defaults.cloneDir, else the first usual repo folder that
-// exists (not Documents/Downloads/Desktop), else ~/code.
-export function cloneRoot(config) {
-  if (config.defaults?.cloneDir) return expand(config.defaults.cloneDir);
-  const dir = REPO_ROOTS.slice(0, -3)
-    .map((r) => path.join(os.homedir(), r))
-    .find((d) => fs.existsSync(d) && fs.statSync(d).isDirectory());
-  return dir || path.join(os.homedir(), 'code');
-}
+export { cloneRoot };
 
 export function register(r, app) {
   const { store, telemetry, prefs, retro, remote, machines } = app;
@@ -119,12 +109,30 @@ export function register(r, app) {
       cloned = { url: repo.url, existed: out.existed };
     }
     if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return c.send(400, { error: `Not a folder: ${dir}` });
-    const p = store.addProject(dir, { name: body.name });
+    // Its origin: the same repo added on another place joins that project, and a machine
+    // without a checkout of it can clone it.
+    const origin = await originAt(dir);
+    const p = store.addProject(dir, { name: body.name, repo: origin || undefined });
     app.broadcast('config', {});
-    c.send(201, cloned ? { ...p, cloned } : p);
+    c.send(201, { ...p, ...(cloned && { cloned }), ...(origin && { origin }) });
   });
+  // Another wisp (this computer is one of its machines) needs a checkout of `repo` here: one that's
+  // already here, else a fresh clone. It's added as a project here too.
+  r.route(
+    'POST',
+    '/projects/checkout',
+    async (c) => {
+      const { repo, name } = await c.body();
+      const out = await checkout(store, String(repo || ''));
+      const p = store.addProject(out.dir, { name: name ? String(name) : undefined, repo: String(repo) });
+      app.broadcast('config', {});
+      c.send(200, { path: out.dir, existed: !!out.existed, name: p.name });
+    },
+    { doc: false },
+  );
+  r.route('GET', '/projects/origin', async (c) => c.send(200, { origin: await originAt(expand(c.query.get('path') || '.')) }), { doc: false });
   // Find git repos in the usual places so adding projects is one click.
-  r.route('GET', '/projects/discover', (c) => c.send(200, discoverRepos(new Set(store.config.projects.map((p) => p.path)))), { doc: false });
+  r.route('GET', '/projects/discover', (c) => c.send(200, discoverRepos(new Set(store.config.projects.map((p) => store.pathAt(p)).filter(Boolean)))), { doc: false });
   // The user's GitHub repos (gh's login), newest first, minus ones already added: one click clones.
   // Empty when gh isn't installed or signed in.
   r.route(
@@ -136,7 +144,7 @@ export function register(r, app) {
         .catch(() => null);
       if (!list) return c.send(200, []);
       const origins = await Promise.all(
-        store.config.projects.filter((p) => !p.machine).map((p) => git(p.path, ['remote', 'get-url', 'origin'], { timeout: 5000 }).catch(() => '')),
+        store.config.projects.map((p) => p.repo || (store.pathAt(p) ? git(store.pathAt(p), ['remote', 'get-url', 'origin'], { timeout: 5000 }).catch(() => '') : '')),
       );
       const have = new Set(origins.map((o) => parseRepo(o)?.gh?.toLowerCase()).filter(Boolean));
       c.send(
@@ -169,25 +177,3 @@ export function register(r, app) {
     c.send(200, { ok: true });
   });
 }
-
-// Git repos up to two levels under the usual folders, newest first, skipping known ones.
-function discoverRepos(known) {
-  const found = [];
-  const walk = (dir, depth) => {
-    if (found.length >= 60) return;
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    if (entries.some((e) => e.name === '.git')) {
-      if (!known.has(dir)) found.push({ path: dir, name: path.basename(dir), mtime: fs.statSync(dir).mtimeMs });
-      return;
-    }
-    if (depth <= 0) return;
-    for (const e of entries) if (e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules') walk(path.join(dir, e.name), depth - 1);
-  };
-  for (const r of REPO_ROOTS) walk(path.join(os.homedir(), r), 2);
-  return found.sort((a, b) => b.mtime - a.mtime).slice(0, 24);
-}