@openagents-org/agent-launcher 0.2.183 → 0.2.185

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/index.js

@@ -26,6 +26,7 @@ const AntigravityAdapter = require('./antigravity');
 const CommandCodeAdapter = require('./commandcode');
 const OpenWorkerAdapter = require('./openworker');
 const CodeBuddyAdapter = require('./codebuddy');
+const CodeArtsAdapter = require('./codearts');
 
 const ADAPTER_MAP = {
   openclaw: OpenClawAdapter,
@@ -49,11 +50,12 @@ const ADAPTER_MAP = {
   commandcode: CommandCodeAdapter,
   openworker: OpenWorkerAdapter,
   codebuddy: CodeBuddyAdapter,
+  codearts: CodeArtsAdapter,
 };
 
 /**
  * Create an adapter instance for the given agent type.
- * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp, mini-swe-agent, pi, deepseek, antigravity, commandcode, openworker, codebuddy)
+ * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp, mini-swe-agent, pi, deepseek, antigravity, commandcode, openworker, codebuddy, codearts)
  * @param {object} opts - Adapter constructor options
  * @returns {BaseAdapter}
  */
@@ -87,6 +89,7 @@ module.exports = {
   AntigravityAdapter,
   CommandCodeAdapter,
   OpenWorkerAdapter,
+  CodeArtsAdapter,
   createAdapter,
   ADAPTER_MAP,
 };

package/src/adapters/kimi-stream.js

@@ -26,6 +26,8 @@
 
 'use strict';
 
+const crypto = require('crypto');
+
 // ---------------------------------------------------------------------------
 // Version / product classification
 // ---------------------------------------------------------------------------
@@ -270,6 +272,30 @@ function buildKimiEnv(agentEnv) {
   return { env, viaEnvProvider: true };
 }
 
+// ---------------------------------------------------------------------------
+// Session journal location
+// ---------------------------------------------------------------------------
+
+/**
+ * The directory Kimi Code CLI files a working directory's sessions under:
+ * `<KIMI_CODE_HOME>/sessions/<key>/<session id>/`. Mirrors the CLI's own
+ * `encodeWorkDirKey` (v0.42.0): `wd_` + a slug of the last path segment + `_` +
+ * the first 12 hex of sha256 over the path with `\` turned into `/` and no
+ * trailing slash. Case is kept, so `C:\Users\86177` → `wd_86177_5d6fa4a9b53d`.
+ */
+function encodeKimiWorkDirKey(workDir) {
+  const normalized = String(workDir).replace(/\\/g, '/').replace(/\/+$/, '');
+  let slug = (normalized.split('/').pop() ?? normalized)
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40)
+    .replace(/^-+|-+$/g, '');
+  if (slug === '' || slug === '.' || slug === '..') slug = 'workspace';
+  const hash = crypto.createHash('sha256').update(normalized).digest('hex').slice(0, 12);
+  return `wd_${slug}_${hash}`;
+}
+
 // ---------------------------------------------------------------------------
 // Error classification
 // ---------------------------------------------------------------------------
@@ -292,13 +318,28 @@ function extractStderrError(stderrText) {
 
 /**
  * Classify a failed run into a user-facing message.
- * @param {{code: number|null, signal: string|null, stderrText: string, retryMessage: string}} info
+ * @param {{code: number|null, signal: string|null, stderrText: string, retryMessage: string, timedOutMs?: number}} info
+ *   `timedOutMs` is set when the adapter's idle watchdog stopped the run after
+ *   that long without any sign of progress.
  * @returns {{kind: string, userMessage: string}}
  */
 function classifyKimiError(info) {
-  const { code, signal, stderrText, retryMessage } = info || {};
+  const { code, signal, stderrText, retryMessage, timedOutMs } = info || {};
   const detail = extractStderrError(stderrText) || redactSecrets(retryMessage || '');
 
+  // The watchdog's own stop wins: the signal it leaves behind (SIGINT on
+  // Windows) explains nothing, and stderr by then holds whatever tools printed.
+  if (timedOutMs) {
+    const minutes = Math.max(1, Math.round(timedOutMs / 60000));
+    return {
+      kind: 'timeout',
+      userMessage:
+        `Kimi showed no progress for about ${minutes} min and was stopped. ` +
+        'Send the request again, or break a long task into smaller steps.' +
+        (detail ? `\n\nDetails: ${detail}` : ''),
+    };
+  }
+
   if (/auth_error|401|unauthorized|invalid.{0,20}(api.?key|token)|credential/i.test(detail)) {
     return {
       kind: 'auth',
@@ -351,6 +392,7 @@ module.exports = {
   toolPreview,
   buildKimiArgs,
   buildKimiEnv,
+  encodeKimiWorkDirKey,
   extractStderrError,
   classifyKimiError,
   DEFAULT_KIMI_MODEL,

package/src/adapters/kimi.js

@@ -47,6 +47,7 @@ const {
   redactSecrets,
   classifyKimiVersion,
   classifyKimiError,
+  encodeKimiWorkDirKey,
 } = require('./kimi-stream');
 
 const IS_WINDOWS = process.platform === 'win32';
@@ -54,10 +55,13 @@ const IS_WINDOWS = process.platform === 'win32';
 const DEFAULT_BASE_URL = 'https://api.moonshot.ai/v1';
 const DEFAULT_MODEL = 'kimi-k2.6';
 
-// Idle watchdog: if stdout is silent this long while a run is in flight we
-// nudge the user; after MAX consecutive silences we kill the (possibly hung)
-// process. Kimi's provider retry backoff can reach ~1 min between attempts,
-// so the kill threshold stays generous.
+// Idle watchdog: if a run shows no sign of life this long we nudge the user;
+// after MAX consecutive silences we kill the (possibly hung) process. Sign of
+// life is any stdout or stderr, or a write to the run's session journal. The
+// journal is the only trace a subagent leaves: print mode never forwards its
+// events, so a main agent waiting on an `Agent` tool call is otherwise mute.
+// Kimi's provider retry backoff can reach ~1 min between attempts, so the kill
+// threshold stays generous.
 const WATCHDOG_INTERVAL_MS = 15_000;
 const WATCHDOG_NUDGE_AT = 2;     // ~30s of silence → "still working"
 const WATCHDOG_MAX = 20;         // ~5 min of silence → kill
@@ -67,6 +71,27 @@ const WATCHDOG_MAX = 20;         // ~5 min of silence → kill
 const VERSION_CACHE_TTL_MS = 5 * 60 * 1000;
 const _kimiVersionCache = new Map(); // binPath -> { version, product, at }
 
+/** Newest mtime (ms) of a directory and everything under it, `depth` levels deep. */
+function newestMtimeMs(dir, depth) {
+  let newest = 0;
+  let entries;
+  try {
+    newest = fs.statSync(dir).mtimeMs;
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return newest;
+  }
+  for (const entry of entries) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (depth > 0) newest = Math.max(newest, newestMtimeMs(p, depth - 1));
+    } else {
+      try { newest = Math.max(newest, fs.statSync(p).mtimeMs); } catch {}
+    }
+  }
+  return newest;
+}
+
 class KimiAdapter extends LlmDirectAdapter {
   constructor(opts) {
     super({
@@ -106,6 +131,10 @@ class KimiAdapter extends LlmDirectAdapter {
     this._channelProcesses = {};  // channel → in-flight child process
     this._stoppingChannels = new Set();
     this._loggedCliMode = false;
+    // Watchdog timings live on the instance so tests can run them in ms.
+    this._watchdogIntervalMs = WATCHDOG_INTERVAL_MS;
+    this._watchdogNudgeAt = WATCHDOG_NUDGE_AT;
+    this._watchdogMax = WATCHDOG_MAX;
     this._sessionsFile = path.join(
       os.homedir(), '.openagents', 'sessions',
       `${this.workspaceId}_${this.agentName}_kimi.json`,
@@ -170,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) {
@@ -577,8 +588,9 @@ class KimiAdapter extends LlmDirectAdapter {
       if (result.userStopped) return;
 
       // Stale-session handling: a resume that died/erred with nothing useful →
-      // clear and retry fresh once.
-      if (resumeId && !result.ok && !result.anyOutput && attempt === 0) {
+      // clear and retry fresh once. A watchdog stop is not a stale session, and
+      // retrying it would just repeat the long task.
+      if (resumeId && !result.ok && !result.anyOutput && !result.timedOutMs && attempt === 0) {
         this._log(`Resume of session ${resumeId} failed — clearing and retrying fresh`);
         this._clearSession(channel);
         continue;
@@ -598,6 +610,7 @@ class KimiAdapter extends LlmDirectAdapter {
           signal: result.exitSignal,
           stderrText: result.stderrText,
           retryMessage: result.retryMessage,
+          timedOutMs: result.timedOutMs,
         });
         try { await this.sendError(channel, userMessage); } catch {}
       } else {
@@ -611,16 +624,55 @@ class KimiAdapter extends LlmDirectAdapter {
     try { return fs.statSync(p).isDirectory(); } catch { return false; }
   }
 
+  /**
+   * Snapshot the session journals that exist before a run starts, so the
+   * watchdog can tell this run's writes from other sessions' in the same
+   * working directory. Kimi files them under
+   * <KIMI_CODE_HOME>/sessions/<workdir key>/<session id>/.
+   */
+  _watchKimiSessions(env, workingDir, args) {
+    const home = env.KIMI_CODE_HOME || path.join(os.homedir(), '.kimi-code');
+    const bucket = path.join(home, 'sessions', encodeKimiWorkDirKey(workingDir));
+    let known = [];
+    try { known = fs.readdirSync(bucket); } catch {}
+    const s = args.indexOf('-S');
+    return { bucket, known: new Set(known), resumeId: s >= 0 ? args[s + 1] : null };
+  }
+
+  /**
+   * Newest write (ms) inside this run's session journals: the resumed session,
+   * plus any session created since the run started. A second fresh run in the
+   * same directory can be counted too; that only ever keeps a run alive
+   * longer, never stops one early. 0 when there is nothing to look at.
+   */
+  _latestKimiSessionWrite(watch) {
+    let names;
+    try { names = fs.readdirSync(watch.bucket); } catch { return 0; }
+    let latest = 0;
+    for (const name of names) {
+      const resumed = !!watch.resumeId &&
+        (name === watch.resumeId || name === `session_${watch.resumeId}`);
+      if (watch.known.has(name) && !resumed) continue;
+      latest = Math.max(latest, newestMtimeMs(path.join(watch.bucket, name), 3));
+    }
+    return latest;
+  }
+
   /**
    * Spawn one `kimi -p … --output-format stream-json` run, stream-parse it,
    * and resolve a summary:
    *   { ok, finalText, sessionId, anyOutput, userStopped,
-   *     exitCode, exitSignal, stderrText, retryMessage }
-   * `ok` is exit code 0; `finalText` is the LAST assistant text of the turn.
+   *     exitCode, exitSignal, stderrText, retryMessage, timedOutMs }
+   * `ok` is exit code 0; `finalText` is the LAST assistant text of the turn;
+   * `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.
+    const sessionWatch = this._watchKimiSessions(cleanEnv, workingDir, args);
 
     this._log(`Spawning kimi in ${workingDir}: ${redactArgs([kimiBin, ...args]).join(' ')}`);
 
@@ -644,6 +696,7 @@ class KimiAdapter extends LlmDirectAdapter {
       exitSignal: null,
       stderrText: '',
       retryMessage: '',
+      timedOutMs: 0,
     };
 
     return new Promise((resolve) => {
@@ -651,6 +704,8 @@ class KimiAdapter extends LlmDirectAdapter {
       let watchdogTimer = null;
       let fallbackTimer = null;
       let lastDataMs = Date.now();
+      let seenSessionWriteMs = lastDataMs;
+      let loggedSessionAlive = false;
       let silences = 0;
       let queue = Promise.resolve();
 
@@ -713,8 +768,11 @@ class KimiAdapter extends LlmDirectAdapter {
       });
 
       // stderr: `error: ...` lines carry the fatal cause; collected for
-      // classification, never surfaced verbatim as an assistant reply.
+      // classification, never surfaced verbatim as an assistant reply. Tool
+      // progress also lands here in print mode, so it counts as life.
       proc.stderr.on('data', (chunk) => {
+        lastDataMs = Date.now();
+        silences = 0;
         state.stderrText += chunk.toString('utf-8');
         if (state.stderrText.length > 64 * 1024) {
           state.stderrText = state.stderrText.slice(-32 * 1024);
@@ -722,21 +780,47 @@ class KimiAdapter extends LlmDirectAdapter {
       });
 
       // Idle watchdog
+      const intervalMs = this._watchdogIntervalMs;
       watchdogTimer = setInterval(async () => {
         if (settled) return;
         const elapsed = Date.now() - lastDataMs;
-        if (elapsed < WATCHDOG_INTERVAL_MS) { silences = 0; return; }
+        if (elapsed < intervalMs) { silences = 0; return; }
+        // Both pipes are quiet. A subagent still working only shows up in the
+        // session journal, so a fresh write there resets the count too.
+        const wrote = this._latestKimiSessionWrite(sessionWatch);
+        if (wrote > seenSessionWriteMs) {
+          seenSessionWriteMs = wrote;
+          lastDataMs = Date.now();
+          silences = 0;
+          if (!loggedSessionAlive) {
+            loggedSessionAlive = true;
+            this._log(`Watchdog: kimi quiet on ${channel} but its session is still being written — keeping it alive`);
+          }
+          return;
+        }
         silences++;
-        lastDataMs = Date.now();
-        if (silences === WATCHDOG_NUDGE_AT) {
+        // Deliberately NOT touching lastDataMs here: it marks the last real
+        // sign of life, and the data handlers above already reset `silences`
+        // themselves. Refreshing it on a silent tick parked the next tick's
+        // `elapsed` right on the interval boundary, where an early-firing
+        // timer (routine on Windows) read as "data just arrived" and reset
+        // the count — so a genuinely hung run was never stopped.
+        if (silences === this._watchdogNudgeAt) {
           try { await this.sendStatus(channel, 'Still working...'); } catch {}
         }
-        if (silences >= WATCHDOG_MAX) {
-          this._log(`Watchdog: kimi silent ${silences * 15}s on ${channel} — killing`);
-          if (!state.stderrText) state.stderrText = 'error: Kimi became unresponsive and was stopped.';
+        if (silences >= this._watchdogMax) {
+          // Stop ticking before the (awaited) kill: _stopProcess can take
+          // seconds to escalate, and a tick landing inside that wait would
+          // re-log, re-kill and keep inflating timedOutMs past the budget.
+          clearInterval(watchdogTimer);
+          const silentMs = silences * intervalMs;
+          this._log(`Watchdog: kimi silent ${Math.round(silentMs / 1000)}s on ${channel} — killing`);
+          // Its own field, not stderr: tool noise already there used to leave
+          // the user with nothing but the signal name.
+          state.timedOutMs = silentMs;
           await this._stopProcess(proc);
         }
-      }, WATCHDOG_INTERVAL_MS);
+      }, intervalMs);
 
       // Finalize only once BOTH the process has exited AND stdout has ended,
       // so the final buffered lines are never dropped (same race as Cline on

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. */