@openagents-org/agent-launcher 0.2.183 → 0.2.185

package/src/adapters/base.js

@@ -72,7 +72,30 @@ const MODEL_ENV_ALIASES = {
   codex: ['CODEX_MODEL', 'OPENCLAW_MODEL'],
 };
 
+/**
+ * Wrap an adapter's `_channelProcesses` so registering a child for a turn that
+ * was already stopped kills it at once (see `_onProcessRegistered`).
+ */
+function watchProcessRegistry(adapter, registry) {
+  if (!registry || typeof registry !== 'object') return registry;
+  return new Proxy(registry, {
+    set(target, key, value) {
+      target[key] = value;
+      if (typeof key === 'string') adapter._onProcessRegistered(key, value);
+      return true;
+    },
+  });
+}
+
 class BaseAdapter {
+  get _channelProcesses() {
+    return this.__channelProcesses;
+  }
+
+  set _channelProcesses(registry) {
+    this.__channelProcesses = watchProcessRegistry(this, registry);
+  }
+
   /**
    * @param {object} opts
    * @param {string} opts.workspaceId
@@ -124,6 +147,31 @@ class BaseAdapter {
     // Per-channel task tracking for parallel execution
     this._channelBusy = new Set();
     this._channelQueues = {};
+    // Stop generations. A stop has to cancel work that is no longer IN the
+    // queue: the message a channel worker already shifted out, and anything
+    // the interrupted turn queues on its way out (Claude's todo nudge). The
+    // adapters clear `_channelQueues`, which cannot reach either — that is
+    // why one press of Stop used to report a stop and then let the agent
+    // pick straight back up, and only a second press stuck. Workers capture
+    // the generation they started under and abandon their drain loop the
+    // moment it moves.
+    this._stopGeneration = 0;
+    this._channelStopGeneration = {};
+    // The generation a channel's in-flight message started under, so an
+    // adapter can tell "a stop landed while I was preparing this turn" from
+    // "this turn started after the stop and is meant to run".
+    this._channelRunGeneration = {};
+    // Channels a user stopped whose next turn has not started yet. Everything
+    // the send* helpers would post there is dropped: output a killed run was
+    // still flushing lands after the stop notice otherwise, and the workspace
+    // UI reads the latest message to decide whether the agent is running.
+    this._mutedChannels = new Set();
+    // Channels whose current stop has been announced, so the control handler
+    // and an in-flight turn racing to report the same stop post it once.
+    this._stopNoticeSent = new Set();
+    // Channels being torn down by a stop. Adapters read it from their exit
+    // handlers to tell a user stop from a crash.
+    this._stoppingChannels = new Set();
     // Cached workspace.browser_enabled. Populated lazily on first read so we
     // don't pay an HTTP roundtrip per message — adapters that toggle the
     // workspace flag must reconnect/restart to pick up the change (matches
@@ -471,6 +519,11 @@ class BaseAdapter {
             this._mode = newMode;
             this._log(`Mode changed: ${oldMode} -> ${newMode}`);
           }
+        } else if (action === 'stop') {
+          // Handled here for every adapter, never by an override: a stop has
+          // to stay inside the channel it names, and each adapter used to
+          // decide that for itself — several stopped every channel.
+          await this._handleUserStop(payload.channel || null);
         } else {
           await this._onControlAction(action, payload);
         }
@@ -478,6 +531,212 @@ class BaseAdapter {
     } catch {}
   }
 
+  /**
+   * Record a user stop for `channel` — or for every channel when it is null,
+   * which is how a workspace-wide stop arrives — and drop what is still
+   * queued there. A stop ends the queued work; it does not defer it.
+   */
+  _markStopRequested(channel) {
+    if (channel) {
+      this._channelStopGeneration[channel] = (this._channelStopGeneration[channel] || 0) + 1;
+      delete this._channelQueues[channel];
+    } else {
+      this._stopGeneration++;
+      this._channelQueues = {};
+    }
+  }
+
+  /** Stop generation for one channel; a channel-less stop counts for all. */
+  _stopGenerationFor(channel) {
+    return `${this._stopGeneration}:${this._channelStopGeneration[channel] || 0}`;
+  }
+
+  /**
+   * True when a stop landed after the worker handed this channel its current
+   * message. Adapters call this at their point of no return — the checks in
+   * `_channelWorker` cover the queue, but `_handleMessage` then spends
+   * several more HTTP round trips (session lookup, thinking status, pinned
+   * knowledge, channel recap) before the CLI is touched, and a stop landing
+   * inside those otherwise still reaches it.
+   */
+  _stopRequestedDuringTurn(channel) {
+    const started = this._channelRunGeneration[channel];
+    return started !== undefined && this._stopGenerationFor(channel) !== started;
+  }
+
+  /**
+   * Stop what a user asked to stop, and nothing else.
+   *
+   * `channel` is the thread the Stop button was pressed in; the workspace
+   * sends it for every participant agent. Only that channel's work is
+   * touched — the same agent running in another thread carries on. A null
+   * channel is the workspace-wide "stop everything" path.
+   *
+   * Order matters, and all of it is here so no adapter can get it wrong:
+   *   1. record the stop and mute the channel before the first await, so
+   *      workers and output parsers running during the teardown see it;
+   *   2. let the adapter stop its work for that channel;
+   *   3. cancel the stopped plan's todos (that posts the updated list);
+   *   4. announce the stop last — the UI reads the latest message.
+   */
+  async _handleUserStop(channel) {
+    const channels = channel ? [channel] : this._channelsWithWork();
+    // A repeat stop for a thread that has not started a new turn since its
+    // last stop — the workspace client re-sends Stop after 3s while it still
+    // shows "Stopping…" — has nothing new to cancel. Moving the generation
+    // again would only discard what the user typed after the first press.
+    const repeat = !!channel && this._mutedChannels.has(channel);
+    if (!repeat) this._markStopRequested(channel);
+    for (const ch of channels) {
+      this._mutedChannels.add(ch);
+      this._stoppingChannels.add(ch);
+    }
+    if (!channel) {
+      try { await this._stopSharedWork(); } catch (e) {
+        this._log(`Stop: shared work did not stop cleanly: ${e && e.message ? e.message : e}`);
+      }
+    }
+    for (const ch of channels) {
+      let outcome;
+      try {
+        outcome = await this._stopChannelWork(ch);
+      } catch (e) {
+        this._log(`Stop: ${ch} did not stop cleanly: ${e && e.message ? e.message : e}`);
+        outcome = 'failed';
+      }
+      // The pressed channel is always answered, so its UI settles even when
+      // the agent had nothing running there. A workspace-wide stop only
+      // speaks where it actually stopped something.
+      if (outcome === 'idle' && ch !== channel) continue;
+      await this._finishUserStop(ch, outcome === 'failed' ? 'failed' : 'stopped');
+    }
+  }
+
+  /**
+   * Channels with work a workspace-wide stop should end. Adapters that track
+   * runs somewhere other than `_channelProcesses` extend this.
+   */
+  _channelsWithWork() {
+    return [...new Set([...this._channelBusy, ...Object.keys(this._channelProcesses || {})])];
+  }
+
+  /**
+   * Stop this adapter's work for ONE channel. Returns 'stopped' when
+   * something was running, 'idle' when nothing was, 'failed' when the run
+   * could not be confirmed dead. Must never touch another channel.
+   *
+   * The default covers every adapter that registers one child process per
+   * channel in `_channelProcesses` and kills it with `_stopProcess`.
+   * Adapters with other kinds of work (persistent processes, sockets, open
+   * HTTP requests) override it, and call super for their child processes.
+   */
+  async _stopChannelWork(channel) {
+    const procs = this._channelProcesses || {};
+    const proc = procs[channel];
+    if (!proc) return this._channelBusy.has(channel) ? 'stopped' : 'idle';
+    this._log(`Stopping process for channel=${channel}`);
+    const ended = typeof this._stopProcess === 'function'
+      ? await this._stopProcess(proc)
+      : undefined;
+    delete procs[channel];
+    // `_stopProcess` implementations that can tell return false for a kill
+    // they could not confirm; the rest return nothing.
+    return ended === false ? 'failed' : 'stopped';
+  }
+
+  /** Work shared by every channel, ended only by a workspace-wide stop. */
+  async _stopSharedWork() {}
+
+  /**
+   * Close out a stopped channel: cancel its plan, then say so. Deduped per
+   * channel until its next turn starts.
+   */
+  async _finishUserStop(channel, outcome = 'stopped') {
+    if (!channel || this._stopNoticeSent.has(channel)) return;
+    this._stopNoticeSent.add(channel);
+    await this.cleanupTodos(channel);
+    await this._announceUserStop(channel, outcome);
+  }
+
+  /**
+   * Post the stop notice. Bypasses the mute on purpose — it is the one
+   * message a stopped channel is meant to get.
+   *
+   * A plain message rather than a `status`: the workspace UI folds statuses
+   * into the collapsed step list, and the user has to see that the stop took.
+   * No `status_kind` either, which would push it as "<agent> finished".
+   * Both wordings match the client's terminal-status regex
+   * (/stopped|stopping failed/i).
+   */
+  async _announceUserStop(channel, outcome) {
+    const content = this._stopNoticeText(outcome);
+    try {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+        senderType: 'agent',
+        senderName: this.agentName,
+        metadata: { agent_mode: this._mode, stop_notice: true },
+        sessionId: this._sessionId,
+      });
+    } catch (e) {
+      if (e instanceof SessionRevokedError) this._onSessionRevoked();
+    }
+  }
+
+  /**
+   * The words of the stop notice. Override to tell the user something more
+   * specific — both must keep matching /stopped|stopping failed/i.
+   */
+  _stopNoticeText(outcome) {
+    return outcome === 'failed'
+      ? (this._stopFailedMessage || 'Stopping failed — the agent process did not exit and may still be running.')
+      : 'Execution stopped by user.';
+  }
+
+  /**
+   * The check every adapter makes right before it starts its CLI, sends a
+   * prompt, or opens a model request: did the user stop this turn while it
+   * was still being prepared? Preparing takes several round trips (session
+   * lookup, status post, pinned knowledge, recap), and a run started after
+   * the stop spends tokens on an answer nobody will see.
+   *
+   * Returns true when the caller must give up without starting anything. The
+   * stop has already been announced by `_handleUserStop`. The channel is
+   * (re)marked as stopping because several adapters clear that flag only
+   * after their own first await, which can run after the stop landed.
+   */
+  _stoppedBeforeStart(channel) {
+    if (!this._stopRequestedDuringTurn(channel)) return false;
+    this._stoppingChannels.add(channel);
+    this._log(`Stop landed while preparing ${channel} — not starting the run`);
+    return true;
+  }
+
+  /**
+   * Last line of defence behind `_stoppedBeforeStart`: a child registered in
+   * `_channelProcesses` for a turn that was stopped while it was being
+   * prepared is killed on the spot, before it can reach the model. Covers any
+   * adapter that misses the explicit check, including ones added later.
+   */
+  _onProcessRegistered(channel, proc) {
+    if (!proc || typeof proc !== 'object' || typeof proc.on !== 'function') return;
+    if (!this._stopRequestedDuringTurn(channel)) return;
+    this._stoppingChannels.add(channel);
+    this._log(`Stop landed before ${channel}'s run registered — killing it`);
+    const kill = typeof this._stopProcess === 'function'
+      ? this._stopProcess(proc)
+      : Promise.resolve(proc.kill && proc.kill('SIGTERM'));
+    Promise.resolve(kill).catch(() => {}).finally(() => {
+      if (this._channelProcesses && this._channelProcesses[channel] === proc) {
+        delete this._channelProcesses[channel];
+      }
+    });
+  }
+
+  /** True while a stopped channel is waiting for its next turn. */
+  _isMuted(channel) {
+    return !!channel && this._mutedChannels.has(channel);
+  }
+
   /**
    * Handle adapter-specific control actions. Override in subclasses to add
    * per-adapter actions (`stop`, `restart`, …); always call
@@ -486,7 +745,9 @@ class BaseAdapter {
    * working uniformly across adapter types.
    */
   async _onControlAction(action, payload) {
-    if (action === 'status') {
+    if (action === 'stop') {
+      await this._handleUserStop((payload && payload.channel) || null);
+    } else if (action === 'status') {
       await this._postStatusReport(payload);
     } else if (action === 'routines') {
       await this._postRoutinesReport(payload);
@@ -924,6 +1185,7 @@ class BaseAdapter {
       if (!this._channelQueues[channel]) this._channelQueues[channel] = [];
       const queueId = `q-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
       msg._queueId = queueId;
+      msg._acceptedGeneration = this._stopGenerationFor(channel);
       this._channelQueues[channel].push(msg);
       try {
         await this.sendStatus(channel, 'message queued — will process after current task', {
@@ -934,6 +1196,10 @@ class BaseAdapter {
       return;
     }
 
+    // A message belongs to the stop generation it arrived in. One accepted
+    // before a stop never runs after it; one that arrives after the stop — the
+    // user typing again while the stopped run is still winding down — does.
+    msg._acceptedGeneration = this._stopGenerationFor(channel);
     // Run channel worker (don't await — parallel execution)
     this._channelWorker(channel, msg);
     this._wakeControlPoller();
@@ -951,31 +1217,48 @@ class BaseAdapter {
 
   async _channelWorker(channel, msg) {
     this._channelBusy.add(channel);
-    try {
-      await this._prefetchPinnedContext(channel);
-      await this._handleMessage(msg);
-    } catch (e) {
-      this._log(`Error in channel worker for ${channel}: ${e.message}`);
-      try { await this.sendError(channel, `Agent error: ${e.message}`); } catch {}
-    }
-
-    // Drain queue
-    while (true) {
-      const queue = this._channelQueues[channel];
-      if (!queue || queue.length === 0) break;
-      const nextMsg = queue.shift();
-      if (nextMsg._queueId) {
-        try { await this.sendStatus(channel, 'processing queued message', { queue_id: nextMsg._queueId, queue_status: 'processed' }); } catch {}
-      }
+    // Messages an adapter queues for itself (Claude's todo nudge) carry no
+    // generation; they belong to the turn that queued them.
+    const startGeneration = msg._acceptedGeneration !== undefined
+      ? msg._acceptedGeneration
+      : this._stopGenerationFor(channel);
+    const generationOf = (m) => (m._acceptedGeneration !== undefined ? m._acceptedGeneration : startGeneration);
+    let dropped = 0;
+
+    let next = msg;
+    let first = true;
+    while (next) {
+      const current = next;
+      const generation = generationOf(current);
       try {
+        if (!first && current._queueId && generation === this._stopGenerationFor(channel)) {
+          try { await this.sendStatus(channel, 'processing queued message', { queue_id: current._queueId, queue_status: 'processed' }); } catch {}
+        }
         // Pinned entries may have changed while this message waited.
         await this._prefetchPinnedContext(channel);
-        await this._handleMessage(nextMsg);
+        // Checked after the round trips above, which a stop can land inside:
+        // a message from before the stop never reaches the CLI.
+        if (generation !== this._stopGenerationFor(channel)) {
+          dropped++;
+        } else {
+          this._channelRunGeneration[channel] = generation;
+          // A turn the user asked for after the stop speaks normally again.
+          this._mutedChannels.delete(channel);
+          this._stopNoticeSent.delete(channel);
+          this._stoppingChannels.delete(channel);
+          await this._handleMessage(current);
+        }
       } catch (e) {
-        this._log(`Error processing queued message in ${channel}: ${e.message}`);
+        this._log(`Error ${first ? 'in channel worker' : 'processing queued message'} for ${channel}: ${e.message}`);
         try { await this.sendError(channel, `Agent error: ${e.message}`); } catch {}
       }
+      delete this._channelRunGeneration[channel];
+      first = false;
+
+      const queue = this._channelQueues[channel];
+      next = queue && queue.length ? queue.shift() : null;
     }
+    if (dropped) this._log(`Stop in ${channel} — dropped ${dropped} message(s) accepted before it`);
     this._channelBusy.delete(channel);
   }
 
@@ -1201,6 +1484,7 @@ class BaseAdapter {
   // ------------------------------------------------------------------
 
   async sendStatus(channel, content, extraMeta) {
+    if (this._isMuted(channel)) return;
     try {
       await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
         senderType: 'agent',
@@ -1217,6 +1501,7 @@ class BaseAdapter {
   async sendThinking(channel, content) {
     // Skip empty thinking traces entirely.
     if (!content || !content.trim()) return;
+    if (this._isMuted(channel)) return;
     try {
       await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
         senderType: 'agent',
@@ -1242,6 +1527,7 @@ class BaseAdapter {
    * message text and fired on every bash for-loop that ended in `done`.
    */
   async sendResponse(channel, content) {
+    if (this._isMuted(channel)) return;
     try {
       await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
         senderType: 'agent',
@@ -1292,6 +1578,7 @@ class BaseAdapter {
   }
 
   async sendTodos(channel, todos) {
+    if (this._isMuted(channel)) return;
     try {
       await this.client.putTodos(this.workspaceId, channel, this.token, todos, {
         source: `openagents:${this.agentName}`,
@@ -1324,6 +1611,7 @@ class BaseAdapter {
    * sendResponse's 'completed'.
    */
   async sendError(channel, error) {
+    if (this._isMuted(channel)) return;
     try {
       await this.client.sendMessage(this.workspaceId, channel, this.token, error, {
         senderType: 'agent',

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);