wisp-agents 0.16.0 → 0.18.0

package/server/routes/ship.js

@@ -27,11 +27,20 @@ export function register(r, app) {
     one(async (c, s) => {
       if (!s.worktree) return c.send(400, { error: NO_TREE });
       if (runner.live.has(s.id)) return c.send(409, { error: 'Still working: wait for it to finish, or stop it.' });
+      if (s.shipping) return c.send(409, { error: 'Already shipping: wait for it to land.' });
       const body = await c.body();
       const draft = app.ship.draft(s);
-      s.pr = await ship(s.worktree, { title: body.title ?? draft.title, body: body.body ?? draft.body, draft: !!body.draft, pr: s.pr });
+      // The card follows along: s.shipping names the stage running now, sent with each summary.
+      s.shipping = { step: 'start', update: s.pr?.state === 'OPEN', startedAt: Date.now() };
+      app.sessionChanged(s);
+      const onStep = (step) => ((s.shipping = { ...s.shipping, step }), app.sessionChanged(s));
+      try {
+        s.pr = await ship(s.worktree, { title: body.title ?? draft.title, body: body.body ?? draft.body, draft: !!body.draft, pr: s.pr, onStep });
+      } finally {
+        delete s.shipping;
+        app.sessionChanged(s, { now: true });
+      }
       telemetry.track('ship', { agent: s.agent, draft: !!body.draft });
-      app.sessionChanged(s, { now: true });
       app.ship.recheck(s);
       c.send(200, s.pr);
     }),
@@ -44,6 +53,19 @@ export function register(r, app) {
       c.send(200, await app.ship.refreshPr(s));
     }),
   );
+  // Try the automatic conflict fix again after it gave up (see services/ship.js).
+  r.route(
+    'POST',
+    '/sessions/:id/fix-conflicts',
+    one(async (c, s) => {
+      if (s.pr?.state !== 'OPEN' || !s.worktree) return c.send(400, { error: 'No open pull request.' });
+      if (runner.live.has(s.id)) return c.send(409, { error: 'Still working: wait for it to finish, or stop it.' });
+      s.conflictFix = { tries: 0 };
+      await app.ship.refreshPr(s);
+      if (s.conflictFix?.step !== 'fixing') return c.send(409, { error: s.pr.conflict ? 'It merges cleanly with the latest base here: GitHub may not have caught up yet.' : 'The PR has no merge conflicts now.' });
+      c.send(200, { conflictFix: s.conflictFix });
+    }),
+  );
   // Squash-merge the reviewed head, sync the user's base branch, clean up the worktree.
   r.route(
     'POST',

package/server/runner.js

@@ -11,6 +11,7 @@ import { systemPrompt, parsePresentation, heroOf } from './protocol.js';
 import { captureCheckpoint, freshCheckpoint, readGitFile } from './checkpoint.js';
 import { teamNote, copies, SUBAGENT_ASK } from './subagents.js';
 import { handoffNote } from './handoff.js';
+import { agentPrompt, plainMentions } from './mentions.js';
 import { bad, MODES, newId } from './util.js';
 
 const MAX_ACTIVITY = 400;
@@ -19,6 +20,26 @@ const BACKGROUND_MAX_MS = 60 * 60_000; // how long a turn may wait on its backgr
 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');
+// The answers a live approval offers. Typed text instead is a "no, do this instead".
+export const APPROVAL = { allow: 'Allow', always: 'Always allow in this task', deny: 'Deny' };
+const sameAction = (a, b) => a.tool === b.tool && a.detail === b.detail;
+
+// A live approval's answer: the button the user clicked, a yes/no typed out, or anything else,
+// which denies the call and hands the agent the user's words.
+export function approvalDecision(text) {
+  const t = String(text || '').trim();
+  if (t === APPROVAL.always || /^(always\b|2$)/i.test(t)) return { decision: 'allow', always: true };
+  if (t === APPROVAL.allow || /^(y|yes|ok|allow|approve|go ahead|1)$/i.test(t)) return { decision: 'allow' };
+  if (t === APPROVAL.deny || /^(n|no|deny|reject|3)$/i.test(t)) return { decision: 'deny' };
+  return { decision: 'deny', message: t };
+}
+
+// The follow-up that retries what a turn's permissions refused, once the user allowed it.
+function retryPrompt(items, scoped) {
+  const list = items.map((b) => `- ${b.tool}${b.detail ? `: \`${b.detail}\`` : ''}`).join('\n');
+  const how = scoped ? 'I allowed exactly these for this follow-up' : 'This follow-up runs in Full auto, so nothing is blocked';
+  return `These actions were blocked by your permissions last turn:\n${list}\n\n${how}. Run them now and finish the task.`;
+}
 
 export { newId };
 
@@ -43,7 +64,7 @@ function changedRun(session, run) {
 }
 
 function autoTitle(prompt) {
-  const line = prompt.trim().split('\n')[0].replace(/\s+/g, ' ');
+  const line = plainMentions(prompt).trim().split('\n')[0].replace(/\s+/g, ' ');
   return line.length > 64 ? `${line.slice(0, 63)}…` : line;
 }
 
@@ -60,7 +81,8 @@ export function summarize(s, store) {
     title: s.title,
     agent: s.agent,
     cwd: s.cwd,
-    project: s.agent === 'wisp' ? 'tour' : project?.name || path.basename(s.cwd || ''),
+    scratch: store?.isScratch?.(s.cwd) || undefined,
+    project: s.agent === 'wisp' ? 'tour' : (store?.isScratch?.(s.cwd) ? 'General' : project?.name) || path.basename(s.cwd || ''),
     projectId: project?.id || null,
     color: project?.color || 'slate',
     mode: s.mode,
@@ -78,9 +100,13 @@ export function summarize(s, store) {
     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 || '',
+    approval: !!s.ask?.permission, // the question is a live approval (Allow / Deny)
     branch: s.worktree?.branch || '',
     toShip: s.toShip || null, // { dirty, ahead, unpushed } of the worktree, null until checked
-    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,
+    shipping: s.shipping || null, // { step: 'start' | 'commit' | 'push' | 'pr', update } while Ship it runs
+    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, conflict: !!s.pr.conflict } : null,
+    // wisp fixing the PR's merge conflicts on its own: { step: 'fixing' | 'pushing' | 'done' | 'failed', why }
+    conflictFix: s.conflictFix ? { step: s.conflictFix.step, why: s.conflictFix.why || '' } : null,
     groupId: s.groupId || null,
     origin: s.origin || null, // { kind: 'recipe' | 'trigger' | 'telegram', id, name }
     // The roster, for the stacked logos on the card: used = delegated to at least once, busy = working now.
@@ -122,7 +148,7 @@ export class Runner extends EventEmitter {
   }
 
   // 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 = '', route = null }) {
+  create({ id = newId(), prompt, cwd, agent = 'claude', mode = 'auto', model = '', effort = '', attachments = [], worktree = null, groupId = null, origin = null, subagents = [], parentId = null, member = '', route = null }) {
     if (!adapters[agent]) throw new Error(`Unknown agent: ${agent}`);
     const now = Date.now();
     const session = {
@@ -158,11 +184,12 @@ export class Runner extends EventEmitter {
   // mode: switch the permission mode (plan / edits / auto) from this follow-up on. A queued
   // follow-up keeps its own, so the run before it isn't affected. run: { agent, model, effort }
   // switches the harness, model and thinking level the same way (see #switchRun).
-  reply(session, text, attachments = [], { queue = false, mode, run } = {}) {
+  // grants / once: a retry of what the last turn's permissions blocked (see approveBlocked).
+  reply(session, text, attachments = [], { queue = false, mode, run, grants, once } = {}) {
     if (!MODES.has(mode) || mode === session.mode) mode = undefined;
     run = changedRun(session, run);
-    const extra = { ...(mode && { mode }), ...(run && { run }) };
-    if (session.ask && !mode && !run) {
+    const extra = { ...(mode && { mode }), ...(run && { run }), ...(grants?.length && { grants }), ...(MODES.has(once) && { once }) };
+    if (session.ask && !Object.keys(extra).length) {
       this.answer(session, text);
       return { answered: true };
     }
@@ -190,10 +217,29 @@ export class Runner extends EventEmitter {
     }
     if (mode) session.mode = mode;
     if (run) this.#switchRun(session, run);
-    this.#startTurn(session, text, attachments);
+    this.#startTurn(session, text, attachments, extra);
     return { queued: false };
   }
 
+  // The card under a turn whose permissions refused something: allow retries it as a follow-up,
+  // with exactly those actions allowed where the harness can scope a grant, else in Full auto for
+  // that one follow-up. Deny just closes the card.
+  approveBlocked(session, { turnId, allow }) {
+    const turn = turnId ? session.turns.find((t) => t.id === turnId) : session.turns.at(-1);
+    if (!turn?.blocked?.length) throw bad('Nothing on that turn is waiting for approval.', 404);
+    if (turn.approval) throw bad(`Already ${turn.approval}.`, 409);
+    if (turn !== session.turns.at(-1) || this.live.has(session.id)) throw bad('The task has moved on since; send a follow-up instead.', 409);
+    turn.approval = allow ? 'allowed' : 'denied';
+    if (!allow) {
+      this.#touch(session, { turn: turn.id });
+      return { denied: true };
+    }
+    const scoped = turn.blocked.every((b) => b.rule !== undefined);
+    const out = this.reply(session, retryPrompt(turn.blocked, scoped), [], scoped ? { grants: turn.blocked.map((b) => b.rule) } : { once: 'auto' });
+    this.#touch(session, { turn: turn.id });
+    return { ...out, scoped };
+  }
+
   // A follow-up on another harness, model or thinking level. A model or level change resumes the
   // same conversation; a harness change resumes that harness's own one (if it ran earlier in this
   // task) or starts it fresh, and #startTurn hands it the turns it missed.
@@ -222,7 +268,8 @@ export class Runner extends EventEmitter {
   }
 
   // ask_user: the agent is blocked inside a tool call until answer() is called.
-  ask(session, { question, context, options }) {
+  // permission: set for a live approval ({ tool, action, detail }), see requestApproval().
+  ask(session, { question, context, options, permission }) {
     const turn = session.turns.at(-1);
     session.ask = {
       id: newId(),
@@ -230,34 +277,66 @@ export class Runner extends EventEmitter {
       context: context ? String(context) : '',
       options: Array.isArray(options) ? options.map(String).slice(0, 6) : [],
       askedAt: Date.now(),
+      ...(permission && { permission }),
     };
     session.state = 'waiting';
     session.unread = true;
     delete session.archived; // a question needs the user, so it comes back to the feed
-    if (turn) this.#onEvent(session, turn, { type: 'tool', kind: 'ask', label: `Asked you: ${session.ask.question}` });
+    const label = permission ? `Needs your OK to ${permission.action}` : `Asked you: ${session.ask.question}`;
+    if (turn) this.#onEvent(session, turn, { type: 'tool', kind: 'ask', label });
     this.#touch(session, { turn: turn?.id });
     this.emit('finished', { session: summarize(session, this.store) });
     return session.ask.id;
   }
 
+  // Live approval: the harness asks before a tool call its permission mode doesn't allow on its
+  // own (Claude's --permission-prompt-tool). It waits on the answer like ask_user; something the
+  // user said "always" to earlier in this task goes through at once.
+  requestApproval(session, { tool, input }) {
+    const adapter = adapters[session.agent];
+    const p = adapter.permission?.(String(tool || ''), input && typeof input === 'object' ? input : {}, workdir(session)) || { tool: String(tool || 'tool'), action: `use ${tool}`, detail: '' };
+    const turn = session.turns.at(-1);
+    if ((session.grants || []).some((g) => sameAction(g, p))) {
+      if (turn) this.#onEvent(session, turn, { type: 'tool', kind: 'answer', label: `Allowed (always in this task): ${p.action}` });
+      return { decision: 'allow' };
+    }
+    const id = this.ask(session, {
+      question: `Allow ${adapter.name} to ${p.action}?`,
+      context: p.why || '',
+      options: [APPROVAL.allow, APPROVAL.always, APPROVAL.deny],
+      permission: { tool: p.tool, action: p.action, detail: p.detail },
+    });
+    return { id };
+  }
+
   answer(session, text) {
     const ask = session.ask;
     if (!ask) return false;
     ask.answer = text;
-    this.answers.set(ask.id, text);
+    const turn = session.turns.at(-1);
+    let label = `You answered: ${text}`;
+    if (ask.permission) {
+      const d = approvalDecision(text);
+      this.answers.set(ask.id, { answer: text, ...d });
+      const p = ask.permission;
+      if (d.always) (session.grants ||= []).push({ tool: p.tool, detail: p.detail });
+      // Denied here, so the turn's "blocked" card shouldn't offer it again.
+      if (d.decision === 'deny' && turn) (turn.denied ||= []).push({ tool: p.tool, detail: p.detail });
+      label = d.decision === 'allow' ? `You allowed${d.always ? ' (always in this task)' : ''}: ${p.action}` : `You denied: ${p.action}${d.message ? ` (“${d.message}”)` : ''}`;
+    } else this.answers.set(ask.id, { answer: text });
     delete session.ask;
     session.state = this.live.has(session.id) ? 'running' : 'review';
-    const turn = session.turns.at(-1);
-    if (turn) this.#onEvent(session, turn, { type: 'tool', kind: 'answer', label: `You answered: ${text}` });
+    if (turn) this.#onEvent(session, turn, { type: 'tool', kind: 'answer', label });
     this.#touch(session, { turn: turn?.id });
     return true;
   }
 
+  // { answer } once answered (plus { decision, message? } for an approval), { pending }, or { cancelled }.
   pollAnswer(askId) {
     if (this.answers.has(askId)) {
-      const answer = this.answers.get(askId);
+      const out = this.answers.get(askId);
       this.answers.delete(askId);
-      return { answer };
+      return out;
     }
     const open = this.store.all().some((s) => s.ask?.id === askId);
     return open ? { pending: true } : { cancelled: true };
@@ -354,7 +433,7 @@ export class Runner extends EventEmitter {
   }
 
   // The record of a new turn, with the checkpoint taken before the agent touches anything.
-  #newTurn(session, prompt, attachments) {
+  #newTurn(session, prompt, attachments, mode = session.mode) {
     const id = newId();
     // A subagent's edits land in the lead's turn, whose checkpoint already covers them.
     const checkpoint =
@@ -369,7 +448,7 @@ export class Runner extends EventEmitter {
       agent: session.agent,
       model: session.model,
       effort: session.effort || '',
-      mode: session.mode,
+      mode,
       attachments: attachments.map(({ id, name, mime, size }) => ({ id, name, mime, size })),
       startedAt: Date.now(),
       endedAt: null,
@@ -404,14 +483,18 @@ export class Runner extends EventEmitter {
           WISP_URL: this.bridge.url,
           WISP_TOKEN: this.bridge.token,
           WISP_SESSION: session.id,
+          ...(adapter.approveTool && { WISP_APPROVE: '1' }),
           ...(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) }))) }),
         },
       },
     };
   }
 
-  #startTurn(session, prompt, attachments = []) {
-    const turn = this.#newTurn(session, prompt, attachments);
+  // grants: harness rules allowing what the user approved, for this turn only. once: a mode for
+  // this turn only (an approved retry the harness can't scope runs in Full auto).
+  #startTurn(session, prompt, attachments = [], { grants = [], once } = {}) {
+    const mode = MODES.has(once) ? once : session.mode;
+    const turn = this.#newTurn(session, prompt, attachments, mode);
     session.turns.push(turn);
     session.state = 'running';
     session.unread = false;
@@ -427,12 +510,16 @@ export class Runner extends EventEmitter {
     const team = adapter.askTool !== null ? session.subagents || [] : [];
     // A harness that hasn't seen every earlier turn (the user switched to it) gets them first.
     const handoff = session.parentId ? '' : handoffNote(session, session.agent, session.agentSessionId, (t) => adapters[t.agent]?.name || t.agent);
+    // Mentioned tasks: a lead reads them with wisp_session; a run without wisp's tools gets their reports.
+    const tools = !session.parentId && adapter.askTool !== null && this.bridge;
+    const text = agentPrompt(prompt, this.store, { tool: tools ? (adapter.askTool ?? 'mcp__wisp__ask_user').replace(/ask_user$/, 'wisp_session') : null, self: session.id });
     const handle = adapter.run({
-      prompt: handoff ? `${handoff}\n\n${prompt}` : prompt,
+      prompt: handoff ? `${handoff}\n\n${text}` : text,
       attachments,
       cwd: workdir(session),
       resumeId: session.agentSessionId,
-      mode: session.mode,
+      mode,
+      grants,
       model: session.model,
       effort: session.effort || '',
       systemPrompt: this.#systemPrompt(session, adapter, team),
@@ -467,7 +554,7 @@ export class Runner extends EventEmitter {
       const next = session.queue.shift();
       if (next?.mode) session.mode = next.mode;
       if (next?.run && adapters[next.run.agent]) this.#switchRun(session, next.run);
-      if (next && this.store.get(session.id)) this.#startTurn(session, next.text, next.attachments);
+      if (next && this.store.get(session.id)) this.#startTurn(session, next.text, next.attachments, next);
       else this.#touch(session);
     };
     handle.release = release;
@@ -516,6 +603,14 @@ export class Runner extends EventEmitter {
         if (leadTurn?.status === 'running') this.#onEvent(lead, leadTurn, { ...ev, by: session.member });
         return;
       }
+      case 'blocked': {
+        // A tool call the harness's permissions refused. The card after the turn offers to retry it.
+        const item = { tool: String(ev.tool || 'tool'), detail: String(ev.detail ?? ''), ...(ev.rule !== undefined && { rule: ev.rule }) };
+        const list = (turn.blocked ||= []);
+        if (!list.some((b) => sameAction(b, item))) list.push(item);
+        this.store.save(session);
+        return;
+      }
       case 'background': {
         turn.background = ev.tasks;
         if (turn.interim) this.#waitItem(session, turn);
@@ -583,6 +678,7 @@ export class Runner extends EventEmitter {
       // 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;
     }
+    if (!ev.stopped) blockedCard(turn);
     session.state = 'review';
     session.unread = !interrupted;
     this.store.save(session, { now: true });
@@ -601,3 +697,27 @@ export class Runner extends EventEmitter {
     if (turn) this.emit('turn', { sessionId: session.id, turnId: turn });
   }
 }
+
+// What the turn's permissions refused, as one "blocked" block after the hero: the harness's own
+// reports (which can carry a rule to allow exactly that) merged with the agent's "blocked" block,
+// minus anything the user already denied. turn.blocked keeps the list for the retry.
+function blockedCard(turn) {
+  const blocks = turn.presentation?.blocks || [];
+  const own = blocks.filter((b) => b.type === 'blocked').flatMap((b) => (Array.isArray(b.items) ? b.items : []));
+  const items = [...(turn.blocked || [])];
+  for (const i of own) {
+    if (!i || typeof i !== 'object') continue;
+    const item = { tool: String(i.tool || 'tool'), detail: String(i.detail ?? i.command ?? i.path ?? ''), ...(i.why && { why: String(i.why) }) };
+    const known = items.find((b) => sameAction(b, item) || (item.detail && b.detail === item.detail));
+    if (known) known.why ||= item.why;
+    else items.push(item);
+  }
+  // The agent may name a tool its own way (shell for Bash): the same command still counts.
+  const left = items.filter((b) => !(turn.denied || []).some((d) => sameAction(d, b) || (b.detail && d.detail === b.detail))).slice(0, 12);
+  if (left.length) turn.blocked = left;
+  else delete turn.blocked;
+  if (!turn.presentation) return;
+  const rest = blocks.filter((b) => b.type !== 'blocked');
+  if (left.length) rest.splice(rest[0]?.type === 'hero' ? 1 : 0, 0, { type: 'blocked', items: left.map(({ rule, ...b }) => b) });
+  turn.presentation.blocks = rest;
+}

package/server/services/auto.js

@@ -19,6 +19,17 @@ export function createAuto(app) {
   };
   // This computer's harnesses: the last ones detected, else detected now.
   const agents = async () => (agentsHere.length ? agentsHere : await detect());
+  // What the page asks for on every load: the last detection right away, checked again in the
+  // background (a cold probe takes seconds: opencode lists its models), and an 'agents' event
+  // if that changed anything, so the launcher never waits on it.
+  const listed = async () => {
+    if (!agentsHere.length) return detect();
+    const before = JSON.stringify(agentsHere);
+    detect()
+      .then((now) => JSON.stringify(now) !== before && app.broadcast('agents', {}))
+      .catch(() => {});
+    return agentsHere;
+  };
 
   const opts = () => {
     const r = store.config.defaults.router || {};
@@ -63,5 +74,5 @@ export function createAuto(app) {
   // What the Auto view shows: goals, settings, and what the router learned.
   const view = async () => ({ goals: GOALS, goal: goalOf(), settings: { explore: opts().explore, allowed: opts().allowed }, ...router.report(await agents()) });
 
-  return { detect, agents, opts, goalOf, signals, resolve, view };
+  return { detect, agents, listed, opts, goalOf, signals, resolve, view };
 }

package/server/services/launch.js

@@ -15,11 +15,13 @@ export const MAX_COMPARE = 4;
 export function createLaunch(app) {
   const { store, runner, machines } = app;
 
-  // body: { prompt, cwd, agent, mode, model, effort, attachments: [uploadId], worktree, compare,
+  // body: { prompt, cwd, scratch: true = no folder, agent, mode, model, effort, attachments: [uploadId], worktree, compare,
   //         subagents: [{ name, agent, model, effort, use }] | preset: teamId }
   async function launch(body, origin = null) {
     if (!String(body.prompt || '').trim()) throw bad('prompt required');
-    const cwd = expand(body.cwd || process.cwd());
+    // scratch: no project folder (general questions); the task gets an empty directory of its own.
+    const scratch = body.scratch === true;
+    const cwd = scratch ? store.scratchDir(newId()) : expand(body.cwd || process.cwd());
     if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) throw bad(`Not a directory: ${cwd}`);
     const d = store.config.defaults;
     const preset = body.preset && store.config.teams.find((t) => t.id === body.preset);
@@ -33,11 +35,11 @@ export function createLaunch(app) {
       if (!adapters[agent]) throw bad(`unknown agent: ${agent}`);
       return { agent, model: r.model ?? (i ? d.models?.[agent] || '' : ''), effort: /^[\w-]{1,20}$/.test(r.effort || '') ? r.effort : '', ...(r.route && { route: r.route }) };
     });
-    const mode = MODES.has(body.mode) ? body.mode : 'edits';
+    const mode = MODES.has(body.mode) ? body.mode : 'auto';
     // Worktrees are on by default in git repos (off in Plan mode: nothing gets written). Compare
     // runs need one each, or the harnesses would edit the same files.
     const comparing = runners.length > 1;
-    const wantTree = body.worktree ?? (comparing || (mode !== 'plan' && d.worktree !== 'off'));
+    const wantTree = !scratch && (body.worktree ?? (comparing || (mode !== 'plan' && d.worktree !== 'off')));
     // groupId: one launch sent to several machines (or here and there) shows as one task.
     const groupId = /^[a-f0-9]{12}$/.test(body.groupId || '') ? body.groupId : comparing ? newId() : null;
     const attachments = app.uploads.resolve(body.attachments);
@@ -92,10 +94,12 @@ export function createLaunch(app) {
     if (!sendBody.compare?.length && !body.compare) delete sendBody.compare;
     const out = await machines.launch(mid, { ...sendBody, attachments: await pushUploads(mid, body.attachments), ...(origin && { origin }) });
     (out.group || [out]).forEach((x, i) => routes[i] && app.router.record(qualify(x.id, mid), routes[i]));
-    const known = store.projectFor(out.cwd, mid);
-    (known || store.addProject(out.cwd, { machine: mid })).lastUsedAt = Date.now();
-    store.saveConfig();
-    if (!known) app.broadcast('config', {});
+    const known = out.scratch || store.projectFor(out.cwd, mid);
+    if (!out.scratch) {
+      (known || store.addProject(out.cwd, { machine: mid })).lastUsedAt = Date.now();
+      store.saveConfig();
+      if (!known) app.broadcast('config', {});
+    }
     return (out.group || [out]).map((x) => machines.summary(mid, x));
   }
 

package/server/services/phone.js

@@ -27,7 +27,7 @@ export function phoneActions(app) {
       const d = store.config.defaults;
       const agent = d.agent || 'claude';
       const model = d.models?.[agent] ?? d.model ?? '';
-      const [s] = await app.launcher.launchAny({ prompt, cwd: project.path, machine: project.machine || undefined, agent, model, mode: d.mode || 'edits' }, { kind: 'telegram', name: 'Telegram' });
+      const [s] = await app.launcher.launchAny({ prompt, cwd: project.path, machine: project.machine || undefined, agent, model, mode: d.mode || 'auto' }, { kind: 'telegram', name: 'Telegram' });
       app.broadcast('config', {});
       return s;
     },

package/server/services/ship.js

@@ -1,13 +1,30 @@
 // Ship it: whether a worktree session has something to ship, the draft commit message and PR
-// text, and following open PRs (checks, reviews, merges) so their cards stay current.
+// text, and following open PRs (checks, reviews, merges) so their cards stay current. A PR that
+// starts conflicting with its base gets fixed on its own: the task is sent a follow-up to merge the
+// base in, and the result is pushed to the PR when it's done (defaults.fixConflicts: 'off' to stop).
 
 import fs from 'node:fs';
-import { worktreeStatus, prView } from '../git.js';
+import { worktreeStatus, prView, ship, baseMerged, conflictsWithBase } from '../git.js';
 import { blocksToMarkdown } from '../render.js';
 import { summarize } from '../runner.js';
 
 const PR_POLL_MS = 60_000;
 const SHIP_RECHECK_MS = 5_000;
+const MAX_CONFLICT_FIXES = 3; // per task, so a base that keeps moving can't run up the bill
+
+export const conflictPrompt = (s) => {
+  const { remote, base } = s.worktree;
+  return [
+    `PR #${s.pr.number} (${s.pr.url}) can no longer merge into \`${base}\`: changes that landed there since conflict with this branch. Bring the branch up to date:`,
+    '',
+    `1. \`git fetch ${remote}\`, then \`git merge ${remote}/${base}\`. Don't rebase: the branch is already pushed.`,
+    `2. Resolve every conflict, keeping the intent of both sides: what landed on \`${base}\` and what this task changed. Don't drop either side's changes to make a conflict go away.`,
+    '3. Run the checks that are cheap here (tests, type-check, build) on the merged result and fix what the merge broke.',
+    "4. Finish with `git commit --no-edit`. Don't push: wisp pushes to the PR when you're done.",
+    '',
+    'If a conflict needs a decision only the user can make, ask them.',
+  ].join('\n');
+};
 
 export function createShip(app) {
   const { store, runner } = app;
@@ -48,14 +65,68 @@ export function createShip(app) {
     const pr = await prView(dir, prev.number);
     const changed = (k) => JSON.stringify(k(pr)) !== JSON.stringify(k(prev));
     s.pr = pr;
+    if (s.conflictFix && !pr.conflict && !['fixing', 'pushing'].includes(s.conflictFix.step)) delete s.conflictFix;
     if (pr.state !== prev.state) app.auto.signals(summarize(s, store));
     // Things worth coming back for: CI finished either way, a review landed, it merged or closed.
     const settledChecks = (x) => (x.checks.pending ? 'pending' : x.checks.fail ? 'fail' : 'pass');
     if (changed((x) => x.state) || changed((x) => x.review) || (changed(settledChecks) && settledChecks(pr) !== 'pending')) s.unread = true;
     app.sessionChanged(s);
+    await fixConflicts(s).catch(() => {});
     return pr;
   };
 
+  // The PR conflicts with its base: send the task a follow-up to merge the base in. Once per PR
+  // head, so a fix that didn't take isn't retried until something changes the branch.
+  const starting = new Set(); // a poll and a refresh at once must not both send it
+  const fixConflicts = async (s) => {
+    const pr = s.pr;
+    if (store.config.defaults.fixConflicts === 'off' || pr?.state !== 'OPEN' || !pr.conflict || !s.worktree?.remote) return;
+    if (runner.live.has(s.id) || s.shipping || s.ask || s.archived || starting.has(s.id)) return;
+    const tries = s.conflictFix?.tries || 0;
+    if (s.conflictFix?.head === pr.head || tries >= MAX_CONFLICT_FIXES) return;
+    starting.add(s.id);
+    try {
+      if ((await conflictsWithBase(s.worktree)) === false || runner.live.has(s.id)) return;
+    } finally {
+      starting.delete(s.id);
+    }
+    s.conflictFix = { step: 'fixing', head: pr.head, tries: tries + 1, startedAt: Date.now() };
+    await app.launcher.replyTo(s, conflictPrompt(s), [], true);
+    app.telemetry?.track?.('conflict_fix', { agent: s.agent });
+    app.sessionChanged(s, { now: true });
+  };
+
+  // The fix-up turn ended: push it to the PR if the base really is merged in, else leave the task
+  // for the user with why.
+  const finishFix = async (s, { interrupted, errorText }) => {
+    const fix = s.conflictFix;
+    if (fix?.step !== 'fixing') return;
+    const fail = (why) => {
+      Object.assign(fix, { step: 'failed', why });
+      s.unread = true;
+      app.sessionChanged(s, { now: true });
+    };
+    if (interrupted || s.queue?.length) return fail('Stopped: the task moved on before the conflicts were fixed.');
+    if (errorText) return fail(`The agent run failed: ${errorText}`.slice(0, 300));
+    const check = await baseMerged(s.worktree).catch((err) => ({ ok: false, why: err.message }));
+    if (!check.ok) return fail(check.why);
+    fix.step = 'pushing';
+    s.shipping = { step: 'start', update: true, startedAt: Date.now() };
+    app.sessionChanged(s);
+    const onStep = (step) => ((s.shipping = { ...s.shipping, step }), app.sessionChanged(s));
+    try {
+      s.pr = await ship(s.worktree, { title: `Merge ${s.worktree.remote}/${s.worktree.base} into ${s.worktree.branch}`, pr: s.pr, onStep });
+      fix.step = 'done';
+    } catch (err) {
+      Object.assign(fix, { step: 'failed', why: `Push failed: ${err.message}` });
+      s.unread = true;
+    } finally {
+      delete s.shipping;
+      app.sessionChanged(s, { now: true });
+    }
+    recheck(s);
+  };
+
   // Default commit message and PR text, from the session's latest presentation.
   const draft = (s) => {
     const turn = s.turns.findLast((t) => t.status === 'done') || s.turns.at(-1);
@@ -70,7 +141,15 @@ export function createShip(app) {
     return { title: title.slice(0, 100), body: `${body}\n\n_Shipped from [wisp](https://github.com/M0xoo/wisp)._`.trim() };
   };
 
-  runner.on('ended', ({ session }) => recheck(store.get(session.id)));
+  runner.on('ended', ({ session, interrupted, errorText }) => {
+    const s = store.get(session.id);
+    recheck(s);
+    if (s?.conflictFix?.step === 'fixing') finishFix(s, { interrupted, errorText }).catch(() => {});
+  });
+  for (const s of store.all()) {
+    delete s.shipping; // a ship cut short by a restart isn't running anymore
+    if (s.conflictFix?.step === 'pushing') Object.assign(s.conflictFix, { step: 'failed', why: 'wisp restarted while pushing the fix.' });
+  }
   for (const s of store.all()) if (s.worktree && !s.archived && s.pr?.state !== 'MERGED') recheck(s);
 
   const timer = setInterval(async () => {
@@ -78,5 +157,5 @@ export function createShip(app) {
   }, PR_POLL_MS);
   timer.unref();
 
-  return { recheck, refreshPr, draft, stop: () => clearInterval(timer) };
+  return { recheck, refreshPr, fixConflicts, draft, stop: () => clearInterval(timer) };
 }

package/server/store.js

@@ -9,7 +9,7 @@ import { writeJsonAtomic } from './util.js';
 
 const DEFAULT_CONFIG = {
   projects: [], // [{ id, name, path, color, addedAt, machine? }]; machine: the server/machines.js id it lives on
-  defaults: { agent: 'auto', mode: 'edits', model: '', effort: '' }, // auto: wisp picks harness and model (server/router.js)
+  defaults: { agent: 'auto', mode: 'auto', model: '', effort: '' }, // agent auto: wisp picks harness and model (server/router.js)
   recipes: [], // saved prompts with {params}: server/recipes.js
   triggers: [], // schedules and GitHub watchers: server/triggers.js
   teams: [], // saved subagent presets: server/subagents.js
@@ -66,9 +66,15 @@ export class Store {
         cfg.defaults.effort = '';
         cfg.autoIntroduced = true;
       }
+      // Full auto became the default mode: switch once from Edits (the old default); Plan and
+      // any later pick stick.
+      if (!cfg.fullAutoIntroduced) {
+        if (cfg.defaults.mode === 'edits') cfg.defaults.mode = 'auto';
+        cfg.fullAutoIntroduced = true;
+      }
       return cfg;
     } catch {
-      return { ...structuredClone(DEFAULT_CONFIG), autoIntroduced: true };
+      return { ...structuredClone(DEFAULT_CONFIG), autoIntroduced: true, fullAutoIntroduced: true };
     }
   }
 
@@ -82,6 +88,7 @@ export class Store {
 
   // machine: a project on another computer (paths there are POSIX); null = this one.
   projectFor(cwd = '', machine = null) {
+    if (!machine && this.isScratch(cwd)) return null; // never inside a project, even one at ~
     const sep = machine ? '/' : path.sep;
     let best = null;
     for (const p of this.config.projects)
@@ -106,7 +113,19 @@ export class Store {
     return project;
   }
 
+  // Folder-less tasks run in a throwaway directory of their own under ~/.wisp/scratch.
+  scratchDir(id) {
+    const dir = path.join(this.home, 'scratch', id);
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+  }
+
+  isScratch(dir = '') {
+    return String(dir).startsWith(path.join(this.home, 'scratch') + path.sep);
+  }
+
   touchProject(dir) {
+    if (this.isScratch(dir)) return null;
     const p = this.projectFor(dir) || this.addProject(dir);
     p.lastUsedAt = Date.now();
     this.saveConfig();
@@ -141,6 +160,8 @@ export class Store {
 
   delete(id) {
     clearTimeout(this.timers.get(id));
+    const cwd = this.sessions.get(id)?.cwd;
+    if (this.isScratch(cwd)) fs.rmSync(cwd, { recursive: true, force: true }); // a folder-less task's files go with it
     this.sessions.delete(id);
     fs.rmSync(path.join(this.dir, `${id}.json`), { force: true });
     fs.rmSync(path.join(this.shots, id), { recursive: true, force: true });

package/server/triggers.js

@@ -100,7 +100,7 @@ export function normalizeTrigger(body, prev = null, { recipes = [] } = {}) {
   if (kind === 'schedule') parseCron(cron);
   const label = kind === 'issues' ? String(v('label', 'wisp')).trim() : '';
   if (kind === 'issues' && !label) throw bad('Pick the issue label to watch.');
-  const mode = String(v('mode', kind === 'issues' ? 'plan' : 'edits'));
+  const mode = String(v('mode', kind === 'issues' ? 'plan' : 'auto'));
   if (!MODES.has(mode)) throw bad('mode must be plan, edits or auto.');
   const changedSource = prev && (kind !== prev.kind || cwd !== prev.cwd || label !== prev.label || String(v('branch')) !== prev.branch);
   return {