wisp-agents 0.7.0 → 0.8.0

package/server/remote.js

@@ -0,0 +1,279 @@
+// Phone: push "needs you" moments to ntfy or Telegram and take the answers back. Both run on
+// outbound connections only (wisp polls them), so nothing has to reach this machine.
+//
+//   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.
+
+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 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 || ''));
+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 });
+    this.status = { ntfy: null, telegram: null };
+    this.ac = null;
+    this.ntfyPollMs = 4000;
+    this.tgLongPoll = 25;
+  }
+
+  get cfg() {
+    return (this.store.config.remote ||= {});
+  }
+
+  get secret() {
+    if (!this.cfg.secret) {
+      this.cfg.secret = randomBytes(16).toString('hex');
+      this.store.saveConfig();
+    }
+    return this.cfg.secret;
+  }
+
+  get on() {
+    const c = this.cfg;
+    return !!((c.ntfy?.enabled && c.ntfy.topic) || (c.telegram?.enabled && c.telegram.token));
+  }
+
+  start() {
+    this.stop();
+    const ac = (this.ac = new AbortController());
+    const c = this.cfg;
+    if (c.ntfy?.enabled && c.ntfy.topic) this.#ntfyLoop(ac.signal);
+    if (c.telegram?.enabled && c.telegram.token) {
+      if (!c.telegram.chatId && !c.telegram.linkCode) (c.telegram.linkCode = String(randomInt(100000, 999999))), this.store.saveConfig();
+      this.#tgLoop(ac.signal);
+    }
+  }
+
+  stop() {
+    this.ac?.abort();
+    this.ac = null;
+  }
+
+  // What the phone gets for a session that needs you, and the buttons under it.
+  message(s, summary) {
+    const where = `${summary?.project || ''}: ${s.title}`;
+    if (s.ask) {
+      return {
+        title: `❓ ${where}`,
+        text: [s.ask.question, s.ask.context && clip(s.ask.context, 600)].filter(Boolean).join('\n\n'),
+        actions: (s.ask.options || []).map((label, index) => ({ label, kind: 'answer', ref: s.ask.id, index })),
+      };
+    }
+    const turn = s.turns.at(-1);
+    const blocks = turn?.presentation?.blocks || [];
+    const hero = blocks.find((b) => b?.type === 'hero');
+    const q = blocks.findLast((b) => b?.type === 'question');
+    const icon = { done: '✅', partial: '🟡', blocked: '⛔' }[hero?.status] || (turn?.status === 'error' ? '⛔' : '📝');
+    const options = (q?.options || []).map((o) => (typeof o === 'string' ? { label: o } : o));
+    return {
+      title: `${icon} ${where}`,
+      text: [hero?.title && hero.title !== s.title ? hero.title : '', hero?.summary || summary?.preview || 'Ready for review.', q?.question].filter(Boolean).join('\n\n'),
+      actions: options.length ? options.map((o, index) => ({ label: o.label || String(o.reply || ''), kind: 'reply', ref: turn.id, index })) : [{ label: 'Mark done', kind: 'done', ref: turn?.id || '', index: 0 }],
+    };
+  }
+
+  async notify(s, summary) {
+    if (!this.on || !s || s.agent === 'wisp') return;
+    const event = s.state === 'waiting' ? 'waiting' : 'finished';
+    if (!(this.cfg.events || ['waiting', 'finished']).includes(event)) return;
+    await this.send(this.message(s, summary), s);
+  }
+
+  async send(msg, s = null) {
+    const c = this.cfg;
+    const jobs = [];
+    if (c.ntfy?.enabled && c.ntfy.topic) jobs.push(this.#ntfyPublish(msg, s).then(() => this.#mark('ntfy', { ok: true }), (e) => this.#mark('ntfy', { ok: false, error: e.message })));
+    if (c.telegram?.enabled && c.telegram.token && c.telegram.chatId) jobs.push(this.#tgPublish(msg, s).then(() => this.#mark('telegram', { ok: true }), (e) => this.#mark('telegram', { ok: false, error: e.message })));
+    await Promise.all(jobs);
+    return jobs.length;
+  }
+
+  #mark(channel, st) {
+    this.status[channel] = { ...this.status[channel], ...st, at: Date.now() };
+    this.onChange();
+  }
+
+  // --- answers: signed, so a stranger who guesses the topic can't steer your agents ------------
+
+  sign(sessionId, kind, ref, index) {
+    return createHmac('sha256', this.secret).update(`${sessionId}.${kind}.${ref}.${index}`).digest('base64url').slice(0, 22);
+  }
+
+  verify(p) {
+    if (!p || typeof p !== 'object' || !KIND[p.k] || typeof p.sig !== 'string') return false;
+    const want = Buffer.from(this.sign(p.s, KIND[p.k], p.r, p.i));
+    const got = Buffer.from(p.sig);
+    return want.length === got.length && timingSafeEqual(want, got);
+  }
+
+  // --- ntfy ------------------------------------------------------------------------------------
+
+  #ntfy() {
+    const n = this.cfg.ntfy;
+    const server = String(n.server || 'https://ntfy.sh').replace(/\/+$/, '');
+    return { server, topic: n.topic, headers: n.token ? { authorization: `Bearer ${n.token}` } : {} };
+  }
+
+  async #ntfyPublish(msg, s) {
+    const { server, topic, headers } = this.#ntfy();
+    const actions = (s ? msg.actions : []).slice(0, 3).map((a) => {
+      const k = CODE[a.kind];
+      return { action: 'http', label: clip(a.label, 40), url: `${server}/${topic}-reply`, method: 'POST', headers, body: JSON.stringify({ s: s.id, k, r: a.ref, i: a.index, sig: this.sign(s.id, a.kind, a.ref, a.index) }), clear: true };
+    });
+    const r = await fetch(server, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...headers },
+      body: JSON.stringify({ topic, title: clip(msg.title, 200), message: clip(msg.text, 3000), tags: ['wisp'], ...(actions.length && { actions }) }),
+      signal: AbortSignal.timeout(10_000),
+    });
+    if (!r.ok) throw new Error(`ntfy: ${r.status} ${(await r.text().catch(() => '')).slice(0, 120)}`);
+  }
+
+  async #ntfyLoop(signal) {
+    let since = String(Math.floor(Date.now() / 1000));
+    while (!signal.aborted) {
+      try {
+        const { server, topic, headers } = this.#ntfy();
+        const r = await fetch(`${server}/${topic}-reply/json?poll=1&since=${since}`, { headers, signal });
+        if (!r.ok) throw new Error(`ntfy: ${r.status}`);
+        for (const line of (await r.text()).split('\n')) {
+          if (!line.trim()) continue;
+          const m = JSON.parse(line);
+          if (m.id) since = m.id;
+          if (m.event !== 'message') continue;
+          let p = null;
+          try {
+            p = JSON.parse(m.message);
+          } catch {}
+          if (!this.verify(p)) continue; // not ours, or forged
+          await this.act({ sessionId: p.s, kind: KIND[p.k], ref: p.r, index: Number(p.i) }).catch(() => {});
+        }
+        if (this.status.ntfy?.error) this.#mark('ntfy', { ok: true, error: '' });
+      } catch (err) {
+        if (signal.aborted) return;
+        this.#mark('ntfy', { ok: false, error: err.message });
+      }
+      await sleep(this.ntfyPollMs, signal);
+    }
+  }
+
+  // --- Telegram --------------------------------------------------------------------------------
+
+  async #tg(method, body, signal) {
+    const base = (process.env.WISP_TELEGRAM_API || 'https://api.telegram.org').replace(/\/+$/, '');
+    const r = await fetch(`${base}/bot${this.cfg.telegram.token}/${method}`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: signal || AbortSignal.timeout(15_000),
+    });
+    const j = await r.json().catch(() => ({}));
+    if (!j.ok) throw new Error(`Telegram: ${j.description || r.status}`);
+    return j.result;
+  }
+
+  async #tgPublish(msg, s) {
+    const buttons = (s ? msg.actions : []).map((a) => [{ text: clip(a.label, 60), callback_data: `${CODE[a.kind]}:${s.id}:${a.ref}:${a.index}` }]);
+    const sent = await this.#tg('sendMessage', {
+      chat_id: this.cfg.telegram.chatId,
+      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) {
+      s.remote = { ...s.remote, tg: [...(s.remote?.tg || []), sent.message_id].slice(-MAX_TG_IDS) };
+      this.store.save(s);
+    }
+  }
+
+  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);
+        if (this.status.telegram?.error) this.#mark('telegram', { ok: true, error: '' });
+        for (const u of updates) {
+          offset = u.update_id + 1;
+          await this.#fromTelegram(u).catch((err) => console.warn(`wisp: telegram: ${err.message}`));
+        }
+      } catch (err) {
+        if (signal.aborted) return;
+        this.#mark('telegram', { ok: false, error: err.message });
+        await sleep(5000, signal);
+      }
+    }
+  }
+
+  async #fromTelegram(u) {
+    const t = this.cfg.telegram;
+    const say = (text, extra = {}) => this.#tg('sendMessage', { chat_id: t.chatId, text, ...extra });
+    if (u.callback_query) {
+      const q = u.callback_query;
+      if (!t.chatId || String(q.message?.chat?.id) !== String(t.chatId)) return;
+      const [k, sessionId, ref, i] = String(q.data || '').split(':');
+      const result = KIND[k] ? await this.act({ sessionId, kind: KIND[k], ref, index: Number(i) }) : 'Unknown button.';
+      await this.#tg('answerCallbackQuery', { callback_query_id: q.id, text: clip(result, 190) }).catch(() => {});
+      await this.#tg('editMessageReplyMarkup', { chat_id: t.chatId, message_id: q.message.message_id, reply_markup: { inline_keyboard: [] } }).catch(() => {});
+      return;
+    }
+    const m = u.message;
+    if (!m?.text) return;
+    if (!t.chatId) {
+      // Linking: only the chat that sends the code shown in wisp's settings gets attached.
+      if (t.linkCode && m.text.replace(/^\/(start|link)\s*/, '').trim() === t.linkCode) {
+        Object.assign(t, { chatId: m.chat.id, chatName: m.chat.title || [m.chat.first_name, m.chat.last_name].filter(Boolean).join(' ') || m.chat.username || '', linkCode: '' });
+        this.store.saveConfig();
+        this.#mark('telegram', { ok: true, error: '' });
+        await say('✓ Linked to wisp. Questions and finished tasks will show up here.');
+      }
+      return;
+    }
+    if (String(m.chat.id) !== String(t.chatId)) return;
+    const replyTo = m.reply_to_message?.message_id;
+    const s = replyTo && this.store.all().find((x) => x.remote?.tg?.includes(replyTo));
+    if (!s) return say('Reply to one of wisp’s messages to answer it or send a follow-up.');
+    await say(await this.act({ sessionId: s.id, kind: 'text', text: m.text }), { reply_to_message_id: m.message_id });
+  }
+
+  // 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 || '' },
+      status: this.status,
+    };
+  }
+
+  // PUT body: { events, ntfy: {…}, telegram: {…, unlink} }. Masked tokens mean "unchanged".
+  update(body = {}) {
+    const c = this.cfg;
+    const keep = (v, prev) => (typeof v === 'string' && v.startsWith('••••') ? prev : v);
+    if (Array.isArray(body.events)) c.events = body.events.filter((e) => e === 'waiting' || e === 'finished');
+    if (body.ntfy) {
+      const n = { ...c.ntfy, ...body.ntfy };
+      n.token = keep(body.ntfy.token, c.ntfy?.token) || '';
+      if (n.server && !/^https?:\/\/\S+$/.test(n.server)) throw Object.assign(new Error('ntfy server must be an http(s) URL'), { status: 400 });
+      if (n.topic && !/^[\w-]{1,64}$/.test(n.topic)) throw Object.assign(new Error('ntfy topic: letters, digits, - and _ only'), { status: 400 });
+      c.ntfy = { enabled: !!n.enabled, server: n.server || 'https://ntfy.sh', topic: n.topic || '', token: n.token };
+    }
+    if (body.telegram) {
+      const prev = c.telegram || {};
+      const token = keep(body.telegram.token, prev.token) || '';
+      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)) : '' }) };
+    }
+    this.store.saveConfig();
+    this.start();
+    return this.view();
+  }
+}

package/server/render.js

@@ -55,6 +55,18 @@ const R = {
     `${b.branch ? `**Branch** \`${b.branch}\`\n\n` : ''}${list(b.items)
       .map((c) => `- \`${str(c.hash).slice(0, 7)}\` ${str(c.message)}${c.additions !== undefined ? ` (+${c.additions}/−${c.deletions ?? 0})` : ''}`)
       .join('\n')}`,
+  graph: (b) => {
+    const head = `**${str(b.title) || 'Branches'}**${b.ref ? ` ${b.ref}` : ''}${b.state ? ` · ${b.state}` : ''}${b.into ? ` → \`${b.into}\`${b.merge ? ` (${b.merge})` : ''}` : ''}`;
+    const commits = list(b.commits).map((c) => `- ${c.conflict ? '⚠️ ' : ''}\`${str(c.hash).slice(0, 7)}\` ${str(c.message)}${c.branch ? ` [${c.branch}]` : ''}${c.author ? ` — ${c.author}${c.when ? `, ${c.when}` : ''}` : ''}`);
+    const conflicts = list(b.conflicts).map((c, i) => {
+      const o = typeof c === 'string' ? { file: c } : c || {};
+      return `${i + 1}. \`${str(o.file)}${o.line || o.lines ? `:${o.line || o.lines}` : ''}\`${o.detail ? ` — ${o.detail}` : ''}${o.ours ? `\n   - ours: \`${o.ours}\`` : ''}${o.theirs ? `\n   - theirs: \`${o.theirs}\`` : ''}${o.resolution ? `\n   - ✔︎ ${o.resolution}` : ''}`;
+    });
+    const checks = list(b.checks).map((c) => `${c.status === 'fail' ? '❌' : c.status === 'pending' ? '⏳' : '✅'} ${str(c.label || c)}${c.value ? ` ${c.value}` : ''}`);
+    return [head, commits.join('\n'), conflicts.length ? `**Conflicts**\n${conflicts.join('\n')}` : '', checks.join(' · '), b.summary ? str(b.summary) : '']
+      .filter(Boolean)
+      .join('\n\n');
+  },
   terminal: (b) => fence(`$ ${str(b.command)}\n${str(b.output)}${b.exitCode !== undefined && b.exitCode !== 0 ? `\n[exit ${b.exitCode}]` : ''}`, 'console'),
   compare: (b) => ['before', 'after'].map((k) => `**${str(b[k]?.label) || (k === 'before' ? 'Before' : 'After')}**\n${list(b[k]?.items).map((i) => `- ${str(i)}`).join('\n')}`).join('\n\n'),
   flow: (b) => {
@@ -68,6 +80,10 @@ const R = {
   callout: (b) => `> **${b.tone === 'danger' ? '⛔' : b.tone === 'warn' ? '⚠️' : b.tone === 'success' ? '✅' : 'ℹ️'} ${str(b.title)}**\n> ${str(b.text).replace(/\n/g, '\n> ')}`,
   image: (b) => `🖼️ \`${str(b.path || b.src)}\`${b.caption ? ` — ${b.caption}` : ''}`,
   question: (b) => `**❓ ${str(b.question)}**\n${list(b.options).map((o, i) => `${i + 1}. ${str(o.label || o)}`).join('\n')}`,
+  actions: (b) =>
+    `${b.title ? `**${b.title}**\n` : '**Actions**\n'}${list(b.items)
+      .map((a) => (typeof a === 'string' ? `- ${a}` : `- **${str(a.label || a.command)}**${a.command ? ` — \`$ ${str(a.command)}\`` : a.reply ? ` — _${str(a.reply)}_` : ''}${a.detail ? ` (${str(a.detail)})` : ''}`))
+      .join('\n')}`,
   next: (b) => `**Next**\n${list(b.items).map((i) => `- ${str(i)}`).join('\n')}`,
 };
 
@@ -96,5 +112,7 @@ export function sessionToMarkdown(session) {
     out.push(`**❓ The agent is waiting for your answer:** ${session.ask.question}${session.ask.context ? `\n\n${session.ask.context}` : ''}`);
     if (session.ask.options?.length) out.push(session.ask.options.map((o, i) => `${i + 1}. ${o}`).join('\n'));
   }
+  // Worktree sessions: say where the changes are, since they aren't in the caller's checkout.
+  if (session.worktree && turn?.status !== 'running') out.push(`_Changes are on branch \`${session.worktree.branch}\` in the worktree \`${session.worktree.path}\`${session.pr ? ` · PR #${session.pr.number} (${String(session.pr.state).toLowerCase()}): ${session.pr.url}` : ''}._`);
   return out.join('\n\n');
 }

package/server/runner.js

@@ -9,13 +9,27 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { adapters } from './adapters/index.js';
 import { systemPrompt, parsePresentation, heroOf } from './protocol.js';
+import { captureCheckpoint, freshCheckpoint, readGitFile } from './checkpoint.js';
+import { teamNote, copies, SUBAGENT_ASK } from './subagents.js';
 
 const MAX_ACTIVITY = 400;
 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.
+const delegateTool = (askTool) => askTool && askTool.replace(/ask_user$/, 'delegate');
 
 export const newId = () => randomUUID().replace(/-/g, '').slice(0, 12);
 
+// Where the agent actually works: its own worktree when it has one, else the project folder.
+export const workdir = (s) => s.worktree?.cwd || s.cwd;
+
+// Worktree sessions get told where they are, so they don't go looking for the main checkout.
+function workspaceNote(s) {
+  const wt = s.worktree;
+  if (!wt) return '';
+  return `\n\n## Workspace\n\nYou are in an isolated git worktree (${wt.path}) on branch \`${wt.branch}\`, created from \`${wt.baseRef}\` for this task only. Other agents may be working in the user's main checkout, so make every change here. Dependencies and build output (node_modules, virtualenvs, dist/) are not shared with the main checkout: install them if a command needs them. Leave your changes uncommitted unless the user asks you to commit; the user ships them from wisp (commit, push, pull request).`;
+}
+
 function autoTitle(prompt) {
   const line = prompt.trim().split('\n')[0].replace(/\s+/g, ' ');
   return line.length > 64 ? `${line.slice(0, 63)}…` : line;
@@ -26,6 +40,9 @@ export function summarize(s, store) {
   const last = s.turns.at(-1);
   const hero = heroOf(last?.presentation);
   const lastAct = last?.activity?.findLast?.((a) => a.kind !== 'text');
+  // A lead blocked on its subagents says who it's waiting for.
+  const busy = last?.status === 'running' ? (last.delegations || []).filter((d) => store?.get(d.sessionId)?.turns.find((t) => t.id === d.turnId)?.status === 'running') : [];
+  const waitingOn = busy.length ? `Waiting on ${[...new Set(busy.map((d) => d.name))].join(', ')}` : '';
   return {
     id: s.id,
     title: s.title,
@@ -46,9 +63,21 @@ export function summarize(s, store) {
     queued: s.queue?.length || 0,
     status: last?.status === 'running' ? 'running' : hero?.status || (last?.status === 'error' ? 'blocked' : 'info'),
     preview: hero?.summary || '',
-    live: s.ask ? `Asks: ${s.ask.question}` : last?.status === 'running' ? lastAct?.label || 'Starting up' : '',
+    live: s.ask ? `Asks: ${s.ask.question}` : last?.status === 'running' ? waitingOn || lastAct?.label || 'Starting up' : '',
     asks: !!s.ask || !!last?.presentation?.blocks?.some((b) => b.type === 'question'),
     question: s.ask?.question || '',
+    branch: s.worktree?.branch || '',
+    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 }
+    // 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) => {
+        const child = store?.get(s.children?.[name]);
+        return { name, agent: m.agent, model: m.model, effort: m.effort, used: !!child, busy: child?.state === 'running' };
+      }),
+    ),
+    ...(s.parentId && { parentId: s.parentId, member: s.member }),
   };
 }
 
@@ -76,11 +105,12 @@ export class Runner extends EventEmitter {
     }
   }
 
-  create({ prompt, cwd, agent = 'claude', mode = 'edits', model = '', effort = '', attachments = [] }) {
+  // subagents: the team a lead may delegate to. parentId/member: this session is one of them.
+  create({ id = newId(), prompt, cwd, agent = 'claude', mode = 'edits', model = '', effort = '', attachments = [], worktree = null, groupId = null, origin = null, subagents = [], parentId = null, member = '' }) {
     if (!adapters[agent]) throw new Error(`Unknown agent: ${agent}`);
     const now = Date.now();
     const session = {
-      id: newId(),
+      id,
       title: autoTitle(prompt),
       titleAuto: true,
       agent,
@@ -95,9 +125,14 @@ export class Runner extends EventEmitter {
       agentSessionId: null,
       queue: [],
       turns: [],
+      ...(worktree && { worktree }),
+      ...(groupId && { groupId }),
+      ...(origin && { origin }),
+      ...(subagents.length && { subagents, children: {} }),
+      ...(parentId && { parentId, member }),
     };
     this.store.put(session);
-    this.store.touchProject(cwd);
+    if (!parentId) this.store.touchProject(cwd); // a subagent's cwd may be the lead's worktree
     this.#startTurn(session, prompt, attachments);
     return session;
   }
@@ -184,9 +219,75 @@ export class Runner extends EventEmitter {
     return open ? { pending: true } : { cancelled: true };
   }
 
+  // delegate: the lead hands tasks to members of its team. Each member is one child session,
+  // created on first use and resumed after that. Returns one record (or { error }) per task.
+  delegate(lead, tasks) {
+    const turn = lead.turns.at(-1);
+    if (turn?.status !== 'running') throw Object.assign(new Error('The lead agent is not running.'), { status: 409 });
+    const team = lead.subagents || [];
+    if (!team.length) throw Object.assign(new Error('This session has no subagents. The user can add them when launching.'), { status: 400 });
+    const out = [];
+    const claimed = new Set(); // copies handed a task in this call
+    const busy = (name) => claimed.has(name) || this.live.has(lead.children?.[name]);
+    for (const task of Array.isArray(tasks) ? tasks.slice(0, 12) : []) {
+      const want = String(task?.subagent || '').trim();
+      const m = team.find((x) => x.name === want || copies(x).includes(want));
+      const prompt = String(task?.prompt || '').trim();
+      if (!m) {
+        out.push({ subagent: want, error: `No subagent named "${want}". The team: ${team.map((x) => x.name).join(', ')}.` });
+        continue;
+      }
+      if (!prompt) {
+        out.push({ subagent: want, error: 'The task prompt is empty.' });
+        continue;
+      }
+      // A member name goes to its first free copy; a copy name (codex#2) to that copy.
+      const slot = (want === m.name ? copies(m) : [want]).find((n) => !busy(n));
+      if (!slot) {
+        out.push({ subagent: want, error: `${want} is still working${m.count > 1 && want === m.name ? ` (all ${m.count} copies)` : ''} on earlier tasks. Wait with subagent_results, then delegate again.` });
+        continue;
+      }
+      claimed.add(slot);
+      let child = this.store.get(lead.children?.[slot]);
+      if (child) {
+        child.cwd = workdir(lead); // follows the lead if its worktree moved
+        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 });
+        (lead.children ||= {})[slot] = child.id;
+      }
+      const d = { id: newId(), name: slot, member: m.name, agent: m.agent, model: m.model, effort: m.effort, sessionId: child.id, turnId: child.turns.at(-1).id, prompt, startedAt: Date.now() };
+      (turn.delegations ||= []).push(d);
+      out.push(d);
+    }
+    const sent = out.filter((d) => !d.error);
+    if (sent.length) this.#onEvent(lead, turn, { type: 'tool', kind: 'agent', label: `Delegated to ${[...new Set(sent.map((d) => d.name))].join(', ')}` });
+    this.#touch(lead, { turn: turn.id });
+    return out;
+  }
+
+  // Delegations by id (any turn), or the current turn's when ids is empty, with their child sessions.
+  delegations(lead, ids = []) {
+    const all = lead.turns.flatMap((t) => t.delegations || []);
+    const list = ids.length ? all.filter((d) => ids.includes(d.id)) : lead.turns.at(-1)?.delegations || [];
+    return list.map((d) => ({ d, child: this.store.get(d.sessionId) }));
+  }
+
+  // A child's state changed: the lead's card shows it, so the lead's turn re-renders too.
+  #touchLead(child) {
+    const lead = child.parentId && this.store.get(child.parentId);
+    if (!lead) return;
+    const turn = lead.turns.findLast((t) => t.delegations?.some((d) => d.sessionId === child.id)) || lead.turns.at(-1);
+    this.#touch(lead, { turn: turn?.id });
+  }
+
   stop(session) {
     session.queue = [];
     delete session.ask;
+    for (const cid of Object.values(session.children || {})) {
+      const child = this.store.get(cid);
+      if (child) this.stop(child);
+    }
     if (!this.live.has(session.id)) return;
     this.stopping.add(session.id);
     this.live.get(session.id).stop();
@@ -201,8 +302,16 @@ export class Runner extends EventEmitter {
   }
 
   #startTurn(session, prompt, attachments = []) {
+    const id = newId();
+    // A subagent's edits land in the lead's turn, whose checkpoint already covers them.
+    const checkpoint =
+      session.agent === 'wisp' || session.parentId
+        ? null
+        : !session.turns.length && session.worktree?.head
+          ? freshCheckpoint(session.worktree)
+          : captureCheckpoint(workdir(session), session.id, id);
     const turn = {
-      id: newId(),
+      id,
       prompt,
       agent: session.agent,
       model: session.model,
@@ -211,6 +320,7 @@ export class Runner extends EventEmitter {
       startedAt: Date.now(),
       endedAt: null,
       status: 'running',
+      checkpoint,
       activity: [],
       changes: [],
       presentation: null,
@@ -221,28 +331,40 @@ export class Runner extends EventEmitter {
     session.unread = false;
     delete session.archived;
     this.#touch(session, { turn: turn.id });
+    this.#touchLead(session);
     this.emit('started', { session, turn });
 
     let released = false;
     let linger;
     const adapter = adapters[session.agent];
+    // Leads get the delegate tool next to ask_user; subagents get neither (nobody to ask).
+    const team = adapter.askTool !== null ? session.subagents || [] : [];
+    const prompt0 = session.parentId
+      ? systemPrompt({ ask: SUBAGENT_ASK })
+      : systemPrompt({ askTool: adapter.askTool }) + teamNote(team, adapters, delegateTool(adapter.askTool ?? 'mcp__wisp__ask_user'));
     const handle = adapter.run({
       prompt,
       attachments,
-      cwd: session.cwd,
+      cwd: workdir(session),
       resumeId: session.agentSessionId,
       mode: session.mode,
       model: session.model,
       effort: session.effort || '',
-      systemPrompt: systemPrompt({ askTool: adapter.askTool }) + this.promptExtra(session),
-      mcpServers: this.bridge && adapter.askTool !== null
+      systemPrompt: prompt0 + workspaceNote(session) + this.promptExtra(session),
+      mcpServers: this.bridge && adapter.askTool !== null && !session.parentId
         ? {
             wisp: {
               command: process.execPath,
               args: [ASK_SERVER],
               // Inside the desktop app execPath is the Electron binary; without
               // ELECTRON_RUN_AS_NODE it boots a second app (extra Dock icon) per turn.
-              env: { ELECTRON_RUN_AS_NODE: '1', WISP_URL: this.bridge.url, WISP_TOKEN: this.bridge.token, WISP_SESSION: session.id },
+              env: {
+                ELECTRON_RUN_AS_NODE: '1',
+                WISP_URL: this.bridge.url,
+                WISP_TOKEN: this.bridge.token,
+                WISP_SESSION: session.id,
+                ...(team.length && { WISP_TEAM: JSON.stringify(team.map((m) => ({ name: m.name, agent: adapters[m.agent]?.name || m.agent, model: m.model, effort: m.effort, use: m.use, count: m.count || 1, copies: copies(m) }))) }),
+              },
             },
           }
         : {},
@@ -294,10 +416,24 @@ export class Runner extends EventEmitter {
       }
       case 'change': {
         let entry = turn.changes.find((c) => c.file === ev.file);
-        if (!entry) turn.changes.push((entry = { file: ev.file, op: ev.op, edits: [] }));
+        if (!entry) {
+          let beforeFile = ev.beforeFile;
+          if (turn.checkpoint?.commit && !path.isAbsolute(ev.file)) {
+            const fromGit = readGitFile(workdir(session), turn.checkpoint.commit, ev.file);
+            if (fromGit !== null) beforeFile = fromGit;
+            else if (!(turn.checkpoint.untracked || []).includes(ev.file)) beforeFile = null;
+          }
+          turn.changes.push((entry = { file: ev.file, op: ev.op, ...(beforeFile !== undefined ? { beforeFile } : {}), edits: [] }));
+        }
         if (ev.op === 'create' && entry.edits.length === 0) entry.op = 'create';
+        delete entry.reverted;
         entry.edits.push(...ev.edits);
+        if (ev.by && !entry.by?.includes(ev.by)) (entry.by ||= []).push(ev.by);
         this.store.save(session);
+        // A subagent's edits are the lead's too: they show up in its files, diffs and Ship it.
+        const lead = session.parentId && this.store.get(session.parentId);
+        const leadTurn = lead?.turns.at(-1);
+        if (leadTurn?.status === 'running') this.#onEvent(lead, leadTurn, { ...ev, by: session.member });
         return;
       }
       case 'result':
@@ -337,15 +473,18 @@ export class Runner extends EventEmitter {
       turn.presentation = parsePresentation(ev.text);
       this.store.keepImages(session, turn);
       const hero = heroOf(turn.presentation);
-      if (hero?.title && session.titleAuto && session.turns.length === 1) session.title = hero.title;
+      // Compare runs keep the prompt's title: they're one task, and one run's headline shouldn't name it.
+      if (hero?.title && session.titleAuto && session.turns.length === 1 && !session.groupId) session.title = hero.title;
     }
     session.state = 'review';
     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) });
+    this.#touchLead(session);
+    // The follow-up starts right away; don't notify for the run it replaced. A subagent reports
+    // to its lead, not to the user.
+    if (!interrupted && !session.parentId) this.emit('finished', { session: summarize(session, this.store) });
   }
 
   #touch(session, { turn, quiet } = {}) {

package/server/store.js

@@ -9,6 +9,10 @@ import { parsePresentation } from './protocol.js';
 const DEFAULT_CONFIG = {
   projects: [], // [{ id, name, path, color, addedAt }]
   defaults: { agent: 'claude', mode: 'edits', model: '', effort: '' },
+  recipes: [], // saved prompts with {params}: server/recipes.js
+  triggers: [], // schedules and GitHub watchers: server/triggers.js
+  teams: [], // saved subagent presets: server/subagents.js
+  remote: {}, // phone channels (ntfy, Telegram): server/remote.js
 };
 
 const IMAGE_EXT = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg']);
@@ -47,6 +51,10 @@ export class Store {
       const raw = JSON.parse(fs.readFileSync(path.join(this.home, 'config.json'), 'utf8'));
       const cfg = { ...structuredClone(DEFAULT_CONFIG), ...raw, defaults: { ...DEFAULT_CONFIG.defaults, ...raw.defaults } };
       cfg.projects ||= [];
+      cfg.recipes ||= [];
+      cfg.triggers ||= [];
+      cfg.teams ||= [];
+      cfg.remote ||= {};
       return cfg;
     } catch {
       return structuredClone(DEFAULT_CONFIG);
@@ -130,7 +138,7 @@ export class Store {
     (turn.presentation?.blocks || []).forEach((b, i) => {
       const rel = b?.type === 'image' && (b.path || b.src);
       if (typeof rel !== 'string' || !rel || /^https?:/.test(rel)) return;
-      const src = path.resolve(session.cwd || this.home, rel);
+      const src = path.resolve(session.worktree?.cwd || session.cwd || this.home, rel);
       const ext = path.extname(src).toLowerCase();
       if (!IMAGE_EXT.has(ext) || src.startsWith(this.shots + path.sep)) return;
       try {