wisp-agents 0.20.0 → 0.22.0

package/server/services/move.js

@@ -0,0 +1,130 @@
+// Moving a task to another place (this computer or a machine) with a follow-up. A session lives on
+// the wisp that runs it, so the move starts a new session there that carries the task on:
+//
+//   pack     the source packs each folder's work (git.js packWork: the branch, plus a snapshot
+//            of what isn't committed) into bundles, kept as uploads there.
+//   carry    the bundles travel through this wisp to the target, like attachments do.
+//   launch   the target gets the project's checkout (services/places.js), unpacks each bundle into
+//            a worktree on the same branch, and starts the follow-up with the earlier turns as
+//            its history: the harness there hears them first (handoff.js).
+//   retire   the old session is archived, pointing at the new one.
+
+import os from 'node:os';
+import { listAgents, adapters } from '../adapters/index.js';
+import { packWork, unpackWork } from '../git.js';
+import { splitId } from '../machines.js';
+import { workdir } from '../runner.js';
+import { bad } from '../util.js';
+
+export function createMove(app) {
+  const { store, machines, uploads } = app;
+  // What a place is called in a moved task's history: the machine's name, or this computer's.
+  const where = (mid) => (mid ? machines.get(mid).name : os.hostname().replace(/\.local$/, '') || 'this computer');
+
+  // Source side: the session and its folders' bundles. A running task has nothing settled to pack.
+  async function pack(s) {
+    if (s.agent === 'wisp') throw bad('This is the tour — launch a real wisp to move it.');
+    if (s.parentId) throw bad('A subagent runs where its lead does.');
+    if (s.state === 'running' || s.state === 'waiting') throw bad('Stop the task or let it finish first: a running task can’t move.', 409);
+    const one = async (dir, wt) => {
+      const u = uploads.reserve('work.bundle');
+      const out = await packWork(dir, wt, u.file).catch((err) => {
+        throw bad(`Couldn’t pack the work in ${dir}: ${err.message}`);
+      });
+      return out && { ...out, upload: u.add().id };
+    };
+    const scratch = store.isScratch(s.cwd);
+    const packs = scratch ? [] : [await one(workdir(s), s.worktree), ...(await Promise.all((s.also || []).map((a) => one(a.worktree?.cwd || a.cwd, a.worktree))))];
+    return { session: s, scratch, packs };
+  }
+
+  // Target side (launch.js): the worktrees for a moved launch, one per folder, from the bundles.
+  async function unpack(dirs, packs, { id, title }) {
+    return Promise.all(
+      dirs.map(async (cwd, i) => {
+        const p = packs?.[i];
+        const u = p && uploads.get(p.upload);
+        if (!p || !u) return null;
+        try {
+          return await unpackWork({ cwd, home: store.home, id, title, pack: p, file: u.path });
+        } finally {
+          uploads.remove(u.id);
+        }
+      }),
+    );
+  }
+
+  // A bundle from the source (null = here) as an upload on the target.
+  async function carry(upload, from, to) {
+    let u = from ? null : uploads.get(upload);
+    if (from) u = await uploads.receive(await machines.stream(from, 'GET', `/uploads/${upload}`, { timeout: 10 * 60_000 }), { name: 'work.bundle', type: 'application/octet-stream' });
+    if (!u) throw bad('The packed work went missing on its way.', 500);
+    if (!to) return u.id;
+    const there = await machines.upload(to, u);
+    uploads.remove(u.id); // the copy here was only on its way through
+    return there.id;
+  }
+
+  // The earlier turns, as history for the new session: what ran where, without what only made
+  // sense there (checkpoints, attachment files, subagent sessions).
+  const history = (s, from) =>
+    s.turns.map((t) => {
+      const { checkpoint, delegations, attachments, ...rest } = t;
+      return { ...rest, moved: t.moved || where(from), checkpoint: null, ...(t.status === 'running' && { status: 'stopped' }) };
+    });
+
+  // id: the session as this wisp names it (<id>@<machine> on a machine). to: a machine id, or
+  // null for this computer. Resolves the new session's summary.
+  async function move(id, to, { text, attachments = [], mode, agent, model, effort } = {}) {
+    const at = splitId(id);
+    const from = at?.machine || null;
+    to = to || null;
+    if (from === to) throw bad('The task is already there.');
+    if (to) machines.get(to);
+    if (to && !machines.isOnline(to)) throw bad(`${machines.get(to).name} is offline. Connect it from Machines.`, 503);
+    const local = !from && store.get(id);
+    if (!from && !local) throw bad('no such session', 404);
+    const src = from ? await machines.json(from, 'GET', `/sessions/${at.id}`) : local;
+    // The harness the follow-up runs on has to be there.
+    const run = { agent: agent || src.agent, model: model ?? (agent && agent !== src.agent ? '' : src.model || ''), effort: effort ?? (agent && agent !== src.agent ? '' : src.effort || '') };
+    const there = to ? machines.agentsOf(to) || [] : await listAgents();
+    if (!there.some((a) => a.id === run.agent && a.available)) throw bad(`${adapters[run.agent]?.name || run.agent} isn’t installed on ${where(to)}. Pick another harness for this follow-up.`);
+
+    const packed = from ? await machines.json(from, 'POST', `/sessions/${at.id}/pack`, {}, { timeout: 10 * 60_000 }) : await pack(local);
+    const s = from ? machines.session(from, packed.session) : packed.session;
+    const packs = await Promise.all(packed.packs.map(async (p) => p && { ...p, upload: await carry(p.upload, from, to) }));
+    if (from) for (const p of packed.packs) if (p) machines.json(from, 'DELETE', `/uploads/${p.upload}`).catch(() => {});
+
+    const body = {
+      prompt: text,
+      ...(packed.scratch ? { scratch: true } : { cwd: s.cwd, also: (s.also || []).map((a) => a.cwd) }),
+      machine: to || '',
+      agent: run.agent,
+      model: run.model,
+      effort: run.effort,
+      mode: mode || s.mode,
+      attachments,
+      ...(s.groupId && { groupId: s.groupId }),
+      ...(s.subagents?.length && { subagents: s.subagents }),
+      moved: { from: where(from), title: s.title, turns: history(s, from), packs, ...(s.origin && { origin: s.origin }) },
+    };
+    let next;
+    try {
+      [next] = await app.launcher.launchAny(body);
+    } catch (err) {
+      for (const p of packs) if (p) (to ? machines.json(to, 'DELETE', `/uploads/${p.upload}`) : Promise.resolve(uploads.remove(p.upload))).catch(() => {});
+      throw err;
+    }
+    // The old one steps aside: archived (its worktree stays until you delete it), pointing here.
+    const movedTo = { id: next.id, place: where(to) };
+    if (from) await machines.json(from, 'PATCH', `/sessions/${at.id}`, { archived: true, movedTo }).catch(() => {});
+    else {
+      Object.assign(local, { archived: true, unread: false, movedTo });
+      app.sessionChanged(local);
+    }
+    app.telemetry?.track('move_task', { from: from ? 'machine' : 'here', to: to ? 'machine' : 'here', agent: run.agent });
+    return { moved: true, from: id, session: next };
+  }
+
+  return { pack, unpack, move };
+}

package/server/services/phone.js

@@ -1,6 +1,8 @@
 // Phone (ntfy / Telegram): what a tap or a reply there does to a session, here or on a machine.
 
+import { BTW_TIMEOUT_MS } from '../btw.js';
 import { splitId } from '../machines.js';
+import { truncate } from '../util.js';
 
 export function phoneActions(app) {
   const { store, runner, machines } = app;
@@ -21,6 +23,17 @@ export function phoneActions(app) {
     return s && { s: machines.session(at.machine, s), answer: (a) => call('POST', '/answer', { text: a }), reply: (t) => call('POST', '/reply', { text: t }), done: async () => !live && !!(await call('PATCH', '', { state: 'done' })) };
   }
 
+  // A /btw from the phone: its answer, once it's in (null if it was dismissed or never came).
+  async function btwAnswer(sessionId, btwId) {
+    for (const end = Date.now() + BTW_TIMEOUT_MS + 30_000; Date.now() < end; ) {
+      await new Promise((r) => setTimeout(r, 1500));
+      const b = (await sessionOps(sessionId).catch(() => null))?.s.turns.flatMap((t) => t.btw || []).find((x) => x.id === btwId);
+      if (!b) return null;
+      if (b.status !== 'running') return b;
+    }
+    return null;
+  }
+
   return {
     // /new from Telegram: the launcher's remembered harness, model and mode, like `wisp "…"`.
     launch: async ({ project, prompt }) => {
@@ -31,7 +44,8 @@ export function phoneActions(app) {
       app.broadcast('config', {});
       return s;
     },
-    act: async ({ sessionId, kind, ref, index, text }) => {
+    // later(text): a message sent after this one (Telegram), for a /btw's answer.
+    act: async ({ sessionId, kind, ref, index, text, later }) => {
       const ops = await sessionOps(sessionId).catch((err) => ({ error: err.message }));
       if (ops?.error) return `Can’t reach it: ${ops.error}`;
       if (!ops) return 'That session is gone.';
@@ -59,6 +73,11 @@ export function phoneActions(app) {
       }
       if (s.agent === 'wisp') return 'That is the tour; it can’t take follow-ups.';
       const r = await ops.reply(String(text || '').trim());
+      if (r.btw) {
+        // Not awaited: the bot keeps taking messages while the side run answers.
+        btwAnswer(sessionId, r.btw.id).then((b) => b && later?.(truncate(b.status === 'done' ? `btw: ${b.answer}` : `Couldn’t answer that: ${b.error}`, 4000))).catch(() => {});
+        return later ? '✓ Asking on the side; the agent keeps working. The answer follows here.' : '✓ Asked on the side; the answer shows on the card in wisp.';
+      }
       return r.answered ? '✓ Answered' : r.interrupted ? '✓ Sent; the agent picked it up mid-run' : r.queued ? '✓ Queued for when it finishes' : '✓ Sent';
     },
   };

package/server/services/places.js

@@ -0,0 +1,150 @@
+// Places: this computer and the machines. A project is one repo that every place can run, so a
+// task launched on a machine that has no checkout of it yet gets one first: a clone of the same
+// repo that's already there (registered or in the usual folders), else a fresh clone of its
+// origin. The checkout is remembered as the project's copy on that machine (store.setCopy).
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { cloneRepo, git, repoOf, sameRepo } from '../git.js';
+import { HERE } from '../store.js';
+import { bad, expand } from '../util.js';
+
+const CLONE_TIMEOUT_MS = 10 * 60_000;
+
+// Where people keep their repos, for one-click "add project".
+export 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');
+}
+
+// Git repos up to two levels under the usual folders, newest first, skipping known ones.
+export function discoverRepos(known = new Set()) {
+  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);
+}
+
+export const originAt = (dir) => git(dir, ['remote', 'get-url', 'origin'], { timeout: 5000 }).catch(() => '');
+
+// A checkout of `url` on this computer: a project (or copy) here that is that repo, else one in
+// the usual folders, else a fresh clone into the clone folder. Resolves { dir, existed }.
+export async function checkout(store, url) {
+  const repo = repoOf(url);
+  if (!repo) throw bad(`Not a repo URL: ${url}`);
+  const mine = store.config.projects.map((p) => [p, store.pathAt(p)]).filter(([, dir]) => dir && fs.existsSync(dir));
+  for (const [p, dir] of mine) if (sameRepo(p.repo || (await originAt(dir)), url)) return { dir, existed: true };
+  const found = discoverRepos();
+  const origins = await Promise.all(found.map((f) => originAt(f.path)));
+  const hit = found.find((f, i) => sameRepo(origins[i], url));
+  if (hit) return { dir: hit.path, existed: true };
+  return cloneRepo(repo, cloneRoot(store.config), { timeout: CLONE_TIMEOUT_MS });
+}
+
+export function createPlaces(app) {
+  const { store, machines } = app;
+  const placeName = (mid) => (mid ? machines.get(mid).name : 'this computer');
+  const inflight = new Map(); // `${project}@${place}` -> promise, so two launches clone once
+
+  // The project's origin URL, asked of whichever place has a checkout; kept on the project.
+  async function originOf(p) {
+    if (p.repo) return p.repo;
+    const places = [p.machine || null, ...Object.keys(p.copies || {}).map((k) => (k === HERE ? null : k))];
+    for (const mid of places) {
+      const dir = store.pathAt(p, mid);
+      let url = '';
+      if (!mid) url = fs.existsSync(dir) ? await originAt(dir) : '';
+      else if (machines.isOnline(mid)) url = (await machines.json(mid, 'GET', `/projects/origin?path=${encodeURIComponent(dir)}`).catch(() => null))?.origin || '';
+      if (url) {
+        p.repo = url;
+        store.saveConfig();
+        return url;
+      }
+    }
+    return '';
+  }
+
+  async function remoteCheckout(mid, repo, name) {
+    try {
+      const r = await machines.json(mid, 'POST', '/projects/checkout', { repo, name }, { timeout: CLONE_TIMEOUT_MS });
+      return { dir: r.path, existed: !!r.existed };
+    } catch (err) {
+      if (err.status !== 404) throw err;
+    }
+    // An older wisp there: its POST /projects clones the repo (or reuses a clone of it).
+    const r = await machines.json(mid, 'POST', '/projects', { repo }, { timeout: CLONE_TIMEOUT_MS });
+    return { dir: r.path, existed: !!r.cloned?.existed };
+  }
+
+  // The project's folder on `mid` (null = this computer). fresh: the one wisp knew is gone.
+  async function ensureAt(p, mid = null, { fresh = false } = {}) {
+    const known = store.pathAt(p, mid);
+    if (known && !fresh && (mid || fs.existsSync(known))) return known;
+    const key = `${p.id}@${mid || HERE}`;
+    if (!inflight.has(key)) {
+      const job = (async () => {
+        const repo = await originOf(p);
+        if (!repo) throw bad(`${p.name} has no git remote (origin) to clone from, so wisp can’t set it up on ${placeName(mid)}. Push it to a remote first, or add its folder there in Projects.`, 409);
+        const out = mid ? await remoteCheckout(mid, repo, p.name) : await checkout(store, repo);
+        store.setCopy(p, mid, out.dir);
+        app.configChanged();
+        return out.dir;
+      })().finally(() => inflight.delete(key));
+      inflight.set(key, job);
+    }
+    return inflight.get(key);
+  }
+
+  // A task's folder, for running it on `mid`: the same folder in that place's checkout of its
+  // project. Folders that are no project's (and ones already on that place) stay as they are.
+  async function dirAt(dir, mid = null) {
+    if (!dir) return dir;
+    if (!mid) dir = expand(dir);
+    if (store.projectFor(dir, mid)) return dir;
+    for (const from of [null, ...machines.list.map((m) => m.id)]) {
+      if (from === (mid || null)) continue;
+      const p = store.projectFor(dir, from);
+      if (!p) continue;
+      // A folder that's here too (the same layout on both computers) is used as it is, unless the
+      // project already has its own checkout here.
+      if (!mid && fs.existsSync(dir) && !store.pathAt(p)) return dir;
+      const rest = dir.slice(store.pathAt(p, from).length).split(/[\\/]/).filter(Boolean);
+      const there = await ensureAt(p, mid);
+      return rest.length ? (mid ? path.posix : path).join(there, ...rest) : there;
+    }
+    return dir;
+  }
+
+  // A launch body with its folders (cwd, also) moved to `mid`.
+  async function placeBody(body, mid = null) {
+    if (body.scratch === true) return body;
+    const out = { ...body };
+    if (body.cwd) out.cwd = await dirAt(String(body.cwd), mid);
+    if (Array.isArray(body.also)) out.also = await Promise.all(body.also.map((x) => (typeof x === 'string' ? dirAt(x, mid) : x?.cwd ? dirAt(String(x.cwd), mid) : x)));
+    return out;
+  }
+
+  return { originOf, ensureAt, dirAt, placeBody, placeName };
+}

package/server/services/ship.js

@@ -5,9 +5,11 @@
 // result is pushed to the PR when it's done.
 
 import fs from 'node:fs';
-import { worktreeStatus, prView, ship, baseMerged, conflictsWithBase } from '../git.js';
+import path from 'node:path';
+import { worktreeStatus, prView, ship, merge, baseMerged, conflictsWithBase } from '../git.js';
 import { blocksToMarkdown } from '../render.js';
 import { summarize } from '../runner.js';
+import { bad } from '../util.js';
 
 const PR_POLL_MS = 60_000;
 const PR_FAST_POLL_MS = 10_000; // while GitHub is still working something out: checks running, mergeability unknown, a push just landed
@@ -29,15 +31,28 @@ export const conflictPrompt = (s) => {
   ].join('\n');
 };
 
+// The repos a task ships: its own worktree, then those of its other folders (also). Each is
+// { name, wt, at }, where `at` holds that repo's PR (the session for its own, else the also entry).
+export function reposOf(s, store) {
+  const name = (dir) => store?.projectFor?.(dir)?.name || path.basename(dir || '');
+  return [s.worktree && { name: name(s.cwd), wt: s.worktree, at: s }, ...(s.also || []).map((a) => a.worktree && { name: name(a.cwd), wt: a.worktree, at: a })].filter(Boolean);
+}
+// Something new for this repo's PR: uncommitted changes, or commits its open PR (or a new one) lacks.
+const pending = (st, pr) => !!(st.dirty || (pr?.state === 'OPEN' ? st.unpushed : st.ahead));
+const hasTrees = (s) => !!(s?.worktree || s?.also?.some((a) => a.worktree));
+
 export function createShip(app) {
   const { store, runner } = app;
 
   // Ship it shows only when the worktree has something to ship: uncommitted changes, or commits
-  // not yet pushed. Rechecked whenever wisp might have changed the worktree.
+  // not yet pushed. Rechecked whenever wisp might have changed the worktree. A task in several
+  // repos adds theirs up, and `repos` counts the ones with something to ship.
   const check = async (s) => {
-    if (!s?.worktree || s.parentId) return;
-    const { dirty, ahead, unpushed } = await worktreeStatus(s.worktree);
-    const next = { dirty, ahead, unpushed };
+    if (!hasTrees(s) || s.parentId) return;
+    const repos = reposOf(s, store);
+    const all = await Promise.all(repos.map((r) => worktreeStatus(r.wt)));
+    const sum = (k) => all.reduce((n, st) => n + st[k], 0);
+    const next = { dirty: sum('dirty'), ahead: sum('ahead'), unpushed: sum('unpushed'), ...(repos.length > 1 && { repos: all.filter((st, i) => pending(st, repos[i].at.pr)).length }) };
     if (JSON.stringify(next) === JSON.stringify(s.toShip)) return;
     s.toShip = next;
     app.sessionChanged(s);
@@ -47,7 +62,7 @@ export function createShip(app) {
   const checks = new Map(); // id → true while checking, 'again' if another check is due
   const checkedAt = new Map();
   const recheck = (s, { lazy = false } = {}) => {
-    if (!s?.worktree || s.parentId) return;
+    if (!hasTrees(s) || s.parentId) return;
     if (lazy && (runner.live.has(s.id) || checks.has(s.id) || Date.now() - (checkedAt.get(s.id) || 0) < SHIP_RECHECK_MS)) return;
     if (checks.has(s.id)) return void checks.set(s.id, 'again');
     checks.set(s.id, true);
@@ -61,8 +76,25 @@ export function createShip(app) {
       });
   };
 
+  // The PRs of the task's other repos: their state, checks and reviews, for the card.
+  const refreshAlso = async (s) => {
+    const open = (s.also || []).filter((a) => a.pr && a.worktree && a.pr.state === 'OPEN');
+    if (!open.length) return false;
+    let news = false;
+    await Promise.all(
+      open.map(async (a) => {
+        const prev = a.pr;
+        a.pr = await prView(fs.existsSync(a.worktree.path) ? a.worktree.path : a.worktree.root, prev.number).catch(() => ({ ...prev, checkedAt: Date.now() }));
+        if (a.pr.state !== prev.state || a.pr.review !== prev.review || (!a.pr.checks.pending && prev.checks?.pending)) news = true;
+      }),
+    );
+    if (news) s.unread = true;
+    app.sessionChanged(s);
+    return true;
+  };
   const refreshPr = async (s) => {
-    if (!s.pr || !s.worktree) return s.pr;
+    await refreshAlso(s);
+    if (!s.pr || !s.worktree) return s.pr || s.also?.find((a) => a.pr)?.pr;
     const prev = s.pr;
     const dir = fs.existsSync(s.worktree.path) ? s.worktree.path : s.worktree.root;
     const pr = await prView(dir, prev.number);
@@ -135,6 +167,59 @@ export function createShip(app) {
     recheck(s);
   };
 
+  // Ship it: commit, push and open (or update) the PR, in each of the task's repos with something
+  // new. One repo ships as before, even with nothing new (git says why). Several: one PR each,
+  // each noting the others; a failure names its repo and leaves the PRs already opened in place.
+  const shipAll = async (s, { title, body = '', draft = false }) => {
+    const repos = reposOf(s, store);
+    let todo = repos;
+    if (repos.length > 1) {
+      const st = await Promise.all(repos.map((r) => worktreeStatus(r.wt)));
+      todo = repos.filter((r, i) => pending(st[i], r.at.pr));
+      if (!todo.length) throw bad('Nothing to ship: none of the task’s repos have new changes.');
+    }
+    const note = repos.length > 1 ? `\n\nPart of one task across ${repos.map((r) => `\`${r.name}\``).join(', ')}: wisp opens a pull request in each.` : '';
+    s.shipping = { step: 'start', update: todo.every((r) => r.at.pr?.state === 'OPEN'), startedAt: Date.now(), ...(todo.length > 1 && { of: todo.length }) };
+    app.sessionChanged(s);
+    try {
+      for (const [i, r] of todo.entries()) {
+        const onStep = (step) => ((s.shipping = { ...s.shipping, step, ...(todo.length > 1 && { repo: r.name, at: i + 1 }) }), app.sessionChanged(s));
+        try {
+          r.at.pr = await ship(r.wt, { title, body: `${body}${note}`.trim(), draft, pr: r.at.pr, onStep });
+        } catch (err) {
+          throw repos.length > 1 ? Object.assign(new Error(`${r.name}: ${err.message}`), { status: err.status }) : err;
+        }
+      }
+      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 });
+    }
+    recheck(s);
+    return { ...(s.pr || todo[0].at.pr), ...(repos.length > 1 && { prs: prsOf(s) }) };
+  };
+  // Every PR the task opened, its own first: { repo, number, url, state }.
+  const prsOf = (s) => reposOf(s, store).filter((r) => r.at.pr).map((r) => ({ repo: r.name, number: r.at.pr.number, url: r.at.pr.url, state: r.at.pr.state }));
+
+  // Merge: squash-merge each open PR of the task, its own first. Stops at the first that fails.
+  const mergeAll = async (s) => {
+    const open = reposOf(s, store).filter((r) => r.at.pr?.state === 'OPEN');
+    if (!open.length) throw bad('No pull request to merge.');
+    const synced = [];
+    for (const r of open) {
+      try {
+        const { pr, sync } = await merge(r.wt, r.at.pr.number);
+        r.at.pr = pr;
+        synced.push(sync);
+      } catch (err) {
+        app.sessionChanged(s, { now: true });
+        throw open.length > 1 ? Object.assign(new Error(`${r.name}: ${err.message}`), { status: err.status }) : err;
+      }
+    }
+    const sync = { ok: synced.every((x) => x.ok), text: synced.map((x) => x.text).join(' ') };
+    return { pr: s.pr || open[0].at.pr, sync, ...(reposOf(s, store).length > 1 && { prs: prsOf(s) }) };
+  };
+
   // Default commit message and PR text, from the session's latest presentation.
   const draft = (s) => {
     const turn = s.turns.findLast((t) => t.status === 'done') || s.turns.at(-1);
@@ -158,7 +243,7 @@ export function createShip(app) {
     delete s.shipping; // a ship cut short by a restart isn't running anymore
     if (s.conflictFix?.step === 'pushing') Object.assign(s.conflictFix, { step: 'failed', why: 'wisp restarted while pushing the fix.' });
   }
-  for (const s of store.all()) if (s.worktree && !s.archived && s.pr?.state !== 'MERGED') recheck(s);
+  for (const s of store.all()) if (hasTrees(s) && !s.archived && s.pr?.state !== 'MERGED') recheck(s);
 
   // Open PRs are checked every minute, and every few seconds while their state is still settling,
   // so a check finishing or a pushed fix clearing the conflict shows up quickly.
@@ -171,7 +256,9 @@ export function createShip(app) {
     if (polling) return;
     polling = true;
     try {
-      const due = store.all().filter((s) => s.pr?.state === 'OPEN' && Date.now() - (s.pr.checkedAt || 0) >= (settling(s) ? PR_FAST_POLL_MS : PR_POLL_MS));
+      // A task's other repos' PRs ride along with its own (or poll on their own when it has none open).
+      const lead = (s) => (s.pr?.state === 'OPEN' ? s.pr : s.also?.find((a) => a.pr?.state === 'OPEN')?.pr);
+      const due = store.all().filter((s) => lead(s) && Date.now() - (lead(s).checkedAt || 0) >= (s.pr?.state === 'OPEN' && settling(s) ? PR_FAST_POLL_MS : PR_POLL_MS));
       await Promise.all(due.map((s) => refreshPr(s).catch(() => {})));
     } finally {
       polling = false;
@@ -179,5 +266,5 @@ export function createShip(app) {
   }, PR_TICK_MS);
   timer.unref();
 
-  return { recheck, refreshPr, fixConflicts, draft, stop: () => clearInterval(timer) };
+  return { recheck, refreshPr, fixConflicts, draft, shipAll, mergeAll, prsOf, stop: () => clearInterval(timer) };
 }

package/server/services/uploads.js

@@ -31,6 +31,28 @@ export class Uploads {
     return Array.isArray(ids) ? ids.map((i) => this.byId.get(i)).filter(Boolean) : [];
   }
 
+  // A file to fill in here (a moved task's bundle): its path, and add() once it's written.
+  reserve(name) {
+    const id = newId();
+    const file = path.join(this.dir, `${id}-${name}`);
+    return { id, file, add: () => this.#record({ id, name, size: fs.statSync(file).size, mime: 'application/octet-stream', path: file }) };
+  }
+
+  remove(id) {
+    const u = this.byId.get(id);
+    if (!u) return false;
+    this.byId.delete(id);
+    fs.rmSync(u.path, { force: true });
+    fs.rmSync(path.join(this.dir, `${id}.json`), { force: true });
+    return true;
+  }
+
+  #record(meta) {
+    this.byId.set(meta.id, meta);
+    fs.writeFileSync(path.join(this.dir, `${meta.id}.json`), JSON.stringify(meta));
+    return meta;
+  }
+
   async receive(req, { name, type }) {
     name = path.basename(name || 'file').replace(/[^\w.\- ]+/g, '_').slice(-120) || 'file';
     const id = newId();
@@ -51,9 +73,6 @@ export class Uploads {
       out.on('finish', resolve);
       out.on('error', reject);
     });
-    const meta = { id, name, size, mime: type || MIME[path.extname(name).toLowerCase()] || 'application/octet-stream', path: file };
-    this.byId.set(id, meta);
-    fs.writeFileSync(path.join(this.dir, `${id}.json`), JSON.stringify(meta));
-    return meta;
+    return this.#record({ id, name, size, mime: type || MIME[path.extname(name).toLowerCase()] || 'application/octet-stream', path: file });
   }
 }

package/server/store.js

@@ -4,11 +4,12 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { randomUUID } from 'node:crypto';
+import { sameRepo } from './git.js';
 import { parsePresentation } from './protocol.js';
 import { writeJsonAtomic } from './util.js';
 
 const DEFAULT_CONFIG = {
-  projects: [], // [{ id, name, path, color, addedAt, machine? }]; machine: the server/machines.js id it lives on
+  projects: [], // [{ id, name, path, color, addedAt, machine?, repo?, copies? }]: see projectFor()
   defaults: { agent: 'auto', mode: 'auto', model: '', effort: '' }, // agent auto: wisp picks harness and model (server/router.js)
   recipes: [], // saved prompts with {params}: server/recipes.js
   triggers: [], // schedules and GitHub watchers: server/triggers.js
@@ -20,6 +21,9 @@ const DEFAULT_CONFIG = {
 const IMAGE_EXT = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg']);
 const MAX_KEPT_IMAGE = 25 * 1024 * 1024;
 
+// The key for this computer in a project's copies (machine ids are 6 hex characters).
+export const HERE = 'here';
+
 export const PROJECT_COLORS = ['violet', 'teal', 'amber', 'rose', 'sky', 'lime', 'orange', 'indigo'];
 
 export class Store {
@@ -85,26 +89,47 @@ export class Store {
   }
 
   // --- projects: plain folders, matched to sessions by path prefix ---
+  //
+  // A project is one repo, and every place can run it. path (on machine, null = this computer) is
+  // where it was added; copies are its checkouts elsewhere, which wisp found or cloned there the
+  // first time a task ran there: { [machine id, or HERE]: path }. repo: its origin URL, once known.
+
+  // The project's folder on `machine` (null = this computer), or null when it has none there yet.
+  pathAt(p, machine = null) {
+    return (p.machine || null) === (machine || null) ? p.path : p.copies?.[machine || HERE] || null;
+  }
 
-  // machine: a project on another computer (paths there are POSIX); null = this one.
+  // machine: a folder on another computer (paths there are POSIX); null = this one.
   projectFor(cwd = '', machine = null) {
     if (!machine && this.isScratch(cwd)) return null; // never inside a project, even one at ~
     const sep = machine ? '/' : path.sep;
     let best = null;
-    for (const p of this.config.projects)
-      if ((p.machine || null) === machine && (cwd === p.path || cwd.startsWith(p.path + sep)) && (!best || p.path.length > best.path.length)) best = p;
+    let len = 0;
+    for (const p of this.config.projects) {
+      const dir = this.pathAt(p, machine);
+      if (dir && (cwd === dir || cwd.startsWith(dir + sep)) && dir.length > len) [best, len] = [p, dir.length];
+    }
     return best;
   }
 
-  addProject(dir, { name, color, machine } = {}) {
-    const existing = this.config.projects.find((p) => p.path === dir && (p.machine || null) === (machine || null));
+  // repo: the folder's origin URL. A folder of a repo that's already a project becomes that
+  // project's copy on this place, so the same repo is one project wherever it's checked out.
+  addProject(dir, { name, color, machine, repo } = {}) {
+    const existing = this.config.projects.find((p) => this.pathAt(p, machine) === dir);
     if (existing) return existing;
+    const same = repo && this.config.projects.find((p) => p.repo && sameRepo(p.repo, repo) && !this.pathAt(p, machine));
+    if (same) {
+      (same.copies ||= {})[machine || HERE] = dir;
+      this.saveConfig();
+      return same;
+    }
     const used = new Set(this.config.projects.map((p) => p.color));
     const project = {
       id: Math.random().toString(36).slice(2, 10),
       name: name || (machine ? path.posix.basename(dir) : path.basename(dir)) || dir,
       path: dir,
       ...(machine && { machine }),
+      ...(repo && { repo }),
       color: color || PROJECT_COLORS.find((c) => !used.has(c)) || PROJECT_COLORS[this.config.projects.length % PROJECT_COLORS.length],
       addedAt: Date.now(),
     };
@@ -113,6 +138,14 @@ export class Store {
     return project;
   }
 
+  // A checkout of the project on `machine`, found or cloned there (services/places.js).
+  setCopy(p, machine, dir) {
+    if (this.pathAt(p, machine) === dir) return;
+    if ((p.machine || null) === (machine || null)) p.path = dir;
+    else (p.copies ||= {})[machine || HERE] = dir;
+    this.saveConfig();
+  }
+
   // Folder-less tasks run in a throwaway directory of their own under ~/.wisp/scratch.
   scratchDir(id) {
     const dir = path.join(this.home, 'scratch', id);

package/skills/wisp/SKILL.md

@@ -23,7 +23,8 @@ wisp "add pagination to /api/users" --cwd ~/code/api --wait     # block until do
 ```
 
 Options: `--agent claude|codex|opencode|cursor|antigravity|grok`, `--mode plan|edits|auto`, `--model ID`,
-`--effort low|medium|high`, `--cwd DIR` (default: current folder), `--wait`, `--json`.
+`--effort low|medium|high`, `--cwd DIR` (default: current folder), `--also DIR` (another folder the
+same agent works in, repeatable: e.g. the API and its web app), `--wait`, `--json`.
 `--json` prints the session summary; its `id` is what every other command takes.
 
 Write the prompt as a self-contained brief: the agent cannot see your conversation. Include the
@@ -36,6 +37,7 @@ wisp wait <id>            # block until it finishes or asks a question; prints t
 wisp show <id>            # current state + latest presentation as markdown
 wisp ls --state running,waiting
 wisp reply <id> "also cover the empty-list case"   # follow-up; answers a pending question too
+wisp btw <id> "did you touch the migrations?"       # side question: answered without interrupting the run
 wisp stop <id>
 ```
 

package/web/css/blocks.css

@@ -412,6 +412,8 @@ pre.code { margin: 0 0 12px; padding: 12px 14px; border-radius: 10px; background
 .tests-rerun-out { margin-top: 12px; padding: 10px 12px; border-radius: 10px; background: var(--term-bg); color: var(--term-ink); }
 .tests-rerun-out pre { margin: 0; font: 12px/1.55 var(--mono); white-space: pre-wrap; word-break: break-word; max-height: 260px; overflow-y: auto; color: #b4b4b0; }
 .rev-tag { display: inline-flex; align-items: center; padding: 1px 6px; border-radius: 5px; font: 500 11px var(--sans); background: var(--bg-2); color: var(--muted); border: 1px solid var(--line); }
+.t-moved { display: inline-flex; align-items: center; gap: 3px; font-size: 11px; color: var(--faint); }
+.t-moved .i { width: 11px; height: 11px; }
 .cp-sha { font: 500 11px var(--mono); color: var(--faint); padding: 1px 5px; border-radius: 5px; background: var(--surface); border: 1px solid var(--line); }
 .b-diff.is-reverted .diff-scroll { opacity: 0.55; }
 .b-diff.is-reverted .path .base, .b-files li.is-reverted .path .base { text-decoration: line-through; color: var(--muted); }