wisp-agents 0.18.0 → 0.20.0

package/server/adapters/cursor.js

@@ -4,6 +4,7 @@
 // ask_user tool isn't available here; the protocol tells the agent to end with a question block.
 
 import { attachmentNote, clip, detectVersion, exitText, fileTracker, quietOutput, rel, spawnJsonl, withProtocol } from './common.js';
+import { describeCommand } from './commands.js';
 
 const BIN = process.env.WISP_CURSOR_BIN || 'cursor-agent';
 
@@ -130,7 +131,7 @@ function describeTool(name, a, cwd) {
     case 'deleteToolCall':
       return { kind: 'edit', label: `Deleting ${f}`, file: f };
     case 'shellToolCall':
-      return { kind: 'run', label: a.description ? clip(a.description) : `Running ${clip(a.command, 60)}`, detail: a.command };
+      return { kind: 'run', label: a.description ? clip(a.description) : describeCommand(a.command, cwd), detail: a.command };
     case 'grepToolCall':
       return { kind: 'search', label: `Searching for “${clip(a.pattern, 40)}”` };
     case 'globToolCall':

package/server/adapters/grok.js

@@ -10,6 +10,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { ASK_TIMEOUT_MS, attachmentNote, clip, detectVersion, exitText, fileTracker, flatten, quietOutput, rel, spawnJsonl } from './common.js';
+import { describeCommand } from './commands.js';
 
 const BIN = process.env.WISP_GROK_BIN || 'grok';
 
@@ -195,7 +196,7 @@ function describeTool(name, input, cwd) {
       return { kind: 'edit', label: `Writing ${f}`, file: f };
     case 'run_terminal_command':
     case 'run_terminal_cmd':
-      return { kind: 'run', label: input.description ? clip(input.description) : `Running ${clip(input.command, 60)}`, detail: input.command };
+      return { kind: 'run', label: input.description ? clip(input.description) : describeCommand(input.command, cwd), detail: input.command };
     case 'grep':
       return { kind: 'search', label: `Searching for “${clip(input.pattern, 40)}”` };
     case 'list_dir':

package/server/adapters/opencode.js

@@ -5,6 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { toolsDir } from '../util.js';
 import { ASK_TIMEOUT_MS, attachmentNote, clip, detectVersion, exitText, fileTracker, quietOutput, rel, spawnJsonl, withProtocol } from './common.js';
+import { describeCommand } from './commands.js';
 
 const exe = process.platform === 'win32' ? 'opencode.cmd' : 'opencode';
 // Where opencode lives when it isn't on PATH: the copy wisp installs (POST /agents/install),
@@ -213,7 +214,7 @@ function describeTool(name, input, cwd) {
       return { kind: 'edit', label: `Writing ${f}`, file: f };
     case 'bash':
     case 'shell':
-      return { kind: 'run', label: input.description ? clip(input.description) : `Running ${clip(input.command, 60)}`, detail: input.command };
+      return { kind: 'run', label: input.description ? clip(input.description) : describeCommand(input.command, cwd), detail: input.command };
     case 'grep':
       return { kind: 'search', label: `Searching for “${clip(input.pattern, 40)}”` };
     case 'glob':

package/server/check.js

@@ -0,0 +1,205 @@
+// wisp's own test check: after an Auto turn, wisp runs the project's tests itself instead of taking
+// the agent's word for it (in the wisp-bench pilot, 19 of 20 failed runs still said "done").
+//
+// detectTests(dir, project) finds the command; runCheck(dir, command) runs it and reads which tests
+// failed from the usual reporters (node --test, jest/vitest, pytest, go, cargo, rspec). A failure
+// only counts against the agent when it's new: check() compares with the same command on the
+// task's base commit (a throwaway worktree, cached per base and command), and runs a failing
+// command twice so a flaky test doesn't send the agent off to fix nothing.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { git } from './git.js';
+import { killTree } from './proc.js';
+
+const MAX_OUTPUT = 400 * 1024;
+export const CHECK_TIMEOUT_MS = Number(process.env.WISP_CHECK_TIMEOUT_MS || 10 * 60_000);
+
+const read = (f) => {
+  try {
+    return fs.readFileSync(f, 'utf8');
+  } catch {
+    return null;
+  }
+};
+const has = (dir, f) => fs.existsSync(path.join(dir, f));
+
+// { command, kind, why } | { skip: reason } | null (nothing that looks like tests).
+// project.testCommand overrides it; 'off' turns the check off for that project.
+export function detectTests(dir, project = null) {
+  const custom = String(project?.testCommand || '').trim();
+  if (custom === 'off') return { skip: 'Turned off for this project' };
+  if (custom) return { command: custom, kind: 'custom', why: 'Set for this project' };
+
+  const pkg = JSON.parse(read(path.join(dir, 'package.json')) || 'null');
+  const script = pkg?.scripts?.test;
+  if (script && !/no test specified/.test(script)) {
+    const deps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
+    if (deps.length && !has(dir, 'node_modules')) return { skip: 'Dependencies are not installed in this worktree (no node_modules)' };
+    const pm = has(dir, 'pnpm-lock.yaml') ? 'pnpm' : has(dir, 'yarn.lock') ? 'yarn' : has(dir, 'bun.lockb') || has(dir, 'bun.lock') ? 'bun' : 'npm';
+    return { command: `${pm} test`, kind: 'node', why: 'package.json "test" script' };
+  }
+  const py = ['pytest.ini', 'tox.ini', 'conftest.py'].some((f) => has(dir, f)) || /\[tool\.pytest/.test(read(path.join(dir, 'pyproject.toml')) || '') || /\[tool:pytest\]/.test(read(path.join(dir, 'setup.cfg')) || '') || (has(dir, 'tests') && fs.readdirSync(path.join(dir, 'tests')).some((f) => /^test_.*\.py$|_test\.py$/.test(f)));
+  if (py) {
+    const python = ['.venv/bin/python', 'venv/bin/python', '.venv/Scripts/python.exe'].find((p) => has(dir, p)) || 'python3';
+    return { command: `${python} -m pytest -q -rA`, kind: 'pytest', why: 'pytest configuration' };
+  }
+  if (has(dir, 'go.mod')) return { command: 'go test ./...', kind: 'go', why: 'go.mod' };
+  if (has(dir, 'Cargo.toml')) return { command: 'cargo test', kind: 'cargo', why: 'Cargo.toml' };
+  if (has(dir, 'Gemfile') && has(dir, 'spec')) return { command: 'bundle exec rspec', kind: 'rspec', why: 'Gemfile and spec/' };
+  if (/^test:/m.test(read(path.join(dir, 'Makefile')) || '')) return { command: 'make test', kind: 'make', why: 'Makefile test target' };
+  return null;
+}
+
+// Failing test names and pass/fail counts from whatever reporter printed `out`.
+export function parseResults(out) {
+  const failed = new Set();
+  let passed = null;
+  let failedN = null;
+  let skipped = null;
+  const add = (x) => x && failed.add(x.trim().replace(/\s+\(\d+(\.\d+)?m?s\)$/, ''));
+  for (const line of out.split('\n')) {
+    let m;
+    if ((m = line.match(/^\s*✖ (.+?)(?: \([\d.]+m?s\))?$/)) && !/^failing tests:$/.test(m[1])) add(m[1]); // node --test spec
+    else if ((m = line.match(/^not ok \d+ - (.+?)(?: # .*)?$/))) add(m[1]); // TAP, top level
+    else if ((m = line.match(/^(?:FAILED|ERROR) (\S+)/))) add(m[1]); // pytest -rA
+    else if ((m = line.match(/^\s+[✕×] (.+?)(?: \(\d+ ?ms\))?$/))) add(m[1]); // jest / vitest
+    else if ((m = line.match(/^--- FAIL: (\S+)/))) add(m[1]); // go
+    else if ((m = line.match(/^test (\S+) \.\.\. FAILED/))) add(m[1]); // cargo
+    else if ((m = line.match(/^rspec (\.\/\S+)/))) add(m[1]); // rspec
+    if ((m = line.match(/^ℹ pass (\d+)/))) passed = +m[1];
+    if ((m = line.match(/^ℹ fail (\d+)/))) failedN = +m[1];
+    if ((m = line.match(/^ℹ skipped (\d+)/))) skipped = +m[1];
+    if ((m = line.match(/^# pass (\d+)/))) passed = +m[1];
+    if ((m = line.match(/^# fail (\d+)/))) failedN = +m[1];
+    if ((m = line.match(/^=+ (.*) in [\d.]+s/))) {
+      // pytest summary: "== 3 failed, 41 passed, 2 skipped in 1.2s =="
+      passed = +(m[1].match(/(\d+) passed/)?.[1] || 0);
+      failedN = +(m[1].match(/(\d+) failed/)?.[1] || 0) + +(m[1].match(/(\d+) errors?/)?.[1] || 0);
+      skipped = +(m[1].match(/(\d+) skipped/)?.[1] || 0) || null;
+    }
+    if ((m = line.match(/^Tests:\s+(.*)$/))) {
+      // jest / vitest: "Tests: 1 failed, 12 passed, 13 total"
+      passed = +(m[1].match(/(\d+) passed/)?.[1] || 0);
+      failedN = +(m[1].match(/(\d+) failed/)?.[1] || 0);
+      skipped = +(m[1].match(/(\d+) skipped/)?.[1] || 0) || null;
+    }
+    if ((m = line.match(/^test result: \w+\. (\d+) passed; (\d+) failed/))) {
+      passed = (passed || 0) + +m[1];
+      failedN = (failedN || 0) + +m[2];
+    }
+  }
+  return { failed: [...failed].slice(0, 200), passed, failedCount: failedN ?? failed.size, skipped };
+}
+
+// Run `command` in dir: { exitCode, output, durationMs, timedOut, ...parseResults }.
+export function runCheck(dir, command, { timeout = CHECK_TIMEOUT_MS, env = {} } = {}) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    let output = '';
+    let timedOut = false;
+    // Not inherited: a test runner's own markers (wisp under `node --test` would make the project's
+    // `node --test` report to it and exit 0) and wisp's.
+    const base = Object.fromEntries(Object.entries(process.env).filter(([k]) => !/^(NODE_TEST_CONTEXT|NODE_UNIQUE_ID|WISP_|FAKE_)/.test(k)));
+    const child = spawn(process.platform === 'win32' ? 'cmd.exe' : 'sh', process.platform === 'win32' ? ['/d', '/s', '/c', command] : ['-c', command], {
+      cwd: dir,
+      env: { ...base, CI: '1', FORCE_COLOR: '0', NO_COLOR: '1', ...env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: process.platform !== 'win32',
+    });
+    const take = (d) => {
+      output += d;
+      if (output.length > MAX_OUTPUT * 2) output = output.slice(-MAX_OUTPUT);
+    };
+    child.stdout.on('data', take);
+    child.stderr.on('data', take);
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killTree(child);
+    }, timeout);
+    const done = (exitCode) => {
+      clearTimeout(timer);
+      output = output.replace(/\x1b\[[0-9;]*m/g, '').slice(-MAX_OUTPUT);
+      resolve({ exitCode, output, durationMs: Date.now() - started, timedOut, ...parseResults(output) });
+    };
+    child.on('error', (err) => ((output += `\n${err.message}`), done(127)));
+    child.on('close', (code) => done(timedOut ? 124 : code ?? 1));
+  });
+}
+
+// The same command at the base commit, once per (repo, base, command).
+const baselines = new Map();
+export async function baseline(wt, command) {
+  if (!wt?.root || !wt.head) return null;
+  const key = `${wt.root}\0${wt.head}\0${command}`;
+  if (!baselines.has(key)) {
+    baselines.set(
+      key,
+      (async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'wisp-base-'));
+        try {
+          await git(wt.root, ['worktree', 'add', '--quiet', '--detach', dir, wt.head]);
+          // node_modules and virtualenvs aren't in git: borrow the task's, so the base can run too.
+          for (const d of ['node_modules', '.venv', 'venv']) {
+            const from = path.join(wt.path, d);
+            if (fs.existsSync(from) && !fs.existsSync(path.join(dir, d))) fs.symlinkSync(from, path.join(dir, d), 'dir');
+          }
+          const sub = path.relative(wt.path, wt.cwd || wt.path);
+          return await runCheck(path.join(dir, sub), command);
+        } catch {
+          return null;
+        } finally {
+          await git(wt.root, ['worktree', 'remove', '--force', dir]).catch(() => {});
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      })(),
+    );
+  }
+  return baselines.get(key);
+}
+
+// The verdict wisp acts on. pass: exit 0, or every failure was failing on the base already.
+// fail: tests that passed on the base fail now (twice). unknown: it failed and we can't tell why
+// (no base to compare with, or a reporter we can't read). skip: nothing to run.
+export async function check({ dir, project, worktree, timeout } = {}) {
+  const found = detectTests(dir, project);
+  if (!found) return { verdict: 'skip', reason: 'No test command found', command: null };
+  if (found.skip) return { verdict: 'skip', reason: found.skip, command: null };
+  const { command } = found;
+  let run = await runCheck(dir, command, { timeout });
+  if (run.exitCode === 0 && !run.timedOut) return summary('pass', command, run, [], []);
+  // Flaky? Only failures that happen twice count.
+  const again = await runCheck(dir, command, { timeout });
+  if (again.exitCode === 0 && !again.timedOut) return summary('pass', command, again, [], [], 'Passed on a second run (a flaky test)');
+  const twice = run.failed.filter((t) => again.failed.includes(t));
+  run = { ...again, failed: twice.length || !again.failed.length ? twice : again.failed };
+  const base = await baseline(worktree, command);
+  if (!base) return summary(run.failed.length || run.timedOut ? 'fail' : 'unknown', command, run, run.failed, [], 'No base to compare with');
+  if (base.exitCode === 0) return summary('fail', command, run, run.failed, []);
+  const before = new Set(base.failed);
+  const fresh = run.failed.filter((t) => !before.has(t));
+  const old = run.failed.filter((t) => before.has(t));
+  if (!run.failed.length || !base.failed.length) return summary('unknown', command, run, [], [], 'Fails on the base commit too, and the failures could not be read');
+  return summary(fresh.length ? 'fail' : 'pass', command, run, fresh, old, fresh.length ? '' : `${old.length} failing on the base commit too`);
+}
+
+function summary(verdict, command, run, fresh, old, note = '') {
+  const tail = run.output.split('\n').filter((l) => l.trim()).slice(-60).join('\n');
+  return {
+    verdict,
+    command,
+    exitCode: run.exitCode,
+    passed: run.passed,
+    failed: run.failedCount || run.failed.length || (run.exitCode ? 1 : 0),
+    skipped: run.skipped,
+    newFailures: fresh.slice(0, 50),
+    preexisting: old.slice(0, 50),
+    timedOut: run.timedOut,
+    durationMs: run.durationMs,
+    note,
+    output: verdict === 'pass' ? '' : tail.slice(-6000),
+    at: Date.now(),
+  };
+}

package/server/index.js

@@ -25,6 +25,7 @@ import { Routes } from './http/router.js';
 import { send, eventStream } from './http/respond.js';
 import { serveStatic } from './http/static.js';
 import { createAuto } from './services/auto.js';
+import { scoutNote } from './scout.js';
 import { createFeedback } from './services/feedback.js';
 import { createInstaller } from './services/install.js';
 import { createLaunch } from './services/launch.js';
@@ -119,7 +120,7 @@ export async function startServer({ port = DEFAULT_PORT, host = '127.0.0.1', han
   app.prefs = new Preferences(store.home);
   app.learning = () => store.config.defaults.learn !== 'off';
   const projectOf = (cwd) => store.projectFor(cwd)?.path || cwd;
-  runner.promptExtra = (s) => (app.learning() && s.agent !== 'wisp' ? app.prefs.prompt(projectOf(s.cwd)) : '');
+  runner.promptExtra = (s) => (app.learning() && s.agent !== 'wisp' ? app.prefs.prompt(projectOf(s.cwd)) : '') + scoutNote(s.scout);
   app.retro = new Retro({
     store,
     runner,

package/server/judge.js

@@ -0,0 +1,78 @@
+// Picking between two runs of the same task (best-of-2). Tests decide when they can: a run whose
+// check passed beats one whose check failed. Otherwise a cheap model reads both diffs, and if
+// that isn't available either, fewer new failures and then the smaller diff win.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { askJson } from './quick.js';
+
+const MAX_DIFF = 24_000;
+
+// The run's changes against its base: tracked diff plus new files.
+export function diffOf(dir, base = 'HEAD') {
+  const run = (args) => {
+    try {
+      return execFileSync('git', args, { cwd: dir, stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 64 << 20, timeout: 15_000 }).toString();
+    } catch {
+      return '';
+    }
+  };
+  let out = run(['diff', base, '--', '.', ':(exclude)node_modules']);
+  for (const f of run(['ls-files', '--others', '--exclude-standard']).split('\n').filter(Boolean).slice(0, 30)) {
+    try {
+      out += `\n--- /dev/null\n+++ b/${f}\n${fs.readFileSync(path.join(dir, f), 'utf8').slice(0, 4000).split('\n').map((l) => `+${l}`).join('\n')}`;
+    } catch {}
+  }
+  return out;
+}
+
+const changed = (d) => d.split('\n').filter((l) => /^[+-](?![+-])/.test(l)).length;
+const SCORE = { pass: 3, unknown: 2, skip: 2, fail: 0 };
+
+// candidates: [{ id, label, check, diff }]. Resolves with { winner, why, by }.
+export async function judge({ prompt, candidates, agents }) {
+  const [a, b] = candidates;
+  const sa = SCORE[a.check?.verdict] ?? 1;
+  const sb = SCORE[b.check?.verdict] ?? 1;
+  if (sa !== sb) {
+    const w = sa > sb ? a : b;
+    return { winner: w.id, by: 'tests', why: `${w.label}'s changes pass the tests; the other run's don't.` };
+  }
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'wisp-judge-'));
+  try {
+    const ask = `Two coding agents did the same task. Judge which change is better: correct, complete, minimal, and in the style of the code around it. Tests: run A ${a.check?.verdict || 'not checked'}, run B ${b.check?.verdict || 'not checked'}.
+
+<task>
+${String(prompt).slice(0, 4000)}
+</task>
+
+<run id="A" label="${a.label}">
+${a.diff.slice(0, MAX_DIFF) || '(no changes)'}
+</run>
+
+<run id="B" label="${b.label}">
+${b.diff.slice(0, MAX_DIFF) || '(no changes)'}
+</run>
+
+Reply with one JSON object: {"winner": "A" | "B", "why": "one sentence"}`;
+    const j = await askJson({ agents, prompt: ask, cwd, timeoutMs: 120_000 });
+    if (j && (j.winner === 'A' || j.winner === 'B')) return { winner: (j.winner === 'A' ? a : b).id, by: 'model', why: String(j.why || '').slice(0, 300) };
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+  const fa = a.check?.newFailures?.length ?? 0;
+  const fb = b.check?.newFailures?.length ?? 0;
+  if (fa !== fb) {
+    const w = fa < fb ? a : b;
+    return { winner: w.id, by: 'rule', why: `${w.label} leaves fewer new failing tests.` };
+  }
+  const empty = (c) => !c.diff.trim();
+  if (empty(a) !== empty(b)) {
+    const w = empty(a) ? b : a;
+    return { winner: w.id, by: 'rule', why: `${w.label} changed something; the other run didn't.` };
+  }
+  const w = changed(a.diff) <= changed(b.diff) ? a : b;
+  return { winner: w.id, by: 'rule', why: `${w.label} made the smaller change.` };
+}

package/server/openapi.js

@@ -47,7 +47,7 @@ export function openapi({ version, port }) {
       '/agents': { get: { summary: 'Installed harnesses with their models and thinking levels (?fresh=1 detects again)', responses: { 200: json({ type: 'array', items: ref('Agent') }) } } },
       '/router': {
         get: { summary: 'Auto: the goal, settings, every harness · model with its learned chance of success and cost, and recent routes', responses: { 200: json({ type: 'object' }) } },
-        patch: { summary: 'Auto settings', requestBody: body({ type: 'object', properties: { goal: { enum: ['cheap', 'balanced', 'best'] }, explore: { type: 'boolean', description: 'Let Auto try new models on a few tasks' }, allowed: { type: 'array', items: { type: 'string' }, description: 'Harness ids Auto may pick; empty or null = all' } } }), responses: { 200: json({ type: 'object' }) } },
+        patch: { summary: 'Auto settings', requestBody: body({ type: 'object', properties: { goal: { enum: ['cheap', 'balanced', 'best'] }, explore: { type: 'boolean', description: 'Let Auto try new models on a few tasks' }, allowed: { type: 'array', items: { type: 'string' }, description: 'Harness ids Auto may pick; empty or null = all' }, check: { type: 'boolean', description: 'Run the project tests after an Auto run; only new failures count' }, repairs: { type: 'integer', minimum: 0, maximum: 2, description: 'Times failing tests go back to the same agent' }, escalate: { type: 'boolean', description: 'Still failing: run the task again on a stronger pick, in its own worktree' }, best2: { type: 'boolean', description: 'Goal Best: two picks side by side, the better one marked' }, scout: { enum: ['off', 'big', 'all'], description: 'A cheap model looks at the repo first' } } }), responses: { 200: json({ type: 'object' }) } },
       },
       '/router/reset': { post: { summary: 'Forget what Auto learned here (the shipped starting point stays)', responses: { 200: json({ type: 'object' }) } } },
       '/agents/install': {
@@ -144,7 +144,7 @@ export function openapi({ version, port }) {
         },
       },
       '/sessions/{id}/pr': { parameters: [id], post: { summary: 'Refresh the PR status (checks, review, state) now; it is also polled every minute', responses: { 200: json(ref('PullRequest')), 404: err[404] } } },
-      '/sessions/{id}/fix-conflicts': { parameters: [id], post: { summary: 'Retry the automatic merge-conflict fix after it gave up: a follow-up merges the base in, then wisp pushes to the PR', responses: { 200: json({ type: 'object' }), 400: err[400] } } },
+      '/sessions/{id}/fix-conflicts': { parameters: [id], post: { summary: 'Fix the PR\'s merge conflicts now (the PR row\'s Fix conflicts button): a follow-up merges the base in, then wisp pushes to the PR', responses: { 200: json({ type: 'object' }), 400: err[400] } } },
       '/sessions/{id}/merge': {
         parameters: [id],
         post: { summary: 'Mark the PR ready if draft, squash-merge it with --match-head-commit, fast-forward the local base branch, remove the worktree', responses: { 200: json({ type: 'object', properties: { pr: ref('PullRequest'), sync: { type: 'object', properties: { ok: { type: 'boolean' }, text: { type: 'string' } } } } }), 400: err[400] } },
@@ -409,7 +409,7 @@ export function openapi({ version, port }) {
             branch: { type: 'string', description: 'Worktree branch, if it has one' },
             pr: { type: ['object', 'null'], description: 'Its pull request, once shipped' },
             shipping: { type: ['object', 'null'], description: "{ step: start | commit | push | pr, update } while Ship it runs" },
-            conflictFix: { type: ['object', 'null'], description: "{ step: fixing | pushing | done | failed, why } while wisp fixes the PR's merge conflicts on its own (defaults.fixConflicts: 'off' turns it off)" },
+            conflictFix: { type: ['object', 'null'], description: "{ step: fixing | pushing | done | failed, why } while wisp fixes the PR's merge conflicts: after Fix conflicts, or on its own with defaults.fixConflicts: 'on'" },
             groupId: { type: ['string', 'null'], description: 'Shared by sessions launched together with compare' },
             origin: { type: ['object', 'null'], description: '{ kind: recipe | trigger, id, name } when not launched by hand' },
           },

package/server/pipeline.js

@@ -0,0 +1,217 @@
+// What Auto does after the agent says it's done, before the task lands in your queue:
+//
+//   check     wisp runs the project's tests itself (server/check.js). Only new failures count.
+//   repair    tests fail → the same session gets the failures back, up to `repairs` rounds.
+//   escalate  still failing (or the run errored) → the task goes to a stronger harness · model,
+//             in its own worktree, next to the first run (one task, two rows).
+//   judge     best-of-2 (goal Best): both runs are checked, then the better one is marked
+//             (server/judge.js): tests first, then a cheap model reading both diffs.
+//
+// The turn's presentation gets wisp's own tests block, and when the agent said "all green" but
+// wisp's run disagrees, a callout saying so. The router learns from the verdicts.
+//
+// State lives on the session as `auto`: { strategy, busy, stage, label, repairs, checks[],
+// escalatedTo, escalatedFrom, pick }. The runner keeps a session in Working while `busy`.
+
+import { check as runCheck } from './check.js';
+import { judge, diffOf } from './judge.js';
+import { workdir } from './runner.js';
+import { infraError, tierOf } from './router.js';
+
+// What an errored turn said (the terminal block the runner puts on it).
+const errorText = (turn) => (turn.presentation?.blocks || []).filter((b) => b.type === 'terminal').map((b) => b.output || '').join('\n');
+const MAX_MOVES = 4; // a task moved this many times because harnesses were at their limit stops there
+
+export const AUTO_DEFAULTS = { check: 'on', repairs: 1, escalate: 'on', best2: 'off', scout: 'big' };
+
+export function autoSettings(d = {}) {
+  const r = d.router || {};
+  return {
+    check: r.check !== 'off',
+    repairs: [0, 1, 2].includes(Number(r.repairs)) ? Number(r.repairs) : AUTO_DEFAULTS.repairs,
+    escalate: r.escalate !== 'off',
+    best2: r.best2 === 'on', // opt-in: it runs every Best task twice
+    scout: ['off', 'big', 'all'].includes(r.scout) ? r.scout : AUTO_DEFAULTS.scout,
+  };
+}
+
+const plural = (n, w) => `${n} ${w}${n === 1 ? '' : 's'}`;
+
+export class Pipeline {
+  // deps: { store, runner, router, settings(), agents(), projectOf(session), launchSibling(session, pick),
+  //         onSettled(session), broadcast(event, data) }
+  constructor(deps) {
+    Object.assign(this, deps);
+    this.tokens = new Map(); // sessionId -> token of the step in flight; a user's move cancels it
+  }
+
+  // Called by the runner as a turn ends: true keeps the session in Working while wisp checks.
+  wants(session, turn, ev) {
+    const a = session.auto;
+    if (!a || session.parentId || ev.stopped || session.mode === 'plan') return false;
+    const s = this.settings();
+    // At its limit: not the model's fault, so the task moves on whatever the hand-over setting says.
+    if (ev.isError) return !!infraError(ev.text) || (s.escalate && this.#canEscalate(session));
+    return s.check;
+  }
+
+  // A follow-up or Stop from the user: whatever wisp was about to do is off.
+  cancel(session) {
+    if (!session.auto?.busy) return;
+    this.tokens.delete(session.id);
+    Object.assign(session.auto, { busy: false, stage: 'cancelled', label: '' });
+  }
+
+  async run(session, turn) {
+    const a = session.auto;
+    const token = Symbol('step');
+    this.tokens.set(session.id, token);
+    const live = () => this.tokens.get(session.id) === token && this.store.get(session.id) === session;
+    const s = this.settings();
+    try {
+      let result;
+      const limit = turn.status === 'error' && infraError(errorText(turn));
+      if (limit) return await this.#moveOn(session, turn, limit, live);
+      if (turn.status === 'error') result = { verdict: 'error' };
+      else {
+        this.#stage(session, turn, 'checking', 'Checking with the tests');
+        result = await runCheck({ dir: workdir(session), project: this.projectOf(session), worktree: session.worktree });
+        if (!live()) return;
+        a.checks.push({ turnId: turn.id, ...result, output: undefined });
+        this.#present(session, turn, result);
+      }
+      this.router.signal(session.id, { check: result.verdict, repaired: a.repairs > 0 || undefined });
+
+      const failing = result.verdict === 'fail' || result.verdict === 'error';
+      // Repairs and hand-overs are for the task as you sent it: once you've followed up yourself,
+      // wisp still checks and shows the result, but leaves the next move to you.
+      const yours = session.turns.some((t, i) => i > 0 && t.by !== 'wisp');
+      if (result.verdict === 'fail' && a.repairs < s.repairs && !yours) {
+        a.repairs++;
+        this.#stage(session, turn, 'repairing', `Fixing ${plural(result.newFailures.length || result.failed || 1, 'failing test')}`);
+        this.runner.reply(session, repairPrompt(result, a.repairs, s.repairs), [], { by: 'wisp' });
+        return; // the repair turn comes back through wants()/run()
+      }
+      if (failing && s.escalate && this.#canEscalate(session)) {
+        // A step up: a stronger tier than this run's (or the strongest there is, if it was already top).
+        const tier = tierOf(session.route?.key || '');
+        const pick = this.router.choose({ prompt: session.turns[0].prompt, agents: this.agents(), goal: 'best', important: true, minTier: Math.min(3, tier + 1), exclude: [session.route?.key, ...(a.tried || [])].filter(Boolean), needDelegate: !!session.subagents?.length });
+        if (!pick || tierOf(pick.key) < tier) this.#note(session, turn, 'check', 'No stronger harness · model to hand it to');
+        else {
+          this.#stage(session, turn, 'escalating', `Handing it to ${pick.label}`);
+          const sib = await this.launchSibling(session, pick, { reason: result.verdict === 'error' ? 'error' : 'tests' });
+          if (!live()) return;
+          a.escalatedTo = sib.id;
+          a.reason = result.verdict === 'error' ? 'error' : 'tests';
+          this.#note(session, turn, 'check', `wisp handed this task to ${pick.label}: ${result.verdict === 'error' ? 'the run ended with an error' : 'the tests still fail'}`);
+          return this.#settle(session, { quiet: true });
+        }
+      }
+      this.#settle(session);
+      if (a.strategy === 'best2') await this.#judgeGroup(session);
+    } catch (err) {
+      console.warn(`wisp: auto pipeline: ${err.stack || err.message}`);
+      if (live()) this.#settle(session);
+    }
+  }
+
+  // The harness was at a usage or rate limit: the run doesn't count against it, it cools down until
+  // the limit resets, and the task moves to the best pick that can run now.
+  async #moveOn(session, turn, limit, live) {
+    const a = session.auto;
+    const why = errorText(turn).split('\n').find((l) => l.trim())?.trim() || 'at its limit';
+    const cooled = this.router.cool(session.route?.key || `${session.agent}:${session.model || ''}`, { ...limit, why });
+    this.router.void(session.id);
+    const name = cooled.endsWith(':*') ? session.route?.label?.split(' · ')[0] || session.agent : session.route?.label || session.agent;
+    const tried = [...(a.tried || []), session.route?.key].filter(Boolean);
+    const pick = tried.length < MAX_MOVES ? this.router.choose({ prompt: session.turns[0].prompt, agents: this.agents(), goal: session.route?.goal || 'balanced', exclude: tried, needDelegate: !!session.subagents?.length }) : null;
+    if (!pick) {
+      this.#note(session, turn, 'check', `${name} is at its limit, and nothing else Auto may use can run right now`);
+      return this.#settle(session);
+    }
+    this.#stage(session, turn, 'moving', `${name} is at its limit · moving to ${pick.label}`);
+    const sib = await this.launchSibling(session, pick, { reason: 'limit', tried });
+    if (!live()) return;
+    a.escalatedTo = sib.id;
+    a.reason = 'limit';
+    return this.#settle(session, { quiet: true });
+  }
+
+  // Escalate once per task, and only while the user hasn't stepped in with follow-ups.
+  #canEscalate(session) {
+    const a = session.auto;
+    // A fresh worktree from the same base, or the second run would build on the first one's mess.
+    return a.strategy === 'single' && !a.escalatedTo && !!session.worktree && !session.turns.some((t, i) => i > 0 && t.by !== 'wisp');
+  }
+
+  #stage(session, turn, stage, label) {
+    Object.assign(session.auto, { busy: true, stage, label });
+    this.#note(session, turn, 'check', `${label}…`);
+  }
+
+  #note(session, turn, kind, label) {
+    this.runner.note(session, turn, { kind, label });
+  }
+
+  #settle(session, { quiet = false } = {}) {
+    this.tokens.delete(session.id);
+    Object.assign(session.auto, { busy: false, stage: 'done', label: '' });
+    this.runner.settle(session, { quiet });
+    this.onSettled?.(session);
+  }
+
+  // wisp's tests block goes right under the hero; a "done" that wisp's run contradicts is called out.
+  #present(session, turn, r) {
+    const blocks = turn.presentation?.blocks;
+    if (!blocks) return;
+    const label = `${r.command ? `\`${r.command}\`` : 'the tests'}`;
+    if (r.verdict === 'skip') {
+      this.#note(session, turn, 'check', `No tests to run: ${r.reason}`);
+      return;
+    }
+    const failures = (r.newFailures.length ? r.newFailures : r.verdict === 'fail' ? ['(see output)'] : []).slice(0, 8).map((name) => ({ name, message: '' }));
+    const block = { type: 'tests', by: 'wisp', command: r.command, passed: r.passed ?? undefined, failed: r.verdict === 'pass' ? 0 : r.newFailures.length || r.failed, skipped: r.skipped ?? undefined, durationMs: r.durationMs, failures, note: r.note || undefined };
+    if (r.verdict === 'pass' && block.passed == null) block.passed = 1;
+    const at = Math.max(0, blocks.findIndex((b) => b.type === 'hero') + 1);
+    blocks.splice(at, 0, block);
+    const hero = blocks.find((b) => b.type === 'hero');
+    const claimed = blocks.some((b) => b.type === 'tests' && b.by !== 'wisp' && !(Number(b.failed) > 0)) || hero?.status === 'done';
+    if (r.verdict === 'fail') {
+      if (hero && hero.status === 'done') (hero.agentStatus = hero.status), (hero.status = 'partial');
+      if (claimed) blocks.splice(at + 1, 0, { type: 'callout', tone: 'danger', by: 'wisp', title: "wisp's test run disagrees", text: `The agent reported this as done, but ${label} has ${plural(r.newFailures.length || r.failed, 'failing test')} that passed before the change.` });
+    }
+    this.#note(session, turn, 'check', r.verdict === 'pass' ? `Tests pass: ${label}${r.note ? ` (${r.note})` : ''}` : r.verdict === 'fail' ? `Tests fail: ${plural(r.newFailures.length || r.failed, 'new failure')} in ${label}` : `Tests inconclusive: ${r.note || label}`);
+    this.store.save(session);
+    this.broadcast('turn', { sessionId: session.id, turnId: turn.id });
+  }
+
+  // Best-of-2: once both runs have settled, mark the better one.
+  async #judgeGroup(session) {
+    const group = this.store.all().filter((x) => x.groupId === session.groupId && x.auto?.strategy === 'best2');
+    if (group.length < 2 || group.some((x) => x.auto.busy || x.state === 'running') || group.some((x) => x.auto.pick)) return;
+    group.forEach((x) => (x.auto.pick = { pending: true }));
+    const candidates = group.slice(0, 2).map((x) => ({ id: x.id, label: x.route?.label || x.agent, check: x.auto.checks.at(-1), diff: diffOf(workdir(x), x.worktree?.head || 'HEAD') }));
+    const j = await judge({ prompt: group[0].turns[0].prompt, candidates, agents: this.agents() });
+    for (const x of group) {
+      x.auto.pick = { winner: x.id === j.winner, why: j.why, by: j.by };
+      this.store.save(x);
+      this.broadcast('summary', this.summarize(x));
+    }
+    const w = group.find((x) => x.id === j.winner);
+    if (w) this.#note(w, w.turns.at(-1), 'check', `wisp's pick of the two runs: ${j.why}`);
+    for (const x of group) this.router.signal(x.id, { picked: x.id === j.winner });
+  }
+}
+
+function repairPrompt(r, round, max) {
+  const list = r.newFailures.length ? r.newFailures.slice(0, 20).map((t) => `- ${t}`).join('\n') : '';
+  return [
+    `wisp ran \`${r.command}\` on your change and it fails${list ? ':' : '.'}`,
+    list,
+    r.output ? `Output (tail):\n\`\`\`\n${r.output.slice(-3500)}\n\`\`\`` : '',
+    'These tests passed before your change. Fix the code so they pass again: do not delete, skip or weaken tests. Run the tests yourself, then finish with an updated presentation.',
+    max > 1 ? `(Repair round ${round} of ${max}.)` : '',
+  ]
+    .filter(Boolean)
+    .join('\n\n');
+}