wisp-agents 0.21.0 → 0.23.0

package/server/git.js

@@ -4,6 +4,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
 import { execFile } from './proc.js';
 import { bad } from './util.js';
 
@@ -12,9 +13,9 @@ const GH = () => process.env.WISP_GH_BIN || 'gh';
 // Never wait on a credential or confirmation prompt nobody can see.
 const QUIET_ENV = { GIT_TERMINAL_PROMPT: '0', GH_PROMPT_DISABLED: '1', GH_NO_UPDATE_NOTIFIER: '1', GIT_EDITOR: 'true' };
 
-export function run(bin, args, { cwd, timeout = 60_000 } = {}) {
+export function run(bin, args, { cwd, timeout = 60_000, env } = {}) {
   return new Promise((resolve, reject) => {
-    execFile(bin, args, { cwd, timeout, maxBuffer: 16 * 1024 * 1024, env: { ...process.env, ...QUIET_ENV } }, (err, stdout, stderr) => {
+    execFile(bin, args, { cwd, timeout, maxBuffer: 16 * 1024 * 1024, env: { ...process.env, ...QUIET_ENV, ...env } }, (err, stdout, stderr) => {
       if (!err) return resolve(String(stdout).trim());
       // git and gh lead with "fatal:" / "error:"; otherwise the tail is the useful part.
       const lines = String(stderr || '').trim().split('\n').filter(Boolean);
@@ -279,10 +280,13 @@ export function parseRepo(input, { shorthand = false } = {}) {
   return null;
 }
 
+// parseRepo, plus a plain path to a repo on disk (an origin can be one).
+export const repoOf = (u) => parseRepo(u) || (path.isAbsolute(String(u || '')) ? parseRepo(pathToFileURL(String(u)).href) : null);
+
 // The same repo, however it was spelled (https vs ssh, .git or not, case of the host).
-const sameRepo = (a, b) => {
+export const sameRepo = (a, b) => {
   const key = (u) => {
-    const r = parseRepo(u);
+    const r = repoOf(u);
     return r && (r.gh ? `github.com/${r.gh.toLowerCase()}` : `${r.host}/${r.path}`);
   };
   return !!key(a) && key(a) === key(b);
@@ -317,3 +321,75 @@ export async function cloneRepo(repo, parent, { timeout = 10 * 60_000 } = {}) {
     throw bad(`Couldn’t clone ${what}: it doesn’t exist, or this login can’t see it.${repo.gh ? ' Private repo? Check `gh auth status`.' : ''}`);
   throw bad(`Couldn’t clone ${what}: ${last.message}`);
 }
+
+// --- moving a task to another place: its work travels as a git bundle ---
+
+// Who the snapshot commit is by, so packing works where git has no user.name.
+const MOVER = { GIT_AUTHOR_NAME: 'wisp', GIT_AUTHOR_EMAIL: 'wisp@localhost', GIT_COMMITTER_NAME: 'wisp', GIT_COMMITTER_EMAIL: 'wisp@localhost' };
+
+// Pack the work in `dir` into `file`: the branch's commits plus one snapshot commit on top that
+// holds what isn't committed (untracked files too, ignored ones not). The user's index and
+// working tree are only read. Commits the remote already has (from wt.head down) stay out.
+// Resolves the pack's description for unpackWork(), or null outside a repo with commits.
+export async function packWork(dir, wt, file) {
+  const root = await repoRoot(dir);
+  const head = root && (await quiet(git(root, ['rev-parse', '--verify', '--quiet', 'HEAD^{commit}'])));
+  if (!head) return null;
+  const index = `${file}.index`;
+  const env = { ...MOVER, GIT_INDEX_FILE: index };
+  const ref = `refs/wisp/move/${path.basename(file).replace(/\W+/g, '-')}`;
+  try {
+    await git(root, ['read-tree', 'HEAD'], { env });
+    await git(root, ['add', '-A'], { env, timeout: 120_000 });
+    const tree = await git(root, ['write-tree'], { env });
+    const snap = await git(root, ['commit-tree', tree, '-p', head, '-m', 'wisp: work in progress, moved'], { env });
+    await git(root, ['update-ref', ref, snap]);
+    const published = wt?.head && (await quiet(git(root, ['branch', '-r', '--contains', wt.head])));
+    await git(root, ['bundle', 'create', file, ref, ...(published ? [`^${wt.head}`] : [])], { timeout: 300_000 });
+    const branch = wt?.branch || '';
+    return { ref, branch, base: wt?.base || '', baseRef: wt?.baseRef || '', head: wt?.head || null, remote: wt?.remote ?? null, prereq: !!published };
+  } finally {
+    fs.rmSync(index, { force: true });
+    await quiet(git(root, ['update-ref', '-d', ref]));
+  }
+}
+
+// Unpack a packWork() bundle into a new worktree of the repo at `cwd`, on the same branch name
+// when it's free: its commits as commits, the snapshot as uncommitted changes again.
+export async function unpackWork({ cwd, home, id, title, pack, file }) {
+  const root = await repoRoot(cwd);
+  if (!root) throw bad(`${cwd} isn’t a git repo here, so the work has nowhere to go.`);
+  if (pack.prereq) await quiet(git(root, ['fetch', '--quiet', 'origin'], { timeout: 60_000 })); // the commits the bundle leaves out
+  const local = `refs/wisp/moved/${id}`;
+  try {
+    await git(root, ['fetch', '--quiet', '--no-tags', file, `+${pack.ref}:${local}`], { timeout: 300_000 });
+  } catch (err) {
+    throw bad(`Couldn’t bring the work over: ${err.message}`);
+  }
+  const taken = async (b) => !!(await quiet(git(root, ['rev-parse', '--verify', '--quiet', `refs/heads/${b}`])));
+  let branch = /^[\w./-]{1,120}$/.test(pack.branch || '') && !(await taken(pack.branch)) ? pack.branch : `wisp/${slug(title) || 'task'}-${id.slice(0, 6)}`;
+  if (await taken(branch)) branch = `wisp/${slug(title) || 'task'}-${id}`;
+  const dir = path.join(home, 'worktrees', `${path.basename(root)}-${id}`);
+  fs.mkdirSync(path.dirname(dir), { recursive: true });
+  try {
+    await git(root, ['worktree', 'add', '--quiet', '--no-track', '-b', branch, dir, `${local}^`]);
+    await git(dir, ['read-tree', '-u', '--reset', local]);
+    await git(dir, ['reset', '--quiet']);
+  } finally {
+    await quiet(git(root, ['update-ref', '-d', local]));
+  }
+  // A task that ran in the folder itself (no worktree) branches from what's here.
+  const base = pack.baseRef ? null : await baseRef(root);
+  const sub = path.relative(realpath(root), realpath(cwd));
+  return {
+    path: dir,
+    cwd: sub && !sub.startsWith('..') ? path.join(dir, sub) : dir,
+    branch,
+    base: pack.base || base?.branch || '',
+    baseRef: pack.baseRef || base?.ref || '',
+    head: pack.head || (await quiet(git(dir, ['rev-parse', 'HEAD']))) || null,
+    remote: pack.baseRef ? pack.remote : base?.remote || null,
+    root,
+    createdAt: Date.now(),
+  };
+}

package/server/handoff.js

@@ -15,19 +15,22 @@ const KEEP = new Set(['hero', 'markdown', 'steps', 'stats', 'files', 'tests', 'c
 // The turns before the current one that `agent` hasn't seen: everything after the last turn it
 // ran, or all of them when it has no conversation of its own to resume (resumeId). Only a gap
 // that another harness filled counts: on its own, a harness has nothing to catch up on.
+// Turns that ran on another place before the task moved here (t.moved) count as unseen by every
+// harness: their conversations stayed there.
 export function missedTurns(session, agent, resumeId) {
   const prior = session.turns.slice(0, -1);
-  const missed = resumeId ? prior.slice(prior.findLastIndex((t) => (t.agent || agent) === agent) + 1) : prior;
-  return missed.some((t) => (t.agent || agent) !== agent) ? missed : [];
+  const missed = resumeId ? prior.slice(prior.findLastIndex((t) => !t.moved && (t.agent || agent) === agent) + 1) : prior;
+  return missed.some((t) => t.moved || (t.agent || agent) !== agent) ? missed : [];
 }
 
-function turnText(t, n, name) {
+// One earlier turn as markdown: the request, its report and the files it edited. /btw uses it too.
+export function turnText(t, n, name) {
   const blocks = (t.presentation?.blocks || []).filter((b) => KEEP.has(b?.type));
   const report = t.status === 'running' ? '' : blocksToMarkdown(blocks, t) || clip(t.raw, 1500);
   const files = (t.changes || []).filter((c) => !c.reverted).map((c) => `\`${c.file}\``);
   return truncate(
     [
-      `### Turn ${n} · ${name(t)}${t.model ? ` (${t.model})` : ''}${t.status === 'stopped' ? ' · stopped' : t.status === 'error' ? ' · failed' : ''}${t.rolledBackAt ? ' · rolled back, its edits were undone' : ''}`,
+      `### Turn ${n} · ${name(t)}${t.model ? ` (${t.model})` : ''}${t.moved ? ` · on ${t.moved}` : ''}${t.status === 'stopped' ? ' · stopped' : t.status === 'error' ? ' · failed' : ''}${t.rolledBackAt ? ' · rolled back, its edits were undone' : ''}`,
       `**User:** ${textMentions(t.prompt)}`,
       report && `**Report:**\n\n${report}`,
       files.length && `**Files it edited:** ${files.join(', ')}`,
@@ -55,9 +58,12 @@ export function handoffNote(session, agent, resumeId, name) {
   const dropped = missed.length - parts.length;
   const fresh = !resumeId;
   const others = [...new Set(missed.filter((t) => t.agent !== agent).map(name))].join(', ');
-  const intro = fresh
-    ? `You are taking over a task that another coding agent (${others}) has been working on. Its work is already in this folder. Below is what happened so far, oldest first; read the files and \`git diff\` for the details, then carry on with the follow-up.`
-    : `While you were away, this task continued on another coding agent (${others}). Its work is already in this folder. Below is what happened since your last turn, oldest first; check the files and \`git diff\` before you rely on what you remember.`;
+  const places = [...new Set(missed.map((t) => t.moved).filter(Boolean))].join(', ');
+  const intro = places
+    ? `You are taking over a task that ran on another computer (${places})${others ? `, on ${others}` : ''}, and was moved here. Its work so far is already in this folder: committed work as commits, the rest as uncommitted changes. Below is what happened so far, oldest first; read the files and \`git diff\` for the details, then carry on with the follow-up.`
+    : fresh
+      ? `You are taking over a task that another coding agent (${others}) has been working on. Its work is already in this folder. Below is what happened so far, oldest first; read the files and \`git diff\` for the details, then carry on with the follow-up.`
+      : `While you were away, this task continued on another coding agent (${others}). Its work is already in this folder. Below is what happened since your last turn, oldest first; check the files and \`git diff\` before you rely on what you remember.`;
   return [
     '## Earlier in this task',
     intro,

package/server/index.js

@@ -29,6 +29,8 @@ import { scoutNote } from './scout.js';
 import { createFeedback } from './services/feedback.js';
 import { createInstaller } from './services/install.js';
 import { createLaunch } from './services/launch.js';
+import { createMove } from './services/move.js';
+import { createPlaces } from './services/places.js';
 import { phoneActions } from './services/phone.js';
 import { createShip } from './services/ship.js';
 import { trackTurns } from './services/telemetry.js';
@@ -148,6 +150,8 @@ export async function startServer({ port = DEFAULT_PORT, host = '127.0.0.1', han
   });
   trackTurns(app);
 
+  app.places = createPlaces(app);
+  app.mover = createMove(app);
   app.launcher = createLaunch(app);
   app.sendFeedback = createFeedback(app);
   app.triggers = new Triggers({ store, launch: async (body, origin) => (await app.launcher.launchAny(body, origin))[0], onChange: () => app.broadcast('config', {}) });

package/server/machines.js

@@ -21,6 +21,7 @@ import { spawn, killTree } from './proc.js';
 import { newer } from './update.js';
 import { bootstrapScript } from './machines/bootstrap.js';
 import { sshHint, sshHosts, knownHosts, tailscalePeers, discoverHosts, TARGET } from './machines/hosts.js';
+import { HERE } from './store.js';
 import { bad, DEFAULT_PORT, shq } from './util.js';
 
 export { DEFAULT_PORT };
@@ -153,7 +154,17 @@ export class Machines extends EventEmitter {
     this.conns.delete(id);
     this.cache.delete(id);
     this.store.config.machines = this.list.filter((x) => x.id !== id);
-    this.store.config.projects = this.store.config.projects.filter((p) => p.machine !== id);
+    // Its checkouts go. A project added there lives on in a copy elsewhere, if it has one.
+    this.store.config.projects = this.store.config.projects.filter((p) => {
+      delete p.copies?.[id];
+      if (p.machine !== id) return true;
+      const [k, dir] = Object.entries(p.copies || {})[0] || [];
+      if (!k) return false;
+      delete p.copies[k];
+      delete p.machine;
+      Object.assign(p, { path: dir }, k !== HERE && { machine: k });
+      return true;
+    });
     this.store.saveConfig();
     this.onChange();
   }
@@ -175,7 +186,7 @@ export class Machines extends EventEmitter {
         remote: c?.remote || null,
         outdated: updateTo(this.version, c?.remote?.version, m.command),
         log: c?.log.slice(-30) || [],
-        projects: this.store.config.projects.filter((p) => p.machine === m.id).length,
+        projects: this.store.config.projects.filter((p) => this.store.pathAt(p, m.id)).length,
         working: cached.filter((s) => s.state === 'running').length,
       };
     });
@@ -577,10 +588,10 @@ export class Machines extends EventEmitter {
     return j;
   }
 
+  // A folder there that's a checkout of a repo already added elsewhere joins that project.
   async addProject(mid, dir, name) {
     const p = await this.json(mid, 'POST', '/projects', { path: dir }, { timeout: 10 * 60_000 }); // dir may be a repo URL to clone
-    const local = this.store.addProject(p.path, { name: name || p.name, machine: mid });
-    return local;
+    return this.store.addProject(p.path, { name: name || p.name, machine: mid, repo: p.origin || p.cloned?.url || undefined });
   }
 
   // A terminal on the machine running `command` (Take over), in the user's own interactive login

package/server/openapi.js

@@ -234,11 +234,20 @@ export function openapi({ version, port }) {
       '/sessions/{id}/reply': {
         parameters: [id],
         post: {
-          summary: 'Follow up (answers a pending ask_user question if there is one)',
+          summary: 'Follow up (answers a pending ask_user question if there is one). Text starting with /btw is a side question instead (see /btw)',
           requestBody: body({ type: 'object', required: ['text'], properties: { text: { type: 'string' }, attachments: { type: 'array', items: { type: 'string' } }, queue: { type: 'boolean', description: 'Wait for the current run instead of interrupting it' }, mode: { enum: ['plan', 'edits', 'auto'], description: 'Switch the session to this mode from this follow-up on' }, agent: { type: 'string', description: 'Switch to this harness from this follow-up on; it is handed the turns it has not seen' }, model: { type: 'string', description: 'Switch model (empty: the harness default)' }, effort: { type: 'string', description: 'Switch thinking level (empty: the default)' } } }),
-          responses: { 200: json({ type: 'object', properties: { answered: { type: 'boolean' }, queued: { type: 'boolean' }, interrupted: { type: 'boolean' }, ahead: { type: 'integer' } } }), 400: err[400] },
+          responses: { 200: json({ type: 'object', properties: { answered: { type: 'boolean' }, queued: { type: 'boolean' }, interrupted: { type: 'boolean' }, ahead: { type: 'integer' }, btw: ref('Btw') } }), 400: err[400] },
         },
       },
+      '/sessions/{id}/btw': {
+        parameters: [id],
+        post: {
+          summary: 'Ask a side question without interrupting: a read-only run of its own answers it (on a fork of the agent’s conversation where the harness can fork) and the answer lands on the latest turn’s btw list',
+          requestBody: body({ type: 'object', required: ['text'], properties: { text: { type: 'string', description: 'The question; a leading /btw is dropped' }, attachments: { type: 'array', items: { type: 'string' } } } }),
+          responses: { 200: json(ref('Btw')), 400: err[400], 404: err[404], 429: err[400] },
+        },
+        delete: { summary: 'Dismiss a side question (stops its run if it is still answering)', parameters: [{ name: 'item', in: 'query', required: true, schema: { type: 'string' } }], responses: { 200: ok, 404: err[404] } },
+      },
       '/sessions/{id}/answer': { parameters: [id], post: { summary: 'Answer the pending ask_user question (or approval: Allow, Always allow in this task, Deny, or what to do instead)', requestBody: body({ type: 'object', required: ['text'], properties: { text: { type: 'string' } } }), responses: { 200: ok } } },
       '/sessions/{id}/approve': { parameters: [id], post: { summary: 'Allow and retry (or deny) what a finished turn’s permissions blocked', requestBody: body({ type: 'object', properties: { turnId: { type: 'string' }, allow: { type: 'boolean', description: 'Default true' } } }), responses: { 200: ok } } },
       '/sessions/{id}/revert': {
@@ -431,6 +440,22 @@ export function openapi({ version, port }) {
             stats: { type: ['object', 'null'] },
           },
         },
+        Btw: {
+          type: 'object',
+          description: 'A side question (/btw). It sits on turns[].btw of the turn it was asked during; GET the session or wait for its turn event to see the answer',
+          properties: {
+            id: { type: 'string' },
+            question: { type: 'string' },
+            status: { enum: ['running', 'done', 'error'] },
+            answer: { type: 'string', description: 'Markdown, once done' },
+            error: { type: 'string' },
+            forked: { type: 'boolean', description: 'Answered on a copy of the agent’s conversation (else from wisp’s record of the task)' },
+            agent: { type: 'string' },
+            model: { type: 'string' },
+            askedAt: { type: 'integer' },
+            answeredAt: { type: 'integer' },
+          },
+        },
       },
     },
   };

package/server/remote.js

@@ -25,7 +25,8 @@ export function findProject(projects, q) {
 export const mask = (t) => (t ? `••••${String(t).slice(-4)}` : '');
 
 export class Remote {
-  // act({ sessionId, kind: answer|reply|done|text, ref, index, text }) → a short result line.
+  // act({ sessionId, kind: answer|reply|done|text, ref, index, text, later? }) → a short result line;
+  // later(text) sends one more message afterwards (a /btw answer).
   // launch({ project, prompt }) → the new session's summary (a task started with /new).
   constructor({ store, act, launch = async () => null, onChange = () => {} }) {
     Object.assign(this, { store, act, launch, onChange });
@@ -253,7 +254,8 @@ export class Remote {
     const replyTo = m.reply_to_message?.message_id;
     const sessionId = replyTo && (this.store.all().find((x) => x.remote?.tg?.includes(replyTo))?.id || this.tgElsewhere.get(replyTo));
     if (!sessionId) return say(t.allowStart ? 'Reply to one of wisp’s messages to answer it or follow up, or send /new <task> to start one.' : 'Reply to one of wisp’s messages to answer it or send a follow-up.');
-    await say(await this.act({ sessionId, kind: 'text', text: m.text }), { reply_to_message_id: m.message_id });
+    const later = (text) => say(text, { reply_to_message_id: m.message_id }).catch(() => {});
+    await say(await this.act({ sessionId, kind: 'text', text: m.text, later }), { reply_to_message_id: m.message_id });
   }
 
   async #tgCommand(name, arg, m, say) {

package/server/router.js

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

package/server/routes/machines.js

@@ -36,7 +36,7 @@ export function register(r, app) {
     'GET',
     '/machines/:id/discover',
     known(async (c, id) => {
-      const have = new Set(store.config.projects.filter((p) => p.machine === id).map((p) => p.path));
+      const have = new Set(store.config.projects.map((p) => store.pathAt(p, id)).filter(Boolean));
       c.send(200, (await machines.json(id, 'GET', '/projects/discover')).filter((f) => !have.has(f.path)));
     }),
   );

package/server/routes/proxy.js

@@ -2,6 +2,7 @@
 // Registered before the session routes, so a qualified id never reaches them.
 
 import os from 'node:os';
+import { btwQuestion } from '../btw.js';
 import { pipeFrom } from '../http/respond.js';
 import { splitId, qualify } from '../machines.js';
 import { openInTerminal, shq } from '../terminal.js';
@@ -34,6 +35,11 @@ export function register(r, app) {
       return c.send(200, { command: argv.map(shq).join(' ') });
     }
     const body = m === 'GET' ? undefined : await c.body();
+    // A follow-up that moves the task here or to another machine (services/move.js).
+    if (action === 'reply' && typeof body?.machine === 'string') {
+      if (body.machine !== mid && btwQuestion(body.text) === null) return c.send(200, await app.mover.move(c.params.id, body.machine, { ...body, text: String(body.text || '').trim() }));
+      delete body.machine;
+    }
     if (action === 'reply' && body?.attachments?.length) body.attachments = await app.launcher.pushUploads(mid, body.attachments);
     const out = await machines.json(mid, m, sub, body, action === 'wait' ? { timeout: (MAX_WAIT_S + 30) * 1000 } : undefined);
     if (!action && m === 'GET') return c.send(200, machines.session(mid, out));

package/server/routes/sessions.js

@@ -1,10 +1,11 @@
 // Sessions: list and launch, one session (read, edit, delete), and what can be done to it:
-// wait, presentation, reply, queue, answer, revert, rollback, exec, takeover, stop, file.
+// wait, presentation, reply, btw, queue, answer, revert, rollback, exec, takeover, stop, file.
 // Ids of the form <id>@<machine> are passed through to that machine's wisp (proxy.js).
 
 import fs from 'node:fs';
 import path from 'node:path';
 import { adapters, listAgents } from '../adapters/index.js';
+import { btwQuestion } from '../btw.js';
 import { cleanupCheckpoints, revertFileChange, rollbackToTurn } from '../checkpoint.js';
 import { execCommand } from '../proc.js';
 import { ensureWorktree, removeWorktree } from '../git.js';
@@ -96,6 +97,8 @@ export function register(r, app) {
       if (body.state === 'done' && s.state !== 'running') s.state = 'done';
       if (body.state === 'review' && s.state === 'done') s.state = 'review';
       if (typeof body.unread === 'boolean') s.unread = body.unread;
+      // Moved to another place by the wisp that shows it (services/move.js): where it went.
+      if (body.movedTo && typeof body.movedTo === 'object') s.movedTo = { id: String(body.movedTo.id || ''), place: String(body.movedTo.place || '') };
       // The team can change between turns; the next turn's lead sees the new roster.
       if (body.subagents !== undefined && !s.parentId) {
         s.subagents = normalizeTeam(body.subagents, adapters);
@@ -117,6 +120,7 @@ export function register(r, app) {
     '/sessions/:id',
     one(async (c, s) => {
       runner.stop(s);
+      runner.stopSides(s);
       await runner.live.get(s.id)?.done;
       cleanupCheckpoints(workdir(s), s.id);
       for (const cid of Object.values(s.children || {})) {
@@ -184,16 +188,42 @@ export function register(r, app) {
     'POST',
     '/sessions/:id/reply',
     one(async (c, s) => {
-      const { text, attachments, queue, mode, agent, model, effort } = await c.body();
+      const { text, attachments, queue, mode, agent, model, effort, machine } = await c.body();
       if (!text?.trim()) return c.send(400, { error: 'text required' });
       notTour(s, 'follow up');
       if (mode !== undefined && !MODES.has(mode)) return c.send(400, { error: 'mode must be plan, edits or auto.' });
+      // machine: carry the task on on a machine instead (services/move.js). '' is here, where it is.
+      // A /btw side question never moves it.
+      if (typeof machine === 'string' && machine && btwQuestion(text) === null) return c.send(200, await app.mover.move(s.id, machine, { text: text.trim(), attachments, mode, agent, model, effort }));
       // agent / model / effort: run this follow-up (and the ones after it) on another harness or model.
       const run = agent !== undefined || model !== undefined || effort !== undefined ? await followUpRun(s, { agent, model, effort }) : undefined;
       c.send(200, await launcher.replyTo(s, text.trim(), app.uploads.resolve(attachments), queue, mode, run));
     }),
   );
 
+  // Pack the task's work to move it to another place (services/move.js): bundles, as uploads.
+  r.route(
+    'POST',
+    '/sessions/:id/pack',
+    one(async (c, s) => c.send(200, await app.mover.pack(s))),
+    { doc: false },
+  );
+
+  // A side question (/btw): answered next to the run, which carries on. text may keep its /btw.
+  r.route(
+    'POST',
+    '/sessions/:id/btw',
+    one(async (c, s) => {
+      const { text, attachments } = await c.body();
+      c.send(200, await launcher.askBtw(s, btwQuestion(text) ?? String(text || ''), app.uploads.resolve(attachments)));
+    }),
+  );
+  r.route(
+    'DELETE',
+    '/sessions/:id/btw',
+    one((c, s) => (runner.dropBtw(s, c.query.get('item') || '') ? c.send(200, { ok: true }) : c.send(404, { error: 'No such side question.' }))),
+  );
+
   r.route(
     'DELETE',
     '/sessions/:id/queue',

package/server/routes/settings.js

@@ -10,20 +10,10 @@ import { envDisabled, feedbackAvailable } from '../telemetry.js';
 import { TERMINALS } from '../terminal.js';
 import { normalizeWebhooks } from '../services/webhooks.js';
 import { cloneRepo, gh, git, parseRepo } from '../git.js';
+import { checkout, cloneRoot, discoverRepos, originAt } from '../services/places.js';
 import { expand } from '../util.js';
 
-// Where people keep their repos, for one-click "add project".
-const REPO_ROOTS = ['code', 'Code', 'dev', 'Developer', 'projects', 'Projects', 'src', 'repos', 'work', 'git', 'GitHub', 'Documents', 'Downloads', 'Desktop'];
-
-// Where a pasted repo URL is cloned: defaults.cloneDir, else the first usual repo folder that
-// exists (not Documents/Downloads/Desktop), else ~/code.
-export function cloneRoot(config) {
-  if (config.defaults?.cloneDir) return expand(config.defaults.cloneDir);
-  const dir = REPO_ROOTS.slice(0, -3)
-    .map((r) => path.join(os.homedir(), r))
-    .find((d) => fs.existsSync(d) && fs.statSync(d).isDirectory());
-  return dir || path.join(os.homedir(), 'code');
-}
+export { cloneRoot };
 
 export function register(r, app) {
   const { store, telemetry, prefs, retro, remote, machines } = app;
@@ -119,12 +109,30 @@ export function register(r, app) {
       cloned = { url: repo.url, existed: out.existed };
     }
     if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return c.send(400, { error: `Not a folder: ${dir}` });
-    const p = store.addProject(dir, { name: body.name });
+    // Its origin: the same repo added on another place joins that project, and a machine
+    // without a checkout of it can clone it.
+    const origin = await originAt(dir);
+    const p = store.addProject(dir, { name: body.name, repo: origin || undefined });
     app.broadcast('config', {});
-    c.send(201, cloned ? { ...p, cloned } : p);
+    c.send(201, { ...p, ...(cloned && { cloned }), ...(origin && { origin }) });
   });
+  // Another wisp (this computer is one of its machines) needs a checkout of `repo` here: one that's
+  // already here, else a fresh clone. It's added as a project here too.
+  r.route(
+    'POST',
+    '/projects/checkout',
+    async (c) => {
+      const { repo, name } = await c.body();
+      const out = await checkout(store, String(repo || ''));
+      const p = store.addProject(out.dir, { name: name ? String(name) : undefined, repo: String(repo) });
+      app.broadcast('config', {});
+      c.send(200, { path: out.dir, existed: !!out.existed, name: p.name });
+    },
+    { doc: false },
+  );
+  r.route('GET', '/projects/origin', async (c) => c.send(200, { origin: await originAt(expand(c.query.get('path') || '.')) }), { doc: false });
   // Find git repos in the usual places so adding projects is one click.
-  r.route('GET', '/projects/discover', (c) => c.send(200, discoverRepos(new Set(store.config.projects.map((p) => p.path)))), { doc: false });
+  r.route('GET', '/projects/discover', (c) => c.send(200, discoverRepos(new Set(store.config.projects.map((p) => store.pathAt(p)).filter(Boolean)))), { doc: false });
   // The user's GitHub repos (gh's login), newest first, minus ones already added: one click clones.
   // Empty when gh isn't installed or signed in.
   r.route(
@@ -136,7 +144,7 @@ export function register(r, app) {
         .catch(() => null);
       if (!list) return c.send(200, []);
       const origins = await Promise.all(
-        store.config.projects.filter((p) => !p.machine).map((p) => git(p.path, ['remote', 'get-url', 'origin'], { timeout: 5000 }).catch(() => '')),
+        store.config.projects.map((p) => p.repo || (store.pathAt(p) ? git(store.pathAt(p), ['remote', 'get-url', 'origin'], { timeout: 5000 }).catch(() => '') : '')),
       );
       const have = new Set(origins.map((o) => parseRepo(o)?.gh?.toLowerCase()).filter(Boolean));
       c.send(
@@ -169,25 +177,3 @@ export function register(r, app) {
     c.send(200, { ok: true });
   });
 }
-
-// Git repos up to two levels under the usual folders, newest first, skipping known ones.
-function discoverRepos(known) {
-  const found = [];
-  const walk = (dir, depth) => {
-    if (found.length >= 60) return;
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    if (entries.some((e) => e.name === '.git')) {
-      if (!known.has(dir)) found.push({ path: dir, name: path.basename(dir), mtime: fs.statSync(dir).mtimeMs });
-      return;
-    }
-    if (depth <= 0) return;
-    for (const e of entries) if (e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules') walk(path.join(dir, e.name), depth - 1);
-  };
-  for (const r of REPO_ROOTS) walk(path.join(os.homedir(), r), 2);
-  return found.sort((a, b) => b.mtime - a.mtime).slice(0, 24);
-}