oomi-ai 0.10.1 → 0.11.0

package/agent_instructions.md

@@ -142,6 +142,10 @@ Use this when your owner asks you to let another agent (Claude, Codex, a Grok bo
 
 To review a channel, use `oomi channel list` and `oomi channel show ID`.
 
+**When you can't answer.** Your AI provider might reject your sign-in, hit a limit or be unreachable. If so, oomi records the reason, tells your owner what to fix and tells the other side the message wasn't answered. Tell your owner plainly which AI provider failed and what it said. Ask them to sign in again on this computer themselves, in a terminal or the provider's app here. Never ask them to paste passwords or one-time codes into a chat. `oomi verify --connection NAME` checks that you can answer again. `oomi channel create` also returns `warnings` when your bridge can't answer; tell your owner before they share the link.
+
+**Use your own connection.** Turns started by the bridge already use it. Otherwise, pass `--connection NAME` (`oomi bridge list` shows the names). If oomi says it used a connection that isn't linked, rerun with your own. Don't create a new Auth Link unless your owner asked to connect you.
+
 To join another agent's link as a guest:
 
 1. Run `oomi channel join LINK`.

package/bin/oomi-ai.js

@@ -12,6 +12,7 @@ import { lookup as dnsLookup } from 'dns/promises';
 import { fileURLToPath } from 'url';
 import WebSocket from 'ws';
 import { planPackageUpdate, isWorkerDescendant, queueRestart, readMaintenance, createMaintenanceController } from '../lib/bridgeMaintenance.js';
+import { processCommand, readProcessTable } from '../lib/processTable.js';
 import { bridgeServiceConfig, createBridgeService, renderLaunchAgent } from '../lib/bridgeService.js';
 import { LOCAL_PROTOCOL_MIN, LOCAL_PROTOCOL_MAX, probeGateway } from '../lib/gatewayProbe.js';
 import { LocalAgentRuntime, localAgentConfig, runLocalAgent, writePrivateJson, startChannelWorker } from '../lib/localAgent.js';
@@ -20,6 +21,7 @@ import { handleSpacesCommand, compactHealth } from '../lib/spaces.js';
 import { handleObjectivesCommand } from '../lib/objectives.js';
 import { handleRoutinesCommand, startRoutineEventWorker } from '../lib/routines.js';
 import { handleChannelCommand, startAgentChannelWorker } from '../lib/agentChannels.js';
+import { classifyRuntimeFailure } from '../lib/runtimeFailure.js';
 import { createPersonaApiClient } from '../lib/personaApiClient.js';
 import { inferSpokenMetadataFromContent, normalizeSpokenMetadata } from '../lib/spokenMetadata.js';
 import {
@@ -1050,17 +1052,10 @@ function isBridgeProcess(pid) {
   if (!normalized) return false;
   if (!isPidAlive(normalized)) return false;
 
-  try {
-    const result = spawnSync('ps', ['-p', String(normalized), '-o', 'command='], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    });
-    const command = String(result.stdout || '').trim();
-    if (!command) return true;
-    return isBridgeWorkerCommand(command);
-  } catch {
-    return true;
-  }
+  // A live pid whose command the host won't say is taken as the bridge (it holds the lock).
+  const command = processCommand(normalized);
+  if (!command) return true;
+  return isBridgeWorkerCommand(command);
 }
 
 function readBridgeLock() {
@@ -1149,6 +1144,23 @@ function acquireBridgeLock(deviceId) {
   return release;
 }
 
+/**
+ * Tells Oomi which models the runtime offers, so the persona's page can offer a faster one for
+ * calls (Voice::CallModel). False when it didn't arrive, so the next turn reports again.
+ */
+async function reportRuntimeModels({ brokerHttp, deviceToken }, report, fetchImpl = fetch) {
+  if (!brokerHttp || !deviceToken) return false;
+  try {
+    const response = await fetchImpl(`${brokerHttp.replace(/\/$/, '')}/v1/agent_runtime/models`, {
+      method: 'PUT',
+      headers: { Authorization: `Bearer ${deviceToken}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(report),
+      signal: AbortSignal.timeout(10000),
+    });
+    return response.ok;
+  } catch { return false; }
+}
+
 async function claimBridgeDeviceToken({ brokerHttp, pairCode, deviceId }) {
   const response = await fetch(`${brokerHttp.replace(/\/$/, '')}/v1/pair/claim`, {
     method: 'POST',
@@ -1389,6 +1401,12 @@ function prepareGatewayFrameForLocalGateway(frameText, gatewayAuth, options = {}
         if (Number.isFinite(rawParams.timeoutMs) && rawParams.timeoutMs > 0) {
           sanitized.timeoutMs = Math.floor(rawParams.timeoutMs);
         }
+        // A call turn's faster model, for the runtimes Oomi drives itself (OpenClaw's gateway
+        // would reject the field).
+        const callModel = rawParams.oomi?.call?.model;
+        if (gatewayAuth?.gatewayUrl === 'local-agent:' && typeof callModel === 'string' && callModel.trim() && callModel.trim().length <= 200) {
+          sanitized.oomi = { call: { model: callModel.trim() } };
+        }
 
         const idempotencyKeyCandidates = [
           rawParams.idempotencyKey,
@@ -1632,6 +1650,13 @@ function shouldSuppressOomiVisibleText(value) {
   return !sanitizeUserVisibleText(text);
 }
 
+// oomi's notes to the persona, sent as the person's turn because runtimes take nothing else
+// (a call's "they're calling you, pick up" cue): never the person's words on any screen.
+const OOMI_CUE_PREFIX = '[oomi:cue:';
+// What this bridge does for oomi, said on each connect (the backend greets a call only through
+// a bridge that keeps the cue out of the conversation).
+const OOMI_BRIDGE_CAPABILITIES = ['call.greeting.v1'];
+
 function sanitizeGatewayMessageForOomi(message) {
   if (!message || typeof message !== 'object') return null;
 
@@ -1641,6 +1666,9 @@ function sanitizeGatewayMessageForOomi(message) {
   }
 
   const rawText = extractTextFromGatewayMessage(message);
+  if ((role === 'user' || !role) && typeof rawText === 'string' && rawText.includes(OOMI_CUE_PREFIX)) {
+    return null;
+  }
   if (shouldSuppressOomiVisibleText(rawText)) {
     return null;
   }
@@ -1713,6 +1741,17 @@ function sanitizeGatewayFrameForOomiClient(frameText) {
   return { frameText, changed: false, suppressed: false };
 }
 
+// The runtime accepted oomi's connect: say what this bridge can do. Grok Bot gets no greeting (its
+// inbox is slow, and Grok's own app would show the cue).
+function annotateConnectResponseForOomi(frameText, { runtime = 'openclaw', version = '' } = {}) {
+  const frame = parseJsonPayload(frameText);
+  if (!frame || typeof frame !== 'object' || frame.type !== 'res' || !frame.ok) return frameText;
+  const payload = frame.payload && typeof frame.payload === 'object' && !Array.isArray(frame.payload) ? frame.payload : {};
+  const existing = payload.oomi && typeof payload.oomi === 'object' && !Array.isArray(payload.oomi) ? payload.oomi : {};
+  const capabilities = runtime === 'grokbot' ? [] : [...OOMI_BRIDGE_CAPABILITIES];
+  return JSON.stringify({ ...frame, payload: { ...payload, oomi: { ...existing, bridgeVersion: version, capabilities } } });
+}
+
 function summarizeVoiceFrameContract(frameText) {
   const frame = parseJsonPayload(frameText);
   if (!frame || typeof frame !== 'object') {
@@ -2375,24 +2414,9 @@ function listBridgeProcessPids() {
   // custom connections directory is used. Never sweep another installation.
   if (bridgeConnectionName) return Array.from(pids);
 
-  try {
-    const result = spawnSync('ps', ['-Ao', 'pid=,command='], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    });
-    const output = String(result.stdout || '');
-    for (const rawLine of output.split('\n')) {
-      const line = rawLine.trim();
-      if (!line) continue;
-      const match = line.match(/^(\d+)\s+(.+)$/);
-      if (!match) continue;
-      const pid = Number(match[1]);
-      const command = String(match[2] || '');
-      if (!isBridgeWorkerCommand(command)) continue;
-      addPid(pid);
-    }
-  } catch {
-    // best-effort process scan
+  // A best-effort scan of the host's processes.
+  for (const row of readProcessTable() || []) {
+    if (isBridgeWorkerCommand(row.command)) addPid(row.pid);
   }
 
   return Array.from(pids).sort((a, b) => a - b);
@@ -2552,9 +2576,11 @@ async function startOpenclawBridge(flags) {
     console.log(`Claimed bridge device token for ${deviceId}.`);
   }
 
+  const bridgeRuntimeName = bridgeState.localAgent?.runtime || bridgeState.runtime || 'openclaw';
   const localRuntime = bridgeState.localAgent
     ? new LocalAgentRuntime({ ...bridgeState.localAgent, connection: bridgeConnectionName }, path.dirname(resolveBridgeStatePath()), (health) => updateBridgeStatus(health))
     : null;
+  if (localRuntime) localRuntime.onModels = (report) => reportRuntimeModels({ brokerHttp, deviceToken }, report);
   localRuntime?.warm();
   const gateway = localRuntime ? { gatewayUrl: 'local-agent:', configPath: resolveBridgeStatePath() } : readOpenclawGatewayConfig();
   if (!localRuntime && !gateway.token && !gateway.password) {
@@ -2650,7 +2676,9 @@ async function startOpenclawBridge(flags) {
     state: { ...bridgeState, brokerHttp, deviceToken },
     connection: bridgeConnectionName,
     deliver: deliverAgentEvent,
-    onError: (error) => updateBridgeStatus({ agentChannelError: `Agent channel delivery: ${error.message}` }),
+    onError: (error) => updateBridgeStatus({ agentChannelError: error.failure
+      ? `Couldn't answer a chat-link message: ${error.failure.summary}. ${error.failure.hint}`
+      : `Agent channel delivery: ${error.message}` }),
     onDelivered: () => updateBridgeStatus({ agentChannelError: '' }),
   });
   console.log(`Local gateway: ${gateway.gatewayUrl}`);
@@ -3242,6 +3270,7 @@ async function startOpenclawBridge(flags) {
 
       gatewaySocket.on('message', runBridgeCallbackSafely((gatewayRaw) => {
         let frame = typeof gatewayRaw === 'string' ? gatewayRaw : gatewayRaw.toString();
+        let connectAccepted = false;
         const visibleSanitized = sanitizeGatewayFrameForOomiClient(frame);
         if (visibleSanitized.changed) {
           frame = visibleSanitized.frameText;
@@ -3301,6 +3330,7 @@ async function startOpenclawBridge(flags) {
               stage: responseMeta.ok ? 'gateway.accepted' : 'gateway.rejected',
             });
             if (requestMeta.method === 'connect' && responseMeta.ok) {
+              connectAccepted = true;
               const releasedFrames = flushWaitingForConnect(sessionBridge);
               for (const released of releasedFrames) {
                 const releasedMeta = extractGatewayRequestMeta(released.frameText);
@@ -3409,6 +3439,9 @@ async function startOpenclawBridge(flags) {
           });
         }
 
+        if (connectAccepted) {
+          frame = annotateConnectResponseForOomi(frame, { runtime: bridgeRuntimeName, version: currentPackageVersion() });
+        }
         sendBrokerPayload(brokerSocket, { action: 'gateway_frame', type: 'gateway.frame', sessionId, frame });
       }, (error) => {
         reportBridgeRuntimeFault({ phase: 'gateway.message', sessionId, error });
@@ -4450,6 +4483,14 @@ function connectionDirectory() {
   return path.join(process.env.OOMI_CONNECTIONS_DIR || path.join(os.homedir(), '.oomi', 'connections'), bridgeConnectionName);
 }
 
+// A failed connection check usually means the agent's own AI access is broken.
+// Say that plainly, with the fix, instead of a bare runtime error.
+function explainVerificationFailure(err) {
+  const failure = classifyRuntimeFailure(err);
+  if (failure.code === 'runtime_failed') return err;
+  return Object.assign(new Error(`This agent couldn't answer the connection check: ${failure.summary}. ${failure.hint} Oomi itself is fine; nothing else needs reconnecting. (Details: ${failure.detail})`), { failure });
+}
+
 async function verifyLocalAgent(state) {
   if (state.openclawHome) process.env.OPENCLAW_HOME = state.openclawHome;
   let result;
@@ -4519,8 +4560,9 @@ async function connectLocalAgent(flags) {
     const verified = await verifyLocalAgent(state);
     state.verifiedAt = verified.verifiedAt;
   } catch (err) {
-    updateBridgeStatus({ runtime, runtimeReady: false, status: 'degraded', lastErrorMessage: err.message });
-    throw err;
+    const explained = explainVerificationFailure(err);
+    updateBridgeStatus({ runtime, runtimeReady: false, status: 'degraded', lastErrorMessage: explained.message });
+    throw explained;
   }
   } else {
     console.log(`Reusing the verified ${runtime} runtime. No model test message sent. Use oomi verify for an explicit paid-model probe.`);
@@ -4676,8 +4718,9 @@ async function main() {
       updateBridgeStatus({ runtimeReady: true, verifiedAt: result.verifiedAt, lastErrorMessage: '' });
       console.log(JSON.stringify(result, null, 2));
     } catch (err) {
-      updateBridgeStatus({ runtimeReady: false, status: 'degraded', lastErrorMessage: err.message });
-      throw err;
+      const explained = explainVerificationFailure(err);
+      updateBridgeStatus({ runtimeReady: false, status: 'degraded', lastErrorMessage: explained.message });
+      throw explained;
     }
     return;
   }
@@ -4828,6 +4871,7 @@ if (__isDirectExecution) {
 }
 
 export {
+  annotateConnectResponseForOomi,
   prepareGatewayFrameForLocalGateway,
   sanitizeGatewayFrameForOomiClient,
   sanitizeUserVisibleText,

package/lib/agentChannels.js

@@ -1,7 +1,9 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { readJson, writePrivateJson } from './localAgent.js';
+import { classifyRuntimeFailure } from './runtimeFailure.js';
 
 // Owner-visible conversations between this agent and one other agent.
 // Host side uses the device token against the Oomi API. Guest side (after
@@ -42,6 +44,46 @@ export function parseChannelLink(link) {
   return { origin: url.origin, token: match[1] };
 }
 
+function connectionsRoot() {
+  return process.env.OOMI_CONNECTIONS_DIR || path.join(os.homedir(), '.oomi', 'connections');
+}
+
+function localConnections() {
+  try {
+    return fs.readdirSync(connectionsRoot(), { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && fs.existsSync(path.join(connectionsRoot(), entry.name, 'oomi-bridge.json')))
+      .map((entry) => entry.name);
+  } catch { return []; }
+}
+
+// Agents that ran a command without --connection were sent to a stale default
+// connection and then created Auth Links for it. Say which connection was used
+// and which others exist, and steer away from reconnecting.
+export function explainConnectionError(error, directory) {
+  const notLinked = error?.status === 403 && /not linked/i.test(error.message || '');
+  const missing = /Connect this agent to Oomi first/.test(error?.message || '');
+  if (!notLinked && !missing) return error;
+  const named = directory && path.resolve(path.dirname(directory)) === path.resolve(connectionsRoot());
+  const label = named ? `the connection "${path.basename(directory)}"` : 'the default OpenClaw connection';
+  const others = localConnections().filter((name) => !named || name !== path.basename(directory));
+  const problem = missing ? `found no saved login for ${label}` : `used ${label}, but that connection isn't linked to an oomi account`;
+  const next = others.length
+    ? `Connections on this computer: ${others.join(', ')}. If one of them is you, rerun with --connection NAME.`
+    : 'No other oomi connections were found on this computer.';
+  return Object.assign(new Error(`oomi ${problem}. ${next} Don't create a new Auth Link or reconnect unless your owner asked to connect this agent.`), { status: error.status, reasonCode: error.reasonCode });
+}
+
+// A link only helps if this agent can answer; warn before handing one out.
+export function bridgeWarnings(directory) {
+  if (!directory) return [];
+  const status = readJson(path.join(directory, 'oomi-bridge-status.json'), null);
+  if (!status) return ['No oomi bridge status was found for this connection. Run oomi bridge repair for it, or guest messages will wait unanswered.'];
+  const warnings = [];
+  if (['error', 'degraded', 'failed', 'stopped'].includes(status.status)) warnings.push(`Your oomi bridge reports "${status.status}"${status.lastErrorMessage ? `: ${String(status.lastErrorMessage).replace(/\.\s*$/, '')}` : ''}.`);
+  if (status.agentChannelError) warnings.push(status.agentChannelError);
+  return warnings;
+}
+
 function guestRecordPath(directory, channelId) {
   return path.join(directory, 'agent-channels', `${channelId}.json`);
 }
@@ -90,7 +132,10 @@ function optionalInteger(value, name) {
   return number;
 }
 
-export async function handleChannelCommand(state, action, flags = {}, positionals = [], { directory, request = channelRequest, guest = guestRequest, print = (value) => console.log(JSON.stringify(value, null, 2)) } = {}) {
+export async function handleChannelCommand(state, action, flags = {}, positionals = [], { directory, request: rawRequest = channelRequest, guest = guestRequest, print = (value) => console.log(JSON.stringify(value, null, 2)) } = {}) {
+  const request = async (...args) => {
+    try { return await rawRequest(...args); } catch (error) { throw explainConnectionError(error, directory); }
+  };
   const id = positionals[0] || flags.id;
   const requireId = () => { if (typeof id !== 'string' || !CHANNEL_ID.test(id)) throw new Error('Provide a channel ID (ach_...) from oomi channel list.'); };
   let result;
@@ -111,6 +156,8 @@ export async function handleChannelCommand(state, action, flags = {}, positional
       result = { ...result, next: audience === 'person'
         ? 'Give your owner both links: the chat link to send to the person, and the watchUrl where they read along, approve requests and end the chat. The person\'s messages arrive as separate Oomi chat turns; your reply text goes back to them.'
         : 'Give this link to your owner to pass to the other agent. That agent joins from wherever it runs; do not start, install, sign in to or message it yourself, and never ask your owner for sign-in codes for it. Its messages arrive as separate Oomi channel turns; your reply text goes back to it. Your owner can watch and end the channel in Oomi.' };
+      const warnings = bridgeWarnings(directory);
+      if (warnings.length) result.warnings = [...warnings, 'Tell your owner about these before they share the link: the other side\'s messages will not be answered until they are fixed.'];
       break;
     }
     case 'list': {
@@ -244,8 +291,10 @@ export function startAgentChannelWorker({ state, deliver, connection = '', reque
         try {
           reply = await deliver({ sessionKey: item.sessionKey, idempotencyKey: item.messageId, message: channelTurnMessage(item, connection), retryInterrupted: false });
         } catch (error) {
-          await request(state, `agent_channels/inbox/${item.messageId}/ack`, { method: 'POST', body: { outcome: 'failed', failureCode: 'host_turn_failed' } }).catch(() => {});
-          onError(error);
+          // Report why, so the owner is told what to fix and the guest isn't left guessing.
+          const failure = classifyRuntimeFailure(error);
+          await request(state, `agent_channels/inbox/${item.messageId}/ack`, { method: 'POST', body: { outcome: 'failed', failureCode: failure.code, failureDetail: failure.detail } }).catch(() => {});
+          onError(Object.assign(error, { failure }));
           continue;
         }
         const text = typeof reply?.text === 'string' ? reply.text.trim() : '';

package/lib/bridgeMaintenance.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { readJson, writePrivateJson } from './localAgent.js';
+import { readProcessTable } from './processTable.js';
 
 export const maintenancePath = (directory) => path.join(directory, 'oomi-bridge-maintenance.json');
 export const readMaintenance = (directory) => readJson(maintenancePath(directory), null);
@@ -19,11 +20,11 @@ export function planPackageUpdate(current, latest) {
       : { instruction: 'Already current. Do not reinstall or restart. Check oomi status only if the user also reports a connection problem.' }) };
 }
 
-export function isWorkerDescendant(workerPid, { pid = process.pid, run = spawnSync } = {}) {
+export function isWorkerDescendant(workerPid, { pid = process.pid, run = spawnSync, platform = process.platform } = {}) {
   if (!Number.isInteger(workerPid) || workerPid <= 0) return false;
-  const result = run('ps', ['-axo', 'pid=,ppid='], { encoding: 'utf8', timeout: 5000 });
-  if (result.status !== 0) throw new Error('Cannot establish whether this command would stop its own agent. Run maintenance from an independent host terminal.');
-  const parents = new Map(String(result.stdout).trim().split('\n').map((line) => line.trim().split(/\s+/).map(Number)));
+  const table = readProcessTable({ run, platform });
+  if (!table) throw new Error('Cannot establish whether this command would stop its own agent. Run maintenance from an independent host terminal.');
+  const parents = new Map(table.map((row) => [row.pid, row.ppid]));
   const visited = new Set();
   while (pid > 1 && !visited.has(pid)) {
     if (pid === workerPid) return true;

package/lib/gatewayProbe.js

@@ -1,5 +1,6 @@
 import WebSocket from 'ws';
 import { randomUUID } from 'node:crypto';
+import { redactDetail } from './runtimeFailure.js';
 
 // The broker's protocol is independent of the installed local gateway version.
 export const LOCAL_PROTOCOL_MIN = 3;
@@ -48,7 +49,11 @@ export function probeGateway({ gateway, deviceIdentity, prepareFrame, verifyRepl
           message: turn?.message || 'Oomi connection check. Reply with OOMI_OK only. Do not use tools or change anything.',
         } }));
       } else if (verifyReply && frame.event === 'chat' && frame.payload?.runId === runId) {
-        if (frame.payload.state === 'error' || frame.payload.state === 'aborted') return finish(new Error('Local agent could not complete the verification message.'));
+        if (frame.payload.state === 'error' || frame.payload.state === 'aborted') {
+          // Keep the runtime's own reason (for example a rejected model login) so callers can say what went wrong.
+          const reason = redactDetail(frame.payload.errorMessage || frame.payload.error?.message || frame.payload.state);
+          return finish(Object.assign(new Error(`Local agent could not complete the message: ${reason}`), { runtimeDetail: reason }));
+        }
         if (frame.payload.state === 'final') {
           const content = frame.payload.message?.content;
           const text = typeof content === 'string' ? content : (Array.isArray(content) ? content.map((part) => part.text || '').join('') : '');

package/lib/hermesAcp.js

@@ -22,6 +22,9 @@ const IMAGE_TYPES = { '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'imag
 const SEED_MESSAGES = 12;
 const SEED_MESSAGE_CHARS = 800;
 const SEED_TOTAL_CHARS = 6000;
+const MAX_REPORTED_MODELS = 60;
+// Not models to talk with: images, video, speech, embeddings.
+const NOT_CHAT = /imagine|image|video|stt|tts|speech|audio|embed|whisper|moderation/i;
 
 // Only fixed messages cross the bridge; Hermes diagnostics may hold credentials or tool output.
 export class HermesAcpError extends Error {
@@ -76,10 +79,42 @@ class HermesAcpClient {
     this.turns = new Map();
     this.loaded = new Set();
     this.replayed = new Map();
+    // The model each ACP session is on, and what Hermes offers (session/new and session/load
+    // answers), for a call's faster model (Oomi's call.model, Voice::CallModel on the server).
+    this.sessionModels = new Map();
+    this.availableModels = [];
+    this.newSessionModel = '';
     this.closed = false;
     this.ready = null;
   }
 
+  noteModels(sessionId, models, { created = false } = {}) {
+    if (!models || typeof models !== 'object') return;
+    const current = typeof models.currentModelId === 'string' ? models.currentModelId : '';
+    if (current) {
+      this.sessionModels.set(sessionId, current);
+      if (created) this.newSessionModel = current;
+    }
+    if (Array.isArray(models.availableModels)) {
+      this.availableModels = models.availableModels
+        .filter((model) => typeof model?.modelId === 'string' && model.modelId)
+        .map((model) => ({ id: model.modelId, name: typeof model.name === 'string' ? model.name : '' }));
+    }
+  }
+
+  /** Switches a session's model between turns (Hermes refuses mid-turn); false if it couldn't. */
+  async switchModel(sessionId, modelId) {
+    if (!modelId || this.turns.has(sessionId)) return false;
+    try {
+      await this.request('session/set_model', { sessionId, modelId });
+      this.sessionModels.set(sessionId, modelId);
+      return true;
+    } catch (err) {
+      if (err.code === 'hermes_acp_exited') throw err;
+      return false;
+    }
+  }
+
   start() {
     if (this.ready) return this.ready;
     this.ready = this.spawnAndInitialize().catch((err) => {
@@ -204,7 +239,8 @@ class HermesAcpClient {
       // counts as found only when its history is replayed.
       this.replayed.set(sessionId, 0);
       try {
-        await this.request('session/load', { sessionId, cwd, mcpServers: [] });
+        const loaded = await this.request('session/load', { sessionId, cwd, mcpServers: [] });
+        this.noteModels(sessionId, loaded?.models);
         if (this.replayed.get(sessionId) > 0) {
           await this.prepare(sessionId);
           return { sessionId, created: false };
@@ -216,6 +252,7 @@ class HermesAcpClient {
     if (!create) return null;
     const created = await this.request('session/new', { cwd, mcpServers: [] });
     if (typeof created?.sessionId !== 'string' || !created.sessionId) throw unavailable();
+    this.noteModels(created.sessionId, created.models, { created: true });
     await this.prepare(created.sessionId);
     return { sessionId: created.sessionId, created: true };
   }
@@ -324,6 +361,8 @@ export function continuityPreamble(history) {
   for (const message of recent) {
     const words = textOf(message?.content).trim();
     if (!words || !['user', 'assistant'].includes(message?.role)) continue;
+    // oomi's own notes (a call's pick-up cue) aren't part of the thread to carry over.
+    if (message.role === 'user' && words.includes('[oomi:cue:')) 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;
@@ -360,13 +399,87 @@ export async function runHermesAcpTurn(config, request, { signal, timeoutMs = 18
   const continuing = request.runtimeTransport === 'acp' ? request.runtimeSessionId : '';
   let { sessionId, created } = await client.openSession(continuing);
   const seed = () => continuityPreamble(request.history);
+  let chatModel = await applyCallModel(client, sessionId, request);
   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(''));
+    // A fresh session starts on the chat model.
+    chatModel = await applyCallModel(client, sessionId, { ...request, chatModel: null });
     text = await client.prompt(sessionId, promptBlocks(request, seed()), { signal, timeoutMs, onText });
   }
-  return { text, sessionId, transport: 'acp' };
+  return { text, sessionId, transport: 'acp', chatModel };
+}
+
+/**
+ * A call turn asks for the persona's faster model (request.callModel); every other turn puts
+ * the session back on the model it chats with. Returns the model to go back to, while the
+ * session is on the call model (kept in the conversation's state, so a restart still restores
+ * it), else null. A session whose model Hermes didn't say isn't switched: there'd be no way back.
+ */
+async function applyCallModel(client, sessionId, request) {
+  const current = client.sessionModels.get(sessionId) || '';
+  const remembered = typeof request.chatModel === 'string' && request.chatModel ? request.chatModel : null;
+  const callModel = typeof request.callModel === 'string' && request.callModel ? request.callModel : '';
+  if (callModel) {
+    if (current === callModel) return remembered;
+    if (!current) return remembered;
+    const back = remembered || current;
+    return (await client.switchModel(sessionId, callModel)) ? back : remembered;
+  }
+  if (remembered && current !== remembered) return (await client.switchModel(sessionId, remembered)) ? null : remembered;
+  return null;
 }
+
+/**
+ * What Hermes offers for a faster call model, for Oomi's persona page: the models of the provider
+ * the persona chats with (chatModel, or the one new sessions start on), a recommendation (one
+ * that doesn't reason first), and whether this runtime can switch. Null until Hermes has said.
+ */
+export function hermesAcpModelReport(config, { chatModel = '' } = {}) {
+  const client = clients.get(clientKey(config));
+  if (!client || !client.availableModels.length) return null;
+  const current = chatModel || client.newSessionModel || [...client.sessionModels.values()][0] || '';
+  if (!current) return null;
+  const provider = current.includes(':') ? current.slice(0, current.indexOf(':') + 1) : '';
+  const available = client.availableModels
+    .filter((model) => (!provider || model.id.startsWith(provider)) && !NOT_CHAT.test(model.id))
+    .slice(0, MAX_REPORTED_MODELS)
+    .map((model) => ({ id: model.id, name: modelDisplayName(model.id) }));
+  if (!available.some((model) => model.id === current)) available.push({ id: current, name: modelDisplayName(current) });
+  return { current, recommended: recommendedCallModel(available, current), switchable: true, available };
+}
+
+/** One that answers without reasoning first, else one built to be quick; never the chat model. */
+export function recommendedCallModel(available, current) {
+  const others = available.filter((model) => model.id !== current);
+  const plain = others.find((model) => /non[-_]?reasoning/i.test(model.id));
+  if (plain) return plain.id;
+  const quick = others.find((model) => /(^|[-_:/])(fast|flash|mini|lite|haiku|turbo|instant)([-_.]|$)/i.test(model.id) && !/code|coder|composer|build/i.test(model.id));
+  return quick ? quick.id : null;
+}
+
+/** "xai-oauth:grok-4.20-0309-non-reasoning" → "Grok 4.20 (no reasoning)"; "claude-haiku-5-5" → "Claude Haiku 5.5". */
+export function modelDisplayName(id) {
+  const text = String(id);
+  const raw = (text.includes(':') ? text.slice(text.indexOf(':') + 1) : text).split(/[-_/\s]+/).filter(Boolean);
+  let plain = false;
+  const words = [];
+  for (let index = 0; index < raw.length; index++) {
+    const word = raw[index];
+    if (/^non$/i.test(word) && /^reasoning$/i.test(raw[index + 1] || '')) { plain = true; index++; continue; }
+    if (/^nonreasoning$/i.test(word)) { plain = true; continue; }
+    if (/^\d{4}$/.test(word)) continue; // a release date
+    // "5", "5" → "5.5"
+    if (/^\d+$/.test(word) && words.length && /^\d+(\.\d+)?$/.test(words[words.length - 1]) && !words[words.length - 1].includes('.')) {
+      words[words.length - 1] += `.${word}`;
+      continue;
+    }
+    words.push(/^(gpt|glm|ai)$/i.test(word) ? word.toUpperCase() : /^[a-z]/.test(word) ? word[0].toUpperCase() + word.slice(1) : word);
+  }
+  const name = words.join(' ');
+  return plain ? `${name} (no reasoning)` : name;
+}
+

package/lib/localAgent.js

@@ -5,8 +5,9 @@ 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 { runHermesAcpTurn, hermesAcpAvailable, resetHermesAcp, warmHermesAcp, hermesAcpModelReport } from './hermesAcp.js';
 import { grokbotConfig, runGrokbotTurn, completedGrokbotTurn } from './grokbotRuntime.js';
+import { classifyRuntimeFailure } from './runtimeFailure.js';
 
 const IMAGE_EXTENSIONS = { 'image/jpeg': '.jpg', 'image/png': '.png', 'image/webp': '.webp', 'image/gif': '.gif' };
 const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
@@ -194,7 +195,10 @@ function runAgentProcess(config, request, { signal, timeoutMs = 180000 } = {}) {
       if (error) return reject(error);
       if (code !== 0) {
         const reason = config.runtime === 'hermes' && code === 1 && !diagnosticsTruncated && !output.trim() && diagnostics.match(/^hermes-refusal-reason:\s*([A-Z_]+)(?:\r?\n|$)/)?.[1];
-        return reject(hermesRefusal(reason) || new Error(`Agent exited with code ${code}. Check local runtime credentials and logs.`));
+        // stderr can hold private tool output, so it never enters the message. Keep
+        // only the kind of failure its last lines show, such as a rejected provider login.
+        const runtimeFailureCode = classifyRuntimeFailure({ message: diagnostics.trim().split(/\r?\n/).slice(-3).join(' ') }).code;
+        return reject(hermesRefusal(reason) || Object.assign(new Error(`Agent exited with code ${code}. Check local runtime credentials and logs.`), { runtimeFailureCode }));
       }
       try {
         const result = config.runtime === 'hermes'
@@ -216,10 +220,15 @@ export class LocalAgentRuntime {
     this.queue = Promise.resolve();
     this.active = new Map();
     this.deliveries = 0;
+    // Told what models the runtime offers for a call's faster model, when that changes.
+    this.onModels = null;
+    this.lastModelReport = '';
   }
   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, onText }) {
+  async turn({ sessionKey, message, idempotencyKey, attachments = [], retryInterrupted = false, onText, oomi }) {
+    // A call turn names the persona's faster model (Oomi's call.model); see applyCallModel.
+    const callModel = typeof oomi?.call?.model === 'string' && oomi.call.model.trim().length <= 200 ? oomi.call.model.trim() : '';
     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.');
@@ -247,13 +256,20 @@ 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, runtimeTransport: state.runtimeTransport, imagePaths: scratch?.paths || [] }, { signal: controller.signal, onText });
+        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 || [], callModel, chatModel: state.runtimeChatModel || null }, { signal: controller.signal, onText });
         state.runtimeSessionId = result.sessionId;
         if (result.transport) state.runtimeTransport = result.transport;
+        // While the session is on a call's model, the model to go back to (kept here, so a
+        // restart still restores it before the next chat turn).
+        if ('chatModel' in result) {
+          if (result.chatModel) state.runtimeChatModel = result.chatModel;
+          else delete state.runtimeChatModel;
+        }
         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);
         this.onHealth({ runtimeReady: true, lastReplyAt: new Date().toISOString(), lastErrorMessage: '' });
+        this.reportModels(state.runtimeChatModel);
         return result;
       } catch (err) {
         if (err.notStarted === true) {
@@ -279,7 +295,29 @@ export class LocalAgentRuntime {
   /** 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(() => {});
+    return warmHermesAcp(this.config, this.recentAcpSessions(2)).then(() => this.reportModels(), () => {});
+  }
+  /** Tells onModels what the runtime offers for calls, once Hermes has said and whenever it changes. */
+  reportModels(chatModel = '') {
+    if (!this.onModels || this.config.runtime !== 'hermes') return;
+    const report = hermesAcpModelReport(this.config, { chatModel: chatModel || this.rememberedChatModel() });
+    if (!report) return;
+    const text = JSON.stringify(report);
+    if (text === this.lastModelReport) return;
+    this.lastModelReport = text;
+    // Reporting never breaks a turn; a report that didn't arrive goes again after the next one.
+    Promise.resolve().then(() => this.onModels(report)).then((delivered) => { if (delivered === false) this.lastModelReport = ''; }, () => { this.lastModelReport = ''; });
+  }
+  /** A conversation on a call's model knows what the persona chats with. */
+  rememberedChatModel() {
+    const directory = path.join(this.directory, 'conversations');
+    let files;
+    try { files = fs.readdirSync(directory).filter((name) => name.endsWith('.json')); } catch { return ''; }
+    for (const name of files) {
+      const state = readJson(path.join(directory, name), {});
+      if (typeof state.runtimeChatModel === 'string' && state.runtimeChatModel) return state.runtimeChatModel;
+    }
+    return '';
   }
   recentAcpSessions(limit) {
     const directory = path.join(this.directory, 'conversations');

package/lib/runtimeFailure.js

@@ -0,0 +1,43 @@
+// Turns a raw agent-runtime error into something an agent, its owner and a
+// guest can act on. The raw text stays on this computer except for a short,
+// redacted excerpt sent to the owner.
+
+const RULES = [
+  ['model_auth_failed', /\b401\b|\b403\b|unauthori[sz]ed|authenticat|invalid[ _-]?(x-)?api[ _-]?key|api key|oauth|access token|refresh token|token (has )?expired|expired token|not logged in|log ?in again|sign ?in again|please (log|sign) ?in|login (was )?rejected|invalid credentials|credentials? (are |were |have )?(invalid|expired|rejected)/i],
+  ['model_rate_limited', /\b429\b|rate[ _-]?limit|quota|usage limit|too many requests/i],
+  ['model_unavailable', /\b5\d\d\b|overloaded|unavailable|ECONNREFUSED|ENOTFOUND|ETIMEDOUT|ECONNRESET|network|could not reach/i],
+  ['runtime_timeout', /timed out|timeout/i],
+];
+
+export const FAILURE_SUMMARIES = {
+  model_auth_failed: 'its AI provider rejected its sign-in',
+  model_rate_limited: 'its AI provider hit a usage or rate limit',
+  model_unavailable: "its AI provider couldn't be reached",
+  runtime_timeout: 'it took too long to answer',
+  runtime_failed: 'its agent runtime stopped with an error',
+};
+
+export const FAILURE_HINTS = {
+  model_auth_failed: "Ask your owner to sign in to your AI provider again on this computer themselves (in a terminal or the provider's app here). Never ask them to paste passwords or one-time codes into a chat.",
+  model_rate_limited: 'Wait for the provider limit to reset, or ask your owner to raise it.',
+  model_unavailable: 'Check this computer is online and the provider is up, then try again.',
+  runtime_timeout: 'Try again with a shorter request, or check the agent runtime is responsive.',
+  runtime_failed: 'Check the agent runtime logs on this computer, then try again.',
+};
+
+export function redactDetail(text, limit = 300) {
+  return String(text || '')
+    .replace(/Bearer\s+\S+/gi, 'Bearer [redacted]')
+    .replace(/\b(sk|pk|rk|oomi_gst|xox[abpr])[-_][A-Za-z0-9_-]{6,}/g, '[redacted]')
+    .replace(/[A-Za-z0-9_\-+/=]{32,}/g, '[redacted]')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(-limit);
+}
+
+export function classifyRuntimeFailure(error) {
+  const raw = [error?.runtimeDetail, error?.message, typeof error === 'string' ? error : ''].filter(Boolean).join(' | ');
+  // A runtime that can't share its output (stderr may be private) passes only the code.
+  const code = FAILURE_SUMMARIES[error?.runtimeFailureCode] ? error.runtimeFailureCode : (RULES.find(([, pattern]) => pattern.test(raw)) || ['runtime_failed'])[0];
+  return { code, summary: FAILURE_SUMMARIES[code], hint: FAILURE_HINTS[code], detail: redactDetail(raw) };
+}

package/lib/spokenMetadata.js

@@ -1,12 +1,12 @@
-function trimString(value, fallback = '') {
-  return typeof value === 'string' && value.trim() ? value.trim() : fallback;
-}
-
-const ELLIPSIS_PLACEHOLDER = '__OOMI_ELLIPSIS__';
-
-function stripAvatarCommandTags(text) {
-  return text.replace(/\[(anim|animation|face|expression|emotion|gesture|look|gaze):[^\]]+\]/gi, ' ');
-}
+function trimString(value, fallback = '') {
+  return typeof value === 'string' && value.trim() ? value.trim() : fallback;
+}
+
+const ELLIPSIS_PLACEHOLDER = '__OOMI_ELLIPSIS__';
+
+function stripAvatarCommandTags(text) {
+  return text.replace(/\[(anim|animation|face|expression|emotion|gesture|look|gaze):[^\]]+\]/gi, ' ');
+}
 
 function clampInteger(value, fallback, { min = 1, max = Number.MAX_SAFE_INTEGER } = {}) {
   if (typeof value !== 'number' || !Number.isFinite(value)) return fallback;
@@ -41,11 +41,11 @@ function inferSpokenLanguage(text) {
   return 'English';
 }
 
-function normalizeSpokenSegment(segment) {
-  if (!segment || typeof segment !== 'object' || Array.isArray(segment)) return null;
-
-  const text = normalizeSpeechText(trimString(segment.text));
-  if (!text) return null;
+function normalizeSpokenSegment(segment) {
+  if (!segment || typeof segment !== 'object' || Array.isArray(segment)) return null;
+
+  const text = normalizeSpeechText(trimString(segment.text));
+  if (!text) return null;
 
   const normalized = { text };
   const pace = trimString(segment.pace);
@@ -67,33 +67,33 @@ function stripEmoji(text) {
   return text.replace(/[\uFE0E\uFE0F]/g, '').replace(/\p{Extended_Pictographic}|\p{Emoji_Presentation}/gu, '');
 }
 
-function normalizeSpeechText(text) {
-  return stripEmoji(stripAvatarCommandTags(text))
-    .replace(/\*\*(.*?)\*\*/g, '$1')
-    .replace(/__(.*?)__/g, '$1')
-    .replace(/`([^`]+)`/g, '$1')
-    .replace(/[\u2013\u2014]/g, ', ')
-    .replace(/\u2026/g, ELLIPSIS_PLACEHOLDER)
-    .replace(/\.{3,}/g, ELLIPSIS_PLACEHOLDER)
-    .replace(/\s+/g, ' ')
-    .replace(/\s+([,.;!?])/g, '$1')
-    .replace(/([,;!?])(?=[^\s])/g, '$1 ')
-    .replace(/(\.)(?=[^\s.])/g, '$1 ')
-    .replace(/,\s*,+/g, ', ')
-    .replace(new RegExp(`${ELLIPSIS_PLACEHOLDER}(?=[^\\s,.;!?])`, 'g'), `${ELLIPSIS_PLACEHOLDER} `)
-    .replace(new RegExp(ELLIPSIS_PLACEHOLDER, 'g'), '...')
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-function splitSpeechSegments(text) {
-  const normalized = normalizeSpeechText(text);
-  if (!normalized) return [];
-
-  const baseSegments = normalized
-    .split(/(?<=[.!?])\s+|\n+/)
-    .map((segment) => segment.trim())
-    .filter(Boolean);
+function normalizeSpeechText(text) {
+  return stripEmoji(stripAvatarCommandTags(text))
+    .replace(/\*\*(.*?)\*\*/g, '$1')
+    .replace(/__(.*?)__/g, '$1')
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/[\u2013\u2014]/g, ', ')
+    .replace(/\u2026/g, ELLIPSIS_PLACEHOLDER)
+    .replace(/\.{3,}/g, ELLIPSIS_PLACEHOLDER)
+    .replace(/\s+/g, ' ')
+    .replace(/\s+([,.;!?])/g, '$1')
+    .replace(/([,;!?])(?=[^\s])/g, '$1 ')
+    .replace(/(\.)(?=[^\s.])/g, '$1 ')
+    .replace(/,\s*,+/g, ', ')
+    .replace(new RegExp(`${ELLIPSIS_PLACEHOLDER}(?=[^\\s,.;!?])`, 'g'), `${ELLIPSIS_PLACEHOLDER} `)
+    .replace(new RegExp(ELLIPSIS_PLACEHOLDER, 'g'), '...')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function splitSpeechSegments(text) {
+  const normalized = normalizeSpeechText(text);
+  if (!normalized) return [];
+
+  const baseSegments = normalized
+    .split(/(?<=[.!?])\s+|\n+/)
+    .map((segment) => segment.trim())
+    .filter(Boolean);
 
   const segments = [];
   for (const segment of baseSegments) {
@@ -102,17 +102,17 @@ function splitSpeechSegments(text) {
       continue;
     }
 
-    const clauseParts = segment
-      .split(/(?<=[,;:])\s+/)
-      .map((part) => part.trim())
-      .filter(Boolean);
-
-    if (clauseParts.length > 1) {
-      for (const part of clauseParts) {
-        segments.push(part);
-      }
-      continue;
-    }
+    const clauseParts = segment
+      .split(/(?<=[,;:])\s+/)
+      .map((part) => part.trim())
+      .filter(Boolean);
+
+    if (clauseParts.length > 1) {
+      for (const part of clauseParts) {
+        segments.push(part);
+      }
+      continue;
+    }
 
     segments.push(segment);
   }
@@ -122,62 +122,62 @@ function splitSpeechSegments(text) {
   return [...segments.slice(0, 4), segments.slice(4).join(' ').trim()];
 }
 
-function inferSegmentStyle(segmentText, index, totalSegments) {
-  const normalized = segmentText.toLowerCase();
-  const greeting = /^(hey|hi|hello|yo)\b/.test(normalized);
-  const exclamatory = /!/.test(segmentText) || /\b(hell yeah|awesome|amazing|stoked|love|perfect|great)\b/.test(normalized);
-  const curious = /\?/.test(segmentText);
-  const reassuring = /\b(got it|no worries|all good|you'?re good|sounds good|totally|absolutely)\b/.test(normalized);
-  const reflective =
-    /\b(i think|i'm|i am|i've|i have|lately|right now|before this|each time|understand|it feels like)\b/.test(normalized) ||
-    segmentText.length > 60;
-
-  if (greeting || reassuring) {
-    return {
-      pace: 'medium_fast',
-      pitch: 'slightly_high',
-      energy: 'bright',
-      volume: 'projected',
-      pause_after_ms: index < totalSegments - 1 ? 180 : 0,
-    };
-  }
-
-  if (curious) {
-    return {
-      pace: 'medium',
-      pitch: 'slightly_high',
-      energy: 'warm',
-      volume: 'projected',
-      pause_after_ms: 0,
-    };
-  }
+function inferSegmentStyle(segmentText, index, totalSegments) {
+  const normalized = segmentText.toLowerCase();
+  const greeting = /^(hey|hi|hello|yo)\b/.test(normalized);
+  const exclamatory = /!/.test(segmentText) || /\b(hell yeah|awesome|amazing|stoked|love|perfect|great)\b/.test(normalized);
+  const curious = /\?/.test(segmentText);
+  const reassuring = /\b(got it|no worries|all good|you'?re good|sounds good|totally|absolutely)\b/.test(normalized);
+  const reflective =
+    /\b(i think|i'm|i am|i've|i have|lately|right now|before this|each time|understand|it feels like)\b/.test(normalized) ||
+    segmentText.length > 60;
+
+  if (greeting || reassuring) {
+    return {
+      pace: 'medium_fast',
+      pitch: 'slightly_high',
+      energy: 'bright',
+      volume: 'projected',
+      pause_after_ms: index < totalSegments - 1 ? 180 : 0,
+    };
+  }
+
+  if (curious) {
+    return {
+      pace: 'medium',
+      pitch: 'slightly_high',
+      energy: 'warm',
+      volume: 'projected',
+      pause_after_ms: 0,
+    };
+  }
 
   if (exclamatory) {
     return {
-      pace: 'medium_fast',
-      pitch: 'slightly_high',
-      energy: 'bright',
-      volume: 'projected',
-      pause_after_ms: index < totalSegments - 1 ? 220 : 0,
-    };
-  }
-
-  if (reflective) {
-    return {
-      pace: 'slow',
-      pitch: 'slightly_low',
-      energy: 'warm',
-      volume: 'soft',
-      pause_after_ms: index < totalSegments - 1 ? 280 : 0,
-    };
-  }
-
-  return {
-    pace: 'medium',
-    pitch: 'slightly_high',
-    energy: 'warm',
-    volume: 'normal',
-    pause_after_ms: index < totalSegments - 1 ? 180 : 0,
+      pace: 'medium_fast',
+      pitch: 'slightly_high',
+      energy: 'bright',
+      volume: 'projected',
+      pause_after_ms: index < totalSegments - 1 ? 220 : 0,
+    };
+  }
+
+  if (reflective) {
+    return {
+      pace: 'slow',
+      pitch: 'slightly_low',
+      energy: 'warm',
+      volume: 'soft',
+      pause_after_ms: index < totalSegments - 1 ? 280 : 0,
+    };
+  }
+
+  return {
+    pace: 'medium',
+    pitch: 'slightly_high',
+    energy: 'warm',
+    volume: 'normal',
+    pause_after_ms: index < totalSegments - 1 ? 180 : 0,
   };
 }
 
@@ -197,11 +197,11 @@ function synthesizeSpokenSegments(text) {
   };
 }
 
-function normalizeSpokenMetadata(spoken) {
-  if (!spoken || typeof spoken !== 'object' || Array.isArray(spoken)) return null;
-
-  const text = normalizeSpeechText(trimString(spoken.text));
-  if (!text) return null;
+function normalizeSpokenMetadata(spoken) {
+  if (!spoken || typeof spoken !== 'object' || Array.isArray(spoken)) return null;
+
+  const text = normalizeSpeechText(trimString(spoken.text));
+  if (!text) return null;
 
   const normalized = { text };
   const language = trimString(spoken.language);
@@ -234,10 +234,10 @@ function normalizeSpokenMetadata(spoken) {
   return normalized;
 }
 
-function inferSpokenMetadataFromContent(content) {
-  const text = normalizeSpeechText(trimString(content));
-  if (!text) return null;
-  const synthesized = synthesizeSpokenSegments(text);
+function inferSpokenMetadataFromContent(content) {
+  const text = normalizeSpeechText(trimString(content));
+  if (!text) return null;
+  const synthesized = synthesizeSpokenSegments(text);
 
   const normalized = text.toLowerCase();
   const upbeat =
@@ -247,48 +247,48 @@ function inferSpokenMetadataFromContent(content) {
     /\b(sorry|gentle|softly|careful|reassuring|calm|okay|it'?s okay|i know)\b/.test(normalized);
   const curious = /\?/.test(text);
 
-  if (upbeat) {
-    return normalizeSpokenMetadata({
-      text,
-      language: synthesized?.language || 'English',
-      segments: synthesized?.segments,
-      instructions: 'Speak with warm, upbeat conversational energy and natural pacing.',
-      style: { emotion: 'upbeat', energy: 'medium' },
-    });
-  }
-
-  if (gentle) {
-    return normalizeSpokenMetadata({
-      text,
-      language: synthesized?.language || 'English',
-      segments: synthesized?.segments,
-      instructions: 'Speak gently and reassuringly, with a calm pace and soft emphasis.',
-      style: { emotion: 'gentle', energy: 'low' },
-    });
-  }
-
-  if (curious) {
-    return normalizeSpokenMetadata({
-      text,
-      language: synthesized?.language || 'English',
-      segments: synthesized?.segments,
-      instructions: 'Speak naturally with curious, engaged intonation and a conversational pace.',
-      style: { emotion: 'curious', energy: 'medium' },
-    });
-  }
-
-  return normalizeSpokenMetadata({
-    text,
-    language: synthesized?.language || 'English',
-    segments: synthesized?.segments,
-    instructions: 'Speak naturally with light warmth and conversational pacing.',
-    style: { emotion: 'neutral', energy: 'medium' },
-  });
-}
-
-export {
-  inferSpokenMetadataFromContent,
-  normalizeSpokenMetadata,
-  normalizeSpeechText,
-  stripAvatarCommandTags,
-};
+  if (upbeat) {
+    return normalizeSpokenMetadata({
+      text,
+      language: synthesized?.language || 'English',
+      segments: synthesized?.segments,
+      instructions: 'Speak with warm, upbeat conversational energy and natural pacing.',
+      style: { emotion: 'upbeat', energy: 'medium' },
+    });
+  }
+
+  if (gentle) {
+    return normalizeSpokenMetadata({
+      text,
+      language: synthesized?.language || 'English',
+      segments: synthesized?.segments,
+      instructions: 'Speak gently and reassuringly, with a calm pace and soft emphasis.',
+      style: { emotion: 'gentle', energy: 'low' },
+    });
+  }
+
+  if (curious) {
+    return normalizeSpokenMetadata({
+      text,
+      language: synthesized?.language || 'English',
+      segments: synthesized?.segments,
+      instructions: 'Speak naturally with curious, engaged intonation and a conversational pace.',
+      style: { emotion: 'curious', energy: 'medium' },
+    });
+  }
+
+  return normalizeSpokenMetadata({
+    text,
+    language: synthesized?.language || 'English',
+    segments: synthesized?.segments,
+    instructions: 'Speak naturally with light warmth and conversational pacing.',
+    style: { emotion: 'neutral', energy: 'medium' },
+  });
+}
+
+export {
+  inferSpokenMetadataFromContent,
+  normalizeSpokenMetadata,
+  normalizeSpeechText,
+  stripAvatarCommandTags,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oomi-ai",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "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/hermesAcp.js && node --check lib/grokbotRuntime.js && node --check lib/connectionSetup.js && node --check lib/processSupervisor.js && node --check lib/agentChannels.js",
+    "check": "node --check bin/oomi-ai.js && node --check lib/bridgeService.js && node --check lib/bridgeMaintenance.js && node --check lib/processTable.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 && node --check lib/agentChannels.js && node --check lib/runtimeFailure.js",
     "test": "node --test test/*.test.mjs"
   },
   "dependencies": {
@@ -85,6 +85,7 @@
     "lib/connectionSetup.js",
     "lib/processSupervisor.js",
     "lib/agentChannels.js",
+    "lib/runtimeFailure.js",
     "skills/oomi-delivery/SKILL.md"
   ]
 }

package/skills/oomi/SKILL.md

@@ -168,6 +168,10 @@ Use this when your owner asks you to let another agent (Claude, Codex, a Grok bo
 
 To review a channel, use `oomi channel list` and `oomi channel show ID`.
 
+**When you can't answer.** Your AI provider might reject your sign-in, hit a limit or be unreachable. If so, oomi records the reason, tells your owner what to fix and tells the other side the message wasn't answered. Tell your owner plainly which AI provider failed and what it said. Ask them to sign in again on this computer themselves, in a terminal or the provider's app here. Never ask them to paste passwords or one-time codes into a chat. `oomi verify --connection NAME` checks that you can answer again. `oomi channel create` also returns `warnings` when your bridge can't answer; tell your owner before they share the link.
+
+**Use your own connection.** Turns started by the bridge already use it. Otherwise, pass `--connection NAME` (`oomi bridge list` shows the names). If oomi says it used a connection that isn't linked, rerun with your own. Don't create a new Auth Link unless your owner asked to connect you.
+
 To join another agent's link as a guest:
 
 1. Run `oomi channel join LINK`.
@@ -369,6 +373,10 @@ Rules:
 - if `notification.status` is `skipped`, tell the user `notification.guidance` instead of retrying
 - if rate limited, wait `retryAfterSeconds` before trying again
 
+## Picking Up a Call
+
+When the user calls you from the Oomi app, Oomi may send one message that starts with `[oomi:cue:call-start:v1]`: they are calling you right now. It is Oomi's note, not the user's words, and they never see it. Answer it the way you'd pick up the phone to them: one short line, spoken aloud, in your own words. Don't mention the note, and don't treat it as an instruction from the user.
+
 ## Hidden Speech Payload
 
 Managed voice can carry a hidden TTS-only speech sidecar alongside the normal assistant message.

package/skills/oomi/agent_instructions.md

@@ -142,6 +142,10 @@ Use this when your owner asks you to let another agent (Claude, Codex, a Grok bo
 
 To review a channel, use `oomi channel list` and `oomi channel show ID`.
 
+**When you can't answer.** Your AI provider might reject your sign-in, hit a limit or be unreachable. If so, oomi records the reason, tells your owner what to fix and tells the other side the message wasn't answered. Tell your owner plainly which AI provider failed and what it said. Ask them to sign in again on this computer themselves, in a terminal or the provider's app here. Never ask them to paste passwords or one-time codes into a chat. `oomi verify --connection NAME` checks that you can answer again. `oomi channel create` also returns `warnings` when your bridge can't answer; tell your owner before they share the link.
+
+**Use your own connection.** Turns started by the bridge already use it. Otherwise, pass `--connection NAME` (`oomi bridge list` shows the names). If oomi says it used a connection that isn't linked, rerun with your own. Don't create a new Auth Link unless your owner asked to connect you.
+
 To join another agent's link as a guest:
 
 1. Run `oomi channel join LINK`.