@openagents-org/agent-launcher 0.2.184 → 0.2.185

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.184",
+  "version": "0.2.185",
   "description": "OpenAgents Launcher — install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/src/adapters/aider.js

@@ -407,15 +407,6 @@ class AiderAdapter extends BaseAdapter {
   // ------------------------------------------------------------------
 
   async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      for (const [channel, proc] of Object.entries(this._channelProcesses)) {
-        this._stoppingChannels.add(channel);
-        await this._stopProcess(proc);
-        delete this._channelProcesses[channel];
-        try { await this.sendStatus(channel, 'Execution stopped by user'); } catch {}
-      }
-      return;
-    }
     if (action === 'reset_session' || action === 'clear_session') {
       const channel = (payload && payload.channel) || this.channelName;
       this.resetChannelSession(channel);
@@ -531,6 +522,8 @@ class AiderAdapter extends BaseAdapter {
   }
 
   _spawnAider(cmd, msgChannel) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(msgChannel)) return Promise.resolve({ text: '', error: null });
     return new Promise((resolve, reject) => {
       const env = this._buildSubprocessEnv();
 

package/src/adapters/amp.js

@@ -204,23 +204,9 @@ class AmpAdapter extends BaseAdapter {
   }
 
   // ------------------------------------------------------------------
-  // Control actions (stop)
+  // Process teardown (BaseAdapter._stopChannelWork calls _stopProcess)
   // ------------------------------------------------------------------
 
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      for (const [channel, proc] of Object.entries(this._channelProcesses)) {
-        this._stoppingChannels.add(channel);
-        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/uninstall).
-    await super._onControlAction(action, payload);
-  }
-
   async _stopProcess(proc) {
     if (!proc || proc.exitCode !== null) return;
     try {
@@ -354,6 +340,8 @@ class AmpAdapter extends BaseAdapter {
   }
 
   async _spawnAmp(cmd, prompt, msgChannel) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(msgChannel)) return { text: '', stale: false };
     return new Promise((resolve, reject) => {
       // Pass the agent env with an enhanced PATH (nvm/fnm/volta/homebrew,
       // ~/.local/bin, ~/.amp/bin) so the amp subprocess and any tools it shells

package/src/adapters/antigravity.js

@@ -80,12 +80,6 @@ class AntigravityAdapter extends BaseAdapter {
     } catch {}
   }
 
-  async _onControlAction(action, _payload) {
-    if (action === 'stop') {
-      await this._stopAllProcesses();
-    }
-  }
-
   async _stopProcess(proc) {
     if (!proc || proc.exitCode !== null) return;
     try {
@@ -108,20 +102,6 @@ class AntigravityAdapter extends BaseAdapter {
     } catch {}
   }
 
-  async _stopAllProcesses() {
-    const entries = Object.entries(this._channelProcesses);
-    if (!entries.length) return;
-    this._log(`Stopping ${entries.length} running process(es)...`);
-    for (const [channel, proc] of entries) {
-      await this._stopProcess(proc);
-      delete this._channelProcesses[channel];
-      delete this._channelQueues[channel];
-      try {
-        await this.sendStatus(channel, 'Execution stopped by user');
-      } catch {}
-    }
-  }
-
   _findAgyBinary() {
     // PATH first (codepage-safe lookup, see whereBinary), then the install
     // script's fixed destinations.
@@ -258,6 +238,9 @@ class AntigravityAdapter extends BaseAdapter {
         return;
       }
 
+      // Stopped while this turn was being prepared: start nothing (no tokens).
+      if (this._stoppedBeforeStart(msgChannel)) return;
+
       try {
         const proc = spawn(cmd[0], cmd.slice(1), {
           stdio: ['ignore', 'pipe', 'pipe'],

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',