wisp-agents 0.2.1 → 0.3.0

package/server/adapters/common.js

@@ -0,0 +1,175 @@
+// Helpers shared by the adapters: process plumbing, labels, and diff capture.
+
+import { execFileSync } from 'node:child_process';
+import readline from 'node:readline';
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn, execFile, killTree } from '../proc.js';
+
+export const MAX_SNAPSHOT = 256 * 1024;
+export const ASK_TIMEOUT_MS = 7 * 24 * 3600 * 1000; // ask_user may wait for the human a long time
+
+export function detectVersion(bin, args = ['--version']) {
+  return new Promise((resolve) => {
+    execFile(bin, args, { timeout: 10_000 }, (err, stdout) => {
+      resolve(err ? { available: false, error: err.message } : { available: true, version: stdout.trim().split('\n')[0] });
+    });
+  });
+}
+
+// Run `bin args` and resolve with stdout, or '' on any failure. Used for model discovery.
+export function quietOutput(bin, args, timeout = 15_000) {
+  return new Promise((resolve) => {
+    execFile(bin, args, { timeout, maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => resolve(err ? '' : stdout));
+  });
+}
+
+// Spawn a CLI that prints one JSON object per line. onJson gets each parsed line;
+// onClose({ code, signal, stderr }) must emit the final `result` if the stream didn't.
+export function spawnJsonl({ bin, args, cwd, env, input, onJson, onClose, onEvent }) {
+  // Some CLIs (opencode) take their working directory from $PWD rather than the real cwd.
+  const child = spawn(bin, args, { cwd, env: { ...env, PWD: cwd }, stdio: ['pipe', 'pipe', 'pipe'] });
+  child.stdin.on('error', () => {}); // the CLI may exit before reading stdin
+  child.stdin.end(input ?? '');
+
+  let stderr = '';
+  child.stderr.on('data', (d) => {
+    stderr = (stderr + d).slice(-8000);
+  });
+  readline.createInterface({ input: child.stdout }).on('line', (line) => {
+    if (!line.trim()) return;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return;
+    }
+    onJson(msg);
+  });
+
+  let failed = false;
+  let stopping = false; // Windows reports a taskkill'd child as an exit code, not a signal
+  const done = new Promise((resolve) => {
+    child.on('error', (err) => {
+      failed = true;
+      onEvent({ type: 'result', isError: true, text: `Could not start \`${bin}\`: ${err.message}` });
+      resolve();
+    });
+    child.on('close', (code, signal) => {
+      if (!failed) onClose({ code, signal, stderr: stderr.trim(), stopped: stopping || signal === 'SIGTERM' || signal === 'SIGINT' });
+      resolve();
+    });
+  });
+
+  return {
+    done,
+    stop() {
+      stopping = true;
+      killTree(child);
+    },
+  };
+}
+
+export function attachmentNote(files, how = 'Read images and PDFs with your file-reading tool') {
+  if (!files.length) return '';
+  const lines = files.map((f) => `- ${f.path}  (${f.mime}, ${Math.max(1, Math.round(f.size / 1024))} KB)`);
+  return `\n\n<attachments>\nThe user attached these files. ${how}; for video/audio/other formats use the shell (e.g. ffmpeg, ffprobe) if needed.\n${lines.join('\n')}\n</attachments>`;
+}
+
+// Harnesses without a system-prompt flag get the wisp protocol in front of the first prompt.
+// Follow-ups resume the same session, so the protocol is still in context.
+export function withProtocol(prompt, systemPrompt, resumeId) {
+  return resumeId ? prompt : `${systemPrompt.trim()}\n\n---\n\n# Task\n\n${prompt}`;
+}
+
+const realDirs = new Map();
+function realDir(dir) {
+  if (!realDirs.has(dir)) {
+    try {
+      realDirs.set(dir, fs.realpathSync(dir));
+    } catch {
+      realDirs.set(dir, dir);
+    }
+  }
+  return realDirs.get(dir);
+}
+
+// Path relative to cwd, or the path as given if it lies outside. Harnesses may report paths
+// through the resolved cwd (/private/tmp vs /tmp on macOS), so both spellings count.
+export function rel(file, cwd) {
+  if (!file) return '';
+  const abs = path.resolve(cwd, file);
+  for (const base of [cwd, realDir(cwd)]) {
+    const r = path.relative(base, abs);
+    if (r && !r.startsWith('..') && !path.isAbsolute(r)) return r;
+  }
+  return file;
+}
+
+export function clip(s, n = 80) {
+  s = String(s ?? '').replace(/\s+/g, ' ').trim();
+  return s.length > n ? `${s.slice(0, n - 1)}…` : s;
+}
+
+export function flatten(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) return content.map((c) => c.text || '').join('\n');
+  return '';
+}
+
+function readSnapshot(abs) {
+  try {
+    const st = fs.statSync(abs);
+    if (!st.isFile()) return null;
+    return st.size <= MAX_SNAPSHOT ? fs.readFileSync(abs, 'utf8') : '';
+  } catch {
+    return null;
+  }
+}
+
+// For harnesses that only report "file X changed" after the fact. The "before" side comes from,
+// in order: the content after the previous change we saw, else a snapshot taken when the
+// harness announced the edit (only if it predates the write — the harness doesn't wait for us),
+// else the file as it was when the turn started — `git stash create` captures tracked
+// working-tree changes without touching anything — else nothing (treated as a new file).
+export function fileTracker(cwd) {
+  const known = new Map(); // rel path -> content after our last change() (null = missing)
+  const announced = new Map(); // rel path -> content when the harness announced an edit
+  let base;
+  const git = (args, opts = {}) => execFileSync('git', args, { cwd, stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000, ...opts });
+  try {
+    // Pinned before the agent starts writing.
+    base = git(['stash', 'create']).toString().trim() || git(['rev-parse', '--verify', 'HEAD']).toString().trim();
+  } catch {
+    base = null;
+  }
+  const fromGit = (r) => {
+    if (!base || path.isAbsolute(r)) return null;
+    try {
+      const out = git(['show', `${base}:./${r.split(path.sep).join('/')}`], { maxBuffer: 8 * MAX_SNAPSHOT }); // git wants / even on Windows
+      return out.length <= MAX_SNAPSHOT ? out.toString('utf8') : '';
+    } catch {
+      return null;
+    }
+  };
+
+  return {
+    remember(file) {
+      const r = rel(file, cwd);
+      if (!known.has(r) && !announced.has(r)) announced.set(r, readSnapshot(path.resolve(cwd, file)));
+    },
+    // Call after the harness wrote `file`. Returns a `change` event payload, or null if unchanged.
+    change(file) {
+      const r = rel(file, cwd);
+      const after = readSnapshot(path.resolve(cwd, file));
+      let before;
+      if (known.has(r)) before = known.get(r);
+      else if (announced.has(r) && announced.get(r) !== after) before = announced.get(r);
+      else before = fromGit(r);
+      known.set(r, after);
+      announced.delete(r);
+      if (before === after) return null;
+      return { file: r, op: before === null ? 'create' : 'write', edits: [{ before: before ?? '', after: after ?? '' }] };
+    },
+  };
+}

package/server/adapters/cursor.js

@@ -0,0 +1,156 @@
+// Cursor CLI adapter — drives `cursor-agent -p --output-format stream-json`.
+//
+// cursor-agent has no flag to inject an MCP server (it only reads .cursor/mcp.json), so wisp's
+// ask_user tool isn't available here; the protocol tells the agent to end with a question block.
+
+import { attachmentNote, clip, detectVersion, fileTracker, quietOutput, rel, spawnJsonl, withProtocol } from './common.js';
+
+const BIN = process.env.WISP_CURSOR_BIN || 'cursor-agent';
+
+export default {
+  id: 'cursor',
+  name: 'Cursor',
+  askTool: null,
+  models: [{ id: '', label: 'Default', hint: 'Whatever Cursor is set to' }],
+
+  resumeCommand({ resumeId, model }) {
+    return [BIN, ...(resumeId ? ['--resume', resumeId] : []), ...(model ? ['--model', model] : [])];
+  },
+
+  async detect() {
+    const found = await detectVersion(BIN);
+    if (!found.available) return found;
+    // `--list-models` prints "id - Label" lines, with "(current, default)" on the active one.
+    const models = [];
+    for (const line of (await quietOutput(BIN, ['--list-models'])).split('\n')) {
+      const m = line.trim().match(/^([\w.\-[\]=,]+) - (.+?)(?:\s+\((?:current|default)[^)]*\))?$/);
+      if (m && m[1] !== 'auto') models.push({ id: m[1], label: m[2], hint: m[1] });
+    }
+    return { ...found, models: [this.models[0], ...models] };
+  },
+
+  run({ prompt, attachments = [], cwd, resumeId, mode, model, systemPrompt, onEvent }) {
+    const args = ['-p', '--output-format', 'stream-json', '--trust'];
+    if (mode === 'plan') args.push('--mode', 'plan');
+    if (mode === 'auto') args.push('--force');
+    if (model) args.push('--model', model);
+    if (resumeId) args.push('--resume', resumeId);
+    // No prompt argument: in --print mode cursor-agent reads it from stdin.
+
+    const input = withProtocol(prompt, systemPrompt, resumeId) + attachmentNote(attachments);
+    const files = fileTracker(cwd);
+    let sawResult = false;
+    let session = null;
+
+    return spawnJsonl({
+      bin: BIN,
+      args,
+      cwd,
+      env: process.env,
+      input,
+      onEvent,
+      onJson(msg) {
+        if (msg.session_id && msg.session_id !== session) onEvent({ type: 'session', id: (session = msg.session_id) });
+        switch (msg.type) {
+          case 'assistant':
+            for (const part of msg.message?.content || []) {
+              if (part.type === 'text' && part.text?.trim()) onEvent({ type: 'text', text: part.text });
+            }
+            break;
+          case 'thinking':
+            if (msg.subtype === 'completed') onEvent({ type: 'thinking' });
+            break;
+          case 'tool_call': {
+            const [name, body = {}] = toolOf(msg.tool_call);
+            if (!name) break;
+            const args = body.args || {};
+            if (msg.subtype === 'started') {
+              if ((name === 'editToolCall' || name === 'deleteToolCall') && args.path) files.remember(args.path);
+              onEvent({ type: 'tool', ...describeTool(name, args, cwd) });
+            } else if (msg.subtype === 'completed') {
+              const [outcome, value = {}] = resultOf(body.result);
+              if (outcome && outcome !== 'success') {
+                onEvent({ type: 'tool_error', name: name.replace(/ToolCall$/, ''), text: clip(value.error || value.message || value.reason || value.stderr || outcome, 400) });
+              } else if (name === 'editToolCall' || name === 'deleteToolCall') {
+                const change = editChange(args.path || value.path, value, cwd, files);
+                if (change) onEvent({ type: 'change', ...change });
+              }
+            }
+            break;
+          }
+          case 'result':
+            sawResult = true;
+            onEvent({
+              type: 'result',
+              text: msg.result ?? '',
+              isError: !!msg.is_error || (msg.subtype && msg.subtype !== 'success'),
+              stats: { durationMs: msg.duration_ms, inputTokens: msg.usage?.inputTokens ?? msg.usage?.input_tokens, outputTokens: msg.usage?.outputTokens ?? msg.usage?.output_tokens },
+            });
+            break;
+        }
+      },
+      onClose({ code, signal, stderr, stopped }) {
+        if (sawResult) return;
+        onEvent({ type: 'result', isError: true, stopped, text: stderr || `cursor-agent exited with ${signal || `code ${code}`}` });
+      },
+    });
+  },
+};
+
+// Tool calls are protobuf oneofs; depending on the serializer they arrive as
+// { editToolCall: {...} } or { tool: { case: 'editToolCall', value: {...} } }.
+function oneof(o) {
+  if (!o || typeof o !== 'object') return [];
+  if ('case' in o) return [o.case, o.value];
+  const k = Object.keys(o)[0];
+  return k ? [k, o[k]] : [];
+}
+const toolOf = (tc) => oneof(tc?.tool && typeof tc.tool === 'object' ? tc.tool : tc);
+const resultOf = (r) => oneof(r?.result && typeof r.result === 'object' && 'case' in r.result ? r.result : r);
+
+function editChange(file, value, cwd, files) {
+  if (!file) return null;
+  if (typeof value.afterFullFileContent === 'string') {
+    files.change(file); // keep the snapshot current
+    const before = value.beforeFullFileContent;
+    return { file: rel(file, cwd), op: before == null ? 'create' : 'write', edits: [{ before: before ?? '', after: value.afterFullFileContent }] };
+  }
+  return files.change(file);
+}
+
+function describeTool(name, a, cwd) {
+  const f = rel(a.path, cwd);
+  switch (name) {
+    case 'readToolCall':
+      return { kind: 'read', label: `Reading ${f}`, file: f };
+    case 'editToolCall':
+      return { kind: 'edit', label: `Editing ${f}`, file: f };
+    case 'deleteToolCall':
+      return { kind: 'edit', label: `Deleting ${f}`, file: f };
+    case 'shellToolCall':
+      return { kind: 'run', label: a.description ? clip(a.description) : `Running ${clip(a.command, 60)}`, detail: a.command };
+    case 'grepToolCall':
+      return { kind: 'search', label: `Searching for “${clip(a.pattern, 40)}”` };
+    case 'globToolCall':
+      return { kind: 'search', label: `Finding ${clip(a.globPattern || a.pattern, 50)}` };
+    case 'lsToolCall':
+      return { kind: 'search', label: `Listing ${f || '.'}` };
+    case 'semSearchToolCall':
+      return { kind: 'search', label: `Searching the codebase: ${clip(a.query, 50)}` };
+    case 'webSearchToolCall':
+      return { kind: 'web', label: `Searching the web: ${clip(a.searchTerm || a.query, 50)}` };
+    case 'webFetchToolCall':
+    case 'fetchToolCall':
+      return { kind: 'web', label: `Reading ${clip(a.url, 60)}` };
+    case 'taskToolCall':
+      return { kind: 'agent', label: `Delegating: ${clip(a.description || a.prompt, 60)}` };
+    case 'updateTodosToolCall': {
+      const active = a.todos?.find((t) => /in_?progress/i.test(String(t.status)));
+      return { kind: 'plan', label: active ? clip(active.content) : 'Planning' };
+    }
+    case 'mcpToolCall':
+      return { kind: 'tool', label: `Using ${a.providerIdentifier || 'mcp'} · ${a.toolName || 'tool'}` };
+    default:
+      return { kind: 'tool', label: `Using ${name.replace(/ToolCall$/, '').replace(/([A-Z])/g, ' $1').toLowerCase()}` };
+  }
+}

package/server/adapters/index.js

@@ -1,9 +1,11 @@
-// Agent registry. To add a harness (codex, opencode, …) write an adapter with the
-// same shape as ./claude.js and register it here:
+// Agent registry. To add a harness write an adapter with the same shape as ./claude.js
+// (./common.js has the shared plumbing) and register it here:
 //
 //   {
-//     id, name, models: [{id, label}],
-//     detect(): Promise<{ available, version?, error? }>,
+//     id, name, models: [{id, label, hint?}],
+//     askTool: string | null | undefined           how the agent sees wisp's ask_user MCP tool;
+//                                                  null = can't inject MCP, ask via a question block
+//     detect(): Promise<{ available, version?, error?, models? }>   models overrides the static list
 //     resumeCommand({ resumeId, model }): string[]   argv to continue the session interactively
 //     run({ prompt, cwd, resumeId, mode, model, systemPrompt, onEvent }): { stop(), done: Promise }
 //   }
@@ -18,11 +20,14 @@
 //   { type: 'result', text, isError, stopped?, stats? }   exactly once, at the end
 //
 // mode is one of: plan (read-only), edits (auto-accept file edits), auto (no permission prompts).
-// Agents without a system-prompt flag can prepend `systemPrompt` to the first prompt instead.
+// Agents without a system-prompt flag prepend `systemPrompt` to the first prompt (withProtocol).
 
 import claude from './claude.js';
+import codex from './codex.js';
+import opencode from './opencode.js';
+import cursor from './cursor.js';
 
-export const adapters = { [claude.id]: claude };
+export const adapters = Object.fromEntries([claude, codex, opencode, cursor].map((a) => [a.id, a]));
 
 const detected = new Map();
 

package/server/adapters/opencode.js

@@ -0,0 +1,180 @@
+// opencode adapter — drives `opencode run --format json` (one JSON event per line).
+
+import { ASK_TIMEOUT_MS, attachmentNote, clip, detectVersion, fileTracker, quietOutput, rel, spawnJsonl, withProtocol } from './common.js';
+
+const BIN = process.env.WISP_OPENCODE_BIN || 'opencode';
+
+export default {
+  id: 'opencode',
+  name: 'opencode',
+  askTool: 'wisp_ask_user',
+  models: [{ id: '', label: 'Default', hint: 'Whatever opencode is set to' }],
+
+  resumeCommand({ resumeId, model }) {
+    return [BIN, ...(resumeId ? ['--session', resumeId] : []), ...(model ? ['--model', model] : [])];
+  },
+
+  async detect() {
+    const found = await detectVersion(BIN);
+    if (!found.available) return found;
+    // `opencode models` prints provider/model ids, one per line, for every configured provider.
+    const ids = (await quietOutput(BIN, ['models'])).split('\n').map((l) => l.trim()).filter((l) => /^[\w.-]+\/\S+$/.test(l));
+    return { ...found, models: [this.models[0], ...ids.map((id) => ({ id, label: id.split('/').slice(1).join('/'), hint: id.split('/')[0] }))] };
+  },
+
+  run({ prompt, attachments = [], cwd, resumeId, mode, model, systemPrompt, mcpServers = {}, onEvent }) {
+    // The prompt goes on stdin; `run` appends piped stdin to the (empty) message.
+    const args = ['run', '--format', 'json'];
+    if (mode === 'plan') args.push('--agent', 'plan');
+    if (mode === 'auto') args.push('--auto');
+    if (model) args.push('--model', model);
+    if (resumeId) args.push('--session', resumeId);
+    for (const a of attachments) args.push('--file', a.path);
+
+    // Inject the ask_user server through inline config, merged over the user's own.
+    const mcp = {};
+    for (const [name, srv] of Object.entries(mcpServers)) {
+      mcp[name] = { type: 'local', command: [srv.command, ...(srv.args || [])], environment: srv.env || {}, enabled: true, timeout: ASK_TIMEOUT_MS };
+    }
+    const env = { ...process.env };
+    if (Object.keys(mcp).length) {
+      const inline = env.OPENCODE_CONFIG_CONTENT ? safeJson(env.OPENCODE_CONFIG_CONTENT) : {};
+      env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
+        ...inline,
+        mcp: { ...inline.mcp, ...mcp },
+        experimental: { ...inline.experimental, mcp_timeout: ASK_TIMEOUT_MS },
+      });
+    }
+
+    const input = withProtocol(prompt, systemPrompt, resumeId) + attachmentNote(attachments, 'They are also attached to this message');
+    const files = fileTracker(cwd);
+    const started = Date.now();
+    let session = null;
+    let lastMsg = null; // messageID of the latest assistant text
+    let text = [];
+    let error = null;
+    const tokens = { input: 0, output: 0 };
+    let cost = 0;
+
+    return spawnJsonl({
+      bin: BIN,
+      args,
+      cwd,
+      env,
+      input,
+      onEvent,
+      onJson(msg) {
+        if (msg.sessionID && msg.sessionID !== session) onEvent({ type: 'session', id: (session = msg.sessionID) });
+        const part = msg.part || {};
+        switch (msg.type) {
+          case 'text':
+            if (!part.text?.trim()) break;
+            // The final answer is the text of the last assistant message.
+            if (part.messageID !== lastMsg) ((lastMsg = part.messageID), (text = []));
+            text.push(part.text);
+            onEvent({ type: 'text', text: part.text });
+            break;
+          case 'reasoning':
+            onEvent({ type: 'thinking' });
+            break;
+          case 'tool_use': {
+            // Emitted once the tool has finished, with its input and output.
+            const state = part.state || {};
+            const input = state.input || {};
+            onEvent({ type: 'tool', ...describeTool(part.tool, input, cwd) });
+            if (state.status === 'error') onEvent({ type: 'tool_error', name: part.tool, text: clip(state.error || state.output, 400) });
+            else {
+              for (const change of captureChanges(part.tool, input, state.metadata || {}, cwd, files)) onEvent({ type: 'change', ...change });
+            }
+            break;
+          }
+          case 'step_finish':
+            tokens.input += part.tokens?.input || 0;
+            tokens.output += part.tokens?.output || 0;
+            cost += part.cost || 0;
+            break;
+          case 'error':
+            error = msg.error?.data?.message || msg.error?.message || msg.error?.name || 'opencode reported an error.';
+            break;
+        }
+      },
+      onClose({ code, signal, stderr, stopped }) {
+        const ok = code === 0 && !error;
+        onEvent({
+          type: 'result',
+          isError: !ok,
+          stopped,
+          text: ok ? text.join('\n') : error || stderr || `opencode exited with ${signal || `code ${code}`}`,
+          stats: { durationMs: Date.now() - started, costUsd: cost || undefined, inputTokens: tokens.input, outputTokens: tokens.output },
+        });
+      },
+    });
+  },
+};
+
+function safeJson(s) {
+  try {
+    return JSON.parse(s) || {};
+  } catch {
+    return {};
+  }
+}
+
+function describeTool(name, input, cwd) {
+  const f = rel(input.filePath || input.path, cwd);
+  switch (name) {
+    case 'read':
+      return { kind: 'read', label: `Reading ${f}`, file: f };
+    case 'edit':
+    case 'patch':
+    case 'apply_patch':
+    case 'multiedit':
+      return { kind: 'edit', label: f ? `Editing ${f}` : 'Editing files', file: f || undefined };
+    case 'write':
+      return { kind: 'edit', label: `Writing ${f}`, file: f };
+    case 'bash':
+    case 'shell':
+      return { kind: 'run', label: input.description ? clip(input.description) : `Running ${clip(input.command, 60)}`, detail: input.command };
+    case 'grep':
+      return { kind: 'search', label: `Searching for “${clip(input.pattern, 40)}”` };
+    case 'glob':
+    case 'list':
+      return { kind: 'search', label: input.pattern ? `Finding ${clip(input.pattern, 50)}` : `Listing ${f || '.'}` };
+    case 'webfetch':
+      return { kind: 'web', label: `Reading ${clip(input.url, 60)}` };
+    case 'websearch':
+      return { kind: 'web', label: `Searching the web: ${clip(input.query, 50)}` };
+    case 'task':
+      return { kind: 'agent', label: `Delegating: ${clip(input.description || input.prompt, 60)}` };
+    case 'todowrite': {
+      const active = input.todos?.find((t) => t.status === 'in_progress');
+      return { kind: 'plan', label: active ? clip(active.content) : 'Planning' };
+    }
+    case 'wisp_ask_user':
+      return { kind: 'wait', label: 'Waiting for your answer' };
+    default:
+      return { kind: 'tool', label: `Using ${name.replace(/_/g, ' ')}` };
+  }
+}
+
+// opencode reports tools after they ran. Edits carry old/new strings (key names vary across
+// versions); anything else is diffed against the tracker's snapshot of the file.
+function captureChanges(tool, input, meta, cwd, files) {
+  const file = input.filePath || input.path;
+  const before = input.oldString ?? input.old_string;
+  if (tool === 'edit' && file && typeof before === 'string') {
+    files.change(file); // keep the tracker's snapshot current for later writes
+    return [{ file: rel(file, cwd), op: 'edit', edits: [{ before, after: input.newString ?? input.new_string ?? '' }] }];
+  }
+  let paths = [];
+  if (['write', 'edit', 'multiedit'].includes(tool) && file) paths = [file];
+  else if (tool === 'patch' || tool === 'apply_patch') {
+    const listed = (meta.files || []).map((x) => (typeof x === 'string' ? x : x.filePath || x.file));
+    paths = [...new Set([...listed, ...patchPaths(input.patchText || input.patch || '')])].filter((p) => typeof p === 'string');
+  }
+  return paths.map((p) => files.change(p)).filter(Boolean);
+}
+
+function patchPaths(text) {
+  return [...String(text).matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm)].map((m) => m[1].trim());
+}

package/server/index.js

@@ -162,7 +162,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
       if (!id && m === 'GET') return send(res, 200, store.config.projects);
       if (!id && m === 'POST') {
         const body = await readJson(req);
-        const dir = path.resolve(String(body.path || '').replace(/^~(?=$|\/)/, os.homedir()));
+        const dir = path.resolve(String(body.path || '').replace(/^~(?=$|[\\/])/, os.homedir()));
         if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return send(res, 400, { error: `Not a folder: ${dir}` });
         const p = store.addProject(dir, { name: body.name });
         broadcast('config', {});
@@ -211,9 +211,10 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
 
     // Directory suggestions for the launcher's project picker.
     if (root === 'fs' && m === 'GET') {
-      const raw = (url.searchParams.get('q') || '').replace(/^~(?=$|\/)/, os.homedir());
-      const dir = raw.endsWith('/') ? raw : path.dirname(raw);
-      const prefix = raw.endsWith('/') ? '' : path.basename(raw).toLowerCase();
+      const raw = (url.searchParams.get('q') || '').replace(/^~(?=$|[\\/])/, os.homedir());
+      const trailing = /[\\/]$/.test(raw); // a trailing backslash counts too (Windows)
+      const dir = trailing ? raw : path.dirname(raw);
+      const prefix = trailing ? '' : path.basename(raw).toLowerCase();
       let entries = [];
       try {
         entries = fs
@@ -231,7 +232,7 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
         if (m === 'POST') {
           const body = await readJson(req);
           if (!body.prompt?.trim()) return send(res, 400, { error: 'prompt required' });
-          const cwd = path.resolve((body.cwd || process.cwd()).replace(/^~(?=$|\/)/, os.homedir()));
+          const cwd = path.resolve((body.cwd || process.cwd()).replace(/^~(?=$|[\\/])/, os.homedir()));
           if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) return send(res, 400, { error: `Not a directory: ${cwd}` });
           if (!adapters[body.agent || 'claude']) return send(res, 400, { error: 'unknown agent' });
           const s = runner.create({ prompt: body.prompt, cwd, agent: body.agent, mode: body.mode, model: body.model, attachments: resolveAttachments(body.attachments) });
@@ -250,6 +251,8 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
           if (body.state === 'done' && s.state !== 'running') s.state = 'done';
           if (body.state === 'review' && s.state === 'done') s.state = 'review';
           if (typeof body.unread === 'boolean') s.unread = body.unread;
+          if (body.archived === true && s.state !== 'running' && s.state !== 'waiting') Object.assign(s, { archived: true, unread: false });
+          if (body.archived === false) delete s.archived;
           store.save(s);
           broadcast('summary', summarize(s, store));
           return send(res, 200, summarize(s, store));
@@ -263,10 +266,15 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
       }
 
       if (action === 'reply' && m === 'POST') {
-        const { text, attachments } = await readJson(req);
+        const { text, attachments, queue } = await readJson(req);
         if (!text?.trim()) return send(res, 400, { error: 'text required' });
         if (s.agent === 'wisp') return send(res, 400, { error: 'This is the tour — launch a real wisp to follow up.' });
-        return send(res, 200, runner.reply(s, text.trim(), resolveAttachments(attachments)));
+        return send(res, 200, runner.reply(s, text.trim(), resolveAttachments(attachments), { queue: queue ?? store.config.defaults.followUp === 'queue' }));
+      }
+
+      if (action === 'queue' && m === 'DELETE') {
+        const ok = runner.unqueue(s, url.searchParams.get('item') || '');
+        return ok ? send(res, 200, { ok }) : send(res, 404, { error: 'Already sent.' });
       }
 
       if (action === 'answer' && m === 'POST') {
@@ -299,11 +307,18 @@ export async function startServer({ port = 4477, host = '127.0.0.1', handleSigna
         return send(res, 200, { ok: true });
       }
 
-      // Images the agent pointed at (screenshots etc.), confined to the session's project.
+      // Images the agent pointed at (screenshots etc.). Served if inside the session's project,
+      // or if the agent named that exact path in an image block (screenshots often land in /tmp).
       if (action === 'file' && m === 'GET') {
-        const p = path.resolve(s.cwd, url.searchParams.get('path') || '');
+        let p = path.resolve(s.cwd, url.searchParams.get('path') || '');
         const ext = path.extname(p).toLowerCase();
-        if (!p.startsWith(s.cwd + path.sep) || !IMAGE_EXT.has(ext) || !fs.existsSync(p)) return send(res, 404, { error: 'not found' });
+        const images = s.turns.flatMap((t) => (t.presentation?.blocks || []).filter((b) => b?.type === 'image'));
+        const at = (v) => typeof v === 'string' && path.resolve(s.cwd, v) === p;
+        const named = images.find((b) => at(b.path || b.src));
+        // A page rendered before keepImages() rewrote the block still asks for the original path.
+        const kept = !named && images.find((b) => at(b.source) && typeof b.path === 'string');
+        if (kept) p = path.resolve(s.cwd, kept.path);
+        if (!(p.startsWith(s.cwd + path.sep) || named || kept) || !IMAGE_EXT.has(ext) || !fs.existsSync(p)) return send(res, 404, { error: 'not found' });
         res.writeHead(200, { 'content-type': MIME[ext] });
         return fs.createReadStream(p).pipe(res);
       }