@openagents-org/agent-launcher 0.2.184 → 0.2.186

package/src/adapters/gemini.js

@@ -68,12 +68,6 @@ class GeminiAdapter extends BaseAdapter {
     } catch {}
   }
 
-  async _onControlAction(action, _payload) {
-    if (action === 'stop') {
-      await this._stopAllProcesses();
-    }
-  }
-
   async _stopProcess(proc) {
     if (!proc || proc.exitCode !== null) return;
     try {
@@ -96,20 +90,6 @@ class GeminiAdapter 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 {}
-    }
-  }
-
   _findNodeBin() {
     const home = os.homedir();
     const candidates = IS_WINDOWS
@@ -316,6 +296,9 @@ class GeminiAdapter 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) {

package/src/adapters/goose.js

@@ -287,20 +287,7 @@ class GooseAdapter extends BaseAdapter {
     return redactSecrets(text, this._secrets);
   }
 
-  // -- control actions (stop) ---------------------------------------------
-
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const channel = (payload && typeof payload === 'object') ? payload.channel : null;
-      if (channel) {
-        await this._stopChannel(channel, 'Execution stopped by user.');
-      } else {
-        await this._stopAll('Execution stopped by user.');
-      }
-      return;
-    }
-    await super._onControlAction(action, payload);
-  }
+  // -- teardown -----------------------------------------------------------
 
   async _stopChannel(channel, message) {
     const proc = this._channelProcesses[channel];
@@ -490,6 +477,9 @@ class GooseAdapter extends BaseAdapter {
     this._log(`CLI: goose run --output-format stream-json --name ${sessionName}`
       + `${resume ? ' --resume' : ''} --no-profile --with-builtin developer`);
 
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) return Promise.resolve(null);
+
     return new Promise((resolve) => {
       let proc;
       try {

package/src/adapters/hermes.js

@@ -283,6 +283,8 @@ class HermesAdapter extends BaseAdapter {
   }
 
   async _runHermes(prompt, channelName) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channelName)) return '';
     const resumeId = this._channelSessions[channelName];
     const args = this._buildHermesCmd(prompt, resumeId);
     this._log(`Running hermes (profile=${this.hermesProfile}, channel=${channelName}, resume=${!!resumeId})`);
@@ -357,16 +359,6 @@ class HermesAdapter 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 {}
-      }
-    }
-  }
-
   // ------------------------------------------------------------------
   // Message handler
   // ------------------------------------------------------------------

package/src/adapters/kimi.js

@@ -199,24 +199,6 @@ class KimiAdapter extends LlmDirectAdapter {
   // ------------------------------------------------------------------
 
   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 {}
-        return;
-      }
-      if (Object.keys(this._channelProcesses).length) {
-        await this._stopAllProcesses('Execution stopped by user.');
-        return;
-      }
-      // No CLI runs in flight — fall through to the direct-API stop.
-      await super._onControlAction(action, payload);
-      return;
-    }
     if (action === 'restart') {
       const channel = (payload && typeof payload === 'object') ? payload.channel : null;
       if (channel) {
@@ -685,6 +667,8 @@ class KimiAdapter extends LlmDirectAdapter {
    * `timedOutMs` is non-zero when the idle watchdog stopped the run.
    */
   _runKimi(channel, kimiBin, args, workingDir) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) return Promise.resolve({ userStopped: true });
     const { env: cleanEnv } = buildKimiEnv(this.agentEnv || process.env);
     const [cmd, ...spawnArgs] = this._spawnableCmd(kimiBin, args);
     // Before the spawn, so the session this run creates shows up as new.

package/src/adapters/llm-direct.js

@@ -62,13 +62,21 @@ class LlmDirectAdapter extends BaseAdapter {
     this._activeRequests.clear();
   }
 
-  async _onControlAction(action, _payload) {
-    if (action === 'stop') {
-      for (const req of this._activeRequests) {
-        try { req.destroy(new Error('LLM API request stopped')); } catch {}
-      }
-      this._activeRequests.clear();
+  /**
+   * A stop ends this channel's open completion requests, and only those —
+   * the same agent may be answering in another thread. Subclasses that also
+   * run child processes (kimi) get those stopped by super.
+   */
+  async _stopChannelWork(channel) {
+    let aborted = 0;
+    for (const req of this._activeRequests) {
+      if (req._oaChannel !== channel) continue;
+      try { req.destroy(new Error('LLM API request stopped')); } catch {}
+      this._activeRequests.delete(req);
+      aborted++;
     }
+    const processes = await super._stopChannelWork(channel);
+    return aborted && processes === 'idle' ? 'stopped' : processes;
   }
 
   /** The model this runner actually calls with — see `_model` above. */
@@ -114,6 +122,8 @@ class LlmDirectAdapter extends BaseAdapter {
         return;
       }
 
+      // Stopped while this turn was being prepared: start nothing (no tokens).
+      if (this._stoppedBeforeStart(msgChannel)) return;
       const responseText = await this._callCompletionApi(content, msgChannel);
 
       if (responseText) {
@@ -205,6 +215,7 @@ class LlmDirectAdapter extends BaseAdapter {
         });
       });
 
+      req._oaChannel = channel;
       this._activeRequests.add(req);
       req.on('error', (err) => {
         this._activeRequests.delete(req);

package/src/adapters/mini.js

@@ -297,22 +297,9 @@ class MiniSweAgentAdapter 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;
-    }
-    await super._onControlAction(action, payload);
-  }
-
   async _stopProcess(proc) {
     if (!proc || proc.exitCode !== null) return;
     try {
@@ -460,6 +447,8 @@ class MiniSweAgentAdapter extends BaseAdapter {
   }
 
   _spawnMini(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/nanoclaw.js

@@ -248,6 +248,12 @@ class NanoClawAdapter extends BaseAdapter {
     await this._autoTitleChannel(channel, content);
     await this.sendStatus(channel, 'thinking...');
 
+    // Stopped while this turn was being prepared: inject nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) {
+      if (this._activeTurn.get(channel) === turnId) this._activeTurn.delete(channel);
+      return;
+    }
+
     // Inject and await the turn.
     this._injectedIds.add(msgId);
     let injected = false;
@@ -278,14 +284,25 @@ class NanoClawAdapter extends BaseAdapter {
   // never kills the Agent Group, the NanoClaw host, or any shared container.
   // ------------------------------------------------------------------
 
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const ch = payload && (payload.channel || payload.sessionId || payload.session);
-      if (ch) this._detachChannel(String(ch));
-      else for (const c of this._activeChannels()) this._detachChannel(c);
-      return;
-    }
-    await super._onControlAction(action, payload);
+  // BaseAdapter._handleUserStop drives these. A named channel is always
+  // detached (its epoch moves even if nothing was in flight), matching what
+  // the stop meant here before it moved into the base class.
+  async _stopChannelWork(channel) {
+    const wasActive = this._activeTurn.has(channel)
+      || this._pending.has(proto.platformIdFor(this.workspaceId, channel));
+    this._detachChannel(channel);
+    return wasActive ? 'stopped' : 'idle';
+  }
+
+  _channelsWithWork() {
+    return [...new Set([...super._channelsWithWork(), ...this._activeChannels()])];
+  }
+
+  /** The container task is not cancelled, only let go of — say so. */
+  _stopNoticeText(outcome) {
+    if (outcome === 'failed') return super._stopNoticeText(outcome);
+    return 'Stopped \u2014 replies from the previous task are dropped; a new message starts a fresh '
+      + 'NanoClaw session. The previous task may keep running in the background.';
   }
 
   _activeChannels() {
@@ -329,11 +346,6 @@ class NanoClawAdapter extends BaseAdapter {
     const state = this._pending.get(platformId);
     if (state && state.settle) state.settle({ detached: true });
     if (this._bridge) this._bridge.sendCancel(platformId, null); // best-effort notify
-    this.sendStatus(
-      channel,
-      'Stopped — replies from the previous task are dropped; a new message starts a fresh NanoClaw session. The previous task may keep running in the background.',
-      { nanoclaw_state: 'detached' },
-    ).catch(() => {});
   }
 
   /** A queued NanoClaw reply was dropped (overflow / expiry / corrupt) — surface it. */

package/src/adapters/openclaw.js

@@ -41,6 +41,9 @@ class OpenClawAdapter extends BaseAdapter {
     super(opts);
     this.openclawAgentId = opts.openclawAgentId || 'main';
     this.disabledModules = opts.disabledModules || new Set();
+    // channel → the `openclaw agent` run in flight, so a stop can end it
+    // instead of letting it spend tokens until it finishes on its own.
+    this._channelProcesses = {};
 
     // Find the openclaw binary — always use CLI/gateway mode for full tool support
     this._openclawBinary = this._findOpenclawBinary();
@@ -250,6 +253,7 @@ class OpenClawAdapter extends BaseAdapter {
 
     try {
       const responseText = await this._runCliAgent(content, msgChannel);
+      if (this._stoppingChannels.has(msgChannel)) return;
 
       if (responseText) {
         await this.sendResponse(msgChannel, responseText);
@@ -268,6 +272,11 @@ class OpenClawAdapter extends BaseAdapter {
 
   _runCliAgent(userMessage, channel) {
     return new Promise((resolve, reject) => {
+      // Stopped while this turn was being prepared: start nothing (no tokens).
+      if (this._stoppedBeforeStart(channel)) {
+        resolve('');
+        return;
+      }
       // Re-check binary if not found at construction time (installed after daemon started)
       if (!this._openclawBinary) {
         this._openclawBinary = this._findOpenclawBinary();
@@ -383,8 +392,14 @@ class OpenClawAdapter extends BaseAdapter {
         env: spawnEnv,
         cwd: this.workingDir || process.env.HOME || '/',
         timeout: 600000,
+        // Its own process group, so a stop reaches the tools it started too.
+        detached: !IS_WINDOWS,
         windowsHide: true,
       });
+      this._channelProcesses[channel] = proc;
+      const unregister = () => {
+        if (this._channelProcesses[channel] === proc) delete this._channelProcesses[channel];
+      };
       if (proc.stdout) proc.stdout.on('data', (d) => { output += d; });
 
       // Poll stderr file every 500ms for tool events
@@ -423,6 +438,7 @@ class OpenClawAdapter extends BaseAdapter {
       }, 600000);
 
       proc.on('error', (err) => {
+        unregister();
         if (settled) return;
         settled = true;
         clearInterval(pollInterval);
@@ -432,6 +448,7 @@ class OpenClawAdapter extends BaseAdapter {
         reject(err);
       });
       proc.on('exit', (code) => {
+        unregister();
         if (settled) return;
         settled = true;
         clearInterval(pollInterval);
@@ -457,6 +474,11 @@ class OpenClawAdapter extends BaseAdapter {
         const hasPayloads = allOutput.includes('"payloads"');
         this._log(`CLI parse: hasPayloads=${hasPayloads}, total=${allOutput.length}b`);
 
+        // Killed by a user stop: the stop has been announced, nothing to report.
+        if (this._stoppingChannels.has(channel)) {
+          resolve('');
+          return;
+        }
         if (code !== 0) {
           reject(new Error(`CLI exited ${code}: ${allOutput.slice(-300)}`));
           return;
@@ -466,6 +488,25 @@ class OpenClawAdapter extends BaseAdapter {
     });
   }
 
+  /** End a run and everything it started (BaseAdapter._stopChannelWork calls this). */
+  async _stopProcess(proc) {
+    if (!proc || proc.exitCode !== null) return;
+    try {
+      if (IS_WINDOWS) {
+        try { execSync(`taskkill /F /T /PID ${proc.pid}`, { timeout: 5000 }); } catch {}
+        return;
+      }
+      try { process.kill(-proc.pid, 'SIGTERM'); } catch { proc.kill('SIGTERM'); }
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          try { process.kill(-proc.pid, 'SIGKILL'); } catch { proc.kill('SIGKILL'); }
+          resolve();
+        }, 5000);
+        proc.on('exit', () => { clearTimeout(timeout); resolve(); });
+      });
+    } catch {}
+  }
+
   _parseCliOutput(output, resolve) {
     const text = output.trim();
     if (!text) { resolve(''); return; }

package/src/adapters/opencode.js

@@ -27,8 +27,10 @@ const { whichBinary, whereBinary, getEnhancedEnv } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
 
-// Max wall-clock for a single `opencode run`. When it fires, Node kills the
-// child with SIGTERM, the 'close' handler sees signal='SIGTERM' / code=null.
+// Max time an `opencode run` may stay completely silent. This is deliberately
+// an IDLE timeout, not a wall-clock cap: long coding tasks routinely exceed
+// five minutes while continuing to emit text/tool events. A fixed spawn
+// timeout killed those healthy runs midway through their answer.
 const TIMEOUT_MS = 300000; // 5 minutes
 
 // Pinned OpenCode CLI version. Do NOT use @latest anywhere (registry.json /
@@ -158,6 +160,34 @@ class OpenCodeAdapter extends BaseAdapter {
   }
 
   /** Environment the CLI is spawned with. */
+
+  /** Test seam for the inactivity watchdog. */
+  _runTimeoutMs() {
+    return TIMEOUT_MS;
+  }
+
+  /**
+   * Arm a watchdog that expires only after a continuous period without CLI
+   * output. Every stdout/stderr chunk proves the process is still making
+   * progress and pushes the deadline out again.
+   */
+  _createIdleWatchdog(onTimeout) {
+    const timeoutMs = this._runTimeoutMs();
+    let timer = null;
+    let stopped = false;
+    const touch = () => {
+      if (stopped) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(onTimeout, timeoutMs);
+    };
+    const cancel = () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+      timer = null;
+    };
+    touch();
+    return { touch, cancel, timeoutMs };
+  }
   _spawnEnv() {
     return { ...(this.agentEnv || process.env) };
   }
@@ -237,32 +267,6 @@ class OpenCodeAdapter extends BaseAdapter {
     return path.join(this.agentHome, `sessions-${slug}.json`);
   }
 
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const channel = (payload && typeof payload === 'object') ? payload.channel : null;
-      if (channel) {
-        const proc = this._channelProcesses[channel];
-        const hadQueuedWork = !!this._channelQueues[channel]?.length;
-        if (proc) {
-          this._log(`Stopping process for channel=${channel}`);
-          this._stoppingChannels.add(channel);
-          await this._stopProcess(proc);
-          delete this._channelProcesses[channel];
-        }
-        delete this._channelQueues[channel];
-        if (proc || hadQueuedWork) {
-          try {
-            await this.sendResponse(channel, 'Execution stopped by user.');
-          } catch {}
-        }
-      } else {
-        await this._stopAllProcesses('Execution stopped by user.');
-      }
-      return;
-    }
-    await super._onControlAction(action, payload);
-  }
-
   /**
    * Write workspace skill to OpenCode's skill directory for auto-discovery.
    */
@@ -727,8 +731,8 @@ class OpenCodeAdapter extends BaseAdapter {
    * CRITICAL: opencode-ai does NOT read the OPENCODE_MODEL env var. When no
    * model is given on the command line AND none is set in opencode.json, the
    * non-interactive `run` command hangs forever waiting for interactive
-   * provider/model selection — it emits zero output until the spawn timeout
-   * kills it with SIGTERM (surfaced as the misleading "exited with code null").
+   * provider/model selection — it emits zero output until the inactivity
+   * watchdog kills it with SIGTERM.
    * Passing `--model` explicitly is what makes headless runs actually work.
    */
   _resolveModel() {
@@ -861,12 +865,14 @@ class OpenCodeAdapter extends BaseAdapter {
       spawnBinary = process.env.COMSPEC || 'cmd.exe';
     }
 
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(msgChannel)) return Promise.resolve('');
+
     return new Promise((resolve, reject) => {
       const proc = spawn(spawnBinary, spawnArgs, {
         stdio: ['pipe', 'pipe', 'pipe'],
         env: spawnEnv,
         cwd: runCwd,
-        timeout: TIMEOUT_MS,
         detached: !IS_WINDOWS,
         // Never let a console window appear. Besides being ugly, an attached
         // console makes opencode start its interactive TUI and hang instead of
@@ -882,9 +888,16 @@ class OpenCodeAdapter extends BaseAdapter {
       let pendingEvents = Promise.resolve();
       const responseState = { finalText: '', allText: '', seenText: false };
       let settled = false;
+      let timedOut = false;
+      const watchdog = this._createIdleWatchdog(() => {
+        timedOut = true;
+        this._log(`opencode idle for ${this._runTimeoutMs() / 1000}s; terminating`);
+        this._stopProcess(proc).catch(() => {});
+      });
       const finish = (fn, arg) => {
         if (settled) return;
         settled = true;
+        watchdog.cancel();
         if (this._channelProcesses[msgChannel] === proc) {
           delete this._channelProcesses[msgChannel];
         }
@@ -893,6 +906,7 @@ class OpenCodeAdapter extends BaseAdapter {
 
       if (proc.stdout) {
         proc.stdout.on('data', (d) => {
+          watchdog.touch();
           const chunk = d.toString('utf-8');
           stdout += chunk;
           streamBuffer += chunk;
@@ -905,7 +919,10 @@ class OpenCodeAdapter extends BaseAdapter {
           }
         });
       }
-      if (proc.stderr) proc.stderr.on('data', (d) => { stderr += d; });
+      if (proc.stderr) proc.stderr.on('data', (d) => {
+        watchdog.touch();
+        stderr += d;
+      });
 
       // Send the prompt via stdin, then close it so opencode knows the message
       // is complete and never blocks waiting for more input. Guard the write:
@@ -920,9 +937,8 @@ class OpenCodeAdapter extends BaseAdapter {
 
       proc.on('error', (err) => finish(reject, err));
       // 'close' (not 'exit') fires after stdout/stderr have fully drained, so we
-      // never parse a truncated response. The handler receives (code, signal):
-      // when the spawn timeout kills the child, code is null and signal is the
-      // signal name — report that as a timeout rather than "exited with code null".
+      // never parse a truncated response. The explicit `timedOut` flag keeps a
+      // watchdog termination distinct from an external signal or crash.
       proc.on('close', async (code, signal) => {
         try { await pendingEvents; } catch {}
 
@@ -940,14 +956,18 @@ class OpenCodeAdapter extends BaseAdapter {
         // because stderr happened to be empty.
         const stdoutErr = OpenCodeAdapter._extractErrorFromStdout(stdout);
 
-        if (signal) {
-          this._log(`opencode killed by signal ${signal} after ${TIMEOUT_MS / 1000}s (output: ${!!stdout})`);
+        if (timedOut) {
+          this._log(`opencode timed out after ${watchdog.timeoutMs / 1000}s idle (output: ${!!stdout})`);
           const cls = this.constructor._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
-          // A signal almost always means our own timeout fired; only override to
-          // a more specific provider error if stdout/stderr clearly show one.
           const category = (cls.category === 'unknown_error' || cls.category === 'process_crashed')
             ? 'timeout' : cls.category;
-          return finish(reject, this._failure(category, cls.diagnostic || `signal=${signal}`, cls.detail));
+          return finish(reject, this._failure(category, cls.diagnostic || `idle=${watchdog.timeoutMs}ms`, cls.detail));
+        }
+
+        if (signal) {
+          this._log(`opencode killed by signal ${signal} (output: ${!!stdout})`);
+          const cls = this.constructor._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
+          return finish(reject, this._failure(cls.category, cls.diagnostic || `signal=${signal}`, cls.detail));
         }
 
         if (code !== 0) {
@@ -1177,6 +1197,8 @@ class OpenCodeAdapter extends BaseAdapter {
    * normal reply. Carries `error_category` in metadata so the UI can route it.
    */
   async _sendClassifiedError(channel, category, detail) {
+    // A run the user stopped reads as "stopped mid-task"; it is not an error.
+    if (this._isMuted(channel)) return;
     const messages = this._failureMessages();
     const base = messages[category] || messages.unknown_error;
     const safe = detail ? OpenCodeAdapter._redact(detail).trim() : '';

package/src/adapters/openworker.js

@@ -98,7 +98,6 @@ const SERVER_READY_TIMEOUT_MS = 90000;
 const HEALTH_POLL_INTERVAL_MS = 400;
 
 // Max wall-clock for one turn, after which we interrupt and report it.
-const TURN_TIMEOUT_MS = 900000; // 15 minutes
 
 // Idle watchdog over the event stream, in the same shape the CLI adapters use.
 const WATCHDOG_INTERVAL_MS = 15000;
@@ -536,28 +535,26 @@ class OpenWorkerAdapter extends BaseAdapter {
   }
 
   // ------------------------------------------------------------------
-  // Control actions (stop / restart)
+  // Stop / shutdown
   // ------------------------------------------------------------------
 
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const channel = (payload && payload.channel) || null;
-      if (channel) {
-        await this._stopChannel(channel, 'Execution stopped.');
-        return;
-      }
-      await this._stopAllChannels();
-      return;
-    }
-    return super._onControlAction(action, payload);
-  }
-
   stop() {
     super.stop();
     this._serverStopped = true;
     void this._stopAllChannels('Agent stopped.').finally(() => this._stopServer());
   }
 
+  /** A turn here is a socket to the engine, not a child process. */
+  async _stopChannelWork(channel) {
+    if (!this._channelSockets[channel]) return super._stopChannelWork(channel);
+    await this._stopChannel(channel, null);
+    return 'stopped';
+  }
+
+  _channelsWithWork() {
+    return [...new Set([...super._channelsWithWork(), ...Object.keys(this._channelSockets)])];
+  }
+
   async _stopChannel(channel, message) {
     const socket = this._channelSockets[channel];
     if (!socket) return;
@@ -637,6 +634,10 @@ class OpenWorkerAdapter extends BaseAdapter {
    * @returns {Promise<object>} { texts, error, interrupted, userStopped, sent }
    */
   _runTurn(channel, server, sessionId, workingDir, text, { planMode, model }) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) {
+      return Promise.resolve({ texts: [], error: null, interrupted: false, userStopped: true, sent: false });
+    }
     return new Promise((resolve) => {
       const url = sessionUrl({
         port: server.port,
@@ -672,7 +673,6 @@ class OpenWorkerAdapter extends BaseAdapter {
         if (settled) return;
         settled = true;
         clearInterval(watchdog);
-        clearTimeout(timeout);
         if (this._channelSockets[channel] === socket) delete this._channelSockets[channel];
         try { socket.close(); } catch {}
         const userStopped = this._stoppingChannels.has(channel);
@@ -686,6 +686,11 @@ class OpenWorkerAdapter extends BaseAdapter {
 
       const sendTurn = () => {
         if (sentMessage) return;
+        // The handshake takes a moment; a stop inside it still sends nothing.
+        if (this._stoppedBeforeStart(channel)) {
+          finish({});
+          return;
+        }
         sentMessage = true;
         // Anything observed before this point belongs to the turn we cleared out
         // of the way (see the `ready.running` branch), not to ours — carrying it
@@ -814,12 +819,6 @@ class OpenWorkerAdapter extends BaseAdapter {
         }
       }, WATCHDOG_INTERVAL_MS);
 
-      const timeout = setTimeout(() => {
-        this._log(`Turn exceeded ${TURN_TIMEOUT_MS}ms — interrupting`);
-        send({ type: 'interrupt' });
-        if (!error) error = 'The turn ran past its time limit and was stopped.';
-        finish({});
-      }, TURN_TIMEOUT_MS);
     });
   }