wisp-agents 0.18.0 → 0.21.0

package/server/pipeline.js

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

package/server/quick.js

@@ -0,0 +1,76 @@
+// One quick question to a cheap model, through whichever harness is installed: the scout and the
+// judge use it. Read-only (plan mode), no wisp protocol, a hard time limit, and the reply's JSON.
+
+import { adapters } from './adapters/index.js';
+
+// Cheapest first: what the scout and judge run on when it's installed.
+const CHEAP = [
+  ['claude', 'haiku'],
+  ['antigravity', 'gemini-3.8-flash-low'],
+  ['codex', ''],
+  ['opencode', ''],
+  ['grok', ''],
+  ['claude', ''],
+];
+
+export function cheapest(agents) {
+  for (const [id, model] of CHEAP) {
+    const a = agents.find((x) => x.id === id && x.available);
+    if (a && (!model || (a.models || []).some((m) => m.id === model))) return { agent: id, model };
+  }
+  return null;
+}
+
+// Resolves with the parsed JSON object from the reply, or null (no harness, timeout, no JSON).
+export function askJson({ agents, prompt, cwd, timeoutMs = 90_000, pick = cheapest(agents) }) {
+  if (!pick || !adapters[pick.agent]) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    let text = '';
+    let handle;
+    try {
+      handle = adapters[pick.agent].run({
+        prompt,
+        cwd,
+        mode: 'plan',
+        model: pick.model,
+        effort: '',
+        systemPrompt: 'You are a helper inside wisp. Answer with one JSON object and nothing else.',
+        attachments: [],
+        onEvent: (e) => {
+          if (e.type === 'result') text = e.isError ? '' : e.text || '';
+        },
+      });
+    } catch {
+      return resolve(null);
+    }
+    const timer = setTimeout(() => handle.stop(), timeoutMs);
+    handle.done.then(() => {
+      clearTimeout(timer);
+      resolve(readJson(text));
+    });
+  });
+}
+
+export function readJson(text = '') {
+  const s = String(text);
+  for (let i = s.indexOf('{'); i >= 0; i = s.indexOf('{', i + 1)) {
+    let depth = 0;
+    let inStr = false;
+    for (let j = i; j < s.length; j++) {
+      const c = s[j];
+      if (inStr) {
+        if (c === '\\') j++;
+        else if (c === '"') inStr = false;
+      } else if (c === '"') inStr = true;
+      else if (c === '{') depth++;
+      else if (c === '}' && !--depth) {
+        try {
+          return JSON.parse(s.slice(i, j + 1));
+        } catch {
+          break;
+        }
+      }
+    }
+  }
+  return null;
+}

package/server/router.js

@@ -1,6 +1,9 @@
-// Auto: wisp picks the harness and model for a task, and learns from how it went.
+// Auto: wisp picks the harness, model and thinking level for a task, and learns from how it went.
 //
-// Every harness × model the user has is an "arm". For each kind of task (bug, ui, docs, …) wisp
+// 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
 // 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
@@ -25,14 +28,16 @@ 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: 'Best result; cost only breaks ties' },
+  best: { label: 'Best', value: 50, hint: 'Frontier models only; 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 = 8; // shipped priors count as at most this many tasks, so your own soon outweigh them
+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
+const LEVEL_WEIGHT = 0.5; // the same model's record at its other thinking levels counts half
 const MAX_ROUTES = 2000;
 
 // --- task features ---------------------------------------------------------------------------
@@ -58,15 +63,78 @@ export function classify(prompt = '', { attachments = 0 } = {}) {
 
 // --- arms ------------------------------------------------------------------------------------
 
-export const armKey = (agent, model = '') => `${agent}:${model || ''}`;
-const splitKey = (k) => {
+// Thinking levels, by how hard they think, against the harness's default (''): a shift in the
+// chance of success and multipliers on cost and time. Only a starting guess; outcomes take over.
+export const EFFORTS = {
+  minimal: { chance: -0.1, usd: 0.55, min: 0.65 },
+  low: { chance: -0.04, usd: 0.6, min: 0.7 },
+  medium: { chance: -0.01, usd: 0.85, min: 0.85 },
+  '': { chance: 0, usd: 1, min: 1 },
+  high: { chance: 0.02, usd: 1.3, min: 1.3 },
+  xhigh: { chance: 0.02, usd: 1.7, min: 1.6 },
+  max: { chance: 0.03, usd: 2.2, min: 2 },
+};
+// The levels each goal may run at, where the harness has them; none of them → the default.
+const BANDS = { cheap: ['minimal', 'low'], balanced: ['', 'medium'], best: ['high', 'xhigh'] };
+export const levelsFor = (efforts = [], goal = 'balanced') => {
+  const have = (BANDS[goal] || BANDS.balanced).filter((e) => e === '' || efforts.includes(e));
+  return have.length ? have : [''];
+};
+const effortLabel = (e) => ({ xhigh: 'X-High' })[e] || e.charAt(0).toUpperCase() + e.slice(1);
+
+export const armKey = (agent, model = '', effort = '') => `${agent}:${model || ''}${effort ? `:${effort}` : ''}`;
+// agent:model[:effort]. A trailing segment is a level only if it's one wisp knows, so a model id
+// with a colon in it (ollama's llama3:8b) stays whole.
+export const splitKey = (k) => {
   const i = k.indexOf(':');
-  return { agent: k.slice(0, i), model: k.slice(i + 1) };
+  const rest = k.slice(i + 1);
+  const j = rest.lastIndexOf(':');
+  const effort = j >= 0 && rest.slice(j + 1) && Object.hasOwn(EFFORTS, rest.slice(j + 1)) ? rest.slice(j + 1) : '';
+  return { agent: k.slice(0, i), model: effort ? rest.slice(0, j) : rest, effort };
+};
+// The harness · model an arm runs on, whatever its level: probation, cooling and compare go by it.
+export const baseOf = (k) => {
+  const { agent, model } = splitKey(k);
+  return armKey(agent, model);
 };
 // 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, '');
 
+// 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+.
+// 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) {
+  const { agent, model } = splitKey(key);
+  const m = model.toLowerCase();
+  // Whole name segments only: "gemini" is not "mini".
+  const seg = m.split(/[-/.:_]/);
+  if (seg.some((x) => ['haiku', 'flash', 'mini', 'nano', 'lite', 'small', 'free', 'fast', 'low'].includes(x))) return 1;
+  if (seg.some((x) => ['opus', 'argon', 'ultra', 'pro', 'xhigh', 'high', 'max'].includes(x)) || FRONTIER_DEFAULTS.has(key) || (agent === 'grok' && /^grok-\d/.test(m))) return 3;
+  return 2;
+}
+
+// An error that says the harness can't run right now (a usage limit, a rate limit, no credit),
+// not that the model got the task wrong. Returns { scope: 'agent' | 'arm', ms } or null.
+export function infraError(text = '') {
+  const t = String(text);
+  if (/session limit|usage limit|limit reached|resets \d|quota|exceeded your|insufficient (credit|balance|quota)|balance exhausted|payment required|\b402\b|billing/i.test(t)) return { scope: 'agent', ms: resetIn(t) ?? 60 * 60_000 };
+  if (/rate[- ]?limit|too many requests|\b429\b|overloaded|\b529\b|try again in a few minutes/i.test(t)) return { scope: 'arm', ms: 10 * 60_000 };
+  return null;
+}
+// "resets 9pm" / "resets at 21:00" → ms until then (today, else tomorrow), capped at 6 h.
+function resetIn(t) {
+  const m = t.match(/resets?(?: at)? (\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
+  if (!m) return null;
+  let h = Number(m[1]) % 12 + (/pm/i.test(m[3] || '') ? 12 : 0);
+  if (!m[3]) h = Number(m[1]);
+  const at = new Date();
+  at.setHours(h, Number(m[2] || 0), 0, 0);
+  if (at <= new Date()) at.setDate(at.getDate() + 1);
+  return Math.min(6 * 3600_000, at - Date.now() + 60_000);
+}
+
 // The arms wisp may route to, from listAgents(): each harness's default model, the models the
 // priors know, models with history here, and new models in a known family (on probation).
 function candidates(agents, known) {
@@ -77,7 +145,8 @@ function candidates(agents, known) {
     for (const id of models) {
       const k = armKey(a.id, id);
       if (id === '' || PRIORS.arms[k] || known.has(k) || [...known, ...Object.keys(PRIORS.arms)].some((x) => family(x) === family(k) && x !== k && x.startsWith(`${a.id}:`))) {
-        out.push({ key: k, agent: a.id, model: id, label: `${a.name}${id ? ` · ${(a.models || []).find((m) => m.id === id)?.label || id}` : ''}`, delegates: a.delegates !== false });
+        const m = (a.models || []).find((x) => x.id === id);
+        out.push({ key: k, agent: a.id, model: id, label: `${a.name}${id ? ` · ${m?.label || id}` : ''}`, efforts: m?.efforts ?? a.efforts ?? [], delegates: a.delegates !== false });
       }
     }
   }
@@ -128,6 +197,15 @@ export class Router {
   }
 
   #prior(k) {
+    const { agent, model, effort } = splitKey(k);
+    if (effort) {
+      // A level starts from its model's record, shifted by how hard it thinks.
+      const base = this.#prior(armKey(agent, model)) || { a: 1, b: 1 };
+      const e = EFFORTS[effort];
+      const n = base.a + base.b;
+      const mean = Math.min(0.95, Math.max(0.05, base.a / n + e.chance));
+      return { ...base, a: mean * n, b: (1 - mean) * n, usd: (base.usd ?? 0.3) * e.usd, min: (base.min ?? 5) * e.min };
+    }
     const p = PRIORS.arms[k];
     if (p) return p;
     // A new version inherits its family's record, with less weight.
@@ -147,32 +225,75 @@ export class Router {
     return { a: s.a * f, b: s.b * f, n: s.n, usd: s.usdN ? s.usd / s.usdN : null, ms: s.n ? s.ms / s.n : null };
   }
 
+  // The same model at its other thinking levels, on this kind of task.
+  #levels(type, key) {
+    const base = baseOf(key);
+    const out = { a: 0, b: 0 };
+    for (const sk of Object.keys(this.state.stats)) {
+      const i = sk.indexOf('|');
+      const k = sk.slice(i + 1);
+      if (sk.slice(0, i) !== type || k === key || baseOf(k) !== base) continue;
+      const c = this.#counts(type, k);
+      out.a += c.a;
+      out.b += c.b;
+    }
+    return out;
+  }
+
   // Beta posterior for an arm on a kind of task, plus what it usually costs.
   estimate(type, key) {
     const prior = this.#prior(key) || { a: 1, b: 1 };
     const scale = Math.min(1, PRIOR_CAP / Math.max(1, prior.a + prior.b));
     const mine = this.#counts(type, key);
     const all = this.#counts('*', key);
-    const a = 1 + prior.a * scale + (all.a - mine.a) * ALL_WEIGHT + mine.a;
-    const b = 1 + prior.b * scale + (all.b - mine.b) * ALL_WEIGHT + mine.b;
+    const kin = this.#levels(type, key);
+    const a = 1 + prior.a * scale + (all.a - mine.a) * ALL_WEIGHT + kin.a * LEVEL_WEIGHT + mine.a;
+    const b = 1 + prior.b * scale + (all.b - mine.b) * ALL_WEIGHT + kin.b * LEVEL_WEIGHT + mine.b;
     // Cost and time: the prior's guess, pulled toward what this user's runs actually cost as they add up.
     const blend = (own, n, guess) => (own === null ? guess : (guess * 3 + own * n) / (3 + n));
     const usd = blend(all.usd, all.n, prior.usd ?? 0.3);
     const minutes = blend(all.ms === null ? null : all.ms / 60_000, all.n, prior.min ?? 5);
-    return { a, b, mean: a / (a + b), n: mine.n, nAll: all.n, usd: round(usd, 4), minutes, prior: !!PRIORS.arms[key], inherited: !!prior.inherited };
+    return { a, b, mean: a / (a + b), n: mine.n, nAll: all.n, usd: round(usd, 4), minutes, prior: !!PRIORS.arms[baseOf(key)], inherited: !!prior.inherited };
   }
 
-  // Pick an arm. agents: listAgents() of the place it runs. goal: cheap | balanced | best.
-  // important: no exploring. exclude: arm keys already taken (compare). needDelegate: the lead
+  // 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.
-  choose({ prompt = '', attachments = 0, agents = [], goal = 'balanced', important = false, explore = true, exclude = [], needDelegate = false, allowed = null, rng = Math.random } = {}) {
+  // 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.
+  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);
-    const { type, size } = classify(prompt, { attachments });
+    const guess = classify(prompt, { attachments });
+    const type = scouted?.type || guess.type;
+    const size = scouted?.size || guess.size;
     const V = (GOALS[goal] || GOALS.balanced).value;
-    let arms = candidates(agents, new Set(Object.keys(this.state.arms)))
-      .filter((c) => !exclude.includes(c.key) && (!needDelegate || c.delegates) && (!allowed || allowed.includes(c.agent)))
-      .map((c) => ({ ...c, est: this.estimate(type, c.key), state: this.state.arms[c.key]?.state || 'new' }));
+    const out = new Set(exclude.map(baseOf));
+    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))
+      .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);
+    for (let t = floorTier; t > 0; t--) {
+      const strong = arms.filter((x) => tierOf(x.key) >= t);
+      if (strong.length) {
+        arms = strong;
+        break;
+      }
+    }
     // Quality floor: an arm that keeps failing this kind of task here is left out.
     const floor = arms.filter((x) => !(x.est.n >= 5 && x.est.mean < 0.35));
     if (floor.length) arms = floor;
@@ -198,6 +319,7 @@ export class Router {
     return {
       agent: pick.agent,
       model: pick.model,
+      effort: pick.effort,
       key: pick.key,
       label: pick.label,
       route: {
@@ -205,6 +327,7 @@ export class Router {
         type,
         size,
         key: pick.key,
+        effort: pick.effort,
         label: pick.label,
         chance: round(pick.est.mean),
         n: pick.est.n,
@@ -212,6 +335,8 @@ export class Router {
         minutes: round(pick.est.minutes, 1),
         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(),
@@ -231,7 +356,7 @@ export class Router {
   // rolledBack, switched, costUsd, ms }. The reward is recomputed and the stats move by the difference.
   signal(id, patch) {
     const route = this.state.routes[id];
-    if (!route) return null;
+    if (!route || route.void) return route || null;
     Object.assign(route.signals, Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== undefined)));
     const r = reward(route.signals);
     if (r === null) return this.save(), route;
@@ -251,9 +376,11 @@ export class Router {
       s.at = this.now();
     }
     route.r = r;
-    // Probation ends once an arm has a few outcomes of its own.
-    const arm = this.state.arms[route.key];
-    if (arm?.state === 'new' && (this.state.stats[`*|${route.key}`]?.n || 0) >= 3) arm.state = 'ready';
+    // Probation ends once a harness · model has a few outcomes of its own, at any level.
+    const base = baseOf(route.key);
+    const arm = this.state.arms[base];
+    const n = Object.entries(this.state.stats).reduce((sum, [k, x]) => sum + (k.startsWith('*|') && baseOf(k.slice(2)) === base ? x.n : 0), 0);
+    if (arm?.state === 'new' && n >= 3) arm.state = 'ready';
     this.save();
     return route;
   }
@@ -262,22 +389,63 @@ export class Router {
     return this.state.routes[id] || null;
   }
 
+  // Outcomes of your own tasks the router has learned from.
+  learned() {
+    return Object.values(this.state.routes).filter((r) => r.r !== null).length;
+  }
+
+  // A harness (or one model, at every level) hit a usage or rate limit: skip it until it resets.
+  cool(key, { scope = 'arm', ms = 10 * 60_000, why = '' } = {}) {
+    const target = scope === 'agent' ? `${splitKey(key).agent}:*` : baseOf(key);
+    (this.state.cooling ||= {})[target] = { until: this.now() + ms, why: String(why).slice(0, 160) };
+    this.save();
+    return target;
+  }
+
+  cooling(key) {
+    const c = this.state.cooling || {};
+    const hit = c[key] || c[baseOf(key)] || c[`${splitKey(key).agent}:*`];
+    return hit && hit.until > this.now() ? hit : null;
+  }
+
+  // The run never got to work (the harness was at its limit): forget it ever counted.
+  void(id) {
+    const route = this.state.routes[id];
+    if (!route) return;
+    if (route.r !== null) {
+      for (const type of [route.type, '*']) {
+        const s = this.state.stats[`${type}|${route.key}`];
+        if (!s) continue;
+        s.a -= route.r;
+        s.b -= 1 - route.r;
+        s.n = Math.max(0, s.n - 1);
+      }
+    }
+    route.r = null;
+    route.void = true;
+    this.save();
+  }
+
   reset() {
     this.state.stats = {};
     this.state.routes = {};
     this.save();
   }
 
-  // Settings → Auto: every arm with its record overall and per kind, and the latest routes.
+  // Settings → Auto: every harness · model, the thinking levels it has a record at, each with its
+  // record overall and per kind, and the latest routes.
   report(agents = []) {
-    const keys = new Set([...Object.keys(this.state.arms), ...candidates(agents, new Set(Object.keys(this.state.arms))).map((c) => c.key)]);
-    const labels = Object.fromEntries(candidates(agents, keys).map((c) => [c.key, c.label]));
+    const levels = Object.keys(this.state.stats).map((sk) => sk.slice(sk.indexOf('|') + 1)).filter((k) => splitKey(k).effort);
+    const keys = new Set([...Object.keys(this.state.arms), ...candidates(agents, new Set(Object.keys(this.state.arms))).map((c) => c.key), ...levels]);
+    const names = Object.fromEntries(candidates(agents, new Set([...keys].map(baseOf))).map((c) => [c.key, c.label]));
+    const labels = Object.fromEntries([...keys].filter((k) => names[baseOf(k)]).map((k) => [k, `${names[baseOf(k)]}${splitKey(k).effort ? ` · ${effortLabel(splitKey(k).effort)}` : ''}`]));
     const arms = [...keys]
       .map((k) => {
         const e = this.estimate('*', k);
         const byType = Object.fromEntries(TYPES.map((t) => [t, this.#counts(t, k)]).filter(([, c]) => c.n).map(([t]) => [t, { n: this.#counts(t, k).n, chance: round(this.estimate(t, k).mean) }]));
-        const state = this.state.arms[k]?.state || (labels[k] ? 'ready' : 'gone');
-        return { key: k, ...splitKey(k), label: labels[k] || k, state: state === 'ready' && !e.prior && !e.inherited && !e.nAll ? 'untried' : state, chance: round(e.mean), n: e.n, usd: round(e.usd), minutes: round(e.minutes, 1), prior: e.prior, byType };
+        const state = this.state.arms[baseOf(k)]?.state || (labels[k] ? 'ready' : 'gone');
+        const cool = this.cooling(k);
+        return { key: k, ...splitKey(k), label: labels[k] || k, tier: tierOf(k), ...(cool && { coolingUntil: cool.until, coolingWhy: cool.why }), state: cool && state !== 'gone' ? 'cooling' : state === 'ready' && !e.prior && !e.inherited && !e.nAll ? 'untried' : state, chance: round(e.mean), n: e.n, usd: round(e.usd), minutes: round(e.minutes, 1), prior: e.prior, byType };
       })
       .filter((a) => a.state !== 'gone' || a.n)
       .sort((p, q) => q.chance - p.chance);
@@ -285,6 +453,7 @@ 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 })),
@@ -300,7 +469,11 @@ export function reward(sig) {
   if (sig.feedback === 'down') return 0;
   if (sig.closed) return 0.2;
   if (sig.rolledBack) return 0.1;
-  if (sig.error) return 0;
+  if (sig.error || sig.check === 'error') return 0;
+  // wisp's own test run beats the agent's word; needing a repair round costs some of the credit,
+  // and losing a best-of-2 to the other run a little more.
+  if (sig.check === 'fail') return 0.1;
+  if (sig.check === 'pass') return round(Math.max(0.3, (sig.repaired ? 0.6 : 0.8) - (sig.picked === false ? 0.15 : 0) - 0.1 * (sig.followups || 0)));
   const base = { done: 0.6, partial: 0.3, blocked: 0.1, info: 0.5 }[sig.hero];
   if (base === undefined) return null;
   return round(Math.max(0.05, base - 0.1 * (sig.followups || 0)));