wisp-agents 0.12.0 → 0.14.0

package/server/machines.js

@@ -266,6 +266,11 @@ export class Machines extends EventEmitter {
     return m;
   }
 
+  // The harnesses the machine reported when it came online (Auto routes with these), or null.
+  agentsOf(id) {
+    return this.conns.get(id)?.remote?.agents || null;
+  }
+
   isOnline(id) {
     return this.conns.get(id)?.state === 'online';
   }

package/server/mcp-wisp.js

@@ -9,7 +9,7 @@ import fs from 'node:fs';
 import { WispClient } from './client.js';
 
 const VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
-const AGENTS = ['claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'];
+const AGENTS = ['auto', 'claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'];
 const DEFAULT_WAIT_S = 240; // stay under typical MCP client tool-call timeouts; call wisp_wait again for more
 
 const TOOLS = [
@@ -24,7 +24,7 @@ const TOOLS = [
       properties: {
         prompt: { type: 'string', description: 'The task, written as you would brief a colleague: goal, constraints, how to verify.' },
         cwd: { type: 'string', description: 'Absolute path of the project folder. Default: this MCP server’s working directory.' },
-        agent: { type: 'string', enum: AGENTS, description: 'Harness to run. Default: the user’s last pick in wisp.' },
+        agent: { type: 'string', enum: AGENTS, description: 'Harness to run; auto lets wisp pick harness and model from what worked before. Default: the user’s last pick in wisp.' },
         mode: { type: 'string', enum: ['plan', 'edits', 'auto'], description: 'plan = read-only, edits = auto-accept file edits, auto = no permission prompts. Default: the user’s pick.' },
         model: { type: 'string', description: 'Model id for that harness. Default: the user’s pick.' },
         effort: { type: 'string', description: 'Thinking level, e.g. low | medium | high.' },
@@ -66,8 +66,8 @@ const TOOLS = [
     name: 'wisp_reply',
     description:
       'Send a follow-up to a session; it resumes the same agent conversation. If the agent is waiting on a question, this answers it. ' +
-      'A follow-up sent while it runs interrupts it (queue=true waits for the run to finish instead).',
-    inputSchema: { type: 'object', properties: { id: { type: 'string' }, text: { type: 'string' }, queue: { type: 'boolean' } }, required: ['id', 'text'] },
+      'A follow-up sent while it runs interrupts it (queue=true waits for the run to finish instead). mode switches the session’s mode from this follow-up on.',
+    inputSchema: { type: 'object', properties: { id: { type: 'string' }, text: { type: 'string' }, queue: { type: 'boolean' }, mode: { type: 'string', enum: ['plan', 'edits', 'auto'] } }, required: ['id', 'text'] },
   },
   {
     name: 'wisp_stop',
@@ -118,7 +118,7 @@ async function callTool(name, a = {}) {
       return waitFor(a.id);
     case 'wisp_reply': {
       if (!a.text?.trim()) throw new Error('text is required');
-      const r = await c.reply(a.id, a.text.trim(), { queue: a.queue });
+      const r = await c.reply(a.id, a.text.trim(), { queue: a.queue, mode: a.mode });
       return r.answered ? 'Answered the agent’s question; it is continuing.' : r.interrupted ? 'Interrupted the run; it resumes with your message.' : r.queued ? 'Queued; it goes out when the current run finishes.' : 'Sent; the agent is working on it.';
     }
     case 'wisp_stop':

package/server/openapi.js

@@ -45,7 +45,28 @@ export function openapi({ version, port }) {
         },
       },
       '/agents': { get: { summary: 'Installed harnesses with their models and thinking levels (?fresh=1 detects again)', responses: { 200: json({ type: 'array', items: ref('Agent') }) } } },
+      '/router': {
+        get: { summary: 'Auto: the goal, settings, every harness · model with its learned chance of success and cost, and recent routes', responses: { 200: json({ type: 'object' }) } },
+        patch: { summary: 'Auto settings', requestBody: body({ type: 'object', properties: { goal: { enum: ['cheap', 'balanced', 'best'] }, explore: { type: 'boolean', description: 'Let Auto try new models on a few tasks' }, allowed: { type: 'array', items: { type: 'string' }, description: 'Harness ids Auto may pick; empty or null = all' } } }), responses: { 200: json({ type: 'object' }) } },
+      },
+      '/router/reset': { post: { summary: 'Forget what Auto learned here (the shipped starting point stays)', responses: { 200: json({ type: 'object' }) } } },
       '/agents/recheck': { post: { summary: 'Detect harnesses and models again, here and on every online machine', responses: { 200: json({ type: 'array', items: ref('Agent') }) } } },
+      '/feedback': {
+        post: {
+          summary: 'Send feedback to the wisp team: thumbs on a turn and/or a note. Sent even with usage stats off; WISP_FEEDBACK=0 turns it off',
+          requestBody: body({
+            type: 'object',
+            properties: {
+              rating: { type: ['string', 'null'], enum: ['up', 'down', null], description: 'With turnId: kept on that turn; null takes it back' },
+              text: { type: 'string', maxLength: 4000 },
+              sessionId: { type: 'string', description: 'Adds that run\'s harness, model and status (never the prompt or result)' },
+              turnId: { type: 'string' },
+              source: { type: 'string', description: 'turn | command | dialog' },
+            },
+          }),
+          responses: { 200: json({ type: 'object', properties: { ok: { type: 'boolean' }, sent: { type: 'boolean', description: 'false: kept in ~/.wisp/feedback-outbox.json and retried' }, available: { type: 'boolean' } } }), 400: err[400] },
+        },
+      },
       '/config': {
         get: { summary: 'Launcher defaults, projects, webhooks', responses: { 200: json({ type: 'object' }) } },
         patch: {
@@ -140,7 +161,7 @@ export function openapi({ version, port }) {
         get: { summary: 'Phone channels (ntfy, Telegram) with secrets masked, and their status', responses: { 200: json({ type: 'object' }) } },
         put: {
           summary: 'Configure phone channels. A masked token (••••1234) means unchanged',
-          requestBody: body({ type: 'object', properties: { events: { type: 'array', items: { enum: ['waiting', 'finished'] } }, ntfy: { type: 'object', properties: { enabled: { type: 'boolean' }, server: { type: 'string' }, topic: { type: 'string' }, token: { type: 'string' } } }, telegram: { type: 'object', properties: { enabled: { type: 'boolean' }, token: { type: 'string' }, unlink: { type: 'boolean' } } } } }),
+          requestBody: body({ type: 'object', properties: { events: { type: 'array', items: { enum: ['waiting', 'finished'] } }, ntfy: { type: 'object', properties: { enabled: { type: 'boolean' }, server: { type: 'string' }, topic: { type: 'string' }, token: { type: 'string' } } }, telegram: { type: 'object', properties: { enabled: { type: 'boolean' }, token: { type: 'string' }, unlink: { type: 'boolean' }, allowStart: { type: 'boolean', description: '/new in the linked chat starts tasks' }, project: { type: 'string', description: 'Project id /new uses without @name; empty = last used' } } } } }),
           responses: { 200: json({ type: 'object' }), 400: err[400] },
         },
       },
@@ -184,7 +205,7 @@ export function openapi({ version, port }) {
         parameters: [id],
         post: {
           summary: 'Follow up (answers a pending ask_user question if there is one)',
-          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' } } }),
+          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' } } }),
           responses: { 200: json({ type: 'object', properties: { answered: { type: 'boolean' }, queued: { type: 'boolean' }, interrupted: { type: 'boolean' }, ahead: { type: 'integer' } } }), 400: err[400] },
         },
       },
@@ -248,7 +269,8 @@ export function openapi({ version, port }) {
           properties: {
             prompt: { type: 'string' },
             cwd: { type: 'string', description: 'Project folder (absolute; ~ allowed). Default: the server’s cwd' },
-            agent: { enum: ['claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'], default: 'claude' },
+            agent: { enum: ['auto', 'claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'], default: 'auto', description: 'auto: wisp picks the harness and model from what worked before; model is then the goal (cheap, balanced, best)' },
+            important: { type: 'boolean', description: 'With agent auto: no exploring, take the pick with the best record' },
             mode: { enum: ['plan', 'edits', 'auto'], default: 'edits' },
             model: { type: 'string' },
             effort: { type: 'string', description: 'Thinking level: low, medium, high, xhigh, max (per harness)' },

package/server/protocol.js

@@ -14,6 +14,10 @@ presentation you put in your final message. Work autonomously:
 - If the task is done but there is a choice for later, end with a "question" block instead.
 - Verify your work where it is cheap (tests, type-check, lint, build) and report results honestly,
   including failures. Never claim something passes that you did not run.
+- Your final message ends the task. Don't end a turn with "I'll report once it has finished": wait for
+  background work (builds, test runs, background shells) to finish, then report its result. Anything
+  still running when you finish may be stopped; if you leave something up on purpose (a dev server),
+  say so.
 - The user can follow up; follow-ups resume this same session.
 - Attached files (images, video, docs) are listed in an <attachments> section of the prompt.
 

package/server/remote.js

@@ -4,26 +4,37 @@
 //   ntfy      notification with up to 3 buttons. A tap makes the ntfy app POST a signed answer to
 //             <topic>-reply, which wisp polls. No free text (ntfy has no reply box).
 //   Telegram  a bot message with buttons; reply to the message to answer in your own words or
-//             send a follow-up. Linked to one chat with a one-time code.
+//             send a follow-up. Linked to one chat with a one-time code. With allowStart on,
+//             /new [@project] <task> starts a task and /projects lists where it can run.
 
 import { createHmac, randomBytes, randomInt, timingSafeEqual } from 'node:crypto';
 
 const KIND = { a: 'answer', r: 'reply', d: 'done' };
 const CODE = { answer: 'a', reply: 'r', done: 'd' };
 const MAX_TG_IDS = 20;
+const STALE_S = 10 * 60;
 const sleep = (ms, signal) => new Promise((r) => (signal?.aborted ? r() : (setTimeout(r, ms).unref?.(), signal?.addEventListener('abort', r, { once: true }))));
 const clip = (s, n) => (String(s || '').length > n ? `${String(s).slice(0, n - 1)}…` : String(s || ''));
+// /new @name: exact name, then name prefix, then anywhere in the name or path.
+export function findProject(projects, q) {
+  const n = String(q || '').toLowerCase();
+  if (!n) return null;
+  const name = (p) => String(p.name || '').toLowerCase();
+  return projects.find((p) => name(p) === n) || projects.find((p) => name(p).startsWith(n)) || projects.find((p) => name(p).includes(n) || String(p.path || '').toLowerCase().includes(n)) || null;
+}
 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.
-  constructor({ store, act, onChange = () => {} }) {
-    Object.assign(this, { store, act, onChange });
+  // 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 });
     this.status = { ntfy: null, telegram: null };
     this.tgElsewhere = new Map(); // Telegram message id -> session id, for sessions on a machine (server/machines.js)
     this.ac = null;
     this.ntfyPollMs = 4000;
     this.tgLongPoll = 25;
+    this.tgOffset = 0;
   }
 
   get cfg() {
@@ -189,23 +200,19 @@ export class Remote {
       text: clip(`${msg.title}\n\n${msg.text}${s ? '\n\n↩ Reply to this message to answer or follow up.' : ''}`, 4000),
       ...(buttons.length && { reply_markup: { inline_keyboard: buttons } }),
     });
-    if (s && sent?.message_id && this.store.get(s.id) === s) {
-      s.remote = { ...s.remote, tg: [...(s.remote?.tg || []), sent.message_id].slice(-MAX_TG_IDS) };
-      this.store.save(s);
-    } else if (s && sent?.message_id) {
-      this.tgElsewhere.set(sent.message_id, s.id);
-      if (this.tgElsewhere.size > 200) this.tgElsewhere.delete(this.tgElsewhere.keys().next().value);
-    }
+    if (s && sent?.message_id) this.#tgLink(s.id, sent.message_id);
   }
 
+  // The offset outlives restarts (every settings change restarts the loop), or Telegram would
+  // hand back updates already handled and a /new would start its task twice.
   async #tgLoop(signal) {
-    let offset = 0;
     while (!signal.aborted) {
       try {
-        const updates = await this.#tg('getUpdates', { offset, timeout: this.tgLongPoll, allowed_updates: ['message', 'callback_query'] }, signal);
+        const updates = await this.#tg('getUpdates', { offset: this.tgOffset, timeout: this.tgLongPoll, allowed_updates: ['message', 'callback_query'] }, signal);
         if (this.status.telegram?.error) this.#mark('telegram', { ok: true, error: '' });
         for (const u of updates) {
-          offset = u.update_id + 1;
+          if (u.update_id < this.tgOffset) continue;
+          this.tgOffset = u.update_id + 1;
           await this.#fromTelegram(u).catch((err) => console.warn(`wisp: telegram: ${err.message}`));
         }
       } catch (err) {
@@ -241,19 +248,88 @@ export class Remote {
       return;
     }
     if (String(m.chat.id) !== String(t.chatId)) return;
+    const cmd = m.text.match(/^\/(\w+)(?:@\w+)?\s*([\s\S]*)$/);
+    if (cmd && ['new', 'projects', 'help', 'start'].includes(cmd[1].toLowerCase())) return this.#tgCommand(cmd[1].toLowerCase(), cmd[2].trim(), m, say);
     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('Reply to one of wisp’s messages to answer it or send a follow-up.');
+    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 });
   }
 
+  async #tgCommand(name, arg, m, say) {
+    const t = this.cfg.telegram;
+    const off = 'Starting tasks from Telegram is off. Turn it on in wisp → Phone → Telegram.';
+    const projects = this.store.config.projects;
+    if (name === 'help' || name === 'start')
+      return say(
+        t.allowStart
+          ? 'Send /new <task> to start a task in your default project, or /new @project <task> to pick one (/projects lists them). Reply to wisp’s messages to answer or follow up.'
+          : `Reply to wisp’s messages to answer or follow up. ${off}`,
+      );
+    if (!t.allowStart) return say(off);
+    // Telegram keeps updates for a day: don't start what was sent while wisp was off.
+    if (name === 'new' && m.date && Date.now() / 1000 - m.date > STALE_S) return say('That /new arrived while wisp was offline, so it didn’t start. Send it again to run it now.', { reply_to_message_id: m.message_id });
+    if (name === 'projects') {
+      if (!projects.length) return say('No projects yet. Open a folder in wisp first.');
+      const def = this.defaultProject();
+      const where = (id) => (this.store.config.machines || []).find((x) => x.id === id)?.name || id;
+      const lines = projects.map((p) => `• ${p.name}${p.machine ? ` (on ${where(p.machine)})` : ''}${p === def ? '  ← default' : ''}`);
+      return say(clip(`Projects:\n${lines.join('\n')}\n\n/new @name <task> runs in one of them.`, 4000));
+    }
+    let prompt = arg;
+    let project = this.defaultProject();
+    const at = arg.match(/^@(\S+)\s*([\s\S]*)$/);
+    if (at) {
+      project = findProject(projects, at[1]);
+      if (!project) return say(`No project matches “${clip(at[1], 60)}”. Send /projects to see them.`);
+      prompt = at[2].trim();
+    }
+    if (!prompt) return say('What should it do? Send /new <task>, or /new @project <task>.');
+    if (!project) return say('No projects yet. Open a folder in wisp first.');
+    let s;
+    try {
+      s = await this.launch({ project, prompt });
+    } catch (err) {
+      return say(`Couldn’t start it: ${clip(err.message, 300)}`, { reply_to_message_id: m.message_id });
+    }
+    const sent = await say(clip(`▶ Started in ${project.name}: ${s?.title || prompt}\n\nwisp will message you when it needs you or is done. Reply to this message to follow up.`, 4000), { reply_to_message_id: m.message_id });
+    if (s?.id && sent?.message_id) this.#tgLink(s.id, sent.message_id);
+  }
+
+  // The project /new uses without an @name: the one picked in settings, else the last used.
+  defaultProject() {
+    const projects = this.store.config.projects;
+    const id = this.cfg.telegram?.project;
+    return (id && projects.find((p) => p.id === id)) || [...projects].sort((a, b) => (b.lastUsedAt || b.addedAt || 0) - (a.lastUsedAt || a.addedAt || 0))[0] || null;
+  }
+
+  // Replies to a Telegram message reach the session it belongs to.
+  #tgLink(sessionId, messageId) {
+    const s = this.store.get(sessionId);
+    if (s) {
+      s.remote = { ...s.remote, tg: [...(s.remote?.tg || []), messageId].slice(-MAX_TG_IDS) };
+      this.store.save(s);
+      return;
+    }
+    this.tgElsewhere.set(messageId, sessionId);
+    if (this.tgElsewhere.size > 200) this.tgElsewhere.delete(this.tgElsewhere.keys().next().value);
+  }
+
   // For the settings view: config with secrets masked, plus channel health.
   view() {
     const c = this.cfg;
     return {
       events: c.events || ['waiting', 'finished'],
       ntfy: { enabled: !!c.ntfy?.enabled, server: c.ntfy?.server || 'https://ntfy.sh', topic: c.ntfy?.topic || '', token: mask(c.ntfy?.token) },
-      telegram: { enabled: !!c.telegram?.enabled, token: mask(c.telegram?.token), linked: !!c.telegram?.chatId, chatName: c.telegram?.chatName || '', linkCode: c.telegram?.chatId ? '' : c.telegram?.linkCode || '' },
+      telegram: {
+        enabled: !!c.telegram?.enabled,
+        token: mask(c.telegram?.token),
+        linked: !!c.telegram?.chatId,
+        chatName: c.telegram?.chatName || '',
+        linkCode: c.telegram?.chatId ? '' : c.telegram?.linkCode || '',
+        allowStart: !!c.telegram?.allowStart,
+        project: c.telegram?.project || '',
+      },
       status: this.status,
     };
   }
@@ -272,9 +348,19 @@ export class Remote {
     }
     if (body.telegram) {
       const prev = c.telegram || {};
-      const token = keep(body.telegram.token, prev.token) || '';
+      const token = (body.telegram.token === undefined ? prev.token : keep(body.telegram.token, prev.token)) || ''; // missing = unchanged
       const relink = body.telegram.unlink || token !== prev.token;
-      c.telegram = { ...prev, enabled: !!(body.telegram.enabled ?? prev.enabled), token, ...(relink && { chatId: null, chatName: '', linkCode: token ? String(randomInt(100000, 999999)) : '' }) };
+      if (token !== prev.token) this.tgOffset = 0; // another bot, another update counter
+      const project = body.telegram.project ?? prev.project ?? '';
+      if (project && !this.store.config.projects.some((p) => p.id === project)) throw Object.assign(new Error('Unknown project'), { status: 400 });
+      c.telegram = {
+        ...prev,
+        enabled: !!(body.telegram.enabled ?? prev.enabled),
+        token,
+        allowStart: !!(body.telegram.allowStart ?? prev.allowStart),
+        project,
+        ...(relink && { chatId: null, chatName: '', linkCode: token ? String(randomInt(100000, 999999)) : '' }),
+      };
     }
     this.store.saveConfig();
     this.start();

package/server/router-priors.json

@@ -0,0 +1,54 @@
+{
+  "version": "pilot-2026-10-18",
+  "source": "wisp-bench pilot: 121 runs on SWE-bench Verified, Harness-Bench and replayed wisp PRs, graded by hidden tests (first attempt). Thin: treat as a starting point.",
+  "arms": {
+    "opencode:opencode/deepseek-v4.1-flash-free": {
+      "a": 10,
+      "b": 0,
+      "usd": 0.0,
+      "min": 3.1
+    },
+    "claude:haiku": {
+      "a": 18,
+      "b": 3,
+      "usd": 0.017,
+      "min": 1.5
+    },
+    "claude:sonnet": {
+      "a": 18,
+      "b": 3,
+      "usd": 0.137,
+      "min": 0.7
+    },
+    "grok:grok-4.7": {
+      "a": 10,
+      "b": 2,
+      "usd": 0.984,
+      "min": 5.2
+    },
+    "claude:opus": {
+      "a": 17,
+      "b": 4,
+      "usd": 0.344,
+      "min": 1.3
+    },
+    "antigravity:gemini-3.8-flash-medium": {
+      "a": 4,
+      "b": 1,
+      "usd": 0.054,
+      "min": 4.4
+    },
+    "codex:": {
+      "a": 19,
+      "b": 5,
+      "usd": 0.129,
+      "min": 0.6
+    },
+    "antigravity:gemini-4-argon-medium": {
+      "a": 5,
+      "b": 2,
+      "usd": 0.677,
+      "min": 4.7
+    }
+  }
+}