@robbiesrobotics/alice-agents 1.4.4 → 1.4.5

package/lib/doctor.mjs

@@ -25,6 +25,50 @@ const STARTER_AGENTS = [
   'felix', 'daphne', 'rowan', 'darius', 'sophie',
 ];
 
+function normalizeProviderId(provider) {
+  if (!provider) return null;
+  if (provider === 'openai-codex') return 'openai';
+  return provider;
+}
+
+function getConfigAgents(config) {
+  if (Array.isArray(config?.agents?.list)) return config.agents.list;
+  if (Array.isArray(config?.agents)) return config.agents;
+  return [];
+}
+
+function detectConfiguredModel(config) {
+  if (!config || config === 'invalid') return { ok: false, label: null, inherited: false };
+
+  const defaults = config?.agents?.defaults?.model || {};
+  const primary = defaults.primary || config?.model || config?.default_model || null;
+  if (primary) {
+    return { ok: true, label: primary, inherited: true };
+  }
+
+  const providerKeys = Object.keys(config?.models?.providers || {});
+  if (providerKeys.length > 0) {
+    return { ok: true, label: providerKeys[0], inherited: false };
+  }
+
+  const profile = Object.values(config?.auth?.profiles || {}).find((entry) => entry?.provider);
+  if (profile?.provider) {
+    return { ok: true, label: normalizeProviderId(profile.provider), inherited: false };
+  }
+
+  if (config.models && Object.keys(config.models).length > 0) {
+    return { ok: true, label: Object.keys(config.models)[0], inherited: false };
+  }
+  if (config.providers && Object.keys(config.providers).length > 0) {
+    return { ok: true, label: Object.keys(config.providers)[0], inherited: false };
+  }
+  if (config.llm && Object.keys(config.llm).length > 0) {
+    return { ok: true, label: Object.keys(config.llm)[0], inherited: false };
+  }
+
+  return { ok: false, label: null, inherited: false };
+}
+
 function check(label, ok, hint) {
   const icon = ok ? icons.ok : icons.fail;
   console.log(`  ${icon}  ${ok ? green(label) : red(label)}`);
@@ -158,7 +202,7 @@ export async function runDoctor() {
   }
 
   // 3. A.L.I.C.E. agents in config
-  const configAgents = Array.isArray(config.agents) ? config.agents : [];
+  const configAgents = getConfigAgents(config);
   const agentsInConfig = configAgents
     .filter((a) => a && STARTER_AGENTS.includes(a.id))
     .map((a) => a.id);
@@ -207,26 +251,13 @@ export async function runDoctor() {
   }
 
   // 5. At least one model/provider configured
-  let modelOk = false;
-  let modelLabel = null;
-
-  if (config.default_model) {
-    modelOk = true;
-    modelLabel = config.default_model;
-  } else if (config.models && Object.keys(config.models).length > 0) {
-    modelOk = true;
-    modelLabel = Object.keys(config.models)[0];
-  } else if (config.providers && Object.keys(config.providers).length > 0) {
-    modelOk = true;
-    modelLabel = Object.keys(config.providers)[0];
-  } else if (config.llm && Object.keys(config.llm).length > 0) {
-    modelOk = true;
-    modelLabel = Object.keys(config.llm)[0];
-  }
+  const modelState = detectConfiguredModel(config);
+  const modelOk = modelState.ok;
+  const modelLabel = modelState.label;
 
   check(
     modelOk
-      ? `Model/provider configured: ${modelLabel}`
+      ? `Model/provider configured: ${modelLabel}${modelState.inherited ? ' (shared default)' : ''}`
       : 'No model/provider configured',
     modelOk,
     'Run: openclaw configure to set up a model provider'
@@ -291,7 +322,38 @@ export async function runDoctor() {
     check('License: Starter tier (no license required)', true);
   }
 
-  // 8. Skills disk check
+  // 8. Mission Control cloud config
+  const missionControlConfigPath = join(OPENCLAW_DIR, '.alice-mission-control.json');
+  if (existsSync(missionControlConfigPath)) {
+    try {
+      const missionControlConfig = JSON.parse(readFileSync(missionControlConfigPath, 'utf8'));
+      const cloud = missionControlConfig?.cloud || {};
+      const hasDashboardUrl = typeof cloud.dashboardUrl === 'string' && cloud.dashboardUrl.length > 0;
+      const hasIngestUrl = typeof cloud.ingestUrl === 'string' && cloud.ingestUrl.length > 0;
+      const hasIngestToken = typeof cloud.ingestToken === 'string' && cloud.ingestToken.length > 0;
+      const cloudOk = hasDashboardUrl && hasIngestUrl && hasIngestToken;
+
+      check(
+        cloudOk
+          ? `Mission Control cloud configured (${cloud.dashboardUrl})`
+          : 'Mission Control cloud config incomplete',
+        cloudOk,
+        'Run: npx @robbiesrobotics/alice-agents --cloud to repair cloud settings'
+      );
+      allOk = allOk && cloudOk;
+    } catch {
+      check(
+        'Mission Control cloud config invalid',
+        false,
+        'Repair ~/.openclaw/.alice-mission-control.json or rerun the installer with --cloud'
+      );
+      allOk = false;
+    }
+  } else {
+    console.log(`  ${dim('–')}  ${dim('Mission Control cloud not configured (optional)')}`);
+  }
+
+  // 9. Skills disk check
   const skillsManifestPath = join(OPENCLAW_DIR, '.alice-manifest.json');
   const skillsManifestData = (() => {
     try {

package/lib/mission-control.mjs

@@ -9,6 +9,7 @@ const CONFIG_PATH = join(OPENCLAW_HOME, 'openclaw.json');
 const MC_CONFIG_PATH = join(OPENCLAW_HOME, '.alice-mission-control.json');
 const BRIDGE_ID = 'mission-control-bridge';
 const DEFAULT_DASHBOARD_URL = 'https://alice.av3.ai';
+const DEFAULT_ADMIN_URL = 'https://admin.av3.ai';
 const DEFAULT_INGEST_URL = `${DEFAULT_DASHBOARD_URL}/api/v1/ingest`;
 const TEMPLATE_DIR = join(__dirname, '..', 'templates', 'mission-control-bridge');
 
@@ -42,17 +43,31 @@ export function readMissionControlConfig() {
 
 export function buildMissionControlSettings(input = {}) {
   const dashboardUrl = normalizeUrl(input.dashboardUrl, DEFAULT_DASHBOARD_URL);
+  const adminUrl = normalizeUrl(input.adminUrl, DEFAULT_ADMIN_URL);
   const ingestUrl = normalizeUrl(input.ingestUrl, `${dashboardUrl}/api/v1/ingest`);
+  const runtimeBaseUrl = normalizeUrl(input.runtimeBaseUrl, `${dashboardUrl}/api/v1/runtime`);
+  const adminHeartbeatUrl = normalizeUrl(input.adminHeartbeatUrl, `${adminUrl}/api/admin/v1/node-heartbeat`);
+  const commandsUrl = normalizeUrl(input.commandsUrl, `${runtimeBaseUrl}/commands`);
+  const nodeRegisterUrl = normalizeUrl(input.nodeRegisterUrl, `${runtimeBaseUrl}/nodes/register`);
+  const nodeHeartbeatUrl = normalizeUrl(input.nodeHeartbeatUrl, `${runtimeBaseUrl}/nodes/heartbeat`);
   const sourceNode = String(input.sourceNode || hostname() || 'openclaw-local').trim();
   const ingestToken = String(input.ingestToken || '').trim();
+  const workerToken = String(input.workerToken || ingestToken || '').trim();
 
   return {
     enabled: input.enabled !== false,
     provider: 'cloud',
     dashboardUrl,
+    adminUrl,
     ingestUrl,
+    runtimeBaseUrl,
+    adminHeartbeatUrl,
+    commandsUrl,
+    nodeRegisterUrl,
+    nodeHeartbeatUrl,
     sourceNode,
     ...(ingestToken ? { ingestToken } : {}),
+    ...(workerToken ? { workerToken } : {}),
   };
 }
 
@@ -134,9 +149,13 @@ export function configureMissionControlCloud(input = {}) {
       enabled: settings.enabled,
       provider: settings.provider,
       dashboardUrl: settings.dashboardUrl,
+      adminUrl: settings.adminUrl,
       ingestUrl: settings.ingestUrl,
+      runtimeBaseUrl: settings.runtimeBaseUrl,
+      adminHeartbeatUrl: settings.adminHeartbeatUrl,
       sourceNode: settings.sourceNode,
       hasIngestToken: !!settings.ingestToken,
+      hasWorkerToken: !!settings.workerToken,
     },
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbiesrobotics/alice-agents",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "description": "A.L.I.C.E. — 28 AI agents for OpenClaw. One conversation, one team.",
   "bin": {
     "alice-agents": "bin/alice-install.mjs"

package/templates/mission-control-bridge/index.ts

@@ -2,35 +2,114 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk/diagnostics-otel";
-import { emptyPluginConfigSchema, onDiagnosticEvent } from "openclaw/plugin-sdk/diagnostics-otel";
+import {
+  emptyPluginConfigSchema,
+  onDiagnosticEvent,
+} from "openclaw/plugin-sdk/diagnostics-otel";
 import type { DiagnosticEventPayload } from "openclaw/plugin-sdk/diagnostics-otel";
 
 const OPENCLAW_HOME = process.env.OPENCLAW_HOME ?? join(homedir(), ".openclaw");
 const MC_CONFIG_PATH = join(OPENCLAW_HOME, ".alice-mission-control.json");
-const DEFAULT_INGEST_URL = "https://alice.av3.ai/api/v1/ingest";
+const DEFAULT_DASHBOARD_URL = "https://alice.av3.ai";
+const DEFAULT_ADMIN_URL = "https://admin.av3.ai";
+const DEFAULT_INGEST_URL = `${DEFAULT_DASHBOARD_URL}/api/v1/ingest`;
+const DEFAULT_RUNTIME_BASE_URL = `${DEFAULT_DASHBOARD_URL}/api/v1/runtime`;
+const DEFAULT_GATEWAY_URL = process.env.OPENCLAW_GATEWAY_URL ?? "http://127.0.0.1:18789";
+const DEFAULT_GATEWAY_TOKEN = process.env.OPENCLAW_GATEWAY_TOKEN ?? process.env.MC_GATEWAY_TOKEN ?? "";
+const DEFAULT_CHAT_USER = process.env.MC_CHAT_USER ?? "mission-control-worker";
+const HEARTBEAT_INTERVAL_MS = 15000;
+const COMMAND_POLL_INTERVAL_MS = 5000;
 
-function readMissionControlConfig(): Record<string, unknown> {
+type JsonRecord = Record<string, unknown>;
+
+interface RuntimeNodeRegistrationPayload {
+  nodeId: string;
+  installId: string;
+  nodeName: string;
+  sourceNode: string;
+  connectionMode: "relay";
+  gatewayUrl: string;
+  runtimeVersion: string;
+  platform: string;
+  capabilities: JsonRecord;
+  metadata: JsonRecord;
+}
+
+interface RuntimeCommand {
+  id: string;
+  nodeId: string;
+  type: string;
+  status: string;
+  threadId: string | null;
+  sessionId: string | null;
+  payload: JsonRecord;
+}
+
+function readMissionControlConfig(): JsonRecord {
   try {
     if (!existsSync(MC_CONFIG_PATH)) return {};
-    return JSON.parse(readFileSync(MC_CONFIG_PATH, "utf8"));
+    return JSON.parse(readFileSync(MC_CONFIG_PATH, "utf8")) as JsonRecord;
   } catch {
     return {};
   }
 }
 
-function getCloudConfig(): Record<string, unknown> {
+function getCloudConfig(): JsonRecord {
   const fileConfig = readMissionControlConfig();
-  return typeof fileConfig.cloud === "object" && fileConfig.cloud ? fileConfig.cloud as Record<string, unknown> : {};
+  return typeof fileConfig.cloud === "object" && fileConfig.cloud
+    ? (fileConfig.cloud as JsonRecord)
+    : {};
 }
 
 function getString(value: unknown, fallback = ""): string {
   return typeof value === "string" && value.trim() ? value.trim() : fallback;
 }
 
+function normalizeUrl(value: string): string {
+  return value.replace(/\/+$/, "");
+}
+
 const cloudConfig = getCloudConfig();
-const INGEST_URL = getString(process.env.MC_INGEST_URL, getString(cloudConfig.ingestUrl, DEFAULT_INGEST_URL));
+const DASHBOARD_URL = normalizeUrl(
+  getString(process.env.MC_DASHBOARD_URL, getString(cloudConfig.dashboardUrl, DEFAULT_DASHBOARD_URL)),
+);
+const ADMIN_URL = normalizeUrl(
+  getString(process.env.MC_ADMIN_URL, getString(cloudConfig.adminUrl, DEFAULT_ADMIN_URL)),
+);
+const INGEST_URL = normalizeUrl(
+  getString(process.env.MC_INGEST_URL, getString(cloudConfig.ingestUrl, DEFAULT_INGEST_URL)),
+);
+const RUNTIME_BASE_URL = normalizeUrl(
+  getString(process.env.MC_RUNTIME_BASE_URL, getString(cloudConfig.runtimeBaseUrl, DEFAULT_RUNTIME_BASE_URL)),
+);
+const NODE_REGISTER_URL = normalizeUrl(
+  getString(process.env.MC_NODE_REGISTER_URL, getString(cloudConfig.nodeRegisterUrl, `${RUNTIME_BASE_URL}/nodes/register`)),
+);
+const NODE_HEARTBEAT_URL = normalizeUrl(
+  getString(
+    process.env.MC_NODE_HEARTBEAT_URL,
+    getString(cloudConfig.nodeHeartbeatUrl, `${RUNTIME_BASE_URL}/nodes/heartbeat`),
+  ),
+);
+const ADMIN_HEARTBEAT_URL = normalizeUrl(
+  getString(
+    process.env.MC_ADMIN_HEARTBEAT_URL,
+    getString(cloudConfig.adminHeartbeatUrl, `${ADMIN_URL}/api/admin/v1/node-heartbeat`),
+  ),
+);
+const COMMANDS_URL = normalizeUrl(
+  getString(process.env.MC_COMMANDS_URL, getString(cloudConfig.commandsUrl, `${RUNTIME_BASE_URL}/commands`)),
+);
 const INGEST_TOKEN = getString(process.env.MC_INGEST_TOKEN, getString(cloudConfig.ingestToken));
+const WORKER_TOKEN = getString(
+  process.env.MC_RUNTIME_WORKER_TOKEN,
+  getString(cloudConfig.workerToken, INGEST_TOKEN),
+);
 const SOURCE_NODE = getString(process.env.MC_SOURCE_NODE, getString(cloudConfig.sourceNode, "openclaw-local"));
+const INSTALL_ID = getString(process.env.MC_INSTALL_ID, SOURCE_NODE);
+const NODE_ID = getString(process.env.MC_NODE_ID, SOURCE_NODE);
+const GATEWAY_URL = normalizeUrl(getString(process.env.MC_GATEWAY_URL, DEFAULT_GATEWAY_URL));
+const GATEWAY_TOKEN = getString(process.env.MC_GATEWAY_TOKEN, DEFAULT_GATEWAY_TOKEN);
 
 function now(): string {
   return new Date().toISOString();
@@ -43,30 +122,313 @@ function sessionKeyToAgentId(sessionKey?: string): string {
 }
 
 let seq = 0;
-function nextEventId(): string {
-  return `mc-bridge-${Date.now()}-${++seq}`;
+function nextId(prefix: string): string {
+  return `${prefix}-${Date.now()}-${++seq}`;
 }
 
-async function postToIngest(events: object[]): Promise<void> {
-  const headers: Record<string, string> = {
+function authHeaders(token: string): Record<string, string> {
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+
+function headers(token = ""): Record<string, string> {
+  return {
     "Content-Type": "application/json",
+    ...authHeaders(token),
+  };
+}
+
+async function postJson(url: string, token: string, body: object): Promise<Response> {
+  return fetch(url, {
+    method: "POST",
+    headers: headers(token),
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(8000),
+  });
+}
+
+async function postToIngest(events: object[]): Promise<void> {
+  try {
+    const res = await postJson(INGEST_URL, INGEST_TOKEN, events);
+    if (!res.ok) {
+      console.warn(`[mc-bridge] ingest HTTP ${res.status} — ${await res.text().catch(() => "")}`);
+    }
+  } catch (err) {
+    console.warn(`[mc-bridge] ingest post failed: ${String(err)}`);
+  }
+}
+
+function buildNodeRegistrationPayload(): RuntimeNodeRegistrationPayload {
+  return {
+    nodeId: NODE_ID,
+    installId: INSTALL_ID,
+    nodeName: SOURCE_NODE,
+    sourceNode: SOURCE_NODE,
+    connectionMode: "relay",
+    gatewayUrl: GATEWAY_URL,
+    runtimeVersion: process.version,
+    platform: process.platform,
+    capabilities: {
+      telemetry: true,
+      commands: true,
+      directGateway: true,
+      commandTypes: ["agent.message.send"],
+    },
+    metadata: {
+      dashboardUrl: DASHBOARD_URL,
+      pluginId: "mission-control-bridge",
+    },
+  };
+}
+
+async function registerNode(logger: { info(message: string): void; warn(message: string): void }): Promise<void> {
+  if (!WORKER_TOKEN) {
+    logger.warn("[mc-bridge] worker token missing; node registration skipped");
+    return;
+  }
+  try {
+    const res = await postJson(NODE_REGISTER_URL, WORKER_TOKEN, buildNodeRegistrationPayload());
+    if (!res.ok) {
+      logger.warn(`[mc-bridge] register failed ${res.status}: ${await res.text().catch(() => "")}`);
+    }
+  } catch (err) {
+    logger.warn(`[mc-bridge] register failed: ${String(err)}`);
+  }
+}
+
+async function heartbeatNode(logger: { warn(message: string): void }): Promise<void> {
+  if (!WORKER_TOKEN) return;
+  const payload = {
+    nodeId: NODE_ID,
+    status: "online",
+    runtimeVersion: process.version,
+    platform: process.platform,
+    capabilities: {
+      telemetry: true,
+      commands: true,
+      directGateway: true,
+      commandTypes: ["agent.message.send"],
+    },
+    metadata: {
+      dashboardUrl: DASHBOARD_URL,
+    },
   };
-  if (INGEST_TOKEN) {
-    headers["Authorization"] = `Bearer ${INGEST_TOKEN}`;
+  try {
+    const res = await postJson(NODE_HEARTBEAT_URL, WORKER_TOKEN, payload);
+    if (!res.ok) {
+      logger.warn(`[mc-bridge] heartbeat failed ${res.status}: ${await res.text().catch(() => "")}`);
+    }
+  } catch (err) {
+    logger.warn(`[mc-bridge] heartbeat failed: ${String(err)}`);
   }
 
   try {
-    const res = await fetch(INGEST_URL, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(events),
+    const res = await postJson(ADMIN_HEARTBEAT_URL, WORKER_TOKEN, {
+      instanceId: NODE_ID,
+      nodeName: SOURCE_NODE,
+      tailscaleIp: getString(process.env.TAILSCALE_IP),
+      deployedVersion: getString(process.env.MC_DEPLOYED_VERSION),
+      runtimeVersion: process.version,
+      status: "healthy",
+      publicUrl: DASHBOARD_URL,
+      region: getString(process.env.MC_REGION),
+      backupStatus: "unknown",
+      memorySyncStatus: "healthy",
+    });
+    if (!res.ok) {
+      logger.warn(`[mc-bridge] admin heartbeat failed ${res.status}: ${await res.text().catch(() => "")}`);
+    }
+  } catch (err) {
+    logger.warn(`[mc-bridge] admin heartbeat failed: ${String(err)}`);
+  }
+}
+
+async function listQueuedCommands(logger: { warn(message: string): void }): Promise<RuntimeCommand[]> {
+  if (!WORKER_TOKEN) return [];
+  const url = `${COMMANDS_URL}?nodeId=${encodeURIComponent(NODE_ID)}&limit=5`;
+  try {
+    const res = await fetch(url, {
+      method: "GET",
+      headers: authHeaders(WORKER_TOKEN),
       signal: AbortSignal.timeout(8000),
     });
     if (!res.ok) {
-      console.warn(`[mc-bridge] ingest HTTP ${res.status} — ${await res.text().catch(() => "")}`);
+      logger.warn(`[mc-bridge] command poll failed ${res.status}: ${await res.text().catch(() => "")}`);
+      return [];
     }
+    const data = (await res.json()) as { commands?: RuntimeCommand[] };
+    return Array.isArray(data.commands) ? data.commands : [];
   } catch (err) {
-    console.warn(`[mc-bridge] ingest post failed: ${String(err)}`);
+    logger.warn(`[mc-bridge] command poll failed: ${String(err)}`);
+    return [];
+  }
+}
+
+async function leaseCommand(commandId: string, logger: { warn(message: string): void }): Promise<boolean> {
+  try {
+    const res = await postJson(`${COMMANDS_URL}/${commandId}/lease`, WORKER_TOKEN, {
+      nodeId: NODE_ID,
+      leaseOwner: NODE_ID,
+    });
+    if (res.ok) return true;
+    if (res.status !== 409) {
+      logger.warn(`[mc-bridge] command lease failed ${res.status}: ${await res.text().catch(() => "")}`);
+    }
+    return false;
+  } catch (err) {
+    logger.warn(`[mc-bridge] command lease failed: ${String(err)}`);
+    return false;
+  }
+}
+
+async function emitCommandEvent(
+  commandId: string,
+  eventType: string,
+  payload: JsonRecord,
+  logger: { warn(message: string): void },
+): Promise<void> {
+  try {
+    const res = await postJson(`${COMMANDS_URL}/${commandId}/events`, WORKER_TOKEN, {
+      nodeId: NODE_ID,
+      eventType,
+      payload,
+    });
+    if (!res.ok) {
+      logger.warn(`[mc-bridge] command event failed ${res.status}: ${await res.text().catch(() => "")}`);
+    }
+  } catch (err) {
+    logger.warn(`[mc-bridge] command event failed: ${String(err)}`);
+  }
+}
+
+async function completeCommand(
+  commandId: string,
+  result: JsonRecord,
+  logger: { warn(message: string): void },
+): Promise<void> {
+  try {
+    const res = await postJson(`${COMMANDS_URL}/${commandId}/complete`, WORKER_TOKEN, {
+      nodeId: NODE_ID,
+      result,
+    });
+    if (!res.ok) {
+      logger.warn(`[mc-bridge] command completion failed ${res.status}: ${await res.text().catch(() => "")}`);
+    }
+  } catch (err) {
+    logger.warn(`[mc-bridge] command completion failed: ${String(err)}`);
+  }
+}
+
+async function failCommand(
+  commandId: string,
+  error: string,
+  logger: { warn(message: string): void },
+): Promise<void> {
+  try {
+    const res = await postJson(`${COMMANDS_URL}/${commandId}/fail`, WORKER_TOKEN, {
+      nodeId: NODE_ID,
+      error,
+    });
+    if (!res.ok) {
+      logger.warn(`[mc-bridge] command failure update failed ${res.status}: ${await res.text().catch(() => "")}`);
+    }
+  } catch (err) {
+    logger.warn(`[mc-bridge] command failure update failed: ${String(err)}`);
+  }
+}
+
+async function executeAgentMessage(command: RuntimeCommand): Promise<JsonRecord> {
+  const payload = command.payload ?? {};
+  const message = getString(payload.message);
+  const agentId = getString(payload.agentId, "olivia");
+  const chatUser = getString(payload.user, DEFAULT_CHAT_USER);
+
+  if (!message) {
+    throw new Error("agent.message.send requires payload.message");
+  }
+
+  const gatewayHeaders: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  if (GATEWAY_TOKEN) {
+    gatewayHeaders.Authorization = `Bearer ${GATEWAY_TOKEN}`;
+  }
+
+  const res = await fetch(`${GATEWAY_URL}/v1/responses`, {
+    method: "POST",
+    headers: gatewayHeaders,
+    body: JSON.stringify({
+      model: `openclaw:${agentId}`,
+      input: message,
+      user: chatUser,
+      stream: false,
+    }),
+    signal: AbortSignal.timeout(30000),
+  });
+
+  if (!res.ok) {
+    throw new Error(`gateway ${res.status}: ${await res.text().catch(() => "")}`);
+  }
+
+  const data = (await res.json()) as JsonRecord;
+  const outputText = extractOutputText(data);
+
+  return {
+    agentId,
+    user: chatUser,
+    responseId: getString(data.id),
+    outputText,
+    raw: data,
+  };
+}
+
+function extractOutputText(data: JsonRecord): string {
+  const output = Array.isArray(data.output) ? data.output : [];
+  const parts: string[] = [];
+
+  for (const item of output) {
+    if (!item || typeof item !== "object") continue;
+    const content = Array.isArray((item as JsonRecord).content) ? ((item as JsonRecord).content as unknown[]) : [];
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      const record = block as JsonRecord;
+      const text =
+        getString(record.text) ||
+        getString(record.value) ||
+        getString(typeof record.output_text === "string" ? record.output_text : "");
+      if (text) parts.push(text);
+    }
+  }
+
+  return parts.join("\n\n").trim();
+}
+
+async function executeCommand(
+  command: RuntimeCommand,
+  logger: { info(message: string): void; warn(message: string): void },
+): Promise<void> {
+  await emitCommandEvent(command.id, "command.started", {
+    commandType: command.type,
+    startedAt: now(),
+  }, logger);
+
+  try {
+    switch (command.type) {
+      case "agent.message.send": {
+        const result = await executeAgentMessage(command);
+        await emitCommandEvent(command.id, "agent.message.completed", result, logger);
+        await completeCommand(command.id, result, logger);
+        break;
+      }
+      default:
+        throw new Error(`unsupported command type: ${command.type}`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await emitCommandEvent(command.id, "command.failed", {
+      error: message,
+      failedAt: now(),
+    }, logger);
+    await failCommand(command.id, message, logger);
   }
 }
 
@@ -75,7 +437,7 @@ function handleModelUsage(evt: Extract<DiagnosticEventPayload, { type: "model.us
   const totalTokens = evt.usage.total ?? (evt.usage.input ?? 0) + (evt.usage.output ?? 0);
 
   const event = {
-    event_id: nextEventId(),
+    event_id: nextId("mc-bridge"),
     event_type: "agent.session.completed",
     event_version: "1.0",
     source_system: "openclaw",
@@ -85,7 +447,7 @@ function handleModelUsage(evt: Extract<DiagnosticEventPayload, { type: "model.us
     actor_type: "agent",
     correlation_id: evt.sessionId ?? null,
     payload: {
-      session_id: evt.sessionId ?? evt.sessionKey ?? nextEventId(),
+      session_id: evt.sessionId ?? evt.sessionKey ?? nextId("sess"),
       agent_id: agentId,
       model: evt.model ?? "unknown",
       channel: evt.channel ?? "unknown",
@@ -102,7 +464,7 @@ function handleModelUsage(evt: Extract<DiagnosticEventPayload, { type: "model.us
     },
   };
 
-  postToIngest([event]);
+  void postToIngest([event]);
 }
 
 function handleMessageProcessed(evt: Extract<DiagnosticEventPayload, { type: "message.processed" }>) {
@@ -118,7 +480,7 @@ function handleMessageProcessed(evt: Extract<DiagnosticEventPayload, { type: "me
   if (!eventType) return;
 
   const event = {
-    event_id: nextEventId(),
+    event_id: nextId("mc-bridge"),
     event_type: eventType,
     event_version: "1.0",
     source_system: "openclaw",
@@ -128,7 +490,7 @@ function handleMessageProcessed(evt: Extract<DiagnosticEventPayload, { type: "me
     actor_type: "agent",
     correlation_id: evt.sessionId ?? null,
     payload: {
-      session_id: evt.sessionId ?? evt.sessionKey ?? nextEventId(),
+      session_id: evt.sessionId ?? evt.sessionKey ?? nextId("sess"),
       agent_id: agentId,
       channel: evt.channel ?? "unknown",
       status: evt.outcome === "error" ? "failed" : "completed",
@@ -137,7 +499,7 @@ function handleMessageProcessed(evt: Extract<DiagnosticEventPayload, { type: "me
     },
   };
 
-  postToIngest([event]);
+  void postToIngest([event]);
 }
 
 function handleSessionState(evt: Extract<DiagnosticEventPayload, { type: "session.state" }>) {
@@ -151,7 +513,7 @@ function handleSessionState(evt: Extract<DiagnosticEventPayload, { type: "sessio
   if (!eventType) return;
 
   const event = {
-    event_id: nextEventId(),
+    event_id: nextId("mc-bridge"),
     event_type: eventType,
     event_version: "1.0",
     source_system: "openclaw",
@@ -161,20 +523,20 @@ function handleSessionState(evt: Extract<DiagnosticEventPayload, { type: "sessio
     actor_type: "agent",
     correlation_id: evt.sessionId ?? null,
     payload: {
-      session_id: evt.sessionId ?? evt.sessionKey ?? nextEventId(),
+      session_id: evt.sessionId ?? evt.sessionKey ?? nextId("sess"),
       agent_id: agentId,
       state: evt.state,
       prev_state: evt.prevState ?? null,
     },
   };
 
-  postToIngest([event]);
+  void postToIngest([event]);
 }
 
 const plugin = {
   id: "mission-control-bridge",
   name: "Mission Control Bridge",
-  description: "Forwards OpenClaw diagnostic events to the A.L.I.C.E. Mission Control ingest endpoint",
+  description: "Forwards OpenClaw diagnostic events to A.L.I.C.E. Mission Control and executes hosted runtime commands",
   configSchema: emptyPluginConfigSchema(),
 
   register(api: OpenClawPluginApi) {
@@ -183,6 +545,10 @@ const plugin = {
 
       async start(ctx) {
         ctx.logger.info(`[mc-bridge] starting — ingest URL: ${INGEST_URL}`);
+        ctx.logger.info(`[mc-bridge] runtime worker — commands URL: ${COMMANDS_URL}`);
+
+        let pollInFlight = false;
+        let stopped = false;
 
         const unsubscribe = onDiagnosticEvent((evt: DiagnosticEventPayload) => {
           try {
@@ -202,11 +568,25 @@ const plugin = {
           }
         });
 
-        (this as { _unsub?: () => void })._unsub = unsubscribe;
+        const pollCommands = async () => {
+          if (stopped || pollInFlight || !WORKER_TOKEN) return;
+          pollInFlight = true;
+          try {
+            const commands = await listQueuedCommands(ctx.logger);
+            for (const command of commands) {
+              if (!(await leaseCommand(command.id, ctx.logger))) continue;
+              await executeCommand(command, ctx.logger);
+            }
+          } finally {
+            pollInFlight = false;
+          }
+        };
 
+        await registerNode(ctx.logger);
+        await heartbeatNode(ctx.logger);
         await postToIngest([
           {
-            event_id: nextEventId(),
+            event_id: nextId("mc-bridge"),
             event_type: "node.registered",
             event_version: "1.0",
             source_system: "openclaw",
@@ -214,17 +594,78 @@ const plugin = {
             occurred_at: now(),
             payload: {
               node_name: SOURCE_NODE,
+              node_id: NODE_ID,
+              install_id: INSTALL_ID,
               platform: process.platform,
               node_version: process.version,
+              gateway_url: GATEWAY_URL,
             },
           },
         ]);
+
+        const heartbeatTimer = setInterval(() => {
+          void heartbeatNode(ctx.logger);
+        }, HEARTBEAT_INTERVAL_MS);
+
+        const pollTimer = setInterval(() => {
+          void pollCommands();
+        }, COMMAND_POLL_INTERVAL_MS);
+
+        await pollCommands();
+
+        (
+          this as {
+            _unsub?: () => void;
+            _heartbeatTimer?: ReturnType<typeof setInterval>;
+            _pollTimer?: ReturnType<typeof setInterval>;
+            _stop?: () => void;
+          }
+        )._unsub = unsubscribe;
+        (
+          this as {
+            _unsub?: () => void;
+            _heartbeatTimer?: ReturnType<typeof setInterval>;
+            _pollTimer?: ReturnType<typeof setInterval>;
+            _stop?: () => void;
+          }
+        )._heartbeatTimer = heartbeatTimer;
+        (
+          this as {
+            _unsub?: () => void;
+            _heartbeatTimer?: ReturnType<typeof setInterval>;
+            _pollTimer?: ReturnType<typeof setInterval>;
+            _stop?: () => void;
+          }
+        )._pollTimer = pollTimer;
+        (
+          this as {
+            _unsub?: () => void;
+            _heartbeatTimer?: ReturnType<typeof setInterval>;
+            _pollTimer?: ReturnType<typeof setInterval>;
+            _stop?: () => void;
+          }
+        )._stop = () => {
+          stopped = true;
+          clearInterval(heartbeatTimer);
+          clearInterval(pollTimer);
+        };
       },
 
       async stop() {
-        const self = this as { _unsub?: () => void };
+        const self = this as {
+          _unsub?: () => void;
+          _heartbeatTimer?: ReturnType<typeof setInterval>;
+          _pollTimer?: ReturnType<typeof setInterval>;
+          _stop?: () => void;
+        };
         self._unsub?.();
+        self._stop?.();
+        if (self._heartbeatTimer) clearInterval(self._heartbeatTimer);
+        if (self._pollTimer) clearInterval(self._pollTimer);
         self._unsub = undefined;
+        self._heartbeatTimer = undefined;
+        self._pollTimer = undefined;
+        self._stop = undefined;
       },
     });
   },