wisp-agents 0.21.0 → 0.22.0

package/server/runner.js

@@ -12,9 +12,14 @@ 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';
+import { BTW_SYSTEM, BTW_TIMEOUT_MS, MAX_BTW, btwAnswer, btwPrompt } from './btw.js';
+import { bad, clip, MODES, newId } from './util.js';
 
 const MAX_ACTIVITY = 400;
+const MAX_TEXT = 20_000; // an agent message, kept whole for the transcript up to this
+const MAX_OUTPUT = 2_000; // what a tool call returned: its start and end past this
+// The calls whose output the transcript shows. A read returns the file and an edit a confirmation.
+const OUTPUT_KINDS = new Set(['run', 'search', 'web', 'tool', 'agent']);
 const LINGER_MS = 3000; // how long a CLI may keep running after it reported its result
 const BACKGROUND_MAX_MS = 60 * 60_000; // how long a turn may wait on its background tasks
 const ASK_SERVER = path.join(path.dirname(fileURLToPath(import.meta.url)), 'mcp-ask.js');
@@ -43,6 +48,20 @@ function retryPrompt(items, scoped) {
 
 export { newId };
 
+// A tool call's output for the transcript: whole when short, else its first and last lines (the
+// end of a test run or a build is what tells how it went).
+export function clipOutput(text) {
+  const out = String(text ?? '').replace(/\s+$/, '');
+  if (out.length <= MAX_OUTPUT) return out;
+  let head = out.slice(0, 600);
+  let tail = out.slice(-1300);
+  if (head.includes('\n')) head = head.slice(0, head.lastIndexOf('\n'));
+  if (tail.includes('\n')) tail = tail.slice(tail.indexOf('\n') + 1);
+  const cut = out.slice(head.length, out.length - tail.length);
+  const lines = cut.split('\n').length - 1;
+  return `${head}\n… ${lines > 1 ? `${lines} lines` : `${cut.length} characters`} cut …\n${tail}`;
+}
+
 // Where the agent actually works: its own worktree when it has one, else the project folder.
 export const workdir = (s) => s.worktree?.cwd || s.cwd;
 
@@ -126,6 +145,8 @@ export function summarize(s, store) {
     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 }
+    moved: s.moved || null, // { from }: carried on here from another place (services/move.js)
+    movedTo: s.movedTo || null, // { id, place }: this one carried on there, and was archived
     // The roster, for the stacked logos on the card: used = delegated to at least once, busy = working now.
     team: (s.subagents || []).flatMap((m) =>
       copies(m).map((name) => {
@@ -164,6 +185,7 @@ export class Runner extends EventEmitter {
     this.stopping = new Set();
     this.interrupting = new Set();
     this.answers = new Map(); // askId -> answer, until the MCP server picks it up
+    this.sides = new Map(); // /btw id -> { sessionId, handle }: side questions being answered
     this.promptExtra = () => ''; // (session) => text appended to the system prompt (learned preferences)
     this.routeAuto = null; // (prompt, { cwd }) => { agent, model, route } for subagents set to Auto
     this.pipeline = null; // Auto's check / repair / hand-over steps (server/pipeline.js)
@@ -178,18 +200,22 @@ export class Runner extends EventEmitter {
         s.state = 'review';
         store.save(s);
       }
+      const asked = s.turns.flatMap((x) => x.btw || []).filter((b) => b.status === 'running');
+      for (const b of asked) Object.assign(b, { status: 'error', error: 'wisp was restarted before this was answered.' });
+      if (asked.length) store.save(s);
     }
   }
 
   // subagents: the team a lead may delegate to. parentId/member: this session is one of them.
   // also: the task's other folders, [{ cwd, worktree }] (services/launch.js).
-  create({ id = newId(), prompt, cwd, also = [], agent = 'claude', mode = 'auto', model = '', effort = '', attachments = [], worktree = null, groupId = null, origin = null, subagents = [], parentId = null, member = '', route = null, auto = null, scout = null }) {
+  // history / title / moved: a task moved here from another place, with the turns it had there.
+  create({ id = newId(), prompt, cwd, also = [], agent = 'claude', mode = 'auto', model = '', effort = '', attachments = [], worktree = null, groupId = null, origin = null, subagents = [], parentId = null, member = '', route = null, auto = null, scout = null, history = [], title = '', moved = null }) {
     if (!adapters[agent]) throw new Error(`Unknown agent: ${agent}`);
     const now = Date.now();
     const session = {
       id,
-      title: autoTitle(prompt),
-      titleAuto: true,
+      title: title || autoTitle(prompt),
+      titleAuto: !title,
       agent,
       cwd,
       mode,
@@ -202,7 +228,8 @@ export class Runner extends EventEmitter {
       agentSessionId: null,
       agentSessions: {}, // harness -> its own conversation id, so switching back resumes it
       queue: [],
-      turns: [],
+      turns: [...history],
+      ...(moved && { moved }),
       ...(worktree && { worktree }),
       ...(also.length && { also }),
       ...(groupId && { groupId }),
@@ -308,6 +335,99 @@ export class Runner extends EventEmitter {
     return true;
   }
 
+  // /btw: a side question, answered by a read-only run of its own while the task's run carries on
+  // (server/btw.js). It lands on the latest turn and never reaches the task's conversation.
+  btw(session, question, attachments = []) {
+    const turn = session.turns.at(-1);
+    if (!turn) throw bad('Nothing to ask about yet.', 409);
+    if ([...this.sides.values()].filter((x) => x.sessionId === session.id).length >= MAX_BTW) throw bad(`${MAX_BTW} side questions are still being answered. Ask again once one is in.`, 429);
+    const entry = {
+      id: newId(),
+      question,
+      status: 'running',
+      askedAt: Date.now(),
+      agent: session.agent,
+      model: session.model || '',
+      ...(attachments.length && { attachments: attachments.map(({ id, name, mime, size }) => ({ id, name, mime, size })) }),
+    };
+    (turn.btw ||= []).push(entry);
+    this.#sideRun(session, turn, entry, attachments, !!adapters[session.agent]?.fork && !!session.agentSessionId);
+    this.#btwChanged(session, turn);
+    return entry;
+  }
+
+  // forked: on a copy of the agent's conversation, so it knows what the run did and why. A fork
+  // that fails (a CLI too old to fork) asks again with wisp's record of the task instead.
+  #sideRun(session, turn, entry, attachments, forked) {
+    const adapter = adapters[entry.agent];
+    const name = (t) => adapters[t.agent || session.agent]?.name || t.agent || session.agent;
+    const question = agentPrompt(entry.question, this.store, { tool: null, self: session.id });
+    entry.forked = forked;
+    let reply = null;
+    let handle;
+    try {
+      handle = adapter.run({
+        prompt: btwPrompt(session, question, { forked, name }),
+        attachments,
+        cwd: workdir(session),
+        dirs: alsoDirs(session),
+        resumeId: forked ? session.agentSessionId : null,
+        fork: forked,
+        mode: 'plan',
+        model: entry.model,
+        effort: session.effort || '',
+        systemPrompt: BTW_SYSTEM,
+        onEvent: (ev) => {
+          if (ev.type === 'result') reply = ev;
+        },
+      });
+    } catch (err) {
+      reply = { isError: true, text: err.message };
+      handle = { done: Promise.resolve(), stop() {} };
+    }
+    const side = { sessionId: session.id, handle, timedOut: false };
+    this.sides.set(entry.id, side);
+    const timer = setTimeout(() => ((side.timedOut = true), handle.stop()), BTW_TIMEOUT_MS);
+    handle.done.then(() => {
+      clearTimeout(timer);
+      if (this.sides.get(entry.id) !== side) return; // dismissed, or the task was deleted
+      this.sides.delete(entry.id);
+      const ok = reply && !reply.isError && !reply.stopped;
+      if (!ok && forked && !side.timedOut) return this.#sideRun(session, turn, entry, attachments, false);
+      if (ok) Object.assign(entry, { status: 'done', answer: btwAnswer(reply.text), ...(reply.stats?.costUsd && { costUsd: reply.stats.costUsd }) });
+      else Object.assign(entry, { status: 'error', error: side.timedOut ? `No answer after ${BTW_TIMEOUT_MS / 60_000} minutes.` : clip(reply?.text || 'The side run ended without an answer.', 400) });
+      entry.answeredAt = Date.now();
+      this.#btwChanged(session, turn);
+    });
+  }
+
+  // Dismiss a side question, stopping its run if it's still going.
+  dropBtw(session, id) {
+    const turn = session.turns.find((t) => t.btw?.some((b) => b.id === id));
+    if (!turn) return false;
+    turn.btw = turn.btw.filter((b) => b.id !== id);
+    if (!turn.btw.length) delete turn.btw;
+    this.sides.get(id)?.handle.stop();
+    this.sides.delete(id);
+    this.#btwChanged(session, turn);
+    return true;
+  }
+
+  // The task is going away: its side questions stop too.
+  stopSides(session) {
+    for (const [id, side] of this.sides) {
+      if (side.sessionId !== session.id) continue;
+      this.sides.delete(id);
+      side.handle.stop();
+    }
+  }
+
+  // A side question changed: the card repaints it in place. The task's own state is untouched.
+  #btwChanged(session, turn) {
+    this.store.save(session);
+    this.emit('turn', { sessionId: session.id, turnId: turn.id });
+  }
+
   // ask_user: the agent is blocked inside a tool call until answer() is called.
   // permission: set for a live approval ({ tool, action, detail }), see requestApproval().
   ask(session, { question, context, options, permission }) {
@@ -538,6 +658,14 @@ export class Runner extends EventEmitter {
     const mode = MODES.has(once) ? once : session.mode;
     const turn = this.#newTurn(session, prompt, attachments, mode);
     if (by === 'wisp') turn.by = 'wisp'; // sent by wisp (Auto's repair round), not by you
+    // Side questions still being answered move to the new turn: the old one folds away on the card.
+    const prev = session.turns.at(-1);
+    const open = prev?.btw?.filter((b) => b.status === 'running') || [];
+    if (open.length) {
+      prev.btw = prev.btw.filter((b) => !open.includes(b));
+      if (!prev.btw.length) delete prev.btw;
+      turn.btw = open;
+    }
     session.turns.push(turn);
     session.state = 'running';
     session.unread = false;
@@ -616,15 +744,29 @@ export class Runner extends EventEmitter {
       case 'tool_error':
       case 'text': {
         const item = { t: Date.now(), kind: ev.type === 'tool' ? ev.kind : ev.type === 'text' ? 'text' : 'error' };
-        if (ev.type === 'tool') Object.assign(item, { label: ev.label, file: ev.file, detail: ev.detail });
-        else if (ev.type === 'text') item.label = ev.text.slice(0, 600);
+        if (ev.type === 'tool') {
+          Object.assign(item, { label: ev.label, file: ev.file, detail: ev.detail });
+          if (ev.id) item.call = String(ev.id); // a tool_output later finds its call by this
+          if (ev.output && OUTPUT_KINDS.has(item.kind)) item.output = clipOutput(ev.output);
+        } else if (ev.type === 'text') item.label = ev.text.slice(0, MAX_TEXT);
         else item.label = `${ev.name || 'Tool'} failed: ${ev.text}`;
         turn.activity.push(item);
-        if (turn.activity.length > MAX_ACTIVITY) turn.activity.splice(0, turn.activity.length - MAX_ACTIVITY);
+        // The transcript says how many of the oldest steps it no longer has.
+        if (turn.activity.length > MAX_ACTIVITY) turn.trimmed = (turn.trimmed || 0) + turn.activity.splice(0, turn.activity.length - MAX_ACTIVITY).length;
         this.emit('activity', { sessionId: session.id, turnId: turn.id, item });
         this.#touch(session, { quiet: ev.type === 'text' });
         return;
       }
+      case 'tool_output': {
+        // What a call returned, for the transcript: matched to the call by the harness's id.
+        const item = ev.id && turn.activity.findLast((a) => a.call === String(ev.id));
+        const output = clipOutput(ev.text);
+        if (!item || !OUTPUT_KINDS.has(item.kind) || !output.trim()) return;
+        item.output = output;
+        this.emit('activity', { sessionId: session.id, turnId: turn.id, item, update: true });
+        this.store.save(session);
+        return;
+      }
       case 'change': {
         let entry = turn.changes.find((c) => c.file === ev.file);
         if (!entry) {
@@ -638,7 +780,11 @@ export class Runner extends EventEmitter {
         }
         if (ev.op === 'create' && entry.edits.length === 0) entry.op = 'create';
         delete entry.reverted;
+        const from = entry.edits.length;
         entry.edits.push(...ev.edits);
+        // The transcript shows each edit under the call that made it: [from, to) in entry.edits.
+        const call = !ev.by && turn.activity.findLast((a) => a.kind === 'edit' && a.file === ev.file);
+        if (call) call.edits = [call.edits?.[0] ?? from, entry.edits.length];
         if (ev.by && !entry.by?.includes(ev.by)) (entry.by ||= []).push(ev.by);
         this.store.save(session);
         // A subagent's edits are the lead's too: they show up in its files, diffs and Ship it.

package/server/services/launch.js

@@ -4,6 +4,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { adapters } from '../adapters/index.js';
+import { btwQuestion } from '../btw.js';
 import { createWorktree, worktreeSource, ensureWorktree, removeWorktree } from '../git.js';
 import { qualify } from '../machines.js';
 import { fill, positional } from '../recipes.js';
@@ -38,7 +39,7 @@ export function createLaunch(app) {
   const { store, runner, machines } = app;
 
   // body: { prompt, cwd, also: [folder], scratch: true = no folder, agent, mode, model, effort, attachments: [uploadId], worktree, compare,
-  //         subagents: [{ name, agent, model, effort, use }] | preset: teamId }
+  //         subagents: [{ name, agent, model, effort, use }] | preset: teamId, moved: { from, title, turns, packs } }
   async function launch(body, origin = null) {
     if (!String(body.prompt || '').trim()) throw bad('prompt required');
     // scratch: no project folder (general questions); the task gets an empty directory of its own.
@@ -72,6 +73,16 @@ export function createLaunch(app) {
     const attachments = app.uploads.resolve(body.attachments);
     const ids = runners.map(() => newId());
     let trees = ids.map(() => null);
+    // A task moved here from another place (services/move.js): its work comes in its bundles.
+    const moved = body.moved && typeof body.moved === 'object' && !comparing ? body.moved : null;
+    if (moved) {
+      const made = await app.mover.unpack([cwd, ...also], moved.packs, { id: ids[0], title: moved.title || body.prompt });
+      trees = [made[0]];
+      const extras = also.map((dir, i) => ({ cwd: dir, ...(made[i + 1] && { worktree: made[i + 1] }) }));
+      const history = Array.isArray(moved.turns) ? moved.turns.filter((t) => t && typeof t === 'object' && typeof t.prompt === 'string') : [];
+      const r = runners[0];
+      return [runner.create({ id: ids[0], prompt: body.prompt, cwd, also: extras, ...r, mode, attachments, worktree: trees[0], groupId, origin: origin || moved.origin || null, subagents, history, title: moved.title, moved: { from: String(moved.from || ''), at: Date.now() } })];
+    }
     if (wantTree) {
       const must = body.worktree === true || (comparing && mode !== 'plan');
       // One fetch for the whole launch, then the checkouts side by side: compare runs used to
@@ -101,9 +112,10 @@ export function createLaunch(app) {
     return runners.map((r, i) => runner.create({ id: ids[i], prompt: body.prompt, cwd, also: extras.map((x) => x[i]), ...r, mode, attachments, worktree: trees[i], groupId, origin, subagents, ...(r.route && { auto: { strategy }, scout: resolved.scout || null }) }));
   }
 
-  // Where a launch runs: body.machine, else a project folder that only exists on a machine
-  // (recipes and schedules keep just the path). null = here.
+  // Where a launch runs: body.machine ('' = here), else a project folder that only exists on a
+  // machine (recipes and schedules keep just the path). null = here.
   function machineFor(body) {
+    if (typeof body.machine === 'string') return body.machine ? machines.get(body.machine).id : null; // '' = this computer
     if (body.machine) return machines.get(String(body.machine)).id;
     const cwd = String(body.cwd || '');
     if (!cwd || fs.existsSync(expand(cwd))) return null;
@@ -120,6 +132,8 @@ export function createLaunch(app) {
   // launch(), here or on a machine. Resolves with summaries (a compare launch has several).
   async function launchAny(body, origin = null) {
     const mid = machineFor(body);
+    // Every project runs anywhere: its folders become the ones on that place, cloned there first if need be.
+    body = await app.places.placeBody(body, mid);
     if (!mid) return (await launch(body, origin)).map((x) => summarize(x, store));
     // Auto for a machine: routed here, with the harnesses that machine has; its outcomes come
     // back through the summaries it streams (auto.signals), so one router learns from every place.
@@ -141,11 +155,25 @@ export function createLaunch(app) {
   }
 
   // A follow-up from anywhere (UI, CLI, phone). An archived session may have lost its worktree.
+  // One that starts with /btw is a side question instead: the run carries on (see askBtw).
   async function replyTo(s, text, attachments = [], queue, mode, run) {
+    const question = btwQuestion(text);
+    if (question !== null) return { btw: await askBtw(s, question, attachments) };
     for (const x of [s, ...(s.also || [])]) await ensureWorktree(x.worktree);
     return runner.reply(s, text, attachments, { queue: queue ?? store.config.defaults.followUp === 'queue', mode, run });
   }
 
+  // /btw: answered by a read-only run of its own, next to the task's run (server/btw.js).
+  async function askBtw(s, question, attachments = []) {
+    question = String(question || '').trim();
+    if (!question) throw bad('Type your question after /btw.');
+    if (s.agent === 'wisp') throw bad('This is the tour — launch a real wisp to ask it things.');
+    for (const x of [s, ...(s.also || [])]) await ensureWorktree(x.worktree);
+    const entry = runner.btw(s, question, attachments);
+    app.telemetry?.track('btw', { agent: s.agent, forked: entry.forked, running: runner.live.has(s.id) });
+    return entry;
+  }
+
   function markDone(s) {
     if (s.state === 'running' || s.state === 'waiting') return false;
     s.state = 'done';
@@ -164,5 +192,5 @@ export function createLaunch(app) {
     return s;
   }
 
-  return { launch, launchAny, machineFor, pushUploads, replyTo, markDone, runRecipe };
+  return { launch, launchAny, machineFor, pushUploads, replyTo, askBtw, markDone, runRecipe };
 }

package/server/services/move.js

@@ -0,0 +1,130 @@
+// Moving a task to another place (this computer or a machine) with a follow-up. A session lives on
+// the wisp that runs it, so the move starts a new session there that carries the task on:
+//
+//   pack     the source packs each folder's work (git.js packWork: the branch, plus a snapshot
+//            of what isn't committed) into bundles, kept as uploads there.
+//   carry    the bundles travel through this wisp to the target, like attachments do.
+//   launch   the target gets the project's checkout (services/places.js), unpacks each bundle into
+//            a worktree on the same branch, and starts the follow-up with the earlier turns as
+//            its history: the harness there hears them first (handoff.js).
+//   retire   the old session is archived, pointing at the new one.
+
+import os from 'node:os';
+import { listAgents, adapters } from '../adapters/index.js';
+import { packWork, unpackWork } from '../git.js';
+import { splitId } from '../machines.js';
+import { workdir } from '../runner.js';
+import { bad } from '../util.js';
+
+export function createMove(app) {
+  const { store, machines, uploads } = app;
+  // What a place is called in a moved task's history: the machine's name, or this computer's.
+  const where = (mid) => (mid ? machines.get(mid).name : os.hostname().replace(/\.local$/, '') || 'this computer');
+
+  // Source side: the session and its folders' bundles. A running task has nothing settled to pack.
+  async function pack(s) {
+    if (s.agent === 'wisp') throw bad('This is the tour — launch a real wisp to move it.');
+    if (s.parentId) throw bad('A subagent runs where its lead does.');
+    if (s.state === 'running' || s.state === 'waiting') throw bad('Stop the task or let it finish first: a running task can’t move.', 409);
+    const one = async (dir, wt) => {
+      const u = uploads.reserve('work.bundle');
+      const out = await packWork(dir, wt, u.file).catch((err) => {
+        throw bad(`Couldn’t pack the work in ${dir}: ${err.message}`);
+      });
+      return out && { ...out, upload: u.add().id };
+    };
+    const scratch = store.isScratch(s.cwd);
+    const packs = scratch ? [] : [await one(workdir(s), s.worktree), ...(await Promise.all((s.also || []).map((a) => one(a.worktree?.cwd || a.cwd, a.worktree))))];
+    return { session: s, scratch, packs };
+  }
+
+  // Target side (launch.js): the worktrees for a moved launch, one per folder, from the bundles.
+  async function unpack(dirs, packs, { id, title }) {
+    return Promise.all(
+      dirs.map(async (cwd, i) => {
+        const p = packs?.[i];
+        const u = p && uploads.get(p.upload);
+        if (!p || !u) return null;
+        try {
+          return await unpackWork({ cwd, home: store.home, id, title, pack: p, file: u.path });
+        } finally {
+          uploads.remove(u.id);
+        }
+      }),
+    );
+  }
+
+  // A bundle from the source (null = here) as an upload on the target.
+  async function carry(upload, from, to) {
+    let u = from ? null : uploads.get(upload);
+    if (from) u = await uploads.receive(await machines.stream(from, 'GET', `/uploads/${upload}`, { timeout: 10 * 60_000 }), { name: 'work.bundle', type: 'application/octet-stream' });
+    if (!u) throw bad('The packed work went missing on its way.', 500);
+    if (!to) return u.id;
+    const there = await machines.upload(to, u);
+    uploads.remove(u.id); // the copy here was only on its way through
+    return there.id;
+  }
+
+  // The earlier turns, as history for the new session: what ran where, without what only made
+  // sense there (checkpoints, attachment files, subagent sessions).
+  const history = (s, from) =>
+    s.turns.map((t) => {
+      const { checkpoint, delegations, attachments, ...rest } = t;
+      return { ...rest, moved: t.moved || where(from), checkpoint: null, ...(t.status === 'running' && { status: 'stopped' }) };
+    });
+
+  // id: the session as this wisp names it (<id>@<machine> on a machine). to: a machine id, or
+  // null for this computer. Resolves the new session's summary.
+  async function move(id, to, { text, attachments = [], mode, agent, model, effort } = {}) {
+    const at = splitId(id);
+    const from = at?.machine || null;
+    to = to || null;
+    if (from === to) throw bad('The task is already there.');
+    if (to) machines.get(to);
+    if (to && !machines.isOnline(to)) throw bad(`${machines.get(to).name} is offline. Connect it from Machines.`, 503);
+    const local = !from && store.get(id);
+    if (!from && !local) throw bad('no such session', 404);
+    const src = from ? await machines.json(from, 'GET', `/sessions/${at.id}`) : local;
+    // The harness the follow-up runs on has to be there.
+    const run = { agent: agent || src.agent, model: model ?? (agent && agent !== src.agent ? '' : src.model || ''), effort: effort ?? (agent && agent !== src.agent ? '' : src.effort || '') };
+    const there = to ? machines.agentsOf(to) || [] : await listAgents();
+    if (!there.some((a) => a.id === run.agent && a.available)) throw bad(`${adapters[run.agent]?.name || run.agent} isn’t installed on ${where(to)}. Pick another harness for this follow-up.`);
+
+    const packed = from ? await machines.json(from, 'POST', `/sessions/${at.id}/pack`, {}, { timeout: 10 * 60_000 }) : await pack(local);
+    const s = from ? machines.session(from, packed.session) : packed.session;
+    const packs = await Promise.all(packed.packs.map(async (p) => p && { ...p, upload: await carry(p.upload, from, to) }));
+    if (from) for (const p of packed.packs) if (p) machines.json(from, 'DELETE', `/uploads/${p.upload}`).catch(() => {});
+
+    const body = {
+      prompt: text,
+      ...(packed.scratch ? { scratch: true } : { cwd: s.cwd, also: (s.also || []).map((a) => a.cwd) }),
+      machine: to || '',
+      agent: run.agent,
+      model: run.model,
+      effort: run.effort,
+      mode: mode || s.mode,
+      attachments,
+      ...(s.groupId && { groupId: s.groupId }),
+      ...(s.subagents?.length && { subagents: s.subagents }),
+      moved: { from: where(from), title: s.title, turns: history(s, from), packs, ...(s.origin && { origin: s.origin }) },
+    };
+    let next;
+    try {
+      [next] = await app.launcher.launchAny(body);
+    } catch (err) {
+      for (const p of packs) if (p) (to ? machines.json(to, 'DELETE', `/uploads/${p.upload}`) : Promise.resolve(uploads.remove(p.upload))).catch(() => {});
+      throw err;
+    }
+    // The old one steps aside: archived (its worktree stays until you delete it), pointing here.
+    const movedTo = { id: next.id, place: where(to) };
+    if (from) await machines.json(from, 'PATCH', `/sessions/${at.id}`, { archived: true, movedTo }).catch(() => {});
+    else {
+      Object.assign(local, { archived: true, unread: false, movedTo });
+      app.sessionChanged(local);
+    }
+    app.telemetry?.track('move_task', { from: from ? 'machine' : 'here', to: to ? 'machine' : 'here', agent: run.agent });
+    return { moved: true, from: id, session: next };
+  }
+
+  return { pack, unpack, move };
+}

package/server/services/phone.js

@@ -1,6 +1,8 @@
 // Phone (ntfy / Telegram): what a tap or a reply there does to a session, here or on a machine.
 
+import { BTW_TIMEOUT_MS } from '../btw.js';
 import { splitId } from '../machines.js';
+import { truncate } from '../util.js';
 
 export function phoneActions(app) {
   const { store, runner, machines } = app;
@@ -21,6 +23,17 @@ export function phoneActions(app) {
     return s && { s: machines.session(at.machine, s), answer: (a) => call('POST', '/answer', { text: a }), reply: (t) => call('POST', '/reply', { text: t }), done: async () => !live && !!(await call('PATCH', '', { state: 'done' })) };
   }
 
+  // A /btw from the phone: its answer, once it's in (null if it was dismissed or never came).
+  async function btwAnswer(sessionId, btwId) {
+    for (const end = Date.now() + BTW_TIMEOUT_MS + 30_000; Date.now() < end; ) {
+      await new Promise((r) => setTimeout(r, 1500));
+      const b = (await sessionOps(sessionId).catch(() => null))?.s.turns.flatMap((t) => t.btw || []).find((x) => x.id === btwId);
+      if (!b) return null;
+      if (b.status !== 'running') return b;
+    }
+    return null;
+  }
+
   return {
     // /new from Telegram: the launcher's remembered harness, model and mode, like `wisp "…"`.
     launch: async ({ project, prompt }) => {
@@ -31,7 +44,8 @@ export function phoneActions(app) {
       app.broadcast('config', {});
       return s;
     },
-    act: async ({ sessionId, kind, ref, index, text }) => {
+    // later(text): a message sent after this one (Telegram), for a /btw's answer.
+    act: async ({ sessionId, kind, ref, index, text, later }) => {
       const ops = await sessionOps(sessionId).catch((err) => ({ error: err.message }));
       if (ops?.error) return `Can’t reach it: ${ops.error}`;
       if (!ops) return 'That session is gone.';
@@ -59,6 +73,11 @@ export function phoneActions(app) {
       }
       if (s.agent === 'wisp') return 'That is the tour; it can’t take follow-ups.';
       const r = await ops.reply(String(text || '').trim());
+      if (r.btw) {
+        // Not awaited: the bot keeps taking messages while the side run answers.
+        btwAnswer(sessionId, r.btw.id).then((b) => b && later?.(truncate(b.status === 'done' ? `btw: ${b.answer}` : `Couldn’t answer that: ${b.error}`, 4000))).catch(() => {});
+        return later ? '✓ Asking on the side; the agent keeps working. The answer follows here.' : '✓ Asked on the side; the answer shows on the card in wisp.';
+      }
       return r.answered ? '✓ Answered' : r.interrupted ? '✓ Sent; the agent picked it up mid-run' : r.queued ? '✓ Queued for when it finishes' : '✓ Sent';
     },
   };