wisp-agents 0.13.0 → 0.15.0

package/CHANGELOG.md

@@ -5,6 +5,28 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [0.15.0] - 2026-10-18
+
+### Changed
+
+- **Calmer turn bar.** The bar under each turn now fits on one line: the read / edited / ran / searched counts open the activity log themselves (no separate **Activity** link), and **Restore to before this turn** and **Agent notes** are icon buttons next to 👍 / 👎 that stay faint until you hover the turn. After a restore, **Re-apply** shows as text so the rolled-back state stays visible.
+
+### Fixed
+
+- Rating a turn with 👍 / 👎 no longer re-renders the whole card and replays its entrance animation. Every refetch re-inserted the turn nodes, which restarts their CSS animations; unchanged turns are now left in place.
+
+## [0.14.0] - 2026-10-18
+
+### Added
+
+- **Auto: wisp picks the harness and model for you, and it's now the default.** Choose **Auto** in the harness picker (existing setups are switched to it once) and set a goal in the model slot: **Balanced**, **Cheap** or **Best**. For each task, Auto estimates how likely each harness · model you have installed is to do that kind of task (bug, UI, docs, tests…) well. It starts from a wisp-bench pilot that ships with wisp, then learns from your own outcomes: merged or closed PRs, 👍 / 👎, rollbacks, follow-ups and how the run ended. It weighs that against cost and time, and now and then tries an alternative so the estimates stay honest. Hover a card's harness logo to see why Auto picked it. **Settings → Auto** sets the goal, whether new models get tried, and which harnesses Auto may use; **Open** shows what it learned. A harness or model that shows up later (a new CLI, a new version) gets a few tasks that aren't marked important before Auto relies on it, and a new version starts from its family's record. Auto works for compare runs (a different pick each), for subagents (a team member set to Auto is picked on its first task), on machines (picked here from what the machine has, and that machine's outcomes feed the same router), and from the CLI, recipes, triggers and Telegram. Everything it learns stays in `~/.wisp/router.json`. API: `agent: "auto"` on launch, `GET`/`PATCH /api/router`, `POST /api/router/reset`.
+
+### Fixed
+
+- **Claude Code tasks that say "I'll report once it has finished" now do.** When Claude ends its turn with background work still running (a test run, a build, a background subagent), the task stays in **Working** and shows **Waiting on background task: …**. When the work finishes, Claude's follow-up report becomes the task's answer. Before, wisp stopped Claude 3 seconds after its first reply, which also killed the background work, and the task ended on that "I'll report…" line. **Stop** and follow-ups still work while it waits, and it waits at most an hour. A reply that is already a full answer, for example one that leaves a dev server running, still ends the task right away. All harnesses are now also told to wait for their background work before finishing.
+
+- **Follow-ups no longer end on "The agent finished without a message."** When a Claude Code run left background commands behind, the next follow-up ended right away with an empty answer, and the agent was cut off before it started on your message, so you had to send it again. wisp now waits for the answer to your follow-up.
+
 ## [0.13.0] - 2026-10-18
 
 ### Added
@@ -240,7 +262,9 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 - Session queue with follow-ups, answers to agent questions, terminal takeover and mark-as-done.
 - Older turns are folded, with a floating collapse-all button and back-to-top.
 
-[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.13.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.15.0...HEAD
+[0.15.0]: https://github.com/M0xoo/wisp/compare/v0.14.0...v0.15.0
+[0.14.0]: https://github.com/M0xoo/wisp/compare/v0.13.0...v0.14.0
 [0.13.0]: https://github.com/M0xoo/wisp/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/M0xoo/wisp/compare/v0.11.0...v0.12.0
 [0.11.0]: https://github.com/M0xoo/wisp/compare/v0.10.0...v0.11.0

package/README.md

@@ -44,6 +44,7 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 | 📥 **A queue** | Sessions sort into *Needs you*, *Working* (with a live one-line status), and *Done*. Archive what you don't need to see. |
 | 💬 **Follow-ups that interrupt** | A follow-up sent mid-run interrupts the agent and resumes it with your message. Turn on **Queue** to wait for the run to finish instead; queued messages can be cancelled. |
 | 🔎 **Command palette** | `⌘K` / `Ctrl+K` fuzzy-searches sessions, projects, and actions. |
+| ✨ **Auto** | The default harness: wisp picks the harness and model per task from what worked before, and learns from merges, 👍 / 👎 and follow-ups. See [Auto](#auto). |
 | 🤖 **Any harness** | Claude Code, Codex, opencode, Cursor CLI, Antigravity CLI, or Grok Build. Pick the harness, model and thinking level together in the launcher; both are remembered per harness. Each card shows the harness it ran on. |
 | 🖥️ **Take over** | Opens your terminal with the harness's resume command (`claude --resume <id>`, `codex resume <id>`, …) in the project folder. Works with Terminal, iTerm, Ghostty, Warp, cmux, kitty, WezTerm, GNOME Terminal, Konsole, Alacritty, Windows Terminal, PowerShell, or a custom command. |
 | 📎 **Attachments** | Paste screenshots or drop images, video, logs, or PDFs into the launcher. |
@@ -53,7 +54,7 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 | 🤝 **Subagents** | Give the lead agent a team on other harnesses (e.g. Claude Code hands tests to Codex ×3). It delegates through a `delegate` tool; their edits land in its worktree. See [Subagents](#subagents). |
 | ⏪ **Checkpoints & rollback** | Every turn is snapshotted first. Restore to before any turn, revert a single file, or re-run a command block from the presentation. |
 | ⚖️ **Compare** | Run one task on two harnesses side by side, and keep the better run. |
-| 🧾 **Recipes & triggers** | Saved prompts with `{params}` (`wisp run release 0.13.0`), run by hand, on a schedule, when CI fails, or when an issue is labelled. |
+| 🧾 **Recipes & triggers** | Saved prompts with `{params}` (`wisp run release 0.15.0`), run by hand, on a schedule, when CI fails, or when an issue is labelled. |
 | 📊 **Usage** | Spend, success rate and questions per project and per harness · model. |
 | 📱 **Phone** | Questions and finished tasks on ntfy or Telegram; answer from there, or start a task with `/new`. |
 | 🔐 **Permission modes** | Choose **Plan** (read-only), **Edits** (file edits auto-accepted), or **Full auto** for each launch. `Shift+Tab` in the prompt cycles modes. |
@@ -125,7 +126,7 @@ wisp reply <id> "also do X"       # follow up (answers a pending question; --mod
 wisp stop <id>
 wisp ship <id> [--draft]          # commit, push and open a PR for a worktree task
 wisp merge <id>                   # squash-merge its PR, fast-forward your local main
-wisp run release 0.13.0            # run a recipe; values fill its {params} (or version=0.13.0)
+wisp run release 0.15.0            # run a recipe; values fill its {params} (or version=0.15.0)
 wisp recipes                      # list recipes
 wisp usage [--days 7]             # spend and outcomes
 wisp mcp                          # MCP server for other agents and editors
@@ -279,6 +280,18 @@ If the harness has no system-prompt flag, prepend `systemPrompt` to the first pr
 - [x] Antigravity CLI adapter
 - [x] Grok Build adapter
 
+## Auto
+
+**Auto** is the default harness: wisp picks the harness and model for each task. Its "model" is a goal: **Balanced** (best result per dollar), **Cheap** or **Best**.
+
+How it picks: every harness · model you have installed is an option. For the kind of task (bug, feature, UI, tests, refactor, docs, release, question) Auto keeps an estimate of how often each option does it well. The estimate starts from a small wisp-bench pilot that ships with wisp (`server/router-priors.json`), then counts your own outcomes: merged PR (best), closed PR, 👍 / 👎, rollback, then how the run ended, less a bit for each follow-up you needed. It draws from each estimate (Thompson sampling), so options with little data now and then get a turn, and takes the best value for the goal after expected cost and time. A launch with `important: true` (API, SDK) gets the best-known option, with no trying. Options that keep failing a kind of task are left out of it.
+
+New harnesses and models: when a CLI or model shows up (after an install or a Re-check), it's on probation. It only gets the occasional exploring slot until it has three outcomes, and a new version (say a new Sonnet) starts from its family's record. **Settings → Auto** turns trying new models off, limits which harnesses Auto may use, and shows what it learned; **Forget** clears it.
+
+Compare runs get different picks. A subagent set to Auto is picked on its first task and keeps that harness. A launch on a machine is picked here, from the harnesses that machine reported, and that machine's outcomes come back to the same router. All of it stays in `~/.wisp/router.json`; usage stats only add which goal, kind of task and size were used, and whether the pick was exploring.
+
+The benchmark behind the priors is in [`bench/`](bench/README.md).
+
 ## Worktrees and shipping
 
 In a git repo, every launch (except Plan mode) runs in its own [git worktree](https://git-scm.com/docs/git-worktree) under `~/.wisp/worktrees/`, on a branch named `wisp/<task>-<id>` made from the remote's default branch (`origin/main`, fetched first; `HEAD` when there is no remote). Uncommitted changes in your own checkout are not carried over, and dependencies aren't shared: the agent is told to install what it needs. The card shows the branch, and **Take over** opens the worktree.
@@ -295,7 +308,7 @@ The launcher's **Subagents** button gives the lead agent a team: up to 6 members
 
 ## Checkpoints and rollback
 
-Before each turn, wisp snapshots the git working tree (pinned at `refs/wisp/checkpoints/<session>/<turn>`). **Restore to before this turn** (turn bar, session menu or ⌘K) rolls back; **Re-apply turn** undoes that. `diff` and `files` blocks have a per-file **Revert / Re-apply**, and `actions`, `terminal` and `tests` blocks run their command in the project folder with one click.
+Before each turn, wisp snapshots the git working tree (pinned at `refs/wisp/checkpoints/<session>/<turn>`). **Restore to before this turn** (the ⏪ icon in the turn bar, session menu or ⌘K) rolls back; **Re-apply** undoes that. `diff` and `files` blocks have a per-file **Revert / Re-apply**, and `actions`, `terminal` and `tests` blocks run their command in the project folder with one click.
 
 ## Automations
 
@@ -305,7 +318,7 @@ Before each turn, wisp snapshots the git working tree (pinned at `refs/wisp/chec
 Prepare release {version}: update CHANGELOG, README and docs/, bump package.json, tag v{version}.
 ```
 
-Make one from ⌘K → *Recipes*, or *Save as recipe…* on any card. A recipe may pin a project, harness, model and mode. Run it from ⌘K (*Run: Release*), from the Recipes view, or from a terminal: `wisp run release 0.13.0` fills the fields in order, `wisp run release version=0.13.0` by name.
+Make one from ⌘K → *Recipes*, or *Save as recipe…* on any card. A recipe may pin a project, harness, model and mode. Run it from ⌘K (*Run: Release*), from the Recipes view, or from a terminal: `wisp run release 0.15.0` fills the fields in order, `wisp run release version=0.15.0` by name.
 
 **Triggers** launch sessions on their own while wisp is open (⌘K → *Triggers*):
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wisp-agents",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Launch coding agents, skip the transcript, read the presentation.",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "app": "node bin/wisp.js",
     "dev": "WISP_DEV=1 node bin/wisp.js",
     "dev:web": "node --watch-path=server bin/wisp.js --no-open",
-    "test": "node --test test/proc.test.js test/terminal.test.js test/adapters.test.js test/e2e.test.js test/fuzzy.test.js test/integrations.test.js test/update.test.js test/learn.test.js test/ship.test.js test/subagents.test.js test/machines.test.js test/feedback.test.js",
+    "test": "node --test test/proc.test.js test/terminal.test.js test/adapters.test.js test/e2e.test.js test/fuzzy.test.js test/integrations.test.js test/update.test.js test/learn.test.js test/ship.test.js test/subagents.test.js test/machines.test.js test/feedback.test.js test/router.test.js",
     "test:real": "node test/real-clis.mjs",
     "prepublishOnly": "node --check bin/wisp.js && node --check bin/mac-app.js && node -e \"import('./server/index.js').then(() => import('./server/mcp-wisp.js'))\" && node --check electron/main.js"
   },

package/server/adapters/claude.js

@@ -65,8 +65,17 @@ export default {
     child.stdin.end(prompt);
 
     let sawResult = false;
+    let early = null; // an empty result that came before our prompt was answered (see below)
     let stderr = '';
     const pendingTools = new Map(); // tool_use_id -> name, to flag failed tool results
+    // Background tasks (run_in_background shells, background subagents) still running. While any
+    // are, the CLI stays up after its result and starts another turn when they finish.
+    let background = new Map(); // task_id -> description
+    const setBackground = (next) => {
+      const was = [...background.keys()].join(' ');
+      background = next;
+      if ([...next.keys()].join(' ') !== was) onEvent({ type: 'background', tasks: [...next.values()] });
+    };
 
     child.stderr.on('data', (d) => {
       stderr = (stderr + d).slice(-8000);
@@ -102,20 +111,30 @@ export default {
             onEvent({ type: 'tool_error', name, text: flatten(part.content).slice(0, 400) });
           }
         }
+      } else if (msg.type === 'system') {
+        // background_tasks_changed carries the full list; task_started/task_notification are the
+        // per-task edges, kept as a fallback in case a CLI version only sends those.
+        if (msg.subtype === 'background_tasks_changed' && Array.isArray(msg.tasks)) {
+          setBackground(new Map(msg.tasks.map((t) => [t.task_id, t.description || 'Background task'])));
+        } else if (msg.subtype === 'task_started' && msg.is_backgrounded && msg.task_id) {
+          setBackground(new Map(background).set(msg.task_id, msg.description || 'Background task'));
+        } else if (msg.subtype === 'task_notification' && background.has(msg.task_id)) {
+          const next = new Map(background);
+          next.delete(msg.task_id);
+          setBackground(next);
+        }
       } else if (msg.type === 'result') {
+        const ev = resultEvent(msg);
+        // On --resume, background tasks the last run left behind come back as a task
+        // notification queued ahead of our prompt. The CLI answers it with an empty,
+        // zero-turn result, then goes on to the prompt and reports a second result. Ending the
+        // turn on the first one would drop the real answer, so hold it in case it's all we get.
+        if (!ev.isError && !ev.text.trim() && !msg.num_turns) {
+          early = ev;
+          return;
+        }
         sawResult = true;
-        onEvent({
-          type: 'result',
-          text: msg.result ?? '',
-          isError: !!msg.is_error || (msg.subtype && msg.subtype !== 'success'),
-          stats: {
-            costUsd: msg.total_cost_usd,
-            durationMs: msg.duration_ms,
-            turns: msg.num_turns,
-            inputTokens: msg.usage?.input_tokens,
-            outputTokens: msg.usage?.output_tokens,
-          },
-        });
+        onEvent({ ...ev, background: background.size }); // > 0: another turn and result follow when they finish
       }
     });
 
@@ -127,6 +146,10 @@ export default {
         resolve();
       });
       child.on('close', (code, signal) => {
+        if (!sawResult && early && !stopping) {
+          sawResult = true;
+          onEvent(early);
+        }
         if (!sawResult) {
           onEvent({
             type: 'result',
@@ -152,6 +175,21 @@ export default {
 
 
 
+function resultEvent(msg) {
+  return {
+    type: 'result',
+    text: msg.result ?? '',
+    isError: !!msg.is_error || (msg.subtype && msg.subtype !== 'success'),
+    stats: {
+      costUsd: msg.total_cost_usd,
+      durationMs: msg.duration_ms,
+      turns: msg.num_turns,
+      inputTokens: msg.usage?.input_tokens,
+      outputTokens: msg.usage?.output_tokens,
+    },
+  };
+}
+
 // Human sentence for the live ticker + a coarse kind for the trail summary.
 function describeTool(name, input, cwd) {
   const f = rel(input.file_path || input.notebook_path || input.path, cwd);

package/server/client.js

@@ -134,7 +134,7 @@ export class WispClient {
   async launch({ prompt, cwd = process.cwd(), agent, mode, model, effort, attachments, worktree, compare, subagents, preset } = {}) {
     if (!agent || !mode || model === undefined) {
       const { defaults = {} } = await this.config();
-      agent ||= defaults.agent || 'claude';
+      agent ||= defaults.agent || 'auto';
       mode ||= defaults.mode || 'edits';
       model ??= defaults.models?.[agent] ?? (agent === defaults.agent ? defaults.model || '' : '');
     }

package/server/index.js

@@ -25,6 +25,7 @@ import { Remote } from './remote.js';
 import { Machines, splitId, qualify, sshHosts, discoverHosts } from './machines.js';
 import { usage } from './usage.js';
 import { normalizeTeam, normalizePreset, delegationReport } from './subagents.js';
+import { Router, GOALS } from './router.js';
 
 const WEB = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'web');
 
@@ -99,6 +100,8 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
     onChange: () => broadcast('machines', machines.view()),
     onEvent: (event, data) => {
       broadcast(event, data);
+      if ((event === 'finished' || event === 'summary') && data?.session) routeSignals(data.session);
+      else if (event === 'summary' && data?.id) routeSignals(data);
       if (event === 'finished' && remote.on) notifyFromMachine(data.session).catch((err) => console.warn(`wisp: phone: ${err.message}`));
     },
   });
@@ -135,13 +138,55 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
       broadcast('preferences', { added: added.length, removed: removed.length });
     },
   });
+  // Auto: wisp picks harness and model per task and learns from outcomes (server/router.js).
+  const router = new Router(store.home);
+  let agentsHere = [];
+  const detect = async (opts) => {
+    const agents = await listAgents(opts);
+    agentsHere = agents;
+    const added = router.sync(agents);
+    if (added.length) broadcast('router', { added });
+    return agents;
+  };
+  const autoOpts = () => {
+    const r = store.config.defaults.router || {};
+    return { explore: r.explore !== 'off', allowed: Array.isArray(r.allowed) && r.allowed.length ? r.allowed : null };
+  };
+  const goalOf = (model) => (GOALS[model] ? model : GOALS[store.config.defaults.models?.auto] ? store.config.defaults.models.auto : 'balanced');
+  // Subagents set to Auto are routed on their first task, from this computer's harnesses.
+  runner.routeAuto = (prompt) => router.choose({ prompt, agents: agentsHere, goal: goalOf(), ...autoOpts() });
+  // A routed session's outcome so far, from its summary: works the same for sessions on machines.
+  // Follow-ups after the first turn count as corrections; a merged or closed PR settles it.
+  const routeSignals = (sum) => {
+    if (!sum?.id || !router.route(sum.id) || sum.status === 'running' || sum.state === 'running') return;
+    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),
+      merged: pr === 'MERGED' || undefined,
+      closed: pr === 'CLOSED' || undefined,
+    });
+  };
+  runner.on('started', ({ session }) => {
+    if (session.route && !router.route(session.id)) router.record(session.id, session.route);
+  });
+  runner.on('ended', ({ session, turn, interrupted }) => {
+    if (!session.route || interrupted) return;
+    if (session.turns.indexOf(turn) === 0) router.signal(session.id, { error: turn.status === 'error' || undefined, costUsd: turn.stats?.costUsd, ms: turn.endedAt - turn.startedAt });
+    routeSignals(summarize(session, store));
+  });
+
   const run = (s, t) => ({ agent: s.agent, model: s.model || 'default', mode: s.mode, effort: s.effort || 'default', followUp: s.turns.indexOf(t) > 0 });
+  // Auto's choice, as fixed values only: never the prompt.
+  const routeProps = (s) =>
+    s.route ? { routed: true, routeGoal: s.route.goal, routeType: s.route.type, routeSize: s.route.size, routeExplored: !!s.route.explored, routeTrying: !!s.route.trying, routePropensity: s.route.propensity } : {};
   runner.on('started', ({ session, turn }) => telemetry.track('turn_started', { ...run(session, turn), attachments: turn.attachments.length }));
   runner.on('ended', ({ session, turn, interrupted, errorText }) => {
     const blocks = turn.presentation?.blocks || [];
     const st = turn.stats || {};
     telemetry.track('turn_ended', {
       ...run(session, turn),
+      ...routeProps(session),
       status: interrupted ? 'interrupted' : turn.status, // done | error | stopped | interrupted
       heroStatus: blocks.find((b) => b.type === 'hero')?.status,
       durationMs: turn.endedAt - turn.startedAt,
@@ -165,11 +210,16 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
     const cwd = expand(body.cwd || process.cwd());
     if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) throw bad(`Not a directory: ${cwd}`);
     const d = store.config.defaults;
-    // compare: more { agent, model, effort } to run the same task on, side by side.
-    const runners = [{ agent: body.agent, model: body.model, effort: body.effort }, ...(Array.isArray(body.compare) ? body.compare : [])].slice(0, MAX_COMPARE).map((r, i) => {
+    const preset = body.preset && store.config.teams.find((t) => t.id === body.preset);
+    if (body.preset && !preset && !body.subagents) throw bad(`no such subagent preset: ${body.preset}`);
+    const subagents = normalizeTeam(body.subagents ?? preset?.members, adapters);
+    // compare: more { agent, model, effort } to run the same task on, side by side. 'auto' is
+    // resolved here: the router picks a harness and model (a different one per compare run).
+    const resolved = await resolveAuto(body, agentsHere.length ? agentsHere : await detect(), { 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 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 : '' };
+      return { agent, model: r.model ?? (i ? d.models?.[agent] || '' : ''), effort: /^[\w-]{1,20}$/.test(r.effort || '') ? r.effort : '', ...(r.route && { route: r.route }) };
     });
     const mode = MODES.has(body.mode) ? body.mode : 'edits';
     // Worktrees are on by default in git repos (off in Plan mode: nothing gets written). Compare
@@ -179,9 +229,6 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
     // groupId: one launch sent to several machines (or here and there) shows as one task.
     const groupId = /^[a-f0-9]{12}$/.test(body.groupId || '') ? body.groupId : comparing ? newId() : null;
     const attachments = resolveAttachments(body.attachments);
-    const preset = body.preset && store.config.teams.find((t) => t.id === body.preset);
-    if (body.preset && !preset && !body.subagents) throw bad(`no such subagent preset: ${body.preset}`);
-    const subagents = normalizeTeam(body.subagents ?? preset?.members, adapters);
     const ids = runners.map(() => newId());
     let trees = ids.map(() => null);
     if (wantTree) {
@@ -204,6 +251,22 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
     return runners.map((r, i) => runner.create({ id: ids[i], prompt: body.prompt, cwd, ...r, mode, attachments, worktree: trees[i], groupId, origin, subagents }));
   }
 
+  // agent 'auto' (and compare entries set to it) → a harness and model picked by the router from
+  // `agents`: this computer's, or the machine's the launch goes to. Model is the goal for Auto.
+  async function resolveAuto(body, agents, { team = false } = {}) {
+    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 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, ...autoOpts() });
+      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 };
+    });
+    return { ...body, ...out[0], compare: out.slice(1) };
+  }
+
   // Where a launch runs: body.machine, else a project folder that only exists on a machine
   // (recipes and schedules keep just the path). null = here.
   function machineFor(body) {
@@ -217,7 +280,15 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
   async function launchAny(body, origin = null) {
     const mid = machineFor(body);
     if (!mid) return (await launch(body, origin)).map((x) => summarize(x, store));
-    const out = await machines.launch(mid, { ...body, attachments: await pushUploads(mid, body.attachments), ...(origin && { origin }) });
+    // Auto for a machine: routed here, with the harnesses that machine has; its outcomes come
+    // back through the summaries it streams (routeSignals), so one router learns from every place.
+    const routed = await resolveAuto(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;
+    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] && router.record(qualify(x.id, mid), routes[i]));
     const known = store.projectFor(out.cwd, mid);
     (known || store.addProject(out.cwd, { machine: mid })).lastUsedAt = Date.now();
     store.saveConfig();
@@ -354,6 +425,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
     const pr = await prView(dir, prev.number);
     const changed = (k) => JSON.stringify(k(pr)) !== JSON.stringify(k(prev));
     s.pr = pr;
+    if (pr.state !== prev.state) routeSignals(summarize(s, store));
     // Things worth coming back for: CI finished either way, a review landed, it merged or closed.
     const settledChecks = (x) => (x.checks.pending ? 'pending' : x.checks.fail ? 'fail' : 'pass');
     if (changed((x) => x.state) || changed((x) => x.review) || (changed(settledChecks) && settledChecks(pr) !== 'pending')) s.unread = true;
@@ -438,13 +510,39 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
     }
     if (root === 'openapi.json' && m === 'GET') return send(res, 200, openapi({ version: VERSION, port }));
 
-    if (root === 'agents' && m === 'GET') return send(res, 200, await listAgents({ fresh: url.searchParams.has('fresh') }));
+    if (root === 'agents' && m === 'GET') return send(res, 200, await detect({ fresh: url.searchParams.has('fresh') }));
     // Re-check: detect harnesses and models again, here and on every online machine.
     if (root === 'agents' && id === 'recheck' && m === 'POST') {
-      const [agents] = await Promise.all([listAgents({ fresh: true }), machines.recheckAgents()]);
+      const [agents] = await Promise.all([detect({ fresh: true }), machines.recheckAgents()]);
       return send(res, 200, agents);
     }
 
+    // Auto: what the router learned, and its settings (goal, trying new models, allowed harnesses).
+    if (root === 'router') {
+      const view = async () => ({ goals: GOALS, goal: goalOf(), settings: { explore: autoOpts().explore, allowed: autoOpts().allowed }, ...router.report(agentsHere.length ? agentsHere : await detect()) });
+      if (!id && m === 'GET') return send(res, 200, await view());
+      if (!id && m === 'PATCH') {
+        const body = await readJson(req);
+        const d = store.config.defaults;
+        if (body.goal !== undefined) {
+          if (!GOALS[body.goal]) return send(res, 400, { error: `goal must be one of ${Object.keys(GOALS).join(', ')}` });
+          d.models = { ...d.models, auto: body.goal };
+          if (d.agent === 'auto') d.model = body.goal;
+        }
+        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;
+        store.saveConfig();
+        broadcast('config', {});
+        return send(res, 200, await view());
+      }
+      if (id === 'reset' && m === 'POST') {
+        router.reset();
+        broadcast('router', {});
+        return send(res, 200, await view());
+      }
+    }
+
     // Bridge for the ask_user MCP server running inside an agent process.
     if (root === 'internal') {
       if (req.headers['x-wisp-token'] !== token) return send(res, 403, { error: 'bad token' });
@@ -900,6 +998,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
         broadcast('summary', summarize(s, store));
         broadcast('turn', { sessionId: s.id, turnId: turn.id });
         telemetry.track('rollback_turn', { agent: s.agent, restore: !!restore });
+        router.signal(s.id, { rolledBack: restore ? null : true });
         recheckShip(s);
         return send(res, 200, { ok: true, turnId: turn.id, ...result });
       }
@@ -1051,6 +1150,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
     if (rating === undefined && !text) throw Object.assign(new Error('Write something, or pick 👍 / 👎.'), { status: 400 });
     // A session on a machine: that wisp keeps the rating on its turn and sends it.
     const at = sessionId && splitId(sessionId);
+    if (sessionId && turnId && rating !== undefined) router.signal(sessionId, { feedback: rating });
     if (at) {
       try {
         return await machines.json(at.machine, 'POST', '/feedback', { rating, text, sessionId: at.id, turnId, source });
@@ -1153,6 +1253,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
   remote.start();
   machines.start();
 
+  detect().catch(() => {});
   if (telemetry.enabled) {
     if (store.config.defaults.telemetryNotice !== 'seen') console.log('wisp sends anonymous usage stats and error reports (no prompts, paths or code). Opt out: Settings, or WISP_TELEMETRY=0 / DO_NOT_TRACK=1.');
     listAgents()

package/server/machines.js

@@ -266,6 +266,11 @@ export class Machines extends EventEmitter {
     return m;
   }
 
+  // The harnesses the machine reported when it came online (Auto routes with these), or null.
+  agentsOf(id) {
+    return this.conns.get(id)?.remote?.agents || null;
+  }
+
   isOnline(id) {
     return this.conns.get(id)?.state === 'online';
   }

package/server/mcp-wisp.js

@@ -9,7 +9,7 @@ import fs from 'node:fs';
 import { WispClient } from './client.js';
 
 const VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
-const AGENTS = ['claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'];
+const AGENTS = ['auto', 'claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'];
 const DEFAULT_WAIT_S = 240; // stay under typical MCP client tool-call timeouts; call wisp_wait again for more
 
 const TOOLS = [
@@ -24,7 +24,7 @@ const TOOLS = [
       properties: {
         prompt: { type: 'string', description: 'The task, written as you would brief a colleague: goal, constraints, how to verify.' },
         cwd: { type: 'string', description: 'Absolute path of the project folder. Default: this MCP server’s working directory.' },
-        agent: { type: 'string', enum: AGENTS, description: 'Harness to run. Default: the user’s last pick in wisp.' },
+        agent: { type: 'string', enum: AGENTS, description: 'Harness to run; auto lets wisp pick harness and model from what worked before. Default: the user’s last pick in wisp.' },
         mode: { type: 'string', enum: ['plan', 'edits', 'auto'], description: 'plan = read-only, edits = auto-accept file edits, auto = no permission prompts. Default: the user’s pick.' },
         model: { type: 'string', description: 'Model id for that harness. Default: the user’s pick.' },
         effort: { type: 'string', description: 'Thinking level, e.g. low | medium | high.' },

package/server/openapi.js

@@ -45,6 +45,11 @@ 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' }) } },
+      },
+      '/router/reset': { post: { summary: 'Forget what Auto learned here (the shipped starting point stays)', responses: { 200: json({ type: 'object' }) } } },
       '/agents/recheck': { post: { summary: 'Detect harnesses and models again, here and on every online machine', responses: { 200: json({ type: 'array', items: ref('Agent') }) } } },
       '/feedback': {
         post: {
@@ -264,7 +269,8 @@ export function openapi({ version, port }) {
           properties: {
             prompt: { type: 'string' },
             cwd: { type: 'string', description: 'Project folder (absolute; ~ allowed). Default: the server’s cwd' },
-            agent: { enum: ['claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'], default: 'claude' },
+            agent: { enum: ['auto', 'claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'], default: 'auto', description: 'auto: wisp picks the harness and model from what worked before; model is then the goal (cheap, balanced, best)' },
+            important: { type: 'boolean', description: 'With agent auto: no exploring, take the pick with the best record' },
             mode: { enum: ['plan', 'edits', 'auto'], default: 'edits' },
             model: { type: 'string' },
             effort: { type: 'string', description: 'Thinking level: low, medium, high, xhigh, max (per harness)' },

package/server/protocol.js

@@ -14,6 +14,10 @@ presentation you put in your final message. Work autonomously:
 - If the task is done but there is a choice for later, end with a "question" block instead.
 - Verify your work where it is cheap (tests, type-check, lint, build) and report results honestly,
   including failures. Never claim something passes that you did not run.
+- Your final message ends the task. Don't end a turn with "I'll report once it has finished": wait for
+  background work (builds, test runs, background shells) to finish, then report its result. Anything
+  still running when you finish may be stopped; if you leave something up on purpose (a dev server),
+  say so.
 - The user can follow up; follow-ups resume this same session.
 - Attached files (images, video, docs) are listed in an <attachments> section of the prompt.
 

package/server/router-priors.json

@@ -0,0 +1,54 @@
+{
+  "version": "pilot-2026-10-18",
+  "source": "wisp-bench pilot: 121 runs on SWE-bench Verified, Harness-Bench and replayed wisp PRs, graded by hidden tests (first attempt). Thin: treat as a starting point.",
+  "arms": {
+    "opencode:opencode/deepseek-v4.1-flash-free": {
+      "a": 10,
+      "b": 0,
+      "usd": 0.0,
+      "min": 3.1
+    },
+    "claude:haiku": {
+      "a": 18,
+      "b": 3,
+      "usd": 0.017,
+      "min": 1.5
+    },
+    "claude:sonnet": {
+      "a": 18,
+      "b": 3,
+      "usd": 0.137,
+      "min": 0.7
+    },
+    "grok:grok-4.7": {
+      "a": 10,
+      "b": 2,
+      "usd": 0.984,
+      "min": 5.2
+    },
+    "claude:opus": {
+      "a": 17,
+      "b": 4,
+      "usd": 0.344,
+      "min": 1.3
+    },
+    "antigravity:gemini-3.8-flash-medium": {
+      "a": 4,
+      "b": 1,
+      "usd": 0.054,
+      "min": 4.4
+    },
+    "codex:": {
+      "a": 19,
+      "b": 5,
+      "usd": 0.129,
+      "min": 0.6
+    },
+    "antigravity:gemini-4-argon-medium": {
+      "a": 5,
+      "b": 2,
+      "usd": 0.677,
+      "min": 4.7
+    }
+  }
+}