@openagents-org/agent-launcher 0.2.111 → 0.2.113

package/package.json

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

package/registry.json

@@ -535,5 +535,37 @@
       "linux": "pip install sweagent",
       "windows": "pip install sweagent"
     }
+  },
+  {
+    "name": "hermes",
+    "label": "Hermes Agent",
+    "description": "Nous Hermes Agent — self-improving AI with tools, profiles, memory, and messaging",
+    "homepage": "https://github.com/NousResearch/hermes-agent",
+    "tags": [
+      "coding",
+      "tools",
+      "orchestration",
+      "profiles"
+    ],
+    "featured": true,
+    "order": 6,
+    "support": { "install": true, "workspace": true, "collaboration": true },
+    "builtin": true,
+    "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",
+      "windows": "echo 'Hermes requires WSL2 on Windows — see https://github.com/NousResearch/hermes-agent'"
+    },
+    "launch": {
+      "args": []
+    },
+    "check_ready": {
+      "creds_file": "~/.hermes/config.yaml",
+      "status_command": "hermes status",
+      "login_command": "hermes setup",
+      "not_ready_message": "Hermes not configured — run: hermes setup"
+    }
   }
 ]

package/src/adapters/base.js

@@ -53,7 +53,7 @@ class BaseAdapter {
     this._channelQueues = {};
     this._log = (msg) => {
       const ts = new Date().toISOString();
-      console.log(`${ts} INFO adapter: ${msg}`);
+      console.log(`${ts} INFO adapter [${this.agentName}]: ${msg}`);
     };
   }
 
@@ -109,20 +109,15 @@ class BaseAdapter {
   // ------------------------------------------------------------------
 
   async _skipExistingEvents() {
-    try {
-      while (true) {
-        const { cursor } = await this.client.pollPending(
-          this.workspaceId, this.agentName, this.token,
-          { after: this._lastEventId, limit: 200 }
-        );
-        if (!cursor || cursor === this._lastEventId) break;
-        this._lastEventId = cursor;
-      }
-      if (this._lastEventId) {
-        this._log(`Skipped existing events, cursor at ${this._lastEventId}`);
-      }
-    } catch (e) {
-      this._log(`Failed to skip existing events: ${e.message}`);
+    // Jump straight to the head with one server call. Pagination from the
+    // start was slow and brittle: on a busy workspace it could take many
+    // minutes to chew through historical events 200 at a time, leaving the
+    // agent silently behind, and a transient mid-paginate empty response
+    // (e.g. shared-cache race) would strand the cursor at a non-head id.
+    const head = await this.client.getHeadEventId(this.workspaceId, this.token);
+    if (head) {
+      this._lastEventId = head;
+      this._log(`Skipped existing events, cursor at ${head}`);
     }
   }
 

package/src/adapters/hermes.js

@@ -0,0 +1,360 @@
+/**
+ * Hermes adapter for OpenAgents workspace.
+ *
+ * Bridges Nous Research's Hermes Agent CLI (https://github.com/NousResearch/hermes-agent)
+ * to an OpenAgents workspace by spawning `hermes chat -q <prompt> -Q` per
+ * incoming message and posting the response back to the workspace channel.
+ *
+ * Mirrors the Python adapter at sdk/src/openagents/adapters/hermes.py:
+ * - per-channel Hermes session IDs persisted to ~/.openagents/sessions/
+ * - profile auto-detection from the agent name (falls back to 'default')
+ * - workspace context injection (identity + recent history + agent roster)
+ * - subprocess isolation (hermes manages its own HERMES_HOME per profile)
+ */
+
+'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 { buildOpenclawSystemPrompt } = require('./workspace-prompt');
+
+const IS_WINDOWS = process.platform === 'win32';
+const SESSION_ID_RE = /session_id:\s*(\S+)/;
+const MAX_HISTORY_ENTRIES = 12;
+
+class HermesAdapter extends BaseAdapter {
+  /**
+   * @param {object} opts - BaseAdapter opts plus:
+   * @param {string} [opts.hermesProfile] - explicit Hermes profile, or 'auto'
+   * @param {string} [opts.hermesSource]  - `--source` label (default: 'tool')
+   * @param {number} [opts.maxTurns]      - `--max-turns` value
+   * @param {boolean} [opts.yolo]         - pass `--yolo` to skip prompts
+   * @param {Set} [opts.disabledModules]
+   */
+  constructor(opts) {
+    super(opts);
+    this.disabledModules = opts.disabledModules || new Set();
+    this.hermesProfile = this._resolveProfile(opts.hermesProfile, this.agentName);
+    this.hermesSource = opts.hermesSource || 'tool';
+    this.maxTurns = Number.isInteger(opts.maxTurns) ? opts.maxTurns : 60;
+    this.yolo = !!opts.yolo;
+
+    this._channelSessions = {};
+    this._channelProcesses = {};
+    this._sessionsFile = path.join(
+      os.homedir(), '.openagents', 'sessions',
+      `${this.workspaceId}_${this.agentName}_hermes.json`,
+    );
+    this._loadSessions();
+
+    this._hermesBin = this._findHermesBinary();
+    if (this._hermesBin) {
+      this._log(`Using Hermes binary: ${this._hermesBin} (profile=${this.hermesProfile})`);
+    } else {
+      this._log('Warning: hermes CLI not found. Install: curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash');
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // Binary discovery (multi-tier, matching codex/claude pattern)
+  // ------------------------------------------------------------------
+
+  _findHermesBinary() {
+    const home = os.homedir();
+
+    // Tier 1: PATH
+    try {
+      if (IS_WINDOWS) {
+        // Native Windows unsupported upstream — we try anyway for WSL cases
+        const r = execSync('where hermes 2>nul', { encoding: 'utf-8', timeout: 5000 });
+        const found = r.split(/\r?\n/)[0].trim();
+        if (found) return found;
+      } else {
+        const found = execSync('which hermes', { encoding: 'utf-8', timeout: 5000 }).trim();
+        if (found) return found;
+      }
+    } catch {}
+
+    // Tier 2: Common install locations (hermes installer uses ~/.local/bin)
+    const candidates = IS_WINDOWS ? [] : [
+      path.join(home, '.local', 'bin', 'hermes'),
+      '/opt/homebrew/bin/hermes',
+      '/usr/local/bin/hermes',
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) return c;
+    }
+
+    return null;
+  }
+
+  _resolveProfile(explicit, agentName) {
+    if (explicit && explicit !== '' && explicit !== 'auto') return explicit;
+    // Match agent name to an existing ~/.hermes/profiles/<name> if present
+    try {
+      const profileDir = path.join(os.homedir(), '.hermes', 'profiles', agentName);
+      if (fs.existsSync(profileDir)) return agentName;
+    } catch {}
+    return 'default';
+  }
+
+  // ------------------------------------------------------------------
+  // Session persistence (per-channel Hermes session IDs)
+  // ------------------------------------------------------------------
+
+  _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} Hermes session(s)`);
+        }
+      }
+    } catch {
+      this._log('Could not load Hermes sessions file, starting fresh');
+    }
+  }
+
+  _saveSessions() {
+    try {
+      fs.mkdirSync(path.dirname(this._sessionsFile), { recursive: true });
+      fs.writeFileSync(this._sessionsFile, JSON.stringify(this._channelSessions));
+    } catch {}
+  }
+
+  // ------------------------------------------------------------------
+  // Prompt assembly
+  // ------------------------------------------------------------------
+
+  async _getAgentsText() {
+    try {
+      const agents = await this.client.getAgents(this.workspaceId, this.token);
+      if (!Array.isArray(agents) || agents.length === 0) return '';
+      const lines = agents
+        .map((a) => {
+          const name = a.agentName || a.agent_name || a.name;
+          if (!name) return null;
+          const role = a.role || 'member';
+          const status = a.status || 'unknown';
+          return `- ${name} (${role}, ${status})`;
+        })
+        .filter(Boolean);
+      return lines.length ? `## Available Workspace Agents\n${lines.join('\n')}` : '';
+    } catch {
+      return '';
+    }
+  }
+
+  async _getRecentHistoryText(channelName) {
+    try {
+      const messages = await this.client.pollMessages({
+        workspaceId: this.workspaceId,
+        channelName,
+        token: this.token,
+        limit: MAX_HISTORY_ENTRIES,
+      });
+      if (!Array.isArray(messages) || messages.length === 0) return '';
+      const lines = messages
+        .filter((m) => m.messageType !== 'status')
+        .map((m) => {
+          const sender = m.senderName || m.senderType || 'unknown';
+          const content = (m.content || '').trim();
+          if (!content) return null;
+          return `- ${sender}: ${content.slice(0, 400)}`;
+        })
+        .filter(Boolean);
+      return lines.length ? `## Recent Workspace Messages\n${lines.join('\n')}` : '';
+    } catch {
+      return '';
+    }
+  }
+
+  async _buildContextPrefix(channelName) {
+    const parts = [
+      buildOpenclawSystemPrompt({
+        agentName: this.agentName,
+        workspaceId: this.workspaceId,
+        channelName,
+        endpoint: this.endpoint,
+        token: this.token,
+        mode: this._mode,
+        disabledModules: this.disabledModules,
+      }),
+      '\n## OpenAgents-specific Rules',
+      '- Your final text response is posted back to the workspace automatically.',
+      '- If you need to ask the user something, ask in normal text. Do not try to open an interactive prompt.',
+      '- Do not reveal secrets, tokens, raw auth headers, or internal command lines.',
+      '- Keep status concise. Focus on useful output over theatre.',
+    ];
+
+    const [agentsText, historyText] = await Promise.all([
+      this._getAgentsText(),
+      this._getRecentHistoryText(channelName),
+    ]);
+    if (agentsText) parts.push('\n' + agentsText);
+    if (historyText) parts.push('\n' + historyText);
+    return parts.join('\n').trim();
+  }
+
+  // ------------------------------------------------------------------
+  // Output parsing
+  // ------------------------------------------------------------------
+
+  _parseHermesOutput(raw) {
+    let sessionId = null;
+    let body = raw;
+
+    const m = SESSION_ID_RE.exec(body);
+    if (m) {
+      sessionId = m[1];
+      body = body.replace(SESSION_ID_RE, '');
+    }
+
+    const lines = [];
+    for (const line of body.split(/\r?\n/)) {
+      const stripped = line.trim();
+      if (!stripped) continue;
+      if (stripped.startsWith('↻ Resumed session ')) continue;
+      lines.push(line);
+    }
+    return { text: lines.join('\n').trim(), sessionId };
+  }
+
+  // ------------------------------------------------------------------
+  // Subprocess lifecycle
+  // ------------------------------------------------------------------
+
+  _buildHermesCmd(prompt, resumeSessionId) {
+    if (!this._hermesBin) {
+      throw new Error('hermes CLI not found. Install with: curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash');
+    }
+    const args = [];
+    if (this.hermesProfile && this.hermesProfile !== 'default') {
+      args.push('-p', this.hermesProfile);
+    }
+    args.push(
+      'chat',
+      '-q', prompt,
+      '-Q',
+      '--source', this.hermesSource,
+      '--max-turns', String(this.maxTurns),
+    );
+    if (resumeSessionId) args.push('--resume', resumeSessionId);
+    if (this.yolo) args.push('--yolo');
+    return args;
+  }
+
+  async _runHermes(prompt, channelName) {
+    const resumeId = this._channelSessions[channelName];
+    const args = this._buildHermesCmd(prompt, resumeId);
+    this._log(`Running hermes (profile=${this.hermesProfile}, channel=${channelName}, resume=${!!resumeId})`);
+
+    const env = { ...(this.agentEnv || process.env) };
+    const proc = spawn(this._hermesBin, args, {
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: !IS_WINDOWS,
+    });
+    this._channelProcesses[channelName] = proc;
+
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => { stdout += d.toString('utf-8'); });
+    proc.stderr.on('data', (d) => { stderr += d.toString('utf-8'); });
+
+    const exitCode = await new Promise((resolve) => {
+      proc.on('exit', resolve);
+      proc.on('error', () => resolve(-1));
+    });
+    delete this._channelProcesses[channelName];
+
+    if (exitCode !== 0) {
+      if (resumeId) {
+        // Resume may have failed because the session was deleted — drop it and retry fresh
+        this._log(`Hermes resume failed (code=${exitCode}), retrying without resume`);
+        delete this._channelSessions[channelName];
+        this._saveSessions();
+        return this._runHermes(prompt, channelName);
+      }
+      const detail = (stderr || stdout).trim().slice(0, 600);
+      throw new Error(`hermes exited with code ${exitCode}: ${detail}`);
+    }
+
+    const { text, sessionId } = this._parseHermesOutput(stdout);
+    if (sessionId) {
+      this._channelSessions[channelName] = sessionId;
+      this._saveSessions();
+    }
+    return text;
+  }
+
+  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 _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
+  // ------------------------------------------------------------------
+
+  async _handleMessage(msg) {
+    const content = (msg.content || '').trim();
+    if (!content) return;
+
+    const msgChannel = msg.sessionId || this.channelName;
+    const sender = msg.senderName || msg.senderType || 'user';
+    this._log(`Processing workspace message from ${sender} in ${msgChannel}`);
+
+    await this._autoTitleChannel(msgChannel, content);
+    await this.sendStatus(msgChannel, 'thinking...');
+
+    try {
+      const context = await this._buildContextPrefix(msgChannel);
+      const prompt = context ? `${context}\n\n---\n\nUser message:\n${content}` : content;
+      const responseText = await this._runHermes(prompt, msgChannel);
+
+      if (responseText) {
+        await this.sendResponse(msgChannel, responseText);
+      } else {
+        await this.sendResponse(msgChannel, 'No response generated. Please try again.');
+      }
+    } catch (e) {
+      this._log(`Hermes adapter error: ${e.message}`);
+      await this.sendError(msgChannel, `Error processing message: ${e.message}`);
+    }
+  }
+}
+
+module.exports = HermesAdapter;

package/src/adapters/index.js

@@ -11,6 +11,7 @@ const CodexAdapter = require('./codex');
 const OpenCodeAdapter = require('./opencode');
 const NanoClawAdapter = require('./nanoclaw');
 const CursorAdapter = require('./cursor');
+const HermesAdapter = require('./hermes');
 
 const ADAPTER_MAP = {
   openclaw: OpenClawAdapter,
@@ -19,11 +20,12 @@ const ADAPTER_MAP = {
   opencode: OpenCodeAdapter,
   nanoclaw: NanoClawAdapter,
   cursor: CursorAdapter,
+  hermes: HermesAdapter,
 };
 
 /**
  * Create an adapter instance for the given agent type.
- * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor)
+ * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes)
  * @param {object} opts - Adapter constructor options
  * @returns {BaseAdapter}
  */
@@ -43,6 +45,7 @@ module.exports = {
   OpenCodeAdapter,
   NanoClawAdapter,
   CursorAdapter,
+  HermesAdapter,
   createAdapter,
   ADAPTER_MAP,
 };

package/src/cli.js

@@ -117,7 +117,7 @@ async function cmdStatus(connector) {
 
 async function cmdCreate(connector, flags, positional) {
   const name = positional[0];
-  if (!name) { print('Usage: agn create <name> [--type <type>]'); return; }
+  if (!name) { print('Usage: agn create <name> [--type <type>] [--install]'); return; }
   const type = flags.type || 'openclaw';
   const role = flags.role || 'worker';
 
@@ -128,8 +128,12 @@ async function cmdCreate(connector, flags, positional) {
     // Signal daemon to pick up the new agent
     try { connector.sendDaemonCommand('reload'); } catch {}
 
-    // Auto-install if not installed
     if (!connector.isInstalled(type)) {
+      if (!flags.install) {
+        print(`Runtime '${type}' is not installed. Run: agn install ${type}`);
+        return;
+      }
+
       print(`Installing ${type}...`);
       try {
         await connector.install(type);
@@ -513,6 +517,7 @@ Commands:
 
 Options:
   --config <dir>              Config directory (default: ~/.openagents)
+  --install                   Install runtime during create
 `);
 }
 

package/src/config.js

@@ -50,13 +50,14 @@ class Config {
     fs.writeFileSync(this.configFile, serializeYaml(config), 'utf-8');
   }
 
-  addAgent({ name, type, role, path: agentPath }) {
+  addAgent({ name, type, role, path: agentPath, env }) {
     const config = this.load();
     if (config.agents.some((a) => a.name === name)) {
       throw new Error(`Agent '${name}' already exists`);
     }
     const entry = { name, type: type || 'openclaw', role: role || 'worker' };
     if (agentPath) entry.path = agentPath;
+    if (env && Object.keys(env).length > 0) entry.env = env;
     config.agents.push(entry);
     this.save(config);
     return entry;
@@ -80,6 +81,27 @@ class Config {
     return agent;
   }
 
+  updateAgentEnv(name, env) {
+    const config = this.load();
+    const agent = config.agents.find((a) => a.name === name);
+    if (!agent) throw new Error(`Agent '${name}' not found`);
+
+    const merged = { ...(agent.env || {}), ...(env || {}) };
+    const cleaned = {};
+    for (const [key, value] of Object.entries(merged)) {
+      if (value !== null && value !== undefined && value !== '') cleaned[key] = value;
+    }
+
+    if (Object.keys(cleaned).length > 0) {
+      agent.env = cleaned;
+    } else {
+      delete agent.env;
+    }
+
+    this.save(config);
+    return agent.env || {};
+  }
+
   setAgentNetwork(agentName, networkSlug) {
     const config = this.load();
     const agent = config.agents.find((a) => a.name === agentName);
@@ -191,6 +213,43 @@ class Config {
       return { lines: [], size: 0 };
     }
   }
+
+  /**
+   * Remove log entries whose leading timestamp falls within [start, end].
+   * Lines without a parseable timestamp are preserved to avoid deleting
+   * stack traces or continuation lines incorrectly.
+   * @param {Object} opts - { start, end }
+   * @param {string|number|Date} opts.start
+   * @param {string|number|Date} opts.end
+   * @returns {{ removed: number, remaining: number }}
+   */
+  clearLogsInRange(opts = {}) {
+    const start = normalizeTimeValue(opts.start);
+    const end = normalizeTimeValue(opts.end);
+
+    if (!start || !end) {
+      throw new Error('Start time and end time are required');
+    }
+    if (start.getTime() > end.getTime()) {
+      throw new Error('Start time must be before end time');
+    }
+    if (!fs.existsSync(this.logFile)) {
+      return { removed: 0, remaining: 0 };
+    }
+
+    const content = fs.readFileSync(this.logFile, 'utf-8');
+    const hasTrailingNewline = content.endsWith('\n');
+    const allLines = content.split('\n');
+    if (hasTrailingNewline) allLines.pop();
+    const { keptLines, removed } = filterLogsByTimeRange(allLines, start, end);
+
+    const nextContent = keptLines.join('\n') + (hasTrailingNewline && keptLines.length > 0 ? '\n' : '');
+    const tempFile = `${this.logFile}.tmp`;
+    fs.writeFileSync(tempFile, nextContent, 'utf-8');
+    fs.renameSync(tempFile, this.logFile);
+
+    return { removed, remaining: keptLines.length };
+  }
 }
 
 // -- YAML parser (compatible with Python SDK's daemon.yaml format) --
@@ -253,6 +312,115 @@ function parseYaml(text) {
   return result;
 }
 
+function normalizeTimeValue(value) {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value;
+  }
+  if (typeof value === 'number') {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  if (typeof value === 'string' && value.trim()) {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  return null;
+}
+
+function filterLogsByTimeRange(lines, start, end) {
+  const headerTimes = resolveLogHeaderTimestamps(lines, end);
+  let activeRemove = false;
+  let removed = 0;
+  const keptLines = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const headerTime = headerTimes[index];
+    if (headerTime) {
+      const time = headerTime.getTime();
+      activeRemove = time >= start.getTime() && time <= end.getTime();
+    }
+
+    if (activeRemove) {
+      removed += 1;
+    } else {
+      keptLines.push(lines[index]);
+    }
+  }
+
+  return { keptLines, removed };
+}
+
+function resolveLogHeaderTimestamps(lines, referenceTime) {
+  const resolved = new Array(lines.length).fill(null);
+  let currentDay = startOfLocalDay(referenceTime);
+  let lastClockSeconds = null;
+
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const token = parseLogTimestampToken(lines[index]);
+    if (!token) continue;
+
+    if (token.kind === 'iso') {
+      resolved[index] = token.date;
+      currentDay = startOfLocalDay(token.date);
+      lastClockSeconds = (
+        token.date.getHours() * 3600 +
+        token.date.getMinutes() * 60 +
+        token.date.getSeconds()
+      );
+      continue;
+    }
+
+    if (lastClockSeconds !== null && token.seconds > lastClockSeconds) {
+      currentDay = addLocalDays(currentDay, -1);
+    }
+
+    resolved[index] = withLocalClock(currentDay, token.seconds);
+    lastClockSeconds = token.seconds;
+  }
+
+  return resolved;
+}
+
+function parseLogTimestampToken(line) {
+  if (!line) return null;
+
+  const isoMatch = line.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2}))/);
+  if (isoMatch) {
+    const date = new Date(isoMatch[1]);
+    if (!Number.isNaN(date.getTime())) {
+      return { kind: 'iso', date };
+    }
+  }
+
+  const clockMatch = line.match(/^\[(\d{2}):(\d{2}):(\d{2})\]/);
+  if (clockMatch) {
+    return {
+      kind: 'clock',
+      seconds:
+        Number(clockMatch[1]) * 3600 +
+        Number(clockMatch[2]) * 60 +
+        Number(clockMatch[3]),
+    };
+  }
+
+  return null;
+}
+
+function startOfLocalDay(date) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+
+function addLocalDays(date, days) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate() + days);
+}
+
+function withLocalClock(day, seconds) {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = seconds % 60;
+  return new Date(day.getFullYear(), day.getMonth(), day.getDate(), hours, minutes, secs);
+}
+
 function parseYamlValue(val) {
   if (val === '' || val === 'null' || val === '~') return null;
   if (val === 'true') return true;

package/src/daemon.js

@@ -70,7 +70,7 @@ class Daemon {
     this._writeStatus();
     this._cachedAgentNames = new Set(agents.map(a => a.name));
     this._cachedAgentConfigs = {};
-    for (const a of agents) this._cachedAgentConfigs[a.name] = a.network || '';
+    for (const a of agents) this._cachedAgentConfigs[a.name] = this._agentConfigFingerprint(a);
     this._log(`Daemon started with ${agents.length} agent(s)`);
 
     // Block until shutdown
@@ -553,11 +553,19 @@ class Daemon {
   _buildAgentEnv(agentCfg) {
     const type = agentCfg.type || 'openclaw';
     const saved = this.envManager.load(type);
-    const resolved = this.envManager.resolve(type, saved, this.registry);
-    const merged = { ...saved, ...resolved, ...(agentCfg.env || {}) };
+    const mergedSaved = { ...saved, ...(agentCfg.env || {}) };
+    const resolved = this.envManager.resolve(type, mergedSaved, this.registry);
+    const merged = { ...mergedSaved, ...resolved };
     return { ...process.env, ...merged };
   }
 
+  _agentConfigFingerprint(agentCfg) {
+    return JSON.stringify({
+      network: agentCfg.network || '',
+      env: agentCfg.env || {},
+    });
+  }
+
   // ---------------------------------------------------------------------------
   // Internal — agent kill
   // ---------------------------------------------------------------------------
@@ -682,7 +690,7 @@ class Daemon {
     const newAgents = this.config.getAgents();
     const newNames = new Set(newAgents.map(a => a.name));
     const newConfigs = {};
-    for (const a of newAgents) newConfigs[a.name] = a.network || '';
+    for (const a of newAgents) newConfigs[a.name] = this._agentConfigFingerprint(a);
 
     // Stop removed agents
     for (const name of oldNames) {
@@ -698,13 +706,13 @@ class Daemon {
         await this._ensureAdapterCleared(agent.name);
         this._launchAgent(agent);
         this._log(`Reload: started new agent '${agent.name}'`);
-      } else if ((oldConfigs[agent.name] || '') !== (agent.network || '')) {
-        // Network config changed — restart agent
+      } else if ((oldConfigs[agent.name] || '') !== newConfigs[agent.name]) {
+        // Network or env config changed — restart agent
         await this.stopAgent(agent.name);
         this._stoppedAgents.delete(agent.name);
         await this._ensureAdapterCleared(agent.name);
         this._launchAgent(agent);
-        this._log(`Reload: restarted '${agent.name}' (network changed)`);
+        this._log(`Reload: restarted '${agent.name}' (config changed)`);
       }
     }
 

package/src/index.js

@@ -74,22 +74,24 @@ class AgentConnector {
     const agents = this.config.getAgents();
     const networks = this.config.getNetworks();
     return agents.map((a) => {
-      const agentEnv = this.env.load(a.type);
+      const type = a.type || 'openclaw';
+      const typeEnv = this.env.load(type);
       const network = networks.find((n) => n.slug === a.network || n.id === a.network);
       return {
         name: a.name,
-        type: a.type || 'openclaw',
+        type,
         role: a.role || 'worker',
         network: a.network || null,
         networkName: network ? (network.name || network.slug) : null,
         path: a.path || null,
-        env: { ...agentEnv, ...(a.env || {}) },
+        env: { ...typeEnv, ...(a.env || {}) },
+        instanceEnv: { ...(a.env || {}) },
       };
     });
   }
 
-  addAgent({ name, type, role, path }) {
-    this.config.addAgent({ name, type: type || 'openclaw', role: role || 'worker', path });
+  addAgent({ name, type, role, path, env }) {
+    this.config.addAgent({ name, type: type || 'openclaw', role: role || 'worker', path, env });
     return { success: true };
   }
 
@@ -104,6 +106,12 @@ class AgentConnector {
     return this.env.load(agentType);
   }
 
+  getAgentInstanceEnv(agentName) {
+    const agent = this.config.getAgent(agentName);
+    if (!agent) throw new Error(`Agent '${agentName}' not found`);
+    return { ...(agent.env || {}) };
+  }
+
   saveAgentEnv(agentType, env) {
     this.env.save(agentType, env);
     // Configure native auth for agents that need it (e.g. OpenClaw auth-profiles.json)
@@ -117,6 +125,24 @@ class AgentConnector {
     return { success: true };
   }
 
+  saveAgentInstanceEnv(agentName, env) {
+    const agent = this.config.getAgent(agentName);
+    if (!agent) throw new Error(`Agent '${agentName}' not found`);
+    const saved = this.config.updateAgentEnv(agentName, env);
+
+    // Preserve native auth side effects for agents that need them while
+    // keeping the model choice scoped to this individual agent.
+    try {
+      if ((agent.type || 'openclaw') === 'openclaw') {
+        const OpenClawAdapter = require('./adapters/openclaw');
+        const typeEnv = this.env.load(agent.type || 'openclaw');
+        OpenClawAdapter.configureNativeAuth({ ...typeEnv, ...saved });
+      }
+    } catch {}
+
+    return { success: true };
+  }
+
   resolveAgentEnv(agentType, saved) {
     return this.env.resolve(agentType, saved, this.registry);
   }
@@ -199,6 +225,14 @@ class AgentConnector {
     return this.config.getLogs(agentName, lines);
   }
 
+  tailLogs(opts = {}) {
+    return this.config.tailLogs(opts);
+  }
+
+  clearLogsInRange(opts = {}) {
+    return this.config.clearLogsInRange(opts);
+  }
+
   // -- Workspace API --
 
   async createWorkspace(opts) {

package/src/workspace-client.js

@@ -179,6 +179,29 @@ class WorkspaceClient {
     return events.map((e) => this._eventToMessage(e));
   }
 
+  /**
+   * Fetch the latest workspace.message.posted event id (head cursor).
+   * Used by adapters to skip past existing events on join in O(1) instead
+   * of paginating from the start. Returns null if the workspace is empty
+   * or the request fails.
+   */
+  async getHeadEventId(workspaceId, token) {
+    try {
+      const params = new URLSearchParams({
+        network: workspaceId,
+        type: 'workspace.message.posted',
+        sort: 'desc',
+        limit: '1',
+      });
+      const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
+      const result = data.data || data;
+      const events = (result && result.events) || [];
+      return events.length > 0 ? (events[0].id || null) : null;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Poll for pending messages targeted at an agent via GET /v1/events.
    * Returns { messages, cursor } where cursor is the last event ID.