@openagents-org/agent-launcher 0.2.145 → 0.2.147

package/package.json

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

package/src/adapters/base.js

@@ -70,7 +70,6 @@ class BaseAdapter {
     this._stopRequested = false;
     this.client = new WorkspaceClient(this.endpoint);
     this._lastEventId = null;
-    this._lastToolResultId = null;
     this._running = false;
     this._sessionId = null;  // issued by server on /v1/join; used to prove liveness
     this._processedIds = new Set();
@@ -653,31 +652,6 @@ class BaseAdapter {
         idleCount++;
       }
 
-      // Sidecar poll: A2UI tool_result events. These are the user's response
-      // to a UI spec this agent (or any agent in the network) emitted. We
-      // surface each one as a synthetic user message so the LLM sees it as
-      // the next turn and can react. Failures here don't break the main
-      // message poll.
-      try {
-        const toolResult = await this.client.pollToolResults(
-          this.workspaceId, this.token,
-          { after: this._lastToolResultId }
-        );
-        if (toolResult.cursor) this._lastToolResultId = toolResult.cursor;
-        for (const event of toolResult.events || []) {
-          const msgId = event.id;
-          if (msgId && this._processedIds.has(msgId)) continue;
-          if (msgId) this._processedIds.add(msgId);
-          const synth = synthesizeToolResultMessage(event);
-          if (synth) await this._dispatchMessage(synth);
-        }
-      } catch (e) {
-        // Non-fatal — log once per poll if it fails
-        if (pollCount <= 3 || pollCount % 20 === 0) {
-          this._log(`tool_result poll #${pollCount} failed: ${e.message}`);
-        }
-      }
-
       // Adaptive polling with warm plateau:
       //   Active (messages incoming):  2s
       //   Warm (≤5 min since last msg): 5s
@@ -811,15 +785,10 @@ class BaseAdapter {
   }
 
   async sendThinking(channel, content) {
-    // Strip ```a2ui blocks if they leak into Claude's intermediate thinking
-    // trace — the real spec gets emitted via sendResponse with proper
-    // payload.spec extraction, so showing the raw block here is just noise
-    // (and a duplicate). If stripping leaves the thinking message empty,
-    // skip it entirely.
-    const { cleanContent } = extractA2UISpec(content);
-    if (!cleanContent || !cleanContent.trim()) return;
+    // Skip empty thinking traces entirely.
+    if (!content || !content.trim()) return;
     try {
-      await this.client.sendMessage(this.workspaceId, channel, this.token, cleanContent, {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
         senderType: 'agent',
         senderName: this.agentName,
         messageType: 'thinking',
@@ -832,14 +801,11 @@ class BaseAdapter {
   }
 
   async sendResponse(channel, content) {
-    const { cleanContent, spec, specToolCallId } = extractA2UISpec(content);
     try {
-      await this.client.sendMessage(this.workspaceId, channel, this.token, cleanContent, {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
         senderType: 'agent',
         senderName: this.agentName,
         sessionId: this._sessionId,
-        spec,
-        specToolCallId,
       });
     } catch (e) {
       if (e instanceof SessionRevokedError) {
@@ -966,74 +932,4 @@ class BaseAdapter {
   }
 }
 
-// ------------------------------------------------------------------
-// A2UI helpers
-// ------------------------------------------------------------------
-
-/**
- * Pull the first ```a2ui ... ``` fenced block out of LLM-produced content.
- * Returns the content with the block stripped, the parsed spec, and a
- * tool-call id derived from `spec.tool_call_id` (if present) or a new one.
- * If no block is present or parsing fails, returns the content unchanged
- * with null spec — the message still goes out as plain markdown.
- */
-/**
- * Convert a workspace.tool_result event into a synthetic user-message
- * shape that the agent's _handleMessage can dispatch. The LLM sees this
- * as the next user turn — the content is a short, machine-readable line
- * the LLM can parse without ambiguity. The original spec it emitted is
- * already in the LLM's conversation history; the tool_call_id lets the
- * LLM correlate this back.
- */
-function synthesizeToolResultMessage(event) {
-  if (!event || !event.payload) return null;
-  const p = event.payload;
-  const actionId = p.action_id || '';
-  const toolCallId = p.tool_call_id || '';
-  let valueStr = '';
-  if (p.value !== undefined && p.value !== null) {
-    try { valueStr = JSON.stringify(p.value); } catch (_) { valueStr = String(p.value); }
-  }
-  const lines = [
-    '[ui_action]',
-    `action=${actionId}`,
-    toolCallId ? `tool_call_id=${toolCallId}` : null,
-    valueStr ? `value=${valueStr}` : null,
-  ].filter(Boolean);
-  const content = lines.join(' ');
-  const target = event.target || '';
-  return {
-    messageId: event.id || '',
-    sessionId: target.startsWith('channel/') ? target.replace('channel/', '') : target,
-    senderType: 'human',
-    senderName: 'user',
-    content,
-    mentions: [],
-    messageType: 'chat',
-    metadata: event.metadata || {},
-  };
-}
-
-function extractA2UISpec(content) {
-  if (!content || typeof content !== 'string') {
-    return { cleanContent: content, spec: null, specToolCallId: null };
-  }
-  const match = content.match(/```a2ui\s*\n([\s\S]*?)\n```/);
-  if (!match) return { cleanContent: content, spec: null, specToolCallId: null };
-
-  let spec;
-  try {
-    spec = JSON.parse(match[1]);
-  } catch (_) {
-    return { cleanContent: content, spec: null, specToolCallId: null };
-  }
-
-  const specToolCallId = (spec && spec.tool_call_id) || `tc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-  if (spec && spec.tool_call_id) delete spec.tool_call_id;
-
-  const cleanContent = content.replace(match[0], '').trim();
-  return { cleanContent, spec, specToolCallId };
-}
-
 module.exports = BaseAdapter;
-module.exports.extractA2UISpec = extractA2UISpec;

package/src/adapters/gemini.js

@@ -182,7 +182,41 @@ class GeminiAdapter extends BaseAdapter {
     return null;
   }
 
+  // The Gemini CLI refuses to run non-interactively unless an auth method is
+  // explicitly selected in ~/.gemini/settings.json ("Invalid auth method
+  // selected"), even when GEMINI_API_KEY is present. When the user configured an
+  // API key, select API-key auth (both the legacy flat and current nested
+  // schema) and disable folder-trust so `-y` isn't downgraded. We never override
+  // an existing non-api-key selection (e.g. a real OAuth sign-in).
+  _ensureGeminiAuth() {
+    if (this._geminiAuthReady) return;
+    this._geminiAuthReady = true;
+    try {
+      const env = this.agentEnv || process.env;
+      const apiKey = (env.GEMINI_API_KEY || env.GOOGLE_API_KEY || '').trim();
+      if (!apiKey) return; // OAuth / other — leave the user's setup alone.
+      const dir = path.join(os.homedir(), '.gemini');
+      fs.mkdirSync(dir, { recursive: true });
+      const file = path.join(dir, 'settings.json');
+      let settings = {};
+      try { settings = JSON.parse(fs.readFileSync(file, 'utf-8')) || {}; } catch {}
+      const current =
+        settings.selectedAuthType ||
+        (settings.security && settings.security.auth && settings.security.auth.selectedType);
+      if (current && current !== 'gemini-api-key') return; // respect explicit OAuth/Vertex.
+      settings.selectedAuthType = 'gemini-api-key';
+      settings.security = settings.security || {};
+      settings.security.auth = { ...(settings.security.auth || {}), selectedType: 'gemini-api-key' };
+      settings.security.folderTrust = { ...(settings.security.folderTrust || {}), enabled: false };
+      fs.writeFileSync(file, JSON.stringify(settings, null, 2));
+      this._log('Configured Gemini CLI for API-key auth (~/.gemini/settings.json)');
+    } catch (e) {
+      this._log(`gemini auth setup skipped: ${e.message}`);
+    }
+  }
+
   _buildGeminiCmd(prompt, channelName, { skipResume = false } = {}) {
+    this._ensureGeminiAuth();
     const geminiBin = this._findGeminiBinary();
     if (!geminiBin) {
       throw new Error('gemini CLI not found. Install with: npm install -g @google/gemini-cli');

package/src/adapters/workspace-prompt.js

@@ -462,7 +462,6 @@ function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = '
   );
   parts.push(buildBrowserDirective(browserEnabled));
   parts.push(buildCollaborationPrompt());
-  parts.push(buildA2UIPrompt());
 
   if (mode === 'plan') {
     parts.push(
@@ -476,83 +475,6 @@ function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = '
   return parts.join('\n');
 }
 
-/**
- * Teach the LLM how to emit interactive UI alongside its text response.
- * The frontend (OpenAgents Go) renders any A2UI-shaped JSON spec inline
- * in the chat bubble; the agent-connector strips the fenced block before
- * posting and ferries the spec via payload.spec.
- */
-function buildA2UIPrompt() {
-  return (
-    '\n## Rendering interactive UI\n' +
-    'When you want the user to interact with structured UI (a button choice, ' +
-    'a form, a chart, a table, a confirmation dialog) instead of just reading ' +
-    'text, emit a fenced code block tagged `a2ui` containing a JSON spec. The ' +
-    "frontend renders it inline below any markdown narration you write.\n\n" +
-    "The spec is a tree of `{ type, props, children?, action? }` nodes. " +
-    'Supported component types include `Stack`, `Heading`, `Text`, `Image`, ' +
-    '`Icon`, `Button`, `ChoiceList`, `ConfirmDialog`, `AmountInput`, `Card`, ' +
-    '`Divider`, `Spacer`, `Alert`, `LineChart`, `PieChart`, `AssetPrice`, ' +
-    '`BalanceCard`, `TransactionList`, `TransactionRow`. Unknown types render ' +
-    'as a placeholder chip, so feel free to compose freely.\n\n' +
-    'Interactive components attach an `action` object with a `name` field you ' +
-    'choose. Example:\n\n' +
-    '```a2ui\n' +
-    '{\n' +
-    '  "type": "Stack",\n' +
-    '  "props": { "direction": "vertical", "spacing": 12 },\n' +
-    '  "children": [\n' +
-    '    { "type": "Heading", "props": { "text": "Pick a time", "level": 2 } },\n' +
-    '    { "type": "Button", "props": { "label": "Morning", "action": { "name": "pick_morning" } } },\n' +
-    '    { "type": "Button", "props": { "label": "Evening", "action": { "name": "pick_evening" } } }\n' +
-    '  ]\n' +
-    '}\n' +
-    '```\n\n' +
-    '### Exact prop names (these are checked verbatim — guessing will render "No data")\n\n' +
-    'Layout / content:\n' +
-    '- `Stack` — props: `direction` ("vertical"|"horizontal"), `spacing`, `alignment`\n' +
-    '- `Card` — props: `title`, `padding`, `cornerRadius`\n' +
-    '- `Divider`, `Spacer` — props: `size`, `orientation`\n' +
-    '- `Heading` — props: `text`, `level` (1–4)\n' +
-    '- `Text` — props: `content` **(NOT `text`)**, `style`, `weight`, `color`\n' +
-    '- `Image` — props: `url`, `name`, `contentMode`, `width`, `height`\n' +
-    '- `Icon` — props: `name`, `size`, `color`\n\n' +
-    'Interactive:\n' +
-    '- `Button` — props: `label`, `style` ("primary"|"secondary"|"destructive"), `icon`, `disabled`, `action: {name, params?}`\n' +
-    '- `ConfirmDialog` — props: `title`, `message`, `confirmLabel`, `cancelLabel`, `triggerLabel`, `action`\n' +
-    '- `ChoiceList` — props: `question`, `options: [{id, label}]`, `action`\n' +
-    '- `AmountInput` — props: `label`, `placeholder`, `currency`, `action`\n' +
-    '- `input` (lowercase) — props: `inputType` ("text"|"choice"|"number"|"date"), `id`, `label`, `placeholder`, `options`\n\n' +
-    'Feedback:\n' +
-    '- `Alert` — props: `title`, `message`, `severity` ("info"|"success"|"warning"|"error"), `dismissible`, `action`\n\n' +
-    'Charts (Swift Charts under the hood — needs **non-empty** data with the right key):\n' +
-    '- `LineChart` — props: `title`, `color`, `points: [{x, y}]` **(NOT `data`)**\n' +
-    '- `PieChart` — props: `title`, `segments: [{label, value, color?}]` **(NOT `slices`)**, `showLegend`\n' +
-    '- `chart` (lowercase) — simple sparkline/bar: props: `style` ("sparkline"|"bar"), `data: [number, ...]`, `labels`, `color`\n\n' +
-    'Data display:\n' +
-    '- `metric` (lowercase) — props: `label`, `value`, `caption`, `captionColor`, `icon`\n' +
-    '- `list` (lowercase) — props: `items: [{title, subtitle, trailing, icon}]`, `maxVisible`, `expandLabel`\n' +
-    '- `table` (lowercase) — **key-value rows only, not multi-column**: props: `rows: [{label, value}]`, `maxVisible`\n\n' +
-    'There is no multi-column data table in the catalog. For tabular data with ' +
-    'columns you have two choices: (a) use `list` with title/subtitle/trailing ' +
-    'mapped to your columns, or (b) compose a Stack of horizontal Stacks of Text ' +
-    'manually. Pick whichever reads better.\n\n' +
-    'If your data is empty or you can\'t fit it into the available primitives, ' +
-    'fall back to plain markdown — don\'t emit a spec just to wrap text in a card.\n\n' +
-    'When the user interacts with a rendered component, you will receive a ' +
-    "user message shaped like `[ui_action] action=pick_morning tool_call_id=... value=...`. " +
-    "Use the `action` name (which you chose) to decide what to do next; the " +
-    "spec you emitted earlier is in your conversation history for context.\n\n" +
-    'Use a spec when:\n' +
-    '- The user needs to make a discrete choice (offer buttons rather than ' +
-    'asking them to type a free-form answer).\n' +
-    '- Structured data is easier to scan as a chart or table than as prose.\n' +
-    '- You need explicit confirmation before a destructive action.\n' +
-    "- A form would gather several fields faster than back-and-forth chat.\n\n" +
-    "Don't emit a spec for ordinary prose answers — narration alone is fine.\n"
-  );
-}
-
 /**
  * Build the full system prompt for OpenClaw/non-MCP agents.
  */
@@ -561,7 +483,6 @@ function buildOpenclawSystemPrompt({ agentName, workspaceId, channelName, endpoi
   parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode));
   parts.push(buildBrowserDirective(browserEnabled));
   parts.push(buildCollaborationPrompt());
-  parts.push(buildA2UIPrompt());
   parts.push(buildModePrompt(mode));
   parts.push(buildApiSkillsPrompt({
     endpoint, workspaceId, token, agentName, channelName, disabledModules, mode,

package/src/cli.js

@@ -103,6 +103,19 @@ async function cmdDown(connector) {
   }
 }
 
+async function cmdRestart(connector, flags) {
+  // Stop then start. stopDaemon() already SIGTERM/SIGKILLs and waits for the
+  // process to die, but poll getDaemonPid() (which checks liveness) until the
+  // pid clears so the singleton guard in cmdUp can't trip on a not-yet-gone
+  // daemon and refuse to start.
+  const stopped = connector.stopDaemon();
+  print(stopped ? 'Daemon stopped' : 'Daemon was not running');
+  for (let i = 0; i < 25 && connector.getDaemonPid(); i++) {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  await cmdUp(connector, flags);
+}
+
 async function cmdStatus(connector) {
   const pid = connector.getDaemonPid();
   if (!pid) {
@@ -134,6 +147,18 @@ async function cmdCreate(connector, flags, positional) {
   const type = flags.type || 'openclaw';
   const role = flags.role || 'worker';
 
+  // Validate the runtime type BEFORE creating any local entry. A typo'd or
+  // otherwise unknown type (e.g. "calude") must not leave a broken agent in
+  // config — an uninstalled-but-valid type is fine and handled further down.
+  if (!connector.registry.getEntry(type)) {
+    const known = connector.registry.getCatalogSync().map((e) => e.name).sort();
+    print(`Error: unknown agent type '${type}'.`);
+    print(`Supported types: ${known.join(', ')}`);
+    print('Run `agn search` to browse available agent types.');
+    process.exitCode = 1;
+    return;
+  }
+
   try {
     connector.addAgent({ name, type, role, path: flags.path || process.cwd() });
 
@@ -708,6 +733,7 @@ async function cmdHelp() {
 Commands:
   up [--foreground]           Start daemon (background by default)
   down                        Stop daemon
+  restart [--foreground]      Restart daemon (down + up)
   status                      Show agent status
   list                        List configured agents
   create <name> [--type T]    Create a new agent
@@ -792,6 +818,7 @@ async function main() {
     tui: () => { const { run } = require('./tui'); run(); },
     up: () => cmdUp(connector, flags),
     down: () => cmdDown(connector),
+    restart: () => cmdRestart(connector, flags),
     status: () => cmdStatus(connector),
     list: () => cmdList(connector),
     create: () => cmdCreate(connector, flags, positional),

package/src/daemon.js

@@ -235,15 +235,17 @@ class Daemon {
     // Refuse to start if an existing daemon is already running.
     // Without this check, repeated `agn up` invocations would spawn
     // multiple daemons that each process the same message → duplicate
-    // bot replies.
-    const existingPid = Daemon._readPid(pidFile);
-    if (existingPid && Daemon._isAlive(existingPid)) {
+    // bot replies. Check BOTH the pid file and the status file (a live daemon
+    // rewrites the latter every 5s with its own pid): a clobbered/stale pid
+    // file must not let a duplicate slip past this guard.
+    const existingPid = Daemon.runningDaemonPid(configDir);
+    if (existingPid) {
       console.error(`Daemon already running (PID ${existingPid}).`);
       console.error(`Run 'agn down' first, or 'agn status' to check.`);
       process.exit(1);
     }
     // Stale pid file — clean up before spawning fresh
-    if (existingPid) {
+    if (Daemon._readPid(pidFile)) {
       try { fs.unlinkSync(pidFile); } catch {}
     }
 
@@ -287,41 +289,53 @@ class Daemon {
     const pidFile = path.join(configDir, 'daemon.pid');
     const statusFile = path.join(configDir, 'daemon.status.json');
 
-    const pid = Daemon._readPid(pidFile);
-    if (!pid) return false;
-
-    try {
-      if (IS_WINDOWS) {
-        execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore', timeout: 5000 });
-      } else {
-        process.kill(pid, 'SIGTERM');
-      }
-    } catch {}
-
-    // Always clean up PID and status files after kill attempt
-    try { fs.unlinkSync(pidFile); } catch {}
-    try { fs.unlinkSync(statusFile); } catch {}
-
-    // Wait briefly for process to die
-    for (let i = 0; i < 5; i++) {
-      if (!Daemon._isAlive(pid)) return true;
-      execSync(IS_WINDOWS ? 'ping -n 2 127.0.0.1 >nul' : 'sleep 0.5', {
-        stdio: 'ignore', timeout: 5000,
-      });
+    // Resolve the REAL running daemon(s) from BOTH the pid file and the status
+    // file. A live daemon rewrites the status file every 5s with its own pid,
+    // so when the pid file is stale/clobbered the status file is the only
+    // record of the actual process. The old code trusted only the pid file:
+    // `agn down` would signal a dead pid, delete the files, report "Daemon
+    // stopped", and leave the real daemon orphaned — which then blocked every
+    // subsequent `agn up` ("already running") and kept its agents wedged.
+    const pids = Daemon._liveDaemonPids(configDir);
+
+    // SIGTERM every distinct live pid.
+    for (const pid of pids) {
+      try {
+        if (IS_WINDOWS) {
+          execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore', timeout: 5000 });
+        } else {
+          process.kill(pid, 'SIGTERM');
+        }
+      } catch {}
     }
 
-    // Force kill
-    try {
-      if (IS_WINDOWS) {
-        execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore', timeout: 5000 });
-      } else {
-        process.kill(pid, 'SIGKILL');
+    // Wait briefly, then SIGKILL any survivor that ignored SIGTERM (this is
+    // what today's zombie required — a foreground daemon that didn't exit on
+    // SIGTERM).
+    for (const pid of pids) {
+      let alive = Daemon._isAlive(pid);
+      for (let i = 0; alive && i < 5; i++) {
+        execSync(IS_WINDOWS ? 'ping -n 2 127.0.0.1 >nul' : 'sleep 0.5', {
+          stdio: 'ignore', timeout: 5000,
+        });
+        alive = Daemon._isAlive(pid);
       }
-    } catch {}
+      if (alive) {
+        try {
+          if (IS_WINDOWS) {
+            execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore', timeout: 5000 });
+          } else {
+            process.kill(pid, 'SIGKILL');
+          }
+        } catch {}
+      }
+    }
 
+    // Always clear BOTH sources of truth so a fresh `agn up` starts clean.
     try { fs.unlinkSync(pidFile); } catch {}
     try { fs.unlinkSync(statusFile); } catch {}
-    return true;
+
+    return pids.length > 0;
   }
 
   /**
@@ -331,14 +345,18 @@ class Daemon {
     const pidFile = path.join(configDir, 'daemon.pid');
     const statusFile = path.join(configDir, 'daemon.status.json');
     const pid = Daemon._readPid(pidFile);
-    if (!pid) return null;
+    if (pid && Daemon._isAlive(pid)) return pid;
 
-    if (!Daemon._isAlive(pid)) {
-      Daemon._cleanupStaleDaemonFiles(pidFile, statusFile);
-      return null;
-    }
+    // pid file missing or stale — fall back to the status file so `agn status`
+    // reports the SAME live daemon the `agn up` singleton guard detects.
+    // Otherwise status says "not running" (dead pid file) while up refuses
+    // ("already running", from the status file) — the exact contradiction that
+    // hid today's orphaned daemon.
+    const live = Daemon.runningDaemonPid(configDir);
+    if (live) return live;
 
-    return pid;
+    Daemon._cleanupStaleDaemonFiles(pidFile, statusFile);
+    return null;
   }
 
   // ---------------------------------------------------------------------------
@@ -997,12 +1015,27 @@ class Daemon {
    * stopped for a legitimate restart doesn't block the replacement.
    */
   static runningDaemonPid(configDir) {
+    return Daemon._liveDaemonPids(configDir)[0] || null;
+  }
+
+  /**
+   * Return all distinct live daemon PIDs for this configDir (never including
+   * the calling process), gathered from BOTH the pid file and the status file.
+   * The pid file is considered first so its PID sorts ahead of the status
+   * file's. Used by the singleton guard, `agn status`, and `agn down` so every
+   * command agrees on which process(es) are the daemon — the divergence that
+   * let a stale pid file orphan a running daemon.
+   */
+  static _liveDaemonPids(configDir) {
     const self = process.pid;
-    const isOtherAlive = (pid) =>
-      pid && pid !== self && Daemon._isAlive(pid);
+    const pids = [];
+    const consider = (pid) => {
+      if (pid && pid !== self && Daemon._isAlive(pid) && !pids.includes(pid)) {
+        pids.push(pid);
+      }
+    };
 
-    const pidFromFile = Daemon._readPid(path.join(configDir, 'daemon.pid'));
-    if (isOtherAlive(pidFromFile)) return pidFromFile;
+    consider(Daemon._readPid(path.join(configDir, 'daemon.pid')));
 
     try {
       const statusFile = path.join(configDir, 'daemon.status.json');
@@ -1011,11 +1044,11 @@ class Daemon {
       // unrelated process can't masquerade as a live daemon.
       if (age < 30000) {
         const raw = JSON.parse(fs.readFileSync(statusFile, 'utf-8'));
-        const pid = raw && raw.pid;
-        if (isOtherAlive(pid)) return pid;
+        consider(raw && raw.pid);
       }
     } catch {}
-    return null;
+
+    return pids;
   }
 }
 

package/src/installer.js

@@ -356,6 +356,57 @@ class Installer {
     );
   }
 
+  // Hermes's install.ps1 can print "[X] Installation failed" (e.g. its bundled
+  // `uv` step fails) yet still exit 0, so exit-code-only success is unreliable.
+  // Confirm a real hermes binary exists before recording the install. Mirrors
+  // the paths the HermesAdapter._findHermesBinary() searches.
+  _verifyHermesBinary() {
+    try { clearBinaryLookupCache(); } catch {}
+    const isWin = process.platform === 'win32';
+    const home = os.homedir();
+    const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+    const candidates = [];
+    const resolved = this._whichBinary('hermes');
+    if (resolved) candidates.push(resolved);
+    if (isWin) {
+      candidates.push(
+        path.join(localAppData, 'hermes', 'hermes-agent', 'venv', 'Scripts', 'hermes.exe'),
+        path.join(localAppData, 'hermes', 'hermes-agent', 'venv', 'Scripts', 'hermes.cmd'),
+        path.join(localAppData, 'hermes', 'bin', 'hermes.exe'),
+        path.join(localAppData, 'hermes', 'bin', 'hermes.cmd'),
+        path.join(home, '.hermes', 'bin', 'hermes.exe'),
+        path.join(home, '.hermes', 'bin', 'hermes.cmd'),
+        path.join(home, '.local', 'bin', 'hermes.exe'),
+        path.join(home, '.local', 'bin', 'hermes.cmd'),
+      );
+    } else {
+      candidates.push(
+        path.join(home, '.hermes', 'bin', 'hermes'),
+        path.join(home, '.local', 'bin', 'hermes'),
+        '/opt/homebrew/bin/hermes',
+        '/usr/local/bin/hermes',
+      );
+    }
+    let found = null;
+    for (const c of candidates) {
+      try { if (c && fs.existsSync(c)) { found = c; break; } } catch {}
+    }
+    return found ? { path: found } : null;
+  }
+
+  _hermesBinaryNotFoundMessage() {
+    const isWin = process.platform === 'win32';
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    const expected = isWin
+      ? path.join(localAppData, 'hermes', 'hermes-agent', 'venv', 'Scripts', 'hermes.exe')
+      : path.join(os.homedir(), '.hermes', 'bin', 'hermes');
+    return (
+      'Hermes install command completed, but the Hermes CLI binary could not be found\n' +
+      "(its installer can report a uv/setup failure yet still exit 0).\n\n" +
+      `Expected path:\n${expected}`
+    );
+  }
+
   /**
    * Find the binary path for an agent type.
    */
@@ -953,6 +1004,18 @@ class Installer {
             }
             if (onData) onData(`\nAmp CLI resolved: ${amp.path}${amp.version ? ` (${amp.version})` : ''}\n`);
           }
+          // Hermes-only: its install.ps1 can exit 0 after a failed uv/setup step,
+          // so verify a real binary exists before recording the install.
+          if (agentType === 'hermes') {
+            const hermes = this._verifyHermesBinary();
+            if (!hermes) {
+              const msg = this._hermesBinaryNotFoundMessage();
+              if (onData) onData(`\n${msg}\n`);
+              reject(new Error(msg));
+              return;
+            }
+            if (onData) onData(`\nHermes CLI resolved: ${hermes.path}\n`);
+          }
           this._markInstalled(agentType);
           if (onData) onData(`\nDone! ${agentType} is now installed.\n`);
           resolve({ success: true, command: displayCmd });

package/src/update-check.js

@@ -88,20 +88,31 @@ async function checkForUpdate() {
 }
 
 /**
- * Walk up from __dirname until we find the enclosing node_modules; the
- * directory containing node_modules is the install prefix.
+ * Derive the npm `--prefix` for a global install from the npm binary location.
+ *
+ * npm resolves `-g` installs relative to a PREFIX, and the layout differs by
+ * platform:
+ *   Unix:    packages → {prefix}/lib/node_modules   (npm bin at {prefix}/bin)
+ *   Windows: packages → {prefix}/node_modules        (npm bin at {prefix})
+ *
+ * So the prefix is the PARENT of npm's bin dir on Unix, and the bin dir itself
+ * on Windows. The previous implementation walked up to the enclosing
+ * node_modules and returned the directory containing it — which on Unix is
+ * `{prefix}/lib`. Passing THAT as `--prefix` made npm append `lib/node_modules`
+ * again, installing into `{prefix}/lib/lib/node_modules` while the running `agn`
+ * (loaded from `{prefix}/lib/node_modules`) never changed: `agn update` reported
+ * success but silently no-op'd on every Unix host.
  */
-function detectInstallPrefix() {
-  let dir = __dirname;
-  for (let i = 0; i < 10; i++) {
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    if (path.basename(parent) === 'node_modules') {
-      return path.dirname(parent);
-    }
-    dir = parent;
-  }
-  return null;
+function npmPrefixFromBin(npmBin, platform = process.platform) {
+  if (!npmBin) return null;
+  // Use the target platform's path semantics so a Windows path resolves
+  // correctly even when this runs on a POSIX host (and vice versa).
+  const p = platform === 'win32' ? path.win32 : path.posix;
+  const binDir = p.dirname(npmBin);
+  // A bare name (e.g. 'npm' from the PATH hard-fallback) has no usable
+  // directory — let npm resolve its own default global prefix instead.
+  if (binDir === '.' || binDir === '') return null;
+  return platform === 'win32' ? binDir : p.dirname(binDir);
 }
 
 /**
@@ -139,7 +150,7 @@ function runUpdate(opts = {}) {
   const platform = opts.platform || process.platform;
   const spawn = opts.spawn || spawnSync;
   const npmBin = opts.npmBin || findNpmBin({ platform });
-  const prefix = opts.prefix !== undefined ? opts.prefix : detectInstallPrefix();
+  const prefix = opts.prefix !== undefined ? opts.prefix : npmPrefixFromBin(npmBin, platform);
   // Use a GLOBAL install (-g). A LOCAL install (`npm install <pkg> --prefix
   // <dir>`) treats <dir> as a project root and prunes every node_modules entry
   // not reachable from its package.json. When the prefix is the portable node
@@ -228,5 +239,6 @@ module.exports = {
   notifyAndMaybeUpdate,
   runUpdate,
   findNpmBin,
+  npmPrefixFromBin,
   currentVersion,
 };

package/src/workspace-client.js

@@ -156,15 +156,12 @@ class WorkspaceClient {
    */
   async sendMessage(workspaceId, channelName, token, content, {
     senderType = 'agent', senderName, messageType = 'chat', metadata, attachments, sessionId,
-    spec, specToolCallId,
   } = {}) {
     const sourcePrefix = senderType === 'agent' ? 'openagents' : 'human';
     const source = senderName ? `${sourcePrefix}:${senderName}` : `${sourcePrefix}:unknown`;
 
     const payload = { content, message_type: messageType };
     if (attachments && attachments.length) payload.attachments = attachments;
-    if (spec) payload.spec = spec;
-    if (specToolCallId) payload.spec_tool_call_id = specToolCallId;
 
     return this.sendEvent(workspaceId, {
       type: 'workspace.message.posted',
@@ -175,30 +172,6 @@ class WorkspaceClient {
     }, token, sessionId);
   }
 
-  /**
-   * Poll workspace.tool_result events — the client's response to an agent's
-   * render_ui invocation. Returns events directly (no message normalization)
-   * because the caller treats them differently than chat messages.
-   */
-  async pollToolResults(workspaceId, token, { after, limit = 50 } = {}) {
-    const params = new URLSearchParams({
-      network: workspaceId,
-      type: 'workspace.tool_result',
-      limit: String(limit),
-    });
-    if (after) params.set('after', after);
-
-    const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
-    const result = data.data || data;
-    const events = (result && result.events) || [];
-
-    let cursor = null;
-    if (events.length > 0) {
-      cursor = events[events.length - 1].id || null;
-    }
-    return { events, cursor };
-  }
-
   /**
    * Poll messages in a channel via GET /v1/events.
    * @returns {Array} message-compatible objects
@@ -275,6 +248,11 @@ class WorkspaceClient {
     const params = new URLSearchParams({
       network: workspaceId,
       type: 'workspace.message.posted',
+      // Server-side pre-filter: only return events routed to this agent (plus
+      // untargeted ones) instead of the whole network's traffic. Backward
+      // compatible — older backends ignore the unknown param and return
+      // everything, so the client-side filter below stays as the safety net.
+      target_agents: agentName,
       limit: String(limit),
     });
     if (after) params.set('after', after);
@@ -283,12 +261,23 @@ class WorkspaceClient {
     const result = data.data || data;
     const events = (result && result.events) || [];
 
+    // Prefer the server's next_cursor: with server-side target filtering the
+    // last returned event lags the stream tip, so advancing by it alone would
+    // re-scan the same range every poll. next_cursor jumps past other agents'
+    // events once ours are drained. Older backends don't send it — fall back
+    // to the last returned event id (they return the full stream, so that IS
+    // the tip).
     let cursor = null;
-    if (events.length > 0) {
+    if (result && result.next_cursor) {
+      cursor = result.next_cursor;
+    } else if (events.length > 0) {
       cursor = events[events.length - 1].id || null;
     }
 
-    // Filter for messages targeted at this agent.
+    // Filter for messages targeted at this agent. With a targeting-aware
+    // backend this is mostly a no-op (server already narrowed the set); it
+    // remains authoritative for older backends and for the untargeted events
+    // the server includes as a safe superset.
     //
     // target_agents semantics:
     //   • absent            → legacy server with no routing decision
@@ -802,6 +791,14 @@ class WorkspaceClient {
         method: 'GET',
         headers,
         timeout,
+        // Hard end-to-end deadline. The `timeout` option above is only a SOCKET
+        // inactivity timeout — it is NOT armed until a socket exists, so it does
+        // not bound DNS resolution or TCP connect. During a network partition a
+        // request stuck in getaddrinfo/connect never fires 'timeout', so the
+        // await never settles and the caller's single poll loop wedges forever
+        // (the agent stays "online" via its separate heartbeat but stops
+        // consuming messages). AbortSignal.timeout fires in ANY phase.
+        signal: AbortSignal.timeout(timeout),
       }, (res) => {
         let data = '';
         res.on('data', (chunk) => { data += chunk; });
@@ -836,6 +833,7 @@ class WorkspaceClient {
         method: 'GET',
         headers,
         timeout,
+        signal: AbortSignal.timeout(timeout), // hard deadline (covers DNS/connect); see _get
       }, (res) => {
         const chunks = [];
         res.on('data', (chunk) => { chunks.push(chunk); });
@@ -868,6 +866,7 @@ class WorkspaceClient {
         method: 'POST',
         headers: { ...headers, 'Content-Length': Buffer.byteLength(jsonBody) },
         timeout,
+        signal: AbortSignal.timeout(timeout), // hard deadline (covers DNS/connect); see _get
       }, (res) => {
         let data = '';
         res.on('data', (chunk) => { data += chunk; });
@@ -910,6 +909,7 @@ class WorkspaceClient {
         method: 'PUT',
         headers: { ...headers, 'Content-Length': Buffer.byteLength(jsonBody) },
         timeout,
+        signal: AbortSignal.timeout(timeout), // hard deadline (covers DNS/connect); see _get
       }, (res) => {
         let data = '';
         res.on('data', (chunk) => { data += chunk; });
@@ -952,6 +952,7 @@ class WorkspaceClient {
         method: 'PATCH',
         headers: { ...headers, 'Content-Length': Buffer.byteLength(jsonBody) },
         timeout,
+        signal: AbortSignal.timeout(timeout), // hard deadline (covers DNS/connect); see _get
       }, (res) => {
         let data = '';
         res.on('data', (chunk) => { data += chunk; });
@@ -987,6 +988,7 @@ class WorkspaceClient {
         method: 'DELETE',
         headers,
         timeout: 15000,
+        signal: AbortSignal.timeout(15000), // hard deadline (covers DNS/connect); see _get
       }, (res) => {
         let data = '';
         res.on('data', (chunk) => { data += chunk; });