wisp-agents 0.22.0 → 0.24.0

package/CHANGELOG.md

@@ -5,6 +5,29 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [0.24.0] - 2026-10-20
+
+### Added
+
+- **How to get a missing harness, where you look for it.** Settings → Agents now shows, for each harness wisp didn't find, what to do on that computer's OS: a one-line tip (e.g. that the ChatGPT app is enough for Codex on macOS and Linux but not on Windows, or that the Antigravity and Cursor editors don't include their CLIs), the install command to copy with one click, and a **Docs** link. In the harness picker, hovering a greyed-out harness shows the same tip, and clicking it (or arrowing onto it) shows the steps in place of its models, with **Re-check** (and **Install** for opencode). It still can't be picked. API: unavailable harnesses in `GET /agents` carry `setup: { tip, command?, url }`; adapters provide it through an optional `setup(platform)`.
+- **Codex and Claude Code from their desktop apps, no CLI install needed.** If `codex` isn't on PATH, wisp uses the Codex CLI the ChatGPT desktop app ships: `ChatGPT.app/Contents/Resources/codex-cli/bin/codex` on macOS (or `Codex.app/Contents/Resources/codex` from the older Codex app), in `/Applications` or `~/Applications`, and `/usr/lib/chatgpt/resources/codex` from the Linux `.deb`. It shares `~/.codex`, so the app's sign-in carries over. The Windows app is a Store package whose files can't be run from outside it, so on Windows Codex still needs the CLI. If `claude` isn't on PATH, wisp uses the newest copy the Claude desktop app downloads for its Code tab, on macOS and Windows (`<app data>/Claude/claude-code/<version>/…`, including the Store installs' folders). That copy is signed in only while the app runs it, so run it once and `/login`. Both adapters also look in the CLIs' own install folders (`~/.codex/packages/standalone/current/bin`, `%LOCALAPPDATA%\Programs\OpenAI\Codex\bin`, `~/.local/bin`, `~/.claude/local`), which an app started from the Dock or Start menu may not have on PATH. A `WISP_CODEX_BIN` or `WISP_CLAUDE_BIN` override still wins.
+
+### Changed
+
+- **The website shows moving a task to another computer or agent.** A new landing-page section, *Start on your laptop. Finish on the dev box.*, has a working copy of a task card's follow-up box: pick a computer under **Runs on** and an agent, press ↵, and it packs the work, hands the history over and carries on there, the way the app does. It plays once by itself when it comes into view; click anything to try it. A new guide, [Move a task to another machine or agent, mid-way](https://trywisp.dev/guides/move-a-task-to-another-machine-or-agent.html), covers doing it by hand with `git bundle`, what wisp moves, what each agent is told when you switch harness, model or computer, and the CLI and API. The landing FAQ answers it too, and *Machines* is in the landing nav. In *Also in the box*, the Machines tile became *Several folders*, since machines now have their own section. The landing nav no longer wraps onto two lines between 960 and 1200px wide; it drops Control and CLI there.
+
+### Fixed
+
+- **The site builds the same on Windows.** With a CRLF checkout, the integrations page kept its markdown title as a second `<h1>` and the changelog page repeated each release heading, because `scripts/site.mjs` matched `\n` line ends only. It now normalizes line ends when reading `docs/integrations.md` and `CHANGELOG.md`, and the site test passes on Windows CI.
+- **Done and Archived count every task and load more as you scroll.** Their headings always said 60 once you had more than that, and the older tasks never showed. The headings now count them all, the lists show 60 cards at first and add the next 60 as you scroll near the end (or click **Show 60 more · N left**), and opening an older task from a notification or ⌘K shows the cards down to it.
+
+## [0.23.0] - 2026-10-20
+
+### Changed
+
+- **Auto's Balanced goal runs frontier models.** When you have a frontier model installed and allowed (Opus, Codex's default, Gemini Argon, Grok 4.x), Balanced now picks it, at the harness's default or medium thinking, instead of Sonnet or Haiku. Best stays on frontier models at high or x-high, so the thinking level is what sets the two apart. Balanced steps down to an everyday model (Sonnet, never Haiku) only while every frontier model is at its limit, so the task still runs, or when you have none; small models' wins no longer pull Balanced to them after 20 outcomes. Cheap is unchanged. For models with the level in their name (Antigravity's `gemini-4-argon-low` / `-medium` / `-high`), the goal now picks the variant: Cheap low, Balanced medium, Best high, and the other variants count as the same model.
+- **Guides on the website for what people search for.** Six new pages under [trywisp.dev/guides](https://trywisp.dev/guides/): [run Claude Code and Codex in parallel](https://trywisp.dev/guides/run-claude-code-and-codex-in-parallel.html), [run multiple Claude Code agents in parallel](https://trywisp.dev/guides/run-multiple-claude-code-agents-in-parallel.html), [run coding agents on multiple machines](https://trywisp.dev/guides/run-coding-agents-on-multiple-machines.html), [multi-agent coding](https://trywisp.dev/guides/multi-agent-coding.html), [Claude Code vs Codex on your own repo](https://trywisp.dev/guides/claude-code-vs-codex.html) and [run coding agents in the background](https://trywisp.dev/guides/run-coding-agents-in-the-background.html). Each answers its question in the first paragraph, shows the manual way with `git worktree` and `ssh`, then how wisp does it, and ends with FAQs (with `FAQPage` structured data). `scripts/guides.mjs` holds them; `scripts/site.mjs` renders them into the sitemap. The landing page's title, description and structured data now say *in parallel* and *on your other machines*, its FAQ answers both questions, and Guides is in the nav and footer of every page. The npm description and keywords match.
+
 ## [0.22.0] - 2026-10-20
 
 ### Added
@@ -413,7 +436,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.22.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.24.0...HEAD
+[0.24.0]: https://github.com/M0xoo/wisp/compare/v0.23.0...v0.24.0
+[0.23.0]: https://github.com/M0xoo/wisp/compare/v0.22.0...v0.23.0
 [0.22.0]: https://github.com/M0xoo/wisp/compare/v0.21.0...v0.22.0
 [0.21.0]: https://github.com/M0xoo/wisp/compare/v0.20.0...v0.21.0
 [0.20.0]: https://github.com/M0xoo/wisp/compare/v0.19.0...v0.20.0

package/README.md

@@ -56,7 +56,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.22.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.24.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** (no permission prompts, the default) for each launch. `Shift+Tab` in the prompt cycles modes. In Edits mode, anything the permissions block comes to you: Claude Code waits for **Allow / Always / Deny**, and the other harnesses show an **Allow & retry** card. |
@@ -65,7 +65,7 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 
 ## Quick start
 
-> **Requirements:** macOS, Linux, or Windows; Node.js ≥ 20; and at least one harness installed and signed in: [Claude Code](https://claude.com/claude-code) (`claude`), [Codex](https://github.com/openai/codex) (`codex`), [opencode](https://opencode.ai) (`opencode`), [Cursor CLI](https://cursor.com/cli) (`cursor-agent`), [Antigravity CLI](https://antigravity.google/docs/cli/headless/) (`agy`), or [Grok Build](https://x.ai/cli) (`grok`). Override a binary path with `WISP_CLAUDE_BIN`, `WISP_CODEX_BIN`, `WISP_OPENCODE_BIN`, `WISP_CURSOR_BIN`, or `WISP_ANTIGRAVITY_BIN`.
+> **Requirements:** macOS, Linux, or Windows; Node.js ≥ 20; and at least one harness installed and signed in: [Claude Code](https://claude.com/claude-code) (`claude`), [Codex](https://github.com/openai/codex) (`codex`), [opencode](https://opencode.ai) (`opencode`), [Cursor CLI](https://cursor.com/cli) (`cursor-agent`), [Antigravity CLI](https://antigravity.google/docs/cli/headless/) (`agy`), or [Grok Build](https://x.ai/cli) (`grok`). No CLI? The [ChatGPT desktop app](https://chatgpt.com/download) is enough for Codex on macOS and Linux, and the [Claude desktop app](https://claude.com/download) for Claude Code on macOS and Windows once you've opened its Code tab and signed that CLI in once: wisp uses the CLI each app ships when the command isn't on PATH. Override a binary path with `WISP_CLAUDE_BIN`, `WISP_CODEX_BIN`, `WISP_OPENCODE_BIN`, `WISP_CURSOR_BIN`, or `WISP_ANTIGRAVITY_BIN`.
 
 ```sh
 npx wisp-agents                          # open the wisp desktop app
@@ -85,7 +85,7 @@ brew install m0xoo/tap/wisp-agents             # Homebrew: CLI and browser mode,
 wisp "fix the flaky auth test"
 ```
 
-The Homebrew formula lives in [M0xoo/homebrew-tap](https://github.com/M0xoo/homebrew-tap). `install.sh` honors `WISP_VERSION` to pin a release (`curl -fsSL https://trywisp.dev/install.sh | WISP_VERSION=0.22.0 bash`).
+The Homebrew formula lives in [M0xoo/homebrew-tap](https://github.com/M0xoo/homebrew-tap). `install.sh` honors `WISP_VERSION` to pin a release (`curl -fsSL https://trywisp.dev/install.sh | WISP_VERSION=0.24.0 bash`).
 
 From source:
 
@@ -135,7 +135,7 @@ wisp btw <id> "did you do X?"     # ask on the side without interrupting the run
 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.22.0            # run a recipe; values fill its {params} (or version=0.22.0)
+wisp run release 0.24.0            # run a recipe; values fill its {params} (or version=0.24.0)
 wisp recipes                      # list recipes
 wisp usage [--days 7]             # spend and outcomes
 wisp mcp                          # MCP server for other agents and editors
@@ -304,7 +304,7 @@ If the harness has no system-prompt flag, prepend `systemPrompt` to the first pr
 
 ## Auto
 
-**Auto** is the default harness: wisp picks the harness, model and thinking level for each task. Its "model" is a goal: **Balanced** (best result per dollar), **Cheap** or **Best**. The goal also sets how hard the agent thinks: Cheap runs at low (or minimal), Balanced at the harness's default or medium, Best at high or x-high. A harness or model without levels runs at its default.
+**Auto** is the default harness: wisp picks the harness, model and thinking level for each task. Its "model" is a goal: **Balanced** (the default), **Cheap** or **Best**. Balanced and Best both run frontier models (Opus, not Sonnet or Haiku) when you have one installed and allowed; what sets them apart is how hard the agent thinks: Balanced runs at the harness's default or medium, Best at high or x-high. Cheap runs at low (or minimal) on whichever model does the job for least. A harness or model without levels runs at its default; for models with the level in their name (Antigravity's `gemini-4-argon-high`) the goal picks the variant the same way.
 
 How it picks: every harness · model · thinking level you have installed is an option (`claude:opus:high`). 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. Thinking harder starts out a little more likely to work and costs more, and then your outcomes decide. A model's record at one level counts half at its other levels.
 
@@ -319,7 +319,7 @@ After the run, Auto checks the work before it lands in your queue:
 3. **Repair**: new failures go back to the same agent (1 round by default, up to 2).
 4. **Hand over**: still failing, or the run errored, so the task runs again on a stronger tier (small → everyday → frontier) in its own worktree, next to the first run.
 
-A harness that says it's at its limit (session or usage limit, rate limit, no credit) isn't failing the task. Auto rests it until the limit resets, doesn't count the run against it, and moves the task to the best pick that can run now. Best always runs frontier models only (Opus, not Sonnet or Haiku); it falls back to the strongest you have only when no frontier model is installed. Until Auto has 20 of your own outcomes, Balanced picks only everyday and frontier models. The shipped estimates come from a small pilot, so they count for at most 4 tasks each.
+A harness that says it's at its limit (session or usage limit, rate limit, no credit) isn't failing the task. Auto rests it until the limit resets, doesn't count the run against it, and moves the task to the best pick that can run now. Best always runs frontier models only; it falls back to the strongest you have only when no frontier model is installed. Balanced runs on the strongest tier that can run now, whatever the record of the weaker models: frontier, or everyday (Sonnet, never Haiku) while every frontier model is at its limit or when you have none. The shipped estimates come from a small pilot, so they count for at most 4 tasks each.
 5. **Best of two** (goal Best, off by default): two picks work side by side; tests decide, then a cheap model reads both diffs, and the better run is marked **Pick**.
 
 Each step's outcome feeds the router: a test pass counts more than the agent's "done", needing a repair counts less, and losing a best-of-2 a little less again. Your own follow-up stops whatever Auto was about to do next. A launch on a machine is checked on that machine, where the files are. Settings → Auto turns each step on or off and sets the test command per project.
@@ -354,7 +354,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.22.0` fills the fields in order, `wisp run release version=0.22.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.24.0` fills the fields in order, `wisp run release version=0.24.0` by name.
 
 **Triggers** launch sessions on their own while wisp is open (⌘K → *Triggers*):
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wisp-agents",
-  "version": "0.22.0",
-  "description": "Launch coding agents, skip the transcript, read the presentation.",
+  "version": "0.24.0",
+  "description": "Run Claude Code, Codex, Cursor and other coding agents in parallel, in the background, on any of your machines. Skip the transcript, read the report.",
   "type": "module",
   "bin": {
     "wisp": "bin/wisp.js",
@@ -31,7 +31,17 @@
   "keywords": [
     "claude",
     "claude-code",
+    "codex",
+    "openai-codex",
+    "cursor",
+    "opencode",
     "coding-agent",
+    "ai-agents",
+    "multi-agent",
+    "parallel",
+    "git-worktree",
+    "ssh",
+    "orchestration",
     "ai",
     "agents",
     "cli",

package/server/adapters/antigravity.js

@@ -37,6 +37,11 @@ export default {
     return [BIN, ...(resumeId ? ['--conversation', resumeId] : []), ...(model ? ['--model', model] : []), ...(effort ? ['--effort', effort] : [])];
   },
 
+  // How to get it, shown in Settings → Agents and the picker while it isn't found (this OS's steps).
+  setup() {
+    return { tip: 'Install the Antigravity CLI (agy) and sign in. The Antigravity app doesn’t include it', url: 'https://antigravity.google/docs/cli/headless/' };
+  },
+
   async detect() {
     const found = await detectVersion(BIN);
     if (!found.available) return found;

package/server/adapters/claude.js

@@ -3,10 +3,46 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { ASK_TIMEOUT_MS, MAX_SNAPSHOT, attachmentNote, clip, detectVersion, exitText, flatten, rel, spawnJsonl } from './common.js';
+import { ASK_TIMEOUT_MS, MAX_SNAPSHOT, attachmentNote, clip, detectFirst, exitText, flatten, rel, spawnJsonl } from './common.js';
 import { describeCommand } from './commands.js';
 
-const BIN = process.env.WISP_CLAUDE_BIN || 'claude';
+const DEFAULT_BIN = process.env.WISP_CLAUDE_BIN || 'claude';
+let BIN = DEFAULT_BIN;
+// Where claude lives when it isn't on PATH: the native installer's folders (an app started from
+// the Dock never reads the shell profile that adds them), then the copies the Claude desktop app
+// downloads for its Code tab into <userData>/claude-code/<version>/<sha12>/ (older builds: straight
+// into <version>/; macOS builds may wrap it in claude.app), newest version first. That copy is
+// signed in only while the app runs it, so on its own it needs one sign-in.
+const newestFirst = (dir) => {
+  try {
+    return fs.readdirSync(dir).sort((a, b) => b.localeCompare(a, 'en', { numeric: true }));
+  } catch {
+    return [];
+  }
+};
+export const fallbackBins = () => {
+  const home = os.homedir();
+  const win = process.platform === 'win32';
+  const exe = win ? 'claude.exe' : 'claude';
+  const local = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+  // The app's userData: a direct install, then the two Store (MSIX) packages, whose AppData writes
+  // land in their own LocalCache.
+  const userData = {
+    darwin: [path.join(home, 'Library', 'Application Support', 'Claude')],
+    win32: [
+      path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'Claude'),
+      ...['Claude_pzs8sxrjxfjjc', 'AnthropicPBC.Claude_fnn82j28hfe8t'].map((p) => path.join(local, 'Packages', p, 'LocalCache', 'Roaming', 'Claude')),
+    ],
+  }[process.platform] || [];
+  const desktop = userData.flatMap((d) => {
+    const root = path.join(d, 'claude-code');
+    return newestFirst(root).flatMap((v) => [
+      ...newestFirst(path.join(root, v)).flatMap((h) => [path.join(root, v, h, exe), path.join(root, v, h, 'claude.app', 'Contents', 'MacOS', 'claude')]),
+      path.join(root, v, exe),
+    ]);
+  });
+  return [path.join(home, '.local', 'bin', exe), ...(win ? [] : [path.join(home, '.claude', 'local', 'claude')]), ...desktop];
+};
 
 // Claude in Chrome turns itself on only in interactive sessions; `-p` needs --chrome. Follow the
 // user's own "enabled by default" choice (/chrome in Claude Code) so a wisp run gets the same tools.
@@ -46,8 +82,19 @@ export default {
     return [BIN, ...(resumeId ? ['--resume', resumeId] : []), ...(model ? ['--model', model] : []), ...(effort ? ['--effort', effort] : []), ...dirs.flatMap((d) => ['--add-dir', d])];
   },
 
-  detect() {
-    return detectVersion(BIN);
+  // How to get it, shown in Settings → Agents and the picker while it isn't found (this OS's steps).
+  setup(platform = process.platform) {
+    return {
+      tip: platform === 'linux' ? 'Install Claude Code, then run claude once to sign in' : 'Install Claude Code and run claude once to sign in. Or open the Claude app’s Code tab once: wisp uses the copy it downloads',
+      command: platform === 'win32' ? 'irm https://claude.ai/install.ps1 | iex' : 'curl -fsSL https://claude.ai/install.sh | bash',
+      url: 'https://claude.com/claude-code',
+    };
+  },
+
+  async detect() {
+    const { bin, ...found } = await detectFirst(DEFAULT_BIN, fallbackBins, !!process.env.WISP_CLAUDE_BIN);
+    BIN = bin;
+    return found;
   },
 
   // What a permission prompt is about, for the approval card and for matching "always allow".

package/server/adapters/codex.js

@@ -1,10 +1,30 @@
 // Codex CLI adapter — drives `codex exec --json` (JSONL thread/turn/item events).
 
+import os from 'node:os';
 import path from 'node:path';
-import { ASK_TIMEOUT_MS, attachmentNote, clip, detectVersion, exitText, fileTracker, flatten, rel, spawnJsonl, withProtocol } from './common.js';
+import { ASK_TIMEOUT_MS, attachmentNote, clip, detectFirst, exitText, fileTracker, flatten, rel, spawnJsonl, withProtocol } from './common.js';
 import { describeCommand } from './commands.js';
 
-const BIN = process.env.WISP_CODEX_BIN || 'codex';
+const DEFAULT_BIN = process.env.WISP_CODEX_BIN || 'codex';
+let BIN = DEFAULT_BIN;
+// Where codex lives when it isn't on PATH: the standalone installer's own copy (its ~/.local/bin
+// link may not be on an app's PATH; on Windows it also keeps one in Programs\OpenAI\Codex), then
+// the CLI the ChatGPT desktop app ships: in its bundle on macOS (the older Codex.app kept it at
+// Resources/codex) and in /usr/lib/chatgpt from the Linux .deb. They share ~/.codex, so the app's
+// sign-in carries. The Windows app is a Store package whose files can't be run from outside it.
+export const fallbackBins = () => {
+  const home = os.homedir();
+  if (process.platform === 'win32') {
+    const local = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+    return [path.join(home, '.codex', 'packages', 'standalone', 'current', 'bin', 'codex.exe'), path.join(local, 'Programs', 'OpenAI', 'Codex', 'bin', 'codex.exe')];
+  }
+  const apps = process.platform === 'darwin' ? ['/Applications', path.join(home, 'Applications')] : [];
+  return [
+    path.join(home, '.codex', 'packages', 'standalone', 'current', 'bin', 'codex'),
+    ...apps.flatMap((d) => [path.join(d, 'ChatGPT.app', 'Contents', 'Resources', 'codex-cli', 'bin', 'codex'), path.join(d, 'Codex.app', 'Contents', 'Resources', 'codex')]),
+    ...(process.platform === 'linux' ? ['/usr/lib/chatgpt/resources/codex'] : []),
+  ];
+};
 const IMAGE = /^image\/(png|jpe?g|gif|webp)$/;
 
 // Codex has no "accept edits only" mode; workspace-write lets it edit the project and run
@@ -29,8 +49,22 @@ export default {
     return [BIN, ...(resumeId ? ['resume', resumeId] : []), ...(model ? ['--model', model] : []), ...(effort ? ['-c', `model_reasoning_effort=${toml(effort)}`] : [])];
   },
 
-  detect() {
-    return detectVersion(BIN);
+  // How to get it, shown in Settings → Agents and the picker while it isn't found (this OS's steps).
+  setup(platform = process.platform) {
+    return {
+      tip:
+        platform === 'win32'
+          ? 'Install the Codex CLI and run codex once to sign in. On Windows the ChatGPT app’s built-in Codex can’t be run from outside the app'
+          : 'Install the Codex CLI and run codex once to sign in. Or install the ChatGPT desktop app and sign in there: wisp uses the Codex inside it',
+      command: 'npm i -g @openai/codex',
+      url: 'https://github.com/openai/codex',
+    };
+  },
+
+  async detect() {
+    const { bin, ...found } = await detectFirst(DEFAULT_BIN, fallbackBins, !!process.env.WISP_CODEX_BIN);
+    BIN = bin;
+    return found;
   },
 
   // dirs: the task's other folders, writable like cwd.

package/server/adapters/common.js

@@ -18,6 +18,19 @@ export function detectVersion(bin, args = ['--version']) {
   });
 }
 
+// Detect `bin`, or when it doesn't run, the first copy in fallbacks() that does: CLIs that live
+// off PATH (an install wisp made, a desktop app's bundled CLI). Resolves detectVersion's answer
+// plus the `bin` that answered. An explicit WISP_*_BIN override (`pinned`) is never second-guessed.
+export async function detectFirst(bin, fallbacks, pinned = false) {
+  const found = await detectVersion(bin);
+  if (found.available || pinned) return { ...found, bin };
+  for (const b of fallbacks().filter((f) => fs.existsSync(f))) {
+    const there = await detectVersion(b);
+    if (there.available) return { ...there, bin: b };
+  }
+  return { ...found, bin };
+}
+
 // Run `bin args` and resolve with stdout, or '' on any failure. Used for model discovery.
 export function quietOutput(bin, args, timeout = 15_000) {
   return new Promise((resolve) => {

package/server/adapters/cursor.js

@@ -18,6 +18,15 @@ export default {
     return [BIN, ...(resumeId ? ['--resume', resumeId] : []), ...(model ? ['--model', model] : [])];
   },
 
+  // How to get it, shown in Settings → Agents and the picker while it isn't found (this OS's steps).
+  setup(platform = process.platform) {
+    return {
+      tip: 'Install the Cursor CLI, then run cursor-agent login. The Cursor editor doesn’t include it',
+      ...(platform === 'win32' ? {} : { command: 'curl https://cursor.com/install -fsS | bash' }),
+      url: 'https://cursor.com/cli',
+    };
+  },
+
   async detect() {
     const found = await detectVersion(BIN);
     if (!found.available) return found;

package/server/adapters/grok.js

@@ -35,6 +35,11 @@ export default {
     return [BIN, ...(resumeId ? ['--resume', resumeId] : []), ...(model ? ['--model', model] : []), ...(effort ? ['--reasoning-effort', effort] : [])];
   },
 
+  // How to get it, shown in Settings → Agents and the picker while it isn't found (this OS's steps).
+  setup() {
+    return { tip: 'Install Grok Build (grok) and sign in', url: 'https://x.ai/cli' };
+  },
+
   async detect() {
     const found = await detectVersion(BIN);
     if (!found.available) return found;

package/server/adapters/index.js

@@ -13,6 +13,7 @@
 //                                                  that conversation, leaving it as it is (/btw)
 //     permission?(tool, input, cwd): { tool, action, detail, why? }   what a live approval is about
 //     detect(): Promise<{ available, version?, error?, models? }>   models overrides the static list
+//     setup?(platform): { tip, command?, url? }    how to get it on that OS, sent while it isn't found
 //     resumeCommand({ resumeId, model, effort }): string[]   argv to continue the session interactively
 //     run({ prompt, cwd, resumeId, mode, model, effort, systemPrompt, grants, onEvent }): { stop(), done: Promise }
 //                                                  grants: `rule`s from its own blocked events the
@@ -52,6 +53,7 @@ function checked(a) {
     a.askTool !== null && a.askTool !== undefined && typeof a.askTool !== 'string' && 'askTool',
     a.approveTool !== undefined && (typeof a.approveTool !== 'string' || typeof a.permission !== 'function') && 'approveTool + permission()',
     typeof a.detect !== 'function' && 'detect()',
+    a.setup !== undefined && typeof a.setup !== 'function' && 'setup()',
     typeof a.run !== 'function' && 'run()',
     a.resumeCommand !== undefined && typeof a.resumeCommand !== 'function' && 'resumeCommand()',
   ].filter(Boolean);
@@ -74,7 +76,7 @@ export async function listAgents({ fresh = false } = {}) {
       // Only a hit is cached: a CLI installed while wisp is running shows up on the next call.
       if (!found.available) detected.delete(a.id);
       // delegates: can lead a team of subagents (needs wisp's MCP server injected).
-      return { id: a.id, name: a.name, models: a.models, efforts: a.efforts || [], delegates: a.askTool !== null, ...found };
+      return { id: a.id, name: a.name, models: a.models, efforts: a.efforts || [], delegates: a.askTool !== null, ...found, ...(!found.available && a.setup && { setup: a.setup() }) };
     }),
   );
 }

package/server/adapters/opencode.js

@@ -1,10 +1,9 @@
 // opencode adapter — drives `opencode run --format json` (one JSON event per line).
 
-import fs from 'node:fs';
 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 { ASK_TIMEOUT_MS, attachmentNote, clip, detectFirst, exitText, fileTracker, quietOutput, rel, spawnJsonl, withProtocol } from './common.js';
 import { describeCommand } from './commands.js';
 
 const exe = process.platform === 'win32' ? 'opencode.cmd' : 'opencode';
@@ -12,7 +11,8 @@ const exe = process.platform === 'win32' ? 'opencode.cmd' : 'opencode';
 // and the official install script's folder (it edits your shell profile, which an app started
 // from the Dock or a service never reads).
 export const fallbackBins = () => [path.join(toolsDir(), 'node_modules', '.bin', exe), path.join(os.homedir(), '.opencode', 'bin', process.platform === 'win32' ? 'opencode.exe' : 'opencode')];
-let BIN = process.env.WISP_OPENCODE_BIN || 'opencode';
+const DEFAULT_BIN = process.env.WISP_OPENCODE_BIN || 'opencode';
+let BIN = DEFAULT_BIN;
 // Rate-limited (the free models, mostly), `opencode run` keeps retrying and prints nothing, so
 // the task would sit at "Starting up" for good. Its error log says so: give it this long to get
 // through, then stop and tell the user what to do.
@@ -35,17 +35,14 @@ export default {
     return [BIN, ...(resumeId ? ['--session', resumeId] : []), ...(model ? ['--model', model] : [])];
   },
 
+  // How to get it, shown in Settings → Agents and the picker while it isn't found (this OS's steps).
+  setup() {
+    return { tip: 'wisp can install it here: free models, no account needed', command: 'npm i -g opencode-ai', url: 'https://opencode.ai' };
+  },
+
   async detect() {
-    let found = await detectVersion(BIN);
-    if (!found.available && !process.env.WISP_OPENCODE_BIN) {
-      for (const bin of fallbackBins().filter((b) => fs.existsSync(b))) {
-        const there = await detectVersion(bin);
-        if (!there.available) continue;
-        BIN = bin;
-        found = there;
-        break;
-      }
-    }
+    const { bin, ...found } = await detectFirst(DEFAULT_BIN, fallbackBins, !!process.env.WISP_OPENCODE_BIN);
+    BIN = bin;
     if (!found.available) return found;
     // `opencode models --verbose` prints each provider/model id followed by its JSON metadata;
     // the metadata's `variants` are the reasoning efforts `run --variant` accepts for that model.

package/server/openapi.js

@@ -304,7 +304,7 @@ export function openapi({ version, port }) {
       schemas: {
         Error: { type: 'object', properties: { error: { type: 'string' } } },
         Health: { type: 'object', properties: { ok: { type: 'boolean' }, name: { const: 'wisp' }, version: { type: 'string' }, apiVersion: { type: 'integer' }, pid: { type: 'integer' }, url: { type: 'string' } } },
-        Agent: { type: 'object', properties: { id: { type: 'string' }, name: { type: 'string' }, available: { type: 'boolean' }, version: { type: 'string' }, models: { type: 'array', items: { type: 'object' } }, efforts: { type: 'array', items: { type: 'string' } } } },
+        Agent: { type: 'object', properties: { id: { type: 'string' }, name: { type: 'string' }, available: { type: 'boolean' }, version: { type: 'string' }, models: { type: 'array', items: { type: 'object' } }, efforts: { type: 'array', items: { type: 'string' } }, setup: { type: 'object', description: 'Only while not found: how to get it on that OS', properties: { tip: { type: 'string' }, command: { type: 'string' }, url: { type: 'string' } } } } },
         Project: { type: 'object', properties: { id: { type: 'string' }, name: { type: 'string' }, path: { type: 'string' }, color: { type: 'string' } } },
         Webhook: { type: 'object', required: ['url'], properties: { url: { type: 'string', format: 'uri' }, events: { type: 'array', items: { enum: ['session.finished', 'session.waiting'] } } } },
         Launch: {

package/server/router.js

@@ -2,8 +2,9 @@
 //
 // Every harness × model × thinking level the user has is an "arm" (claude:opus:high; no level is
 // the harness's default). The goal picks the band of levels: Cheap runs low, Balanced the default
-// or medium, Best high. Within the band the levels are learned like models are, and a model's
-// record at its other levels counts half. For each kind of task (bug, ui, docs, …) wisp
+// or medium, Best high. Balanced and Best both run frontier models when you have one, so the
+// level is what tells them apart. Within the band the levels are learned like models are, and a
+// model's record at its other levels counts half. For each kind of task (bug, ui, docs, …) wisp
 // keeps a Beta(wins, losses) estimate per arm, stacked from three sources: the shipped priors
 // (./router-priors.json, from wisp-bench), the user's history on every kind of task, and the
 // history on this kind. A launch draws a chance of success from each estimate (Thompson
@@ -27,13 +28,12 @@ const PRIORS = JSON.parse(fs.readFileSync(new URL('./router-priors.json', import
 
 export const GOALS = {
   cheap: { label: 'Cheap', value: 1, hint: 'Lowest cost that still gets it done' },
-  balanced: { label: 'Balanced', value: 5, hint: 'Best result per dollar' },
-  best: { label: 'Best', value: 50, hint: 'Frontier models only; cost only breaks ties' },
+  balanced: { label: 'Balanced', value: 5, hint: 'Frontier models at default or medium thinking' },
+  best: { label: 'Best', value: 50, hint: 'Frontier models at high thinking; cost only breaks ties' },
 };
 export const TYPES = ['bug', 'feature', 'ui', 'test', 'refactor', 'docs', 'release', 'question'];
 const MINUTE_USD = 0.05; // what a minute of waiting costs you, in the utility
 const PRIOR_CAP = 4; // shipped priors count as at most this many tasks, so your own soon outweigh them
-const COLD_START = 20; // until Auto has this many of your outcomes, Balanced and Best stay on stronger tiers
 const ALL_WEIGHT = 0.5; // your history on other kinds of task counts half
 const HALF_LIFE_MS = 30 * 864e5; // models change: older outcomes fade
 const NEW_ARM_SHARE = 0.25; // how often a new arm on probation may take an exploring slot
@@ -80,6 +80,17 @@ export const levelsFor = (efforts = [], goal = 'balanced') => {
   const have = (BANDS[goal] || BANDS.balanced).filter((e) => e === '' || efforts.includes(e));
   return have.length ? have : [''];
 };
+// Some harnesses bake the level into the model id (Antigravity's gemini-4-argon-high, no separate
+// selector): there the goal picks among a model's variants the same way.
+const SUFFIX = /-(minimal|low|medium|high|xhigh|max)$/;
+const NAMED = { cheap: ['minimal', 'low'], balanced: ['medium'], best: ['high', 'xhigh', 'max'] };
+const stemOf = (k) => baseOf(k).replace(SUFFIX, '');
+function byNamedLevel(cands, goal) {
+  const want = NAMED[goal] || NAMED.balanced;
+  const named = (c) => !c.efforts.length && c.model.match(SUFFIX)?.[1];
+  const fits = new Set(cands.filter((c) => want.includes(named(c))).map((c) => stemOf(c.key)));
+  return cands.filter((c) => !named(c) || want.includes(named(c)) || !fits.has(stemOf(c.key)));
+}
 const effortLabel = (e) => ({ xhigh: 'X-High' })[e] || e.charAt(0).toUpperCase() + e.slice(1);
 
 export const armKey = (agent, model = '', effort = '') => `${agent}:${model || ''}${effort ? `:${effort}` : ''}`;
@@ -99,10 +110,12 @@ export const baseOf = (k) => {
 };
 // Versions stripped: claude-sonnet-5-5 and claude-sonnet-5-6 are one family, and a new version
 // starts from what the family already showed.
-const family = (k) => k.replace(/[-.]?\d+([.-]\d+)*/g, '');
+// A level in the id is the same model too: gemini-4-argon-high starts from what -medium showed.
+const family = (k) => k.replace(SUFFIX, '').replace(/[-.]?\d+([.-]\d+)*/g, '');
 
 // How strong a model is, roughly: 1 small/fast/free, 2 everyday, 3 frontier. Best runs on tier 3
-// only, hand-overs step up a tier, and until Auto has your own outcomes Balanced stays on tier 2+.
+// only, Balanced on the strongest tier that can run (frontier when you have one), and hand-overs
+// step up a tier.
 // The shipped priors come from a small pilot that flattered cheap models; tiers keep them honest.
 const FRONTIER_DEFAULTS = new Set(['codex:']); // a harness whose default model is its frontier one
 export function tierOf(key) {
@@ -259,34 +272,38 @@ export class Router {
   // Pick an arm. agents: listAgents() of the place it runs. goal: cheap | balanced | best, which
   // also sets the band of thinking levels (levelsFor).
   // important: no exploring. exclude: arm keys already taken (compare, hand-overs): every level of
-  // that harness · model is out. needDelegate: the lead
-  // of a team must be a harness that can delegate. rng: for tests.
+  // that harness · model is out, and every variant of a model with its level in its id.
+  // needDelegate: the lead of a team must be a harness that can delegate. rng: for tests.
   // scouted: { type, size } from the scout, which beats the keyword guess.
   // minTier: only arms at least that strong (a hand-over steps up). Arms cooling down after a usage
   // or rate limit are skipped while any other arm can run.
   // Best runs frontier models only: if any is installed and allowed, Best never steps down a tier,
   // even when they're all taken or at their limit (null then). With none installed, the strongest.
+  // Balanced runs frontier models too, whatever its record of the others (Sonnet or Haiku winning
+  // a few tasks doesn't make them the face of Auto), and steps down a tier only while every
+  // frontier model is taken or at its limit, so the task still runs.
   choose({ prompt = '', attachments = 0, agents = [], goal = 'balanced', important = false, explore = true, exclude = [], needDelegate = false, allowed = null, scouted = null, minTier = 0, rng = Math.random } = {}) {
     if (!this.synced) this.sync(agents);
+    if (!GOALS[goal]) goal = 'balanced';
     const guess = classify(prompt, { attachments });
     const type = scouted?.type || guess.type;
     const size = scouted?.size || guess.size;
-    const V = (GOALS[goal] || GOALS.balanced).value;
-    const out = new Set(exclude.map(baseOf));
+    const V = GOALS[goal].value;
+    const out = new Set(exclude.map(stemOf));
     const usable = candidates(agents, new Set(Object.keys(this.state.arms))).filter((c) => (!needDelegate || c.delegates) && (!allowed || allowed.includes(c.agent)));
     const frontierOnly = goal === 'best' && usable.some((c) => tierOf(c.key) >= 3);
-    let arms = usable
-      .filter((c) => !out.has(c.key) && (!frontierOnly || tierOf(c.key) >= 3))
+    let arms = byNamedLevel(usable.filter((c) => !out.has(stemOf(c.key))), goal)
+      .filter((c) => !frontierOnly || tierOf(c.key) >= 3)
       .flatMap((c) => levelsFor(c.efforts, goal).map((effort) => ({ ...c, key: armKey(c.agent, c.model, effort), effort, label: `${c.label}${effort ? ` · ${effortLabel(effort)}` : ''}`, base: c.key })))
       .map((c) => ({ ...c, est: this.estimate(type, c.key), state: this.state.arms[c.base]?.state || 'new' }));
     if (!arms.length) return null;
     const free = arms.filter((x) => !this.cooling(x.key));
     if (!free.length) return null; // everything allowed is at its limit: nothing to route to now
     arms = free;
-    // Cold start: until there are enough of your own outcomes, lean to quality (the shipped priors
-    // are thin). Cheap is left alone: that goal asked for cheap.
-    const cold = this.learned() < COLD_START;
-    const floorTier = Math.max(minTier, goal === 'best' ? 3 : cold && goal !== 'cheap' ? 2 : 0);
+    // Balanced and Best run on the strongest tier that can run now, whatever the record of the
+    // weaker ones. Cheap is left alone: that goal asked for cheap.
+    const top = Math.max(...arms.map((x) => tierOf(x.key)));
+    const floorTier = Math.max(minTier, goal === 'cheap' ? 0 : top);
     for (let t = floorTier; t > 0; t--) {
       const strong = arms.filter((x) => tierOf(x.key) >= t);
       if (strong.length) {
@@ -323,7 +340,7 @@ export class Router {
       key: pick.key,
       label: pick.label,
       route: {
-        goal: GOALS[goal] ? goal : 'balanced',
+        goal,
         type,
         size,
         key: pick.key,
@@ -336,7 +353,6 @@ export class Router {
         explored: byMean[0].key !== pick.key,
         trying: pick.state === 'new',
         tier: tierOf(pick.key),
-        ...(cold && goal !== 'cheap' && goal !== 'best' && { coldStart: true }),
         propensity: round(hits / 200),
         alternatives: byMean.filter((x) => x.key !== pick.key).slice(0, 3).map((x) => ({ key: x.key, label: x.label, chance: round(x.est.mean), usd: round(x.est.usd) })),
         at: this.now(),
@@ -453,7 +469,6 @@ export class Router {
     return {
       priors: { version: PRIORS.version, source: PRIORS.source },
       learned: routes.filter((r) => r.r !== null).length,
-      coldStart: { needed: COLD_START, have: this.learned() },
       routed: routes.length,
       arms,
       recent: routes.sort((p, q) => q.at - p.at).slice(0, 30).map((r) => ({ id: r.id, key: r.key, label: r.label, type: r.type, goal: r.goal, chance: r.chance, r: r.r, explored: r.explored, trying: r.trying, at: r.at, signals: r.signals })),

package/web/css/feed.css

@@ -34,6 +34,9 @@
 .f-group h4.toggle-done { width: fit-content; min-height: 24px; margin-left: -4px; padding: 0 8px; border-radius: 6px; transition: background 0.15s, color 0.15s; }
 .f-group h4.toggle-done:hover { background: var(--bg-2); }
 .f-list { display: flex; flex-direction: column; gap: 6px; }
+/* The end of a paged Done / Archived list: scrolling near it adds the next page, clicking does too. */
+.f-more { display: block; margin: 10px auto 0; color: var(--faint); font-weight: 400; }
+.f-more:hover { color: var(--ink-2); }
 .feed-empty { padding: 48px 0; text-align: center; color: var(--faint); font-size: 13.5px; }
 
 /* one feed item — a row that expands in place */

package/web/css/launcher.css

@@ -195,10 +195,11 @@ body:has(.launcher.docked:is(:focus-within, :has(.open))) .to-top { display: non
 .pk-side { display: flex; flex-direction: column; gap: 2px; padding: 6px; overflow-y: auto; background: var(--surface-2); border-right: 1px solid var(--line); }
 .pk-head, .pk-ghead { padding: 8px 10px 5px; font-size: 11px; font-weight: 600; letter-spacing: 0.04em; text-transform: uppercase; color: var(--faint); }
 .pk-h, .pk-m { display: flex; align-items: center; gap: 10px; width: 100%; padding: 7px 9px; border-radius: 9px; text-align: left; outline: 0; color: var(--ink-2); transition: background 0.12s; }
-.pk-h:hover:not(:disabled), .pk-m:hover, .pk-m:focus-visible { background: var(--bg-2); }
+.pk-h:hover, .pk-m:hover, .pk-m:focus-visible { background: var(--bg-2); }
 .pk-h:focus-visible { box-shadow: inset 0 0 0 1px var(--line-2); }
 .pk-h.on { background: var(--surface); box-shadow: 0 0 0 1px var(--line-2), var(--shadow-1); }
-.pk-h.off { opacity: 0.45; cursor: not-allowed; }
+.pk-h.off .pk-logo, .pk-h.off .pk-text { opacity: 0.5; }
+.pk-h.off.on .pk-logo, .pk-h.off.on .pk-text { opacity: 0.8; }
 .pk-logo { display: grid; place-items: center; flex: none; width: 28px; height: 28px; border-radius: 8px; background: var(--surface); border: 1px solid var(--line); color: var(--ink); }
 .pk-h.on .pk-logo { background: var(--bg-2); border-color: transparent; }
 .pk-logo > * { display: block; width: 15px; height: 15px; }
@@ -224,6 +225,21 @@ body:has(.launcher.docked:is(:focus-within, :has(.open))) .to-top { display: non
 .pk-seg button:focus-visible { box-shadow: inset 0 0 0 1px var(--accent); }
 .pk-seg button.on { background: var(--surface); color: var(--accent-ink); font-weight: 500; box-shadow: var(--shadow-1); }
 .pk-empty { padding: 30px 10px; text-align: center; font-size: 13px; color: var(--muted); }
+/* a harness that isn't installed: its setup steps instead of models */
+.pk-setup { display: flex; flex-direction: column; align-items: flex-start; gap: 8px; padding: 12px 8px; }
+.pk-setup b { font-weight: 600; font-size: 13.5px; color: var(--ink); }
+.pk-setup p { margin: 0; font-size: 12.5px; line-height: 1.5; color: var(--muted); }
+.pk-setup-actions { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 2px; }
+.pk-recheck.busy { cursor: progress; }
+.pk-recheck.busy .i { animation: spin 0.8s linear infinite reverse; }
+/* a copyable install command (picker and Settings → Agents) */
+.setup-cmd { display: inline-flex; align-items: center; gap: 7px; max-width: 100%; height: 28px; padding: 0 8px; border: 1px solid var(--line); border-radius: 8px; background: var(--bg-2); color: var(--ink-2); font: 12px/1 var(--mono); cursor: copy; transition: border-color 0.12s, color 0.12s; }
+.setup-cmd:hover { border-color: var(--line-2); color: var(--ink); }
+.setup-cmd .p { color: var(--faint); }
+button.setup-cmd code { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font: inherit; background: none; padding: 0; }
+.setup-cmd .i { flex: none; width: 13px; height: 13px; color: var(--muted); }
+.setup-cmd.copied .i { color: var(--good); }
+.sx-text .setup-cmd { display: flex; width: fit-content; margin-top: 6px; }
 @media (max-width: 560px) {
   .picker { grid-template-columns: 1fr; grid-template-rows: auto 1fr; }
   .pk-side { flex-direction: row; overflow-x: auto; border-right: 0; border-bottom: 1px solid var(--line); }

package/web/css/modals.css

@@ -132,6 +132,9 @@
   .sx-main { padding: 16px; }
   .sx-ctl .input { width: 180px; }
   .sx-usage { grid-template-columns: repeat(2, 1fr); }
+  /* a harness that isn't found: its setup tip gets the full width, its buttons go underneath */
+  .sx-agents .sx-row:has(.sx-state.bad) { flex-wrap: wrap; row-gap: 6px; }
+  .sx-agents .sx-row:has(.sx-state.bad) .sx-text { flex-basis: 100%; }
 }
 
 /* memory: what the background retros learned */

package/web/js/features/auto.js

@@ -25,7 +25,7 @@ export async function openRouter({ host } = {}) {
     if (!r || !node.isConnected) return;
     const arms = r.arms.filter((a) => a.state !== 'gone' || a.n);
     $('.ro-body', node).innerHTML = `
-      <p class="hint">For each task Auto estimates every harness · model · thinking level’s chance of doing it well, from wisp-bench (${esc(r.priors.version)}) and then more and more from your own tasks: merged PRs, 👍 / 👎, rollbacks, follow-ups and how the run ended. It picks the best value for your goal (<b>${esc(AUTO_GOALS.find((g) => g.id === r.goal)?.label || '')}</b>), which also sets how hard it thinks: Cheap low, Balanced default or medium, Best high. Best runs frontier models only (Opus, not Sonnet or Haiku). Now and then it tries an alternative so the estimates stay honest.${r.coldStart && r.coldStart.have < r.coldStart.needed ? ` Until it has ${r.coldStart.needed} of your own outcomes (${r.coldStart.have} so far), Balanced uses everyday and frontier models only.` : ''}</p>
+      <p class="hint">For each task Auto estimates every harness · model · thinking level’s chance of doing it well, from wisp-bench (${esc(r.priors.version)}) and then more and more from your own tasks: merged PRs, 👍 / 👎, rollbacks, follow-ups and how the run ended. It picks the best value for your goal (<b>${esc(AUTO_GOALS.find((g) => g.id === r.goal)?.label || '')}</b>), which also sets how hard it thinks: Cheap low, Balanced default or medium, Best high. Balanced and Best run frontier models (Opus, not Sonnet or Haiku) when you have one; Balanced steps down to an everyday model only while every frontier one is at its limit. Now and then it tries an alternative so the estimates stay honest.</p>
       <h4>Harness · model · thinking</h4>
       <table class="us-table ro-table"><thead><tr><th></th><th>Works</th><th>Your tasks</th><th>~Cost</th><th>~Time</th><th></th></tr></thead><tbody>${arms
         .map((a) => {

package/web/js/features/feed.js

@@ -66,13 +66,47 @@ function groups() {
   return { needs, working, done, archived };
 }
 
+// Done and Archived can hold hundreds of tasks: they show a page of cards and add the next
+// page as the user scrolls to the end of the list. The headings count every one.
+const PAGE = 60;
+const page = { secDone: PAGE, secArchived: PAGE };
+const moreObserver = new IntersectionObserver(
+  (entries) => {
+    for (const e of entries) {
+      if (!e.isIntersecting || e.target.hidden) continue;
+      page[e.target.closest('.f-group').id] += PAGE;
+      renderFeed();
+      // Still in view after a short page: observing again reports it again, so the next page comes.
+      moreObserver.unobserve(e.target);
+      moreObserver.observe(e.target);
+    }
+  },
+  { root: stage, rootMargin: '0px 0px 800px 0px' },
+);
+for (const id of Object.keys(page)) {
+  const more = el(`<button class="f-more link xs" hidden></button>`);
+  more.addEventListener('click', () => {
+    page[id] += PAGE;
+    renderFeed();
+  });
+  $(`#${id}`).append(more);
+  moreObserver.observe(more);
+}
+
 export function renderFeed() {
   const { needs, working, done, archived } = groups();
   const place = (sec, list, show = true) => {
     const box = $('.f-list', sec);
     sec.hidden = !list.length;
     $('h4 .n', sec).textContent = list.length || '';
-    const want = show ? list : [];
+    const cap = page[sec.id] ?? list.length;
+    const want = show ? list.slice(0, cap) : [];
+    const more = $('.f-more', sec);
+    if (more) {
+      const left = show ? list.length - want.length : 0;
+      more.hidden = left <= 0;
+      more.textContent = `Show ${Math.min(left, PAGE)} more · ${left} left`;
+    }
     want.forEach((s, i) => {
       const { card } = s.runs ? taskItem(s) : item(s);
       // Only touch the DOM when the order actually changed: moving a node
@@ -83,9 +117,9 @@ export function renderFeed() {
   };
   place($('#secNeeds'), needs);
   place($('#secWorking'), working);
-  place($('#secDone'), done.slice(0, 60), S.showDone);
+  place($('#secDone'), done, S.showDone);
   $('#secDone').classList.toggle('collapsed', !S.showDone);
-  place($('#secArchived'), archived.slice(0, 60), S.showArchived);
+  place($('#secArchived'), archived, S.showArchived);
   $('#secArchived').classList.toggle('collapsed', !S.showArchived);
 
   // Drop nodes for sessions that are gone or filtered out of the feed entirely.
@@ -399,6 +433,13 @@ export function reveal(id) {
     save('wisp.filter', S.filter);
     renderLaunchChips();
   }
+  // A card further down than the pages shown so far: show pages up to it.
+  const sec = { done: 'secDone', archived: 'secArchived' }[sectionOf(s)];
+  if (sec) {
+    const { done, archived } = groups();
+    const at = (sec === 'secDone' ? done : archived).findIndex((t) => (t.runs || [t]).some((r) => r.id === id));
+    if (at >= page[sec]) page[sec] = Math.ceil((at + 1) / PAGE) * PAGE;
+  }
   renderFeed();
   setFocus(id, { scroll: false });
   if (S.open.has(id)) S.nodes.get(id)?.card.scrollIntoView({ block: 'start', behavior: 'smooth' });

package/web/js/features/runner-picker.js

@@ -1,10 +1,14 @@
 import { esc } from '../md.js';
+import { api } from '../core/api.js';
+import * as bus from '../core/bus.js';
 import { $, $$, el, icon } from '../core/dom.js';
-import { S } from '../core/state.js';
+import { S, setAgents } from '../core/state.js';
 import { popover } from '../ui/popover.js';
+import { toast, toastError } from '../ui/toast.js';
 import { placeName } from './places.js';
 import { AUTO, AUTO_GOALS, effortLabel, effortsFor, harnessesAt, harnessLogo } from './runners.js';
 import { openSettings } from './settings.js';
+import { copySetupCommand, INSTALLABLE, installHarness, setupCommand, setupDocs, setupTip, setupTitle } from './setup.js';
 
 // One popover for all three choices: harnesses on the left, the focused harness's models on the
 // right, and its thinking levels underneath. Clicking (or arrowing to) a harness previews its
@@ -14,9 +18,10 @@ export function runnerPicker(anchor, { agent, model, effort, savedModel, savedEf
   const open = $('.picker');
   if (open) return open.close();
   const agents = places ? harnessesAt(places, { auto }) : auto ? [AUTO, ...S.agents] : S.agents;
+  const remote = places?.length > 1 || !!places?.[0];
   const sub = (a) => {
     if (a.id === 'auto') return 'Picks harness and model for you';
-    if (!a.available) return places?.length > 1 || places?.[0] ? 'Not installed there' : 'Not installed';
+    if (!a.available) return remote ? 'Not installed there' : 'Not installed';
     const models = (a.models || []).length > 1 ? `${a.models.length - 1} models` : 'Default model';
     return a.missing?.length ? `Not on ${a.missing.map(placeName).join(', ')}` : models;
   };
@@ -35,7 +40,7 @@ export function runnerPicker(anchor, { agent, model, effort, savedModel, savedEf
         <div class="pk-head">Harness</div>
         ${agents
           .map(
-            (a) => `<button class="pk-h${a.available ? '' : ' off'}" role="option" data-id="${esc(a.id)}" ${a.available ? '' : 'disabled'}>
+            (a) => `<button class="pk-h${a.available ? '' : ' off'}" role="option" data-id="${esc(a.id)}" ${a.available ? '' : `aria-disabled="true" title="${esc(setupTitle(a))}"`}>
               <span class="pk-logo">${harnessLogo(a.id)}</span>
               <span class="pk-text"><b>${esc(a.name)}</b><small${a.missing?.length ? ' class="warn"' : ''}>${esc(sub(a))}</small></span>
               ${a.id === agent ? '<span class="pk-dot" title="In use"></span>' : ''}
@@ -86,6 +91,7 @@ export function runnerPicker(anchor, { agent, model, effort, savedModel, savedEf
     const models = a?.models || [{ id: '', label: 'Default' }];
     const current = focusAgent === agent ? model : savedModel(focusAgent);
     input.placeholder = `Search ${a?.name || ''} models`;
+    if (a && !a.available) return paintSetup(a);
     if (a?.id === 'auto') {
       list.innerHTML = `<div class="pk-group"><div class="pk-ghead">Goal</div>${AUTO_GOALS.map((g) => `<button class="pk-m${g.id === current ? ' on' : ''}" role="option" aria-selected="${g.id === current}" data-id="${g.id}"><span class="pk-text"><b>${g.label}</b><small>${g.hint}</small></span>${icon('check', 'pk-check')}</button>`).join('')}</div><p class="pk-note">wisp picks the harness and model for each task from what worked before, and learns from how it went. ${'<a href="#" class="pk-auto-more">How Auto picks</a>'}</p><div class="pk-empty" hidden>No models match</div>`;
       $('.pk-search', node).hidden = true;
@@ -120,6 +126,51 @@ export function runnerPicker(anchor, { agent, model, effort, savedModel, savedEf
     filter();
     paintEffort();
   };
+  // A harness that isn't installed: how to get it, in place of its models.
+  const paintSetup = (a) => {
+    $('.pk-search', node).hidden = true;
+    seg.hidden = true;
+    const canInstall = !remote && INSTALLABLE.has(a.id);
+    list.innerHTML = `<div class="pk-setup">
+      <b>${esc(a.name)} isn’t installed${remote ? ' there' : ''}</b>
+      <p>${esc(setupTip(a))}</p>
+      ${a.setup?.command && !canInstall ? setupCommand(a.setup.command) : ''}
+      <div class="pk-setup-actions">
+        ${canInstall ? `<button class="primary sm pk-install">Install ${esc(a.name)}</button>` : ''}
+        ${setupDocs(a)}
+        <button class="ghost sm pk-recheck" title="Look for harnesses again">${icon('replay')}<span>Re-check</span></button>
+      </div>
+    </div>`;
+    const c = $('.setup-cmd', list);
+    if (c) c.onclick = () => {
+      copySetupCommand(c);
+    };
+    const inst = $('.pk-install', list);
+    if (inst) inst.onclick = () => {
+      close();
+      installHarness(a.id);
+    };
+    $('.pk-recheck', list).onclick = async (e) => {
+      const btn = e.currentTarget;
+      btn.disabled = true;
+      btn.classList.add('busy');
+      try {
+        setAgents(await api('/agents/recheck', { method: 'POST', body: {} }));
+        $('#launcher')?.placesChanged?.();
+        bus.emit('agents');
+        const found = S.agents.find((x) => x.id === a.id)?.available;
+        if (found) {
+          close();
+          toast(`<b>${esc(a.name)}</b> found`);
+        } else if (node.isConnected) toast(`Still no ${esc(a.name)}. Install it, sign in, then re-check.`);
+      } catch (err) {
+        toastError(err);
+      } finally {
+        btn.disabled = false;
+        btn.classList.remove('busy');
+      }
+    };
+  };
   const rows = () => $$('.pk-m', list).filter((b) => !b.hidden);
   const filter = () => {
     const q = input.value.trim().toLowerCase();
@@ -145,7 +196,7 @@ export function runnerPicker(anchor, { agent, model, effort, savedModel, savedEf
   // Picking a harness applies it straight away with the model and level it shows as selected.
   const useAgent = (id) => {
     preview(id);
-    if (id === agent) return;
+    if (id === agent || !agents.find((x) => x.id === id)?.available) return;
     markInUse(id);
     agent = id;
     model = savedModel(id);
@@ -171,7 +222,6 @@ export function runnerPicker(anchor, { agent, model, effort, savedModel, savedEf
   };
   const keys = (e) => {
     const inSide = sideRows.includes(document.activeElement);
-    const live = sideRows.filter((b) => !b.disabled);
     const segBtns = $$('button', seg);
     const inSeg = segBtns.includes(document.activeElement);
     // Tab hops from the model list to the thinking levels and back; anywhere else it leaves.
@@ -191,7 +241,7 @@ export function runnerPicker(anchor, { agent, model, effort, savedModel, savedEf
       e.preventDefault();
       e.stopPropagation();
       const d = e.key === 'ArrowDown' ? 1 : -1;
-      if (inSide) preview(step(live, d)?.dataset.id);
+      if (inSide) preview(step(sideRows, d)?.dataset.id); // not-installed ones too: they show how to get them
       else step(rows(), d);
     } else if (e.key === 'ArrowLeft' && document.activeElement !== input) {
       e.preventDefault();

package/web/js/features/runners.js

@@ -21,9 +21,9 @@ export const agentName = (id) => S.agents.find((a) => a.id === id)?.name || (id
 // level per task. Its "models" are the goal it optimises for, which also sets the level band, so
 // there are no thinking levels to pick here.
 export const AUTO_GOALS = [
-  { id: 'balanced', label: 'Balanced', hint: 'Best result per dollar · default or medium thinking' },
+  { id: 'balanced', label: 'Balanced', hint: 'Frontier models · default or medium thinking' },
   { id: 'cheap', label: 'Cheap', hint: 'Lowest cost that still gets it done · low thinking' },
-  { id: 'best', label: 'Best', hint: 'Best result; cost only breaks ties · high thinking' },
+  { id: 'best', label: 'Best', hint: 'Frontier models · high thinking; cost only breaks ties' },
 ];
 export const AUTO = { id: 'auto', name: 'Auto', available: true, delegates: true, models: AUTO_GOALS, efforts: [], hint: 'wisp picks the harness, model and thinking level from what worked before' };
 

package/web/js/features/settings.js

@@ -19,7 +19,7 @@ import { notifyOn } from './notify.js';
 import { openPhone, phoneSummary } from './phone.js';
 import { machinesSummary } from './places.js';
 import { AUTO_GOALS, harnessLogo } from './runners.js';
-import { INSTALLABLE, installHarness, isInstalling } from './setup.js';
+import { copySetupCommand, INSTALLABLE, installHarness, isInstalling, setupCommand, setupDocs, setupTip } from './setup.js';
 import { clearPicks } from './transcript.js';
 import { repaintViews } from './turns.js';
 import { openUsage } from './usage.js';
@@ -156,11 +156,13 @@ export function openSettings(opts) {
         // opencode: wisp can install it (free models, no account), so its row offers that.
         const canInstall = !a.available && INSTALLABLE.has(a.id);
         const busy = isInstalling(a.id);
+        // Not found: this OS's setup tip, with the command to copy unless wisp installs it itself.
         const desc = a.available
-          ? [a.version, n && `${n} model${n === 1 ? '' : 's'}`].filter(Boolean).join(' · ')
-          : busy ? 'Installing into ~/.wisp/tools…' : canInstall ? 'Install it here: free models, no account needed' : `Install the ${a.name} CLI and sign in, then re-check`;
+          ? esc([a.version, n && `${n} model${n === 1 ? '' : 's'}`].filter(Boolean).join(' · '))
+          : busy ? 'Installing into ~/.wisp/tools…' : `${esc(setupTip(a))}${a.setup?.command && !canInstall ? setupCommand(a.setup.command) : ''}`;
         const install = canInstall ? `<button class="ghost sm" data-install="${esc(a.id)}" ${busy ? 'disabled' : ''}>${busy ? 'Installing…' : 'Install'}</button>` : '';
-        return row(`<span class="model-logo">${harnessLogo(a.id)}</span>${esc(a.name)}`, esc(desc), `${install}<span class="sx-state ${a.available ? 'ok' : 'bad'}" ${a.error ? `title="${esc(a.error)}"` : ''}><i class="dot ${a.available ? 'ok' : 'bad'}"></i>${a.available ? 'Ready' : 'Not found'}</span>`);
+        const docs = a.available ? '' : setupDocs(a);
+        return row(`<span class="model-logo">${harnessLogo(a.id)}</span>${esc(a.name)}`, desc, `${install}${docs}<span class="sx-state ${a.available ? 'ok' : 'bad'}" ${a.error ? `title="${esc(a.error)}"` : ''}><i class="dot ${a.available ? 'ok' : 'bad'}"></i>${a.available ? 'Ready' : 'Not found'}</span>`);
       }).join('')
       : '<div class="sx-row"><div class="it-loading"><span class="orb tiny"></span>Looking for harnesses…</div></div>';
     const missing = S.agents.filter((a) => !a.available).length;
@@ -174,6 +176,8 @@ export function openSettings(opts) {
   bus.on('agents', paintAgents, { node });
   bus.on('install', paintAgents, { node });
   $('.sx-agents', node).onclick = (e) => {
+    const c = e.target.closest('[data-copy]');
+    if (c) return copySetupCommand(c);
     const b = e.target.closest('[data-install]');
     if (b) installHarness(b.dataset.install);
   };

package/web/js/features/setup.js

@@ -3,6 +3,7 @@
 // Settings → Agents uses the same install.
 
 import { esc } from '../md.js';
+import { copy } from '../blocks.js';
 import { api } from '../core/api.js';
 import * as bus from '../core/bus.js';
 import { $, icon } from '../core/dom.js';
@@ -13,6 +14,17 @@ import { harnessLogo } from './runners.js';
 // What wisp can install itself (server/services/install.js).
 export const INSTALLABLE = new Set(['opencode']);
 
+// A harness that isn't found: how to get it, from the server for that computer's OS
+// (adapter setup()). As a tooltip, as a copyable command, and as a docs link.
+export const setupTip = (a) => a.setup?.tip || `Install the ${a.name} CLI and sign in, then re-check`;
+export const setupTitle = (a) => [setupTip(a), a.setup?.command && `$ ${a.setup.command}`].filter(Boolean).join('\n');
+export const setupCommand = (cmd) => `<button type="button" class="setup-cmd" data-copy="${esc(cmd)}" title="Copy"><span class="p">$</span><code>${esc(cmd)}</code>${icon('copy')}</button>`;
+export const setupDocs = (a, cls = 'ghost sm') => (a.setup?.url ? `<a class="${cls}" href="${esc(a.setup.url)}" target="_blank" rel="noopener" title="${esc(a.name)} install guide">${icon('external')}<span>Docs</span></a>` : '');
+export function copySetupCommand(btn) {
+  copy(btn.dataset.copy, btn);
+  toast('Copied. Run it in a terminal, sign in, then Re-check');
+}
+
 let installing = null; // the running install's id
 let failed = ''; // the last install's error, shown in the strip until the next try
 
@@ -71,7 +83,7 @@ export function renderSetup() {
       setAgents(await api('/agents/recheck', { method: 'POST', body: {} }));
       $('#launcher')?.placesChanged?.();
       bus.emit('agents');
-      if (needsSetup()) toast('Still no harness found. Install opencode here, or Claude Code, Codex, Cursor… yourself.');
+      if (needsSetup()) toast('Still no harness found. Install opencode here, or Claude Code, Codex, Cursor… yourself. The ChatGPT app (Codex) or the Claude app (its Code tab) works too.');
     } catch (err) {
       toastError(err);
     } finally {