wisp-agents 0.7.0 → 0.9.0

package/server/mcp-ask.js

@@ -2,10 +2,16 @@
 // Minimal stdio MCP server exposing `ask_user`, injected into every agent wisp launches.
 // The call is relayed to the wisp server, which surfaces it in the queue and blocks
 // (by polling) until the user answers — so the agent keeps its full context.
+// With a team (WISP_TEAM), it also offers `delegate` and `subagent_results`: tasks for the
+// subagents the user picked, which wisp runs as child sessions while this call waits.
 
 import readline from 'node:readline';
 
 const { WISP_URL, WISP_TOKEN, WISP_SESSION } = process.env;
+let TEAM = [];
+try {
+  TEAM = JSON.parse(process.env.WISP_TEAM || '[]');
+} catch {}
 
 const TOOL = {
   name: 'ask_user',
@@ -24,6 +30,67 @@ const TOOL = {
   },
 };
 
+const roster = TEAM.map((m) => `- ${m.name}${m.count > 1 ? ` ×${m.count} (parallel copies ${m.copies.join(', ')})` : ''}: ${[m.agent, m.model || 'default model', m.effort && `${m.effort} thinking`].filter(Boolean).join(' · ')}${m.use ? ` — use for: ${m.use}` : ''}`).join('\n');
+const TEAM_TOOLS = [
+  {
+    name: 'delegate',
+    description:
+      'Hand tasks to your subagents (separate coding agents the user picked, each on its own harness and model). ' +
+      'Tasks in one call run in parallel in your working folder. By default the call waits until every task finishes and ' +
+      'returns each report plus the files it changed; wait=false returns delegation ids at once. Delegating to a subagent ' +
+      'again continues its conversation. Use this instead of any built-in subagent or task tool.\n\nThe team:\n' + roster,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        tasks: {
+          type: 'array',
+          minItems: 1,
+          items: {
+            type: 'object',
+            properties: {
+              subagent: { type: 'string', enum: TEAM.flatMap((m) => (m.count > 1 ? [m.name, ...m.copies] : [m.name])), description: 'Which subagent. A name with copies (×N) goes to a free copy; name a copy (x#2) to continue it.' },
+              prompt: { type: 'string', description: 'The task, briefed like a colleague: goal, files, constraints, how to verify. It cannot see your conversation.' },
+            },
+            required: ['subagent', 'prompt'],
+          },
+        },
+        wait: { type: 'boolean', description: 'Wait for all tasks to finish (default true).' },
+      },
+      required: ['tasks'],
+    },
+  },
+  {
+    name: 'subagent_results',
+    description: 'Wait for delegated tasks and return their reports. Pass the ids delegate returned; with none, every task delegated in this turn.',
+    inputSchema: { type: 'object', properties: { ids: { type: 'array', items: { type: 'string' } }, wait: { type: 'boolean', description: 'Default true; false returns current status at once.' } } },
+  },
+];
+
+async function results(ids, wait = true) {
+  for (;;) {
+    let r;
+    try {
+      r = await call(`/api/internal/delegate/${WISP_SESSION}?ids=${encodeURIComponent((ids || []).join(','))}`);
+    } catch (err) {
+      if (!wait) throw err;
+      await sleep(1500);
+      continue; // wisp restarting — keep waiting
+    }
+    if (r.done || !wait) return r.text;
+    await sleep(1500);
+  }
+}
+
+async function delegate({ tasks, wait = true }) {
+  const r = await call(`/api/internal/delegate/${WISP_SESSION}`, { tasks });
+  const ok = r.delegations.filter((d) => !d.error);
+  const errors = r.delegations.filter((d) => d.error).map((d) => `- ${d.subagent}: ${d.error}`).join('\n');
+  if (!ok.length) return `Nothing was delegated.\n${errors}`;
+  const head = errors ? `Some tasks were not delegated:\n${errors}\n\n` : '';
+  if (!wait) return `${head}Delegated: ${ok.map((d) => `${d.name} (id ${d.id})`).join(', ')}. Collect the reports with subagent_results.`;
+  return head + (await results(ok.map((d) => d.id)));
+}
+
 const send = (msg) => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', ...msg }) + '\n');
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
@@ -66,17 +133,23 @@ readline.createInterface({ input: process.stdin }).on('line', async (line) => {
     if (method === 'initialize') {
       send({ id, result: { protocolVersion: params?.protocolVersion || '2025-06-18', capabilities: { tools: {} }, serverInfo: { name: 'wisp', version: '0.1.0' } } });
     } else if (method === 'tools/list') {
-      send({ id, result: { tools: [TOOL] } });
+      send({ id, result: { tools: TEAM.length ? [TOOL, ...TEAM_TOOLS] : [TOOL] } });
     } else if (method === 'tools/call' && params?.name === 'ask_user') {
       const answer = await askUser(params.arguments || {});
       const text = answer === null ? 'The user did not answer (the question was cancelled). Use your best judgment and note the assumption.' : `The user answered: ${answer}`;
       send({ id, result: { content: [{ type: 'text', text }] } });
+    } else if (method === 'tools/call' && TEAM.length && params?.name === 'delegate') {
+      send({ id, result: { content: [{ type: 'text', text: await delegate(params.arguments || {}) }] } });
+    } else if (method === 'tools/call' && TEAM.length && params?.name === 'subagent_results') {
+      const a = params.arguments || {};
+      send({ id, result: { content: [{ type: 'text', text: await results(a.ids, a.wait !== false) }] } });
     } else if (method === 'ping') {
       send({ id, result: {} });
     } else {
       send({ id, error: { code: -32601, message: `Method not found: ${method}` } });
     }
   } catch (err) {
-    send({ id, result: { isError: true, content: [{ type: 'text', text: `wisp could not reach the user: ${err.message}` }] } });
+    const what = params?.name === 'ask_user' ? 'wisp could not reach the user' : 'wisp';
+    send({ id, result: { isError: true, content: [{ type: 'text', text: `${what}: ${err.message}` }] } });
   }
 });

package/server/mcp-wisp.js

@@ -1,5 +1,5 @@
 // `wisp mcp`: a stdio MCP server that lets any MCP-capable agent or editor (Claude Code, Codex,
-// opencode, Cursor, Antigravity, Claude Desktop, Zed, …) hand tasks to wisp and read the results back.
+// opencode, Cursor, Antigravity, Grok, Claude Desktop, Zed, …) hand tasks to wisp and read the results back.
 // It talks to the running wisp over HTTP (starting a headless one if needed) via the client SDK.
 //
 //   claude mcp add wisp -- npx -y wisp-agents mcp
@@ -9,7 +9,7 @@ import fs from 'node:fs';
 import { WispClient } from './client.js';
 
 const VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
-const AGENTS = ['claude', 'codex', 'opencode', 'cursor', 'antigravity'];
+const AGENTS = ['claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'];
 const DEFAULT_WAIT_S = 240; // stay under typical MCP client tool-call timeouts; call wisp_wait again for more
 
 const TOOLS = [
@@ -28,6 +28,12 @@ const TOOLS = [
         mode: { type: 'string', enum: ['plan', 'edits', 'auto'], description: 'plan = read-only, edits = auto-accept file edits, auto = no permission prompts. Default: the user’s pick.' },
         model: { type: 'string', description: 'Model id for that harness. Default: the user’s pick.' },
         effort: { type: 'string', description: 'Thinking level, e.g. low | medium | high.' },
+        subagents: {
+          type: 'array',
+          description: 'A team the agent can delegate to, each on its own harness: [{ agent, model?, effort?, name?, use?, count? }]. use = when to pick it ("research", "image work"); count = parallel copies (1–5).',
+          items: { type: 'object', properties: { agent: { type: 'string', enum: AGENTS }, model: { type: 'string' }, effort: { type: 'string' }, name: { type: 'string' }, use: { type: 'string' }, count: { type: 'integer', minimum: 1, maximum: 5 } }, required: ['agent'] },
+        },
+        preset: { type: 'string', description: 'Id of a saved subagent preset, instead of subagents.' },
         wait: { type: 'boolean', description: 'Block until the agent finishes or asks (up to timeout_seconds).' },
         timeout_seconds: { type: 'number', description: `Max wait when wait=true. Default ${DEFAULT_WAIT_S}.` },
       },
@@ -98,7 +104,7 @@ async function callTool(name, a = {}) {
   switch (name) {
     case 'wisp_launch': {
       if (!a.prompt?.trim()) throw new Error('prompt is required');
-      const s = await c.launch({ prompt: a.prompt, cwd: a.cwd || process.cwd(), agent: a.agent, mode: a.mode, model: a.model, effort: a.effort });
+      const s = await c.launch({ prompt: a.prompt, cwd: a.cwd || process.cwd(), agent: a.agent, mode: a.mode, model: a.model, effort: a.effort, subagents: a.subagents, preset: a.preset });
       if (a.wait) return waitFor(s.id);
       return `Launched session \`${s.id}\` (“${s.title}”) on ${s.agent} in ${s.cwd}, mode ${s.mode}. Call wisp_wait or wisp_get with this id for the result.`;
     }

package/server/openapi.js

@@ -16,7 +16,7 @@ export function openapi({ version, port }) {
       title: 'wisp',
       version,
       description:
-        'Local API of wisp, a launcher and queue for coding agents (Claude Code, Codex, opencode, Cursor, Antigravity). ' +
+        'Local API of wisp, a launcher and queue for coding agents (Claude Code, Codex, opencode, Cursor, Antigravity, Grok). ' +
         'Binds to 127.0.0.1 only. Requests must carry a Host of 127.0.0.1/localhost:<port>; non-GET requests must be ' +
         'application/json (uploads: application/octet-stream) and, if they send an Origin, a local one. ' +
         'The running server advertises { url, port, pid, version } in ~/.wisp/server.json.',
@@ -81,17 +81,90 @@ export function openapi({ version, port }) {
           ],
           responses: { 200: json({ type: 'array', items: ref('Summary') }) },
         },
-        post: { summary: 'Launch a task', requestBody: body(ref('Launch')), responses: { 201: json(ref('Summary')), 400: err[400] } },
+        post: { summary: 'Launch a task. With `compare`, the response is the first session plus `group`: every session started', requestBody: body(ref('Launch')), responses: { 201: json(ref('Summary')), 400: err[400] } },
       },
       '/sessions/{id}': {
         parameters: [id],
         get: { summary: 'Full session record: turns, activity, captured edits, presentations', responses: { 200: json({ type: 'object' }), 404: err[404] } },
         patch: {
           summary: 'Rename, mark done/review, mark read, archive',
-          requestBody: body({ type: 'object', properties: { title: { type: 'string' }, state: { enum: ['done', 'review'] }, unread: { type: 'boolean' }, archived: { type: 'boolean' } } }),
+          requestBody: body({ type: 'object', properties: { title: { type: 'string' }, state: { enum: ['done', 'review'] }, unread: { type: 'boolean' }, archived: { type: 'boolean' }, discardWorktree: { type: 'boolean', description: 'Remove the worktree and its uncommitted changes (a compare run you did not keep)' } } }),
           responses: { 200: json(ref('Summary')), 404: err[404] },
         },
-        delete: { summary: 'Stop and delete', responses: { 200: ok, 404: err[404] } },
+        delete: { summary: 'Stop and delete. Its worktree is removed; its branch too unless it has commits', responses: { 200: ok, 404: err[404] } },
+      },
+      '/sessions/{id}/ship': {
+        parameters: [id],
+        get: { summary: 'What would ship: { branch, base, remote, dirty, ahead, pr, title, body } (drafted from the latest presentation)', responses: { 200: json({ type: 'object' }), 400: err[400] } },
+        post: {
+          summary: 'Commit uncommitted changes in the worktree, push its branch, open (or update) the pull request with gh',
+          requestBody: body({ type: 'object', properties: { title: { type: 'string', description: 'Commit message and PR title' }, body: { type: 'string' }, draft: { type: 'boolean' } } }),
+          responses: { 200: json(ref('PullRequest')), 400: err[400], 409: json(ref('Error'), 'Still running') },
+        },
+      },
+      '/sessions/{id}/pr': { parameters: [id], post: { summary: 'Refresh the PR status (checks, review, state) now; it is also polled every minute', responses: { 200: json(ref('PullRequest')), 404: err[404] } } },
+      '/sessions/{id}/merge': {
+        parameters: [id],
+        post: { summary: 'Mark the PR ready if draft, squash-merge it with --match-head-commit, fast-forward the local base branch, remove the worktree', responses: { 200: json({ type: 'object', properties: { pr: ref('PullRequest'), sync: { type: 'object', properties: { ok: { type: 'boolean' }, text: { type: 'string' } } } } }), 400: err[400] } },
+      },
+      '/recipes': {
+        get: { summary: 'Saved recipes, with the {params} found in each prompt', responses: { 200: json({ type: 'array', items: ref('Recipe') }) } },
+        post: { summary: 'Save a recipe', requestBody: body(ref('Recipe')), responses: { 201: json(ref('Recipe')), 400: err[400] } },
+      },
+      '/recipes/{key}': {
+        parameters: [{ name: 'key', in: 'path', required: true, schema: { type: 'string' }, description: 'Recipe id or name' }],
+        get: { summary: 'One recipe', responses: { 200: json(ref('Recipe')), 404: err[404] } },
+        patch: { summary: 'Edit a recipe', requestBody: body(ref('Recipe')), responses: { 200: json(ref('Recipe')), 400: err[400] } },
+        delete: { summary: 'Delete a recipe', responses: { 200: ok } },
+      },
+      '/recipes/{key}/run': {
+        parameters: [{ name: 'key', in: 'path', required: true, schema: { type: 'string' } }],
+        post: {
+          summary: 'Run a recipe: fill its {params} and launch',
+          requestBody: body({ type: 'object', properties: { params: { type: 'object', additionalProperties: { type: 'string' } }, words: { type: 'array', items: { type: 'string' }, description: 'Positional values, in the order the params appear' }, cwd: { type: 'string', description: 'Used when the recipe has no project of its own' }, agent: { type: 'string' }, model: { type: 'string' }, effort: { type: 'string' }, mode: { enum: ['plan', 'edits', 'auto'] } } }),
+          responses: { 201: json(ref('Summary')), 400: err[400], 404: err[404] },
+        },
+      },
+      '/triggers': {
+        get: { summary: 'Schedules and GitHub watchers, with nextAt and the last run', responses: { 200: json({ type: 'array', items: ref('Trigger') }) } },
+        post: { summary: 'Add a trigger', requestBody: body(ref('Trigger')), responses: { 201: json(ref('Trigger')), 400: err[400] } },
+      },
+      '/triggers/{tid}': {
+        parameters: [{ name: 'tid', in: 'path', required: true, schema: { type: 'string' } }],
+        patch: { summary: 'Edit, enable or disable a trigger', requestBody: body(ref('Trigger')), responses: { 200: json(ref('Trigger')), 400: err[400] } },
+        delete: { summary: 'Delete a trigger', responses: { 200: ok } },
+      },
+      '/triggers/{tid}/run': { parameters: [{ name: 'tid', in: 'path', required: true, schema: { type: 'string' } }], post: { summary: 'Fire a schedule now, or poll a watcher now (firing for anything new)', responses: { 200: json({ type: 'object', properties: { started: { type: 'array', items: ref('Summary') }, trigger: ref('Trigger') } }) } } },
+      '/remote': {
+        get: { summary: 'Phone channels (ntfy, Telegram) with secrets masked, and their status', responses: { 200: json({ type: 'object' }) } },
+        put: {
+          summary: 'Configure phone channels. A masked token (••••1234) means unchanged',
+          requestBody: body({ type: 'object', properties: { events: { type: 'array', items: { enum: ['waiting', 'finished'] } }, ntfy: { type: 'object', properties: { enabled: { type: 'boolean' }, server: { type: 'string' }, topic: { type: 'string' }, token: { type: 'string' } } }, telegram: { type: 'object', properties: { enabled: { type: 'boolean' }, token: { type: 'string' }, unlink: { type: 'boolean' } } } } }),
+          responses: { 200: json({ type: 'object' }), 400: err[400] },
+        },
+      },
+      '/machines': {
+        get: { summary: 'Machines (other computers over SSH) with connection state, steps, hints and their wisp version and harnesses', responses: { 200: json({ type: 'array', items: { type: 'object' } }) } },
+        post: {
+          summary: 'Add a machine and connect (unless connect: false). wisp starts itself there over SSH and tunnels back',
+          requestBody: body({ type: 'object', required: ['target'], properties: { target: { type: 'string', description: 'user@host, a host, or a Host from ~/.ssh/config' }, name: { type: 'string' }, port: { type: 'integer', default: 4477, description: 'wisp port on the machine' }, command: { type: 'string', description: 'Start command; default npx -y wisp-agents@<this version>' }, autoConnect: { type: 'boolean', default: true }, connect: { type: 'boolean', default: true } } }),
+          responses: { 201: json({ type: 'object' }), 400: err[400] },
+        },
+      },
+      '/machines/ssh-hosts': { get: { summary: 'Hosts from ~/.ssh/config, for suggestions', responses: { 200: json({ type: 'array', items: { type: 'object' } }) } } },
+      '/machines/{mid}': { parameters: [{ name: 'mid', in: 'path', required: true, schema: { type: 'string' } }], patch: { summary: 'Edit a machine (host, port or command changes reconnect)', responses: { 200: json({ type: 'object' }) } }, delete: { summary: 'Remove a machine and its projects here (nothing on the machine is touched)', responses: { 200: json({ type: 'object' }) } } },
+      '/machines/{mid}/connect': { parameters: [{ name: 'mid', in: 'path', required: true, schema: { type: 'string' } }], post: { summary: 'Connect: SSH in, start wisp there if needed, open the tunnel', responses: { 200: json({ type: 'object' }) } } },
+      '/machines/{mid}/disconnect': { parameters: [{ name: 'mid', in: 'path', required: true, schema: { type: 'string' } }], post: { summary: 'Close the tunnel; wisp and its agents keep running there', responses: { 200: json({ type: 'object' }) } } },
+      '/machines/{mid}/stop': { parameters: [{ name: 'mid', in: 'path', required: true, schema: { type: 'string' } }], post: { summary: 'Stop wisp on the machine (its agents too); restart: true starts this version in its place', requestBody: body({ type: 'object', properties: { restart: { type: 'boolean' } } }), responses: { 200: json({ type: 'object' }) } } },
+      '/machines/{mid}/fs': { parameters: [{ name: 'mid', in: 'path', required: true, schema: { type: 'string' } }, { name: 'q', in: 'query', schema: { type: 'string' } }], get: { summary: 'Folder suggestions on the machine', responses: { 200: json({ type: 'array', items: { type: 'string' } }) } } },
+      '/machines/{mid}/discover': { parameters: [{ name: 'mid', in: 'path', required: true, schema: { type: 'string' } }], get: { summary: 'Git repos found on the machine that are not projects yet', responses: { 200: json({ type: 'array', items: { type: 'object' } }) } } },
+      '/remote/test': { post: { summary: 'Send a test message to the enabled channels', responses: { 200: json({ type: 'object' }), 400: err[400] } } },
+      '/usage': {
+        get: {
+          summary: 'Spend and outcomes: totals, per day, per project, per harness · model',
+          parameters: [{ name: 'days', in: 'query', schema: { type: 'integer', default: 30, maximum: 365 } }],
+          responses: { 200: json({ type: 'object' }) },
+        },
       },
       '/sessions/{id}/wait': {
         parameters: [id, { name: 'timeout', in: 'query', schema: { type: 'integer', default: 60, maximum: 290 }, description: 'Seconds' }],
@@ -114,6 +187,30 @@ export function openapi({ version, port }) {
         },
       },
       '/sessions/{id}/answer': { parameters: [id], post: { summary: 'Answer the pending ask_user question', requestBody: body({ type: 'object', required: ['text'], properties: { text: { type: 'string' } } }), responses: { 200: ok } } },
+      '/sessions/{id}/revert': {
+        parameters: [id],
+        post: {
+          summary: 'Revert (or re-apply) a single file’s changes from a turn',
+          requestBody: body({ type: 'object', required: ['file'], properties: { file: { type: 'string' }, turnId: { type: 'string' }, restore: { type: 'boolean' } } }),
+          responses: { 200: json({ type: 'object', properties: { ok: { type: 'boolean' }, turnId: { type: 'string' }, file: { type: 'string' }, reverted: { type: 'boolean' } } }), 400: err[400], 404: err[404] },
+        },
+      },
+      '/sessions/{id}/rollback': {
+        parameters: [id],
+        post: {
+          summary: 'Restore the project working tree to the checkpoint before a turn (or re-apply)',
+          requestBody: body({ type: 'object', properties: { turnId: { type: 'string' }, restore: { type: 'boolean' } } }),
+          responses: { 200: json({ type: 'object', properties: { ok: { type: 'boolean' }, turnId: { type: 'string' }, rolledBack: { type: 'boolean' }, files: { type: 'array', items: { type: 'string' } } } }), 400: err[400], 404: err[404] },
+        },
+      },
+      '/sessions/{id}/exec': {
+        parameters: [id],
+        post: {
+          summary: 'Run a shell command from an actionable presentation block in the session’s project folder',
+          requestBody: body({ type: 'object', required: ['command'], properties: { command: { type: 'string' }, turnId: { type: 'string' }, key: { type: 'string' } } }),
+          responses: { 200: json({ type: 'object', properties: { command: { type: 'string' }, output: { type: 'string' }, exitCode: { type: 'integer' }, durationMs: { type: 'integer' } } }), 400: err[400] },
+        },
+      },
       '/sessions/{id}/stop': { parameters: [id], post: { summary: 'Stop the run and drop queued follow-ups', responses: { 200: ok } } },
       '/sessions/{id}/queue': { parameters: [id, { name: 'item', in: 'query', required: true, schema: { type: 'string' } }], delete: { summary: 'Cancel a queued follow-up', responses: { 200: ok, 404: err[404] } } },
       '/sessions/{id}/takeover': {
@@ -149,11 +246,69 @@ export function openapi({ version, port }) {
           properties: {
             prompt: { type: 'string' },
             cwd: { type: 'string', description: 'Project folder (absolute; ~ allowed). Default: the server’s cwd' },
-            agent: { enum: ['claude', 'codex', 'opencode', 'cursor', 'antigravity'], default: 'claude' },
+            agent: { enum: ['claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'], default: 'claude' },
             mode: { enum: ['plan', 'edits', 'auto'], default: 'edits' },
             model: { type: 'string' },
             effort: { type: 'string', description: 'Thinking level: low, medium, high, xhigh, max (per harness)' },
             attachments: { type: 'array', items: { type: 'string' }, description: 'Upload ids' },
+            worktree: { type: 'boolean', description: 'Run in a fresh git worktree + branch. Default: on in git repos (Settings), off in plan mode' },
+            subagents: { type: 'array', maxItems: 6, items: { type: 'object', required: ['agent'], properties: { name: { type: 'string' }, agent: { type: 'string' }, model: { type: 'string' }, effort: { type: 'string' }, use: { type: 'string', description: 'When the lead should pick this one' }, count: { type: 'integer', minimum: 1, maximum: 5, description: 'Identical copies that take tasks in parallel (name#1, name#2, …); 12 in all' } } }, description: 'A team the lead can delegate to through the injected `delegate` tool. Each runs as a child session in the lead’s folder' },
+            preset: { type: 'string', description: 'Id of a saved team (`/teams`), used when `subagents` is absent' },
+            compare: { type: 'array', maxItems: 3, items: { type: 'object', properties: { agent: { type: 'string' }, model: { type: 'string' }, effort: { type: 'string' } } }, description: 'Also run the same task on these, each in its own worktree' },
+          },
+        },
+        PullRequest: {
+          type: 'object',
+          properties: {
+            number: { type: 'integer' },
+            url: { type: 'string' },
+            state: { enum: ['OPEN', 'CLOSED', 'MERGED'] },
+            draft: { type: 'boolean' },
+            review: { type: 'string', description: 'APPROVED | CHANGES_REQUESTED | REVIEW_REQUIRED | ""' },
+            checks: { type: 'object', properties: { pass: { type: 'integer' }, fail: { type: 'integer' }, pending: { type: 'integer' } } },
+            head: { type: 'string' },
+            base: { type: 'string' },
+          },
+        },
+        Recipe: {
+          type: 'object',
+          required: ['name', 'prompt'],
+          properties: {
+            id: { type: 'string' },
+            name: { type: 'string' },
+            prompt: { type: 'string', description: '{name} placeholders become parameters' },
+            params: { type: 'array', items: { type: 'string' }, readOnly: true },
+            cwd: { type: 'string', description: 'Project path, or empty for any project' },
+            agent: { type: 'string' },
+            model: { type: 'string' },
+            effort: { type: 'string' },
+            mode: { enum: ['', 'plan', 'edits', 'auto'] },
+          },
+        },
+        Trigger: {
+          type: 'object',
+          required: ['kind', 'cwd'],
+          properties: {
+            id: { type: 'string' },
+            name: { type: 'string' },
+            kind: { enum: ['schedule', 'ci', 'issues'] },
+            enabled: { type: 'boolean' },
+            cwd: { type: 'string' },
+            prompt: { type: 'string', description: 'Template; ci gets {id} {name} {branch} {sha} {url}, issues get {number} {title} {body} {url} {author}' },
+            recipeId: { type: 'string', description: 'Run this recipe instead of prompt' },
+            params: { type: 'object' },
+            cron: { type: 'string', description: 'schedule: 5-field cron, local time' },
+            branch: { type: 'string', description: 'ci: only failures on this branch' },
+            label: { type: 'string', description: 'issues: the label to watch' },
+            every: { type: 'integer', description: 'ci/issues: minutes between polls' },
+            agent: { type: 'string' },
+            model: { type: 'string' },
+            effort: { type: 'string' },
+            mode: { enum: ['plan', 'edits', 'auto'] },
+            nextAt: { type: ['integer', 'null'], readOnly: true },
+            lastRunAt: { type: ['integer', 'null'], readOnly: true },
+            lastSessionId: { type: ['string', 'null'], readOnly: true },
+            lastError: { type: 'string', readOnly: true },
           },
         },
         Summary: {
@@ -180,6 +335,10 @@ export function openapi({ version, port }) {
             turnCount: { type: 'integer' },
             createdAt: { type: 'integer' },
             updatedAt: { type: 'integer' },
+            branch: { type: 'string', description: 'Worktree branch, if it has one' },
+            pr: { type: ['object', 'null'], description: 'Its pull request, once shipped' },
+            groupId: { type: ['string', 'null'], description: 'Shared by sessions launched together with compare' },
+            origin: { type: ['object', 'null'], description: '{ kind: recipe | trigger, id, name } when not launched by hand' },
           },
         },
         Presentation: {

package/server/protocol.js

@@ -42,6 +42,13 @@ diff, the test run, the command output — over prose. Use file paths relative t
   A test/lint/type-check run you actually executed. Prefer this over "terminal" for test runs.
 - {"type":"commits","items":[{"hash":"a1b2c3d","message":"feat(auth): add rate limiter","files":3,"additions":120,"deletions":8}],"branch":"feat/limit"}
   Commits you created, if any.
+- {"type":"graph","title":"Refresh sessions in auth","ref":"#128","state":"open|draft|merged|closed","into":"main","merge":"conflict|ready|merged|blocked|pending",
+   "commits":[{"hash":"d29f50","message":"Add refresh tests","branch":"feat/refresh","author":"You","when":"now"},{"hash":"5be27d","message":"Rotate keys","branch":"main","author":"Lena","when":"6m","conflict":true}],
+   "conflicts":[{"file":"src/auth.ts","line":42,"commit":"5be27d","detail":"Both sides rewrote getSession()","ours":"refresh(token)","theirs":"rotate(key)","resolution":"Rotate first, then refresh"}],
+   "checks":[{"label":"Tests","value":"42 passed","status":"pass|fail|pending"}],"action":{"label":"Resolve conflicts","reply":"Merge main in and resolve the conflicts"}}
+  Branch graph, newest commit first; each commit's "branch" gives its lane ("into" is the base lane).
+  Use it to explain merge conflicts, a rebase, or where branches diverged. Mark the base commits that
+  conflict with "conflict":true; optional "parents":[hash,…] for merge commits.
 - {"type":"tree","title":"…","items":[{"path":"src/auth/limiter.ts","change":"added","note":"…"}]}
   A file tree; use for new modules/scaffolding where structure matters.
 - {"type":"code","language":"ts","code":"…","caption":"…","file":"src/a.ts","line":10,"highlight":[3,4]}
@@ -58,6 +65,8 @@ diff, the test run, the command output — over prose. Use file paths relative t
   A screenshot or generated image on disk.
 - {"type":"question","question":"…","options":[{"label":"Short choice","reply":"full message sent back to you"}]}
   When you need a decision. The user's click resumes you with the reply.
+- {"type":"actions","title":"…","items":[{"label":"Run tests","command":"npm test"},{"label":"Follow up","reply":"…"}]}
+  One-click shell commands (executed in the project root) or follow-up actions the user may want to trigger.
 - {"type":"next","items":["Suggested follow-up the user might send", "…"]}
   Usually last. 2–4 concrete follow-ups.
 
@@ -82,7 +91,8 @@ const ASK_BLOCK = `- If a decision would change the rest of the work (ambiguous
   The user's answer comes back as a follow-up in this same session.`;
 
 // askTool: how the harness names wisp's injected ask_user tool, or null if it can't take one.
-export const systemPrompt = ({ askTool = 'mcp__wisp__ask_user' } = {}) => PROTOCOL.replace('{{ASK}}', askTool ? ASK_TOOL(askTool) : ASK_BLOCK);
+// ask: replaces the ask guidance outright (subagents, who have nobody to ask).
+export const systemPrompt = ({ askTool = 'mcp__wisp__ask_user', ask } = {}) => PROTOCOL.replace('{{ASK}}', ask || (askTool ? ASK_TOOL(askTool) : ASK_BLOCK));
 export const SYSTEM_PROMPT = systemPrompt();
 
 // Only the opener is matched by regex. The closing fence can't be: the JSON itself often

package/server/recipes.js

@@ -0,0 +1,64 @@
+// Recipes: saved prompts for tasks you send again and again. `{name}` in the prompt is a
+// parameter, filled in when the recipe runs (the run dialog, `wisp run release 0.8.0`, a trigger).
+
+import path from 'node:path';
+import { newId } from './runner.js';
+
+const PARAM = /\{([a-zA-Z][\w-]{0,30})\}/g;
+const MODES = new Set(['plan', 'edits', 'auto']);
+
+export const params = (prompt) => [...new Set([...String(prompt || '').matchAll(PARAM)].map((m) => m[1]))];
+
+// strict: every parameter needs a value (a person ran it). Otherwise unknown ones become ''
+// (a trigger filling in an empty issue body). Values are inserted once, never re-expanded.
+export function fill(prompt, values = {}, { strict = true } = {}) {
+  const has = (k) => values[k] !== undefined && values[k] !== null && String(values[k]).trim() !== '';
+  const missing = params(prompt).filter((k) => !has(k));
+  if (strict && missing.length) throw Object.assign(new Error(`Missing ${missing.map((k) => `{${k}}`).join(', ')}`), { status: 400 });
+  return String(prompt).replace(PARAM, (_, k) => (has(k) ? String(values[k]) : ''));
+}
+
+// Fill positional CLI words into the parameters in the order they appear.
+export function positional(prompt, words = []) {
+  const out = {};
+  params(prompt).forEach((k, i) => words[i] !== undefined && (out[k] = words[i]));
+  return out;
+}
+
+const bad = (msg) => Object.assign(new Error(msg), { status: 400 });
+
+export function normalizeRecipe(body, prev = null) {
+  const name = String(body.name ?? prev?.name ?? '').trim().slice(0, 60);
+  const prompt = String(body.prompt ?? prev?.prompt ?? '').trim();
+  if (!name) throw bad('A recipe needs a name.');
+  if (!prompt) throw bad('A recipe needs a prompt.');
+  const cwd = body.cwd !== undefined ? String(body.cwd || '') : prev?.cwd || '';
+  if (cwd && !path.isAbsolute(cwd)) throw bad('cwd must be an absolute project path (or empty for any project).');
+  const mode = body.mode ?? prev?.mode ?? '';
+  if (mode && !MODES.has(mode)) throw bad('mode must be plan, edits or auto.');
+  const pick = (k) => String(body[k] ?? prev?.[k] ?? '');
+  return {
+    id: prev?.id || newId(),
+    name,
+    prompt,
+    cwd, // '' = whichever project it's run in
+    agent: pick('agent'),
+    model: pick('model'),
+    effort: /^[\w-]{0,20}$/.test(pick('effort')) ? pick('effort') : '',
+    mode,
+    createdAt: prev?.createdAt || Date.now(),
+    updatedAt: Date.now(),
+    runs: prev?.runs || 0,
+    lastRunAt: prev?.lastRunAt || null,
+  };
+}
+
+// By id, else by name (case- and punctuation-insensitive), so `wisp run "Release"` and
+// `wisp run release` both work.
+export function findRecipe(recipes, key) {
+  const k = String(key || '');
+  const loose = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '');
+  return recipes.find((r) => r.id === k) || recipes.find((r) => loose(r.name) === loose(k)) || null;
+}
+
+export const recipeView = (r) => ({ ...r, params: params(r.prompt) });