wisp-agents 0.18.0 → 0.20.0

package/server/runner.js

@@ -95,9 +95,9 @@ 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)
@@ -117,8 +117,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 +149,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 +165,7 @@ 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 }) {
+  create({ id = newId(), prompt, cwd, agent = 'claude', mode = 'auto', model = '', effort = '', attachments = [], worktree = null, groupId = null, origin = null, subagents = [], parentId = null, member = '', route = null, auto = null, scout = null }) {
     if (!adapters[agent]) throw new Error(`Unknown agent: ${agent}`);
     const now = Date.now();
     const session = {
@@ -172,8 +189,10 @@ export class Runner extends EventEmitter {
       ...(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
@@ -185,10 +204,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 +271,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 +405,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 +435,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 +515,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;
@@ -679,15 +703,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')}` : '';
+}

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,115 @@ 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 wt = s.worktree;
+    const worktree = wt ? await createWorktree({ cwd: s.cwd, home: store.home, id, title: first.prompt, source: { root: wt.root, base: { ref: wt.head || wt.baseRef, branch: wt.base, remote: wt.remote, sha: wt.head } } }).catch(() => null) : null;
+    const sib = app.runner.create({
+      id,
+      prompt: first.prompt,
+      cwd: s.cwd,
+      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

@@ -29,12 +29,16 @@ export function createLaunch(app) {
     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 +66,7 @@ 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 }));
+    return runners.map((r, i) => runner.create({ id: ids[i], prompt: body.prompt, cwd, ...r, mode, attachments, worktree: trees[i], groupId, origin, subagents, ...(r.route && { auto: { strategy }, scout: resolved.scout || null }) }));
   }
 
   // Where a launch runs: body.machine, else a project folder that only exists on a machine
@@ -89,8 +93,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]));

package/server/services/ship.js

@@ -1,7 +1,8 @@
 // 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';
@@ -9,6 +10,8 @@ import { blocksToMarkdown } from '../render.js';
 import { summarize } from '../runner.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
 
@@ -75,20 +78,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 +123,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}` });
@@ -152,9 +160,23 @@ export function createShip(app) {
   }
   for (const s of store.all()) if (s.worktree && !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 {
+      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));
+      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) };

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/ship.css

@@ -63,6 +63,10 @@
 .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%); }
@@ -128,7 +132,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; } }

package/web/index.html

@@ -47,6 +47,7 @@
       <symbol id="i-pen" viewBox="0 0 24 24"><path d="M4 20l1-4L16 5l3 3L8 19l-4 1z" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linejoin="round"/></symbol>
       <symbol id="i-spark" viewBox="0 0 24 24"><path d="M12 3l1.8 5.4L19 10l-5.2 1.6L12 17l-1.8-5.4L5 10l5.2-1.6L12 3zM18.5 15.5l.8 2.2 2.2.8-2.2.8-.8 2.2-.8-2.2-2.2-.8 2.2-.8.8-2.2z" fill="currentColor"/></symbol>
       <symbol id="i-stop" viewBox="0 0 24 24"><rect x="6.5" y="6.5" width="11" height="11" rx="2" fill="currentColor"/></symbol>
+      <symbol id="i-merge" viewBox="0 0 24 24"><circle cx="6" cy="5" r="2.2" fill="none" stroke="currentColor" stroke-width="1.7"/><circle cx="6" cy="19" r="2.2" fill="none" stroke="currentColor" stroke-width="1.7"/><circle cx="18" cy="15" r="2.2" fill="none" stroke="currentColor" stroke-width="1.7"/><path d="M6 7.2v9.6M6 7.2c0 4.4 4.4 7.8 9.8 7.8" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"/></symbol>
       <symbol id="i-send" viewBox="0 0 24 24"><path d="M12 19V5m-6 6l6-6 6 6" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"/></symbol>
       <symbol id="i-enter" viewBox="0 0 24 24"><path d="M19 5v7a3 3 0 01-3 3H5m4-4l-4 4 4 4" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"/></symbol>
       <symbol id="i-queue" viewBox="0 0 24 24"><path d="M4 6h12M4 12h12M4 18h7M17 15v6m-3-3h6" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/></symbol>

package/web/js/blocks.js

@@ -512,7 +512,7 @@ R.tests = (b, ctx) => {
         </svg>
         <div class="ring-label">${icon(ok ? 'check' : 'x')}</div>
         <div class="tests-text">
-          <div class="verdict">${ok ? 'All green' : `${failed} failing`}</div>
+          <div class="verdict">${ok ? 'All green' : `${failed} failing`}${b.by === 'wisp' ? `<span class="tests-by" title="wisp ran the project's tests itself after the agent finished${b.note ? `: ${esc(b.note)}` : ''}">Run by wisp</span>` : ''}</div>
           <div class="counts"><span class="pass"><b class="v" data-v="${passed}"></b> passed</span>${failed ? `<span class="fail"><b class="v" data-v="${failed}"></b> failed</span>` : ''}${skipped ? `<span class="skip"><b class="v" data-v="${skipped}"></b> skipped</span>` : ''}${b.durationMs ? `<span class="dur">${fmtDuration(b.durationMs)}</span>` : ''}</div>
           ${cmd ? `<div class="tests-cmd"><code class="cmdline">$ ${esc(cmd)}</code>${ctx.exec ? `<button class="ghost xs run-tests" title="Re-run ${esc(cmd)}">${icon('rerun')}<span>Re-run</span></button>` : ''}</div>` : ''}
         </div>

package/web/js/features/actions.js

@@ -8,7 +8,7 @@ import { $, el, icon } from '../core/dom.js';
 import { S } from '../core/state.js';
 import { keyHint } from '../ui/kbd.js';
 import { overlay } from '../ui/overlay.js';
-import { popover } from '../ui/popover.js';
+import { clampToViewport, popover } from '../ui/popover.js';
 import { toast, toastError, tryApi } from '../ui/toast.js';
 import { autosize } from './attachments.js';
 import { saveAsRecipe } from './automations.js';
@@ -208,9 +208,7 @@ export function taskMenu(id, e) {
     if (a === 'delete') deleteSession(id);
   };
   const close = popover(menu);
-  const r = menu.getBoundingClientRect();
-  if (r.right > innerWidth - 8) menu.style.left = `${innerWidth - r.width - 8}px`;
-  if (r.bottom > innerHeight - 8) menu.style.top = `${innerHeight - r.height - 8}px`;
+  clampToViewport(menu, e.clientX, e.clientY);
 }
 
 export async function deleteSession(id) {