@openagents-org/agent-launcher 0.2.184 → 0.2.186

package/src/adapters/claude.js

@@ -96,12 +96,6 @@ class ClaudeAdapter extends BaseAdapter {
     this._channelSessions = {}; // channel → Claude CLI session_id
     this._channelProcesses = {}; // channel → child process
     this._stoppingChannels = new Set();
-    // Channels that have already announced "Execution stopped by user." for the
-    // current stop. Two paths race to post it (the control-action handler that
-    // kills the process, and the in-flight message handler that sees
-    // pp.userStopped after exit), so this dedups to a single notice. Reset when
-    // a new message starts processing in the channel.
-    this._stopNoticeSent = new Set();
     this._persistentProcs = {}; // channel → { proc, lineBuffer, pendingLines, idleTimer, messageResolve }
     // Knowledge pinning (decision log + glossary) lives in BaseAdapter; this
     // adapter fetches directly in _handleMessage because the result also
@@ -139,26 +133,6 @@ class ClaudeAdapter extends BaseAdapter {
   }
 
   async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const channel = (payload && typeof payload === 'object') ? payload.channel : null;
-      if (channel) {
-        const pp = this._persistentProcs[channel];
-        if (pp) pp.userStopped = true;
-      }
-      if (channel && this._channelProcesses[channel]) {
-        this._log(`Stopping process for channel=${channel}`);
-        this._stoppingChannels.add(channel);
-        const proc = this._channelProcesses[channel];
-        await this._stopProcess(proc);
-        delete this._channelProcesses[channel];
-        delete this._channelQueues[channel];
-        await this._postStopNotice(channel);
-      } else {
-        for (const pp of Object.values(this._persistentProcs)) pp.userStopped = true;
-        await this._stopAllProcesses('Execution stopped by user.');
-      }
-      return;
-    }
     if (action === 'restart') {
       const channel = (payload && typeof payload === 'object') ? payload.channel : null;
       if (channel) {
@@ -317,15 +291,37 @@ class ClaudeAdapter extends BaseAdapter {
   }
 
   /**
-   * Post "Execution stopped by user." at most once per channel for a given
-   * stop. The control-action handler and the in-flight message handler both
-   * race to announce a stop; without this guard the user sees it twice. The
-   * guard is reset when a new message starts processing in the channel.
+   * Abandon this turn when a stop landed while it was being prepared. The
+   * stop handler kills whatever process is registered, but a turn still
+   * working through its pre-CLI round trips has none yet — so without this
+   * it goes on to spawn one and the agent resumes seconds after saying it
+   * stopped. Returns true when the caller should give up.
    */
-  async _postStopNotice(channel) {
-    if (!channel || this._stopNoticeSent.has(channel)) return;
-    this._stopNoticeSent.add(channel);
-    try { await this.sendResponse(channel, 'Execution stopped by user.'); } catch {}
+  async _bailOnStopDuringTurn(msgChannel) {
+    if (!this._stoppedBeforeStart(msgChannel)) return false;
+    // Deduped: normally the stop handler already announced it.
+    await this._finishUserStop(msgChannel);
+    return true;
+  }
+
+  /**
+   * Stop ONE channel's Claude run (BaseAdapter._handleUserStop drives this).
+   *
+   * `userStopped` goes on before the kill: the turn waiting on this process
+   * must read its exit as a stop, not as a stale session to retry, and the
+   * output parser drops what the process wrote before dying.
+   */
+  async _stopChannelWork(channel) {
+    const pp = this._persistentProcs[channel];
+    if (pp) pp.userStopped = true;
+    const outcome = await super._stopChannelWork(channel);
+    // Those leftover lines are still being parsed on this chain. They post
+    // nothing now, but wait them out so none of their bookkeeping races the
+    // notice BaseAdapter posts next.
+    if (pp) {
+      try { await pp.pendingLines; } catch {}
+    }
+    return outcome;
   }
 
   async _stopAllProcesses(completionMessage = 'Execution stopped.') {
@@ -839,6 +835,23 @@ class ClaudeAdapter extends BaseAdapter {
       try { event = JSON.parse(line); } catch { return; }
       const eventType = event.type;
 
+      // The user stopped this process. What it wrote before dying is still
+      // queued here, and posting any of it — a thinking block, a tool status,
+      // even the finished answer — lands after "Execution stopped by user."
+      // and makes the thread read as running again. Keep the session id so
+      // the next message resumes the conversation; drop everything else.
+      if (pp.userStopped) {
+        if (eventType === 'result' && event.session_id) {
+          this._channelSessions[pp.msgChannel] = event.session_id;
+          this._saveSessions();
+        }
+        if (eventType === 'result' && pp.messageResolve) {
+          pp.messageResolve({ resultEvent: event });
+          pp.messageResolve = null;
+        }
+        return;
+      }
+
       if (eventType === 'assistant') {
         pp.awaitingToolResult = false;
         const blocks = (event.message || {}).content || [];
@@ -1109,6 +1122,10 @@ class ClaudeAdapter extends BaseAdapter {
   /** Queue a reminder about unfinished todos (skipped when this turn IS one). */
   async _queueTodoNudge(msgChannel, msg) {
     if (msg._todoNudge) return;
+    // A stop ends the plan, it does not pause it. When the stop lands while
+    // this turn is finishing, nudging here is what handed the agent its own
+    // "please continue" right after it announced it had stopped.
+    if (this._stoppingChannels.has(msgChannel)) return;
     try {
       const remaining = await this.getRemainingTodos(msgChannel);
       if (remaining.length > 0) {
@@ -1136,7 +1153,6 @@ class ClaudeAdapter extends BaseAdapter {
 
     const msgChannel = msg.sessionId || this.channelName;
     this._stoppingChannels.delete(msgChannel);
-    this._stopNoticeSent.delete(msgChannel);
     const sender = msg.senderName || msg.senderType || 'user';
     this._log(`Processing message from ${sender} in ${msgChannel}: ${content.slice(0, 80)}...`);
 
@@ -1213,9 +1229,14 @@ class ClaudeAdapter extends BaseAdapter {
         await this._killPersistentProc(msgChannel);
       } else {
         this._log(`Reusing persistent process for ${msgChannel}`);
+        if (await this._bailOnStopDuringTurn(msgChannel)) return;
         this._resetIdleTimer(msgChannel);
         existingPP.msgChannel = msgChannel;
         const result = await this._sendToPersistentProc(existingPP, content);
+        if (existingPP.userStopped) {
+          await this._finishUserStop(msgChannel);
+          return;
+        }
         if (result.resultEvent) {
           const finalResponse = this._composeFinalResponse(existingPP);
           if (this._isPromptTooLong(existingPP, finalResponse) && this._channelSessions[msgChannel]) {
@@ -1228,11 +1249,6 @@ class ClaudeAdapter extends BaseAdapter {
             await this._queueTodoNudge(msgChannel, msg);
             return;
           }
-        } else if (existingPP.userStopped) {
-          if (!existingPP.everPostedAnything) {
-            await this._postStopNotice(msgChannel);
-          }
-          return;
         } else {
           // Process died mid-message — fall through to spawn a fresh one
           this._log(`Persistent process died, falling back to fresh spawn for ${msgChannel}`);
@@ -1285,6 +1301,7 @@ class ClaudeAdapter extends BaseAdapter {
       }
 
       try {
+        if (await this._bailOnStopDuringTurn(msgChannel)) return;
         const pp = this._spawnPersistentProc(msgChannel, cmd, cleanEnv);
         // Remember the spawn-time configuration so the fast-path can detect
         // staleness on later messages — the pinned knowledge and the mode
@@ -1301,14 +1318,13 @@ class ClaudeAdapter extends BaseAdapter {
 
         const result = await this._sendToPersistentProc(pp, effectiveContent);
 
+        if (pp.userStopped) {
+          await this._finishUserStop(msgChannel);
+          break;
+        }
+
         if (result.exited) {
-          this._log(`Process exited during first message (attempt ${attempt + 1}), userStopped=${pp.userStopped}`);
-          if (pp.userStopped) {
-            if (!pp.everPostedAnything) {
-              await this._postStopNotice(msgChannel);
-            }
-            break;
-          }
+          this._log(`Process exited during first message (attempt ${attempt + 1})`);
           if (attempt === 0 && this._channelSessions[msgChannel]) {
             this._log(`Stale session detected, retrying without resume`);
             delete this._channelSessions[msgChannel];

package/src/adapters/cline.js

@@ -136,19 +136,6 @@ class ClineAdapter extends BaseAdapter {
   // ------------------------------------------------------------------
 
   async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const channel = (payload && typeof payload === 'object') ? payload.channel : null;
-      if (channel && this._channelProcesses[channel]) {
-        this._stoppingChannels.add(channel);
-        await this._stopProcess(this._channelProcesses[channel]);
-        delete this._channelProcesses[channel];
-        delete this._channelQueues[channel];
-        try { await this.sendResponse(channel, 'Execution stopped by user.'); } catch {}
-      } else {
-        await this._stopAllProcesses('Execution stopped by user.');
-      }
-      return;
-    }
     if (action === 'restart') {
       const channel = (payload && typeof payload === 'object') ? payload.channel : null;
       if (channel) {
@@ -631,6 +618,8 @@ class ClineAdapter extends BaseAdapter {
    * `ok` reflects run_result.finishReason === "completed".
    */
   _runCline(channel, clineBin, args, workingDir) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) return Promise.resolve({ userStopped: true });
     const cleanEnv = { ...(this.agentEnv || process.env) };
     const [cmd, ...spawnArgs] = this._spawnableCmd(clineBin, args);
 

package/src/adapters/codebuddy.js

@@ -76,7 +76,6 @@ const IS_WINDOWS = process.platform === 'win32';
 
 // Max wall-clock for a single headless run, after which the process group is
 // killed and the turn reported as interrupted.
-const TIMEOUT_MS = 600000; // 10 minutes
 
 // Idle watchdog: with no stdout frame for this long we nudge the channel, and
 // after MAX consecutive silences we kill a run that is probably wedged.
@@ -176,29 +175,9 @@ class CodeBuddyAdapter extends BaseAdapter {
   }
 
   // ------------------------------------------------------------------
-  // Control actions (stop / restart)
+  // Shutdown
   // ------------------------------------------------------------------
 
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const channel = (payload && payload.channel) || null;
-      if (channel) {
-        const proc = this._channelProcesses[channel];
-        if (proc) {
-          this._stoppingChannels.add(channel);
-          await this._stopProcess(proc);
-          delete this._channelProcesses[channel];
-          delete this._channelQueues[channel];
-          try { await this.sendResponse(channel, 'Execution stopped.'); } catch {}
-        }
-        return;
-      }
-      await this._stopAllProcesses();
-      return;
-    }
-    return super._onControlAction(action, payload);
-  }
-
   stop() {
     super.stop();
     void this._stopAllProcesses('Agent stopped.');
@@ -591,6 +570,8 @@ class CodeBuddyAdapter extends BaseAdapter {
    * @returns {Promise<object>} { code, signal, result, sessionId, anyOutput, lastAssistantText, userStopped, stderr }
    */
   _runCodeBuddy(channel, bin, args, workingDir, prompt) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) return Promise.resolve({ userStopped: true });
     return new Promise((resolve) => {
       const [cmd, ...spawnArgs] = this._spawnableCmd(bin, args);
       this._log(`Spawning: ${path.basename(cmd)} ${redactArgs(spawnArgs).join(' ')} (cwd=${workingDir})`);
@@ -633,7 +614,6 @@ class CodeBuddyAdapter extends BaseAdapter {
         if (settled) return;
         settled = true;
         clearInterval(watchdog);
-        clearTimeout(timeout);
         if (this._channelProcesses[channel] === proc) delete this._channelProcesses[channel];
         resolve(payload);
       };
@@ -739,12 +719,6 @@ class CodeBuddyAdapter extends BaseAdapter {
         }
       }, WATCHDOG_INTERVAL_MS);
 
-      const timeout = setTimeout(() => {
-        this._log(`Run exceeded ${TIMEOUT_MS}ms — killing`);
-        killedByWatchdog = true;
-        void this._stopProcess(proc);
-      }, TIMEOUT_MS);
-
       try {
         proc.stdin.on('error', () => {});
         proc.stdin.write(prompt, 'utf-8');

package/src/adapters/codex.js

@@ -247,19 +247,6 @@ class CodexAdapter extends BaseAdapter {
     } catch {}
   }
 
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      for (const [channel, proc] of Object.entries(this._channelProcesses)) {
-        await this._stopProcess(proc);
-        delete this._channelProcesses[channel];
-        try { await this.sendStatus(channel, 'Execution stopped by user'); } catch {}
-      }
-      return;
-    }
-    // Shared actions (status, routines, skill.install, skill.uninstall).
-    await super._onControlAction(action, payload);
-  }
-
   // ------------------------------------------------------------------
   // Message handler
   // ------------------------------------------------------------------
@@ -325,6 +312,7 @@ class CodexAdapter extends BaseAdapter {
 
       try {
         const result = await this._spawnCodex(cmd, env, msgChannel, fullPrompt);
+        if (result.stopped) return;
 
         if (result.responseText) {
           await this.sendResponse(msgChannel, result.responseText);
@@ -351,6 +339,8 @@ class CodexAdapter extends BaseAdapter {
   }
 
   async _spawnCodex(cmd, env, msgChannel, prompt) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(msgChannel)) return { stopped: true, responseText: '', exitCode: null };
     return new Promise((resolve, reject) => {
       const proc = spawn(cmd[0], cmd.slice(1), {
         stdio: ['pipe', 'pipe', 'pipe'],

package/src/adapters/commandcode.js

@@ -71,7 +71,6 @@ const IS_WINDOWS = process.platform === 'win32';
 
 // Max wall-clock for a single headless run, after which the process group is
 // killed and the turn reported as interrupted.
-const TIMEOUT_MS = 600000; // 10 minutes
 
 // Idle watchdog: with no stdout frame for this long we nudge the channel, and
 // after MAX consecutive silences we kill a run that is probably wedged.
@@ -175,29 +174,9 @@ class CommandCodeAdapter extends BaseAdapter {
   }
 
   // ------------------------------------------------------------------
-  // Control actions (stop / restart)
+  // Shutdown
   // ------------------------------------------------------------------
 
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const channel = (payload && payload.channel) || null;
-      if (channel) {
-        const proc = this._channelProcesses[channel];
-        if (proc) {
-          this._stoppingChannels.add(channel);
-          await this._stopProcess(proc);
-          delete this._channelProcesses[channel];
-          delete this._channelQueues[channel];
-          try { await this.sendResponse(channel, 'Execution stopped.'); } catch {}
-        }
-        return;
-      }
-      await this._stopAllProcesses();
-      return;
-    }
-    return super._onControlAction(action, payload);
-  }
-
   stop() {
     super.stop();
     void this._stopAllProcesses('Agent stopped.');
@@ -545,6 +524,8 @@ class CommandCodeAdapter extends BaseAdapter {
    * @returns {Promise<object>} { code, signal, result, anyOutput, userStopped, stderrSessionId }
    */
   _runCommandCode(channel, bin, args, workingDir, prompt) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) return Promise.resolve({ userStopped: true });
     return new Promise((resolve) => {
       const [cmd, ...spawnArgs] = this._spawnableCmd(bin, args);
       this._log(`Spawning: ${path.basename(cmd)} ${redactArgs(spawnArgs).join(' ')} (cwd=${workingDir})`);
@@ -585,7 +566,6 @@ class CommandCodeAdapter extends BaseAdapter {
         if (settled) return;
         settled = true;
         clearInterval(watchdog);
-        clearTimeout(timeout);
         if (this._channelProcesses[channel] === proc) delete this._channelProcesses[channel];
         resolve(payload);
       };
@@ -671,12 +651,6 @@ class CommandCodeAdapter extends BaseAdapter {
         }
       }, WATCHDOG_INTERVAL_MS);
 
-      const timeout = setTimeout(() => {
-        this._log(`Run exceeded ${TIMEOUT_MS}ms — killing`);
-        killedByWatchdog = true;
-        void this._stopProcess(proc);
-      }, TIMEOUT_MS);
-
       // Feed the prompt. stdin is closed immediately: Command Code times out a
       // piped stdin after 30s of silence, so an unclosed pipe would stall.
       try {

package/src/adapters/copilot.js

@@ -76,7 +76,7 @@ const SECRET_ENV_VARS = [
 const ACT_ALLOW_TOOLS = ['shell', 'write'];
 
 // How long to wait for a turn before giving up (no output / hung CLI).
-const TURN_TIMEOUT_MS = 10 * 60 * 1000;
+const TURN_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
 
 class CopilotAdapter extends BaseAdapter {
   /**
@@ -336,32 +336,6 @@ class CopilotAdapter extends BaseAdapter {
     });
   }
 
-  // ------------------------------------------------------------------
-  // Control actions (stop / interrupt)
-  // ------------------------------------------------------------------
-
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const channel = (payload && typeof payload === 'object') ? payload.channel : null;
-      if (channel && this._channelProcesses[channel]) {
-        this._stoppingChannels.add(channel);
-        await this._stopProcess(this._channelProcesses[channel]);
-        delete this._channelProcesses[channel];
-        delete this._channelQueues[channel];
-        try { await this.sendStatus(channel, 'Execution stopped by user'); } catch {}
-      } else {
-        for (const [ch, proc] of Object.entries(this._channelProcesses)) {
-          this._stoppingChannels.add(ch);
-          await this._stopProcess(proc);
-          delete this._channelProcesses[ch];
-          try { await this.sendStatus(ch, 'Execution stopped by user'); } catch {}
-        }
-      }
-      return;
-    }
-    await super._onControlAction(action, payload);
-  }
-
   /**
    * Daemon shutdown: tear down any in-flight Copilot subprocess so the thread
    * doesn't get stuck showing "running".
@@ -544,6 +518,8 @@ class CopilotAdapter extends BaseAdapter {
    * `errorMessage` / `staleSession` / `timedOut` so the caller can react.
    */
   _runTurn(channel, args) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) return Promise.resolve({ userStopped: true });
     const [file, ...prefix] = this._resolveExec(this._copilotBin);
     const env = getEnhancedEnv({ ...(this.agentEnv || process.env) });
     const cwd = this.workingDir || defaultAgentWorkdir(this.agentName);
@@ -589,10 +565,15 @@ class CopilotAdapter extends BaseAdapter {
       let pending = Promise.resolve();
       let settled = false;
 
-      const timeout = setTimeout(() => {
-        this._stopProcess(proc).catch(() => {});
-        finish({ timedOut: true, finalText: accumulatedText() });
-      }, TURN_TIMEOUT_MS);
+      let timeout = null;
+      const resetTimeout = () => {
+        if (timeout) clearTimeout(timeout);
+        timeout = setTimeout(() => {
+          this._stopProcess(proc).catch(() => {});
+          finish({ timedOut: true, finalText: accumulatedText() });
+        }, TURN_IDLE_TIMEOUT_MS);
+      };
+      resetTimeout();
 
       const finish = (summary) => {
         if (settled) return;
@@ -681,6 +662,9 @@ class CopilotAdapter extends BaseAdapter {
         }
       };
 
+      if (proc.stdout) proc.stdout.on('data', resetTimeout);
+      if (proc.stderr) proc.stderr.on('data', resetTimeout);
+
       proc.stdout.on('data', (chunk) => {
         for (const ev of parser.push(chunk)) {
           pending = pending.then(() => handle(ev)).catch(() => {});

package/src/adapters/cursor.js

@@ -62,18 +62,7 @@ class CursorAdapter extends BaseAdapter {
   }
 
   async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const channel = (payload && typeof payload === 'object') ? payload.channel : null;
-      if (channel && this._channelProcesses[channel]) {
-        this._stoppingChannels.add(channel);
-        await this._stopProcess(this._channelProcesses[channel]);
-        delete this._channelProcesses[channel];
-        delete this._channelQueues[channel];
-        try { await this.sendResponse(channel, 'Execution stopped.'); } catch {}
-      } else {
-        await this._stopAllProcesses('Execution stopped.');
-      }
-    } else if (action === 'restart') {
+    if (action === 'restart') {
       const channel = (payload && typeof payload === 'object') ? payload.channel : null;
       if (channel) {
         if (this._channelProcesses[channel]) {
@@ -86,7 +75,10 @@ class CursorAdapter extends BaseAdapter {
         this._saveSessions();
         try { await this.sendResponse(channel, 'Session cleared. Send a new message to start fresh.'); } catch {}
       }
+      return;
     }
+    // Shared actions (status, routines, skill.install, model.set).
+    await super._onControlAction(action, payload);
   }
 
   stop() {
@@ -444,6 +436,9 @@ class CursorAdapter extends BaseAdapter {
         return;
       }
 
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(msgChannel)) return;
+
     try {
       const resolved = this._resolveToNodeCmd(cmd[0]);
       if (resolved) {
@@ -573,7 +568,7 @@ class CursorAdapter extends BaseAdapter {
           const stoppedByUser = this._stoppingChannels.has(msgChannel);
 
           if (stoppedByUser) {
-            try { await this.cleanupTodos(msgChannel); } catch {}
+            // BaseAdapter._handleUserStop cancels the plan before announcing.
           } else if (!msg._todoNudge) {
             try {
               const remaining = await this.getRemainingTodos(msgChannel);

package/src/adapters/deepseek.js

@@ -123,18 +123,8 @@ const RECAP_TAIL = 60;
 const TOKEN_ENV = 'OPENAGENTS_WORKSPACE_TOKEN';
 
 /**
- * The status that ends a run in the workspace UI.
- *
- * The client clears its "stopping" state only on a status matching
- * /stopped|stopping failed/i (chat-view.tsx). Any other final status leaves the
- * session marked as working forever — and a cancelled run produces nothing
- * later that could correct it. The wording is therefore load-bearing, and the
- * tests assert it against the client's own regex.
- */
-const STOPPED_STATUS = 'Execution stopped by user';
-
-/**
- * The status for a stop that could NOT be confirmed.
+ * The notice for a stop that could NOT be confirmed (BaseAdapter posts it when
+ * `_stopChannelWork` reports 'failed').
  *
  * Contains "stopping failed" because that is the other half of the client's
  * terminal-status regex. Reporting a clean stop when the child may still be
@@ -169,6 +159,7 @@ class DeepSeekAdapter extends BaseAdapter {
     // arriving in that window has no process to kill. Without this set the stop
     // would be silently dropped and the task would start anyway.
     this._busyChannels = new Set();
+    this._stopFailedMessage = STOP_FAILED_STATUS;
     // Channels cancelled while busy. Checked at every await boundary and once
     // more immediately before spawning.
     this._cancelledChannels = new Set();
@@ -590,78 +581,52 @@ class DeepSeekAdapter extends BaseAdapter {
   }
 
   // ------------------------------------------------------------------
-  // Control actions (stop)
+  // Stop (BaseAdapter._handleUserStop drives these)
   // ------------------------------------------------------------------
 
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      // The workspace sends the conversation it wants stopped. Honouring it is
-      // what keeps one user's stop from tearing down every other concurrent
-      // run — claude.js already scopes its stop this way; mini/amp do not, and
-      // following them here was the mistake. A stop with no channel still
-      // means "everything".
-      const target = (payload && typeof payload === 'object' && payload.channel)
-        ? payload.channel
-        : null;
-      await this._stopChannels(target);
-      return;
-    }
-    await super._onControlAction(action, payload);
-  }
-
   /**
-   * Stop one channel, or every channel when `target` is null.
-   *
-   * Each affected channel is told exactly once what happened — and told the
-   * TRUTH: a kill that could not be confirmed reports a failed stop rather than
-   * a clean one, because the child may still be writing to the workspace.
+   * Stop ONE conversation. A run that has not spawned yet is cancelled by
+   * flagging it — nothing is running, so that is complete by definition.
+   * A child whose kill could not be confirmed reports 'failed', and the user
+   * is told the truth: it may still be writing to the workspace.
    */
-  async _stopChannels(target) {
-    // channel -> was termination confirmed
-    const outcome = new Map();
-
-    const busy = target
-      ? (this._busyChannels.has(target) ? [target] : [])
-      : [...this._busyChannels];
-    for (const channel of busy) {
+  async _stopChannelWork(channel) {
+    let outcome = 'idle';
+    if (this._busyChannels.has(channel)) {
       this._cancelledChannels.add(channel);
-      this._stoppingChannels.add(channel);
       // Release a waiter parked on the shared bootstrap. Marking alone is not
       // enough: the flag is only read between awaits, and this one can last
       // the whole bootstrap timeout.
       const release = this._cancelWaiters.get(channel);
       if (release) release();
-      // Nothing has spawned yet, so cancellation is complete by definition.
-      outcome.set(channel, true);
+      outcome = 'stopped';
     }
-
-    for (const [channel, proc] of Object.entries(this._channelProcesses)) {
-      if (channel === BOOTSTRAP_KEY) {
-        // Bootstrap is SHARED: every channel waits on the same profile
-        // compose. Tearing it down because one conversation was stopped would
-        // fail the others too, so a scoped stop leaves it alone.
-        if (target) continue;
-      } else if (target && channel !== target) {
-        continue;
-      }
-
+    const proc = this._channelProcesses[channel];
+    if (proc) {
       // Untrack only once the kill has been attempted, so the child is never
       // missing from the registry while it may still be running.
       const ended = await this._stopProcess(proc);
       delete this._channelProcesses[channel];
-
-      if (channel === BOOTSTRAP_KEY) continue;
-      this._stoppingChannels.add(channel);
-      outcome.set(channel, ended);
+      outcome = ended ? 'stopped' : 'failed';
     }
+    return outcome;
+  }
 
-    // The client clears its stopping state only on a terminal status, and a
-    // cancelled run produces nothing later that could supply one.
-    for (const [channel, ended] of outcome) {
-      try {
-        await this.sendStatus(channel, ended ? STOPPED_STATUS : STOP_FAILED_STATUS);
-      } catch { /* the run is already over; a failed post must not throw here */ }
-    }
+  _channelsWithWork() {
+    return [...new Set([...super._channelsWithWork(), ...this._busyChannels])]
+      .filter((channel) => channel !== BOOTSTRAP_KEY);
+  }
+
+  /**
+   * Bootstrap is SHARED: every conversation waits on the same profile
+   * compose. A scoped stop leaves it alone, or it would fail the others too;
+   * only a workspace-wide stop tears it down.
+   */
+  async _stopSharedWork() {
+    const proc = this._channelProcesses[BOOTSTRAP_KEY];
+    if (!proc) return;
+    await this._stopProcess(proc);
+    delete this._channelProcesses[BOOTSTRAP_KEY];
   }
 
   /** True when a child has ended, by exit code OR by signal. */
@@ -987,7 +952,7 @@ class DeepSeekAdapter extends BaseAdapter {
     try {
       // Last gate before anything is started. Everything above this line is
       // reversible; a process is not.
-      if (this._cancelled(msgChannel)) return { text: '', error: null };
+      if (this._cancelled(msgChannel) || this._stoppedBeforeStart(msgChannel)) return { text: '', error: null };
       return await this._spawnDsh({ taskFile, msgChannel, permissionMode });
     } finally {
       try { fs.rmSync(taskFile, { force: true }); } catch { /* best effort */ }