wisp-agents 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -5,6 +5,26 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [0.13.0] - 2026-10-18
+
+### Added
+
+- **Start tasks from Telegram.** In **Phone → Telegram**, switch on **Start tasks from Telegram**, then send your bot `/new fix the flaky login test`. The task runs in your default project (the last used, or the one you pick in that section) with the launcher's harness, model and mode. `/new @api add rate limiting` picks a project by name, and `/projects` lists them. The bot replies **▶ Started**, and replying to that message sends a follow-up. Its card shows **Telegram** as where it came from. It's off by default, only the linked chat can start tasks, and a `/new` sent while wisp was offline is not run later. API: `PUT /api/remote` with `telegram.allowStart` and `telegram.project`.
+
+- **Feedback for the wisp team.** Each finished turn has a small 👍 / 👎 at the end of its trail. It stays faint until you hover the turn. Click again to take the rating back. 👎 opens one optional line for what went wrong (↵ sends, Esc skips). You can also type `/feedback <note>` in the launcher or any follow-up box, or use `⌘K` → **Send feedback…** for a short dialog. Bare `/feedback` opens the dialog too. It thanks you right away; offline, the feedback is kept and sent later. It goes to PostHog with the harness, model and status of the run, never your prompt, output or code. It's sent even with usage stats off, and `WISP_FEEDBACK=0` turns it off. API: `POST /api/feedback`.
+
+### Changed
+
+- **Switch modes in a follow-up.** Each task's follow-up box now has the same mode button as the launcher (Plan, Edits, Full auto; Shift+Tab cycles). Start in Plan, read the plan, then pick **Edits** and say "go ahead": that follow-up and the ones after it run in the new mode. Any mode can switch to any other. The pick only takes effect when you send, and the follow-up shows the new mode next to its model. A follow-up queued while the agent works keeps its own mode, so the run already going isn't affected. A task started in Plan has no worktree, so edits after switching land in the project folder. API: `mode` on `POST /api/sessions/{id}/reply`; CLI: `wisp reply <id> "…" --mode edits`; MCP: `mode` on `wisp_reply`.
+
+- **Compare more than two harnesses.** Clicking **vs** in the launcher adds a second harness as before, and a **+** at the end of the pill now adds a third and a fourth (four side by side, the server's limit). Each one sits behind its own **vs**: hover it for **×** to drop just that harness. A new one starts on a harness that isn't in the pill yet. With three or four, the pill shows logos only (hover a logo for harness, model and thinking level), and the mode and Subagents labels fold to icons so the bar stays on one line.
+
+### Fixed
+
+- Changing a Telegram setting through the API without a `token` no longer clears the bot token and unlinks the chat. After a settings change, Telegram no longer re-delivers messages wisp already handled.
+
+- Following up on a task now keeps it on screen as it moves to **Working**, and again when it lands back in **Needs you**. On a long card, the previous answer folding away used to pull the whole card off the top of the screen, so you lost the task you had just replied to. The composer now holds still and the new exchange appears where you were typing.
+
 ## [0.12.0] - 2026-10-18
 
 ### Added
@@ -220,7 +240,8 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 - Session queue with follow-ups, answers to agent questions, terminal takeover and mark-as-done.
 - Older turns are folded, with a floating collapse-all button and back-to-top.
 
-[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.12.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.13.0...HEAD
+[0.13.0]: https://github.com/M0xoo/wisp/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/M0xoo/wisp/compare/v0.11.0...v0.12.0
 [0.11.0]: https://github.com/M0xoo/wisp/compare/v0.10.0...v0.11.0
 [0.10.0]: https://github.com/M0xoo/wisp/compare/v0.9.0...v0.10.0

package/README.md

@@ -53,9 +53,9 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 | 🤝 **Subagents** | Give the lead agent a team on other harnesses (e.g. Claude Code hands tests to Codex ×3). It delegates through a `delegate` tool; their edits land in its worktree. See [Subagents](#subagents). |
 | ⏪ **Checkpoints & rollback** | Every turn is snapshotted first. Restore to before any turn, revert a single file, or re-run a command block from the presentation. |
 | ⚖️ **Compare** | Run one task on two harnesses side by side, and keep the better run. |
-| 🧾 **Recipes & triggers** | Saved prompts with `{params}` (`wisp run release 0.12.0`), run by hand, on a schedule, when CI fails, or when an issue is labelled. |
+| 🧾 **Recipes & triggers** | Saved prompts with `{params}` (`wisp run release 0.13.0`), run by hand, on a schedule, when CI fails, or when an issue is labelled. |
 | 📊 **Usage** | Spend, success rate and questions per project and per harness · model. |
-| 📱 **Phone** | Questions and finished tasks on ntfy or Telegram; answer from there. |
+| 📱 **Phone** | Questions and finished tasks on ntfy or Telegram; answer from there, or start a task with `/new`. |
 | 🔐 **Permission modes** | Choose **Plan** (read-only), **Edits** (file edits auto-accepted), or **Full auto** for each launch. `Shift+Tab` in the prompt cycles modes. |
 | 🔌 **Integrations** | An MCP server (`wisp mcp`), an agent skill, a scriptable CLI, a JS SDK, an OpenAPI-described HTTP API, and webhooks. Hand tasks to wisp from Claude Code, Codex, opencode, Cursor, scripts or CI. |
 | 🪶 **No runtime dependencies** | The server uses only Node built-ins. Electron is needed only for the desktop app. |
@@ -121,11 +121,11 @@ wisp "add a test" --wait          # block until it finishes, print the presentat
 wisp ls --state running,waiting   # list sessions
 wisp show <id>                    # state + latest presentation
 wisp wait <id>                    # until it finishes or asks you something
-wisp reply <id> "also do X"       # follow up (answers a pending question)
+wisp reply <id> "also do X"       # follow up (answers a pending question; --mode to switch)
 wisp stop <id>
 wisp ship <id> [--draft]          # commit, push and open a PR for a worktree task
 wisp merge <id>                   # squash-merge its PR, fast-forward your local main
-wisp run release 0.12.0            # run a recipe; values fill its {params} (or version=0.12.0)
+wisp run release 0.13.0            # run a recipe; values fill its {params} (or version=0.13.0)
 wisp recipes                      # list recipes
 wisp usage [--days 7]             # spend and outcomes
 wisp mcp                          # MCP server for other agents and editors
@@ -305,7 +305,7 @@ Before each turn, wisp snapshots the git working tree (pinned at `refs/wisp/chec
 Prepare release {version}: update CHANGELOG, README and docs/, bump package.json, tag v{version}.
 ```
 
-Make one from ⌘K → *Recipes*, or *Save as recipe…* on any card. A recipe may pin a project, harness, model and mode. Run it from ⌘K (*Run: Release*), from the Recipes view, or from a terminal: `wisp run release 0.12.0` fills the fields in order, `wisp run release version=0.12.0` by name.
+Make one from ⌘K → *Recipes*, or *Save as recipe…* on any card. A recipe may pin a project, harness, model and mode. Run it from ⌘K (*Run: Release*), from the Recipes view, or from a terminal: `wisp run release 0.13.0` fills the fields in order, `wisp run release version=0.13.0` by name.
 
 **Triggers** launch sessions on their own while wisp is open (⌘K → *Triggers*):
 
@@ -327,6 +327,7 @@ Settings → *Phone* sends questions and finished tasks to your phone and takes
 
 - **[ntfy](https://ntfy.sh)**: subscribe to the topic in the ntfy app. Notifications carry up to three buttons (the question's options, or *Mark done*); a tap sends a signed answer back. Use a long random topic (wisp suggests one): anyone who knows it can read the notifications, but only wisp can make answers that count.
 - **Telegram**: create a bot with @BotFather, paste its token, then send `/link <code>` to the bot. Tap a button to answer, or reply to a message to answer in your own words or send a follow-up.
+  Switch on **Start tasks from Telegram** to launch from the chat: `/new <task>` runs in the default project (the last used, or the one you pick), `/new @project <task>` picks one by name and `/projects` lists them. Tasks use the launcher's harness, model and mode. It's off by default, and only the linked chat can start tasks.
 
 They receive titles, summaries and questions (with their context), never code or diffs.
 
@@ -370,6 +371,14 @@ wisp sends anonymous usage stats and error reports to [PostHog](https://posthog.
 
 It is also off whenever `CI` is set.
 
+### Feedback
+
+Rate any result with 👍 / 👎 at the end of the turn (👎 asks for an optional line on what went wrong), type `/feedback <your note>` in any prompt box, or use `⌘K` → *Send feedback*. It goes to the wisp team on PostHog as a `turn_rated` or `feedback` event.
+
+**What is sent:** your rating and note (with your home directory replaced by `~`), the wisp version and OS. For a rated turn it also sends the run's harness, model, mode, status, duration and presentation block types. Your prompt, the agent's output and your code are **never sent**.
+
+You send feedback on purpose, so it goes out even with usage stats off, under a one-off id. Offline, it waits in `~/.wisp/feedback-outbox.json` and is sent later. `WISP_FEEDBACK=0` turns it off and hides the thumbs.
+
 ## Contributing
 
 Issues and PRs are welcome. wisp has no build step: edit `web/` or `server/`, then run `npm run dev` (or `npm run dev:web`) to see your changes.

package/bin/wisp.js

@@ -24,7 +24,7 @@ const HELP = `usage:
   wisp ls                       list sessions        (--state running,waiting  --limit N)
   wisp show <id>                state + latest presentation as markdown
   wisp wait <id>                block until it finishes or asks you something
-  wisp reply <id> "text"        follow up (answers a pending question)   (--queue)
+  wisp reply <id> "text"        follow up (answers a pending question)   (--queue  --mode plan|edits|auto)
   wisp stop <id>                stop a run
   wisp ship <id>                commit, push and open a PR for a worktree session   (--draft)
   wisp merge <id>               squash-merge its PR and sync your local base branch
@@ -132,7 +132,7 @@ async function scripted(cmd, args) {
     }
     case 'reply': {
       const id = need(args[0], 'session id');
-      const r = await wisp.reply(id, need(args.slice(1).join(' ').trim(), 'text'), { queue: flags.queue });
+      const r = await wisp.reply(id, need(args.slice(1).join(' ').trim(), 'text'), { queue: flags.queue, mode: flags.mode || undefined });
       if (!flags.wait) return out(r, r.answered ? '  ✓ answered' : r.interrupted ? '  ✓ interrupted; resuming with your message' : r.queued ? '  ✓ queued' : '  ✓ sent');
       return show(id, await wisp.wait(id));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wisp-agents",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Launch coding agents, skip the transcript, read the presentation.",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "app": "node bin/wisp.js",
     "dev": "WISP_DEV=1 node bin/wisp.js",
     "dev:web": "node --watch-path=server bin/wisp.js --no-open",
-    "test": "node --test test/proc.test.js test/terminal.test.js test/adapters.test.js test/e2e.test.js test/fuzzy.test.js test/integrations.test.js test/update.test.js test/learn.test.js test/ship.test.js test/subagents.test.js test/machines.test.js",
+    "test": "node --test test/proc.test.js test/terminal.test.js test/adapters.test.js test/e2e.test.js test/fuzzy.test.js test/integrations.test.js test/update.test.js test/learn.test.js test/ship.test.js test/subagents.test.js test/machines.test.js test/feedback.test.js",
     "test:real": "node test/real-clis.mjs",
     "prepublishOnly": "node --check bin/wisp.js && node --check bin/mac-app.js && node -e \"import('./server/index.js').then(() => import('./server/mcp-wisp.js'))\" && node --check electron/main.js"
   },

package/server/client.js

@@ -155,7 +155,7 @@ export class WispClient {
 
   // A follow-up. If the agent is blocked on ask_user, this answers it. queue: wait for the
   // current run instead of interrupting it (default: the user's setting).
-  reply = (id, text, { attachments, queue } = {}) => this.request('POST', `/sessions/${id}/reply`, { text, attachments, queue });
+  reply = (id, text, { attachments, queue, mode } = {}) => this.request('POST', `/sessions/${id}/reply`, { text, attachments, queue, mode });
 
   // Upload a file (path, Buffer or Uint8Array) to attach to a launch or reply. Returns { id, … }.
   async upload(file, { name, type } = {}) {

package/server/index.js

@@ -11,7 +11,7 @@ import { Runner, summarize, newId, workdir } from './runner.js';
 import { adapters, listAgents } from './adapters/index.js';
 import { welcomeSession } from './welcome.js';
 import { openInTerminal, TERMINALS, shq } from './terminal.js';
-import { Telemetry, envDisabled } from './telemetry.js';
+import { Telemetry, envDisabled, feedbackAvailable } from './telemetry.js';
 import { blocksToMarkdown, sessionToMarkdown } from './render.js';
 import { openapi } from './openapi.js';
 import { Updater } from './update.js';
@@ -226,9 +226,9 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
   }
 
   // A follow-up from anywhere (UI, CLI, phone). An archived session may have lost its worktree.
-  async function replyTo(s, text, attachments = [], queue) {
+  async function replyTo(s, text, attachments = [], queue, mode) {
     await ensureWorktree(s.worktree);
-    return runner.reply(s, text, attachments, { queue: queue ?? store.config.defaults.followUp === 'queue' });
+    return runner.reply(s, text, attachments, { queue: queue ?? store.config.defaults.followUp === 'queue', mode });
   }
 
   const markDone = (s) => {
@@ -257,6 +257,15 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
   const remote = new Remote({
     store,
     onChange: () => broadcast('remote', {}),
+    // /new from Telegram: the launcher's remembered harness, model and mode, like `wisp "…"`.
+    launch: async ({ project, prompt }) => {
+      const d = store.config.defaults;
+      const agent = d.agent || 'claude';
+      const model = d.models?.[agent] ?? d.model ?? '';
+      const [s] = await launchAny({ prompt, cwd: project.path, machine: project.machine || undefined, agent, model, mode: d.mode || 'edits' }, { kind: 'telegram', name: 'Telegram' });
+      broadcast('config', {});
+      return s;
+    },
     act: async ({ sessionId, kind, ref, index, text }) => {
       const ops = await sessionOps(sessionId).catch((err) => ({ error: err.message }));
       if (ops?.error) return `Can’t reach it: ${ops.error}`;
@@ -507,7 +516,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
     }
 
     if (root === 'config') {
-      if (m === 'GET') return send(res, 200, { ...store.config, remote: undefined, home: os.homedir(), cwd: process.cwd(), terminals: TERMINALS, telemetry: { available: !envDisabled(), enabled: telemetry.enabled } });
+      if (m === 'GET') return send(res, 200, { ...store.config, remote: undefined, home: os.homedir(), cwd: process.cwd(), terminals: TERMINALS, telemetry: { available: !envDisabled(), enabled: telemetry.enabled }, feedback: feedbackAvailable() });
       if (m === 'PATCH') {
         const body = await readJson(req);
         if (body.defaults) Object.assign(store.config.defaults, body.defaults);
@@ -722,6 +731,9 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
 
     if (root === 'machines') return machinesApi(req, res, url, id, action);
 
+    // Feedback for the wisp team: thumbs on a turn and/or a note. { rating?, text?, sessionId?, turnId? }
+    if (root === 'feedback' && m === 'POST') return send(res, 200, await sendFeedback(await readJson(req)));
+
     if (root === 'sessions') {
       if (id && splitId(id)) return machineSessionApi(req, res, url, splitId(id), action);
       if (!id) {
@@ -742,9 +754,9 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
         }
         if (m === 'POST') {
           const body = await readJson(req);
-          // A machine's wisp hands on where a recipe or trigger launch came from.
+          // A machine's wisp hands on where a recipe, trigger or Telegram launch came from.
           const o = body.origin;
-          const origin = o && (o.kind === 'recipe' || o.kind === 'trigger') ? { kind: o.kind, id: String(o.id || ''), name: String(o.name || '') } : null;
+          const origin = o && ['recipe', 'trigger', 'telegram'].includes(o.kind) ? { kind: o.kind, id: String(o.id || ''), name: String(o.name || '') } : null;
           const out = await launchAny(body, origin);
           return send(res, 201, out.length > 1 ? { ...out[0], group: out } : out[0]);
         }
@@ -836,10 +848,11 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
       }
 
       if (action === 'reply' && m === 'POST') {
-        const { text, attachments, queue } = await readJson(req);
+        const { text, attachments, queue, mode } = await readJson(req);
         if (!text?.trim()) return send(res, 400, { error: 'text required' });
         if (s.agent === 'wisp') return send(res, 400, { error: 'This is the tour — launch a real wisp to follow up.' });
-        return send(res, 200, await replyTo(s, text.trim(), resolveAttachments(attachments), queue));
+        if (mode !== undefined && !MODES.has(mode)) return send(res, 400, { error: 'mode must be plan, edits or auto.' });
+        return send(res, 200, await replyTo(s, text.trim(), resolveAttachments(attachments), queue, mode));
       }
 
       if (action === 'queue' && m === 'DELETE') {
@@ -1030,6 +1043,48 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
   }
 
   // /api/sessions/<id>@<machine>/…: passed through to that machine's wisp, ids rewritten.
+  // A rating sticks to its turn (it shows on the card and can be taken back). What goes out is
+  // the rating, the user's own words, and how the run was set up — never the prompt or the result.
+  async function sendFeedback({ rating, text, sessionId, turnId, source } = {}) {
+    if (rating !== undefined && rating !== null && rating !== 'up' && rating !== 'down') throw Object.assign(new Error('rating must be up or down'), { status: 400 });
+    text = String(text || '').trim();
+    if (rating === undefined && !text) throw Object.assign(new Error('Write something, or pick 👍 / 👎.'), { status: 400 });
+    // A session on a machine: that wisp keeps the rating on its turn and sends it.
+    const at = sessionId && splitId(sessionId);
+    if (at) {
+      try {
+        return await machines.json(at.machine, 'POST', '/feedback', { rating, text, sessionId: at.id, turnId, source });
+      } catch (err) {
+        if (err.status === 400) throw err; // offline, or an older wisp there: send it from here, without the run
+      }
+    }
+    const s = sessionId && !at ? store.get(sessionId) : null;
+    if (sessionId && !at && !s) throw Object.assign(new Error('no such session'), { status: 404 });
+    const turn = s && (turnId ? s.turns.find((t) => t.id === turnId) : s.turns.at(-1));
+    if (turnId && s && !turn) throw Object.assign(new Error('no such turn'), { status: 404 });
+    // Only thumbs on a turn stick to it; a rating in the feedback dialog is about wisp as a whole.
+    if (turn && turnId && rating !== undefined) {
+      turn.feedback = rating ? { rating, at: Date.now() } : undefined;
+      store.save(s);
+      broadcast('turn', { sessionId: s.id, turnId: turn.id });
+    }
+    const blocks = turn?.presentation?.blocks || [];
+    const context = turn && {
+      ...run(s, turn),
+      status: turn.status,
+      heroStatus: blocks.find((b) => b.type === 'hero')?.status,
+      blockTypes: [...new Set(blocks.map((b) => b.type))],
+      durationMs: turn.endedAt ? turn.endedAt - turn.startedAt : undefined,
+      tour: s.agent === 'wisp' || undefined,
+    };
+    const props = { ...context, rating: rating || undefined, source: String(source || (turn ? 'turn' : 'app')).slice(0, 20), machine: at ? true : undefined };
+    // Thumbs on a turn count as a rating; anything written, or sent from the dialog, is 'feedback'.
+    const event = text || !turnId ? 'feedback' : 'turn_rated';
+    if (event === 'turn_rated' && rating === null) props.cleared = true;
+    const sent = await telemetry.feedback(event, { ...props, text: text || undefined });
+    return { ok: true, sent, available: feedbackAvailable() };
+  }
+
   async function machineSessionApi(req, res, url, at, action) {
     const m = req.method;
     const mid = at.machine;

package/server/mcp-wisp.js

@@ -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

@@ -46,6 +46,22 @@ 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') }) } } },
       '/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 +156,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 +200,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] },
         },
       },

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/runner.js

@@ -13,6 +13,7 @@ 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 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.
@@ -70,7 +71,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) => {
@@ -138,8 +139,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 +153,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,6 +257,7 @@ 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 });
@@ -317,6 +323,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,
@@ -391,6 +398,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);
     };