wisp-agents 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -5,6 +5,19 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-10-17
+
+### Added
+
+- Anonymous usage stats and error reports via [PostHog](https://posthog.com): which agents, models and modes are used, run outcomes and timings, and errors (agent failures, server errors, crashes) with paths scrubbed. Never sends prompts, output, paths or project names. Turn it off in Settings → *Anonymous usage stats*, or with `WISP_TELEMETRY=0` / `DO_NOT_TRACK=1`; always off when `CI` is set. See the Telemetry section of the README.
+
+## [0.4.0] - 2026-10-17
+
+### Added
+
+- Thinking level in the harness · model picker: Default / Low / Medium / High / X-High / Max under the model list, remembered per harness and shown on the launcher button. Claude Code gets `--effort`, Codex `-c model_reasoning_effort=…`, opencode `--variant` (levels read per model from `opencode models --verbose`). Cursor bakes effort into its model ids, so it has no separate selector.
+- Take over in [cmux](https://cmux.dev): opens a new cmux workspace in the project running the resume command. Auto-detected when wisp is started from a cmux terminal.
+
 ## [0.3.0] - 2026-10-17
 
 ### Added
@@ -76,7 +89,9 @@ 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.3.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.5.0...HEAD
+[0.5.0]: https://github.com/M0xoo/wisp/compare/v0.4.0...v0.5.0
+[0.4.0]: https://github.com/M0xoo/wisp/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/M0xoo/wisp/compare/v0.2.2...v0.3.0
 [0.2.2]: https://github.com/M0xoo/wisp/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/M0xoo/wisp/compare/v0.2.0...v0.2.1

package/README.md

@@ -44,8 +44,8 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 | 📥 **A queue** | Sessions sort into *Needs you*, *Working* (with a live one-line status), and *Done*. Archive what you don't need to see. |
 | 💬 **Follow-ups that interrupt** | A follow-up sent mid-run interrupts the agent and resumes it with your message. Turn on **Queue** to wait for the run to finish instead; queued messages can be cancelled. |
 | 🔎 **Command palette** | `⌘K` / `Ctrl+K` fuzzy-searches sessions, projects, and actions. |
-| 🤖 **Any harness** | Claude Code, Codex, opencode, or Cursor CLI. Pick the harness and model together in the launcher; the model is remembered per harness. Each card shows the harness it ran on. |
-| 🖥️ **Take over** | Opens your terminal with the harness's resume command (`claude --resume <id>`, `codex resume <id>`, …) in the project folder. Works with Terminal, iTerm, Ghostty, Warp, kitty, WezTerm, GNOME Terminal, Konsole, Alacritty, Windows Terminal, PowerShell, or a custom command. |
+| 🤖 **Any harness** | Claude Code, Codex, opencode, or Cursor CLI. Pick the harness, model and thinking level together in the launcher; both are remembered per harness. Each card shows the harness it ran on. |
+| 🖥️ **Take over** | Opens your terminal with the harness's resume command (`claude --resume <id>`, `codex resume <id>`, …) in the project folder. Works with Terminal, iTerm, Ghostty, Warp, cmux, kitty, WezTerm, GNOME Terminal, Konsole, Alacritty, Windows Terminal, PowerShell, or a custom command. |
 | 📎 **Attachments** | Paste screenshots or drop images, video, logs, or PDFs into the launcher. |
 | 🔐 **Permission modes** | Choose **Plan** (read-only), **Edits** (file edits auto-accepted), or **Full auto** for each launch. `Shift+Tab` in the prompt cycles modes. |
 | 🪶 **No runtime dependencies** | The server uses only Node built-ins. Electron is needed only for the desktop app. |
@@ -202,6 +202,21 @@ If the harness has no system-prompt flag, prepend `systemPrompt` to the first pr
 - [x] opencode adapter
 - [x] Cursor CLI adapter
 
+## Telemetry
+
+wisp sends anonymous usage stats and error reports to [PostHog](https://posthog.com) so we can see which agents people use and what breaks. The code is in [`server/telemetry.js`](server/telemetry.js).
+
+**What is sent:** a random install id (not tied to you or your machine), the wisp, OS, Node and agent CLI versions, and per run: agent, model, mode, effort, status, duration, token counts and cost, how many files changed, and which presentation block types came back. Errors include a stack trace and message with your home directory and file paths removed, cut to 500 characters.
+
+**Never sent:** prompts, replies, agent output, file contents, project names, paths or repo URLs.
+
+**Opt out** with any of these:
+- Settings → *Anonymous usage stats*
+- `WISP_TELEMETRY=0`
+- `DO_NOT_TRACK=1`
+
+It is also off whenever `CI` is set.
+
 ## 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wisp-agents",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Launch coding agents, skip the transcript, read the presentation.",
   "type": "module",
   "bin": {

package/server/adapters/claude.js

@@ -23,10 +23,11 @@ export default {
     { id: 'sonnet', label: 'Sonnet', hint: 'Fast and smart, everyday work' },
     { id: 'haiku', label: 'Haiku', hint: 'Fastest, for quick tasks' },
   ],
+  efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
 
   // Interactive command to take over a session in a terminal.
-  resumeCommand({ resumeId, model }) {
-    return [BIN, ...(resumeId ? ['--resume', resumeId] : []), ...(model ? ['--model', model] : [])];
+  resumeCommand({ resumeId, model, effort }) {
+    return [BIN, ...(resumeId ? ['--resume', resumeId] : []), ...(model ? ['--model', model] : []), ...(effort ? ['--effort', effort] : [])];
   },
 
   detect() {
@@ -34,7 +35,7 @@ export default {
   },
 
   // Returns { stop(), done: Promise<void> }. Everything else is reported through onEvent.
-  run({ prompt, attachments = [], cwd, resumeId, mode, model, systemPrompt, mcpServers = {}, onEvent }) {
+  run({ prompt, attachments = [], cwd, resumeId, mode, model, effort, systemPrompt, mcpServers = {}, onEvent }) {
     const args = [
       '-p',
       '--output-format', 'stream-json',
@@ -42,6 +43,7 @@ export default {
       '--permission-mode', PERMISSION_MODES[mode] || 'acceptEdits',
     ];
     if (model) args.push('--model', model);
+    if (effort) args.push('--effort', effort);
     if (resumeId) args.push('--resume', resumeId);
     if (Object.keys(mcpServers).length) {
       args.push('--mcp-config', JSON.stringify({ mcpServers }));

package/server/adapters/codex.js

@@ -21,21 +21,23 @@ export default {
   name: 'Codex',
   askTool: 'mcp__wisp__ask_user',
   models: [{ id: '', label: 'Default', hint: 'Whatever Codex is set to' }],
+  efforts: ['minimal', 'low', 'medium', 'high', 'xhigh'],
 
-  resumeCommand({ resumeId, model }) {
-    return [BIN, ...(resumeId ? ['resume', resumeId] : []), ...(model ? ['--model', model] : [])];
+  resumeCommand({ resumeId, model, effort }) {
+    return [BIN, ...(resumeId ? ['resume', resumeId] : []), ...(model ? ['--model', model] : []), ...(effort ? ['-c', `model_reasoning_effort=${toml(effort)}`] : [])];
   },
 
   detect() {
     return detectVersion(BIN);
   },
 
-  run({ prompt, attachments = [], cwd, resumeId, mode, model, systemPrompt, mcpServers = {}, onEvent }) {
+  run({ prompt, attachments = [], cwd, resumeId, mode, model, effort, systemPrompt, mcpServers = {}, onEvent }) {
     const args = ['exec', '--json', '--skip-git-repo-check'];
     // `resume` doesn't take --sandbox, so set it through config for both paths.
     if (mode === 'auto') args.push('--dangerously-bypass-approvals-and-sandbox');
     else args.push('-c', `sandbox_mode=${toml(SANDBOX[mode] || 'workspace-write')}`);
     if (model) args.push('-m', model);
+    if (effort) args.push('-c', `model_reasoning_effort=${toml(effort)}`);
     for (const [name, srv] of Object.entries(mcpServers)) {
       const key = `mcp_servers.${name}`;
       args.push('-c', `${key}.command=${toml(srv.command)}`, '-c', `${key}.args=${toml(srv.args || [])}`);

package/server/adapters/index.js

@@ -2,12 +2,14 @@
 // (./common.js has the shared plumbing) and register it here:
 //
 //   {
-//     id, name, models: [{id, label, hint?}],
+//     id, name, models: [{id, label, hint?, efforts?}],
+//     efforts?: string[]                           reasoning levels for every model (a model's own
+//                                                  efforts list wins); omit if the CLI has none
 //     askTool: string | null | undefined           how the agent sees wisp's ask_user MCP tool;
 //                                                  null = can't inject MCP, ask via a question block
 //     detect(): Promise<{ available, version?, error?, models? }>   models overrides the static list
-//     resumeCommand({ resumeId, model }): string[]   argv to continue the session interactively
-//     run({ prompt, cwd, resumeId, mode, model, systemPrompt, onEvent }): { stop(), done: Promise }
+//     resumeCommand({ resumeId, model, effort }): string[]   argv to continue the session interactively
+//     run({ prompt, cwd, resumeId, mode, model, effort, systemPrompt, onEvent }): { stop(), done: Promise }
 //   }
 //
 // onEvent receives normalized events:
@@ -35,7 +37,7 @@ export async function listAgents() {
   return Promise.all(
     Object.values(adapters).map(async (a) => {
       if (!detected.has(a.id)) detected.set(a.id, a.detect());
-      return { id: a.id, name: a.name, models: a.models, ...(await detected.get(a.id)) };
+      return { id: a.id, name: a.name, models: a.models, efforts: a.efforts || [], ...(await detected.get(a.id)) };
     }),
   );
 }

package/server/adapters/opencode.js

@@ -11,23 +11,40 @@ export default {
   models: [{ id: '', label: 'Default', hint: 'Whatever opencode is set to' }],
 
   resumeCommand({ resumeId, model }) {
+    // The TUI has no --variant flag; the effort only applies to `run`.
     return [BIN, ...(resumeId ? ['--session', resumeId] : []), ...(model ? ['--model', model] : [])];
   },
 
   async detect() {
     const found = await detectVersion(BIN);
     if (!found.available) return found;
-    // `opencode models` prints provider/model ids, one per line, for every configured provider.
-    const ids = (await quietOutput(BIN, ['models'])).split('\n').map((l) => l.trim()).filter((l) => /^[\w.-]+\/\S+$/.test(l));
-    return { ...found, models: [this.models[0], ...ids.map((id) => ({ id, label: id.split('/').slice(1).join('/'), hint: id.split('/')[0] }))] };
+    // `opencode models --verbose` prints each provider/model id followed by its JSON metadata;
+    // the metadata's `variants` are the reasoning efforts `run --variant` accepts for that model.
+    const out = await quietOutput(BIN, ['models', '--verbose']);
+    const models = [];
+    for (const [, id, json] of out.matchAll(/^([\w.-]+\/\S+)\n(\{[\s\S]*?\n\})$/gm)) {
+      let efforts = [];
+      try {
+        efforts = Object.keys(JSON.parse(json).variants || {});
+      } catch {}
+      models.push({ id, label: id.split('/').slice(1).join('/'), hint: id.split('/')[0], efforts });
+    }
+    if (!models.length) {
+      // Older builds without --verbose: plain ids, one per line.
+      for (const l of (await quietOutput(BIN, ['models'])).split('\n').map((x) => x.trim())) {
+        if (/^[\w.-]+\/\S+$/.test(l)) models.push({ id: l, label: l.split('/').slice(1).join('/'), hint: l.split('/')[0] });
+      }
+    }
+    return { ...found, models: [this.models[0], ...models] };
   },
 
-  run({ prompt, attachments = [], cwd, resumeId, mode, model, systemPrompt, mcpServers = {}, onEvent }) {
+  run({ prompt, attachments = [], cwd, resumeId, mode, model, effort, systemPrompt, mcpServers = {}, onEvent }) {
     // The prompt goes on stdin; `run` appends piped stdin to the (empty) message.
     const args = ['run', '--format', 'json'];
     if (mode === 'plan') args.push('--agent', 'plan');
     if (mode === 'auto') args.push('--auto');
     if (model) args.push('--model', model);
+    if (model && effort) args.push('--variant', effort);
     if (resumeId) args.push('--session', resumeId);
     for (const a of attachments) args.push('--file', a.path);
 

package/server/index.js

@@ -11,6 +11,7 @@ import { Runner, summarize, newId } 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';
 
 const WEB = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'web');
 
@@ -62,6 +63,29 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
   runner.on('finished', (f) => broadcast('finished', f));
   setInterval(() => broadcast('ping', {}), 25_000).unref();
 
+  const telemetry = new Telemetry(store);
+  const run = (s, t) => ({ agent: s.agent, model: s.model || 'default', mode: s.mode, effort: s.effort || 'default', followUp: s.turns.indexOf(t) > 0 });
+  runner.on('started', ({ session, turn }) => telemetry.track('turn_started', { ...run(session, turn), attachments: turn.attachments.length }));
+  runner.on('ended', ({ session, turn, interrupted, errorText }) => {
+    const blocks = turn.presentation?.blocks || [];
+    const st = turn.stats || {};
+    telemetry.track('turn_ended', {
+      ...run(session, turn),
+      status: interrupted ? 'interrupted' : turn.status, // done | error | stopped | interrupted
+      heroStatus: blocks.find((b) => b.type === 'hero')?.status,
+      durationMs: turn.endedAt - turn.startedAt,
+      blockCount: blocks.length,
+      blockTypes: [...new Set(blocks.map((b) => b.type))],
+      presentationFallback: !!turn.presentation?.fallback, // agent ignored or broke the wisp protocol
+      changedFiles: turn.changes.length,
+      inputTokens: st.inputTokens,
+      outputTokens: st.outputTokens,
+      costUsd: st.costUsd,
+    });
+    if (errorText) telemetry.captureError(new Error(errorText), { type: 'AgentError', ...run(session, turn) });
+  });
+  if (!envDisabled()) process.on('uncaughtExceptionMonitor', (err) => telemetry.crashed(err));
+
   const allowedHosts = new Set([`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`]);
 
   const server = http.createServer(async (req, res) => {
@@ -81,6 +105,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
       return serveStatic(res, url.pathname);
     } catch (err) {
       console.error(err);
+      if (!err.status || err.status >= 500) telemetry.captureError(err, { route: `${req.method} ${url.pathname.replace(/\/[a-f0-9]{8,}(?=\/|$)/g, '/:id')}` });
       send(res, err.status || 500, { error: err.message });
     }
   });
@@ -107,6 +132,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
         const body = await readJson(req);
         const s = store.get(body.session);
         if (!s) return send(res, 404, { error: 'no such session' });
+        telemetry.track('ask_user', { agent: s.agent });
         return send(res, 200, { id: runner.ask(s, body) });
       }
       if (id === 'ask' && action && m === 'GET') return send(res, 200, runner.pollAnswer(action));
@@ -148,7 +174,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, home: os.homedir(), cwd: process.cwd(), terminals: TERMINALS });
+      if (m === 'GET') return send(res, 200, { ...store.config, home: os.homedir(), cwd: process.cwd(), terminals: TERMINALS, telemetry: { available: !envDisabled(), enabled: telemetry.enabled } });
       if (m === 'PATCH') {
         const body = await readJson(req);
         if (body.defaults) Object.assign(store.config.defaults, body.defaults);
@@ -235,7 +261,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
           const cwd = path.resolve((body.cwd || process.cwd()).replace(/^~(?=$|[\\/])/, os.homedir()));
           if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) return send(res, 400, { error: `Not a directory: ${cwd}` });
           if (!adapters[body.agent || 'claude']) return send(res, 400, { error: 'unknown agent' });
-          const s = runner.create({ prompt: body.prompt, cwd, agent: body.agent, mode: body.mode, model: body.model, attachments: resolveAttachments(body.attachments) });
+          const s = runner.create({ prompt: body.prompt, cwd, agent: body.agent, mode: body.mode, model: body.model, effort: /^[\w-]{1,20}$/.test(body.effort || '') ? body.effort : '', attachments: resolveAttachments(body.attachments) });
           return send(res, 201, summarize(s, store));
         }
       }
@@ -287,7 +313,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
       if (action === 'takeover') {
         const adapter = adapters[s.agent];
         if (!adapter?.resumeCommand || !s.agentSessionId) return send(res, 400, { error: 'This session cannot be resumed in a terminal.' });
-        const argv = adapter.resumeCommand({ resumeId: s.agentSessionId, model: s.model });
+        const argv = adapter.resumeCommand({ resumeId: s.agentSessionId, model: s.model, effort: s.effort });
         const command = `cd ${shq(s.cwd)} && ${argv.map(shq).join(' ')}`;
         if (m === 'GET') return send(res, 200, { command });
         if (m === 'POST') {
@@ -297,6 +323,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
           }
           openInTerminal({ cwd: s.cwd, argv, terminal: store.config.defaults.terminal || 'auto', custom: store.config.defaults.terminalCommand });
           s.takenOverAt = Date.now();
+          telemetry.track('takeover', { agent: s.agent, terminal: store.config.defaults.terminal || 'auto' });
           store.save(s);
           return send(res, 200, { command });
         }
@@ -341,6 +368,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
   const shutdown = () => {
     for (const s of store.all()) runner.stop(s);
     store.flush();
+    telemetry.persist();
   };
   if (handleSignals) {
     const exit = () => (shutdown(), process.exit(0));
@@ -353,7 +381,14 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
     server.listen(port, host, resolve);
   });
 
-  return { url: `http://localhost:${port}`, server, store, runner, shutdown };
+  if (telemetry.enabled) {
+    if (store.config.defaults.telemetryNotice !== 'seen') console.log('wisp sends anonymous usage stats and error reports (no prompts, paths or code). Opt out: Settings, or WISP_TELEMETRY=0 / DO_NOT_TRACK=1.');
+    listAgents()
+      .then((agents) => telemetry.track('app_started', { agentsInstalled: agents.filter((a) => a.available).map((a) => a.id), ...Object.fromEntries(agents.filter((a) => a.available).map((a) => [`${a.id}Version`, a.version])) }))
+      .catch(() => {});
+  }
+
+  return { url: `http://localhost:${port}`, server, store, runner, shutdown, telemetry };
 }
 
 function send(res, status, body) {

package/server/runner.js

@@ -36,6 +36,7 @@ export function summarize(s, store) {
     color: project?.color || 'slate',
     mode: s.mode,
     model: s.model,
+    effort: s.effort || '',
     state: s.state,
     unread: s.unread,
     archived: !!s.archived,
@@ -74,7 +75,7 @@ export class Runner extends EventEmitter {
     }
   }
 
-  create({ prompt, cwd, agent = 'claude', mode = 'edits', model = '', attachments = [] }) {
+  create({ prompt, cwd, agent = 'claude', mode = 'edits', model = '', effort = '', attachments = [] }) {
     if (!adapters[agent]) throw new Error(`Unknown agent: ${agent}`);
     const now = Date.now();
     const session = {
@@ -85,6 +86,7 @@ export class Runner extends EventEmitter {
       cwd,
       mode,
       model,
+      effort,
       state: 'running',
       unread: false,
       createdAt: now,
@@ -203,6 +205,7 @@ export class Runner extends EventEmitter {
       prompt,
       agent: session.agent,
       model: session.model,
+      effort: session.effort || '',
       attachments: attachments.map(({ id, name, mime, size }) => ({ id, name, mime, size })),
       startedAt: Date.now(),
       endedAt: null,
@@ -217,6 +220,7 @@ export class Runner extends EventEmitter {
     session.unread = false;
     delete session.archived;
     this.#touch(session, { turn: turn.id });
+    this.emit('started', { session, turn });
 
     let released = false;
     let linger;
@@ -228,6 +232,7 @@ export class Runner extends EventEmitter {
       resumeId: session.agentSessionId,
       mode: session.mode,
       model: session.model,
+      effort: session.effort || '',
       systemPrompt: systemPrompt({ askTool: adapter.askTool }),
       mcpServers: this.bridge && adapter.askTool !== null
         ? {
@@ -337,6 +342,7 @@ export class Runner extends EventEmitter {
     session.unread = !interrupted;
     this.store.save(session, { now: true });
     this.#touch(session, { turn: turn.id });
+    this.emit('ended', { session, turn, interrupted, errorText: ev.isError && !ev.stopped ? ev.text : '' });
     // The follow-up starts right away; don't notify for the run it replaced.
     if (!interrupted) this.emit('finished', { session: summarize(session, this.store) });
   }

package/server/store.js

@@ -8,7 +8,7 @@ import { parsePresentation } from './protocol.js';
 
 const DEFAULT_CONFIG = {
   projects: [], // [{ id, name, path, color, addedAt }]
-  defaults: { agent: 'claude', mode: 'edits', model: '' },
+  defaults: { agent: 'claude', mode: 'edits', model: '', effort: '' },
 };
 
 const IMAGE_EXT = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg']);

package/server/telemetry.js

@@ -0,0 +1,132 @@
+// Anonymous usage analytics + error reports, sent to PostHog over its plain HTTP API (no SDK, to
+// stay dependency-free). What goes out is fixed values only — agent, model, mode, status, timings,
+// counts — never prompts, paths, project names or agent output. Error messages and stacks are
+// scrubbed of the home directory and truncated.
+//
+// Off when any of: no API key, DO_NOT_TRACK=1, WISP_TELEMETRY=0, CI, or "telemetry": "off" in
+// settings. See the Telemetry section of the README.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+// PostHog project API key: write-only, safe to ship in the client.
+const KEY = process.env.WISP_POSTHOG_KEY ?? 'phc_wowwZkbP8e4zYuwT67JtX6oxdPwkMWL5kKnrUmYYXhcD';
+const HOST = (process.env.WISP_POSTHOG_HOST || 'https://us.i.posthog.com').replace(/\/$/, '');
+const FLUSH_MS = 15_000;
+const MAX_QUEUE = 50;
+const TIMEOUT_MS = 3000;
+
+const VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+const truthy = (v) => !!v && !/^(0|false|no|off)$/i.test(v);
+
+export function envDisabled(env = process.env) {
+  return !KEY || truthy(env.DO_NOT_TRACK) || /^(0|false|no|off)$/i.test(env.WISP_TELEMETRY || '') || truthy(env.CI);
+}
+
+const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+
+// Paths in messages and stacks would leak usernames and project names: wisp's own files keep
+// their package-relative path, anything else is cut down to its file name.
+export function scrub(text = '', { home = os.homedir(), root = ROOT } = {}) {
+  let s = String(text).split(root).join('<wisp>');
+  if (home) s = s.split(home).join('~');
+  // Any other absolute path keeps only its file name.
+  return s
+    .replace(/(?<![\w<>~.:/\\-])(?:~|[A-Za-z]:)?[/\\](?:[^\s'"`():/\\]+[/\\])+([^\s'"`():/\\]*)/g, (m, base) => `…/${base}`)
+    .slice(0, 500);
+}
+
+function frames(stack = '') {
+  return String(stack)
+    .split('\n')
+    .slice(1, 30)
+    .map((l) => l.trim().match(/^at (?:(.+?) \()?(.+?):(\d+):(\d+)\)?$/))
+    .filter(Boolean)
+    .map(([, fn, file, line, col]) => ({ platform: 'custom', lang: 'javascript', function: fn || '?', filename: scrub(file.replace(/^file:\/\//, '')), lineno: +line, colno: +col, in_app: file.includes(ROOT) && !file.includes('node_modules') }))
+    .reverse(); // PostHog wants the innermost frame last
+}
+
+export class Telemetry {
+  constructor(store, { shell = process.versions.electron ? 'electron' : 'browser' } = {}) {
+    this.store = store;
+    this.queue = [];
+    this.pendingFile = path.join(store.home, 'telemetry-pending.json');
+    this.common = {
+      $lib: 'wisp',
+      $process_person_profile: false, // anonymous events: no person profiles
+      version: VERSION,
+      os: process.platform,
+      osRelease: os.release(),
+      arch: process.arch,
+      node: process.versions.node,
+      electron: process.versions.electron || undefined,
+      shell,
+    };
+    this.timer = setInterval(() => this.flush(), FLUSH_MS);
+    this.timer.unref();
+    this.#sendPending();
+  }
+
+  get enabled() {
+    return !envDisabled() && this.store.config.defaults.telemetry !== 'off';
+  }
+
+  track(event, props = {}) {
+    if (!this.enabled) return;
+    if (!this.store.config.telemetryId) {
+      this.store.config.telemetryId = randomUUID(); // random per install, not tied to the machine or user
+      this.store.saveConfig();
+    }
+    this.queue.push({ event, timestamp: new Date().toISOString(), properties: { ...this.common, ...props, distinct_id: this.store.config.telemetryId } });
+    if (this.queue.length >= MAX_QUEUE) this.flush();
+  }
+
+  // PostHog error tracking format.
+  captureError(err, props = {}) {
+    const e = err instanceof Error ? err : new Error(String(err));
+    this.track('$exception', {
+      ...props,
+      $exception_list: [{ type: props.type || e.name || 'Error', value: scrub(e.message), mechanism: { handled: props.handled ?? true, synthetic: false }, stacktrace: { type: 'raw', frames: frames(e.stack) } }],
+    });
+  }
+
+  async flush() {
+    if (!this.queue.length) return;
+    const batch = this.queue.splice(0);
+    try {
+      await fetch(`${HOST}/batch/`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ api_key: KEY, batch }),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+      });
+    } catch {} // offline or blocked: drop it, telemetry must never get in the way
+  }
+
+  // Shutdown and crashes leave no time for a request: write what's queued to disk (sync) and
+  // send it on the next start.
+  persist() {
+    clearInterval(this.timer);
+    if (!this.queue.length) return;
+    try {
+      fs.writeFileSync(this.pendingFile, JSON.stringify(this.queue.splice(0)));
+    } catch {}
+  }
+
+  crashed(err) {
+    if (!this.enabled) return;
+    this.captureError(err, { handled: false, type: err?.name || 'UncaughtException' });
+    this.persist();
+  }
+
+  #sendPending() {
+    try {
+      const pending = JSON.parse(fs.readFileSync(this.pendingFile, 'utf8'));
+      fs.rmSync(this.pendingFile, { force: true });
+      if (this.enabled && Array.isArray(pending)) this.queue.push(...pending.slice(-200));
+    } catch {}
+  }
+}

package/server/terminal.js

@@ -13,6 +13,7 @@ const ALL_TERMINALS = [
   { id: 'terminal', label: 'Terminal.app', os: ['darwin'] },
   { id: 'iterm', label: 'iTerm', os: ['darwin'] },
   { id: 'warp', label: 'Warp', os: ['darwin'] },
+  { id: 'cmux', label: 'cmux', os: ['darwin'] },
   { id: 'wt', label: 'Windows Terminal', os: ['win32'] },
   { id: 'powershell', label: 'PowerShell', os: ['win32'] },
   { id: 'cmd', label: 'Command Prompt', os: ['win32'] },
@@ -34,11 +35,16 @@ export const shq = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
 const psq = (s) => `'${String(s).replace(/'/g, "''")}'`; // PowerShell single-quoted string
 const asStr = (s) => `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`; // AppleScript string
 
+const CMUX_APP = '/Applications/cmux.app';
+const CMUX_CLI = `${CMUX_APP}/Contents/Resources/bin/cmux`;
+
 const LINUX_ORDER = ['ghostty', 'kitty', 'wezterm', 'gnome-terminal', 'konsole', 'xfce4-terminal', 'alacritty', 'x-terminal-emulator', 'xterm'];
 
 export function detectTerminal({ platform = process.platform, env = process.env, has = (b) => onPath(b, env), exists = fs.existsSync } = {}) {
   if (platform === 'darwin') {
     if (env.TERM_PROGRAM === 'iTerm.app' && exists('/Applications/iTerm.app')) return 'iterm';
+    // cmux is built on Ghostty and reports TERM_PROGRAM=ghostty, so check it first.
+    if ((env.CMUX_WORKSPACE_ID || env.__CFBundleIdentifier === 'com.cmuxterm.app') && exists(CMUX_APP)) return 'cmux';
     if (env.TERM_PROGRAM === 'ghostty' && exists('/Applications/Ghostty.app')) return 'ghostty';
     return 'terminal';
   }
@@ -69,6 +75,15 @@ export function terminalPlan({ cwd, argv, terminal = 'auto', custom = '', platfo
     case 'warp':
       // Warp has no scripting API; open a tab in the folder and type via System Events.
       return [{ command: 'open', args: ['-a', 'Warp', cwd] }, { delay: 1200 }, { osa: `tell application "System Events" to keystroke ${asStr(cmd)} & return` }];
+    case 'cmux': {
+      // `cmux new-workspace` talks to cmux's socket, which by default only accepts processes started
+      // inside cmux. When it's refused (or cmux isn't running), open the folder as a new workspace
+      // and type the command, like Warp.
+      const cli = (has || ((b) => onPath(b, env)))('cmux') ? 'cmux' : CMUX_CLI;
+      const typeIt = `tell application "System Events" to keystroke ${asStr(cmd)} & return`;
+      const script = '"$1" new-workspace --cwd "$2" --command "$3" >/dev/null 2>&1 && open -a cmux || { open -a cmux "$2" && sleep 1.5 && osascript -e "$4"; }';
+      return [{ command: '/bin/sh', args: ['-c', script, 'sh', cli, cwd, cmd, typeIt], options: detached }];
+    }
     case 'wt':
       // `;` separates wt subcommands, so it can't appear unescaped in the command line.
       return [{ command: 'wt.exe', args: ['-d', cwd, 'powershell.exe', '-NoExit', '-Command', ps.replace(/;/g, '\\;')], options: detached }];

package/web/css/app.css

@@ -290,6 +290,7 @@ select {
 .rb-h { font-weight: 500; color: var(--ink); }
 .rb-m { position: relative; margin-left: 13px; max-width: 180px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--muted); }
 .rb-m::before { content: ''; position: absolute; left: -7px; top: 50%; width: 1px; height: 12px; margin-top: -6px; background: var(--line-2); }
+.rb-e { flex: none; margin-left: 6px; padding: 1px 6px; border-radius: 6px; font-size: 11.5px; background: var(--accent-soft); color: var(--accent-ink); }
 .runner-btn .chev { width: 12px; height: 12px; margin-left: 6px; color: var(--faint); transform: rotate(90deg); transition: transform 0.2s var(--ease); }
 .runner-btn.open .chev { transform: rotate(-90deg); }
 
@@ -323,6 +324,14 @@ select {
 .pk-check { width: 15px; height: 15px; flex: none; color: var(--accent); visibility: hidden; }
 .pk-m.on .pk-check { visibility: visible; }
 .pk-m.on b { color: var(--accent-ink); }
+.pk-effort { flex: none; display: flex; flex-direction: column; gap: 6px; padding: 8px 8px 10px; border-top: 1px solid var(--line); background: var(--surface-2); }
+.pk-effort[hidden] { display: none; }
+.pk-ehead { padding: 0 2px; font-size: 11px; font-weight: 600; letter-spacing: 0.04em; text-transform: uppercase; color: var(--faint); }
+.pk-seg { display: flex; min-width: 0; gap: 2px; padding: 2px; overflow-x: auto; border-radius: 9px; background: var(--bg-2); border: 1px solid var(--line); }
+.pk-seg button { flex: 1 0 auto; padding: 4px 7px; border-radius: 7px; font-size: 12px; color: var(--muted); white-space: nowrap; outline: 0; transition: background 0.12s, color 0.12s; }
+.pk-seg button:hover { color: var(--ink); }
+.pk-seg button:focus-visible { box-shadow: inset 0 0 0 1px var(--accent); }
+.pk-seg button.on { background: var(--surface); color: var(--accent-ink); font-weight: 500; box-shadow: var(--shadow-1); }
 .pk-empty { padding: 30px 10px; text-align: center; font-size: 13px; color: var(--muted); }
 @media (max-width: 560px) {
   .picker { grid-template-columns: 1fr; grid-template-rows: auto 1fr; }

package/web/js/app.js

@@ -73,10 +73,18 @@ function harnessLogo(agent) {
   const src = l && `/logos/${l.file}.svg`;
   return !l ? icon('spark') : l.mono ? `<i class="mono" style="--logo:url(${src})"></i>` : `<img src="${src}" alt="">`;
 }
-function modelBadge(agent, model) {
+// Reasoning levels the harness accepts for a model: the model's own list (opencode variants),
+// else the harness-wide one. Empty means the harness has no knob for it.
+function effortsFor(agent, model) {
+  const a = S.agents.find((x) => x.id === agent);
+  return a?.models?.find((m) => m.id === model)?.efforts ?? a?.efforts ?? [];
+}
+const effortLabel = (e) => ({ xhigh: 'X-High' })[e] || e.charAt(0).toUpperCase() + e.slice(1);
+
+function modelBadge(agent, model, effort) {
   if (agent === 'wisp') return '';
   const label = (model && S.agents.find((a) => a.id === agent)?.models?.find((x) => x.id === model)?.label) || model || 'Default model';
-  const tip = `${agentName(agent)} · ${label}`;
+  const tip = `${agentName(agent)} · ${label}${effort ? ` · ${effortLabel(effort)} thinking` : ''}`;
   const logo = harnessLogo(agent);
   return `<span class="model-logo" data-tip="${esc(tip)}" aria-label="${esc(tip)}" tabindex="0">${logo}</span>`;
 }
@@ -241,7 +249,7 @@ function renderHead(n, s) {
     <span class="it-side">
       ${pill}
       ${s.queued ? `<span class="q-queued" title="Follow-ups queued">+${s.queued}</span>` : ''}
-      ${modelBadge(s.agent, s.model)}
+      ${modelBadge(s.agent, s.model, s.effort)}
       <span class="q-proj">${esc(s.project)}</span>
       <span class="q-time">${ago(s.updatedAt)}</span>
       ${s.state === 'review' && !open && !s.archived ? `<button class="it-quick" data-a="quick-done" title="Mark done (E)">${icon('done')}</button>` : ''}
@@ -484,21 +492,33 @@ function renderLauncher() {
     const models = S.agents.find((a) => a.id === id)?.models || [];
     return models.some((m) => m.id === want) ? want : '';
   };
+  // Thinking level too, and only if the chosen model still accepts it.
+  const savedEffort = (id, model) => {
+    const d = S.config.defaults;
+    const want = d.efforts?.[id] ?? (id === d.agent ? d.effort : '');
+    return effortsFor(id, model).includes(want) ? want : '';
+  };
   let curModel = savedModel(agent?.id);
+  let curEffort = savedEffort(agent?.id, curModel);
   const runnerBtn = $('#runner', box);
   const paintRunner = () => {
     const m = (agent?.models || []).find((x) => x.id === curModel);
-    runnerBtn.innerHTML = `<span class="rb-logo">${harnessLogo(agent?.id)}</span><span class="rb-h">${esc(agent?.name || 'No agent')}</span><span class="rb-m">${esc(m && m.id ? m.label : 'Default')}</span>${icon('chevron', 'chev')}`;
+    runnerBtn.innerHTML = `<span class="rb-logo">${harnessLogo(agent?.id)}</span><span class="rb-h">${esc(agent?.name || 'No agent')}</span><span class="rb-m">${esc(m && m.id ? m.label : 'Default')}</span>${curEffort ? `<span class="rb-e">${esc(effortLabel(curEffort))}</span>` : ''}${icon('chevron', 'chev')}`;
+    runnerBtn.title = `Harness, model and thinking level${curEffort ? `\nThinking: ${effortLabel(curEffort)}` : ''}`;
   };
   paintRunner();
   runnerBtn.onclick = () =>
-    runnerPicker(runnerBtn, { agent: agent?.id, model: curModel, savedModel }, (id, model) => {
+    runnerPicker(runnerBtn, { agent: agent?.id, model: curModel, effort: curEffort, savedModel, savedEffort }, (id, model, effort) => {
       agent = S.agents.find((a) => a.id === id);
       curModel = model;
+      curEffort = effort;
       paintRunner();
-      const models = { ...S.config.defaults.models, [id]: model };
-      Object.assign(S.config.defaults, { agent: id, model, models });
-      api('/config', { method: 'PATCH', body: { defaults: { agent: id, model, models } } }).catch(() => {});
+      const d = S.config.defaults;
+      const models = { ...d.models, [id]: model };
+      // A model without levels leaves the harness's saved level alone, so switching back restores it.
+      const efforts = effort || effortsFor(id, model).length ? { ...d.efforts, [id]: effort } : d.efforts;
+      Object.assign(d, { agent: id, model, models, effort, efforts });
+      api('/config', { method: 'PATCH', body: { defaults: { agent: id, model, models, effort, efforts } } }).catch(() => {});
     });
 
   const launch = async () => {
@@ -510,7 +530,7 @@ function renderLauncher() {
     btn.disabled = true;
     try {
       const attachments = await tray.ids();
-      const s = await api('/sessions', { method: 'POST', body: { prompt, cwd: project.path, agent: agent?.id || 'claude', mode: curMode, model: curModel, attachments } });
+      const s = await api('/sessions', { method: 'POST', body: { prompt, cwd: project.path, agent: agent?.id || 'claude', mode: curMode, model: curModel, effort: curEffort, attachments } });
       S.sessions.set(s.id, s);
       ta.value = '';
       S.drafts.delete('home');
@@ -765,6 +785,7 @@ function renderBody(id, { fresh }) {
     <span class="m">${esc(agentName(s.agent))}</span>
     <span class="m">${esc(MODES.find((m) => m.id === s.mode)?.label || s.mode)}</span>
     ${s.model ? `<span class="m">${esc(s.model)}</span>` : ''}
+    ${s.effort ? `<span class="m">${esc(effortLabel(s.effort))} thinking</span>` : ''}
     <span class="m path" title="${esc(s.cwd)}">${esc((proj?.path || s.cwd).replace(S.config.home || '', '~'))}</span>`;
   // Done lives both in the top bar and next to the composer, so it's reachable after reading.
   $$('[data-a="done"]', body).forEach((b) => {
@@ -838,7 +859,7 @@ function renderTurn(s, t, isLatest, fold) {
       <div class="ask-text ${long ? 'clamped' : ''}">${esc(t.prompt)}</div>
       ${long ? '<button class="link xs more-btn">Show all</button>' : ''}
       ${t.attachments?.length ? `<div class="ask-atts">${t.attachments.map((a) => (a.mime?.startsWith('image/') ? `<img src="/api/uploads/${a.id}" alt="${esc(a.name)}" title="${esc(a.name)}">` : `<a class="att-pill" href="/api/uploads/${a.id}" target="_blank">${icon('file')}${esc(a.name)}</a>`)).join('')}</div>` : ''}
-      <div class="ask-foot">${modelBadge(t.agent || s.agent, t.model ?? s.model)}<time>${new Date(t.startedAt).toLocaleString([], { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' })}</time></div>
+      <div class="ask-foot">${modelBadge(t.agent || s.agent, t.model ?? s.model, t.effort ?? s.effort)}<time>${new Date(t.startedAt).toLocaleString([], { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' })}</time></div>
       ${fold ? `<button class="ghost xs t-unfold" title="Collapse this exchange">${icon('chevron', 'chev')}</button>` : ''}
     </div>`);
   if (fold) ask.querySelector('.t-unfold').onclick = fold;
@@ -1199,9 +1220,10 @@ function rename(id) {
   title.onblur = () => done(true);
 }
 
-// One popover for both choices: harnesses on the left, the focused harness's models on the right.
-// Clicking (or arrowing to) a harness previews its models; picking a model commits both.
-function runnerPicker(anchor, { agent, model, savedModel }, pick) {
+// One popover for all three choices: harnesses on the left, the focused harness's models on the
+// right, and its thinking levels underneath. Clicking (or arrowing to) a harness previews its
+// models; picking a model commits harness + model, picking a thinking level commits it in place.
+function runnerPicker(anchor, { agent, model, effort, savedModel, savedEffort }, pick) {
   const open = $('.picker');
   if (open) return open.close();
   let focusAgent = S.agents.find((a) => a.id === agent && a.available) ? agent : S.agents.find((a) => a.available)?.id;
@@ -1214,7 +1236,7 @@ function runnerPicker(anchor, { agent, model, savedModel }, pick) {
   const left = Math.max(12, Math.min(r.left, right - width));
   const below = r.bottom + 440 < innerHeight;
   const node = el(`
-    <div class="picker" role="dialog" aria-label="Harness and model" style="left:${left}px;width:${width}px;${below ? `top:${r.bottom + 6}px` : `bottom:${innerHeight - r.top + 6}px`}">
+    <div class="picker" role="dialog" aria-label="Harness, model and thinking level" style="left:${left}px;width:${width}px;${below ? `top:${r.bottom + 6}px` : `bottom:${innerHeight - r.top + 6}px`}">
       <div class="pk-side" role="listbox" aria-label="Harness">
         <div class="pk-head">Harness</div>
         ${S.agents
@@ -1230,11 +1252,38 @@ function runnerPicker(anchor, { agent, model, savedModel }, pick) {
       <div class="pk-main">
         <label class="pk-search">${icon('search')}<input spellcheck="false" autocomplete="off"></label>
         <div class="pk-list" role="listbox" aria-label="Model"></div>
+        <div class="pk-effort" role="radiogroup" aria-label="Thinking level"></div>
       </div>
     </div>`);
   const input = $('.pk-search input', node);
   const list = $('.pk-list', node);
   const sideRows = $$('.pk-h', node);
+  const seg = $('.pk-effort', node);
+  const modelOf = (id) => (id === agent ? model : savedModel(id));
+  const effortOf = (id) => (id === agent ? effort : savedEffort(id, modelOf(id)));
+
+  const paintEffort = () => {
+    const levels = effortsFor(focusAgent, modelOf(focusAgent));
+    const current = effortOf(focusAgent);
+    seg.hidden = !levels.length;
+    seg.innerHTML = `<span class="pk-ehead">Thinking</span><span class="pk-seg">${['', ...levels]
+      .map((e) => `<button role="radio" aria-checked="${e === current}" class="${e === current ? 'on' : ''}" data-e="${esc(e)}" title="${e ? `${esc(effortLabel(e))} reasoning effort` : 'Whatever the harness is set to'}">${esc(e ? effortLabel(e) : 'Default')}</button>`)
+      .join('')}</span>`;
+  };
+  const chooseEffort = (e) => {
+    const m = modelOf(focusAgent);
+    if (focusAgent === agent && e === effort) return;
+    if (focusAgent !== agent) {
+      $$('.pk-dot', node).forEach((d) => d.remove());
+      sideRows.find((b) => b.dataset.id === focusAgent)?.insertAdjacentHTML('beforeend', '<span class="pk-dot" title="In use"></span>');
+    }
+    agent = focusAgent;
+    model = m;
+    effort = e;
+    pick(agent, model, effort);
+    paintEffort();
+    $(`button[data-e="${CSS.escape(e)}"]`, seg)?.focus();
+  };
 
   const paintModels = () => {
     const a = S.agents.find((x) => x.id === focusAgent);
@@ -1263,6 +1312,7 @@ function runnerPicker(anchor, { agent, model, savedModel }, pick) {
       )
       .join('') + '<div class="pk-empty" hidden>No models match</div>';
     filter();
+    paintEffort();
   };
   const rows = () => $$('.pk-m', list).filter((b) => !b.hidden);
   const filter = () => {
@@ -1296,7 +1346,10 @@ function runnerPicker(anchor, { agent, model, savedModel }, pick) {
   const choose = (m) => {
     close();
     anchor.focus();
-    if (focusAgent !== agent || m !== model) pick(focusAgent, m);
+    // Carry the thinking level over when the new model accepts it, else fall back to the saved one.
+    const cur = effortOf(focusAgent);
+    const e = effortsFor(focusAgent, m).includes(cur) ? cur : savedEffort(focusAgent, m);
+    if (focusAgent !== agent || m !== model || e !== effort) pick(focusAgent, m, e);
   };
   const outside = (e) => !node.contains(e.target) && !anchor.contains(e.target) && close();
   const step = (items, d) => {
@@ -1310,8 +1363,22 @@ function runnerPicker(anchor, { agent, model, savedModel }, pick) {
   const keys = (e) => {
     const inSide = sideRows.includes(document.activeElement);
     const live = sideRows.filter((b) => !b.disabled);
+    const segBtns = $$('button', seg);
+    const inSeg = segBtns.includes(document.activeElement);
     if (e.key === 'Escape') return e.preventDefault(), e.stopPropagation(), close(), anchor.focus();
+    // Tab hops from the model list to the thinking levels and back; anywhere else it leaves.
+    if (e.key === 'Tab' && !seg.hidden && (inSeg ? e.shiftKey : !e.shiftKey && !inSide)) {
+      e.preventDefault();
+      return inSeg ? focusModels() : (segBtns.find((b) => b.classList.contains('on')) || segBtns[0]).focus();
+    }
     if (e.key === 'Tab') return close();
+    if (inSeg && (e.key === 'ArrowLeft' || e.key === 'ArrowRight')) {
+      e.preventDefault();
+      e.stopPropagation();
+      return step(segBtns, e.key === 'ArrowRight' ? 1 : -1);
+    }
+    if (inSeg && e.key === 'ArrowUp') return e.preventDefault(), focusModels();
+    if (inSeg && (e.key === 'Enter' || e.key === ' ')) return e.preventDefault(), chooseEffort(document.activeElement.dataset.e);
     if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
       e.preventDefault();
       e.stopPropagation();
@@ -1337,6 +1404,10 @@ function runnerPicker(anchor, { agent, model, savedModel }, pick) {
     if (b) choose(b.dataset.id);
   };
   input.oninput = filter;
+  seg.onclick = (e) => {
+    const b = e.target.closest('button[data-e]');
+    if (b) chooseEffort(b.dataset.e);
+  };
 
   paintModels();
   setTimeout(() => document.addEventListener('mousedown', outside));
@@ -1630,6 +1701,7 @@ function openSettings() {
       <label class="custom-term" ${d.terminal === 'custom' ? '' : 'hidden'}><span>Terminal command</span>
         <input name="terminalCommand" value="${esc(d.terminalCommand || '')}" placeholder="alacritty --working-directory {cwd} -e {cmd}" spellcheck="false"></label>
       <div class="setting"><span>Desktop notifications</span><span class="notif-hint muted xs"></span><button class="switch" id="notif" role="switch"></button></div>
+      <div class="setting"><span>Anonymous usage stats</span><span class="tele-hint muted xs"></span><button class="switch" id="tele" role="switch"></button></div>
       <div class="agents">${S.agents
         .map((a) => `<div class="agent-row"><span class="dot ${a.available ? 'ok' : 'bad'}"></span><b>${esc(a.name)}</b><span class="muted">${esc(a.available ? a.version : a.error || 'not found')}</span></div>`)
         .join('')}<p class="muted xs">Pick the agent next to the model in the launcher. Others plug in via <code>server/adapters</code>.</p></div>
@@ -1662,6 +1734,28 @@ function openSettings() {
     paint();
   };
   paint();
+  // Agent, model, status, timings and scrubbed errors only; never prompts, paths or code.
+  const tele = $('#tele', node);
+  const paintTele = () => {
+    const t = S.config.telemetry || {};
+    tele.setAttribute('aria-checked', !!t.enabled);
+    tele.disabled = !t.available;
+    $('.tele-hint', node).textContent = !t.available ? 'Off (DO_NOT_TRACK, WISP_TELEMETRY=0 or CI)' : 'No prompts, paths or code';
+  };
+  tele.onclick = async () => {
+    await api('/config', { method: 'PATCH', body: { defaults: { telemetry: S.config.telemetry?.enabled ? 'off' : 'on' } } });
+    await loadConfig();
+    paintTele();
+  };
+  paintTele();
+}
+
+// Say once that anonymous stats are on, with a way out.
+function telemetryNotice() {
+  if (!S.config.telemetry?.enabled || S.config.defaults.telemetryNotice === 'seen') return;
+  S.config.defaults.telemetryNotice = 'seen';
+  api('/config', { method: 'PATCH', body: { defaults: { telemetryNotice: 'seen' } } }).catch(() => {});
+  toast('wisp sends anonymous usage stats and error reports. No prompts, paths or code.', { timeout: 10_000, action: { label: 'Settings', run: openSettings } });
 }
 
 function shortcuts() {
@@ -1970,4 +2064,5 @@ window.addEventListener('focus', () => {
   connect();
   route();
   $('#prompt')?.focus();
+  telemetryNotice();
 })();