wisp-agents 0.18.0 → 0.21.0

package/server/routes/auto.js

@@ -1,4 +1,5 @@
-// Auto: what the router learned, and its settings (goal, trying new models, allowed harnesses).
+// Auto: what the router learned, and its settings (goal, trying new models, allowed harnesses,
+// and the steps after a run: check, repairs, hand-over, best of two, scout).
 
 import { adapters } from '../adapters/index.js';
 import { GOALS } from '../router.js';
@@ -18,6 +19,12 @@ export function register(r, app) {
     d.router = { ...d.router };
     if (body.explore !== undefined) d.router.explore = body.explore ? 'on' : 'off';
     if (body.allowed !== undefined) d.router.allowed = Array.isArray(body.allowed) ? body.allowed.filter((a) => adapters[a]) : null;
+    for (const k of ['check', 'escalate', 'best2']) if (body[k] !== undefined) d.router[k] = body[k] ? 'on' : 'off';
+    if (body.repairs !== undefined) d.router.repairs = Math.max(0, Math.min(2, Math.round(Number(body.repairs)) || 0));
+    if (body.scout !== undefined) {
+      if (!['off', 'big', 'all'].includes(body.scout)) return c.send(400, { error: 'scout must be off, big or all' });
+      d.router.scout = body.scout;
+    }
     app.configChanged();
     c.send(200, await auto.view());
   });

package/server/routes/sessions.js

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

package/server/routes/settings.js

@@ -157,6 +157,8 @@ export function register(r, app) {
     const body = await c.body();
     if (typeof body.name === 'string' && body.name.trim()) p.name = body.name.trim();
     if (typeof body.color === 'string') p.color = body.color;
+    // Auto's test check: the command to run, '' to detect it, 'off' for none.
+    if (typeof body.testCommand === 'string') body.testCommand.trim() ? (p.testCommand = body.testCommand.trim().slice(0, 500)) : delete p.testCommand;
     app.configChanged();
     c.send(200, p);
   });

package/server/routes/ship.js

@@ -1,7 +1,9 @@
 // Ship it. GET: what would ship (branch, changes, draft message). POST { title, body, draft }:
-// commit, push, open or update the PR. Then follow it (pr) and squash-merge it (merge).
+// commit, push, open or update the PR. Then follow it (pr) and squash-merge it (merge). A task in
+// several repos (also) ships, follows and merges a PR in each (services/ship.js).
 
-import { ship, merge, worktreeStatus } from '../git.js';
+import { worktreeStatus } from '../git.js';
+import { reposOf } from '../services/ship.js';
 
 export function register(r, app) {
   const { store, runner, telemetry } = app;
@@ -11,58 +13,57 @@ export function register(r, app) {
     return fn(c, s);
   };
   const NO_TREE = 'Ship it works on worktree sessions: launch with a worktree to get one.';
+  const hasTrees = (s) => !!(s.worktree || s.also?.some((a) => a.worktree));
 
   r.route(
     'GET',
     '/sessions/:id/ship',
     one(async (c, s) => {
-      if (!s.worktree) return c.send(400, { error: NO_TREE });
+      if (!hasTrees(s)) return c.send(400, { error: NO_TREE });
       app.ship.recheck(s);
-      c.send(200, { branch: s.worktree.branch, base: s.worktree.base, remote: s.worktree.remote, ...(await worktreeStatus(s.worktree)), pr: s.pr || null, ...app.ship.draft(s) });
+      const repos = await Promise.all(reposOf(s, store).map(async (r) => ({ repo: r.name, branch: r.wt.branch, base: r.wt.base, remote: r.wt.remote, ...(await worktreeStatus(r.wt)), pr: r.at.pr || null })));
+      // The first repo's fields at the top level (as before one task could span repos), each in `repos`.
+      const sum = (k) => repos.reduce((n, r) => n + r[k], 0);
+      c.send(200, { ...repos[0], ...(repos.length > 1 && { dirty: sum('dirty'), ahead: sum('ahead'), repos }), ...app.ship.draft(s) });
     }),
   );
   r.route(
     'POST',
     '/sessions/:id/ship',
     one(async (c, s) => {
-      if (!s.worktree) return c.send(400, { error: NO_TREE });
+      if (!hasTrees(s)) return c.send(400, { error: NO_TREE });
       if (runner.live.has(s.id)) return c.send(409, { error: 'Still working: wait for it to finish, or stop it.' });
       if (s.shipping) return c.send(409, { error: 'Already shipping: wait for it to land.' });
       const body = await c.body();
       const draft = app.ship.draft(s);
-      // The card follows along: s.shipping names the stage running now, sent with each summary.
-      s.shipping = { step: 'start', update: s.pr?.state === 'OPEN', startedAt: Date.now() };
-      app.sessionChanged(s);
-      const onStep = (step) => ((s.shipping = { ...s.shipping, step }), app.sessionChanged(s));
-      try {
-        s.pr = await ship(s.worktree, { title: body.title ?? draft.title, body: body.body ?? draft.body, draft: !!body.draft, pr: s.pr, onStep });
-      } finally {
-        delete s.shipping;
-        app.sessionChanged(s, { now: true });
-      }
-      telemetry.track('ship', { agent: s.agent, draft: !!body.draft });
-      app.ship.recheck(s);
-      c.send(200, s.pr);
+      // The card follows along: s.shipping names the stage (and repo) running now, sent with each summary.
+      const pr = await app.ship.shipAll(s, { title: body.title ?? draft.title, body: body.body ?? draft.body, draft: !!body.draft });
+      telemetry.track('ship', { agent: s.agent, draft: !!body.draft, ...(pr.prs && { repos: pr.prs.length }) });
+      c.send(200, pr);
     }),
   );
   r.route(
     'POST',
     '/sessions/:id/pr',
     one(async (c, s) => {
-      if (!s.pr) return c.send(404, { error: 'No pull request yet.' });
+      if (!s.pr && !s.also?.some((a) => a.pr)) return c.send(404, { error: 'No pull request yet.' });
       c.send(200, await app.ship.refreshPr(s));
     }),
   );
-  // Try the automatic conflict fix again after it gave up (see services/ship.js).
+  // Fix conflicts on the PR row: send the task a follow-up to merge the base in now (see
+  // services/ship.js). Trusts the conflict wisp last saw, so it starts at once; asks GitHub only if it saw none.
   r.route(
     'POST',
     '/sessions/:id/fix-conflicts',
     one(async (c, s) => {
       if (s.pr?.state !== 'OPEN' || !s.worktree) return c.send(400, { error: 'No open pull request.' });
       if (runner.live.has(s.id)) return c.send(409, { error: 'Still working: wait for it to finish, or stop it.' });
-      s.conflictFix = { tries: 0 };
-      await app.ship.refreshPr(s);
-      if (s.conflictFix?.step !== 'fixing') return c.send(409, { error: s.pr.conflict ? 'It merges cleanly with the latest base here: GitHub may not have caught up yet.' : 'The PR has no merge conflicts now.' });
+      if (!s.pr.conflict) await app.ship.refreshPr(s);
+      if (s.conflictFix?.step !== 'fixing') await app.ship.fixConflicts(s, { force: true });
+      if (s.conflictFix?.step !== 'fixing') {
+        const why = !s.pr.conflict ? 'The PR has no merge conflicts now.' : !s.worktree.remote ? 'This repo has no origin remote to push to.' : s.ask ? 'The task is waiting for your answer first.' : s.shipping ? 'Already shipping: wait for it to land.' : 'Could not start the fix: try again in a moment.';
+        return c.send(409, { error: why });
+      }
       c.send(200, { conflictFix: s.conflictFix });
     }),
   );
@@ -71,13 +72,12 @@ export function register(r, app) {
     'POST',
     '/sessions/:id/merge',
     one(async (c, s) => {
-      if (!s.pr || !s.worktree) return c.send(400, { error: 'No pull request to merge.' });
-      const { pr, sync } = await merge(s.worktree, s.pr.number);
-      s.pr = pr;
+      if (!reposOf(s, store).some((r) => r.at.pr)) return c.send(400, { error: 'No pull request to merge.' });
+      const out = await app.ship.mergeAll(s);
       app.launcher.markDone(s);
       telemetry.track('merge', { agent: s.agent });
       app.sessionChanged(s, { now: true });
-      c.send(200, { pr, sync });
+      c.send(200, out);
     }),
   );
 }

package/server/runner.js

@@ -46,11 +46,21 @@ export { newId };
 // Where the agent actually works: its own worktree when it has one, else the project folder.
 export const workdir = (s) => s.worktree?.cwd || s.cwd;
 
-// Worktree sessions get told where they are, so they don't go looking for the main checkout.
+// Where the agent works in the task's other folders (also): their worktrees, else the folders.
+export const alsoDirs = (s) => (s.also || []).map((a) => a.worktree?.cwd || a.cwd);
+
+// Worktree sessions get told where they are, so they don't go looking for the main checkout. A task
+// with other folders (also) gets their paths: that's where the work in them goes.
 function workspaceNote(s) {
   const wt = s.worktree;
-  if (!wt) return '';
-  return `\n\n## Workspace\n\nYou are in an isolated git worktree (${wt.path}) on branch \`${wt.branch}\`, created from \`${wt.baseRef}\` for this task only. Other agents may be working in the user's main checkout, so make every change here. Dependencies and build output (node_modules, virtualenvs, dist/) are not shared with the main checkout: install them if a command needs them. Leave your changes uncommitted unless the user asks you to commit; the user ships them from wisp (commit, push, pull request).`;
+  const also = s.also || [];
+  const out = [];
+  if (wt) out.push(`You are in an isolated git worktree (${wt.path}) on branch \`${wt.branch}\`, created from \`${wt.baseRef}\` for this task only. Other agents may be working in the user's main checkout, so make every change here. Dependencies and build output (node_modules, virtualenvs, dist/) are not shared with the main checkout: install them if a command needs them. Leave your changes uncommitted unless the user asks you to commit; the user ships them from wisp (commit, push, pull request).`);
+  if (also.length) {
+    const line = (a) => (a.worktree ? `- \`${a.worktree.cwd}\`: a worktree of \`${a.cwd}\` on branch \`${a.worktree.branch}\` (from \`${a.worktree.baseRef}\`). Work here, not in \`${a.cwd}\`.` : `- \`${a.cwd}\``);
+    out.push(`This task spans ${also.length + 1} folders. Besides your working directory (${workdir(s)}), you work in:\n${also.map(line).join('\n')}\n\nRead and change files in all of them as the task needs, using absolute paths outside your working directory. Run each folder's commands (tests, builds) from inside that folder.${also.some((a) => a.worktree) ? ' Leave the changes there uncommitted too; Ship it opens a pull request per repo.' : ''}`);
+  }
+  return out.length ? `\n\n## Workspace\n\n${out.join('\n\n')}` : '';
 }
 
 // A follow-up's { agent, model, effort }, or null when it's what the session already runs on.
@@ -95,13 +105,20 @@ export function summarize(s, store) {
     updatedAt: s.updatedAt,
     turnCount: s.turns.length,
     queued: s.queue?.length || 0,
-    status: last?.status === 'running' ? 'running' : hero?.status || (last?.status === 'error' ? 'blocked' : 'info'),
+    status: last?.status === 'running' || s.auto?.busy ? 'running' : hero?.status || (last?.status === 'error' ? 'blocked' : 'info'),
     preview: hero?.summary || '',
-    live: s.ask ? `Asks: ${s.ask.question}` : last?.status === 'running' ? waitingOn || lastAct?.label || 'Starting up' : '',
+    live: s.ask ? `Asks: ${s.ask.question}` : last?.status === 'running' ? waitingOn || lastAct?.label || 'Starting up' : s.auto?.busy ? s.auto.label : '',
     asks: !!s.ask || !!last?.presentation?.blocks?.some((b) => b.type === 'question'),
     question: s.ask?.question || '',
     approval: !!s.ask?.permission, // the question is a live approval (Allow / Deny)
     branch: s.worktree?.branch || '',
+    // The task's other folders: their project, worktree branch and PR, for the card and the filter.
+    ...(s.also?.length && {
+      also: s.also.map((a) => {
+        const p = store?.projectFor(a.cwd);
+        return { cwd: a.cwd, project: p?.name || path.basename(a.cwd), projectId: p?.id || null, color: p?.color || 'slate', branch: a.worktree?.branch || '', pr: a.pr ? { number: a.pr.number, url: a.pr.url, state: a.pr.state, draft: a.pr.draft, review: a.pr.review, checks: a.pr.checks, conflict: !!a.pr.conflict } : null };
+      }),
+    }),
     toShip: s.toShip || null, // { dirty, ahead, unpushed } of the worktree, null until checked
     shipping: s.shipping || null, // { step: 'start' | 'commit' | 'push' | 'pr', update } while Ship it runs
     pr: s.pr ? { number: s.pr.number, url: s.pr.url, state: s.pr.state, draft: s.pr.draft, review: s.pr.review, checks: s.pr.checks, conflict: !!s.pr.conflict } : null,
@@ -117,8 +134,23 @@ export function summarize(s, store) {
       }),
     ),
     ...(s.parentId && { parentId: s.parentId, member: s.member }),
+    followups: s.turns.slice(1).filter((t) => t.by !== 'wisp').length, // yours, not Auto's repair rounds
+    // Auto's steps after the run: the last test check, repairs, a hand-over, the best-of-2 pick.
+    auto: s.auto
+      ? {
+          strategy: s.auto.strategy,
+          busy: !!s.auto.busy,
+          stage: s.auto.stage,
+          repairs: s.auto.repairs,
+          check: s.auto.checks.at(-1) ? (({ verdict, command, passed, failed, newFailures, note }) => ({ verdict, command, passed, failed, newFailures: newFailures?.length || 0, note }))(s.auto.checks.at(-1)) : null,
+          escalatedTo: s.auto.escalatedTo || null,
+          escalatedFrom: s.auto.escalatedFrom || null,
+          reason: s.auto.reason || null, // why it moved on: tests | error | limit
+          pick: s.auto.pick && !s.auto.pick.pending ? s.auto.pick : null,
+        }
+      : null,
     // Auto: what it picked and why, for the card's tooltip.
-    route: s.route ? { goal: s.route.goal, type: s.route.type, label: s.route.label, chance: s.route.chance, n: s.route.n, usd: s.route.usd, explored: s.route.explored, trying: s.route.trying, alternatives: s.route.alternatives, ...(s.route.switched && { switched: true }) } : null,
+    route: s.route ? { goal: s.route.goal, type: s.route.type, label: s.route.label, effort: s.route.effort, chance: s.route.chance, n: s.route.n, usd: s.route.usd, explored: s.route.explored, trying: s.route.trying, alternatives: s.route.alternatives, ...(s.route.switched && { switched: true }) } : null,
   };
 }
 
@@ -134,11 +166,13 @@ export class Runner extends EventEmitter {
     this.answers = new Map(); // askId -> answer, until the MCP server picks it up
     this.promptExtra = () => ''; // (session) => text appended to the system prompt (learned preferences)
     this.routeAuto = null; // (prompt, { cwd }) => { agent, model, route } for subagents set to Auto
+    this.pipeline = null; // Auto's check / repair / hand-over steps (server/pipeline.js)
 
     // Anything that was mid-flight when wisp last died is now orphaned.
     for (const s of store.all()) {
       const t = s.turns.at(-1);
       delete s.ask;
+      if (s.auto?.busy) Object.assign(s.auto, { busy: false, stage: 'cancelled', label: '' }); // Auto's step died with wisp
       if (s.state === 'running' || s.state === 'waiting' || t?.status === 'running') {
         if (t?.status === 'running') this.#finishTurn(s, t, { isError: true, stopped: true, text: '' }, 'wisp was restarted while this was running.');
         s.state = 'review';
@@ -148,7 +182,8 @@ export class Runner extends EventEmitter {
   }
 
   // subagents: the team a lead may delegate to. parentId/member: this session is one of them.
-  create({ id = newId(), prompt, cwd, agent = 'claude', mode = 'auto', model = '', effort = '', attachments = [], worktree = null, groupId = null, origin = null, subagents = [], parentId = null, member = '', route = null }) {
+  // also: the task's other folders, [{ cwd, worktree }] (services/launch.js).
+  create({ id = newId(), prompt, cwd, also = [], agent = 'claude', mode = 'auto', model = '', effort = '', attachments = [], worktree = null, groupId = null, origin = null, subagents = [], parentId = null, member = '', route = null, auto = null, scout = null }) {
     if (!adapters[agent]) throw new Error(`Unknown agent: ${agent}`);
     const now = Date.now();
     const session = {
@@ -169,14 +204,17 @@ export class Runner extends EventEmitter {
       queue: [],
       turns: [],
       ...(worktree && { worktree }),
+      ...(also.length && { also }),
       ...(groupId && { groupId }),
       ...(origin && { origin }),
       ...(subagents.length && { subagents, children: {} }),
+      ...(auto && { auto: { strategy: 'single', busy: false, stage: '', label: '', repairs: 0, checks: [], ...auto } }), // server/pipeline.js
+      ...(scout && { scout }), // what the scout found before it started (server/scout.js)
       ...(parentId && { parentId, member }),
-      ...(route && { route }), // how Auto picked agent and model (server/router.js)
+      ...(route && { route }), // how Auto picked agent, model and level (server/router.js)
     };
     this.store.put(session);
-    if (!parentId) this.store.touchProject(cwd); // a subagent's cwd may be the lead's worktree
+    if (!parentId) for (const dir of [...also.map((a) => a.cwd), cwd]) this.store.touchProject(dir); // a subagent's cwd may be the lead's worktree
     this.#startTurn(session, prompt, attachments);
     return session;
   }
@@ -185,10 +223,13 @@ export class Runner extends EventEmitter {
   // follow-up keeps its own, so the run before it isn't affected. run: { agent, model, effort }
   // switches the harness, model and thinking level the same way (see #switchRun).
   // grants / once: a retry of what the last turn's permissions blocked (see approveBlocked).
-  reply(session, text, attachments = [], { queue = false, mode, run, grants, once } = {}) {
+  // by: 'wisp' for a follow-up wisp sends itself (Auto's repair round). Anything else is the
+  // user's, and cancels whatever Auto was about to do next.
+  reply(session, text, attachments = [], { queue = false, mode, run, grants, once, by } = {}) {
     if (!MODES.has(mode) || mode === session.mode) mode = undefined;
     run = changedRun(session, run);
-    const extra = { ...(mode && { mode }), ...(run && { run }), ...(grants?.length && { grants }), ...(MODES.has(once) && { once }) };
+    if (by !== 'wisp') this.pipeline?.cancel(session);
+    const extra = { ...(mode && { mode }), ...(run && { run }), ...(grants?.length && { grants }), ...(MODES.has(once) && { once }), ...(by === 'wisp' && { by }) };
     if (session.ask && !Object.keys(extra).length) {
       this.answer(session, text);
       return { answered: true };
@@ -249,7 +290,7 @@ export class Runner extends EventEmitter {
     if (session.agentSessionId) session.agentSessions[session.agent] = session.agentSessionId;
     for (const t of session.turns) t.agent ||= session.agent;
     // Auto's pick was overruled: the card stops crediting it, and the router learns (services/auto.js).
-    if (session.route && (agent !== session.agent || model !== session.model)) session.route.switched = true;
+    if (session.route && (agent !== session.agent || model !== session.model || effort !== (session.effort || ''))) session.route.switched = true;
     if (agent !== session.agent) {
       session.agent = agent;
       session.agentSessionId = session.agentSessions[agent] || null;
@@ -383,7 +424,7 @@ export class Runner extends EventEmitter {
           out.push({ subagent: want, error: 'Auto found no harness to run this on.' });
           continue;
         }
-        const run = pick ? { agent: pick.agent, model: pick.model, effort: '', route: pick.route } : { agent: m.agent, model: m.model, effort: m.effort };
+        const run = pick ? { agent: pick.agent, model: pick.model, effort: pick.effort || '', route: pick.route } : { agent: m.agent, model: m.model, effort: m.effort };
         child = this.create({ prompt, cwd: workdir(lead), ...run, mode: lead.mode, parentId: lead.id, member: slot });
         (lead.children ||= {})[slot] = child.id;
       }
@@ -413,6 +454,7 @@ export class Runner extends EventEmitter {
   }
 
   stop(session) {
+    this.pipeline?.cancel(session);
     session.queue = [];
     delete session.ask;
     for (const cid of Object.values(session.children || {})) {
@@ -492,9 +534,10 @@ export class Runner extends EventEmitter {
 
   // grants: harness rules allowing what the user approved, for this turn only. once: a mode for
   // this turn only (an approved retry the harness can't scope runs in Full auto).
-  #startTurn(session, prompt, attachments = [], { grants = [], once } = {}) {
+  #startTurn(session, prompt, attachments = [], { grants = [], once, by } = {}) {
     const mode = MODES.has(once) ? once : session.mode;
     const turn = this.#newTurn(session, prompt, attachments, mode);
+    if (by === 'wisp') turn.by = 'wisp'; // sent by wisp (Auto's repair round), not by you
     session.turns.push(turn);
     session.state = 'running';
     session.unread = false;
@@ -517,6 +560,7 @@ export class Runner extends EventEmitter {
       prompt: handoff ? `${handoff}\n\n${text}` : text,
       attachments,
       cwd: workdir(session),
+      dirs: alsoDirs((session.parentId && this.store.get(session.parentId)) || session), // the task's other folders (a subagent's are its lead's)
       resumeId: session.agentSessionId,
       mode,
       grants,
@@ -679,15 +723,37 @@ export class Runner extends EventEmitter {
       if (hero?.title && session.titleAuto && session.turns.length === 1 && !session.groupId) session.title = hero.title;
     }
     if (!ev.stopped) blockedCard(turn);
-    session.state = 'review';
-    session.unread = !interrupted;
+    // Auto checks the work before it reaches you: the session stays in Working meanwhile.
+    const holding = !interrupted && !session.queue.length && !!this.pipeline?.wants(session, turn, ev);
+    session.state = holding ? 'running' : 'review';
+    session.unread = !interrupted && !holding;
     this.store.save(session, { now: true });
     this.#touch(session, { turn: turn.id });
     this.emit('ended', { session, turn, interrupted, errorText: ev.isError && !ev.stopped ? ev.text : '' });
     this.#touchLead(session);
+    if (holding) setImmediate(() => this.pipeline.run(session, turn));
     // The follow-up starts right away; don't notify for the run it replaced. A subagent reports
     // to its lead, not to the user.
-    if (!interrupted && !session.parentId) this.emit('finished', { session: summarize(session, this.store) });
+    else if (!interrupted && !session.parentId) this.emit('finished', { session: summarize(session, this.store) });
+  }
+
+  // Auto is done with a session it held: it lands in your queue (quiet: handed to another run,
+  // which will be the one to notify).
+  settle(session, { quiet = false } = {}) {
+    if (session.state !== 'running' || (this.live.has(session.id) && session.turns.at(-1)?.status === 'running')) return this.#touch(session);
+    session.state = 'review';
+    session.unread = !quiet;
+    this.store.save(session, { now: true });
+    this.#touch(session, { turn: session.turns.at(-1)?.id });
+    if (!quiet && !session.parentId) this.emit('finished', { session: summarize(session, this.store) });
+  }
+
+  // A line in a turn's activity from wisp itself (Auto's check, repair, hand-over).
+  note(session, turn, { kind = 'check', label }) {
+    const item = { t: Date.now(), kind, label: String(label).slice(0, 300), by: 'wisp' };
+    turn.activity.push(item);
+    this.emit('activity', { sessionId: session.id, turnId: turn.id, item });
+    this.#touch(session, { turn: turn.id });
   }
 
   #touch(session, { turn, quiet } = {}) {

package/server/scout.js

@@ -0,0 +1,71 @@
+// The scout: a quick look before an Auto task starts. scanProject() is free (files on disk: the
+// test command, languages, size) and cached; scoutTask() asks a cheap model, read-only, which kind
+// of task it is, how big, and which files matter. Auto routes on that, and the agent gets the
+// file list and test command as a head start.
+
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { detectTests } from './check.js';
+import { askJson } from './quick.js';
+import { TYPES } from './router.js';
+
+const scans = new Map(); // dir -> { at, value }
+const SCAN_TTL_MS = 10 * 60_000;
+
+export function scanProject(dir, project = null) {
+  const key = `${dir}\0${project?.testCommand || ''}`;
+  const hit = scans.get(key);
+  if (hit && Date.now() - hit.at < SCAN_TTL_MS) return hit.value;
+  let files = [];
+  try {
+    files = execFileSync('git', ['ls-files'], { cwd: dir, stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 64 << 20, timeout: 5000 }).toString().split('\n').filter(Boolean);
+  } catch {}
+  const ext = {};
+  for (const f of files) {
+    const e = path.extname(f).slice(1).toLowerCase();
+    if (e && e.length <= 5) ext[e] = (ext[e] || 0) + 1;
+  }
+  const value = {
+    tests: detectTests(dir, project),
+    languages: Object.entries(ext).sort((a, b) => b[1] - a[1]).slice(0, 4).map(([e]) => e),
+    files: files.length,
+  };
+  scans.set(key, { at: Date.now(), value });
+  return value;
+}
+
+// { type, size, files, tests, notes } from a cheap model, or null. Read-only, at most timeoutMs.
+export async function scoutTask({ prompt, cwd, agents, timeoutMs = 75_000, scan = null }) {
+  const ask = `A coding agent is about to work on the task below in this repository. Take a quick, read-only look (list and read a few files; don't run anything slow) and reply with one JSON object:
+
+{"type": one of ${TYPES.map((t) => `"${t}"`).join(', ')},
+ "size": "S" (a few lines in one file) | "M" (a few files) | "L" (many files or a design decision),
+ "files": [up to 8 repo-relative paths that will most likely change or matter],
+ "tests": "the command that runs the tests that cover this, or empty",
+ "notes": "one sentence the agent should know before starting, or empty"}
+${scan?.tests?.command ? `\nThe project's test command is \`${scan.tests.command}\`.` : ''}
+<task>
+${String(prompt).slice(0, 6000)}
+</task>`;
+  const j = await askJson({ agents, prompt: ask, cwd, timeoutMs });
+  if (!j) return null;
+  const files = (Array.isArray(j.files) ? j.files : []).map(String).filter((f) => f && !f.startsWith('/') && !f.includes('..')).slice(0, 8);
+  return {
+    type: TYPES.includes(j.type) ? j.type : null,
+    size: ['S', 'M', 'L'].includes(j.size) ? j.size : null,
+    files,
+    tests: typeof j.tests === 'string' ? j.tests.slice(0, 200) : '',
+    notes: typeof j.notes === 'string' ? j.notes.slice(0, 300) : '',
+  };
+}
+
+// What the agent is told, appended to its system prompt.
+export function scoutNote(scout) {
+  if (!scout) return '';
+  const lines = [];
+  if (scout.files?.length) lines.push(`Likely relevant files: ${scout.files.map((f) => `\`${f}\``).join(', ')}.`);
+  const tests = scout.tests || scout.testCommand;
+  if (tests) lines.push(`Tests: \`${tests}\`. When you finish, wisp runs the project's tests itself and sends any new failures back to you.`);
+  if (scout.notes) lines.push(scout.notes);
+  return lines.length ? `\n\n## Scouted by wisp\n\n${lines.join('\n')}` : '';
+}