wisp-agents 0.15.0 → 0.17.0

package/server/services/install.js

@@ -0,0 +1,69 @@
+// One-click setup for people with no harness yet. opencode is the one wisp installs: its free
+// models work without an account, so a fresh computer can run a task right away. It goes into
+// wisp's own folder (~/.wisp/tools) through npm, which every wisp install already has: no sudo,
+// no shell profile edits, the same on Windows. The opencode adapter finds it there.
+
+import fs from 'node:fs';
+import { spawn } from '../proc.js';
+import { bad, toolsDir } from '../util.js';
+
+export const INSTALLABLE = {
+  opencode: { pkg: 'opencode-ai', name: 'opencode' },
+};
+const TIMEOUT_MS = 5 * 60_000;
+
+// npm install --prefix <dir> <pkg>@latest. Resolves when it worked, rejects with the tail of
+// npm's output when it didn't: a 424, since offline or a broken npm isn't a wisp bug (it's
+// counted in the harness_install event instead of reported as an exception).
+export function npmInstall(pkg, dir, { npm = process.env.WISP_NPM || 'npm', timeout = TIMEOUT_MS } = {}) {
+  fs.mkdirSync(dir, { recursive: true });
+  const env = { ...process.env };
+  delete env.ELECTRON_RUN_AS_NODE; // the desktop app's node mode must not leak into npm
+  return new Promise((resolve, reject) => {
+    const child = spawn(npm, ['install', '--prefix', dir, '--no-audit', '--no-fund', '--loglevel=error', `${pkg}@latest`], { env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '';
+    const keep = (d) => (out = (out + d).slice(-4000));
+    child.stdout.on('data', keep);
+    child.stderr.on('data', keep);
+    const timer = setTimeout(() => child.kill(), timeout);
+    child.on('error', (err) => (clearTimeout(timer), reject(bad(err.code === 'ENOENT' ? 'npm isn’t on PATH, so wisp can’t install it. Install Node.js (it comes with npm), then try again.' : err.message, 424))));
+    child.on('close', (code, signal) => {
+      clearTimeout(timer);
+      if (code === 0) return resolve();
+      const tail = out.trim().split('\n').filter(Boolean).slice(-3).join(' ');
+      reject(bad(`npm install ${pkg} ${signal ? 'timed out' : 'failed'}${tail ? `: ${tail}` : ''}`, 424));
+    });
+  });
+}
+
+export function createInstaller(app, { install = npmInstall } = {}) {
+  const running = new Map(); // id -> promise: a second click (or tab) waits for the same install
+
+  // Installs the harness, detects again and returns the harness list. Throws when the install
+  // failed or the harness still isn't found afterwards.
+  async function run(id) {
+    const spec = INSTALLABLE[id];
+    if (!spec) throw bad(`wisp can’t install ${id}. Install it yourself, then re-check.`);
+    if (!running.has(id)) {
+      const job = (async () => {
+        const started = Date.now();
+        try {
+          await install(spec.pkg, toolsDir());
+        } catch (err) {
+          app.telemetry?.track('harness_install', { agent: id, ok: false, ms: Date.now() - started });
+          throw err;
+        }
+        const agents = await app.auto.detect({ fresh: true });
+        const ok = agents.find((a) => a.id === id)?.available;
+        app.telemetry?.track('harness_install', { agent: id, ok: !!ok, ms: Date.now() - started });
+        if (!ok) throw bad(`${spec.name} was installed but doesn’t start: ${agents.find((a) => a.id === id)?.error || 'unknown error'}`, 500);
+        app.broadcast('agents', {});
+        return agents;
+      })().finally(() => running.delete(id));
+      running.set(id, job);
+    }
+    return running.get(id);
+  }
+
+  return { run, installing: (id) => running.has(id) };
+}

package/server/services/launch.js

@@ -0,0 +1,127 @@
+// One way in for every launch (the launcher, the CLI, recipes, triggers, the phone and compare
+// runs), here or on a machine, plus the follow-ups and "done" that every surface shares.
+
+import fs from 'node:fs';
+import { adapters } from '../adapters/index.js';
+import { createWorktree, worktreeSource, ensureWorktree, removeWorktree } from '../git.js';
+import { qualify } from '../machines.js';
+import { fill, positional } from '../recipes.js';
+import { summarize } from '../runner.js';
+import { normalizeTeam } from '../subagents.js';
+import { bad, expand, MODES, newId } from '../util.js';
+
+export const MAX_COMPARE = 4;
+
+export function createLaunch(app) {
+  const { store, runner, machines } = app;
+
+  // body: { prompt, cwd, agent, mode, model, effort, attachments: [uploadId], worktree, compare,
+  //         subagents: [{ name, agent, model, effort, use }] | preset: teamId }
+  async function launch(body, origin = null) {
+    if (!String(body.prompt || '').trim()) throw bad('prompt required');
+    const cwd = expand(body.cwd || process.cwd());
+    if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) throw bad(`Not a directory: ${cwd}`);
+    const d = store.config.defaults;
+    const preset = body.preset && store.config.teams.find((t) => t.id === body.preset);
+    if (body.preset && !preset && !body.subagents) throw bad(`no such subagent preset: ${body.preset}`);
+    const subagents = normalizeTeam(body.subagents ?? preset?.members, adapters);
+    // compare: more { agent, model, effort } to run the same task on, side by side. 'auto' is
+    // resolved here: the router picks a harness and model (a different one per compare run).
+    const resolved = await app.auto.resolve(body, await app.auto.agents(), { team: subagents.length > 0 });
+    const runners = [{ agent: resolved.agent, model: resolved.model, effort: resolved.effort, route: resolved.route }, ...(resolved.compare || [])].slice(0, MAX_COMPARE).map((r, i) => {
+      const agent = r.agent || (i ? d.agent : '') || 'claude';
+      if (!adapters[agent]) throw bad(`unknown agent: ${agent}`);
+      return { agent, model: r.model ?? (i ? d.models?.[agent] || '' : ''), effort: /^[\w-]{1,20}$/.test(r.effort || '') ? r.effort : '', ...(r.route && { route: r.route }) };
+    });
+    const mode = MODES.has(body.mode) ? body.mode : 'auto';
+    // Worktrees are on by default in git repos (off in Plan mode: nothing gets written). Compare
+    // runs need one each, or the harnesses would edit the same files.
+    const comparing = runners.length > 1;
+    const wantTree = body.worktree ?? (comparing || (mode !== 'plan' && d.worktree !== 'off'));
+    // groupId: one launch sent to several machines (or here and there) shows as one task.
+    const groupId = /^[a-f0-9]{12}$/.test(body.groupId || '') ? body.groupId : comparing ? newId() : null;
+    const attachments = app.uploads.resolve(body.attachments);
+    const ids = runners.map(() => newId());
+    let trees = ids.map(() => null);
+    if (wantTree) {
+      const must = body.worktree === true || (comparing && mode !== 'plan');
+      // One fetch for the whole launch, then the checkouts side by side: compare runs used to
+      // fetch and check out one after the other before anything showed up in the feed.
+      const results = await worktreeSource(cwd).then(
+        (source) => source && Promise.allSettled(ids.map((id) => createWorktree({ cwd, home: store.home, id, title: body.prompt, source }))),
+        (err) => [{ status: 'rejected', reason: err }],
+      );
+      const failed = results?.find((x) => x.status === 'rejected')?.reason;
+      trees = ids.map((_, i) => (results?.[i]?.status === 'fulfilled' ? results[i].value : null));
+      if (must && (failed || trees.some((t) => !t))) {
+        await Promise.all(trees.map((t) => t && removeWorktree(t, { force: true, branch: 'force' }).catch(() => {})));
+        if (failed) throw bad(`Could not create a worktree: ${failed.message}`);
+        throw bad(comparing ? 'Compare needs a git repo with at least one commit, so each harness gets its own worktree.' : 'Not a git repo with commits, so there is nothing to make a worktree from.');
+      }
+      if (failed) console.warn(`wisp: no worktree for ${cwd}: ${failed.message}`);
+    }
+    return runners.map((r, i) => runner.create({ id: ids[i], prompt: body.prompt, cwd, ...r, mode, attachments, worktree: trees[i], groupId, origin, subagents }));
+  }
+
+  // Where a launch runs: body.machine, else a project folder that only exists on a machine
+  // (recipes and schedules keep just the path). null = here.
+  function machineFor(body) {
+    if (body.machine) return machines.get(String(body.machine)).id;
+    const cwd = String(body.cwd || '');
+    if (!cwd || fs.existsSync(expand(cwd))) return null;
+    return store.config.projects.find((p) => p.machine && (cwd === p.path || cwd.startsWith(`${p.path}/`)))?.machine || null;
+  }
+
+  // Attachments are uploaded here; a machine gets its own copies before a launch or reply.
+  async function pushUploads(mid, ids) {
+    const out = [];
+    for (const u of app.uploads.resolve(ids)) out.push((await machines.upload(mid, u)).id);
+    return out;
+  }
+
+  // launch(), here or on a machine. Resolves with summaries (a compare launch has several).
+  async function launchAny(body, origin = null) {
+    const mid = machineFor(body);
+    if (!mid) return (await launch(body, origin)).map((x) => summarize(x, store));
+    // Auto for a machine: routed here, with the harnesses that machine has; its outcomes come
+    // back through the summaries it streams (auto.signals), so one router learns from every place.
+    const routed = await app.auto.resolve(body, machines.agentsOf(mid) || [], { team: !!(body.subagents?.length || body.preset) });
+    const routes = [routed.route, ...(routed.compare || []).map((c) => c.route)];
+    const sendBody = { ...routed, compare: routed.compare?.map(({ route, ...c }) => c) };
+    delete sendBody.route;
+    if (!sendBody.compare?.length && !body.compare) delete sendBody.compare;
+    const out = await machines.launch(mid, { ...sendBody, attachments: await pushUploads(mid, body.attachments), ...(origin && { origin }) });
+    (out.group || [out]).forEach((x, i) => routes[i] && app.router.record(qualify(x.id, mid), routes[i]));
+    const known = store.projectFor(out.cwd, mid);
+    (known || store.addProject(out.cwd, { machine: mid })).lastUsedAt = Date.now();
+    store.saveConfig();
+    if (!known) app.broadcast('config', {});
+    return (out.group || [out]).map((x) => machines.summary(mid, x));
+  }
+
+  // A follow-up from anywhere (UI, CLI, phone). An archived session may have lost its worktree.
+  async function replyTo(s, text, attachments = [], queue, mode, run) {
+    await ensureWorktree(s.worktree);
+    return runner.reply(s, text, attachments, { queue: queue ?? store.config.defaults.followUp === 'queue', mode, run });
+  }
+
+  function markDone(s) {
+    if (s.state === 'running' || s.state === 'waiting') return false;
+    s.state = 'done';
+    s.unread = false;
+    app.retro.schedule(s, 0);
+    app.sessionChanged(s);
+    return true;
+  }
+
+  async function runRecipe(r, { params = {}, words, cwd, machine, agent, model, effort, mode } = {}) {
+    const values = words ? { ...positional(r.prompt, words), ...params } : params;
+    const [s] = await launchAny({ prompt: fill(r.prompt, values), cwd: r.cwd || cwd, machine, agent: agent || r.agent || undefined, model: model ?? (r.model || undefined), effort: effort || r.effort || undefined, mode: mode || r.mode || undefined }, { kind: 'recipe', id: r.id, name: r.name });
+    r.runs = (r.runs || 0) + 1;
+    r.lastRunAt = Date.now();
+    app.configChanged();
+    return s;
+  }
+
+  return { launch, launchAny, machineFor, pushUploads, replyTo, markDone, runRecipe };
+}

package/server/services/phone.js

@@ -0,0 +1,65 @@
+// Phone (ntfy / Telegram): what a tap or a reply there does to a session, here or on a machine.
+
+import { splitId } from '../machines.js';
+
+export function phoneActions(app) {
+  const { store, runner, machines } = app;
+
+  // What the phone can do to a session, here or on a machine: { s, answer, reply, done } or null.
+  async function sessionOps(sessionId) {
+    const at = splitId(sessionId);
+    if (!at) {
+      const s = store.get(sessionId);
+      return s && { s, answer: (a) => runner.answer(s, a), reply: (t) => app.launcher.replyTo(s, t), done: () => app.launcher.markDone(s) };
+    }
+    const call = (method, p, body) => machines.json(at.machine, method, `/sessions/${at.id}${p}`, body);
+    const s = await call('GET', '').catch((err) => {
+      if (err.status === 404) return null;
+      throw err;
+    });
+    const live = s && (s.state === 'running' || s.state === 'waiting');
+    return s && { s: machines.session(at.machine, s), answer: (a) => call('POST', '/answer', { text: a }), reply: (t) => call('POST', '/reply', { text: t }), done: async () => !live && !!(await call('PATCH', '', { state: 'done' })) };
+  }
+
+  return {
+    // /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 app.launcher.launchAny({ prompt, cwd: project.path, machine: project.machine || undefined, agent, model, mode: d.mode || 'auto' }, { kind: 'telegram', name: 'Telegram' });
+      app.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}`;
+      if (!ops) return 'That session is gone.';
+      const { s } = ops;
+      if (kind === 'answer') {
+        if (!s.ask || s.ask.id !== ref) return 'That question was already answered.';
+        const answer = s.ask.options[index];
+        if (answer === undefined) return 'Unknown option.';
+        await ops.answer(answer);
+        return `✓ Answered: ${answer}`;
+      }
+      if (kind === 'reply') {
+        const turn = s.turns.at(-1);
+        if (!turn || turn.id !== ref || s.state === 'running') return 'That was already answered.';
+        const q = turn.presentation?.blocks?.findLast((b) => b?.type === 'question');
+        const o = q?.options?.[index];
+        const msg = typeof o === 'string' ? o : o?.reply || o?.label;
+        if (!msg) return 'Unknown option.';
+        await ops.reply(msg);
+        return `✓ Sent: ${typeof o === 'string' ? o : o.label || msg}`;
+      }
+      if (kind === 'done') {
+        if (s.turns.at(-1)?.id !== ref && ref) return 'There is newer work on that session; open wisp to review it.';
+        return (await ops.done()) ? '✓ Marked done' : 'It is still working.';
+      }
+      if (s.agent === 'wisp') return 'That is the tour; it can’t take follow-ups.';
+      const r = await ops.reply(String(text || '').trim());
+      return r.answered ? '✓ Answered' : r.interrupted ? '✓ Sent; the agent picked it up mid-run' : r.queued ? '✓ Queued for when it finishes' : '✓ Sent';
+    },
+  };
+}

package/server/services/ship.js

@@ -0,0 +1,82 @@
+// Ship it: whether a worktree session has something to ship, the draft commit message and PR
+// text, and following open PRs (checks, reviews, merges) so their cards stay current.
+
+import fs from 'node:fs';
+import { worktreeStatus, prView } from '../git.js';
+import { blocksToMarkdown } from '../render.js';
+import { summarize } from '../runner.js';
+
+const PR_POLL_MS = 60_000;
+const SHIP_RECHECK_MS = 5_000;
+
+export function createShip(app) {
+  const { store, runner } = app;
+
+  // Ship it shows only when the worktree has something to ship: uncommitted changes, or commits
+  // not yet pushed. Rechecked whenever wisp might have changed the worktree.
+  const check = async (s) => {
+    if (!s?.worktree || s.parentId) return;
+    const { dirty, ahead, unpushed } = await worktreeStatus(s.worktree);
+    const next = { dirty, ahead, unpushed };
+    if (JSON.stringify(next) === JSON.stringify(s.toShip)) return;
+    s.toShip = next;
+    app.sessionChanged(s);
+  };
+  // One check at a time per session (one asked for meanwhile runs right after); `lazy` (a card
+  // fetching its session) skips running sessions and runs at most every few seconds.
+  const checks = new Map(); // id → true while checking, 'again' if another check is due
+  const checkedAt = new Map();
+  const recheck = (s, { lazy = false } = {}) => {
+    if (!s?.worktree || s.parentId) return;
+    if (lazy && (runner.live.has(s.id) || checks.has(s.id) || Date.now() - (checkedAt.get(s.id) || 0) < SHIP_RECHECK_MS)) return;
+    if (checks.has(s.id)) return void checks.set(s.id, 'again');
+    checks.set(s.id, true);
+    checkedAt.set(s.id, Date.now());
+    check(s)
+      .catch(() => {})
+      .finally(() => {
+        const again = checks.get(s.id) === 'again';
+        checks.delete(s.id);
+        if (again) recheck(s);
+      });
+  };
+
+  const refreshPr = async (s) => {
+    if (!s.pr || !s.worktree) return s.pr;
+    const prev = s.pr;
+    const dir = fs.existsSync(s.worktree.path) ? s.worktree.path : s.worktree.root;
+    const pr = await prView(dir, prev.number);
+    const changed = (k) => JSON.stringify(k(pr)) !== JSON.stringify(k(prev));
+    s.pr = pr;
+    if (pr.state !== prev.state) app.auto.signals(summarize(s, store));
+    // Things worth coming back for: CI finished either way, a review landed, it merged or closed.
+    const settledChecks = (x) => (x.checks.pending ? 'pending' : x.checks.fail ? 'fail' : 'pass');
+    if (changed((x) => x.state) || changed((x) => x.review) || (changed(settledChecks) && settledChecks(pr) !== 'pending')) s.unread = true;
+    app.sessionChanged(s);
+    return pr;
+  };
+
+  // Default commit message and PR text, from the session's latest presentation.
+  const draft = (s) => {
+    const turn = s.turns.findLast((t) => t.status === 'done') || s.turns.at(-1);
+    const blocks = turn?.presentation?.blocks || [];
+    const hero = blocks.find((b) => b?.type === 'hero');
+    const text = `${hero?.title || s.title}`.trim();
+    const conventional = /^[a-z]+(\([\w./-]+\))?!?: /.test(text);
+    const type = /\b(fix|bug|broken|crash|flaky|regression)/i.test(`${text} ${s.turns[0]?.prompt || ''}`) ? 'fix' : /\b(docs?|readme|changelog)\b/i.test(text) ? 'docs' : /\b(refactor|clean ?up|simplif)/i.test(text) ? 'refactor' : /\btests?\b/i.test(text) ? 'test' : 'feat';
+    const title = conventional ? text : `${type}: ${text.charAt(0).toLowerCase()}${text.slice(1)}`;
+    const keep = blocks.filter((b) => !['hero', 'next', 'question', 'diff', 'code', 'image', 'terminal'].includes(b?.type));
+    const body = [hero?.summary, blocksToMarkdown(keep, turn)].filter(Boolean).join('\n\n').trim();
+    return { title: title.slice(0, 100), body: `${body}\n\n_Shipped from [wisp](https://github.com/M0xoo/wisp)._`.trim() };
+  };
+
+  runner.on('ended', ({ session }) => recheck(store.get(session.id)));
+  for (const s of store.all()) if (s.worktree && !s.archived && s.pr?.state !== 'MERGED') recheck(s);
+
+  const timer = setInterval(async () => {
+    for (const s of store.all()) if (s.pr?.state === 'OPEN') await refreshPr(s).catch(() => {});
+  }, PR_POLL_MS);
+  timer.unref();
+
+  return { recheck, refreshPr, draft, stop: () => clearInterval(timer) };
+}

package/server/services/telemetry.js

@@ -0,0 +1,34 @@
+// What the runner, the router and the retro report to telemetry: fixed values about how a turn
+// ran and ended, never the prompt or the result.
+
+import { envDisabled } from '../telemetry.js';
+
+export const runProps = (s, t) => ({ agent: s.agent, model: s.model || 'default', mode: s.mode, effort: s.effort || 'default', followUp: s.turns.indexOf(t) > 0 });
+
+// Auto's choice, as fixed values only: never the prompt.
+const routeProps = (s) =>
+  s.route ? { routed: true, routeGoal: s.route.goal, routeType: s.route.type, routeSize: s.route.size, routeExplored: !!s.route.explored, routeTrying: !!s.route.trying, routePropensity: s.route.propensity } : {};
+
+export function trackTurns({ runner, telemetry }) {
+  runner.on('started', ({ session, turn }) => telemetry.track('turn_started', { ...runProps(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', {
+      ...runProps(session, turn),
+      ...routeProps(session),
+      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', ...runProps(session, turn) });
+  });
+  if (!envDisabled()) process.on('uncaughtExceptionMonitor', (err) => telemetry.crashed(err));
+}

package/server/services/uploads.js

@@ -0,0 +1,59 @@
+// Attachments: raw bodies streamed to disk, referenced by id from launches and replies.
+// Each upload is <id>-<name> next to an <id>.json with its metadata.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { MIME } from '../http/static.js';
+import { bad, newId } from '../util.js';
+
+export const MAX_UPLOAD = 500 * 1024 * 1024;
+
+export class Uploads {
+  constructor(dir) {
+    this.dir = dir;
+    this.byId = new Map(); // id -> { id, name, mime, size, path }
+    fs.mkdirSync(dir, { recursive: true });
+    for (const f of fs.readdirSync(dir)) {
+      if (!f.endsWith('.json')) continue;
+      try {
+        const u = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8'));
+        this.byId.set(u.id, u);
+      } catch {}
+    }
+  }
+
+  get(id) {
+    return this.byId.get(id);
+  }
+
+  // Upload ids from a request body → their records (unknown ids are dropped).
+  resolve(ids) {
+    return Array.isArray(ids) ? ids.map((i) => this.byId.get(i)).filter(Boolean) : [];
+  }
+
+  async receive(req, { name, type }) {
+    name = path.basename(name || 'file').replace(/[^\w.\- ]+/g, '_').slice(-120) || 'file';
+    const id = newId();
+    const file = path.join(this.dir, `${id}-${name}`);
+    let size = 0;
+    await new Promise((resolve, reject) => {
+      const out = fs.createWriteStream(file);
+      req.on('data', (c) => {
+        size += c.length;
+        if (size > MAX_UPLOAD) {
+          req.destroy();
+          out.destroy();
+          fs.rmSync(file, { force: true });
+          reject(bad('file too large (500 MB max)', 413));
+        }
+      });
+      req.pipe(out);
+      out.on('finish', resolve);
+      out.on('error', reject);
+    });
+    const meta = { id, name, size, mime: type || MIME[path.extname(name).toLowerCase()] || 'application/octet-stream', path: file };
+    this.byId.set(id, meta);
+    fs.writeFileSync(path.join(this.dir, `${id}.json`), JSON.stringify(meta));
+    return meta;
+  }
+}

package/server/services/webhooks.js

@@ -0,0 +1,28 @@
+// POST { event, session, markdown } to each configured webhook (Slack bridges, CI, notifiers).
+// event: session.waiting (blocked on ask_user) | session.finished. Fire and forget.
+
+import { sessionToMarkdown } from '../render.js';
+import { VERSION } from '../util.js';
+
+export function notifyWebhooks(store, summary) {
+  const hooks = store.config.webhooks || [];
+  if (!hooks.length) return;
+  const s = store.get(summary.id);
+  if (!s) return;
+  const event = s.state === 'waiting' ? 'session.waiting' : 'session.finished';
+  const body = JSON.stringify({ event, session: summary, markdown: sessionToMarkdown(s), at: Date.now() });
+  for (const h of hooks) {
+    if (h.events?.length && !h.events.includes(event)) continue;
+    fetch(h.url, { method: 'POST', headers: { 'content-type': 'application/json', 'user-agent': `wisp/${VERSION}` }, body, signal: AbortSignal.timeout(10_000) }).catch((err) =>
+      console.warn(`wisp: webhook ${h.url} failed: ${err.message}`),
+    );
+  }
+}
+
+// A webhook entry from the config API: a URL string or { url, events }.
+export function normalizeWebhooks(list) {
+  const hooks = Array.isArray(list) ? list : [];
+  const wrong = hooks.find((h) => !/^https?:\/\/\S+$/.test(String(h?.url ?? h)));
+  if (wrong !== undefined) return { error: `Not an http(s) URL: ${wrong?.url ?? wrong}` };
+  return { hooks: hooks.map((h) => (typeof h === 'string' ? { url: h } : { url: h.url, events: Array.isArray(h.events) ? h.events : undefined })) };
+}

package/server/store.js

@@ -5,10 +5,11 @@ import path from 'node:path';
 import os from 'node:os';
 import { randomUUID } from 'node:crypto';
 import { parsePresentation } from './protocol.js';
+import { writeJsonAtomic } from './util.js';
 
 const DEFAULT_CONFIG = {
   projects: [], // [{ id, name, path, color, addedAt, machine? }]; machine: the server/machines.js id it lives on
-  defaults: { agent: 'auto', mode: 'edits', model: '', effort: '' }, // auto: wisp picks harness and model (server/router.js)
+  defaults: { agent: 'auto', mode: 'auto', model: '', effort: '' }, // agent auto: wisp picks harness and model (server/router.js)
   recipes: [], // saved prompts with {params}: server/recipes.js
   triggers: [], // schedules and GitHub watchers: server/triggers.js
   teams: [], // saved subagent presets: server/subagents.js
@@ -65,14 +66,22 @@ export class Store {
         cfg.defaults.effort = '';
         cfg.autoIntroduced = true;
       }
+      // Full auto became the default mode: switch once from Edits (the old default); Plan and
+      // any later pick stick.
+      if (!cfg.fullAutoIntroduced) {
+        if (cfg.defaults.mode === 'edits') cfg.defaults.mode = 'auto';
+        cfg.fullAutoIntroduced = true;
+      }
       return cfg;
     } catch {
-      return { ...structuredClone(DEFAULT_CONFIG), autoIntroduced: true };
+      return { ...structuredClone(DEFAULT_CONFIG), autoIntroduced: true, fullAutoIntroduced: true };
     }
   }
 
   saveConfig() {
-    fs.writeFileSync(path.join(this.home, 'config.json'), JSON.stringify(this.config, null, 2));
+    // Atomic: a crash mid-write used to leave a cut-off config.json, which loads as the defaults
+    // (no projects, recipes, triggers or machines) and is then saved over.
+    writeJsonAtomic(path.join(this.home, 'config.json'), this.config, 2);
   }
 
   // --- projects: plain folders, matched to sessions by path prefix ---
@@ -130,8 +139,7 @@ export class Store {
       this.timers.delete(session.id);
       if (!this.sessions.has(session.id)) return;
       const file = path.join(this.dir, `${session.id}.json`);
-      fs.writeFileSync(`${file}.tmp`, JSON.stringify(session));
-      fs.renameSync(`${file}.tmp`, file);
+      writeJsonAtomic(file, session);
     };
     if (now) write();
     else this.timers.set(session.id, setTimeout(write, 400));

package/server/subagents.js

@@ -3,6 +3,7 @@
 // hidden child session working in the lead's folder; delegating to it again resumes it.
 
 import { blocksToMarkdown } from './render.js';
+import { bad } from './util.js';
 
 export const MAX_SUBAGENTS = 6; // rows in the team
 export const MAX_COPIES = 5; // parallel copies of one row
@@ -20,7 +21,7 @@ export function normalizeTeam(list, adapters) {
   const team = list.slice(0, MAX_SUBAGENTS).map((m) => {
     const agent = String(m?.agent || '');
     // auto: wisp picks the harness and model when this member gets its first task.
-    if ((!adapters[agent] && agent !== 'auto') || agent === 'wisp') throw Object.assign(new Error(`unknown subagent harness: ${agent}`), { status: 400 });
+    if ((!adapters[agent] && agent !== 'auto') || agent === 'wisp') throw bad(`unknown subagent harness: ${agent}`);
     let base = slug(m.name) || agent;
     let name = base;
     for (let i = 2; taken.has(name); i++) name = `${base}-${i}`;
@@ -30,7 +31,7 @@ export function normalizeTeam(list, adapters) {
     return { name, agent, model: typeof m.model === 'string' ? m.model.slice(0, 120) : '', effort: EFFORT.test(m.effort || '') ? m.effort : '', use, count };
   });
   const total = team.reduce((n, m) => n + m.count, 0);
-  if (total > MAX_INSTANCES) throw Object.assign(new Error(`At most ${MAX_INSTANCES} subagents in all (this team has ${total}).`), { status: 400 });
+  if (total > MAX_INSTANCES) throw bad(`At most ${MAX_INSTANCES} subagents in all (this team has ${total}).`);
   return team;
 }
 
@@ -40,9 +41,9 @@ export const copies = (m) => ((m.count || 1) > 1 ? Array.from({ length: m.count
 // Saved teams the user can reuse from the launcher: { id, name, members }.
 export function normalizePreset(body, adapters, prev = {}) {
   const name = String(body?.name ?? prev.name ?? '').trim().slice(0, 60);
-  if (!name) throw Object.assign(new Error('A preset needs a name.'), { status: 400 });
+  if (!name) throw bad('A preset needs a name.');
   const members = body?.members !== undefined ? normalizeTeam(body.members, adapters) : prev.members || [];
-  if (!members.length) throw Object.assign(new Error('A preset needs at least one subagent.'), { status: 400 });
+  if (!members.length) throw bad('A preset needs at least one subagent.');
   return { id: prev.id || slug(name) + '-' + Math.random().toString(36).slice(2, 6), name, members, updatedAt: Date.now() };
 }
 

package/server/telemetry.js

@@ -15,6 +15,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
+import { VERSION } from './util.js';
 
 // PostHog project API key: write-only, safe to ship in the client.
 const KEY = process.env.WISP_POSTHOG_KEY ?? 'phc_wowwZkbP8e4zYuwT67JtX6oxdPwkMWL5kKnrUmYYXhcD';
@@ -23,7 +24,6 @@ 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);
 
 const falsy = (v) => /^(0|false|no|off)$/i.test(v || '');

package/server/terminal.js

@@ -6,6 +6,7 @@
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import { escapeCmdArgument, escapeCmdCommand, onPath } from './proc.js';
+import { shq } from './util.js';
 
 // os: which platforms list the entry (all if omitted).
 const ALL_TERMINALS = [
@@ -31,7 +32,7 @@ const ALL_TERMINALS = [
 export const terminalsFor = (platform = process.platform) => ALL_TERMINALS.filter((t) => !t.os || t.os.includes(platform === 'darwin' || platform === 'win32' ? platform : 'linux')).map(({ id, label }) => ({ id, label }));
 export const TERMINALS = terminalsFor();
 
-export const shq = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
+export { shq };
 const psq = (s) => `'${String(s).replace(/'/g, "''")}'`; // PowerShell single-quoted string
 const asStr = (s) => `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`; // AppleScript string
 

package/server/triggers.js

@@ -7,12 +7,11 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { newId } from './runner.js';
+import { bad, MODES, newId } from './util.js';
 import { gh as ghCli } from './git.js';
 import { fill, findRecipe } from './recipes.js';
 
 const KINDS = new Set(['schedule', 'ci', 'issues']);
-const MODES = new Set(['plan', 'edits', 'auto']);
 const TICK_MS = 20_000;
 const MAX_SEEN = 200;
 const MAX_PER_POLL = 3; // a burst of failures shouldn't start a dozen agents
@@ -37,20 +36,20 @@ const ALIASES = { '@hourly': '0 * * * *', '@daily': '0 0 * * *', '@weekly': '0 0
 export function parseCron(expr) {
   const src = ALIASES[String(expr || '').trim()] || String(expr || '').trim();
   const parts = src.split(/\s+/);
-  if (parts.length !== 5) throw Object.assign(new Error('A schedule needs 5 fields: minute hour day-of-month month day-of-week'), { status: 400 });
+  if (parts.length !== 5) throw bad('A schedule needs 5 fields: minute hour day-of-month month day-of-week');
   const out = {};
   parts.forEach((part, i) => {
     const [name, lo, hi] = FIELDS[i];
     const set = new Set();
     for (const piece of part.split(',')) {
       const m = piece.match(/^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/);
-      if (!m) throw Object.assign(new Error(`Bad ${name} field: ${piece}`), { status: 400 });
+      if (!m) throw bad(`Bad ${name} field: ${piece}`);
       let a = m[1] === '*' ? lo : Number(m[2]);
       let b = m[1] === '*' ? hi : m[3] !== undefined ? Number(m[3]) : m[4] ? hi : a;
       const step = m[4] ? Number(m[4]) : 1;
       if (name === 'dow' && b === 7) b = 6, set.add(0); // 7 is Sunday too
       if (name === 'dow' && a === 7) a = 0;
-      if (a < lo || b > hi || a > b || step < 1) throw Object.assign(new Error(`Bad ${name} field: ${piece}`), { status: 400 });
+      if (a < lo || b > hi || a > b || step < 1) throw bad(`Bad ${name} field: ${piece}`);
       for (let v = a; v <= b; v += step) set.add(v);
     }
     out[name] = set;
@@ -86,7 +85,6 @@ export function nextRun(c, from = Date.now()) {
 
 // --- config ----------------------------------------------------------------------------------
 
-const bad = (msg) => Object.assign(new Error(msg), { status: 400 });
 
 export function normalizeTrigger(body, prev = null, { recipes = [] } = {}) {
   const v = (k, d = '') => (body[k] !== undefined ? body[k] : prev?.[k] !== undefined ? prev[k] : d);
@@ -102,7 +100,7 @@ export function normalizeTrigger(body, prev = null, { recipes = [] } = {}) {
   if (kind === 'schedule') parseCron(cron);
   const label = kind === 'issues' ? String(v('label', 'wisp')).trim() : '';
   if (kind === 'issues' && !label) throw bad('Pick the issue label to watch.');
-  const mode = String(v('mode', kind === 'issues' ? 'plan' : 'edits'));
+  const mode = String(v('mode', kind === 'issues' ? 'plan' : 'auto'));
   if (!MODES.has(mode)) throw bad('mode must be plan, edits or auto.');
   const changedSource = prev && (kind !== prev.kind || cwd !== prev.cwd || label !== prev.label || String(v('branch')) !== prev.branch);
   return {