oomi-ai 0.8.5 → 0.9.1

package/README.md

@@ -109,7 +109,7 @@ oomi connect --runtime hermes --name hermes --app-url https://www.oomi.ai
 oomi connect --runtime command --name my-agent --command '["/absolute/path/to/adapter"]' --app-url https://www.oomi.ai
 ```
 
-Use the user's app URL when provided. Hermes supports `--profile <profile>` and `--resume <exact-session-id>`. Without `--resume`, Oomi starts a persistent conversation with the same configured agent. Do not use `latest` or claim that an existing chat session was transferred unless its exact ID was selected. With oomi-ai 0.8.2+, an already-open Hermes conversation uses its existing local gateway owner and exact profile/session. Oomi attaches as another client; it never closes desktop, clears history, deletes a session lock, or substitutes a new chat. When no live owner exists, Hermes uses `chat --quiet --query-file -` and resumes the exact returned `session_id` on subsequent turns.
+Use the user's app URL when provided. Hermes supports `--profile <profile>` and `--resume <exact-session-id>`. Without `--resume`, Oomi starts a persistent conversation with the same configured agent. Do not use `latest` or claim that an existing chat session was transferred unless its exact ID was selected. With oomi-ai 0.8.2+, an already-open Hermes conversation uses its existing local gateway owner and exact profile/session. Oomi attaches as another client; it never closes desktop, clears history, deletes a session lock, or substitutes a new chat. When no live owner exists, an Oomi-owned conversation (no `--resume`) runs on a warm `hermes acp` process with oomi-ai 0.9.0+: replies stream as they are written and stop when the person interrupts. From 0.9.1 the bridge starts Hermes and reopens recent conversations ahead of time (at bridge start and when a call opens), so the first message doesn't wait for Hermes to start. Hermes permission requests are denied, as `chat --quiet` denies dangerous commands; ordinary file edits run as they do in quiet mode. A conversation moving from the CLI starts a new Hermes session that receives the recent Oomi history. `--resume` conversations, Hermes without ACP, and `--hermes-transport cli` use `chat --quiet --query-file -` and resume the exact returned `session_id` on subsequent turns.
 
 Shared desktop conversations require Hermes's loopback WebSocket gateway, active-session discovery, and durable prompt/reply row IDs. Busy conversations ask you to retry after the current task. If a simultaneous desktop send queues your message without a reply receipt, or the connection drops after sending, check the same Hermes chat before resending. Oomi cannot safely repeat an uncertain action. Human approvals stay in the existing Hermes desktop UI. Shared photo submission is not yet supported; use Hermes desktop for that photo. Older or terminal-only owners without a shared gateway receive an actionable error, never a competing process. The shared owner keeps its existing environment, so use the explicit Oomi `--connection NAME` for account commands.
 

package/bin/oomi-ai.js

@@ -210,6 +210,7 @@ Commands:
   connect --runtime openclaw|hermes|grokbot|command [--name CONNECTION] [--agent-name "Your name"] [--app-url URL]
     Verify the selected local agent, pair once, start its bridge, and return an Auth Link.
     Hermes: --profile PROFILE and --resume SESSION select the intended agent/session.
+    Hermes: --hermes-transport auto|acp|cli (default auto streams replies over ACP when Hermes supports it).
     Other agents: --command '["/absolute/path/to/adapter"]' (JSON stdin / JSON stdout).
     --cwd PATH selects the agent working directory; --name isolates multiple agents.
     Installs automatic startup on macOS/Linux. --no-service opts into external supervision.
@@ -2538,6 +2539,7 @@ async function startOpenclawBridge(flags) {
   const localRuntime = bridgeState.localAgent
     ? new LocalAgentRuntime({ ...bridgeState.localAgent, connection: bridgeConnectionName }, path.dirname(resolveBridgeStatePath()), (health) => updateBridgeStatus(health))
     : null;
+  localRuntime?.warm();
   const gateway = localRuntime ? { gatewayUrl: 'local-agent:', configPath: resolveBridgeStatePath() } : readOpenclawGatewayConfig();
   if (!localRuntime && !gateway.token && !gateway.password) {
     throw new Error(`Gateway auth token/password not found in ${gateway.configPath}.`);
@@ -3599,6 +3601,8 @@ async function startOpenclawBridge(flags) {
         const sessionId = String(payload.sessionId || '').trim();
         if (!sessionId) return;
         bridgeDebugLog(`[bridge] client.open ${sessionId}`);
+        // A call is starting: make sure the agent is awake before the caller's first words.
+        if (classifyBridgeSessionScope(sessionId) === 'voice') localRuntime?.warm();
         getOrCreateGatewaySession(sessionId);
         return;
       }
@@ -3826,7 +3830,7 @@ async function startOpenclawBridge(flags) {
     stopChannelWorker();
     stopIdentityWorker();
     stopRoutineWorker();
-    if (localRuntime) await localRuntime.queue;
+    if (localRuntime) { await localRuntime.queue; localRuntime.close(); }
     if (reconnectState.timer) {
       clearTimeout(reconnectState.timer);
       reconnectState.timer = null;
@@ -4472,9 +4476,12 @@ async function connectLocalAgent(flags) {
       profile: flags.profile ?? saved?.profile,
       'hermes-home': saved?.hermesHome,
       resume: flags.resume ?? saved?.resume,
+      'hermes-transport': flags['hermes-transport'] ?? saved?.hermesTransport,
       cwd: flags.cwd ?? saved?.cwd,
     });
-    if (saved && JSON.stringify(saved) !== JSON.stringify(state.localAgent)) throw new Error('This name already identifies a different agent configuration. Use a new --name to change its command, profile, session, or working directory.');
+    // How Hermes is reached (ACP or the quiet CLI) may change; the agent itself may not.
+    const identity = ({ hermesTransport, ...rest } = {}) => JSON.stringify(rest);
+    if (saved && identity(saved) !== identity(state.localAgent)) throw new Error('This name already identifies a different agent configuration. Use a new --name to change its command, profile, session, or working directory.');
   }
   if (!previous.verifiedAt || isTruthyFlag(flags.verify)) {
   console.log(`Verifying ${runtime}${state.localAgent?.profile ? ` profile ${state.localAgent.profile}` : ''} with a local test message...`);

package/lib/hermesAcp.js

@@ -0,0 +1,372 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+// Hermes over the Agent Client Protocol (`hermes acp`): one warm process per Hermes
+// profile, kept between turns, whose replies stream as they are written and can be
+// cancelled mid-turn. JSON-RPC 2.0, one message per line, over stdio.
+//
+// Approvals stay at least as strict as `hermes chat --quiet`, which denies dangerous
+// commands without asking: Oomi denies every permission request Hermes sends. Sessions
+// run in Hermes's "Don't ask" edit mode, so ordinary file edits work as they do in quiet
+// mode and only sensitive paths (.git, .ssh, .env) reach that denial.
+
+const PROTOCOL_VERSION = 1;
+const START_TIMEOUT_MS = 20000;
+const CONTROL_TIMEOUT_MS = 30000;
+const UNAVAILABLE_BACKOFF_MS = 10 * 60 * 1000;
+const TEXT_INTERVAL_MS = 80;
+const MAX_REPLY_CHARS = 4 * 1024 * 1024;
+const EDIT_MODE = 'dont_ask';
+const IMAGE_TYPES = { '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png', '.webp': 'image/webp', '.gif': 'image/gif' };
+const SEED_MESSAGES = 12;
+const SEED_MESSAGE_CHARS = 800;
+const SEED_TOTAL_CHARS = 6000;
+
+// Only fixed messages cross the bridge; Hermes diagnostics may hold credentials or tool output.
+export class HermesAcpError extends Error {
+  constructor(code, message, { notStarted = false, runtimeReady = true } = {}) {
+    super(message); this.code = code; this.notStarted = notStarted; this.runtimeReady = runtimeReady;
+  }
+}
+const unavailable = () => new HermesAcpError('hermes_acp_unavailable', 'Hermes could not start its streaming connection.', { notStarted: true, runtimeReady: false });
+const exited = () => new HermesAcpError('hermes_acp_exited', 'Hermes stopped while answering. Check Hermes on that computer before sending this message again.', { runtimeReady: false });
+
+const clients = new Map();
+const unavailableUntil = new Map();
+
+function clientKey(config) {
+  return JSON.stringify([config.command, config.hermesHome || '', config.profile || '', config.cwd || '', config.connection || '']);
+}
+
+/** False while a recent start attempt failed, so a broken install doesn't delay every turn. */
+export function hermesAcpAvailable(config) {
+  return (unavailableUntil.get(clientKey(config)) || 0) <= Date.now();
+}
+
+/** Drop the warm process, for example after another Hermes client changed the conversation. */
+export function resetHermesAcp(config) {
+  const key = clientKey(config);
+  clients.get(key)?.close();
+  clients.delete(key);
+}
+
+export function closeHermesAcpClients() {
+  for (const client of clients.values()) client.close();
+  clients.clear();
+  unavailableUntil.clear();
+}
+
+function hermesAcpClient(config) {
+  const key = clientKey(config);
+  let client = clients.get(key);
+  if (!client || client.closed) {
+    client = new HermesAcpClient(config, () => unavailableUntil.set(key, Date.now() + UNAVAILABLE_BACKOFF_MS));
+    clients.set(key, client);
+  }
+  return client;
+}
+
+class HermesAcpClient {
+  constructor(config, onUnavailable) {
+    this.config = config;
+    this.onUnavailable = onUnavailable;
+    this.nextId = 0;
+    this.pending = new Map();
+    this.turns = new Map();
+    this.loaded = new Set();
+    this.replayed = new Map();
+    this.closed = false;
+    this.ready = null;
+  }
+
+  start() {
+    if (this.ready) return this.ready;
+    this.ready = this.spawnAndInitialize().catch((err) => {
+      this.onUnavailable();
+      this.close();
+      throw err instanceof HermesAcpError ? err : unavailable();
+    });
+    return this.ready;
+  }
+
+  async spawnAndInitialize() {
+    const { config } = this;
+    const args = config.command.slice(1);
+    if (config.profile) args.push('--profile', config.profile);
+    args.push('acp');
+    // The agent's own `oomi` commands (notify, routines, spaces) use this connection by default.
+    const env = { ...process.env, ...(config.hermesHome ? { HERMES_HOME: config.hermesHome } : {}), ...(config.connection ? { OOMI_CONNECTION: config.connection } : {}) };
+    const child = spawn(config.command[0], args, { env, cwd: config.cwd, shell: false, detached: process.platform !== 'win32', stdio: ['pipe', 'pipe', 'pipe'] });
+    this.child = child;
+    let buffered = '';
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (data) => {
+      buffered += data;
+      let newline;
+      while ((newline = buffered.indexOf('\n')) >= 0) {
+        const line = buffered.slice(0, newline).trim();
+        buffered = buffered.slice(newline + 1);
+        if (!line) continue;
+        let message;
+        try { message = JSON.parse(line); } catch { continue; } // Stray output is not protocol.
+        this.handle(message);
+      }
+    });
+    // Diagnostics may contain credentials or tool output; never forward them to Oomi.
+    child.stderr.resume();
+    child.stdin.on('error', () => {});
+    const spawnFailed = new Promise((_, reject) => child.once('error', () => reject(unavailable())));
+    spawnFailed.catch(() => {});
+    child.once('exit', () => this.exited());
+
+    const initialized = await Promise.race([
+      this.request('initialize', {
+        protocolVersion: PROTOCOL_VERSION,
+        clientCapabilities: {},
+        clientInfo: { name: 'oomi-ai', title: 'Oomi', version: packageVersion() },
+      }, START_TIMEOUT_MS),
+      spawnFailed,
+    ]).catch(() => { throw unavailable(); });
+    if (initialized?.protocolVersion !== PROTOCOL_VERSION) throw unavailable();
+  }
+
+  request(method, params, timeoutMs = CONTROL_TIMEOUT_MS) {
+    if (this.closed || !this.child) return Promise.reject(exited());
+    const id = ++this.nextId;
+    return new Promise((resolve, reject) => {
+      const timer = timeoutMs ? setTimeout(() => { this.pending.delete(id); reject(new HermesAcpError('hermes_acp_timeout', 'Hermes did not respond in time.')); }, timeoutMs) : null;
+      this.pending.set(id, { resolve, reject, timer });
+      this.write({ jsonrpc: '2.0', id, method, params });
+    });
+  }
+
+  notify(method, params) {
+    if (!this.closed && this.child) this.write({ jsonrpc: '2.0', method, params });
+  }
+
+  write(message) {
+    try { this.child.stdin.write(JSON.stringify(message) + '\n'); } catch { /* The exit handler reports it. */ }
+  }
+
+  handle(message) {
+    if (message.method && message.id !== undefined) return this.answer(message);
+    if (message.method === 'session/update') return this.update(message.params);
+    if (message.id === undefined || !this.pending.has(message.id)) return;
+    const pending = this.pending.get(message.id);
+    this.pending.delete(message.id);
+    clearTimeout(pending.timer);
+    if (message.error) pending.reject(Object.assign(new HermesAcpError('hermes_acp_rpc', 'Hermes rejected the request.'), { rpcCode: message.error.code }));
+    else pending.resolve(message.result ?? null);
+  }
+
+  // Requests from Hermes. Oomi offers no file or terminal access of its own, and denies
+  // every permission request (see the note at the top).
+  answer(message) {
+    if (message.method === 'session/request_permission') {
+      const options = Array.isArray(message.params?.options) ? message.params.options : [];
+      const deny = options.find((option) => option?.kind === 'reject_once') || options.find((option) => option?.kind === 'reject_always');
+      const outcome = deny ? { outcome: 'selected', optionId: deny.optionId } : { outcome: 'cancelled' };
+      this.write({ jsonrpc: '2.0', id: message.id, result: { outcome } });
+      return;
+    }
+    this.write({ jsonrpc: '2.0', id: message.id, error: { code: -32601, message: 'Not supported by Oomi.' } });
+  }
+
+  update(params) {
+    const sessionId = params?.sessionId;
+    if (!sessionId) return;
+    if (this.replayed.has(sessionId)) this.replayed.set(sessionId, this.replayed.get(sessionId) + 1);
+    const turn = this.turns.get(sessionId);
+    const update = params.update;
+    if (!turn || update?.sessionUpdate !== 'agent_message_chunk' || update.content?.type !== 'text') return;
+    turn.onChunk(String(update.content.text || ''), update.messageId);
+  }
+
+  exited() {
+    const error = exited();
+    this.closed = true;
+    for (const pending of this.pending.values()) { clearTimeout(pending.timer); pending.reject(error); }
+    this.pending.clear();
+    for (const turn of this.turns.values()) turn.fail(error);
+    this.turns.clear();
+  }
+
+  /**
+   * The ACP session for a conversation in this process: the one it already has, a stored one
+   * reloaded from Hermes's history, or a new one. `created` says whether history was lost.
+   */
+  async openSession(sessionId, { create = true } = {}) {
+    const cwd = this.config.cwd;
+    if (sessionId && this.loaded.has(sessionId)) return { sessionId, created: false };
+    if (sessionId) {
+      // Hermes answers a load for an unknown session with an empty success, so a session
+      // counts as found only when its history is replayed.
+      this.replayed.set(sessionId, 0);
+      try {
+        await this.request('session/load', { sessionId, cwd, mcpServers: [] });
+        if (this.replayed.get(sessionId) > 0) {
+          await this.prepare(sessionId);
+          return { sessionId, created: false };
+        }
+      } catch (err) {
+        if (err.code === 'hermes_acp_exited') throw err;
+      } finally { this.replayed.delete(sessionId); }
+    }
+    if (!create) return null;
+    const created = await this.request('session/new', { cwd, mcpServers: [] });
+    if (typeof created?.sessionId !== 'string' || !created.sessionId) throw unavailable();
+    await this.prepare(created.sessionId);
+    return { sessionId: created.sessionId, created: true };
+  }
+
+  async prepare(sessionId) {
+    // Without this mode Hermes asks before every file edit, which Oomi would deny.
+    await this.request('session/set_mode', { sessionId, modeId: EDIT_MODE }).catch(() => {});
+    this.loaded.add(sessionId);
+  }
+
+  prompt(sessionId, prompt, { signal, timeoutMs = 180000, onText } = {}) {
+    if (this.turns.has(sessionId)) return Promise.reject(new HermesAcpError('hermes_session_busy', 'Hermes is still answering in this conversation.', { notStarted: true }));
+    return new Promise((resolve, reject) => {
+      let text = '';
+      let sent = '';
+      let messageId;
+      let textTimer = null;
+      let settled = false;
+      const flush = () => {
+        textTimer = null;
+        if (text !== sent) { sent = text; onText?.(text); }
+      };
+      const finish = (callback, value) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer); clearTimeout(textTimer);
+        signal?.removeEventListener('abort', abort);
+        this.turns.delete(sessionId);
+        callback(value);
+      };
+      const cancel = (error) => {
+        this.notify('session/cancel', { sessionId });
+        finish(reject, error);
+      };
+      const abort = () => cancel(new HermesAcpError('cancelled', 'Agent turn cancelled.'));
+      const timer = setTimeout(() => cancel(new HermesAcpError('timeout', 'Agent turn timed out.')), timeoutMs);
+      this.turns.set(sessionId, {
+        onChunk: (chunk, id) => {
+          if (settled || !chunk) return;
+          // Words before and after a tool call are separate messages; keep them apart.
+          if (id && messageId && id !== messageId && text && !/\s$/.test(text)) text += '\n\n';
+          if (id) messageId = id;
+          if (text.length + chunk.length > MAX_REPLY_CHARS) return cancel(new HermesAcpError('too_long', 'Agent output exceeded 4 MiB.'));
+          text += chunk;
+          // Send the first words right away, then at most every TEXT_INTERVAL_MS.
+          if (!sent) flush();
+          else textTimer ??= setTimeout(flush, TEXT_INTERVAL_MS);
+        },
+        fail: (error) => finish(reject, error),
+      });
+      if (signal?.aborted) return abort();
+      signal?.addEventListener('abort', abort, { once: true });
+      this.request('session/prompt', { sessionId, prompt }, 0).then((result) => {
+        if (settled) return;
+        const reply = text.trim();
+        if (result?.stopReason === 'cancelled') return finish(reject, new HermesAcpError('cancelled', 'Agent turn cancelled.'));
+        if (result?.stopReason === 'refusal' && !reply) {
+          this.loaded.delete(sessionId);
+          return finish(reject, new HermesAcpError('hermes_session_unknown', 'Hermes no longer has this conversation.', { notStarted: true }));
+        }
+        if (!reply) return finish(reject, new HermesAcpError('empty_reply', 'Agent did not return a successful final reply.'));
+        clearTimeout(textTimer);
+        flush();
+        finish(resolve, reply);
+      }, (err) => finish(reject, err));
+    });
+  }
+
+  close() {
+    if (this.closed && !this.child) return;
+    this.closed = true;
+    const child = this.child;
+    this.child = null;
+    if (!child || child.exitCode !== null) return;
+    const terminate = (signal) => {
+      try {
+        if (process.platform !== 'win32' && child.pid) process.kill(-child.pid, signal);
+        else child.kill(signal);
+      } catch { /* Already exited. */ }
+    };
+    try { child.stdin.end(); } catch { /* Closed. */ }
+    terminate('SIGTERM');
+    setTimeout(() => terminate('SIGKILL'), 1000).unref();
+  }
+}
+
+let cachedVersion;
+function packageVersion() {
+  if (cachedVersion) return cachedVersion;
+  try { cachedVersion = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version; } catch { cachedVersion = '0.0.0'; }
+  return cachedVersion;
+}
+
+function textOf(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content.map((part) => (part?.type === 'text' ? part.text : part?.type === 'image' ? '[photo]' : '')).filter(Boolean).join(' ');
+}
+
+// A conversation that moves to a new Hermes session (from the quiet CLI, or after Hermes lost
+// it) keeps its thread: the first prompt carries the recent Oomi history.
+export function continuityPreamble(history) {
+  const recent = (Array.isArray(history) ? history : []).slice(-SEED_MESSAGES);
+  const lines = [];
+  let total = 0;
+  for (const message of recent) {
+    const words = textOf(message?.content).trim();
+    if (!words || !['user', 'assistant'].includes(message?.role)) continue;
+    const line = `${message.role === 'user' ? 'User' : 'You'}: ${words.length > SEED_MESSAGE_CHARS ? `${words.slice(0, SEED_MESSAGE_CHARS)}…` : words}`;
+    total += line.length;
+    if (total > SEED_TOTAL_CHARS) break;
+    lines.push(line);
+  }
+  if (!lines.length) return '';
+  return `For continuity, here is the recent part of this Oomi conversation:\n${lines.join('\n')}\n---\n`;
+}
+
+function promptBlocks(request, seed) {
+  const blocks = [{ type: 'text', text: `${seed}${request.message}` }];
+  const image = request.imagePaths?.[0];
+  if (image) {
+    const mimeType = IMAGE_TYPES[path.extname(image).toLowerCase()];
+    if (mimeType) blocks.push({ type: 'image', mimeType, data: fs.readFileSync(image).toString('base64') });
+  }
+  return blocks;
+}
+
+/**
+ * Starts Hermes ahead of the first message and reopens recent conversations, so a call's first
+ * turn doesn't wait for Hermes to start (about 3.5 s on the maintainer's Mac).
+ */
+export async function warmHermesAcp(config, sessionIds = []) {
+  const client = hermesAcpClient(config);
+  await client.start();
+  for (const sessionId of sessionIds) await client.openSession(sessionId, { create: false }).catch(() => null);
+}
+
+/** One Hermes turn over ACP. Returns the reply and the ACP session that holds the conversation. */
+export async function runHermesAcpTurn(config, request, { signal, timeoutMs = 180000, onText } = {}) {
+  const client = hermesAcpClient(config);
+  await client.start();
+  const continuing = request.runtimeTransport === 'acp' ? request.runtimeSessionId : '';
+  let { sessionId, created } = await client.openSession(continuing);
+  const seed = () => continuityPreamble(request.history);
+  let text;
+  try {
+    text = await client.prompt(sessionId, promptBlocks(request, created ? seed() : ''), { signal, timeoutMs, onText });
+  } catch (err) {
+    if (err.code !== 'hermes_session_unknown' || created) throw err;
+    ({ sessionId } = await client.openSession(''));
+    text = await client.prompt(sessionId, promptBlocks(request, seed()), { signal, timeoutMs, onText });
+  }
+  return { text, sessionId, transport: 'acp' };
+}

package/lib/localAgent.js

@@ -5,6 +5,7 @@ import { spawn } from 'node:child_process';
 import { EventEmitter } from 'node:events';
 import { createHash, randomUUID } from 'node:crypto';
 import { runSharedHermesTurn, hermesRefusal } from './hermesGateway.js';
+import { runHermesAcpTurn, hermesAcpAvailable, resetHermesAcp, warmHermesAcp } from './hermesAcp.js';
 import { grokbotConfig, runGrokbotTurn, completedGrokbotTurn } from './grokbotRuntime.js';
 
 const IMAGE_EXTENSIONS = { 'image/jpeg': '.jpg', 'image/png': '.png', 'image/webp': '.webp', 'image/gif': '.gif' };
@@ -81,6 +82,9 @@ export function localAgentConfig(flags) {
     if (!Array.isArray(command) || !command.length || command.some((arg) => typeof arg !== 'string') || !command[0]) throw new Error('--command must contain an executable and optional arguments.');
   }
   if (flags.resume === 'latest') throw new Error('Use an exact Hermes session ID, never latest.');
+  // Unset means auto: ACP when Hermes supports it, otherwise the quiet CLI.
+  const hermesTransport = flags['hermes-transport'] ? String(flags['hermes-transport']) : undefined;
+  if (hermesTransport && !['auto', 'acp', 'cli'].includes(hermesTransport)) throw new Error('--hermes-transport must be auto, acp, or cli.');
   let profile = flags.profile || '';
   let hermesHome;
   if (runtime === 'hermes') {
@@ -97,7 +101,15 @@ export function localAgentConfig(flags) {
     profile ||= 'default';
     if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(profile)) throw new Error('Specify a valid Hermes --profile.');
   }
-  return { runtime, command, profile, hermesHome, resume: flags.resume || '', cwd: path.resolve(flags.cwd || process.cwd()) };
+  return { runtime, command, profile, hermesHome, resume: flags.resume || '', ...(runtime === 'hermes' && hermesTransport ? { hermesTransport } : {}), cwd: path.resolve(flags.cwd || process.cwd()) };
+}
+
+// Hermes streams over ACP for conversations Oomi owns. A conversation pinned to an exact
+// existing Hermes session (--resume) stays on the quiet CLI, because ACP can only reopen
+// sessions it created.
+function usesHermesAcp(config) {
+  if (config.hermesTransport === 'cli' || config.resume) return false;
+  return config.hermesTransport === 'acp' || hermesAcpAvailable(config);
 }
 
 // No shell interpolation. Message bodies travel over stdin, never as executable code.
@@ -105,7 +117,18 @@ export async function runLocalAgent(config, request, options = {}) {
   if (config.runtime === 'grokbot') return runGrokbotTurn(config, request, options);
   if (config.runtime === 'hermes') {
     const shared = await runSharedHermesTurn(config, request, options);
-    if (shared) return shared;
+    if (shared) {
+      // Hermes desktop answered in this conversation; the warm ACP copy is now behind.
+      if (request.runtimeTransport === 'acp') resetHermesAcp(config);
+      return { ...shared, ...(request.runtimeTransport ? { transport: request.runtimeTransport } : {}) };
+    }
+    if (usesHermesAcp(config)) {
+      try { return await runHermesAcpTurn(config, request, options); }
+      catch (err) {
+        // Only a Hermes that can't start ACP falls back, and only before anything was sent.
+        if (err.code !== 'hermes_acp_unavailable' || config.hermesTransport === 'acp') throw err;
+      }
+    }
   }
   try { return await runAgentProcess(config, request, options); }
   catch (err) {
@@ -120,6 +143,7 @@ export async function runLocalAgent(config, request, options = {}) {
 }
 
 function runAgentProcess(config, request, { signal, timeoutMs = 180000 } = {}) {
+  if (config.runtime === 'hermes') request = { ...request, transport: 'cli' };
   return new Promise((resolve, reject) => {
     const args = config.command.slice(1);
     if (config.runtime === 'hermes') {
@@ -176,7 +200,7 @@ function runAgentProcess(config, request, { signal, timeoutMs = 180000 } = {}) {
           ? { text: output, sessionId: diagnostics.match(/(?:^|\n)session_id:\s*([A-Za-z0-9_-]+)\s*(?:\n|$)/)?.[1] }
           : JSON.parse(output);
         if (!result || (config.runtime === 'hermes' && !result.sessionId) || typeof result.text !== 'string' || !result.text.trim()) throw new Error();
-        resolve({ text: result.text.trim(), sessionId: result.session_id || result.sessionId || request.runtimeSessionId || '' });
+        resolve({ text: result.text.trim(), sessionId: result.session_id || result.sessionId || request.runtimeSessionId || '', ...(request.transport ? { transport: request.transport } : {}) });
       } catch { reject(new Error('Agent did not return a successful final reply. Hermes must emit its quiet-mode session_id; command adapters must return {"text":"..."}.')); }
     });
     child.stdin.end(config.runtime === 'hermes' ? request.message : JSON.stringify(request) + '\n');
@@ -194,7 +218,7 @@ export class LocalAgentRuntime {
   }
   file(sessionKey) { return path.join(this.directory, 'conversations', createHash('sha256').update(sessionKey).digest('hex') + '.json'); }
   history(sessionKey) { return readJson(this.file(sessionKey), { messages: [], receipts: {} }); }
-  async turn({ sessionKey, message, idempotencyKey, attachments = [], retryInterrupted = false }) {
+  async turn({ sessionKey, message, idempotencyKey, attachments = [], retryInterrupted = false, onText }) {
     const images = readImageAttachments(attachments);
     const text = typeof message === 'string' ? message : '';
     if (typeof sessionKey !== 'string' || !sessionKey || typeof idempotencyKey !== 'string' || !idempotencyKey || (!text.trim() && !images.length)) throw new Error('A session, message, and idempotency key are required.');
@@ -222,8 +246,9 @@ export class LocalAgentRuntime {
       let scratch;
       try {
         scratch = images.length ? writeTurnImages(images) : null;
-        const result = resumedReply || await runLocalAgent(this.config, { sessionKey, message: prompt, idempotencyKey, history: state.messages, runtimeSessionId: state.runtimeSessionId || this.config.resume, imagePaths: scratch?.paths || [] }, { signal: controller.signal });
+        const result = resumedReply || await runLocalAgent(this.config, { sessionKey, message: prompt, idempotencyKey, history: state.messages, runtimeSessionId: state.runtimeSessionId || this.config.resume, runtimeTransport: state.runtimeTransport, imagePaths: scratch?.paths || [] }, { signal: controller.signal, onText });
         state.runtimeSessionId = result.sessionId;
+        if (result.transport) state.runtimeTransport = result.transport;
         state.messages.push({ role: 'user', content: userContent(text, images), timestamp: Date.now() }, { role: 'assistant', content: [{ type: 'text', text: result.text }], timestamp: Date.now() });
         state.receipts[receiptKey] = { message, result };
         writePrivateJson(this.file(sessionKey), state);
@@ -249,6 +274,25 @@ export class LocalAgentRuntime {
     return aborted;
   }
   socket() { return new LocalAgentSocket(this); }
+  close() { if (this.config.runtime === 'hermes') resetHermesAcp(this.config); }
+  /** Gets Hermes ready before a message arrives: at bridge start and when a call opens. */
+  warm() {
+    if (this.config.runtime !== 'hermes' || !usesHermesAcp(this.config)) return Promise.resolve();
+    return warmHermesAcp(this.config, this.recentAcpSessions(2)).catch(() => {});
+  }
+  recentAcpSessions(limit) {
+    const directory = path.join(this.directory, 'conversations');
+    let files;
+    try { files = fs.readdirSync(directory).filter((name) => name.endsWith('.json')); } catch { return []; }
+    return files
+      .map((name) => { const file = path.join(directory, name); try { return { file, modified: fs.statSync(file).mtimeMs }; } catch { return null; } })
+      .filter(Boolean)
+      .sort((a, b) => b.modified - a.modified)
+      .map(({ file }) => readJson(file, {}))
+      .filter((state) => state.runtimeTransport === 'acp' && state.runtimeSessionId)
+      .slice(0, limit)
+      .map((state) => state.runtimeSessionId);
+  }
 }
 
 class LocalAgentSocket extends EventEmitter {
@@ -282,7 +326,9 @@ class LocalAgentSocket extends EventEmitter {
     if (req.method !== 'chat.send') return fail(`Method ${req.method} is not supported by this agent adapter.`);
     const runId = params.idempotencyKey || req.id || randomUUID();
     reply({ runId, status: 'started' });
-    this.runtime.turn({ ...params, idempotencyKey: runId }).then((result) => {
+    // Streaming runtimes send the reply so far as it grows, the shape OpenClaw's gateway uses.
+    const onText = (text) => this.frame({ type: 'event', event: 'chat', payload: { runId, sessionKey: params.sessionKey, state: 'delta', message: { role: 'assistant', content: [{ type: 'text', text }], timestamp: Date.now() } } });
+    this.runtime.turn({ ...params, idempotencyKey: runId, onText }).then((result) => {
       this.frame({ type: 'event', event: 'chat', payload: { runId, sessionKey: params.sessionKey, state: 'final', message: { role: 'assistant', content: [{ type: 'text', text: result.text }], timestamp: Date.now() } } });
     }, (err) => {
       this.frame({ type: 'event', event: 'chat', payload: { runId, sessionKey: params.sessionKey, state: 'error', errorMessage: err.message, ...(typeof err.runtimeReady === 'boolean' ? { runtimeReady: err.runtimeReady } : {}) } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oomi-ai",
-  "version": "0.8.5",
+  "version": "0.9.1",
   "description": "Connect OpenClaw, Hermes, Grok Bot, and other agents to Oomi with verified runtime adapters",
   "bin": {
     "oomi": "bin/oomi-ai.js"
@@ -49,7 +49,7 @@
     "url": "https://github.com/crispcode-io/oomi/issues"
   },
   "scripts": {
-    "check": "node --check bin/oomi-ai.js && node --check lib/bridgeService.js && node --check lib/bridgeMaintenance.js && node --check lib/localAgent.js && node --check lib/hermesGateway.js && node --check lib/grokbotRuntime.js && node --check lib/connectionSetup.js && node --check lib/processSupervisor.js",
+    "check": "node --check bin/oomi-ai.js && node --check lib/bridgeService.js && node --check lib/bridgeMaintenance.js && node --check lib/localAgent.js && node --check lib/hermesGateway.js && node --check lib/hermesAcp.js && node --check lib/grokbotRuntime.js && node --check lib/connectionSetup.js && node --check lib/processSupervisor.js",
     "test": "node --test test/*.test.mjs"
   },
   "dependencies": {
@@ -80,6 +80,7 @@
     "lib/bridgeService.js",
     "lib/bridgeMaintenance.js",
     "lib/hermesGateway.js",
+    "lib/hermesAcp.js",
     "lib/grokbotRuntime.js",
     "lib/connectionSetup.js",
     "lib/processSupervisor.js",

package/skills/oomi/SKILL.md

@@ -188,7 +188,7 @@ oomi connect --runtime hermes --name hermes --app-url https://www.oomi.ai
 oomi connect --runtime command --name my-agent --command '["/absolute/path/to/adapter"]' --app-url https://www.oomi.ai
 ```
 
-Use the user's app URL when provided. Hermes supports `--profile <profile>` and `--resume <exact-session-id>`. Without `--resume`, Oomi starts a persistent conversation with the same configured agent. Do not use `latest` or claim that an existing chat session was transferred unless its exact ID was selected. With oomi-ai 0.8.2+, an already-open Hermes conversation uses its existing local gateway owner and exact profile/session. Oomi attaches as another client; it never closes desktop, clears history, deletes a session lock, or substitutes a new chat. When no live owner exists, Hermes uses `chat --quiet --query-file -` and resumes the exact returned `session_id` on subsequent turns.
+Use the user's app URL when provided. Hermes supports `--profile <profile>` and `--resume <exact-session-id>`. Without `--resume`, Oomi starts a persistent conversation with the same configured agent. Do not use `latest` or claim that an existing chat session was transferred unless its exact ID was selected. With oomi-ai 0.8.2+, an already-open Hermes conversation uses its existing local gateway owner and exact profile/session. Oomi attaches as another client; it never closes desktop, clears history, deletes a session lock, or substitutes a new chat. When no live owner exists, an Oomi-owned conversation (no `--resume`) runs on a warm `hermes acp` process with oomi-ai 0.9.0+: replies stream as they are written and stop when the person interrupts. From 0.9.1 the bridge starts Hermes and reopens recent conversations ahead of time (at bridge start and when a call opens), so the first message doesn't wait for Hermes to start. Hermes permission requests are denied, as `chat --quiet` denies dangerous commands; ordinary file edits run as they do in quiet mode. A conversation moving from the CLI starts a new Hermes session that receives the recent Oomi history. `--resume` conversations, Hermes without ACP, and `--hermes-transport cli` use `chat --quiet --query-file -` and resume the exact returned `session_id` on subsequent turns.
 
 Shared desktop conversations require Hermes's loopback WebSocket gateway, active-session discovery, and durable prompt/reply row IDs. Busy conversations ask you to retry after the current task. If a simultaneous desktop send queues your message without a reply receipt, or the connection drops after sending, check the same Hermes chat before resending. Oomi cannot safely repeat an uncertain action. Human approvals stay in the existing Hermes desktop UI. Shared photo submission is not yet supported; use Hermes desktop for that photo. Older or terminal-only owners without a shared gateway receive an actionable error, never a competing process. The shared owner keeps its existing environment, so use the explicit Oomi `--connection NAME` for account commands.