wisp-agents 0.18.0 → 0.21.0

package/server/services/auto.js

@@ -1,10 +1,15 @@
-// Auto: wisp picks harness and model per task and learns from outcomes (server/router.js).
+// Auto: wisp picks harness, model and thinking level per task and learns from outcomes (server/router.js).
 // This wires the router to the rest of the server: which harnesses are installed here, the
 // user's Auto settings, and the outcome signals that come back from summaries.
 
+import fs from 'node:fs';
 import { listAgents } from '../adapters/index.js';
-import { GOALS } from '../router.js';
-import { bad } from '../util.js';
+import { GOALS, classify } from '../router.js';
+import { createWorktree, repoRoot } from '../git.js';
+import { Pipeline, autoSettings } from '../pipeline.js';
+import { scanProject, scoutTask } from '../scout.js';
+import { summarize } from '../runner.js';
+import { bad, newId } from '../util.js';
 
 export function createAuto(app) {
   const { store, router } = app;
@@ -48,31 +53,123 @@ export function createAuto(app) {
     const pr = sum.pr?.state;
     router.signal(sum.id, {
       hero: ['done', 'partial', 'blocked', 'info'].includes(sum.status) ? sum.status : undefined,
-      followups: Math.max(0, (sum.turnCount || 1) - 1),
+      followups: sum.followups ?? Math.max(0, (sum.turnCount || 1) - 1),
+      check: sum.auto?.check?.verdict && sum.auto.check.verdict !== 'skip' ? sum.auto.check.verdict : undefined,
       merged: pr === 'MERGED' || undefined,
       closed: pr === 'CLOSED' || undefined,
       switched: sum.route?.switched || undefined,
     });
   };
 
-  // agent 'auto' (and compare entries set to it) → a harness and model picked by the router from
+  // agent 'auto' (and compare entries set to it) → a harness, model and thinking level picked by the router from
   // `agents`: this computer's, or the machine's the launch goes to. Model is the goal for Auto.
-  const resolve = async (body, agents, { team = false } = {}) => {
+  // cwd (launches here only): the scout looks at it first, and best-of-2 needs it to be a repo.
+  const resolve = async (body, agents, { team = false, cwd = null } = {}) => {
     const want = [{ agent: body.agent, model: body.model, effort: body.effort }, ...(Array.isArray(body.compare) ? body.compare : [])];
     if (!want.some((r) => r.agent === 'auto')) return body;
+    const set = autoSettings(store.config.defaults);
+    // The scout: the scan is free; the cheap-model look runs for bigger tasks, every task, or never.
+    let scout = null;
+    if (cwd) {
+      const scan = scanProject(cwd, store.projectFor(cwd));
+      scout = { testCommand: scan.tests?.command || '', languages: scan.languages };
+      const big = classify(body.prompt).size !== 'S' || String(body.prompt).length > 400;
+      if (set.scout === 'all' || (set.scout === 'big' && big)) {
+        const found = await scoutTask({ prompt: body.prompt, cwd, agents, scan }).catch(() => null);
+        if (found) Object.assign(scout, found, { by: 'model' });
+      }
+    }
+    // Best-of-2: the Best goal (or an important task) gets two different picks side by side, each
+    // in its own worktree, and wisp marks the better one once both are checked.
+    const goal = goalOf(want[0].model);
+    const best2 = !!cwd && set.best2 && want.length === 1 && want[0].agent === 'auto' && (goal === 'best' || !!body.important) && !team && !!(await repoRoot(cwd).catch(() => null));
+    if (best2) want.push({ agent: 'auto', model: want[0].model });
     const taken = [];
-    const out = want.map((r, i) => {
-      if (r.agent !== 'auto') return r;
-      const pick = router.choose({ prompt: body.prompt, attachments: (body.attachments || []).length, agents, goal: goalOf(r.model), important: !!body.important, exclude: taken, needDelegate: i === 0 && team, ...opts() });
-      if (!pick) throw bad('Auto found no installed harness to run this on.');
-      taken.push(pick.key);
-      return { agent: pick.agent, model: pick.model, effort: '', route: pick.route };
+    const out = want
+      .map((r, i) => {
+        if (r.agent !== 'auto') return r;
+        const pick = router.choose({ prompt: body.prompt, attachments: (body.attachments || []).length, agents, goal: goalOf(r.model), important: !!body.important || (best2 && i === 0), exclude: taken, needDelegate: i === 0 && team, scouted: scout?.by ? scout : null, ...opts() });
+        if (!pick) {
+          if (best2 && i === 1) return null; // only one option to pick from: a single run then
+          throw bad('Auto found no installed harness to run this on.');
+        }
+        taken.push(pick.key);
+        return { agent: pick.agent, model: pick.model, effort: pick.effort, route: pick.route };
+      })
+      .filter(Boolean);
+    const autoStrategy = best2 && out.length === 2 ? 'best2' : out.length > 1 ? 'compare' : 'single';
+    return { ...body, ...out[0], compare: out.slice(1), scout, autoStrategy };
+  };
+
+  // Escalation: the same task again on a stronger pick, in its own worktree from the same base,
+  // next to the first run (one task, two rows).
+  // reason: 'tests' | 'error' (a hand-over to a stronger pick) or 'limit' (the harness was at its
+  // usage limit: the new run is a fresh start that may still repair and hand over itself).
+  const launchSibling = async (s, pick, { reason = 'tests', tried = [] } = {}) => {
+    const first = s.turns[0];
+    const id = newId();
+    if (!s.groupId) s.groupId = newId();
+    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 || '',
+      mode: s.mode,
+      attachments: app.uploads.resolve((first.attachments || []).map((a) => a.id)),
+      worktree,
+      groupId: s.groupId,
+      origin: s.origin || null,
+      subagents: s.subagents || [],
+      route: { ...pick.route, escalated: reason !== 'limit', ...(reason === 'limit' && { moved: true }) },
+      auto: { strategy: reason === 'limit' ? s.auto?.strategy || 'single' : 'escalated', escalatedFrom: s.id, reason, tried: [...new Set([...tried, ...(s.auto?.tried || []), s.route?.key].filter(Boolean))] },
+      scout: s.scout || null,
     });
-    return { ...body, ...out[0], compare: out.slice(1) };
+    // Now one task with two runs: it's named after the prompt, like a compare task.
+    if (s.titleAuto) s.title = sib.title;
+    app.sessionChanged(s);
+    return sib;
   };
 
+  // Auto's steps after a run: check with the tests, repair, hand over, judge best-of-2.
+  const pipeline = new Pipeline({
+    store,
+    runner: app.runner,
+    router,
+    settings: () => autoSettings(store.config.defaults),
+    agents: () => agentsHere,
+    projectOf: (s) => store.projectFor(s.cwd),
+    launchSibling,
+    broadcast: (e, d) => app.broadcast(e, d),
+    summarize: (s) => summarize(s, store),
+    onSettled: (s) => {
+      signals(summarize(s, store));
+      const a = s.auto;
+      const c = a.checks.at(-1);
+      app.telemetry.track('auto_settled', { strategy: a.strategy, verdict: c?.verdict || 'none', repairs: a.repairs, escalated: !!a.escalatedTo, escalation: !!a.escalatedFrom, checkMs: c?.durationMs, routeType: s.route?.type });
+    },
+  });
+  app.runner.pipeline = pipeline;
+
+  // The test command per project (here only), for the Auto view.
+  const projects = () =>
+    store.config.projects
+      .filter((p) => !p.machine && fs.existsSync(p.path))
+      .map((p) => ({ id: p.id, name: p.name, color: p.color, testCommand: p.testCommand || '', detected: scanProject(p.path, { ...p, testCommand: '' }).tests }));
+
   // What the Auto view shows: goals, settings, and what the router learned.
-  const view = async () => ({ goals: GOALS, goal: goalOf(), settings: { explore: opts().explore, allowed: opts().allowed }, ...router.report(await agents()) });
+  const view = async () => ({ goals: GOALS, goal: goalOf(), settings: { explore: opts().explore, allowed: opts().allowed, ...autoSettings(store.config.defaults) }, projects: projects(), ...router.report(await agents()) });
 
   return { detect, agents, listed, opts, goalOf, signals, resolve, view };
 }

package/server/services/launch.js

@@ -2,6 +2,7 @@
 // runs), here or on a machine, plus the follow-ups and "done" that every surface shares.
 
 import fs from 'node:fs';
+import path from 'node:path';
 import { adapters } from '../adapters/index.js';
 import { createWorktree, worktreeSource, ensureWorktree, removeWorktree } from '../git.js';
 import { qualify } from '../machines.js';
@@ -11,11 +12,32 @@ import { normalizeTeam } from '../subagents.js';
 import { bad, expand, MODES, newId } from '../util.js';
 
 export const MAX_COMPARE = 4;
+export const MAX_ALSO = 8; // extra folders one task may work in
+
+// also: more folders the task works in besides cwd (a backend and its web app, say). Each must be
+// a directory; repeats, cwd itself and folders inside one already listed are dropped.
+export function alsoDirs(list, cwd) {
+  if (list === undefined || list === null) return [];
+  if (!Array.isArray(list)) throw bad('also must be a list of folders.');
+  const inside = (a, b) => a === b || a.startsWith(b.endsWith(path.sep) ? b : b + path.sep);
+  const out = [];
+  for (const x of list) {
+    const raw = typeof x === 'string' ? x : x?.cwd;
+    if (!String(raw || '').trim()) continue;
+    const dir = path.resolve(expand(String(raw).trim()));
+    if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) throw bad(`Not a directory: ${dir}`);
+    if (inside(dir, cwd) || out.some((d) => inside(dir, d))) continue;
+    for (let i = out.length - 1; i >= 0; i--) if (inside(out[i], dir)) out.splice(i, 1);
+    out.push(dir);
+  }
+  if (out.length > MAX_ALSO) throw bad(`A task can work in up to ${MAX_ALSO + 1} folders.`);
+  return out;
+}
 
 export function createLaunch(app) {
   const { store, runner, machines } = app;
 
-  // body: { prompt, cwd, scratch: true = no folder, agent, mode, model, effort, attachments: [uploadId], worktree, compare,
+  // body: { prompt, cwd, also: [folder], scratch: true = no folder, agent, mode, model, effort, attachments: [uploadId], worktree, compare,
   //         subagents: [{ name, agent, model, effort, use }] | preset: teamId }
   async function launch(body, origin = null) {
     if (!String(body.prompt || '').trim()) throw bad('prompt required');
@@ -23,18 +45,23 @@ export function createLaunch(app) {
     const scratch = body.scratch === true;
     const cwd = scratch ? store.scratchDir(newId()) : expand(body.cwd || process.cwd());
     if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) throw bad(`Not a directory: ${cwd}`);
+    const also = scratch ? [] : alsoDirs(body.also, cwd);
     const d = store.config.defaults;
     const preset = body.preset && store.config.teams.find((t) => t.id === body.preset);
     if (body.preset && !preset && !body.subagents) throw bad(`no such subagent preset: ${body.preset}`);
     const subagents = normalizeTeam(body.subagents ?? preset?.members, adapters);
     // compare: more { agent, model, effort } to run the same task on, side by side. 'auto' is
     // resolved here: the router picks a harness and model (a different one per compare run).
-    const resolved = await app.auto.resolve(body, await app.auto.agents(), { team: subagents.length > 0 });
-    const runners = [{ agent: resolved.agent, model: resolved.model, effort: resolved.effort, route: resolved.route }, ...(resolved.compare || [])].slice(0, MAX_COMPARE).map((r, i) => {
+    const resolved = await app.auto.resolve(body, await app.auto.agents(), { team: subagents.length > 0, cwd });
+    // A launch routed by another wisp (this is a machine) arrives with its route: Auto's steps
+    // (check, repair) still run here, where the files are.
+    const isRoute = (x) => x && typeof x === 'object' && typeof x.key === 'string';
+    const runners = [{ agent: resolved.agent, model: resolved.model, effort: resolved.effort, route: resolved.route ?? body.route }, ...(resolved.compare || [])].slice(0, MAX_COMPARE).map((r, i) => {
       const agent = r.agent || (i ? d.agent : '') || 'claude';
       if (!adapters[agent]) throw bad(`unknown agent: ${agent}`);
-      return { agent, model: r.model ?? (i ? d.models?.[agent] || '' : ''), effort: /^[\w-]{1,20}$/.test(r.effort || '') ? r.effort : '', ...(r.route && { route: r.route }) };
+      return { agent, model: r.model ?? (i ? d.models?.[agent] || '' : ''), effort: /^[\w-]{1,20}$/.test(r.effort || '') ? r.effort : '', ...(isRoute(r.route) && { route: r.route }) };
     });
+    const strategy = ['single', 'best2', 'compare'].includes(resolved.autoStrategy) ? resolved.autoStrategy : runners.length > 1 ? 'compare' : 'single';
     const mode = MODES.has(body.mode) ? body.mode : 'auto';
     // Worktrees are on by default in git repos (off in Plan mode: nothing gets written). Compare
     // runs need one each, or the harnesses would edit the same files.
@@ -62,7 +89,16 @@ export function createLaunch(app) {
       }
       if (failed) console.warn(`wisp: no worktree for ${cwd}: ${failed.message}`);
     }
-    return runners.map((r, i) => runner.create({ id: ids[i], prompt: body.prompt, cwd, ...r, mode, attachments, worktree: trees[i], groupId, origin, subagents }));
+    // 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
@@ -89,8 +125,9 @@ export function createLaunch(app) {
     // back through the summaries it streams (auto.signals), so one router learns from every place.
     const routed = await app.auto.resolve(body, machines.agentsOf(mid) || [], { team: !!(body.subagents?.length || body.preset) });
     const routes = [routed.route, ...(routed.compare || []).map((c) => c.route)];
-    const sendBody = { ...routed, compare: routed.compare?.map(({ route, ...c }) => c) };
-    delete sendBody.route;
+    // The machine runs Auto's check and repair on these picks (an older wisp there ignores them).
+    const sendBody = { ...routed };
+    delete sendBody.scout;
     if (!sendBody.compare?.length && !body.compare) delete sendBody.compare;
     const out = await machines.launch(mid, { ...sendBody, attachments: await pushUploads(mid, body.attachments), ...(origin && { origin }) });
     (out.group || [out]).forEach((x, i) => routes[i] && app.router.record(qualify(x.id, mid), routes[i]));
@@ -105,7 +142,7 @@ export function createLaunch(app) {
 
   // A follow-up from anywhere (UI, CLI, phone). An archived session may have lost its worktree.
   async function replyTo(s, text, attachments = [], queue, mode, run) {
-    await ensureWorktree(s.worktree);
+    for (const x of [s, ...(s.also || [])]) await ensureWorktree(x.worktree);
     return runner.reply(s, text, attachments, { queue: queue ?? store.config.defaults.followUp === 'queue', mode, run });
   }
 

package/server/services/ship.js

@@ -1,14 +1,19 @@
 // Ship it: whether a worktree session has something to ship, the draft commit message and PR
 // text, and following open PRs (checks, reviews, merges) so their cards stay current. A PR that
-// starts conflicting with its base gets fixed on its own: the task is sent a follow-up to merge the
-// base in, and the result is pushed to the PR when it's done (defaults.fixConflicts: 'off' to stop).
+// conflicts with its base gets fixed when the user clicks Fix conflicts on its row (or on its own
+// with defaults.fixConflicts: 'on'): the task is sent a follow-up to merge the base in, and the
+// 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
+const PR_TICK_MS = 5_000;
 const SHIP_RECHECK_MS = 5_000;
 const MAX_CONFLICT_FIXES = 3; // per task, so a base that keeps moving can't run up the bill
 
@@ -26,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);
@@ -44,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);
@@ -58,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);
@@ -75,20 +110,24 @@ export function createShip(app) {
     return pr;
   };
 
-  // The PR conflicts with its base: send the task a follow-up to merge the base in. Once per PR
-  // head, so a fix that didn't take isn't retried until something changes the branch.
+  // The PR conflicts with its base: send the task a follow-up to merge the base in. Only when the
+  // user clicks Fix conflicts (force), unless defaults.fixConflicts is 'on': then on its own, once
+  // per PR head, so a fix that didn't take isn't retried until something changes the branch.
   const starting = new Set(); // a poll and a refresh at once must not both send it
-  const fixConflicts = async (s) => {
+  const fixConflicts = async (s, { force = false } = {}) => {
     const pr = s.pr;
-    if (store.config.defaults.fixConflicts === 'off' || pr?.state !== 'OPEN' || !pr.conflict || !s.worktree?.remote) return;
+    if ((!force && store.config.defaults.fixConflicts !== 'on') || pr?.state !== 'OPEN' || !pr.conflict || !s.worktree?.remote) return;
     if (runner.live.has(s.id) || s.shipping || s.ask || s.archived || starting.has(s.id)) return;
     const tries = s.conflictFix?.tries || 0;
-    if (s.conflictFix?.head === pr.head || tries >= MAX_CONFLICT_FIXES) return;
-    starting.add(s.id);
-    try {
-      if ((await conflictsWithBase(s.worktree)) === false || runner.live.has(s.id)) return;
-    } finally {
-      starting.delete(s.id);
+    if (!force && (s.conflictFix?.head === pr.head || tries >= MAX_CONFLICT_FIXES)) return;
+    // The user saw the conflict and asked: no fetch first, the follow-up starts at once.
+    if (!force) {
+      starting.add(s.id);
+      try {
+        if ((await conflictsWithBase(s.worktree)) === false || runner.live.has(s.id)) return;
+      } finally {
+        starting.delete(s.id);
+      }
     }
     s.conflictFix = { step: 'fixing', head: pr.head, tries: tries + 1, startedAt: Date.now() };
     await app.launcher.replyTo(s, conflictPrompt(s), [], true);
@@ -116,6 +155,7 @@ export function createShip(app) {
     const onStep = (step) => ((s.shipping = { ...s.shipping, step }), app.sessionChanged(s));
     try {
       s.pr = await ship(s.worktree, { title: `Merge ${s.worktree.remote}/${s.worktree.base} into ${s.worktree.branch}`, pr: s.pr, onStep });
+      s.pushedAt = Date.now();
       fix.step = 'done';
     } catch (err) {
       Object.assign(fix, { step: 'failed', why: `Push failed: ${err.message}` });
@@ -127,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);
@@ -150,12 +243,28 @@ 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.
+  const settling = (s) => {
+    const pr = s.pr;
+    return !!(pr.checks?.pending || pr.mergeState === 'UNKNOWN' || ['pushing', 'done'].includes(s.conflictFix?.step) || Date.now() - (s.pushedAt || 0) < 5 * 60_000);
+  };
+  let polling = false;
   const timer = setInterval(async () => {
-    for (const s of store.all()) if (s.pr?.state === 'OPEN') await refreshPr(s).catch(() => {});
-  }, PR_POLL_MS);
+    if (polling) return;
+    polling = true;
+    try {
+      // 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;
+    }
+  }, 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/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

package/web/css/auto.css

@@ -27,3 +27,25 @@
 .ro-recent .dim { color: var(--faint); }
 .ro-foot { display: flex; align-items: center; gap: 10px; margin-top: 16px; }
 .ro-foot .hint { margin: 0; }
+
+/* Auto's steps after a run: check, repair, hand-over, best of two */
+.pill.auto-ck { gap: 4px; }
+.pill.auto-ck .i, .pill.auto-pick .i { width: 11px; height: 11px; }
+.pill.auto-ck.ck-pass { --tone: var(--good); color: var(--good); }
+.pill.auto-ck.ck-fail { --tone: var(--bad); color: var(--bad); }
+.pill.auto-ck.ck-unknown { color: var(--muted); }
+.pill.auto-pick { gap: 4px; color: var(--accent-ink); }
+.pill.auto-handed { color: var(--muted); }
+.ask.by-wisp { background: color-mix(in srgb, var(--accent) 6%, var(--bg-2)); }
+.ask-by { display: flex; align-items: center; gap: 5px; margin-bottom: 4px; font-size: 11.5px; font-weight: 500; color: var(--accent-ink); }
+.ask-by .i { width: 12px; height: 12px; }
+.t-by { font-weight: 600; color: var(--accent-ink); }
+.tests-by { margin-left: 8px; padding: 1px 6px; border-radius: 5px; font-size: 11px; font-weight: 500; vertical-align: middle; color: var(--accent-ink); background: var(--accent-soft); }
+.ro-repairs, .ro-scout { flex: none; }
+.ro-tests { display: flex; flex-direction: column; }
+.ro-test { display: flex; align-items: center; gap: 12px; padding: 6px 0; border-bottom: 1px solid var(--line); }
+.ro-test .us-proj { width: 160px; flex: none; font-size: 12.5px; }
+.ro-test .input { flex: 1; min-width: 0; font-size: 12px; }
+.router-modal .hint code { font-size: 11px; padding: 0 4px; border-radius: 4px; background: var(--bg-2); }
+.ro-tier { margin-left: 6px; padding: 0 5px; border-radius: 4px; font-style: normal; font-size: 10.5px; color: var(--faint); background: var(--bg-2); }
+.ro-tier.t3 { color: var(--accent-ink); background: var(--accent-soft); }

package/web/css/feed.css

@@ -78,6 +78,9 @@
   font-size: 11px; font-weight: 500; padding: 0 7px; border-radius: 5px; line-height: 19px; white-space: nowrap; max-width: 120px; overflow: hidden; text-overflow: ellipsis;
   color: color-mix(in srgb, var(--pc) 65%, var(--ink)); background: color-mix(in srgb, var(--pc) 10%, transparent);
 }
+/* a task in several folders: the others after its own, each in its colour */
+.q-proj.multi { max-width: 180px; }
+.q-also { margin-left: 4px; color: color-mix(in srgb, var(--pc) 65%, var(--ink)); }
 .q-time { font-size: 11.5px; color: var(--faint); min-width: 26px; text-align: right; font-variant-numeric: tabular-nums; }
 .q-queued { font-size: 11px; color: var(--accent-ink); font-weight: 600; }
 /* one-click done on collapsed review rows; revealed on hover/focus */

package/web/css/launcher.css

@@ -41,6 +41,18 @@
 .lp-chip.more:hover, .lp-chip.more.open { color: var(--ink); border-color: var(--line-2); }
 .lp-chip.more .i { width: 12px; height: 12px; }
 .l-projects .lp-chip[hidden] { display: none; }
+/* one task, several folders: a small badge on a chip's corner adds it (+) or leaves it out (×) */
+.l-projects .lp-chip { position: relative; }
+.lp-also {
+  position: absolute; top: -6px; right: -5px; display: grid; place-items: center; width: 16px; height: 16px; border-radius: 50%;
+  background: var(--surface); border: 1px solid var(--line-2); color: var(--muted); box-shadow: var(--shadow-1);
+  opacity: 0; transform: scale(0.6); transition: opacity 0.12s, transform 0.12s, color 0.12s, background 0.12s; pointer-events: none;
+}
+.lp-also .i { width: 10px; height: 10px; }
+.lp-chip:is(:hover, :focus-visible) .lp-also { opacity: 1; transform: none; pointer-events: auto; }
+.lp-also:hover { color: #fff; background: var(--accent); border-color: var(--accent); }
+.lp-also.x:hover { background: var(--bad); border-color: var(--bad); }
+@media (hover: none) { .lp-also:not(.x) { opacity: 1; transform: none; pointer-events: auto; } }
 /* narrow, with "+N" (whose list has No folder too): it goes icon-only unless picked */
 @container launcher (max-width: 520px) { .l-projects:has(.more:not([hidden])) .lp-chip.none:not(.on) span { display: none; } }
 /* recipes: one-click prompts under the launch bar */

package/web/css/palette.css

@@ -73,6 +73,12 @@
 .pm-row .p-run { flex: none; }
 .pm-row .pm-check { flex: none; width: 14px; height: 14px; color: var(--accent); visibility: hidden; }
 .pm-row.on .pm-check { visibility: visible; }
+/* the launcher's list: + adds a project to the task, ✓ shows it's in */
+.pm-also { flex: none; display: grid; place-items: center; width: 20px; height: 20px; margin: -2px -4px -2px 0; border-radius: 6px; color: var(--faint); }
+.pm-also .i { width: 13px; height: 13px; }
+.pm-also:hover { color: var(--ink); background: var(--surface-2); }
+.pm-row.in .pm-also { color: var(--accent); }
+.pm-row.in .pm-name { font-weight: 500; color: var(--ink); }
 .pm-x .i { width: 14px; height: 14px; color: var(--muted); }
 .pm-empty { padding: 18px 10px; text-align: center; font-size: 13px; color: var(--muted); }
 .menu .danger:hover { color: var(--bad); background: var(--del-bg); }

package/web/css/ship.css

@@ -42,6 +42,7 @@
 .pill.st-running { --tone: var(--accent); }
 .it-meta .m.branch, .it-meta .m:has(> .i) { display: inline-flex; align-items: center; gap: 4px; min-width: 0; overflow: hidden; text-overflow: ellipsis; }
 .it-meta .m.branch { font: 11px var(--mono); color: var(--ink-2); }
+.it-meta .m.also { display: inline-flex; align-items: center; gap: 5px; color: var(--ink-2); }
 .it-meta .m .i { width: 12px; height: 12px; flex: none; color: var(--faint); }
 .it-meta .m.m-plan, .it-meta .m.m-plan .i { color: var(--accent-ink); }
 .it-meta .m.m-auto, .it-meta .m.m-auto .i { color: var(--warn); }
@@ -60,9 +61,21 @@
 .pr-dot { width: 7px; height: 7px; border-radius: 50%; background: var(--tone); flex: none; }
 .pr-strip.pr-pending .pr-dot { animation: pulse 1.4s ease-in-out infinite; }
 .pr-num { font-weight: 600; color: var(--ink); white-space: nowrap; }
+/* a task in several repos: their PRs after the first, each with its own tone */
+.pr-also { --tone: var(--good); display: inline-flex; align-items: center; gap: 5px; flex: none; padding: 1px 7px; border-radius: 6px; font-weight: 500; color: var(--ink); white-space: nowrap; background: color-mix(in srgb, var(--tone) 10%, transparent); }
+.pr-also i { width: 6px; height: 6px; border-radius: 50%; background: var(--tone); }
+.pr-also:hover { background: color-mix(in srgb, var(--tone) 18%, transparent); }
+.pr-also.pr-pending { --tone: var(--warn); }
+.pr-also.pr-fail { --tone: var(--bad); }
+.pr-also.pr-merged { --tone: #8250df; }
+.pr-also.pr-closed { --tone: var(--faint); }
 .pr-line { color: var(--ink-2); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
 .pr-strip .ghost .i { width: 13px; height: 13px; }
 .pr-strip .pr-merge { color: var(--good); font-weight: 500; }
+.pr-strip .pr-fix { color: var(--bad); font-weight: 500; }
+.pr-strip > .ghost { flex: none; white-space: nowrap; }
+.pr-strip [data-pr="refresh"].busy .i { animation: pr-spin 0.8s linear infinite; }
+@keyframes pr-spin { to { transform: rotate(-360deg); } }
 @keyframes pulse { 50% { opacity: 0.35; } }
 
 .ship-modal, .run-modal { width: min(620px, 100%); }
@@ -70,12 +83,15 @@
 .ship-route code { font: 12px var(--mono); padding: 1px 6px; border-radius: 6px; background: var(--bg-2); }
 .ship-route .i { width: 13px; height: 13px; color: var(--faint); }
 .ship-route .muted { margin-left: auto; }
+.ship-route .ship-repo { font-weight: 600; color: var(--ink); }
+.ship-route + .ship-route { margin-top: -6px; }
 .ship-field { display: flex; flex-direction: column; gap: 6px; margin: 12px 0 0; }
 .ship-field > span { font-size: 12.5px; font-weight: 500; color: var(--ink-2); }
 .ship-field select { width: 100%; }
 .ship-check { display: flex; margin-top: 10px; }
 .ship-foot { display: flex; align-items: center; gap: 12px; margin-top: 16px; }
 .ship-foot > .muted { margin-right: auto; }
+.ship-foot > .primary { flex: none; white-space: nowrap; }
 .ship-foot code { font-size: 11px; }
 .hint.bad { color: var(--bad); }
 
@@ -128,7 +144,7 @@
 .pill.ship-pill { --tone: var(--accent); }
 .pill.ship-pill i { animation: pulse 1.1s ease-in-out infinite; }
 @keyframes ship-in { from { opacity: 0; transform: translateY(6px) scale(0.98); } }
-@keyframes ship-fly { 50% { transform: translate(2px, -2px); } }
+@keyframes ship-fly { 50% { transform: translateY(-2.5px); } }
 @keyframes ship-sweep { from { background-position: -40% 0; } to { background-position: 140% 0; } }
 @keyframes ship-land { from { box-shadow: 0 0 0 3px color-mix(in srgb, var(--good) 30%, transparent); transform: scale(1.015); } }
 @media (max-width: 640px) { .ship-track span { display: none; } }