@openagents-org/agent-launcher 0.2.183 → 0.2.185

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

@@ -114,12 +114,54 @@ class OpenCodeAdapter extends BaseAdapter {
 
     this._opencodeBinary = this._findOpencodeBinary();
     if (this._opencodeBinary) {
-      this._log(`Using OpenCode subprocess mode: ${this._opencodeBinary}`);
+      this._log(`Using ${this._cliLabel()} subprocess mode: ${this._opencodeBinary}`);
     } else {
-      this._log(`OpenCode binary not found. Install with: npm install -g opencode-ai@${OPENCODE_PINNED_VERSION}`);
+      this._log(`${this._cliLabel()} binary not found. ${this._installHint()}`);
     }
   }
 
+  // ------------------------------------------------------------------
+  // What differs between OpenCode and the CLIs built on it
+  // ------------------------------------------------------------------
+  //
+  // Vendors ship their own agents on top of OpenCode (Huawei's CodeArts Agent
+  // is one — see codearts.js). They keep its `run --format json` stream, its
+  // sessions and its failure shapes, and change how the CLI is found, launched
+  // and authenticated. These hooks are exactly that difference.
+
+  /** Product name used in logs and user-facing errors. */
+  _cliLabel() {
+    return 'OpenCode';
+  }
+
+  _installHint() {
+    return `Install with: npm install -g opencode-ai@${OPENCODE_PINNED_VERSION}`;
+  }
+
+  /** User-facing message per failure category. */
+  _failureMessages() {
+    return FAILURE_MESSAGES;
+  }
+
+  /** Whether a run may not start without a model (OpenCode hangs without one). */
+  _modelRequired() {
+    return true;
+  }
+
+  /** Arguments after the binary for one `run`. */
+  _buildRunArgs({ runCwd, model, sessionId }) {
+    // Preflight guarantees a resolvable model; pin it explicitly — without it
+    // opencode hangs waiting for interactive provider/model selection.
+    const args = ['run', '--format', 'json', '--dir', runCwd, '--model', model];
+    if (sessionId) args.push('--session', sessionId);
+    return args;
+  }
+
+  /** Environment the CLI is spawned with. */
+  _spawnEnv() {
+    return { ...(this.agentEnv || process.env) };
+  }
+
   /**
    * Migrate sessions file from old location to agent home.
    */
@@ -195,32 +237,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.
    */
@@ -793,30 +809,25 @@ class OpenCodeAdapter extends BaseAdapter {
     try { this._ensureCustomProviderConfig(runCwd); } catch (e) {
       this._log(`Gateway provider config failed (continuing): ${e.message}`);
     }
-    const cmd = [binary, 'run', '--format', 'json', '--dir', runCwd];
-
-    // Preflight guarantees a resolvable model; pin it explicitly — without it
-    // opencode hangs waiting for interactive provider/model selection.
     const model = this._resolveModel();
-    cmd.push('--model', model);
-
     const sessionId = this._channelSessions[msgChannel];
+    const args = this._buildRunArgs({ runCwd, model, sessionId });
+
     let fullPrompt;
     if (sessionId) {
       fullPrompt = content;
-      cmd.push('--session', sessionId);
     } else {
       this._ensureWorkspaceSkill(msgChannel);
       const context = this._buildSystemContext(msgChannel);
       fullPrompt = `${context}\n\n---\n\n${content}`;
     }
 
-    this._log(`CLI: ${binary} run --format json --dir ${runCwd} --model ${model || '(none)'}`);
+    this._log(`CLI: ${binary} ${args.join(' ')}`);
 
-    const spawnEnv = { ...(this.agentEnv || process.env) };
+    const spawnEnv = this._spawnEnv();
 
-    let spawnBinary = cmd[0];
-    let spawnArgs = cmd.slice(1);
+    let spawnBinary = binary;
+    let spawnArgs = args;
     // Only the npm `.cmd` shim needs a cmd.exe host. The native opencode.exe
     // (preferred by _findOpencodeBinary) is spawned directly — no console host.
     if (IS_WINDOWS && spawnBinary.toLowerCase().endsWith('.cmd')) {
@@ -824,6 +835,9 @@ 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'],
@@ -905,7 +919,7 @@ class OpenCodeAdapter extends BaseAdapter {
 
         if (signal) {
           this._log(`opencode killed by signal ${signal} after ${TIMEOUT_MS / 1000}s (output: ${!!stdout})`);
-          const cls = OpenCodeAdapter._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
+          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')
@@ -914,14 +928,14 @@ class OpenCodeAdapter extends BaseAdapter {
         }
 
         if (code !== 0) {
-          const cls = OpenCodeAdapter._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
+          const cls = this.constructor._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
           this._log(`opencode exited code ${code} → [${cls.category}]: ${OpenCodeAdapter._redact(cls.diagnostic).slice(0, 300)}`);
           return finish(reject, this._failure(cls.category, cls.diagnostic, cls.detail));
         }
 
         // Exit 0.
         if (stdout) this._persistSessionId(msgChannel, stdout);
-        const outcome = OpenCodeAdapter._outcomeForCleanExit({ stdout, stderr, stdoutErr, responseState });
+        const outcome = this.constructor._outcomeForCleanExit({ stdout, stderr, stdoutErr, responseState });
         if (outcome.text) return finish(resolve, outcome.text);
         const f = outcome.failure;
         this._log(`opencode exit 0 → [${f.category}]: ${OpenCodeAdapter._redact(f.diagnostic).slice(0, 300)}`);
@@ -951,7 +965,7 @@ class OpenCodeAdapter extends BaseAdapter {
 
     if (endedOnTool) {
       if (stdoutErr) {
-        const cls = OpenCodeAdapter._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
+        const cls = this._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
         const vague = ['unknown_error', 'process_crashed', 'empty_response'].includes(cls.category);
         return {
           failure: {
@@ -977,7 +991,7 @@ class OpenCodeAdapter extends BaseAdapter {
     // provider — it can be a structured error on stdout, an incomplete
     // stream, or a genuinely empty completion. Classify rather than guess.
     if (stdoutErr) {
-      const cls = OpenCodeAdapter._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
+      const cls = this._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
       return { failure: { category: cls.category, diagnostic: `exit 0 with error event: ${cls.diagnostic || ''}`, detail: cls.detail } };
     }
     const emptyCat = OpenCodeAdapter._emptyExitCategory(stdout);
@@ -1010,7 +1024,7 @@ class OpenCodeAdapter extends BaseAdapter {
     if (!probe.executable) {
       return { ok: false, category: 'cli_not_executable', diagnostic: 'opencode --version did not run' };
     }
-    const vclass = OpenCodeAdapter._classifyVersion(probe.version);
+    const vclass = this.constructor._classifyVersion(probe.version);
     if (vclass === 'unsupported') {
       return {
         ok: false,
@@ -1022,7 +1036,7 @@ class OpenCodeAdapter extends BaseAdapter {
     // 'unknown' (unparseable) and 'degraded' (newer than tested) still run.
 
     const model = this._resolveModel();
-    if (!model) return { ok: false, category: 'model_missing' };
+    if (!model && this._modelRequired()) return { ok: false, category: 'model_missing' };
 
     const cred = this._credentialState();
     if (cred === 'missing') return { ok: false, category: 'credential_missing' };
@@ -1140,10 +1154,14 @@ class OpenCodeAdapter extends BaseAdapter {
    * normal reply. Carries `error_category` in metadata so the UI can route it.
    */
   async _sendClassifiedError(channel, category, detail) {
-    const base = FAILURE_MESSAGES[category] || FAILURE_MESSAGES.unknown_error;
+    // 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() : '';
     const body = safe ? `${base}\n\n> ${safe}` : base;
-    const headline = category === 'incomplete_run' ? 'OpenCode stopped mid-task' : "OpenCode couldn't run";
+    const label = this._cliLabel();
+    const headline = category === 'incomplete_run' ? `${label} stopped mid-task` : `${label} couldn't run`;
     const content = `⚠️ **${headline}** — ${body}`;
     try {
       await this.client.sendMessage(this.workspaceId, channel, this.token, content, {

package/src/adapters/openworker.js

@@ -536,28 +536,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 +635,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,
@@ -686,6 +688,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

package/src/adapters/pi.js

@@ -147,9 +147,6 @@ class PiAdapter extends BaseAdapter {
     // channel → child process (BaseAdapter/stop paths read this)
     this._channelProcesses = {};
     this._stoppingChannels = new Set();
-    // Dedup for "Execution stopped by user." — the control handler and the
-    // in-flight message handler both race to announce it (see claude.js).
-    this._stopNoticeSent = new Set();
 
     this._sessionsFile = path.join(
       os.homedir(), '.openagents', 'sessions',
@@ -524,24 +521,6 @@ class PiAdapter 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 (this._channelProcesses[channel]) {
-          this._log(`Stopping Pi for channel=${channel}`);
-          this._stoppingChannels.add(channel);
-          await this._abortChannel(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) {
@@ -594,11 +573,20 @@ class PiAdapter extends BaseAdapter {
     }
   }
 
-  /** Post "Execution stopped by user." at most once per stop, per channel. */
-  async _postStopNotice(channel) {
-    if (!channel || this._stopNoticeSent.has(channel)) return;
-    this._stopNoticeSent.add(channel);
-    try { await this.sendResponse(channel, 'Execution stopped by user.'); } catch {}
+  /**
+   * Stop ONE channel's Pi turn (BaseAdapter._handleUserStop drives this).
+   * `userStopped` goes on first so the turn that is winding down reports a
+   * stop rather than a failure.
+   */
+  async _stopChannelWork(channel) {
+    const pp = this._persistentProcs[channel];
+    if (pp) pp.userStopped = true;
+    // Abort goes over the RPC channel of the persistent record; a bare child
+    // with no record is simply killed.
+    if (!pp || !this._channelProcesses[channel]) return super._stopChannelWork(channel);
+    this._log(`Stopping Pi for channel=${channel}`);
+    await this._abortChannel(channel);
+    return 'stopped';
   }
 
   /**
@@ -1346,7 +1334,6 @@ class PiAdapter extends BaseAdapter {
     const channel = msg.sessionId || this.channelName || 'general';
 
     this._stoppingChannels.delete(channel);
-    this._stopNoticeSent.delete(channel);
 
     if (!content && !attachments.length) return;
 
@@ -1400,6 +1387,9 @@ class PiAdapter extends BaseAdapter {
       browserEnabled,
     });
 
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) return;
+
     let pp;
     try {
       pp = await this._ensureProc(channel, workingDir, systemPrompt);
@@ -1408,6 +1398,9 @@ class PiAdapter extends BaseAdapter {
       return;
     }
 
+    // Starting the process takes a moment; the prompt is what costs tokens.
+    if (this._stoppedBeforeStart(channel)) return;
+
     // Fresh per-turn accounting.
     pp.msgChannel = channel;
     pp.turnTexts = [];
@@ -1453,7 +1446,7 @@ class PiAdapter extends BaseAdapter {
     pp.turnInFlight = false;
 
     if (pp.userStopped || this._stoppingChannels.has(channel)) {
-      if (!pp.everPosted) await this._postStopNotice(channel);
+      await this._finishUserStop(channel);
       pp.userStopped = false;
       return;
     }
@@ -1470,7 +1463,7 @@ class PiAdapter extends BaseAdapter {
   async _reportTurnFailure(pp, channel, error) {
     const raw = (error && error.message) || String(error);
     if (error instanceof PiCancelledError && (pp.userStopped || this._stoppingChannels.has(channel))) {
-      await this._postStopNotice(channel);
+      await this._finishUserStop(channel);
       return;
     }
     const { kind, userMessage } = classifyPiError(raw);

package/src/daemon.js

@@ -23,6 +23,27 @@ function maskApiKey(key) {
   return key.slice(0, 4) + '...' + key.slice(-4);
 }
 
+/**
+ * Top-level filesystem locations the workspace folder picker can jump to.
+ * Windows has one root per mounted drive; POSIX systems have a single root.
+ * Keeping this as a small pure helper makes the Windows behaviour testable on
+ * every CI platform.
+ */
+function filesystemRoots(platform = os.platform(), exists = fs.existsSync) {
+  if (platform !== 'win32') return ['/'];
+
+  const roots = [];
+  for (let code = 'A'.charCodeAt(0); code <= 'Z'.charCodeAt(0); code++) {
+    const root = `${String.fromCharCode(code)}:\\`;
+    try {
+      if (exists(root)) roots.push(root);
+    } catch {
+      // A disconnected or unreadable mapped drive should not break heartbeat.
+    }
+  }
+  return roots;
+}
+
 /**
  * Agent process lifecycle manager.
  *
@@ -327,8 +348,9 @@ class Daemon {
   }
 
   /**
-   * Filesystem hint for the working-directory picker: home + its immediate
-   * (non-hidden) subfolders, so the workspace can show real folders instantly.
+   * Filesystem hint for the working-directory picker: home, its immediate
+   * (non-hidden) subfolders, and the device's filesystem roots. Roots let a
+   * Windows user switch drives instead of being trapped on the home drive.
    */
   _buildFs() {
     try {
@@ -338,7 +360,7 @@ class Daemon {
         .map((d) => d.name)
         .sort((a, b) => a.localeCompare(b))
         .slice(0, 100);
-      return { home, dirs };
+      return { home, dirs, roots: filesystemRoots() };
     } catch {
       return {};
     }
@@ -369,11 +391,57 @@ class Daemon {
    */
   async _setModelEnv(type, model) {
     const val = String(model || '');
-    const nativeVar = { claude: 'ANTHROPIC_MODEL', gemini: 'GEMINI_MODEL' }[type];
     await this._runAgn(['env', type, '--set', `LLM_MODEL=${val}`]);
+    const nativeVar = { claude: 'ANTHROPIC_MODEL', gemini: 'GEMINI_MODEL' }[type] || this._nativeModelVar(type);
     if (nativeVar) await this._runAgn(['env', type, '--set', `${nativeVar}=${val}`]);
   }
 
+  /**
+   * A node command targets one agent. The launcher may already have saved an
+   * instance-level model/key/URL, which wins over the type env written above.
+   * Mirror the command onto that instance so the running adapter and the
+   * launcher's "This Computer" row both see the requested settings.
+   */
+  _saveNodeAgentEnv(name, type, args) {
+    const changes = {};
+    if (args.apiKey && !args.useDeviceCredentials) changes.LLM_API_KEY = args.apiKey;
+    if (args.baseUrl !== undefined) changes.LLM_BASE_URL = args.baseUrl;
+    if (args.model !== undefined) {
+      const existing = this.config.getAgent(name);
+      if (!existing) throw new Error(`Agent '${name}' not found after create`);
+      // Old instance-level native model keys can outrank LLM_MODEL in the
+      // launcher's display and in CLIs without a resolve_env model rule.
+      for (const key of Object.keys(existing.env || {})) {
+        if (key === 'MODEL' || key.endsWith('_MODEL')) changes[key] = '';
+      }
+      changes.LLM_MODEL = String(args.model || '');
+      const nativeVar = { claude: 'ANTHROPIC_MODEL', gemini: 'GEMINI_MODEL' }[type] || this._nativeModelVar(type);
+      if (nativeVar) changes[nativeVar] = String(args.model || '');
+    }
+    if (Object.keys(changes).length) this.config.updateAgentEnv(name, changes);
+  }
+
+  /**
+   * The agent's own model setting, for a type whose registry declares one and
+   * does not map LLM_MODEL onto anything itself (CodeArts reads CODEARTS_MODEL
+   * and nothing else). A type with a resolve_env rule for LLM_MODEL already
+   * gets there through env resolution, so it is left alone.
+   */
+  _nativeModelVar(type) {
+    try {
+      const entry = this.registry.getEntry(type);
+      if (!entry) return null;
+      const rules = (entry.resolve_env && entry.resolve_env.rules) || [];
+      if (rules.some((r) => r && r.from === 'LLM_MODEL')) return null;
+      const field = (entry.env_config || []).find(
+        (f) => f && /_MODEL$/.test(f.name || '') && f.name !== 'LLM_MODEL',
+      );
+      return field ? field.name : null;
+    } catch {
+      return null;
+    }
+  }
+
   async _refreshRuntimes() {
     try {
       const r = await this._runAgn(['runtimes', '--json']);
@@ -456,6 +524,7 @@ async _runNodeCommand(n, cmd) {
         if (args.model) await this._setModelEnv(type, args.model);
         if (args.baseUrl) await this._runAgn(['env', type, '--set', `LLM_BASE_URL=${args.baseUrl}`]);
         await this._applyConfigMap(type, args.config);
+        this._saveNodeAgentEnv(name, type, args);
         // Attach to this node's workspace BY SLUG: the daemon already knows
         // which workspace this command came from, so there is no token to
         // pass and no /v1/token/resolve round-trip to fail (the outage class
@@ -498,6 +567,7 @@ async _runNodeCommand(n, cmd) {
           await this._runAgn(['remove', name]);
           const rc = await this._runAgn(['create', name, '--type', type, '--install', '--path', newDir]);
           if (rc.code !== 0) throw new Error(rc.stderr || rc.stdout || 'recreate failed');
+          this._saveNodeAgentEnv(name, type, args);
           const rc2 = await this._runAgn([
             'connect', name, '--workspace', n.workspace_slug || n.workspace_id,
           ]);
@@ -507,6 +577,7 @@ async _runNodeCommand(n, cmd) {
           // through daemon.cmd, and writeCommand() OVERWRITES that file — the
           // start could clobber the unread stop (agent keeps the stale env) or
           // interleave with the poll so the agent stops and never restarts.
+          this._saveNodeAgentEnv(name, type, args);
           await this.restartAgent(name);
         }
         ok = true;
@@ -1701,4 +1772,4 @@ async _runNodeCommand(n, cmd) {
   }
 }
 
-module.exports = { Daemon };
+module.exports = { Daemon, filesystemRoots };