wisp-agents 0.17.0 → 0.20.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/meta.js

@@ -34,7 +34,7 @@ export function register(r, app) {
 
   r.route('GET', '/openapi.json', (c) => c.send(200, openapi({ version: VERSION, port })), { doc: false });
 
-  r.route('GET', '/agents', async (c) => c.send(200, await app.auto.detect({ fresh: c.query.has('fresh') })));
+  r.route('GET', '/agents', async (c) => c.send(200, await (c.query.has('fresh') ? app.auto.detect({ fresh: true }) : app.auto.listed())));
   // Re-check: detect harnesses and models again, here and on every online machine.
   r.route('POST', '/agents/recheck', async (c) => {
     const [agents] = await Promise.all([app.auto.detect({ fresh: true }), machines.recheckAgents()]);

package/server/routes/settings.js

@@ -9,16 +9,27 @@ import { normalizePreset } from '../subagents.js';
 import { envDisabled, feedbackAvailable } from '../telemetry.js';
 import { TERMINALS } from '../terminal.js';
 import { normalizeWebhooks } from '../services/webhooks.js';
+import { cloneRepo, gh, git, parseRepo } from '../git.js';
 import { expand } from '../util.js';
 
 // Where people keep their repos, for one-click "add project".
 const REPO_ROOTS = ['code', 'Code', 'dev', 'Developer', 'projects', 'Projects', 'src', 'repos', 'work', 'git', 'GitHub', 'Documents', 'Downloads', 'Desktop'];
 
+// Where a pasted repo URL is cloned: defaults.cloneDir, else the first usual repo folder that
+// exists (not Documents/Downloads/Desktop), else ~/code.
+export function cloneRoot(config) {
+  if (config.defaults?.cloneDir) return expand(config.defaults.cloneDir);
+  const dir = REPO_ROOTS.slice(0, -3)
+    .map((r) => path.join(os.homedir(), r))
+    .find((d) => fs.existsSync(d) && fs.statSync(d).isDirectory());
+  return dir || path.join(os.homedir(), 'code');
+}
+
 export function register(r, app) {
   const { store, telemetry, prefs, retro, remote, machines } = app;
 
   r.route('GET', '/config', (c) =>
-    c.send(200, { ...store.config, remote: undefined, home: os.homedir(), cwd: process.cwd(), terminals: TERMINALS, telemetry: { available: !envDisabled(), enabled: telemetry.enabled }, feedback: feedbackAvailable() }),
+    c.send(200, { ...store.config, remote: undefined, home: os.homedir(), cwd: process.cwd(), cloneDir: cloneRoot(store.config), terminals: TERMINALS, telemetry: { available: !envDisabled(), enabled: telemetry.enabled }, feedback: feedbackAvailable() }),
   );
   r.route('PATCH', '/config', async (c) => {
     const body = await c.body();
@@ -91,18 +102,54 @@ export function register(r, app) {
   r.route('POST', '/projects', async (c) => {
     const body = await c.body();
     if (body.machine) {
-      const p = await machines.addProject(String(body.machine), String(body.path || '').trim(), body.name);
+      const p = await machines.addProject(String(body.machine), String(body.repo || body.path || '').trim(), body.name);
       app.broadcast('config', {});
       return c.send(201, p);
     }
-    const dir = expand(body.path || '');
+    // A repo URL (in `repo`, or pasted into `path`): clone it, then add the clone.
+    const typed = String(body.repo || body.path || '').trim();
+    const local = !body.repo && (/^[~./\\]|^[a-z]:/i.test(typed) || fs.existsSync(expand(typed)));
+    const repo = !local && parseRepo(typed, { shorthand: true });
+    if (body.repo && !repo) return c.send(400, { error: `Not a repo URL: ${typed}` });
+    let dir = expand(typed);
+    let cloned = null;
+    if (repo) {
+      const out = await cloneRepo(repo, cloneRoot(store.config));
+      dir = out.dir;
+      cloned = { url: repo.url, existed: out.existed };
+    }
     if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return c.send(400, { error: `Not a folder: ${dir}` });
     const p = store.addProject(dir, { name: body.name });
     app.broadcast('config', {});
-    c.send(201, p);
+    c.send(201, cloned ? { ...p, cloned } : p);
   });
   // Find git repos in the usual places so adding projects is one click.
   r.route('GET', '/projects/discover', (c) => c.send(200, discoverRepos(new Set(store.config.projects.map((p) => p.path)))), { doc: false });
+  // The user's GitHub repos (gh's login), newest first, minus ones already added: one click clones.
+  // Empty when gh isn't installed or signed in.
+  r.route(
+    'GET',
+    '/projects/github',
+    async (c) => {
+      const list = await gh(os.homedir(), ['repo', 'list', '--limit', '40', '--json', 'nameWithOwner,description,isPrivate,isFork,pushedAt,url'], { timeout: 20_000 })
+        .then((out) => JSON.parse(out || '[]'))
+        .catch(() => null);
+      if (!list) return c.send(200, []);
+      const origins = await Promise.all(
+        store.config.projects.filter((p) => !p.machine).map((p) => git(p.path, ['remote', 'get-url', 'origin'], { timeout: 5000 }).catch(() => '')),
+      );
+      const have = new Set(origins.map((o) => parseRepo(o)?.gh?.toLowerCase()).filter(Boolean));
+      c.send(
+        200,
+        list
+          .filter((x) => !have.has(x.nameWithOwner.toLowerCase()))
+          .sort((a, b) => String(b.pushedAt).localeCompare(String(a.pushedAt)))
+          .slice(0, 24)
+          .map((x) => ({ repo: x.nameWithOwner, url: x.url, description: x.description || '', private: !!x.isPrivate, fork: !!x.isFork, pushedAt: x.pushedAt })),
+      );
+    },
+    { doc: false },
+  );
   const project = (c) => store.config.projects.find((x) => x.id === c.params.id);
   r.route('PATCH', '/projects/:id', async (c) => {
     const p = project(c);
@@ -110,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

@@ -27,11 +27,21 @@ export function register(r, app) {
     one(async (c, s) => {
       if (!s.worktree) 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);
-      s.pr = await ship(s.worktree, { title: body.title ?? draft.title, body: body.body ?? draft.body, draft: !!body.draft, pr: s.pr });
+      // 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 });
+        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 });
+      }
       telemetry.track('ship', { agent: s.agent, draft: !!body.draft });
-      app.sessionChanged(s, { now: true });
       app.ship.recheck(s);
       c.send(200, s.pr);
     }),
@@ -44,6 +54,23 @@ export function register(r, app) {
       c.send(200, await app.ship.refreshPr(s));
     }),
   );
+  // 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.' });
+      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 });
+    }),
+  );
   // Squash-merge the reviewed head, sync the user's base branch, clean up the worktree.
   r.route(
     'POST',

package/server/runner.js

@@ -81,7 +81,8 @@ export function summarize(s, store) {
     title: s.title,
     agent: s.agent,
     cwd: s.cwd,
-    project: s.agent === 'wisp' ? 'tour' : project?.name || path.basename(s.cwd || ''),
+    scratch: store?.isScratch?.(s.cwd) || undefined,
+    project: s.agent === 'wisp' ? 'tour' : (store?.isScratch?.(s.cwd) ? 'General' : project?.name) || path.basename(s.cwd || ''),
     projectId: project?.id || null,
     color: project?.color || 'slate',
     mode: s.mode,
@@ -94,15 +95,18 @@ 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 || '',
     toShip: s.toShip || null, // { dirty, ahead, unpushed } of the worktree, null until checked
-    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 } : null,
+    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,
+    // wisp fixing the PR's merge conflicts on its own: { step: 'fixing' | 'pushing' | 'done' | 'failed', why }
+    conflictFix: s.conflictFix ? { step: s.conflictFix.step, why: s.conflictFix.why || '' } : null,
     groupId: s.groupId || null,
     origin: s.origin || null, // { kind: 'recipe' | 'trigger' | 'telegram', id, name }
     // The roster, for the stacked logos on the card: used = delegated to at least once, busy = working now.
@@ -113,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,
   };
 }
 
@@ -130,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';
@@ -144,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 = {
@@ -168,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
@@ -181,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 };
@@ -245,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;
@@ -379,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;
       }
@@ -409,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 || {})) {
@@ -488,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;
@@ -675,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;
@@ -19,6 +24,17 @@ export function createAuto(app) {
   };
   // This computer's harnesses: the last ones detected, else detected now.
   const agents = async () => (agentsHere.length ? agentsHere : await detect());
+  // What the page asks for on every load: the last detection right away, checked again in the
+  // background (a cold probe takes seconds: opencode lists its models), and an 'agents' event
+  // if that changed anything, so the launcher never waits on it.
+  const listed = async () => {
+    if (!agentsHere.length) return detect();
+    const before = JSON.stringify(agentsHere);
+    detect()
+      .then((now) => JSON.stringify(now) !== before && app.broadcast('agents', {}))
+      .catch(() => {});
+    return agentsHere;
+  };
 
   const opts = () => {
     const r = store.config.defaults.router || {};
@@ -37,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, opts, goalOf, signals, resolve, view };
+  return { detect, agents, listed, opts, goalOf, signals, resolve, view };
 }