wisp-agents 0.12.0 → 0.14.0

package/CHANGELOG.md

@@ -5,6 +5,38 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [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
+
+- **Start tasks from Telegram.** In **Phone → Telegram**, switch on **Start tasks from Telegram**, then send your bot `/new fix the flaky login test`. The task runs in your default project (the last used, or the one you pick in that section) with the launcher's harness, model and mode. `/new @api add rate limiting` picks a project by name, and `/projects` lists them. The bot replies **▶ Started**, and replying to that message sends a follow-up. Its card shows **Telegram** as where it came from. It's off by default, only the linked chat can start tasks, and a `/new` sent while wisp was offline is not run later. API: `PUT /api/remote` with `telegram.allowStart` and `telegram.project`.
+
+- **Feedback for the wisp team.** Each finished turn has a small 👍 / 👎 at the end of its trail. It stays faint until you hover the turn. Click again to take the rating back. 👎 opens one optional line for what went wrong (↵ sends, Esc skips). You can also type `/feedback <note>` in the launcher or any follow-up box, or use `⌘K` → **Send feedback…** for a short dialog. Bare `/feedback` opens the dialog too. It thanks you right away; offline, the feedback is kept and sent later. It goes to PostHog with the harness, model and status of the run, never your prompt, output or code. It's sent even with usage stats off, and `WISP_FEEDBACK=0` turns it off. API: `POST /api/feedback`.
+
+### Changed
+
+- **Switch modes in a follow-up.** Each task's follow-up box now has the same mode button as the launcher (Plan, Edits, Full auto; Shift+Tab cycles). Start in Plan, read the plan, then pick **Edits** and say "go ahead": that follow-up and the ones after it run in the new mode. Any mode can switch to any other. The pick only takes effect when you send, and the follow-up shows the new mode next to its model. A follow-up queued while the agent works keeps its own mode, so the run already going isn't affected. A task started in Plan has no worktree, so edits after switching land in the project folder. API: `mode` on `POST /api/sessions/{id}/reply`; CLI: `wisp reply <id> "…" --mode edits`; MCP: `mode` on `wisp_reply`.
+
+- **Compare more than two harnesses.** Clicking **vs** in the launcher adds a second harness as before, and a **+** at the end of the pill now adds a third and a fourth (four side by side, the server's limit). Each one sits behind its own **vs**: hover it for **×** to drop just that harness. A new one starts on a harness that isn't in the pill yet. With three or four, the pill shows logos only (hover a logo for harness, model and thinking level), and the mode and Subagents labels fold to icons so the bar stays on one line.
+
+### Fixed
+
+- Changing a Telegram setting through the API without a `token` no longer clears the bot token and unlinks the chat. After a settings change, Telegram no longer re-delivers messages wisp already handled.
+
+- Following up on a task now keeps it on screen as it moves to **Working**, and again when it lands back in **Needs you**. On a long card, the previous answer folding away used to pull the whole card off the top of the screen, so you lost the task you had just replied to. The composer now holds still and the new exchange appears where you were typing.
+
 ## [0.12.0] - 2026-10-18
 
 ### Added
@@ -220,7 +252,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.12.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.14.0...HEAD
+[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
 [0.10.0]: https://github.com/M0xoo/wisp/compare/v0.9.0...v0.10.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,9 +54,9 @@ 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.12.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.14.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. |
+| 📱 **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. |
 | 🔌 **Integrations** | An MCP server (`wisp mcp`), an agent skill, a scriptable CLI, a JS SDK, an OpenAPI-described HTTP API, and webhooks. Hand tasks to wisp from Claude Code, Codex, opencode, Cursor, scripts or CI. |
 | 🪶 **No runtime dependencies** | The server uses only Node built-ins. Electron is needed only for the desktop app. |
@@ -121,11 +122,11 @@ wisp "add a test" --wait          # block until it finishes, print the presentat
 wisp ls --state running,waiting   # list sessions
 wisp show <id>                    # state + latest presentation
 wisp wait <id>                    # until it finishes or asks you something
-wisp reply <id> "also do X"       # follow up (answers a pending question)
+wisp reply <id> "also do X"       # follow up (answers a pending question; --mode to switch)
 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.12.0            # run a recipe; values fill its {params} (or version=0.12.0)
+wisp run release 0.14.0            # run a recipe; values fill its {params} (or version=0.14.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.
@@ -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.12.0` fills the fields in order, `wisp run release version=0.12.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.14.0` fills the fields in order, `wisp run release version=0.14.0` by name.
 
 **Triggers** launch sessions on their own while wisp is open (⌘K → *Triggers*):
 
@@ -327,6 +340,7 @@ Settings → *Phone* sends questions and finished tasks to your phone and takes
 
 - **[ntfy](https://ntfy.sh)**: subscribe to the topic in the ntfy app. Notifications carry up to three buttons (the question's options, or *Mark done*); a tap sends a signed answer back. Use a long random topic (wisp suggests one): anyone who knows it can read the notifications, but only wisp can make answers that count.
 - **Telegram**: create a bot with @BotFather, paste its token, then send `/link <code>` to the bot. Tap a button to answer, or reply to a message to answer in your own words or send a follow-up.
+  Switch on **Start tasks from Telegram** to launch from the chat: `/new <task>` runs in the default project (the last used, or the one you pick), `/new @project <task>` picks one by name and `/projects` lists them. Tasks use the launcher's harness, model and mode. It's off by default, and only the linked chat can start tasks.
 
 They receive titles, summaries and questions (with their context), never code or diffs.
 
@@ -370,6 +384,14 @@ wisp sends anonymous usage stats and error reports to [PostHog](https://posthog.
 
 It is also off whenever `CI` is set.
 
+### Feedback
+
+Rate any result with 👍 / 👎 at the end of the turn (👎 asks for an optional line on what went wrong), type `/feedback <your note>` in any prompt box, or use `⌘K` → *Send feedback*. It goes to the wisp team on PostHog as a `turn_rated` or `feedback` event.
+
+**What is sent:** your rating and note (with your home directory replaced by `~`), the wisp version and OS. For a rated turn it also sends the run's harness, model, mode, status, duration and presentation block types. Your prompt, the agent's output and your code are **never sent**.
+
+You send feedback on purpose, so it goes out even with usage stats off, under a one-off id. Offline, it waits in `~/.wisp/feedback-outbox.json` and is sent later. `WISP_FEEDBACK=0` turns it off and hides the thumbs.
+
 ## Contributing
 
 Issues and PRs are welcome. wisp has no build step: edit `web/` or `server/`, then run `npm run dev` (or `npm run dev:web`) to see your changes.

package/bin/wisp.js

@@ -24,7 +24,7 @@ const HELP = `usage:
   wisp ls                       list sessions        (--state running,waiting  --limit N)
   wisp show <id>                state + latest presentation as markdown
   wisp wait <id>                block until it finishes or asks you something
-  wisp reply <id> "text"        follow up (answers a pending question)   (--queue)
+  wisp reply <id> "text"        follow up (answers a pending question)   (--queue  --mode plan|edits|auto)
   wisp stop <id>                stop a run
   wisp ship <id>                commit, push and open a PR for a worktree session   (--draft)
   wisp merge <id>               squash-merge its PR and sync your local base branch
@@ -132,7 +132,7 @@ async function scripted(cmd, args) {
     }
     case 'reply': {
       const id = need(args[0], 'session id');
-      const r = await wisp.reply(id, need(args.slice(1).join(' ').trim(), 'text'), { queue: flags.queue });
+      const r = await wisp.reply(id, need(args.slice(1).join(' ').trim(), 'text'), { queue: flags.queue, mode: flags.mode || undefined });
       if (!flags.wait) return out(r, r.answered ? '  ✓ answered' : r.interrupted ? '  ✓ interrupted; resuming with your message' : r.queued ? '  ✓ queued' : '  ✓ sent');
       return show(id, await wisp.wait(id));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wisp-agents",
-  "version": "0.12.0",
+  "version": "0.14.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": "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 || '' : '');
     }
@@ -155,7 +155,7 @@ export class WispClient {
 
   // A follow-up. If the agent is blocked on ask_user, this answers it. queue: wait for the
   // current run instead of interrupting it (default: the user's setting).
-  reply = (id, text, { attachments, queue } = {}) => this.request('POST', `/sessions/${id}/reply`, { text, attachments, queue });
+  reply = (id, text, { attachments, queue, mode } = {}) => this.request('POST', `/sessions/${id}/reply`, { text, attachments, queue, mode });
 
   // Upload a file (path, Buffer or Uint8Array) to attach to a launch or reply. Returns { id, … }.
   async upload(file, { name, type } = {}) {

package/server/index.js

@@ -11,7 +11,7 @@ import { Runner, summarize, newId, workdir } from './runner.js';
 import { adapters, listAgents } from './adapters/index.js';
 import { welcomeSession } from './welcome.js';
 import { openInTerminal, TERMINALS, shq } from './terminal.js';
-import { Telemetry, envDisabled } from './telemetry.js';
+import { Telemetry, envDisabled, feedbackAvailable } from './telemetry.js';
 import { blocksToMarkdown, sessionToMarkdown } from './render.js';
 import { openapi } from './openapi.js';
 import { Updater } from './update.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();
@@ -226,9 +297,9 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
   }
 
   // A follow-up from anywhere (UI, CLI, phone). An archived session may have lost its worktree.
-  async function replyTo(s, text, attachments = [], queue) {
+  async function replyTo(s, text, attachments = [], queue, mode) {
     await ensureWorktree(s.worktree);
-    return runner.reply(s, text, attachments, { queue: queue ?? store.config.defaults.followUp === 'queue' });
+    return runner.reply(s, text, attachments, { queue: queue ?? store.config.defaults.followUp === 'queue', mode });
   }
 
   const markDone = (s) => {
@@ -257,6 +328,15 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
   const remote = new Remote({
     store,
     onChange: () => broadcast('remote', {}),
+    // /new from Telegram: the launcher's remembered harness, model and mode, like `wisp "…"`.
+    launch: async ({ project, prompt }) => {
+      const d = store.config.defaults;
+      const agent = d.agent || 'claude';
+      const model = d.models?.[agent] ?? d.model ?? '';
+      const [s] = await launchAny({ prompt, cwd: project.path, machine: project.machine || undefined, agent, model, mode: d.mode || 'edits' }, { kind: 'telegram', name: 'Telegram' });
+      broadcast('config', {});
+      return s;
+    },
     act: async ({ sessionId, kind, ref, index, text }) => {
       const ops = await sessionOps(sessionId).catch((err) => ({ error: err.message }));
       if (ops?.error) return `Can’t reach it: ${ops.error}`;
@@ -345,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;
@@ -429,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' });
@@ -507,7 +614,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
     }
 
     if (root === 'config') {
-      if (m === 'GET') return send(res, 200, { ...store.config, remote: undefined, home: os.homedir(), cwd: process.cwd(), terminals: TERMINALS, telemetry: { available: !envDisabled(), enabled: telemetry.enabled } });
+      if (m === 'GET') return send(res, 200, { ...store.config, remote: undefined, home: os.homedir(), cwd: process.cwd(), terminals: TERMINALS, telemetry: { available: !envDisabled(), enabled: telemetry.enabled }, feedback: feedbackAvailable() });
       if (m === 'PATCH') {
         const body = await readJson(req);
         if (body.defaults) Object.assign(store.config.defaults, body.defaults);
@@ -722,6 +829,9 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
 
     if (root === 'machines') return machinesApi(req, res, url, id, action);
 
+    // Feedback for the wisp team: thumbs on a turn and/or a note. { rating?, text?, sessionId?, turnId? }
+    if (root === 'feedback' && m === 'POST') return send(res, 200, await sendFeedback(await readJson(req)));
+
     if (root === 'sessions') {
       if (id && splitId(id)) return machineSessionApi(req, res, url, splitId(id), action);
       if (!id) {
@@ -742,9 +852,9 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
         }
         if (m === 'POST') {
           const body = await readJson(req);
-          // A machine's wisp hands on where a recipe or trigger launch came from.
+          // A machine's wisp hands on where a recipe, trigger or Telegram launch came from.
           const o = body.origin;
-          const origin = o && (o.kind === 'recipe' || o.kind === 'trigger') ? { kind: o.kind, id: String(o.id || ''), name: String(o.name || '') } : null;
+          const origin = o && ['recipe', 'trigger', 'telegram'].includes(o.kind) ? { kind: o.kind, id: String(o.id || ''), name: String(o.name || '') } : null;
           const out = await launchAny(body, origin);
           return send(res, 201, out.length > 1 ? { ...out[0], group: out } : out[0]);
         }
@@ -836,10 +946,11 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
       }
 
       if (action === 'reply' && m === 'POST') {
-        const { text, attachments, queue } = await readJson(req);
+        const { text, attachments, queue, mode } = await readJson(req);
         if (!text?.trim()) return send(res, 400, { error: 'text required' });
         if (s.agent === 'wisp') return send(res, 400, { error: 'This is the tour — launch a real wisp to follow up.' });
-        return send(res, 200, await replyTo(s, text.trim(), resolveAttachments(attachments), queue));
+        if (mode !== undefined && !MODES.has(mode)) return send(res, 400, { error: 'mode must be plan, edits or auto.' });
+        return send(res, 200, await replyTo(s, text.trim(), resolveAttachments(attachments), queue, mode));
       }
 
       if (action === 'queue' && m === 'DELETE') {
@@ -887,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 });
       }
@@ -1030,6 +1142,49 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
   }
 
   // /api/sessions/<id>@<machine>/…: passed through to that machine's wisp, ids rewritten.
+  // A rating sticks to its turn (it shows on the card and can be taken back). What goes out is
+  // the rating, the user's own words, and how the run was set up — never the prompt or the result.
+  async function sendFeedback({ rating, text, sessionId, turnId, source } = {}) {
+    if (rating !== undefined && rating !== null && rating !== 'up' && rating !== 'down') throw Object.assign(new Error('rating must be up or down'), { status: 400 });
+    text = String(text || '').trim();
+    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 });
+      } catch (err) {
+        if (err.status === 400) throw err; // offline, or an older wisp there: send it from here, without the run
+      }
+    }
+    const s = sessionId && !at ? store.get(sessionId) : null;
+    if (sessionId && !at && !s) throw Object.assign(new Error('no such session'), { status: 404 });
+    const turn = s && (turnId ? s.turns.find((t) => t.id === turnId) : s.turns.at(-1));
+    if (turnId && s && !turn) throw Object.assign(new Error('no such turn'), { status: 404 });
+    // Only thumbs on a turn stick to it; a rating in the feedback dialog is about wisp as a whole.
+    if (turn && turnId && rating !== undefined) {
+      turn.feedback = rating ? { rating, at: Date.now() } : undefined;
+      store.save(s);
+      broadcast('turn', { sessionId: s.id, turnId: turn.id });
+    }
+    const blocks = turn?.presentation?.blocks || [];
+    const context = turn && {
+      ...run(s, turn),
+      status: turn.status,
+      heroStatus: blocks.find((b) => b.type === 'hero')?.status,
+      blockTypes: [...new Set(blocks.map((b) => b.type))],
+      durationMs: turn.endedAt ? turn.endedAt - turn.startedAt : undefined,
+      tour: s.agent === 'wisp' || undefined,
+    };
+    const props = { ...context, rating: rating || undefined, source: String(source || (turn ? 'turn' : 'app')).slice(0, 20), machine: at ? true : undefined };
+    // Thumbs on a turn count as a rating; anything written, or sent from the dialog, is 'feedback'.
+    const event = text || !turnId ? 'feedback' : 'turn_rated';
+    if (event === 'turn_rated' && rating === null) props.cleared = true;
+    const sent = await telemetry.feedback(event, { ...props, text: text || undefined });
+    return { ok: true, sent, available: feedbackAvailable() };
+  }
+
   async function machineSessionApi(req, res, url, at, action) {
     const m = req.method;
     const mid = at.machine;
@@ -1098,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()