wisp-agents 0.18.0 → 0.20.0

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)));

package/server/routes/auto.js

@@ -1,4 +1,5 @@
-// Auto: what the router learned, and its settings (goal, trying new models, allowed harnesses).
+// Auto: what the router learned, and its settings (goal, trying new models, allowed harnesses,
+// and the steps after a run: check, repairs, hand-over, best of two, scout).
 
 import { adapters } from '../adapters/index.js';
 import { GOALS } from '../router.js';
@@ -18,6 +19,12 @@ export function register(r, app) {
     d.router = { ...d.router };
     if (body.explore !== undefined) d.router.explore = body.explore ? 'on' : 'off';
     if (body.allowed !== undefined) d.router.allowed = Array.isArray(body.allowed) ? body.allowed.filter((a) => adapters[a]) : null;
+    for (const k of ['check', 'escalate', 'best2']) if (body[k] !== undefined) d.router[k] = body[k] ? 'on' : 'off';
+    if (body.repairs !== undefined) d.router.repairs = Math.max(0, Math.min(2, Math.round(Number(body.repairs)) || 0));
+    if (body.scout !== undefined) {
+      if (!['off', 'big', 'all'].includes(body.scout)) return c.send(400, { error: 'scout must be off, big or all' });
+      d.router.scout = body.scout;
+    }
     app.configChanged();
     c.send(200, await auto.view());
   });

package/server/routes/settings.js

@@ -157,6 +157,8 @@ export function register(r, app) {
     const body = await c.body();
     if (typeof body.name === 'string' && body.name.trim()) p.name = body.name.trim();
     if (typeof body.color === 'string') p.color = body.color;
+    // Auto's test check: the command to run, '' to detect it, 'off' for none.
+    if (typeof body.testCommand === 'string') body.testCommand.trim() ? (p.testCommand = body.testCommand.trim().slice(0, 500)) : delete p.testCommand;
     app.configChanged();
     c.send(200, p);
   });

package/server/routes/ship.js

@@ -36,6 +36,7 @@ export function register(r, app) {
       const onStep = (step) => ((s.shipping = { ...s.shipping, step }), app.sessionChanged(s));
       try {
         s.pr = await ship(s.worktree, { title: body.title ?? draft.title, body: body.body ?? draft.body, draft: !!body.draft, pr: s.pr, onStep });
+        s.pushedAt = Date.now(); // the PR is polled fast for a while, so its checks show up as they start
       } finally {
         delete s.shipping;
         app.sessionChanged(s, { now: true });
@@ -53,16 +54,20 @@ export function register(r, app) {
       c.send(200, await app.ship.refreshPr(s));
     }),
   );
-  // Try the automatic conflict fix again after it gave up (see services/ship.js).
+  // Fix conflicts on the PR row: send the task a follow-up to merge the base in now (see
+  // services/ship.js). Trusts the conflict wisp last saw, so it starts at once; asks GitHub only if it saw none.
   r.route(
     'POST',
     '/sessions/:id/fix-conflicts',
     one(async (c, s) => {
       if (s.pr?.state !== 'OPEN' || !s.worktree) return c.send(400, { error: 'No open pull request.' });
       if (runner.live.has(s.id)) return c.send(409, { error: 'Still working: wait for it to finish, or stop it.' });
-      s.conflictFix = { tries: 0 };
-      await app.ship.refreshPr(s);
-      if (s.conflictFix?.step !== 'fixing') return c.send(409, { error: s.pr.conflict ? 'It merges cleanly with the latest base here: GitHub may not have caught up yet.' : 'The PR has no merge conflicts now.' });
+      if (!s.pr.conflict) await app.ship.refreshPr(s);
+      if (s.conflictFix?.step !== 'fixing') await app.ship.fixConflicts(s, { force: true });
+      if (s.conflictFix?.step !== 'fixing') {
+        const why = !s.pr.conflict ? 'The PR has no merge conflicts now.' : !s.worktree.remote ? 'This repo has no origin remote to push to.' : s.ask ? 'The task is waiting for your answer first.' : s.shipping ? 'Already shipping: wait for it to land.' : 'Could not start the fix: try again in a moment.';
+        return c.send(409, { error: why });
+      }
       c.send(200, { conflictFix: s.conflictFix });
     }),
   );