@openagents-org/agent-launcher 0.2.114 → 0.2.116

package/package.json

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

package/registry.json

@@ -271,6 +271,8 @@
       "open-source",
       "cli"
     ],
+    "builtin": true,
+    "support": { "install": true, "workspace": true, "collaboration": true },
     "install": {
       "binary": "gemini",
       "requires": [
@@ -279,7 +281,26 @@
       "macos": "npm install -g @google/gemini-cli",
       "linux": "npm install -g @google/gemini-cli",
       "windows": "npm install -g @google/gemini-cli"
-    }
+    },
+    "adapter": {
+      "module": "openagents.adapters.gemini",
+      "class": "GeminiAdapter"
+    },
+    "launch": {
+      "args": [
+        "-p",
+        "Your agent name is '{agent_name}'.",
+        "-y",
+        "-o",
+        "stream-json"
+      ]
+    },
+    "check_ready": {
+      "not_ready_message": "Not logged in. Run: gemini",
+      "login_command": "gemini",
+      "alt_check": "gemini --version"
+    },
+    "env_config": []
   },
   {
     "name": "goose",
@@ -554,8 +575,8 @@
     "install": {
       "binary": "hermes",
       "requires": ["python3"],
-      "macos": "curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash",
-      "linux": "curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash",
+      "macos": "curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash -s -- --skip-setup",
+      "linux": "curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash -s -- --skip-setup",
       "windows": "echo 'Hermes requires WSL2 on Windows — see https://github.com/NousResearch/hermes-agent'"
     },
     "launch": {

package/src/adapters/base.js

@@ -48,6 +48,7 @@ class BaseAdapter {
     this._titledSessions = new Set();
     this._mode = 'execute';
     this._lastControlId = null;
+    this._controlWake = null;
     // Per-channel task tracking for parallel execution
     this._channelBusy = new Set();
     this._channelQueues = {};
@@ -75,13 +76,13 @@ class BaseAdapter {
       this._sessionId = (joinResult && joinResult.session_id) || null;
       this._log(`Joined workspace ${this.workspaceId}${this._sessionId ? ` (session ${this._sessionId.slice(0, 8)})` : ''}`);
     } catch (e) {
-      this._log(`Warning: join failed: ${e.message}`);
+      this._log(`Warning: join failed: ${e.message} \nStack: ${e.stack}`);
     }
 
     await this._skipExistingEvents();
 
     const heartbeatInterval = setInterval(() => this._heartbeat(), 30000);
-    const controlInterval = setInterval(() => this._pollControl(), 2000);
+    const controlPoller = this._controlPollerLoop();
 
     try {
       // Send initial heartbeat
@@ -92,8 +93,9 @@ class BaseAdapter {
       await this._pollLoop();
     } finally {
       this._running = false;
+      this._wakeControlPoller();
       clearInterval(heartbeatInterval);
-      clearInterval(controlInterval);
+      try { await controlPoller; } catch {}
       try {
         await this.client.disconnect(this.workspaceId, this.agentName, this.token);
       } catch {}
@@ -171,6 +173,40 @@ class BaseAdapter {
    */
   async _onControlAction(_action, _payload) {}
 
+  _hasActiveWork() {
+    return this._channelBusy.size > 0;
+  }
+
+  _controlPollDelayMs() {
+    return this._hasActiveWork() ? 250 : 2000;
+  }
+
+  _wakeControlPoller() {
+    if (this._controlWake) {
+      this._controlWake();
+      this._controlWake = null;
+    }
+  }
+
+  async _sleepUntilControlPollDue(delayMs) {
+    await new Promise((resolve) => {
+      const timeout = setTimeout(resolve, delayMs);
+      this._controlWake = () => {
+        clearTimeout(timeout);
+        resolve();
+      };
+    });
+    this._controlWake = null;
+  }
+
+  async _controlPollerLoop() {
+    while (this._running) {
+      await this._pollControl();
+      if (!this._running) break;
+      await this._sleepUntilControlPollDue(this._controlPollDelayMs());
+    }
+  }
+
   // ------------------------------------------------------------------
   // Poll loop
   // ------------------------------------------------------------------
@@ -193,7 +229,7 @@ class BaseAdapter {
           this._log(`Poll #${pollCount}: ${messages.length} messages, cursor=${rawCursor || 'none'}`);
         }
       } catch (e) {
-        this._log(`Poll #${pollCount} failed: ${e.message}`);
+        this._log(`Poll #${pollCount} failed: ${e.message} \nStack: ${e.stack}`);
         await this._sleep(5000);
         continue;
       }
@@ -226,7 +262,10 @@ class BaseAdapter {
         idleCount++;
       }
 
-      // Adaptive polling: 2s active, up to 15s idle
+      // Adaptive polling: 2s active, up to 15s idle.
+      // Each connected agent runs this loop, so faster rates multiply across
+      // every workspace member — keep this conservative and tune separately
+      // with a load-impact analysis on workspace-endpoint.
       const delay = incoming.length > 0 ? 2000 : Math.min(2000 + idleCount * 1000, 15000);
       await this._sleep(delay);
     }
@@ -254,6 +293,7 @@ class BaseAdapter {
 
     // Run channel worker (don't await — parallel execution)
     this._channelWorker(channel, msg);
+    this._wakeControlPoller();
   }
 
   async _channelWorker(channel, msg) {

package/src/adapters/claude.js

@@ -33,6 +33,7 @@ class ClaudeAdapter extends BaseAdapter {
     this.disabledModules = opts.disabledModules || new Set();
     this._channelSessions = {}; // channel → Claude CLI session_id
     this._channelProcesses = {}; // channel → child process
+    this._stoppingChannels = new Set();
     this._sessionsFile = path.join(
       os.homedir(), '.openagents', 'sessions',
       `${this.workspaceId}_${this.agentName}.json`
@@ -64,42 +65,125 @@ class ClaudeAdapter extends BaseAdapter {
 
   async _onControlAction(action, _payload) {
     if (action === 'stop') {
-      await this._stopAllProcesses();
+      await this._stopAllProcesses('Execution stopped by user.');
     }
   }
 
+  /**
+   * Override BaseAdapter.stop so daemon shutdown also tears down in-flight
+   * claude subprocesses cleanly. Without this, killing the daemon leaves
+   * the channel's last event as a `status` (e.g. "Bash › ..." mid-tool-call)
+   * forever — the workspace UI then shows the thread as "running" until a
+   * new message arrives. Fire-and-forget; daemon._killAgent gives us up to
+   * 5s to actually finish the cleanup before the parent exits.
+   */
+  stop() {
+    this._stopAllProcesses(
+      'Task interrupted — daemon restarting. Send another message to continue.'
+    ).catch(() => {});
+    super.stop();
+  }
+
   async _stopProcess(proc) {
     if (!proc || proc.exitCode !== null) return;
     try {
       if (IS_WINDOWS) {
-        try { execSync(`taskkill /F /T /PID ${proc.pid}`, { timeout: 5000 }); } catch {}
+        // Give Claude Code a Ctrl+C-like interrupt first so it can cancel
+        // shell/background tasks it manages before the forceful process-tree
+        // cleanup below. Going straight to /F can leave detached tool work
+        // alive even though the Claude CLI process itself is gone.
+        try { proc.kill('SIGINT'); } catch {}
+        const exited = await new Promise((resolve) => {
+          if (proc.exitCode !== null) {
+            resolve(true);
+            return;
+          }
+          const timeout = setTimeout(() => resolve(false), 1500);
+          proc.once('exit', () => { clearTimeout(timeout); resolve(true); });
+        });
+        if (!exited) {
+          try { execSync(`taskkill /F /T /PID ${proc.pid}`, { timeout: 5000 }); } catch {}
+        }
       } else {
         try { process.kill(-proc.pid, 'SIGTERM'); } catch {
           proc.kill('SIGTERM');
         }
         await new Promise((resolve) => {
+          let done = false;
+          const finish = () => {
+            if (done) return;
+            done = true;
+            resolve();
+          };
           const timeout = setTimeout(() => {
             try { process.kill(-proc.pid, 'SIGKILL'); } catch {
               proc.kill('SIGKILL');
             }
-            resolve();
-          }, 5000);
-          proc.on('exit', () => { clearTimeout(timeout); resolve(); });
+            const reapTimeout = setTimeout(finish, 1000);
+            proc.once('exit', () => { clearTimeout(reapTimeout); finish(); });
+          }, 1500);
+          proc.once('exit', () => { clearTimeout(timeout); finish(); });
         });
       }
     } catch {}
   }
 
-  async _stopAllProcesses() {
+  /**
+   * Build a short transcript of the channel's last chat exchanges, used to
+   * re-seed context when --resume fails and we have to start a fresh
+   * Claude Code session. Returns null when there's nothing useful to add.
+   *
+   * Excludes the user's current message (the for-loop will append it
+   * normally) and any status/thinking events, which are mostly tool-call
+   * noise and inflate the prompt without adding signal.
+   */
+  async _buildChannelRecap(channelName, currentMessage) {
+    const messages = await this.client.getRecentMessages(
+      this.workspaceId, channelName, this.token, 30
+    );
+    if (!messages || messages.length === 0) return null;
+
+    const lines = [];
+    for (const m of messages) {
+      const mt = m.messageType || 'chat';
+      if (mt === 'status' || mt === 'thinking' || mt === 'loading') continue;
+      const text = (m.content || '').trim();
+      if (!text) continue;
+      // Don't echo the user's current message back at them.
+      if (text === currentMessage) continue;
+      const who = m.senderType === 'human'
+        ? (m.senderName || 'user')
+        : (m.senderName || 'agent');
+      // Cap each line so a single huge paste doesn't blow up the prompt.
+      const truncated = text.length > 800 ? text.slice(0, 800) + '…' : text;
+      lines.push(`[${who}] ${truncated}`);
+    }
+    if (lines.length === 0) return null;
+
+    // Keep only the tail; older context has diminishing value and we
+    // don't want to balloon the system prompt.
+    const tail = lines.slice(-15).join('\n');
+    return (
+      'You previously worked in this channel but your prior session is no ' +
+      'longer available, so here is the recent conversation for context:\n\n' +
+      tail
+    );
+  }
+
+  async _stopAllProcesses(completionMessage = 'Execution stopped.') {
     const entries = Object.entries(this._channelProcesses);
     if (!entries.length) return;
     this._log(`Stopping ${entries.length} running process(es)...`);
     for (const [channel, proc] of entries) {
+      this._stoppingChannels.add(channel);
       await this._stopProcess(proc);
       delete this._channelProcesses[channel];
       delete this._channelQueues[channel];
+      // Post as a chat message (not status) so the channel's last event
+      // type is non-status — the workspace UI then transitions out of
+      // "agent is working" state instead of shimmering forever.
       try {
-        await this.sendStatus(channel, 'Execution stopped by user');
+        await this.sendResponse(channel, completionMessage);
       } catch {}
     }
   }
@@ -356,6 +440,7 @@ class ClaudeAdapter extends BaseAdapter {
     if (!content) return;
 
     const msgChannel = msg.sessionId || this.channelName;
+    this._stoppingChannels.delete(msgChannel);
     const sender = msg.senderName || msg.senderType || 'user';
     this._log(`Processing message from ${sender} in ${msgChannel}: ${content.slice(0, 80)}...`);
 
@@ -406,10 +491,23 @@ class ClaudeAdapter extends BaseAdapter {
 
     // Run up to 2 attempts: first with session resume, then fresh if stale session detected
     let _shouldRetry = false;
+    let effectiveContent = content;
     for (let attempt = 0; attempt < 2; attempt++) {
       if (mcpConfigFile) { try { fs.unlinkSync(mcpConfigFile); } catch {} mcpConfigFile = null; }
+
+      // On the retry pass after a stale --resume, the spawned `claude`
+      // starts a brand-new session with no memory of prior turns. Replay
+      // the channel's recent chat history so the agent at least has a
+      // recap instead of saying "I don't see any previous messages."
+      if (attempt > 0) {
+        try {
+          const recap = await this._buildChannelRecap(msgChannel, content);
+          if (recap) effectiveContent = `${recap}\n\n---\n\n${content}`;
+        } catch {}
+      }
+
       try {
-        const built = this._buildClaudeCmd(content, msgChannel, { skipResume: attempt > 0 });
+        const built = this._buildClaudeCmd(effectiveContent, msgChannel, { skipResume: attempt > 0 });
         cmd = built.cmd;
         mcpConfigFile = built.mcpConfigFile;
       } catch (e) {
@@ -557,6 +655,12 @@ class ClaudeAdapter extends BaseAdapter {
           }
 
           delete this._channelProcesses[msgChannel];
+          const stoppedByUser = this._stoppingChannels.has(msgChannel);
+          if (stoppedByUser) {
+            this._stoppingChannels.delete(msgChannel);
+            resolve(false);
+            return;
+          }
 
           if (code !== 0) {
             this._log(`CLI exited with code ${code}`);

package/src/adapters/gemini.js

@@ -0,0 +1,426 @@
+/**
+ * Gemini CLI adapter for OpenAgents workspace.
+ *
+ * Bridges Gemini CLI to an OpenAgents workspace via:
+ * - Polling loop for incoming messages
+ * - Gemini CLI subprocess (stream-json) for task execution
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+
+const BaseAdapter = require('./base');
+const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
+const { buildClaudeSystemPrompt } = require('./workspace-prompt');
+
+const IS_WINDOWS = process.platform === 'win32';
+
+class GeminiAdapter extends BaseAdapter {
+  /**
+   * @param {object} opts - BaseAdapter opts plus:
+   * @param {Set} [opts.disabledModules]
+   * @param {string} [opts.workingDir]
+   */
+  constructor(opts) {
+    super(opts);
+    this.disabledModules = opts.disabledModules || new Set();
+    this._channelSessions = {}; // channel → Gemini CLI session_id
+    this._channelProcesses = {}; // channel → child process
+    this._sessionsFile = path.join(
+      os.homedir(), '.openagents', 'sessions',
+      `${this.workspaceId}_${this.agentName}_gemini.json`
+    );
+    this._loadSessions();
+  }
+
+  _loadSessions() {
+    try {
+      if (fs.existsSync(this._sessionsFile)) {
+        const data = JSON.parse(fs.readFileSync(this._sessionsFile, 'utf-8'));
+        if (data && typeof data === 'object') {
+          Object.assign(this._channelSessions, data);
+          this._log(`Loaded ${Object.keys(data).length} session(s)`);
+        }
+      }
+    } catch {
+      this._log('Could not load sessions file, starting fresh');
+    }
+  }
+
+  _saveSessions() {
+    try {
+      const dir = path.dirname(this._sessionsFile);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(this._sessionsFile, JSON.stringify(this._channelSessions));
+    } catch {}
+  }
+
+  async _onControlAction(action, _payload) {
+    if (action === 'stop') {
+      await this._stopAllProcesses();
+    }
+  }
+
+  async _stopProcess(proc) {
+    if (!proc || proc.exitCode !== null) return;
+    try {
+      if (IS_WINDOWS) {
+        try { execSync(`taskkill /F /T /PID ${proc.pid}`, { timeout: 5000 }); } catch {}
+      } else {
+        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 {}
+  }
+
+  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
+      ? [path.join(home, '.openagents', 'nodejs', 'node.exe')]
+      : [path.join(home, '.openagents', 'nodejs', 'node'),
+         path.join(home, '.openagents', 'nodejs', 'bin', 'node')];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) return c;
+    }
+    return 'node';
+  }
+
+  _resolveToNodeCmd(binPath) {
+    const nodeBin = this._findNodeBin();
+    if (IS_WINDOWS && binPath.toLowerCase().endsWith('.cmd')) {
+      const cmdDir = path.dirname(path.resolve(binPath));
+      const cmdContent = fs.readFileSync(binPath, 'utf-8');
+      const jsMatch = cmdContent.match(/%dp0%\\([^\s"*?]+\.m?js)/i);
+      if (jsMatch) {
+        return [nodeBin, path.resolve(cmdDir, jsMatch[1])];
+      }
+    } else {
+      try {
+        let target = binPath;
+        if (fs.lstatSync(binPath).isSymbolicLink()) {
+          target = path.resolve(path.dirname(binPath), fs.readlinkSync(binPath));
+        }
+        if (target.endsWith('.js') || target.endsWith('.mjs')) {
+          return [nodeBin, target];
+        }
+      } catch {}
+    }
+    return null;
+  }
+
+  _findGeminiBinary() {
+    const home = os.homedir();
+    const ext = IS_WINDOWS ? '.cmd' : '';
+
+    // Tier 0: Isolated runtime prefix
+    const runtimeCandidate = path.join(home, '.openagents', 'runtimes', 'gemini', 'node_modules', '.bin', `gemini${ext}`);
+    if (fs.existsSync(runtimeCandidate)) return runtimeCandidate;
+
+    // Tier 1: PATH search
+    try {
+      if (IS_WINDOWS) {
+        const r = execSync('where gemini.cmd 2>nul || where gemini.exe 2>nul || where gemini 2>nul', {
+          encoding: 'utf-8', timeout: 5000,
+        });
+        return r.split(/\r?\n/)[0].trim();
+      } else {
+        return execSync('which gemini', { encoding: 'utf-8', timeout: 5000 }).trim();
+      }
+    } catch {}
+
+    // Tier 2: Next to current Node.js interpreter
+    const nodeBinDir = path.dirname(process.execPath);
+    const nearNode = path.join(nodeBinDir, `gemini${ext}`);
+    if (fs.existsSync(nearNode)) return nearNode;
+
+    // Tier 3: Common install locations
+    const candidates = IS_WINDOWS ? [
+      path.join(process.env.APPDATA || '', 'npm', 'gemini.cmd'),
+    ] : [
+      path.join(home, '.local', 'bin', 'gemini'),
+      path.join(home, '.npm-global', 'bin', 'gemini'),
+      '/opt/homebrew/bin/gemini',
+      '/usr/local/bin/gemini',
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) return c;
+    }
+
+    return null;
+  }
+
+  _buildGeminiCmd(prompt, channelName, { skipResume = false } = {}) {
+    const geminiBin = this._findGeminiBinary();
+    if (!geminiBin) {
+      throw new Error('gemini CLI not found. Install with: npm install -g @google/gemini-cli');
+    }
+
+    const systemPrompt = '\n' + buildClaudeSystemPrompt({
+      agentName: this.agentName,
+      workspaceId: this.workspaceId,
+      channelName,
+      mode: this._mode,
+    });
+    
+    // For gemini, we combine system prompt with the user message since it doesn't have an append-system-prompt flag
+    const fullPrompt = `${systemPrompt}\n\n---\n\nUser message:\n${prompt}`;
+
+    const cmd = [geminiBin, '-p', fullPrompt, '-y', '-o', 'stream-json'];
+
+    const sessionId = this._channelSessions[channelName];
+    if (sessionId && !skipResume) {
+      cmd.push('-r', sessionId);
+    }
+
+    return { cmd };
+  }
+
+  async _handleMessage(msg) {
+    let content = (msg.content || '').trim();
+    const attachments = msg.attachments || [];
+
+    const attText = formatAttachmentsForPrompt(attachments);
+    if (attText) {
+      content = content ? content + attText : attText.trim();
+    }
+
+    if (!content) return;
+
+    const msgChannel = msg.sessionId || this.channelName;
+    const sender = msg.senderName || msg.senderType || 'user';
+    this._log(`Processing message from ${sender} in ${msgChannel}: ${content.slice(0, 80)}...`);
+
+    if (!this._titledSessions.has(msgChannel)) {
+      this._titledSessions.add(msgChannel);
+      try {
+        const info = await this.client.getSession(this.workspaceId, msgChannel, this.token);
+        const resumeFrom = info.resumeFrom;
+        if (resumeFrom && !this._channelSessions[msgChannel]) {
+          const sourceSession = this._channelSessions[resumeFrom];
+          if (sourceSession) {
+            this._channelSessions[msgChannel] = sourceSession;
+            this._saveSessions();
+            this._log(`Resuming channel ${msgChannel} from ${resumeFrom}`);
+          }
+        }
+        const title = generateSessionTitle(content);
+        if (title && !info.titleManuallySet && SESSION_DEFAULT_RE.test(info.title || '')) {
+          await this.client.updateSession(
+            this.workspaceId, msgChannel, this.token,
+            { title, autoTitle: true }
+          );
+        }
+      } catch {}
+    }
+
+    await this.sendStatus(msgChannel, 'thinking...');
+
+    let cmd;
+    const cleanEnv = { ...(this.agentEnv || process.env) };
+
+    let _shouldRetry = false;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        const built = this._buildGeminiCmd(content, msgChannel, { skipResume: attempt > 0 });
+        cmd = built.cmd;
+      } catch (e) {
+        await this.sendError(msgChannel, e.message);
+        return;
+      }
+
+      try {
+        const resolved = this._resolveToNodeCmd(cmd[0]);
+        if (resolved) {
+          cmd = [resolved[0], resolved[1], ...cmd.slice(1)];
+        } else if (IS_WINDOWS && cmd[0].toLowerCase().endsWith('.cmd')) {
+          cmd = ['cmd.exe', '/c', ...cmd];
+        }
+
+        const proc = spawn(cmd[0], cmd.slice(1), {
+          stdio: ['ignore', 'pipe', 'pipe'],
+          env: cleanEnv,
+          cwd: this.workingDir,
+          detached: !IS_WINDOWS,
+          windowsHide: true,
+        });
+        this._channelProcesses[msgChannel] = proc;
+
+        const lastResponseText = [];
+        let hasToolUseSinceLastText = false;
+        let postedThinking = false;
+        let stderrBuf = '';
+        let lineBuffer = '';
+        let _pendingLines = Promise.resolve();
+
+        if (proc.stderr) {
+          proc.stderr.on('data', (chunk) => { stderrBuf += chunk.toString('utf-8'); });
+        }
+
+        _shouldRetry = await new Promise((resolve, reject) => {
+          let consecutiveTimeouts = 0;
+          let lastDataTime = Date.now();
+          let timeoutTimer = null;
+
+          const resetTimeout = () => {
+            consecutiveTimeouts = 0;
+            lastDataTime = Date.now();
+          };
+
+          const startTimeoutMonitor = () => {
+            timeoutTimer = setInterval(async () => {
+              const elapsed = Date.now() - lastDataTime;
+              if (elapsed >= 15000) {
+                consecutiveTimeouts++;
+                lastDataTime = Date.now();
+                if (consecutiveTimeouts === 2) {
+                  try { await this.sendStatus(msgChannel, 'Processing...'); } catch {}
+                }
+                if (consecutiveTimeouts >= 20) {
+                  this._log(`Process idle for ${consecutiveTimeouts * 15}s, killing...`);
+                  await this._stopProcess(proc);
+                }
+              }
+            }, 15000);
+          };
+          startTimeoutMonitor();
+
+          const processLine = async (line) => {
+            line = line.trim();
+            if (!line) return;
+            resetTimeout();
+
+            let event;
+            try { event = JSON.parse(line); } catch { return; }
+
+            const eventType = event.type;
+
+            if (eventType === 'init' && event.session_id) {
+              this._channelSessions[msgChannel] = event.session_id;
+              this._saveSessions();
+            } else if (eventType === 'message' && event.role === 'assistant') {
+              const text = event.content || '';
+              if (text) {
+                if (hasToolUseSinceLastText) {
+                  lastResponseText.length = 0;
+                  hasToolUseSinceLastText = false;
+                }
+                lastResponseText.push(text);
+                postedThinking = true;
+                try { await this.sendThinking(msgChannel, text); } catch {}
+              }
+            } else if (eventType === 'tool_use') {
+              hasToolUseSinceLastText = true;
+              postedThinking = false;
+              lastResponseText.length = 0;
+              const toolName = event.tool_name || '';
+              let inputPreview = '';
+              if (event.parameters && typeof event.parameters === 'object') {
+                const inp = event.parameters;
+                if (inp.command) inputPreview = inp.command;
+                else if (inp.file_path || inp.path) inputPreview = inp.file_path || inp.path;
+                else if (inp.pattern) inputPreview = inp.pattern;
+                else if (inp.query) inputPreview = inp.query;
+                else inputPreview = JSON.stringify(inp).slice(0, 150);
+              }
+              await this.sendStatus(msgChannel, `${toolName} › ${inputPreview}`);
+            } else if (eventType === 'result') {
+               if (event.session_id) {
+                 this._channelSessions[msgChannel] = event.session_id;
+                 this._saveSessions();
+               }
+            }
+          };
+
+          proc.on('exit', async (code) => {
+            if (timeoutTimer) clearInterval(timeoutTimer);
+
+            try { await _pendingLines; } catch {}
+
+            const lines = lineBuffer.split('\n');
+            for (const line of lines) {
+              try { await processLine(line); } catch {}
+            }
+
+            delete this._channelProcesses[msgChannel];
+
+            if (code !== 0) {
+              this._log(`CLI exited with code ${code}`);
+              if (stderrBuf.trim()) {
+                this._log(`stderr: ${stderrBuf.trim().slice(0, 500)}`);
+              }
+            }
+
+            if (lastResponseText.length > 0) {
+              const fullResponse = lastResponseText.join('').trim(); // Gemini deltas are partial strings, no newline needed between them usually, but wait, delta:true means it appends. If it's multiple blocks, we should join with empty string? Let's check `delta: true`.
+              // Actually if delta: true, they are chunks. We pushed them to array. `lastResponseText.join('')` is correct.
+              if (fullResponse) {
+                try { await this.sendResponse(msgChannel, fullResponse); } catch {}
+              }
+              resolve(false);
+            } else if (code !== 0 && this._channelSessions[msgChannel]) {
+              this._log(`Stale session detected for ${msgChannel}, clearing and retrying without resume`);
+              delete this._channelSessions[msgChannel];
+              this._saveSessions();
+              resolve(true);
+            } else {
+              if (!postedThinking) {
+                try { await this.sendResponse(msgChannel, 'No response generated. Please try again.'); } catch {}
+              }
+              resolve(false);
+            }
+          });
+
+          proc.on('error', (err) => {
+            if (timeoutTimer) clearInterval(timeoutTimer);
+            reject(err);
+          });
+
+          proc.stdout.on('data', (chunk) => {
+            lineBuffer += chunk.toString('utf-8');
+            resetTimeout();
+            const lines = lineBuffer.split('\n');
+            lineBuffer = lines.pop();
+            for (const line of lines) {
+              _pendingLines = _pendingLines.then(() => processLine(line)).catch(() => {});
+            }
+          });
+        });
+      } catch (e) {
+        this._log(`Error handling message: ${e.message}`);
+        await this.sendError(msgChannel, `Error processing message: ${e.message}`);
+        break;
+      }
+      if (!_shouldRetry) break;
+    }
+  }
+}
+
+module.exports = GeminiAdapter;

package/src/adapters/index.js

@@ -12,6 +12,7 @@ const OpenCodeAdapter = require('./opencode');
 const NanoClawAdapter = require('./nanoclaw');
 const CursorAdapter = require('./cursor');
 const HermesAdapter = require('./hermes');
+const GeminiAdapter = require('./gemini');
 
 const ADAPTER_MAP = {
   openclaw: OpenClawAdapter,
@@ -21,6 +22,7 @@ const ADAPTER_MAP = {
   nanoclaw: NanoClawAdapter,
   cursor: CursorAdapter,
   hermes: HermesAdapter,
+  gemini: GeminiAdapter,
 };
 
 /**
@@ -46,6 +48,7 @@ module.exports = {
   NanoClawAdapter,
   CursorAdapter,
   HermesAdapter,
+  GeminiAdapter,
   createAdapter,
   ADAPTER_MAP,
 };

package/src/index.js

@@ -169,6 +169,22 @@ class AgentConnector {
     return { success: true };
   }
 
+  async removeWorkspace(slug) {
+    const networks = this.config.getNetworks();
+    const network = networks.find(n => n.slug === slug || n.id === slug);
+    if (network && network.id) {
+      // Use the network's specific endpoint (e.g., localhost vs official)
+      const endpoint = network.endpoint || (this.workspace && this.workspace.endpoint);
+      const { WorkspaceClient } = require('./workspace-client');
+      const tempClient = new WorkspaceClient(endpoint);
+      // Try to remove from backend first
+      await tempClient.deleteWorkspace(network.id, network.token || '');
+    }
+    // Remove from local config (which also disconnects any agents)
+    this.config.removeNetwork(slug);
+    return { success: true };
+  }
+
   // -- Daemon lifecycle --
 
   /**

package/src/workspace-client.js

@@ -72,6 +72,18 @@ class WorkspaceClient {
     };
   }
 
+  /**
+   * Delete a workspace via DELETE /v1/workspaces/{workspaceId}.
+   */
+  async deleteWorkspace(workspaceId, token) {
+    try {
+      await this._delete(`/v1/workspaces/${workspaceId}`, this._wsHeaders(token));
+    } catch (e) {
+      // Best-effort remote deletion.
+      console.warn(`Failed to remotely delete workspace ${workspaceId}: ${e.message}`);
+    }
+  }
+
   /**
    * Join a workspace via POST /v1/join.
    */
@@ -179,6 +191,32 @@ class WorkspaceClient {
     return events.map((e) => this._eventToMessage(e));
   }
 
+  /**
+   * Fetch the most recent N messages in a channel, returned oldest-to-newest.
+   * Used by adapters to rebuild context for a fresh Claude Code session
+   * when --resume of the previous session fails (the channel's chat history
+   * is the only thing that survives a session-storage rotation).
+   */
+  async getRecentMessages(workspaceId, channelName, token, limit = 30) {
+    try {
+      const params = new URLSearchParams({
+        network: workspaceId,
+        channel: channelName,
+        type: 'workspace.message',
+        sort: 'desc',
+        limit: String(limit),
+      });
+      const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
+      const result = data.data || data;
+      const events = (result && result.events) || [];
+      // Server returned newest-first; reverse so the caller can present them
+      // in chronological order without further fiddling.
+      return events.slice().reverse().map((e) => this._eventToMessage(e));
+    } catch {
+      return [];
+    }
+  }
+
   /**
    * Fetch the latest workspace.message.posted event id (head cursor).
    * Used by adapters to skip past existing events on join in O(1) instead