wisp-agents 0.12.0 → 0.14.0

package/server/router.js

@@ -0,0 +1,340 @@
+// Auto: wisp picks the harness and model 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
+// 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
+// sampling: arms with little data sometimes draw high and get tried) and picks the best value
+// for the goal: value × chance − expected $ − a price on your waiting time.
+//
+// What happened afterwards is the reward, strongest signal first: merged (1) / PR closed (0.2),
+// 👍 (1) / 👎 (0), rolled back (0.1), else the presentation's hero (done 0.6, partial 0.3,
+// blocked 0.1, error 0) less 0.1 per follow-up. A later, stronger signal replaces an earlier one.
+//
+// State lives in ~/.wisp/router.json; nothing leaves the machine except the anonymous telemetry
+// fields the caller adds. Routes are recorded for local sessions and for sessions launched on
+// machines (id@machine): one router per user, fed by every place it runs.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const PRIORS = JSON.parse(fs.readFileSync(new URL('./router-priors.json', import.meta.url), 'utf8'));
+
+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' },
+};
+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 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 MAX_ROUTES = 2000;
+
+// --- task features ---------------------------------------------------------------------------
+
+const RULES = [
+  ['release', /\b(release|bump(ed)? (the )?version|publish|changelog for|tag v?\d)/i],
+  ['docs', /\b(readme|docs?|documentation|typos?|comment(s)? in|jsdoc|docstring)\b/i],
+  ['test', /\b(tests?|coverage|flaky|spec(s)?|e2e|unit test)\b/i],
+  ['bug', /\b(fix|bug|broken|crash(es|ing)?|error|exception|fails?|failing|regression|doesn'?t work|not working|wrong|issue)\b/i],
+  ['ui', /\b(ui|ux|button|css|layout|style|styling|color|colour|dark mode|dialog|modal|popup|screen|page|responsive|icon|animation|card|sidebar|toolbar)\b/i],
+  ['refactor', /\b(refactor|clean ?up|rename|simplif(y|ies)|extract|reorgani[sz]e|dedupe|split)\b/i],
+  ['question', /^(how|why|what|where|when|which|can|could|should|is|are|does|do)\b.*\?\s*$|\b(explain|investigate|look into|research|compare)\b/i],
+];
+
+// { type, size }: a coarse kind of task (the router learns per kind) and a size bucket.
+export function classify(prompt = '', { attachments = 0 } = {}) {
+  const text = String(prompt);
+  const type = RULES.find(([, re]) => re.test(text))?.[0] || 'feature';
+  const files = (text.match(/[\w./-]+\.(js|ts|tsx|jsx|py|go|rs|rb|java|css|html|md|json|ya?ml)\b/g) || []).length;
+  const score = text.length / 400 + files + attachments;
+  return { type, size: score < 1 ? 'S' : score < 4 ? 'M' : 'L' };
+}
+
+// --- arms ------------------------------------------------------------------------------------
+
+export const armKey = (agent, model = '') => `${agent}:${model || ''}`;
+const splitKey = (k) => {
+  const i = k.indexOf(':');
+  return { agent: k.slice(0, i), model: k.slice(i + 1) };
+};
+// 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, '');
+
+// 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) {
+  const out = [];
+  for (const a of agents) {
+    if (!a.available) continue;
+    const models = new Set(['', ...(a.models || []).map((m) => m.id)]);
+    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 });
+      }
+    }
+  }
+  return out;
+}
+
+// --- the router ------------------------------------------------------------------------------
+
+export class Router {
+  constructor(home, { now = Date.now } = {}) {
+    this.file = path.join(home, 'router.json');
+    this.now = now;
+    this.state = { version: 1, arms: {}, stats: {}, routes: {} };
+    try {
+      Object.assign(this.state, JSON.parse(fs.readFileSync(this.file, 'utf8')));
+    } catch {}
+    this.synced = false;
+  }
+
+  save() {
+    try {
+      fs.writeFileSync(this.file, JSON.stringify(this.state));
+    } catch (err) {
+      console.warn(`wisp: router: ${err.message}`);
+    }
+  }
+
+  // New harnesses and models since the last look. The first look only learns what's there.
+  // Returns [{ key, label }] of arms that just showed up (they start on probation).
+  sync(agents) {
+    const first = !Object.keys(this.state.arms).length;
+    const known = new Set(Object.keys(this.state.arms));
+    const added = [];
+    const seen = new Set();
+    for (const c of candidates(agents, known)) {
+      seen.add(c.key);
+      const arm = this.state.arms[c.key];
+      if (!arm) {
+        // Something new later on is on probation until it has shown what it can do.
+        this.state.arms[c.key] = { firstSeen: this.now(), state: first || this.#prior(c.key) ? 'ready' : 'new' };
+        if (!first) added.push({ key: c.key, label: c.label, state: this.state.arms[c.key].state });
+      } else if (arm.state === 'gone') arm.state = 'ready';
+    }
+    for (const [k, arm] of Object.entries(this.state.arms)) if (!seen.has(k) && arm.state !== 'gone' && agents.some((a) => a.id === splitKey(k).agent)) arm.state = 'gone';
+    this.synced = true;
+    this.save();
+    return added;
+  }
+
+  #prior(k) {
+    const p = PRIORS.arms[k];
+    if (p) return p;
+    // A new version inherits its family's record, with less weight.
+    const kin = Object.entries(PRIORS.arms).filter(([x]) => family(x) === family(k) && splitKey(x).agent === splitKey(k).agent);
+    if (!kin.length) return null;
+    const [, best] = kin.sort((a, b) => b[1].a + b[1].b - (a[1].a + a[1].b))[0];
+    const s = Math.min(1, 4 / (best.a + best.b));
+    return { ...best, a: best.a * s, b: best.b * s, inherited: true };
+  }
+
+  // Decayed counts for (kind, arm) from this user's routes.
+  #counts(type, key) {
+    const s = this.state.stats[`${type}|${key}`];
+    if (!s) return { a: 0, b: 0, n: 0, usd: null, ms: null };
+    const age = this.now() - (s.at || this.now());
+    const f = Math.pow(0.5, age / HALF_LIFE_MS);
+    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 };
+  }
+
+  // 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;
+    // 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 };
+  }
+
+  // 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
+  // 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 } = {}) {
+    if (!this.synced) this.sync(agents);
+    const { type, size } = classify(prompt, { attachments });
+    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' }));
+    if (!arms.length) return null;
+    // 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;
+    const utility = (x, theta) => V * theta - x.est.usd - MINUTE_USD * x.est.minutes;
+    const draw = (r) => {
+      const pool = arms.filter((x) => x.state !== 'new' || (explore && !important && r() < NEW_ARM_SHARE));
+      const list = pool.length ? pool : arms;
+      let best = null;
+      let bu = -Infinity;
+      for (const x of list) {
+        const theta = important || !explore ? x.est.mean : betaSample(x.est.a, x.est.b, r);
+        const u = utility(x, theta);
+        if (u > bu) (best = x), (bu = u);
+      }
+      return best;
+    };
+    const pick = draw(rng);
+    // How likely this pick was: logged so the router's own choices can be corrected for later.
+    let hits = 0;
+    const sim = mulberry32(Math.floor(rng() * 2 ** 31));
+    for (let i = 0; i < 200; i++) if (draw(sim).key === pick.key) hits++;
+    const byMean = [...arms].sort((p, q) => utility(q, q.est.mean) - utility(p, p.est.mean));
+    return {
+      agent: pick.agent,
+      model: pick.model,
+      key: pick.key,
+      label: pick.label,
+      route: {
+        goal: GOALS[goal] ? goal : 'balanced',
+        type,
+        size,
+        key: pick.key,
+        label: pick.label,
+        chance: round(pick.est.mean),
+        n: pick.est.n,
+        usd: round(pick.est.usd),
+        minutes: round(pick.est.minutes, 1),
+        explored: byMean[0].key !== pick.key,
+        trying: pick.state === 'new',
+        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(),
+      },
+    };
+  }
+
+  // A launch went out with this route. id: the session id (id@machine for one on a machine).
+  record(id, route) {
+    this.state.routes[id] = { ...route, signals: {}, r: null };
+    const ids = Object.keys(this.state.routes);
+    if (ids.length > MAX_ROUTES) for (const old of ids.slice(0, ids.length - MAX_ROUTES)) delete this.state.routes[old];
+    this.save();
+  }
+
+  // Something happened to a routed session: { hero, error, followups, feedback, merged, closed,
+  // rolledBack, 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;
+    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;
+    for (const type of [route.type, '*']) {
+      const k = `${type}|${route.key}`;
+      const s = (this.state.stats[k] ||= { a: 0, b: 0, n: 0, usd: 0, usdN: 0, ms: 0, at: this.now() });
+      if (route.r === null) {
+        s.n++;
+        if (typeof route.signals.costUsd === 'number') (s.usd += route.signals.costUsd), s.usdN++;
+        s.ms += route.signals.ms || 0;
+      } else {
+        s.a -= route.r;
+        s.b -= 1 - route.r;
+      }
+      s.a += r;
+      s.b += 1 - r;
+      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';
+    this.save();
+    return route;
+  }
+
+  route(id) {
+    return this.state.routes[id] || null;
+  }
+
+  reset() {
+    this.state.stats = {};
+    this.state.routes = {};
+    this.save();
+  }
+
+  // Settings → Auto: every arm 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 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 };
+      })
+      .filter((a) => a.state !== 'gone' || a.n)
+      .sort((p, q) => q.chance - p.chance);
+    const routes = Object.entries(this.state.routes).map(([id, r]) => ({ id, ...r }));
+    return {
+      priors: { version: PRIORS.version, source: PRIORS.source },
+      learned: routes.filter((r) => r.r !== null).length,
+      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 })),
+    };
+  }
+}
+
+export function reward(sig) {
+  if (sig.merged) return 1;
+  if (sig.feedback === 'up') return 1;
+  if (sig.feedback === 'down') return 0;
+  if (sig.closed) return 0.2;
+  if (sig.rolledBack) return 0.1;
+  if (sig.error) return 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)));
+}
+
+const round = (x, d = 2) => Math.round(x * 10 ** d) / 10 ** d;
+
+function mulberry32(a) {
+  return () => {
+    a |= 0;
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+// Beta(a, b) from two Gamma draws (Marsaglia–Tsang).
+function gammaSample(k, r) {
+  if (k < 1) return gammaSample(k + 1, r) * Math.pow(r() || 1e-12, 1 / k);
+  const d = k - 1 / 3;
+  const c = 1 / Math.sqrt(9 * d);
+  for (;;) {
+    let x;
+    let v;
+    do {
+      const u1 = r() || 1e-12;
+      const u2 = r();
+      x = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+      v = 1 + c * x;
+    } while (v <= 0);
+    v = v * v * v;
+    const u = r() || 1e-12;
+    if (Math.log(u) < 0.5 * x * x + d - d * v + d * Math.log(v)) return d * v;
+  }
+}
+export function betaSample(a, b, r = Math.random) {
+  const x = gammaSample(a, r);
+  const y = gammaSample(b, r);
+  return x / (x + y);
+}

package/server/runner.js

@@ -13,7 +13,9 @@ import { captureCheckpoint, freshCheckpoint, readGitFile } from './checkpoint.js
 import { teamNote, copies, SUBAGENT_ASK } from './subagents.js';
 
 const MAX_ACTIVITY = 400;
+const MODES = new Set(['plan', 'edits', 'auto']);
 const LINGER_MS = 3000; // how long a CLI may keep running after it reported its result
+const BACKGROUND_MAX_MS = 60 * 60_000; // how long a turn may wait on its background tasks
 const ASK_SERVER = path.join(path.dirname(fileURLToPath(import.meta.url)), 'mcp-ask.js');
 // The delegate tool lives on the same injected server, so harnesses name it like ask_user.
 const delegateTool = (askTool) => askTool && askTool.replace(/ask_user$/, 'delegate');
@@ -70,7 +72,7 @@ export function summarize(s, store) {
     toShip: s.toShip || null, // { dirty, ahead, unpushed } of the worktree, null until checked
     pr: s.pr ? { number: s.pr.number, url: s.pr.url, state: s.pr.state, draft: s.pr.draft, review: s.pr.review, checks: s.pr.checks } : null,
     groupId: s.groupId || null,
-    origin: s.origin || null, // { kind: 'recipe' | 'trigger', id, name }
+    origin: s.origin || null, // { kind: 'recipe' | 'trigger' | 'telegram', id, name }
     // The roster, for the stacked logos on the card: used = delegated to at least once, busy = working now.
     team: (s.subagents || []).flatMap((m) =>
       copies(m).map((name) => {
@@ -79,6 +81,8 @@ export function summarize(s, store) {
       }),
     ),
     ...(s.parentId && { parentId: s.parentId, member: s.member }),
+    // Auto: what it picked and why, for the card's tooltip.
+    route: s.route ? { goal: s.route.goal, type: s.route.type, label: s.route.label, chance: s.route.chance, n: s.route.n, usd: s.route.usd, explored: s.route.explored, trying: s.route.trying, alternatives: s.route.alternatives } : null,
   };
 }
 
@@ -93,6 +97,7 @@ export class Runner extends EventEmitter {
     this.interrupting = new Set();
     this.answers = new Map(); // askId -> answer, until the MCP server picks it up
     this.promptExtra = () => ''; // (session) => text appended to the system prompt (learned preferences)
+    this.routeAuto = null; // (prompt, { cwd }) => { agent, model, route } for subagents set to Auto
 
     // Anything that was mid-flight when wisp last died is now orphaned.
     for (const s of store.all()) {
@@ -107,7 +112,7 @@ export class Runner extends EventEmitter {
   }
 
   // subagents: the team a lead may delegate to. parentId/member: this session is one of them.
-  create({ id = newId(), prompt, cwd, agent = 'claude', mode = 'edits', model = '', effort = '', attachments = [], worktree = null, groupId = null, origin = null, subagents = [], parentId = null, member = '' }) {
+  create({ id = newId(), prompt, cwd, agent = 'claude', mode = 'edits', model = '', effort = '', attachments = [], worktree = null, groupId = null, origin = null, subagents = [], parentId = null, member = '', route = null }) {
     if (!adapters[agent]) throw new Error(`Unknown agent: ${agent}`);
     const now = Date.now();
     const session = {
@@ -131,6 +136,7 @@ export class Runner extends EventEmitter {
       ...(origin && { origin }),
       ...(subagents.length && { subagents, children: {} }),
       ...(parentId && { parentId, member }),
+      ...(route && { route }), // how Auto picked agent and model (server/router.js)
     };
     this.store.put(session);
     if (!parentId) this.store.touchProject(cwd); // a subagent's cwd may be the lead's worktree
@@ -138,8 +144,11 @@ export class Runner extends EventEmitter {
     return session;
   }
 
-  reply(session, text, attachments = [], { queue = false } = {}) {
-    if (session.ask) {
+  // mode: switch the permission mode (plan / edits / auto) from this follow-up on. A queued
+  // follow-up keeps its own, so the run before it isn't affected.
+  reply(session, text, attachments = [], { queue = false, mode } = {}) {
+    if (!MODES.has(mode) || mode === session.mode) mode = undefined;
+    if (session.ask && !mode) {
       this.answer(session, text);
       return { answered: true };
     }
@@ -149,22 +158,23 @@ export class Runner extends EventEmitter {
       // The run already produced its result and the CLI is only lingering on its way out:
       // there's nothing to wait for, so let it go and start the follow-up now.
       if (turn?.status !== 'running') {
-        session.queue.push({ id: newId(), text, attachments });
+        session.queue.push({ id: newId(), text, attachments, ...(mode && { mode }) });
         handle.release();
         return { queued: session.queue.length > 0 };
       }
       // Interrupting needs an agent session to resume; before the agent reports one, queue.
       if (queue || !session.agentSessionId) {
-        session.queue.push({ id: newId(), text, attachments });
+        session.queue.push({ id: newId(), text, attachments, ...(mode && { mode }) });
         this.#touch(session);
         return { queued: true, ahead: session.queue.length - 1 };
       }
       // Ahead of anything queued, but after earlier interrupting follow-ups, so they keep their order.
       const at = session.queue.findIndex((q) => !q.now);
-      session.queue.splice(at < 0 ? session.queue.length : at, 0, { id: newId(), text, attachments, now: true });
+      session.queue.splice(at < 0 ? session.queue.length : at, 0, { id: newId(), text, attachments, now: true, ...(mode && { mode }) });
       this.#interrupt(session);
       return { interrupted: true };
     }
+    if (mode) session.mode = mode;
     this.#startTurn(session, text, attachments);
     return { queued: false };
   }
@@ -252,12 +262,20 @@ export class Runner extends EventEmitter {
       let child = this.store.get(lead.children?.[slot]);
       if (child) {
         child.cwd = workdir(lead); // follows the lead if its worktree moved
+        child.mode = lead.mode; // and its mode, if a follow-up switched it
         this.#startTurn(child, prompt);
       } else {
-        child = this.create({ prompt, cwd: workdir(lead), agent: m.agent, mode: lead.mode, model: m.model, effort: m.effort, parentId: lead.id, member: slot });
+        // An Auto member is routed on its first task and keeps that pick, so later tasks resume it.
+        const pick = m.agent === 'auto' ? this.routeAuto?.(prompt, { cwd: workdir(lead) }) : null;
+        if (m.agent === 'auto' && !pick) {
+          out.push({ subagent: want, error: 'Auto found no harness to run this on.' });
+          continue;
+        }
+        const run = pick ? { agent: pick.agent, model: pick.model, effort: '', route: pick.route } : { agent: m.agent, model: m.model, effort: m.effort };
+        child = this.create({ prompt, cwd: workdir(lead), ...run, mode: lead.mode, parentId: lead.id, member: slot });
         (lead.children ||= {})[slot] = child.id;
       }
-      const d = { id: newId(), name: slot, member: m.name, agent: m.agent, model: m.model, effort: m.effort, sessionId: child.id, turnId: child.turns.at(-1).id, prompt, startedAt: Date.now() };
+      const d = { id: newId(), name: slot, member: m.name, agent: child.agent, model: child.model, effort: child.effort, sessionId: child.id, turnId: child.turns.at(-1).id, prompt, startedAt: Date.now() };
       (turn.delegations ||= []).push(d);
       out.push(d);
     }
@@ -317,6 +335,7 @@ export class Runner extends EventEmitter {
       agent: session.agent,
       model: session.model,
       effort: session.effort || '',
+      mode: session.mode,
       attachments: attachments.map(({ id, name, mime, size }) => ({ id, name, mime, size })),
       startedAt: Date.now(),
       endedAt: null,
@@ -373,16 +392,22 @@ export class Runner extends EventEmitter {
         : {},
       onEvent: (ev) => {
         if (released) return; // a lingering process we already let go of
-        this.#onEvent(session, turn, ev);
+        const waiting = this.#onEvent(session, turn, ev) === 'waiting';
         // A CLI can outlive its result (flushing, or a background process it spawned holding
-        // stdout open, so 'close' never fires). Don't hold the session hostage to that.
-        if (ev.type === 'result') linger = setTimeout(release, LINGER_MS);
+        // stdout open, so 'close' never fires). Don't hold the session hostage to that. A result
+        // that left background tasks running gets up to BACKGROUND_MAX_MS for its next one.
+        if (ev.type === 'result') {
+          clearTimeout(linger);
+          linger = setTimeout(release, waiting ? BACKGROUND_MAX_MS : LINGER_MS);
+        }
       },
     });
     // Ends the run exactly once: on exit, LINGER_MS after the result, or when a follow-up arrives.
     const release = () => {
       if (released) return;
-      if (turn.status === 'running') this.#finishTurn(session, turn, { isError: true, text: 'The agent exited without a result.' });
+      // Gone while waiting on background work (stopped, interrupted, or it died): the result it
+      // gave before waiting is the best we have.
+      if (turn.status === 'running') this.#finishTurn(session, turn, turn.interim || { isError: true, text: 'The agent exited without a result.' });
       released = true;
       clearTimeout(linger);
       handle.stop();
@@ -391,6 +416,7 @@ export class Runner extends EventEmitter {
       this.interrupting.delete(session.id);
       this.stopping.delete(session.id); // a stop that landed after the result has nothing left to stop
       const next = session.queue.shift();
+      if (next?.mode) session.mode = next.mode;
       if (next && this.store.get(session.id)) this.#startTurn(session, next.text, next.attachments);
       else this.#touch(session);
     };
@@ -439,14 +465,41 @@ export class Runner extends EventEmitter {
         if (leadTurn?.status === 'running') this.#onEvent(lead, leadTurn, { ...ev, by: session.member });
         return;
       }
+      case 'background': {
+        turn.background = ev.tasks;
+        if (turn.interim) this.#waitItem(session, turn);
+        else this.store.save(session);
+        return;
+      }
       case 'result':
+        // It ended its turn in plain text with background tasks still running ("I'll report once
+        // it's done"): the CLI wakes it up when they finish and it reports again, so the turn stays
+        // open. A full presentation is a finished task that left something up (a dev server).
+        if (ev.background > 0 && !ev.isError && parsePresentation(ev.text).fallback) {
+          turn.interim = { text: ev.text, stats: ev.stats };
+          this.#waitItem(session, turn);
+          return 'waiting';
+        }
         this.#finishTurn(session, turn, ev);
         return;
     }
   }
 
+  // The live line while a turn waits on its background tasks.
+  #waitItem(session, turn) {
+    const tasks = turn.background || [];
+    const label = !tasks.length
+      ? 'Background work finished, wrapping up'
+      : tasks.length === 1
+        ? `Waiting on background task: ${tasks[0]}`
+        : `Waiting on ${tasks.length} background tasks`;
+    this.#onEvent(session, turn, { type: 'tool', kind: 'background', label: label.slice(0, 200) });
+  }
+
   #finishTurn(session, turn, ev, reason) {
     turn.endedAt = Date.now();
+    delete turn.interim;
+    delete turn.background;
     turn.stats = ev.stats || null;
     delete session.ask;
     if (this.stopping.delete(session.id)) ev = { ...ev, stopped: true };

package/server/store.js

@@ -8,7 +8,7 @@ import { parsePresentation } from './protocol.js';
 
 const DEFAULT_CONFIG = {
   projects: [], // [{ id, name, path, color, addedAt, machine? }]; machine: the server/machines.js id it lives on
-  defaults: { agent: 'claude', mode: 'edits', model: '', effort: '' },
+  defaults: { agent: 'auto', mode: 'edits', model: '', effort: '' }, // auto: wisp picks harness and model (server/router.js)
   recipes: [], // saved prompts with {params}: server/recipes.js
   triggers: [], // schedules and GitHub watchers: server/triggers.js
   teams: [], // saved subagent presets: server/subagents.js
@@ -57,9 +57,17 @@ export class Store {
       cfg.teams ||= [];
       cfg.remote ||= {};
       cfg.machines ||= [];
+      // Auto became the default harness: switch once, after that the user's pick sticks.
+      if (!cfg.autoIntroduced) {
+        if (cfg.defaults.agent !== 'auto') cfg.defaults.agentBeforeAuto = cfg.defaults.agent;
+        cfg.defaults.agent = 'auto';
+        cfg.defaults.model = cfg.defaults.models?.auto || '';
+        cfg.defaults.effort = '';
+        cfg.autoIntroduced = true;
+      }
       return cfg;
     } catch {
-      return structuredClone(DEFAULT_CONFIG);
+      return { ...structuredClone(DEFAULT_CONFIG), autoIntroduced: true };
     }
   }
 

package/server/subagents.js

@@ -19,7 +19,8 @@ export function normalizeTeam(list, adapters) {
   const taken = new Set();
   const team = list.slice(0, MAX_SUBAGENTS).map((m) => {
     const agent = String(m?.agent || '');
-    if (!adapters[agent] || agent === 'wisp') throw Object.assign(new Error(`unknown subagent harness: ${agent}`), { status: 400 });
+    // auto: wisp picks the harness and model when this member gets its first task.
+    if ((!adapters[agent] && agent !== 'auto') || agent === 'wisp') throw Object.assign(new Error(`unknown subagent harness: ${agent}`), { status: 400 });
     let base = slug(m.name) || agent;
     let name = base;
     for (let i = 2; taken.has(name); i++) name = `${base}-${i}`;
@@ -45,7 +46,10 @@ export function normalizePreset(body, adapters, prev = {}) {
   return { id: prev.id || slug(name) + '-' + Math.random().toString(36).slice(2, 6), name, members, updatedAt: Date.now() };
 }
 
-const who = (m, adapters) => [adapters[m.agent]?.name || m.agent, m.model || 'default model', m.effort && `${m.effort} thinking`].filter(Boolean).join(' · ');
+const who = (m, adapters) =>
+  m.agent === 'auto'
+    ? 'Auto (wisp picks the harness and model for the first task you give it)'
+    : [adapters[m.agent]?.name || m.agent, m.model || 'default model', m.effort && `${m.effort} thinking`].filter(Boolean).join(' · ');
 
 // Appended to the lead's system prompt. `tool` is how its harness names the delegate tool.
 export function teamNote(team, adapters, tool) {